jakis rok czy pol roku temu trzasnalem kawalek kodu elementarnego
raytracera

https://dl.dropbox.com/u/42887985/re29.zip

bylo to pisane ledwie dwa dni (chyba nawet niecale) i bylem zadowolony ze
dobrze poszlo, ale kod jest rozbabrany i nie optymalizowany, ew teraz bym
chcial pokombinowac czy da sie to przyoptymalizowac - najchetniej przepisac
kluczowe kawalki na asma (sse2 bo mam tymczasowo wiekowa maszyne z p4),

moze nie bede wklejac calek procedury bo jest rozbabrana ale opisze
kluczowe kawalki, i ew ktos moglby najlepiej udzielic mi jakichs
cennych uwag (najlepiej jak by to moglo wygladac konkretnie w asmie)
- mozna by wtedy porozmawiac o optymalizacji a sa to ciekawe topiki

jak to leci - mam cztery kulki i jedna plaszczyzne,
dl akazdego punktu okna wyznaczam odleglosc do kazdej z kulek i
plaszczyzny


float distSphere01 = intersectRaySphere(&ray0,&rayV,&sphere01,15);
float distSphere02 = intersectRaySphere(&ray0,&rayV,&sphere02,15);
float distSphere03 = intersectRaySphere(&ray0,&rayV,&sphere03,15);

float distSphere1 = intersectRaySphere(&ray0,&rayV,&sphere1,100);
float distSphere2 = -1;// intersectRaySphere
(&ray0,&rayV,&sphere2,1500);

float distPlane = intersectionRayPlane(&ray0, &rayV, &vPlane,
&planeNormal);




inline float intersectionRayPlane(float3* rayOrigin,
float3* rayDirection,
float3* planeOrigin,
float3* planeNormal)
{
static float3 D;

D = sub(planeOrigin, rayOrigin);

float a = dot(&D, planeNormal);
float b = dot(rayDirection, planeNormal);

if(b!=0)
{
return a/b;
}
else
{
return -1;
}

}

inline float intersectRaySphere(float3* rO, float3* rV, float3* sO, float sR)
{
static float3 Q;

Q = sub(sO,rO);
float c = length(&Q);
float v = dot(&Q,rV);
float d = sR*sR - (c*c - v*v);

// If there was no intersection, return -1
if (d < 0.0) return (-1.0f);

// Return the distance to the [first] intersecting point
return (v - sqrt(d));
}

pozniej znajduje najblizsza z tych odleglosci licze normalna i
w zaleznosci od iloczynu sklarnego zapalam punkt - ta druga czesc mozna
by na razie pominac - pytanie jak przyoptymalizowac to co powyzej -
ktos ma jakies konkretne rozwiazania, ?? moge przetestowac i zobacze
czy bedzie speed up - sam tez moze pokombinuje ale sensowne merytoryczne
uwagi mile widziane









--
Wysłano z serwisu Usenet w portalu Gazeta.pl -> http://www.gazeta.pl/usenet/

do góry

przegladam np asma generowanego przez borlanda i mam tam cos takiego

; intersectionPoint = add(ray0, scalarMul(distPlane, rayV));
;
mov ecx,dword ptr [esp+296]
mov dword ptr [esp+488],ecx
mov ecx,dword ptr [esp+300]
mov dword ptr [esp+492],ecx
mov ecx,dword ptr [esp+304]
mov dword ptr [esp+496],ecx
mov eax,dword ptr [esp+88]
mov dword ptr [esp+112],eax
fld dword ptr [esp+488]
fmul dword ptr [esp+112]
fstp dword ptr [esp+500]
fld dword ptr [esp+492]
fmul dword ptr [esp+112]
fstp dword ptr [esp+504]
fld dword ptr [esp+496]
fmul dword ptr [esp+112]
fstp dword ptr [esp+508]
mov edx,dword ptr [esp+500]
mov dword ptr [esp+512],edx
mov edx,dword ptr [esp+504]
mov dword ptr [esp+516],edx
mov edx,dword ptr [esp+508]
mov dword ptr [esp+520],edx
mov ecx,dword ptr [esp+284]
mov dword ptr [esp+524],ecx
mov ecx,dword ptr [esp+288]
mov dword ptr [esp+528],ecx
mov ecx,dword ptr [esp+292]
mov dword ptr [esp+532],ecx
fld dword ptr [esp+524]
fadd dword ptr [esp+512]
fstp dword ptr [esp+536]
fld dword ptr [esp+528]
fadd dword ptr [esp+516]
fstp dword ptr [esp+540]
fld dword ptr [esp+532]
fadd dword ptr [esp+520]
fstp dword ptr [esp+544]
mov eax,dword ptr [esp+536]
mov dword ptr [esp+428],eax
mov eax,dword ptr [esp+540]
mov dword ptr [esp+432],eax
mov eax,dword ptr [esp+544]
mov dword ptr [esp+436],eax

