8371347: Move the ObjectMonitorTable to a separate new file

Reviewed-by: dholmes, coleenp

src/hotspot/share/runtime/objectMonitorTable.cpp

@@ -0,0 +1,308 @@
+/*
+ * Copyright (c) 2024, 2025, 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.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ *
+ */
+
+#include "logging/log.hpp"
+#include "runtime/interfaceSupport.inline.hpp"
+#include "runtime/javaThread.hpp"
+#include "runtime/mutexLocker.hpp"
+#include "runtime/objectMonitorTable.hpp"
+#include "runtime/safepoint.hpp"
+#include "runtime/thread.hpp"
+#include "runtime/timerTrace.hpp"
+#include "runtime/trimNativeHeap.hpp"
+#include "utilities/concurrentHashTableTasks.inline.hpp"
+#include "utilities/globalDefinitions.hpp"
+
+// -----------------------------------------------------------------------------
+// ConcurrentHashTable storing links from objects to ObjectMonitors
+
+using ConcurrentTable = ConcurrentHashTable<ObjectMonitorTableConfig, mtObjectMonitor>;
+
+static ConcurrentTable* _table = nullptr;
+static volatile size_t _items_count = 0;
+static size_t _table_size = 0;
+static volatile bool _resize = false;
+
+class ObjectMonitorTableConfig : public AllStatic {
+ public:
+  using Value = ObjectMonitor*;
+  static uintx get_hash(Value const& value, bool* is_dead) {
+    return (uintx)value->hash();
+  }
+  static void* allocate_node(void* context, size_t size, Value const& value) {
+    ObjectMonitorTable::inc_items_count();
+    return AllocateHeap(size, mtObjectMonitor);
+  };
+  static void free_node(void* context, void* memory, Value const& value) {
+    ObjectMonitorTable::dec_items_count();
+    FreeHeap(memory);
+  }
+};
+
+class Lookup : public StackObj {
+  oop _obj;
+
+ public:
+  explicit Lookup(oop obj) : _obj(obj) {}
+
+  uintx get_hash() const {
+    uintx hash = _obj->mark().hash();
+    assert(hash != 0, "should have a hash");
+    return hash;
+  }
+
+  bool equals(ObjectMonitor** value) {
+    assert(*value != nullptr, "must be");
+    return (*value)->object_refers_to(_obj);
+  }
+
+  bool is_dead(ObjectMonitor** value) {
+    assert(*value != nullptr, "must be");
+    return false;
+  }
+};
+
+class LookupMonitor : public StackObj {
+  ObjectMonitor* _monitor;
+
+ public:
+  explicit LookupMonitor(ObjectMonitor* monitor) : _monitor(monitor) {}
+
+  uintx get_hash() const {
+    return _monitor->hash();
+  }
+
+  bool equals(ObjectMonitor** value) {
+    return (*value) == _monitor;
+  }
+
+  bool is_dead(ObjectMonitor** value) {
+    assert(*value != nullptr, "must be");
+    return (*value)->object_is_dead();
+  }
+};
+
+void ObjectMonitorTable::inc_items_count() {
+  AtomicAccess::inc(&_items_count, memory_order_relaxed);
+}
+
+void ObjectMonitorTable::dec_items_count() {
+  AtomicAccess::dec(&_items_count, memory_order_relaxed);
+}
+
+double ObjectMonitorTable::get_load_factor() {
+  size_t count = AtomicAccess::load(&_items_count);
+  return (double)count / (double)_table_size;
+}
+
+size_t ObjectMonitorTable::table_size(Thread* current) {
+  return ((size_t)1) << _table->get_size_log2(current);
+}
+
+size_t ObjectMonitorTable::max_log_size() {
+  // TODO[OMTable]: Evaluate the max size.
+  // TODO[OMTable]: Need to fix init order to use Universe::heap()->max_capacity();
+  //                Using MaxHeapSize directly this early may be wrong, and there
+  //                are definitely rounding errors (alignment).
+  const size_t max_capacity = MaxHeapSize;
+  const size_t min_object_size = CollectedHeap::min_dummy_object_size() * HeapWordSize;
+  const size_t max_objects = max_capacity / MAX2(MinObjAlignmentInBytes, checked_cast<int>(min_object_size));
+  const size_t log_max_objects = log2i_graceful(max_objects);
+
+  return MAX2(MIN2<size_t>(SIZE_BIG_LOG2, log_max_objects), min_log_size());
+}
+
+// ~= log(AvgMonitorsPerThreadEstimate default)
+size_t ObjectMonitorTable::min_log_size() {
+  return 10;
+}
+
+template<typename V>
+size_t ObjectMonitorTable::clamp_log_size(V log_size) {
+  return MAX2(MIN2(log_size, checked_cast<V>(max_log_size())), checked_cast<V>(min_log_size()));
+}
+
+size_t ObjectMonitorTable::initial_log_size() {
+  const size_t estimate = log2i(MAX2(os::processor_count(), 1)) + log2i(MAX2(AvgMonitorsPerThreadEstimate, size_t(1)));
+  return clamp_log_size(estimate);
+}
+
+size_t ObjectMonitorTable::grow_hint() {
+  return ConcurrentTable::DEFAULT_GROW_HINT;
+}
+
+void ObjectMonitorTable::create() {
+  _table = new ConcurrentTable(initial_log_size(), max_log_size(), grow_hint());
+  _items_count = 0;
+  _table_size = table_size(Thread::current());
+  _resize = false;
+}
+
+void ObjectMonitorTable::verify_monitor_get_result(oop obj, ObjectMonitor* monitor) {
+#ifdef ASSERT
+  if (SafepointSynchronize::is_at_safepoint()) {
+    bool has_monitor = obj->mark().has_monitor();
+    assert(has_monitor == (monitor != nullptr),
+           "Inconsistency between markWord and ObjectMonitorTable has_monitor: %s monitor: " PTR_FORMAT,
+           BOOL_TO_STR(has_monitor), p2i(monitor));
+  }
+#endif
+}
+
+ObjectMonitor* ObjectMonitorTable::monitor_get(Thread* current, oop obj) {
+  ObjectMonitor* result = nullptr;
+  Lookup lookup_f(obj);
+  auto found_f = [&](ObjectMonitor** found) {
+    assert((*found)->object_peek() == obj, "must be");
+    result = *found;
+  };
+  _table->get(current, lookup_f, found_f);
+  verify_monitor_get_result(obj, result);
+  return result;
+}
+
+void ObjectMonitorTable::try_notify_grow() {
+  if (!_table->is_max_size_reached() && !AtomicAccess::load(&_resize)) {
+    AtomicAccess::store(&_resize, true);
+    if (Service_lock->try_lock()) {
+      Service_lock->notify();
+      Service_lock->unlock();
+    }
+  }
+}
+
+bool ObjectMonitorTable::should_grow() {
+  return get_load_factor() > GROW_LOAD_FACTOR && !_table->is_max_size_reached();
+}
+
+bool ObjectMonitorTable::should_resize() {
+  return should_grow() || should_shrink() || AtomicAccess::load(&_resize);
+}
+
+template <typename Task, typename... Args>
+bool ObjectMonitorTable::run_task(JavaThread* current, Task& task, const char* task_name, Args&... args) {
+  if (task.prepare(current)) {
+    log_trace(monitortable)("Started to %s", task_name);
+    TraceTime timer(task_name, TRACETIME_LOG(Debug, monitortable, perf));
+    while (task.do_task(current, args...)) {
+      task.pause(current);
+      {
+        ThreadBlockInVM tbivm(current);
+      }
+      task.cont(current);
+    }
+    task.done(current);
+    return true;
+  }
+  return false;
+}
+
+bool ObjectMonitorTable::grow(JavaThread* current) {
+  ConcurrentTable::GrowTask grow_task(_table);
+  if (run_task(current, grow_task, "Grow")) {
+    _table_size = table_size(current);
+    log_info(monitortable)("Grown to size: %zu", _table_size);
+    return true;
+  }
+  return false;
+}
+
+bool ObjectMonitorTable::clean(JavaThread* current) {
+  ConcurrentTable::BulkDeleteTask clean_task(_table);
+  auto is_dead = [&](ObjectMonitor** monitor) {
+    return (*monitor)->object_is_dead();
+  };
+  auto do_nothing = [&](ObjectMonitor** monitor) {};
+  NativeHeapTrimmer::SuspendMark sm("ObjectMonitorTable");
+  return run_task(current, clean_task, "Clean", is_dead, do_nothing);
+}
+
+bool ObjectMonitorTable::resize(JavaThread* current) {
+  LogTarget(Info, monitortable) lt;
+  bool success = false;
+
+  if (should_grow()) {
+    lt.print("Start growing with load factor %f", get_load_factor());
+    success = grow(current);
+  } else {
+    if (!_table->is_max_size_reached() && AtomicAccess::load(&_resize)) {
+      lt.print("WARNING: Getting resize hints with load factor %f", get_load_factor());
+    }
+    lt.print("Start cleaning with load factor %f", get_load_factor());
+    success = clean(current);
+  }
+
+  AtomicAccess::store(&_resize, false);
+
+  return success;
+}
+
+ObjectMonitor* ObjectMonitorTable::monitor_put_get(Thread* current, ObjectMonitor* monitor, oop obj) {
+  // Enter the monitor into the concurrent hashtable.
+  ObjectMonitor* result = monitor;
+  Lookup lookup_f(obj);
+  auto found_f = [&](ObjectMonitor** found) {
+    assert((*found)->object_peek() == obj, "must be");
+    result = *found;
+  };
+  bool grow;
+  _table->insert_get(current, lookup_f, monitor, found_f, &grow);
+  verify_monitor_get_result(obj, result);
+  if (grow) {
+    try_notify_grow();
+  }
+  return result;
+}
+
+bool ObjectMonitorTable::remove_monitor_entry(Thread* current, ObjectMonitor* monitor) {
+  LookupMonitor lookup_f(monitor);
+  return _table->remove(current, lookup_f);
+}
+
+bool ObjectMonitorTable::contains_monitor(Thread* current, ObjectMonitor* monitor) {
+  LookupMonitor lookup_f(monitor);
+  bool result = false;
+  auto found_f = [&](ObjectMonitor** found) {
+    result = true;
+  };
+  _table->get(current, lookup_f, found_f);
+  return result;
+}
+
+void ObjectMonitorTable::print_on(outputStream* st) {
+  auto printer = [&] (ObjectMonitor** entry) {
+    ObjectMonitor* om = *entry;
+    oop obj = om->object_peek();
+    st->print("monitor=" PTR_FORMAT ", ", p2i(om));
+    st->print("object=" PTR_FORMAT, p2i(obj));
+    assert(obj->mark().hash() == om->hash(), "hash must match");
+    st->cr();
+    return true;
+  };
+  if (SafepointSynchronize::is_at_safepoint()) {
+    _table->do_safepoint_scan(printer);
+  } else {
+    _table->do_scan(Thread::current(), printer);
+  }
+}

