Discussion :

[petitours]

Bonjour,

J'ai besoin de decaler à gauche toutes les valeurs d'un tableau de char de plus de 2Mo.
{0,1,2,3,4,5,6,7....,2100000} devient {6,7,8,9,....,2100000,?,?,?,?,?,?}

C'est facile a faire avec une boucle for mais ca me prend plus de 4s avec un pc à 2GHz alors que j'ai seulement quelques ms pour le faire avec un pc 3 fois moins rapide !

: Comment peut on faire un tel décalage en deux temps trois mouvements ?

J'ai regardé pour faire ca avec un TStringList mais d'une part je n'y arrive pas (mes string font 1 caratère...)
d'autre par j'ai l'impression d'utiliser un tank pour tuer une fourmie (mes string font 1 caratère...)

Merci d'avance pour votre aide

[Laurent Gomila]

La solution dépend beaucoup du contexte d'utilisation.

Peut-être peux-tu utiliser la fonction memmove ?

Peut-être peux-tu te contenter d'une simple réindexation ? (char* new_tab = tab + 6)

Peut-être peux-tu utiliser une liste chaînée ?

[petitours]

etant donné que je ne vois pas les contraintes et subtilités des différentes propositions, je vais essayer de cader au maximum le contexte

J'ai un tableau de char declaré en publique ainsi

Code :

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

1
2
__fastcall TForm1(TComponent* Owner);
          unsigned char *Buffer ;

puis je reserve la mémoire ainsi

Code :

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

1
2
3
4
__fastcall TForm1::TForm1(TComponent* Owner)
        : TForm(Owner)
{
Buffer = new char[2100000] ;

dans ce buffer, j'empile des caractères recus par paquets par une liaison USB.
Apres traitement d'une partie des octets de ce buffer, je souhaite retirer ces octets du buffer et decaler tous les autres vers le debut du tableau pour continuer d'epiler d'autres octets à la suite, traiter d'autres octets et recommencer...encore et encore...en continu

Le tableau fait 2Mo puisque c'est la longueur maximal des "parties des octets du buffer" que je traite avant de les retirer du buffer

merci beaucoup pour la réponse, je regarde à quoi correspondent les solutions proposées

[petitours]

La reindexation parait pouvoir etre interessante...

Ca veut dire que je peux demander à BCB que la mémoire que j'ai reservé au début (buffer = new char[210000000] soit reservée à coté afin que les octets inscrits en mémoire ne soit plus indexés de la même manière par rapport à Buffer ?

Je ne bouge plus les données mais leur contenant ?

re merci

[Laurent Gomila]

En fait la réindexation est inutile dans ton cas : il ne s'agit que de faire pointer une variable sur le premier élément du nouveau tableau. L'intérêt est simplement d'accéder au N-ième élément avec l'indice 0, etc... Un simple décalage donc, mais à part ça ton tableau ne bouge pas (la mémoire allouée non plus).

memove semble plus adaptée : elle effectue un déplacement de la mémoire.

Code :

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

memmove(buffer, buffer + 6, taille_a_deplacer);

Faut voir si ça améliore les perfs.

Mais je pense que tu peux trouver une structure plus adaptée à ce genre de traitements. As-tu réellement besoin de stocker ces 2 Mo ? Es-tu obligé de les garder dans l'ordre dans ton tableau ?

[petitours]

ca y est !

memmove c'est génial !

j'imagine qu'il y a des structures moins couillones que celle que j'ai imaginé mais j'ai du mal a faire l'bstraction necessaire à une structure plus puissante.

Je pense que je peux m'en sortie ainsi, etant donné la relative simplicité de mon appli, je vais poursuivre.

merci mille fois en tous ca !

[diogene]

L'inconvénient majeur de la solution memmove est .... le déplacement des données alors que le problème n'est qu'un problème d'indexation. Si tu les lis par paquets de 6, ça fait un nombre de déplacements inutiles gigantesque. Il faut peut être concevoir ton buffer comme un buffer circulaire qui ne nécessite aucun déplacement de données. Si ça t'intéresse, je peux développer le truc (J'ai peut être qq part du code pour ça en CBuilder)

