Extra lab. Nu på fredag kl 8-12 Frivillig Enbart hjälp med projektuppgiften Ingen examination

Extra lab Nu på fredag kl 8-12 Frivillig Enbart hjälp med projektuppgiften Ingen examination

Erfarenheter från projektstart Läs på i Downey om klasser och objekt! När kan/ska man använda self? När bollarna krockar så fastnar de i varandra Hur placera flera bollar slumpvis så de inte överlappar?

Användning av self self används enbart när man definierar en metod till en klass. self ska vara första parametern till varje metod, även till init () I metodkroppen representerar self det objekt som används vid metodanropet

class Ball():.. def krock(self,otherball):.. theball = Ball(...) self -> theball otherball -> redball redball = Ball(...) theball.krock(redball)

class Ball():.. def move(self): for otherball in ballist: if self.krock(otherball):.. def krock(self,otherball):.. ballist =... for ball in ballist: ball.move()

Krock: distansen mellan centra är mindre än summan av radierna och bollarna är på väg mot varandra Avståndet minskar om bollarna får köra ett steg till: dist(add(b1.pos, b1.velocity)), add(b2.pos, b2.velocity))) ska vara mindre än dist(b1.pos, b2.pos)

Placera bollar så de inte överlappar

Placera bollar så de inte överlappar def overlaps(newpos,ball): ## will a new ball at newpos overlab the ball ball? return distance(ball.pos, newpos < 2*ball.radius)

Placera bollar så de inte överlappar def overlaps(newpos,ball): ## will a new ball at newpos overlab the ball ball? return distance(ball.pos, newpos < 2*ball.radius) def isgood(pos): ## will a new ball at pos stay clear of all balls? for ball in ballist: if overlaps(ball,pos): return False return True

Placera bollar så de inte överlappar def overlaps(newpos,ball): ## will a new ball at newpos overlab the ball ball? return distance(ball.pos, newpos < 2*ball.radius) def isgood(pos): ## will a new ball at pos stay clear of all balls? for ball in ballist: if overlaps(ball,pos): return False return True def placeball(ball): ## find a good place for ball while True: newpos = randomly generate new position if isgood(newpos): ball.pos = newpos break

Placera bollar så de inte överlappar def overlaps(newpos,ball): ## will a new ball at newpos overlab the ball ball? return distance(ball.pos, newpos < 2*ball.radius) def isgood(pos): ## will a new ball at pos stay clear of all balls? for ball in ballist: if overlaps(ball,pos): return False return True def placeball(ball): ## find a good place for ball while True: newpos = randomly generate new position if isgood(newpos): ball.pos = newpos break ballist = [] for i in range(15): # Generate and place 15 balls ball = Ball(...) placeball(ball) ballist.append(ball)

Mål Efter godkänd kurs ska den studerande kunna: övergripande kunna förklara principerna för hur en dator är uppbyggd och arbetar. Denna vecka: en provtur i assemblerprogrammering

Inuti en dator

Moderkort

Processor

Dopad kiselkristall

Floor plan

CMOS transistorer

Transistor

Logiska grindar (Gates)

Logiska nätverk

Aritmetik

Minnen (1 bit)

Processorkärnor

Datavägen Register ALU! 7 8! Databussar

Datavägen Register ALU! 7! 8 Databussar

Datavägen Register ALU!! 15 Databussar

Exekveringscykeln!! *)+#,-.,)! "#$%#&'! (&)&! Instruktion Instruktion Instruktion! Minne

Exekveringscykeln!! *)+#,-.,)! Instruktion "#$%#&'! (&)&! Instruktion Instruktion! Minne

Exekveringscykeln!! Styrsignaler Styrsignaler: Välj rätt register Välj rätt ALU-operation *)+#,-.,)! Instruktion "#$%#&'! (&)&! Instruktion Instruktion! Minne

