How to implement two periodical processes in C++ under Linux?

MarijaS · 07-26-2010, 06:43 AM

Hello,

I am doing real time programming in C++, under Linux.

I have two process, let me say A and B. A process is being started periodically, every 5ms. B process is being started every 10ms. The process A is doing some change of data. The process B is reading that data and displays it.

I am confused about how to run periodically processes.

Is the only way to create child process? Can I create independent processes on some other way?

Tnx!

bigearsbilly · 07-26-2010, 09:58 AM

look here first...

time.h

esp. look at timer_create

it's quite hard to follow. I have a messy example if you want.
I think it needs the pthread and realtime libraries.

LDFLAGS = -lrt -lpthread

if you are using an X toolkit they often have a timer.

Sergei Steshenko · 07-26-2010, 04:56 PM

Quote:

Originally Posted by MarijaS

Hello,

I am doing real time programming in C++, under Linux.

I have two process, let me say A and B. A process is being started periodically, every 5ms. B process is being started every 10ms. The process A is doing some change of data. The process B is reading that data and displays it.

I am confused about how to run periodically processes.

Is the only way to create child process? Can I create independent processes on some other way?

Tnx!

Independent processes are child processes of the shell you invoke them from.

Do you really want processes or you want threads ? Regarding the latter look up "POSIX threads" -> https://computing.llnl.gov/tutorials/pthreads/ .

The info is in addition to bigearsbilly's post.

bigearsbilly · 07-27-2010, 06:04 AM

