Nou zitten we hier natuurlijk allemaal vooral voor de elektronische kant van de zaak en hebben we al de nodige AVR/PIC flamewars gehad (toen ik nog lurkte of postte onder mijn vorige alias, diguru), maar zijn we hier ook geïnteresseerd in de architectuur van CPU's vanuit het programmeer standpunt, of is dat hoogstens een obstakel om de schakeling werkend te krijgen?

Wat dat betreft heb ik een grote voorkeur voor microcontrollers die echt RISC zijn (alles, of bijna alles in 1 klokpuls doen, zolang het duidelijk is welke instructies langer duren), wil heel graag zoveel mogelijk registers (of adressen die in 1 of 2 klokpuls(en) te benaderen zijn), goede ondersteuning voor interrupts op zo'n beetje alles en de mogelijkheid om externe zaken (vooral geheugen) rechtstreeks te benaderen, zonder dat je die eerst via een poort in een register hoeft te laden. En ik wil iedere byte in het geheugen graag op een simpele manier in een register kunnen laden.

Aan de andere kant is me dat worst, zolang de compiler dat allemaal simpel doet (dus eigenlijk liever iets als Pascal dan C), en wil ik vooral dat het simpel is om mijn prototype te ontwerpen en bouwen. Dus hoe meer ik alles kan instellen en configureren in de firmware, en gewoon het dichtstbijzijnde pootje voor de gewenste functie kan gebruiken, hoe beter.

Een simpele "pin mapping table" zou wat dat betreft bovenaan mijn lijstje staan.

Als we het echter gaan hebben over CPU architectuur, dan kom je er al snel op uit, dat 80%+ van alle hedendaagse CPU's intern superscalar RISC zijn. Dat betekent dus, dat ze heel veel registers hebben, alleen hele simpele instructies ondersteunen, een minimale afhandeltijd hebben van meerdere klokcycli per instructie, maar wel iedere klokcyclus een instructie afhandelen (latency) en meerdere dingen tegelijkertijd kunnen doen, maar een beperkt aantal hardware-units hebben voor ieder type bewerking.

Je kunt dus bijvoorbeeld tegelijkertijd een integer en float instructie uitvoeren, maar niet twee van hetzelfde type. En die zijn dan bijvoorbeeld na 16 klokpulsen klaar. Maar er zijn dan nog 15 * 2 andere bewerkingen bezig, waarvan er iedere klokpuls 2 klaar zijn.

En ze hebben allemaal een vertaalslag (decode) van de feitelijke instructie naar een reeks RISC-instructies, vaak via microcode (software in hele snelle ROM), maar tegenwoordig voor de snelheidsmonsters via dedicated hardware. Gewoon omdat bijvoorbeeld op de PC alle programma's de 80386 instructies gebruiken.

Echter, daar een klokfrequentie van rond de drie gigahertz toch wel een grote barrière blijkt te zijn, ligt de nadruk nu op meerdere dingen parallel naast elkaar doen. Dus je programma word niet meer sneller, maar je kunt er meerdere tegelijk uitvoeren.

Er worden dus heel veel transistors verspild met het versnellen en behouden van de i386 instructieset, terwijl die zich nu net heel erg slecht leent voor het verder opvoeren van de snelheid of parallellisme, vooral omdat die niet RISC is en geen benul heeft van andere CPU kernen.

