///-*-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.
//
//////////////////////////////////////////////////////////////////////////////

//#include <limits.h>
#include <string.h>

#include "config.h"

#include "heap.h"
#include "threadheap.h"
#include "processheap.h"

using namespace BPrivate;


threadHeap::threadHeap(void)
        :_pHeap(0)
{
}


// malloc (sz):
//   inputs: the size of the object to be allocated.
//   returns: a pointer to an object of the appropriate size.
//   side effects: allocates a block from a superblock;
//                 may call sbrk() (via makeSuperblock).

void *
threadHeap::malloc(const size_t size)
{
#if MAX_INTERNAL_FRAGMENTATION == 2
        if (size > 1063315264UL) {
                debug_printf("malloc() of %lu bytes asked\n", size);
                return NULL;
        }
#endif

        const int sizeclass = sizeClass(size);
        block *b = NULL;

        lock();

        // Look for a free block.
        // We usually have memory locally so we first look for space in the
        // superblock list.

        superblock *sb = findAvailableSuperblock(sizeclass, b, _pHeap);
        if (sb == NULL) {
                // We don't have memory locally.
                // Try to get more from the process heap.

                assert(_pHeap);
                sb = _pHeap->acquire((int)sizeclass, this);

                // If we didn't get any memory from the process heap,
                // we'll have to allocate our own superblock.
                if (sb == NULL) {
                        sb = superblock::makeSuperblock(sizeclass, _pHeap);
                        if (sb == NULL) {
                                // We're out of memory!
                                unlock();
                                return NULL;
                        }
#if HEAP_LOG
                        // Record the memory allocation.
                        MemoryRequest m;
                        m.allocate((int)sb->getNumBlocks() *
                                (int)sizeFromClass(sb->getBlockSizeClass()));
                        _pHeap->getLog(getIndex()).append(m);
#endif
#if HEAP_FRAG_STATS
                        _pHeap->setAllocated(0,
                                sb->getNumBlocks() * sizeFromClass(sb->getBlockSizeClass()));
#endif
                }
                // Get a block from the superblock.
                b = sb->getBlock();
                assert(b != NULL);

                // Insert the superblock into our list.
                insertSuperblock(sizeclass, sb, _pHeap);
        }

        assert(b != NULL);
        assert(b->isValid());
        assert(sb->isValid());

        b->markAllocated();

#if HEAP_LOG
        MemoryRequest m;
        m.malloc((void *)(b + 1), align(size));
        _pHeap->getLog(getIndex()).append(m);
#endif
#if HEAP_FRAG_STATS
        b->setRequestedSize(align(size));
        _pHeap->setAllocated(align(size), 0);
#endif

        unlock();

        // Skip past the block header and return the pointer.
        return (void *)(b + 1);
}