2017-08-23 19:53:20 -04:00
|
|
|
#include <iostream>
|
2017-09-28 10:55:17 -04:00
|
|
|
#include <sstream>
|
2017-08-23 19:53:20 -04:00
|
|
|
#include <thread>
|
|
|
|
#include <mutex>
|
2017-09-28 14:18:29 -04:00
|
|
|
#include "freertos/FreeRTOS.h"
|
|
|
|
#include "freertos/task.h"
|
2017-08-23 19:53:20 -04:00
|
|
|
#include "unity.h"
|
|
|
|
|
2017-08-31 19:18:14 -04:00
|
|
|
#if __GTHREADS && __GTHREADS_CXX0X
|
|
|
|
|
2017-09-28 10:55:17 -04:00
|
|
|
#include "esp_log.h"
|
|
|
|
const static char *TAG = "pthread_test";
|
|
|
|
|
2017-08-31 19:18:14 -04:00
|
|
|
static std::mutex mtx;
|
2019-12-18 19:01:06 -05:00
|
|
|
static std::shared_ptr<int> global_sp_mtx; // protected by mux
|
|
|
|
|
2017-08-31 19:18:14 -04:00
|
|
|
static std::recursive_mutex recur_mtx;
|
2019-12-18 19:01:06 -05:00
|
|
|
static std::shared_ptr<int> global_sp_recur_mtx; // protected by recursive mux
|
2017-08-23 19:53:20 -04:00
|
|
|
|
2017-08-25 14:24:17 -04:00
|
|
|
static void thread_do_nothing() {}
|
|
|
|
|
|
|
|
static void thread_main()
|
|
|
|
{
|
2017-08-24 15:52:49 -04:00
|
|
|
std::cout << "thread_main CXX " << std::hex << std::this_thread::get_id() << std::endl;
|
2019-12-18 19:01:06 -05:00
|
|
|
std::chrono::milliseconds dur = std::chrono::milliseconds(10);
|
|
|
|
|
|
|
|
for (int i = 0; i < 10; i++) {
|
|
|
|
for (int j = 0; j < 10; j++) {
|
|
|
|
int old_val, new_val;
|
|
|
|
|
|
|
|
// mux test
|
|
|
|
mtx.lock();
|
|
|
|
old_val = *global_sp_mtx;
|
|
|
|
std::this_thread::yield();
|
|
|
|
(*global_sp_mtx)++;
|
|
|
|
std::this_thread::yield();
|
|
|
|
new_val = *global_sp_mtx;
|
|
|
|
mtx.unlock();
|
|
|
|
std::cout << "thread " << std::hex << std::this_thread::get_id() << ": nrec " << i << " val= " << *global_sp_mtx << std::endl;
|
|
|
|
TEST_ASSERT_EQUAL(old_val + 1, new_val);
|
|
|
|
|
|
|
|
// sleep_for test
|
|
|
|
std::this_thread::sleep_for(dur);
|
|
|
|
|
|
|
|
// recursive mux test
|
|
|
|
recur_mtx.lock();
|
|
|
|
recur_mtx.lock();
|
|
|
|
old_val = *global_sp_recur_mtx;
|
|
|
|
std::this_thread::yield();
|
|
|
|
(*global_sp_recur_mtx)++;
|
|
|
|
std::this_thread::yield();
|
|
|
|
new_val = *global_sp_recur_mtx;
|
|
|
|
recur_mtx.unlock();
|
|
|
|
recur_mtx.unlock();
|
|
|
|
std::cout << "thread " << std::hex << std::this_thread::get_id() << ": rec " << i << " val= " << *global_sp_recur_mtx << std::endl;
|
|
|
|
TEST_ASSERT_EQUAL(old_val + 1, new_val);
|
|
|
|
}
|
2017-08-25 14:24:17 -04:00
|
|
|
|
|
|
|
// sleep_until test
|
2017-08-31 19:18:14 -04:00
|
|
|
using std::chrono::system_clock;
|
|
|
|
std::time_t tt = system_clock::to_time_t(system_clock::now());
|
|
|
|
struct std::tm *ptm = std::localtime(&tt);
|
|
|
|
ptm->tm_sec++;
|
2017-11-14 03:43:32 -05:00
|
|
|
std::this_thread::sleep_until(system_clock::from_time_t(mktime(ptm)));
|
2017-08-23 19:53:20 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-09-28 14:18:29 -04:00
|
|
|
TEST_CASE("pthread C++", "[pthread]")
|
2017-08-23 19:53:20 -04:00
|
|
|
{
|
2019-12-18 19:01:06 -05:00
|
|
|
global_sp_mtx.reset(new int(1));
|
|
|
|
global_sp_recur_mtx.reset(new int(-1000));
|
2017-08-25 14:24:17 -04:00
|
|
|
|
|
|
|
std::thread t1(thread_do_nothing);
|
|
|
|
t1.join();
|
|
|
|
|
2017-08-24 15:52:49 -04:00
|
|
|
std::thread t2(thread_main);
|
2017-08-25 14:24:17 -04:00
|
|
|
std::cout << "Detach thread " << std::hex << t2.get_id() << std::endl;
|
|
|
|
t2.detach();
|
|
|
|
TEST_ASSERT_FALSE(t2.joinable());
|
|
|
|
|
|
|
|
std::thread t3(thread_main);
|
|
|
|
std::thread t4(thread_main);
|
2021-06-15 20:43:21 -04:00
|
|
|
TEST_ASSERT(t3.joinable());
|
|
|
|
TEST_ASSERT(t4.joinable());
|
|
|
|
std::cout << "Join thread " << std::hex << t3.get_id() << std::endl;
|
|
|
|
t3.join();
|
|
|
|
std::cout << "Join thread " << std::hex << t4.get_id() << std::endl;
|
|
|
|
t4.join();
|
|
|
|
|
|
|
|
// we don't know if/when t2 has finished, so delay another 2s before
|
|
|
|
// deleting the common mutexes
|
|
|
|
std::this_thread::sleep_for(std::chrono::seconds(2));
|
2017-10-04 02:30:10 -04:00
|
|
|
|
2019-12-18 19:01:06 -05:00
|
|
|
global_sp_mtx.reset(); // avoid reported leak
|
|
|
|
global_sp_recur_mtx.reset();
|
2017-08-23 19:53:20 -04:00
|
|
|
}
|
2017-08-31 19:18:14 -04:00
|
|
|
|
2017-11-14 03:43:32 -05:00
|
|
|
static void task_test_sandbox()
|
2017-09-28 14:18:29 -04:00
|
|
|
{
|
2017-11-14 03:43:32 -05:00
|
|
|
std::stringstream ss;
|
2017-09-28 14:18:29 -04:00
|
|
|
|
2017-09-28 10:55:17 -04:00
|
|
|
ESP_LOGI(TAG, "About to create a string stream");
|
|
|
|
ESP_LOGI(TAG, "About to write to string stream");
|
|
|
|
ss << "Hello World!";
|
2017-09-28 14:18:29 -04:00
|
|
|
ESP_LOGI(TAG, "About to extract from stringstream");
|
|
|
|
ESP_LOGI(TAG, "Text: %s", ss.str().c_str());
|
2017-11-14 03:43:32 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
static void task_test_sandbox_c(void *arg)
|
|
|
|
{
|
|
|
|
bool *running = (bool *)arg;
|
|
|
|
|
|
|
|
// wrap thread func to ensure that all C++ stack objects are cleaned up by their destructors
|
|
|
|
task_test_sandbox();
|
2017-09-28 14:18:29 -04:00
|
|
|
|
2017-11-14 03:43:32 -05:00
|
|
|
ESP_LOGI(TAG, "Task stk_wm = %d", uxTaskGetStackHighWaterMark(NULL));
|
2017-09-28 14:18:29 -04:00
|
|
|
if (running) {
|
|
|
|
*running = false;
|
|
|
|
vTaskDelete(NULL);
|
|
|
|
}
|
2017-09-28 10:55:17 -04:00
|
|
|
}
|
|
|
|
|
2017-09-28 14:18:29 -04:00
|
|
|
TEST_CASE("pthread mix C/C++", "[pthread]")
|
2017-09-28 10:55:17 -04:00
|
|
|
{
|
2017-11-14 03:43:32 -05:00
|
|
|
bool c_running = true;
|
2017-09-28 14:18:29 -04:00
|
|
|
|
2017-11-14 03:43:32 -05:00
|
|
|
std::thread t1(task_test_sandbox);
|
|
|
|
xTaskCreatePinnedToCore((TaskFunction_t)&task_test_sandbox_c, "task_test_sandbox", 3072, &c_running, 5, NULL, 0);
|
|
|
|
while (c_running) {
|
2017-09-28 14:18:29 -04:00
|
|
|
vTaskDelay(1);
|
|
|
|
}
|
2017-09-28 10:55:17 -04:00
|
|
|
if (t1.joinable()) {
|
|
|
|
std::cout << "Join thread " << std::hex << t1.get_id() << std::endl;
|
|
|
|
t1.join();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-08-31 19:18:14 -04:00
|
|
|
#endif
|