La la valeur de buff est stable, alors c'est head et tail qui sont susceptible d'être modifiés lors du remplissage ? Ce serait alors éventuellement ces deux variables qui devraient être volatiles.
Qu'en penses-tu ?
Je suis d'accord (c'est ce que j'avais mis il me semble dans mon post initial, mais je n'ai peut-être pas été clair, vu l'heure ou je l'ai fait).
Les scénarios :
lors de la phase d'initialisation, je crée mon buffer (j'initialise la structure avec la zone mémoire à remplir/vider, et je positionne les variables tail et head, aisi que le status de mon buffer à Empty).
j'initialise les routines d'interruption qui vont remplir le buffer (3 sources différentes).
lorsque je reçois une interruption de l'une de ces 3 sources :
je lis l'état de 2 entrées
je lis le contenu d'un timer (14 bits utiles)
je merge les données sur 16 bits
je remplis mon buffer.
Note : quand je remplis mon buffer, je positionne la variable status à NON_EMPTY, et je la positionne à FULL lorsque je n'ai plus de place.
Pour info, sur mon microcontroleur, les interruptions ne peuvent être interrompues.
Dans ma routine principale, j'envisage de:
- tester le taux de remplissage du buffer (vérifier qu'il y a plus de N octets dispo).
- si le buffer est plein à plus de n%, je démarre la transmission des données sur une UART. L'idée serait de transmettre via interruption tant que le buffer n'est pas vide. Lorsque le buffer est vide, je stoppe le transfert (ais pour cette partie, je ne suis pas sur que ce soit la meilleure façon de faire, je n'ai pas encore les idées tout à fait claires, il est possible que je vienne à emettre via le a boucle principale).
Donc au final:
- dans mes interruptions de remplissage, je n'accède qu'à la variable tail (et à mon buffer)
- dans la boucle principale : je n'ai pas encore déterminé comment détecter le taux de remplissage. Probablement en lisant les variables head, tail et size de ma structure.
- si j'émets via interruption, je ne modifie que la variable head dans cette interruption. Comme une it ne peut être interrompu, je suis sur qu'il n'y aura rien de modifié pendant le déroulement de celle-ci
- si j'emets dans ma boucle principale, je suis suceptible d'être interrompu par une interruption de remplissage. Mais comme les variables modifiées pendant l'émission (head) n'est pas modifiée par la routine de remplissage. Par contre cette routile va la lire pour savoir si mon buffer est plein ou non. C'est là qu'il faut que je m'assure que ça ne pose pas de pb.
Dis-toi que sans volatile, un code peut-être optimisé de sorte à ne pas systématiquement lire ou écrire en mémoire vive mais soit récupérer une valeur toujours présente dans un registre ou postposer l'écriture en mémoire tant que le registre ne doit pas être libéré.
C'est bien ce que je pensais avoir compris, mais toujours avec un doute quelque part. Merci à toi, tu as levé mes doutes.
[^] # Re: multithread et optimisation
Posté par totof2000 . En réponse au message Volatile, struct et interruptions.. Évalué à 2. Dernière modification le 14 janvier 2016 à 17:05.
Je suis d'accord (c'est ce que j'avais mis il me semble dans mon post initial, mais je n'ai peut-être pas été clair, vu l'heure ou je l'ai fait).
Les scénarios :
lors de la phase d'initialisation, je crée mon buffer (j'initialise la structure avec la zone mémoire à remplir/vider, et je positionne les variables tail et head, aisi que le status de mon buffer à Empty).
j'initialise les routines d'interruption qui vont remplir le buffer (3 sources différentes).
lorsque je reçois une interruption de l'une de ces 3 sources :
Note : quand je remplis mon buffer, je positionne la variable status à NON_EMPTY, et je la positionne à FULL lorsque je n'ai plus de place.
Pour info, sur mon microcontroleur, les interruptions ne peuvent être interrompues.
Dans ma routine principale, j'envisage de:
- tester le taux de remplissage du buffer (vérifier qu'il y a plus de N octets dispo).
- si le buffer est plein à plus de n%, je démarre la transmission des données sur une UART. L'idée serait de transmettre via interruption tant que le buffer n'est pas vide. Lorsque le buffer est vide, je stoppe le transfert (ais pour cette partie, je ne suis pas sur que ce soit la meilleure façon de faire, je n'ai pas encore les idées tout à fait claires, il est possible que je vienne à emettre via le a boucle principale).
Donc au final:
- dans mes interruptions de remplissage, je n'accède qu'à la variable tail (et à mon buffer)
- dans la boucle principale : je n'ai pas encore déterminé comment détecter le taux de remplissage. Probablement en lisant les variables head, tail et size de ma structure.
- si j'émets via interruption, je ne modifie que la variable head dans cette interruption. Comme une it ne peut être interrompu, je suis sur qu'il n'y aura rien de modifié pendant le déroulement de celle-ci
- si j'emets dans ma boucle principale, je suis suceptible d'être interrompu par une interruption de remplissage. Mais comme les variables modifiées pendant l'émission (head) n'est pas modifiée par la routine de remplissage. Par contre cette routile va la lire pour savoir si mon buffer est plein ou non. C'est là qu'il faut que je m'assure que ça ne pose pas de pb.
C'est bien ce que je pensais avoir compris, mais toujours avec un doute quelque part. Merci à toi, tu as levé mes doutes.