Výkon ARM vs. x86

Rado2

Re:Výkon ARM vs. x86
« Odpověď #15 kdy: 19. 10. 2016, 20:15:49 »
pochybujem, že kompatibilita so 16/32 bit architektúrou je až taký veľký problém, že by to malo viditeľný vplyv na parametre dnešných CPU. Pokiaľ sa nemýlim zo 64bit módu (teda t 64 bit OS) už 16 bitový kód aj tak nejde spustiť, iba ak emuláciou a ten 32 bitový je veľmi príbuzný 64bitovému, len má skrátené registre a je ich menej + možno pár detailov navyše.
To, že by sa dali lepšie využiť niektoré krátke inštrukčné kódy je nepodstatné dnes je dosť pamäte a o pár % menší kód nič zásadné nerieši.


Lael.Ophir

Re:arm vs x86
« Odpověď #16 kdy: 20. 10. 2016, 13:23:57 »
mrp.cz má jenom 16-bitové produkty verze??? Jak se teda pustí na většině nových systémů, jak je napsáno v druhém odstavci? Produkt, který by byl dneska 16-bitový, by na trhu neměl naprosto žádnou šanci.
mrp.cz a řada dalších nabízí SW psaný ještě pro DOS, a to za velmi malé peníze. Upozorňují na to, že běží jen pod 32-bitovými Windows. Přesně z toho důvodu, že na 64-bitovém OS nespustíte 16-bitový kód.
Mimochodem dalším podobným příkladem mohou být pokladny založené na embedded DOSu. Pokud si je firma koupila před 10 lety za levný peníz, a pořád fungují, tak není jediný důvod do toho sahat.

Proto jsem psal, že odstranění 32 bitů by si část korporátních zákazníků všimla. Zrovna Oracle ale není úplně dobrý příklad, neboť ten se dá zrovna snadno pustit v 64-bitové variantě a je to pro klienty zcela transparentní. Nehledě na to, že provozovat jakýkoli starý software je bezpečnostní riziko...
SW nerezaví, a interní firemní systémy mohou být (a často jsou) velmi staré.

IA64 dojel na úplně jiné věci, podporu od relevantních software společností měl dostatečnou (bavíme se o server side), primárním důvodem byla kombinace mizerného výkonu a vysoké ceny. Sice možná mohla porazit (v té době už) dinosaury typu Alpha, PA-RISC a další, ale utopická architektura nakonec podlehla ač zastaralé, tak přesto flexibilní x86_64. Nicméně, i kdyby tomu tak bylo, IA64 byla novinka ve světě x86, zatímco o 15 let později je x86 legacy ostrůvek ve světě x86_64, ARM a dalších.
Ano IA64, mohla porazit dinosaury typu Alpha, PA-RISC. Jenže ti dinosauři byli tak jako tak na odchodu, a pro IA64 nebylo dost SW. Je fajn mít OS, MS SQL Server a Oracle, ale firma potřebuje daleko víc SW. Bylo možné použít běžný x86 SW, ale emulace x86 neměla nic moc výkon, takže jste měl zatraceně drahou IA64 a efektivně na ní jel s výkonem nižším než na x86. Společnost AMD pak IA64 zabila svými procesory s x64. Ten samý CPU bylo možné použít na desktopu i serveru, pro 32-bit i 64-bit OS, a starý 32-bitový kód fungoval beze ztráty výkonu. To že x64 je z technického hlediska fialový hnus pak nikoho netrápilo, hlavně že fungovala zpětná kompatibilita.

Lael.Ophir

