jdk-sandbox: comparison hotspot/src/share/vm/classfile/compactHashtable.hpp

equal deleted inserted replaced

-:1a816b464178
+:92aec042a43b
 /*
-* Copyright (c) 1997, 2015, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 1997, 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/symbolTable.hpp"
 #include "oops/symbol.hpp"
 #include "services/diagnosticCommand.hpp"
 #include "utilities/hashtable.hpp"
+template <class T, class N> class CompactHashtable;
 class NumberSeq;
+class SimpleCompactHashtable;
+class SerializeClosure;
 // Stats for symbol tables in the CDS archive
 class CompactHashtableStats VALUE_OBJ_CLASS_SPEC {
 public:
 int hashentry_count;
 // Buckets without entry are skipped from the table. Their offsets are
 // still written out for faster lookup.
 //
 class CompactHashtableWriter: public StackObj {
 public:
-class Entry: public CHeapObj<mtSymbol> {
+class Entry VALUE_OBJ_CLASS_SPEC {
-Entry* _next;
 unsigned int _hash;
-void* _literal;
+u4 _value;
 public:
-Entry(unsigned int hash, Symbol *symbol) : _next(NULL), _hash(hash), _literal(symbol) {}
+Entry() {}
-Entry(unsigned int hash, oop string)     : _next(NULL), _hash(hash), _literal(string) {}
+Entry(unsigned int hash, u4 val) : _hash(hash), _value(val) {}
-void *value() {
+u4 value() {
-return _literal;
+return _value;
-}
-Symbol *symbol() {
-return (Symbol*)_literal;
-}
-oop string() {
-return (oop)_literal;
 }
 unsigned int hash() {
 return _hash;
 }
-Entry *next()           {return _next;}
-void set_next(Entry *p) {_next = p;}
+bool operator==(const CompactHashtableWriter::Entry& other) {
+return (_value == other._value && _hash == other._hash);
+}
 }; // class CompactHashtableWriter::Entry
 private:
-static int number_of_buckets(int num_entries);
-int _type;
 int _num_entries;
 int _num_buckets;
-juint* _bucket_sizes;
+int _num_empty_buckets;
-Entry** _buckets;
+int _num_value_only_buckets;
-int _required_bytes;
+int _num_other_buckets;
+GrowableArray<Entry>** _buckets;
 CompactHashtableStats* _stats;
+Array<u4>* _compact_buckets;
+Array<u4>* _compact_entries;
 public:
 // This is called at dump-time only
-CompactHashtableWriter(int table_type, int num_entries, CompactHashtableStats* stats);
+CompactHashtableWriter(int num_buckets, CompactHashtableStats* stats);
 ~CompactHashtableWriter();
-int get_required_bytes() {
+void add(unsigned int hash, u4 value);
-return _required_bytes;
+void add(u4 value) {
-}
+add((unsigned int)value, value);
+}
-inline void add(unsigned int hash, Symbol* symbol);
-inline void add(unsigned int hash, oop string);
 private:
-void add(unsigned int hash, Entry* entry);
+void allocate_table();
-juint* dump_table(juint* p, juint** first_bucket, NumberSeq* summary);
+void dump_table(NumberSeq* summary);
-juint* dump_buckets(juint* table, juint* p, NumberSeq* summary);
+public:
-public:
+void dump(SimpleCompactHashtable *cht, const char* table_name);
-void dump(char** top, char* end);
 const char* table_name();
 };
+class CompactSymbolTableWriter: public CompactHashtableWriter {
+public:
+CompactSymbolTableWriter(int num_buckets, CompactHashtableStats* stats) :
+CompactHashtableWriter(num_buckets, stats) {}
+void add(unsigned int hash, Symbol *symbol);
+void dump(CompactHashtable<Symbol*, char> *cht);
+};
+class CompactStringTableWriter: public CompactHashtableWriter {
+public:
+CompactStringTableWriter(int num_entries, CompactHashtableStats* stats) :
+CompactHashtableWriter(num_entries, stats) {}
+void add(unsigned int hash, oop string);
+void dump(CompactHashtable<oop, char> *cht);
+};
 #define REGULAR_BUCKET_TYPE       0
-#define COMPACT_BUCKET_TYPE       1
+#define VALUE_ONLY_BUCKET_TYPE    1
 #define TABLEEND_BUCKET_TYPE      3
 #define BUCKET_OFFSET_MASK        0x3FFFFFFF
 #define BUCKET_OFFSET(info)       ((info) & BUCKET_OFFSET_MASK)
 #define BUCKET_TYPE_SHIFT         30
 #define BUCKET_TYPE(info)         (((info) & ~BUCKET_OFFSET_MASK) >> BUCKET_TYPE_SHIFT)
 //
 // Because these tables are read-only (no entries can be added/deleted) at run-time
 // and tend to have large number of entries, we try to minimize the footprint
 // cost per entry.
 //
-// Layout of compact table in the shared archive:
+// The CompactHashtable is split into two arrays
 //
-//   uintx base_address;
+//   u4 buckets[num_buckets+1]; // bit[31,30]: type; bit[29-0]: offset
-//   juint num_entries;
+//   u4 entries[<variable size>]
-//   juint num_buckets;
+//
-//   juint bucket_infos[num_buckets+1]; // bit[31,30]: type; bit[29-0]: offset
+// The size of buckets[] is 'num_buckets + 1'. Each entry of
-//   juint table[]
+// buckets[] is a 32-bit encoding of the bucket type and bucket offset,
-//
-// -----------------------------------
-// | base_address  | num_entries     |
-// |---------------------------------|
-// | num_buckets   | bucket_info0    |
-// |---------------------------------|
-// | bucket_info1  | bucket_info2    |
-// | bucket_info3    ...             |
-// | ....          | table_end_info  |
-// |---------------------------------|
-// | entry0                          |
-// | entry1                          |
-// | entry2                          |
-// |                                 |
-// | ...                             |
-// -----------------------------------
-//
-// The size of the bucket_info table is 'num_buckets + 1'. Each entry of the
-// bucket_info table is a 32-bit encoding of the bucket type and bucket offset,
 // with the type in the left-most 2-bit and offset in the remaining 30-bit.
-// The last entry is a special type. It contains the offset of the last
+// The last entry is a special type. It contains the end of the last
-// bucket end. We use that information when traversing the compact table.
+// bucket.
 //
-// There are two types of buckets, regular buckets and compact buckets. The
+// There are two types of buckets, regular buckets and value_only buckets. The
-// compact buckets have '01' in their highest 2-bit, and regular buckets have
+// value_only buckets have '01' in their highest 2-bit, and regular buckets have
 // '00' in their highest 2-bit.
 //
-// For normal buckets, each entry is 8 bytes in the table[]:
+// For normal buckets, each entry is 8 bytes in the entries[]:
-//   juint hash;    /* symbol/string hash */
+//   u4 hash;    /* symbol/string hash */
 //   union {
