From 07962b5314ab9d2b784f29e79fb21dd02a055e2d Mon Sep 17 00:00:00 2001
From: Michael Ploujnikov <ploujj@gmail.com>
Date: Wed, 25 Nov 2009 17:43:22 -0500
Subject: [PATCH] add comments about locking in
 lumiera_threadpool_release_thread() output the size of the created thread
 struct don't print "destroying thread" (lets tests become shorter with
 repeated matching) add a test which spans many threads in all pools

---
 src/backend/threadpool.c         | 12 +++++++---
 src/backend/threads.c            |  2 +-
 tests/30backend-threadpool.tests | 39 ++++++++++++++++++++++++++++++--
 tests/backend/test-threadpool.c  | 28 +++++++++++++++++++++++
 4 files changed, 75 insertions(+), 6 deletions(-)

diff --git a/src/backend/threadpool.c b/src/backend/threadpool.c
index 5960c890f..1a48967dd 100644
--- a/src/backend/threadpool.c
+++ b/src/backend/threadpool.c
@@ -112,9 +112,15 @@ lumiera_threadpool_release_thread(LumieraThread thread)
 {
   REQUIRE (thread, "invalid thread given");
   REQUIRE (thread->kind < LUMIERA_THREADCLASS_COUNT, "thread belongs to an unknown pool kind: %d", thread->kind);
-  REQUIRE (llist_is_single(&thread->node), "thread already belongs to some list");
-  llist_insert_head(&threadpool.kind[thread->kind].pool, &thread->node);
-  REQUIRE (!llist_is_empty (&threadpool.kind[thread->kind].pool), "thread pool is still empty after insertion");
+  REQUIRE (&threadpool.kind[thread->kind].lock, "invalid threadpool lock");
+
+  // TOOD: currently, locking produces memory leaks
+  //  LUMIERA_MUTEX_SECTION (threadpool, &threadpool.kind[thread->kind].lock)
+  //    {
+      //REQUIRE (llist_is_single(&thread->node), "thread already belongs to some list");
+      llist_insert_head(&threadpool.kind[thread->kind].pool, &thread->node);
+      //      REQUIRE (!llist_is_empty (&threadpool.kind[thread->kind].pool), "thread pool is still empty after insertion");
+      //    }
 }
 
 /*
diff --git a/src/backend/threads.c b/src/backend/threads.c
index 4471fb444..52125fcef 100644
--- a/src/backend/threads.c
+++ b/src/backend/threads.c
@@ -170,6 +170,7 @@ lumiera_thread_new (enum lumiera_thread_class kind,
   //REQUIRE (finished, "invalid finished flag passed");
 
   LumieraThread self = lumiera_malloc (sizeof (*self));
+  ECHO ("allocated thread struct of size %zd", sizeof (*self));
   llist_init(&self->node);
   self->finished = finished;
   self->kind = kind;
@@ -193,7 +194,6 @@ lumiera_thread_new (enum lumiera_thread_class kind,
 LumieraThread
 lumiera_thread_destroy (LumieraThread self)
 {
-  ECHO ("destroying thread");
   REQUIRE (self, "trying to destroy an invalid thread");
 
   // TODO: stop the pthread
diff --git a/tests/30backend-threadpool.tests b/tests/30backend-threadpool.tests
index a23ff38ea..44392f279 100644
--- a/tests/30backend-threadpool.tests
+++ b/tests/30backend-threadpool.tests
@@ -8,17 +8,19 @@ PLANNED "cancel"
 TEST "Acquire/Release test" basic-acquire-release <<END
 err: start by initializing the threadpool
 err: acquiring thread 1
+err: allocated thread struct of size
 err: acquiring thread 2
+err: allocated thread struct of size
 err: releasing thread 1
 err: thread 1 has been released
 err: releasing thread 2
 err: thread 2 has been released
+
 err: destroying threadpool
 
 err: destroying individual pool #0
 err: number of threads in the pool=1
 err: deleting thread
-err: destroying thread
 err: destroying the pool mutex
 err: pool mutex destroyed
 
@@ -40,8 +42,41 @@ err: pool mutex destroyed
 err: destroying individual pool #4
 err: number of threads in the pool=1
 err: deleting thread
-err: destroying thread
 err: destroying the pool mutex
 err: pool mutex destroyed
 END
 
+TEST "Many Acquires/Releases test" many-acquire-release <<END
+err: allocated thread struct of size
+err: destroying threadpool
+
+err: destroying individual pool #0
+err: number of threads in the pool=1000
+err: deleting thread
+err: destroying the pool mutex
+err: pool mutex destroyed
+
+err: destroying individual pool #1
+err: number of threads in the pool=1000
+err: deleting thread
+err: destroying the pool mutex
+err: pool mutex destroyed
+
+err: destroying individual pool #2
+err: number of threads in the pool=1000
+err: deleting thread
+err: destroying the pool mutex
+err: pool mutex destroyed
+
+err: destroying individual pool #3
+err: number of threads in the pool=1000
+err: deleting thread
+err: destroying the pool mutex
+err: pool mutex destroyed
+
+err: destroying individual pool #4
+err: number of threads in the pool=1000
+err: deleting thread
+err: destroying the pool mutex
+err: pool mutex destroyed
+END
diff --git a/tests/backend/test-threadpool.c b/tests/backend/test-threadpool.c
index be3b4311c..4ad8e1a15 100644
--- a/tests/backend/test-threadpool.c
+++ b/tests/backend/test-threadpool.c
@@ -64,4 +64,32 @@ TEST ("basic-acquire-release")
   lumiera_threadpool_destroy();
 }
 
+TEST ("many-acquire-release")
+{
+
+  const int threads_per_pool_count = 1000;
+
+  lumiera_threadpool_init();
+  LumieraThread threads[threads_per_pool_count*LUMIERA_THREADCLASS_COUNT];
+  
+  for (int kind = 0; kind < LUMIERA_THREADCLASS_COUNT; ++kind)
+    {
+      for (int i = 0; i < threads_per_pool_count; ++i)
+	{
+	  threads[i+kind*threads_per_pool_count] =
+	    lumiera_threadpool_acquire_thread(kind,
+					      "test purpose",
+					      NULL);
+	}
+    }
+
+  for (int i = 0; i < threads_per_pool_count*LUMIERA_THREADCLASS_COUNT; ++i)
+    {
+      lumiera_threadpool_release_thread(threads[i]);
+    }
+
+  lumiera_threadpool_destroy();
+
+}
+
 TESTS_END