///-*-C++-*-//////////////////////////////////////////////////////////////////
//
// Hoard: A Fast, Scalable, and Memory-Efficient Allocator
//        for Shared-Memory Multiprocessors
// Contact author: Emery Berger, http://www.cs.utexas.edu/users/emery
//
// Copyright (c) 1998-2000, The University of Texas at Austin.
//
// This library is free software; you can redistribute it and/or modify
// it under the terms of the GNU Library General Public License as
// published by the Free Software Foundation, http://www.fsf.org.
//
// This library 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
// Library General Public License for more details.
//
//////////////////////////////////////////////////////////////////////////////

/* We use one processHeap for the whole program. */

#ifndef _PROCESSHEAP_H_
#define _PROCESSHEAP_H_

#include "config.h"

#include <stdio.h>
#include <stdlib.h>

#include "arch-specific.h"
#include "heap.h"
#if USE_PRIVATE_HEAPS
#	include "privateheap.h"
#	define HEAPTYPE privateHeap
#else
#	define HEAPTYPE threadHeap
#	include "threadheap.h"
#endif

#if HEAP_LOG
#	include "memstat.h"
#	include "log.h"
#endif


namespace BPrivate {

class processHeap : public hoardHeap {
	public:
		// Always grab at least this many superblocks' worth of memory which
		// we parcel out.
		enum { REFILL_NUMBER_OF_SUPERBLOCKS = 16 };

		processHeap();
		~processHeap(void)
		{
#if HEAP_STATS
			stats();
#endif
		}
		// Memory deallocation routines.
		void free(void *ptr);

		// Print out statistics information.
		void stats(void);

		// Get a thread heap index.
		inline int getHeapIndex(void);

		// Get thread heap max.
		inline int getMaxThreadHeaps(void);

		// Get the thread heap with index i.
		inline HEAPTYPE & getHeap(int i);

		// Extract a superblock.
		inline superblock *acquire(const int c, hoardHeap * dest);

		// Get space for a superblock.
		inline char *getSuperblockBuffer(void);

		// Insert a superblock.
		inline void release(superblock * sb);

#if HEAP_LOG
		// Get the log for index i.
		inline Log < MemoryRequest > &getLog(int i);
#endif

#if HEAP_FRAG_STATS
		// Declare that we have allocated an object.
		void setAllocated(int requestedSize, int actualSize);

		// Declare that we have deallocated an object.
		void setDeallocated(int requestedSize, int actualSize);

		// Return the number of wasted bytes at the high-water mark
		// (maxAllocated - maxRequested)
		inline int getFragmentation(void);

		int
		getMaxAllocated(void)
		{
			return _maxAllocated;
		}

		int
		getInUseAtMaxAllocated(void)
		{
			return _inUseAtMaxAllocated;
		}

		int
		getMaxRequested(void)
		{
			return _maxRequested;
		}
#endif

	private:
		// Hide the lock & unlock methods.
		void
		lock(void)
		{
			hoardHeap::lock();
		}

		void
		unlock(void)
		{
			hoardHeap::unlock();
		}

		// Prevent copying and assignment.
		processHeap(const processHeap &);
		const processHeap & operator=(const processHeap &);

		// The per-thread heaps.
		HEAPTYPE* theap;

#if HEAP_FRAG_STATS
		// Statistics required to compute fragmentation.  We cannot
		// unintrusively keep track of these on a multiprocessor, because
		// this would become a bottleneck.

		int _currentAllocated;
		int _currentRequested;
		int _maxAllocated;
		int _maxRequested;
		int _inUseAtMaxAllocated;
		int _fragmentation;

		// A lock to protect these statistics.
		hoardLockType _statsLock;
#endif

#if HEAP_LOG
		Log < MemoryRequest >* _log;
#endif

		// A lock for the superblock buffer.
		hoardLockType _bufferLock;

		char *_buffer;
		int _bufferCount;
};


HEAPTYPE &
processHeap::getHeap(int i)
{
	assert(theap != NULL);
	assert(i >= 0);
	assert(i < fMaxThreadHeaps);
	return theap[i];
}


#if HEAP_LOG
Log<MemoryRequest > &
processHeap::getLog(int i)
{
	assert(_log != NULL);
	assert(i >= 0);
	assert(i < fMaxThreadHeaps + 1);
	return _log[i];
}
#endif


// Hash out the thread id to a heap and return an index to that heap.

int
processHeap::getHeapIndex(void)
{
	// Here we use the number of processors as the maximum number of heaps.
	// In fact, for efficiency, we just round up to the highest power of two,
	// times two.
	int tid = find_thread(NULL) & _numProcessorsMask;
	assert(tid < fMaxThreadHeaps);
	return tid;
}


// Return the maximum number of heaps.

int
processHeap::getMaxThreadHeaps(void)
{
	return fMaxThreadHeaps;
}


superblock *
processHeap::acquire(const int sizeclass, hoardHeap * dest)
{
	lock();

	// Remove the superblock with the most free space.
	superblock *maxSb = removeMaxSuperblock(sizeclass);
	if (maxSb)
		maxSb->setOwner(dest);

	unlock();

	return maxSb;
}


inline char *
processHeap::getSuperblockBuffer(void)
{
	char *buf;
	hoardLock(_bufferLock);
	if (_bufferCount == 0) {
		_buffer = (char *)hoardSbrk(SUPERBLOCK_SIZE
			* REFILL_NUMBER_OF_SUPERBLOCKS);
		_bufferCount = REFILL_NUMBER_OF_SUPERBLOCKS;
	}

	buf = _buffer;
	_buffer += SUPERBLOCK_SIZE;
	_bufferCount--;
	hoardUnlock(_bufferLock);

	return buf;
}


// Put a superblock back into our list of superblocks.

void
processHeap::release(superblock *sb)
{
	assert(EMPTY_FRACTION * sb->getNumAvailable() > sb->getNumBlocks());

	lock();

	// Insert the superblock.
	insertSuperblock(sb->getBlockSizeClass(), sb, this);

	unlock();
}

}	// namespace BPrivate

#endif // _PROCESSHEAP_H_