nie rozumiem blokow tych movow - skad to sie wzielo i co to jest, ?
normalnie to wydawaloby sie ze wystarczylo by chyba cos takiego

fld dword ptr [rayV.x]
fmul dword ptr [dist]
fstp dword ptr [m.x]
fld dword ptr [rayV.y]
fmul dword ptr [dist]
fstp dword ptr [m.y]
fld dword ptr [rayV.z]
fmul dword ptr [dist]
fstp dword ptr [m.z]

fld dword ptr [m.x]
fadd dword ptr [ray0.x]
fstp dword ptr [out.x]
fld dword ptr [m.y]
fadd dword ptr [ray0.y]
fstp dword ptr [out.y]
fld dword ptr [m.z]
fadd dword ptr [ray0.z]
fstp dword ptr [out.z]

albo jeszcze mniej :O jek wytlumaczyc te masywne bloki mov'ow ?



--
Wysłano z serwisu Usenet w portalu Gazeta.pl -> http://www.gazeta.pl/usenet/

do góry

fir <f...@W...gazeta.pl> napisał(a):

> mov eax,dword ptr [esp+536]
> mov dword ptr [esp+428],eax
> mov eax,dword ptr [esp+540]
> mov dword ptr [esp+432],eax
> mov eax,dword ptr [esp+544]
> mov dword ptr [esp+436],eax
>
> albo jeszcze mniej :O jek wytlumaczyc te masywne bloki mov'ow ?
Chyba: kopiowanie 12 bajtów spod adresu esp+536 do adresu esp+428 za
pośrednictwem młodszej cztero-bajtowej części rejestru EAX; 3 razy
po 4 bajty. Dlaczego kompilator nie wyrównał do 8 bajtów i nie dał
dwa razy na pełnym rejestrze eax to nie wiem.
Pozdrawiam


--
Wysłano z serwisu Usenet w portalu Gazeta.pl -> http://www.gazeta.pl/usenet/

do góry

W dniu 2012-08-01 22:11, M.M. pisze:
> fir <f...@W...gazeta.pl> napisał(a):
>
>> mov eax,dword ptr [esp+536]
>> mov dword ptr [esp+428],eax
>> mov eax,dword ptr [esp+540]
>> mov dword ptr [esp+432],eax
>> mov eax,dword ptr [esp+544]
>> mov dword ptr [esp+436],eax
>>
>> albo jeszcze mniej :O jek wytlumaczyc te masywne bloki mov'ow ?
> Chyba: kopiowanie 12 bajtów spod adresu esp+536 do adresu esp+428 za
> pośrednictwem młodszej cztero-bajtowej części rejestru EAX; 3 razy
> po 4 bajty. Dlaczego kompilator nie wyrównał do 8 bajtów i nie dał
> dwa razy na pełnym rejestrze eax to nie wiem.
> Pozdrawiam
>
>
Bo EAX to rejestr 32-bitowy (w przeciwieństwie do RAX).

do góry

M.M. <m...@W...gazeta.pl> napisał(a):