Met bitslices (1-bit ALU's) of zelfs met losse poortjes (of een FPGA voor de gevorderden) kun je zelf een willekeurige processor bouwen. Wat zouden dan jouw ontwerpspecificaties zijn, er van uitgaande dat die architectuur een groot succes word?

het grote probleem van hedendaagse 'programmeurs' is dat ze niks meer kennen van de architectuur... ze kunnen hoogstens wat C of C++ 'kakken'.

en maak van die 80% maar 10% .. Een processor die 2 instructies kan pipelinen of simultaan uitvoeren is al een flinke jongen hoor..
Intel of AMD , Mips en een paar andere grote kleppers.
een doorsnee 8 16 en 32 bitter kan dat allemaal niet.
Een doorsnee risc kan dat ook niet.

Als je alle processoren optelt die vandaag nog van de band rollen ( tussen nu 13u47 en pakweg middernacht) dan zullen van al die chips er maar weinig superscalar zijn hoor ...

dat 80%+ van alle hedendaagse CPU's intern superscalar RISC zijn. Dat betekent dus, dat ze heel veel registers hebben, alleen hele simpele instructies ondersteunen, een minimale afhandeltijd hebben van meerdere klokcycli per instructie,

Dat klinkt veel meer als een GPU van amd of nvidia. Maar met 800 kernen in een chip van AMD wil je enkel simpele instructies.

Er worden dus heel veel transistors verspild met het versnellen en behouden van de i386 instructieset,

Aan de buiten kant denkt de software wel met een i386 of eigenlijk x86 architectuur te maken hebben. Echter intern allang niet meer. De x86 instructies worden vertaald en via de eigen architectuur verwerkt.

Bovenop de x86 heb je nog vele andere instructie set. waarbij intel en AMD soms hun eigen instructieset toepassen.

[Bericht gewijzigd door benleentje op (38%)]

Op 3 september 2009 22:46:41 schreef free_electron:
het grote probleem van hedendaagse 'programmeurs' is dat ze niks meer kennen van de architectuur... ze kunnen hoogstens wat C of C++ 'kakken'.

Nog erger: alleen .NET of Java, met een beetje C van een projectje op school. Moeilijk om mee te praten. Maar wel de grote doelgroep.

en maak van die 80% maar 10% .. Een processor die 2 instructies kan pipelinen of simultaan uitvoeren is al een flinke jongen hoor..
Intel of AMD , Mips en een paar andere grote kleppers.
een doorsnee 8 16 en 32 bitter kan dat allemaal niet.
Een doorsnee risc kan dat ook niet.

Als je alle processoren optelt die vandaag nog van de band rollen ( tussen nu 13u47 en pakweg middernacht) dan zullen van al die chips er maar weinig superscalar zijn hoor ...

Goed punt, maar het ligt er ook aan wat je verstaat onder een processor, en superscalar. Voor zover ik weet hebben alle PIC microcontrollers een pipeline van 4 kloks, en zijn in ieder geval de 16 en 32 bitters superscalar.

En veel spul van een wasmachine met een dedicated chip met een ARM macro, tot alle hedendaagse grafische kaarten doen meerdere dingen parallel.

Op 3 september 2009 22:53:40 schreef benleentje:
Dat klinkt veel meer als een GPU van amd of nvidia. Maar met 800 kernen in een chip van AMD wil je enkel simpele instructies.

Mee eens.

Aan de buiten kant denkt de software wel met een i386 of eigenlijk x86 architectuur te maken hebben. Echter intern allang niet meer. De x86 instructies worden vertaald en via de eigen architectuur verwerkt.

Bovenop de x86 heb je nog vele andere instructie set. waarbij intel en AMD soms hun eigen instructieset toepassen.

Ja, en het is Intel een grote doorn in het oog dat AMD de i64 instructieset heeft ontworpen en aan de man heeft weten te brengen.

[Bericht gewijzigd door Henry S. op (23%)]

Veel programmeurs (nou ja, mensen die programmeren) hebben zelfs de datasheet nog nooit gelezen.
Je ziet dan ook vaak dat als men bij 8 bits MCU's bijvoorbeeld Basic of C gebruikt, er geen idee van heeft dat het gebruik van een dword of long als teller veel meer code genereert dan wanneer je een byte gebruikt.
Ik persoonlijk vindt dat je het beste kunt beginnen met assembly, dan leer je alle (on)hebbelijkheden van de MCU...

Absoluut. Daar hebben we op Beyond3D ook een keer een hele lange discussie over gehad, en alle programmeurs die al wat langer in het vak zaten vonden assembly en zelf "prutsen" uit hobby belangrijker dan een opleiding.

Gelukkig maar, want ik heb ook geen opleiding (nou ja, Mavo). Ik heb van mijn hobby's mijn werk gemaakt. :D

[Bericht gewijzigd door Henry S. op (45%)]

Op 3 september 2009 23:29:04 schreef Arco:
Veel programmeurs (nou ja, mensen die programmeren) hebben zelfs de datasheet nog nooit gelezen.
Je ziet dan ook vaak dat als men bij 8 bits MCU's bijvoorbeeld Basic of C gebruikt, er geen idee van heeft dat het gebruik van een dword of long als teller veel meer code genereert dan wanneer je een byte gebruikt.
Ik persoonlijk vindt dat je het beste kunt beginnen met assembly, dan leer je alle (on)hebbelijkheden van de MCU...

Dat is een groot verschil tussen programmeurs die uit de elektrohoek komen, en die uit de informatica komen.

Informatici worden geleerd dat hardware ideaal is, RAM oneindig groot, parallelle code wordt altijd parallel uitgevoerd, etc. Elektrotechnici kennen de beperkingen van hardware, maar kunnen er ook efficiënter gebruik van maken.

Niet dat ik beweer dat elektrotechnici betere programmeurs zijn dan informatici. ;) Misschien low-level. High-level is het gebied van de informatici, en dat gebied wordt steeds belangrijker naarmate hardware ingewikkelder wordt, compilers worden dus ook belangrijker, maar gelukkig ook steeds beter.

Zelfs tegenwoordig vraag ik tijdens sollicitatiegesprekken nog steeds of mensen kunnen solderen ;-) .

Niet dat er bij ons iets gesoldeerd hoeft te worden :-).

Groeten, Bram

Op 4 september 2009 00:01:57 schreef Neen:
[...]

