Programming Fundamentals

Which of the following are true? I. A programming language which does not permit global variables of any kind and has no nesting of procedures/functions, but permits recursion can be implemented with static storage allocation II. Multi-level access link (or display) arrangement is needed to arrange activation records only if the programming language being implemented has nesting of procedures/functions III. Recursion in programming languages cannot be implemented with dynamic storage allocation IV. Nesting procedures/functions and recursion require a dynamic heap allocation scheme and cannot be implemented with a stack-based allocation scheme for activation records V. Programming languages which permit a function to return a function as its result cannot be implemented with a stack-based storage allocation scheme for activation records

The enter_CS() and leave_CS() functions to implement critical section of a process are realized using test-and-set instruction as follows:

void enter_CS(X)
{
    while(test-and-set(X));
}

void leave_CS(X)
{
    X = 0;
}

In the above solution, X is a memory location associated with the CS and is initialized to 0. Now consider the following statements: I. The above solution to CS problem is deadlock-free. II. The solution is starvation free. III. The processes enter CS in FIFO order. IV More than one process can enter CS at the same time. Which of the above statements is/are TRUE?

The following C function takes a simply-linked list as input argument. It modifies the list by moving the last element to the front of the list and returns the modified list. Some part of the code is left blank.

typedef struct node {
  int value;
  struct node * next;
}Node;

Node * move_to_front(Node * head) {
    Node * p, * q;
    if ((head = = NULL: || (head - > next = = NULL)) return head; q = NULL; p = head;
      while (p - > next != NULL) {
        q = P;
        p = p - > next;
      }
      return head;
    }

Choose the correct alternative to replace the blank line.

The program below uses six temporary variables a, b, c, d, e, f.

Assuming that all operations take their operands from registers, what is the minimum number of registers needed to execute this program without spilling?

Fetch_And_Add (X, i) is an atomic Read-Modify-Write instruction that reads the value of memory location X, increments it by the value i, and returns the old value of X. It is used in the pseudocode shown below to implement a busy-wait lock. L is an unsigned integer shared variable initialized to 0. The value of 0 corresponds to lock being available, while any non-zero value corresponds to the lock being not available. AcquireLock(L){ While (Fetch_And_Add(L,1)) L = 1; } Release Lock (L){ L = 0; } This implementation

Direction: The following code segment is executed on a processor which allows only register operands in its instructions. Each instruction can have almost two source operands and one destination operand. Assume that all variables are dead after this code segment. c = a + b; d = c * a; e = c + a; x = c * c; if (x > a) { y = a* a; } else { d = d * d; e = e * e; }

Suppose the instruction set architecture of the processor has only two registers. The only allowed compiler optimisation is code motion, which moves statements from one place to another while preserving correctness. What is the minimum number of spills to memory in the compiled code?