source: trunk/kernel/kern/scheduler.c @ 433

Last change on this file since 433 was 433, checked in by alain, 4 years ago

blip

File size: 13.2 KB
Line 
1/*
2 * scheduler.c - Core scheduler implementation.
3 *
4 * Author    Alain Greiner (2016)
5 *
6 * Copyright (c)  UPMC Sorbonne Universites
7 *
8 * This file is part of ALMOS-MKH.
9 *
10 * ALMOS-MKH. is free software; you can redistribute it and/or modify it
11 * under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; version 2.0 of the License.
13 *
14 * ALMOS-MKH. is distributed in the hope that it will be useful, but
15 * WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17 * General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with ALMOS-MKH.; if not, write to the Free Software Foundation,
21 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
22 */
23
24#include <kernel_config.h>
25#include <hal_types.h>
26#include <hal_switch.h>
27#include <hal_irqmask.h>
28#include <hal_context.h>
29#include <printk.h>
30#include <list.h>
31#include <core.h>
32#include <thread.h>
33#include <chdev.h>
34#include <scheduler.h>
35
36///////////////////////////////////////////////////////////////////////////////////////////
37// Extern global variables
38///////////////////////////////////////////////////////////////////////////////////////////
39
40extern chdev_directory_t    chdev_dir;            // allocated in kernel_init.c file
41extern uint32_t             switch_save_sr[];     // allocated in kernel_init.c file
42
43////////////////////////////////
44void sched_init( core_t * core )
45{
46    scheduler_t * sched = &core->scheduler;
47
48    sched->u_threads_nr   = 0;
49    sched->k_threads_nr   = 0;
50
51    sched->current        = CURRENT_THREAD;
52    sched->idle           = NULL;             // initialized in kernel_init()
53    sched->u_last         = NULL;             // initialized in sched_register_thread()
54    sched->k_last         = NULL;             // initialized in sched_register_thread()
55
56    // initialise threads lists
57    list_root_init( &sched->u_root );
58    list_root_init( &sched->k_root );
59
60    sched->req_ack_pending = false;           // no pending request
61
62}  // end sched_init()
63
64////////////////////////////////////////////
65void sched_register_thread( core_t   * core,
66                            thread_t * thread )
67{
68    scheduler_t * sched = &core->scheduler;
69    thread_type_t type  = thread->type;
70
71    // take lock protecting sheduler lists
72    spinlock_lock( &sched->lock );
73
74    if( type == THREAD_USER )
75    {
76        list_add_last( &sched->u_root , &thread->sched_list );
77        sched->u_threads_nr++;
78        if( sched->u_last == NULL ) sched->u_last = &thread->sched_list;
79    }
80    else // kernel thread
81    {
82        list_add_last( &sched->k_root , &thread->sched_list );
83        sched->k_threads_nr++;
84        if( sched->k_last == NULL ) sched->k_last = &thread->sched_list; 
85    }
86
87    // release lock
88    hal_fence();
89    spinlock_unlock( &sched->lock );
90
91}  // end sched_register_thread()
92
93//////////////////////////////////////////////
94thread_t * sched_select( scheduler_t * sched )
95{
96    thread_t     * thread;
97    list_entry_t * current;
98    list_entry_t * last;
99
100    // take lock protecting sheduler lists
101    spinlock_lock( &sched->lock );
102
103    // first loop : scan the kernel threads list if not empty
104    if( list_is_empty( &sched->k_root ) == false )
105    {
106        last    = sched->k_last;
107        current = sched->k_last;
108        do
109        {
110            // get next entry in kernel list
111            current = list_next( &sched->k_root , current );
112
113            // skip the root that does not contain a thread
114            if( current == NULL ) current = sched->k_root.next;
115
116            // get thread pointer for this entry
117            thread = LIST_ELEMENT( current , thread_t , sched_list );
118
119            // analyse kernel thread type
120            switch( thread->type )
121            {
122                case THREAD_IDLE: // skip IDLE thread
123                break;
124
125                case THREAD_RPC:  // RPC thread if non blocked and FIFO non-empty
126                if( (thread->blocked == 0) && 
127                    (local_fifo_is_empty( &LOCAL_CLUSTER->rpc_fifo ) == 0) )
128                {
129                    spinlock_unlock( &sched->lock );
130                    return thread;
131                }
132                break;
133
134                default:          // DEV thread if non blocked and waiting queue non empty
135                if( (thread->blocked == 0) &&
136                    (xlist_is_empty( XPTR( local_cxy , &thread->chdev->wait_root)) == 0) ) 
137                {
138                    spinlock_unlock( &sched->lock );
139                    return thread;
140                }
141                break;
142            }  // end switch type
143        }
144        while( current != last );
145    }
146
147    // second loop : scan the user threads list if not empty
148    if( list_is_empty( &sched->u_root ) == false )
149    {
150        last    = sched->u_last;
151        current = sched->u_last;
152        do
153        {
154            // get next entry in user list
155            current = list_next( &sched->u_root , current );
156
157            // skip the root that does not contain a thread
158            if( current == NULL ) current = sched->u_root.next;
159
160            // get thread pointer for this entry
161            thread = LIST_ELEMENT( current , thread_t , sched_list );
162
163            // return thread if runnable
164            if( thread->blocked == 0 )
165            {
166                spinlock_unlock( &sched->lock );
167                return thread;
168            }
169        }
170        while( current != last );
171    }
172
173    // third : return idle thread if no runnable thread
174    spinlock_unlock( &sched->lock );
175    return sched->idle;
176
177}  // end sched_select()
178
179///////////////////////////////////////////
180void sched_handle_signals( core_t * core )
181{
182    list_entry_t * iter;
183    thread_t     * thread;
184    process_t    * process;
185
186    scheduler_t  * sched = &core->scheduler;
187
188    // take lock protecting threads lists
189    spinlock_lock( &sched->lock );
190
191    // scan all user threads
192    LIST_FOREACH( &sched->u_root , iter )
193    {
194        thread = LIST_ELEMENT( iter , thread_t , sched_list );
195
196        // handle REQ_ACK
197        if( thread->flags & THREAD_FLAG_REQ_ACK )
198        {
199            // check thread blocked
200            assert( (thread->blocked & THREAD_BLOCKED_GLOBAL) , 
201            __FUNCTION__ , "thread not blocked" );
202 
203            // decrement response counter
204            hal_atomic_add( thread->ack_rsp_count , -1 );
205
206            // reset REQ_ACK in thread descriptor
207            thread_reset_req_ack( thread );
208        }
209
210        // handle REQ_DELETE
211        if( thread->flags & THREAD_FLAG_REQ_DELETE )
212        {
213            // get thread process descriptor
214            process = thread->process;
215
216                // release FPU if required
217                if( thread->core->fpu_owner == thread )  thread->core->fpu_owner = NULL;
218
219            // detach thread from parent if attached
220            if( (thread->flags & THREAD_FLAG_DETACHED) == 0 ) 
221            thread_child_parent_unlink( thread->parent , XPTR( local_cxy , thread ) );
222
223            // remove thread from scheduler (scheduler lock already taken)
224            uint32_t threads_nr = sched->u_threads_nr;
225            assert( (threads_nr != 0) , __FUNCTION__ , "u_threads_nr cannot be 0\n" );
226            sched->u_threads_nr = threads_nr - 1;
227            list_unlink( &thread->sched_list );
228            if( threads_nr == 1 ) sched->u_last = NULL;
229
230            // delete thread
231            thread_destroy( thread );
232
233#if CONFIG_DEBUG_SCHED_HANDLE_SIGNALS
234uint32_t cycle = (uint32_t)hal_get_cycles();
235if( CONFIG_DEBUG_SCHED_HANDLE_SIGNALS < cycle )
236printk("\n[DBG] %s : thread %x deleted thread %x / cycle %d\n",
237__FUNCTION__ , CURRENT_THREAD , thread , cycle );
238#endif
239            // destroy process descriptor if no more threads
240            if( process->th_nr == 0 ) 
241            {
242                // delete process   
243                process_destroy( process );
244
245#if CONFIG_DEBUG_SCHED_HANDLE_SIGNALS
246cycle = (uint32_t)hal_get_cycles();
247if( CONFIG_DEBUG_SCHED_HANDLE_SIGNALS < cycle )
248printk("\n[DBG] %s : thread %x deleted process %x / cycle %d\n",
249__FUNCTION__ , CURRENT_THREAD , process , cycle );
250#endif
251
252            }
253        }
254    }
255
256    // release lock
257    hal_fence();
258    spinlock_unlock( &sched->lock );
259
260} // end sched_handle_signals()
261
262////////////////////////////////
263void sched_yield( char * cause )
264{
265    thread_t    * next;
266    thread_t    * current = CURRENT_THREAD;
267    core_t      * core    = current->core;
268    scheduler_t * sched   = &core->scheduler;
269 
270#if (CONFIG_DEBUG_SCHED_YIELD & 0x1)
271if( CONFIG_DEBUG_SCHED_YIELD < (uint32_t)hal_get_cycles() )
272sched_display( core->lid );
273#endif
274
275    // delay the yield if current thread has locks
276    if( (current->local_locks != 0) || (current->remote_locks != 0) )
277    {
278        current->flags |= THREAD_FLAG_SCHED;
279        return;
280    }
281
282    // enter critical section / save SR in current thread context
283    hal_disable_irq( &current->save_sr );
284
285    // loop on threads to select next thread
286    next = sched_select( sched );
287
288    // check next thread attached to same core as the calling thread
289    assert( (next->core == current->core), __FUNCTION__ , 
290    "next core != current core\n");
291
292    // check next thread not blocked when type != IDLE
293    assert( ((next->blocked == 0) || (next->type == THREAD_IDLE)) , __FUNCTION__ ,
294    "next thread %x (%s) is blocked on core[%x,%d]\n", 
295    next->trdid , thread_type_str(next->type) , local_cxy , core->lid );
296
297    // switch contexts and update scheduler state if next != current
298        if( next != current )
299    {
300
301#if CONFIG_DEBUG_SCHED_YIELD
302uint32_t cycle = (uint32_t)hal_get_cycles();
303if( CONFIG_DEBUG_SCHED_YIELD < cycle )
304printk("\n[DBG] %s : core[%x,%d] / cause = %s\n"
305"      thread %x (%s) (%x,%x) => thread %x (%s) (%x,%x) / cycle %d\n",
306__FUNCTION__, local_cxy, core->lid, cause, 
307current, thread_type_str(current->type), current->process->pid, current->trdid,
308next , thread_type_str(next->type) , next->process->pid , next->trdid , cycle );
309#endif
310
311        // update scheduler
312        sched->current = next;
313        if( next->type == THREAD_USER ) sched->u_last = &next->sched_list;
314        else                            sched->k_last = &next->sched_list;
315
316        // handle FPU ownership
317            if( next->type == THREAD_USER )
318        {
319                if( next == current->core->fpu_owner )  hal_fpu_enable();
320                else                                    hal_fpu_disable();
321        }
322
323        // switch CPU from calling thread context to new thread context
324        hal_do_cpu_switch( current->cpu_context, next->cpu_context );
325    }
326    else
327    {
328
329#if( CONFIG_DEBUG_SCHED_YIELD & 0x1 )
330uint32_t cycle = (uint32_t)hal_get_cycles();
331if( CONFIG_DEBUG_SCHED_YIELD < cycle )
332printk("\n[DBG] %s : core[%x,%d] / cause = %s / thread %x (%s) (%x,%x) continue / cycle %d\n",
333__FUNCTION__, local_cxy, core->lid, cause,
334current, thread_type_str(current->type), current->process->pid, current->trdid, cycle );
335#endif
336
337    }
338
339    // handle pending requests for all threads executing on this core.
340    sched_handle_signals( core );
341
342    // exit critical section / restore SR from next thread context
343    hal_restore_irq( next->save_sr );
344
345}  // end sched_yield()
346
347
348///////////////////////////////
349void sched_display( lid_t lid )
350{
351    list_entry_t * iter;
352    thread_t     * thread;
353    uint32_t       save_sr;
354
355    if( lid >= LOCAL_CLUSTER->cores_nr )
356    {
357        printk("\n[ERROR] in %s : illegal local index %d in cluster %x\n",
358        __FUNCTION__ , lid , local_cxy );
359        return;
360    }
361
362    core_t       * core    = &LOCAL_CLUSTER->core_tbl[lid];
363    scheduler_t  * sched   = &core->scheduler;
364   
365    // get pointers on TXT0 chdev
366    xptr_t    txt0_xp  = chdev_dir.txt_tx[0];
367    cxy_t     txt0_cxy = GET_CXY( txt0_xp );
368    chdev_t * txt0_ptr = GET_PTR( txt0_xp );
369
370    // get extended pointer on remote TXT0 chdev lock
371    xptr_t  lock_xp = XPTR( txt0_cxy , &txt0_ptr->wait_lock );
372
373    // get TXT0 lock in busy waiting mode
374    remote_spinlock_lock_busy( lock_xp , &save_sr );
375
376    nolock_printk("\n***** scheduler state for core[%x,%d] / cycle %d / current = (%x,%x)\n",
377            local_cxy , core->lid, (uint32_t)hal_get_cycles(),
378            sched->current->process->pid , sched->current->trdid );
379
380    // display kernel threads
381    LIST_FOREACH( &sched->k_root , iter )
382    {
383        thread = LIST_ELEMENT( iter , thread_t , sched_list );
384        if (thread->type == THREAD_DEV) 
385        {
386            nolock_printk(" - %s / pid %X / trdid %X / desc %X / block %X / flags %X / %s\n",
387            thread_type_str( thread->type ), thread->process->pid, thread->trdid,
388            thread, thread->blocked, thread->flags, thread->chdev->name );
389        }
390        else
391        {
392            nolock_printk(" - %s / pid %X / trdid %X / desc %X / block %X / flags %X \n",
393            thread_type_str( thread->type ), thread->process->pid, thread->trdid,
394            thread, thread->blocked, thread->flags  );
395        }
396    }
397
398    // display user threads
399    LIST_FOREACH( &sched->u_root , iter )
400    {
401        thread = LIST_ELEMENT( iter , thread_t , sched_list );
402        nolock_printk(" - %s / pid %X / trdid %X / desc %X / block %X / flags %X\n",
403        thread_type_str( thread->type ), thread->process->pid, thread->trdid,
404        thread, thread->blocked, thread->flags );
405    }
406
407    // release TXT0 lock
408    remote_spinlock_unlock_busy( lock_xp , save_sr );
409
410}  // end sched_display()
411
Note: See TracBrowser for help on using the repository browser.