is1200 datorteknik

April 20, 2023 IS1200 Datorteknik, föreläsning 5 1

IS1200 Datorteknik

Föreläsning 5Maskinnära

programmeringmed C


Föreläsning 5 Innehåll, rubriker

Lagring av datatyper Minnesallokering, statisk / dynamisk Compile-time / Run-time .text, .data, .bss, .stack, .heap value, address, pointer, type cast vector, array , struct bit-operations malloc / free


F1 F2

F3

F4

F5

F7

F8

F9

F10

Ö2

Ö1

Ö3 LAB-1

Hemlab-1Ö4

Ö7 LAB-3

Hemlab-2Ö8

Hemlab-3Ö9

TentamenÖ10

Assemblerkod 4 stegs pipeline

Nios2time

C-kod

Nios2io

Nios2int

Cache-minnen

CPU-scheduling

IS1200 Datorteknikhttp://www.ict.kth.se/courses/IS1200

F6 Ö5 Ö6 LAB-2


LitteraturhänvisningarKursbokens avsnitt 3.2 och 3.7 Heltal och flyttal 4.5 och 4.6 Stack med mera Appendix C Ex-samling del 4 Hemlaboration 1(Vägen till C: Bilting/Skansholm, sidorna 135 m.fl.)


Datatyperheltalstyper

Heltalstyper används för att representera följande slag av data:

Heltal utan tecken(unsigned int)Heltal med tecken (signed int)Tecken i texter (t.ex. ASCII-kod)Logiska värden (False/True = 0/icke

0)Bitmönster (t.ex. 0x000F)


Datatyperheltalstyper

I C finns fyra storlekar av heltalstyper1. char (minst 8 bitar)2. short int (minst 16 bitar)3. int (minst 16 bitar)4. long int (minst 32 bitar)Var och en signed eller unsignedchar <= short <= int <= long#include <limits.h> /* aktuell implementation */


Operatorn sizeof()

Det finns en operator/funktion, sizeof(), som kan användas för att ta reda på storleken räknat i antal bytes, för en datatyp eller en variabel

int antal;...nrbytes = sizeof(something);sizeof() ”utförs” ”at compile time” ! (i förväg) dvs vid kompileringen, inte vid exekveringen


DatatyperUnsigned Integer

0000 1111 0101 0000 1111 0111 0111 0000binärkodhexadecimal kod0x 0F 50 F7 70tolkas som positivt heltal ”som vanligt”med viktad binär kod, 1-tal, 2-tal, 4-tal, ...i analogi med decimal viktad kod1-tal, 10-tal, 100-tal, ...


DatatyperSigned Integer

0000 1111 0101 0000 1111 0111 0111 0000binärkodhexadecimal kod0x 0F 50 F7 70negativa tal lagras oftast i2-komplement-representationMSB - most significant bit är teckenbit.Koden för ett negativt värde erhålls genom attinvertera varje bit och addera värdet 1


Binärkod för värdet minus ett

Koden för + 1 0000 0000 .... 0001

Bitvis invertering 1111 1111 .... 1110Addition av ett + 0000 0000 .... 0001

Och vi får kod för -1 1111 1111 .... 1111(Koden för -1 är alltid ”bara ettor” för alla ordlängder)


värdet av kod för negativt tal

Koden för negativt tal 1111 .... 1010 0101

Bitvis invertering 0000 .... 0101 1010Addition av ett + 0000 .... 0000 0001

Och vi får kod 0000 .... 0101 1011Som tolkas till värdet 1+2+8+16+64 =

91


Byte order, i minnetlittle or big endian

0xBB0xAA

0xDD0xCC

0xBB0xAA 0xDD0xCC 0xBB0xAA 0xDD0xCC

Little endian byte ordering Big endian byte ordering

Nios-2/Intel Motorola

Mot låga adresser

Mot höga adresser

”lill-ändan först” ”stor-ändan först”

Skrivning av 0xAABBCCDD till Minnet

0xCC0xDD

0xAA0xBB


Byte order, i minnetlittle or big endian

0x000x00

0x570x59

0x000x00 0x570x59 0x590x57 0x000x00

Little endian byte ordering Big endian byte ordering

Nios-2/Intel Motorola

Mot låga adresser

Mot höga adresser

”lill-ändan först” ”stor-ändan först”

Läsning av 0x00005957 från Minnet


DatatyperChar

En byte - 8 bitar - oktettexempel binärkod 0110 0001 = ascii-koden för lilla ”a”hexadecimal kod0x61 = ’a’ i Nios-2-assembler(Sid 95 i kursboken)


DatatyperFlyt-tal

