Pause and resume a c++ function - c++

Question

I'm facing a problem in programmation where I did not find any convenient and fast execution solutions.
I'm trying to implement some kind of state machine : take one byte in entry, process it, change state, loop, etc... The purpose is to process byte stream without requiring any memory buffer (processing byte per byte).
The class should looks like this :
class Decoder {
void next() {
int i = 0;
std::cout << i << "\n";
i++;
yield(); // pseudo code => should stop the function and save the current state (or simply not freeing allocated variables)
std::cout << i << "\n";
}
};
Decoder decoder = Decoder();
decoder.next(); // print 1
std::cout << "1.5" << "\n"; // print 1.5
decoder.next(); // print 2
A solution could be to create a step property to save the step and then resume with a switch but the performances would be strongly impacted. I would like to know if there is a way to exit the execution of a function and then resume it later ?
To be clear, I don't want to pause the entire program, only a function. Pausing such a function would return to the caller and continue the execution of the program until the next next is called.
Moreover, I would like to avoid thread and std as much (I prefer all environnements code). Finally, if you have any other alternatives to my problem : process byte stream efficiently for the memory, I'm open to your suggestions.
Thanks for your help.

Answer 1

I believe you could achieve just that using these two ways:
Option 1: Member state
Split the state machine object into a separate object, and convert all your local variables to members.
For each step of the way, save a State member, signifying where are you now throughout the execution of your program.
Each time you enter next() check your state against a switch and call the designated inner method for that step.
Each such step method simulates code execution between to consecutive yields.
struct Decoder {
void next() {
switch (_step) {
case s1:
step1();
_step = s2;
return;
case s2:
step2();
_step = s1;
return;
default:
return; // handle error...
}
}
private:
enum Step { s1, s2 };
Step _step = s1;
int _i = 1;
void step1() {
std::cout << _i << "\n";
_i++;
}
void step2() {
std::cout << _i << "\n";
}
};
int main() {
Decoder decoder = Decoder();
decoder.next(); // print 1
std::cout << "1.5" << "\n"; // print 1.5
decoder.next(); // print 2
}
Option 2: Thread and signalling
Use a thread, which you could of course run using native APIs (e.g. pthread_create on POSIX platforms).
Inside your thread, every time you want to yield, wait on a conditional variable, e.g:
struct Decoder {
Decoder() {
_thread = std::thread { &Decoder::worker, this };
}
~Decoder() {
_thread.join();
}
void next() {
std::lock_guard<std::mutex> lock(_mutex);
_work = true;
}
private:
void wait() {
std::unique_lock<std::mutex> lock(_mutex);
_cond.wait(lock, [this](){return _work;});
}
void worker() {
wait();
int i = 0;
std::cout << i << "\n";
i++;
wait();
std::cout << i << "\n";
}
std::thread _thread;
std::mutex _mutex;
std::condition_variable _cond;
bool _work = false;
};
int main() {
Decoder decoder;
decoder.next(); // print 1
std::cout << "1.5" << "\n"; // print 1.5
decoder.next(); // print 2
}