src/share/vm/utilities/hashtable.hpp
Index Unified diffs Context diffs Sdiffs Patch New Old Previous File Next File
*** old/src/share/vm/utilities/hashtable.hpp	Tue Feb 25 14:00:58 2014
--- new/src/share/vm/utilities/hashtable.hpp	Tue Feb 25 14:00:58 2014

*** 298,308 **** --- 298,308 ---- private: static juint _seed; }; ! // Verions of hashtable where two handles are used to compute the index. ! // Versions of hashtable where two handles are used to compute the index. template <class T, MEMFLAGS F> class TwoOopHashtable : public Hashtable<T, F> { friend class VMStructs; protected: TwoOopHashtable(int table_size, int entry_size)
*** 325,330 **** --- 325,416 ---- int index_for(Symbol* name, ClassLoaderData* loader_data) { return this->hash_to_index(compute_hash(name, loader_data)); } }; + + /* + * Usage of GenericHashtable: + * + * class X : public GenericHashtableEntry<X, ResourceObj> { + * + * // Implement virtual functions in class X + * bool equals(X* sig) const; + * uintptr_t hash() const; + * }; + * + * void foo() { + * GenericHashtable<X, ResourceObj>* table = new GenericHashtable<X, ResourceObj>(11027, false); + * + * X* elem = new X(); + * table->add(elem); + * table->contains(elem); + * } + * + * You can choose other allocation types as well. For example, to store the hashtable to a + * particular region (CHeapObj<type>) simply replace ResourceObj with the desired type: + * + * class X : public GenericHashtableEntry<X, CHeapObj<mtCode> > { ... }; + * + * To make the destructor (and remove) of the hashtable work: + * 1) override the delete operator of X + * 2) provide a destructor of the X + * + * You may also find it convenient to override the new operator. + * + * If you use this templates do not forget to add an explicit initialization + * (at the end of hashtable.cpp). + * + * template class GenericHashtable<X, ResourceObj>; + */ + template <class T, class M> class GenericHashtableEntry : public M { + private: + T* _next; + T* _prev; + public: + // Must be implemented by subclass. + virtual uintptr_t key() const = 0; + virtual bool equals(T* other) const = 0; + + T* next() const { return _next; } + T* prev() const { return _prev; } + void set_next(T* item) { _next = item; } + void set_prev(T* item) { _prev = item; } + + // Constructor and destructor + GenericHashtableEntry() : _next(NULL), _prev(NULL) { }; + virtual ~GenericHashtableEntry() {}; + }; + + template <class T, class M> class GenericHashtable : public M { + private: + T** _items; + int _size; + bool _C_heap; + MEMFLAGS _memflag; + enum OpType { CONTAINS, ADD, REMOVE }; + + + T* contains_impl(T* item, int idx); + T* remove_impl (T* item, int idx, bool contains); + T* add_impl (T* item, int idx, bool contains); + T* perform_op (T* item, OpType op); + + // Accessor methods + T* head(int idx) const { return _items[idx]; } + void set_head(T* element, int idx) { _items[idx] = element; } + + DEBUG_ONLY(int _num_items;) + + public: + GenericHashtable(int size, bool C_heap = false, MEMFLAGS memflag = mtNone); + ~GenericHashtable(); + T* contains(T* match_item); + T* remove (T* match_item); + bool add (T* item); + + + bool on_C_heap() const { return _C_heap; } + int size() const { return _size; } + }; + #endif // SHARE_VM_UTILITIES_HASHTABLE_HPP

src/share/vm/utilities/hashtable.hpp
Index Unified diffs Context diffs Sdiffs Patch New Old Previous File Next File