Procesory 64-bitowe i korzyści Opcje

[Jabol]

Witam,
ostatnio czytałem (przeglądałem (IMG:http://forum.php.pl/style_emoticons/default/tongue.gif) ) dokumentacje Intela i wyczytałem, że główna róznica pomiędzy 64 a 32 bitowymi procesorami to to, że te pierwsze mają większy zakres dostępu do pamięci (wirtualnej i fizycznej). Słyszałem to też drogą ploteczkową. I teraz stąd moje pytanie: czy jest to naprawdę jedyna różnica? Warto w takim razie kupować takie procesory (dla mnie i tak już za późno...), jeżeli nie mam zamiaru w ciągu najbliższych pięciu lat mieć więcej jak 4GB pamięci (tym bardziej, że Linux potrafi więcej obsługiwać nawet przy 32-bitowych maszynach, nie wiem jak reszta)?

Pozdrawiam

[Turgon]

Jabol chodzi tutaj o błąd roku 2000 któregoś... W 32 bitowym systemie obecna data zmieni się nagle na datę 1970 roku... Bo przejdzie do liczby minusowej...

[dr_bonzo]

Ahaaa, i to dlatego takie procki wprowadzili, ciekawe, i czemu dopiero teraz a nie w 1999 kiedy by sie lepiej sprzedaly w zwiazku z Y2K?. A nie prosciej bylo uzyc 8bajtow do przechowywania daty tylko robic nowy procek?


Na powaznie: nie wiem, ponoc maja byc szybsze dla aplikacji pisanych specjalnie pod 64b w porownaniu z aplikacjiami 32b na maszynach 32b (no bo teoretycznie przetwarzaja 2x wiecej danych w rozkazie)

[Jabol]

Na powaznie: nie wiem, ponoc maja byc szybsze dla aplikacji pisanych specjalnie pod 64b w porownaniu z aplikacjiami 32b na maszynach 32b (no bo teoretycznie przetwarzaja 2x wiecej danych w rozkazie)

Masz na myśli aplikacje kompilowane specjalnie pod 64 bity? Bo te które pisze się z zachowaniem jakieś przenośności nie powinny zawierać żadnych róznić poza asemblerem.

A tak co do tego co teorii Turgona. Jest ona rzeczywiście mało wiarygodna. Raczej skutkiem ubocznym jest ominięcie końca wyjścia poza możliwości time_t. Swoją drogą, zaciekawiło mnie i sprawdziłem -> time_t jest typu signed!!! Czy ktoś mnie uświadomi why? Przecież to pomylenie jakieś... bład projektowania, założeń. Chyba termin kogoś gonił jak to wymyślał...

[Turgon]

http://pl.wikipedia.org/wiki/Problem_roku_2038

Jabol... Czytaj wikipedię! Z resztą zwiększenie z 32 bitów do 64 bitów rozmiar da na pewno większą wydajność, przy mniejszym taktowaniu.

[sztosz]

64 bity to int 64 bitowy. To więcej rozkazów. Jest taki program do obróbki/tworzenia muzyki "Sonar", wersja 64 bitowa jest o wiele wydajniejsza od 32 bitowej, sprawdzane doświadczalnie. Tak więc wydaje mi się że wzrost wydajności jest spory pod warunkiem, że aplikacja jest 64 bitowa (no i system operacyjny (IMG:http://forum.php.pl/style_emoticons/default/winksmiley.jpg) ) Poczytaj tu: http://en.wikipedia.org/wiki/X86-64

[Jabol]

http://pl.wikipedia.org/wiki/Problem_roku_2038

Jabol... Czytaj wikipedię! Z resztą zwiększenie z 32 bitów do 64 bitów rozmiar da na pewno większą wydajność, przy mniejszym taktowaniu.

WTF ze znakiem? Kogoś chyba bolała głowa... Chyba, że to wymyślili jeszcze przed 1.1.1970
A tak swoją drogą nie widzę powodu aby samo zwiększenie długości słowa miało dać zwiększenie wydajności

A wracając do tematu: dzięki za odpowiedzi! dochodzę do wniosku, że wygląda na to, że jednak było warto. Co do większej ilości rozkazów to można również więcej rozkazów na 32-bitowcach zaimplementować, to nie kwestia wielkości słowa, a raczej tego, czy kompilator będzie umiał ich użyć (dlatego winy to shit, bo nie używają zupełnie rozszerzeń optymalizacyjnych specyficznych dla danego modelu procesora! a jedynie tylko standardowych operacji i686! chyba, że znają jakąś strasznie sprytną sztuczkę, żeby to obejść?). W każdym razie skoro te aplikacje są wydajniejsze to świetnie. Jednak nie były to wyrzucone pięniądze.

Jedyne co mnie irytuje to to, że muszę działać na systemie w profilu multilib, bo inaczje połowa aplikacji by mi nie działa (na windowsach też by nie działały, nie łudźcie się. jeżeli Wam 32-bitowe aplikacje działają to znaczy, że Wasz win to multilib!). Teraz rozumiem, czemu wszyscy tak swojego czasu jechali win 95 i 98 (pamiętam te czasy, tylko wtedy jeszcze nie wiedziałem o co chodzi).

Inna sprawa, że w 64 bitowych maszynach int ma 4 bajty. long ma dla odmiany 8 bajtów oraz pointer. A long long to po prostu long (tutaj na pewno jest przyśpieszenie). Czy to znaczy też szybsze działania zmiennoprzecinkowe? Tutaj małe podsumowanie.

Kod

sizeof(void *)=8
sizeof(char)=1
sizeof(short)=2
sizeof(int)=4
sizeof(long)=8
sizeof(long long)=8
sizeof(float)=4
sizeof(double)=8
sizeof(long double)=16

Mógły ktoś na 32-bitowcu odpalić?

Kod

#include<stdio.h>

int main(void)
{
    printf("sizeof(%s)=%d\n", "void *", (int)sizeof(void *));
    printf("sizeof(%s)=%d\n", "char", (int)sizeof(char));
    printf("sizeof(%s)=%d\n", "short", (int)sizeof(short));
    printf("sizeof(%s)=%d\n", "int", (int)sizeof(int));
    printf("sizeof(%s)=%d\n", "long", (int)sizeof(long));
    printf("sizeof(%s)=%d\n", "long long", (int)sizeof(long long));
    printf("sizeof(%s)=%d\n", "float", (int)sizeof(float));
    printf("sizeof(%s)=%d\n", "double", (int)sizeof(double));
    printf("sizeof(%s)=%d\n", "long double", (int)sizeof(long double));
    return 0;
}

Ten post edytował Jabol 16.06.2007, 22:44:22

[kwiateusz]

Kod

sizeof(void *)=4
sizeof(char)=1
sizeof(short)=2
sizeof(int)=4
sizeof(long)=4
sizeof(long long)=8
sizeof(float)=4
sizeof(double)=8
sizeof(long double)=10

[dr_bonzo]

Zaraz odpale, ale z tego co wiem to tylko void* bedzie 4B

edit: hehe, a u mnie:

Kod

sizeof(void *)=4
sizeof(char)=1
sizeof(short)=2
sizeof(int)=4
sizeof(long)=4
sizeof(long long)=8
sizeof(float)=4
sizeof(double)=8
sizeof(long double)=12

edit:

gcc version 3.3.6
Linux localhost 2.4.31 #6 Sun Jun 5 19:04:47 PDT 2005 i686 unknown unknown GNU/Linux


"Moje long double jest lepsze niz twoje long double" (IMG:http://forum.php.pl/style_emoticons/default/tongue.gif)

[sztosz]

A może by tak podać kompilator i OS panowie? (IMG:http://forum.php.pl/style_emoticons/default/tongue.gif)

sztosz@skynet ~
$ ./a.exe
sizeof(void *)=4
sizeof(char)=1
sizeof(short)=2
sizeof(int)=4
sizeof(long)=4
sizeof(long long)=8
sizeof(float)=4
sizeof(double)=8
sizeof(long double)=12

Cygwin@XP

PS. Szybka Instalka i nauka Cygwina (IMG:http://forum.php.pl/style_emoticons/default/biggrin.gif) Czemu ja się z VS męczyłem? (IMG:http://forum.php.pl/style_emoticons/default/biggrin.gif)

Ten post edytował sztosz 16.06.2007, 23:56:09

[kwiateusz]

BCB@XP u mnie było widze że moj long duble nie domaga

[Turgon]

sizeof(void *)=4
sizeof(char)=1
sizeof(short)=2
sizeof(int)=4
sizeof(long)=4
sizeof(long long)=8
sizeof(float)=4
sizeof(double)=8
sizeof(long double)=12

Baleron D 2,93 GHZ i Kubuntu 6.10 Edgy Efts

[hwao]

Tak naprawdę jedyna odczuwalna różnica dla użytkownika widoczna jest przy operacjach na dużych plikach. Ponad 2gb i posiadanie równie dużo pamięci ram.

Stawianie systemów 64'bitowcych też pociąga za sobą pewne konsekwencje, a wzrost wydajności dla normalnego użytkownika jest praktycznie nie odczuwalny. Koniec końców jak każdy sobie kompiluje wszystko sam, odpowiednio dla 64bitów to wszystko śmiga ładnie, część osób tak działa na linuxie. Co do windows'a to już gorzej (IMG:http://forum.php.pl/style_emoticons/default/winksmiley.jpg) ale stopniowo pojawiają się biblioteki 64bitowe (jeżeli masz odtwarzacz, to musisz mieć do niego kodek skompilowane dla 64bitów, ect)

[Jabol]

No rzeczywiście u Was ten long double nie domaga. U mnie

Kod

adam@localhost ~ $ gcc-config -c
x86_64-pc-linux-gnu-4.1.2

Teraz wychodzę, jak wróce przygotuje jakieś testy na tego long double i zobaczymy jak to wygląda w prawdziwym życiu.

Pozdrawiam

No dobra, mam następujący kod:

Kod

#include <stdio.h>

int main(void)
{
  long double test;
  double factor = 13.0;
  unsigned int i, j;
#define VALUES_LEN 4
  long double values[] = {1.0, 100.0, 10000.0, 1000000.0};

  for(j = 0; j < VALUES_LEN; j++)
    {
    test = values[j];
    printf("before: %LF\n", test);
    for(i = 0; i < (unsigned int) 1<<31 /* ~2 milion */; i++)
      {
        test /= factor;
        test *= factor;
      }
    printf("after: %LF\n", test);
    printf("difference: %LF\n", values[j] - test);
    }
  return 0;
}

I za każdym razem difference = 0.000000000
Ktoś mi wytłumaczy *czemu to działa*?
Przetestujcie to też na jakimś 32 bitowym, może wtedy coś się wyjaśni..

A tak swoją drogą to co 64-bitowych linuxów to właśnie sam jestem taki okaz. Wszystko oprócz plugina do flasha mam 64-bitowe (a firefox działa z tym pluginem, bo jest napisany wrapper jakiś...). Wszystko compilowane z -march=nocona (czyli Core 2 Duo). Muszę przyznać, że śmiga nieźle, ale inna sprawa to są po prostu mocne procesory, także sam nie wiem czego to wina..


Btw. Wiecie, jak teraz się nazywa instrunction pointer register? RIP (sic!)! Mogli wybrać jakąś inną literkę do prefiksowania 64bitowych rejestrów (IMG:http://forum.php.pl/style_emoticons/default/tongue.gif)

[fridek]

Procki 64-bit przydają się, jeśli ktoś chce mieć więcej niż 3GB ramu,
ponieważ w 32bitach można zaadresować tylko 4GB. Dlaczego w takim razie 3 a nie 4? Bo Procesor musi też adresować pamięć karty graficznej (i kilku innych, mniej znaczących duperołów). Jeśli ktoś kupuje 4gb ramu, to jest wysoce prawdopodobne, że ma kartę z min. 512mb na pokładzie.
Dlatego za kilka lat systemy i procki na 32bit wyginą, nie będzie można dokupić do nich sprzętu.

[Jabol]

@fridek: z pamięcią to już wiemy. teraz szukam jakiś innych różnic.

Dobra, udało mi się ten test stworzyć który chciałem. Mógłby to ktoś przetestować u siebie? Porównamy sobie i zobaczymy jak te procki na działania zmiennoprzecinkowe wpływają:

Kod

#include <stdio.h>

#define TEST(NAME, FORMAT, TYPE) \
void NAME(TYPE test, int steps) \
{ \
  TYPE sum = 0.0; \
  int i; \
\
  printf("before: " FORMAT "\n", test); \
  for(i = 0; i < steps; i++) \
    sum += (test / (TYPE) steps); \
  printf("after: " FORMAT "\n", sum); \
  if(sum == test) \
    puts("exact"); \
  else \
    printf("diff: " FORMAT "\n", test - sum); \
}

TEST(long_double2, "%.50LF", long double)
TEST(double2, "%.50F", double)
TEST(float2, "%.50F", float)

int main(void)
{
  int steps = 13;
  double test = 1.0;
  
  puts("long double:");
  long_double2((long double)test, steps);
  
  puts("double:");
  double2((double)test, steps);
  
  puts("float:");
  float2((float)test, steps);

  return 0;
}

Moje wyniki to:

Kod

adam@localhost ~/devel/c/64bit $ ./precision_test long double:
before: 1.00000000000000000000000000000000000000000000000000
after: 0.99999999999999999989157978275144955659925471991301
diff: 0.00000000000000000010842021724855044340074528008699
double:
before: 1.00000000000000000000000000000000000000000000000000
after: 0.99999999999999977795539507496869191527366638183594
diff: 0.00000000000000022204460492503130808472633361816406
float:
before: 1.00000000000000000000000000000000000000000000000000
after: 1.00000000000000000000000000000000000000000000000000
exact

Ten post edytował Jabol 17.06.2007, 13:03:37

[sztosz]

Kod

sztosz@skynet ~
$ ./a.exe
before: 1.00000F+00
after: 1.00000F+00
difference: 0.00000F+00
before: 1.00000F+02
after: 1.00000F+02
difference: 0.00000F+00
before: 1.00000F+04
after: 1.00000F+04
difference: 0.00000F+00

Kod

sztosz@skynet ~
$ ./a.exe
long double:
before: 1.00000F+00
after: 1.00000F+00
diff: 1.0842021724855044340074528008699417114257810000000F-19
double:
before: 1.00000F+00
after: 1.00000F+00
diff: 3.3306690738754696212708950042724609375000000000000F-16
float:
before: 1.00000F+00
after: 1.00000F+00
exact

cygwin(g++)@XP

Ten post edytował sztosz 17.06.2007, 12:59:48

[Jabol]

hmmm... ciekawy, long double ma dokładnie tą samą dokładność, a double jest u mnie o połowe bardziej dokładny...

[sztosz]

To po zmianie testu:

Kod

sztosz@skynet ~
$ ./a.exe
long double:
before: 1.0000000000000000000000000000000000000000000000000F+00
after: 9.9999999999999999989157978275144955659925470000000F-01
diff: 1.0842021724855044340074528008699417114257810000000F-19
double:
before: 1.0000000000000000000000000000000000000000000000000F+00
after: 9.9999999999999966693309261245303787291049960000000F-01
diff: 3.3306690738754696212708950042724609375000000000000F-16
float:
before: 1.0000000000000000000000000000000000000000000000000F+00
after: 1.0000000000000000000000000000000000000000000000000F+00
exact

[Turgon]

U mnie:

turgon@genesis:~/Desktop$ ./a.out
before: 1.000000

Pierwsze (IMG:http://forum.php.pl/style_emoticons/default/tongue.gif)
Drugie:

turgon@genesis:~/Desktop$ ./a.out
long double:
before: 1.00000000000000000000000000000000000000000000000000
after: 0.99999999999999999989157978275144955659925471991301
diff: 0.00000000000000000010842021724855044340074528008699
double:
before: 1.00000000000000000000000000000000000000000000000000
after: 0.99999999999999966693309261245303787291049957275391
diff: 0.00000000000000033306690738754696212708950042724609
float:
before: 1.00000000000000000000000000000000000000000000000000
after: 1.00000000000000000000000000000000000000000000000000
exact