Sortrace V2

Sharedmemory Array wird von mehreren Kindern sortiert befüllt. Auftreten von Raceconditions.

/************************************************************
*  sortrace.c - Array mit Zufallszahlen sortiert befuellen  *
* (c) 2009 Manuel Krischer fuer das Betriebssystempraktikum *
************************************************************/
 
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/ipc.h>  
#include <sys/shm.h>  
#include <sys/wait.h> 
#include <time.h>     
 
/*Festlegungen*/      
#define ARRAYSIZE       1000
#define MAXWERT         5000
#define KINDER          5 /*muss durch Arraysize ohne rest teilbar sein*/
 
/*Zufallszahlen ziehen*/
int zufall(int max) {   
  return rand() % max;  
}                       
 
/*array befuellen*/
void insert_array(int wert, int *array, int max) {
  int i, j, k, insert, empty;                     
 
  /*Position fuer insert suchen*/
  for (i=0; i<ARRAYSIZE; i++) {  
      if (wert < array[i] || array[i] < 0) {
          insert = i;                       
          break;                            
      }                                     
  }                                         
  /*leeres feld suchen*/                    
  for (j=insert+1; j<ARRAYSIZE; j++) {      
      if (array[j] < 0) {                   
          empty = j;                        
          break;                            
      }                                     
  }                                         
  /*felder von insert bis leer um eins verschieben wenn zwischendrin eingefuegt wird*/
  if (insert < empty) {                                                               
      for (k=empty; k>insert; k--) {                                                  
        array[k] = array[k-1];                                                        
      }                                                                               
  }                                                                                   
  /*wert einfuegen*/                                                                  
  array[insert] = wert;                                                               
exit;                                                                                 
}                                                                                     
 
/*uebergebenes array auf falsche sortierung und leere felder untersuchen*/
void status(int  *array) {                                                
  printf("\n---------- Array mit %i Werten aus Random(%i) sortiert befuellt ----------\n", ARRAYSIZE, MAXWERT);
  int fehler=0, nullen=0, i;                                                                                   
 
    for (i=0; i<ARRAYSIZE; i++) {
    /*pruefen auf leeres feld*/  
      if (array[i] < 0 ) {       
        printf("Feld %i nicht genutzt.\n", i);
        nullen++; }                           
 
    /*pruefen auf falsche sortierung*/
        if (array[i] > array[i+1]) {  
          if ( i+1 >= ARRAYSIZE ) break;
          fehler++;                     
        printf("\nWert %i: %i ist groesser als \nWert %i: %i\n", i, array[i], i+1, array[i+1]);
        }                                                                                      
    }                                                                                          
  printf("Fehler: %i, Nullen: %i\n\n", fehler, nullen);                                        
/*aufraumen*/                                                                                  
exit;                                                                                          
}                                                                                              
 
/*Speicher wieder freigeben*/
void cleanup(int id, int *array) {
/*Shared Memory aus dem Adresseraum des aktuellen Prozesses ausklinken*/
    if (shmdt(array) != 0 ) {                                           
      printf("Entfernen des Shared-Memory fehlgeschlagen!\n");          
    }                                                                   
/*Shared-Memory Element mit IPC_RMID aus dem Speicher entfernen*/       
   if (shmctl(id, IPC_RMID, 0) != 0 ) {                                 
      printf("Loeschen des Shared-Memory nicht moeglich!\n");           
   }                                                                    
exit;                                                                   
}                                                                       
 
/***********************hauptprogramm*******************************/
int main(int argc,char *argv[]) {                                    
int k, j;                                                            
 
/*Sharedmemory mit Groesse eines Int[] holen*/
int id = shmget(IPC_PRIVATE, sizeof(int[ARRAYSIZE]), IPC_CREAT | 0777);
  if (id<0) {                                                          
    printf("Speicherreservierung Fehlgeschlagen!\n");                  
  }                                                                    
 
/*Array an Prozess anklinken*/
int *array = shmat(id, 0, 0); 
 
/*einmaliges initialisieren des randomizers*/
srand(time(NULL));                           
 
/*startaufstellung: array mit -1 befuellen*/
for (j=0; j<ARRAYSIZE; j++) {               
  array[j] = -1;                            
}                                           
 
/*array befuellen mit kindern*/
     if (fork() == 0) {        
           for (k=0; k<ARRAYSIZE/KINDER; k++) {
               insert_array(zufall(MAXWERT), array, ARRAYSIZE);
           }                                                   
     }                                                         
     else if (fork() == 0) {                                   
           for (k=0; k<ARRAYSIZE/KINDER; k++) {                
               insert_array(zufall(MAXWERT), array, ARRAYSIZE);
           }
     }
     else if (fork() == 0) {
           for (k=0; k<ARRAYSIZE/KINDER; k++) {
               insert_array(zufall(MAXWERT), array, ARRAYSIZE);
           }
     }
     else if (fork() == 0) {
           for (k=0; k<ARRAYSIZE/KINDER; k++) {
               insert_array(zufall(MAXWERT), array, ARRAYSIZE);
           }
     }
     else if (fork() == 0) {
           for (k=0; k<ARRAYSIZE/KINDER; k++) {
               insert_array(zufall(MAXWERT), array, ARRAYSIZE);
           }
     }
     else {
         wait(0);
         wait(0);
         wait(0);
         wait(0);
         wait(0);
         status(array);
         cleanup(id, array);
     }
return 0;
}