Cookies op Tweakers

Tweakers maakt gebruik van cookies, onder andere om de website te analyseren, het gebruiksgemak te vergroten en advertenties te tonen. Door gebruik te maken van deze website, of door op 'Ga verder' te klikken, geef je toestemming voor het gebruik van cookies. Wil je meer informatie over cookies en hoe ze worden gebruikt, bekijk dan ons cookiebeleid.

Meer informatie

Door , , 46 reacties

Intel heeft op de SC16-conferentie in Salt Lake City een demonstratie gehouden van een Xeon E5-processor met een ge´ntegreerde Altera Arria 10-fpga. Intel kondigde bovendien een losse accelerator-kaart op basis van de Arria 10-fpga aan.

Het gaat om een on-package-combinatie van de fpga en de Xeon E5-chip en de processor is op de Broadwell-EP-architectuur gebaseerd, bevestigde Intel tegen Servethehome. De fpga en de processor zijn met een interconnect verbonden en nemen samen zitting onder de ihs. Intel zou de eerste Xeon E5-testchips met fpga's inmiddels naar klanten hebben verstuurd. De processor met accelerator draaide een recommendation engine op Apache Spark.

De toevoeging van een fpga maakt dat ontwikkelaars een programmeerbare chip kunnen inzetten voor de versnelling van specifieke datacenterwerklasten. De verwachting is dat steeds meer datacenters systemen met fpga's gaan inzetten, vanwege de voordelen op gebied van snelheid en verbruik. De integratie is een van de eerste resultaten van de overname van Altera door Intel.

Intel Broadwell EP Xeon fpgaIntel Xeon Broadwell EP Arria fpga

Intel kondigde op de conferentie tegelijkertijd een pci-e-kaart aan die rond de Altera Arria 10 is opgebouwd. De Intel Deep Learning Inference Accelerator is bedoeld voor rekentaken op gebied van beeldherkenning en moet volgend jaar beschikbaar komen.

Intel Deep Learning Inference Accelerator SC16

Moderatie-faq Wijzig weergave

Reacties (46)

Voor de geintereseerden, een FPGA (Field Programmable Gate Array) is een chip waarmee digitale circuits dynamisch gemaakt kunnen worden. Waar een processor bestaat uit een statische connectie tussen digitale poorten (AND en OR en varianten) kunnen deze connecties bij een FPGA dynamisch gemaakt worden. Deze connecties worden beschreven in een Hardware Description Language (HDL) waarvan VHDL vooral in Europa gebruikt wordt en Verilog in USA.

Het voordeel van een FPGA is dat het meestal vele malen efficienter (snelheid Ún vermogen) is om bepaalde, specialistische, berekeningen te doen omdat alles parallel uitgevoerd kan worden. Je bepaald tenslotte zelf de hardware in plaats van de instructies zoals op een processor.

Een FPGA heeft meestal ook directe toegang tot het RAM waardoor het in staat is om grote hoeveelheden data snel te verwerken en weg te schrijven naar het geheugen om vervolgens de processor er iets mee te laten doen.

Het combineren van een processor en FPGA in ÚÚn chip is niet nieuw. Xilinx en Altera hebben beide hiervoor al SoCs (systems on chips) waarop de processor een ARM is. Respectievelijk de Zynq en Altera SoC FPGAs. Echter is de combinatie tussen een x86 architectuur en een FPGA wel nieuw en bied dat vooral voor datacenters en serverparken mogelijkheden tot efficientere computatie.

[Reactie gewijzigd door PinQ op 16 november 2016 12:40]

Wat Xilinx (zynq) en Altera (soc) hebben gedaan is wel een wereld van verschil met wat Intel hier doet.

Intel maakt gewoon een losse x86 en een losse FPGA, plakt er een bus tussen, en propt ze in een stucje plastic.

