148 - ThreadLocal and Mutex for pthread

src/gtest-port.cc

 // Copyright 2008, Google Inc.
 // All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
@@ skipping 55 matching lines @@
 namespace testing {
 namespace internal {
 
 #if defined(_MSC_VER) || defined(__BORLANDC__)
 // MSVC and C++Builder do not provide a definition of STDERR_FILENO.
 const int kStdErrFileno = 2;
 #else
 const int kStdErrFileno = STDERR_FILENO;
 #endif  // _MSC_VER
 
+#if GTEST_HAS_PTHREAD
+pthread_exception::pthread_exception(int error,const char* msg) : buffer_() {
+  buffer_[0] = 0;
+  snprintf(buffer_,sizeof(buffer_),"%s - failed: %d:%s",msg,error, strerror(error));
+}
+
+const char* pthread_exception::what() const throw() {
+  return buffer_;·
+}
+
+PthreadMutex::PthreadMutex() : mutex_(), owner_(0) {
+  init();
+}
+
+PthreadMutex::PthreadMutex(NoConstructorNeededSelector) {}
+
+PthreadMutex::~PthreadMutex() {
+  int err = pthread_mutex_destroy(&mutex_);
+  if (err != 0)
+    throw pthread_exception(err,"pthread_mutex_destroy");
+}
+··
+void PthreadMutex::AssertHeld() const {
+  GTEST_CHECK_ (owner_ == pthread_self()) << "AssertHeld failed.";

[Vlad, 2009/10/20 22:40:20]

Please provide a more informative message, such as

"Current thread is not holding mutex " << this;

As this will be the last printout from the process, it makes sense to provide
any information that can be useful for analysis.

+}
+
+void PthreadMutex::lock() {
+  int err = pthread_mutex_lock(&mutex_);
+  if (err != 0)
+    throw pthread_exception(err,"pthread_mutex_lock");
+  owner_ = pthread_self();
+}
+··
+void PthreadMutex::unlock() {
+  int err = pthread_mutex_unlock(&mutex_);
+  if (err != 0)
+    throw pthread_exception(err,"pthread_mutex_unlock");
+  owner_ = 0;

[florianlink, 2009/10/15 07:38:20]

Setting the owner_ to 0 here is too late, it is a race with another thread being
in lock(). You need to move owner_ = 0 before line 110

[mfazekas, 2009/10/15 14:33:07]

Yes, the owner_ = 0 should be moved before pthread_mutex_unlock.

+}
+··
+void PthreadMutex::init() {
+  owner_ = 0;
+  int err = pthread_mutex_init(&mutex_,0);
+  if (err != 0)
+    throw pthread_exception(err,"pthread_mutex_init");
+}
+
+Mutex::ImplMutex& Mutex::lazyInit() {
+  // This double checked locking handles the case where two threads trying use
+  // a mutex before it was constructed. It can only happen when if we launch·
+  // threads before main is entered, or we use Mutex as static locals on a·
+  // compiler where it's not threadsafe.
+  // Maybe we don't need to bother with all this, and we could remove this·
+  // whacky stuff here. Not to meantion, that we'd also need a fence to make this·
+  // work.
+  if (inited_ == 0) {
+    ImplMutex::LockGuard lock(&staticMutex());
+    if (inited_ == 0) {
+      new (&uninitializedImpl_) ImplMutex();············
+      // fenc();
+      inited_++;
+    }
+  }
+  return uninitializedImpl_;
+}
+
+Mutex::ImplMutex& Mutex::_staticMutex() {
+  // Unfortunatelyy static locals are not thread safe on all compilers
+  // so we provide staticMutex() which uses pthread_once to avoid the data race
+  static ImplMutex mutex;
+  return mutex;
+}
+
+void Mutex::initStaticMutexOnce() {
+  _staticMutex();
+}
+
+pthread_once_t Mutex::once_control = PTHREAD_ONCE_INIT;
+
+Mutex::ImplMutex& Mutex::staticMutex() {
+  int err = pthread_once(&once_control, &Mutex::initStaticMutexOnce);
+  if (err != 0)
+    throw pthread_exception(err,"pthread_mutex_init");
+  return _staticMutex();
+}
+
+#endif

[Vlad, 2009/10/20 22:40:20]

#endif  // GTEST_HAS_PTHREAD

+
 #if GTEST_OS_MAC
 
 // Returns the number of threads running in the process, or 0 to indicate that
 // we cannot detect it.
 size_t GetThreadCount() {
   const task_t task = mach_task_self();
   mach_msg_type_number_t thread_count;
   thread_act_array_t thread_list;
   const kern_return_t status = task_threads(task, &thread_list, &thread_count);
   if (status == KERN_SUCCESS) {
@@ skipping 585 matching lines @@
 // Reads and returns the string environment variable corresponding to
 // the given flag; if it's not set, returns default_value.
 const char* StringFromGTestEnv(const char* flag, const char* default_value) {
   const String env_var = FlagToEnvVar(flag);
   const char* const value = posix::GetEnv(env_var.c_str());
   return value == NULL ? default_value : value;
 }
 
 }  // namespace internal
 }  // namespace testing