CPSC 213, Winter 2016, Term 2 Final Exam Date: April 19, 2017; Instructor: Mike Feeley and Alan Wagner

Transcription

1 CPSC 213, Winter 2016, Term 2 Final Exam Date: April 19, 2017; Instructor: Mike Feeley and Alan Wagner This is a closed book exam. No notes or electronic calculators are permitted. You may remove the last page. Answer in the space provided. Show your work; use the backs of pages if needed. There are 15 questions on 16 pages, totaling 103 marks. You have 3 hours to complete the exam. STUDENT NUMBER: NAME: SIGNATURE: Q1 / 4 Q2 / 6 Q3 / 6 Q4 / 8 Q5 / 4 Q6 / 9 Q7 / 10 Q8 / 9 Q9 / 6 Q10 / 6 Q11 / 6 Q12 / 8 Q13 / 9 Q14 / 6 Q15 / 6 1 (4 marks) Variables and Memory. Consider the following code running on 32-bit, big-endian architecture. struct S { char a[4]; ; int i; struct S* s; char foo() { i = 0x ; s = (struct S*) &i; return s->a[1]; Does the procedure foo() compile and execute without error? If not, what is the error? If so, can you determine what value it returns? If so, what is that value?

2 2 (6 marks) Global Variables. Consider the following C declaration of global variables. Give the SM213 assembly code for each of the following C statements. Use labels such as a, b etc. for statically know values. Comments are not required. You can treat your answers as a sequence and thus use register values loaded in one subquestion in subsequent ones to avoid duplication. int a; int* b; int* c[10]; 2a b = &a; 2b a = b[a]; 2c a = *c[a]; 2

3 3 (6 marks) Instance and Local Variables. Give the SM213 assembly code for the following statements that access elements of global and local structs. Consider each statement as if it were the last line of foo() at the location indicated by the comment. Use labels such as a, b etc. for statically known values. Assume that r5 stores the value of the stack pointer. Comments are not required. You can treat your answers as a sequence and thus use register values loaded in one subquestion in subsequent ones to avoid duplication. struct S { int w; int x; struct S* y; struct T z; ; struct T { int w; int x; ; int i; struct S* a; void foo() { struct S* b; // QUESTION CODE IS HERE 3a i = a->y->x; 3b i = a->z.x; 3c i = b->x; 3

4 4 (8 marks) Reading Assembly Code. Consider the following SM213 assembly procedure defined as int foo(int n). The procedure used the call/return conventions described in class where register r5 is the stack pointer. Register r0 is used to store the return value of the function. foo: deca r5 # deca r5 # st r6, 4(r5) # ld 8(r5), r1 # bgt r1, L1 # ld $0, r2 # br L3 # L1: dec r1 # bgt r1, L2 # ld $1, r2 # br L3 # L2: ld 8(r5), r1 # dec r1 # deca r5 # st r1, 0(r5) # gpc $0x6, r6 # j foo # inca r5 # st r0, 0(r5) # ld 8(r5), r1 # dec r1 # dec r1 # deca r5 # st r1, 0(r5) # gpc $0x6, r6 # j foo # inca r5 # ld (r5), r2 # add r0, r2 # L3: mov r2,r0 # ld 4(r5), r6 # inca r5 # inca r5 # j (r6) # 4a Carefully comment every line of code above. 4

5 4b Convert the assembly into C. 4c The code implements a simple function. What is it? Give the simplest, plain English description you can. 5 (4 marks) Procedure Calls. Given these global declarations int x; int (*proc) (int); Give the SM213 assembly for the code below (just for this single statement, not for the procedure itself). Assume that the return value is in r0. Comments are not required. x = proc (1); 5

6 6 (9 marks) C Pointers and Functions Consider the following C code. void foo(int x, int *p) { A. printf("x = %d, *p = %d", x, *p); *p = x + 12; --x; p = 0; int main (void) { int a = 1; int b = 2; int *p = &a; int **q = &p; B. printf("**q = %d", **q); foo(*p, *q); C. printf("a = %d", a); if (!p) D. printf("p is 0"); else E. printf("*p is %d", *p); *q = &b; F. printf("*p = %d", *p); return 0; In the above code, what if anything is printed by the printf instruction at locations A to F when the program is executed? 6a A 6b B 6c C 6d D 6e E 6f F 6

7 7 (10 marks) Allocation in C. You are giving expert advice to a development team about what type of variable allocation strategy is ideal for various aspects of their system. Indicate which of the following five strategies best suits each of the scenarios listed below (a strategy can apply to more than one scenario and some strategies may not be best for any of them). Name the strategy using its letter (i.e., A-E) and justify your answer briefly. Strategies Scenarios A. Global variable storing the entire object in question. B. Local variable storing the entire object in question. C. Calling malloc and free in the same procedure. D. Calling malloc and free in different procedures. E. Calling malloc and using reference counting instead of calling free. 7a An object that is allocated when a procedure is called and deallocated when it returns, where the primary concern is to prevent memory leaks and to simplify the code for allocation and deallocation. 7b An object that is allocated when a procedure is called and deallocated when it returns, where the primary concern is to prevent stack-smash, buffer-overflow attacks. 7c A dynamically-allocated object whose lifetime can only be determined by understanding the implementation of multiple procedures in different modules of the program. 7d An object whose size is independent of program inputs and that exists for the entire execution of the program, where the primary concern is to minimize runtime costs (i.e., CPU time) for allocating and accessing the object. 7e An object whose size depends on program inputs and that exists for the entire execution of the program, where the primary concern is to efficiently handle a very wide range of input values. 7

8 8 (9 marks) C Memory Errors. There are four memory related errors in the program below. For each error, give the line number on which the error occurred, the type of error, and indicate how to fix it. 1 struct my_struct { 2 int nnums; 3 int *nums; 4 ; typedef struct my_struct *my_struct_t; 5 void foo(my_struct_t ptr) { 6 int i; 7 for (i = 0; i <= ptr->nnums; i++) { 8 printf("%d", ptr->nums[i]); 9 10 free(ptr); int main(void) 13 { 14 my_struct_t s = malloc(sizeof(s)); 15 s->nnums = 5; 16 s->nums = malloc(5 * sizeof(*s->nums)); 17 for (int i = 0; i < s->nnums; i++) { 18 s->nums[i] = i + 4; foo(s); 21 free(s); 22 return 0; 23 8a Error 1: line: type: fix: 8b Error 2: line: type: fix: 8

9 8c Error 3: line: type: fix: 8d Error 4: line: type: fix: 9 (6 marks) Reference Counting. The following code has a memory leak bug. Add calls to inc(o) and dec(o) to increment and decrement the reference count of object o and make any other small changes necessary so that the program is free of memory leaks and dangling pointers. Assume that rc_malloc calls malloc and initializes the object s reference count to zero. void foo (int i) { int* ip = rc_malloc (sizeof (int)); int c = 0; int* v[2]; *ip = i; bar (ip); void bar (int* ap) { if (v[c] == NULL *ap < *v[c]) { zot (*ip); v[c] = ap; c = (c + 1) % 2; void zot (int a) { if (v[c]!= NULL && a < *v[c]) *v[c] = a; c = (c + 1) % 2; 9

10 10 (6 marks) Using Function Pointers. Write a C procedure named apply that returns either the minimum or maximum value of a list of non-negative integers, as determined by one of its parameters, a function pointer. If the list is empty it should return -1. Assume the existence of procedures named min(a,b) and max(a,b) that compare two integers and returns the min or max integer. No other procedures are allowed and apply is not permitted to use an if statement. For example, the following statement should compute the maximum value in list a of length n. int m = apply (max, a, n); Write the procedure apply(): 11 (6 marks) IO Devices. For each of the following, (a) explain what it is and (b) state whether the CPU or IO controller determines when it occurs (i.e., initiates it). 11a Programmed IO (PIO): 11b DMA: 11c Interrupts: 10

11 12 (8 marks) Threads and Scheduling. Answer the following questions about threads. 12a Explain briefly (without giving any code) how threads can be used to simplify code that performs asynchronous operations such as communicating with an IO controller. 12b Explain briefly the difference between uthread_yield and uthread_block. 12c Is it possible for a thread to unblock itself? Explain your answer. 12d Consider a system in which there is at least one thread on the ready queue when a thread unblocks. What happens to the unblocked thread? Explain. 11

12 13 (9 marks) Synchronization Consider the following C code that uses mutexes and condition variables. The code is considered to be is correct if both procedures complete successfully when they are called from concurrent threads (i.e., one thread calls procx and the other calls procy). Indicate whether or not the code is correct. If it is correct, describe why. If it is not correct, carefully describe the problem; you must be specific. All variations share the following declarations. Note that initialization code is omitted for brevity; you should assume that all variables were initialized correctly. int flag = 0; uthread_mutex mx; uthread_cond condx, condy; 13a void procx() { for (int i=0; i<100; i++) { uthread_cond_signal (condx); uthread_cond_wait (condy); void procy() { for (int i=0; i<100; i++) { uthread_cond_signal (condy); uthread_cond_wait (condx); Is this code correct? Justify your answer. 13b void procx() { uthread_mutex_lock (mx); for (int i=0; i<100; i++) { uthread_cond_signal (condx); uthread_cond_wait (condy); uthread_mutex_unlock (mx); void procy() { uthread_mutex_lock (mx); for (int i=0; i<100; i++) { uthread_cond_signal (condy); uthread_cond_wait (condx); uthread_mutex_unlock (mx); Is this code correct? Justify your answer. 12

13 13c void procx() { uthread_mutex_lock (mx); for (int i=0; i<100; i++) { uthread_cond_signal (condx); if (i!=0 flag==0) { flag = 1; uthread_cond_wait (condy); uthread_mutex_unlock (mx); void procy() { uthread_mutex_lock (mx); for (int i=0; i<100; i++) { uthread_cond_signal (condy); if (i!=0 flag==0) { flag = 1; uthread_cond_wait (condx); uthread_mutex_unlock (mx); Is this code correct? Justify your answer. 13

14 14 (6 marks) Semaphores. Add semaphores to the code shown below to guarantee that the program always prints do...re...me. Add code in the blank areas, if necessary. You can only use the uthread_sem_t API: uthread_sem_create(int), uthread_sem_wait(uthread_sem_t), and uthread_sem_signal(uthread_sem_t). #include <stdio.h> void* doe(void* p) { printf("do..."); return 0; void* re(void* p) { printf("re..."); return 0; void* me(void* p) { printf("me"); return 0; int main (int argc, char** argv) { uthread_t at,bt,ct; uthread_init(3); at = uthread_create (doe,null); bt = uthread_create (re,null); ct = uthread_create (me,null); uthread_join(at,0); uthread_join(bt,0); uthread_join(ct,0); 14

15 15 (6 marks) Deadlock. Consider these three procedures that are allowed to run concurrently in different threads. void one() { uthread_mutex_lock (a); uthread_mutex_lock (b);... uthread_mutex_unlock (b); uthread_mutex_unlock (a); void two() { uthread_mutex_lock (b); uthread_mutex_lock (c);... uthread_mutex_unlock (c); uthread_mutex_unlock (b); void three() { uthread_mutex_lock (c); uthread_mutex_lock (a);... uthread_mutex_unlock (a); uthread_mutex_unlock (c); Can this program deadlock? Explain briefly. 15

16 These two tables describe the SM213 ISA. The first gives a template for instruction machine and assembly language and describes instruction semantics. It uses s and d to refer to source and destination register numbers and p and i to refer to compressed-offset and index values. Each character of the machine template corresponds to a 4-bit, hexit. Offsets in assembly use o while machine code stores this as p such that o is either 2 or 4 times p as indicated in the semantics column. The second table gives an example of each instruction. With the exception of pc-relative branches and shift, all immediate values stored in instructions are unsigned. Operation Machine Language Semantics / RTL Assembly load immediate 0d-- vvvvvvvv r[d] v ld $v,rd load base+offset 1psd r[d] m[(o = p 4) + r[s]] ld o(rs),rd load indexed 2sid r[d] m[r[s] + r[i] 4] ld (rs,ri,4),rd store base+offset 3spd m[(o = p 4) + r[d]] r[s] st rs,o(rd) store indexed 4sdi m[r[d] + r[i] 4] r[s] st rs,(rd,ri,4) halt F000 (stop execution) halt nop FF00 (do nothing) nop rr move 60sd r[d] r[s] mov rs, rd add 61sd r[d] r[d] + r[s] add rs, rd and 62sd r[d] r[d] & r[s] and rs, rd inc 63-d r[d] r[d] + 1 inc rd inc addr 64-d r[d] r[d] + 4 inca rd dec 65-d r[d] r[d] 1 dec rd dec addr 66-d r[d] r[d] 4 deca rd not 67-d r[d] r[d] not rd shift 7dss r[d] r[d] << s shl $s, rd (if s is negative) shr $-s, rd branch 8-pp pc (a = pc + p 2) br a branch if equal 9rpp if r[r] == 0 : pc (a = pc + p 2) beq rr, a branch if greater Arpp if r[r] > 0 : pc (a = pc + p 2) bgt rr, a jump B--- aaaaaaaa pc a j a get program counter 6Fpd r[d] pc + (o = 2 p) gpc $o, rd jump indirect Cdpp pc r[d] + (o = 2 p) j o(rd) jump double ind, b+off Ddpp pc m[(o = 4 p) + r[d]] j *o(rd) jump double ind, index Edi- pc m[4 r[i] + r[d]] j *(rd,ri,4) Operation Machine Language Example Assembly Language Example load immediate ld $0x1000,r1 load base+offset 1123 ld 4(r2),r3 load indexed 2123 ld (r1,r2,4),r3 store base+offset 3123 st r1,8(r3) store indexed 4123 st r1,(r2,r3,4) halt f000 halt nop ff00 nop rr move 6012 mov r1, r2 add 6112 add r1, r2 and 6212 and r1, r2 inc 6301 inc r1 inc addr 6401 inca r1 dec 6501 dec r1 dec addr 6601 deca r1 not 6701 not r1 shift 7102 shl $2, r1 71fe shr $2, r1 branch 1000: 8003 br 0x1008 branch if equal 1000: 9103 beq r1, 0x1008 branch if greater 1000: a103 bgt r1, 0x1008 jump b j 0x1000 get program counter 6f31 gpc $6, r1 jump indirect c104 j 8(r1) jump double ind, b+off d102 j *8(r1) jump double ind, index e120 j *(r1,r2,4) 16