blob: 40836842a7f7c972b5aa7fc8707e159b4a58de9d [file] [log] [blame]
// Copyright 2015 Google Inc. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include "starboard/thread.h"
#include "testing/gtest/include/gtest/gtest.h"
namespace starboard {
namespace nplb {
namespace {
struct ThreadLocalValue {
ThreadLocalValue() : destroyed(false) {}
bool destroyed;
};
struct Context {
Context() : key(), in_value(), out_value(), destroyed_before_exit(false) {}
SbThreadLocalKey key;
void* in_value;
void* out_value;
bool destroyed_before_exit;
};
void DestroyThreadLocalValue(void* value) {
ThreadLocalValue* thread_local_value = static_cast<ThreadLocalValue*>(value);
thread_local_value->destroyed = true;
}
void* EntryPoint(void* context) {
Context* real_context = static_cast<Context*>(context);
SbThreadSetLocalValue(real_context->key, real_context->in_value);
real_context->out_value = SbThreadGetLocalValue(real_context->key);
ThreadLocalValue* thread_local_value =
static_cast<ThreadLocalValue*>(real_context->out_value);
real_context->destroyed_before_exit = thread_local_value->destroyed;
return NULL;
}
void DoSunnyDayTest(bool use_destructor) {
const int kThreads = 16;
ThreadLocalValue values[kThreads];
Context contexts[kThreads];
SbThread threads[kThreads];
ThreadLocalValue my_value;
SbThreadLocalKey key =
SbThreadCreateLocalKey(use_destructor ? DestroyThreadLocalValue : NULL);
EXPECT_TRUE(SbThreadIsValidLocalKey(key));
SbThreadSetLocalValue(key, &my_value);
for (int i = 0; i < kThreads; ++i) {
contexts[i].key = key;
contexts[i].in_value = &values[i];
}
for (int i = 0; i < kThreads; ++i) {
threads[i] = SbThreadCreate(0, kSbThreadNoPriority, kSbThreadNoAffinity,
true, NULL, EntryPoint, &contexts[i]);
}
for (int i = 0; i < kThreads; ++i) {
EXPECT_TRUE(SbThreadIsValid(threads[i]));
EXPECT_TRUE(SbThreadJoin(threads[i], NULL));
EXPECT_EQ(contexts[i].in_value, contexts[i].out_value);
// The destructor for all thread-local values will be called at thread exit
// time.
EXPECT_FALSE(contexts[i].destroyed_before_exit);
if (use_destructor) {
EXPECT_TRUE(values[i].destroyed);
} else {
EXPECT_FALSE(values[i].destroyed);
}
}
EXPECT_FALSE(my_value.destroyed);
SbThreadDestroyLocalKey(key);
// The destructor will never be called on my_value.
EXPECT_FALSE(my_value.destroyed);
}
// Helper function that ensures that the returned key is not recycled.
SbThreadLocalKey CreateTLSKey_NoRecycle(SbThreadLocalDestructor dtor) {
SbThreadLocalKey key = SbThreadCreateLocalKey(NULL);
EXPECT_EQ(NULL, SbThreadGetLocalValue(key));
// Some Starboard implementations may recycle the original key, so this test
// ensures that in that case it will be reset to NULL.
SbThreadSetLocalValue(key, reinterpret_cast<void*>(1));
SbThreadDestroyLocalKey(key);
key = SbThreadCreateLocalKey(DestroyThreadLocalValue);
return key;
}
// Tests the expectation that thread at-exit destructors don't
// run for ThreadLocal pointers that are set to NULL.
TEST(SbThreadLocalValueTest, NoDestructorsForNullValue) {
static int s_num_destructor_calls = 0; // Must be initialized to 0.
s_num_destructor_calls = 0; // Allows test to be re-run.
// Thread functionality needs to bind to functions. In C++11 we'd use a
// lambda function to tie everything together locally, but this
// function-scoped struct with static members emulates this functionality
// pretty well.
struct LocalStatic {
// Used as a fake destructor for thread-local-storage objects in this
// test.
static void CountsDestructorCalls(void* /*value*/) {
s_num_destructor_calls++;
}
// Sets a thread local non-NULL value, and then sets it back to NULL.
static void* ThreadEntryPoint(void* ptr) {
SbThreadLocalKey key = *static_cast<SbThreadLocalKey*>(ptr);
EXPECT_EQ(NULL, SbThreadGetLocalValue(key));
// Set the value and then NULL it out. We expect that because the final
// value set was NULL, that the destructor attached to the thread's
// at-exit function will not run.
SbThreadSetLocalValue(key, reinterpret_cast<void*>(1));
SbThreadSetLocalValue(key, NULL);
return NULL;
}
};
// Setup the thread key and bind the fake test destructor.
SbThreadLocalKey key =
CreateTLSKey_NoRecycle(LocalStatic::CountsDestructorCalls);
EXPECT_EQ(NULL, SbThreadGetLocalValue(key));
// Spawn the thread.
SbThread thread = SbThreadCreate(
0, // Signals automatic thread stack size.
kSbThreadNoPriority, // Signals default priority.
kSbThreadNoAffinity, // Signals default affinity.
true, // joinable thread.
"TestThread",
LocalStatic::ThreadEntryPoint,
static_cast<void*>(&key));
ASSERT_NE(kSbThreadInvalid, thread) << "Thread creation not successful";
// 2nd param is return value from ThreadEntryPoint, which is always NULL.
ASSERT_TRUE(SbThreadJoin(thread, NULL));
// No destructors should have run.
EXPECT_EQ(0, s_num_destructor_calls);
SbThreadDestroyLocalKey(key);
}
TEST(SbThreadLocalValueTest, SunnyDay) {
DoSunnyDayTest(true);
}
TEST(SbThreadLocalValueTest, SunnyDayNoDestructor) {
DoSunnyDayTest(false);
}
TEST(SbThreadLocalValueTest, SunnyDayFreshlyCreatedValuesAreNull) {
SbThreadLocalKey key = CreateTLSKey_NoRecycle(NULL); // NULL dtor.
EXPECT_EQ(NULL, SbThreadGetLocalValue(key));
EXPECT_EQ(NULL, SbThreadGetLocalValue(key));
SbThreadDestroyLocalKey(key);
}
TEST(SbThreadLocalValueTest, SunnyDayMany) {
const int kMany = (2 * SB_MAX_THREAD_LOCAL_KEYS) / 3;
SbThreadLocalKey keys[kMany];
for (int i = 0; i < kMany; ++i) {
keys[i] = SbThreadCreateLocalKey(NULL);
EXPECT_TRUE(SbThreadIsValidLocalKey(keys[i])) << "key #" << i;
}
for (int i = 0; i < kMany; ++i) {
SbThreadDestroyLocalKey(keys[i]);
}
}
} // namespace
} // namespace nplb
} // namespace starboard