the timer_create functions generally run as non-joinable threads.
(though I believe it's not mandatory)

so mutexes, conditions etc, are available to manage data.
on my linux and freebsd anyway.

if you want a scruffy example of using them
let me know.

MarijaS · 07-27-2010, 11:34 AM

Thank you for your suggestions!
I really need independent processes...

@bigearsbilly
Some example would be very useful!

dwhitney67 · 07-27-2010, 12:06 PM

Quote:

Originally Posted by MarijaS

Thank you for your suggestions!
I really need independent processes...

Must you start and stop, and then restart your processes, every 10ms and 5ms, respectively? Or can they be run once and remain dormant (ie in a wait state) for the aforementioned periods while they are not processing data?

Starting and stopping processes is major CPU-hog; you would be better off placing the processes in a wait state, and perhaps even better off utilizing a multi-threaded solution.

Your requirements are too vague to provide further assistance. If you plan to stick with independent processes, I would suggest you look into using shared-memory for the data.

zirias · 07-27-2010, 03:10 PM

To get periodical tasks, I'd follow dwhitney67's suggestion and use alarm(2) at the beginning of each computation period and send the process to blocked state e.g. by calling wait().

But the instant the SIGALRM occurs, the scheduler could STILL decide to first run another process out of the ready queue, so this doesn't qualify as a true real time system. If you need true realtime, you'll need a different scheduler (for example an implementation of rate monotonic scheduling) in the kernel.

MarijaS · 07-28-2010, 03:17 AM

I can run processes once, and then put them in blocked (wait) state.

Actually, the problem is that the period of process A should be as much as it is possible accurate (5ms). For the process B it isn't so important. So I don't know what is the best way to deal with precision. Is it complicated to implement some other scheduler? It seems to me complicated...

I have created independent processes, each in one .cpp file, and I am starting them from bash file. Is that OK? Then I can try to use shared memory for inter-process communication?

bigearsbilly · 07-28-2010, 03:19 AM

OK try this. It uses the POSIX realtime library.

It's a silly toy to write independent counters to the terminal.
it may mess up your cursor.

It's a very very very scruffy work in progress example in C++, so apologies.
the key code is is the set_timer function.
esp. the:

Code:

    se.sigev_notify = SIGEV_THREAD;
    se.sigev_value.sival_ptr = data;
    se.sigev_notify_function = timer_thread;  # the callback
    se.sigev_notify_attributes = NULL;

compile like this:

Code:

 
export LDLIBS='-lrt -lpthreads'  # link realtime and pthreads
make timers.cpp

Code:

/*
 * (c) bigearsbilly
 *
 *    need LDLIBS =  -lrt -lpthread
 */
#include <pthread.h>
#include <signal.h>
#include <sys/time.h>
#include <cstdio>
#include <cstdlib>
#include <string>
#include <iostream>
#include <iomanip>

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;


struct blob {

    int row;
    int column;
    std::string buffer;
    size_t count;
    timer_t timer_id;

    blob(int r, int c, std::string s) :
		row(r), column(c), buffer(s), count(0) {};

    friend std::ostream& operator<< (std::ostream& out, blob & b) {

	out << '\033' << "[" << b.row << ";" << b.column <<
		"f" << b.buffer << b.count << std::flush;

	++b.count;
	return out;
    }

};

void timer_thread (union sigval si)
{

    blob* p = static_cast<blob *>(si.sival_ptr);

    if(si.sival_ptr) {
	pthread_mutex_lock(&mutex);
	std::cout << *p;
	pthread_mutex_unlock(&mutex);
    }
}

typedef void (t_callback) (union sigval si);

int set_timer(float delay, float interval, t_callback func, void * data) 
{
    int status =0;
    struct itimerspec ts;
    struct sigevent se;
    blob * b = static_cast<blob *>(data);

    se.sigev_notify = SIGEV_THREAD;
    se.sigev_value.sival_ptr = data;
    se.sigev_notify_function = timer_thread;
    se.sigev_notify_attributes = NULL;

    status = timer_create(CLOCK_REALTIME, &se, &(b->timer_id));

    ts.it_value.tv_sec = abs(delay);
    ts.it_value.tv_nsec = (delay-abs(delay)) * 1e09;
    ts.it_interval.tv_sec = abs(interval);
    ts.it_interval.tv_nsec = (interval-abs(interval)) * 1e09;

    status = timer_settime(b->timer_id, 0, &ts, 0);
    return 0;
}

int main(int argc, char ** argv)
{

    unsigned int timeout = 0;
    if(argc == 2) {
	timeout = atoi(argv[1]);
    }

    blob a(5,12,"seconds:");
    blob b(10,12,"tenths:");
    blob c(15,12,"hundredths:");
    blob d(20,12,"thousandths:");

    std::cout << '\033' << " L";
    std::cout << '\033' << "7";
    std::cout << '\033' << "[2J";
    std::cout << '\033' << "[?25l";

    set_timer(1, 1.0, timer_thread, &a );
    set_timer(1, 0.1, timer_thread, &b );
    set_timer(1, 0.01, timer_thread, &c );
    set_timer(1, 0.001, timer_thread, &d );

    getchar();
    std::cout << '\033' << "8";
    std::cout << '\033' << "[?25h";

    return 0;
}

p.s. you may find the thousands 'slip' as the timer overruns.

zirias · 07-28-2010, 03:23 AM

You can just test the alarm()/wait() approach, it should be "somwhat accurate" as long as the system isn't under heavy load. Just be sure to set the alarm() as the FIRST thing you do on each computational period, so you don't accidently add your own execution time to the period.

As for implementing an own scheduler: This is probably a LOT of trouble and only worthwile if you REALLY need TRUE realtime -- and you'll still face some problems like "stolen" cycles in management mode. If it's an embedded system whose realtime requirements are crucial for ppls health, go for it

MarijaS · 07-28-2010, 06:34 AM

Thank you!
For this time I'll skip TRUE realtime

and try to deal with your suggestions.

bigearsbilly · 07-28-2010, 01:43 PM

the timer_create and timer_settime examples
I posted are part of the POSIX realtime library.

here is a much simpler but less fun example...
don't forget to link -lrt -lpthread

Code:

/*
 * (c) bigearsbilly
 *
 *    need LDLIBS =  -lrt -lpthread
 */
#include <pthread.h>
#include <signal.h>
#include <sys/time.h>
#include <cstdio>
#include <cstdlib>
#include <string>
#include <iostream>
#include <iomanip>

using std::cout;
using std::cerr;
using std::endl;

typedef void (timer_callback) (union sigval);

int set_timer(timer_t * timer_id, float delay, float interval, timer_callback * func, void * data) 
{
    int status =0;
    struct itimerspec ts;
    struct sigevent se;

    se.sigev_notify = SIGEV_THREAD;
    se.sigev_value.sival_ptr = data;
    se.sigev_notify_function = func;
    se.sigev_notify_attributes = NULL;

    status = timer_create(CLOCK_REALTIME, &se, timer_id);

    ts.it_value.tv_sec = abs(delay);
    ts.it_value.tv_nsec = (delay-abs(delay)) * 1e09;
    ts.it_interval.tv_sec = abs(interval);
    ts.it_interval.tv_nsec = (interval-abs(interval)) * 1e09;

    status = timer_settime(*timer_id, 0, &ts, 0);
    return 0;
}

void callback(union sigval si)
{
    char * msg = (char *) si.sigval_ptr;
    std::cout << msg << std::endl;
}

int main(int argc, char ** argv)
{

    timer_t tick;
    timer_t tock;
    set_timer(&tick, 1, 1, callback, (void *) "tick" );
    set_timer(&tock, 1.5, 1, callback, (void *) "tock" );
    getchar();

    return 0;
}

but this is very simplistic, to get started.
you will need to read the documentation.

MarijaS · 07-29-2010, 06:46 AM

Thank you!
Beacuse this is my first time working with timers of the POSIX, for the beginning I did something very similar to your code. I just used SIGEV_SIGNAL instead of SIGEV_THREAD.
Compaling was successful. But running not. I have some errors in object file: Undefined reference to 'timer_create' and Undefined reference to 'timer_settime'.
I really don't know what is the problem...

dwhitney67 · 07-29-2010, 07:17 AM

You have to link your code the the real-time library; specifically, add -lrt to your GCC link statement. For example

Code:

gcc MyProg.c -lrt

bigearsbilly · 07-29-2010, 09:55 AM

Yes It took me lots of searching to get an idea of how to use
it. There is scant documentation on line.

:-) Undefined reference to 'timer_create' and Undefined reference to 'timer_settime'.

You also need pthread - it may compile
without but probably will break.

easy way to link the libraries is like this:

(assuming prog.cpp)

Code:

export LDLIBS='-lrt -lpthread'
make prog