> fir <f...@W...gazeta.pl> napisał(a):
>
> > mov eax,dword ptr [esp+536]
> > mov dword ptr [esp+428],eax
> > mov eax,dword ptr [esp+540]
> > mov dword ptr [esp+432],eax
> > mov eax,dword ptr [esp+544]
> > mov dword ptr [esp+436],eax
> >
> > albo jeszcze mniej :O jek wytlumaczyc te masywne bloki mov'ow ?
> Chyba: kopiowanie 12 bajtów spod adresu esp+536 do adresu esp+428 za
> pośrednictwem młodszej cztero-bajtowej części rejestru EAX; 3 razy
> po 4 bajty. Dlaczego kompilator nie wyrównał do 8 bajtów i nie dał
> dwa razy na pełnym rejestrze eax to nie wiem.

eax to 4 bajty - rax to 8 ale ja mam 32 bitowego kompa;
wiem ze to kopiowania tylko pytanie dlaczego to ma miejsce bo
raczej nie jest potrzebne, widac ze jakosci tego generowanego kodu
daleko do optymalnej, a trzasnac takie procedurki dla fpu z reki
reczej nie jest tak trudno (kiedys pisalem ale wiele lat temu)
(choc wiadomo, ze ew trzeba moze bedzie debugowac itp jak trafia sie
bledy a kompilator przy generowaniu asma nieoptymalizuje ale tez i
beldow nie wtrynia)








--
Wysłano z serwisu Usenet w portalu Gazeta.pl -> http://www.gazeta.pl/usenet/

do góry

M.B. <c...@n...wp.pl> napisał(a):

> W dniu 2012-08-01 22:11, M.M. pisze:
> > fir <f...@W...gazeta.pl> napisał(a):
> >
> >> mov eax,dword ptr [esp+536]
> >> mov dword ptr [esp+428],eax
> >> mov eax,dword ptr [esp+540]
> >> mov dword ptr [esp+432],eax
> >> mov eax,dword ptr [esp+544]
> >> mov dword ptr [esp+436],eax
> >>
> >> albo jeszcze mniej :O jek wytlumaczyc te masywne bloki mov'ow ?
> > Chyba: kopiowanie 12 bajtów spod adresu esp+536 do adresu esp+428 za
> > pośrednictwem młodszej cztero-bajtowej części rejestru EAX; 3 razy
> > po 4 bajty. Dlaczego kompilator nie wyrównał do 8 bajtów i nie dał
> > dwa razy na pełnym rejestrze eax to nie wiem.
> > Pozdrawiam
> >
> >
> Bo EAX to rejestr 32-bitowy (w przeciwieństwie do RAX).
Racja, widocznie dawno nie programowałem w asemblerze :)
Pozdrawiam



--
Wysłano z serwisu Usenet w portalu Gazeta.pl -> http://www.gazeta.pl/usenet/

do góry

Użytkownik " fir" <f...@W...gazeta.pl> napisał:

> jek wytlumaczyc te masywne bloki mov'ow ?

Firze.
Wiedziony umiejetnoscia prekognicji zadalem Ci drzewiej zadanie
tyczace optymalizacji ramy wywolania procedury C .
Jak zwykle "olales" to zadanie, a gdybys podszedl do tego powaznie
jak profesjonalista (a nie jak rozkapryszony dzieciak i zwykly dres)
to nie zadawalbys teraz w/w glupiego pytania.

Ktos kto dzis uzywa BCC32 do "kodzienia" w (Twoim) zalozeniu majacego
byc wysoce optymalnym (w sensie optymalnosci kodu assemblerowego)
jest totanym palantem, dresem i betonem.
Wiadomo albowiem od zawsze (15 lat min.) ze kompilatory Borlanda w tym
zakresie _zatrzymaly sie kompletnie w rozwoju_.
Oczywiscie mozna im znacznie pomoc (stad moje 'prekognicyjne' zadanie dla Ciebie),
i o dziwo mozna to zrobic jeszcze w C. No ale widze, ze i w tym jezyku jestes jeszcze
dresem i newbie, wiec moze udaj sie ze swoimi pytaniami na pl.comp.lang.c
Tam wiecej takich jak Ty, wiec bedziecie mogli sobie spokojnie rozwazac "dobroc"
generatora kodu i optymalizatora warstwy bajtkodu kochanego Borlanda.

