Transcript Assembly Language

Assembly Language
Co-Routines
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
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.
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:
1. Several processes or threads take turns executing with the task switch
occurring independently of the executing code.
2. The Operating System takes responsibility for interrupting one task
and transferring control to other task.
II. Cooperative
1. Blocks of code explicitly pass control between one another.
2. The program manages the control flow usually using co-routines
Routines
Entry
Return
Return
Routine B
Return
Entry
Routine A
Return
Routine B
Entry
Routine A
Entry
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
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
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.
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
1. The limitations of stack-based subroutine implementation.
2. The standard call mechanism
3. Coroutines needs an initialization process, which is different from the
typical resume.
When a program begins execution
1. The main coroutine takes control and uses the stack associated with
the entire program.
2. Each process have its own stack, which size depends on its coroutine
Implementation
For each coroutines we define a structure that stores
1. Pointer to a code
2. Pointer to a stack
3. Content of used flags and registers
I.
II.
We define a global array that stores that information of all the coroutines in the application.
Initialize all the co-rountines
Co-routine initialization
Co-routine initialization
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
1. Global variables
2. Registers
3. Pass the address of a block of parameters vi a register
Resume
• Resume
– Save the state of the current co-routine
– Resume the state of the next co-routine (its reference in EBX)
Resume