CS611
Spring 2003
Programming Assignment 6
Due Sunday May 4

Implement a simple threads package for the IAS machine. This package should support the threads making recursive function calls.

You should implement these two functions: thrCreate and thrYield.

The thrCreate function is passed two parameters. The first parameter is a function that should be executed by the newly created thread. The second parameter is a parameter to be passed to that function.

The thrCreate function returns 0 if it cannot create the thread. Otherwise it returns 1.

A FIFO list of active threads should be maintained. This list should be initialized upon the first call to a thread function and should initially contain the "main" thread, the thread of control created "automatically" when the process was created. When thrCreate is called, the newly created thread should be placed on the end of the list. Note: a newly created thread does not start executing immediately. Rather it is simply placed at the end of the list of active threads.

When thrYield is called, the currently executing thread should be moved to the end of the list of active threads and the thread that is now at the front of the list should become the thread that is now executing. If there is only one active thread, then that thread continues executing.

There is no status associated with a call to thrYield (i.e. it must succeed) so the primitive returns nothing.

When a thread returns from its "outermost" function, then the thread is terminated and it is removed from the list of active threads.

You should support at least five concurrently executing threads. Each created thread should be given a stack of 100 words.

The symbols thrCreate and thrYield should be publicized to the linker via the GLOBL directive. All other symbols in your code should be hidden from the linker.

You should use the following function calling conventions:

• There will be global variables called SP and FP. SP points to the top item on the stack. FP is the frame pointer. The stack grows from high memory down toward low memory.

• The caller will first push the arguments, if any, in reverse order onto the stack. Next it will push the return address. Then the caller will execute a "ubh" to the function entry point.

• The called function (the callee), upon entry, must push the FP on top of the stack. It then establishes a new FP to point at the saved FP. This means that the function's arguments can be accessed starting at the address resulting from adding contents(FP) + 2.

• Before returning, the callee will restore the FP by popping the saved FP from the top of stack. The callee will then pop the return address from the stack and store it in the UBL instruction located at the function entry point. The callee then returns by performing a UBL to the function entry point.

• Return values are returned in AC.

• The caller should remove the arguments from the stack after being returned to.

• AC and MQ are designated as "caller-saved". This means that, if the caller has important values in AC or MQ, the caller must save and restore these values. And, therefore, the callee can freely use AC and MQ.

Place your source code for thrCreate and thrYield, as well as any supporting code, into a file called "thr.asm".

Your program will first be graded for its general design. Your source code should start with a comment that documents your design. Be sure to discuss the following points:

• the list of active threads: how do you implement a linked list in IAS assembler? what is the contents of a list node?
• how do you allocate list nodes and stacks?
• exactly what thrCreate must do.
• exactly what thrYield must do.
• exactly what should happen when a thread returns from its "outermost" function.
• if not already discussed, describe where and why the amodl or amodh instructions are required.

Your program will be then be tested for correct functionality. The two functions, thrCreate and thrYield, will each be worth 20 points.

Good program structure and documentation is absolutely critical for assembly language programs. Therefore, you may lose points if your program is not properly structured or adequately documented.

Your assignment should be submitted for grading from a CIS Linux machine (e.g. turing.unh.edu). To turn in this assignment, type:
~cs611/bin/submit prog6 thr.asm

Submissions can be checked from a CIS Linux machine by typing:
~cs611/bin/scheck prog6

To receive full credit for the assignment, you must turn in your files prior to 8am on Monday May 5. Late submissions will be accepted at the penalty of 5 points per day up to one week late.

Remember: as always you are expected to do your own work on this assignment. Copying code from another student or from sites on the internet is explicitly forbidden!

Comments and questions should be directed to hatcher@unh.edu