Xilinx en Altera bakken de FPGA en de CPU (multicore ARM) in hetzelfde process, op dezelfde die. Dat betekent dat er consessies gedaan worden aan de CPU qua specs, maar dat de link tussen logica en CPU echt helemaal supergeweldig is. Op de Xilinx Zynq kan de FPGA logic direct de L1 en L2 caches van de CPU lezen en schrijven, maar natuurlijk ook met de DDR controller data uitwisselen. Tussen CPU en FPGA ligt niet een enkele bus, maar een dozijn bussen, met een varieteit aan latencies en bandbreedte.

Als je een FPGA "accelerator" kaart in je PC wilt hebben, kun je die vandaag de dag gewoon kopen bij een Nederlands bedrijf. Die leveren ook de benodigde knowhow, drivers en infrastructuur om er wat nuttigs mee te doen. (Misschien moet tweakers.net eens aandacht besteden aan een relatief klein bedrijf die momenteel wereldwijd een koppositie inneemt op dat gebied.)

Intel loopt gewoon nog ver achter ;)

[Reactie gewijzigd door cdwave op 16 november 2016 14:33]

Intel loopt gewoon nog ver achter.
Dat lijkt me een rare claim als je ze vergelijkt met Xilinx en Altera, en ze hebben Altera overgenomen... dan zijn ze toch gewoon helemaal bij? :Y)

Maar zoals ik in mijn andere post al schetste, het zal nog wel even duren voordat er complete integratie komt van FPGA technologie en x86 chips, de design cycle van dat soort dingen is veel langer, dus dat kunnen we misschien over een jaar of 5 pas verwachten. Als het uberhaupt een geschikte oplossing is, het zou goed kunnen dat een multi-chip design oplossing voor hun veel efficienter uitpakt.

Dat is natuurlijk een ander verhaal bij de FPGAs die jij aanhaalde met bijvoorbeeld embedded ARM (en vroeger ook PowerPC bij Xilinx in ieder geval staat me zo bij). Daar waren de embedded cores meer een hulpstuk, terwijl het voor Intel precies andersom zal liggen. Ze zullen geen compromissen willen maken in CPU performance om een FPGA op de chip te kunnen integreren.
Processen om FPGA logica mee te maken zijn per definitie minder geschikt om een CPU mee te maken. Een ARM Cortex A9 kun je doorgaans tot 1,5 GHz klokken, de A9 in de Zynq gaat maar tot 1GHz in de hoogste speedgrades (en tot 666MHz in de normale uitvoering).

Als je een gecombineerde chip maakt, zul je dus een compromis moeten sluiten, je kunt niet een "perfecte CPU core in een perfecte FPGA" integreren. Een van de twee zal moeten inleveren. In zo'n Zynq of Altera Soc beslaan de ARM cores minder dan 10% van het oppervlak, dus de keus is dan snel gemaakt.

Als Intel iets soortgelijks wil gaan doen komen ze ook voor dezelfde keus te staan.

De "harde" cores in deze FPGA's lopen wel rondjes rond de softcores (PPC, Leon, Microblaze) die je normaal gesproken in een FPGA integreert. En dat niet alleen op rekenkracht en brute kloksnelheid, maar ook op power efficientie, warmte dissipatie en en chipoppervlak. Wat dat betreft een enorme stap.
Nu intel zich heeft ingekocht in die markt komen hun producten uiteraard met iNtel state of the art moderne procedes. En zal dus een of meer van iNtel fab (s )de productie doen.

Maar ja voordeel van gekoppelde chip is dat elk deel op voor hun optimale procede gemaakt zijn. Met als nadeel interchip connectie ipv directe in chip connectie.
De 'accelerator' kaarten zijn er nu natuurlijk ook al. Iedere development kit met een PCI Express interface voldoet daar aan.

Het unieke zal voortkomen uit de standaard development tools die Intel daarbij gaat leveren.

