mpool.h

Go to the documentation of this file.

// ============================================================================
// Project:     Deductive Database
// Filename:    mpool.h
// Purpose:     Pool of memory pages (allocation, deallocation, statistics).
// Last Change: 04.08.2017
// Language:    C++
// EMail:       brass@informatik.uni-halle.de
// WWW:         http://www.informatik.uni-halle.de/~brass/
// Address:     Feldschloesschen 15, D-06120 Halle (Saale), GERMANY
// Copyright:   (c) 2015-2017 by Stefan Brass
// License:     See file "LICENSE" for copying conditions.
// Note:        There is no warranty at all - this code may contain bugs.
// ============================================================================


//=============================================================================
// Include File Frame:
//=============================================================================

#ifndef MPOOL_INCLUDED
#define MPOOL_INCLUDED

//=============================================================================
// Used Types and Macros:
//=============================================================================

#ifndef VER_INCLUDED
#include "../base/ver.h"
#endif

#ifndef STR_INCLUDED
#include "../base/str.h"
#endif

#ifndef CHECK_INCLUDED
#include "../base/check.h"
#endif

#ifndef PAGE_INCLUDED
#include "page.h"
#endif


//=============================================================================
// Private Constants:
//=============================================================================

//-----------------------------------------------------------------------------
// MPOOL_MAGIC: Magic number (identifies objects of this class).
//-----------------------------------------------------------------------------

static const long MPOOL_MAGIC = 0x4D504F0AL;    // 'MPO\n'

//-----------------------------------------------------------------------------
// MPOOL_PAGEARRAY_SIZE: Number of places in local array of allocated pages.
//-----------------------------------------------------------------------------

static const int MPOOL_PAGEARRAY_SIZE = 10;

        // This reduces the overhead of keeping track of allocated pages
        // if only a few pages are allocated.
        // If more pages are allocated than fit in the array,
        // entire pages are used to store the addresses of allocated pages.

//=============================================================================
// Class for Pool of Dynamic Memory Pages:
//=============================================================================

class mpool_c {
        public:


//-----------------------------------------------------------------------------
// Constructor, Destructor:
//-----------------------------------------------------------------------------

        // Constructor:
        mpool_c(str_t name);

        // Destructor (frees all allocated pages of this memory pool):
        ~mpool_c();

//-----------------------------------------------------------------------------
// Class Methods:
//-----------------------------------------------------------------------------

        // first_pool: Start of linked list of all memory pools.
        static mpool_c* first_pool()
        {
                return FirstPool;
        }

//-----------------------------------------------------------------------------
// (Object) Methods:
//-----------------------------------------------------------------------------

        // alloc_page: Allocate a memory page.
        page_t alloc_page();

        // next_pool: Follow link to next memory pool.
        mpool_c* next_pool() const
        {
                CHECK_VALID("mpool_c::next_pool");
                return NextPool;
        }

        // name: Get name of this memory pool (for printing statistics):
        str_t name() const
        {
                CHECK_VALID("mpool_c::name");
                return Name;
        }

        // num_alloc_pages: Number of mem pages that are currently allocated.
        int num_alloc_pages() const
        {
                CHECK_VALID("mpool_c::num_alloc_pages");
                return NumAllocPages;
        }


//-----------------------------------------------------------------------------
// Debugging Support:
//-----------------------------------------------------------------------------

#if     VER_DEBUG
        // Integrity check:
        public:
        str_t   check() const;

        // Magic number (identifies objects of this class for debugging).
        private:
        long    Magic;          // Must be "MPOOL_MAGIC".
#endif

#if     VER_DUMP
        // dump: Show data structure.
        public:
        void dump(str_t headline = STR_NULL) const;
#endif


//-----------------------------------------------------------------------------
// Copy-constructor and assignment operator are not supported for this class:
//-----------------------------------------------------------------------------

        private:

        mpool_c(const mpool_c& mpool);          // Not implemented
        mpool_c& operator=(const mpool_c& mpool); // Not implemented


//-----------------------------------------------------------------------------
// Private Class Members:
//-----------------------------------------------------------------------------

        private:

        // Linked list of all memory pools (for printing statistics).
        static mpool_c *FirstPool;
        static mpool_c *LastPool;

        // Total number of memory pages (allocated by any pool).
        static int TotalPages;

//-----------------------------------------------------------------------------
// Private Object Members:
//-----------------------------------------------------------------------------

        private:

        // Name of this memory pool:
        str_t Name;

        // Current number of allocated memory pages.
        int NumAllocPages;

        // Doubly linked list of all memory pools:
        mpool_c *NextPool;
        mpool_c *PrevPool;

        // Array for first allocated pages (if only a few pages are needed):
        page_t PageDirArr[MPOOL_PAGEARRAY_SIZE];

        // Linked list of pages with links to allocated pages:
        page_t *FirstDirPage;

        // Current page of the page directory (last in the list):
        page_t *CurrDirPage;

        // Number of free places in the current page of the page directory:
        int CurrDirFree;

        // Pointer to the next free place in the current directory page:
        page_t *CurrDirPtr;

//=============================================================================
// End of Class:
//=============================================================================

};

//-----------------------------------------------------------------------------
// Define pointer type:
//-----------------------------------------------------------------------------

typedef mpool_c *mpool_t;

//-----------------------------------------------------------------------------
// Define null pointer:
//-----------------------------------------------------------------------------

#define MPOOL_NULL (static_cast<mpool_t>(0))

//=============================================================================
// End of Include File:
//=============================================================================

#endif