-//     juint offset;  /* Symbol* sym = (Symbol*)(base_address + offset) */
+//     u4 offset;  /* Symbol* sym = (Symbol*)(base_address + offset) */
 //     narrowOop str; /* String narrowOop encoding */
 //   }
 //
 //
-// For compact buckets, each entry has only the 4-byte 'offset' in the table[].
+// For value_only buckets, each entry has only the 4-byte 'offset' in the entries[].
+//
+// Example -- note that the second bucket is a VALUE_ONLY_BUCKET_TYPE so the hash code
+//            is skipped.
+// buckets[0, 4, 5, ....]
+//         |  |  |
+//         |  |  +---+
+//         |  |      |
+//         |  +----+ |
+//         v       v v
+// entries[H,O,H,O,O,H,O,H,O.....]
 //
 // See CompactHashtable::lookup() for how the table is searched at runtime.
 // See CompactHashtableWriter::dump() for how the table is written at CDS
 // dump time.
 //
-template <class T, class N> class CompactHashtable VALUE_OBJ_CLASS_SPEC {
+class SimpleCompactHashtable VALUE_OBJ_CLASS_SPEC {
+protected:
+address  _base_address;
+u4  _bucket_count;
+u4  _entry_count;
+u4* _buckets;
+u4* _entries;
+public:
+SimpleCompactHashtable() {
+_entry_count = 0;
+_bucket_count = 0;
+_buckets = 0;
+_entries = 0;
+}
+void reset() {
+_bucket_count = 0;
+_entry_count = 0;
+_buckets = 0;
+_entries = 0;
+}
+void init(address base_address, u4 entry_count, u4 bucket_count, u4* buckets, u4* entries) {
+_base_address = base_address;
+_bucket_count = bucket_count;
+_entry_count = entry_count;
+_buckets = buckets;
+_entries = entries;
+}
+template <class I> inline void iterate(const I& iterator);
+bool exists(u4 value);
+// For reading from/writing to the CDS archive
+void serialize(SerializeClosure* soc);
+};
+template <class T, class N> class CompactHashtable : public SimpleCompactHashtable {
 friend class VMStructs;
 public:
 enum CompactHashtableType {
 _symbol_table = 0,
 _string_table = 1
 };
 private:
-CompactHashtableType _type;
+u4 _type;
-uintx  _base_address;
-juint  _entry_count;
+inline Symbol* decode_entry(CompactHashtable<Symbol*, char>* const t,
-juint  _bucket_count;
+u4 offset, const char* name, int len);
-juint  _table_end_offset;
-juint* _buckets;
+inline oop decode_entry(CompactHashtable<oop, char>* const t,
+u4 offset, const char* name, int len);
-inline Symbol* lookup_entry(CompactHashtable<Symbol*, char>* const t,
+public:
-juint* addr, const char* name, int len);
+CompactHashtable() : SimpleCompactHashtable() {}
-inline oop lookup_entry(CompactHashtable<oop, char>* const t,
+void set_type(CompactHashtableType type) {
-juint* addr, const char* name, int len);
+_type = (u4)type;
-public:
-CompactHashtable() {
-_entry_count = 0;
-_bucket_count = 0;
-_table_end_offset = 0;
-_buckets = 0;
-}
-const char* init(CompactHashtableType type, const char *buffer);
-void reset() {
-_entry_count = 0;
-_bucket_count = 0;
-_table_end_offset = 0;
-_buckets = 0;
 }
 // Lookup an entry from the compact table
 inline T lookup(const N* name, unsigned int hash, int len);
 // iterate over symbols
 void symbols_do(SymbolClosure *cl);
 // iterate over strings
 void oops_do(OopClosure* f);
+// For reading from/writing to the CDS archive
+void serialize(SerializeClosure* soc);
 };
 ////////////////////////////////////////////////////////////////////////
 //
 // Read/Write the contents of a hashtable textual dump (created by
 const char* p   = _p;
 const char* end = _end;
 u8 n = 0;
 while (p < end) {
-char c = *p ++;
+char c = *p++;
 if ('0' <= c && c <= '9') {
 n = n * 10 + (c - '0');
 if (n > (u8)INT_MAX) {
 corrupted(_p, "Num overflow");
 }

changeset 37995	92aec042a43b
parent 35868	bf29f15cdf30
child 39713	29ece76096cb