Door de OpenCL compiler is het nu ook al mogelijk, maar voor machine learning en dergelijke is dit blijkbaar nog niet eenvoudig genoeg.

Dat Nederlandse bedrijf zal toch ook wel iets meer met Intel FPGA's gaan doen zodat Intel niet meer achter loopt ;-)
niet alleen op hardware vlak zijn ze sterk en kop loper, maar ook op het software gebied. met hun framework Dyplo kan je snel en makkelijk je vdhl of c/c++(synthesizer) in de fpga schieten. Zonder dat je de communicatie tussen cpu en fpga hoeft te regelen.

Ook een handige feature is de "partial reconfigration" van de FPGA. hierbij kan je runtime je fpga (delen ervan) reconfigureren zonder dat andere delen bij wijze van spreken offline gaan.
heb je dus een critisch onderdeel draaien in je fpga dan kan je als software/hardware ontwikkelaar er nog steets andere delen (algoritmes) updaten in je fpga logic.

lees stof : https://topicembeddedprod...dyplo/technical-benefits/
Dat lijkt me nogal boud - om een vergelijking te trekken: Apple heeft de SoC en de modemchip niet op 1 die geintegreerd, en Mediatek wel. Betekent dit dat Apple ver achterloopt op Mediatek? Natuurlijk niet. Is een PC met losse nVidia GPU en losse Xeon CPU (zonder IGP) ver achter op een PC met een APU erin? Ook niet natuurlijk. Ze maken enkel de keuze voor een design met 2 krachtige aparte chips versus de compromissen die je mbt performance en kosten moet doen om ze beide op 1 die te bakken.

[Reactie gewijzigd door Dreamvoid op 16 november 2016 20:15]

En hoe moet ik dat dan zien, worden er fysiek and / or schakelingen omgezet in dit apparaat om zo de hardware te veranderen. Of is dit op een virtuele laag, wat zou klinken dat het niets uitmaakt dan op een gewone processor een virtuele laag te creŰren?
VROEGER, was het zo dat een FGPA werkte met echte poorten. (NAND, NOR,..)
De chip bestond uit allemaal poorten, allemaal met elkaar verbonden.
Door verbindingen door te branden, kon je bepaalde logica hardware matig maken.

Met een software programma tekende, of beschreef je de logica voor de poorten, waarna dit in dit chip werd geflashed.

Iedere poort heeft een waarheidstabel, tegenwoordig worden deze tabellen als lookuptables gebruikt om je logica naar hardware te flashen.
Het voordeel is dat de chip steeds opnieuw geflashed kan worden.
Eens je FPGA geflashed is, werkt het inderdaad als een gewone chip met in en uit. Let op, ook hier zijn er natuurlijk vertragingen. Om digitale gegevens te verwerken, werk je nog steeds met een klok, en sommige FPGA's komen niet verder dan 50MHz, maar laat je niet beetnemen, op 50MHz kan je al bijzonder veel berekenen!

* Field Gate Programmable Array, het gaat hier om poorten, niet om individuele transistors, al zal het waarschijnlijk ook wel mogelijk zijn.

[Reactie gewijzigd door g4wx3 op 16 november 2016 14:36]

* Field Gate Programmable Array, het gaat hier om poorten, niet om individuele transistors, al zal het waarschijnlijk ook wel mogelijk zijn.

FYI: Los daarvan schrijf je de term consequent verkeerd.
Het is FPGA oftewel Field Programmable Gate Array.
Je hebt een groot aantal functieblokken met bijvoorbeeld and, or, counter functies e.d. Met VHDL of Verilog beschrijf je hoe deze elementen aan elkaar verbonden worden. Als je dus bijvoorbeeld 1 +1 optel chip wil maken verbind je een aantal poorten (bijvoorbeeld een OR en een AND). Dat flash je in de chip als je dan spanning op de pinnen zet komt er bijna direct een signaal op de uitgangspin. Dit is dan simpel maar je kan op deze manier ook hele computerchips flashen.

