Bloquer le programme dans l'attente d'un buffer

**tartine** · 07/10/2009, 12h51

Bonjour a tous !

J'ai deux programmes qui communiquent grace aux SHM ( shared mermory ), et pour pouvoir gerer la lecture ecriture des données , j'ai opté pour la technique e "busy,wait": un programme attend que le recepteur sois pres et quand celui-ci l'est, bloque l'ecriture et indique au lecteur qu'une donnée est presente. tout ceci jusqu'a ce que le lecteur puisse debloquer ls situation et permettre une nouvelle ecriture. Ceci marche tres bien et roule comme sur des roulettes et il n'y a aucun deadlock ( pour le moment, avec un mois que l'application tourne

).

Oui, mais voila, pour verfier que le programme ecrivain n'as rien a dire, j'utilise une boucle

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
 
while(1){
while (rien a dire){
rien
}
else{
bloquer_ecriture();
lire_la_donnee();
debloquer_ecriture();
}
}

Comme nous pouvons le voir, le processeur est tout le temps a 100% de ses capacitées ici ( pas de sleep ou else)
Donc je me demandais si il existait quelque chose pour pouvoir changer cette ligne :
while (rien a dire)
et surtout comment s'y prendre.
Je suis pres a reprendre le code from scratch si vous jugez qu'une autre technique plus efficace et moins "bourrine" marchera ( et surtout laquelle).

PS : le lock est dans le shm lui aussi.

Tartine

**Médinoc** · 07/10/2009, 13h35

Il faudrait qu'on en sache plus sur ce qui fait qu'on ait quelque chose à dire ou non.

**tartine** · 07/10/2009, 14h27

Voici la partie du code qui s'occupe de la gestion du lock :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
while(1){
//tout le temps effectuer cette operation
 
if( getout == 1 ){ // si les 30 secondes ne sont pas ecoulées
 
        while(*buf!=2 && getout==1){    /* attend que le message soit disponible */
        //printf("%d\n",*buf);
        if(time(NULL) - last > 30){
                        getout=0;
                }
        }
        //Traitement du message reçu
                }
}

Je suis sur qu'il existe une technique plus classe que ce while(*buf!=2 && getout==1){
En effet, celui-ci bouffe 100% de proc tout le temps.
j'aimerai bien pouvoir rendre cette partie bloquante ou tout du moins moins gourmande.

PS : si tu souhaites une partie bien spécifique, est-ce que tu peux m'en faire part stp ?

**Médinoc** · 07/10/2009, 14h40

Le plus simple, c'est que le programme écrivain signale un événement ou un sémaphore quand il y a un message disponible.

Quand il n'y a qu'un seul lecteur et un seul écrivain, il est très facile de faire un modèle producteur/consommateur avec une file d'attente de plusieurs messages, en utilisant un buffer circulaire et deux sémaphores (l'un pour le nombre d'objets présents dans le buffer, l'un pour le nombre de places libres).

**tartine** · 07/10/2009, 14h50

Le seul probleme proviens du fait que l'ecrivain peut etre executer un nombre indefnie de fois : celui-ci se lance grace a un trigger sur une base de donnée, fait passer la valeur souhaitée et s'arrete.

Donc, est ce que les signaux et les semaphores sont-ils utiliseables dans cette configuration?

**Médinoc** · 07/10/2009, 15h04

Ça dépend ce que tu veux dire par "un nombre indéfini de fois". Si c'est un nombre indéfini de fois simultanémént, alors il y a plusieurs écrivains.

Mais ce n'est pas forcément un problème: On peut toujours rajouter autour du modèle précédent un "mutex d'écriture" (enfin, mutex ou sémaphore binaire, selon la plate-forme) pour faire en sorte qu'un seul écrivain puisse écrire à la fois...
Mais oui, c'est tout-à-fait possible.

**tartine** · 07/10/2009, 15h46

Uhm , je suis en train de regarder les solutions fournies par create_sem et toute et aquire_sem de cette page :
http://guillaume.maillard.free.fr/bebook/The Kernel Kit/SemaphoreExamps.html

Cependant, je voudrai savoir si cette technique(aquire_sem) est bloquante. Comme je l'ai expliqué, je ne veux pas d'un if ou while qui me pourri mon proc de façon ultra bourrine