1 /*
   2  * Copyright (c) 1997, 2018, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 #ifndef SHARE_VM_CLASSFILE_SYMBOLTABLE_HPP
  26 #define SHARE_VM_CLASSFILE_SYMBOLTABLE_HPP
  27 
  28 #include "memory/allocation.hpp"
  29 #include "memory/padded.hpp"
  30 #include "oops/symbol.hpp"
  31 #include "utilities/concurrentHashTable.hpp"
  32 #include "utilities/hashtable.hpp"
  33 
  34 // TempNewSymbol acts as a handle class in a handle/body idiom and is
  35 // responsible for proper resource management of the body (which is a Symbol*).
  36 // The body is resource managed by a reference counting scheme.
  37 // TempNewSymbol can therefore be used to properly hold a newly created or referenced
  38 // Symbol* temporarily in scope.
  39 //
  40 // Routines in SymbolTable will initialize the reference count of a Symbol* before
  41 // it becomes "managed" by TempNewSymbol instances. As a handle class, TempNewSymbol
  42 // needs to maintain proper reference counting in context of copy semantics.
  43 //
  44 // In SymbolTable, new_symbol() and lookup() will create a Symbol* if not already in the
  45 // symbol table and add to the symbol's reference count.
  46 // probe() and lookup_only() will increment the refcount if symbol is found.
  47 class TempNewSymbol : public StackObj {
  48   Symbol* _temp;
  49 
  50 public:
  51   TempNewSymbol() : _temp(NULL) {}
  52 
  53   // Conversion from a Symbol* to a TempNewSymbol.
  54   // Does not increment the current reference count.
  55   TempNewSymbol(Symbol *s) : _temp(s) {}
  56 
  57   // Copy constructor increments reference count.
  58   TempNewSymbol(const TempNewSymbol& rhs) : _temp(rhs._temp) {
  59     if (_temp != NULL) {
  60       _temp->increment_refcount();
  61     }
  62   }
  63 
  64   // Assignment operator uses a c++ trick called copy and swap idiom.
  65   // rhs is passed by value so within the scope of this method it is a copy.
  66   // At method exit it contains the former value of _temp, triggering the correct refcount
  67   // decrement upon destruction.
  68   void operator=(TempNewSymbol rhs) {
  69     Symbol* tmp = rhs._temp;
  70     rhs._temp = _temp;
  71     _temp = tmp;
  72   }
  73 
  74   // Decrement reference counter so it can go away if it's unused
  75   ~TempNewSymbol() {
  76     if (_temp != NULL) {
  77       _temp->decrement_refcount();
  78     }
  79   }
  80 
  81   // Symbol* conversion operators
  82   Symbol* operator -> () const                   { return _temp; }
  83   bool    operator == (Symbol* o) const          { return _temp == o; }
  84   operator Symbol*()                             { return _temp; }
  85 };
  86 
  87 template <class T, class N> class CompactHashtable;
  88 class CompactSymbolTableWriter;
  89 class SerializeClosure;
  90 
  91 class SymbolTableConfig;
  92 typedef ConcurrentHashTable<Symbol*,
  93                               SymbolTableConfig, mtSymbol> SymbolTableHash;
  94 
  95 class SymbolTableCreateEntry;
  96 
  97 class SymbolTable : public CHeapObj<mtSymbol> {
  98   friend class VMStructs;
  99   friend class Symbol;
 100   friend class ClassFileParser;
 101   friend class SymbolTableConfig;
 102   friend class SymbolTableCreateEntry;
 103 
 104 private:
 105   static void delete_symbol(Symbol* sym);
 106   void grow(JavaThread* jt);
 107   void clean_dead_entries(JavaThread* jt);
 108 
 109   // The symbol table
 110   static SymbolTable* _the_table;
 111   // Shared symbol table.
 112   static CompactHashtable<Symbol*, char> _shared_table;
 113   static bool _lookup_shared_first;
 114   static bool _alt_hash;
 115 
 116   // For statistics
 117   static int _symbols_removed;
 118   static int _symbols_counted;
 119 
 120   // Set if one bucket is out of balance due to hash algorithm deficiency
 121   SymbolTableHash* _local_table;
 122   size_t _current_size;
 123   volatile bool _has_work;

 124   volatile bool _needs_rehashing;
 125 
 126   volatile int _items;
 127   DEFINE_PAD_MINUS_SIZE(1, DEFAULT_CACHE_LINE_SIZE, sizeof(volatile int));
 128   volatile int _uncleaned_items;
 129   DEFINE_PAD_MINUS_SIZE(2, DEFAULT_CACHE_LINE_SIZE, sizeof(volatile int));
 130 
 131   double get_load_factor();
 132   double get_dead_factor();
 133 
 134   void check_concurrent_work();
 135   void trigger_concurrent_work();
 136 
 137   static uintx item_added();
 138   static void item_removed();
 139   static void set_item_clean_count(size_t ncl);
 140   static void mark_item_clean_count();
 141 
 142   SymbolTable();
 143 
 144   Symbol* allocate_symbol(const u1* name, int len, bool c_heap, TRAPS); // Assumes no characters larger than 0x7F
 145   Symbol* do_lookup(char* name, int len, uintx hash);
 146   Symbol* do_add_if_needed(char* name, int len, uintx hash, bool heap, TRAPS);
 147 
 148   // Adding elements
 149   static void add(ClassLoaderData* loader_data,
 150                   const constantPoolHandle& cp, int names_count,
 151                   const char** names, int* lengths, int* cp_indices,
 152                   unsigned int* hashValues, TRAPS);
 153 
 154   static void new_symbols(ClassLoaderData* loader_data,
 155                           const constantPoolHandle& cp, int names_count,
 156                           const char** name, int* lengths,
 157                           int* cp_indices, unsigned int* hashValues,
 158                           TRAPS) {
 159     add(loader_data, cp, names_count, name, lengths, cp_indices, hashValues, THREAD);
 160   }
 161 
 162   static Symbol* lookup_shared(const char* name, int len, unsigned int hash);
 163   Symbol* lookup_dynamic(const char* name, int len, unsigned int hash);
 164   Symbol* lookup_common(const char* name, int len, unsigned int hash);
 165 
 166   // Arena for permanent symbols (null class loader) that are never unloaded
 167   static Arena*  _arena;
 168   static Arena* arena() { return _arena; }  // called for statistics
 169 
 170   static void initialize_symbols(int arena_alloc_size = 0);
 171 
 172   void concurrent_work(JavaThread* jt);
 173   void print_table_statistics(outputStream* st, const char* table_name);
 174 
 175   void try_rehash_table();
 176   bool do_rehash();
 177 
 178 public:
 179   // The symbol table
 180   static SymbolTable* the_table() { return _the_table; }
 181   size_t table_size(Thread* thread = NULL);
 182 
 183   enum {
 184     symbol_alloc_batch_size = 8,
 185     // Pick initial size based on java -version size measurements
 186     symbol_alloc_arena_size = 360*K // TODO (revisit)
 187   };
 188 
 189   static void create_table() {
 190     assert(_the_table == NULL, "One symbol table allowed.");
 191     _the_table = new SymbolTable();
 192     initialize_symbols(symbol_alloc_arena_size);
 193   }
 194 
 195   static void unlink() {
 196     do_check_concurrent_work();
 197   }
 198   static void do_check_concurrent_work();
 199   static void do_concurrent_work(JavaThread* jt);
 200   static bool has_work() { return the_table()->_has_work; }
 201 
 202   // Probing
 203   static Symbol* lookup(const char* name, int len, TRAPS);
 204   // lookup only, won't add. Also calculate hash.
 205   static Symbol* lookup_only(const char* name, int len, unsigned int& hash);
 206   // Only copy to C string to be added if lookup failed.
 207   static Symbol* lookup(const Symbol* sym, int begin, int end, TRAPS);
 208   // jchar (UTF16) version of lookups
 209   static Symbol* lookup_unicode(const jchar* name, int len, TRAPS);
 210   static Symbol* lookup_only_unicode(const jchar* name, int len, unsigned int& hash);
 211   // Needed for preloading classes in signatures when compiling.
 212   // Returns the symbol is already present in symbol table, otherwise
 213   // NULL.  NO ALLOCATION IS GUARANTEED!
 214   static Symbol* probe(const char* name, int len) {
 215     unsigned int ignore_hash;
 216     return lookup_only(name, len, ignore_hash);
 217   }
 218   static Symbol* probe_unicode(const jchar* name, int len) {
 219     unsigned int ignore_hash;
 220     return lookup_only_unicode(name, len, ignore_hash);
 221   }
 222 
 223   // Symbol creation
 224   static Symbol* new_symbol(const char* utf8_buffer, int length, TRAPS) {
 225     assert(utf8_buffer != NULL, "just checking");
 226     return lookup(utf8_buffer, length, THREAD);
 227   }
 228   static Symbol* new_symbol(const char* name, TRAPS) {
 229     return new_symbol(name, (int)strlen(name), THREAD);
 230   }
 231   static Symbol* new_symbol(const Symbol* sym, int begin, int end, TRAPS) {
 232     assert(begin <= end && end <= sym->utf8_length(), "just checking");
 233     return lookup(sym, begin, end, THREAD);
 234   }
 235   // Create a symbol in the arena for symbols that are not deleted
 236   static Symbol* new_permanent_symbol(const char* name, TRAPS);
 237 
 238   // Rehash the string table if it gets out of balance
 239   static void rehash_table();
 240   static bool needs_rehashing()
 241     { return SymbolTable::the_table()->_needs_rehashing; }
 242 
 243   // Heap dumper and CDS
 244   static void symbols_do(SymbolClosure *cl);
 245 
 246   // Sharing
 247 private:
 248   static void copy_shared_symbol_table(CompactSymbolTableWriter* ch_table);
 249 public:
 250   static void write_to_archive() NOT_CDS_RETURN;
 251   static void serialize(SerializeClosure* soc) NOT_CDS_RETURN;
 252   static void metaspace_pointers_do(MetaspaceClosure* it);
 253 
 254   // Jcmd
 255   static void dump(outputStream* st, bool verbose=false);
 256   // Debugging
 257   static void verify();
 258   static void read(const char* filename, TRAPS);
 259 
 260   // Histogram
 261   static void print_histogram() PRODUCT_RETURN;
 262 };
 263 
 264 #endif // SHARE_VM_CLASSFILE_SYMBOLTABLE_HPP
--- EOF ---