Use std::thread in thread_test.cc.
The STL already came up with a threading abstraction for us. If this
sticks, that also means we can more easily write tests elsewhere that
use threads. (A test that makes a bunch of TLS connections on a shared
SSL_CTX run under TSan would be nice. Likewise with some of the messy
RSA locking.)
Update-Note: This adds a dependency from crypto_test to C++11 threads.
Hopefully it doesn't cause issues.
Change-Id: I26f89f6b3b79240e516017877d06fd9a815fc315
Reviewed-on: https://boringssl-review.googlesource.com/28865
Reviewed-by: Steven Valdez <svaldez@google.com>
Commit-Queue: Steven Valdez <svaldez@google.com>
CQ-Verified: CQ bot account: commit-bot@chromium.org <commit-bot@chromium.org>
diff --git a/crypto/thread_test.cc b/crypto/thread_test.cc
index 2a6f60b..f89b22e 100644
--- a/crypto/thread_test.cc
+++ b/crypto/thread_test.cc
@@ -14,6 +14,9 @@
#include "internal.h"
+#include <chrono>
+#include <thread>
+
#include <gtest/gtest.h>
#include <openssl/crypto.h>
@@ -24,83 +27,30 @@
#if !defined(OPENSSL_NO_THREADS)
-#if defined(OPENSSL_WINDOWS)
-
-OPENSSL_MSVC_PRAGMA(warning(push, 3))
-#include <windows.h>
-OPENSSL_MSVC_PRAGMA(warning(pop))
-
-typedef HANDLE thread_t;
-
-static DWORD WINAPI thread_run(LPVOID arg) {
- void (*thread_func)(void);
- // VC really doesn't like casting between data and function pointers.
- OPENSSL_memcpy(&thread_func, &arg, sizeof(thread_func));
- thread_func();
- return 0;
-}
-
-static int run_thread(thread_t *out_thread, void (*thread_func)(void)) {
- void *arg;
- // VC really doesn't like casting between data and function pointers.
- OPENSSL_memcpy(&arg, &thread_func, sizeof(arg));
-
- *out_thread = CreateThread(NULL /* security attributes */,
- 0 /* default stack size */, thread_run, arg,
- 0 /* run immediately */, NULL /* ignore id */);
- return *out_thread != NULL;
-}
-
-static int wait_for_thread(thread_t thread) {
- return WaitForSingleObject(thread, INFINITE) == 0;
-}
-
-#else
-
-#include <pthread.h>
-#include <string.h>
-#include <time.h>
-
-typedef pthread_t thread_t;
-
-static void *thread_run(void *arg) {
- void (*thread_func)(void) = reinterpret_cast<void (*)(void)>(arg);
- thread_func();
- return NULL;
-}
-
-static int run_thread(thread_t *out_thread, void (*thread_func)(void)) {
- return pthread_create(out_thread, NULL /* default attributes */, thread_run,
- reinterpret_cast<void *>(thread_func)) == 0;
-}
-
-static int wait_for_thread(thread_t thread) {
- return pthread_join(thread, NULL) == 0;
-}
-
-#endif // OPENSSL_WINDOWS
-
static unsigned g_once_init_called = 0;
static void once_init(void) {
g_once_init_called++;
- // Sleep briefly so one |call_once_thread| instance will call |CRYPTO_once|
+ // Sleep briefly so one |call_once_func| instance will call |CRYPTO_once|
// while the other is running this function.
-#if defined(OPENSSL_WINDOWS)
- Sleep(1 /* milliseconds */);
-#else
- struct timespec req;
- OPENSSL_memset(&req, 0, sizeof(req));
- req.tv_nsec = 1000000;
- nanosleep(&req, NULL);
-#endif
+ std::this_thread::sleep_for(std::chrono::milliseconds(1));
}
static CRYPTO_once_t g_test_once = CRYPTO_ONCE_INIT;
-static void call_once_thread(void) {
+TEST(ThreadTest, Once) {
+ ASSERT_EQ(0u, g_once_init_called)
+ << "g_once_init_called was non-zero at start.";
+
+ auto call_once_func = [] { CRYPTO_once(&g_test_once, once_init); };
+ std::thread thread1(call_once_func), thread2(call_once_func);
+ thread1.join();
+ thread2.join();
+
CRYPTO_once(&g_test_once, once_init);
+
+ EXPECT_EQ(1u, g_once_init_called);
}
static CRYPTO_once_t once_init_value = CRYPTO_ONCE_INIT;
@@ -112,21 +62,6 @@
static CRYPTO_EX_DATA_CLASS ex_data_class_value = CRYPTO_EX_DATA_CLASS_INIT;
static CRYPTO_EX_DATA_CLASS ex_data_class_bss;
-TEST(ThreadTest, Once) {
- ASSERT_EQ(0u, g_once_init_called)
- << "g_once_init_called was non-zero at start.";
-
- thread_t thread1, thread2;
- ASSERT_TRUE(run_thread(&thread1, call_once_thread));
- ASSERT_TRUE(run_thread(&thread2, call_once_thread));
- ASSERT_TRUE(wait_for_thread(thread1));
- ASSERT_TRUE(wait_for_thread(thread2));
-
- CRYPTO_once(&g_test_once, once_init);
-
- EXPECT_EQ(1u, g_once_init_called);
-}
-
TEST(ThreadTest, InitZeros) {
if (FIPS_mode()) {
// Our FIPS tooling currently requires that |CRYPTO_ONCE_INIT|,
@@ -158,8 +93,7 @@
ASSERT_EQ(nullptr, CRYPTO_get_thread_local(OPENSSL_THREAD_LOCAL_TEST))
<< "Thread-local data was non-NULL at start.";
- thread_t thread;
- ASSERT_TRUE(run_thread(&thread, []() {
+ std::thread thread([] {
if (CRYPTO_get_thread_local(OPENSSL_THREAD_LOCAL_TEST) != NULL ||
!CRYPTO_set_thread_local(OPENSSL_THREAD_LOCAL_TEST,
&g_destructor_called_count,
@@ -170,16 +104,16 @@
}
g_test_thread_ok = 1;
- }));
- ASSERT_TRUE(wait_for_thread(thread));
+ });
+ thread.join();
EXPECT_TRUE(g_test_thread_ok) << "Thread-local data didn't work in thread.";
EXPECT_EQ(1u, g_destructor_called_count);
- // Create a no-op thread to test test that the thread destructor function
- // works even if thread-local storage wasn't used for a thread.
- ASSERT_TRUE(run_thread(&thread, []() {}));
- ASSERT_TRUE(wait_for_thread(thread));
+ // Create a no-op thread to test that the thread destructor function works
+ // even if thread-local storage wasn't used for a thread.
+ thread = std::thread([] {});
+ thread.join();
}
TEST(ThreadTest, RandState) {
@@ -189,12 +123,11 @@
uint8_t buf[1];
RAND_bytes(buf, sizeof(buf));
- thread_t thread;
- ASSERT_TRUE(run_thread(&thread, []() {
+ std::thread thread([] {
uint8_t buf2[1];
RAND_bytes(buf2, sizeof(buf2));
- }));
- ASSERT_TRUE(wait_for_thread(thread));
+ });
+ thread.join();
}
#endif // !OPENSSL_NO_THREADS
