Un peu d'assemblage

29 août 2009 par Prashant ·

Commentaires
Filed under: la technologie

Après avoir lu cette article sur les tampons de blocage libres et voir l'utilisation de la CSA (comparer et échanger), je me suis senti comme l'affichage du code assembleur pour faire la même chose. Cas d'utilisation là-bas était d'écrire une méthode native et l'appeler à partir de Java (retour à 1,5, lorsque les structures de données simultanés en Java étaient plus ou moins inexistant). Sans plus tarder, je vais libérer le code sur vous . La première est pour le CAS et le second est pour le calcul GCD en utilisant l'algorithme d'Euclide (celui-ci peut être trouvée dans de nombreux endroits et des tutoriels ainsi).

Compiler et exécuter des instructions gcc file_name.c ; ./a.out

Comparer et Swap

   # Include 
  # Include 
 / / Change - newvalue, comperand est vieux / valeur attendue
 / *
  * Fonction ne fait la chose suivante - si la valeur au * dest est égale à oldValue puis le remplacer par autre newvalue laisser inchangé: faire toutes ces atomiquement
  *
  * Il ya deux options pour la valeur de retour
  * La valeur initiale de 1.is * dest et laisser le fardeau de la FXN appelant à le comparer avec oldval
  * 2.  le faire ici et retourner 0 ou 1, ce devrait être plus efficace
  ** /

 / * Plus tard, il se transformer en macro * /
 int CAS (int * dest, int oldValue, int newvalue) {
	 printf ("(% d,% d,% d)", * dest, oldValue, newvalue);
	 / * Int CAS (int dest, int oldValue, int newvalue) {* /
	 / * Int CAS (int dest, int newvalue, int oldValue) {* /
	 int résultat = 1 ;/ * 1 montre que les CA ont réussi et 0 montre qu'il a échoué * /
	 / * Btw besoin de mettre en cc pour le drapeau démolir!  * /
	 __ volatile__ __asm__ (
			 "Movl% 2,%% eax \ n \ t"
			 "Movl% 3,%% ebx \ n \ t"
			 "0% movl,%% ecx \ n \ t"
			 "LOCK \ n \ t"
			 "CMPXCHG% ebx%, (%% ecx) \ n \ t" / * doit se verrouiller être sur la même ligne * /
			 "Jz FAIT \ n \ t"
			 "Movl $ 0,% 1 \ n \ t"
			 "FAIT: \ n \ t"
			 : "= M" (dest), "= g" (résultat)
			 : "G" (oldValue), "g" (newvalue), "m" (dest)
			 : "% Eax", "% ebx", "ecx", "cc"
			 );
	 printf ("(% d,% d,% d)", * dest, oldValue, newvalue);
	 renvoyer le résultat;
 }

 / * TODO
  * Écrire un autre FXN asm qui met au-dessus FXN dans une boucle while et continuer à essayer si elle réussit * /

 int main () {
	 int a = 5, b = 6;
	 int * c = (int *) malloc (sizeof (int));
	 * C = 6;
	 / * Int c = 6; * /
	 printf ("% d \ n", CAS (c, b, b));
	 printf ("% d \ n", CAS (c, b, a));
	 printf ("% d \ n", CAS (c, a, a));
	 printf ("% d \ n", CAS (c, b, b));
	 * C = 6;
	 / C * = 5; * /
	 printf ("valeur changeante des * c à% d \ n", * c);
	 printf ("% d \ n", CAS (c, b, b));
	 printf ("% d \ n", CAS (c, b, a));
	 printf ("% d \ n", CAS (c, a, a));
	 printf ("% d \ n", CAS (c, a, b));
	 printf ("% d \ n", CAS (c, b, a));
	 retourner 0;
 }

Mise en forme des notes - apparaît comme la coloration syntaxique wp est l'ajout à la fin, l'ignorer.

GCD

 # Include 
 int pgcd (int a, int b) {
     int résultat;
     / * Calcul Plus Grand Commun Diviseur utilisant l'algorithme d'Euclide * /
     __ volatile__ __asm__ ("movl% 1,%% eax;"
                           "Movl% 2,%% ebx;"
                           "SUITE: CMPL 0 $,%% ebx;"
                           "Je FAIT;"
                           "Xorl%% edx,%% edx;"
                           "Idivl%% ebx;"
                           "Ebx movl%%,%% eax;"
                           "Movl%% edx,% ebx%;"
                           "Jmp suite;"
                           "FAIT: movl%% eax,% 0;": "= g" (résultat): "g" (a), "g" (b)
     );

     renvoyer le résultat;
 }

 int main () {
     int premier, deuxième;
     printf ("Entrez deux entiers:");
     scanf ("% d% d", & d'abord, et seconde);

     printf ("% d PGCD de &% d est% d \ n", premier, deuxième, pgcd (premier, deuxième));

     retourner 0;
 }