O wiele lepszy (dzis, bo dawniej - poczatek lat 90tych - bylo dokladnie
odwrotnie) pod tym wzgledem jest VC/VC++, a najlepszym IMHO
pod tym wzgledem kompilatorem byl nieodzalowany (dla mnie:)
MicroWay C/C++, ale tez inny TopSpeed C/C++ czy chocby Watcom C/C++
(na Watcoma uwaga, chyba zatrzymal sie na 32 but i dalej uze niczewo nie budiet).

PS: Szanowny Firze. Kiedys (lata 90te) bedac na bezrobociu i chcac podciagnac
swoj angielski udalem sie do Urzedu Pracy w Rzeszowie w celu uzysania mniejsca
w darmowym kursie j.ang. Jakiez bylo moje "zdziwienie" gdy okazalo sie iz
nauka angielskiego mi nie przysluguje gdyz.. "nie podnosi ona mych kwalifikacji
zawodowych" jako programisty (po prostu nie figuruje w odpowiedniej tabelce
z Ministerstwa Pracy).
Spytalem wiec jakie kursy ew. podnosza te umiejetnosci/kwalifikacje zawodowe.
Okazalo sie, ze np. toczenie w drewnie tudziez umiejetnosc zbrojenia konstrukcji
betonowych. Ja zrezygnowalem z w/w i do dzisiaj zaluje :) Proponuje Ci firze
na powaznie rozwazyc wyzej zasugerowane przekwalifikowanie
(proponuje raczej toczenie w drewnie) bo jako programista C/ASM z takimi
brakami wiedzy i doswiadczenia i tak skonczysz jako zbrojarz na jakiejs
budowie w Niemczech :(

AK

do góry

fir <f...@W...gazeta.pl> napisał(a):

> przegladam np asma generowanego przez borlanda i mam tam cos takiego
>
> ; intersectionPoint = add(ray0, scalarMul(distPlane, rayV));
> ;
> mov ecx,dword ptr [esp+296]
> mov dword ptr [esp+488],ecx
> mov ecx,dword ptr [esp+300]
> mov dword ptr [esp+492],ecx
> mov ecx,dword ptr [esp+304]
> mov dword ptr [esp+496],ecx
> mov eax,dword ptr [esp+88]
> mov dword ptr [esp+112],eax
> fld dword ptr [esp+488]
> fmul dword ptr [esp+112]
> fstp dword ptr [esp+500]
> fld dword ptr [esp+492]
> fmul dword ptr [esp+112]
> fstp dword ptr [esp+504]
> fld dword ptr [esp+496]
> fmul dword ptr [esp+112]
> fstp dword ptr [esp+508]
> mov edx,dword ptr [esp+500]
> mov dword ptr [esp+512],edx
> mov edx,dword ptr [esp+504]
> mov dword ptr [esp+516],edx
> mov edx,dword ptr [esp+508]
> mov dword ptr [esp+520],edx
> mov ecx,dword ptr [esp+284]
> mov dword ptr [esp+524],ecx
> mov ecx,dword ptr [esp+288]
> mov dword ptr [esp+528],ecx
> mov ecx,dword ptr [esp+292]
> mov dword ptr [esp+532],ecx
> fld dword ptr [esp+524]
> fadd dword ptr [esp+512]
> fstp dword ptr [esp+536]
> fld dword ptr [esp+528]
> fadd dword ptr [esp+516]
> fstp dword ptr [esp+540]
> fld dword ptr [esp+532]
> fadd dword ptr [esp+520]
> fstp dword ptr [esp+544]
> mov eax,dword ptr [esp+536]
> mov dword ptr [esp+428],eax
> mov eax,dword ptr [esp+540]
> mov dword ptr [esp+432],eax
> mov eax,dword ptr [esp+544]
> mov dword ptr [esp+436],eax
>
> nie rozumiem blokow tych movow - skad to sie wzielo i co to jest, ?
> normalnie to wydawaloby sie ze wystarczylo by chyba cos takiego
>
> fld dword ptr [rayV.x]
> fmul dword ptr [dist]
> fstp dword ptr [m.x]
> fld dword ptr [rayV.y]
> fmul dword ptr [dist]
> fstp dword ptr [m.y]
> fld dword ptr [rayV.z]
> fmul dword ptr [dist]
> fstp dword ptr [m.z]
>
> fld dword ptr [m.x]
> fadd dword ptr [ray0.x]
> fstp dword ptr [out.x]
> fld dword ptr [m.y]
> fadd dword ptr [ray0.y]
> fstp dword ptr [out.y]
> fld dword ptr [m.z]
> fadd dword ptr [ray0.z]
> fstp dword ptr [out.z]
>
> albo jeszcze mniej :O jek wytlumaczyc te masywne bloki mov'ow ?
>
>
to chyba dlatego, ze genrator faktycznie rozwija funkcje inline ale
nie klopocze sie by scalic output jednej do inputu drugiej tylko
robi na odzielnych i w srodku kopiuje ;-)

