Hi guys,
this is my first posting, so at first hi to everyone!
I have a problem with ucontext_t in connection with signal handling. I want to simulate a preemptive scheduler. I am using the iTimer with ITIMER_PROF, to schedule the interrupts. You find the code below:
Code:
#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...");
}
The "thread function" includes two big for-loops and print-outs, whether the loops finished successfully or not. Unfortunately it doesn't work fine at all runs. Sometimes the for- loops stop before reaching the end condition (i < UPPER_BOUND). This seems to depend from the UPPER_BOUND variable and the length of interval (QUANTUM_SEC and QUANTUM_MICRO_SEC). My first idea was, that the context saving does not save the value of i. But this can't be the reason, because often the loops "survive" the first signals. Because it's hard to debug this signal and context switching stuff, I've decided to ask you. I hope you have more knowledge about what's going on inside the OS. I didn't find much stuff at the web concerning this concrete topic. So, thank your for your help and let me know if you need further information.
I am using a Ubuntu 8.04 in a VMWare Player.
Best,
Matthias
Last edited by XComp; 11-24-2008 at 05:05 PM..
Reason: adding descriptions to the functions in the code
Sure, if you think that there is a better chance for an answer. At first I thought that this is more low-level programming. But anyway...can you move it to the High Level Programming Subforum?!
Ok...I've tried to reduce the code. Maybe it is easier to understand and nobody is scared by the big number of lines. I removed most of the if conditions. So let's take a second try!
Code:
// ...
#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();
}
Interesting problem. What happens when you run your program natively? VMware has some gotchas that can trip you up when you try doing what you are trying to do.
So I've tested it on a OpenSuse machine. And there it behaves a little bit different. Instead of finishing there will be raised a segmentation fault. Here is the sample output for UPPER_BOUND = 500000000 and 500 ms intveral:
Ubuntu and VMWare:
Code:
[Main Function] Program starts...
[Main Function] scheduler_context was initialized...
[Main Function] thread_context was initialized...
[Main Function] The timer was initialized...
[Scheduler Function] Scheduler starts...
[Thread Function] Function starts...
[Signal Handler] SIGPROF was raised at 59902313...
[Scheduler Function ] Swap back is done...
[Thread Function] Error: 1st counting didn't finished (59902313)...
[Signal Handler] SIGPROF was raised at 58254699...
[Scheduler Function] Swap back is done...
[Signal Handler] SIGPROF was raised at 115562955...
[Scheduler Function] Swap back is done...
[Thread Function] Error: 2nd counting didn't finished (115562955)...
[Thread Function] Function finishes...
[Scheduler Function] Swap back is done...
[Scheduler Function] Scheduler finishes...
Code:
[Main Function] Program starts...
[Main Function] scheduler_context was initialized...
[Main Function] thread_context was initialized...
[Main Function] The timer was initialized...
[Scheduler Function] Scheduler starts...
[Thread Function] Function starts...
[Signal Handler] SIGPROF was raised at 98310059...
[Scheduler Function] Swap back is done...
[Signal Handler] SIGPROF was raised at 295005103...
[Scheduler Function] Swap back is done..
[Thread Function] 1st counting worked fine...
[Signal Handler] SIGPROF was raised at 36236813...
Segmentation fault
What could be the reason of this segmentation fault. Could it be raised because of some mistakes in initializing the alternative signal stack? Does anyone has a good source, which explains, what happens inside the OS, when a context is swapped or a signal is raised? I didn't find anything on the web... :/
hi friends i have a problem in signal handling ...
let me explain my problem clearly..
i have four process ..
main process forks two child process and each child process again forks another new process respectively...
the problem is whenever i kill the child process it is reforking and the... (2 Replies)
i wrote handler for sigsegv such that i can allocate memory for a variable to which
sigsegv generated for illlegal acces of memory.
my code is
#include <signal.h>
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
char *j;
void segv_handler(int dummy)
{
j=(char *)malloc(10);
... (4 Replies)
I am trying to write a small program where I can send signals and then ask for an action to be triggered if that signal is received. For example, here is an example where I am trying to write a programme that will say you pressed ctrl*c when someone presses ctrl+c. My questions are what you would... (1 Reply)
Hello all,
I am starting to learn signal handling in Linux and have been trying out some simple codes to deal with SIGALRM. The code shown below sets a timer to count down. When the timer is finished a SIGALRM is produced. The handler for the signal just increments a variable called count. This... (7 Replies)
#1: does anyone know how to detect how many times (and/or the time length) a given thread has been context switched out of the CPU?
#2: are there any tchniques that minimize/eliminate your thread getting context switched?
I would be happy to know the answers to these questions for ANY... (2 Replies)
Guys,
I'm doing signal handling in Perl. I'm trying to catch ^C signal inside the script.
There two scripts : one shell script and one perl script.
The shell script calls the perl script.
For e.g. shell script a.sh and perl scipt sig.pl.
Shell script a.sh looks something like this :... (6 Replies)
Hi folks
I'm trying to write a signal handler (in c on HPUX) that will catch the child process launched by execl when it's finished so that I can check a compliance file.
The signal handler appears to catch the child process terminating however when the signal handler completes the parent... (3 Replies)
HI,
I need to handle SIGUSR2 signal in my application to change the state of the application dynamically. I have implemented the signal handler. However the application is able to catch only one SIGUSR2 signal. The second SIGUSR2 signal causes the application to crash. This is happning only with... (3 Replies)