Bonjour,
Je me pose un probleme de synchronisation sur nintendo DS.
Quels sont les opérations atomiques a disposition ? fetch and add ? compare and swap ? test and set ?

comment les acceder ? Les built-ins de gcc sont ils suffisant ?

Je sais pas si il y a beaucoup de monde qui programme sur DS sur ce forum.

Par contre, sans vouloir faire de pub, je connais un site qui pourrait t´interesser :
http://www.playeradvance.org

Je programme sur DS mais je ne sais pas ce qu´est une "synchronisation". Peux tu etre plus clair ?

Je parles de la synchronisation entre les deux processeurs (ARM7 et ARM9). Il faut arriver a faire des access regulé a la mémoire. étant donné qu´il n´y a pas de noyau sur la machine, on ne doit pouvoir faire que "a la main". C´est a dire utiliser des opérations atomique d´acces a la mémoire.
Les plus connue sont "test and set" et "fetch and add". Ce sont ces opérations que je cherches a utiliser.

Mon probleme réel n´est d´ailleurs pas un probleme de synchronisation des deux processeur mais un probleme d´interuption. Le code de la fonction d´interuption rajoute des elements dans une liste. Ces element sont lus par le code "normal". Si le code normal est entrain de lire mais que l´interuption arive a ce moment la, alors il y a fort a parier que ca va partir en cacahuette. Je cherche donc a mettre deux listes. l´une en ecriture et l´autre en lecture.
L´operation qui peut encore poser probleme est l´operation d´inversion. Cette opération doit être atomique pour que cela ne pose pas de probleme (d´ou mon interet pour ´test and set´ et ses copains)

Ah ok.
J´ai pas ce probleme la, puisque dans le SDK officiel, l´accés a l´ARM7 est interdit (il y a des libs qui tournent dessus c´est tout).

Qu´appels tu par opération d´inversion?

hmm je ne connais pas l archi de la DS, mais si j ai bien compris il ya des interruptions qui break un seul proc (si c est pas le cas, un simple load + cmp devrait faire l´affaire).
Dans ce cas, deux solutions a ma connaissance:
- ldrex/strex si ton archi les supporte
- ldr/str/swp/cmp/spwne sont tes amis pour implementer ton interlocked compare and exchange.

Note que si tu as besoin de clearer tes caches, regarde l´instruction mcr.
Bon tout ca de tete, ca fait longtemps que j ai plus fait d asm ARM.

/d

ce que je voulais dire par operation d´inversion:

void* frontbuffer;
void* backbuffer;

inverse()
{
void* toto = backbuffer;
backbuffer = frontbuffer;
frontbuffer = toto;
}

malheureusement cette fonction n´est pas atomique. Si on me coupe en plein millieu, je peux peut etre avoir des surprise (quoi que, pas sur).

je pourais implanter un genre de mutex en assembleur, mais j´ai jamais (en environement reel) fait d´assembleur, donc ca me disait pas trop de commencer sur une machine sur laquel j´ai aussi peut de moyen de debuggage.

Mais bon, je vais regarder ca.

Faut voir qui peut t´interompre.
T´as des commandes pour desactiver les interruptions et ainsi proteger des sections criques.

oui, c´est ce que je fais actuellement, mais lorsque l´interuption apparait, la probabilité qu´elle rentre en conflit avec le "thread main" est assez faible. Bon, ca ne gene pas la jouabilité, mais du coup je me pose la question.