Un peu d'assemblage

29 août 2009 par Prashant ·

Commentaires
Filed under: la technologie

Après la lecture de cet article sur tampons verrouiller gratuitement et en voyant l'utilisation de la CAS (comparaison et d'échange), je me sentais comme affichant le code assembleur à faire de même. Cas d'utilisation plus il y avait à écrire une méthode native et l'appeler à partir de Java (retour en 1.5, où les structures de données simultanés en Java ont été plus ou moins inexistante). Sans plus tarder, je vais libérer le code sur votre . La première est pour CAS et la deuxième est pour le calcul de PGCD en utilisant l'algorithme d'Euclide (celui-ci peut être trouvé dans de nombreux endroits et des tutoriels ainsi).

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

Comparez et Swap

   # Include 
  # Include 
 / / Change - nouvelle_valeur, comperand est vieux / valeur attendue
 / *
  * Fonction ne fait la chose suivante - si la valeur au * dest est égal à oldValue, puis le remplacer par newValue ailleurs laisser inchangé: faire toutes ces atomiquement
  *
  * Il existe deux options pour la valeur de retour
  * 1.is valeur initiale de * dest et laisser la charge d'appeler FXN de le comparer avec oldval
  * 2.  faire par 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 result = 1; / * 1 montre que les CA ont réussi et 0 montre qu'il a échoué * /
	 / * Btw nécessité de mettre en cc pour le drapeau démolir!  * /
	 __asm__ __volatile__ (
			 "Movl% 2,%% eax \ n \ t"
			 "Movl% 3,%% ebx \ n \ t"
			 "0 movl%,%% ecx \ n \ t"
			 "LOCK \ n \ t"
			 "CMPXCHG% ebx% (%% ecx) \ n \ t" / * devrait être VERROUILLAGE 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" (nouvelle_valeur), «m» (DEST)
			 : "% Eax", "% ebx", "ecx", "cc"
			 );
	 printf ("% (d,% d,% d)", * dest, oldValue, newValue);
	 retour 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 de change * 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));
	 return 0;
 }

Formatage 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 result;
     / * Calcule plus grand commun diviseur en utilisant l'algorithme d'Euclide * /
     __asm__ __volatile__ ("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)
     );

     retour 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));

     return 0;
 }