ale pozatym generuje w miare poprawny chyba kod np dla

inline float intersectRaySphere(float3* rO, float3* rV, float3* sO, float sR)
{
static float3 Q;

Q = sub(sO,rO);
float c = length(&Q);
float v = dot(&Q,rV);
float d = sR*sR - (c*c - v*v);

// If there was no intersection, return -1
if (d < 0.0) return (-1.0f);

// Return the distance to the [first] intersecting point
return (v - sqrt(d));
}


_TEXT segment dword public use32 'CODE'
@intersectRaySphere$qp6float3t1t1f segment virtual
align 2
@@intersectRaySphere$qp6float3t1t1f proc near
?live16492@0:
@1533:
push ebp
mov ebp,esp
add esp,-24
push ebx
push esi
push edi
?live16492@16: ; EDI = rV
add esp,-8
mov esi,dword ptr [ebp+16]
mov ebx,dword ptr [ebp+8]
?live16492@48: ;
mov edi,dword ptr [ebp+12]
?live16492@64: ; EDI = rV
fld dword ptr [esi]
fsub dword ptr [ebx]
fstp dword ptr [ebp-24]
fld dword ptr [esi+4]
fsub dword ptr [ebx+4]
fstp dword ptr [ebp-20]
fld dword ptr [esi+8]
fsub dword ptr [ebx+8]
fstp dword ptr [ebp-16]
mov eax,dword ptr [ebp-24]
mov dword ptr [$afdngfia],eax
mov eax,dword ptr [ebp-20]
mov dword ptr [$afdngfia+4],eax
mov eax,dword ptr [ebp-16]
mov dword ptr [$afdngfia+8],eax
fld dword ptr [$afdngfia]
fmul dword ptr [$afdngfia]
fld dword ptr [$afdngfia+4]
fmul dword ptr [$afdngfia+4]
faddp st(1),st
fld dword ptr [$afdngfia+8]
fmul dword ptr [$afdngfia+8]
faddp st(1),st
fstp qword ptr [esp]
call @_sqrt
fstp dword ptr [ebp-4]
fld dword ptr [$afdngfia]
fmul dword ptr [edi]
add esp,8
fld dword ptr [$afdngfia+4]
fmul dword ptr [edi+4]
faddp st(1),st
fld dword ptr [$afdngfia+8]
fmul dword ptr [edi+8]
faddp st(1),st
fstp dword ptr [ebp-8]
?live16492@144: ;
fld dword ptr [ebp-4]
fmul dword ptr [ebp-4]
fld dword ptr [ebp-8]
fmul dword ptr [ebp-8]
fsubp st(1),st
fld dword ptr [ebp+20]
fmul dword ptr [ebp+20]
fsubrp st(1),st
fstp dword ptr [ebp-12]
fld dword ptr [ebp-12]
fcomp dword ptr [@1535]
fnstsw ax
sahf
jae short @1534
fld dword ptr [@1535+4]
jmp short @1536
@1534:
add esp,-8
fld dword ptr [ebp-12]
fstp qword ptr [esp]
call @_sqrt
fsubr dword ptr [ebp-8]
add esp,8
@1537:
@1536:
pop edi
pop esi
pop ebx
mov esp,ebp
pop ebp
ret
align 4
@1535:
db 0,0,0,0,0,0,128,191
@@intersectRaySphere$qp6float3t1t1f endp
@intersectRaySphere$qp6float3t1t1f ends


