jdk-sandbox: comparison hotspot/src/share/vm/utilities/hashtable.hpp

equal deleted inserted replaced

-:582dd25571b2
+:96d498ec7ae1
 #ifndef SHARE_VM_UTILITIES_HASHTABLE_HPP
 #define SHARE_VM_UTILITIES_HASHTABLE_HPP
 #include "memory/allocation.hpp"
 #include "oops/oop.hpp"
-#include "oops/symbolOop.hpp"
+#include "oops/symbol.hpp"
 #include "runtime/handles.hpp"
 // This is a generic hashtable, designed to be used for the symbol
 // and string tables.
 //
 }
 };
-class HashtableEntry : public BasicHashtableEntry {
+template <class T> class HashtableEntry : public BasicHashtableEntry {
 friend class VMStructs;
 private:
-oop               _literal;          // ref to item in table.
+T               _literal;          // ref to item in table.
 public:
 // Literal
-oop literal() const                   { return _literal; }
+T literal() const                   { return _literal; }
-oop* literal_addr()                   { return &_literal; }
+T* literal_addr()                   { return &_literal; }
-void set_literal(oop s)               { _literal = s; }
+void set_literal(T s)               { _literal = s; }
 HashtableEntry* next() const {
 return (HashtableEntry*)BasicHashtableEntry::next();
 }
 HashtableEntry** next_addr() {
 return h;
 }
 // Reverse the order of elements in each of the buckets.
 void reverse();
+static unsigned int hash_symbol(const char* s, int len);
 private:
 // Instance variables
 int               _table_size;
 HashtableBucket*  _buckets;
 void verify() PRODUCT_RETURN;
 };
-class Hashtable : public BasicHashtable {
+template <class T> class Hashtable : public BasicHashtable {
 friend class VMStructs;
 public:
 Hashtable(int table_size, int entry_size)
 : BasicHashtable(table_size, entry_size) { }
 Hashtable(int table_size, int entry_size,
 HashtableBucket* buckets, int number_of_entries)
 : BasicHashtable(table_size, entry_size, buckets, number_of_entries) { }
-// Invoke "f->do_oop" on the locations of all oops in the table.
-void oops_do(OopClosure* f);
 // Debugging
 void print()               PRODUCT_RETURN;
-// GC support
-//   Delete pointers to otherwise-unreachable objects.
-void unlink(BoolObjectClosure* cl);
 // Reverse the order of elements in each of the buckets. Hashtable
 // entries which refer to objects at a lower address than 'boundary'
 // are separated from those which refer to objects at higher
 // addresses, and appear first in the list.
 void reverse(void* boundary = NULL);
 protected:
-static unsigned int hash_symbol(const char* s, int len);
+unsigned int compute_hash(Symbol* name) {
-unsigned int compute_hash(symbolHandle name) {
 return (unsigned int) name->identity_hash();
 }
-int index_for(symbolHandle name) {
+int index_for(Symbol* name) {
 return hash_to_index(compute_hash(name));
 }
 // Table entry management
-HashtableEntry* new_entry(unsigned int hashValue, oop obj);
+HashtableEntry<T>* new_entry(unsigned int hashValue, T obj);
 // The following method is MT-safe and may be used with caution.
-HashtableEntry* bucket(int i) {
+HashtableEntry<T>* bucket(int i) {
-return (HashtableEntry*)BasicHashtable::bucket(i);
+return (HashtableEntry<T>*)BasicHashtable::bucket(i);
 }
 // The following method is not MT-safe and must be done under lock.
-HashtableEntry** bucket_addr(int i) {
+HashtableEntry<T>** bucket_addr(int i) {
-return (HashtableEntry**)BasicHashtable::bucket_addr(i);
+return (HashtableEntry<T>**)BasicHashtable::bucket_addr(i);
 }
 };
 //  Verions of hashtable where two handles are used to compute the index.
-class TwoOopHashtable : public Hashtable {
+template <class T> class TwoOopHashtable : public Hashtable<T> {
 friend class VMStructs;
 protected:
 TwoOopHashtable(int table_size, int entry_size)
-: Hashtable(table_size, entry_size) {}
+: Hashtable<T>(table_size, entry_size) {}
 TwoOopHashtable(int table_size, int entry_size, HashtableBucket* t,
 int number_of_entries)
-: Hashtable(table_size, entry_size, t, number_of_entries) {}
+: Hashtable<T>(table_size, entry_size, t, number_of_entries) {}
 public:
-unsigned int compute_hash(symbolHandle name, Handle loader) {
+unsigned int compute_hash(Symbol* name, Handle loader) {
 // Be careful with identity_hash(), it can safepoint and if this
 // were one expression, the compiler could choose to unhandle each
 // oop before calling identity_hash() for either of them.  If the first
 // causes a GC, the next would fail.
 unsigned int name_hash = name->identity_hash();
 unsigned int loader_hash = loader.is_null() ? 0 : loader->identity_hash();
 return name_hash ^ loader_hash;
 }
-int index_for(symbolHandle name, Handle loader) {
+int index_for(Symbol* name, Handle loader) {
 return hash_to_index(compute_hash(name, loader));
 }
 };
 #endif // SHARE_VM_UTILITIES_HASHTABLE_HPP

changeset 8076	96d498ec7ae1
parent 7397	5b173b4ca846
child 8310	d7c285113f48