blob: 000c6f4056adf49f18f7835d87d925956eca5bd1 [file] [log] [blame]
// Copyright 2016 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
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// See the License for the specific language governing permissions and
// limitations under the License.
#include <map>
#include <string>
#include "nb/thread_local_object.h"
#include "nb/scoped_ptr.h"
#include "starboard/mutex.h"
#include "starboard/thread.h"
#include "testing/gtest/include/gtest/gtest.h"
namespace base {
namespace {
// Similar to C++11 std::atomic<T>.
// Atomic<T> may be instantiated with any TriviallyCopyable type T.
// Atomic<T> is neither copyable nor movable.
// TODO: Lift this class out into the library.
template <typename T>
class Atomic {
// C++11 forbids a copy constructor for std::atomic<T>, it also forbids
// a move operation.
Atomic() : value_() {}
explicit Atomic(T v) : value_(v) {}
// Checks whether the atomic operations on all objects of this type
// are lock-free.
// Returns true if the atomic operations on the objects of this type
// are lock-free, false otherwise.
// All atomic types may be implemented using mutexes or other locking
// operations, rather than using the lock-free atomic CPU instructions.
// Atomic types are also allowed to be sometimes lock-free, e.g. if only
// aligned memory accesses are naturally atomic on a given architecture,
// misaligned objects of the same type have to use locks.
bool is_lock_free() const { return false; }
bool is_lock_free() const volatile { return false; }
// Atomically replaces the value of the atomic object
// and returns the value held previously.
T Swap(T new_val) {
int old_value = -1;
starboard::ScopedLock lock(mutex_);
old_value = value_;
value_ = new_val;
return old_value;
// Atomically obtains the value of the atomic object.
T Get() const {
starboard::ScopedLock lock(mutex_);
return value_;
// Returns the new updated value after the operation has been applied.
T Add(T val) {
starboard::ScopedLock lock(mutex_);
value_ += val;
return value_;
// TrySwap(...) sets the new value if and only if "expected_old_value"
// matches the actual value during the atomic assignment operation. If this
// succeeds then true is returned. If there is a mismatch then the value is
// left unchanged and false is returned.
// Inputs:
// new_value: Attempt to set the value to this new value.
// expected_old_value: A test condition for success. If the actual value
// matches the expected_old_value then the swap will succeed.
// optional_actual_value: If non-null, then the actual value at the time
// of the attempted operation is set to this value.
bool TrySwap(T new_value, T expected_old_value,
T* optional_actual_value) {
starboard::ScopedLock lock(mutex_);
if (optional_actual_value) {
*optional_actual_value = value_;
if (expected_old_value == value_) {
value_ = new_value;
return true;
return false;
T value_;
starboard::Mutex mutex_;
// Simple atomic int class. This could be optimized for speed using
// compiler intrinsics for concurrent integer modification.
class AtomicInt : public Atomic<int> {
AtomicInt() : Atomic<int>(0) {}
explicit AtomicInt(int initial_val) : Atomic<int>(initial_val) {}
void Increment() { Add(1); }
void Decrement() { Add(-1); }
// Simple atomic bool class. This could be optimized for speed using
// compiler intrinsics for concurrent integer modification.
class AtomicBool : public Atomic<bool> {
AtomicBool() : Atomic<bool>(false) {}
explicit AtomicBool(bool initial_val) : Atomic<bool>(initial_val) {}
// AbstractTestThread that is a bare bones class wrapper around Starboard
// thread. Subclasses must override Run().
// TODO: Move this to nplb/thread_helpers.h
class AbstractTestThread {
explicit AbstractTestThread() : thread_(kSbThreadInvalid) {}
virtual ~AbstractTestThread() {}
// Subclasses should override the Run method.
virtual void Run() = 0;
// Calls SbThreadCreate() with default parameters.
void Start() {
SbThreadEntryPoint entry_point = ThreadEntryPoint;
thread_ = SbThreadCreate(
0, // default stack_size.
kSbThreadNoPriority, // default priority.
kSbThreadNoAffinity, // default affinity.
true, // joinable.
if (kSbThreadInvalid == thread_) {
ADD_FAILURE_AT(__FILE__, __LINE__) << "Invalid thread.";
void Join() {
if (!SbThreadJoin(thread_, NULL)) {
ADD_FAILURE_AT(__FILE__, __LINE__) << "Could not join thread.";
static void* ThreadEntryPoint(void* ptr) {
AbstractTestThread* this_ptr = static_cast<AbstractTestThread*>(ptr);
return NULL;
SbThread thread_;
// Simple class that counts the number of instances alive.
struct CountsInstances {
CountsInstances() { s_instances_.Increment(); }
~CountsInstances() { s_instances_.Decrement(); }
static AtomicInt s_instances_;
static int NumInstances() { return s_instances_.Get(); }
static void ResetNumInstances() { s_instances_.Swap(0); }
AtomicInt CountsInstances::s_instances_(0);
// A simple thread that just creates the an object from the supplied
// ThreadLocalObject<T> and then exits.
template <typename TYPE>
class CreateThreadLocalObjectThenExit : public AbstractTestThread {
explicit CreateThreadLocalObjectThenExit(
ThreadLocalObject<TYPE>* tlo) : tlo_(tlo) {}
virtual void Run() {
// volatile as a defensive measure to prevent compiler from optimizing this
// statement out.
volatile TYPE* val = tlo_->GetOrCreate();
ThreadLocalObject<TYPE>* tlo_;
// A simple thread that just deletes the object supplied on a thread and then
// exists.
template <typename TYPE>
class DestroyTypeOnThread : public AbstractTestThread {
explicit DestroyTypeOnThread(TYPE* ptr)
: ptr_(ptr) {}
virtual void Run() {
ptr_.reset(NULL); // Destroys the object.
nb::scoped_ptr<TYPE> ptr_;
// Tests the expectation that a ThreadLocalObject can be simply used by
// the main thread.
TEST(ThreadLocalObject, MainThread) {
ThreadLocalObject<bool> tlo_bool;
EXPECT_TRUE(NULL == tlo_bool.GetIfExists());
bool* the_bool = tlo_bool.GetOrCreate();
EXPECT_TRUE(the_bool != NULL);
*the_bool = true;
// Tests the expectation that a ThreadLocalObject can be used on
// complex objects type (i.e. non pod types).
TEST(ThreadLocalObject, MainThreadComplexObject) {
typedef std::map<std::string, int> Map;
ThreadLocalObject<Map> map_tlo;
Map* map = map_tlo.GetIfExists();
const Map* const_map = map_tlo.GetIfExists();
// If the object is properly constructed then this find operation
// should succeed.
(*map)["my string"] = 15;
ASSERT_EQ(15, (*map)["my string"]);
// Tests that when a ThreadLocalObject is destroyed on the main thread that
// the pointers it contained are also destroyed.
TEST(ThreadLocalObject, DestroysObjectOnTLODestruction) {
typedef ThreadLocalObject<CountsInstances> TLO;
// Create the TLO object and then immediately destroy it.
nb::scoped_ptr<TLO> tlo_ptr(new TLO);
tlo_ptr->GetOrCreate(); // Instantiate the internal object.
EXPECT_EQ(1, CountsInstances::NumInstances());
tlo_ptr.reset(NULL); // Should destroy all outstanding allocs.
// Now the TLO is destroyed and therefore the destructor should run on the
// internal object.
EXPECT_EQ(0, CountsInstances::NumInstances());
// Tests the expectation that the object can be released and that the pointer
// won't be deleted when the ThreadLocalObject that created it is destroyed.
TEST(ThreadLocalObject, ReleasesObject) {
typedef ThreadLocalObject<CountsInstances> TLO;
nb::scoped_ptr<TLO> tlo_ptr(new TLO);
// Instantiate the internal object.
// Now release the pointer into the container.
nb::scoped_ptr<CountsInstances> last_ref(tlo_ptr->Release());
// Destroying the TLO should not trigger the destruction of the object,
// because it was released.
// 1 instance left, which is held in last_ref.
EXPECT_EQ(1, CountsInstances::NumInstances());
last_ref.reset(NULL); // Now the object should be destroyed and the
// instance count drops to 0.
EXPECT_EQ(0, CountsInstances::NumInstances());
// Tests the expectation that a thread that creates an object from
// the ThreadLocalObject store will automatically be destroyed by the
// thread joining.
TEST(ThreadLocalObject, ThreadJoinDestroysObject) {
typedef ThreadLocalObject<CountsInstances> TLO;
nb::scoped_ptr<TLO> tlo(new TLO);
AbstractTestThread* thread =
new CreateThreadLocalObjectThenExit<CountsInstances>(tlo.get());
// Once the thread joins, the object should be deleted and the instance
// counter falls to 0.
EXPECT_EQ(0, CountsInstances::NumInstances());
delete thread;
tlo.reset(NULL); // Now TLO destructor runs.
EXPECT_EQ(0, CountsInstances::NumInstances());
// Tests the expectation that objects created on the main thread are not
// leaked.
TEST(ThreadLocalObject, NoLeaksOnMainThread) {
ThreadLocalObject<CountsInstances>* tlo =
new ThreadLocalObject<CountsInstances>;
// Creates the object on the main thread. This is important because the
// main thread will never join and therefore at-exit functions won't get
// run.
CountsInstances* main_thread_object = tlo->GetOrCreate();
EXPECT_EQ(1, CountsInstances::NumInstances());
// Thread will simply create the thread local object (CountsInstances)
// and then return.
nb::scoped_ptr<AbstractTestThread> thread_ptr(
new CreateThreadLocalObjectThenExit<CountsInstances>(tlo));
thread_ptr->Start(); // Object is now created.
thread_ptr->Join(); // ...then destroyed.
// Only main_thread_object should be alive now, therefore the count is 1.
EXPECT_EQ(1, CountsInstances::NumInstances());
// We COULD destroy the TLO on the main thread, but to be even fancier lets
// create a thread that will destroy the object on a back ground thread.
// The end result is that the TLO entry should be cleared out.
new DestroyTypeOnThread<ThreadLocalObject<CountsInstances> >(tlo));
// Now we expect that number of instances to be 0.
EXPECT_EQ(0, CountsInstances::NumInstances());
} // anonymous namespace
} // namespace base