src/hotspot/share/runtime/objectMonitorTable.hpp

@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) 2024, 2025, 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.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ *
+ */
+
+#ifndef SHARE_RUNTIME_OBJECTMONITORTABLE_HPP
+#define SHARE_RUNTIME_OBJECTMONITORTABLE_HPP
+
+#include "memory/allStatic.hpp"
+#include "oops/oopsHierarchy.hpp"
+#include "utilities/globalDefinitions.hpp"
+
+class JavaThread;
+class ObjectMonitor;
+class ObjectMonitorTableConfig;
+class outputStream;
+class Thread;
+
+class ObjectMonitorTable : AllStatic {
+  friend class ObjectMonitorTableConfig;
+
+ private:
+  static void inc_items_count();
+  static void dec_items_count();
+  static double get_load_factor();
+  static size_t table_size(Thread* current);
+  static size_t max_log_size();
+  static size_t min_log_size();
+
+  template <typename V>
+  static size_t clamp_log_size(V log_size);
+  static size_t initial_log_size();
+  static size_t grow_hint();
+
+ public:
+  static void create();
+  static void verify_monitor_get_result(oop obj, ObjectMonitor* monitor);
+  static ObjectMonitor* monitor_get(Thread* current, oop obj);
+  static void try_notify_grow();
+  static bool should_shrink() { return false; } // Not implemented
+
+  static constexpr double GROW_LOAD_FACTOR = 0.75;
+
+  static bool should_grow();
+  static bool should_resize();
+
+  template <typename Task, typename... Args>
+  static bool run_task(JavaThread* current, Task& task, const char* task_name, Args&... args);
+  static bool grow(JavaThread* current);
+  static bool clean(JavaThread* current);
+  static bool resize(JavaThread* current);
+  static ObjectMonitor* monitor_put_get(Thread* current, ObjectMonitor* monitor, oop obj);
+  static bool remove_monitor_entry(Thread* current, ObjectMonitor* monitor);
+  static bool contains_monitor(Thread* current, ObjectMonitor* monitor);
+  static void print_on(outputStream* st);
+};
+
+#endif // SHARE_RUNTIME_OBJECTMONITORTABLE_HPP

