mariadb-columnstore-engine/utils/common/simpleallocator.h

/* 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: simpleallocator.h 3495 2013-01-21 14:09:51Z rdempsey $
 *
 ******************************************************************************/

/** @file
 * class SimpleAllocator interface
 */

#ifndef UTILS_SIMPLEALLOCATOR_H
#define UTILS_SIMPLEALLOCATOR_H

#include <unistd.h>
#include <list>
#include <stdint.h>
#include <limits>

#undef min
#undef max

namespace utils
{

// A specialized allocator for std::tr1::unordered_multimap<uint64_t, uint64_t> based joiner
// or std::tr1::unordered_map<uint8_t*, uint8_t*> based aggregation.
// User shall initialize a pool and pass it to allocator, release the pool when map is done.
template<typename T> class SimpleAllocator;

// this pool is best for node size of 3*sizeof(int64).
// map nodes are taken from fixed size blocks, and control hash tables are from ::new.
// assumption is the nodes are not reallocated, but the controls will reallocated when rehash.
// efficient only if the map does not remove nodes, otherwise will take more memory.

#define OPT_NODE_UNITS 10
class SimplePool
{
  public:
	SimplePool() : fNext(NULL), fEnd(NULL), fTableMemSize(0) {}
	~SimplePool() { reset(); }

	inline void* allocate(size_t n, const void* = 0);
	inline void deallocate(void* p, size_t n);
	inline size_t max_size() const throw();
	inline uint64_t getMemUsage() const;

private:
	static const size_t fUnitPerChunk = OPT_NODE_UNITS*10240;

	inline void reset();
	inline void allocateNewChunk();

	// MemUnit stores a pointer to next unit before allocated, and T after allocated.
	union MemUnit
	{
		MemUnit* fNext;
		uint64_t fData;
	} *fNext, *fEnd;    // fNext: next available unit, fEnd: one off the last unit

	std::list<MemUnit*> fBlockList;
	uint64_t fTableMemSize;

	static const size_t fUnitSize = sizeof(MemUnit);
	static const size_t fMaxNodeSize = fUnitSize * OPT_NODE_UNITS;
	static const size_t fChunkSize = fUnitSize * fUnitPerChunk;
};


template<typename T>
class SimpleAllocator
{
  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<typename U> struct rebind { typedef SimpleAllocator<U> other; };

	SimpleAllocator() throw() {}
	SimpleAllocator(boost::shared_ptr<SimplePool> pool) throw() { fPool = pool; }
	SimpleAllocator(const SimpleAllocator& alloc) { fPool = alloc.fPool; }
	template<class U> SimpleAllocator(const SimpleAllocator<U>& alloc) { fPool = alloc.fPool; }

	~SimpleAllocator() throw() { }

	pointer address(reference x) const { return &x; }
	const_pointer address(const_reference x) const { return &x; }

	pointer allocate(size_type n, const void* = 0)
	{ return static_cast<pointer>(fPool->allocate(n*sizeof(T))); }
	void deallocate(pointer p, size_type n)
	{ fPool->deallocate(p, n*sizeof(T)); }

#ifdef _MSC_VER
	//The MSVC STL library really needs this to return a big number...
	size_type max_size() const throw() { return std::numeric_limits<size_type>::max(); }
#else
	size_type max_size() const throw() { return fPool->max_size()/sizeof(T); }
#endif
	void construct(pointer ptr, const T& val) { new ((void *)ptr) T(val); }
	void destroy(pointer ptr) { ptr->T::~T(); }

	SimplePool* getPool() { return fPool; }
	void setPool(SimplePool* pool) { fPool = pool; }

	boost::shared_ptr<SimplePool> fPool;
};


// inlines
inline void * SimplePool::allocate(size_t n, const void *dur)
{
	// make sure the block allocated is on unit boundary
	size_t unitCount = n / fUnitSize;
	if ((n % fUnitSize) != 0)
		unitCount += 1;

	// if for control table, let new allocator handle it.
	if (unitCount > OPT_NODE_UNITS) {
		fTableMemSize += n;
		return new uint8_t[n];
	}
	
	// allocate node
	MemUnit *curr = fNext;
	do {
		if (curr == NULL) {
			allocateNewChunk();
			curr = fNext;
		}
		fNext = curr + unitCount;
		if (fNext > fEnd)
			curr = NULL;
	} while (!curr);

	return curr;
}

inline void SimplePool::deallocate(void* p, size_t n)
{
	// only delete the old control table, which is allocated by new allocator.
	if (n > fMaxNodeSize)
	{
		fTableMemSize -= n;
		delete [] (static_cast<uint8_t*>(p));
	}
}

inline size_t SimplePool::max_size() const throw() 
{
	return fUnitSize * fUnitPerChunk;
}

inline uint64_t SimplePool::getMemUsage() const
{
	return fTableMemSize + fBlockList.size() * fChunkSize +
		// add list overhead, element type is a pointer, and
		// lists store a next pointer.
		fBlockList.size() * 2 * sizeof(void *);
}

inline void SimplePool::reset()
{
	for (std::list<MemUnit*>::iterator i = fBlockList.begin(); i != fBlockList.end(); i++)
		delete [] (*i);
	fNext = NULL;
	fEnd = NULL;
}

inline void SimplePool::allocateNewChunk()
{
	MemUnit* chunk = new MemUnit[fUnitPerChunk];
	fBlockList.push_back(chunk);
	fNext = chunk;
	fEnd = chunk + fUnitPerChunk;
}

template <typename T1, typename T2>
inline bool operator==(const SimpleAllocator<T1>&, const SimpleAllocator<T2>&) {return true;}

template <typename T1, typename T2>
inline bool operator!=(const SimpleAllocator<T1>&, const SimpleAllocator<T2>&) {return false;}
}

#endif  // UTILS_SIMPLEALLOCATOR_H