copie/décalage de bits - Page 1

Je voudrais pouvoir déplacer une grosse zone mémoire (plusieurs Ko) de quelques bits (a priori 4) vers la gauche ou vers la droite en C, tout ça très rapidement. Pour l'instant, je ne peux pas faire ce décalage de moins de 8 bits, en utilisant memcpy ou memmove. Il faudrait une solution rapide (du même ordre que memcpy), sinon ça vaut pas le coup.
Si quelqu'un a une solution (en pur C, je ne connais pas d'ASM)... merci...

Et bien en C c'est possible. Le décalage dans une variable se fait avec l'opérateur << pour "aller vers la gauche", et >> pour l'inverse. Voici un décalage des bits de la varaible MaVar de 4 bits vers la droite (hum, mauvais choix politique 4;) :MaVar= MaVar >> C t'offre une manière plus élégante d'écrire ce décalage :MaVar>>= 4;Le language

En décalant une donnée de type charution (y'a peut-être mieux) est de réaliser ce décalage après l'avoir agrandie :int GrandeVar; char OctetLu; GrandeVar= OctetLu >> 4; (à priori c'est ton cas), tu va perdre des bits ! Ma sol A toi ensuite de gérer l'écriture car tu va comprendre que ça complique un peu les choses...

Merci de la réponse...
Je connaissais déjà les opérateurs >> et <<, mais là, ils ne vont pas m'être utiles -> trop lents car trop de conversions à faire. Il me faudrait une solution de même ordre de rapidité que memcpy.
Au fait, j'utilise en effet des données de type char, mais je pourrais prendre n'importe quoi (short ou long), car ce sont les bits 1 par 1 qui m'intéressent, pas les octets entiers.

Fait bien gaffe alors que la taille de ton buffer soit multiple de 4 ou 2.

Je crains qu'il n'y ait que l'assembleur qui réponde à tes exigences...

>Je crains qu'il n'y ait que l'assembleur qui réponde à tes exigences...

C'est ce que je pensais
D'ailleurs, en fouillant dans les sources d'extgraph, je viens de voir que TN a fait une routine en asm qui apparemment décale d'1 bit sur la gauche une zone mémoire (en l'occurence la zone de l'écran). Je me demandais si c'était pas adaptable à plus d'1 bit et pour une zone mémoire choisie dans la fonction. Voilà la source de ladite fonction :

void ScrollLeft160(unsigned short* buffer,unsigned short lines) {
register short* tmpbuffer = buffer;
register short tmplines = lines;
tmpbuffer += (tmplines<<4) - (tmplines);
tmplines--;
asm volatile (
"0:
sub.w #10,%0
lsl.w -(%0);roxl.w -(%0);roxl.w -(%0);roxl.w -(%0);roxl.w -(%0)
roxl.w -(%0);roxl.w -(%0);roxl.w -(%0);roxl.w -(%0);roxl.w -(%0)
dbra %1,0b"
: "=a" (tmpbuffer), "=d" (tmplines)
: "0" (tmpbuffer), "1" (tmplines));
}

... Ca me paraît pas la solution la plus rapide, mais je me trompe peut-être.

de toute manière, je sais pas l'adapter vu que je connais pas l'asm
si quelqu'un sait...

À part l'appeler 4 fois, je ne vois pas comment utiliser cette routine. En effet, elle utilise une astuce: elle enregistre le bit qui doit passer d'un octet au prochain dans un flag du processeur. Chaque instruction roxl utilise ce flag et en même temps y place le bit pour le prochain roxl. Malheureusement, ce flag ne peut contenir qu'un seul bit, donc on ne peut pas utiliser cette astuce pour 4 octets.

KK> OK, merci. Dans ce cas, il y a pas une solution pour l'appliquer (4 fois si il le faut) sur une zone mémoire autre que 20 octets (en l'occurence 3600) ?

KK> OK, merci. Dans ce cas, il y a pas une solution pour l'appliquer (4 fois si il le faut) sur une zone mémoire autre que 20 octets (en l'occurence 3600) ?

Essaye cela:

