Procedure annidate. Università degli studi di Milano

Documenti analoghi
Procedure annidate. Università degli Studi di Milano Corso di Laurea in Informatica, A.A Homepage del corso

Convenzioni per la chiamata a procedure

Convenzioni di chiamata a procedure

15 April LABORATORIO 04 PROCEDURE STACK. CHIAMATA A PROCEDURE I. Frosio

Il Linguaggio Assembly: Le procedure

Il linguaggio assembly

Assembly (3): le procedure

Gestione dello Stack nel MIPS

Procedure SOMMARIO: DIPARTIMENTO DI INFORMATICA Laboratorio di Architetture degli Elaboratori II Turno B : ( G Z )

Assembly (3): le procedure

Assembly IV Le procedure

Istruzioni di trasferimento dati

Architetture dei Calcolatori

Fetch Decode Execute Program Counter controllare esegue prossima

Istruzioni di controllo del flusso

Gestione dei sottoprogrammi. temporaneo passaggio del controllo dal programma in esecuzione ad un sottoprogramma

Assembly MIPS: le procedure

Addendum: istruzioni linguaggio macchina. Università di Bergamo - corso di Calcolatori Elettronici 1

Università degli Studi di Cassino

Manualino minimale MIPS

p = 7. E = bias + p = = E = s e m

Università degli Studi di Cassino e del Lazio Meridionale

Architettura degli STACK. Dott. Franco Liberati

Le procedure ricorsive Come eseguire un programma. Architettura degli Elaboratori e delle Reti, Turno I

Le procedure. L insieme delle istruzioni (4) Prima della chiamata di una procedura. Le procedure (2) Architetture dei Calcolatori (lettere A-I)

Laboratorio 6 - MIPS 2

Assembly V: Procedure annidate e recursive

Architetture dei Calcolatori

Assembler MIPS 32 Assembly II

Realizzazione delle strutture di controllo in Assembly

Programmi in Assembly

5 April LABORATORIO 03 CONTROLLO DEL FLUSSO DI UN PROGRAMMA JUMP ADDRESS TABLE. I. Frosio

Architettura dei calcolatori e sistemi operativi. Sottoprogrammi e MIPS. Espressioni algebriche. Capitolo 2 P&H

ARCHITETTURE DEI CALCOLATORI (canale A-I) - Prima prova in itinere del 16/6/2003 Compito tipo A

Procedure: esempi. Esempi: ricorsione fattoriale Fibonacci ordinamenti

MIPS! !

MIPS Instruction Set 2

Calcolatori Elettronici

MIPS Instruction Set 2

Lezione 20. della CPU MIPS. Prof. Federico Pedersini Dipartimento di Informatica Università degli Studi di Milano

Laboratorio di Architettura degli Elaboratori LabArch 2006 Secondo Quadimestre, a.a Docente: H. Muccini

Capitolo 5 - Funzioni

Gestione delle eccezioni.

Esempi di Programmi Assembly. Luigi Palopoli, Luca Abeni

Lezione 20. Assembly MIPS: Il set istruzioni, strutture di controllo in Assembly

Il set istruzioni di MIPS Modalità di indirizzamento. Proff. A. Borghese, F. Pedersini

L ambiente di simulazione SPIM

Il linguaggio assembly

Lezione 12. Assembly II. Set di Istruzioni MIPS Strutture di controllo in Assembly

7 May INTERRUPT ED ECCEZIONI I. Frosio

Il linguaggio del calcolatore: linguaggio macchina e linguaggio assembly

L ambiente di simulazione SPIM

Lezione 20. della CPU MIPS. Prof. Federico Pedersini Dipartimento di Informatica Università degli Studi di Milano

Il linguaggio assembly

Architettura degli Elaboratori Lez. 3 ASM: Strutture di controllo. Prof. Andrea Sterbini

Il set istruzioni di MIPS Modalità di indirizzamento. Proff. A. Borghese, F. Pedersini

Controllo di flusso. Università degli Studi di Milano Corso di Laurea in Informatica, A.A

Il linguaggio del calcolatore: linguaggio macchina e linguaggio assembly

