MNMemory.h

Go to the documentation of this file.

/* Copyright (C) 2000 KOM/Darmstadt University of Technology
 *
 * You are allowed to use all other parts of the code under the following terms:
 *
 * For non-commercial use, code may be used in unmodified form provided
 * that this copyright notice and this permission notice appear in
 * supporting documentation.
 *
 * This software is provided "as is" and without any express or implied
 * warranties, including, without limitation, the implied warranty of
 * fitness for a particular purpose.
 *
 * The code may be subjected to the GNU General Public License, Version 2,
 * and re-distributed under the terms of this license.
 * As a special exception, permission is granted to link this code
 * with the Qt library and distribute executables, as long as you
 * follow the requirements of the GNU GPL in regard to all of the
 * software in the executable aside from Qt.
 *
 * Commercial use other than under the terms of the GNU General Public
 * License is allowed only after express negotiation of conditions
 * with the authors.
 */
#ifndef MN_MEMORY_H
#define MN_MEMORY_H

#include <config.h>

#include <string.h>
#include <stdlib.h>
#include <assert.h>

#include "mnstream.h"

#define MN_MEMORY \
    static void *operator new(size_t t)    { return HeapMgmt::heap.allocate(t); } \
    static void  operator delete(void * p) { HeapMgmt::heap.deallocate(p); }

#define MN_MEM_INIT()        HeapMgmt::heap.init()
#define MN_MEM_ALLOCATE(t)   HeapMgmt::heap.allocate(t)
#define MN_MEM_DEALLOCATE(p) HeapMgmt::heap.deallocate(p)

class HeapMgmt
{
    enum HeapSlot
    {
        SLOT_0x0008 = 1,
        SLOT_0x0010,
        SLOT_0x0018,
        SLOT_0x0020,
        SLOT_0x0028,
        SLOT_0x0030,
        SLOT_0x0038,
        SLOT_0x0040,
        SLOT_0x0048,
        SLOT_0x0050,
        SLOT_0x0058,
        SLOT_0x0060,
        SLOT_0x0068,
        SLOT_0x0070,
        SLOT_0x0078,
        SLOT_0x0080,
        SLOT_0x0088,
        NUM_SLOTS
    };

    void* _heap_array[NUM_SLOTS];

#ifndef NDEBUG
    unsigned long  _main_is_running;
#define DO(a) a
#else
#define DO(a)
#endif

    inline int slot_for_size ( size_t t )
    {
        switch ( t )
        {
        case 0x0008 : return SLOT_0x0008; break;
        case 0x0010 : return SLOT_0x0010; break;
        case 0x0018 : return SLOT_0x0018; break;
        case 0x0020 : return SLOT_0x0020; break;
        case 0x0028 : return SLOT_0x0028; break;
        case 0x0030 : return SLOT_0x0030; break;
        case 0x0038 : return SLOT_0x0038; break;
        case 0x0040 : return SLOT_0x0040; break;
        case 0x0048 : return SLOT_0x0048; break;
        case 0x0050 : return SLOT_0x0050; break;
        case 0x0058 : return SLOT_0x0058; break;
        case 0x0060 : return SLOT_0x0060; break;
        case 0x0068 : return SLOT_0x0068; break;
        case 0x0070 : return SLOT_0x0070; break;
        case 0x0078 : return SLOT_0x0078; break;
        case 0x0080 : return SLOT_0x0080; break;
        case 0x0088 : return SLOT_0x0088; break;
        default :     break;
        // I moved the return to end of file because xlC got
        // confused here, below as well.
        // cg 24nov1999
        }
        return 0;
    }

    inline size_t size_for_slot ( int slot )
    {
        switch ( slot )
        {
        case SLOT_0x0008 : return 0x0008; break;
        case SLOT_0x0010 : return 0x0010; break;
        case SLOT_0x0018 : return 0x0018; break;
        case SLOT_0x0020 : return 0x0020; break;
        case SLOT_0x0028 : return 0x0028; break;
        case SLOT_0x0030 : return 0x0030; break;
        case SLOT_0x0038 : return 0x0038; break;
        case SLOT_0x0040 : return 0x0040; break;
        case SLOT_0x0048 : return 0x0048; break;
        case SLOT_0x0050 : return 0x0050; break;
        case SLOT_0x0058 : return 0x0058; break;
        case SLOT_0x0060 : return 0x0060; break;
        case SLOT_0x0068 : return 0x0068; break;
        case SLOT_0x0070 : return 0x0070; break;
        case SLOT_0x0078 : return 0x0078; break;
        case SLOT_0x0080 : return 0x0080; break;
        case SLOT_0x0088 : return 0x0088; break;
        default :          break;
        }
        return 0;
    }

public:
    HeapMgmt();

    void init();

    inline void* allocate( size_t t )
    {
        // ensure that the heap management is not used before main()
        assert ( _main_is_running == 0xfeedcafe );

        /*
         * Reduce the number of slots in the byte array by
         * rouding t up to the next 8 bytes value.
         */
        if ( 0 != (t & 0x7) )
        {
            t += 0x8;
            t &= ~0x7; // bit-wise complement of 7
        }

        /*
         * For frequently requested sizes, hard-compile the sizes
         * into an array. The following switch selects whether the
         * sizes are hard-compiled or not.
         */
        int use_array;
        use_array = slot_for_size(t);

        if ( use_array != 0 )
        {
            if ( _heap_array[use_array] != NULL )
            {
cout << "DEBUG: take " << t << " from stack " << use_array << endl;
                void* ret = _heap_array[use_array];
                _heap_array[use_array] = *(void**)ret;
                return ret;
            }
            else
            {
cout << "DEBUG: alloc " << t << " for stack " << use_array << endl;
                int* ret = (int*)malloc( t + sizeof(int) );
                *ret = use_array;
                ret++;
                return (void*)ret;
            }
        }
        else
        {
cout << "DEBUG: alloc " << t << " for release" << endl;
            int* ret = (int*)malloc( t + sizeof(int) );
            *ret = 0;
            ret++;
            return (void*)ret;
        }
    }

    inline void deallocate( void* ptr )
    {
        // ensure that the heap management is not used before main()
        assert ( _main_is_running == 0xfeedcafe );

        int* ret;
        int  use_array;

        ret = (int*)ptr;
        ret--;
        use_array = *ret;
        if ( use_array == 0 )
        {
cout << "DEBUG: release" << endl;
            free ( ret );
        }
        else
        {
cout << "DEBUG: push on stack " << use_array << endl;
            void** q = (void**)ptr;
            *q = _heap_array[use_array];
            _heap_array[use_array] = ptr;
        }
    }

#ifndef NDEBUG
    void dump_stacks( ostream& ostr );
#endif

    static HeapMgmt heap;
};

#endif /* MN_MEMORY_H */

---