1. float, t.ex. 32 bitar2. double, t.ex. 64 bitar3. long double, t.ex. 128 bitar

(implementationsberoende)


Decimalt Flyttal

-047,120 #decimalt fixtal-047,120 * 100 #decimalt flyttal-04,7120 * 101 #normaliserat flyttal

exponent

mantissatecken


Binärt Flyttal

-0101.110 #binärt fixtal-0101.110 * 20 #binärt flyttal-01.01110 * 22 #normaliserat flyttal

exponent

mantissatecken


Binärt Flyttalfloat (32 bitar)

-0101.110 #binärt tal-0101.110 * 20 #binärt flyttal-01.01110 * 22 #normaliserat flyttal

Exponent lagras i excess-127-kod

Tecken, 0 är +, 1 är -Mantissa lagras med enbart signifikand


Binärt Flyttaldouble (64 bitar)

-0101.110 #binärt tal-0101.110 * 20 #binärt flyttal-01.01110 * 22 #normaliserat flyttal

Exponent lagras i excess-1023-kod

Tecken, 0 är +, 1 är -Mantissa lagras med enbart signifikand


Floating Point NumberIEEE 754, 32 bitars float

11000001100010000000000000000000

värde = (-1)s * (1 + signifikand2 ) * 2 (exponent-127)

s exponent signifikand

FLOAT:

-17 (dec) = - 1 0001 (bin) = - 1.0001 * 24

1 1000 0011 000 1000 0000 0000 0000 00001100 0001 1000 1000 0000 0000 0000 00000x C1 88 00 00


Information, 32 bitar adress / värde

0x880xC1

0x000x00

0x880xC1 0x000x00

Little endian byte ordering

FLOAT:

-17 i float-format: 0x C1 88 00 00

-

+


Flyt-talstyperI C finns tre storlekar av heltalstyper1. float (troligen 32 bitar)2. double (troligen 64 bitar)3. long double (troligen 128 bitar)

#include <float.h> /* fil med aktuell information om */

FLT_DIG, DBL_DIG, LDBL_DIG, ”decimala siffror”FLT_MIN och FLT_MAX (och DBL och LDBL), min och maxnr = sizeof(double);


Floating Point NumberIEEE 754, 64 bitars double

1 10000000011 000100 ... 00000000000

(-1)s * (1 + signifikand2 ) * 2 (exponent-1023)

s exponent signifikand

DOUBLE:

-17 (dec) = - 1 0001 (bin) = - 1.0001 * 24

1 100 0000 0011 000 1000 0000 ... 00001100 0000 0011 0001 0000 0000 ... 00000x C0 31 00 00 00 00 00 00



0x000x00

0x000x00

0x310xC0 0x000x00


DOUBLE:

-17 i double-format: 0x C0 31 00 00 00 00 00 00

-

+

0x000x00 0x000x00

0x310xC0

0x000x00


Deklaration av variabel (-typ)Definition av variabel (-värde)

Typ-deklaration möjliggör typkontroll för kompilatorn Deklaration som leder till minnesallokering kallas för

definition Tilldelning av värde vid typ-deklaration leder till

definition dvs minnesallokering med värde i minnetint A; /* typdeklaration och minnesallokering */int B = 17; /* typdeklaration och minnesallokering

samt tilldelning av värde */ int B; /* bara typdeklaration av B, tillåtet !!! */int B = 4712; /* omdefinition, ej tillåten !!! */


Typdeklaration av variabler(exempel avser c-kod)

Exempel på typ-deklaration av variabelint a; /* integer a utan värde

(värdelös?) */int b=7; /* integer b med värde 7 */ char c = ’a’; /* char c med värde asciikod för

a

float fval = 47,11; /* flyttal med värde 47,11 */

double dval = 47,11; /* flyttal med värde 47,11 */



0x000x00

0x570x59

0x000x00 0x570x59


TIME:

TIME: -

+


Information, 32 bitar i minnet adress eller värde ?

#define elefant 4712int TIME = 0x5957; översätts till.equ elefant, 4712.data.align 2TIME: .word 0x5957 0x5957 är ett värde

som finns lagrat i minnet på en adress med värdet TIME

. . .movia r9, 0x5957 # r9:= värdet 0x5957movia r10, elefant # r10:= värdet elefant = 4712 movia r11, TIME # r11:= adressen (värdet) TIME

(kompilatorn vet)ldw r12, 0(r11) # r12 := värdet lagrat på adress TIME dvs

0x5957


värden, pekare, adresser(avser c-kod)

Användning av ”*” vid typ-deklaration av variabel

int a; /* integer a utan värde (värdelös?) */