Programmazione Assembly. RISC e CISC Esecuzione sequenziale Esecuzione condizionata Cicli Subroutine

ESERCIZIO 1 Si consideri la seguente funzione f (A, B, C, D) non completamente specificata definita attraverso il suo ON-SET e DC-SET:

System Calls, Register Spilling

8 March : LABORATORIO 01 ISA & ASSEMBLY REGISTER FILE INTRODUZIONE A SPIM OPERAZIONI ARITMETICHE. I. Frosio

Linguaggio Assembly e linguaggio macchina

Esercizi Programmazione I

Calcolatori Elettronici Prof. Fabio Roli. Linguaggio Assembly. Capitolo 5. Corso di Laurea di Ingegneria Elettronica

Linguaggio Assembly e linguaggio macchina

Controllo di flusso. Università degli Studi di Milano Corso di Laurea in Informatica, A.A Homepage del corso

Architettura degli. Esercizi sullo STACK. Dott. Franco Liberati

Linguaggio Assembly e linguaggio macchina

Architettura degli elaboratori

Esercitazione di Calcolatori Elettronici Ing. Battista Biggio. Corso di Laurea in Ingegneria Elettronica. Capitolo 5 Linguaggio Assembly

Eccezioni. Università degli Studi di Milano Corso di Laurea in Informatica, A.A

Le etichette nei programmi. Istruzioni di branch: beq. Istruzioni di branch: bne. Istruzioni di jump: j

