Can we force quit a C program's execution after a fraction of seconds

Question

Can we force quit a C program's execution after a fraction of seconds (range of milliseconds) or by the size of memory it uses? This way, I want to restrict printing content in an infinite loop and restrict buffer overruns.

I am using cygwin GCC4.3 compiler and want to implement it as a tool in PHP, which takes in the C source as input and displays the corresponding output.

PS - 1. I say milliseconds because my C problems will only involve very simple arithmetic/computations. 2. To restrict the execution time, set_time_limit()in php would restrict the entire PHP script's execution time and not the time allotted to exec( )

Answer 1

You might want to investigate whether your system has nanosleep() from POSIX 2008. Note that even if you can specify a time in nanoseconds, the system may not be able to honour sub-millisecond timings very reliably.

You might find that µ-sleep() (spelled usleep() ) is available instead, though it is officially obsolete. It specifies a time including microseconds. A quick search on Google for 'usleep windows' suggests Sleep() as a native Windows alternative.

See also: Sleep less than one millisecond .

See also: Command line command to auto-kill a command after a certain amount of time . The program there is not currently written to deal with sub-second timing, but the necessary adaptations would not be very hard once you've decided on the sub-second timing interface to use.

Answer 2

You should be able to use the alarm() function. While it is found in unistd.h it is a POSIX.1-2001 function and should be available under cygwin. If SIGALRM is not handled it kills the process.

Try it:

#include <stdio.h>
#include <unistd.h>

int main() {

     alarm(5); /* raise alarm after 5 seconds */

     while(1) {
             printf("Running forever\n");
     }
     return 0; /* never reached */
}

update

As jonathan points out alarm(2) only works in seconds so you can use setitimer instead (also POSIX compliant)

#include <stdio.h>
#include <sys/time.h>

int main() {

     /* --CUT HERE-- */
     struct itimerval timer;
     timer.it_value.tv_sec = 0;
     timer.it_value.tv_usec = 5000; /* 5 milliseconds */
     timer.it_interval.tv_sec = 0;
     timer.it_interval.tv_usec = 0; 

     setitimer(ITIMER_REAL, &timer, NULL);
     /* --END CUT-- */
     while(1) {
             printf("Running forever\n");
     }
     return 0; /* never reached */
}

if the above works on your system, copy code from --CUT HERE-- to --END CUT-- and paste it into your main;

update 2

to limit memory try using setrlimit:

see Set stack size with setrlimit() and provoke a stack overflow/segfault

for an example

Answer 3

I have done something similar in past, and the architecture I used was - Have a parent C-program say main.c, code similar to below (note this is no way a production code, and not even guarantee to compile, the code below is only for the purpose of demonstration).

// ---------------------- main.c ----------------
int main_child(); // the body is defined in "your_test_source.c"

int main()
{
  pthread_t tid;

  // create child thread
  pthread_create(tid, NULL, main_child, NULL);

  // start monitoring the child thread
  // ...
  // you can kill child thread by calling pthread_exit
  // and check for memory usage by system calls.

  return 0;
}

#define main main_child
  // we change the main function to main_child
  #include "your_test_source.c"
#undef main
// ---------------------- end -------------

your_test_source.c - this is the test file.

This adds up a layer for you to compile and debug, but it works.

Answer 4

To limit the size of memory just do not use dynamic memory allocation or recursion. You can then ensure that the memory requirements are bounded (that is the coding standard for safety critical systems).

As to time requirements, why just live with the limitation of seconds granualarity and limit execution to one second?