include/memBlocks.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures

struct  memBlocks

Functions

memBlocks * memBlocks_initialize (size_t entrySize, int4 blockSizes)
void * memBlocks_newEntry (struct memBlocks *memBlocks)
void * memBlocks_newEntries (struct memBlocks *memBlocks, uint4 numNewEntries)
void memBlocks_returnUnused (struct memBlocks *memBlocks, int4 numUnused)
void * memBlocks_getLastEntry (struct memBlocks *memBlocks)
void memBlocks_resetCurrent (struct memBlocks *memBlocks)
void * memBlocks_getCurrent (struct memBlocks *memBlocks)
void memBlocks_free (struct memBlocks *memBlocks)

Function Documentation

void memBlocks_free ( struct memBlocks *  memBlocks  )  [inline]

Definition at line 182 of file memBlocks.c.

References memBlocks::blocks, memBlocks::numBlocks, and memBlocks::numEntries.

Referenced by alignments_free(), index_processQuery(), main(), rsdb_spexClusterSequences(), unpack_free(), and writedb_close().

00183 {
00184         // Free each block
00185         while (memBlocks->numBlocks > 0)
00186     {
00187         memBlocks->numBlocks--;
00188         free(memBlocks->blocks[memBlocks->numBlocks]);
00189     }
00190 
00191     // Free array of pointers and block sizes
00192     free(memBlocks->blocks);
00193     free(memBlocks->numEntries);
00194 
00195     // Free memBlocks itself
00196     free(memBlocks);
00197 }

Here is the caller graph for this function:

void* memBlocks_getCurrent ( struct memBlocks *  memBlocks  )  [inline]

Definition at line 160 of file memBlocks.c.

References memBlocks::blocks, memBlocks::currentBlock, memBlocks::currentEntry, memBlocks::entrySize, memBlocks::numBlocks, and memBlocks::numEntries.

Referenced by alignments_findGoodAlignments(), alignments_free(), cluster_calculateSavings(), cluster_writeClusters(), index_processQuery(), rsdb_calculateSavings(), rsdb_spexClusterSequences(), rsdb_writeClusters(), unpack_free(), and writedb_close().

00161 {
00162         void* entry;
00163 
00164     // Advance to the next block if neccessary
00165     if (memBlocks->currentEntry >= memBlocks->numEntries[memBlocks->currentBlock])
00166     {
00167         memBlocks->currentBlock++;
00168         memBlocks->currentEntry = 0;
00169 
00170         // If that was the last block, return NULL
00171         if (memBlocks->currentBlock >= memBlocks->numBlocks)
00172             return NULL;
00173     }
00174 
00175     entry = ((char*)(memBlocks->blocks[memBlocks->currentBlock])) +
00176                      memBlocks->currentEntry * memBlocks->entrySize;
00177     memBlocks->currentEntry++;
00178     return entry;
00179 }

Here is the caller graph for this function:

void* memBlocks_getLastEntry ( struct memBlocks *  memBlocks  ) 

Definition at line 137 of file memBlocks.c.

References memBlocks::entrySize, memBlocks::lastBlock, memBlocks::numBlocks, and memBlocks::numEntries.

Referenced by unpack_loadSubject(), and unpack_unpackSubject().

00138 {
00139         void* lastEntry;
00140 
00141     fflush(stdout);
00142 
00143     if (memBlocks->numEntries[memBlocks->numBlocks - 1] < 1)
00144         return NULL;
00145 
00146         lastEntry = ((char*)(memBlocks->lastBlock))
00147               + (memBlocks->numEntries[memBlocks->numBlocks - 1] - 1) * memBlocks->entrySize;
00148 
00149     return lastEntry;
00150 }

Here is the caller graph for this function:

struct memBlocks* memBlocks_initialize ( size_t  entrySize,
int4  blockSizes 
) [read]

Definition at line 19 of file memBlocks.c.

