🚀 go-pugleaf

Andrzej Grażyński pisze:
> 
> ale można efektywniej: bez odwoływania się do pamięci i bez skoku. Jak?
mam w 7 liniach, ale efektywniej niż ze skokiem to chyba nie jest - 
skoki są tanie

-- 
Pozdrawiam
Michoo

Michoo pisze:
> Andrzej Grażyński pisze:
>>
>> ale można efektywniej: bez odwoływania się do pamięci i bez skoku. Jak?
> mam w 7 liniach, ale efektywniej niż ze skokiem to chyba nie jest - 
> skoki są tanie
> 




and al,$0f
add al,$90
daa
adc al,$40
daa




A propos:

Skoki NIE są tanie, i wielu uczestników tego forum może znakomicie 
wyjaśnić, dlaczego.

On 08-05-2010 16:21, Andrzej Grażyński wrote:
> Michoo pisze:
>> Andrzej Grażyński pisze:
>>>
>>> ale można efektywniej: bez odwoływania się do pamięci i bez skoku. Jak?
>> mam w 7 liniach, ale efektywniej niż ze skokiem to chyba nie jest -
>> skoki są tanie
>>
>
>
>
>
> and al,$0f
> add al,$90
> daa
> adc al,$40
> daa
>
>
>
>
> A propos:
>
> Skoki NIE są tanie, i wielu uczestników tego forum może znakomicie
> wyjaśnić, dlaczego.
Jestes pewien ?  Jednostki przewidywania skokow bywaja zaskakujaca 
efektywne. Czyszczenie pipelina przy kazdym skoku to historia.

Pozdr

Marek

Andrzej Grażyński pisze:
> and al,$0f
> add al,$90
> daa
> adc al,$40
> daa
Sprytne.
> 
> A propos:
> 
> Skoki NIE są tanie, i wielu uczestników tego forum może znakomicie 
> wyjaśnić, dlaczego.
W porównaniu z moją wersją (swoją drogą jak właśnie zauważyłem błędną: 
'A'-'9' = 8 a nie 9) nie widać różnicy.

         "andb $0x0f,%%al;\n"
         "cmp $10,%%al;\n"
         "jl skip;\n"
         "add $7,%%al;\n"
         "skip: add $48,%%al;\n"

W porównaniu z Twoim kodem na Core2Duo i na Xeonie:
rozkład równomierny - twój kod ~25% szybszy
przedział 0-8 - mój kod szybszy o ~5%
przedział 9-15 - mój kod szybszy o ~5%

W porównaniu z Twoim kodem na AMD Geode:
rozkład równomierny - mój kod ~8% szybszy
przedział 0-8 - mój kod szybszy o ~10%
przedział 9-15 - mój kod szybszy o ~3%


Liczony był czas pracy, więc z jednej strony 25% to strasznie dużo 
biorąc pod uwagę, że czas wykonania uwzględniał call, z drugiej strony 
jest to odpowiednik doklejenia "mov %%eax,%%ebx;mov %%ebx,%%eax" w Twoim 
kodzie - czy to jest drogo pozostawiam do oceny własnej.


Testowane w pętli:
         for(int i=0;i<1000000;i++)
                 for(int j=0;j<255;j++)
                         con2(j);
char con2(uint8_t in)
{
         char c;
__asm__ (
         "movb %0,%%al;\n"
//tutaj kod
         "movb %%al,%1;\n"
         :"=r"(c)
         :"r"(in)
         :"%eax"
         );
         return c;
}

-- 
Pozdrawiam
Michoo

Andrzej Grażyński <grazynsk@petex.com.pl> wrote:

> Do rejestru AL wpisać znak odpowiadający szesnastkowej wartości czterech 
> najmniej znaczących bitów.
> 
> Można to zrobić na przykład tak
> 
> AND AL,$0F
> LEA EBX,HEXTABLE
> XLAT
> 
> ale można efektywniej: bez odwoływania się do pamięci i bez skoku. Jak?

-- hex.c --
// kompilacja: gcc hex.c
#include <stdio.h>

int to_hex(int x) {
	int result;
	asm (
		"andl $0x0f, %%eax			\n"
		"leal -10(%%eax), %%ebx			\n"
		"shrl $29, %%ebx			\n"
		"neg  %%ebx				\n"	// ebx = (eax < 10) ? -7 : 0
		"leal 55(%%eax, %%ebx), %%eax		\n"
		: "=a" (result)
		: "a" (x)
		: "ebx"
	);

	return result;
}

int to_hex2(int x) {
	int result;
	asm (
		"andl $0x0f, %%eax			\n"
		"leal (0x7fffffff-9)(%%eax), %%ebx	\n"	// MSB(ebx)=1 gdy eax >= 10
		"sarl $31, %%ebx			\n"
//		"andl  $7, %%ebx			\n"	// dla dużych liter (A-F)
		"andl $39, %%ebx			\n"	// dla małych liter (a-f)
		"leal '0'(%%eax, %%ebx), %%eax		\n"
		: "=a" (result)
		: "a" (x)
		: "ebx"
	);

	return result;
}

int main() {
	int i;
	for (i=0; i <= 15; i++)
		printf("%d => %d ('%c')\n", i, to_hex(i), to_hex(i));
	
	puts("");
	for (i=0; i <= 15; i++)
		printf("%d => %d ('%c')\n", i, to_hex2(i), to_hex2(i));
	
	return 0;
}
-- eof --

Wersja 2. jest ładniejsza i przede wszystkim bardziej elastyczna niż nr 1.

w.

