117 lines
2.5 KiB
Plaintext
117 lines
2.5 KiB
Plaintext
include <condition_variable>
|
|
#include <iostream>
|
|
#include <mutex>
|
|
#include <string>
|
|
#include <thread>
|
|
|
|
std::mutex m;
|
|
std::condition_variable cv;
|
|
std::string data;
|
|
bool ready = false;
|
|
bool processed = false;
|
|
|
|
void worker_thread()
|
|
{
|
|
// wait until main() sends data
|
|
std::unique_lock lk(m);
|
|
cv.wait(lk, []{ return ready; });
|
|
|
|
// after the wait, we own the lock
|
|
std::cout << "Worker thread is processing data\n";
|
|
data += " after processing";
|
|
|
|
// send data back to main()
|
|
processed = true;
|
|
std::cout << "Worker thread signals data processing completed\n";
|
|
|
|
// manual unlocking is done before notifying, to avoid waking up
|
|
// the waiting thread only to block again (see notify_one for details)
|
|
lk.unlock();
|
|
cv.notify_one();
|
|
}
|
|
|
|
int main()
|
|
{
|
|
std::thread worker(worker_thread);
|
|
|
|
data = "Example data";
|
|
// send data to the worker thread
|
|
{
|
|
std::lock_guard lk(m);
|
|
ready = true;
|
|
std::cout << "main() signals data ready for processing\n";
|
|
}
|
|
cv.notify_one();
|
|
|
|
// wait for the worker
|
|
{
|
|
std::unique_lock lk(m);
|
|
cv.wait(lk, []{ return processed; });
|
|
}
|
|
std::cout << "Back in main(), data = " << data << '\n';
|
|
|
|
worker.join();
|
|
}
|
|
|
|
--------------------
|
|
|
|
// waiting for timeout after 5 seconds
|
|
std::chrono::seconds timeoutPeriod = 5;
|
|
auto timePoint = std::chrono::system_clock::now() + timeoutPeriod;
|
|
std::unique_lock<std::mutex> uLock(myDataMutex);
|
|
while(!DataAreReadyForProcessing())
|
|
{
|
|
if (myCondVar.wait_until(uLock, timePoint) //<##
|
|
== std::cv_status::timeout)
|
|
{
|
|
// data conditions where not fulfilled within
|
|
// the time period; e.g. do some error handling
|
|
break;
|
|
}
|
|
}
|
|
|
|
--
|
|
|
|
if (myCondVar.wait_for(uLock, timeoutPeriod,
|
|
DataAreReadyForProcessing))
|
|
{
|
|
// data conditions where fulfilled
|
|
// regular processing
|
|
}
|
|
else // timeout occured, conditions are not fulfilled
|
|
{
|
|
// e.g. do some error handling
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
-------------
|
|
|
|
|
|
static int rpmsg_sample_probe(struct rpmsg_device *rpdev)
|
|
{
|
|
|
|
int ret;
|
|
struct instance_data *idata;
|
|
|
|
dev_info(&rpdev->dev, "new channel: 0x%x -> 0x%x!\n",
|
|
rpdev->src, rpdev->dst);
|
|
|
|
idata = devm_kzalloc(&rpdev->dev, sizeof(*idata), GFP_KERNEL);
|
|
if (!idata)
|
|
return -ENOMEM;
|
|
|
|
dev_set_drvdata(&rpdev->dev, idata);
|
|
|
|
/* send a message to our remote processor */
|
|
ret = rpmsg_send(rpdev->ept, MSG, strlen(MSG));
|
|
if (ret) {
|
|
dev_err(&rpdev->dev, "rpmsg_send failed: %d\n", ret);
|
|
return ret;
|
|
}
|
|
|
|
return 0;
|