Re:arm vs x86
« Odpověď #17 kdy: 20. 10. 2016, 13:52:58 »
U Itania to Intel podcenil, jenže pro tu zpětnou kompatibilitu vůbec nepotřebujete hardwarovou podporu (tedy pokud tam nepotřebujete spustit Windows, protože nativně spustit nejdou :) ). Zkuste si najít, co dělá libhoudini, hlavní důvod, proč vůbec existují androidí tablety a telefony s Atomy. Nebo si najděte, jak řešil MacOS X přechod z PowerPC na x86-64. Nakonec i systémy na Itaniu dneska umí spouštět aplikace pro x86, jenže než se to naučili, AMD už prodávalo vlastní 64bitový systém, který to uměl taky a byl výrazně levnější.
Itanium mělo od první verze "HW" kompatibilitu s x86 (pár x86 instrukcí vyžadovalo SW podporu). Přechod do x86 módu se prováděl zvláštní instrukcí, a například obsluha interruptu byla vždy v IA64 režimu, takže nebylo možné použít x86 OS (leda by tomu "pomohl" firmware, což se pokud vím nestalo). Bohužel výkon x86 kódu byl na IA64 dost tragický, údajně v nejlepším případě ekvivalent 100MHz Pentia (v době kdy se prodávaly 1.1GHz Pentia). Novější verze OS pro Itanium používaly SW emulaci x86, která nabízela lepší výkon, a novější verzi Itania tu "HW" kompatibilitu s x86 odstranily. Bohužel ta emulace přišla pozdě, a ani tak nebyl výkon nic moc.

Kód pro ARM puštěný na Intelu přes libhoudini má cca třetinový výkon. PPC kód na Mac Rosetta měl cca třetinový až poloviční výkon. V případě Macu se přechod z PPC na Intel povedl, ovšem jen z toho důvodu, že zákazníci neměli moc na vybranou :). Kdyby v AMD nepřišli s x86-64, tak by Intel s Itaniem možná také uspěl.

j

Re:Výkon ARM vs. x86
« Odpověď #18 kdy: 20. 10. 2016, 17:16:27 »
Lulane, fialovej hnus bylo predevsim Itanium, proto pro nej nikdo nic nevyvijel. Protoze to nejen ze nebylo binarne kompatibilni, ono to vyzadovalo i uplne jiny postupy programovani, a to bylo to, co to zabilo.

AMD naopak prislo s naprosto genialnim navrhem, kdy jen proste a jednoduse pridali rozsireny 64bit instrukce, ktery se ale chovaly presne stejne, jako ty 32bit. Takze u spousty aplikaci proste stacilo kompilatoru rict "udelej mi to jako 64bit" ... a FUNGOVALO to.

Sten

Re:Výkon ARM vs. x86
« Odpověď #19 kdy: 20. 10. 2016, 18:58:35 »
Lulane, fialovej hnus bylo predevsim Itanium, proto pro nej nikdo nic nevyvijel. Protoze to nejen ze nebylo binarne kompatibilni, ono to vyzadovalo i uplne jiny postupy programovani, a to bylo to, co to zabilo.

AMD naopak prislo s naprosto genialnim navrhem, kdy jen proste a jednoduse pridali rozsireny 64bit instrukce, ktery se ale chovaly presne stejne, jako ty 32bit. Takze u spousty aplikaci proste stacilo kompilatoru rict "udelej mi to jako 64bit" ... a FUNGOVALO to.

Naprostá většina software se nepíše v assembleru a jiné přístupy to nevyžadovalo. Vyžadovalo to kompilátor, který umí generovat optimalizované VLIW. Což v době vydání Itania byl trochu problém. O pět let později již kompilátory neměly problém generovat složité instrukce, ať již VLIW, SIMD či dokonce paralelizované, ale to už bylo pozdě. K tomu se přidala cena. Je hezké mít 128+128 registrů, 8 ALU a 4 FPU, ale takový procesor nejde udělat levný. AMD se spokojilo se 16+8 registry, jedním ALU a jedním FPU.


Sten

Re:arm vs x86
« Odpověď #20 kdy: 20. 10. 2016, 19:09:13 »
Kód pro ARM puštěný na Intelu přes libhoudini má cca třetinový výkon. PPC kód na Mac Rosetta měl cca třetinový až poloviční výkon. V případě Macu se přechod z PPC na Intel povedl, ovšem jen z toho důvodu, že zákazníci neměli moc na vybranou :). Kdyby v AMD nepřišli s x86-64, tak by Intel s Itaniem možná také uspěl.

S libhoudini mám jinou zkušenost. Ono asi záleží, co překládá a kde. Když jsem to zkoušel na video a audio kodecích, které používají NEON SIMD,  na Lollipop (kde je AOT kompilátor), tak to běželo srovnatelně rychle jako na podobně drahém telefonu s ARMem.

Lael.Ophir