In software zou je dan eerst de pinnen moeten uitlezen, waarde in een register zetten, optellen en dan een uitgangsregister beschrijven. Een virtuele laag is dus per definitie trager.
Wil je zeggen dat dit ook normaal gebeurd als ik iets 'flash', bios bijvoorbeeld?

Thanks voor de answers, ik begon even te twijfelen O-)

[Reactie gewijzigd door Mic2000 op 16 november 2016 13:53]

je bios is opgeslagen in geheugen, dus je flasht eentjes en nulletjes die een programma en/of settings representeren.

In een FGPA flash je niet een programma of data, maar de daadwerkelijke logische gates waar een programma en/of data door verwerkt worden. Je verandert dus hoe de chip instructies verwerkt, welke instructies het kan verwerken en in welke volgorde. Als jij dus bijvoorbeeld veel berekeningen wilt gaan doen waar data eerst vermenigvuldigd word en er vervolgens iets bij opgeteld word dan flash je je FGPA om parallel heel veel verschillende data tegelijk te kunnen vermenigvuldigen in stap 1 en in stap 2 die optelsom te doen met de resulterende data zonder dat je (zoals in een CPU) al die data naar de compute unit moet sturen verantwoordelijk voor vermenigvuldiging, vervolgens terug naar je CPU cache, en dan naar de compute unit die optellen voor zijn rekening neemt, en dan weer terug naar cache/ram.
Nee dat is vaak gewoon een microcontroller/microprocessor en je flashed de programma code. Dat is dus fixed hardware die meer als een CPU werkt.
Een FGPA "flash" je ook niet (da's antieke technologie), die "programmeer" je.

Het programmeren is volatile (vluchtig), net als bij RAM gaat dit verloren als de voeding wegvalt. Doorgaans zit er dus wel flash geheugen in de buurt van de FPGA om die bij het opstarten te programmeren. Je kunt een FPGA dus, net als RAM, vrijwel onbeperkt programmeren, hij slijt er niet van (in tegenstelling tot "flash"). Als je de programmeerdata snel genoeg kunt aanleveren (of een voldoende klein deel van de FPGA herprogrammeert, dat kan ook), kun je 'm dus ook time-sharen door hem tussendoor te voorzien van nieuwe instructies.

Combinaties kunnen ook, zo'n PCI kaart kan bijvoorbeeld initieel opstarten uit een flash chip met net genoeg logica om met de PCI host te communiceren, en vervolgens kan de rest van de FPGA programmering van de host komen. Ook handig om "live" nieuwe dingen uit te proberen.

De FPGA is inderdaad in staat om zichzelf te programmeren (net als een CPU eigenlijk...).

Om een idee te geven, een Zynq 7030 heeft ongeveer 5,5MB (ja, megabyte) configuratie data nodig om in zijn geheel geprogrammeerd te worden. Ik heb hier ook nog een "middenmaatje" MPSoC liggen, daar moet je 26MB naartoe sturen om 'm aan het werk te krijgen.

[Reactie gewijzigd door cdwave op 16 november 2016 15:38]

Het is daadwerkelijk herconfigureerbare hardware.
Er worden fysieke (met transistoren) connecties gemaakt tussen de poorten. De definitie van deze transistoren (aan of uit/verbonden of niet) komt meestal uit een bestand met enen en nullen waarin voor elke transistor staat of hij verbonden moet zijn of niet.
Bedankt, weer wat geleerd (+3) gegeven, maar help me even...techniek is dan duidelijk, maar wat is de toepassing dan waarvoor je het gebruikt? virtuele desktops? medische dna calculaties of de stand van de maan over 40 jr < en daar de berekening van ....
Het is niet per se gericht op zware taken zoals supercomputers, het is gericht op het dedicated gebruiken van hardware. Een CPU kan in theorie alles, en is in alles dus 'redelijk' snel, en daar houdt het op. Een blu-ray film transcoderen op je CPU gaat zoals je misschien wel weet alleen niet erg vlot. Vandaar dat je bij specifieke, simpele maar toch CPU-zware taken hardware acceleration gebruikt en geen CPU.

Alles wat 'hardware geaccellereerd' is, komt uit een fysieke schakeling en dus niet uit software die op een controller/CPU draait. FPGA is het dichtstbij wat je kan komen zonder bij TSMC e.d. chips te gaan bestellen voor bijvoorbeeld je DAC, H264 encoder, Bitcoin miner, SSD controller noem maar op. Een FPGA is dan opzicht een 'versatile IC'. Nieuw algorithme? Laad het erin en gaan. Het nadeel is alleen dat een FPGA een orde van grootte duurder is dan een gebakken IC, en ook concessies moet doen qua specs, zoals maximale warmte en de verbindingen naar buiten toe.

FPGA is echter ontstaan als protoyping van IC's. Het is in wezen de laatste stap die je kan zetten voordat je een echte IC laat bakken, om je design (functioneel) te controleren.
Microsoft is momenteel bezig met een rollout binnen Azure die FPGA toevoegd. En ze leggen ook duidelijk uit hoe dit voordelen heeft. Hun hololens HPU is er mee gebouwdt.
Azure runs a vast number of virtual machines on a substantial number of physical servers, using a close relative of Microsoft's Hyper-V hypervisor to manage the virtualization of the physical hardware. Virtual machines have one or more virtual network adaptors through which they send and receive network traffic. The hypervisor handles the physical network adaptors that are actually connected to Azure's networking infrastructure. Moving traffic to and from the virtual adaptors, while simultaneously applying rules to handle load-balancing, traffic routing, and so on, incurs a CPU cost.

This cost is negligible at low data rates, but when pushing multiple gigabits of traffic per second to a VM, Microsoft was finding that the CPU burden was considerable. Entire processor cores had to be dedicated to this network workload, meaning that they couldn't be used to run VMs.

The Bing team didn't have this network use case, so the way they used FPGAs wasn't immediately suitable. The solution that Microsoft came up with to handle both Bing and Azure was to add a second connection to the FPGAs. In addition to their PCIe connection to each hardware server, the FPGA boards were also plumbed directly into the Azure network, enabling them to send and receive network traffic without needing to pass it through the host system's network interface.
http://arstechnica.com/in...upercomputing-powerhouse/
De combi maakt het bijvoorbeeld mogelijk om een H.265 Encoder te maken die aan te passen is aan de verschillende video standaarden en bitrates / depths.
Ik denk dat het beter is een daadwerkelijke hardware encoder te maken (zoals intel en nvidia nu ook al hebben), deze kunnen ook gewoon omgaan met 8 bit en 10 bit en verschillende bitrates.
Eens, maar wat nu als je niet iets anders nodig hebt.

WDR, HDR of een andere resolutie, beeld verhouding, framerate etc...
Die zijn eigenlijk allemaal configurabel te maken zonder de hardware te veranderen. Het grote nadeel van FPGA's is dat de kloksnelheid een duidelijk limiet heeft wat een stuk lager ligt dan een hardware encoder (bijvoorbeeld) kan hebben. Terwijl het verbruik dan weer een stuk hoger ligt voor FPGA's. En dan is het gewoon praktischer om een nieuwe ASIC te maken vooral op die volumes.

Huidige encoders (GTX960 bijvoorbeeld) supporten ook gigantisch veel opties, van resolutie en pixel formaat tot hele kleine dingen voor de h265 encoding.
Daar zal een directe hardware implementatie natuurlijk ook in uitblinken. FPGA's blinken vooral uit in specifieke iet wat parallelle processen. En natuurlijk digitale signaalbewerking.
Meestal zijn die opties simpele numerieke waarden of vlaggen die anders worden meegenomen in de berekeningen in het algoritme. Er verschilt niets wezenlijks tussen een 640x480p25 H.264 en een 1280x720i50. Deep down zijn het bepaalde berekeningen die worden uitgevoerd op groepen pixels. Dus of die nou 8 of 10 bits per pixelkleur zijn, vaak per seconde voorbij komen of er heel veel van in een frame zitten verandert wel iets aan het effect op de kijker, maar niet aan de berekeningen an sich.
Nee, een "harde" H.265 encoder is veel efficienter. Zo'n encoder zou een behoorlijk forse FPGA in zijn geheel vullen en dan nog niet gelijk presteren.

Wel komen er FPGA's met geintegreerde H265 codecs (de Ultrascale van Xilinx onder andere). Daarmee kun je bijvoorbeeld realtime radarbeeld naar een tablet streamen...
Dan kan je ook gewoon een Kaby Lake chip kopen.
Het grote voordeel van FPGA is dat het kan zonder klok.
Een "if then else" is in de normale processor wereld afhankelijk van de klok, alle 3 bewerkingen (if then en else) hebben een aantal klokcycli nodig om de data te verplaatsen en te bewerken.
In de FPGA is een klok niet nodig, de snelheid is afhankelijk van de halfgeleiders. Een "if then else" is dus niet een reeks bewerkingen maar is een voorgeprogrammeerde single step algoritme, en kan dus b.v. in pico seconden.
Een ander voordeel van FPGA is dat je de programmering kan aanpassen, aanpassen is niet zo snel maar kan handig zijn. Na het booten is de FPGA weer klaar voor een ander doel. De echt snelle Firewalls worden op deze manier van updates voorzien.
Doordat de andere manier van denken (parallel algoritme i.p.v. serieel uitvoeren) niet makkelijk is zie je dat veel FPGA ontwerpen weer een klok gaan gebruiken en daarmee wordt de snelheid verlaagd :-(
Ook in de FPGA gaat tegenwoordig alles op de 'beat' van een klok. Het kan zogeheten asynchroon maar dat is niet echt 'good workmanship' tegenwoordig.

Wel kan je de datapaden maximaal parallel maken waardoor je veel minder klok cycli nodig hebt.
Clock-loze hardware, oftewel asynchroon hardware design, is een totaal andere tak van sport die los van FPGAs bestaat. Er is in het verleden veel onderzoek naar gedaan met soms best aardige resultaten, maar het heeft nooit een grote vlucht genomen. Moderne design tools zijn hier simpelweg niet op ingericht of voor geoptimaliseerd.

Dit is voor FPGA design niet anders. FPGAs zijn uitgerust met allerlei zaken, PLLs, clock-generators, flip-flops, etc, die nodig zijn voor synchrone designs. Hiervoor zijn FPGAs geoptimaliseerd.

Dat wil niet zeggen dat je op een FPGA geen asynchroon design kunt mappen, net als dat met regulier VLSI design kan, maar wel dat het niet sneller of efficienter zal zijn dan een synchrone variant en dat er geen tools voor handen zijn om je te helpen met buffer-insertion en andere trucs die nodig zijn om de delays door je asynchrone hardware te matchen, of om zo'n design te simuleren en verifieren.

Ik weet eerlijk gezegd niet waar je dit vandaan haalt, maar asynchroon design is GEEN typische, of zelf atypische usecase voor FPGAs.

[Reactie gewijzigd door RickN op 16 november 2016 14:36]

Zouden er ook compilers komen die bepaalde software onderdelen omzetten in fpga-programma's? Bijv. een nieuw cryptografie algoritme die dan op een fpga wordt uitgevoerd. Dus programmeren in gewoon c++ of zoiets en automatisch fpga-ontwerp.
Er bestaan al tools die dit kunnen, al blijft het super lastig dit te programmeren door de totaal andere 'manier van denken'.
Zie o.a. https://en.wikipedia.org/wiki/C_to_HDL


Overigens is het niet gek dat dit er aan komt , en steeds beter wordt, Intel heeft immers een enorm belang om dit werkend te krijgen. Hoe 'eenvoudiger' het is om te programmeren voor dit speelgoed, hoe meer Intel kan verkopen. Als't niet zo efficient is, geeft dat niet eens persee heel veel... je plakt er gewoon wat meer hardware tegenaan. Intel vindt meer hardware zeker neit erg, en blijft ons dus volop vertellen dat software-optimalisatie duur is, en hardware goedkoop.

[Reactie gewijzigd door Luxx op 16 november 2016 15:52]

Met de Intel FPGA SDK for OpenCL is dit al wat eenvoudiger geworden.
En dat is ook niet zo gek. Want OpenCL is veel geschikter dan C om naar een accelerator te compileren, of in dit geval naar een FPGA. C in het algemeen is namelijk niet compileerbaar naar hardware, zo is het bijvoorbeeld heel moeilijk om om te gaan met niet pure functies, die dus via pointers operaties op geheugen doen met allerlei voor de compiler moeilijk te analyzeren side-effects waarbij type safety totaal niet gegarandeerd is. Je zal daarom altijd maar een stricte subset van de features van de C taal kunnen ondersteunen in een C naar HDL/RTL/FPGA compiler, hoogstwaarschijnlijk met zeer sterke restricties op het gebruik van pointers. Je kan natuurlijk altijd een general purpose CPU instantieeren op je FPGA die dit wel kan, maar dan streef je je originele doelstelling nogal voorbij ;)

Wellicht is het makkelijker om functionele talen naar FPGA te compileren, maar ook daar zijn grenzen. Niet strikt gelimiteerde recursie bijvoorbeeld, die je alleen in een FPGA kan doen als je het als een tail-recursion kan herschrijven.
Die C naar hardware van Intel komt er ook aan, maar dat is nog wat onder NDA. Stuur maar een PB als je meer wil weten :-)
Intel vindt meer hardware zeker neit erg, en blijft ons dus volop vertellen dat software-optimalisatie duur is, en hardware goedkoop.
En dat is ook zo - niet zozeer omdat Intel dit leuk vindt, maar omdat programmeurs zo veel geld vragen en silicon in hoog tempo goedkoper wordt.
Ik neem aan dat dit model bedoeld is voor het concurreren met wat Microsoft doet met hun Azure servers, waar ze al een tijd bezig zijn met het ondersteunen van deep learning via FPGA op elke server maar dan via een apparte door MS ontworpen chip.
Microsoft koopt juist de Altera-FPGA's, en is de reden dat Intel het bedrijf Altera heeft overgenomen.
Microsoft’s services are so large, and they use so many FPGAs, that they’re shifting the worldwide chip market. The FPGAs come from a company called Altera, and Intel executive vice president Diane Bryant tells me that Microsoft is why Intel acquired Altera last summer
https://www.wired.com/201...uture-chip-reprogram-fly/
Interessant, het ziet ernaar uit dat Microsoft inderdaad de structuur op de blades rondom de FPGA's heeft gecreŰerd, de FPGAs heeft geprogrammeerd, maar de FPGA chip niet zelf heeft ontworpen.

