jdk8-mips64-public/hotspot: comparison src/share/vm/gc_implementation/g1/g1StringDedupTable.cpp

-:649f01d13b2d
+:04a62a3d51d7
 /*
-* Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 2014, 2016, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 #include "classfile/altHashing.hpp"
 #include "classfile/javaClasses.hpp"
 #include "gc_implementation/g1/g1CollectedHeap.inline.hpp"
 #include "gc_implementation/g1/g1SATBCardTableModRefBS.hpp"
 #include "gc_implementation/g1/g1StringDedupTable.hpp"
+#include "gc_implementation/shared/concurrentGCThread.hpp"
 #include "memory/gcLocker.hpp"
 #include "memory/padded.inline.hpp"
 #include "oops/typeArrayOop.hpp"
 #include "runtime/mutexLocker.hpp"
 //
-// Freelist in the deduplication table entry cache. Links table
+// List of deduplication table entries. Links table
 // entries together using their _next fields.
 //
-class G1StringDedupEntryFreeList : public CHeapObj<mtGC> {
+class G1StringDedupEntryList : public CHeapObj<mtGC> {
 private:
 G1StringDedupEntry* _list;
 size_t              _length;
 public:
-G1StringDedupEntryFreeList() :
+G1StringDedupEntryList() :
 _list(NULL),
 _length(0) {
 }
 void add(G1StringDedupEntry* entry) {
 if (entry != NULL) {
 _list = entry->next();
 _length--;
 }
 return entry;
+}
+G1StringDedupEntry* remove_all() {
+G1StringDedupEntry* list = _list;
+_list = NULL;
+return list;
 }
 size_t length() {
 return _length;
 }
 // Allocations are synchronized by StringDedupTable_lock as part of a table
 // modification.
 //
 class G1StringDedupEntryCache : public CHeapObj<mtGC> {
 private:
-// One freelist per GC worker to allow lock less freeing of
+// One cache/overflow list per GC worker to allow lock less freeing of
-// entries while doing a parallel scan of the table. Using
+// entries while doing a parallel scan of the table. Using PaddedEnd to
-// PaddedEnd to avoid false sharing.
+// avoid false sharing.
-PaddedEnd<G1StringDedupEntryFreeList>* _lists;
+size_t                             _nlists;
-size_t                                 _nlists;
+size_t                             _max_list_length;
+PaddedEnd<G1StringDedupEntryList>* _cached;
+PaddedEnd<G1StringDedupEntryList>* _overflowed;
 public:
-G1StringDedupEntryCache();
+G1StringDedupEntryCache(size_t max_size);
 ~G1StringDedupEntryCache();
-// Get a table entry from the cache freelist, or allocate a new
+// Set max number of table entries to cache.
-// entry if the cache is empty.
+void set_max_size(size_t max_size);
+// Get a table entry from the cache, or allocate a new entry if the cache is empty.
 G1StringDedupEntry* alloc();
-// Insert a table entry into the cache freelist.
+// Insert a table entry into the cache.
 void free(G1StringDedupEntry* entry, uint worker_id);
 // Returns current number of entries in the cache.
 size_t size();
-// If the cache has grown above the given max size, trim it down
+// Deletes overflowed entries.
-// and deallocate the memory occupied by trimmed of entries.
+void delete_overflowed();
-void trim(size_t max_size);
 };
-G1StringDedupEntryCache::G1StringDedupEntryCache() {
+G1StringDedupEntryCache::G1StringDedupEntryCache(size_t max_size) :
-_nlists = MAX2(ParallelGCThreads, (size_t)1);
+_nlists(MAX2(ParallelGCThreads, (size_t)1)),
-_lists = PaddedArray<G1StringDedupEntryFreeList, mtGC>::create_unfreeable((uint)_nlists);
+_max_list_length(0),
+_cached(PaddedArray<G1StringDedupEntryList, mtGC>::create_unfreeable((uint)_nlists)),
+_overflowed(PaddedArray<G1StringDedupEntryList, mtGC>::create_unfreeable((uint)_nlists)) {
+set_max_size(max_size);
 }
 G1StringDedupEntryCache::~G1StringDedupEntryCache() {
 ShouldNotReachHere();
 }
+void G1StringDedupEntryCache::set_max_size(size_t size) {
+_max_list_length = size / _nlists;
+}
 G1StringDedupEntry* G1StringDedupEntryCache::alloc() {
 for (size_t i = 0; i < _nlists; i++) {
-G1StringDedupEntry* entry = _lists[i].remove();
+G1StringDedupEntry* entry = _cached[i].remove();
 if (entry != NULL) {
 return entry;
 }
 }
 return new G1StringDedupEntry();
 }
 void G1StringDedupEntryCache::free(G1StringDedupEntry* entry, uint worker_id) {
 assert(entry->obj() != NULL, "Double free");
 assert(worker_id < _nlists, "Invalid worker id");
 entry->set_obj(NULL);
 entry->set_hash(0);
-_lists[worker_id].add(entry);
+if (_cached[worker_id].length() < _max_list_length) {
+// Cache is not full
+_cached[worker_id].add(entry);
+} else {
+// Cache is full, add to overflow list for later deletion
+_overflowed[worker_id].add(entry);
+}
 }
 size_t G1StringDedupEntryCache::size() {
 size_t size = 0;
 for (size_t i = 0; i < _nlists; i++) {
-size += _lists[i].length();
+size += _cached[i].length();
 }
 return size;
 }
-void G1StringDedupEntryCache::trim(size_t max_size) {
+void G1StringDedupEntryCache::delete_overflowed() {
-size_t cache_size = 0;
+double start = os::elapsedTime();
+uintx count = 0;
 for (size_t i = 0; i < _nlists; i++) {
-G1StringDedupEntryFreeList* list = &_lists[i];
+G1StringDedupEntry* entry;
-cache_size += list->length();
-while (cache_size > max_size) {
+{
-G1StringDedupEntry* entry = list->remove();
+// The overflow list can be modified during safepoints, therefore
-assert(entry != NULL, "Should not be null");
+// we temporarily join the suspendible thread set while removing
-cache_size--;
+// all entries from the list.
+SuspendibleThreadSetJoiner sts_join;
+entry = _overflowed[i].remove_all();
+}
+// Delete all entries
+while (entry != NULL) {
+G1StringDedupEntry* next = entry->next();
 delete entry;
-}
+entry = next;
+count++;
+}
+}
+double end = os::elapsedTime();
+if (PrintStringDeduplicationStatistics) {
+gclog_or_tty->print_cr("[GC concurrent-string-deduplication, deleted " UINTX_FORMAT " entries, " G1_STRDEDUP_TIME_FORMAT "]", count, end - start);
 }
 }
 G1StringDedupTable*      G1StringDedupTable::_table = NULL;
 G1StringDedupEntryCache* G1StringDedupTable::_entry_cache = NULL;
 FREE_C_HEAP_ARRAY(G1StringDedupEntry*, _buckets, mtGC);
 }
 void G1StringDedupTable::create() {
 assert(_table == NULL, "One string deduplication table allowed");
-_entry_cache = new G1StringDedupEntryCache();
+_entry_cache = new G1StringDedupEntryCache((size_t)(_min_size * _max_cache_factor));
 _table = new G1StringDedupTable(_min_size);
 }
 void G1StringDedupTable::add(typeArrayOop value, unsigned int hash, G1StringDedupEntry** list) {
 G1StringDedupEntry* entry = _entry_cache->alloc();
 return NULL;
 }
 // Update statistics
 _resize_count++;
+// Update max cache size
+_entry_cache->set_max_size((size_t)(size * _max_cache_factor));
 // Allocate the new table. The new table will be populated by workers
 // calling unlink_or_oops_do() and finally installed by finish_resize().
 return new G1StringDedupTable(size, _table->_hash_seed);
 }
 // Scan the partition followed by the sibling partition in the second half of the table
 removed += unlink_or_oops_do(cl, partition_begin, partition_end, worker_id);
 removed += unlink_or_oops_do(cl, table_half + partition_begin, table_half + partition_end, worker_id);
 }
-// Delayed update avoid contention on the table lock
+// Delayed update to avoid contention on the table lock
 if (removed > 0) {
 MutexLockerEx ml(StringDedupTable_lock, Mutex::_no_safepoint_check_flag);
 _table->_entries -= removed;
 _entries_removed += removed;
 }
 entry1 = (*entry1)->next_addr();
 }
 }
 }
-void G1StringDedupTable::trim_entry_cache() {
+void G1StringDedupTable::clean_entry_cache() {
-MutexLockerEx ml(StringDedupTable_lock, Mutex::_no_safepoint_check_flag);
+_entry_cache->delete_overflowed();
-size_t max_cache_size = (size_t)(_table->_size * _max_cache_factor);
-_entry_cache->trim(max_cache_size);
 }
 void G1StringDedupTable::print_statistics(outputStream* st) {
 st->print_cr(
 "   [Table]\n"

Mercurial > jdk8-mips64-public > hotspot / file comparison

comparison: src/share/vm/gc_implementation/g1/g1StringDedupTable.cpp

src/share/vm/gc_implementation/g1/g1StringDedupTable.cpp