src/share/vm/memory/binaryTreeDictionary.cpp

rev 13203 : [mq]: freebldict
rev 13204 : imported patch dither
rev 13205 : imported patch copyyear

@@ -1,7 +1,7 @@
 /*
- * Copyright (c) 2001, 2015, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2001, 2017, 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.

@@ -25,11 +25,10 @@
 #include "precompiled.hpp"
 #include "gc/cms/allocationStats.hpp"
 #include "gc/shared/spaceDecorator.hpp"
 #include "logging/logStream.inline.hpp"
 #include "memory/binaryTreeDictionary.hpp"
-#include "memory/freeBlockDictionary.hpp"
 #include "memory/freeList.hpp"
 #include "memory/metachunk.hpp"
 #include "memory/resourceArea.hpp"
 #include "runtime/globals.hpp"
 #include "utilities/macros.hpp"

@@ -424,13 +423,11 @@
 }
 
 // Get a free block of size at least size from tree, or NULL.
 template <class Chunk_t, class FreeList_t>
 TreeChunk<Chunk_t, FreeList_t>*
-BinaryTreeDictionary<Chunk_t, FreeList_t>::get_chunk_from_tree(
-                              size_t size,
-                              enum FreeBlockDictionary<Chunk_t>::Dither dither)
+BinaryTreeDictionary<Chunk_t, FreeList_t>::get_chunk_from_tree(size_t size)
 {
   TreeList<Chunk_t, FreeList_t> *curTL, *prevTL;
   TreeChunk<Chunk_t, FreeList_t>* retTC = NULL;
 
   assert((size >= min_size()), "minimum chunk size");

@@ -451,12 +448,10 @@
       curTL = curTL->left();
     }
   }
   if (curTL == NULL) { // couldn't find exact match
 
-    if (dither == FreeBlockDictionary<Chunk_t>::exactly) return NULL;
-
     // try and find the next larger size by walking back up the search path
     for (curTL = prevTL; curTL != NULL;) {
       if (curTL->size() >= size) break;
       else curTL = curTL->parent();
     }

@@ -770,11 +765,11 @@
   }
 }
 
 template <class Chunk_t, class FreeList_t>
 size_t BinaryTreeDictionary<Chunk_t, FreeList_t>::max_chunk_size() const {
-  FreeBlockDictionary<Chunk_t>::verify_par_locked();
+  verify_par_locked();
   TreeList<Chunk_t, FreeList_t>* tc = root();
   if (tc == NULL) return 0;
   for (; tc->right() != NULL; tc = tc->right());
   return tc->size();
 }

@@ -1110,10 +1105,31 @@
 size_t BinaryTreeDictionary<Chunk_t, FreeList_t>::total_count() {
   treeCountClosure<Chunk_t, FreeList_t> ctc(0);
   ctc.do_tree(root());
   return ctc.count;
 }
+
+template <class Chunk_t, class FreeList_t>
+Mutex* BinaryTreeDictionary<Chunk_t, FreeList_t>::par_lock() const {
+  return _lock;
+}
+
+template <class Chunk_t, class FreeList_t>
+void BinaryTreeDictionary<Chunk_t, FreeList_t>::set_par_lock(Mutex* lock) {
+  _lock = lock;
+}
+
+template <class Chunk_t, class FreeList_t>
+void BinaryTreeDictionary<Chunk_t, FreeList_t>::verify_par_locked() const {
+#ifdef ASSERT
+  Thread* my_thread = Thread::current();
+  if (my_thread->is_GC_task_thread()) {
+    assert(par_lock() != NULL, "Should be using locking?");
+    assert_lock_strong(par_lock());
+  }
+#endif // ASSERT
+}
 #endif // PRODUCT
 
 // Calculate surpluses for the lists in the tree.
 template <class Chunk_t, class FreeList_t>
 class setTreeSurplusClosure : public AscendTreeCensusClosure<Chunk_t, FreeList_t> {

@@ -1200,11 +1216,11 @@
 }
 
 // Print summary statistics
 template <class Chunk_t, class FreeList_t>
 void BinaryTreeDictionary<Chunk_t, FreeList_t>::report_statistics(outputStream* st) const {
-  FreeBlockDictionary<Chunk_t>::verify_par_locked();
+  verify_par_locked();
   st->print_cr("Statistics for BinaryTreeDictionary:");
   st->print_cr("------------------------------------");
   size_t total_size = total_chunk_size(debug_only(NULL));
   size_t free_blocks = num_free_blocks();
   st->print_cr("Total Free Space: " SIZE_FORMAT, total_size);