int b=7; /* integer b med värde 7 */ int* apek; /* pekare till integer */int *bpek; /* pekare till integer */char* streng; /* pekare till byte */

(int* pek1, pek2 blir ej samma som int *pek1, *pek2)


Size of pointer i C-kod

int * ptr-i;char * ptr-c;double * ptr-d;

nr1 = sizeof (double);nr2 = sizeof (double *);

-

+

ptr-i

ptr-c

ptr-d


Size of pointer i C-kod

struct tiger{...}tiger * ptr-t

nr1 = sizeof (tiger);nr2 = sizeof (tiger *);

-

+

ptr-t


Incrementing pointer i C-kod

ptr = ptr + 1;

increment by (sizeof(*ptr))

-

+

ptr-i

ptr-c

ptr-d

ptr-+1

ptr-+1

ptr-+1

ptr

ptr

ptr


Incrementing pointer i C-kod

-

+

ptr-t

ptr-+1

ptr

ptr-+1

ptr


Värden, pekare, adresser (avser c-kod)

Användning av ”&” och ”*” vid tilldelningarAdressbildning och avreferering

apek = &a /* apek := adressen till a */b = *apek; /* b:=värdet på adress apek

*/bpek = apek; /* kopiera pekarvärde */a = b; /* kopiera heltalsvärde */Typkontroll görs vid kompilering


Typen void

Typen void är ingen vanlig typVoid kan användas för att ange att en

funktion saknar returvärde, t.ex. void puttime(int time)

Void används för att markera att en funktion inte har några parametrar, t.ex. int main(void)

En pekare till objekt av typen void får peka till ett dataobjekt av godtycklig typ


Void-pekare(avser C-kod)

int tala; /* tala är en integer */void* vp; /* pekare till ”vad som helst” */ En voidpekare får ej avrefereras *vp; /* avreferering ger warning */tala = *vp; /* tilldelning ger dessutom type error

*/

Använd type casttala = * ( (int*) vp ); /* korrekt */


Type castExplicita typomvandlingar

För att kunna avreferera en void-pekare måste man använda type cast

Exempel: dumbo = * (struct elephant*) vp;

/* Tänkbar bakgrund */struct elephant

{char[13] name;int weight;float area;};

struct elephant dumbo;

/* Kan man göranr = sizeof(dumbo);


vektor, textsträngchar [ ]En vektor av bytes

char header [12]; /* 12 bytes */med index 0 .. 11En strängEn textsträngchar text[] = ”Hello World!”; /* 13 bytes *//* nul-terminated text-string *//* text och &text[0] får samma värde men

har olika typ !? */


Lagring av textsträngChar [ ]

C-kod:char text[] = ”Hello World!”;

/* text = &text[0] men olika typ */

Assemblerkod:.datatext: .asciz ”Hello World!”

’l’’l’

’H’’a’

’W’’o’

’o’’ ’

’d’

’r’’l’

’!’

text:

text[4]

0123456789

101112

text[7]

0x00


Heltalsvektorint [ ]

C-kod: int vect[] = {1,10,0xA};/* vect = &vect[0], olika typ */

Assemblerkod:.data.align 2vect: .word 1, 10, 0xA#little endian byte ordering

0x000x00

0x010x00

0x000x00

0x0A

0x00

0x0A0x00

0x00

vect:

vect[1]

0123456789

10

vect[2]

0x00


Bit OperationsAssembly program (Nios-II)

Ettställ valda bitar med OR-operationORI r8, r9, 0x30

Nollställ valda bitar med AND-operation (maska fram utvalda bitar)

ANDI r8, r4, 0x0F Invertera valda bitar med XOR-operation

XORI r2, r4, 0b10000000 Invertera alla bitar med NOR-operation

NOR r10, r9, r0


Bit Operations C-program

Ettställ valda bitar med OR-operationtmp = tmp | 0x30 ;Nollställ valda bitar med AND-operation(maska fram utvalda bitar)tmp = status & 0x0F ;Invertera valda bitar med XOR-

operationtmp = val ^ 0b10000000;


Bit Operations Assembly program (Nios-II)

Skifta höger n steg (heltalsdivision med 2n)SRLI r2, r7, n # det finns även SRAI r2, r7, n Skifta vänster m steg (multiplikation med 2m)SLLI r9, r4, m # det finns ingen SLAI r9, r4, m

Implementationsberoende hantering av teckenbiten


Bit OperationsC-program

Skifta höger n steg (heltalsdivision med 2n)tmp = tmp >> n ;Skifta vänster m steg (multiplikation med

2m)tmp = tmp << m ;

Implementationsberoendehantering av teckenbiten