Exekveringscykeln!! Styrsignaler: Välj rätt register Välj rätt ALU-operation *)+#,-.,)! "#$%#&'! (&)&! Instruktion Instruktion! Minne

Instruktionstyper Registerinstruktioner Aritmetik Flytt mellan register Ladda register med tal Minnesinstruktioner Läs från minnet till register Skriv till minnet från register Programflödesinstruktioner (för att bestämma vilken instruktion som ska utföras härnäst)

Maskinkod Varje instruktion är ett ord = 32 bitar Ex: 0000000111110000100010000010000 betyder addera register nr 15 och 16, lagra resultatet i register 17 Ett program är en linjär sekvens sådana ord 0000000111110000100010000010000 0010000111110000100010000010000 0000000111110000100010110010000 0100000110110000100010000010000 0100000111110000100010110010000 0000000111110000100010000010000...

Kompilator Högnivåkod Maskinkod def hist_max(): loopvar = 1 maximum = 0 var_max = 1 while loopvar <= 50: print "x"*cl(loopvar) if cl(loopvar) > maximum: maximum = cl(loopvar) var_max = loopvar Kompilatorn översätter automatiskt 0000000111110000100010000010000 0010000111110000100010000010000 0000000111110000100010110010000 0100000110110000100010000010000 0100000111110000100010110010000 0000000111110000100010000010000 0000000111110000100010000010000 0010000111110000100010000010000 0000000111110000100010110010000 0100000110110000100010000010000 0100000111110000100010110010000 0000000111110000100010000010000

Assemblerspråk Textformat för maskinkod. add $r17, $r15, $r16 0000000111110000100010000010000 En koncis rad -> En maskininstruktion

Assemblator Assemblerkod Maskinkod inloop: li $v0, 5 syscall move $s0, $v0 beq $s0, 0, continue sw $s0, ($s1) add $s1, $s1, 4 j inloop Assemblatorn översätter automatiskt 0000000111110000100010000010000 0010000111110000100010000010000 0000000111110000100010110010000 0100000110110000100010000010000 0100000111110000100010110010000 0000000111110000100010000010000 0000000111110000100010000010000 0010000111110000100010000010000 0000000111110000100010110010000 0100000110110000100010000010000 0100000111110000100010110010000 0000000111110000100010000010000

Assemblerprogram Program = Linjär lista av instruktioner Instruktion = operation följt av operander Operationer indelas i typer. Registerinstruktioner Minnesinstruktioner Flödesinstruktioner Operander kan vara registerreferenser eller heltal

Register Mips har 32 stycken, $r0... $r31 Vart och ett är 32 bitar. Kan lagra heltal mellan -2 31 och +2 31-1 En del används för speciella ändamål En del har speciella namn $sp, $a0,... Vi kan lugnt använda de 8 registren $s0,..., $s7

Registerinstruktioner Aritmetik: add, sub, mul, div Alltid tre operander: destination, op1, op2 Operanderna är register. op2 får också vara heltal. add $s0, $s1, $s2 sub $s7, $s7, 4 add $s2, $s2, $s2 s0 = s1+s2 s7 = s7 4 s2 = s2+s2

Vad gör följande pgm? add $s3, $s0, $s1 add $s3, $s3, $s2 div $s3, $s3, 3

Vad gör följande pgm? add $s3, $s0, $s1 add $s3, $s3, $s2 div $s3, $s3, 3 s3 blir medelvärdet av s0,s1,s2

move Kopierar innehållet från ett register till ett annat move $s3, $s1 s3 = s1 li (load immediate) Lägger ett tal i ett register li $s2, 17 s2 = 17

syscall Anrop till operativsystemet Används för att Läsa in data Skriva ut data Avsluta program Instruktionen syscall har inga operander. Istället ska registret v0 laddas med rätt anropskod.

Inmatning li $v0, 5 # anropskod för input syscall Läser in ett heltal. Det lagras i v0

