What we will learn. Threaded Systems: Threads. Threads. Threads. Bag of functions & procedures ST OS. AUCs. Threads. AUCs. Processes MT OS MP OS

Size: px

Start display at page:

Download "What we will learn. Threaded Systems: Threads. Threads. Threads. Bag of functions & procedures ST OS. AUCs. Threads. AUCs. Processes MT OS MP OS"

Duane Goodwin
6 years ago
Views:

1 What we will learn Threaded Systems: Threads A thread-driven approach is attractive in sensor networks for many of the same reasons that it has been adopted for PDAs, laptops, and servers. In a thread-driven system, an application programmer need not be concerned about indefinitely blocking or being indefinitely blocked by other tasks during execution, except for shared resources, because the scheduler will preemptively time-slice between threads, allowing some tasks to continue execution even though others may be blocked. This automated time-slicing considerably simplifies programming for an application developer. ST OS MT OS MP OS Threads Bag of functions & procedures Coroutines weak AUCs Threads Processes AUCs AUCs Threads Each abstract machine is called a thread: they all operate in the same (hardware) address space. The Thread approach depends on the existence of an interval timer that periodically raises an interrupt: When a timer interrupt occurs, the currently executing abstract machine is suspended and the OS begins to execute OS can invoke the scheduler to dispatch an abstract machine according to its scheduling policy. newly dispatched AUC executes until it voluntarily yields the CPU or another interval timer interrupt occurs

2 Clock interrupts Real-time clock: hardware device that pulses regularly an integral number of times each second, and interrupts the CPU each time a pulse occurs. Example: clock interrupts Real-time clock: hardware device that pulses regularly an integral number of times each second, and interrupts the CPU each time a pulse occurs. Different from the time-of-day clock that keeps the current time. A time-of-day clock also emits pulses at regular intervals unlike the real time clock, it does not interrupt the CPU after each pulse. Instead, it increments a counter, which the CPU may read to determine the current time Example: clock interrupts The number of times a clock pulses in a second is called clock rate. Typical clock rates are 10Hz, 60Hz, 100Hz, and 1000Hz. It is important that clock interrupts be serviced promptly to ensure that they are not lost. The hardware helps by giving a clock the highest priority among the various devices that can interrupt. The software helps by keeping making clock interrupt processing efficient by reducing the number of procedure calls made. Example: clock interrupts It is important that the processor not spend all its time processing clock interrupts. Solution: adjust the clock rate to match the system. A slower clock can be simulated by the clock interrupt handler: divide the clock rate by ignoring a certain number of interrupts before it processes one. This slower simulated rate is called the tick rate: the smallest size of the granularity of preemption and timed delays.