Dan vind ik nieuws: Microsoft gaat eigen herprogrammeerbare chips inzetten voor deep lear... toch wel een beetje foutief.

[Reactie gewijzigd door Kerome op 16 november 2016 17:07]

Wat er hier in het artikel staat:
Het gaat om een on-package-integratie van de fpga op de Xeon E5-chip en de processor is op de Broadwell-EP-architectuur gebaseerd, bevestigde Intel tegen Servethehome.
... is een zin die zichzelf tegenspreekt ;)

Het is inderdaad (zoals je op de tweede foto kan zien) een on-package integratie, waarbij de FPGA en de x86 CPU twee aparte dies zijn, dus de FPGA is niet geintegreerd op de Xeon E5-chip zelf. Op de package zullen ze waarschijnlijk direct over PCIe of iets dergelijks communiceren, het lijkt me sterk als ze op zo'n korte termijn al QPI integratie zouden hebben geimplementeerd.

Ik ben ook niet verbaasd dat het een on-package integratie is, een on-chip integratie zou wel heel erg snel zijn aangezien Altera pas een jaar geleden is overgenomen door Intel. Een dergelijk geintegreerde chip ontwikkelen, testen en productie klaar maken krijg je niet in zo'n korte tijd voor elkaar als je net een ander bedrijf hebt overgenomen. Maar als je al de twee chip designs op de plank hebt liggen en ze al zonder moeite uit de fabriek rollen, dan kan je ze waarschijnlijk met weinig moeite aan elkaar knopen op een package, en dan is dit het eindresultaat.

