Musterlo ̈sung
U ̈bung1 RAWiSe18/19
Die Kosten fu ̈r eine integrierte Schaltung sind durch folgende Beziehungen gegeben: Kosten-pro-Die = Kosten-pro-Wafer (1)
Dies-pro-Wafer × Ausbeute Dies-pro-Wafer ≈ Waferfla ̈che
(2)
(3)
Ausbeute =
Diefla ̈che
1
(1 + (Defektdichte × Diefla ̈che/α))α
Von diesen Beziehungen ist nur Gleichung 1 exakt. Gleichung 2 ist eine Approximation, da unvollsta ̈ndige Dies am Rande des Wafers nicht beru ̈cksichtigt werden. Gleichung 3 ist eine empirisch festgestellte Beziehung zwischen der Defektdichte (Defekte pro Fla ̈che), Diefla ̈che und Ausbeute. Der Wert fu ̈r α variiert von Technologie zu Technologie. Wir nehmen im folgenden α = 2 an.
Aufgabe 1 (Ausbeute)
Wie ha ̈ngen die Kosten-pro-Die – bei konstanter Waferfla ̈che und Defektdichte – von der Diefla ̈che ab? Hinweis: Untersuchen Sie folgende funktionale Abha ̈ngigkeit: Kosten-pro-Die = f(Diefla ̈chez)
Musterlo ̈sung
Es sind zwei Abha ̈ngigkeiten festzustellen: Dies-pro-Wafer = f(Diefla ̈chex) und Ausbeute = f(Diefla ̈chey). Aus Gleichung 2 ergibt sich x mit -1; aus Gleichung 3 ergibt sich y mit -2. Das Gesamtergebnis ist dann:
Kosten-pro-Die = f(Diefla ̈che3) (4)
Das bedeutet, dass Hardwareentwickler sich gut u ̈berlegen mu ̈ssen, welche Funktionen die Hardware haben soll. Nur Funktionen, die einen deutlichen Gewinn in der Prozessorlei- stung bringen, sollten in Hardware realisiert werden.
Aufgabe 2 (Diekosten)
Nehmen Sie an, auf einem 8-inch Wafer befinden sich 165 Dies mit einer Gro ̈sse von 250 mm2. Ein Wafer kostet $ 1000. Die Defektdichte betra ̈gt 1 Defekt/cm2. Wie hoch sind die Kosten fu ̈r einen Die?
Musterlo ̈sung
Die Ausbeute ergibt sich nach der empirischen Gleichung 3 und α = 2 mit: 11
Ausbeute=(1+(Defektdichte×Diefla ̈che/2))2 =1+ 1 · 250mm22 =0,1975 100mm2 2
(5) Seite 1 / 8
Musterlo ̈sung
U ̈bung1 RAWiSe18/19
Damit lassen sich die Kosten fu ̈r einen Die nach Gleichung 1 bestimmen: Kosten-pro-Die = Kosten-pro-Wafer = $ 1000 = $ 30,68 (6)
Aufgabe 3 (Break-Even)
Eine Firma plant die Herstellung eines neuen IC. Die Fixkosten fu ̈r Forschung und Ent- wicklung, Gera ̈te, etc., belaufen sich auf $ 500’000. Die Kosten zur Herstellung eines Wafers betragen $ 6’000. Ein Wafer kann in 1500 Dies zersa ̈gt werden. Die Die-Ausbeute wird mit 50% gescha ̈tzt. Die Dies werden in Geha ̈use verpackt und nochmals getestet, was pro IC $ 10 kostet. Die Test-Ausbeute wird mit 90% gescha ̈tzt. Der Verkaufspreis sollte 40% u ̈ber den Kosten liegen. Wie viele ICs mu ̈ssen verkauft werden, damit der break-even erreicht wird (Kosten = Verkaufserlo ̈s).
Musterlo ̈sung
Aus einem $ 6’000 teueren Wafer erha ̈lt man 1500 Dies, wovon 750 funktionsfa ̈hig sind. Das packaging dieser 750 Dies kostet $ 10 × 750 = $ 7’500. Nach dem packaging erha ̈lt man 750×0,9 = 675 funktionsfa ̈hige ICs. Die variablen Kosten fu ̈r einen IC sind demnach ($ 6’000 + $ 7’500)/675 = $ 20. Der Verkaufspreis soll 40% daru ̈ber liegen, also bei $ 28. Fertig man n ICs, berechnet sich der break-even mit:
500′000+n·20=! n·28 (7)
Die linke Seite der Gleichung entspricht den Gesamtkosten (fix + variabel); die rechte entspricht dem Gesamterlo ̈s. Die Lo ̈sung ist n=62’500 ICs.
Dies-pro-Wafer × Ausbeute 165 · 0,1975
Seite 2 / 8
Musterlo ̈sung
U ̈bung1 RAWiSe18/19
Aufgabe 4 (MIPS Codefragment 1)
Zu Beginn des folgenden MIPS Codefragments beinhalten die Register $a0 und $a1 die Eingabewerte a und b. Nach der Ausfu ̈hrung des Codefragments steht das Resultat im Register $v0. Kommentieren Sie den Code und beschreiben Sie, was berechnet wird.
add
loop: beq
add
subi
j
finish: addi
add
$t0, $zero, $zero
$a1, $zero, finish
$t0, $t0, $a0
$a1, $a1, 1
loop
$t0, $t0, -50
$v0, $t0, $zero
Musterlo ̈sung
Mit $a0 = a, $a1 = b und $zero = 0 sehen beispielhafte Kommentare fu ̈r das Codefrag- ment wie folgt aus:
add $t0, $zero, $zero
#$t0=0
# if (b == 0) goto finish #$t0=$t0+a #b=b-1
# goto loop #$t0=$t0-50
# $v0 = $t0, d.h.
# Ergebnis in Register $v0
loop: beq
add $t0, $t0, $a0
sub $a1, $a1, 1
j loop
finish: addi
add $v0, $t0, $zero
$a1, $zero, finish
$t0, $t0, -50
Das Codefragment addiert a genau b-mal auf und addiert dazu nochmals -50. Es wird somit berechnet:
f (a, b) = a · b − 50
Die Instruktion sub $a1, $a1, 1 ist keine MIPS Instruktion, da der MIPS Instruktions- satz keine Subtraktion mit einem immediate-Operanden kennt. Ein vernu ̈nftiger MIPS Assembler wird diese Pseudoinstruktion erkennen und durch addi $a1, $a1, -1 erset- zen (siehe Codezeile 6).
Seite 3 / 8
Musterlo ̈sung
U ̈bung1 RAWiSe18/19
Aufgabe 5 (MIPS Codefragment 2)
Das folgende Codefragment verarbeitet zwei Felder A und B und berechnet ein Resultat im Register $v0. Jedes der Felder besteht aus 2500 Wo ̈rtern. Die Basisadressen der Felder A und B sind in den Registern $a0 und $a1 gespeichert, die La ̈ngen der Felder (jeweils 2500) in den Registern $a2 und $a3. Kommentieren Sie den Code und beschreiben Sie, was berechnet wird.
sll $a2, $a2, 2
sll $a3, $a3, 2
add $v0, $zero, $zero
add $t0, $zero, $zero
outer: add
lw $t4, 0($t4)
$t4, $a0, $t0
add $t1, $zero, $zero
inner: add
lw $t3, 0($t3)
bne $t3, $t4, skip
addi $v0, $v0, 1
$t3, $a1, $t1
skip: addi
bne $t1, $a3, inner
addi $t0, $t0, 4
bne $t0, $a2, outer
Musterlo ̈sung
Annahmen: $a0 = Basisadresse A, $a1 = Basisadresse B, $a2 = a und $a3 = b.
$t1, $t1, 4
1
2
3
4
5 outer:
6
7
8 inner: 9
10
11
12 skip:
13
14
15
sll $a2, $a2, 2
sll $a3, $a3, 2
add $v0, $zero,
add $t0, $zero,
add $t4, $a0, $t0
lw $t4, 0($t4)
add $t1, $zero, $zero
add $t3, $a1, $t1
lw $t3, 0($t3)
bne $t3, $t4, skip
addi $v0, $v0, 1
addi $t1, $t1, 4
bne $t1, $a3, inner
addi $t0, $t0, 4
bne $t0, $a2, outer
#a=amal4 #b=bmal4 #$v0=0 #$t0=0
# $t4 = Basisadresse_A + $t0 # $t4 = Speicher[$t4 + 0] #$t1=0
# $t3 = Basisadresse_B + $t1 # $t3 = Speicher[$t3 + 0]
# if ($t3 != $t4) goto skip #$v0=$v0+1 #$t1=$t1+4 #if($t1!=b) goto inner #$t0=$t0+4 #if($t0!=a) goto outer
$zero $zero
Es werden die Inhalte der zwei Felder A und B mittels zwei verschachtelter Schleifen verglichen. Dabei wird paarweise die Anzahl der gleichen Felder bestimmt und im Register $v0 als Ergebnis zur Verfu ̈gung gestellt.
Seite 4 / 8
Musterlo ̈sung
U ̈bung1 RAWiSe18/19
Zum besseren Versta ̈ndnis weitere Kommentare zum Code:
Zeile 1: Zeile 2: Zeile 5: Zeile 6: Zeile 8: Zeile 9: Zeile 10: Zeile 12:
Zeile 13: Zeile 14: Zeile 15:
Speicherplatzbedarf des Feldes A
Speicherplatzbedarf des Feldes B
$t4 erha ̈lt die Speicheradresse des na ̈chsten Elements von A
$t4 erha ̈lt den Inhalt der Speicheradresse $t4
$t3 erha ̈lt die Speicheradresse des na ̈chsten Elements von B
$t3 erha ̈lt den Inhalt der Speicheradresse $t3
sind $t4 und $t3 gleich, wird Zeile 11 ausgefu ̈hrt, ansonsten u ̈bersprungen $t1 wird um 4 erho ̈ht, so dass nach Ausfu ̈hren von Zeile 8 $t3 auf
das na ̈chste Element von B zeigt
so lange das Ende von Feld B nicht erreicht ist, fahre mit dem na ̈chsten Element von B fort
$t0 wird um 4 erho ̈ht, so dass nach Ausfu ̈hren von Zeile 5 $t4 auf
das na ̈chste Element von A zeigt
so lange das Ende von Feld A nicht erreicht ist, fahre mit dem na ̈chsten Element von A fort
Aufgabe 6 (Pseudoinstruktionen)
Pseudoinstruktionen sind Instruktionen, die zwar in Assemblerprogrammen vorkommen ko ̈nnen aber nicht Teil des MIPS Instruktionssatzes sind. Der MIPS Assembler setzt Pseudoinstruktionen in MIPS Instruktionen um. Je nach Pseudoinstruktion wird der As- sembler eine oder mehrere MIPS Instruktionen generieren. Oft ist fu ̈r die Umsetzung ein Hilfsregister notwendig. Dafu ̈r wird das Register $at reserviert. Setzen Sie die Pseudoin- struktionen in der folgenden Tabelle in eine minimale MIPS Instruktionsfolge um. In der Tabelle bedeutet KLEIN eine 16-Bit Konstante und GROSS eine 32-Bit Konstante.
Pseudoinstruktion
Bedeutung
move $t1, $t2
$t1 = $t2
clear $t0
$t0 = 0
li $t1, KLEIN
$t1 = KLEIN
li $t2, GROSS
$t2 = GROSS
beq $t1, KLEIN, L
if ($t1 = KLEIN) goto L
beq $t2, GROSS, L
if ($t2 = GROSS) goto L
ble $t3, $t5, L
if ($t3 <= $t5) goto L
bgt $t4, $t5, L
if ($t4 > $t5) goto L
addi $t0, $t2, GROSS
$t0 = $t2 + GROSS
lw $t5, GROSS($t2)
$t5 = Speicher[$t2 + GROSS]
Seite 5 / 8
Musterlo ̈sung
U ̈bung1 RAWiSe18/19
Musterlo ̈sung
Aufgefu ̈hrt sind beispielhafte Instruktionsfolgen mit einer minimalen Anzahl von Instruk- tionen fu ̈r eine Pseudoinstruktion. upper und lower bedeuten die ho ̈herwertigen bzw. nie- derwertigen 16 Bit einer 32-bit Konstante.
Pseudoinstruktion
MIPS Instruktionsfolge
move $t1, $t2
add $t1, $t2, $zero oder or $t1, $t2, $zero
clear $t0
and $t0, $zero, $zero
li $t1, KLEIN
addi $t1, $zero, KLEIN
li $t2, GROSS
lui $t2, upper(GROSS)
ori $t2, $t2, lower(GROSS)
beq $t1, KLEIN, L
addi $at, $zero, KLEIN
beq $t1, $at, L
beq $t2, GROSS, L
lui $at, upper(GROSS)
ori $at, $at, lower(GROSS)
beq $t2, $at, L
ble $t3, $t5, L
slt $at, $t5, $t3
beq $at, $zero, L
bgt $t4, $t5, L
slt $at, $t5, $t4
bne $at, $zero, L
addi $t0, $t2, GROSS
li $at, GROSS
add $t0, $t2, $at
lw $t5, GROSS($t2)
li $at, GROSS
add $at, $at, $t2
lw $t5, 0($at)
Seite 6 / 8
Musterlo ̈sung
U ̈bung1 RAWiSe18/19
Aufgabe 7 (U ̈bersetzung von Schleifen)
In der Vorlesung wurde die Umsetzung des C-Programms
while (save[i] == k)
i = i + 1;
in folgende MIPS Instruktionen diskutiert:
1 Loop: 2
3
4
sll $t1, $s3, 2
add $t1, $t1, $s6
lw $t0, 0($t1)
bne $t0, $s5, Exit
addi $s3, $s3, 1
j Loop
# $t1=4*i
# $t1= Adresse von save[i]
# $t0=save[i]
# if (save[i]!=k) goto Exit
# i=i+1
# goto Loop
5 6
Exit: …
Dieser Code benutzt eine bedingte Verzweigung und einen unbedingten Sprung pro Schlei- feniteration. Ein solcher Code wu ̈rde nur von einem sehr schlechten Compiler erzeugt werden.
(1) Optimieren Sie den MIPS Code derart, dass maximal eine Verzweigungs/Sprung- instruktion pro Schleifeniteration verwendet wird.
(2) Wieviele Instruktionen werden in der urspru ̈nglichen und in der optimierten Version beno ̈tigt, wenn die Bedingung in der while Schleife genau 19 mal ausgewertet wird?
Seite 7 / 8
Musterlo ̈sung
U ̈bung1 RAWiSe18/19
Musterlo ̈sung
(1) Es existieren viele mo ̈gliche Lo ̈sungen. Im folgenden werden zwei angegeben, die nur
eine Verzweigungsinstruktion pro Iteration verwenden.
Variante A
1 Loop: sll
2 add
3 lw
4 addi
5 beq
6 addi
…
Variante B
1 sll
2 add
3 lw
4 bne
5 Loop: addi
$t1, $s3, 2
$t1, $t1, $s6
$t0, 0($t1)
$s3, $s3, 1
$t0, $s5, Loop
$t3, $t3, -1
$t1, $s3, 2
$t1, $t1, $s6
$t0, 0($t1)
$t0, $s5, Exit
$t3, $t3, 1
$t1, $s3, 2
$t1, $t1, $s6
$t0, 0($t1)
$t0, $s5, Loop
# $t1=4*i
# $t1= Adresse von save[i]
# $t0=save[i]
# i=i+1
# if (save[i]==k) goto Loop
# i=i-1
# $t1=4*i
# $t1= Adresse von save[i] # $t0=save[i]
# if (save[i]!=k) goto Exit #i=i+1
# $t1=4*i
# $t1= Adresse von save[i] # $t0=save[i]
# if (save[i]==k) goto Loop
6
7
8
9
10 Exit: …
sll add lw beq
(2) In der urspru ̈nglichen Version werden 19 mal die Zeilen 1–4 ausgefu ̈hrt und 18 mal die Zeilen 5 und 6. Damit werden insgesamt 76+36 = 112 Instruktionen ausgefu ̈hrt.
In der optimierten Variante A werden 19 mal die Zeilen 1-5 ausgefu ̈hrt und einmal die Zeile 6. Damit werden insgesamt 95 + 1 = 96 Instruktionen ausgefu ̈hrt.
In der optimierten Variante B werden einmal die Zeilen 1-4 ausgefu ̈hrt und 18 mal die Zeilen 5-9. Damit werden insgesamt 4 + 90 = 94 Instruktionen ausgefu ̈hrt.
Die Codegro ̈sse (Anzahl der Instruktionen des Programms) fu ̈r die urspru ̈ngliche Version ist 6 Instruktionen, fu ̈r die optimierte Variante A 6 Instruktionen und fu ̈r die optimierte Variante B 9 Instruktionen.
Seite 8 / 8