Solved some compatibility problems in pthread_t usage

Sebastiano Merlino · Sebastiano Merlino · commit c587f38021c2 · 2013-01-01T16:37:09.000+01:00
diff --git a/src/webserver.cpp b/src/webserver.cpp
@@ -187,14 +187,22 @@ struct modded_request
 
 }
 
+struct pthread_t_comparator
+{
+    bool operator()(const pthread_t& t1, const pthread_t& t2) const
+    {
+        return pthread_equal(t1, t2);
+    }
+};
+
 struct cache_entry
 {
     long ts;
     int validity;
     details::http_response_ptr response;
     pthread_rwlock_t elem_guard;
     pthread_mutex_t lock_guard;
-    set<pthread_t> lockers;
+    set<pthread_t, pthread_t_comparator> lockers;
 
     cache_entry():
         ts(-1),
@@ -241,17 +249,18 @@ struct cache_entry
     void lock(bool write = false)
     {
         pthread_mutex_lock(&lock_guard);
-        if(!lockers.count(pthread_self()))
+        pthread_t tid = pthread_self();
+        if(!lockers.count(tid))
         {
             if(write)
             {
-                lockers.insert(pthread_self());
+                lockers.insert(tid);
                 pthread_mutex_unlock(&lock_guard);
                 pthread_rwlock_wrlock(&elem_guard);
             }
             else
             {
-                lockers.insert(pthread_self());
+                lockers.insert(tid);
                 pthread_mutex_unlock(&lock_guard);
                 pthread_rwlock_rdlock(&elem_guard);
             }
@@ -263,10 +272,13 @@ struct cache_entry
     void unlock()
     {
         pthread_mutex_lock(&lock_guard);
-        if(lockers.count(pthread_self()))
         {
-            lockers.erase(pthread_self());
-            pthread_rwlock_unlock(&elem_guard);
+            pthread_t tid = pthread_self();
+            if(lockers.count(tid))
+            {
+                lockers.erase(tid);
+                pthread_rwlock_unlock(&elem_guard);
+            }
         }
         pthread_mutex_unlock(&lock_guard);
     }

Original file line number	Diff line number	Diff line change
`@@ -187,14 +187,22 @@ struct modded_request`
`187`	`187`
`188`	`188`	`}`
`189`	`189`
	`190`	`+struct pthread_t_comparator`
	`191`	`+{`
	`192`	`+ bool operator()(const pthread_t& t1, const pthread_t& t2) const`
	`193`	`+ {`
	`194`	`+ return pthread_equal(t1, t2);`
	`195`	`+ }`
	`196`	`+};`
	`197`	`+`
`190`	`198`	`struct cache_entry`
`191`	`199`	`{`
`192`	`200`	`long ts;`
`193`	`201`	`int validity;`
`194`	`202`	`details::http_response_ptr response;`
`195`	`203`	`pthread_rwlock_t elem_guard;`
`196`	`204`	`pthread_mutex_t lock_guard;`
`197`		`- set<pthread_t> lockers;`
	`205`	`+ set<pthread_t, pthread_t_comparator> lockers;`
`198`	`206`
`199`	`207`	`cache_entry():`
`200`	`208`	`ts(-1),`
`@@ -241,17 +249,18 @@ struct cache_entry`
`241`	`249`	`void lock(bool write = false)`
`242`	`250`	`{`
`243`	`251`	`pthread_mutex_lock(&lock_guard);`
`244`		`- if(!lockers.count(pthread_self()))`
	`252`	`+ pthread_t tid = pthread_self();`
	`253`	`+ if(!lockers.count(tid))`
`245`	`254`	`{`
`246`	`255`	`if(write)`
`247`	`256`	`{`
`248`		`- lockers.insert(pthread_self());`
	`257`	`+ lockers.insert(tid);`
`249`	`258`	`pthread_mutex_unlock(&lock_guard);`
`250`	`259`	`pthread_rwlock_wrlock(&elem_guard);`
`251`	`260`	`}`
`252`	`261`	`else`
`253`	`262`	`{`
`254`		`- lockers.insert(pthread_self());`
	`263`	`+ lockers.insert(tid);`
`255`	`264`	`pthread_mutex_unlock(&lock_guard);`
`256`	`265`	`pthread_rwlock_rdlock(&elem_guard);`
`257`	`266`	`}`
`@@ -263,10 +272,13 @@ struct cache_entry`
`263`	`272`	`void unlock()`
`264`	`273`	`{`
`265`	`274`	`pthread_mutex_lock(&lock_guard);`
`266`		`- if(lockers.count(pthread_self()))`
`267`	`275`	`{`
`268`		`- lockers.erase(pthread_self());`
`269`		`- pthread_rwlock_unlock(&elem_guard);`
	`276`	`+ pthread_t tid = pthread_self();`
	`277`	`+ if(lockers.count(tid))`
	`278`	`+ {`
	`279`	`+ lockers.erase(tid);`
	`280`	`+ pthread_rwlock_unlock(&elem_guard);`
	`281`	`+ }`
`270`	`282`	`}`
`271`	`283`	`pthread_mutex_unlock(&lock_guard);`
`272`	`284`	`}`