Re:Výkon ARM vs. x86
« Odpověď #21 kdy: 21. 10. 2016, 01:51:34 »
Lulane, fialovej hnus bylo predevsim Itanium, proto pro nej nikdo nic nevyvijel. Protoze to nejen ze nebylo binarne kompatibilni,
Jak jsem už psal, na Itaniu je možné provozovat x86 kód (ale ne kompletní x86 OS, protože například obsluha interruptu jede vždy v EPIC). Itanium má instrukci pro přepnutí do režimu x86, a pak HW dekodér překládá x86 instrukce na nativní EPIC. Problém je v tom, že to bylo pomalé. Zdroj: Intel Itanium Architecture Software developer's manual, chapter 6.
http://www.intel.com/content/www/us/en/processors/itanium/itanium-architecture-vol-1-2-3-4-reference-set-manual.html

ono to vyzadovalo i uplne jiny postupy programovani, a to bylo to, co to zabilo
Hlavně to vyžadovalo úplně jiný kompilátor, který v době uvedení Itania nebyl na dostatečné úrovni, jak už tu někdo psal.

AMD naopak prislo s naprosto genialnim navrhem, kdy jen proste a jednoduse pridali rozsireny 64bit instrukce, ktery se ale chovaly presne stejne, jako ty 32bit.
Ten "geniální" návrh je přesně to co Michal Chovanec dříve v téhle diskusi kritizoval jako zátěž x86-64 architektury zbytečnou historií, což vede k nižší efektivitě. Návrh x86-64 je hlavně "geniální" prasárna. Jenže bylo možné používat
nový 64-bit i stávající 32-bit OS, a bylo možné se stejným výkonem běžet nový 64-bit i starý 32-bit kód. Proto vyhrálo prasácké řešení.

Takze u spousty aplikaci proste stacilo kompilatoru rict "udelej mi to jako 64bit" ... a FUNGOVALO to.
Možná u aplikací typu Hello World. U rozsáhlejších projektů ani náhodou.

Lael.Ophir

Re:arm vs x86
« Odpověď #22 kdy: 21. 10. 2016, 02:01:37 »
S libhoudini mám jinou zkušenost. Ono asi záleží, co překládá a kde. Když jsem to zkoušel na video a audio kodecích, které používají NEON SIMD,  na Lollipop (kde je AOT kompilátor), tak to běželo srovnatelně rychle jako na podobně drahém telefonu s ARMem.
Zkuste na Intelu pustit nějaký benchmark, a použít pak ten samý benchmark ve verzi pro ARM, ovšem puštěný přes libhoudini. Emulace prostě stojí nějaké zdroje.
https://regmedia.co.uk/2014/04/30/watt_benchmarks_large.jpg

kvr kvr kvr

Re:Výkon ARM vs. x86
« Odpověď #23 kdy: 21. 10. 2016, 17:32:41 »
ono to vyzadovalo i uplne jiny postupy programovani, a to bylo to, co to zabilo
Hlavně to vyžadovalo úplně jiný kompilátor, který v době uvedení Itania nebyl na dostatečné úrovni, jak už tu někdo psal.

Kompilátor nedokáže zachránit utopickou architekturu, když program využívá nějaký typ operací, ale jedna VLIW instrukce jich vyžaduje víc. Myšlenka dobrá, ale v reálném světě ve většině aplikací nepoužitelná.

Takze u spousty aplikaci proste stacilo kompilatoru rict "udelej mi to jako 64bit" ... a FUNGOVALO to.
Možná u aplikací typu Hello World. U rozsáhlejších projektů ani náhodou.

To platí pouze pro Windows world, kde je většina proměnných WORD či DWORD a maďarština se používá na každém řádku. Pro POSIX, kde lidi používají platform independent typy size_t, off_t, uintptr_t, time_t a další, portace velkých projektů byla většinou opravdu jen o zkompilování a spuštění (namátkou KDE, Emacs, ViM, OpenOffice). Firefox je nejspíš lehce jiný případ pouze kvůli závislosti na 3rd party plugins.

Lael.Ophir

