OtherHashMaps.h

Go to the documentation of this file.

#ifndef TrackingTools_TrajectoryCleaning_src_OtherHashMaps
#define TrackingTools_TrajectoryCleaning_src_OtherHashMaps

#include <map>
#include <vector>
#include <memory>
#include <list>
#include <iterator>
#include <boost/unordered_map.hpp>
#include <boost/range.hpp>
#include <boost/type_traits.hpp>
#include <boost/mpl/and.hpp>
#include <boost/mpl/logical.hpp>
#include <boost/mpl/assert.hpp>
#include <boost/mpl/if.hpp>

#include <iostream>

namespace cmsutil { 

/*** The concept is the same of std::map<K, std::vector<V>>, but the implementation is much different (and the interface is not really compatible)
 *   It works only for K and V objects with trivial destructors (primitive types and bare pointers are fine)
 *   The main implementation difference w.r.t. unordered_map<K, std::vector<V>> is that this map is optimized to do very few memory allocations
 *   (in particular, clear does not redeme memory so if you just clear the map instead of deleting it you won't call malloc each time you fill it)
 *   The map doesn't rehash, so you should set a reasonable number of buckets (that you can change also when clearing the map)
 *   Note that too many buckets will make your map slow to clear (and possibly more prone to cache misses).
 *   Although it can take an allocator as template argument, it has been tested only with std::allocator.
 *   When used in the TrajectoryCleanerBySharedHits it works and it does improve the performance. Any other usecase was not checked at all.
 * */
template<typename K, typename V, typename Hasher=boost::hash<K>, typename Equals=std::equal_to<K>, typename Alloc=std::allocator<V> >
class SimpleAllocHashMultiMap {
    // taking Alloc definition from http://www.codeproject.com/KB/cpp/allocator.aspx
    BOOST_MPL_ASSERT( (boost::mpl::and_<boost::has_trivial_destructor<K>, boost::has_trivial_destructor<V> > ));
    public:
        typedef Hasher hasher;
        typedef SimpleAllocHashMultiMap<K,V,Hasher,Equals,Alloc> map_type;
        typedef typename boost::mpl::if_<typename boost::is_pointer<V>, V, V const &>::type value_ref; // otherwise we get problems with 'const' if V is a pointer

        SimpleAllocHashMultiMap(size_t buckets, size_t keyRowSize, size_t valueRowSize, size_t maxRows=50) ;

        ~SimpleAllocHashMultiMap() ;

        void clear(size_t newBucketSize=0) { 
            if (newBucketSize != 0) {
                if (newBucketSize > bucketCapacity_) {
                    ptrAlloc_.deallocate(buckets_, bucketCapacity_);
                    bucketCapacity_ = newBucketSize;
                    buckets_ = ptrAlloc_.allocate(bucketCapacity_);
                }
                bucketSize_ = newBucketSize;
            }
            memset(buckets_, 0, bucketSize_ * sizeof(KeyItem *));
            currentKeyRow_ = keyRows_.begin();
            nextKeyItem_ = keyRows_.front(); keyEndMarker_ = nextKeyItem_ + keyRowSize_;
            currentValueRow_ = valueRows_.begin();
            nextValueItem_ = valueRows_.front(); valueEndMarker_ = nextValueItem_ + valueRowSize_;
            if ((keyRows_.size() > maxRows_) || (valueRows_.size() > maxRows_)) freeRows();
        }
        void freeRows() ;

        bool empty() const { return nextKeyItem_ == keyRows_.front(); }

        void insert(K const &key, value_ref value );

        struct ValueItem {
            ValueItem(ValueItem *next1, value_ref val) : next(next1), value(val) {}
            ValueItem * next;
            V           value;
            typedef V value_type;
            const value_type & operator()() const { return value; }
        };

        struct KeyItem {
            KeyItem (KeyItem *next1, K const &key1, ValueItem *val1) : key(key1), next(next1), value(val1) {}
            K           key;
            KeyItem   * next;
            ValueItem * value;
            typedef KeyItem value_type;
            const value_type & operator()() const { return *this; }
        };