chyba nawet troche przyoptymalizowal uzywajac ebx esi i edi
zamiast odwolan do ramu,

z reki pewnie moglbym sie starac wlasnie powywalac ile sie da
odwolan do ramu na rzecz rejestrow i stacka fpu - ale musialbym
troche teraz doczytac o pisaniu asma na fpu, bo pozapominalem, nie
kojarze np jakich rejestrow mozna uzyc zamiast odwolan do ramu -







--
Wysłano z serwisu Usenet w portalu Gazeta.pl -> http://www.gazeta.pl/usenet/

do góry

AK <n...@n...com> napisał(a):

> Użytkownik " fir" <f...@W...gazeta.pl> napisał:
>
> > jek wytlumaczyc te masywne bloki mov'ow ?
>
> Firze.
> Wiedziony umiejetnoscia prekognicji zadalem Ci drzewiej zadanie
> tyczace optymalizacji ramy wywolania procedury C .
> Jak zwykle "olales" to zadanie, a gdybys podszedl do tego powaznie
> jak profesjonalista (a nie jak rozkapryszony dzieciak i zwykly dres)
> to nie zadawalbys teraz w/w glupiego pytania.
>
> Ktos kto dzis uzywa BCC32 do "kodzienia" w (Twoim) zalozeniu majacego
> byc wysoce optymalnym (w sensie optymalnosci kodu assemblerowego)
> jest totanym palantem, dresem i betonem.
> Wiadomo albowiem od zawsze (15 lat min.) ze kompilatory Borlanda w tym
> zakresie _zatrzymaly sie kompletnie w rozwoju_.
> Oczywiscie mozna im znacznie pomoc (stad moje 'prekognicyjne' zadanie dla
Ciebi
> e),
> i o dziwo mozna to zrobic jeszcze w C. No ale widze, ze i w tym jezyku
jestes j
> eszcze
> dresem i newbie, wiec moze udaj sie ze swoimi pytaniami na pl.comp.lang.c
> Tam wiecej takich jak Ty, wiec bedziecie mogli sobie spokojnie rozwazac
"dobroc
> "
> generatora kodu i optymalizatora warstwy bajtkodu kochanego Borlanda.
>
> O wiele lepszy (dzis, bo dawniej - poczatek lat 90tych - bylo dokladnie
> odwrotnie) pod tym wzgledem jest VC/VC++, a najlepszym IMHO
> pod tym wzgledem kompilatorem byl nieodzalowany (dla mnie:)
> MicroWay C/C++, ale tez inny TopSpeed C/C++ czy chocby Watcom C/C++
> (na Watcoma uwaga, chyba zatrzymal sie na 32 but i dalej uze niczewo nie
budiet
> ).
>
> PS: Szanowny Firze. Kiedys (lata 90te) bedac na bezrobociu i chcac
podciagnac
> swoj angielski udalem sie do Urzedu Pracy w Rzeszowie w celu uzysania
mnie
> jsca
> w darmowym kursie j.ang. Jakiez bylo moje "zdziwienie" gdy okazalo sie
iz
> nauka angielskiego mi nie przysluguje gdyz.. "nie podnosi ona mych
kwalifi
> kacji
> zawodowych" jako programisty (po prostu nie figuruje w odpowiedniej
tabelc
> e
> z Ministerstwa Pracy).
> Spytalem wiec jakie kursy ew. podnosza te umiejetnosci/kwalifikacje
zawodow
> e.
> Okazalo sie, ze np. toczenie w drewnie tudziez umiejetnosc zbrojenia
konst
> rukcji
> betonowych. Ja zrezygnowalem z w/w i do dzisiaj zaluje :) Proponuje Ci
firz
> e
> na powaznie rozwazyc wyzej zasugerowane przekwalifikowanie
> (proponuje raczej toczenie w drewnie) bo jako programista C/ASM z takimi
> brakami wiedzy i doswiadczenia i tak skonczysz jako zbrojarz na jakiejs
> budowie w Niemczech :(
>
> AK
>

hehe, tn poziom glabienia mnie przygnebia i na pewno nie pogadamy
na takim poziomie ;) nie umiesz powiedzec nic nt (tematem jest

_optymalizacja procedury_

) to sorrki ;) smieszne ze mi sie zarzuca
smiecenie gdy spojrzcie na siebie tego typu przymulaste blablanie
_all the time_ i nic na temat (czasem sie odnosze bo nie lubie
przymulastego wrazenia (i te moje komentarze sa czy tez były somewhat
wymuszone owym zagłąbianiem wlasnie) - ale normalnie to interesuja
mnie topiki, poprawki c, optymalizacje, paradygmat strukturalny,
ogl) nie podoba ci sie ze lubie sprawdzic cos pod bcc32?: zbij zone,
skop psa, albo spij sie u cioci na imininach ale czemu do mnie takie
przymule teksty :/




