MOre

Author: theEmbeddedGeorge

Data_Struct_Implementation/memoryPoolAllocator/README.md

@@ -18,13 +18,13 @@ The memory pool data structure that contains metadata about the pool
 and maintain a list of free blocks to be allocated.
 */
 typedef struct {
-	uint32_t elementSize;
-	uint32_t blockSize;
-	uint32_t used;
-	int32_t block;
-	poolFreed *freed;
-	uint32_t blocksUsed;
-	uint8_t **blocks;
+	uint32_t chunkSize; // size of each chunk
+	uint32_t blockSize; // size of each block
+	uint32_t used; // number of chunks in use in current block
+	int32_t block; // current block index
+	poolFreed *freed;  // overall free chunks list
+	uint32_t blocksUsed; // number of block allocated
+	uint8_t **blocks; // block memory
 } pool;
 ```
 
@@ -37,18 +37,20 @@ typedef struct {
 #endif
 
 /*
-Pool Initialization function
+Pool Initialization function. Pool is only able to allocate chunSize objects
 */
-void poolInitialize(pool *p, const uint32_t elementSize, const uint32_t blockSize)
+void poolInitialize(pool *p, const uint32_t chunkSize, const uint32_t blockSize)
 {
 	uint32_t i;
 
-	p->elementSize = max(elementSize, sizeof(poolFreed));
+	// define chunk and block parammeters
+	p->chunkSize = max(chunkSize, sizeof(poolFreed));
 	p->blockSize = blockSize;
 
     // Clear the pool before any usage
 	poolFreeAll(p);
 
+	// assign initial number of blocks
 	p->blocksUsed = POOL_BLOCKS_INITIAL; // 1
 	p->blocks = malloc(sizeof(uint8_t*) * p->blocksUsed);
 
@@ -63,38 +65,47 @@ void poolFreePool(pool *p)
 		if(p->blocks[i] == NULL)
 			break;
 		else
-			free(p->blocks[i]);
+			free(p->blocks[i]); // free this block
 	}
 
+	// free all block 
 	free(p->blocks);
 }
 
 #ifndef DISABLE_MEMORY_POOLING
 void *poolMalloc(pool *p)
 {
+	// if there is free chunk, reuse it
 	if(p->freed != NULL) {
 		void *recycle = p->freed;
 		p->freed = p->freed->nextFree;
 		return recycle;
 	}
 
+	// else, we proceed to the chunk in current block
+	// if block is full
 	if(++p->used == p->blockSize) {
-		p->used = 0;
+		p->used = 0; // reset used chunk number to 0
+		// if we also run out of blocks
 		if(++p->block == (int32_t)p->blocksUsed) {
 			uint32_t i;
 
+			// assign 2 times block size
 			p->blocksUsed <<= 1;
 			p->blocks = realloc(p->blocks, sizeof(uint8_t*)* p->blocksUsed);
 
+			// initialize to be NULL
 			for(i = p->blocksUsed >> 1; i < p->blocksUsed; ++i)
 				p->blocks[i] = NULL;
 		}
 
+		// assign memory for this free block
 		if(p->blocks[p->block] == NULL)
-			p->blocks[p->block] = malloc(p->elementSize * p->blockSize);
+			p->blocks[p->block] = malloc(p->chunkSize * p->blockSize);
 	}
 
-	return p->blocks[p->block] + p->used * p->elementSize;
+	// return the next free chunk address
+	return p->blocks[p->block] + p->used * p->chunkSize;
 }
 
 void poolFree(pool *p, void *ptr)
@@ -109,6 +120,7 @@ void poolFree(pool *p, void *ptr)
 
 void poolFreeAll(pool *p)
 {
+	// reinitialize all 
 	p->used = p->blockSize - 1;
 	p->block = -1;
 	p->freed = NULL;

README.md

@@ -59,8 +59,8 @@
 5. [Array of Bits (bit sets/bit map)](Data_Struct_Implementation/bitsArray/README.md)
 6. Low Pass Filter
 7. [Memory map IO register manipulation](Data_Struct_Implementation/memoryMap/memory_map_io.md)
-8. Timer list
-9.  [Memory Pool Allocation](Data_Struct_Implementation\memoryPoolAllocator\README.md)
+8. [Simple One-layer Timer list/wheel](Data_Struct_Implementation/timerWheel/README.md)
+9. [Memory Pool Allocation](Data_Struct_Implementation\memoryPoolAllocator\README.md)
 10. Simple Slab Allocator
 11. Data Structure
     1.  [Ring Buffer](./Data_Struct_Implementation/circularRingBuffer/README.md)