Bitwise operationsLogical operations

Det finns en operator & i C (bitwise AND)Det finns en operator | i C (bitwise OR)Det finns en operator ^ i C (bitwise XOR)Det finns en operator && i C (logical AND)Det finns en operator || i C (logical OR)

Det finns EJ operator ^^ i C (logical XOR)


EditeringExempel på C-kod, lab1-ide’

#define START_TIME 0x5957 /* makrodefinition */#define TRUE 1 /* TRUE = 1 */ int current_time = START_TIME; /* global initierad variabel */

extern void puttime (int* time); /* subroutine, function, procedure, method */extern void tick (int* time);extern void delay (int millisek);extern int hexasc (int hexval);

int main () { /* huvudprogram, main */while (TRUE){ puttime (&current_time); tick (&current_time); delay (1000);}}


funktionen tick i C-kod

void tick (int* inpar) /* se lab nios2time */ {

register int time;time = *inpar; /* ~LDW dreg, 0(ireg) */time = time + 1;if ((time & 0x000F) == 0x000A)time = time - 0x000A + 0x0010;… /* mer kod ska stå här */*inpar = time;

}

Tips till Kompilator

C-kodenregister int time;

Medför att kompilatorn placerar time i ett register (om det finns något ledigt kvar)

Detta kan leda till färre minnesreferenser och därmed (eventuellt) snabbare exekvering, pga mindre risk för D-cache-missar



memcpy i C-kod(block data transfer)

void memcpy (char* dst, char* src, int num) {

int tmp;register int i; for (i=0; i<num, i=i+1)tmp = *src; *dst = tmp;dst = dst + 1;src = src + 1;

}


memcpy i C-kod(block data transfer)

void memcpy (char* dst, char* src, int num) {

register int i;for (i=0; i<num, i=i+1)*dst++ = *src++;

}


memcpy i Nios-2-kod

memcpy: mov r8, r5 # srcpekaremov r9, r4 # destpekaremov r10, r6 # counter

loop: ble r10, r0, out # kolla om klartfast: ldb r12, 0(r8) # läs 1 byte

addi r8, r8, 1 # öka src-pekare stb r12, 0(r9) # skriv 1 byte

addi r9, r9, 1 # öka dst-pekare subi r10, r10, 1 # minska counterbr loop # alt: bgt r10, r0,

fastout: ret

strcpy biblioteksrutin i C

char *strcpy(char *destination, const char *source); char *strcpy(char *dest, const char *src) {

unsigned i; for (i=0; src[i] != '\0'; ++i) dest[i] = src[i]; dest[i] = '\0'; return dest;

}


strcpy biblioteksrutin i C

char *strcpy(char *destination, const char *source); char *strcpy(char *dest, const char *src){ char * save = dest;

while(*dest++ = *src++) /*tomt*/; /* tilldelning och test */ return save;

}


strncpy biblioteksrutin i C

char *strncpy(char *s1, const char *s2, size_t n);

DESCRIPTION

The strncpy() function copies not more than n bytes (bytes that follow a null byte are not copied) from the array pointed to by s2 to the array pointed to by s1. If copying takes place between objects that overlap, the behaviour is undefined. If the array pointed to by s2 is a string that is shorter than n bytes, null bytes are appended to the copy in the array pointed to by s1, until n bytes in all are written.

RETURN VALUE

The strncpy() function returns s1; no return value is reserved to indicate an error.



Matriserlagring i C-kod

#define size 16int A[size][size];int B[size][size];

matriser lagras radvis med hela rad 0 först, sedan rad 1 ...

A[0][1]...

A[i][j]...

A[0][0]

A[15][14]

A[15][15]

. . .

. . .


Matriskopiering i C-kod

#define size 16int A[size][size];int B[size][size];…void matcpy (int* dst, int* src) {

int i, j;for (i=0; i<size, i=i+1) /* radindex */ for (j=0; j<size, j=j+1) /* kolumnindex */ dst[i][j] = src [i][j];

}


matcpy i C-kod

#define size 16int A[size][size];int B[size][size];…void matcpy (int* dst, int* src) {

int i, j;for (j=0; j<size, j=j+1) /* kolumnindex */for (i=0; i<size, i=i+1) /* radindex */ dst[i][j] = src [i][j];

}/* blir det skillnad i prestanda om man byter

”ordning” */


matcpy i C-kod#define size 16int A[size][size];int B[size][size];…adress till A[i][j] bliradress till A[0][0] + size * 4 * i + 4 * jAdressberäkning görs ofta med skift istf multiplikationOm r4 pekar på A[0][0] ochr5 = i och r6 = j får vi i detta falladress till A[i][j] = r4 + r5<<6 + r6 <<2

