CODEWITHSUNDEEP
c++
Jorge Vega Sánchez
Jorge Vega Sánchez

Reputation: 7590

Save data periodically during execution

I have a program which executes constantly and I need to save data every minute.

The program process data and every minute I want to save the value of a variable and do some statistical operations to know the variation of this variable.

I thought i can make it with a signal, SIGALRM and alarm(60). My subquestion is, can I put a class method as the destiny method for SIGALRM?

Any other idea to execute a method to save data and do some operations every minute ??

The program is written in C++, runs in Linux an a mono-core processor.

Upvotes: 1

Views: 541

Answers (3)

R.. GitHub STOP HELPING ICE
R.. GitHub STOP HELPING ICE

Reputation: 215287

Saving data from a signal handler is a very bad idea. Even if open and write are async-signal-safe, your data could very well be in an inconsistent state due to a signal interrupting a function that was modifying it.

A much better approach would be to add to all functions which modify the data:

if (current_time > last_save_time + 60) save();

This will avoid useless saves when the data has not been modified, too. If you don't want the overhead of making a system call to determine the current time on every operation, you could instead install a timer/signal handler that updates current_time, as long as you declare it volatile.

Another good approach would be to use threads instead of signals. Then you should use a mutex (or better, rwlock) to synchronize access to the data.

Upvotes: 2

Damon
Damon

Reputation: 70166

Your solution using alarm will work, both open and write being asynchronous-signal-safe. Though you have to be aware that interactions between alarm and sleep are undefined, so don't use them in the same program.

A different solution, especially in case you already use an epoll, would be to have a timerfd trigger the epoll. That will avoid possible undefined interactions.

As for the actual saving, consider forking. This is a technique that I learned from redis (maybe someone else invented it, but that's where I learned it from), and which I consider totally cool. The point being that the forked process can take all time in the universe to finish writing as much data as you want to disk. It can access the snapshot at the time of forking while the other process keeps running and modifying data. And thanks to page magic done in the kernel, it still all works seamlessly without any risk of corruption, without ever stalling, and without ever needing to look at something like asynchronous IO, which is great.

Upvotes: 4

Arkaitz Jimenez
Arkaitz Jimenez

Reputation: 23188

You can call a class method using something like boost bind

Apart from that I wouldn't recommend to use signals for that, they are not that reliable, and could, for example, make one of your syscalls to return prematurely.

I would spawn a thread, assuming your monocore doesn't mean no threads, that waits 60 seconds, takes locks, makes calcs, outputs and releases locks.

As they have already suggested, if you have an async compatible system(driven by events) you could use timerfd to generate events.

Upvotes: 2

Related Questions