基于分页内存的 HASH MAP

参考VC7.1和 SGI STL 中hash_map的实现

1. #ifndef PAGE_HASH_MAP_HPP
2. #define PAGE_HASH_MAP_HPP
3. #ifdef _MSC_VER
4. # include <xutility>//iterator
5. #else
6. # include <iterator>
7. #endif
8. #include "hash.hpp"
9. #include "allocators.hpp"
11. namespace sm
12. {
14. template
15.      <
16.      class Key,
17.      class Value,
18.      class PageAlloc,
19.      class Hash =  hash::hash_compare<Key>,
20.      class Alloc = sm::allocator<std::pair<const Key, Value> >       
21.      >
22. class page_hash_map
23. {   
24.        page_hash_map(const page_hash_map &);       
25.        page_hash_map & operator = (const page_hash_map &);
26. public:
27.     typedef page_hash_map<Key,Value,PageAlloc,Hash,Alloc> self_type;
28.     typedef Key     key_type;
29.     typedef Hash    key_compare;
30.     typedef std::pair<Key,Value>  value_type;
31.     typedef value_type &       reference;
32.     typedef value_type const & const_reference; 
33.     typedef ptrdiff_t difference_type;  
34.     typedef Value     mapped_type;
35.     typedef typename Alloc::size_type size_type;
36.     typedef typename Alloc::offset_type offset_type;
37.     typedef typename Alloc::byte byte;
38.     typedef typename PageAlloc::pageid_t pageid_t;
39.     typedef typename PageAlloc::address_t address_t;
40.     typedef typename PageAlloc::page_traits_t page_traits_t;
41.         
42.     struct hash_node
43.     {
44.         address_t next;
45.         value_type val;
46.         hash_node():next(MAXPOSITION),val(value_type())
47.         {}
48.         hash_node(value_type const & v):next(MAXPOSITION),val(v)
49.         {}
50.     };
51.     typedef typename Alloc::template rebind<hash_node>::other allocator_type;
52.     typedef typename allocator_type::pointer pointer;
53.         
54.     struct const_iterator
55.     {
56.         typedef std::forward_iterator_tag iterator_category;
57.         typedef difference_type distance_type;
59.         const_iterator():ht(0),ptr(0)
60.         {}
61.         const_iterator(self_type * h,pointer p)
62.         :ht(h),ptr(p)
63.         {}
64.         const_iterator(const_iterator const & other)
65.         :ht(other.ht),ptr(other.ptr)
66.         {}
67.         const_iterator & operator = (const_iterator const & other)
68.         {
69.         if(this != &other)
70.         {
71.             this->ht = other.ht;
72.             this->ptr = other.ptr;
73.         }
74.         return *this;
75.         }
76.         const_iterator & operator ++()
77.         {
78.         ptr = ht->_advance(ptr);
79.         return *this;
80.         }
81.         const_iterator operator ++(int)
82.         {
83.         const_iterator tmp(*this);
84.         ++*this;
85.         return tmp;
86.         }
87.         const_reference operator *()const
88.         {
89.         return (*ptr).val;
90.         }
91.         bool operator == ( const_iterator const & other)
92.         {
93.         return ( this->ht == other.ht && this->ptr == other.ptr );
94.         }
95.         bool operator != ( const_iterator const & other)
96.         {
97.         return  !(operator ==(other) );
98.         }   
99.         pointer get_node()const{ return ptr;}
100.     protected:      
101.         self_type * ht;
102.         pointer ptr;        
103.     };
105.     struct iterator : public const_iterator
106.     {
107.         typedef std::forward_iterator_tag iterator_category;
108.         typedef difference_type distance_type;
110.         iterator():const_iterator()
111.         {}
113.         iterator(self_type * h,pointer p)
114.         :const_iterator(h,p)
115.         {}      
116.         iterator(iterator const & other):const_iterator(other)
117.         {}
118.         iterator & operator = (iterator const & other)
119.         {
120.         if(this != &other)
121.         {
122.             this->ht = other.ht;
123.             this->ptr = other.ptr;
124.         }
125.         return *this;
126.         }
127.         iterator & operator ++()
128.         {
129.         this->ptr = this->ht->_advance(this->ptr);
130.         return *this;
131.         }
132.         iterator operator ++(int)
133.         {
134.         iterator tmp(*this);
135.         ++*this;
136.         return tmp;
137.         }
138.         reference operator *()const
139.         {
140.         return (*this->ptr).val;
141.         }
142.         bool operator == ( iterator const & other)
143.         {
144.         return ( this->ht == other.ht && this->ptr == other.ptr );
145.         }
146.         bool operator != ( iterator const & other)
147.         {
148.         return  !(operator ==(other) );
149.         }
150.     };
151.     typedef std::pair<iterator,bool> iterator_bool;
152.     typedef std::pair<iterator,iterator> iterator_pair;
153.     typedef std::pair<const_iterator,const_iterator> const_iterator_pair;
154.     //Don't init the remembers!!!
155.     page_hash_map()
156.     {}
157.     void init(pageid_t pageid,size_type n)
158.     {   
159.         page_ = pageid;
160.         size_ = 0;
161.         bucket_size_ = (size_type)hash::get_next_prime(n);
162.         for(size_type i = 0;i < bucket_size_;++i)
163.         buckets_[i] = MAXPOSITION;
164.     }
165.     static size_type get_buckets_offset(size_type n)
166.     {
167.         return ((hash::get_next_prime(n) -1 )* sizeof(address_t));
168.     }
169.     ~page_hash_map()
170.     {
171.     }
173.     size_type max_size() const
174.     {   
175.         return bucket_size_;        
176.     }       
177.     size_type size() const
178.     {       
179.         return size_;       
180.     }
181.     size_type capacity()const
182.     {
183.         PageAlloc & pa = PageAlloc::instance();
184.         size_type n = 0;
185.         for(typename PageAlloc::iterator it = pa.begin(page_); it != pa.end();++it)
186.         {
187.         allocator_type * alloc = GETALLOCTOR(allocator_type,(*it).buf);
188.         n += alloc->max_count();
189.         }       
190.         return ( n - size() );
191.     }
192.     size_type memory_page_count()const
193.     {
194.         PageAlloc & pa = PageAlloc::instance();
195.         size_type n = 0; 
196.         for(typename PageAlloc::iterator it = pa.begin(page_); it != pa.end();++it)
197.         {
198.         ++n;
199.         }
200.         return n;
201.     }
202.     double overflow()const
203.     {
204.         PageAlloc & pa = PageAlloc::instance();
205.         size_type n = 0;
206.         for(typename PageAlloc::iterator it = pa.begin(page_); it != pa.end();++it)
207.         {
208.         allocator_type * alloc = GETALLOCTOR(allocator_type,(*it).buf);
209.         n += alloc->max_count();
210.         }       
211.         return ((double)size() / (double)n);
212.     }
213.     bool empty() const
214.     {   
215.         return (size() == 0);
216.     }
217.     iterator begin()
218.     {
219.         return  iterator(this,_first_node());
220.     }           
221.     iterator end()
222.     {   
223.         return  iterator(this,0);
224.     }   
226.     const_iterator begin()const
227.     {
228.         return  const_iterator(this,_first_node());
229.     }           
230.     const_iterator end()const
231.     {   
232.         return  const_iterator(this,0);
233.     }   
235.     iterator find(const key_type& key)
236.     {   
237.         return (lower_bound(key));
238.     }
239.     const_iterator find(const key_type& key)const
240.     {   
241.         return (lower_bound(key));
242.     }
244.     mapped_type & operator[](const key_type & key)
245.     {           
246.         iterator _Where = this->lower_bound(key);
247.         if (_Where == this->end())
248.         _Where = this->insert(value_type(key, mapped_type())).first;
249.         return ((*_Where).second);
250.     }
252.     iterator get_iterator(size_type pos)
253.     {   
254.         return iterator(this,get_node(pos) );
255.     }
257.     const_iterator get_iterator(size_type pos)const
258.     {   
259.         return const_iterator(this,get_node(pos) );
260.     }
262.     address_t get_address(iterator it)const
263.     {   
264.         return address(it.get_node());
265.     }
267.     address_t get_address(const_iterator it)const
268.     {   
269.         return address(it.get_node());
270.     }
271.     iterator lower_bound(const key_type & key)
272.     {           
273.         offset_type bucket =hash_value(key);        
274.         address_t pos = buckets_[bucket];
275.         while(pos != MAXPOSITION )
276.         {
277.         pointer node = get_node(pos);
278.         if (!comp_( get_key(*node), key))
279.             return ( comp_(key, get_key(*node)) ? end() : iterator(this,node));
280.         pos = node->next;
281.         }
282.         return end();
283.     }
285.     const_iterator lower_bound(const key_type & key)const
286.     {                   
287.         offset_type bucket =hash_value(key);        
288.         address_t pos = buckets_[bucket];
289.         while(pos != MAXPOSITION )
290.         {
291.         pointer node = get_node(pos);
292.         if (!comp_( get_key(*node), key))
293.             return ( comp_(key, get_key(*node)) ? end() : const_iterator(this,node));
294.         pos = node->next;
295.         }
296.         return end();
297.     }
299.     void erase(const key_type & key)
300.     {   
301.                 iterator it = lower_bound(key);     
302.         erase(it);
303.     }
304.     void erase(iterator first, iterator last)
305.     {
306.         if (first == begin() && last == end())
307.         {
308.         clear();
309.         }
310.         else
311.         {
312.         while (first != last)
313.             erase(first++);
314.         }
315.     }
317.     void fix()
318.     {
319.         offset_type n = 0;
320.         for(iterator first = begin(); first != end();++first)++n;
321.         size_ = n;
322.     }
323.     void reset(pageid_t pageid)
324.     {
325.              PageAlloc & pa = PageAlloc::instance();
326.          for(typename PageAlloc::iterator it = pa.begin(pageid); it != pa.end();++it)
327.          {
328.          allocator_type * alloc = GETALLOCTOR(allocator_type,(*it).buf);
329.          if( alloc->capacity() )
330.          {
331.                      page_ = it.get();
332.              return;
333.          }
334.          }
335.          page_ = pageid;
336.     }
337.     
338.     void clear()
339.     {                   
340.         PageAlloc & pa = PageAlloc::instance();
341.         for(typename PageAlloc::iterator it = pa.begin(page_); it != pa.end();++it)
342.         {
343.         allocator_type * alloc = GETALLOCTOR(allocator_type,(*it).buf);
344.         alloc->reset();
345.         }
346.         for(size_type i = 0;i < bucket_size_;++i)
347.         {
348.         buckets_[i] = MAXPOSITION;
349.         }
350.         size_ = 0;          
351.     } 
352.     void erase(iterator it)
353.     {   
354.         offset_type bucket =hash_value( get_key(*it) );
355.         address_t pos = buckets_[bucket];
356.         address_t prev = pos;
357.         while(pos != MAXPOSITION )
358.         {
359.         pointer node = get_node(pos);
360.         if (!comp_( get_key(*node), get_key(*it) ))
361.         {
362.             if(!comp_(get_key(*it), get_key(*node )))
363.             {
364.             if(prev != pos )
365.             {
366.                 get_node(prev)->next = node->next;
367.             }
368.             else
369.             {
370.                 buckets_[bucket]=node->next;
371.             }
372.             --size_;
373.             pageid_t pn = HIWORD(pos);
374.             allocator_type & alloc = get_allocator(pn);
375.             alloc.deallocate(node,1);
376.             }
377.             break;
378.         }
379.         prev = pos;
380.         pos = node->next;
381.         }
382.     }
384.     template<typename Handler>
385.     bool dump_bucket(const key_type & key,Handler handler)
386.     {       
387.         offset_type bucket =hash_value(key);
388.         address_t pos = buckets_[bucket];
389.         if(pos == MAXPOSITION ) return false;
390.         while(pos != MAXPOSITION )
391.         {
392.         pointer cur = get_node(pos);
393.         handler(bucket,pos,get_key(*cur),get_value(*cur));
394.         pos = cur->next;
395.         }
396.         return true;
397.     }
399.     iterator_bool insert(const value_type & val)
400.     {           
401.         offset_type bucket =hash_value( get_key(val) );
402.         address_t & head = buckets_[bucket];
403.         address_t pos,prev = head;
405.         for(pos = head; pos != MAXPOSITION ;)
406.         {
407.         pointer node = get_node(pos);
408.         if ( comp_( get_key(val),  get_key( *node ) ) )
409.         {               
410.             break;
411.         }
412.         else if ( comp_( get_key( *node ),  get_key(val)))
413.         {
414.             prev = pos;
415.             pos = node->next;
416.         }           
417.         else
418.             return (iterator_bool(iterator(this,node), false)); // already present
419.         }
420.         pointer newnode = new_node(val);
421.         if(!newnode)
422.         throw outof_memory();
423.         ++size_;
424.         address_t newpos = address(newnode);
425.         newnode->next = pos;
426.         if( prev == pos )
427.         {               
428.         head = newpos;
429.         }
430.         else
431.         {
432.         get_node(prev)->next = newpos;                      
433.         }
434.         return (iterator_bool(iterator(this,newnode), true));
435.     }
436. private:
437.     static const key_type & get_key(const value_type& val)
438.     {
439.         return (val.first);
440.     }   
441.     static const key_type & get_key(const hash_node & node)
442.     {
443.         return get_key(node.val);
444.     }
446.     static const mapped_type & get_value(const hash_node & node)
447.     {
448.         return (node.val).second;
449.     }
450.     static const mapped_type & get_value(const value_type& val)
451.     {
452.         return (val.second);
453.     }
454.     
455.     allocator_type & get_allocator(pageid_t pg)const
456.     {
457.         PageAlloc & pa = PageAlloc::instance();
458.         typename PageAlloc::page * pp = pa.get_page(pg);
459.         if(!pp)
460.         throw page_outof_range();       
461.         allocator_type * alloc = GETALLOCTOR(allocator_type,pp->buf);
462.         assert(alloc);
463.         return *alloc;
464.     }
465.     pointer get_node(address_t pos)const
466.     {       
467.         pageid_t pn = HIWORD(pos);
468.         offset_type offset = LOWORD(pos);
469.         allocator_type & alloc = get_allocator(pn);
470.         return alloc.ptr(offset);
471.     }
472.     inline address_t address(pointer p)const
473.     {   
474.         PageAlloc & pa = PageAlloc::instance();
475. #ifdef _MSC_VER
476.         return pa.address<allocator_type>(p);
477. #else
478.         return pa.address((allocator_type*)0,p);        
479. #endif
480.     }
481.     offset_type hash_value(key_type const & key)const
482.     {
483.         return (this->comp_( key ) % bucket_size_);
484.     }
485.     pointer new_node(const value_type& val)
486.     {       
487.         PageAlloc & pa = PageAlloc::instance();
488.         pointer node = 0;
489.         allocator_type * alloc = 0;     
490.         typename PageAlloc::iterator it = pa.get_iterator(page_);
491.         typename PageAlloc::iterator end = pa.end();        
492.         for(; it != end;++it)
493.         {
494.         alloc = GETALLOCTOR(allocator_type,(*it).buf);
495.         if((node=alloc->allocate() ))
496.         {               
497.             page_ = it.get();
498.             construct(node,val);
499.             return node;
500.         }
501.         }
502.         it = pa.get_iterator(page_);
503.         --it;
504.         for(; it != end; --it)
505.         {
506.         alloc = GETALLOCTOR(allocator_type,(*it).buf);
507.         if((node=alloc->allocate() ))
508.         {                   
509.             page_ = it.get();
510.             construct(node,val);
511.             return node;
512.         }
513.         }
514.         alloc = new_page();
515.         if(alloc)
516.         {
517.         node = alloc->allocate();               
518.         construct(node,val);        
519.         }
520.         return node;
521.     }
523.     allocator_type * new_page()
524.     {
525.         assert( page_ != MAXPAGE );
526.         PageAlloc & pa = PageAlloc::instance();
527.         pageid_t newpage = pa.allocate();
529.         if( MAXPAGE == newpage )
530.         return  (allocator_type*)0;
531.         void * pb = pa.buffer(newpage);         
532.         SETALLOCOFFSET(pb,sizeof(offset_type));
533.         ALLOCATE(allocator_type,alloc,pb);
534.         alloc->open(ALLOC_SIZE(allocator_type,pb),true);
536.         typename PageAlloc::page * np = pa.get_page(newpage);
537.         typename PageAlloc::page * cp = pa.get_page(page_);
538.         np->prev = cp->prev;
539.         np->next = page_;       
540.         if( MAXPAGE != cp->prev )
541.         pa.get_page( cp->prev )->next = newpage;
542.         cp->prev = newpage;
543.         page_ = newpage;
544.         return alloc;
545.     }
547.     pointer _advance(pointer p)const
548.     {
549.         if(p->next != MAXPOSITION)
550.         return get_node(p->next);
551.         offset_type bucket =hash_value( get_key(*p) );
553.         for(size_type i = bucket + 1; i < bucket_size_;++i)
554.         {
555.         address_t bucket = buckets_[i];
556.         if(bucket !=  MAXPOSITION )
557.             return get_node(bucket);
558.         }
559.         return 0;
560.     }
562.     pointer _first_node()const
563.     {           
564.         for(size_type i = 0; i < bucket_size_; ++i)
565.         {
566.         address_t bucket = buckets_[i];
567.         if(bucket != MAXPOSITION)
568.             return get_node(bucket);
570.         }
571.         return 0;
572.     }
574.     pointer _next_bucket_first_node(offset_type cur)const
575.     {           
576.         for(size_type i = cur+1; i < bucket_size_; ++i)
577.         {
578.         address_t bucket = buckets_[i];
579.         if(bucket != MAXPOSITION)
580.             return get_node(bucket);            
581.         }
582.         return 0;
583.     }   
584. private:
585.     pageid_t page_;
586.     size_type size_;
587.     size_type bucket_size_;
588.     key_compare comp_;
589.     address_t buckets_[1];
590. };
592. }; //namesapce sm
594. #endif