Re:Výkon ARM vs. x86
« Odpověď #24 kdy: 21. 10. 2016, 18:47:24 »
To platí pouze pro Windows world, kde je většina proměnných WORD či DWORD a maďarština se používá na každém řádku. Pro POSIX, kde lidi používají platform independent typy size_t, off_t, uintptr_t, time_t a další, portace velkých projektů byla většinou opravdu jen o zkompilování a spuštění (namátkou KDE, Emacs, ViM, OpenOffice). Firefox je nejspíš lehce jiný případ pouze kvůli závislosti na 3rd party plugins.
Aha. Tak se koukneme na GLib (základ GTK), Qt a Win32. Kupodivu definují vlastní typy: quint32, guint32, DWORD, ...
https://developer.gnome.org/glib/stable/glib-Basic-Types.html
http://doc.qt.io/qt-4.8/qtglobal.html
https://msdn.microsoft.com/en-us/library/windows/desktop/aa383751(v=vs.85).aspx

Pojďme se tedy podívat, jak se namátkou OpenOffice "jen zkompiloval a přeložil". Jan Holešovský k tomu měl prezentaci. V té popisuje obvyklé problémy, dvě větve projektu vytvořené za účelem portu, to že ty větvě nefungují, a popisuje že po spoustě práce, kterou nad věcí odvedli, je výsledek nadále nestabilní a nelze ho ani demonstrovat. Sice je to stav k roku 2005, ale ilustruje to, že "jen zkompilovat a přeložit" je nesmysl.
http://artax.karlin.mff.cuni.cz/~kendy/ooo/OOoCon-2005/img5.html

Re:Výkon ARM vs. x86
« Odpověď #25 kdy: 21. 10. 2016, 21:53:44 »
To platí pouze pro Windows world, kde je většina proměnných WORD či DWORD a maďarština se používá na každém řádku. Pro POSIX, kde lidi používají platform independent typy size_t, off_t, uintptr_t, time_t a další, portace velkých projektů byla většinou opravdu jen o zkompilování a spuštění (namátkou KDE, Emacs, ViM, OpenOffice). Firefox je nejspíš lehce jiný případ pouze kvůli závislosti na 3rd party plugins.
Aha. Tak se koukneme na GLib (základ GTK), Qt a Win32. Kupodivu definují vlastní typy: quint32, guint32, DWORD, ...
https://developer.gnome.org/glib/stable/glib-Basic-Types.html
http://doc.qt.io/qt-4.8/qtglobal.html
https://msdn.microsoft.com/en-us/library/windows/desktop/aa383751(v=vs.85).aspx

To je naprosto v pořádku, že tam ty typy jsou. Jsou místa, kde je třeba mít pevně daný typ, například při serializaci. Problém Windows world a jejich developerů je, že je používají naprosto špatně, i v místech, kde mají použít "logický" typedef (off_t, size_t atd). Například
Kód: [Vybrat]
DWORD WINAPI GetFileSize(_In_      HANDLE  hFile,  _Out_opt_ LPDWORD lpFileSizeHigh);, zatímco POSIX má jednoduše off_t. A chování té funkce je tedy lahůdka, nepoužívám ostrá slova, ale tohle musel designovat opravdu blbec posedlý DWORDy: Note that if the return value is INVALID_FILE_SIZE (0xffffffff), an application must call GetLastError to determine whether the function has succeeded or failed. The reason the function may appear to fail when it has not is that lpFileSizeHigh could be non-NULL or the file size could be 0xffffffff. In this case, GetLastError will return NO_ERROR (0) upon success.

Díky za link na Windows Data Types, to je taky dílo:
Kód: [Vybrat]
DWORDLONG - A 64-bit unsigned integer. The range is 0 through 18446744073709551615 decimal.
DWORD32 - A 32-bit unsigned integer.
DWORD64 - A 64-bit unsigned integer.

DWORD byl původně double word, resp 32-bit uint, což je jako platform independent samo o sobě brain-damaged, ale vem to peklo. Tady z pevně daného typu udělají suffixem jiný typ přesto, že logické jméno reflektuje ten starý pevný 32-bit. To byl jen příklad, v rámci toho linku se dají najít mnoho dalších neméně "povedených"

Qt a Glib oproti tomu mají jasné a výstižné názvy, ze kterých je jasně viditelný smysl, použití a velikost.

Martin Dráb

Re:Výkon ARM vs. x86
« Odpověď #26 kdy: 21. 10. 2016, 23:27:44 »
Citace
GetFIieSize