Ik vraag me af of het productietechnisch goed mogelijk zou zijn om een FPGA te integreren op een x86 chip, zonder hem verschrikkelijk inefficient (en veels te groot) te maken. Een general purpose CPU chip heeft over het algemeen een groter aantal lagen dan bijvoorbeeld ASIC logica; daardoor zijn simpelere logica blokken over het algemeen iets groter qua afmeting, maar het groot aantal lagen heb je nodig om alle complexe verbindingen te kunnen maken in een CPU. Ik weet niet hoeveel lagen een FPGA chip in het algemeen heeft, en hoe dat zich verhoudt tot die van een CPU. Maar stel dat een FPGA veel minder lagen bevat, dan zouden de design macros van de FPGA logica waarschijnlijk veel groter uitpakken als ze op het productie proces van een CPU met veel meer lagen worden geplaatst.

Ik verwacht hierom dat de volgende stap van Intel op het gebied van CPU/FPGA integratie meer zoiets zal zijn als AMD's Fury GPU en de integratie daarvan met HBM; een verbinding gebaseerd op een silicon interposer met TSVs, of eventueel een directe 3D stacking van FPGA en CPU chips -- maar dat lijkt me qua hitte productie onwaarschijnlijk. Ik verwacht dat we er de komende jaren een stuk meer over zullen gaan horen in ieder geval :Y)
QPI is gewoon mogelijk op een FPGA. Kwestie van een IP lego blokje.