Wojciech Muła pisze:
> Andrzej Grażyński <grazynsk@petex.com.pl> wrote:
> 
>> Do rejestru AL wpisać znak odpowiadający szesnastkowej wartości czterech 
>> najmniej znaczących bitów.
>>
>> Można to zrobić na przykład tak
>>
>> AND AL,$0F
>> LEA EBX,HEXTABLE
>> XLAT
>>
>> ale można efektywniej: bez odwoływania się do pamięci i bez skoku. Jak?
> 
> -- hex.c --
> // kompilacja: gcc hex.c
> #include <stdio.h>
> 
> int to_hex(int x) {
> 	int result;
> 	asm (
> 		"andl $0x0f, %%eax			\n"
> 		"leal -10(%%eax), %%ebx			\n"
> 		"shrl $29, %%ebx			\n"
> 		"neg  %%ebx				\n"	// ebx = (eax < 10) ? -7 : 0
> 		"leal 55(%%eax, %%ebx), %%eax		\n"
> 		: "=a" (result)
> 		: "a" (x)
> 		: "ebx"
> 	);
> 
> 	return result;
> }
> 
> int to_hex2(int x) {
> 	int result;
> 	asm (
> 		"andl $0x0f, %%eax			\n"
> 		"leal (0x7fffffff-9)(%%eax), %%ebx	\n"	// MSB(ebx)=1 gdy eax >= 10
> 		"sarl $31, %%ebx			\n"
> //		"andl  $7, %%ebx			\n"	// dla dużych liter (A-F)
> 		"andl $39, %%ebx			\n"	// dla małych liter (a-f)
> 		"leal '0'(%%eax, %%ebx), %%eax		\n"
> 		: "=a" (result)
> 		: "a" (x)
> 		: "ebx"
> 	);
> 
> 	return result;
> }
> 
> int main() {
> 	int i;
> 	for (i=0; i <= 15; i++)
> 		printf("%d => %d ('%c')\n", i, to_hex(i), to_hex(i));
> 	
> 	puts("");
> 	for (i=0; i <= 15; i++)
> 		printf("%d => %d ('%c')\n", i, to_hex2(i), to_hex2(i));
> 	
> 	return 0;
> }
> -- eof --
> 
> Wersja 2. jest ładniejsza 

Kwestia gustu (jeżeli cokolwiek w C może być ładne, wszak to język 
ludożerców)


> i przede wszystkim bardziej elastyczna 

A na czym ma polegać ta "elastyczność"?









niż nr 1.
> 
> w.

Andrzej Grażyński <grazynsk@petex.com.pl> wrote:

> > Wersja 2. jest ładniejsza 
> 
> Kwestia gustu (jeżeli cokolwiek w C może być ładne, wszak to język 
> ludożerców)

Mam na myśli kod asemblerowy. :)

> > i przede wszystkim bardziej elastyczna 
> 
> A na czym ma polegać ta "elastyczność"?

Łatwo uzyskać małe lub duże literki.

w.

takie zagadki to się rozwiązywało w przedszkolu, powiedz mi lepiej na ile 
ustawiona jest prekompensacja w stacjach dyskietek 5,25" i 3,5" w PC? 

identifikator: 20040501 pisze:
> takie zagadki to się rozwiązywało w przedszkolu, powiedz mi lepiej na 
> ile ustawiona jest prekompensacja w stacjach dyskietek 5,25" i 3,5" w PC?

Dyskietki magnetyczne widziałem ostatnio w Carrefour. Pudełko (10*1,44M 
= 14,4 M) droższe od płyty DVD-RW.

Mam w domu 6 kompów i żaden nie ma stacji floppów.

On 2010-05-08 16:56, Marek Borowski wrote:
> Jestes pewien ? Jednostki przewidywania skokow bywaja zaskakujaca
> efektywne. Czyszczenie pipelina przy kazdym skoku to historia.

Pokaż mi układ przewidywania, który przewidzi skok zależny od wartości 
danych w tym konkretnym przypadku.

Koszt źle przewidzianego skoku to we współczesnych wielopotokowych 
procesorach utrata czasu wykonania kilkudziesięciu instrukcji procesora.

On 2010-05-08 16:21, Andrzej Grażyński wrote:
> and al,$0f
> add al,$90
> daa
> adc al,$40
> daa

Też to wysłałem, ale mój post zniknął w tajemniczych okolicznościch.
Wobec tego podbijam stawkę - zagadka w wersji utrudnionej:
To samo, ale bez użycia instrukcji korekcji BCD, tak, żeby działało np. 
w trybie 64-bitowym. Cztery instrukcje nie licząc and z przodu oczywiście.

On 2010-05-11 12:13, Bernard wrote:
> On 2010-05-08 16:56, Marek Borowski wrote:
>> Jestes pewien ? Jednostki przewidywania skokow bywaja zaskakujaca
>> efektywne. Czyszczenie pipelina przy kazdym skoku to historia.
>
> Pokaż mi układ przewidywania, który przewidzi skok zależny od wartości
> danych w tym konkretnym przypadku.
>
Prefech dla obu przypadkow. (W skali calego procesora troche sie traci 
bo procesor wykonuje bezuzytecna prace).

> Koszt źle przewidzianego skoku to we współczesnych wielopotokowych
> procesorach utrata czasu wykonania kilkudziesięciu instrukcji procesora.
Co jest niczym w stosunku do nietrafienia w strone pamieci. Milion cykli 
moze byc niedoszacowaniem jesli trzeba ja sciagnosc ze swapa.
Przelaczenia kontekstu, (w tym obsluga przerwan) sa tez duzo bardziej 
kosztowne niz bledny skok.

Kiedys tez uczono aby nie uzywac tego samego rejestru w kolejnych 
instrukcjach - przezytek od czasu pojawienia sie register renaming.


Pozdr

Marek