        template<typename Item>
        class item_iterator { 
            public:
                typedef ::std::forward_iterator_tag iterator_category;
                typedef const typename Item::value_type  value_type;
                typedef const value_type & reference;
                typedef const value_type * pointer;
                typedef ptrdiff_t difference_type;
                typedef item_iterator<Item> self_type;

                item_iterator() : it_(nullptr) {}
                item_iterator(const Item *it) : it_(it) {}
                const value_type & operator*()  const { return   (*it_)(); }
                const value_type * operator->() const { return & (*it_)(); }
                self_type & operator++() { 
                    if (it_ != nullptr) it_ = it_->next; 
                    return *this; 
                }
                bool operator==(const self_type &other) const { return it_ == other.it_; }
                bool operator!=(const self_type &other) const { return it_ != other.it_; }
                bool good() const { return (it_ != nullptr); }
            private:
                const Item *it_;
        };
        typedef item_iterator<ValueItem> value_iterator;

        value_iterator values(K const &key) ;

    private:
        typedef typename Alloc::template rebind<KeyItem>::other   KeyItemAllocator;
        typedef typename Alloc::template rebind<KeyItem *>::other KeyItemPtrAllocator;
        typedef typename Alloc::template rebind<ValueItem>::other ValueItemAllocator;

        // --- buckets ---
        size_t bucketSize_, bucketCapacity_;
        KeyItem ** buckets_;
        // --- keys ---
        size_t keyRowSize_; 
        std::list<KeyItem *> keyRows_;
        typename std::list<KeyItem *>::iterator currentKeyRow_; // last row that is currently in use. nextItem_ and the last valid item are both on this row. it is never rows_.end()
        KeyItem   *nextKeyItem_, *keyEndMarker_;
        // --- values ---
        size_t valueRowSize_;
        std::list<ValueItem *> valueRows_;
        typename std::list<ValueItem *>::iterator currentValueRow_; // last row that is currently in use. nextItem_ and the last valid item are both on this row. it is never rows_.end()
        ValueItem   *nextValueItem_, *valueEndMarker_;
        // --- other ---
        size_t maxRows_;
        Hasher hasher_;
        Equals eq_; 
        KeyItemAllocator    keyAlloc_;
        ValueItemAllocator  valueAlloc_;
        KeyItemPtrAllocator ptrAlloc_;

