Finished more changes

Author: ericxu233

include/acl_thread.h

@@ -84,10 +84,6 @@ static inline void acl_sig_unblock_signals() {
 
 // -- global lock functions --
 
-void acl_lock();
-void acl_unlock();
-int acl_suspend_lock();
-void acl_resume_lock(int lock_count);
 void acl_wait_for_device_update(cl_context context);
 void acl_signal_device_update();
 
@@ -124,17 +120,19 @@ void acl_yield_lock_and_thread();
 // This meets the BasicLockable requirement for std::lock_guard.
 class acl_mutex_wrapper_t {
 public:
-  void lock() { acl_lock(); }
-  void unlock() { acl_unlock(); }
+  void lock();
+  void unlock();
+  int suspend_lock();
+  void resume_lock(int lock_count);
 };
 
 // RAII class warpper for acl specific functionality acl_suspend_lock()
 class acl_suspend_lock_guard {
 public:
   explicit acl_suspend_lock_guard(acl_mutex_wrapper_t &mtex) : mtex(mtex) {
-    lock_count = acl_suspend_lock();
+    lock_count = mtex.suspend_lock();
   };
-  ~acl_suspend_lock_guard() { acl_resume_lock(lock_count); }
+  ~acl_suspend_lock_guard() { mtex.resume_lock(lock_count); }
 
 private:
   int lock_count;

src/acl_thread.cpp

@@ -20,54 +20,54 @@ static struct acl_condvar_s l_acl_global_condvar;
 // l_init_once() is defined in an OS-specific section below
 static void l_init_once();
 
-void acl_lock() {
+int acl_is_locked_callback(void) { return (acl_global_lock_count > 0); }
+
+void acl_wait_for_device_update(cl_context context) {
+  acl_assert_locked();
+  if (acl_get_hal()->get_debug_verbosity &&
+      acl_get_hal()->get_debug_verbosity() > 0) {
+    unsigned timeout = 5; // Seconds
+    // Keep waiting until signal is received
+    while (acl_timed_wait_condvar(&l_acl_global_condvar, timeout))
+      acl_context_print_hung_device_status(context);
+  } else {
+    acl_wait_condvar(&l_acl_global_condvar);
+  }
+}
+
+void acl_signal_device_update() { acl_signal_condvar(&l_acl_global_condvar); }
+
+void acl_mutex_wrapper_t::lock() {
   l_init_once();
   if (acl_global_lock_count == 0) {
     acl_acquire_condvar(&l_acl_global_condvar);
   }
   acl_global_lock_count++;
 }
 
-void acl_unlock() {
+void acl_mutex_wrapper_t::unlock() {
   acl_assert_locked();
   acl_global_lock_count--;
   if (acl_global_lock_count == 0) {
     acl_release_condvar(&l_acl_global_condvar);
   }
 }
 
-int acl_is_locked_callback(void) { return (acl_global_lock_count > 0); }
-
-int acl_suspend_lock() {
+int acl_mutex_wrapper_t::suspend_lock() {
   int old_lock_count = acl_global_lock_count;
   acl_global_lock_count = 0;
   if (old_lock_count > 0)
     acl_release_condvar(&l_acl_global_condvar);
   return old_lock_count;
 }
 
-void acl_resume_lock(int lock_count) {
+void acl_mutex_wrapper_t::resume_lock(int lock_count) {
   acl_assert_unlocked();
   if (lock_count > 0)
     acl_acquire_condvar(&l_acl_global_condvar);
   acl_global_lock_count = lock_count;
 }
 
-void acl_wait_for_device_update(cl_context context) {
-  acl_assert_locked();
-  if (acl_get_hal()->get_debug_verbosity &&
-      acl_get_hal()->get_debug_verbosity() > 0) {
-    unsigned timeout = 5; // Seconds
-    // Keep waiting until signal is received
-    while (acl_timed_wait_condvar(&l_acl_global_condvar, timeout))
-      acl_context_print_hung_device_status(context);
-  } else {
-    acl_wait_condvar(&l_acl_global_condvar);
-  }
-}
-
-void acl_signal_device_update() { acl_signal_condvar(&l_acl_global_condvar); }
-
 #ifdef __linux__
 
 #include <linux/unistd.h>

test/acl_device_op_test.cpp

@@ -133,7 +133,7 @@ static struct _cl_event myevents[EVENT_NUM] = {{0}};
 
 TEST_GROUP(device_op) {
   virtual void setup() {
-    acl_lock();
+    acl_mutex_wrapper.lock();
     acl_test_setup_generic_system();
     acl_init_device_op_queue(&m_doq);
     clear_queue_callbacks(&m_doq);
@@ -152,7 +152,7 @@ TEST_GROUP(device_op) {
   virtual void teardown() {
     unload();
     acl_test_teardown_generic_system();
-    acl_unlock();
+    acl_mutex_wrapper.unlock();
     acl_test_run_standard_teardown_checks();
   }
 

test/acl_event_test.cpp

@@ -292,7 +292,7 @@ MT_TEST(acl_event, acl_create_event) {
 
   // Bad command queue
   struct _cl_command_queue fake_cq = {0};
-  acl_lock();
+  acl_mutex_wrapper.lock();
   CHECK_EQUAL(CL_INVALID_COMMAND_QUEUE,
               acl_create_event(0, 0, 0, CL_COMMAND_MARKER, &user_event));
   CHECK_EQUAL(CL_INVALID_COMMAND_QUEUE,
@@ -338,7 +338,7 @@ MT_TEST(acl_event, acl_create_event) {
   CHECK(cq0);
   acl_update_queue(cq0);
 
-  acl_unlock();
+  acl_mutex_wrapper.unlock();
 
   // Check the callback functions initialization.
   CHECK_EQUAL(NULL, event[0]->callback_list);
@@ -614,7 +614,7 @@ MT_TEST(acl_event, event_liveness) {
   CHECK_EQUAL(CL_SUCCESS, status);
   CHECK(cq0);
 
-  acl_lock();
+  acl_mutex_wrapper.lock();
   cl_event event;
   status = acl_create_event(cq0, 0, 0, CL_COMMAND_MARKER, &event);
   CHECK_EQUAL(CL_SUCCESS, status);
@@ -659,7 +659,7 @@ MT_TEST(acl_event, event_liveness) {
   acl_set_execution_status(event, CL_QUEUED);
   CHECK(acl_event_is_live(event));
   acl_retain(event);
-  acl_unlock();
+  acl_mutex_wrapper.unlock();
 
   this->kill_event(event);
 
@@ -690,7 +690,7 @@ MT_TEST(acl_event, event_callbacks) {
   CHECK_EQUAL(CL_SUCCESS, status);
   CHECK(cq0);
 
-  acl_lock();
+  acl_mutex_wrapper.lock();
   cl_event event, event2, event3;
   status = acl_create_event(cq0, 0, 0, CL_COMMAND_MARKER, &event);
   CHECK_EQUAL(CL_SUCCESS, status);
@@ -807,7 +807,7 @@ MT_TEST(acl_event, event_callbacks) {
     CHECK_EQUAL(1, call_flags_event3[i]);
   }
   clReleaseEvent(user_event);
-  acl_unlock();
+  acl_mutex_wrapper.unlock();
 
   this->kill_event(event);
   this->kill_event(event2);

test/acl_globals_test.cpp

@@ -693,12 +693,12 @@ const acl_system_def_t *acl_test_get_empty_system_def() {
   return &acltest_empty_system;
 }
 
-TEST_GROUP(acl_globals_undef){void setup(){acl_lock();
+TEST_GROUP(acl_globals_undef){void setup(){acl_mutex_wrapper.lock();
 acl_set_hal(acl_test_get_simple_hal());
 }
 void teardown() {
   acl_reset_hal();
-  acl_unlock();
+  acl_mutex_wrapper.unlock();
   acl_test_run_standard_teardown_checks();
 }
 

test/acl_hal_mmd_test.cpp

@@ -19,14 +19,14 @@
 #include <stdio.h>
 #include <string.h>
 
-TEST_GROUP(acl_hal_mmd){void setup(){acl_lock();
+TEST_GROUP(acl_hal_mmd){void setup(){acl_mutex_wrapper.lock();
 acl_hal_test_setup_generic_system();
 this->load();
 }
 void teardown() {
   this->unload();
   acl_hal_test_teardown_generic_system();
-  acl_unlock();
+  acl_mutex_wrapper.unlock();
   acl_test_run_standard_teardown_checks();
 }
 

test/acl_hal_test.cpp

@@ -162,10 +162,10 @@ bool acltest_hal_emulate_device_mem = false;
 static void *acltest_hal_device_mem = 0;
 static size_t acltest_hal_device_mem_size = 0;
 
-TEST_GROUP(acl_hal){void setup(){acl_lock();
+TEST_GROUP(acl_hal){void setup(){acl_mutex_wrapper.lock();
 }
 void teardown() {
-  acl_unlock();
+  acl_mutex_wrapper.unlock();
   acl_assert_unlocked();
 }
 }

test/acl_support_test.cpp

@@ -23,12 +23,12 @@
 #include <glob.h>
 #endif
 
-TEST_GROUP(support){void setup(){acl_lock();
+TEST_GROUP(support){void setup(){acl_mutex_wrapper.lock();
 acl_test_setup_generic_system();
 }
 void teardown() {
   acl_test_teardown_generic_system();
-  acl_unlock();
+  acl_mutex_wrapper.unlock();
   acl_test_run_standard_teardown_checks();
 }
 

test/acl_test.cpp

@@ -91,24 +91,24 @@ int main(int argc, const char **argv) {
 }
 
 void acl_test_setup_generic_system() {
-  acl_lock();
+  acl_mutex_wrapper.lock();
   acl_set_hal(acl_test_get_simple_hal());
   acl_init(acl_test_get_complex_system_def());
-  acl_unlock();
+  acl_mutex_wrapper.unlock();
 }
 
 void acl_test_setup_empty_system() {
-  acl_lock();
+  acl_mutex_wrapper.lock();
   acl_set_hal(acl_test_get_simple_hal());
   acl_init(acl_test_get_empty_system_def());
-  acl_unlock();
+  acl_mutex_wrapper.unlock();
 }
 
 void acl_test_setup_sample_default_board_system(void) {
-  acl_lock();
+  acl_mutex_wrapper.lock();
   acl_set_hal(acl_test_get_simple_hal());
   acl_init(&acl_test_example_binary_sysdef);
-  acl_unlock();
+  acl_mutex_wrapper.unlock();
 }
 
 void acl_test_teardown_sample_default_board_system(void) {
@@ -117,11 +117,11 @@ void acl_test_teardown_sample_default_board_system(void) {
 
 void acl_test_teardown_generic_system(void) { acl_test_teardown_system(); }
 void acl_test_teardown_system(void) {
-  acl_lock();
+  acl_mutex_wrapper.lock();
   acl_reset();
   acl_reset_hal();
   acltest_hal_teardown();
-  acl_unlock();
+  acl_mutex_wrapper.unlock();
 }
 
 void acl_hal_test_setup_generic_system(void) { return; };
@@ -482,20 +482,20 @@ static void l_run_benchmark() {
     times = &results["acl_lock/acl_unlock"];
     for (int inner_rep = 0; inner_rep < INNER_REPS; ++inner_rep) {
       start_time = l_get_timestamp();
-      acl_lock();
-      acl_unlock();
+      acl_mutex_wrapper.lock();
+      acl_mutex_wrapper.unlock();
       end_time = l_get_timestamp();
       times->push_back(end_time - start_time);
     }
 
     std::cout << "Measuring acl_assert_locked..." << std::endl;
     times = &results["acl_assert_locked"];
     for (int inner_rep = 0; inner_rep < INNER_REPS; ++inner_rep) {
-      acl_lock();
+      acl_mutex_wrapper.lock();
       start_time = l_get_timestamp();
       acl_assert_locked();
       end_time = l_get_timestamp();
-      acl_unlock();
+      acl_mutex_wrapper.unlock();
       times->push_back(end_time - start_time);
     }
 

test/acl_test.h

@@ -55,9 +55,9 @@ void CL_CALLBACK acl_test_notify_print(const char *errinfo,
 
 #define ACL_LOCKED(...)                                                        \
   do {                                                                         \
-    acl_lock();                                                                \
+    acl_mutex_wrapper.lock();                                                                \
     { __VA_ARGS__; }                                                           \
-    acl_unlock();                                                              \
+    acl_mutex_wrapper.unlock();                                                              \
   } while (0)
 
 /* CAUTION.  These are only used in self-tests.