8326753: Lilliput: OMCache: Use AoS

Reviewed-by: rkennke

Author: xmas92

Diff for: src/hotspot/share/runtime/javaThread.hpp

@@ -1186,7 +1186,7 @@ class JavaThread: public Thread {
 
 
   static ByteSize om_cache_offset()        { return byte_offset_of(JavaThread, _om_cache); }
-  static ByteSize om_cache_oops_offset()   { return om_cache_offset() + OMCache::oops_offset(); }
+  static ByteSize om_cache_oops_offset()   { return om_cache_offset() + OMCache::entries(); }
 
   void om_set_monitor_cache(ObjectMonitor* monitor);
   void om_clear_monitor_cache();

Diff for: src/hotspot/share/runtime/lockStack.cpp

@@ -36,6 +36,7 @@
 #include "utilities/debug.hpp"
 #include "utilities/globalDefinitions.hpp"
 #include "utilities/ostream.hpp"
+#include "utilities/sizes.hpp"
 
 #include <type_traits>
 
@@ -110,3 +111,11 @@ void LockStack::print_on(outputStream* st) {
     }
   }
 }
+
+OMCache::OMCache(JavaThread* jt) : _entries() {
+  STATIC_ASSERT(std::is_standard_layout<OMCache>::value);
+  STATIC_ASSERT(std::is_standard_layout<OMCache::OMCacheEntry>::value);
+  STATIC_ASSERT(offsetof(OMCache, _null_sentinel) == offsetof(OMCache, _entries) +
+                offsetof(OMCache::OMCacheEntry, _oop) +
+                OMCache::CAPACITY * in_bytes(oop_to_oop_difference()));
+}

Diff for: src/hotspot/share/runtime/lockStack.hpp

@@ -140,17 +140,18 @@ class OMCache {
   static constexpr int CAPACITY = 8;
 
 private:
-  oop _oops[CAPACITY];
-  const oop _null_sentinel;
-  ObjectMonitor* _monitors[CAPACITY];
+  struct OMCacheEntry {
+    oop _oop = nullptr;
+    ObjectMonitor* _monitor = nullptr;
+  } _entries[CAPACITY];
+  const oop _null_sentinel = nullptr;
 
 public:
-  static ByteSize oops_offset() { return byte_offset_of(OMCache, _oops); }
-  static ByteSize monitors_offset() { return byte_offset_of(OMCache, _monitors); }
-  static ByteSize oop_to_oop_difference() { return in_ByteSize(sizeof(oop)); }
-  static ByteSize oop_to_monitor_difference() { return monitors_offset() - oops_offset(); }
+  static ByteSize entries() { return byte_offset_of(OMCache, _entries); }
+  static constexpr ByteSize oop_to_oop_difference() { return in_ByteSize(sizeof(OMCacheEntry)); }
+  static constexpr ByteSize oop_to_monitor_difference() { return in_ByteSize(sizeof(oop)); }
 
-  explicit OMCache(JavaThread* jt) : _oops(), _null_sentinel(nullptr), _monitors() {};
+  explicit OMCache(JavaThread* jt);
 
   inline ObjectMonitor* get_monitor(oop o);
   inline void set_monitor(ObjectMonitor* monitor);

Diff for: src/hotspot/share/runtime/lockStack.inline.hpp

@@ -247,55 +247,46 @@ inline void OMCache::set_monitor(ObjectMonitor *monitor) {
   assert(obj != nullptr, "must be alive");
   assert(monitor == PlaceholderSynchronizer::read_monitor(JavaThread::current(), obj), "must be exist in table");
 
-  oop cmp_obj = obj;
+  OMCacheEntry to_insert = {obj, monitor};
+
   for (int i = 0; i < end; ++i) {
-    if (_oops[i] == cmp_obj ||
-        _monitors[i] == nullptr ||
-        _monitors[i]->is_being_async_deflated()) {
-      _oops[i] = obj;
-      _monitors[i] = monitor;
+    if (_entries[i]._oop == obj ||
+        _entries[i]._monitor == nullptr ||
+        _entries[i]._monitor->is_being_async_deflated()) {
+      // Use stale slot.
+      _entries[i] = to_insert;
       return;
     }
-    // Remember Most Recent Values
-    oop tmp_oop = obj;
-    ObjectMonitor* tmp_mon = monitor;
-    // Set next pair to the next most recent
-    obj = _oops[i];
-    monitor = _monitors[i];
-    // Store most recent values
-    _oops[i] = tmp_oop;
-    _monitors[i] = tmp_mon;
+    // Swap with the most recent value.
+    ::swap(to_insert, _entries[i]);
   }
-  _oops[end] = obj;
-  _monitors[end] = monitor;
+  _entries[end] = to_insert;
 }
 
 inline ObjectMonitor* OMCache::get_monitor(oop o) {
   for (int i = 0; i < OMCacheSize; ++i) {
-    if (_oops[i] == o) {
-      assert(_monitors[i] != nullptr, "monitor must exist");
-      if (_monitors[i]->is_being_async_deflated()) {
+    if (_entries[i]._oop == o) {
+      assert(_entries[i]._monitor != nullptr, "monitor must exist");
+      if (_entries[i]._monitor->is_being_async_deflated()) {
         // Bad monitor
         // Shift down rest
         for (; i < OMCacheSize - 1; ++i) {
-          _oops[i] = _oops[i + 1];
-          _monitors[i] =  _monitors[i + 1];
+          _entries[i] = _entries[i + 1];
         }
-        // i == CAPACITY - 1
-        _oops[i] = nullptr;
-        _monitors[i] = nullptr;
+        // Clear end
+        _entries[i] = {};
         return nullptr;
       }
-      return _monitors[i];
+      return _entries[i]._monitor;
     }
   }
   return nullptr;
 }
 
 inline void OMCache::clear() {
   for (size_t i = 0 , r = 0; i < CAPACITY; ++i) {
-    _oops[i] = nullptr;
-    _monitors[i] = nullptr;
+    // Clear
+    _entries[i] = {};
   }
 }