void MoveLeft3600(unsigned short* buffer) {
register short* tmpbuffer = buffer+1800;
asm volatile (
"moveq.l #118,%%d0
lsl.w -(%0);roxl.w -(%0);roxl.w -(%0);roxl.w -(%0);roxl.w -(%0);roxl.w -(%0);roxl.w -(%0);roxl.w -(%0)
0:
roxl.w -(%0);roxl.w -(%0);roxl.w -(%0);roxl.w -(%0);roxl.w -(%0);roxl.w -(%0);roxl.w -(%0);roxl.w -(%0);roxl.w -(%0);roxl.w -(%0);roxl.w -(%0);roxl.w -(%0);roxl.w -(%0);roxl.w -(%0);roxl.w -(%0)
dbra %%d0,0b
roxl.w -(%0);roxl.w -(%0);roxl.w -(%0);roxl.w -(%0);roxl.w -(%0);roxl.w -(%0);roxl.w -(%0)"
: "=a" (tmpbuffer)
: "0" (tmpbuffer)
: "d0")
}

(à appeler 4 fois)
[edit]Edité par Kevin Kofler le 02-09-2001 à 19:03:58[/edit]

Je suis vraiment trop con, je me suis planté, c'est 3200 octets, pas 3600 !
En tout cas, j'ai pu tester avec 3600 (en allouant plus), à première vue, ça marche, mais je suis pas sûr que ça copie correctement les premiers octets car ça fait une petite erreur graphique sur mon prog (mais bon, c'est plus probable que ce soit à cause de mon prog parce que ça entrainait plein de changements, et que j'ai adapté à la va-vite).
Si tu peux me refaire la fonction pour 3200 octets, ce serait sympa, merci bien.
Au fait, pourquoi c'est pas possible de mettre la taille en paramètre de fonction ?

Kevin, il sert à quoi le volatile dans "asm volatile (..." ?

>JC: Si tu peux me refaire la fonction pour 3200 octets, ce serait sympa, merci bien.

Essaye cela:

void MoveLeft3200(unsigned short* buffer) {
register short* tmpbuffer = buffer+1600;
asm volatile (
"moveq.l #105,%%d0
lsl.w -(%0);roxl.w -(%0);roxl.w -(%0);roxl.w -(%0);roxl.w -(%0);roxl.w -(%0);roxl.w -(%0);roxl.w -(%0);roxl.w -(%0);roxl.w -(%0)
0:
roxl.w -(%0);roxl.w -(%0);roxl.w -(%0);roxl.w -(%0);roxl.w -(%0);roxl.w -(%0);roxl.w -(%0);roxl.w -(%0);roxl.w -(%0);roxl.w -(%0);roxl.w -(%0);roxl.w -(%0);roxl.w -(%0);roxl.w -(%0);roxl.w -(%0)
dbra %%d0,0b"
: "=a" (tmpbuffer)
: "0" (tmpbuffer)
: "d0")
}

(à appeler 4 fois)

>JC: Au fait, pourquoi c'est pas possible de mettre la taille en paramètre de fonction ?

Oui, mais ça complique, et c'est moins pratique pour optimiser.

>JM: Kevin, il sert à quoi le volatile dans "asm volatile (..." ?

À éviter que l'optimisation fasse n'importe quoi avec le bloc asm. Cf. http://tigcc.ticalc.org/doc/gnuexts.html#SEC94
[edit]Edité par Kevin Kofler le 02-09-2001 à 19:56:07[/edit]

À éviter que l'optimisation fasse n'importe quoi avec le bloc asm. Cf. http://tigcc.ticalc.org/doc/gnuexts.html#SEC94
Vu le nombre de fois que j'ai lu cette section, je suis étonné de ne pas avoir remarqué ce passage. J'espère que GCC va m'écouter avant de faire n'importe quoi avec ce que je lui écrit

> KK : Ca marche nickel avec 3200 octets . J'ai vu aussi pourquoi ça merdait pour la copie des premiers octets, c'est moi qui m'était planté, donc c'est bon maintenant.
Au fait, j'ai fait un petit bench, déplacer de 4 bits avec cette méthode prend 2x/2.5x plus de temps que déplacer d'1 octet (appeler 120 fois MoveLeft3200 prend 2x/2.5x plus de temps qu'appeler 30 fois memmove). C'est correct, je pense que ce sera suffisant, mais si il y a mieux, je suis toujours preneur.

On peu toujours trouve mieux...
tu multiplie par deux le contenu de la boucle, tu divise par 2 le nombre de dbra et tu rajoute une derniere fois le code a la fin
resultat: (105-1)/2*10-1=501 cycles de gagne soit
1/(10 000 000)*501=0.0501 ms de gagné... (sur HW1)
Mais ton code source est 2 fois plus gros...

TiMad>désolé, je connais pas l'asm, je sais pas ce que ça donne...
mais bon, si c'est pour gagner 0.2 ms (en 4 fois), je doute que ça vaille le coup.