[petitours]

ben c'est difficile de refuser ce genre de chose...

Mon seul problème par rapport à ca, c'est que je vais certainement pas comprendre le quart du code en question !

ceque j'ai a faire sur les données est trés simple

Je dois trouver un début de trame ("DEBUT")dans le flux d'octet recu (sachant qu'il peut tres bien y avoir un debut de trame à cheval entre deux arrivées d'octets)
une fois que j'ai reconnu ce début de trame, je me fiche complètement
des octets recus avant, considérés comme inconnus
ensuite j'ai 2 octets qui me disent quel est le type des données (et donc le nombre)
Je n'ai plus qu'à attendre le nombre d'octets en question puis vérifier que l'octet suivant est bien le OU exclusif des data
Une fois cette trame reconnue (de 1 à 2Mo de data dans la trame), je range les data quelquepart (un fichier temporaire certainement)
puis je me contrefiche de ces datas dans le buffer.

ceci dit, par rapport au probleme de déplacer 5000x les datas du buffer, il n'est peut etre pas obligé de les déplacer si souvent.
Mon buffer de 2Mo ne se remplira pas trés vite la plupart du temps ; Les datas sont en général par flots petits (<200o/s) avec quelquefois des 500ko et une fois de temps en temps des 2Mo en continu mais cela restera trés rare

Je peux par exemple remettre mon buffer à zero uniquement si je n'ai pas la place d'enregistrer les données que je viens de recevoir par l'USB(entre 0 et 380) ou si je detecte un debut de trame qui indique une arrivée de data > à la place qui reste dans le buffer.
c'est si lourd que ca le déplacement de data en mémoire ?

merci

[diogene]

Code :

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

c'est si lourd que ca le déplacement de data en mémoire ?

Euh si tu déplace 5000 fois 2 Mo, ca veut dire qu'au final tu as déplacé 10 Go! Mais le plus ennuyeux est de gérer ce déplacement en un endroit précis du code.

Code :

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

Je peux par exemple remettre mon buffer à zero uniquement si je n'ai pas la place d'enregistrer les données que je viens de recevoir par l'USB

Mais, ca t'oblige à tester perpétuellement si tu as la place. ce test peut te couter fort cher.
J'ai trouvé, il y a quelques qq années, du code pour un buffer circulaire sur internet. Je l'ai modifié car il était un peu bogué puis je l'ai adapté pour obtenir un composant non visuel CBuilder5. Je l'ai utilisé pour lire et reproduire des fichiers .wav . Il est thread safe ce qui permet de découpler les deux threads lecture et "écriture": un thread remplissait ce buffer pendant qu'un autre au fur et à mesure le lisait
Si tu es interressé, je peux essayer de retrouver tout ça et le commenter un peu avant de te l'expédier

[petitours]

si tu veux bien...ca m'interesse

je vais surement me faire cramer les neuronnes à comprendre mais ca vaut le coup d'essayer de bien faire les choses !

merci beaucoup

[petitours]

pas la peine de retourner tes affaires pour trouver le super code

J'ai pas mal avancé et mon buffer fonctionne avec une remise à zero quand il manque de la place et uniquement a ce moment là.
Cela me permet justement de ne pas avoir à déplacer la mémoire dans beaucoup de cas ! j'ai souvent un simple changement d'adresse "positionBufferDisponible" à faire.

J'attends que ca me pete à la figure... mais ca se présente pas mal du tout !

Le buffer s'autodébrouille, je reconnais les entetes et j'arrive à savoir le nombre d'octets à télecharger, il ne reste que le traitement ! une autre couche informatique koi

Merci mille fois pour votre aide à tous !