3 Network Stack Command Server Example: clock interrupts 20 ns (period) = 200 MHz (frequency) Example: clock handler in FreeRTOS /* * Handler for the timer interrupt. void vtickisr( void *pvbaseaddress ) unsigned portlong ulcsr;! /* Increment the RTOS tick - this might cause a task to unblock.! vtaskincrementtick();! /* Clear the timer interrupt!... Each period, counter is decremented when count =0 clock interrupt Int(t+1) - Int(t) = 1 clock tick! /* If we are using the preemptive scheduler then we also need to determine! if this tick should cause a context switch.! #if configuse_preemption == 1!! vtaskswitchcontext();! #endif Real stuff: Multithreaded MANTIS OS (MOS) MANTIS System API Kernel/Scheduler Hardware T3 T4 Device Drivers T5 User-level threads MANTIS OS Real stuff: Multithreaded MANTIS OS (MOS) When a thread is created, stack space is allocated by the kernel Dynamic thread stack allocated on heap Thread context saved on thread stack The space is recovered when the thread exits. MOS kernel: services provided are a subset of POSIX threads Preemptive multi- threading: priority-based thread scheduling round-robin semantics within a priority level. Fast context switching (~60microsecs) 144 byte footprint for scheduler Static thread table (default 12 threads) 10 bytes per thread entry

4 Real stuff: Multithreaded MANTIS OS (MOS) Driver threads User threads Idle thread created by the kernel at startup. low priority runs when all other threads are blocked. implement power-aware scheduling, as it may detect patterns in CPU utilization and adjust kernel parameters to conserve energy. Real stuff: Multithreaded MANTIS OS (MOS) The scheduler receives a timer interrupt from the hardware to trigger context switches; switches may also be triggered by system calls or semaphore operations. The timer interrupt is the only one handled by the kernel: other hardware interrupts are sent directly to the associated device drivers. Upon an interrupt, a device driver typically posts a semaphore in order to activate a waiting thread,and this thread handles whatever event caused the interrupt. No soft interrupts supported by the MOS kernel MOS Thread Table data structure The kernel s main global data structure is a thread table, with one entry per thread. Allocated statically: there is a fixed maximum number of threads and a fixed level of memory overhead. The maximum thread count is adjustable at compile time (the default is 12). Each thread table contains a current stack pointer, stack boundary information (base pointer and size), a pointer to the thread s starting function, the thread s priority level, and a next thread pointer for use in linked lists. MOS Thread Table data structure Thread structure definition typedef struct thread_s Stack pointer stackval_t *sp; Pointer to stack memory for de-allocating stackval_t *stack; Size of stack (for debugging) uint16_t stacksize; Function pointer to thread's start func void (*func)(void); Thread sleep time uint32_t st; Current thread state uint8_t state; Current thread suspend state uint8_t suspend_state; Thread priority uint8_t priority; Port number -- Only used for net recv uint8_t port; Next thread on list struct thread_s *next; struct thread_s *waiting_for; uint8_t thread_id; mos_thread_t;

5 MOS Thread Table data structure The kernel s main global data structure is a thread table, with one entry per thread. Allocated statically: there is a fixed maximum number of threads and a fixed level of memory overhead. The maximum thread count is adjustable at compile time (the default is 12). Each thread table contains a current stack pointer, stack boundary information (base pointer and size), a pointer to the thread s starting function, the thread s priority level, and a next thread pointer for use in linked lists. // init the thread table for(i = 0; i < MAX_THREADS; i++) threads[i].sp = 0; threads[i].state = EMPTY; threads[i].suspend_state = SUSPEND_STATE_SLEEP; threads[i].priority = 0; threads[i].next = NULL; threads[i].waiting_for = NULL; MOS: Creating a new thread... //Search for a free slot in the thread table. for(id = 0; id < MAX_THREADS; id++) if(threads[id].state == EMPTY) break;... //Allocate memory for the stack space. stack_addr = (stackval_t *)mos_mem_alloc(stack_size); if(stack_addr == NULL) mos_enable_ints(int_handle); return NO_MORE_MEMORY; // Can't continue if we don't have memory // Now save the beginning of the stack to the thread's stack variable threads[id].stack = stack_addr; threads[id].stacksize = stack_size; threads[id].func = function_start; threads[id].state = READY; // Init thread state threads[id].suspend_state = SUSPEND_STATE_IDLE; threads[id].priority = priority; threads[id].thread_id = id; Simple Thread state diagram Better Thread state diagram Schedule READY Sleeping Queue Schedule thread_suspend READY Blocked Queue BLOCKED

6 Thread state in Mantis OS enum Thread is empty. EMPTY = 0, Thread is running., Thread will run at next opportunity. READY, Thread is blocked. BLOCKED, Thread is sleeping. ; Suspend states enum Thread is not waiting on interrupts, ok to sleep SUSPEND_STATE_IDLE = 0, Thread needs an interrupt, do not sleep SUSPEND_STATE_SLEEP, Total number of suspend states SUSPEND_STATE_MAX ; Some thread functions in Mantis /mos/kernel/<platform>/include/msched.h Create a new thread and put it on the ready queue. * Note: There is no memory protection so watch your stack sizes. function_start Pointer to function to call on thread start stack_size Stack space to give the thread. If the specified * stack size is smaller than MIN_STACK_SIZE, MIN_STACK_SIZE will be used instead. priority Priority of the thread THREAD_OK, NO_MORE_THREADS, NO_MORE_MEMORY, BAD_THREAD_PRIORITY uint8_t mos_ (void (*function_start)(void), memtype_t stack_size,uint8_t priority); Resume a blocked thread thread Thread to resume void mos_(mos_thread_t *thread); Suspend to a specific state state the state to suspend to void mos_thread_suspend_(uint8_t state); Put the currently running thread to sleep. * Units are in ms * Minimum sleeptime is 128 ms (will be promoted) void mos_(uint32_t sleeptime); Terminate the calling thread. void mos_ (void); Summing up: How Multi-threaded systems work The computer is initialized: OS is loaded and initialized; this creates a software environment composed of multiple abstract machines, The OS accepts requests to execute an application program, assigns each request to an abstract machine, and then systematically allocates physical machine components to the abstract machines. When an AUC has been allocated the appropriate resources, it executes; otherwise it is blocked. Each AUC is a thread, since it operate in the same (hardware) address space. The TP approach depends on the existence of an interval timer that periodically raises an interrupt. When a timer interrupt occurs, the currently executing abstract machine is suspended and the OS begins to execute. In particular, it can invoke the scheduler to dispatch an abstract machine according to its scheduling policy. The newly dispatched abstract machine executes until it voluntarily yields the CPU or another interval timer interrupt occurs. /mos/sys int main(void) sched_init(); //init scheduler--this MUST BE FIRST Starting the OS = starting the scheduler com_init(); //init com system... mos_(pre_start, START_STACK_SIZE, PRIORITY_NORMAL); //start the scheduler (never returns) mos_sched_start(); return 0;

7 Application's start function. extern void start(void); prestart() is the function for the startup thread, the one spawned by main(). * It does all the initialization that needs to happen after the * kernel is up and running, and then it calls the application start function. void pre_start(void) #ifdef PLATFORM_LINUX mos_node_id_init();! // must be called before gevent_init () gevent_init(); serial_init(); terminal_init(); xmos_radio_init();! // gevent_init() must be called first xmos_flash_init();! // gevent_init() must be called first mos_thread_suspend(); //fixes threading issue with freebsd #elif defined(arch_micro) uart_init(); printf_init(); plat_init(); clock_init(); #if defined(platform_telosb) kernel_timer_init(); #endif mos_node_id_init(); #endif //if defined(arch_avr) #ifdef MOS_DEBUG mos_debug_post_init(); #endif start(); // STARTS THE APPLICATION Scheduling threads Schedule READY Starting the scheduler void mos_sched_start(void) running = TRUE; //initialize the hardware timers which control //sleeping and timeslicing kernel_timer_init(); sleep_timer_init(); From Other States Ready Thread Scheduling threads Thread Descriptor // Once interrupts are enabled here, the sheduler will start to schedule // threads and do time slicing. ENABLE_INTS(); //Start executing the first thread dispatcher(); Enqueuer // On to the idle loop idle_loop(); Dispatcher Context Switcher CPU Running Thread

8 From Other States Ready Thread Enqueuer Scheduling threads Ready queue Thread Descriptor Scheduling threads : Thread context R1 R2... Rn Right Operand Left Operand Result Functional Unit Status Registers ALU Dispatcher Context Switcher CPU Running Thread PC IR CPU Context switching Old Thread Descriptor New Thread Descriptor Context switching in Mantis Scheduler context switches only when it receives timer interrupt from the hardware. No Soft Interrupts /** Save current stack pointer * Change stack pointer to process stack * Push address of start_thread function onto stack * Push zeroes for initial register vals and sreg * Save adjusted stack ptr to thread struct * Restore kernel stack ptr #define PUSH_THREAD_STACK()... asm volatile(!! \! "push r31\n\t"!!! \! "push r30\n\t"!!! \! "push r29\n\t"!!! \! "push r28\n\t"!!! \!... /** Restore the stack pointer * Restore SREG * Restore the other registers #define POP_THREAD_STACK()\!... asm volatile(!!!! "pop r2\n\t"! \! "pop r3\n\t"! \! "pop r4\n\t"! \! "pop r5\n\t"! \!...

9 Invoking the Scheduler Voluntary Sharing Need a mechanism to call the scheduler Voluntary call Process blocks itself Calls the scheduler Involuntary call External force (interrupt) blocks the process Calls the scheduler Every process periodically yields to the scheduler Relies on correct process behavior Malicious Accidental Need a mechanism to override running process Involuntary CPU Sharing Interval timer Device to produce a periodic interrupt Programmable period IntervalTimer() InterruptCount--; if(interruptcount <= 0) Interrupt = TRUE; InterruptCount = K; SetInterval(programmableValue) K = programmablevalue: InterruptCount = K; Involuntary CPU Sharing (cont) Interval timer device handler Keeps an in-memory clock up-to-date Invokes the scheduler IntervalTimerHandler() Time++; // update the clock TimeToSchedule--; if(timetoschedule <= 0) <invoke scheduler>; TimeToSchedule = TimeSlice;

10 Contemporary Scheduling Scheduling threads Involuntary CPU sharing timer interrupts Time quantum determined by interval timer usually fixed size for every process using the system Sometimes called the time slice length From Other States Ready Thread Enqueuer Ready List Thread Descriptor Dispatcher Context Switcher CPU Running Thread Mantis OS scheduling: dispatcher Running to Ready void attribute ((naked)) dispatcher(void) #endif // Prologue: Saves the current state. // All registers go onto current stack and then the stack is saved dispatcher_int_handle = mos_disable_ints(); running = FALSE; elapsed_thread_time = 0; PUSH_THREAD_STACK();... // Only change the thread's state if it was running, not blocked if(_current_thread->state == ) _current_thread->state = READY; mos_tlist_add(&readyq[_current_thread->priority], _current_thread); // Now bring up the new thread // idle thread's existence guarantees we'll get something Disable interrupts begin Context switch Ready to Running // Now bring up the new thread // idle thread's existence guarantees we'll get something for(d_index = 0; d_index < NUM_PRIORITIES; d_index++) _current_thread = mos_tlist_remove(&readyq[d_index]); if(_current_thread!= NULL) break; _current_thread->state = ; POP_THREAD_STACK(); running = TRUE; // return must be explicit because naked functions don't have one #ifdef PLATFORM_IMOTE2 asm volatile("ldmfd r13!,pc"); #elif PLATFORM_MICROBLAZE #else asm volatile("ret\n"); #endif Mantis OS dispatcher mos_enable_ints(dispatcher_int_handle); End Context switch Enable interrupts

11 Mantis OS scheduling Real stuff: Mantis OS In the current implementation, the user is not encouraged to dynamically allocate heap space, although that was an API decision and is not an inherent limitation of MOS. This limitation is imposed because with such limited memory it is importantto have a well planned and coherent memory management policy. A thread s current context, including saved register values, is stored on its stack when the thread is suspended. This is significant, because the context is much larger than a thread table entry, and it only needs to be stored when the thread is allocated. The kernel also maintains ready-list head and tail pointers for each priority level (5 by default, for 20 bytes total). Keeping both pointers allows for fast addition and deletion, which improves performance when manipulating thread lists. This is important because those manipulations are frequent and always occur with interrupts disabled. There is also a current thread pointer (2 bytes), an interrupt status byte, and one byte of flags. The total static overhead for the scheduler is thus 144 bytes. Putting a thread to sleep Putting a thread to sleep Dispatch thread_suspend READY void mos_(uint32_t sleeptime) handle_t int_handle; int_handle = mos_disable_ints(); _current_thread->state = ; // Update the thread state _current_thread->st = sleeptime + elapsed_thread_time; // Update the sleeptime mos_tlist_ordadd(&sleepq, _current_thread); mos_thread_wakeup(elapsed_thread_time, int_handle); BLOCKED

12 Suspending a thread Suspending a thread Dispatch thread_suspend READY void mos_thread_suspend_state(uint8_t state) if(state >= SUSPEND_STATE_MAX) state = SUSPEND_STATE_IDLE; handle_t int_handle = mos_disable_ints(); _current_thread->next = NULL; _current_thread->state = BLOCKED; // Update the thread state // store the old suspend state in the sleep time, // which we aren't using _current_thread->st = (uint32_t)_current_thread->suspend_state; _current_thread->suspend_state = state; mos_thread_wakeup(elapsed_thread_time, int_handle); BLOCKED Resuming a thread Resuming a thread Dispatch thread_suspend READY void mos_(mos_thread_t *thread) handle_t int_handle; int_handle = mos_disable_ints(); // put given thread onto the ready Queue if it was blocked. if(thread->state == BLOCKED) mos_tlist_add(&readyq[thread->priority], thread); thread->state = READY; thread->suspend_state = (uint8_t)thread->st; mos_thread_wakeup(elapsed_thread_time, int_handle); BLOCKED

13 void mos_thread_wakeup(uint16_t sleep_time) //Adjust the sleepq with the times that has already expired. mos_tlist_adjustst(&sleepq, sleep_time); //get the first thread in the sleep queue wakeup_front = mos_tlist_head(&sleepq); //loop through the sleep queue while((wakeup_front!= NULL) && (wakeup_front->st == 0)) Waking up a thread //remove the thread if sleep time is 0 sleep_thread = mos_tlist_remove(&sleepq); sleep_thread->state = READY; // Update the thread state //add thread to ready queue mos_tlist_add(&readyq[sleep_thread->priority], sleep_thread); wakeup_front = mos_tlist_head(&sleepq); dispatcher(); // do the context switch. Dispatching a thread dispatch thread_suspend READY BLOCKED Summary OS does not depend on the CPU mode bit: can support the thread model, but any process can read/write the address space of any other thread and are able to change any CPU register and access all information stored in executable memory. Depend on interrupts, in particular on a timer device that periodically interrupts the CPU and gives control to the OS. Supports schedulable units of computation: threads Threads are AUC but there are few barriers among the the AUCs. Individual programs need not incorporate design dependencies as required in a DS system (coroutine programming)

Threads and Concurrency

Threads and Concurrency 1 Threads and Concurrency key concepts threads, concurrent execution, timesharing, context switch, interrupts, preemption reading Three Easy Pieces: Chapter 26 (Concurrency and