        KeyItem   * push_back_(K const &key,   KeyItem   *next) ; 
        ValueItem * push_back_(value_ref value, ValueItem *next) ; 
        KeyItem   & find_or_insert_(K const &key) ;
    public:
        void dump() {
            std::cout << "Dumping HASH MULTIMAP" << std::endl;
            std::cout << "  Key items: " << (std::distance(keyRows_.begin(), currentKeyRow_) * keyRowSize_ + (nextKeyItem_ - *currentKeyRow_)) << std::endl;
            std::cout << "  Value items: " << (std::distance(valueRows_.begin(), currentValueRow_) * valueRowSize_ + (nextValueItem_ - *currentValueRow_)) << std::endl;
            size_t row = 0;
            std::cout << "  Buckets (size " << bucketSize_ << ", capacity " << bucketCapacity_ << ")";
            for (KeyItem **p = buckets_; p != buckets_ + bucketSize_; ++p, ++row) {
                std::cout << "      ["<<row<<"] " << *p << std::endl;
            }
            row = 0;
            std::cout << "  Key Items " << std::endl;
            for (typename std::list<KeyItem *>::iterator it = keyRows_.begin(), last = keyRows_.end(); it != last; ++it, ++row) {
                KeyItem *lastI = *it + keyRowSize_;
                std::cout << "   Key Row " << row <<  " (of size  " << keyRowSize_ << ")" << std::endl;
                for (KeyItem *p = *it; p != lastI; ++p) {
                    std::cout << "      @ " << p << " [" << p->key << ", @" << p->value <<"], next = " << p->next << std::endl;
                    if ((it == currentKeyRow_) && (p == nextKeyItem_ - 1)) {
                        std::cout << "      ^^^ this was the last valid item." << std::endl;
                        last = 0; break;
                    }
                }
                if (lastI == 0) break;
            }
            row = 0;
            std::cout << "  Value Items " << std::endl;
            for (typename std::list<ValueItem *>::iterator it = valueRows_.begin(), last = valueRows_.end(); it != last; ++it, ++row) {
                ValueItem *lastI = *it + valueRowSize_;
                std::cout << "   Value Row " << row <<  " (of size  " << valueRowSize_ << ")" << std::endl;
                for (ValueItem *p = *it; p != lastI; ++p) {
                    std::cout << "      @ " << p << " [" << p->value <<"], next = " << p->next << std::endl;
                    if ((it == currentValueRow_) && (p == nextValueItem_ - 1)) {
                        std::cout << "      ^^^ this was the last valid item." << std::endl;
                        last = 0; break;
                    }
                }
                if (lastI == 0) break;
            }
            std::cout << "  End of dump" << std::endl; 
            
        }
};

template<typename K, typename V, typename Hasher, typename Equals, typename Alloc>
SimpleAllocHashMultiMap<K,V,Hasher,Equals,Alloc>::SimpleAllocHashMultiMap(size_t buckets, size_t keyRowSize, size_t valueRowSize, size_t maxRows) :
    bucketSize_(buckets), bucketCapacity_(bucketSize_),
    keyRowSize_(keyRowSize),
    valueRowSize_(valueRowSize),
    maxRows_(maxRows)
{
    buckets_ = ptrAlloc_.allocate(bucketCapacity_);
    keyRows_.push_back(keyAlloc_.allocate(keyRowSize_));
    valueRows_.push_back(valueAlloc_.allocate(valueRowSize_));
    clear();
}
template<typename K, typename V, typename Hasher, typename Equals, typename Alloc>
SimpleAllocHashMultiMap<K,V,Hasher,Equals,Alloc>::~SimpleAllocHashMultiMap() 
{
    for (typename std::list<KeyItem *>::iterator it = keyRows_.begin(), last = keyRows_.end(); it != last; ++it) {
        keyAlloc_.deallocate(*it, keyRowSize_);
    }
    for (typename std::list<ValueItem *>::iterator it = valueRows_.begin(), last = valueRows_.end(); it != last; ++it) {
        valueAlloc_.deallocate(*it, valueRowSize_);
    }
    ptrAlloc_.deallocate(buckets_, bucketCapacity_);
}

template<typename K, typename V, typename Hasher, typename Equals, typename Alloc>
void 
SimpleAllocHashMultiMap<K,V,Hasher,Equals,Alloc>::freeRows() {
   if (keyRows_.size() > maxRows_) {
        //std::cerr << "Freeing key rows, current size is " << keyRows_.size() << std::endl;
        typename std::list<KeyItem *>::iterator it = keyRows_.begin(), last = keyRows_.end(); 
        for (std::advance(it, maxRows_); it != last; ++it) {
            keyAlloc_.deallocate(*it, keyRowSize_);
        }
        keyRows_.resize(maxRows_);
   } 
   if (valueRows_.size() > maxRows_) {
        //std::cerr << "Freeing value rows, current size is " << valueRows_.size() << std::endl;
        typename std::list<ValueItem *>::iterator it = valueRows_.begin(), last = valueRows_.end(); 
        for (std::advance(it, maxRows_); it != last; ++it) {
            valueAlloc_.deallocate(*it, valueRowSize_);
        }
        valueRows_.resize(maxRows_);
   } 
}

template<typename K, typename V, typename Hasher, typename Equals, typename Alloc>
typename SimpleAllocHashMultiMap<K,V,Hasher,Equals,Alloc>::KeyItem * 
SimpleAllocHashMultiMap<K,V,Hasher,Equals,Alloc>::push_back_(K const &key, KeyItem *next) { 
    if (nextKeyItem_ == keyEndMarker_) {
        ++currentKeyRow_; 
        if (currentKeyRow_ == keyRows_.end()) {
            keyRows_.push_back(keyAlloc_.allocate(keyRowSize_));
            currentKeyRow_ = keyRows_.end(); --currentKeyRow_; // end - 1 doesn't work!
        }
        nextKeyItem_  = *currentKeyRow_;
        keyEndMarker_ = nextKeyItem_ + keyRowSize_; 
    }
    keyAlloc_.construct(nextKeyItem_, KeyItem(next, key, nullptr));
    nextKeyItem_++;
    return (nextKeyItem_-1);
}
template<typename K, typename V, typename Hasher, typename Equals, typename Alloc>
typename SimpleAllocHashMultiMap<K,V,Hasher,Equals,Alloc>::ValueItem * 
SimpleAllocHashMultiMap<K,V,Hasher,Equals,Alloc>::push_back_(value_ref value, ValueItem *next) { 
    if (nextValueItem_ == valueEndMarker_) {
        ++currentValueRow_; 
        if (currentValueRow_ == valueRows_.end()) {
            valueRows_.push_back(valueAlloc_.allocate(valueRowSize_));
            currentValueRow_ = valueRows_.end(); --currentValueRow_; // end - 1 doesn't work!
        }
        nextValueItem_  = *currentValueRow_;
        valueEndMarker_ = nextValueItem_ + valueRowSize_; 
    }
    valueAlloc_.construct(nextValueItem_, ValueItem(next, value));
    nextValueItem_++;
    return (nextValueItem_-1);
}

template<typename K, typename V, typename Hasher, typename Equals, typename Alloc>
typename SimpleAllocHashMultiMap<K,V,Hasher,Equals,Alloc>::KeyItem &
SimpleAllocHashMultiMap<K,V,Hasher,Equals,Alloc>::find_or_insert_(K const &key) {
    //std::cout << "Find or insert for key " << key << std::endl;
    size_t hash = hasher_(key);
    KeyItem * & buck = buckets_[hash % bucketSize_];
    KeyItem * curr = buck;
    while (curr) {
        if (eq_(curr->key, key)) {
            //std::cout << "  Key " << key << " was found." << std::endl;
            return *curr;
        } 
        curr = curr->next;
    } 
    buck = push_back_(key, buck);
    return *buck;
}

template<typename K, typename V, typename Hasher, typename Equals, typename Alloc>
void SimpleAllocHashMultiMap<K,V,Hasher,Equals,Alloc>::insert(K const &key, value_ref value) {
    //std::cout << "Pushing back value " << value << " for key " << key << std::endl;
    KeyItem &k = find_or_insert_(key);
    //std::cout << "Key " << (k.value ? "exists" : " is new") << std::endl;
    k.value = push_back_(value, k.value);
}

template<typename K, typename V, typename Hasher, typename Equals, typename Alloc>
typename SimpleAllocHashMultiMap<K,V,Hasher,Equals,Alloc>::value_iterator
SimpleAllocHashMultiMap<K,V,Hasher,Equals,Alloc>::values(K const &key) {
    //std::cout << "Gettinv values for key " << key << std::endl;
    size_t hash = hasher_(key);
    for (KeyItem * curr = buckets_[hash % bucketSize_]; curr; curr = curr->next) {
        if (eq_(curr->key, key)) return value_iterator(curr->value);
    }
    return value_iterator();
}


/*** Very very simple map implementation
 *   It's just a std::vector<pair<key,value>>, and the operator[] does a linear search to find the key (it's O(N) time, both if the key exists and if it doesn't)
 *   Anyway, if your map is very small and if you clear it often, it performs better than more complex variants
 *   Semantics is as std::map, except that only very few methods are implemented.
 * */
template<typename K, typename V>
class UnsortedDumbVectorMap {
    public:
        typedef std::pair<K,V> value_type;
        typedef typename std::vector<value_type>::const_iterator const_iterator;
        typedef typename std::vector<value_type>::iterator       iterator; // but please don't mutate the keys

        void clear() { data_.clear(); }
        bool empty() const { return data_.empty(); }
        const_iterator begin() const { return data_.begin(); } 
        const_iterator end()   const { return data_.end(); } 
        iterator begin()  { return data_.begin(); } 
        iterator end()    { return data_.end(); } 
        
        V & operator[](const K &k) {
            for (typename std::vector<value_type>::iterator it = data_.begin(), ed = data_.end(); it != ed; ++it) {
                if (it->first == k) return it->second;
            }
            data_.push_back(value_type(k,V()));
            return data_.back().second;
        }


        UnsortedDumbVectorMap() {}
        
    private:
        std::vector<value_type> data_;

};

} // namespace 

#endif