KLUT

src/hotspot/share/cds/aotLinkedClassBulkLoader.cpp

@@ -36,6 +36,7 @@
 #include "memory/resourceArea.hpp"
 #include "oops/instanceKlass.hpp"
 #include "oops/klass.inline.hpp"
+#include "oops/klassInfoLUT.hpp"
 #include "runtime/handles.inline.hpp"
 #include "runtime/java.hpp"
 
@@ -176,6 +177,7 @@ void AOTLinkedClassBulkLoader::load_classes_impl(AOTLinkedClassCategory class_ca
   }
 
   ClassLoaderData* loader_data = ClassLoaderData::class_loader_data(loader());
+  KlassInfoLUT::register_cld_if_needed(loader_data);
 
   for (int i = 0; i < classes->length(); i++) {
     InstanceKlass* ik = classes->at(i);

src/hotspot/share/cds/archiveBuilder.cpp

@@ -52,6 +52,7 @@
 #include "memory/resourceArea.hpp"
 #include "oops/compressedKlass.inline.hpp"
 #include "oops/instanceKlass.hpp"
+#include "oops/klassInfoLUTEntry.hpp"
 #include "oops/objArrayKlass.hpp"
 #include "oops/objArrayOop.inline.hpp"
 #include "oops/oopHandle.inline.hpp"
@@ -771,13 +772,17 @@ void ArchiveBuilder::make_klasses_shareable() {
   int unreg_unlinked = 0;
 
   for (int i = 0; i < klasses()->length(); i++) {
+    Klass* k = get_buffered_addr(klasses()->at(i));
     // Some of the code in ConstantPool::remove_unshareable_info() requires the classes
     // to be in linked state, so it must be call here before the next loop, which returns
     // all classes to unlinked state.
-    Klass* k = get_buffered_addr(klasses()->at(i));
     if (k->is_instance_klass()) {
       InstanceKlass::cast(k)->constants()->remove_unshareable_info();
     }
+    // Every archived Klass must carry a valid klute. That is because every archived Klass
+    // would have been created via the usual dynamic class loading or - generation, which should
+    // have registered the Klass with klut.
+    DEBUG_ONLY(KlassLUTEntry(k->klute()).verify_against_klass(k));
   }
 
   for (int i = 0; i < klasses()->length(); i++) {

src/hotspot/share/cds/metaspaceShared.cpp

@@ -75,6 +75,7 @@
 #include "oops/compressedKlass.hpp"
 #include "oops/instanceMirrorKlass.hpp"
 #include "oops/klass.inline.hpp"
+#include "oops/klassInfoLUT.hpp"
 #include "oops/objArrayOop.hpp"
 #include "oops/oop.inline.hpp"
 #include "oops/oopHandle.hpp"
@@ -1437,6 +1438,14 @@ MapArchiveResult MetaspaceShared::map_archives(FileMapInfo* static_mapinfo, File
       }
       CompressedKlassPointers::establish_protection_zone(encoding_base, prot_zone_size);
 
+      // Initialize KLUT
+      KlassInfoLUT::initialize();
+
+      // Scan the CDS klass range for already existing Klass structures
+      const address start = (address)align_up(archive_space_rs.base() + prot_zone_size, CompressedKlassPointers::klass_alignment_in_bytes());
+      const address end   = (address)archive_space_rs.base() + archive_space_rs.size();
+      KlassInfoLUT::scan_klass_range_update_lut(start, end);
+
       // map_or_load_heap_region() compares the current narrow oop and klass encodings
       // with the archived ones, so it must be done after all encodings are determined.
       static_mapinfo->map_or_load_heap_region();

src/hotspot/share/classfile/classFileParser.cpp

@@ -5240,6 +5240,8 @@ void ClassFileParser::fill_instance_klass(InstanceKlass* ik,
   // in order for it to not be destroyed in the ClassFileParser destructor.
   set_klass_to_deallocate(nullptr);
 
+  ik->register_with_klut();
+
   // it's official
   set_klass(ik);
 

src/hotspot/share/classfile/systemDictionaryShared.cpp

@@ -65,6 +65,7 @@
 #include "oops/compressedKlass.inline.hpp"
 #include "oops/instanceKlass.hpp"
 #include "oops/klass.inline.hpp"
+#include "oops/klassInfoLUT.hpp"
 #include "oops/objArrayKlass.hpp"
 #include "oops/objArrayOop.inline.hpp"
 #include "oops/oop.inline.hpp"
@@ -170,6 +171,7 @@ InstanceKlass* SystemDictionaryShared::acquire_class_for_current_thread(
 
     // No other thread has acquired this yet, so give it to *this thread*
     ik->set_class_loader_data(loader_data);
+    KlassInfoLUT::shared_klass_cld_changed(ik);
   }
 
   // No longer holding SharedDictionary_lock
@@ -430,6 +432,7 @@ InstanceKlass* SystemDictionaryShared::find_or_load_shared_class(
       if (k != nullptr) {
         SharedClassLoadingMark slm(THREAD, k);
         k = find_or_define_instance_class(name, class_loader, k, CHECK_NULL);
+        k->register_with_klut();
       }
     }
   }

src/hotspot/share/gc/g1/g1FullGCMarker.inline.hpp

@@ -39,6 +39,7 @@
 #include "gc/shared/continuationGCSupport.inline.hpp"
 #include "gc/shared/preservedMarks.inline.hpp"
 #include "gc/shared/stringdedup/stringDedup.hpp"
+#include "memory/iterator.inline.hpp"
 #include "oops/access.inline.hpp"
 #include "oops/compressedOops.inline.hpp"
 #include "oops/oop.inline.hpp"
@@ -108,7 +109,7 @@ void G1FullGCMarker::follow_array_chunk(objArrayOop array, int index) {
     push_objarray(array, end_index);
   }
 
-  array->oop_iterate_range(mark_closure(), beg_index, end_index);
+  OopIteratorClosureDispatch::oop_oop_iterate_range(array, mark_closure(), beg_index, end_index);
 }
 
 inline void G1FullGCMarker::follow_object(oop obj) {

src/hotspot/share/gc/g1/g1ParScanThreadState.cpp

@@ -40,6 +40,7 @@
 #include "gc/shared/stringdedup/stringDedup.hpp"
 #include "gc/shared/taskqueue.inline.hpp"
 #include "memory/allocation.inline.hpp"
+#include "memory/iterator.inline.hpp"
 #include "oops/access.inline.hpp"
 #include "oops/oop.inline.hpp"
 #include "runtime/atomic.hpp"
@@ -232,9 +233,10 @@ void G1ParScanThreadState::do_partial_array(PartialArrayState* state, bool stole
   G1HeapRegionAttr dest_attr = _g1h->region_attr(to_array);
   G1SkipCardEnqueueSetter x(&_scanner, dest_attr.is_new_survivor());
   // Process claimed task.
-  to_array->oop_iterate_range(&_scanner,
-                              checked_cast<int>(claim._start),
-                              checked_cast<int>(claim._end));
+  OopIteratorClosureDispatch::oop_oop_iterate_range(to_array,
+                                                    &_scanner,
+                                                    checked_cast<int>(claim._start),
+                                                    checked_cast<int>(claim._end));
 }
 
 MAYBE_INLINE_EVACUATION
@@ -254,7 +256,9 @@ void G1ParScanThreadState::start_partial_objarray(oop from_obj,
   // Process the initial chunk.  No need to process the type in the
   // klass, as it will already be handled by processing the built-in
   // module.
-  to_array->oop_iterate_range(&_scanner, 0, checked_cast<int>(initial_chunk_size));
+  OopIteratorClosureDispatch::oop_oop_iterate_range(to_array,
+                                                    &_scanner,
+                                                    0, checked_cast<int>(initial_chunk_size));
 }
 
 MAYBE_INLINE_EVACUATION
@@ -452,7 +456,7 @@ void G1ParScanThreadState::do_iterate_object(oop const obj,
     }
 
     assert(_scanner.skip_card_enqueue_set(), "must be");
-    obj->oop_iterate_backwards(&_scanner, klass);
+    obj->oop_iterate_backwards(&_scanner);
 }
 
 // Private inline function, for direct internal use and providing the

src/hotspot/share/gc/parallel/psPromotionManager.inline.hpp

@@ -39,6 +39,7 @@
 #include "logging/log.hpp"
 #include "memory/iterator.inline.hpp"
 #include "oops/access.inline.hpp"
+#include "oops/klassInfoLUTEntry.hpp"
 #include "oops/oop.inline.hpp"
 #include "runtime/orderAccess.hpp"
 #include "runtime/prefetch.inline.hpp"
@@ -114,19 +115,19 @@ class PSPushContentsClosure: public BasicOopIterateClosure {
 // order of these function calls.
 //
 template <>
-inline void InstanceRefKlass::oop_oop_iterate_reverse<oop, PSPushContentsClosure>(oop obj, PSPushContentsClosure* closure) {
+inline void InstanceRefKlass::oop_oop_iterate_reverse<oop, PSPushContentsClosure>(oop obj, PSPushContentsClosure* closure, klute_raw_t klute) {
   oop_oop_iterate_ref_processing<oop>(obj, closure);
-  InstanceKlass::oop_oop_iterate_reverse<oop>(obj, closure);
+  InstanceKlass::oop_oop_iterate_reverse<oop>(obj, closure, klute);
 }
 
 template <>
-inline void InstanceRefKlass::oop_oop_iterate_reverse<narrowOop, PSPushContentsClosure>(oop obj, PSPushContentsClosure* closure) {
+inline void InstanceRefKlass::oop_oop_iterate_reverse<narrowOop, PSPushContentsClosure>(oop obj, PSPushContentsClosure* closure, klute_raw_t klute) {
   oop_oop_iterate_ref_processing<narrowOop>(obj, closure);
-  InstanceKlass::oop_oop_iterate_reverse<narrowOop>(obj, closure);
+  InstanceKlass::oop_oop_iterate_reverse<narrowOop>(obj, closure, klute);
 }
 
 inline void PSPromotionManager::push_contents(oop obj) {
-  if (!obj->klass()->is_typeArray_klass()) {
+  if (!obj->is_typeArray()) {
     PSPushContentsClosure pcc(this);
     obj->oop_iterate_backwards(&pcc);
   }

src/hotspot/share/gc/serial/serialFullGC.cpp

@@ -412,7 +412,7 @@ void SerialFullGC::follow_array_chunk(objArrayOop array, int index) {
   const int stride = MIN2(len - beg_index, (int) ObjArrayMarkingStride);
   const int end_index = beg_index + stride;
 
-  array->oop_iterate_range(&mark_and_push_closure, beg_index, end_index);
+  OopIteratorClosureDispatch::oop_oop_iterate_range(array, &mark_and_push_closure, beg_index, end_index);
 
   if (end_index < len) {
     SerialFullGC::push_objarray(array, end_index); // Push the continuation.

src/hotspot/share/gc/shenandoah/shenandoahMark.inline.hpp

@@ -167,7 +167,7 @@ inline void ShenandoahMark::do_chunked_array_start(ShenandoahObjToScanQueue* q,
 
   if (len <= (int) ObjArrayMarkingStride*2) {
     // A few slices only, process directly
-    array->oop_iterate_range(cl, 0, len);
+    OopIteratorClosureDispatch::oop_oop_iterate_range(array, cl, 0, len);
   } else {
     int bits = log2i_graceful(len);
     // Compensate for non-power-of-two arrays, cover the array in excess:
@@ -216,7 +216,7 @@ inline void ShenandoahMark::do_chunked_array_start(ShenandoahObjToScanQueue* q,
     // Process the irregular tail, if present
     int from = last_idx;
     if (from < len) {
-      array->oop_iterate_range(cl, from, len);
+      OopIteratorClosureDispatch::oop_oop_iterate_range(array, cl, from, len);
     }
   }
 }
@@ -248,7 +248,7 @@ inline void ShenandoahMark::do_chunked_array(ShenandoahObjToScanQueue* q, T* cl,
   assert (0 < to && to <= len, "to is sane: %d/%d", to, len);
 #endif
 
-  array->oop_iterate_range(cl, from, to);
+  OopIteratorClosureDispatch::oop_oop_iterate_range(array, cl, from, to);
 }
 
 template <ShenandoahGenerationType GENERATION>

src/hotspot/share/gc/z/zIterator.inline.hpp

@@ -68,7 +68,7 @@ void ZIterator::oop_iterate(oop obj, OopClosureT* cl) {
 template <typename OopClosureT>
 void ZIterator::oop_iterate_range(objArrayOop obj, OopClosureT* cl, int start, int end) {
   assert(!is_invisible_object_array(obj), "not safe");
-  obj->oop_iterate_range(cl, start, end);
+  OopIteratorClosureDispatch::oop_oop_iterate_range(obj, cl, start, end);
 }
 
 template <typename Function>

src/hotspot/share/logging/logTag.hpp

@@ -110,6 +110,7 @@ class outputStream;
   LOG_TAG(jni) \
   LOG_TAG(jvmci) \
   LOG_TAG(jvmti) \
+  LOG_TAG(klut) \
   LOG_TAG(lambda) \
   LOG_TAG(library) \
   LOG_TAG(link) \

src/hotspot/share/memory/allocation.cpp

@@ -75,15 +75,15 @@ void* MetaspaceObj::operator new(size_t size, ClassLoaderData* loader_data,
                                  MetaspaceObj::Type type, TRAPS) throw() {
   // Klass has its own operator new
   assert(type != ClassType, "class has its own operator new");
-  return Metaspace::allocate(loader_data, word_size, type, /*use_class_space*/ false, THREAD);
+  return Metaspace::allocate(loader_data, word_size, type, /*use_class_space*/ false, /* preferred */ false, THREAD);
 }
 
 void* MetaspaceObj::operator new(size_t size, ClassLoaderData* loader_data,
                                  size_t word_size,
                                  MetaspaceObj::Type type) throw() {
   assert(!Thread::current()->is_Java_thread(), "only allowed by non-Java thread");
   assert(type != ClassType, "class has its own operator new");
-  return Metaspace::allocate(loader_data, word_size, type, /*use_class_space*/ false);
+  return Metaspace::allocate(loader_data, word_size, type, /*use_class_space*/ false, /* preferred */ false);
 }
 
 bool MetaspaceObj::is_valid(const MetaspaceObj* p) {

src/hotspot/share/memory/classLoaderMetaspace.cpp

@@ -85,7 +85,7 @@ ClassLoaderMetaspace::ClassLoaderMetaspace(Mutex* lock, Metaspace::MetaspaceType
         "class arena");
   }
 
-  UL2(debug, "born (nonclass arena: " PTR_FORMAT ", class arena: " PTR_FORMAT ".",
+  UL2(debug, "born (nonclass arena: " PTR_FORMAT ", class arena: " PTR_FORMAT ").",
       p2i(_non_class_space_arena), p2i(_class_space_arena));
 }
 

src/hotspot/share/memory/heapInspection.cpp

@@ -97,21 +97,24 @@ const char* KlassInfoEntry::name() const {
 
 void KlassInfoEntry::print_on(outputStream* st) const {
   ResourceMark rm;
+  const narrowKlass nk = CompressedKlassPointers::is_encodable(_klass) ? CompressedKlassPointers::encode(_klass) : 0;
 
   // simplify the formatting (ILP32 vs LP64) - always cast the numbers to 64-bit
   ModuleEntry* module = _klass->module();
   if (module->is_named()) {
-    st->print_cr(INT64_FORMAT_W(13) "  " UINT64_FORMAT_W(13) "  %s (%s%s%s)",
+    st->print_cr(INT64_FORMAT_W(13) "  " UINT64_FORMAT_W(13) "  " PTR_FORMAT "  %u  %s (%s%s%s)",
                  (int64_t)_instance_count,
                  (uint64_t)_instance_words * HeapWordSize,
+                 p2i(_klass), nk,
                  name(),
                  module->name()->as_C_string(),
                  module->version() != nullptr ? "@" : "",
                  module->version() != nullptr ? module->version()->as_C_string() : "");
   } else {
-    st->print_cr(INT64_FORMAT_W(13) "  " UINT64_FORMAT_W(13) "  %s",
+    st->print_cr(INT64_FORMAT_W(13) "  " UINT64_FORMAT_W(13) "  " PTR_FORMAT "  %u  %s",
                  (int64_t)_instance_count,
                  (uint64_t)_instance_words * HeapWordSize,
+                 p2i(_klass), nk,
                  name());
   }
 }
@@ -492,8 +495,9 @@ void KlassHierarchy::print_class(outputStream* st, KlassInfoEntry* cie, bool pri
 }
 
 void KlassInfoHisto::print_histo_on(outputStream* st) {
-  st->print_cr(" num     #instances         #bytes  class name (module)");
-  st->print_cr("-------------------------------------------------------");
+  int len_divider = 0;
+  st->print_cr(" num     #instances         #bytes      Klass             nKlass     class name (module)");
+  st->print_cr(" ---------------------------------------------------------------------------------------");
   print_elements(st);
 }
 

src/hotspot/share/memory/iterator.hpp

@@ -314,9 +314,12 @@ class CompareClosure : public Closure {
 
 class OopIteratorClosureDispatch {
  public:
-  template <typename OopClosureType> static void oop_oop_iterate(OopClosureType* cl, oop obj, Klass* klass);
-  template <typename OopClosureType> static void oop_oop_iterate(OopClosureType* cl, oop obj, Klass* klass, MemRegion mr);
-  template <typename OopClosureType> static void oop_oop_iterate_backwards(OopClosureType* cl, oop obj, Klass* klass);
+  template <typename OopClosureType> inline static void    oop_oop_iterate              (oop obj, OopClosureType* cl);
+  template <typename OopClosureType> inline static void    oop_oop_iterate_reverse      (oop obj, OopClosureType* cl);
+  template <typename OopClosureType> inline static void    oop_oop_iterate_bounded      (oop obj, OopClosureType* cl, MemRegion mr);
+  template <typename OopClosureType> inline static size_t  oop_oop_iterate_size         (oop obj, OopClosureType* cl);
+  template <typename OopClosureType> inline static size_t  oop_oop_iterate_bounded_size (oop obj, OopClosureType* cl, MemRegion mr);
+  template <typename OopClosureType> inline static void    oop_oop_iterate_range        (objArrayOop obj, OopClosureType* cl, int start, int end);
 };
 
 #endif // SHARE_MEMORY_ITERATOR_HPP