De Stratix 10 met HBM2 integratie is al aangekondigd.
QPI is gewoon mogelijk op een FPGA. Kwestie van een IP lego blokje.
I stand corrected. Inderdaad, zo te zien boden beide Xilinx (7 series) en Altera (Stratix 5) al een QPI oplossing aan, dus dan kan je er wel van uit gaan dat ze QPI zullen gebruiken in deze oplossing.

Nog even verder zoeken leverde nog een bevestiging op, namelijk een slide set van intel zelf;
Intel« Xeon«+FPGA Platform for the Data Center
... waar op slide 12 inderdaad een FPGA en Intel CPU met QPI op een package beschreven wordt. Het ziet er naar uit dat wat er vandaag naar buiten gekomen is het resultaat is van het project wat daar tijdens die presentatie vorig jaar al werd beschreven.
Vergeet ook niet dat Intel voor 2010 al bezig was met twee dies (Atom en Altera) op een package te krijgen, toen met PCI Express.

http://www.eejournal.com/...cles/20101123-stellarton/


Om te kunnen reageren moet je ingelogd zijn



Nintendo Switch Google Pixel Sony PlayStation VR Samsung Galaxy S8 Apple iPhone 7 Dishonored 2 Google Android 7.x Watch_Dogs 2

© 1998 - 2016 de Persgroep Online Services B.V. Tweakers vormt samen met o.a. Autotrack en Carsom.nl de Persgroep Online Services B.V. Hosting door True