Zřejmě jim v MS již dávno došlo, že práce s touto API není tak úplně přímočará, a tak s WIndows XP přišla GetFileSizeEx (https://msdn.microsoft.com/en-us/library/windows/desktop/aa364957(v=vs.85).aspx), kterou již přímočaře použít lze.

IIRC tu GetFIleSIze byla s námi ještě ve velmi dávných dobách (Windows 9x, možná dříve?), kde se jako souborové systémy používaly FAT12/16/32. Vzhledem k tamějšímu omezení na velikost souborů obvykle nebylo potřeba vyplňovat druhý parametr. Ale je to jen taková domněnka, proč taková skladba parametrů.

kvr kvr kvr

Re:Výkon ARM vs. x86
« Odpověď #27 kdy: 22. 10. 2016, 06:34:17 »
Zřejmě jim v MS již dávno došlo, že práce s touto API není tak úplně přímočará, a tak s WIndows XP přišla GetFileSizeEx (https://msdn.microsoft.com/en-us/library/windows/desktop/aa364957(v=vs.85).aspx), kterou již přímočaře použít lze.

Tak s přímočarostí bych byl hodně opatrný. V porovnání s POSIX
Kód: [Vybrat]
off_t lseek(int fd, off_t offset, int method) je i tahle pokročilá Windows varianta pořád peklo - jako parametr bere LARGE_INTEGER, což je union, který má v sobě strukturu se dvěma DWORD (low, high) a druhý člen je quadPart, který skutečně obsahuje to číslo. Pominu-li opět platform independence (o big-endian v Microsoftu nejspíš nikdy neslyšeli), tak práce s tímhle, pokud chcu skutečně operovat s offsetem, sčítat ho apod., dostáváme se někde na úroveň mezi assembler a C.

A to je na tom nejhorší - na to, že tahle funkce vznikla v 2000+, tak už bych čekal, že se z toho poučí, nebo aspoň ze 30 let staršího POSIXu. Ale kdepak, to se soudruzi zamysleli, udělali to jinak, ale téměř stejně blbě. V tom musela být nějaká politika, aby náhodou nepřiznali, že to 30 let před nima někdo vymyslel stokrát líp... Mimochodem těma dwOffsetLow, dwOffsetHigh jsou ty "moderní" WINAPI Ex funkce protkané všude...

Lael.Ophir

Re:Výkon ARM vs. x86
« Odpověď #28 kdy: 23. 10. 2016, 03:00:36 »
To je naprosto v pořádku, že tam ty typy jsou. Jsou místa, kde je třeba mít pevně daný typ, například při serializaci. Problém Windows world a jejich developerů je, že je používají naprosto špatně, i v místech, kde mají použít "logický" typedef (off_t, size_t atd). Například
Kód: [Vybrat]
DWORD WINAPI GetFileSize(_In_      HANDLE  hFile,  _Out_opt_ LPDWORD lpFileSizeHigh);, zatímco POSIX má jednoduše off_t. A chování té funkce je tedy lahůdka, nepoužívám ostrá slova, ale tohle musel designovat opravdu blbec posedlý DWORDy: Note that if the return value is INVALID_FILE_SIZE (0xffffffff), an application must call GetLastError to determine whether the function has succeeded or failed. The reason the function may appear to fail when it has not is that lpFileSizeHigh could be non-NULL or the file size could be 0xffffffff. In this case, GetLastError will return NO_ERROR (0) upon success.
Jak už tu padlo, GetFileSize je staré API, a bylo před mnoha lety nahrazeno pomocí GetFileSizeEx. Nakonec je to uvedené i v popisu funkce.
Dále zjištění velikosti souboru na Unixech probíhá pomocí volání stat nebo stat64, výsledek inteligentně dostanete struktuře, a ta obsahuje member, který má typ off_t nebo off64_t. No a jestli vám přijde dobrý nápad mít na file offset vlastní datový typ off_t, který je "signed integer... no narrower than int", a pak ještě off64_t, který je také signed a také no narrower than int, ale navíc je na 32-bitových systémech 64-bitový... tak k tomu asi nemám komentář. BTW o kvalitě dokumentace glibc vs MSDN asi nemá smysl psát.

Díky za link na Windows Data Types, to je taky dílo:
Kód: [Vybrat]
DWORDLONG - A 64-bit unsigned integer. The range is 0 through 18446744073709551615 decimal.
DWORD32 - A 32-bit unsigned integer.
DWORD64 - A 64-bit unsigned integer.

DWORD byl původně double word, resp 32-bit uint, což je jako platform independent samo o sobě brain-damaged, ale vem to peklo. Tady z pevně daného typu udělají suffixem jiný typ přesto, že logické jméno reflektuje ten starý pevný 32-bit. To byl jen příklad, v rámci toho linku se dají najít mnoho dalších neméně "povedených"

Qt a Glib oproti tomu mají jasné a výstižné názvy, ze kterých je jasně viditelný smysl, použití a velikost.
DWORD byl původně double word, a postupem času se z něj stal unsigned int, by default 32-bitový. To že se z něj sufixem 64 udělá 64-bitový typ mi připadá poměrně logické. Jinak použití typů bez definované šířky (jak je nešťastným zvykem v definici jazyka C) považuji za příčinu většiny problémů v portování na 64-bitové platformy.

Qt a Glib jsou poměrně high level knihovny. Win32 je API z roku 1993, a když srovnáte .NET Framework nebo WinRT s Qt nebo Glib, tak na tom MS není s datovými typy špatně. Hlavně je na tom ale velmi dobře s funkcionalitou a dokumentací.

Mimochodem u těch platform independent typů (size_t, off_t, uintptr_t, time_t a další) jste viděl, že portaci velkých projektů nijak nepomohly, a například u OpenOffice to zdaleka nebylo "jen o zkompilování a spuštění". Uvědomte si, že řada starších aplikací například serializuje objekty do binárního blobu, a je tak dělaná mimo jiné většina souborových formátů uvedených před XML. Všechny tyhle věci se vám při změně datových typů zhroutí jako domeček z karet. OO sice používal souborový formát založený na XML, ale kupodivu při portu na x86-64 dospěl i do stádia, kdy byl schopný číst binární dokumenty MS Office, ale ne OOXML (vizte prezentaci).

Lael.Ophir

Re:Výkon ARM vs. x86
« Odpověď #29 kdy: 23. 10. 2016, 03:19:24 »
Tak s přímočarostí bych byl hodně opatrný. V porovnání s POSIX
Kód: [Vybrat]
off_t lseek(int fd, off_t offset, int method) je i tahle pokročilá Windows varianta pořád peklo - jako parametr bere LARGE_INTEGER, což je union, který má v sobě strukturu se dvěma DWORD (low, high) a druhý člen je quadPart, který skutečně obsahuje to číslo. Pominu-li opět platform independence (o big-endian v Microsoftu nejspíš nikdy neslyšeli), tak práce s tímhle, pokud chcu skutečně operovat s offsetem, sčítat ho apod., dostáváme se někde na úroveň mezi assembler a C.

A to je na tom nejhorší - na to, že tahle funkce vznikla v 2000+, tak už bych čekal, že se z toho poučí, nebo aspoň ze 30 let staršího POSIXu. Ale kdepak, to se soudruzi zamysleli, udělali to jinak, ale téměř stejně blbě. V tom musela být nějaká politika, aby náhodou nepřiznali, že to 30 let před nima někdo vymyslel stokrát líp... Mimochodem těma dwOffsetLow, dwOffsetHigh jsou ty "moderní" WINAPI Ex funkce protkané všude...

Předpokládám že víte jak funguje v jazyku C union, takže je vám jasné, že QuadPart a LowPart+HighPart jsou jen různé pohledy na tu samou hodnotu. Pokud compiler umí 64-bitové integery, s klidem používejte QuadPart, a nevidím důvod, proč by se vám s ní počítalo špatně. Pokud je neumí, pořád máte možnost použít LowPart+HighPart.
O big-endian v MS slyšeli, ale asi také vědí, že naprostá většina dnešního HW je bi-endian: ARM 3+, PowerPC, Alpha, SPARC V9+, MIPS, PA-RISC, SuperH SH-4, IA-64 aka Itanium.

Když to shrnu, tak obhajujete platform-independent datové typy, u kterých není daná jejich šířka ani endianness. Jak vidíte u portu OpenOffice na 64-bitovou architekturu, v praxi to portabilitě nepomáhá. Co je ale horší: v takovém prostředí nemáte stabilní ABI. Windows staví na stabilním ABI, ale ve světě POSIXu nic takového neexistuje.