src/hotspot/share/runtime/synchronizer.cpp

@@ -44,6 +44,7 @@
 #include "runtime/lockStack.inline.hpp"
 #include "runtime/mutexLocker.hpp"
 #include "runtime/objectMonitor.inline.hpp"
+#include "runtime/objectMonitorTable.hpp"
 #include "runtime/os.inline.hpp"
 #include "runtime/osThread.hpp"
 #include "runtime/safepointMechanism.inline.hpp"
@@ -1470,291 +1471,6 @@ void ObjectSynchronizer::log_in_use_monitor_details(outputStream* out, bool log_
   out->flush();
 }
 
-// -----------------------------------------------------------------------------
-// ConcurrentHashTable storing links from objects to ObjectMonitors
-class ObjectMonitorTable : AllStatic {
-  struct Config {
-    using Value = ObjectMonitor*;
-    static uintx get_hash(Value const& value, bool* is_dead) {
-      return (uintx)value->hash();
-    }
-    static void* allocate_node(void* context, size_t size, Value const& value) {
-      ObjectMonitorTable::inc_items_count();
-      return AllocateHeap(size, mtObjectMonitor);
-    };
-    static void free_node(void* context, void* memory, Value const& value) {
-      ObjectMonitorTable::dec_items_count();
-      FreeHeap(memory);
-    }
-  };
-  using ConcurrentTable = ConcurrentHashTable<Config, mtObjectMonitor>;
-
-  static ConcurrentTable* _table;
-  static volatile size_t _items_count;
-  static size_t _table_size;
-  static volatile bool _resize;
-
-  class Lookup : public StackObj {
-    oop _obj;
-
-   public:
-    explicit Lookup(oop obj) : _obj(obj) {}
-
-    uintx get_hash() const {
-      uintx hash = _obj->mark().hash();
-      assert(hash != 0, "should have a hash");
-      return hash;
-    }
-
-    bool equals(ObjectMonitor** value) {
-      assert(*value != nullptr, "must be");
-      return (*value)->object_refers_to(_obj);
-    }
-
-    bool is_dead(ObjectMonitor** value) {
-      assert(*value != nullptr, "must be");
-      return false;
-    }
-  };
-
-  class LookupMonitor : public StackObj {
-    ObjectMonitor* _monitor;
-
-   public:
-    explicit LookupMonitor(ObjectMonitor* monitor) : _monitor(monitor) {}
-
-    uintx get_hash() const {
-      return _monitor->hash();
-    }
-
-    bool equals(ObjectMonitor** value) {
-      return (*value) == _monitor;
-    }
-
-    bool is_dead(ObjectMonitor** value) {
-      assert(*value != nullptr, "must be");
-      return (*value)->object_is_dead();
-    }
-  };
-
-  static void inc_items_count() {
-    AtomicAccess::inc(&_items_count, memory_order_relaxed);
-  }
-
-  static void dec_items_count() {
-    AtomicAccess::dec(&_items_count, memory_order_relaxed);
-  }
-
-  static double get_load_factor() {
-    size_t count = AtomicAccess::load(&_items_count);
-    return (double)count / (double)_table_size;
-  }
-
-  static size_t table_size(Thread* current = Thread::current()) {
-    return ((size_t)1) << _table->get_size_log2(current);
-  }
-
-  static size_t max_log_size() {
-    // TODO[OMTable]: Evaluate the max size.
-    // TODO[OMTable]: Need to fix init order to use Universe::heap()->max_capacity();
-    //                Using MaxHeapSize directly this early may be wrong, and there
-    //                are definitely rounding errors (alignment).
-    const size_t max_capacity = MaxHeapSize;
-    const size_t min_object_size = CollectedHeap::min_dummy_object_size() * HeapWordSize;
-    const size_t max_objects = max_capacity / MAX2(MinObjAlignmentInBytes, checked_cast<int>(min_object_size));
-    const size_t log_max_objects = log2i_graceful(max_objects);
-
-    return MAX2(MIN2<size_t>(SIZE_BIG_LOG2, log_max_objects), min_log_size());
-  }
-
-  static size_t min_log_size() {
-    // ~= log(AvgMonitorsPerThreadEstimate default)
-    return 10;
-  }
-
-  template<typename V>
-  static size_t clamp_log_size(V log_size) {
-    return MAX2(MIN2(log_size, checked_cast<V>(max_log_size())), checked_cast<V>(min_log_size()));
-  }
-
-  static size_t initial_log_size() {
-    const size_t estimate = log2i(MAX2(os::processor_count(), 1)) + log2i(MAX2(AvgMonitorsPerThreadEstimate, size_t(1)));
-    return clamp_log_size(estimate);
-  }
-
-  static size_t grow_hint () {
-    return ConcurrentTable::DEFAULT_GROW_HINT;
-  }
-
- public:
-  static void create() {
-    _table = new ConcurrentTable(initial_log_size(), max_log_size(), grow_hint());
-    _items_count = 0;
-    _table_size = table_size();
-    _resize = false;
-  }
-
-  static void verify_monitor_get_result(oop obj, ObjectMonitor* monitor) {
-#ifdef ASSERT
-    if (SafepointSynchronize::is_at_safepoint()) {
-      bool has_monitor = obj->mark().has_monitor();
-      assert(has_monitor == (monitor != nullptr),
-          "Inconsistency between markWord and ObjectMonitorTable has_monitor: %s monitor: " PTR_FORMAT,
-          BOOL_TO_STR(has_monitor), p2i(monitor));
-    }
-#endif
-  }
-
-  static ObjectMonitor* monitor_get(Thread* current, oop obj) {
-    ObjectMonitor* result = nullptr;
-    Lookup lookup_f(obj);
-    auto found_f = [&](ObjectMonitor** found) {
-      assert((*found)->object_peek() == obj, "must be");
-      result = *found;
-    };
-    _table->get(current, lookup_f, found_f);
-    verify_monitor_get_result(obj, result);
-    return result;
-  }
-
-  static void try_notify_grow() {
-    if (!_table->is_max_size_reached() && !AtomicAccess::load(&_resize)) {
-      AtomicAccess::store(&_resize, true);
-      if (Service_lock->try_lock()) {
-        Service_lock->notify();
-        Service_lock->unlock();
-      }
-    }
-  }
-
-  static bool should_shrink() {
-    // Not implemented;
-    return false;
-  }
-
-  static constexpr double GROW_LOAD_FACTOR = 0.75;
-
-  static bool should_grow() {
-    return get_load_factor() > GROW_LOAD_FACTOR && !_table->is_max_size_reached();
-  }
-
-  static bool should_resize() {
-    return should_grow() || should_shrink() || AtomicAccess::load(&_resize);
-  }
-
-  template<typename Task, typename... Args>
-  static bool run_task(JavaThread* current, Task& task, const char* task_name, Args&... args) {
-    if (task.prepare(current)) {
-      log_trace(monitortable)("Started to %s", task_name);
-      TraceTime timer(task_name, TRACETIME_LOG(Debug, monitortable, perf));
-      while (task.do_task(current, args...)) {
-        task.pause(current);
-        {
-          ThreadBlockInVM tbivm(current);
-        }
-        task.cont(current);
-      }
-      task.done(current);
-      return true;
-    }
-    return false;
-  }
-
-  static bool grow(JavaThread* current) {
-    ConcurrentTable::GrowTask grow_task(_table);
-    if (run_task(current, grow_task, "Grow")) {
-      _table_size = table_size(current);
-      log_info(monitortable)("Grown to size: %zu", _table_size);
-      return true;
-    }
-    return false;
-  }
-
-  static bool clean(JavaThread* current) {
-    ConcurrentTable::BulkDeleteTask clean_task(_table);
-    auto is_dead = [&](ObjectMonitor** monitor) {
-      return (*monitor)->object_is_dead();
-    };
-    auto do_nothing = [&](ObjectMonitor** monitor) {};
-    NativeHeapTrimmer::SuspendMark sm("ObjectMonitorTable");
-    return run_task(current, clean_task, "Clean", is_dead, do_nothing);
-  }
-
-  static bool resize(JavaThread* current) {
-    LogTarget(Info, monitortable) lt;
-    bool success = false;
-
-    if (should_grow()) {
-      lt.print("Start growing with load factor %f", get_load_factor());
-      success = grow(current);
-    } else {
-      if (!_table->is_max_size_reached() && AtomicAccess::load(&_resize)) {
-        lt.print("WARNING: Getting resize hints with load factor %f", get_load_factor());
-      }
-      lt.print("Start cleaning with load factor %f", get_load_factor());
-      success = clean(current);
-    }
-
-    AtomicAccess::store(&_resize, false);
-
-    return success;
-  }
-
-  static ObjectMonitor* monitor_put_get(Thread* current, ObjectMonitor* monitor, oop obj) {
-    // Enter the monitor into the concurrent hashtable.
-    ObjectMonitor* result = monitor;
-    Lookup lookup_f(obj);
-    auto found_f = [&](ObjectMonitor** found) {
-      assert((*found)->object_peek() == obj, "must be");
-      result = *found;
-    };
-    bool grow;
-    _table->insert_get(current, lookup_f, monitor, found_f, &grow);
-    verify_monitor_get_result(obj, result);
-    if (grow) {
-      try_notify_grow();
-    }
-    return result;
-  }
-
-  static bool remove_monitor_entry(Thread* current, ObjectMonitor* monitor) {
-    LookupMonitor lookup_f(monitor);
-    return _table->remove(current, lookup_f);
-  }
-
-  static bool contains_monitor(Thread* current, ObjectMonitor* monitor) {
-    LookupMonitor lookup_f(monitor);
-    bool result = false;
-    auto found_f = [&](ObjectMonitor** found) {
-      result = true;
-    };
-    _table->get(current, lookup_f, found_f);
-    return result;
-  }
-
-  static void print_on(outputStream* st) {
-    auto printer = [&] (ObjectMonitor** entry) {
-       ObjectMonitor* om = *entry;
-       oop obj = om->object_peek();
-       st->print("monitor=" PTR_FORMAT ", ", p2i(om));
-       st->print("object=" PTR_FORMAT, p2i(obj));
-       assert(obj->mark().hash() == om->hash(), "hash must match");
-       st->cr();
-       return true;
-    };
-    if (SafepointSynchronize::is_at_safepoint()) {
-      _table->do_safepoint_scan(printer);
-    } else {
-      _table->do_scan(Thread::current(), printer);
-    }
-  }
-};
-
-ObjectMonitorTable::ConcurrentTable* ObjectMonitorTable::_table = nullptr;
-volatile size_t ObjectMonitorTable::_items_count = 0;
-size_t ObjectMonitorTable::_table_size = 0;
-volatile bool ObjectMonitorTable::_resize = false;
-
 ObjectMonitor* ObjectSynchronizer::get_or_insert_monitor_from_table(oop object, JavaThread* current, bool* inserted) {
   ObjectMonitor* monitor = get_monitor_from_table(current, object);
   if (monitor != nullptr) {