semaphore.h, ou comment faire croire que ça existe...

[dulrich]

J'ai besoin de sémaphores.... avec des pthreads. Je m suis dis que le semaphore.h serait tout à fait judicieux.... mais voilà, c'est implémenté à moitié, faut passer par sem_open() et non sem_init() qui n'est pas implémenté (étonnant puisque la focntion est présente dans le .h enfin..).

Y a quoi d'autre, parce qu'à coup de sem_open je n'arrive pas à m'en sortir, j'ai des erreurs dans tous les coins sur les sem_wait etc.

[dulrich]

Bon ben j'ai réussis à obtenir ce que je voulais finalement ...

Il ne me reste plus qu'à développer la partie "bench", parce que pour l'instant ça teste un peu n'importe quoi.... si quelqu'un est intéressé, c'est avec plaisir ...
Le but étant de tester le débit (éventuellement les temps d'accès) de n'importe quel disque passé en argument.... On teste le débit pour une tache, puis deux, puis trois puis........ ça devrait bouchonner assez rapidement. Ensuite on peut facilement recracher les résultats et les parser pour en faire un graphe tri-dimensionnel.... enfin

CODE

#include <pthread.h>
#include <sys/time.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

#define NBR_TASK_MAX 15
#define NBR_ECHANTILLONS_MAX 50

//taille des paquets a ecrire
int size_buffer[] = { 4, 8, 16, 32, 64, 128, 256, 512, 1024};// 2048, 16384};

//mutex de sync des taches de bench
int n = 0; /* Nombre de taches */
pthread_cond_t cond;
pthread_mutex_t verrou;

void rendez_vous ()
{
pthread_mutex_lock (&verrou);
n = n - 1;
if (n == 0) pthread_cond_broadcast (&cond);
else pthread_cond_wait (&cond, &verrou);
n = n + 1;
pthread_mutex_unlock (&verrou);
}

//mutex global utilise par la tache de control pour lancer les taches
//suivantes
int m = 1; /* Nombre de taches init a 1 a cause de la tache de control*/
pthread_cond_t cond_glob;
pthread_mutex_t verrou_glob;

void rendez_vous_glob ()
{
pthread_mutex_lock (&verrou_glob);
m = m - 1;
if (m == 0) pthread_cond_broadcast (&cond_glob);
else pthread_cond_wait (&cond_glob, &verrou_glob);
m = m + 1;
pthread_mutex_unlock (&verrou_glob);
}

//tache de bench bouclant sur le tableau de la taille des buffer
void *thr_bench(void * arg)
{
//on prepare les fichiers de sortie
   FILE *fout;

struct timeval tp1;
   struct timeval tp2;
   double s1, s2, m1, m2;
double total = 0, temp;

//echantillonage cad nombre de test d'ecriture
int nbr_echant = NBR_ECHANTILLONS_MAX, nbr_echant_i;

unsigned int iter_buf;
unsigned max_iter_buff = sizeof(size_buffer)/sizeof(int);

for( iter_buf = 0; iter_buf < max_iter_buff; iter_buf++)
 {
 int size_kilo = size_buffer[iter_buf];
 
 //la taille d'un char fait 1 octet
 char *buf = (char*)malloc (sizeof(char)*(size_kilo*1000));
 
 rendez_vous();
 
 for( nbr_echant_i = nbr_echant; nbr_echant_i > 0; nbr_echant_i--)
  {
 
  gettimeofday(&tp1,0);
  s1 = tp1.tv_sec;
  m1 = tp1.tv_usec;
 
  fout = tmpfile();
  fwrite(buf,1, size_kilo*1000,fout);
 
  gettimeofday(&tp2,0);
  s2 = tp2.tv_sec;
  m2 = tp2.tv_usec;
 
  temp = s2-s1+(m2-m1)/1000000;
 
  total = total + temp;
  fclose(fout);
  }
 
 printf("%d Ko en %lf sec = %lf Mo/s\n" ,
     size_kilo,
     total/nbr_echant,
     (size_kilo/(total/nbr_echant))/1000
     );
 
 free(buf);
 
 sleep(1);
 }

rendez_vous_glob();

pthread_exit(NULL);
}

//tache de control, lance paquet de tache par paquet de taches
void *thr_control(void * arg) {

unsigned int nbr_task;
unsigned int iter_thr;
 
for(nbr_task = 1; nbr_task < NBR_TASK_MAX; nbr_task++) {
 
 pthread_t thr[nbr_task];
 
 pthread_mutex_lock (&verrou);
 n++;
 pthread_mutex_unlock (&verrou);
 
 pthread_mutex_lock (&verrou_glob);
 m++;
 pthread_mutex_unlock (&verrou_glob);
 
 for (iter_thr = 0; iter_thr < nbr_task; iter_thr++)
  {
  pthread_create(&thr[iter_thr], NULL, thr_bench, NULL );
  }
 
 rendez_vous_glob();
}

pthread_exit(NULL);
}

//main, initialise les mutex et lance la tache de control
int main (int argc, const char * argv[]) {

pthread_t thr;

//initialisation des mutex
if (pthread_mutex_init
       (&verrou, NULL) == -1)
       printf ("Error setting up mutex");

   if (pthread_cond_init
       (&cond, NULL) == -1)
       printf ("Error setting up condition signal");

if (pthread_mutex_init
       (&verrou_glob, NULL) == -1)
       printf ("Error setting up mutex");

   if (pthread_cond_init
       (&cond_glob, NULL) == -1)
       printf ("Error setting up condition signal");

pthread_create(&thr, NULL, thr_control, NULL );

pthread_exit(NULL);

}

Fichier(s) joint(s)

 main.c.zip ( 1.37 Ko ) Nombre de téléchargements : 102
 image.jpg ( 46.71 Ko ) Nombre de téléchargements : 169