|
|
Signal Handling and Context Switches
11-24-2008
#include <stdio.h>
#include <stdlib.h>
// signal handling
#include <signal.h>
// context switch
#include <ucontext.h>
// timer
#include <sys/time.h>
#define UPPER_BOUND 500000000
#define QUANTUM_SEC 0
#define QUANTUM_MICRO_SEC 500000
// stores the context of the thread_function context
static ucontext_t thread_context;
// stores the context of the scheduler_function context
static ucontext_t scheduler_context;
int thread_finished;
int i;
// This function provides the signal handling.
// It saves the context of the thread_function and swaps to the scheduler_function context
static void signal_handler_function(int sig_nr, siginfo_t* info, void *context) {
if (sig_nr == SIGPROF) {
printf("\n[Signal Handler]\tSIGPROF was raised at %d...", i);
} else {
printf("\n[Signal Handler]\tA different signal was raised...");
return;
}
// saves the thread context
thread_context = *((ucontext_t*)context);
// swaps back to scheduler context
setcontext(&scheduler_context);
}
// This function simulates a thread function. It consists of two simple for-loops and prints, whether every loop finished successfully.
void thread_function(void) {
printf("\n[Thread Function]\tFunction starts...");
for (i = 0; i < UPPER_BOUND; ++i) {
// do nothing but counting
}
if (i == UPPER_BOUND) {
printf("\n[Thread Function]\t1st counting worked fine...");
} else {
printf("\n[Thread Function]\tError: 1st counting didn't finished (%d)...", i);
}
for (i = 0; i < UPPER_BOUND; ++i) {
// do nothing but counting
}
if (i == UPPER_BOUND) {
printf("\n[Thread Function]\t2nd counting worked fine...");
} else {
printf("\n[Thread Function]\tError: 2nd counting didn't finished (%d)...", i);
}
thread_finished = 1;
printf("\n[Thread Function]\tFunction finishes...");
}
// The context will swap into this function after a signal was raised. The while-loop ends, when thread_finished == 1.
// thread_finished is set to 1 at the end of the thread_function.
void scheduler_function() {
printf("\n[Scheduler Function]\tScheduler starts...");
// thread_finished is a global variable, which is set to 1, if the thread function is finished
while(thread_finished != 1) {
swapcontext(&scheduler_context, &thread_context);
printf("\n[Scheduler Function]\tSwap back is done...");
}
printf("\n[Scheduler Function]\tScheduler finishes...");
}
// main initializes all needed stuff (timer, signal handler) and starts the scheduler_function.
int main(int argc, char **argv) {
printf("\n[Main Function]\t\tProgram starts...");
thread_finished = 0;
char thread_stack[65536];
// initializing scheduler context
if (getcontext(&scheduler_context) == 0) {
printf("\n[Main Function]\t\tscheduler_context was initialized...");
} else {
printf("\n[Main Function]\t\tError while initializing scheduler_context...");
return -1;
}
// initializing thread context
if (getcontext(&thread_context) == 0) {
thread_context.uc_stack.ss_sp = thread_stack;
thread_context.uc_stack.ss_size = sizeof(thread_stack);
thread_context.uc_link = &scheduler_context;
printf("\n[Main Function]\t\tthread_context was initialized...");
} else {
printf("\n[Main Function]\t\tError while initializing thread_context...");
return -1;
}
// initialize alternate stack for signal handling
char * alternate_stack = (char*)malloc(65536);
stack_t new_signal_stack;
new_signal_stack.ss_sp = alternate_stack;
new_signal_stack.ss_size = 65536;
new_signal_stack.ss_flags = 0;
sigaltstack(&new_signal_stack, NULL);
// sets the signal handler for swapping to the scheduler context
struct sigaction scheduling_interuption_handler;
scheduling_interuption_handler.sa_sigaction = signal_handler_function;
scheduling_interuption_handler.sa_flags = SA_RESTART | SA_SIGINFO | SA_ONSTACK;
sigemptyset(&scheduling_interuption_handler.sa_mask);
if (sigaction(SIGPROF, &scheduling_interuption_handler, NULL) == -1) {
printf("\n[Main Function]\t\tAn error occurred while initializing the signal handler for swapping to the scheduler context...");
}
// sets the timer which sends SIGPROF periodically
struct itimerval timeslice;
timeslice.it_value.tv_sec = QUANTUM_SEC;
timeslice.it_value.tv_usec = QUANTUM_MICRO_SEC;
timeslice.it_interval = timeslice.it_value;
if (setitimer(ITIMER_PROF, ×lice, NULL) == 0) {
printf("\n[Main Function]\t\tThe timer was initialized...");
} else {
printf("\n[Main Function]\t\tAn error occurred while executing setitimer...");
}
// sets the thread function
makecontext(&thread_context, thread_function, 0);
// this function handles the swapping part
scheduler_function();
printf("\n[Main Function]\t\tProgram finishes...");
}
11-25-2008
11-25-2008
// ...
#define UPPER_BOUND 500000000
#define QUANTUM_SEC 0
#define QUANTUM_MICRO_SEC 500000
// stores the context of the thread_function context
static ucontext_t thread_context;
// stores the context of the scheduler_function context
static ucontext_t scheduler_context;
int thread_finished;
int i;
static void signal_handler_function(int sig_nr, siginfo_t* info, void *context) {
// saves the thread context
thread_context = *((ucontext_t*)context);
// swaps back to scheduler context
setcontext(&scheduler_context);
}
// This function simulates a thread function. It consists of two simple for-loops and prints, whether every loop finished successfully.
void thread_function(void) {
// 1st count
for (i = 0; i < UPPER_BOUND; ++i);
if (i == UPPER_BOUND) {
printf("\n[Thread Function]\t1st counting worked fine...");
} else {
printf("\n[Thread Function]\tError: 1st counting didn't finished (%d)...", i);
}
// 2nd count
for (i = 0; i < UPPER_BOUND; ++i);
if (i == UPPER_BOUND) {
printf("\n[Thread Function]\t2nd counting worked fine...");
} else {
printf("\n[Thread Function]\tError: 2nd counting didn't finished (%d)...", i);
}
thread_finished = 1;
}
// The context will swap into this function after a signal was raised. The while-loop ends, when thread_finished == 1.
// thread_finished is set to 1 at the end of the thread_function.
void scheduler_function() {
// thread_finished is a global variable, which is set to 1, if the thread function is finished
while(thread_finished != 1) {
swapcontext(&scheduler_context, &thread_context);
printf("\n[Scheduler Function]\tSwap back is done...");
}
}
// main initializes all needed stuff (timer, signal handler) and starts the scheduler_function.
int main(int argc, char **argv) {
thread_finished = 0;
char thread_stack[65536];
// initializing scheduler context
getcontext(&scheduler_context);
// initializing thread context
getcontext(&thread_context);
thread_context.uc_stack.ss_sp = thread_stack;
thread_context.uc_stack.ss_size = sizeof(thread_stack);
thread_context.uc_link = &scheduler_context;
// initialize alternate stack for signal handling
char * alternate_stack = (char*)malloc(65536);
stack_t new_signal_stack;
new_signal_stack.ss_sp = alternate_stack;
new_signal_stack.ss_size = 65536;
new_signal_stack.ss_flags = 0;
sigaltstack(&new_signal_stack, NULL);
// sets the signal handler for swapping to the scheduler context
struct sigaction scheduling_interuption_handler;
scheduling_interuption_handler.sa_sigaction = signal_handler_function;
scheduling_interuption_handler.sa_flags = SA_RESTART | SA_SIGINFO | SA_ONSTACK;
sigemptyset(&scheduling_interuption_handler.sa_mask);
sigaction(SIGPROF, &scheduling_interuption_handler, NULL)
// sets the timer which sends SIGPROF periodically
struct itimerval timeslice;
timeslice.it_value.tv_sec = QUANTUM_SEC;
timeslice.it_value.tv_usec = QUANTUM_MICRO_SEC;
timeslice.it_interval = timeslice.it_value;
setitimer(ITIMER_PROF, ×lice, NULL);
// sets the thread function
makecontext(&thread_context, thread_function, 0);
// this function handles the swapping part
scheduler_function();
}|
|
|
|