napisze to wyrazniej

rozmowy typu

1. poprawki c, optymalizacje, paradygmat strukturalny, ogl

OK

2. nie moge wytrzymac i musze skopac psa, wstawie rozmowke typu
z czerwonym pyskiem po kielichu u cioci na imineianach (np o
monterach w niemczech)

SORRY

teraz spojrzcie ile pisze ja na temat 1 i o czym pisze co bardziej
przymulasta czesc tutejszych 'grupowiczow' (czesc z nich na 1 nie potrafi
powiedziec praktycznie nic, ( poza sugerowaniem ze jestem glupszy od
nich ;-) - co juz nalezy do 2)

Ostatnio odnosilem sie duzo do tego głabienia bo staralem sie dac odpór
tej głupocie - i uwazam ze nawet czesciowo mi sie to udalo, tj glupi nie
zmadrzeli nic a nic, ale przynajmniej zyskalem pewne jasnosc w
pewnych sprawach



--
Wysłano z serwisu Usenet w portalu Gazeta.pl -> http://www.gazeta.pl/usenet/

do góry

Dnia Thu, 2 Aug 2012 09:16:08 +0000 (UTC), f-i-r napisał(a):

>> Firze.
>> Wiedziony umiejetnoscia prekognicji zadalem Ci drzewiej zadanie
>> tyczace optymalizacji ramy wywolania procedury C .
>> Jak zwykle "olales" to zadanie, a gdybys podszedl do tego powaznie
>> jak profesjonalista (a nie jak rozkapryszony dzieciak i zwykly dres)
>> to nie zadawalbys teraz w/w glupiego pytania.
>
> hehe, tn poziom glabienia mnie przygnebia i na pewno nie pogadamy
> na takim poziomie ;) nie umiesz powiedzec nic nt (tematem jest
>
> _optymalizacja procedury_
>
> ) to sorrki ;) smieszne ze mi sie zarzuca
> smiecenie gdy spojrzcie na siebie tego typu przymulaste blablanie

A zadales sobie przyglupie trud przeczytania tego co AK do Ciebie napisal?
Wystarczy tylko pierwszy akapit, powyzej Ci go zacytowalem.

Dasz rade to zrobic?
Potrafisz?
No?

Wytez swoj zmeczony "mysleniem" umysl i pokaz, ze stac Cie na to!


--
pozdro
R.e.m.e.K

do góry