Buffer circulaire pour la lecture de lignes en mémoire

Bonjour tout le monde !

Je n'ai pas réussi à trouver de meilleur titre et je m'en excuse.

Dans un petit bout de code que j'écris, je lis aujourd'hui la mémoire (une image en fait) en parcourant deux pointeurs:

Code:

---

1 2	int *src_ptr = (int *)mon_adress; int *src_ptr2 = src_ptr+320;

---

C'est un exemple.
Ensuite chacun de ces pointeurs est utilisé dans une boucle for() en les incrémentant pour parcourir la ligne, puis il sont décalés pour passer à la ligne suivante:

Code:

---

1 2 3 4 5 6 7 8 9 10

for (j = 0 ; j < MAX_HEIGHT ; j++, src_ptr+=320, src_ptr2+=320) { for (int i = 0 ; i < 320 ; i++) { int a = *src_ptr++; int b = *src_ptr2++; // Un traitement complexe (ou pas) } }

---

J'ai ici deux problèmes:

1. Je ne peux pas parcourir l'ensemble de l'image, je suis obligé de parcourir la dernière ligne séparément
2. Surtout, je lis deux fois la même ligne ! src_ptr va pointer sur l'ancien src_ptr2 !

L'idée serait donc de mettre en place un petit buffer qui contiendra la ligne qu'il ne faut pas lire deux fois, et de le rendre "circulaire" pour basculer les lignes correctement.

Mais peut-être est-il possible d'exploiter le C++ et sa puissance pour faire cela ? Car aujourd'hui, je dois bien dire que mon code ressemble beaucoup plus à du C.

Merci d'avance aux cadors qui sauront me donner les bonnes idées ! :)

si je comprends bien ta problématique, tu as des lignes entrelacées

Code:

---

1 2 3 4

1llllllllllllllllllllllllllllllllllllllllllll... sur 320 2LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL... sur 320 3llllllllllllllllllllllllllllllllllllllllllll... sur 320

---

A la première lecture, 1lll... est lu par src_ptr et 2LLL... est lu par src_ptr2
J'ai bon ?

Le problème que tu décrit est qu'au premier changement de ligne 2LLL... est lu par src_ptr et 3lll... est lu par src_ptr2. Mais tu as déjà lu 2LLL...
J'ai toujours bon ?

Et pourquoi ne pas faire un saut de 2 lignes

Code:

---

1 2	for (j = 0 ; j < MAX_HEIGHT ; j++, src_ptr+=640, src_ptr2+=640)

---

Par contre, il va peut être falloir jouer sur "j < MAX_HEIGHT" maintenant que tu lis 2 lignes à la fois et mettre "j < MAX_HEIGHT / 2". C'est une supposition, à toi de voir.

Il y a une implémentation de buffer circulaire dans boost.

Ce n'est pas la question. Je n'utilise pas de librairie externe.

Ben alors réimplemente-la, si tu as du temps à perdre.

Encore une fois, ce n'est pas la question...
Et je ne te demande pas de juger (parfois, tu apprendras qu'il n'est pas possible d'utiliser des librairies comme boost par exemple).

Salut,

Si j'ai bien compris, src_ptr doit s'occuper des lignes paires et src_ptr2 doit s'occuper des lignes impaires.

Si oui, il faut veiller à ce que src_ptr et src_ptr2 soient décalés du nombre d'éléments à lire, une fois qu'ils sont en fin de ligne, pour retourner au début de la ligne qui les occupe ;)

Je ne suis pas très partisan de l'écriture des boucles pour dans lesquelles on fait varier plusieurs variables, et je te proposerais donc le code suivant:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

int* src_ptr= (int *)mon_adress; int* src_ptr2=src_ptr+320; /* tant qu'à faire, calculons directement le nombre d'itérations nécessaires  * pour lire toutes les lignes*/ size_t lignes=MAX_HEIGHT/640; // 640=320 (nombre d'éléments) *2 ;) for(size_t i=0;i<lignes;++i) { for(size_t j=0;j<320;++j) { /* récupération des deux valeurs */ int a=*src_ptr; int b=*src_ptr2; /* gestion de a et b */ ++src_ptr; ++src_ptr2; } /* quand on a lu la ligne, il faut se décaler de 320 valeurs supplémentaires   */ src_ptr+=320; src_ptr+=320; }

---

[EDIT]méfie toi quand meme du transtypage C style vers un entier :P

Citation:

---

(parfois, tu apprendras qu'il n'est pas possible d'utiliser des librairies comme boost par exemple).

---

Quand ?

Quand le compilo validé et approuvé sur le projet est trop vieux pour boost ? ...

Quand les politiques de l'entreprise dans laquelle tu travailles t'empêche de le faire par exemple !

Quel genre de politiques ? Celles qui comprennent pas que t'as parfaitement le droit de copier/coller le code dans ton projet commercial propriétaire ?

T'as déjà bossé pour une grosse boite qui fait dans l'embarqué ? Qui a des limitations en mémoire ?

Si embarqué veut dire compilateur capricieux, pourquoi pas.

Sinon, pour les aspects mémoire, je ne vois pas en quoi interdire d'utiliser boost dans son ensemble serait une bonne chose. Je pense que la granularité de la décision doit se faire bibliothèque par bibliothèque. En l'occurrence, si le buffer circulaire de boost présente les caractéristiques qui vont bien, en terme d'occupation mémoire comme en d'autres termes, pourquoi s'en priver sur une position de principe ?

S'il ne convient pas, s'en inspirer pour le réimplémenter à sa sauce peut aussi être une bonne idée.