Dat is een groot verschil tussen programmeurs die uit de elektrohoek komen, en die uit de informatica komen.

Informatici worden geleerd dat hardware ideaal is, RAM oneindig groot, parallelle code wordt altijd parallel uitgevoerd, etc. Elektrotechnici kennen de beperkingen van hardware, maar kunnen er ook efficiënter gebruik van maken.

Niet dat ik beweer dat elektrotechnici betere programmeurs zijn dan informatici. ;) Misschien low-level. High-level is het gebied van de informatici, en dat gebied wordt steeds belangrijker naarmate hardware ingewikkelder wordt, compilers worden dus ook belangrijker, maar gelukkig ook steeds beter.

ligt eraan waarvoor ik programmeer, als ik voor een PC programmeer reken ik ram idd redelijk oneinding.
en 4GB watik heb is met de redelijk kleine progrjes die ik maak wel oneinding.
pak je een pic/avr/wat dan ook dan is je ram in eens heel klein.
wat KB en dan houdt het wel op bij de kleinere uC's

en asm is goed om mee te beginnen, maar nadat ik een lcd levend had ging ik wel over naar basic, stukken sneller programmeren.
en voor een PC, om nu met asm te beginnen, volgens mij is dat redelijk onmogelijk, het kan wel, maar of het efficiente tijdsbesteding is vraag ik me af.
ok als je een heel groot programma hebt(game engine) kan ik me voorstellen dat je in ASM je code optimaliseert, maar om alles in asm te maken lijkt me onzin.

Ik moet toegeven, dat ik tegenwoordig voor PC programma's ook niet meer controleer op "out of memory" errors. Maar ja, die krijg je toch alleen maar als je over de 2 GB gaat (met 32-bit versies van Windows).

Als je echt wilt weten of jouw geheugenallocatie ook echt in RAM zit, dan moet je daar heel wat trucs voor uithalen.

