source: soft/giet_vm/sys/ctx_handler.c @ 200

Last change on this file since 200 was 199, checked in by alain, 12 years ago

Introducing the "idle" to improve the exit mechanism.

File size: 6.5 KB
Line 
1/////////////////////////////////////////////////////////////////////////////////////////
2// File     : ctx_handler.c
3// Date     : 01/04/2012
4// Authors  : alain greiner & joel porquet
5// Copyright (c) UPMC-LIP6
6/////////////////////////////////////////////////////////////////////////////////////////
7// The ctx_handler.h and ctx_handler.c files are part of the GIET-VM nano-kernel.
8// This code is used to support context switch when several tasks are executing
9// in time multiplexing on a single processor.
10// The tasks are statically allocated to a processor in the boot phase, and
11// there is one private scheduler per processor. Each sheduler occupies 4K bytes,
12// and contains up to 14 task contexts (task_id is from 0 to 13).
13// The task context [14] is reserved for the "idle" task that does nothing, and
14// is launched by the scheduler when there is no other runable task.
15/////////////////////////////////////////////////////////////////////////////////////////
16
17#include <giet_config.h>
18#include <drivers.h>
19#include <common.h>
20#include <ctx_handler.h>
21#include <mapping_info.h>
22#include <sys_handler.h>
23
24/////////////////////////////////////////////////////////////////////////////////////////
25// A task context is an array of 64 words = 256 bytes.
26// It contains copies of processor registers (when the task is preempted):
27// - GPR[i], generally stored in slot (i). $0, *26 & $27 are not saved.
28// - HI & LO registers
29// - CP0 registers: EPC, SR, CR, BVAR
30// - CP2 registers : PTPR
31// It contains some general informations associated to the task:
32// - TTY        : terminal global index
33// - FBDMA      : DMA channel global index
34// - NIC        : NIC channel global index
35// - TIMER  : Timer global index
36// - PTAB   : page table virtual base address
37// - LTID       : Task local index (in scheduler)
38// - VSID   : Virtual space index
39// - RUN        : Task state (0 => sleeping / 1 => runable )
40//
41// ctx[0]<- ***|ctx[8] <- $8 |ctx[16]<- $16|ctx[24]<- $24|ctx[32]<- EPC  |ctx[40]<- TTY
42// ctx[1]<- $1 |ctx[9] <- $9 |ctx[17]<- $17|ctx[25]<- $25|ctx[33]<- CR   |ctx[41]<- FBDMA
43// ctx[2]<- $2 |ctx[10]<- $10|ctx[18]<- $18|ctx[26]<- LO |ctx[34]<- SR   |ctx[42]<- NIC
44// ctx[3]<- $3 |ctx[11]<- $11|ctx[19]<- $19|ctx[27]<- HI |ctx[35]<- BVAR |ctx[43]<- TIMER
45// ctx[4]<- $4 |ctx[12]<- $12|ctx[20]<- $20|ctx[28]<- $28|ctx[36]<- ***  |ctx[44]<- PTAB
46// ctx[5]<- $5 |ctx[13]<- $13|ctx[21]<- $21|ctx[29]<- SP |ctx[37]<- ***  |ctx[45]<- LTID
47// ctx[6]<- $6 |ctx[14]<- $14|ctx[22]<- $22|ctx[30]<- $30|ctx[38]<- ***  |ctx[46]<- VSID
48// ctx[7]<- $7 |ctx[15]<- $15|ctx[23]<- $23|ctx[31]<- RA |ctx[39]<- PTPR |ctx[47]<- RUN
49//////////////////////////////////////////////////////////////////////////////////////////
50
51extern void _task_switch(unsigned int*, unsigned int*);
52
53/////////////////////////////////////////////////////////////////////////////////
54//      _ctx_switch()
55// This function performs a context switch between the running task
56// and  another task, using a round-robin sheduling policy between all
57// tasks allocated to a given processor (static allocation).
58// It selects the next runable task to resume execution.
59// If the only runable task is the current task, return without context switch.
60// If there is no runable task, the scheduler switch to the default "idle" task.
61//
62// Implementation notes:
63// - As we only have the scheduler physical address (in CP0_SCHED register),
64//   this function must use specific assess functions to access the scheduler.
65// - All the context switch procedure is executed with interrupts masked.
66// - The return address contained in $31 is saved in the current task context
67//   (in the ctx[31] slot), and the function actually returns to the address
68//   contained in the ctx[31] slot of the next task context.
69/////////////////////////////////////////////////////////////////////////////////
70void _ctx_switch()
71{
72    // get scheduler physical address
73    static_scheduler_t* psched = (static_scheduler_t*)_get_sched();
74
75    // get number of tasks allocated to scheduler
76    unsigned int        tasks = _get_tasks_number();
77
78    // get current task index
79    unsigned int        curr_task_id = _get_current_task_id();
80
81    // select the next task using a round-robin policy
82    unsigned int        next_task_id;
83    unsigned int        tid;
84    unsigned int        found = 0;
85
86    for ( tid = curr_task_id + 1 ; 
87          tid < curr_task_id + 1 + tasks ;
88          tid++ )
89    {
90        next_task_id = tid % tasks;
91
92        // test if the task is runable
93        if ( _get_context_slot( next_task_id, CTX_RUN_ID ) )   
94        {
95            found = 1;
96                break;
97        }
98    }
99
100    // launch "idle" task if no runable task
101    if ( found == 0 )
102    {
103        next_task_id = IDLE_TASK_INDEX;
104    }
105
106    // no switch if no change
107    if ( curr_task_id != next_task_id )
108    {
109        unsigned int*   curr_ctx_paddr = &(psched->context[curr_task_id][0]);
110        unsigned int*   next_ctx_paddr = &(psched->context[next_task_id][0]);
111
112        _set_current_task_id( next_task_id );
113        _task_switch( curr_ctx_paddr, next_ctx_paddr );
114
115#if GIET_DEBUG_SWITCH
116_get_lock( &_tty_put_lock );
117_puts( "\n[GIET DEBUG] Context switch for processor ");
118_putd( _procid() );
119_puts( " at cycle ");
120_putd( _proctime() );
121_puts("\n");
122_puts( " - tasks        = ");
123_putd( tasks );
124_puts("\n");
125_puts( " - curr_task_id = ");
126_putd( curr_task_id );
127_puts("\n");
128_puts( " - next_task_id = ");
129_putd( next_task_id );
130_puts("\n");
131_release_lock( &_tty_put_lock );
132#endif
133
134    }
135} //end _ctx_switch()
136
137/////////////////////////////////////////////////////////////////////////////////////
138// This function is executed as the"idle" task when no other task can be executed
139/////////////////////////////////////////////////////////////////////////////////////
140void _ctx_idle()
141{
142    unsigned int delay = 1000000;
143
144    while(1)
145    {
146        asm volatile("move  $3,   %0            \n"
147                     "loop:                                     \n"
148                     "addi      $3, $3, -1              \n"
149                     "bnez  $3, loop            \n"
150                     "nop                                       \n"
151                     :
152                     : "r"(delay)
153                     : "$3" ); 
154
155        _get_lock( &_tty_put_lock );
156        _puts( "\n[GIET WARNING] Processor ");
157        _putd( _procid() );
158        _puts( " still idle at cycle ");
159        _putd( _proctime() );
160        _puts("\n");
161        _release_lock( &_tty_put_lock );
162   
163    }
164} // end ctx_idle()
165
166/////////////////////////////////////////////////////////////////////////////////
167// The address of this functionis used to initialise the return address
168// in the "idle" task context.
169/////////////////////////////////////////////////////////////////////////////////
170void _ctx_eret()
171{
172    asm volatile("eret");
173}
174
175
Note: See TracBrowser for help on using the repository browser.