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/hashtable.hpp"
  32 #include "utilities/concurrentHashTable.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 // The symbol table holds all Symbol*s and corresponding interned strings.
  88 // Symbol*s and literal strings should be canonicalized.
  89 //
  90 // The interned strings are created lazily.
  91 //
  92 // %note:
  93 //  - symbolTableEntrys are allocated in blocks to reduce the space overhead.
  94 template <class T, class N> class CompactHashtable;
  95 class CompactSymbolTableWriter;
  96 class SerializeClosure;
  97 
  98 class SymbolTable;
  99 class SymbolTableConfig;
 100 typedef ConcurrentHashTable<Symbol*,
 101                               SymbolTableConfig, mtSymbol> SymbolTableHash;
 102 
 103 class SymbolTableCreateEntry;
 104 
 105 class SymbolTable : public CHeapObj<mtSymbol> {
 106   friend class VMStructs;
 107   friend class Symbol;
 108   friend class ClassFileParser;
 109   friend class SymbolTableConfig;
 110   friend class SymbolTableCreateEntry;
 111 
 112 private:
 113   static void delete_symbol(Symbol* sym);
 114   void grow(JavaThread* jt);
 115   void clean_dead_entries(JavaThread* jt);
 116 
 117   // The symbol table
 118   static SymbolTable* _the_table;
 119   // Shared symbol table.
 120   static CompactHashtable<Symbol*, char> _shared_table;
 121   static bool _lookup_shared_first;
 122   static bool _alt_hash;
 123 
 124   // For statistics
 125   static int _symbols_removed;
 126   static int _symbols_counted;
 127 
 128 private:
 129 
 130   // Set if one bucket is out of balance due to hash algorithm deficiency
 131   SymbolTableHash* _local_table;
 132   size_t _current_size;
 133   volatile bool _has_work;
 134   volatile bool _needs_rehashing;
 135 
 136   volatile size_t _items;
 137   DEFINE_PAD_MINUS_SIZE(1, DEFAULT_CACHE_LINE_SIZE, sizeof(volatile size_t));
 138   volatile int _uncleaned_items;
 139   DEFINE_PAD_MINUS_SIZE(2, DEFAULT_CACHE_LINE_SIZE, sizeof(volatile int));
 140 
 141   double get_load_factor();
 142   double get_dead_factor();
 143 
 144   void check_concurrent_work();
 145   void trigger_concurrent_work();
 146 
 147   static uintx item_added();
 148   static void item_removed();
 149   static void set_item_clean_count(size_t ncl);
 150   static void mark_item_clean_count();
 151 
 152   SymbolTable();
 153 
 154   Symbol* allocate_symbol(const u1* name, int len, bool c_heap, TRAPS); // Assumes no characters larger than 0x7F
 155   Symbol* do_lookup(char* name, int len, uintx hash);
 156   Symbol* do_add_if_needed(char* name, int len, uintx hash, bool heap, TRAPS);
 157 
 158   // Adding elements
 159   static void add(ClassLoaderData* loader_data,
 160                   const constantPoolHandle& cp, int names_count,
 161                   const char** names, int* lengths, int* cp_indices,
 162                   unsigned int* hashValues, TRAPS);
 163 
 164   static void new_symbols(ClassLoaderData* loader_data,
 165                           const constantPoolHandle& cp, int names_count,
 166                           const char** name, int* lengths,
 167                           int* cp_indices, unsigned int* hashValues,
 168                           TRAPS) {
 169     add(loader_data, cp, names_count, name, lengths, cp_indices, hashValues, THREAD);
 170   }
 171 
 172   static Symbol* lookup_shared(const char* name, int len, unsigned int hash);
 173   Symbol* lookup_dynamic(const char* name, int len, unsigned int hash);
 174   Symbol* lookup_common(const char* name, int len, unsigned int hash);
 175 
 176   // Arena for permanent symbols (null class loader) that are never unloaded
 177   static Arena*  _arena;
 178   static Arena* arena() { return _arena; }  // called for statistics
 179 
 180   static void initialize_symbols(int arena_alloc_size = 0);
 181 
 182   void concurrent_work(JavaThread* jt);
 183   void print_table_statistics(outputStream* st, const char* table_name);
 184 
 185   void try_rehash_table();
 186   bool do_rehash();
 187 
 188 public:
 189   // The symbol table
 190   static SymbolTable* the_table() { return _the_table; }
 191   size_t table_size(Thread* thread = NULL);
 192 
 193   enum {
 194     symbol_alloc_batch_size = 8,
 195     // Pick initial size based on java -version size measurements
 196     symbol_alloc_arena_size = 360*K // TODO (revisit)
 197   };
 198 
 199   static void create_table() {
 200     assert(_the_table == NULL, "One symbol table allowed.");
 201     _the_table = new SymbolTable();
 202     initialize_symbols(symbol_alloc_arena_size);
 203   }
 204 
 205   static void unlink() {
 206     do_check_concurrent_work();
 207   }
 208   static void do_check_concurrent_work();
 209   static void do_concurrent_work(JavaThread* jt);
 210   static bool has_work() { return the_table()->_has_work; }
 211 
 212   // Probing
 213   static Symbol* lookup(const char* name, int len, TRAPS);
 214   // lookup only, won't add. Also calculate hash.
 215   static Symbol* lookup_only(const char* name, int len, unsigned int& hash);
 216   // Only copy to C string to be added if lookup failed.
 217   static Symbol* lookup(const Symbol* sym, int begin, int end, TRAPS);
 218   // jchar (UTF16) version of lookups
 219   static Symbol* lookup_unicode(const jchar* name, int len, TRAPS);
 220   static Symbol* lookup_only_unicode(const jchar* name, int len, unsigned int& hash);
 221   // Needed for preloading classes in signatures when compiling.
 222   // Returns the symbol is already present in symbol table, otherwise
 223   // NULL.  NO ALLOCATION IS GUARANTEED!
 224   static Symbol* probe(const char* name, int len) {
 225     unsigned int ignore_hash;
 226     return lookup_only(name, len, ignore_hash);
 227   }
 228   static Symbol* probe_unicode(const jchar* name, int len) {
 229     unsigned int ignore_hash;
 230     return lookup_only_unicode(name, len, ignore_hash);
 231   }
 232 
 233   // Symbol creation
 234   static Symbol* new_symbol(const char* utf8_buffer, int length, TRAPS) {
 235     assert(utf8_buffer != NULL, "just checking");
 236     return lookup(utf8_buffer, length, THREAD);
 237   }
 238   static Symbol* new_symbol(const char* name, TRAPS) {
 239     return new_symbol(name, (int)strlen(name), THREAD);
 240   }
 241   static Symbol* new_symbol(const Symbol* sym, int begin, int end, TRAPS) {
 242     assert(begin <= end && end <= sym->utf8_length(), "just checking");
 243     return lookup(sym, begin, end, THREAD);
 244   }
 245   // Create a symbol in the arena for symbols that are not deleted
 246   static Symbol* new_permanent_symbol(const char* name, TRAPS);
 247 
 248   // Rehash the string table if it gets out of balance
 249   static void rehash_table();
 250   static bool needs_rehashing()
 251     { return SymbolTable::the_table()->_needs_rehashing; }
 252 
 253   // Heap dumper and CDS
 254   static void symbols_do(SymbolClosure *cl);
 255 
 256   // Sharing
 257 private:
 258   static void copy_shared_symbol_table(CompactSymbolTableWriter* ch_table);
 259 public:
 260   static void write_to_archive() NOT_CDS_RETURN;
 261   static void serialize(SerializeClosure* soc) NOT_CDS_RETURN;
 262   static void metaspace_pointers_do(MetaspaceClosure* it);
 263 
 264   // Jcmd
 265   static void dump(outputStream* st, bool verbose=false);
 266   // Debugging
 267   static void verify();
 268   static void read(const char* filename, TRAPS);
 269 
 270   // Histogram
 271   static void print_histogram() PRODUCT_RETURN;
 272 };
 273 
 274 #endif // SHARE_VM_CLASSFILE_SYMBOLTABLE_HPP