Question

This is my first post, but I have been using this site for a while now, been very useful.

I am in the process of writing a memory-pool implementation but I have run into a strange problem. Right now I have 2 memory pools, there is an odd problem that whenever I initialize both of them the first array will have 1 more element than it is supposed to have. For each pool I add beyond the first it gains an additional element. It is not supposed to and I have no idea why.

In my code the first pool has 32 elements (0 – 31) which works fine, but when I initialize the second pool it shows as having 33 elements (0 – 32).

Here is my code :

#include <stdio.h>
typedef struct memoryBlock {
    /* Pointer to array */
    int *Address;                                                
    struct memoryBlock *Next;
}memoryBlock;


/* Small Pool */
#define BLOCKNUM_POOL_S 32 //number of blocks
#define BLOCKSIZE_POOL_S 8 //ints per block

static memoryBlock *Pool_Head_S;
static memoryBlock *Pool_Tail_S;

 /* The memory that will be dynamically allocated will be stored in this array */
static int Pool_Block_S[BLOCKNUM_POOL_S-1][BLOCKSIZE_POOL_S+sizeof(memoryBlock)/sizeof(int)];       

/* This is a free list containing only pointers to free blocks in this pool */
static int Pool_Free_S[BLOCKNUM_POOL_S-1][sizeof(memoryBlock)/sizeof(int)]; 


/* Medium Pool */
#define BLOCKNUM_POOL_M 16 //number of blocks
#define BLOCKSIZE_POOL_M 16 //words per block

static memoryBlock *Pool_Head_M;
static memoryBlock *Pool_Tail_M;

/* The memory that will be dynamically allocated will be stored in this array */
static int Pool_Block_M[BLOCKNUM_POOL_M-1][BLOCKSIZE_POOL_M+sizeof(memoryBlock)/sizeof(int)];           

/* This is a free list containing only pointers to free blocks in this pool */
static int Pool_Free_M[BLOCKNUM_POOL_M-1][sizeof(memoryBlock)/sizeof(int)];


void printS();
void printM();
void initPool_S();
void initPool_M();

void main(){

  initPool_S();
  initPool_M();

  printS();
  printM();

}

void initPool_S(){
   int i;  
   Pool_Tail_S = NULL;
   Pool_Head_S = NULL;
   for(i=0;i<BLOCKNUM_POOL_S;i++){  
      //for each block setup the memory block and pointers
      if(Pool_Tail_S){          
          Pool_Tail_S->Next = (memoryBlock *)&Pool_Free_S[i][0];
          Pool_Tail_S->Next->Address = &Pool_Block_S[i][0];
          Pool_Tail_S = Pool_Tail_S->Next;
          Pool_Tail_S->Next = NULL;
      /* There is nothing in this list yet */
      }else{
          Pool_Head_S = (memoryBlock *)&Pool_Free_S[i][0];
          Pool_Head_S->Address = (int *)&Pool_Block_S[i][0];
          Pool_Head_S->Next = NULL;
          Pool_Tail_S = Pool_Head_S;
      }
   }
}

void initPool_M(){
   int i;
   Pool_Tail_M = NULL;
   Pool_Head_M = NULL;
   for(i=0;i<BLOCKNUM_POOL_M;i++){
        //for each block setup the memory block and pointers
        if(Pool_Tail_M){
            Pool_Tail_M->Next = (memoryBlock *)&Pool_Free_M[i][0];
            Pool_Tail_M->Next->Address = (int *)&Pool_Block_M[i][0];
            Pool_Tail_M = Pool_Tail_M->Next;
            Pool_Tail_M->Next = NULL;
        /* There is nothing in this list yet */
        }else{
            Pool_Head_M = (memoryBlock *)&Pool_Free_M[i][0];
            Pool_Head_M->Address = (int *)&Pool_Block_M[i][0];
            Pool_Head_M->Next = NULL;
            Pool_Tail_M = Pool_Head_M; 
        }      
   }
}

void printM(){
    memoryBlock *tmpPtr2;
    tmpPtr2 = Pool_Head_M;
    int j=0;
    while(tmpPtr2){
        printf(">-------------------------------------------------<\n");
        printf("%d\n",j);
        printf("Pool_Med_Free: %d\n",tmpPtr2);
        printf("Pool_Med_Free->Address: %d\n",tmpPtr2->Address);
        printf("Pool_Med_Free->Next: %d\n",tmpPtr2->Next);
        tmpPtr2 = tmpPtr2->Next;
        j++;
    }
}

void printS(){
  memoryBlock *tmpPtr1;
  tmpPtr1 = Pool_Head_S;
  int j=0;
  while(tmpPtr1){
      printf(">-------------------------------------------------<\n");
      printf("%d\n",j);
      printf("Pool_Small_Free: %d\n",tmpPtr1);
      printf("Pool_Small_Free->Address: %d\n",tmpPtr1->Address);
      printf("Pool_Small_Free->Next: %d\n",tmpPtr1->Next);
      tmpPtr1 = tmpPtr1->Next;
      j++;
  }
}

Also the compiler I am using is minGW.

I am still somewhat new to C so this is probably a stupid mistake, but I cannot seem to solve it. Any Help would be appreciated, Thanks!

Answer 1

Pool_Block_S[BLOCKNUM_POOL_S-1] has only 31 elements. n in array[n] is number of elements not index of last element. This is the source of your problem.

What is the meaning of sizeof(memoryBlock)/sizeof(int)? It doesn’t look correctly.