References global_malloc(), and int4.

Referenced by alignments_findGoodAlignments(), alignments_initialize(), index_processQuery(), main(), rsdb_spexClusterSequences(), ungappedExtension_initialize(), unpack_initialize(), and writedb_initialize().

00020 {
00021         struct memBlocks* memBlocks;
00022 
00023     // Declare memory for first block
00024     memBlocks = (struct memBlocks*)global_malloc(sizeof(struct memBlocks));
00025 
00026     memBlocks->blockSizes = blockSizes;
00027     memBlocks->entrySize = entrySize;
00028     memBlocks->numBlocks = 0;
00029         memBlocks->numTotalEntries = 0;
00030     memBlocks->maxNumBlocks = 10;
00031 
00032     // Declare memory for the first block
00033     memBlocks->lastBlock = (void*)global_malloc(memBlocks->entrySize * memBlocks->blockSizes);
00034 
00035     // Declare memory for pointers to blocks and add the first block
00036         memBlocks->blocks = (void**)global_malloc(sizeof(void*) * memBlocks->maxNumBlocks);
00037         memBlocks->numEntries = (int4*)global_malloc(sizeof(int4) * memBlocks->maxNumBlocks);
00038 
00039     memBlocks->blocks[memBlocks->numBlocks] = memBlocks->lastBlock;
00040     memBlocks->numEntries[memBlocks->numBlocks] = 0;
00041         memBlocks->numBlocks++;
00042 
00043     return memBlocks;
00044 }

Here is the call graph for this function:

Here is the caller graph for this function:

void* memBlocks_newEntries ( struct memBlocks *  memBlocks,
uint4  numNewEntries 
)

Definition at line 86 of file memBlocks.c.

References memBlocks::blocks, memBlocks::blockSizes, memBlocks::entrySize, global_malloc(), global_realloc(), int4, memBlocks::lastBlock, memBlocks::maxNumBlocks, memBlocks::numBlocks, memBlocks::numEntries, and memBlocks::numTotalEntries.

Referenced by unpack_getRegions().

00087 {
00088         void* newEntry;
00089 
00090         // Check if we need to create a new block of memory
00091         if (memBlocks->numEntries[memBlocks->numBlocks - 1] + numNewEntries > memBlocks->blockSizes)
00092         {
00093         // Declare memory for the new block
00094         memBlocks->lastBlock = (void*)global_malloc(memBlocks->entrySize * memBlocks->blockSizes);
00095 
00096         // Check if we need more memory for block pointers
00097         if (memBlocks->numBlocks >= memBlocks->maxNumBlocks)
00098         {
00099                 // Allocate more
00100             memBlocks->maxNumBlocks *= 2;
00101                         memBlocks->blocks = (void**)global_realloc(memBlocks->blocks,
00102                                sizeof(void*) * memBlocks->maxNumBlocks);
00103             memBlocks->numEntries = (int4*)global_realloc(memBlocks->numEntries,
00104                                sizeof(int4) * memBlocks->maxNumBlocks);
00105         }
00106 
00107         // Store the address of this new block
00108         memBlocks->blocks[memBlocks->numBlocks] = memBlocks->lastBlock;
00109 
00110         // Reset number of entries in this block
00111                 memBlocks->numEntries[memBlocks->numBlocks] = 0;
00112                 memBlocks->numBlocks++;
00113     }
00114 
00115     // Use the next available slot in the latest block
00116     newEntry = ((char*)(memBlocks->lastBlock))
00117              + memBlocks->numEntries[memBlocks->numBlocks - 1] * memBlocks->entrySize;
00118 
00119     memBlocks->numEntries[memBlocks->numBlocks - 1] += numNewEntries;
00120     memBlocks->numTotalEntries += numNewEntries;
00121 
00122     return newEntry;
00123 }

Here is the call graph for this function:

Here is the caller graph for this function:

void* memBlocks_newEntry ( struct memBlocks *  memBlocks  ) 

Definition at line 47 of file memBlocks.c.

References memBlocks::blocks, memBlocks::blockSizes, memBlocks::entrySize, global_malloc(), global_realloc(), int4, memBlocks::lastBlock, memBlocks::maxNumBlocks, memBlocks::numBlocks, memBlocks::numEntries, and memBlocks::numTotalEntries.

Referenced by alignments_createNew(), cluster_buildCluster(), cluster_processSequenceMatches(), index_processQuery(), rsdb_spexClusterSequences(), ungappedExtension_extend(), ungappedExtension_nucleotideExtend(), ungappedExtension_oneHitExtend(), unpack_unpackSubject(), and writedb_addSequence().

00048 {
00049         void* newEntry;
00050 
00051         // Check if we need to create a new block of memory
00052         if (memBlocks->numEntries[memBlocks->numBlocks - 1] >= memBlocks->blockSizes)
00053         {
00054         // Declare memory for the new block
00055         memBlocks->lastBlock = (void*)global_malloc(memBlocks->entrySize * memBlocks->blockSizes);
00056 
00057         // Check if we need more memory for block pointers
00058         if (memBlocks->numBlocks >= memBlocks->maxNumBlocks)
00059         {
00060                 // Allocate more
00061             memBlocks->maxNumBlocks *= 2;
00062                         memBlocks->blocks = (void**)global_realloc(memBlocks->blocks,
00063                                sizeof(void*) * memBlocks->maxNumBlocks);
00064             memBlocks->numEntries = (int4*)global_realloc(memBlocks->numEntries,
00065                                sizeof(int4) * memBlocks->maxNumBlocks);
00066         }
00067 
00068         // Store the address of this new block
00069         memBlocks->blocks[memBlocks->numBlocks] = memBlocks->lastBlock;
00070 
00071         // Reset number of entries in this block
00072                 memBlocks->numEntries[memBlocks->numBlocks] = 0;
00073                 memBlocks->numBlocks++;
00074     }
00075 
00076     // Use the next available slot in the latest block
00077     newEntry = ((char*)(memBlocks->lastBlock))
00078              + memBlocks->numEntries[memBlocks->numBlocks - 1] * memBlocks->entrySize;
00079 
00080     memBlocks->numEntries[memBlocks->numBlocks - 1]++;
00081     memBlocks->numTotalEntries++;
00082     return newEntry;
00083 }

Here is the call graph for this function:

Here is the caller graph for this function:

void memBlocks_resetCurrent ( struct memBlocks *  memBlocks  )  [inline]

Definition at line 153 of file memBlocks.c.

References memBlocks::currentBlock, and memBlocks::currentEntry.

Referenced by alignments_findGoodAlignments(), alignments_free(), cluster_calculateSavings(), cluster_writeClusters(), index_processQuery(), rsdb_calculateSavings(), rsdb_spexClusterSequences(), rsdb_writeClusters(), unpack_free(), and writedb_close().

00154 {
00155         memBlocks->currentEntry = 0;
00156         memBlocks->currentBlock = 0;
00157 }

Here is the caller graph for this function:

void memBlocks_returnUnused ( struct memBlocks *  memBlocks,
int4  numUnused 
)

Definition at line 126 of file memBlocks.c.

References memBlocks::numBlocks, and memBlocks::numEntries.

Referenced by unpack_getRegions().

00127 {
00128         memBlocks->numEntries[memBlocks->numBlocks - 1] -= numUnused;
00129     if (memBlocks->numEntries[memBlocks->numBlocks - 1] < 0)
00130     {
00131         fprintf(stderr, "Error: to many unused entries returned\n"); fflush(stderr);
00132         exit(-1);
00133     }
00134 }

Here is the caller graph for this function:

Generated on Wed Dec 19 20:49:55 2007 for fsa-blast by  doxygen 1.5.2