Ik heb sinds een paar maand een eigen processor architectuur war ik mee speel. Dat ding is 1 clocktick per instructie maar het is geen risc. (Er zijn meer dan 100 basis instructies (zonder de modifiers) ,en de instructieset is uitbreidbaar. De ganse boel is een harvard machiene.

Het speciale is dat de processor scalable is op alle vlakken.
Je compileert eerst je programma. Na compilatie weet je exact hoeveel registers je nodig hebt, welke instructies je gebruikt , hoe de address space etc ligt. Die informatie wordt doorgevoerd naar de synthesizer. Die stript alles wat niet nodig is en genereert een geoptimaliseerde core. Je kan zelf opdrukken hoeveel 'spare' registers en memory je wilt. Even synthetiseren en klaar.

De machiene is 32 bit.

De processor kan alle bewerkingen uitvoeren op eender welk register. er is geen vaste accumulator, stack of datapointers.

ADD #14 #12 #25 telt register 14 bij 12 op en stockeert resultaat in 25.
ADD #14 #14 #14 telt 14 bij 14 op en stockeert terug in 14.
ADD #14 #12 @9 telt register 14 bij 12 op en stockeert resultaat in de ram die aangegeven wordt door register #9 (register '9' is nu de datapointer). tezelfdertijd wordt ook de inhoud van 9 met 1 opgehoogd ...

Je kan meerdere processen parallel draaien en elk process vastknopen aan een eigen interrupt. Er is geen context switching nodig omdat er geen stack pointer, of datapointer is. Eender welk van de registers kan daartoe gebruikt worden. als je 5 datapointers wilt: be my guest ...

de programmeertaal is een basic-achtige syntax:


Sub routine_1 uses 
    interrupt 9 
    priority 2
    register a at &hFE 
    register b at &h2A
    pointer my_pointer is &h0C0FFEE  ' definieer een datapointer
begin
    my_pointer = a+b
    my_pointer = a-b
    my_pointer = a*b
    my_pointer = a/b
end sub

alias routine_2 to routine_1
   interrupt 10 
   priority 2
   register a at &hFf 
   register b at &h2b
   pointer my_pointer is &deadbeef
end alias

voila. telkens interrupt 9 geactiveerd wordt zal het getal '0coffee' geladen in de dptr voor dit process.
Er worden 4 bewerkingen uitgevoerd ( + - * / ) de gegevens komen van registers a en b die op ene bepaalde plaats liggen. de output vliegt sequentieel naar de pointer. dus de uitkomst van + ligt op 0c0ffee , de uitkomst van - ligt op 0c0ffef , de uitkomst van * ligt op 0c0fffe en de / ligt op 0c0ffff.

Als de bron geen rol speelt en door de compiler mag gekozen worden laat je het 'at' statement weg.

Deze subroutine kost dus exact 5 clockticks.

via 'priority' geef je op wie voorrang krijgt.

Dat is hetgeen die 'alias' defineert. exact de zelfde code als routine_1 maar met andere bron en doel addressen en vastgeknoopt aan een andere trigger.

Ik kan dus data laden voor process 1 , process 1 wakker maken ,en terwijl het process 1 loopt data laden voor process 2. eenmaal klaar maak ik process 2 wakker en kan ik data terug laden voor process 1.
Geen dma nodig , geen waits nodig. niks. Zolang data laden langer duurt dan mijn process ben ik ok.

je kan ook dingen doen zoals


pointer a is &h1
static pointer b is &h2
static pointer c is &h3
a = b + c

de pointers b en c veranderen niet (static). pointer a incrementeeret dus wel.
telkens je deze routine oproept landt het resultaat op het volgende address.


pointer a is &h10
pointer b is &h20
pointer c is &h30
register aantal = 10
:mijn_lus
   a = b + c
redo aantal mijn_lus

dit telt inhoud van 20 bij inhoud van 30 en gooit in 10 , telt inhoud van 21 bij 31 en gooit in 11 , enzovoort.
Dit is een vector operatie. heel snel een array by een andere array optellen en resultaat in een derde gooien.

Als je dergelijke code op een normale processor uitvoert heb je een immens aantal instructies aan je broek.... je moet immers 3 pointers manipuleren , data van en naar acumulatoren en of registers en of ram gooigen. Hier niet. De boel is 1 clocktick ( ook naar ram... Meer kan ik daar niet over kwijt.. patentjes pending...)

REDO is dus een soort DJZ ,decrement and jump if zero.

De instructieset is een amalgaam van hetgeen vector processoren , vliw en cisc doen.

Ik ben zelf behoorlijk pro-RISC geworden. (Met modified harvard architecture) (Zie 16-bit pics).

Ik heb eerst een en ander gedaan met 8-bit pics en ik misde heel erg de mogelijkheden die de modified harvard architecture wel bood. (makkelijk gebruik van je data memory in je instructies (pointers)).

Maar ook daar zou ik persoonlijk gesproken nog wel wat meer keus in willen hebben. ZOals:
-2x read
-1x write
van -> naar data memory.
(bijv [addrA] AND [addrB] -> [addrC])

Voor de rest ben ik niet echt pro-CISC. Ik kan me er de voordelen wel van zien, voor highlevel als je niets te maken hebt met real time. Maar als je real time applicaties gaat maken dan wil je toch echt wél van te voren weten hoeveel tijd een bepaalde functie gaat kosten.
(let wel, ik heb nooit real-time appliactie hoeven maken op een CISC processor, dit is ons alleen geleerd op school, maar ik sta wel achter de achterliggende gedachte/reden)

Op 4 september 2009 00:41:41 schreef free_electron:
Ik heb sinds een paar maand een eigen processor architectuur war ik mee speel. Dat ding is 1 clocktick per instructie maar het is geen risc. (Er zijn meer dan 100 basis instructies (zonder de modifiers) ,en de instructieset is uitbreidbaar. De ganse boel is een harvard machiene.

Het speciale is dat de processor scalable is op alle vlakken.
Je compileert eerst je programma. Na compilatie weet je exact hoeveel registers je nodig hebt, welke instructies je gebruikt , hoe de address space etc ligt. Die informatie wordt doorgevoerd naar de synthesizer. Die stript alles wat niet nodig is en genereert een geoptimaliseerde core. Je kan zelf opdrukken hoeveel 'spare' registers en memory je wilt. Even synthetiseren en klaar.

De machiene is 32 bit.

De processor kan alle bewerkingen uitvoeren op eender welk register. er is geen vaste accumulator, stack of datapointers.

ADD #14 #12 #25 telt register 14 bij 12 op en stockeert resultaat in 25.
ADD #14 #14 #14 telt 14 bij 14 op en stockeert terug in 14.
ADD #14 #12 @9 telt register 14 bij 12 op en stockeert resultaat in de ram die aangegeven wordt door register #9 (register '9' is nu de datapointer). tezelfdertijd wordt ook de inhoud van 9 met 1 opgehoogd ...

Je kan meerdere processen parallel draaien en elk process vastknopen aan een eigen interrupt. Er is geen context switching nodig omdat er geen stack pointer, of datapointer is. Eender welk van de registers kan daartoe gebruikt worden. als je 5 datapointers wilt: be my guest ...

de programmeertaal is een basic-achtige syntax:


Sub routine_1 uses 
    interrupt 9 
    priority 2
    register a at &hFE 
    register b at &h2A
    pointer my_pointer is &h0C0FFEE  ' definieer een datapointer
begin
    my_pointer = a+b
    my_pointer = a-b
    my_pointer = a*b
    my_pointer = a/b
end sub

alias routine_2 to routine_1
   interrupt 10 
   priority 2
   register a at &hFf 
   register b at &h2b
   pointer my_pointer is &deadbeef
end alias

voila. telkens interrupt 9 geactiveerd wordt zal het getal '0coffee' geladen in de dptr voor dit process.
Er worden 4 bewerkingen uitgevoerd ( + - * / ) de gegevens komen van registers a en b die op ene bepaalde plaats liggen. de output vliegt sequentieel naar de pointer. dus de uitkomst van + ligt op 0c0ffee , de uitkomst van - ligt op 0c0ffef , de uitkomst van * ligt op 0c0fffe en de / ligt op 0c0ffff.

Als de bron geen rol speelt en door de compiler mag gekozen worden laat je het 'at' statement weg.

Deze subroutine kost dus exact 5 clockticks.

via 'priority' geef je op wie voorrang krijgt.

Dat is hetgeen die 'alias' defineert. exact de zelfde code als routine_1 maar met andere bron en doel addressen en vastgeknoopt aan een andere trigger.

Ik kan dus data laden voor process 1 , process 1 wakker maken ,en terwijl het process 1 loopt data laden voor process 2. eenmaal klaar maak ik process 2 wakker en kan ik data terug laden voor process 1.
Geen dma nodig , geen waits nodig. niks. Zolang data laden langer duurt dan mijn process ben ik ok.

je kan ook dingen doen zoals


pointer a is &h1
static pointer b is &h2
static pointer c is &h3
a = b + c

de pointers b en c veranderen niet (static). pointer a incrementeeret dus wel.
telkens je deze routine oproept landt het resultaat op het volgende address.


pointer a is &h10
pointer b is &h20
pointer c is &h30
register aantal = 10
:mijn_lus
   a = b + c
redo aantal mijn_lus

dit telt inhoud van 20 bij inhoud van 30 en gooit in 10 , telt inhoud van 21 bij 31 en gooit in 11 , enzovoort.
Dit is een vector operatie. heel snel een array by een andere array optellen en resultaat in een derde gooien.

Als je dergelijke code op een normale processor uitvoert heb je een immens aantal instructies aan je broek.... je moet immers 3 pointers manipuleren , data van en naar acumulatoren en of registers en of ram gooigen. Hier niet. De boel is 1 clocktick ( ook naar ram... Meer kan ik daar niet over kwijt.. patentjes pending...)

REDO is dus een soort DJZ ,decrement and jump if zero.

De instructieset is een amalgaam van hetgeen vector processoren , vliw en cisc doen.

Dat is wat Intel en AMD ook al een paar generaties doen.

Maar petje af! Ik heb er vaak over na zitten denken, maar ik zou zelf niet weten hoe ik zoiets zou moeten maken. De paar mensen die waarvan ik wist dat ze dat wel konden, werken bij Intel of AMD.

Op 4 september 2009 00:49:05 schreef Daan Timmer:
Ik ben zelf behoorlijk pro-RISC geworden. (Met modified harvard architecture) (Zie 16-bit pics).

Ik heb eerst een en ander gedaan met 8-bit pics en ik misde heel erg de mogelijkheden die de modified harvard architecture wel bood. (makkelijk gebruik van je data memory in je instructies (pointers)).

Maar ook daar zou ik persoonlijk gesproken nog wel wat meer keus in willen hebben. ZOals:
-2x read
-1x write
van -> naar data memory.
(bijv [addrA] AND [addrB] -> [addrC])

Voor de rest ben ik niet echt pro-CISC. Ik kan me er de voordelen wel van zien, voor highlevel als je niets te maken hebt met real time. Maar als je real time applicaties gaat maken dan wil je toch echt wél van te voren weten hoeveel tijd een bepaalde functie gaat kosten.
(let wel, ik heb nooit real-time appliactie hoeven maken op een CISC processor, dit is ons alleen geleerd op school, maar ik sta wel achter de achterliggende gedachte/reden)

Dat is waarom je zelfs op een microcontroller een OS nodig hebt als je niet genoeg hebt aan een eindeloze lus die gaat bit-bangen. En als je daaraan genoeg hebt, dan voldoet een simpele 8-bitter al snel.

Om dus van al die extra mogelijkheden gebruik te kunnen maken, moet je interrupts afhandelen, wat vraagt om gegevensopslag die tegelijkertijd vanuit verschillende "threads" (je hoofdprogramma en de interrupts) te benaderen is, wat dan weer om geheugenbeheer vraagt. En die interrupts zijn dan "device-drivers", die je (net zoals het geheugen) moet beheren, en dus generaliseren. Waarbij "message-parsing" al snel meerwaarde heeft.

Om dat allemaal aan de praat te krijgen, moet je het kunnen debuggen. Wat weer vraagt om een verdere generalisatie en standaardisatie van je I/O en geheugenbeheer, en multitasking moet zijn.

Bij een wat ingewikkeldere microcontroller schakeling moet je dat OS zelf schrijven. En alhoewel dat niet zo heel ingewikkeld is, is het al gauw beter en goedkoper om er 1 te kopen.

@free: indrukwekkend, hoe ziet dat uit qua vermogensverbruik per MIPS en vierkante mil silicon?

Best interessante discussie hier, maar er zijn toch wel wat opmerkingen bij te plaatsen.
Ten eerste RISC versus CISC. RISC is 'gewoon' Reduced Instruction Set', dat heeft te maken met het aantal beschikbare instructies, niet met de klokcycli.
(Sommige puristen vinden de 73 instructies van de 18F al niet meer RISC, duh).

Ten tweede het afgeven op 'informatici'. De vraag waarvoor het programma is bedoeld lijkt helemaal niet terzake te doen. Er zijn heel goede redenen waarom er hogere (3e, 4e) generatie programmeertalen zijn. Ik moet er niet aan denken dat ik een pensioen-systeem in assembler zou moeten schrijven.

Dat is net zoiets als zeggen dat als je geen verstand van de tecnische werking van een auto hebt je niet moet gaan autorijden.

Free_electron:
"het grote probleem van hedendaagse 'programmeurs' is dat ze niks meer kennen van de architectuur... ze kunnen hoogstens wat C of C++ 'kakken'."

-> Bij ons op de universiteit computerwetenschappen kennen ze nog maar 1 ding tegenwoordig en dat is Java. Alles wat in klassen en libraries te draaien valt, moet door de molen. Vorig jaar wel MIPS moeten leren, maar C is er nooit aan te pas gekomen. Mijn redenering is atlijd geweest dat als je niet begrijpt hoe een pointer in C werkt, je onmogelijk een geheugenstructuur kan begrijpen. Helaas denken proffen daar anders over tegenwoordig.

Ten tweede het afgeven op 'informatici'. De vraag waarvoor het programma is bedoeld lijkt helemaal niet terzake te doen. Er zijn heel goede redenen waarom er hogere (3e, 4e) generatie programmeertalen zijn. Ik moet er niet aan denken dat ik een pensioen-systeem in assembler zou moeten schrijven.

Als de programmeur een OS schrijft lijkt me het wel noodzakelijk om er 1 te pakken die heel veel weet van de hardware. maar zo lijkt het niet te gaan. Alleen de drivers werken direct met de hardware en de rest niet.

Als je enkel een boekhoud programma maakt is de kennis over de hardware niet nodig.

Als je enkel een boekhoud programma maakt is de kennis over de hardware niet nodig.

Nog erger :-(. Meegemaakt in de praktijk dat een programmeur een programma geschreven had wat draaide op een Unix server met 3000 gebruikers , meneer had een delay nodig en realiseerde dit door in zn code door tellen (for-next die niks deed) CPU cycles liep te verstoken en daardoor alle CPU capaciteit naar zich toetrok.

Inderdaad, op een Commodore 64 deed je dit zo.

Enige hardware kennis is toch wel wenselijk. In de embedded omgeving werk je vaak rechtstreeks op de hardware en wil je niet altijd driver overhead.

Groeten, Bram

Op 8 september 2009 22:28:54 schreef Bert_mc:
@free: indrukwekkend, hoe ziet dat uit qua vermogensverbruik per MIPS en vierkante mil silicon?

irrelevant. ding draait in een FPGA. de bedoeling is niet om low power te zijn maar om een snelle doorvoer te hebben. het dataflow pad moet snel zijn. alles wat in 1 clocktick kan word in 1 clocktick gedaan.
pipelines en consoorten zijn allemaal lapsussen. ja dat helpt allemaal, maar bij een systeem wat gemaakt is om exception handling te doen ( interrupt afhandeling) ben je daar niks mee. je wordt te sterk gepenaliseerd doordat je telkens je pipeline moet flushen.

@daan timmer. das hetgeen de mijne kan.... twee willekeurige bronnen grabbelen (dericet van register, indirect via pointer), er een bewerking op uitvoeren en dat ofwel direct ( naar register) ofwel indexed (pointer) uitspugen. De pointers zelf zijn daarbij static of dynamic. een pointer die als dynamic is opgegeven incrementeert direct mee. speciaal gemaakt om op tabellen te werken.
je zaait de 3 pointers 1 keer en voert de instructie uit. elke clocktick kan je een bewerking doen en de pointers incrementeren vanzelf. de redo instructie doet de rest ... ( die herdoet het blok totdat de inhoud van het gespecifieerde redo register op nul komt. )
De quicksilver cpu heeft geen MOV instructie. Die is ook niet nodig.

De bedoeling is om de software 'loops' zoveel mogelijk in hardware uit te voeren.

voor veel simpele software loop constructies heb je teveel 'overhead'. de processor moet veel tijd verspillen aan incrementeren van pointers , jumpen , compare en nog vele meer. die ballast probeer ik weg te werken door dat in 1 clocktick in hardware uit te voeren.

je kan daar wel geen bestaande taal op mappen. compilers werken nu eenmaal niet zo. vandaar een eigen taal voor de processor. er is ook geen 'machienetaal'. De instructies zijn vast en de taal is daarrond gebouwd. het enige wat de 'compiler' doet is de geheugenallocatie en registermapping.

@bprosman : op een commodore deed je dat via een van de timers.

Het grote probleem is dat de 'demoscene' verdwenen is. vreoger deed men waanzinnige dingen op die commodores. Kijk naar final reality van Future Crew. Die gasten persten alles uit die simpele processor die in de c64 zat. Maar die kenden de machiene door en door. Later konden ze dat ook op de ibm pc.
Vandaag kan je haast niet meer bare metal programmeren. Der zit altijd een OS , hypervisor of andere troep in de weg ...

Superscalar is niet zoals je zegt dat 1 instructie naar meerdere vertaald wordt, maar dat er meer instructies tegelijk gedaan worden.

De intel960 was daar geloof ik een van de eerste mee. Als de eerste instructie in de pipeline type X was, en de tweede type Y, en er zijn geen register conflicten (Y gebruikt het resultaat van X), dan gingen ze tegelijk.... Later is Intel dat idee natuurlijk gaan verbreden en ook op de i386 familie gaan toepassen.

Om op de originele vraag terug te komen: Ik heb nogsteeds ontzettende bewondering voor de PDP11 instructieset: 8 registers, 8 adresseringsmodes.

<operation><srcreg><srcmode><dstreg><dstmode> 4 + 3+3 + 3+3 = 16

blijkt dat ze aan 16 instructies niet genoeg hadden, dus kreeg je truuken dat bij bepaalde opcodes srcmode als extra opcode gebruikt werd, zodat je niet meer alle srcmodes kon gebruiken. Da's jammer. Als je dit opschaalt naar 32 bits krijg je:

<operation><srcreg><srcmode><dstreg><dstmode> 16 + 5+3 + 5+3 = 16

Dan heb je 32 registers, en nog steeds behoorlijke ruimte voor adresseringsmodes. 16 bits opcode is ook lekker ruim. Eigenlijk zal een stuk of 5 wel genoeg zijn, en blijven er 11 over. Daar valt vast wel wat voor te verzinnen... De MC68000 architectuur lijkt hierop.

De truuk die we hebben uitgevonden toen ik bij Computer architectuur aan het afstuderen was, is: "Opcodes is voor mietjes". Oftewel Alles is een MOVE instructie. Dan heb je dus een opteller unit, die gewoon ALTIJD de waardes in de twee ingangs registers optelt en in een uitgangs register toont.

Je hebt dan wel wat meer register-plekken nodig, omdat ook optellen/aftrekken maar ook de "externe geheugen interface" register plekken nodig hebben.

Dan moet je nog nadenken over hoe 1 unit meerdere functies kan verrichten, zoals optellen/aftrekken. Gebruikelijk is om een optel unit een A, Bp en Bm registers te geven. Stop je de tweede operand in Bm, dan wordt er afgetrokken (R = A - Bm), stop je de tweede in Bp, dan wordt er opgeteld (R = A + Bp)...

Vervolgens is het leuk om meerdere van deze MOVE instructies in 1 instructiewoord te zetten. Dan krijg je expliciete Superscalar...

Een mijnheer van HP is ooit bij ons op bezoek geweest hier in Delft. Een paar jaar later kwam Merced, de 64bit samenwerking tussen HP en Intel. Ik vond het verdacht veel lijken op wat wij hier in Delft bedacht hadden.....

Maar goed, voor embedded controllertjes is dit allemaal overkill. Een 8bit AVR voldoet vaak prima. Anderzijds, een sneller CPUtje in mijn telefoon zou ook niet misstaan....

Op 3 september 2009 23:20:23 schreef SymbolicFrank:
Goed punt, maar het ligt er ook aan wat je verstaat onder een processor, en superscalar. Voor zover ik weet hebben alle PIC microcontrollers een pipeline van 4 kloks, en zijn in ieder geval de 16 en 32 bitters superscalar.

Een pipeline is in mijn ogen nog iets anders dan multithreaden zoals je aanhaalt in je eerste post. Om één instructie (nu in het voorbeeld van een PIC) uit te voeren, moet je hem fetchen, decoden, uitvoeren en wegschrijven. Daar zie je mooi de vier stadia van je pipeline terugkomen. Het is echter niet mogelijk om dit allemaal dubbel te doen, je hebt maar één ALU, dus kan je geen twee berekeningen tegelijk doen. Je kan wel de volgende instructie klaarzetten zodat deze direct achter de vorige afgehandeld kan worden.

Best wel een interessant topic :)
Volgens mij zijn er nog maar weinigen die stil staan bij deze elementaire grondslag van het hele computer gebeuren.

Heb je ook een voorkeur als het gaat over Von-Neumann vs Harvard? Op de PICs heb je bv Harvard tewijl de Motorola's (68HC11 bv) zweren bij Von-Neumann. In een hedendaagse PC heb je dan weer Von-Neumann tussen RAM en CPU en in de CPU zelf (cache) Harvard.

Op 3 september 2009 23:29:04 schreef Arco:
Veel programmeurs (nou ja, mensen die programmeren) hebben zelfs de datasheet nog nooit gelezen.

Haha!! CO is daar hét grote bewijs van. De datasheet lezen, tot twintig keer toe, daar leer je nog het meeste van. Daar is men tegenwoordig echter een beetje te lui voor.

Ik persoonlijk vindt dat je het beste kunt beginnen met assembly, dan leer je alle (on)hebbelijkheden van de MCU...

I agree, zeker voor die kleine microcontrollertjes. In de PC wereld lijkt me dit niet evident.
Ik vrees dat velen gewend zijn te programmeren op een PC en daar heb je (voor de programma's die zij/wij schrijven) resources in overvloed. Een byte, integer of zelfs float maakt allemaal niet uit, gaat toch even snel. Kom je dan in de wondere wereld van de beperkte resources terecht waar je soms ook nog eens kritische timings moet doen, dan hoor je dus wel even op die laatste acht bits te kijken. In de plaats van daar eens aan te denken gaan ze gelijk lopen klagen dat die dingen niet snel genoeg zijn (nuja, zeg zelf 4 of 20MHz klinkt ook écht weinig in vergelijking met 3GHz). We (hier was ik zelf niet bij, hi) zijn met gelijkaardige dingen naar de maan en terug gevlogen! En in de spaceshuttle wordt nu nog gebruik gemaakt van 8 bitters!

Op 4 september 2009 00:05:04 schreef bprosman:
Zelfs tegenwoordig vraag ik tijdens sollicitatiegesprekken nog steeds of mensen kunnen solderen ;-) .

Niet dat er bij ons iets gesoldeerd hoeft te worden :-).

Groeten, Bram

Je bent een man naar mijn hart! Zo zie je direct wie zelf wat heeft liggen klooien (en dus bakken kennis/ervaring heeft) en wie gewoon maar wat boekenwijsheid van op school aframmelt. Zij die alles heel mooi kunnen voorstellen zijn meestal niet degene die ook echt een probleem kunnen oplossen als puntje bij paaltje komt (uitzonderingen daargelaten uiteraard).

Op 8 september 2009 22:49:55 schreef taddam:
-> Bij ons op de universiteit computerwetenschappen kennen ze nog maar 1 ding tegenwoordig en dat is Java. Alles wat in klassen en libraries te draaien valt, moet door de molen. Vorig jaar wel MIPS moeten leren, maar C is er nooit aan te pas gekomen. Mijn redenering is atlijd geweest dat als je niet begrijpt hoe een pointer in C werkt, je onmogelijk een geheugenstructuur kan begrijpen. Helaas denken proffen daar anders over tegenwoordig.

Dat komt omdat de industrie meer en meer Java programmeurs wil hebben, het moet vooruit gaan. Hoe het werkt is niet belangrijk, als het maar werkt én snel gaat.
Die enkele low levelers die tegenwoordig nog nodig zijn komen meestal uit een milieu van tot vakidioten geëvolueerde hobyisten.

Realiseer je het volgende eens: Twintig jaar geleden moest men op vier/vijf jaar alles van processoren etc zien. Nu is die wereld zo geëvolueerd dat je ofwel de basis moet weglaten ofwel de laatste snufjes niet kan behandelen om toch maar alles gezien te krijgen. Idem voor buis, transistor, FET, IGBT, etc... In plaats van te beginnen bij de buis, begint men nu bij de transistor.

Beetje offtopic maar het probleem van het onderwijs zit vooral in de tijd die docenten krijgen om dingen uit te leggen. Er is geen tijd om de gehele architectuur uit te leggen. Net als met buizen, deze worden totaal overgeslagen. Waarom? Ze worden in verhouding bijna niet meer gebruikt, dus hoeven ze niet behandeld te worden. Maar zelfs bij de uitleg over transistoren en andere componenten merk je gewoon dat ze niet verder gaan dan de oppervlakte. Je moet tegenwoordig van alles een klein beetje weten. Dus de diepgang mist volledig. Maar goed, dat is vooral mijn frustratie.

Gelukkig wordt er nog wel gewoon computerarchitectuur onderwezen.
Op de TUD krijg ik straks (2e jaar) het vak.

Mijn ervaring is dat iemand die daar nooit op zelfstandige basis mee is bezig geweest, héél lang nodig heeft om eindelijk eens te begrijpen hoe alles in zn werk gaat. Waarbij je "alles" nog met een serieuze korrel zout moet nemen.
Uiteraard kan dit ook aan de docent/prof liggen...

[Bericht gewijzigd door Henry S. op (27%)]