1. Assembly Language Co-Routines

2. Process A process is a program in execution.
Multiprogramming/Multitasking  Operating systems switches from one process to another.
Each process has its own
Instruction pointer
Stack pointer
Register values
Pointers to
Code Segment
Data Segment
Stack Segment
Three Processes A, B, and C A. B. C.
Create

3. Threads
A process has
Resources: address space, open files, accounting information, etc. A thread of control: instruction pointer, register contents, stack. Multithreading scheme permits multiple threads of control to execute within one process. Threads in the same process share a lot of data, such as code and data segments. Switching between threads with the same process is much less expensive than switching between thread in separate processes as they cause threads in the same process share so much state, between separate processes.

4. Control of the CPU
Multitasking operating systems swap control of the CPU between several code section back and forth while executing.
In two approaches:
I. Preemptive:
Several processes or threads take turns executing with the task switch occurring independently of the executing code.
The Operating System takes responsibility for interrupting one task and transferring control to other task.
II. Cooperative
Blocks of code explicitly pass control between one another.
The program manages the control flow usually using co-routines

5. Routines Routine B Routine A Routine B Routine A Resume B call B
Entry
Entry
Entry
Entry
Resume B
call B
Resume A
Routine B
Routine A
Routine B
Routine A
Resume B
Resume A
return
Return
Return
Return
Return

6. Co-Routines Initial resume (call) of X: create activation for X
resume execution at entry point
resume Y : suspend current activation
Resume which activation of Y?
resume ?  return
anonymous resume
“terminated” activation
Call  create & resume

7. A Use Case
Coroutines are quite useful for games where the “players” take turns, following different strategies. The first player executes some code to make its first move, then resumes the second player and allows it to make a move. After the second player makes its move, it resumes the first process and gives the first player its second move, picking up immediately after its resume. This transfer of control bounces back and forth until one player wins. Coroutines are also useful to implement state machine

8. Implementation
A resume is effectively a call and a return instruction all rolled into one operation.
From the point of view of the routine executing the resume, the resume operation is equivalent to a procedure call
From the point of view of the processing being called (callee), the resume operation is equivalent to a return operation.
When the second routine resumes the first, control resumes not at the be
ginning of the first process, but immediately after the last resume operation from that coroutine.

9. Implementation
Coroutines originated as an assembly-language technique, but are supported in some high-level languages. Most popular programming languages do not have direct support for coroutines within the language or their standard libraries. This due to
The limitations of stack-based subroutine implementation.
The standard call mechanism
Coroutines needs an initialization process, which is different from the typical resume.
When a program begins execution
The main coroutine takes control and uses the stack associated with the entire program.
Each process have its own stack, which size depends on its coroutine

10. Implementation For each coroutines we define a structure that stores
Pointer to a code
Pointer to a stack
Content of used flags and registers
We define a global array that stores that information of all the co-routines in the application.
Initialize all the co-rountines

11. Co-routine initialization

12. Co-routine initialization

13. Passing Parameters Passing parameters to a coroutine is difficult
Typically the stack is used to pass parameters and coroutines all use different stacks.
The parameters one coroutine passes to another won’t be on the correct stack when the second coroutine continues execution.
Typical coroutine has several entry points
It is often necessary to communicate information between coroutines and one could do that by
Global variables
Registers
Pass the address of a block of parameters vi a register

14. Resume Resume Save the state of the current co-routine
Resume the state of the next co-routine (its reference in EBX)

15. Resume