Utmatning li $v0, 1 syscall # anropskod för output # skriv ut talet i a0 Skriver ut det tal som ligger i a0

Programslut li $v0, 10 syscall

Anropskoder v0 gör 5 1 Inmatning av heltal till v0 Utmatning av heltal från a0 10 Avslutar programmet

Exempel: vad gör? main: li $v0, 5 syscall move $s0, $v0 li $v0, 5 syscall add $s0, $s0, $v0 li $v0, 1 move $a0, $s0 syscall li $v0, 10 syscall körexempel

Flödesinstruktioner För att referera till platser i ett assemblerprogram används etiketter (labels) En etikett avslutas med kolon och ska stå först (eller ensamt) på en rad. Ex: loop: Hoppinstruktioner kan medföra att ordinarie linjära körning bryts och att programmet hoppar till, dvs fortsätter vid en given etikett Ex: j loop # hoppa till etikett loop

En oändlig loop main: li $v0, 5 syscall move $s0, $v0 li $v0, 5 syscall add $s0, $s0, $v0 li $v0, 1 move $a0, $s0 syscall j main

Villkorshopp Testar ett enkelt villkor och hoppar bara om det är uppfyllt Inte uppfyllt -> hoppa inte utan fortsätt med nästa instruktion som vanligt Villkor: Jämföra två register eller ett register och ett heltal

Villkor beq bne bgt bge blt ble ==!= > >= < <= Exempel beq $s0, $s1, end Hoppa till etikett end om innehållet i s0 och s1 är lika

Indelat i ord. Minnet 1 ord = 4 byte = 32 bit, dvs kan lagra som ett register (alt. en maskininstruktion) Varje byte har en adress. Första byte har adress 0, andra adress 1, etc. Adressen till ett ord är adressen till dess första byte. Första ord har adress 0, andra adress 4, etc 2 30-4 Det finns storleksordning 109 ord 4 8 0 { 32 bit

Datasegmentet I ett assemblerprogram kan man allokera en mängd minne ur det så kallade datasegmentet.data # anger datasegmentet.space 40 # allokera 40 byte = 10 ord.data och.space är så kallade direktiv, alltså inte assemblerinstruktioner.

Minnesinstruktioner lw sw load word, läs från minne till register store word, skriv till minne från register Tar två operander: 1. Ett register 2. En minnesplats En minnesplats kan vara endera av 1. En etikett i datasegmentet 2. Ett register inom parantes: betyder att det registret anger adressen. la load address, lägg minnesadress i ett register

Exempel lw $s0, base add $s0, $s0, $s0 sw $s0, base.data base:.space 40

Vad gör detta? la $s1, base lw $s0, ($s1) add $s1, $s1, 4 lw $s2, ($s1) add $s0, $s0, $s2

Inför nästa lab Läs på labinstruktionen. Inget annat material denna gång! Välj ny partner, för sista gången! Kolla att du kan starta PCSpim och köra något enkelt exempel

Individuellt prov Sker i labsal i halvklass: A1 - A2 - B1 - B2. Samma typ av uppgifter som labbarna fast enklare. Ingen assembler. Individuell, tyst programmering. Ingen hjälp från lärare. Vi examinerar bara. Samma hjälpmedel som på labbarna tillåtna. Egen dator tillåten. Förbered: Kolla att du kan logga in och öppna filerna words.txt och hamlet.txt. Kodhygien ett krav Graderat betyg som på en lab Uppgifterna får ej avslöjas. Uppgifterna kan variera. Alla får inte säkert precis samma uppgifter.

Projektredovisning Boka tid med respektive labledare. En grupp = 10 minuter. Förbered presentation vid dator om 5 minuter. Visa körning och kod. Bägge ska medverka. Egen dator tillåten. Labledaren kan ställa kontrollfrågor och provköra. Graderade betyg. Kriterier: Hur mycket funktionalitet som implementerats, kodens struktur och hygien, presentationens tydlighet.