Calling infinite loop code multiple times on alarm - c

Question

I'm currently using an alarm signal SIGALRM to exit from an infinite loop.
My code is structured as follows
main_loop() {
set_alarm();
while(1)
counter++;
}
The logic is
- Set an alarm
- Enter while loop
- Read counter when we get SIGALRM
The code that runs upon SIGALRM is given below:
VERBOSE("Cycles :%u\n", counter);
iteration_index++;
if(iteration_index == iterations)
exit(0);
counter = 0;
main_loop();
I would now like to now give the user an option to specify the number of times (iterations) the alarm should go off. In short, modify the above logic into:
- Set an alarm
- Enter while loop
- Read counter when we get SIGALRM
- Increment iteration_index
-If iteration_index < iterations: call main_loop
- Else exit
I implemented the above logic and found that it segfaults after a few thousand iterations. I believe that the reason for this is that:
When the alarm triggers and it makes a new call to main_loop, the original main_loop frame still exists. This keeps repeatedly happening until it runs out of space and throws a segfault.
I've tried coming up with some design that does what I want, but I'm unable to visualize code-flow after the signal is triggered.
What is the right way to implement what I've described?

Answer 1

Regrading the modifications you listed:
- Set an alarm
- Enter while loop
- Read counter when we get SIGALRM
- Increment iteration_index
- If iteration_index < iterations: call main_loop
- Else exit
You could provide a series of keystrokes (say <ctrl> - 1 to allow the user to specify a number of times (just once). This example runs (with delays to allow some time for GetAsyncKeys(). Until the user presses <ctrl> 1, the loop will run forever. When <ctrl> 1 is pressed, program prompts them with how many time to let the alarm sound, then programs runs that many iterations, then quits..
#include <stdio.h>
#include <windows.h>
void set_alarm(void);
int main(void) {
int iterations=-1, counter=0;
while (iterations != counter)
{
if(iterations == -1)//code will run forever if iteration is not set by user
{
set_alarm();
counter++;
if (GetAsyncKeyState(VK_CONTROL)<0)
{
if (GetAsyncKeyState('1')<0)
{
printf("Enter how many time alarm should activate:\n");
scanf("%d", &iterations);
counter = 0;
Sleep(10);
}
}
}
else//this block will monitor alarm count, program quits when limit reached.
{
if(counter < iterations)
{
set_alarm();
counter++;
}
}
Sleep(10);//changed here for my test, you might need to change again
}
return 0;
}
void set_alarm(void)
{
//do something;
}

Answer 2

Yes, you are right. When the handler for SIGALRM runs, the main_loop() function is still running. Both functions will in fact be running on the same thread. If you never exit from the SIGALRM handler, then the next handler will go on top, and this will keep happening until you run out of stack and crash.
To fix this, simply return from the signal handler.
// Make sure that both of these are volatile
volatile int iteration_index;
volatile int counter;
void catch_sigalrm(int signo)
{
// Note: this is not safe, so I commented it out
// VERBOSE("Cycles :%u\n", counter);
iteration_index++;
if(iteration_index == iterations)
exit(0);
counter = 0;
set_alarm();
}
void main_loop(void)
{
set_alarm();
while (1)
__sync_fetch_and_add(&counter, 1);
}
I think this will work. It should use ldrex and strex for incrementing counter.
The problem with using counter++ is that it can be interrupted: counter++ is actually something like this:
int old_value = counter; // memory access
int new_value = old_value + 1;
counter = new_value; // memory access
As you can see, if the alarm goes off in the middle of counter++ the results will get wiped out. That is why you need to use __sync_fetch_and_add() instead.
The volatile specifier is MANDATORY
Here's the main loop with a normal counter variable. I've removed the call to set_alarm() because we're not concerned about it right now.
// This is wrong
int counter;
void main_loop()
{
while (1)
counter++;
}
Here's the assembly:
_main_loop:
b _main_loop
.comm _counter, 4, 2
Wait a second! It doesn't increment anything, it's just an infinite loop!
That's right. The compiler detected that counter can not possibly be read anywhere, and so optimized the increment right out of existence. You MUST use volatile. The volatile keyword instructs the compiler that counter may be read or written by something else that is not a thread (actually, it instructs the compiler to be strict about loads and stores, but that's the technical version). (For working with threads, volatile is almost never useful, you have to use atomics which are different.)
Here's the version with volatile:
// This is ALSO wrong
volatile int counter;
void main_loop(void)
{
while (1) counter++;
}
And the assembly:
_main_loop:
; load address of counter into r0
...
loop:
; increment counter
ldr r1, [r0]
adds r1, #1
str r1, [r0]
b loop
As you can see, this can be interrupted in the middle. This is why you have to use __sync_fetch_and_add(): it detects when counter++ was interrupted and it restarts the operation from the beginning.
Here is the correct version:
// MUST be volatile
volatile int counter;
void main_loop(void)
{
while (1)
__sync_fetch_and_add(&counter, 1);
}
More notes
You can't call printf() in a signal handler.
In fact, try to avoid doing anything in a signal handler.
At most, set a flag, write a byte to a pipe, or something like that.