mem.h

Go to the documentation of this file.

// ============================================================================
// Project:     Deductive Database
// Filename:    mem.h
// Purpose:     Big pieces of dynamic memory, from which pages are taken
// 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 MEM_INCLUDED
#define MEM_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:
//=============================================================================

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

static const long MEM_MAGIC = 0x4D454D0AL;      // 'MEM\n'

//-----------------------------------------------------------------------------
// MEM_CHUNK_PAGES: Number of memory pages per chunk.
//-----------------------------------------------------------------------------

static const int MEM_CHUNK_PAGES = 1022;        // Chunk size slightly < 4MB

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

class mem_c {
        public:

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

        // alloc_page: Get a new memory page.
        static page_t alloc_page();

        // free_page: Deallocate a memory page (enter into free list).
        static void free_page(page_t page);

        // num_alloc_pages: Get current number of allocated memory pages.
        static int num_alloc_pages() {
                return NumAllocPages;
        }

        // num_chunks: Get number of allocated memory chunks.
        static int num_chunks() {
                return NumChunks;
        }


//-----------------------------------------------------------------------------
// 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 "MEM_MAGIC".
#endif

//-----------------------------------------------------------------------------
// Constructor, Destructor (not used):
//-----------------------------------------------------------------------------

        private:

        // Constructor:
        mem_c();                                // Not implemented - use init()

        // Destructor:
        ~mem_c();                               // Not implemented

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

        private:

        mem_c(const mem_c& mem);                // Not implemented
        mem_c& operator=(const mem_c& mem);     // Not implemented


//-----------------------------------------------------------------------------
// Auxiliary Methods:
//-----------------------------------------------------------------------------

        private:

        // Initialize object (replaces constructor):
        void init();

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

        private:

        // Linked list of all memory chunks.
        static mem_c *FirstChunk;
        static mem_c *LastChunk;

        // Total number of allocated memory chunks.
        static int NumChunks;

        // Linked list of free memory pages:
        static page_t FreePageList;

        // Total number of allocated memory pages.
        static int NumAllocPages;


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

        private:

        // Number of free memory pages in this chunk:
        int NumFreePages;

        // Pointer to first memory page:
        VER_BYTE *FirstPage;

        // Pointer to next memory page:
        VER_BYTE *NextPage;

        // Linked list of all allocated memory chunks:
        mem_c *NextChunk;

        // Memory:
        VER_BYTE Memory[VER_PAGESIZE * MEM_CHUNK_PAGES + (VER_PAGESIZE - 1)];

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

};

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

typedef mem_c *mem_t;

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

#define MEM_NULL (static_cast<mem_t>(0))

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

#endif