CS255 Syllabus

Recursion in SPARC

The SAVE instruction and Register Windows in SPARC
- Recall that the save instruction will "create" (i.e., reserve, use, claim,...) a new set of input (i.e., parameters) and local (i.e., local variables) registers.
- The SPARC CPU has 8 sets of window registers:
- Recall that we must always use the save instruction as follows:
```
     save %sp, -96, %sp
  
```
  and that this instruction will decrement the stack pointer by 96 and thus reserve 96 bytes on the system stack.
- This 96 bytes of reserved space is used by the Sun's Operating System to save (24) window registers:
What happens when the register windows "overflows"....
- When the running program executes many save instructions, eventually, the number of unused register windows in the SPARC CPU will be exhausted
- This event can be detected by the use of the WIM (Window Invalid Mask) register inside the SPARC CPU. I will not go into the details how that it is done, just that it can be done.
  When the SPARC CPU executes a save instruction and there is no more unused register windows available, the operating system will intervene.
  The operating system is a program that is running inside the computer which manages the resources of the computer system - e.g., Windows 98, 2000, ME, XP,... in the Sun, the operating system is called "Solaris")
- The following is a situation where a save instruction will cause a register window overflow, i.e., there is no more unused register windows available:
- When SPARC executes anonther save instruction, the next window will occupy some registers that are already in use (the registers rap around)
  When SPARC detects this, it will use the stack pointer in the register window (shaded yellow in the figure) to find the stack segment that was reserved for saving the registers (see the red arrow)
- The result is freeing one register window (at the cost of writing 96 bytes to memory !!!)
- The result is that:
  Although the SPARC CPU has only 8 sets of register windows, the Operating System can "recycle" the register windows and make it appear as it the user has a VERY LARGE set of windows
  In fact, SPARC can use the entire computer memory for this "recycling" trick and you have virtually an unlimited number of register windows....
Recursion in SPARC
- Recall that the main difficulty in implementing recursive functions is the NEED to "create" (i.e., reserve memeory space for) NEW parameter and local variables.
  Recall that when we try to write recursion in M68000, we cannot pass parameters in registers because M68000 has only ONE set of registers and it was not possible for us to "create new register"
- We will only look at function where
  - all parameters can be passed through the output registers in SPARC....
  - the number of local variables used in the function is can be contained in the local registers in SPARC....
- In this case (which is quite common), the problem of creating new parameter and local variables can be done through the save instruction....
  In fact, we have "delegated" the problem of creating new variables on the stack to the Operating System - as you have seen above, SPARC's operating system will take care of saving the window registers away for us....
- As a result, writing recursive functions in SPARC assembler program is no different than writing an ordinary function.

Example 1: Factorial

The program in high level language:

  main:
	int n, r;

	Write("n = ");	// Prompt user to enter n
	n = ReadInt();	// Read in number

	r = fac(n);
	Write("fac = ");
	WriteInt(r);

  int fac(int n)
  {
     int sol;

     if ( n == 0 )
	return(1);
     else
     {
        sol = fac(n-1);
	return (n * sol);
     }
  }

Here is the SPARC assembler program: click here

Example 2: Fibonnaci

The program in high level language:

  main:
	int n, r;

	Write("n = ");	// Prompt user to enter n
	n = ReadInt();	// Read in number

	r = fib(n);
	Write("fib = ");
	WriteInt(r);

  int fib(int n)
  {
     int h1, h2;

     if ( n == 0 )
	return(1);
     esle if ( n == 1 )
	return(1);
     else
     {
        h1 = fib(n-1);
        h2 = fib(n-2);
	return (h1 + h2);
     }
  }

Here is the SPARC assembler program: click here

Example 3: Tower of Hanoi

The program in high level language:

  main:
	int n;

	Write("Number of disks = ");	// Prompt user to enter n
	n = ReadInt();	                // Read in number

	hanoi(n, 1, 3);   // from peg 1 to peg 3


  void hanoi(int ndisks, int fromPeg, int toPeg)
  { 
     int helpPeg;
     if (ndisks == 1) then
        WriteLn "move disk from peg " + fromPeg + " to " + " + toPeg
     else
     {  
        helpPeg := 6 - fromPeg - toPeg;
        hanoi(ndisks-1, fromPeg, helpPeg);
        WriteLn "move disk from peg " + fromPeg + " to " + " + toPeg
        hanoi(ndisks-1, helpPeg, toPeg);
     }
  }

Here is the SPARC assembler program: click here

Example 4: Recursive Insert at Tail of a list

The program in high level language:

  class List
  {
     int value;
     List next;
  }

  main:
	int n;
	List head;   // Start of list
	List ptr;    // Points to new list element

 	head = NULL;
        while(TRUE)
        {
	   Write("Enter number:  ");	// Prompt user to enter n
	   n = ReadInt();	        // Read in number

           ptr = malloc(8);
	   ptr.value = n;

	   head = Insert(head, ptr);
	   PrintList(head);
	}

  List Insert(List head, List elem)
  {
     List help;

     if head == null)
       { // Base case
         elem.next = null;
         return(elem);          // New head
       }
      else
       { // Recursion

         help = Insert(head.next, elem);  
                            // Insert elem in shorter list

         head.next = help;  // Link return list AFTER 
                            // the first elem in orig. list
         return(head);      // head is unchanged
       }
   }

Here is the SPARC assembler program: click here