Soir'

Je vais vous parler d'un truc qui peut servir pour des optimisations en langage C ... que ni Crisot ni Hunoppc ne connaissait.

Imaginons que vous voulez lire des pixels ARGB 32 bits puis les manipuler
Donc vous voudriez voir cette donnée "comme" un ULONG 32bits ou comme 4 UBYTE 8 bits
C'est ce que permet un union : c'est comme une double définition d'une structure

union rgba3D {
struct rgba3DL{
ULONG ARGB32;
} L;
struct rgba3DB{
UBYTE ARGB[4];
} B;
};

si vous avez une variable nommée pix
alors pix.L.ARGB32 donnera accès "comme" un ULONG
et pix.B.ARGB[0] pix.B.ARGB[1] pix.B.ARGB[2] pix.B.ARGB[3] donneront accès aux composantes "comme" un UBYTE

On peut aussi créer un pointeur de ce type et accéder aux pixels en mémoire
union rgba3D *pt;

et faire des trucs du genre avec des registres pour faire comme un pseudo assembleur en C

register union rgba3D *pt;
register union rgba3D pix;
register union rgba3D color;

color.B.ARGB[1]=50;
color.B.ARGB[2]=80;
color.B.ARGB[3]=100;

for(n=0;n!=nbre;n++)
{
pix.L.ARGB32=pt[n].L.ARGB32;
pix.B.ARGB[1]=((UWORD)pix.B.ARGB[1]+(UWORD)color.B.ARGB[1])>1;
pix.B.ARGB[2]=((UWORD)pix.B.ARGB[2]+(UWORD)color.B.ARGB[2])>1;
pix.B.ARGB[3]=((UWORD)pix.B.ARGB[3]+(UWORD)color.B.ARGB[3])>1;
pt[n].L.ARGB32=pix.L.ARGB32;
}

PatchCompositeTags fait un usage intensif de ce genre de manip. encapsulée dans des macros

Bonne Nuit 
Message édité par : thellier / 19-01-2017 00:47

Ooouuups tu as tout a fait raison c'étais un >> (une division par 2) que je voulais mettre et non pas un >

L'idée c'est additionner les 2 couleurs (de valeur entre 0 et 255) puis diviser par 2 pour retomber sur une valeur entre 0 et 255 qui tienne à nouveau dans un UBYTE

Au final on a juste une lecture 32bits et une écriture 32 bits à la fin et les autres opérations entre ces deux accès se font sur les registres sans accès mémoire

A noter l'utilisation du pointeur "comme un tableau" en faisant pt[n]. dont on peut espérer que la conversion en assembleur (la compilation quoi) donnera un accès 32 bits indexé par un registre 

du genre

pix.L.ARGB32=pt[n].L.ARGB32;

qui donnerait  en 68000

MOVE.L D1, $0(A1, D0.L)  

ou un truc similaire en PPC

Alain

 

Super intéressant !!!

Merci pour cette manip !!

@Thellier

Pourquoi faire une division par 2 alors qu'une multiplication par 0.5 c'est plus rapide (les divisions sont à évité le plus possible)

Sinirus,
En fait ce n'est pas considéré comme une divsion mais un décalage de bits beaucoup plus rapide qu'une multiplication.
C'est pourquoi tu vois dans les sources des lignes comme a>>4 plutôt que a/16.

Alain,
Ton code me paraissait faux à cause de pt[n], car non déclaré comme pointeur sur un tableau et non initialisé.
D'après ce que tu as écrit, le compilateur compile comme tu le veux mais le fera-t'il à chaque fois indépendamment du compilateur et/ou de sa version?

Si je ne dit pas de bétise, l'opérateur >> correspond à un décalage de bit, c'est une autre façon de faire une division et il s'agit à ma connaissance de méthode la plus rapide pour faire une division.

merci de me corriger si je me trompe :)

Même si on mettait "/ 2", le compilateur génèrerait un shift de 1 bit.
Message édité par : corto / 19-01-2017 17:24

Soir'
>Et lire la composante rouge avec : pixel.r
Oui tout à fait meme si au final ça changera rien sur l'ASM généré

>une division par 2 alors qu'une multiplication par 0.5 c'est plus rapide
a) le >>1 est plus rapide qu'un (vrai) /2

b) ici c'est des entiers (UBYTE = unsigned byte = entier 8 bits signé) donc pas possible de faire * 0.5 avec un nombre sans virgule
Sauf si on le convertit mais là on perd notre optimisation

>Ton code me paraissait faux à cause [...] tableau non initialisé.

Il est vrai qu'il est pas intialisé mais bon si j'écrivais tout le code pour récupérer un pointeur sur les pixels de l'écran proprement depuis le système .... on serait pas rendu :-P
C'est un exemple abstrait

>car non déclaré comme pointeur sur un tableau.

Je le redis une fois de plus "en C un pointeur et un tableau à une dimension sont fondamentalement la meme chose lors de leur utilisation"
Si vous avez appris qque chose de différent à la fac alors votre prof parlait sans comprendre l'ASM ;-P

Ainsi pt[0].ARGB32 et pt->ARGB32 sont en fait la meme chose une fois compilee
Une fois assimilée ceci n'importe qui peut comprendre ce qu'est un pointeur


Alain