include/Allocator.h

   1 /***************************************************************************
   2  *   Copyright (C) 2007 by www.databasecache.com                           *
   3  *   Contact: praba_tuty@databasecache.com                                 *
   4  *                                                                         *
   5  *   This program is free software; you can redistribute it and/or modify  *
   6  *   it under the terms of the GNU General Public License as published by  *
   7  *   the Free Software Foundation; either version 2 of the License, or     *
   8  *   (at your option) any later version.                                   *
   9  *                                                                         *
  10  *   This program is distributed in the hope that it will be useful,       *
  11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  13  *   GNU General Public License for more details.                          *
  14  *                                                                         *
  15   ***************************************************************************/
  16 #ifndef ALLOCATOR_H
  17 #define ALLOCATOR_H
  18 #include<os.h>
  19 #include<Mutex.h>
  20 #include<ErrorType.h>
  21
  22 typedef void Page;
  23
  24 enum AllocType
  25 {
  26     FixedSizeAllocator = 0,
  27     VariableSizeAllocator = 1,
  28     UnknownAllocator
  29 };
  30
  31 //Used to store the meta data information about the variable size data
  32 class VarSizeInfo
  33 {
  34     public:
  35     size_t size_;
  36     int isUsed_;
  37 };
  38
  39 //Each Page has this info.
  40 //pages are of size PAGE_SIZE normally.
  41 //If data size is more than PAGE_SIZE then
  42 //contigous pages are merged and those pages wont
  43 //have this info in them.Only the start page where that
  44 //data is stored will have this info
  45 //This object is stored at the start of each page
  46 class PageInfo
  47 {
  48      public:
  49      int isUsed_;
  50      int hasFreeSpace_;
  51
  52      Page *nextPageAfterMerge_; //used only in case of
  53      //where pages are merged to store data which are more than
  54      //PAGE_SIZE.
  55      //More detail about how it is used is found in Database::getFreePage
  56
  57      Page *nextPage_; //next page in the same chunk
  58      void setPageAsUsed(size_t offset);
  59      void setFirstPageAsUsed();
  60
  61
  62 };
  63 class Chunk;
  64
  65
  66 //Iterator for the data
  67 //Data is stored in chunks and this class gives
  68 //iterator for it.
  69 class ChunkIterator
  70 {
  71     int chunkID_;
  72     size_t allocSize_; // used if it is a fixed size allocator
  73     AllocType allocType_;
  74
  75     //current iterating page
  76     Page *iterPage_;
  77
  78     //Each page is divided into nodes of size allocSize_
  79     //This gives the offset of the node in the page
  80     int nodeOffset_;
  81
  82     //Total number of nodes in the page
  83     //It is a constant value for this chunk
  84     //and it is cached for performance
  85     int noOfNodes_;
  86
  87     public:
  88     void* nextElement();
  89     friend class Chunk;
  90 };
  91
  92 class Database;
  93 class DatabaseManagerImpl;
  94
  95 class Chunk
  96 {
  97     int chunkID_;
  98
  99     // used if it is a fixed size allocator
 100     size_t allocSize_;
 101     AllocType allocType_;
 102
 103     //Current page where the last data allocation was made
 104     Page *curPage_;
 105
 106     //Page where data allocation was made for the first time
 107     //This is the start of the data
 108     //Iterator should start from this page
 109     Page *firstPage_;
 110     char chunkName[CHUNK_NAME_LEN];
 111     Mutex chunkMutex_;
 112
 113     public:
 114
 115     //sets the size of the allocator
 116     //for fixed size allocator
 117     void setSize(size_t size);
 118
 119     void setChunkNameForSystemDB(int id);
 120     void setChunkName(char const *name){strcpy(chunkName,name);}
 121     char *getChunkName(){return chunkName;}
 122
 123     size_t getSize()                  { return allocSize_; }
 124     void setChunkID(unsigned int id)           { chunkID_ = id; }
 125     int getChunkID()                  { return chunkID_; }
 126     void setAllocType(AllocType type) { allocType_ = type; }
 127     AllocType getAllocType()          { return allocType_; }
 128     Page* getFirstPage(){ return firstPage_; }
 129
 130     PageInfo* getPageInfo(Database *db, void *ptr);
 131     void* allocate(Database *db, DbRetVal *status = NULL);
 132
 133     void* allocate(Database *db, size_t size, DbRetVal *status = NULL);
 134
 135     void  free(Database *db, void* ptr);
 136     ChunkIterator getIterator();
 137     void print();
 138
 139     long getTotalDataNodes();
 140     int totalPages();
 141     int compact();
 142
 143     private:
 144
 145     int initMutex();
 146     int getChunkMutex(int procSlot);
 147     int releaseChunkMutex(int procSlot);
 148     int destroyMutex();
 149     void createDataBucket(Page *page, size_t totalSize, size_t needSize);
 150     void splitDataBucket(VarSizeInfo *varInfo, size_t needSize);
 151     void* varSizeFirstFitAllocate(size_t size);
 152     void freeForLargeAllocator(void *ptr, int pslot);
 153     void freeForVarSizeAllocator(void *ptr, int pslot);
 154
 155     void* allocateForLargeDataSize(Database *db);
 156     void* allocateFromFirstPage(Database *db, int noOfDataNodes);
 157     void* allocateFromNewPage(Database *db);
 158
 159     void* allocateForLargeDataSize(Database *db, size_t size);
 160     void* allocFromNewPageForVarSize(Database *db, size_t size);
 161     void* allocateFromCurPageForVarSize(size_t size);
 162
 163
 164     friend class Database;
 165     friend class DatabaseManagerImpl;
 166 };
 167 #endif