Um pouco de montagem

29 de agosto de 2009 por Prashant
Arquivado em: tecnologia

Depois de ler este artigo sobre buffers Lock Free e vendo o uso de CAS (comparar e trocar), me senti como postar o código assembly para fazer o mesmo. Use caso ali era escrever um método nativo e chamá-lo de Java (de volta em 1,5, quando as estruturas de dados concorrentes em Java eram mais ou menos não existe). Sem mais delongas, eu vou liberar o código para você . O primeiro é para a CAS ea segunda é para a computação GCD usando o algoritmo de Euclides (este pode ser encontrado em muitos lugares e tutoriais bem).

Compilar e executar instruções gcc file_name.c ; ./a.out

Compare e Swap

   # Include 
  # Include 
 / / Troca - newvalue, comperand é velho / valor esperado
 / *
  * Função realmente faz a coisa seguinte - se o valor no * dest é igual a OldValue, em seguida, substituí-lo por newvalue mais deixá-lo inalterado: não tudo isso atomicamente
  *
  * Há duas opções para o valor de retorno
  * O valor inicial de 1.is * dest e deixam o ônus da fxn chamando a compará-lo com oldval
  * 2.  fazê-lo por aqui e retornar 0 ou 1, esta deve ser mais eficiente
  ** /

 / * Depois transformá-lo em macro * /
 cas int (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 resultado = 1 ;/ * 1 mostra que cas conseguiram e 0 mostra que ele falhou * /
	 / * Btw precisa definir cc para sobrepor bandeira!  * /
	 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" / * deve bloquear ser na mesma linha * /
			 "Jz FEITO \ n \ t"
			 "Movl $ 0,% 1 \ n \ t"
			 "FEITO: \ n \ t"
			 : "= M" (dest), "= g" (resultado)
			 : "G" (OldValue), "g" (newvalue), "m" (dest)
			 : "% Eax", "% ebx", "ecx", "cc"
			 );
	 printf ("(% d,% d,% d)", * dest, OldValue, newvalue);
	 resultado de retorno;
 }

 / * TODO
  * Escrever outro fxn asm que coloca acima fxn em um loop while e continuar tentando, a menos que ele consegue * /

 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 ("valor de troca de c * a% 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));
	 retornar 0;
 }

Notas de formatação - parece marcação de sintaxe wp está adicionando no final, ignorar isso.

GCD

 # Include 
 int mdc (int a, int b) {
     int resultado;
     / * Compute Máximo divisor comum usando o algoritmo de Euclides * /
     volatile__ __asm__ __ ("movl% 1,%% eax;"
                           "Movl% 2,%% ebx;"
                           "Cont.: cmpl $ 0,%% ebx;"
                           "Je FEITO";
                           "Xorl%% edx,% edx%;"
                           "Idivl%% ebx;"
                           "Ebx movl%%%% eax;"
                           "Movl% edx%, ebx%%";
                           "Jmp cont.;"
                           "FEITO: movl% eax%, 0%;": "= g" (resultado): "g" (a), "g" (b)
     );

     resultado de retorno;
 }

 int main () {
     int primeiro, segundo;
     printf ("Entre com dois inteiros:");
     scanf ("% d% d", e em primeiro lugar, e segundo);

     printf ("GCD de% d &% d é% d \ n", primeiro, segundo, mdc (primeiro, segundo));

     retornar 0;
 }