Le procedure. Architetture dei Calcolatori (Lettere. Le procedure (3) Le procedure (2)

MIPS Instruction Set 1

ISA (Instruction Set Architecture) della CPU MIPS

Richiami: v[i] e &v[i] Organizzazione della memoria. Organizzazione della memoria. Esercitazione di Calcolatori Elettronici Ing. Gian Luca Marcialis

SPIM e MIPS. Non abbiamo bisogno di una PSP per testare il codice

Lezione 20. Assembly MIPS: Il set istruzioni, strutture di controllo in Assembly

MIPS Instruction Set 1

Architettura degli. Assemblatore Nomenclatura MARS. Dott. Franco Liberati

26 April CHIAMATA A PROCEDURE PROCEDURE ANNIDATE PROCEDURA RICORSIVE I. Frosio

ISA e linguaggio macchina

ESERCIZIO 1 (Funzioni)

15 April INTERRUPT ED ECCEZIONI I. Frosio

Assembly III SPIM: un ambiente di simulazione MIPS

ISA (Instruction Set Architecture) della CPU MIPS32

Introduzione. Indice. Linguaggio macchina. Linguaggio assembler

Istruzioni assembler Istruzione N Registri

Introduzione a MIPS64 (II parte)

Richiami: v[i] e &v[i] Organizzazione della memoria. Esercizio 1. Esercitazione di Calcolatori Elettronici Prof. Gian Luca Marcialis

ESERCIZIO 1 - Funzioni

Programmazione in Java e gestione della grafica. Lezione 6

L insieme delle istruzioni (5)

Subroutine in linguaggio macchina: collegamento e passaggio dei parametri. Sottoprogrammi: richiami

Subroutine in linguaggio macchina: collegamento e passaggio dei parametri

Transcript:

Procedure annidate Università degli studi di Milano matteo.re@unimi.it http://homes.di.unimi.it/re/

Procedura foglia Scenario più semplice: il main chiama una procedura, la procedura termina senza chiamare a sua volta un altra procedura e restituisce il controllo al main main f = f + 1; if (f == g) res = funct(f,g); funct int funct (int p1, int p2){ else f = f -1; print(res) } int out; out = p1 * p2; return out; Una procedura che non ne chiama un altra al suo interno è detta procedura foglia

Procedura annidata Procedure annidate: una procedura può al suo interno chiamare un altra procedura. main funct funct2 f = f + 1; int funct (int p1, int p2){ int funct2 (int p1){ if (f == g) res = funct(f,g); else f = f -1; out; } int out,x; x = p1 * p2; out = funct2(x) return } return p1^2; print(res) Se una procedura contiene una chiamata ad un altra procedura dovrà effettuare delle operazioni per (1) garantire la non-alterazione dei registri opportuni (2) consentire una restituzione del controllo consistente con l annidamento delle chiamate. Ricordiamo: in assembly la modularizzazione in procedure è un assunzione concettuale sulla struttura e sul significato del codice. Nella pratica ogni «blocco» di istruzioni condivide lo stesso register file e aree di memoria.

Procedura annidata Supponiamo che: il main chiami una procedura A passandogli 3 come parametro, i.e., copiando 3 nel registro $a0 e eseguendo jal A la procedura A chiami a sua volta una procedura foglia B passandogli 5 come parametro, i.e., copiando 5 nel registro $a0 e eseguendo jal B Ci sono potenziali conflitti su $a0 e $ra! 1.A potrebbe necessitare di $a0 (il suo parametro in input) anche dopo la chiamata a B 2.invocando B, A perde il suo return address e non sa più a chi restituire il controllo Come prevenirli? Uso dello stack: 1.A salva sullo stack i registri di cui avrà ancora bisogno dopo la chiamata, ad esempio $a0 2.A salva sullo stack il registro $ra. Una volta che B è terminata, A potrà ripristinare le informazioni per terminare correttamente leggendo dallo stack

Esempio Calcolo l espressione (a+b) (c+d) utilizzando due procedure annidate (codice pseudo-c): main { res = f1(a,b,c,d) } int f1(int a, int b, int c, int d) { int t0 = a + b; int t1 = c + d; int result = f2(t0, t1); return(result); } int f2(int t0, int t1) { retrun (t0 t1); }

Esempio Calcolo l espressione (a+b) (c+d) utilizzando due procedure annidate (codice pseudo-c): main: li $s0, 2 #$s0=a=2 li $s1, 25 #$s1=b=25 li $s2, 31 #$s2=c=31 li $s3, 4 #$s3=d=4 mov $a0, $s0 mov $a1, $s1 mov $a2, $s2 mov $a3, $s3 jal f1 mov $s5, $v0 f1: addi $sp, $sp, -4 sw $ra, 0($sp) add $a0, $a0, $a1 add $a1, $a2, $a3 jal f2 lw $ra, 0($sp) addi $sp,$sp,4 jr $ra f2: sub $v0, $a0, $a1 jr $ra

Esempio Calcolo l espressione (a+b) (c+d) utilizzando due procedure annidate (codice pseudo-c): main: li $s0, 2 #$s0=a=2 li $s1, 25 #$s1=b=25 li $s2, 31 #$s2=c=31 li $s3, 4 #$s3=d=4 mov $a0, $s0 mov $a1, $s1 mov $a2, $s2 mov $a3, $s3 jal f1 mov $s5, $v0 f1: addi $sp, $sp, -4 sw $ra, 0($sp) add $a0, $a0, $a1 add $a1, $a2, $a3 jal f2 lw $ra, 0($sp) addi $sp,$sp,4 jr $ra f1 salva sullo stack tutto ciò di cui avrà bisogno per terminare correttamente ogni sua esecuzione f2: sub $v0, $a0, $a1 jr $ra

Esempio Calcolo l espressione (a+b) (c+d) utilizzando due procedure annidate (codice pseudo-c): main: li $s0, 2 #$s0=a=2 li $s1, 25 #$s1=b=25 li $s2, 31 #$s2=c=31 li $s3, 4 #$s3=d=4 mov $a0, $s0 mov $a1, $s1 mov $a2, $s2 mov $a3, $s3 jal f1 mov $s5, $v0 f1: addi $sp, $sp, -4 sw $ra, 0($sp) add $a0, $a0, $a1 add $a1, $a2, $a3 jal f2 lw $ra, 0($sp) addi $sp,$sp,4 jr $ra f2: sub $v0, $a0, $a1 jr $ra dopo la chiamata ad f2, f1 ripristina quanto salvato in precedenza (in questo esempio $ra) e poi riporta lo stack allo stato iniziale

Esempio Stesso esercizio con set del frame pointer: main: li $s0, 2 #$s0=a=2 li $s1, 25 #$s1=b=25 li $s2, 31 #$s2=c=31 li $s3, 4 #$s3=d=4 mov $a0, $s0 mov $a1, $s1 mov $a2, $s2 mov $a3, $s3 jal f1 mov $s5, $v0 f1: subu $sp, $sp, 8 sw $fp, 4($sp) sw $ra, 0($sp) addiu $fp, $sp, 4 add $a0, $a0, $a1 add $a1, $a2, $a3 jal f2 lw $fp, 4($sp) lw $ra, 0($sp) addi $sp,$sp,8 jr $ra f2: subu $sp, $sp, 4 sw $fp, 0($sp) sub $v0, $a0, $a1 lw $fp, 0($sp) addi $sp,$sp,8 jr $ra

Esempio : teorema di Pitagora Teorema Pitagora: c = sqrt(a^2 + b^2) c è l'ipotenusa, a e b i cateti Obiettivo: Scrivere programma che chiami una procedura per calcolare i lati c (ipotenuse) di una serie di triangoli rettangoli. Avremo due array asides[] e bsides[] e i risultati saranno salvati in un array csides[]. Il programma dovra' inoltre calcolare, per il set delle ipotenuse csides[], minimo, massimo, somma e media. Esempio di: - Utilizzo array - Utilizzo cicli - Chiamata a procedura che, a sua volta, chiama una terza procedura

Esempio : teorema di Pitagora # Data declarations.data asides:.word 19, 17, 15, 13, 11, 19, 17, 15, 13, 11.word 12, 14, 16, 18, 10 bsides:.word 34, 32, 31, 35, 34, 33, 32, 37, 38, 39.word 32, 30, 36, 38, 30 csides:.space 60 length:.word 15 min:.word 0 max:.word 0 sum:.word 0 ave:.word 0 (continua...)

Esempio : teorema di Pitagora # text / code section.text.globl main.ent main main: # la chiamata alla funzione csidesstats ha il seguente formato: # csidesstats(asides,bsides,csides,length,min,max,sum,ave) la $a0, asides # passaggio per indirizzo la $a1, bsides # la $a2, csides # lw $a3, length # valore length la $t0, min # indirizzo min la $t1, max # max la $t2, sum # sum la $t3, ave # ave (continua...)

Esempio : teorema di Pitagora # preparazione chiamata (caricamento dati sullo stack) subu $sp, $sp, 16 sw $t0, ($sp) # push indirizzi sw $t1, 4($sp) sw $t2, 8($sp) sw $t3, 12($sp) jal csidesstats # call function addu $sp, $sp, 16 # clear arguments # done li $v0, 10 syscall # exit.end main

Esempio : teorema di Pitagora # Funzione per il calcolo di csides[] (ipotenuse di un set di triangoli # rettangoli) # Usa la funzione isqrt() per trovare la radice quadrata intera di un # intero # Argomenti: ---------------------------------------------- # $a0 address of asides[] # $a1 address of bsides[] # $a2 address of csides[] # $a3 list length # ($fp) addr of min # 4($fp) addr of max # 8($fp) addr of sum # 12($fp) addr of ave # Ritorna (passando indirizzi): ----------------------- # csides[] # min # max # sum # ave

Esempio : teorema di Pitagora.globl csidesstats.ent csidesstats csidesstats: subu $sp, $sp, 20 sw $s0, 0($sp) sw $s1, 4($sp) sw $s2, 8($sp) sw $s3, 12($sp) sw $fp, 16($sp) sw $ra, 20($sp) addu $fp, $sp, 20 # preserve registers # set frame pointer (continua...)

Esempio : teorema di Pitagora # Loop to calculate csides[] # Note, must use $s<n> registers due to isqrt() call move $s0, $a0 # address of asides move $s1, $a1 # address of bsides move $s2, $a2 # address of csides li $s3, 0 # index = 0 csidesloop: lw $t0, ($s0) mul $t0, $t0, $t0 lw $t1, ($s1) mul $t1, $t1, $t1 add $a0, $t0, $t1 jal isqrt sw $v0, ($s2) addu $s0, $s0, 4 addu $s1, $s1, 4 addu $s2, $s2, 4 addu $s3, $s3, 1 # get asides[n] # asides[n]^2 # get bsides[n] # bsides[n]^2 # call isqrt # save to csides[n] # update asides addr # update bsides addr # update csides addr # index++ blt $s3, $a3, csidesloop # if indx<len, loop

Esempio : teorema di Pitagora # Loop to find minimum, maximum, and sum. move $s2, $a2 # start addr of csides li $t0, 0 # index = 0 lw $t1, ($s2) # min = csides[0] lw $t2, ($s2) # max = csides[0] li $t3, 0 # sum = 0 statsloop: lw $t4, ($s2) # get csides[n] bge $t4, $t1, notnewmin # if csides[n] >= item > skip move $t1, $t4 # set new min value notnewmin: ble $t4, $t2, notnewmax # if csides[n] <= item > skip move $t2, $t4 # set new max value notnewmax: add $t3, $t3, $t4 addu $s2, $s2, 4 addu $t0, $t0, 1 blt $t0, $a3, statsloop # sum += csides[n] # update csides addr # index++ # if index<len > loop

Esempio : teorema di Pitagora lw $t5, ($fp) # get address of min sw $t1, ($t5) # save min lw $t5, 4($fp) sw $t2, ($t5) lw $t5, 8($fp) sw $t3, ($t5) div $t0, $t3, $a3 # get address of max # save max # get address of sum # save sum # ave = sum / len lw $t5, 12($fp) # get address of ave sw $t0, ($t5) # save ave # Done, restore registers and return to calling routine. lw $s0, 0($sp) lw $s1, 4($sp) lw $s2, 8($sp) lw $s3, 12($sp) lw $fp, 16($sp) lw $ra, 20($sp) addu $sp, $sp, 20 jr $ra.end csidesstats

Esempio : teorema di Pitagora # Function to computer integer square root for # an integer value. # Uses a simplified version of Newtons method. # x = N # iterate 20 times: # x' = (x + N/x) / 2 # x = x' # # Arguments # $a0 N # Returns # $v0 integer square root of N (continua...)

Esempio : teorema di Pitagora.globl isqrt.ent isqrt isqrt: move $v0, $a0 # St0 = x = N li $t0, 0 # counter sqrloop: div $t1, $a0, $v0 # N/x add $v0, $t1, $v0 # x + N/x div $v0, $v0, 2 # (x + N/x)/2 add $t0, $t0, 1 blt $t0, 20, sqrloop jr $ra.end isqrt

Esercizio 7.1 Si implementino le seguenti procedure. 1.somma: input: due interi a e b output: a+b 2.prodotto_s input: due interi a e b output: a*b. la procedura prodotto_s NON utilizzi istruzioni di moltiplicazione (mult et simila), ma calcoli il prodotto effettuando chiamate multiple alla procedura somma. Esempio: il prodotto 3x2 è svolto come 3+3 oppure 2+2+2. Ricordiamo: i parametri in input vengono passati attraverso i registri $a0-$a3 (e lo stack). I valori in output vengono restituiti attraverso i registri $v0 e $v1.

Esercizio 7.2 Si implementi la procedura subseteq così definita: Input: due array di interi A1 e A2 Output: 1 se ogni elemento di A1 è presente in A2, 0 altrimenti La procedura subseteq dovrà a sua volta utilizzare un altra procedura belongs così definita Input: un array A e un intero i Output: 1 se i è contenuto in A, 0 altrimenti Si implementi infine il main che acquisisca i dati, chiami subseteq e raccolga i risultati

Esercizio 7.3 Si implementi la procedura max così definita: Input: un intero N e un array A di N interi Output: il valore massimo in A Si implementi la procedura min così definita: Input: un intero N e un array A di N interi Output: il valore minimo in A Si implementi la procedura maxmin così definita: Input: un intero N e una matrice di interi M di dimensione N x N Output: il massimo valore tra i minimi di riga in M Si implementi la procedura minmax così definita: Input: un intero N e una matrice di interi M di dimensione N x N Output: il minimo valore tra i massimi di riga in M Si implementi infine il main che acquisisca i dati, chiami maxmin e minmax e raccolga i risultati. Suggerimento: una matrice di N x N interi può essere rappresentata con un array di dimensione N, dove ogni elemento è il base address di un array di dimensione N