In een enkelvoudig uitgevoerde PC zijn al deze componenten tenminste eenmalig aanwezig.
In een dubbel uitgevoerde PC (dual PC) zouden al deze onderdelen tenminste tweemaal beschikbaar moeten zijn. Dat wil zeggen ten minste twee Rekenkundige eenheden, maar ook twee Vaste schijven.
In een dergelijke PC is de prestatie van een en het zelfde programma precies hetzelfde of je het nu een of twee keer uitvoert, in de veronderstelling dat elk programma gelijktijdig parallel van alle componenten gebruik kan maken.
Dit geldt zowel wanneer de toepassing sterk CVE gebonden is, als vergeleken met sterk IO gebonden. Het eerste wil zeggen dat het veel rekenkundig berekeningen vergt en veel gebruik maakt van de rekenkundig eenheid, het tweede wil zeggen dat het programma veel gebruik maakt van de harde schijf.
Dit is niet noodzakelijk het geval wanneer de vaste schijf niet dubbel is geīnstalleerd.
De prestaties van de twee CVE gebonden programma's zal niet veranderen als je het programma een maal of twee maal uitvoert. Aan de andere kant de prestatie van twee IO gebonden programma's verminderd.
De reden is omdat gedurende het uitvoeren beide programma's van de zelfde bron (de vaste schijf) gebruik willen maken, en dat is niet mogelijk van daar dat de prestatatie van zowel beide verminderd.
Detail
We gaan nu ieder van de componenten meer in detail bestuderen.
- De harde schijf is de belangrijkste primaire massa opslag eenheid die programma's en gegevens bevat.
De snelheid van dit medium is in verhouding langzaam.
- Het langzame geheugen is het tweede niveau van opslag voor programma's en gegevens.
De snelheid is middelmatig.
Programma's die men wil uitvoeren, worden eerst gekopieerd van de harde schijf naar het langzame geheugen en als men klaar is dan worden de (gewijzigde) programma's terug gekopieerd van het langzame geheugen naar de harde schijf.
- Het snellle geheugen is een derde niveau van de opslag voor programma's en gegevens.
De snelheid is snel.
Programma's in het snelle geheugen zijn klaar om te worden uitgevoerd.
Het besturingssysteem zorgt voor de controle tussen het snelle en langzame geheugen.
- Ieder afzonderlijk programma van een PC is een taak (in langzaam of snel geheugen).
Elke taak wordt geīdentificeerd door wat heet een taak status buffer of TSB. Een taak status buffer bevat alle noodzakelijke gegevens om er voor te zorgen dat de uitvoering van het programma goed verloopt.
Om dit te doen bevat het TSB het begin adres van het programma een voorzettings adres en de tijd.
- Het begin adres geeft de plaats aan waar het programma begint. Dit is noodzakelijk om het programma te starten. Het voorzettings adres is om te weten waar je verder moet gaan als het programma tijdelijk is onderbroken en de tijd is belangrijk, om aan te geven wanneer je een programma de volgende keer wil starten.
-
Elke taak status buffers bevat een verwijzing naar het volgende taak status buffer.
Deze hele reeks van taak status buffers vormt een ketting. Een ander woord voor taak is draad (thread).
- Taak Beheer heeft drie taken:
- De besturing doorgeven naar de volgende taak (draad) in de ketting.
- Het bijwerken van de informatie in de ketting wanneer een programma tijdelijk onderbroken moet worden of voltooid is.
- Verwijzingen toevoegen of verwijderen in de ketting naar de taakstatus buffers wanneer taken (draden) worden toegevoegd of verwijderd.
- Er zijn vier soorten registers:
- Programma register of Instructie teller. Dit register bevat het geheugen adres van het Programma.
Na elke uitgevoerde instructie wordt dit adres met een verhoogd (ervan uitgaande dat alle instructies dezelfde lengte hebben) of het Programma register krijgt het adres bepaald door een sprong (go to, of if) instructie.
Om het programma te starten Kopieerd Taak Beheer dit adres vanuit het TSB naar het Programma Register. Het omgekeerde gebeurd als het programma tijdelijk vertraagd wordt.
- Instructie Register.
This register contains the instruction copied fast memory at the Program Register.
Dit register bevat de instructie gekopieerd snel geheugen op het programma te registreren.
It is possible that in a single processor CPU the CPU has more instruction registers to improve performance.
Het is mogelijk dat in een enkele processor CPU van de CPU meer instructie registers heeft om prestaties te verbeteren.
- Gegevens Data Registers. Hiervan zijn er meestal vele.
Er zijn twee soorten: Input gegevens en output gegevens.
-
De Rekenkundig eenheid is het belangrijkste onderdeel.
Dit is het centrum van de CVE (CPU) waar de wiskundige bewerkingen worden uitgevoerd zoals: Optellen, aftrekken, vermenigvuldigen en delen. Input komt van de input registers en de resultaten worden opgeslagen in de output registers.
Dit beschrijft min of meer alle eenheden van een CVE (CPU).
Meerdere Processors, Parallel programmeren en Hyper-draden (Hyper-Threading)
In een enkelvoudige CVE (CPU) is er tenminste sprake van snel geheugen, een set van de alle registers en een Rekenkundige Eenheid. Dit heet ook wel: een pijplijn. De maximum prestatie is 100%. We spreken hier ook van een CVE met een kern (one core CPU). De kern slaat op Rekenkundige Eenheid.
In een dubbel uitgevoerde CVE heb je twee afzonderlijk pijplijnen nodig. We spreken hier ook van een twee kernen CVE omdat er sprake is van twee Rekenkundige Eenheden. De maximum prestatie van iedere pijplijn is 50%. De belangrijkste eis is twee afzonderlijke Programma Registers. Als je over twee aparte Programma Registers beschikt dan kun je in principe twee programma's gelijktijdig uitvoeren om twee verschillende problemen optelossen. Je kunt ook gebruik maken van multiprogrammeren om een probleem optelossen. Multiprogrammeren geeft de mogelijkheid om het ene programma in twee taken (threads) op te splitsen en ieder van die taken (threads) in parallel uit te voeren. Multiprogrammeren vereist synchronisatie binnen de individuele taken (threads) van het programma.
In een viervoudige (Quad) uitgevoerde CVE moet er sprake zijn van vier complete aparte pijnlijnen. We spreken hier ook van een vier kernen CVE omdat er sprake is van vier Rekenkundige eenheden. The maximum prestatie van iedere pijplijn is 25%. Dat wil zeggen je kunt tegelijktijd 4 onafhankelijke programma's hebben om 4 verschillende problemen op te lossen of een programma die dan weer bestaat uit 4 taken of draden(threads) om een probleem op te lossen. Dit laatste vereist multiprogrammeren en synchronisatie.
In een "1 core" / "2 thread" CVE de "2 thread" slaat op Hyper-Draden (Hyper-Threading). Hyper-draden in dit geval betekend dat alleen de registers tweevoudig zijn uitgevoerd, maar niet de Rekenkundige Eenheid.
Dit betekent van uit het oogpunt van de gebruiker (besturingssysteem) dat dit een dubbel-processor-systeem is en de eerste indruk is dat een dergelijke configuratie twee keer zo krachtig is.
Maar dit is niet noodzakelijk waar, want er is slechts een Rekenkundige Eenheid. Intern is dit een processor met een kern.
- Het meeste voordeel en verbeterde prestaties krijgt men in een dergelijke configuratie als in een hyper-draad het programma sterk IO gebonden is, terwijl in de andere hyper-draad het programma sterk CPU gebonden is.
Als eerste programma de harde schijf nodig heeft dan kan het tweede programma direct tijdelijk overnemen en de Rekenkundig Eenheid gebruiken totdat het eerste programma klaar is met de harde schijf.
Dat betekent dat een dergelijk werkwijze veelvuldig gebruik maakt van het overschakelen tussen beide hyper-draden.
Een CPU met genoeg snel geheugen en ten minste alle registers tweemaal uitgevoerd zal beter presteren dan "in dit geval" dan een CPU die deze mogelijkheid niet heeft.
- Het minste voordeel heb je met een dergelijke configuratie als de programma's in beide hyper-draden sterk CPU gebonden zijn.
De reden is eenvoudig, omdat beide programma's wiskundige berekeningen uitvoeren en ieder de Rekenkundig Eenheid verreisen.
Dat deel is de flessenhals en omdat dat deel niet dubbel is uitgevoerd zal de algemene prestaties niet verbeteren.
De prestaties kunnen zelfs dalen, omdat:
- ten eerste, in het geval dat je een fysische toepassing wilt oplossen en de CPU voor 100% wilt gebruiken dan moet je parallel programmeren toepassen.
Dat betekent dat je de toepassing moet opsplitsen in twee onafhankelijke delen. Daarnaast moet je dan een vorm synchronisatie tussen beide delen toepassen om de oplossing te vinden. Deze synchronisatie vereist extra CPU-rekenkracht, die de algehele prestaties zal afnemen. De twee onafhankelijke delen komen overeen met de hyper-draden bij het uitvoeren van het programma.
- ten tweede omdat extra CPU-hardware om hyper-threading te ondersteunen kan resulteren in een lagere kloksnelheid. Een extra kern kan het zelfde effect hebben.
In de bovenstaande tekst wordt het woord Hyper-Threading gebruikt met het doel om een CPU architectuur te beschrijven die uit het oogpunt van de gebruiker lijkt op twee processoren dat wil zeggen twee rekenkundig eenheden, maar fysiek is dit niet het geval.
Een veel betere naam is Virtuele Processor.
Met een CPU i5, die een 2 Core / 4 Thread architectuur heeft, kun je bij het laden van het programma PlanetS, dat geschreven is in Visual Basic 2010 en dat niet gebruik maken van de BackGroundworker (hyper-threads) direct aflezen dat het aantal threads dat taak-beheer gebruikt 5 is. Dit komt overeen met het aantal Gebeurtenis Handelaars (Event handlers)
Dit is het geval voor alle Visual Basic 2010-programma's na het laden en is onafhankelijk van het aantal gebruikte BackGroundworkers.
Het aantal processen dat elk programma vertegenwoordigt is 1.
Met dat zelfde CPU als ik het programma PlanetPP plotseling beindig (Ook Visual Basic 2010) met 5 BackGroundworkers actief dan daalt het totale aantal threads met 10.
Dit vertelt me dat een thread (draad) (in het kader van de taak-beheer) veel meer een taak (programma) is en dat het de taak van de taak-beheer is om taken toe te wijzen (of te verwijderen) aan een van de (in het geval van een i5) 4 virtuele processoren. Dat betekent i5 2 Processors en 4 Virtuele Processors heeft.
Core 1
Virt Proc 1 Virt Proc 2
---------- -----------
Snel Pr Geh 1 Snel Pr Geh 2
| |
P Reg 1 P Reg 2
| |
Ins Reg 1 Ins reg 2
| |
------------------
|
I1 I2 I3 | O1 O2 O3
|
Rekenkundige Eenheid 1
Add 1 Sub 1 Mul 1 Div 1
Move 1
|
Core 2
Virt Proc 3 Virt Proc 4
----------- -----------
Snel Pr Geh 3 Snel Pr Geh 4
| |
P Reg 3 P Reg 4
| |
Ins reg 3 Ins Reg 4
| |
------------------
|
I1 I2 I3 | O1 O2 O3
|
Rekenkundige Eenheid 1
Add 2 Sub 2 Mul 2 Div 2
Move 2
|
***********************
* Gemeenschappelijk *
* geheugen*
* M1 M2 M3 M4 *
***********************
^
|
|
|
<-------------
|
Figure 1: 2 Core / 4 Thread CPU
|
Figure 1 Shows a 2 Core / 4 Thread. Dat wil zeggen:
- Dat er 4 virtuele processoren zijn. Elke virtuele processor bevat een van elk:
- Snel Programma Geheugen, Programma Register en Instructie Register
-
Het Programma Register bevat een verwijzing naar het Snelle Programma Geheugen.
Het Instructie Register bevat de instructie op die locatie.
- Er zijn 2 Rekenkundig Eenheden.
Elke rekenkundig Eenheid bevat een van elk:
-
Logische Ingang registers, Logische Uitgang Registers, Opteller, Aftrekker, Vermenigvuldiger, Deler en Verplaats (move)
Als we het hebben over een 2 Core / 2 Draden (Threads) CVE, dan zijn er geen virtuele processoren 2 en 4.
Er is een Gemeenschappelijke-Geheugen.
Beide Rekenkundige Eenheden hebben direct toegang tot dit geheugen door middel van het Verplaats bewerking (of iets vergelijkbaars) Dor middel van de Verplaats bewerking kan men gegevens lezen en schrijven van Gemeenschappelijk-Geheugen data naar en van hun input en output registers.
In het geval van parallel programmeren reserveert elk programma een klein gedeelte van dit Gemeenschappelijke-Geheugen, geīdentificeerd als M1, M2, M3 of M4, voor gegevens opslag.
Een voorbeeld terverduidelijken is om deze gegevens op te vatten als een opdracht. De programma's PlanetPP en FibonacciPP doen dit met behulp van de getallenrij STATE(i).
Om het parallel programmeren goed te laten werken met Visual Basic:
- Moet je jouw toepassing opdelen in onafhankelijke takken. Elk tak wordt dan geimplementeerd als een Backgroundworker. Elke BackGrounworker werkt als een draad (thread) in een verschillende Virtuele Processor.
- Een BackGroundworker is de meester (baas). De anderen BackGroundworkers zijn slaven.
- De meester Backgroundworker zet alle opdrachten naar een specifieke waarde en om alle slaven aan te duiden wat ze moeten doen.
Ieder slaaf onderzoekt zijn eigen Opdracht om te weten wat te doen met behulp van M2, M3 of M4. Bijvoorbeeld Backgrounworker 2 gebruikt STATE(2).
- Ieder slaaf zet zodra men klaar is de opdracht terug naar nul.
- De master gebruikt dit als een indicatie dat een iteratie is voltooid en dat de volgende kan beginnen.
Als je deze strategie volgt dan is er geen kans van race condities.