Lunds universitet Parallellism i CDC 7600, pipelinens ursprung Henrik Norrman EITF60 Datorarkitekturer med operativsystem Kursansvarig: Erik Larsson 4 december 2017
INNEHÅLL Parallellism i CDC 7600 Innehåll 1 Introduktion 2 2 Syfte 2 3 Arkitektur 3 PPU...................................... 3 CPU...................................... 4 Översikt................................. 4 Beräkningsenhet............................ 4 SCM och LCM............................. 5 4 Parallellism 6 CIW (Current Instruction Word)...................... 6 Busy flag................................... 6 Segmentering................................. 7 Exempel på exekvering............................ 8 Klockcykel 0............................... 8 Klockcykel 1............................... 8 Klockcykel 2............................... 9 Klockcykel 3............................... 9 Klockcykel 4............................... 9 Klockcykel 5............................... 10 Klockcykel 6............................... 10 Klockcykel 7............................... 10 Klockcykel 8............................... 11 5 Slutsats 11 6 Referenser 12 1
1. INTRODUKTION Parallellism i CDC 7600 1 Introduktion Control Data Corporation eller CDC, ett företag idag helt okänt för de flesta, var under 1900-talet hjärnorna bakom flera av världens då snabbaste datorer. Under en tid då det tog längre tid att procesera data än vad det tog att ladda in samma data från minnet, var processorn oftast flaskhalsen i marknadens då bästa datorer. Seymour Cray, den ledande konstruktören av CDC, var väl medveten om detta. CDC men framför allt Cray hade som mål att skapa en dator snabbare än något jätten IBM någonsin lyckats skapa (The CDC 6600 Project, 1980). För att åstadkomma detta utnyttjade Cray parallellism för att öppna upp processorns flaskhals, och många principer som fortfarande används idag tog form. CDCs första stora projekt, CDC 6600, var världens snabbaste dator mellan 1964 och 1969, men förutom sin titel som världens snabbaste dator i fem år, var den även känd för sin revolutionerande teknik. Inte bara var den först med multitrådning och superskalär arkitektur, men den ses också som RISC-processorns förfader (Gordon, 1998). CDC 6600 var dessutom det första systemet med dynamic scheduling (eller out-of-order execution) (Smith, 1989). Denna rapport kommer dock inte fokusera på CDC 6600, utan Crays nästa projekt, CDC 7600, en dator nästan identisk till CDC 6600 förutom att den också använde sig av instruction pipelining (Gordon, 1998). Med denna då väldigt nya teknik, tog den över som världens snabbaste dator, och höll titeln i nästan 7 år. One of my guiding principles is don t do anything that other people are doing. Seymour Cray 2 Syfte Syftet med denna rapport är att få en inblick i hur ett gammalt system som CDC 7600 fungerar. Först genom att kolla övergripande på arkitekturen, och sedan genom att kolla djupare på den parallellism som systemet var bland de första i världen med att använda sig av. 2
3. ARKITEKTUR Parallellism i CDC 7600 3 Arkitektur PPU Systemet består av tio stycken PPU (Peripheral Processing Unit), dessa är alla självständiga enheter som procceserar den data som skickas mellan de åtta I/Oenheterna och den centrala processorn. Vid inkommande data eller behov av systemets minne, skickas en interrupt från PPU-enheten till den centrala processorn (Sutherland et al., 1971). Den centrala processorn behöver alltså aldrig proccesera information direkt från I/O-enheterna (se figur 1), detta gör att processorn kan lägga mer kraft på färre instruktioner, och på så sätt arbeta snabbare, en teknik som idag kallas RISC. Fig. 1 Blockdiagram av systemet (Sutherland et al., 1971). 3
3. ARKITEKTUR Parallellism i CDC 7600 CPU Översikt CDC 7600 har en CPU som består av tre delar, en beräkningsenhet (Computation Unit), en SCM (Small Core Memory), och en LCM (Large Core Memory) (CDC, 1969). Dessa enheter arbetar alla synkront efter en klocka med en klockperiod på 27.5 nanosekunder (CDC, 1969), systemet har alltså en klockfrekvens på 36.4 MHz. För att kunna öka systemets klockfrekvens använder CDC 7600, till skillnad från CDC 6600, inte dynamic schedueling utan exekverar instruktionerna i strikt programsekvens (Weiss and Smith, 1984). Beräkningsenhet Beräkningsenheten innehåller nio olika aritmetiska enheter, 24 adresserbara register, och en instruktionsstack med tolv stycken minneplatser (se figur 2). De nio aritmetiska enheterna kan alla arbeta parallellt under samma klockcykel. De adressbara registerna är direkt kopplade till både SCM och LCM, och det tar därför bara en klockcykel att ladda eller spara något till minnet. Beräkningsenheten innehåller också ett CIW (Current Instruction Word)-register där instruktionen får instruktionsstacken sparas precis innan den ska exekveras (CDC, 1969). Fig. 2 Diagram över beräkningsenhetens register och aritmetiska enheter. Figuren hämtad från (Gordon, 1998). 4
3. ARKITEKTUR Parallellism i CDC 7600 SCM och LCM SCM och LCM kan jämföras med moderna processorers cache- och primärminne, där SCM är ett mindre men snabbare minne som ligger närmre processorkärnan, och LCM är ett större minne som SCM hämtar sin data från. Figur 3 visar hur datan stegvis flyttas genom minneshierarkin. Precis som i en modern processor med primär- och cacheminne, måste instruktionerna som ska exekveras först laddas in på SCM innan de kan börja processeras (Sutherland et al., 1971). SCM kan lagra upp till 64K words (word = 60 bitar) medans det betydligt större LCM kan hålla upp till 500K words (Sutherland et al., 1971). Fig. 3 Data flyttas från Disc till SCM via LCM (Sutherland et al., 1971). 5
4. PARALLELLISM Parallellism i CDC 7600 4 Parallellism De nio aritmetiska enheterna i processorns beräkningsenhet (markerade som Functional Units i figur 2); Long Add, Floating Add, Floating Multiply, Floating Divide, Boolean, Shift, Normalize, Population Count, Increment, kan alla arbeta parallellt, vilket betyder att till exempel, en addition, subtraktion, multiplikation och division alla kan påbörjas under samma klockcykel. Detta fenomen kallas superskalär exekvering (Larsson, 2017b), en form av parallellism som fanns redan i CDC 6600. En annan form av parallellism som används i CDC 7600 kallas pipelining, en princip som går ut på att stycka upp en lång process i småsteg, på så sätt kan flera instruktioner bearbetas samtidigt i olika delar av processen (Larsson, 2017a). Systemets pipeline kommer förklaras med de tre nyckelorden; CIW, Busy flag, och Segmentering. CIW (Current Instruction Word) CIW-registret fungerar som ett sista lagringsregister precis innan instruktionen ska exekveras. CIW fungerar som en mellanhand mellan instruktionsstacken och alla aritmetiska enheter (CDC, 1969). Allt som ska exekveras måste alltså först läggas i CIW innan det sedan flyttas vidare till rätt enhet. Busy flag Busy-flaggan används av de aritmatisk enheterna och LCM för att meddela systemet att den är upptagen (CDC, 1969), om flaggan är uppe kan enheten alltså inte ta emot någon data den klockcykeln. Om till exempel Long Add-enheten har satt sin busy-flagga, och en Long Add instruktion ligger redo i CIW, måste instruktionen ligga kvar i registret tills följande klockcykel då flaggan tagits bort igen. Flaggan kan också sättas av LCM, och de aritmetiska enheterna tvingas då vänta med att skriva tillbaka ett resultat tills LCM är redo att ta emot ny data igen. Flaggan används som en enkel kontroll för att säkerställa att det är lämpligt att mata enheten med nya värden. 6
4. PARALLELLISM Parallellism i CDC 7600 Segmentering Tabellen nedan visar hur segmenteringen är uppdelar på de olika enheterna. Segmenttiden är den tid det tar att exekvera varje segment i enheten, medans exekveringstiden är den total tid det tar för värdena att gå genom enhetens alla algoritmer. Aritmatisk enhet segmenttid exekveringstid Long Add 1 clk 2 clk Floating Add 1 clk 4 clk Floating Multiply 2 clk 5 clk Floating Divide 18 clk 20 clk Boolean 1 clk 2 clk Shift 1 clk 2 clk Normalize 1 clk 3 clk Population Count 1 clk 2 clk Increment 1 clk 2 clk Data från (CDC, 1969) Förutom Floating Multiply och Floating Divide är alla enheter uppdelade i segment på en klockcykel, alltså kan dessa enheter ta emot nya värden varie klockcykel. Tabellen visar hur till exempel Floating Add teoretiskt exekveras fyra gånger snabbare med pipelining. 7
4. PARALLELLISM Parallellism i CDC 7600 Exempel på exekvering Nedan följer ett exempel på hur två instruktioner exekveras och passerar genom Floating Multiply-enheten. Notera att det är en Floating Multiply-operation, alltså är segmenttiden 2 klockcyklar, och den totala exekveringstiden 5 klockcyklar. Detta är ett förenklat exempel för att visa hur CIW, Busy flag, och Segmenteringen fungerar tillsammans. Klockcykel 0 clk 0 Input Segment 1 Segment 2 Segment 3 Register 1 Register 2 Klockcykel 1 FLOAT MUL A, A, B clk 1 Input Segment 1 Segment 2 Segment 3 Register 1 A Register 2 B Busy Flag 1 A och B flyttas till enhetens input register. Floating Multiply busy flag = 1 FLOAT MUL A, A, B clk 1 Input Segment 1 Segment 2 Segment 3 Register 1 A Register 2 B Det finns plats inne i enheten, så A och B flyttas direkt in i enhetens första segment. Då värdena flyttats in i enheten kan input registerna ta emot nya värden, busy-flaggan kan därför stängas av. 8
4. PARALLELLISM Parallellism i CDC 7600 Klockcykel 2 FLOAT MUL C, C, D clk 2 Input Segment 1 Segment 2 Segment 3 Register 1 C A Register 2 D B Busy Flag 1 C och D flyttas till enhetens input register. Floating Multiply busy flag = 1 A och B är fortfarande kvar i enhetens första segment, C och D kan därför inte flyttas in i enheten, och måste ligga kvar i input registerna. Klockcykel 3 clk 3 Input Segment 1 Segment 2 Segment 3 Register 1 C A Register 2 D B A och B flyttas vidare till nästa segment. C och D kan då flyttas in i segment 1. Floating Multiply busy flag = 0 Klockcykel 4 clk 4 Input Segment 1 Segment 2 Segment 3 Register 1 C A Register 2 D B A och B - fortfarande i segment 2. C och D - fortfarande i segment 1. 9
4. PARALLELLISM Parallellism i CDC 7600 Klockcykel 5 clk 5 Input Segment 1 Segment 2 Segment 3 Register 1 C A Register 2 D B A och B flyttas vidare till segment 3. C och D flyttas vidare till segment 2. Klockcykel 6 clk 6 Input Segment 1 Segment 2 Segment 3 Register 1 C Register 2 D Resultatet från A och B är klart och kan flyttas till register A (som givet i instruktionen från CIW på clk 1) Klockcykel 7 clk 7 Input Segment 1 Segment 2 Segment 3 Register 1 C Register 2 D C och D flyttas vidare till segment 3. 10
5. SLUTSATS Parallellism i CDC 7600 clk 8 Input Segment 1 Segment 2 Segment 3 Register 1 Register 2 Klockcykel 8 Resultatet från C och D är klart och kan flyttas till register C (som givet i instruktionen från CIW på clk 1) 5 Slutsats Syftet med denna rapport var inte att påstå att en pipeline är allt som krävs för att dubbla ett systems prestanda. Hårdvaran och de exempel som använts är från 1970-talet, en tid då det bara fanns ett fåtal datorer jämfört med idag. De datorer som fanns var också kraftigt begränsade av vad processorn klarade av, därför kunde en liten förbättring i processorn förbättra hela systemet väldigt mycket. Med bara denna rapport är det svårt att få en uppfattning av hur viktigt parallellism är i dagsläget, men det var inte heller syftet. Rapportens mål var att visa en del av de principer som fortfarande används i en så tidig version som möjligt, och detta för att få en förståelse för hur, men också varför de uppkom. 11
6. REFERENSER Parallellism i CDC 7600 6 Referenser Referenser CDC (1969), Control Data 7600 Computer System, Preliminary Reference Manual. Gordon, B. (1998), A seymour cray perspective. Larsson, E. (2017a), Pipeline. Larsson, E. (2017b), Superscalar arkitekturer. Smith, J. E. (1989), Dynamic instruction scheduling and the astronautics zs-1, Computer 22(7), 21 35. Sutherland, G. G., Coverston, H. G., DuBois, P. J., Emery, D. R., Kent, D. A., Lund, P. E., Powles, G. H., Storch, F. D., Tennant, L. O. and Von Buskirk, D. L. (1971), Livermore time-sharing system for the cdc 7600., ACM Operating Systems Review 5(2/3), 6. The CDC 6600 Project (1980), Annals of the History of Computing, Annals Hist. Comput (4), 338. Weiss, S. and Smith, J. (1984), Instruction issue logic in pipelined supercomputers., IEEE Transactions on Computers C-33(11), 1013 1022. 12