Adresspekare till char ökas med 1 när index ökas med 1Adresspekare till int ökas med 4 när index ökas med 1Adresspekare till double ökas med 8 när index ökas med 1


Subrutiner och stack

Gränssnitt mot funktion/subrutinplacering av parametrar till rutinenplacering av lokala variablerplacering av returvärden


Variabler i minnet (register)Viktiga aspekter att ta med

Allokering av minne vid kompileringat compile-time

Allokering av minne vid exekveringat run-time

global / lokal variabel code-area, data-area, heap-area, stack-

area push och pop för stacken malloc() och free() för heapen


Statisk allokering av minneat compile time

Vid kompilering allokeras minne förProgramkoden - code eller textGlobala data

initialized (.data)uninitialized (.bss) (Block Started by Symbol)

Heap-areaStack-area


Dynamisk allokering av minneat execution/run -time

Vid exekvering allokeras minne från stacken och används t. ex. för

Parametrar vid funktionsanropReturadress vid funktionsanropLokala variabler i anropad funktionSkydd av register vid registerbrist


Dynamisk allokering av minneat execution/run time

Vid exekvering allokeras minne från heapen och används t.ex. för

Dynamiska data-strukturer


Kartbild av minnet(UNIX / Linux?)

adress 0

adress 2n -1

7 0

.data

.text

heap

stack

Adressrymdn=32 ger 4 Gbyte

(fetch-execute)

(malloc-free)

(push-pop)

(load-store)

SP - k+k

+

-

PC +n

.bss


Kartbild av minnet(Windows XP?)

adress 0

adress 2n -1

7 0

data

code

heap

PC +n

stackAdressrymdn=32 ger 4 Gbyte

(fetch-execute)

(malloc-free)

(push-pop)

(load-store)

SP - k+k

+

-


malloc() och free()dynamisk allokering från heap

/* Tänkbar bakgrund */struct elephant{

char[13] name; /* 16 bytes ? ! */int weight; /* 4 bytes */double area; /* 8 bytes */

};struct elephant dumbo;


malloc() och free()dynamisk allokering från heap

void * mp...mp = malloc (sizeof (struct elephant)); /* 28 bytes

*/...* (elephant*) vp = dumbo;...free (mp); /* mp SKA ha samma värde som från

malloc */


Föreläsning 5 Innehåll, rubriker

Lagring av datatyper Minnesallokering, statisk / dynamisk Compile-time / Run-time .text, .data, .bss, .stack, .heap value, address, pointer, type cast vector, array , struct bit-operations malloc / free


FödesschemaNågra exempel

Cond ?

code-a

False True


Villkorligt hopp

IF condition THEN GOTO label

Cond ?

code-a code-b

False

True

Label:

L1: Bcc Label

code-a

…

Label: code-b

…

L1:


Villkorliga program

Cond ?

Body1

Body2

True False Bcond BODY1

BRA BODY2

BODY1: …

…

BRA OUT

BODY2: …

…

OUT: …

IF Condition THEN body1 ELSE body2


Villkorliga program

NotCond

Body1

Body2

False True BNOcond BODY2

BODY1: …

…

BRA OUT

BODY2: …

…

OUT: …

IF Not Condition THEN body2 ELSE body1


for-loop transformeras till while-loop

loop: for (start; cond; update) body;

next:

… #start

BRA test

LOOP: … #body… #update

TEST: Bcond LOOP

NEXT: …

start; loop: while (cond) {body;update}next:

… #start

LOOP: Bcond BODYBRA NEXT

BODY: … #body… #updateBRA LOOP

NEXT: …


Cond ?

body

False

True

Loop:

start

update

Cond ?

body

start

False

True

Test

Next

update

Next

for-loop transformeras till while-loop

Loop:

Test


while-loop transformeras till if notcond

start; loop: while (cond) {body;update}next:

… #start

LOOP: Bcond BODYBRA NEXT


NEXT: …

start; loop: if (not cond) goto next

body;update;goto loopnext:

… #start

LOOP: BnocondNEXT


NEXT: …


Cond ?

body

start

False

True

Test

Next

update

while-loop transformeras till if not cond

Not Cond ?

body

start

True

False

Test

Next

update

Loop: Loop:

is1200 datorteknik

Documents

minnetis1200 datorteknik

ordlngderis1200 datorteknik

exekveringenis1200 datorteknik

0x000fis1200 datorteknik

91is1200 datorteknik

vrdet 1is1200 datorteknik

is1200 datorteknikfrelsning

negativt tal koden