Multithread Synchronization - Part 2

Please see the following link for background of a previously thought to be solved question:

https://www.experts-exchange.com/questions/22069123/Multithread-Synchronization.html?anchorAnswerId=17998206#a17998206

Sorry guys - looks like I spoke too soon. Still getting what appears liek a race condition and 'memory access violation' errors. Made the following modifications to my code. Perhaps some background on what I want to accomplish will help. This app will eventually be turned into a dll. The operator should be able to add data to any of the 300 threads at any point in time and also be able to change the rate at which it operates (currently defaulted to 20ms).

The crash occurs when executing the fifo push calls in main (). I've also noticed that the thread id's printing only go 1-5 which means only 5 of the 300 threads are executing? The reason I believe it might be a race condition is that if I put a big enough print statement in the thread I can avoid from having the application from crashing, it's like that extra added delay helps.


#define NUM_THREADS 300

typedef struct{

      int enabled;
      int data;
      int rate;
      FIFO         fifo;      
}Thread_Info_Type;


Thread_Info_Type thread_info[NUM_THREADS] = { 0 };
HANDLE                   thread_event_hdls[NUM_THREADS] = { 0 };


int terminate_flag      = 0;


CRITICAL_SECTION GlobalCriticalSection;


void Worker_Thread(int *i)
{
      int j = *i;
      int data = 0;
      int rate = 0;

      EnterCriticalSection(&GlobalCriticalSection);

      Fifo_Init(&thread_info[j].fifo);
            
      while((!terminate_flag) || (!Is_Fifo_Empty(&thread_info[j].fifo)))
      {
            
            data = Fifo_Pop(&thread_info[j].fifo);      

            rate = thread_info[j].rate;
            
            if(thread_info[j].enabled)
            {
                  printf("Thread %d\n",j);
            }

            LeaveCriticalSection(&GlobalCriticalSection);

            Sleep(rate);

            EnterCriticalSection(&GlobalCriticalSection);

      }

      Fifo_Terminate(&thread_info[j].fifo);

      LeaveCriticalSection(&GlobalCriticalSection);
            
      SetEvent(thread_event_hdls[j]);
}


void Initialize_Threads()
{
      HANDLE ThreadHandle;      
      int      i = 0;

      InitializeCriticalSection(&GlobalCriticalSection);
            
      terminate_flag   = 0;

      for( i = 0; i < NUM_THREADS; i++)
      {      
            EnterCriticalSection(&GlobalCriticalSection);

            thread_event_hdls[i] = CreateEvent ( NULL, FALSE, FALSE, NULL);
            thread_info[i].rate  = 20;
            thread_info[i].enabled  = 1;

            ThreadHandle = CreateThread(NULL,
                                          16000,
                                          (LPTHREAD_START_ROUTINE)Worker_Thread,
                                          &i,
                                          0,
                                          0);  
            
            LeaveCriticalSection(&GlobalCriticalSection);

            if (ThreadHandle == NULL){      
                  MessageBox(0,"Error Creating Thread!", "Initialize Threads Error!", MB_OK);       
            }            
      
            SetThreadPriority(ThreadHandle,THREAD_PRIORITY_NORMAL);
      }
}

void Terminate_Threads()
{
      int i = 0;

      EnterCriticalSection(&GlobalCriticalSection);
      terminate_flag = 1;
      LeaveCriticalSection(&GlobalCriticalSection);

      WaitForMultipleObjects(NUM_THREADS,thread_event_hdls,TRUE, INFINITE);

      MessageBox(0,"DONE With ALL Threads!", "Terminate Done!", MB_OK);

      DeleteCriticalSection(&GlobalCriticalSection);
}


void main( )
{
      int i = 0;

      Initialize_Threads();
      
      

      for(i = 0; i < NUM_THREADS*5; i++){
      EnterCriticalSection(&GlobalCriticalSection);
      Fifo_Push(&thread_info[i%NUM_THREADS].fifo,i);
      LeaveCriticalSection(&GlobalCriticalSection);
      }

      Sleep(1000);
      
      Terminate_Threads();
      
            
}

//////////////////////////
fifo
/////////////////////////
int Fifo_Init(FIFO *fifo)
{
      ELEMENT *e;
      
      InitializeCriticalSection(&fifo->critical_section);

      EnterCriticalSection(&fifo->critical_section);

      e = malloc(sizeof(ELEMENT));
      
      if( e == NULL ){
            DeleteCriticalSection(&fifo->critical_section);
            MessageBox(NULL,"Malloc Failed!","Fifo_Init Error!",MB_OK);
            LeaveCriticalSection(&fifo->critical_section);
            return -1;
      }
      e->next = NULL;
      e->data = 0;
      fifo->first = e;
      fifo->last = e;

      LeaveCriticalSection(&fifo->critical_section);

      return 1;
}

void Fifo_Terminate(FIFO *fifo) {
      
      ELEMENT *e, *e_temp;

      EnterCriticalSection(&fifo->critical_section);
      
      e = fifo->first;

      while ( e != NULL ) {
      
            e_temp = e->next;
            free(e);
            e = e_temp;            
      }

      fifo->first = NULL;
      fifo->last  = NULL;

      LeaveCriticalSection(&fifo->critical_section);

      DeleteCriticalSection(&fifo->critical_section);

}
int Fifo_Push(FIFO *fifo,CEI_UINT32 data) {
      
      ELEMENT *e;

      EnterCriticalSection(&fifo->critical_section);

      if( fifo->last == NULL ) {            
            MessageBox(NULL,"Fifo Not Initialized!","Fifo_Push Error!",MB_OK);
            LeaveCriticalSection(&fifo->critical_section);
            return -1;
      }

      e = malloc(sizeof(ELEMENT));
      
      if( e == NULL ){
            MessageBox(NULL,"Malloc Failed!","Fifo_Push Error!",MB_OK);
            LeaveCriticalSection(&fifo->critical_section);
            return -1;
      }

      e->data = 0;
      e->next = NULL;
      fifo->last->data = data;
      fifo->last->next = e;
      fifo->last = e;

      LeaveCriticalSection(&fifo->critical_section);

      return 1;
}
CEI_UINT32 Fifo_Pop(FIFO *fifo) {
      
      ELEMENT    *e;
      CEI_UINT32 data = 0;

      EnterCriticalSection(&fifo->critical_section);

      if( fifo->last == fifo->first )
      {
            data = fifo->first->data;
            LeaveCriticalSection(&fifo->critical_section);
            return data;
      }

      e = fifo->first;
      fifo->first = fifo->first->next;
      data = e->data;
      free(e);

      LeaveCriticalSection(&fifo->critical_section);

      return data;
}
int Is_Fifo_Empty(FIFO *fifo) {

      int ret_val;

      EnterCriticalSection(&fifo->critical_section);

      ret_val = fifo->last == fifo->first ? 1 : 0;

      LeaveCriticalSection(&fifo->critical_section);

      return ret_val;

}