Föreläsning 5
Minnet från processorns sida
Digitala System: Datorteknik
• Processorn ger kommandon/instruktioner med en adress
och förväntar sig data.
– Exempel: READ(ADR) -> DATA
ERIK LARSSON
Logisk adress
Fysisk adress
READ
00001000
READ (00001000)
Primärminne
Address
00001000
00001001
00001010
00001011
Design av minnesystem
CPU
– Ett minne som får plats med stora program och som
fungerar i hastighet som processorn
» Fetch – execute (MHz/GHz/Multi-core race)
CPU
• Grundproblem:
– Processorer arbetar i hög hastighet och behöver stora
minnen
– Minnen är mycket långsammare än processorer
• Fakta:
– Större minnen är långsammare än mindre minnen
– Snabbare minnen kostar med per bit
Kontrollenhet
0000101110001011
Register
Minne
CPU
Minne-processor hastighet
• Vad vill vi ha?
Primärminne
Instruction
0000101110001011
0001101110000011
0010100000011011
0001001110010011
Aritmetisk Logisk
Enhet (ALU)
Minneshierarki
Minneshierarki
• Processor registers:
8-32 registers (32 bitar -> 32-128 bytes)
accesstid: få ns, 0-1 klockcykler
• On-chip cache memory (L1):
32 till 128 Kbytes
accesstid = ~10 ns, 3 klockcykler
• Off-chip cache memory (L2):
128 Kbytes till 12 Mbytes
accesstid = 10-tal ns, 10 klockcykler
• Main memory:
256 Mbytes till 4Gbytes
accesstid = ~100 ns, 100 klockcykler
• Hard disk:
1Gbyte tid 1Tbyte
accesstid = 10-tal milliseconds, 10 000 000 klockcykler
Cacheminne
Cacheminne
• Ett cacheminne är mindre och snabbare än primärminnet
– Hela program får inte plats
Primärminne
Instruktioner
och data
Instruktioner
och data
Adress
Cacheminne
Kopior av
instruktioner
och data
Instruktioner
och data
Adress
Central
processing unit
(CPU)
Register
– Men, data och instruktioner ska vara tillgängliga när
de behövs
• Om man inte har cacheminne:
– Accesstid för att hämta en instruktion=100ns
• Om man har cacheminne:
– Accesstid för att hämta en instruktion=100+10=110 ns
» Först ska instruktionen hämtas till cacheminne och
sedan hämtas instruktionen från cacheminnet till CPU
Accesstid: 100ns
Accesstid: 10ns
Cache – exempel 1
Cache – exempel 2
• Antag:
• Program:
x=x+1;
y=x+5;
z=y+x;
Assemblyinstruktioner
Instruktion1: x=x+1;
Instruktion2: y=x+5;
Instruktion3: z=y+x;
• Om man inte har cacheminne:
– 1 maskininstruktion per rad
– 100 ns för minnesaccess till primärminnet
– 10 ns för minnesaccess till cacheminnet
• Programmet och dess maskininstruktioner.
– Accesstid för att hämta en instruktion=100ns
» Tid för att hämta instruktioner: 3*100=300ns
• Om man har cacheminne:
– Accesstid för att hämta en instruktion=100+10=110ns
» Tid för hämta instruktioner: 3*110=330ns
Utan cache – exempel 2
Exempel program:
while (x<1000){
Instruktion1: while1000
x=x+1;
Instruktion2: x=x+1
printf(“x=%i”,x);
Instruktion3: print x}
while (y<500){
Instruktion4: while500
y=y+1;
Instruktion5: y=y+1
printf(“y=%i”,y);
Instruktion6: print y
}
Med cache – exempel 2
• Antal instruktioner Instruktioner som exekveras:
Minnesaccess
för 1 instruktion:
100 ns
Totalt 4500
instruktioner.
Tid för
minnesaccesser:
4500*100= 450000ns
1
2
3
Instruktion1:while1000
Instruktion2:x=x+1
Instruktion3:printx
2998
2999
3000
3001
3002
3003
Instruktion1:while1000
Instruktion2:x=x+1
Instruktion3:printx}
Instruktion4:while500
Instruktion5:y=y+1
Instruktion6:printy
4498
4499
4500
Instruktion4:while500
Instruktion5:y=y+1
Instruktion6:printy
Assembly
• Antal instruktioner Instruktioner som exekveras:
Minne+cache
(100+10 ns)
Cache (10 ns)
Minne+cache
(100+10 ns)
Cache (10 ns)
Total tid för
minnesaccesser:
6*100 + 4500*10=
45600ns (~10%
jmf med “utan
cache”)
1
2
3
Instruktion1:while1000
Instruktion2:x=x+1
Instruktion3:printx
2998
2999
3000
3001
3002
3003
Instruktion1:while1000
Instruktion2:x=x+1
Instruktion3:printx}
Instruktion4:while500
Instruktion5:y=y+1
Instruktion6:printy
4498
4499
4500
Instruktion4:while500
Instruktion5:y=y+1
Instruktion6:printy
Cacheminne
Utnyttja lokalitet
• Minnesreferenser tenderar att gruppera sig under exekvering
– både instruktioner (t ex loopar) och data (datastrukturer)
• Lokalitet av referenser (locality of references):
– Temporal lokalitet – lokalitet i tid –
» om en instruktion/data blivit refererat nu, så är sannolikheten
stor att samma referens görs inom kort
– Rumslokalitet –
» om instruktion/data blivit refererat nu, så är sannolikheten
stor att instruktioner/data vid adresser i närheten kommer
användas inom kort
Minneshierarki - nivåer
• Block (line): enhet som kopieras
– Kan vara flera ”words”
• Om ”accessed data” finns i högsta
nivån (upper level)
– Hit: access ges av högsta nivå
» Hit ratio: hits/accesses
• Om ”accessed data” inte finns på
aktuell nivå
– Miss: block kopieras från lägre nivå
– Tid: miss penalty, Miss ratio: antal missar/accesses
= 1 – hit ratio
– Sedan kan data nås från högre nivå
• Minneshierarki
– Lagra allt på hårddisk
– Kopiera ”recently accessed (and nearby) items” från
disk till mindre primärminne
– Kopiera mer ”recently accessed (and nearby) items”
från primärminne till cacheminne
» Cacheminne kopplat till CPU
Skrivstrategier
• Problem: håll minnet konsistent
• Exempel:
x=0;
while (x<1000)
x=x+1;
• Variablen x kommer “finnas” i primärminnet och i
cacheminnet
• I primärminnet är x=0 medan i cacheminnet är x=0,1,2…
och till sist 1000
Skrivstrategier
Skrivstrategier
• Write-through
• Skilj på write-hit och write-miss
– skrivningar i cache görs också direkt i primärminnet
• Write-through with buffers
– Write-hit: se ovan
– Write-miss: Vill skriva på plats som inte finns i
cacheminne
– skrivningar buffras och görs periodiskt
» Alternativ:
• Write (Copy)-back
– Allokera vid miss: hämta block från primärminne
– primärminnet uppdateras först när en cacherad byts
ut (ofta används en bit som markerar om en cacherad
blivit modifierad (dirty)).
– Write around: hämta inte in block från primärminne,
skriv direkt i primärminne
» (För write-back: vanligen fetch block)
• (Omodifierade cacherader behöver inte skrivas i
primärminnet)
Antal cachenivåer (levels)
Separat instruktion/data cache
Cacheminne
Primärminne
Cache
minne
Instruktioner
och data
Cache
minne
Central
processing unit
(CPU)
Register
L1
L2
Primärminne
Kopior av
instruktioner
Instruktioner
och data
Central
processing unit
(CPU)
Register
Cacheminne
Kopior av
data
Prestanda
AMD Athlon 64 CPU
• När CPU prestanda ökar, så blir miss penalty viktig att
minimera
• För att undersöka prestanda måste man ta hänsyn till
cacheminne
• Cachemissar beror på algoritm(implementation) och
kompilatorns optimering
Minnets innehåll över tiden
Paging
Program A
byte 0
byte 1
….
SIDA A0
SIDA A1
SIDA A2
byte n
TID
SIDA A3
(lagring på hårddisk
ej sammanhängande –
se tidigare)
Filsystem - Inode
Paging
Logisk adress
Fysisk adress
ABBA: Dancing Queen
Demand paging
Sammanfattning
• Ladda endast de pages som behövs till primärminnet
• Snabba minnen är små, stora minnen är långsamma
– Vi vill ha snabba och stora minnen
– Cacheminnen och virtuellt minne ger oss den illusionen
CPU utnyttjande
OS tar alltmer tid för att hantera sidfel
• Lokalitet viktigt för att cacheminnen och virtuellt minne ska
fungera
– Program använder vid varje tidpunkt en liten del av sitt
minne ofta
Grad av multiprogrammering
(hur många program som är aktiva)
• Minneshierarki
– L1 cache <->L2 cache …. Primärminne - Sekundärminne
Programmerad I/O
Digitala System: Datorteknik
• Processorn kontrollerar om I/O har skett.
• Exempel:
1. Läs av om tangent är tryckt.
ERIK LARSSON
2. Om tangent tryckt, hantera, annars vänta lite och gå
till 1
• Nackdel: Processorn är låst och gör meningslösa saker
Avbrottstyrd I/O
Avbrottsstyrd I/O
1
I/O
1
0.1 s
3
3
4
Primärminne
Data/instruktioner
Kontroll
“Main”
OS
Fetch
instruction
Central
processing unit
(CPU)
4
Primärminne
Data/instruktioner
Kontroll
“Main”
5
Central
processing unit
(CPU)
5
Execute
instruction
2
Kontrollera och
hantera avbrott
(ändra PC)
Fetch
instruction
Execute
instruction
2
Kontrollera
och hantera
avbrott
Laboration 3
Laboration 3
• Periodiskt avbrott
Så här kan programmet från förra laborationen beskrivas:
– Använda en klocka som genererar ett avbrott
periodiskt.
1. Vänta tills knappen är nedtryckt.
– När avbrott uppkommer, kontrollera om tangent är
tryckt.
3. Utför uppgiften (öka n med ett; om n blir 10 sätt n till
noll; anropa utskriftsfunktionen med n som
inparameter.)
– Fördel, slipper låta processor exekvera en ”tom”-loop
2. Vänta med hjälp av vänteloop så studsarna slutat.
4. Vänta tills knappen är släppt.
5. Vänta med hjälp av vänteloop så studsarna slutat.
6. Gå till punkt 1.
Laboration 3
Laboration 3
Med hjälp av periodiskt avbrott ska vi skapa en lösning som
med jämna intervall gör följande:
• Timer_Counter_1
– TIMSK
1. Läs av knappen.
– TCCR1A
2. Om den är nere nu, men var uppe förra gången: Utför
uppgiften (som är: ”öka n med ett; om n blir 10 sätt n till
noll; anropa utskriftsfunktionen med n som
inparameter.”)
– TCCR1B
– OCR1A
Laboration 3
#include <avr/io.h>
#include <avr/interrupt.h>
unsigned const char segment_table [] = {
0b11111101,
0b11001000,
Digitala System: Datorteknik
//"0”
//"1”};
void display (unsigned char number) { // din kod här }
unsigned char n;
void initOC1(){ // din kod här }
ERIK LARSSON
Avbrottsrutin
ISR (SIG_OUTPUT_COMPARE1A){
static unsigned char //dina variabler;
din kod }
int main(void){
DDRA = 0b01111111; // Utgångar till display
PORTA = 0b10000000; // Aktivera pull-up
initOC1();
SREG = SREG | //din kod;
while (1){
}
}
Laboration 4 - Tillståndsmaskin
Förberedelser
• Syfte:
• Titta på:
– förbättra knappavläsningen
– Key_down
– få förståelse om tillståndsmaskiner
– Count_and_display
• Komplettera knappavläsningen med en ”timeout”-funktion
• Abstrahera bort hårdvarunära detaljer
• Sista uppgiften är frivillig för de som laborerar ensamma
och i par om två. Om laborationsgruppen består av fler än
två personer, är uppgiften obligatorisk.
Tillståndsmaskin
Tillståndsmaskin
• I ord:
– Tillståndsmaskinen har två tillstånd, Knappen uppe
och Knappen nere.
– Om tillståndsmaskinen är i tillstånd ”Knappen uppe”
så byter den tillstånd om knappen trycks ner.
– I tillståndet ”Knappen nere” väntar man på att
knappen ska släppas.
• Observera att eventuella tillståndsändringar bara kan
inträffa med vissa jämna tidsintervall (jämför med
synkrona sekvensnät i digitaltekniken). I laborationen
använder vi tidsintervallet 10 ms.
Tillståndsmaskin
• Implementationer:
1. Privat variabel som
skapas en gång, dvs
variabeln finns kvar nästa
gång funktionen körs.
Funktioner för högre abstraktionsnivå
• I exemplet är:
if((PINA&0b10000000)==0)
• ersatt av
if(Key_down()==1)
• Skriv en funktion, Key_down, som läser av tryckknappen
och returnerar 1 om den är nere och värdet 0 ifall den är
uppe.
• Tidigare:
void display (unsigned char number){
PORTA = segment_table [number];}
2. Läsbarhet?
Funktioner för högre abstraktionsnivå
• Funktion med returvärde:
Tillståndsmaskin
• Vid val används:
char my_function (void){
static unsigned char a;
a=a+10;
Returnerar
return (a);
}
if (villkor) {
kod som utförs om villkoret är sant
}else{
kod som utförs om villkoret är falskt
}
• Bra för 2-vägs alternativ, men om man har flera
alternativ?
– Kombinera flera IF? Eller….
Uppgift 3
Skapa egna typer
Uppgift 3
Switch/case sats som styrs av f
• Switch sats för enkla flerval:
• Switch sats för enkla flerval:
enum fel {hog_t, lag_t, hog_vatten, lag_vatten};
static unsigned char next_state;
enum fel f;
switch(next_state){
case 0:
if(Key_down() == 1){
next_state = 1;
Count_and_display();}
break;
case 1:
if(Key_down() == 0)next_state = 0;
break;}
Om f = hog_t så börja gör detta:
switch(f){
case hog_t:
printf(“Hög temp”);
Avsluta switch-sats här (om
break;
inget break fortsätter man testa på
case lag_t:
nästa (dvs lag_t)
printf(“Hög temp”);
break;
default:
printf(“Kontrollera vatten”);
break;}
Uppgift 5
• Om man trycker ned en tangent på ett tangentbord länge
så kommer flera teckan.
• Konstruera detta! När knappen varit nedtryckt i 0.5
sekunder, skriv ut flera tecken.
Uppgift 6
• Frivillig uppgift för de som laborerar ensamma eller i par
(två)
• Modifiera föregående uppgift genom att ersätta
autorepetitionen med ett sätt att göra manuell
nollställning. När man tryckt länge så ska det nollställas.
Uppgift 5
© Copyright 2024