C++ accurately do action in "every" 100 microsecond without pausing - c++

Question

I writing a program that needs to loop regularly 100 microsecond for one loop. I have found the to loop regularly in a fixed time. But I find a problem when the time for looping is set to be too small.
The following demo code (not complete code) is to:
Increment the count every 100 microsecond.
Show the count every 1 second.
The expected result is showing approximately 10000 every second.
But the result shows about four thousand a second.
void f2(int input)
{
auto start = std::chrono::system_clock::now();
auto displayStart = std::chrono::system_clock::now();
while(true){ //keep looping quickly
auto now = std::chrono::system_clock::now();
auto interval = std::chrono::duration_cast<std::chrono::microseconds>(now - start);
if ( interval.count() > input){ //if 100 microsecond do
count++;
start = std::chrono::system_clock::now();
}
auto displayNow = std::chrono::system_clock::now();
auto displayInterval = std::chrono::duration_cast<std::chrono::microseconds>(displayNow - displayStart);
if ( displayInterval.count() > 1000000){ //if 1 second do
std::cout<< "1 second count: "<<count<<std::endl;
count=0;
displayStart = std::chrono::system_clock::now();
}
}
}
After that I think CPU scheduling may be the problem for this. I have checked the program works normally in every loop . Each iteration takes about 100 microseconds which is accurate. But problem may occur when program/thread is paused and wait for CPU rescheduling.
For example, and lets magnify the value for clearer illustration. The thread paused for 1 second. Normally it will increment for 10000 times. But now, for next iteration it check for >100 microsecond, so count++ and counter is reset as 1 second is passed. For this case, the count incremented only for 1.
With the following code I modified, I can finish 10000 count++ in a second. But the problem is those 10000 count is not evenly distributed in one second. Because this is only the demo program for testing. The action I actually want is to accurately do action in every 100 microsecond. But due to the pausing of thread, I still not find the solution to solve this.
void f2(int input)
{
auto start = std::chrono::system_clock::now();
auto displayStart = std::chrono::system_clock::now();
while(true){ //keep looping quickly
auto now = std::chrono::system_clock::now();
auto interval = std::chrono::duration_cast<std::chrono::microseconds>(now - start);
if ( interval.count() > input){ //if 100 microsecond do
for(int i=0;i<interval.count()/input;i++){ //modified part
count++;
}
start = std::chrono::system_clock::now();
}
auto displayNow = std::chrono::system_clock::now();
auto displayInterval = std::chrono::duration_cast<std::chrono::microseconds>(displayNow - displayStart);
if ( displayInterval.count() > 1000000){ //if 1 second do
std::cout<< "1 second count: "<<count<<std::endl;
count=0;
displayStart = std::chrono::system_clock::now();
}
}
}
Is there any way like:
eg. make process non pause. Keep it in CPU (not so possible)
to make the counting action in demo program works every 100 microseconds?
Thank you very much

Answer 1

Have N buckets, where N is large enough that scheduling delay won't be a problem.
Keep track of the last time your decay code ran.
When a new packet "goes out", put it in a bucket based on the last time your decay code ran (if less than 100 ms, bucket 0, if 200 ms, bucket 1, etc).
When your decay code runs, calculate the current value after decaying everything properly and update the timestamp.
Note that contention (the thread updating and the thread decaying) will remain a problem. You can fix this to some extent with double or triple buffering of the counters, atomic flags and pointers, and busy-loops in the non-performance-sensitive code (say, the decay code).
Alternatively, instead of recording counts, record time stamps. Consume the buffer of time stamps, doing decay at that point. Similar issues involving size of buffer and multiple threads remain, with similar solutions.
Alternatively, do the decay math in the code that is doing the counting.