the begginning

utils/common/stlpoolallocator.h

@@ -0,0 +1,179 @@
+/* Copyright (C) 2014 InfiniDB, Inc.
+
+   This program is free software; you can redistribute it and/or
+   modify it under the terms of the GNU General Public License
+   as published by the Free Software Foundation; version 2 of
+   the License.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+   MA 02110-1301, USA. */
+
+/******************************************************************************************
+* $Id$
+*
+******************************************************************************************/
+
+/* Makes PoolAllocator STL-compliant */
+
+#include <memory>
+#include <boost/shared_ptr.hpp>
+#include "poolallocator.h"
+
+#undef min
+#undef max
+
+#ifndef STLPOOLALLOCATOR_H_
+#define STLPOOLALLOCATOR_H_
+
+namespace utils {
+
+/* If using the pool allocator with a boost smart ptr, use an instance of this
+as the deleter. */
+struct BoostPoolDeallocator
+{
+	inline void operator()(void *ptr) { };
+};
+
+/* This is an STL-compliant wrapper for PoolAllocator + an optimization for containers
+ * that aren't entirely node based (ex: vectors and hash tables)
+ */
+template<class T>
+class STLPoolAllocator
+{
+	public:
+		typedef size_t size_type;
+		typedef ptrdiff_t difference_type;
+		typedef T *pointer;
+		typedef const T *const_pointer;
+		typedef T& reference;
+		typedef const T& const_reference;
+		typedef T value_type;
+		template<class U> struct rebind { typedef STLPoolAllocator<U> other; };
+
+		STLPoolAllocator() throw();
+		STLPoolAllocator(const STLPoolAllocator &) throw();
+		STLPoolAllocator(uint32_t capacity) throw();
+		template<class U> STLPoolAllocator(const STLPoolAllocator<U> &) throw();
+		~STLPoolAllocator();
+
+		STLPoolAllocator<T>& operator=(const STLPoolAllocator<T> &);
+
+		void usePoolAllocator(boost::shared_ptr<PoolAllocator> b);
+		boost::shared_ptr<utils::PoolAllocator> getPoolAllocator();
+
+		pointer allocate(size_type, const void *hint = 0);
+		void deallocate(pointer p, size_type n);
+		size_type max_size() const throw();
+		inline uint64_t getMemUsage() const { return pa->getMemUsage(); }
+
+		void construct(pointer p, const T& val);
+		void destroy(pointer p);
+
+		static const uint32_t DEFAULT_SIZE = 4096*sizeof(T);
+
+		boost::shared_ptr<utils::PoolAllocator> pa;
+};
+
+template<class T>
+STLPoolAllocator<T>::STLPoolAllocator() throw()
+{
+	pa.reset(new PoolAllocator(DEFAULT_SIZE));
+}
+
+template<class T>
+STLPoolAllocator<T>::STLPoolAllocator(const STLPoolAllocator<T> &s) throw()
+{
+	pa = s.pa;
+}
+
+template<class T>
+STLPoolAllocator<T>::STLPoolAllocator(uint32_t capacity) throw()
+{
+	pa.reset(new PoolAllocator(capacity));
+}
+
+template<class T>
+template<class U>
+STLPoolAllocator<T>::STLPoolAllocator(const STLPoolAllocator<U> &s) throw()
+{
+	pa = s.pa;
+}
+
+template<class T>
+STLPoolAllocator<T>::~STLPoolAllocator()
+{
+}
+
+template<class T>
+void STLPoolAllocator<T>::usePoolAllocator(boost::shared_ptr<PoolAllocator> p)
+{
+	pa = p;
+}
+template<class T>
+boost::shared_ptr<utils::PoolAllocator> STLPoolAllocator<T>::getPoolAllocator()
+{
+	return pa;
+}
+
+template<class T>
+typename STLPoolAllocator<T>::pointer
+STLPoolAllocator<T>::allocate(typename STLPoolAllocator<T>::size_type s,
+  typename std::allocator<void>::const_pointer hint)
+{
+	return (pointer) pa->allocate(s*sizeof(T));
+}
+
+template<class T>
+void STLPoolAllocator<T>::deallocate(typename STLPoolAllocator<T>::pointer p,
+  typename STLPoolAllocator<T>::size_type n)
+{
+	pa->deallocate((void *) p);
+}
+
+template<class T>
+typename STLPoolAllocator<T>::size_type STLPoolAllocator<T>::max_size() const throw()
+{
+	return std::numeric_limits<uint64_t>::max()/sizeof(T);
+}
+
+template<class T>
+void STLPoolAllocator<T>::construct(typename STLPoolAllocator<T>::pointer p, const T& val)
+{
+	new((void *)p) T(val);
+}
+
+template<class T>
+void STLPoolAllocator<T>::destroy(typename STLPoolAllocator<T>::pointer p)
+{
+	p->T::~T();
+}
+
+template<class T>
+STLPoolAllocator<T>& STLPoolAllocator<T>::operator=(const STLPoolAllocator<T> &c)
+{
+	pa = c.pa;
+	return *this;
+}
+
+template<typename T>
+bool operator==(const STLPoolAllocator<T> &, const STLPoolAllocator<T> &)
+{
+	return true;
+}
+
+template<typename T>
+bool operator!=(const STLPoolAllocator<T> &, const STLPoolAllocator<T> &)
+{
+	return false;
+}
+
+}
+
+#endif