lib/pthreads/pthreads.nit

   1 # This file is part of NIT (http://www.nitlanguage.org).
   2 #
   3 # Copyright 2014 Alexis Laferrière <alexis.laf@xymus.net>
   4 #
   5 # Licensed under the Apache License, Version 2.0 (the "License");
   6 # you may not use this file except in compliance with the License.
   7 # You may obtain a copy of the License at
   8 #
   9 #     http://www.apache.org/licenses/LICENSE-2.0
  10 #
  11 # Unless required by applicable law or agreed to in writing, software
  12 # distributed under the License is distributed on an "AS IS" BASIS,
  13 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 # See the License for the specific language governing permissions and
  15 # limitations under the License.
  16
  17 # Main POSIX threads support and intro the classes `Thread`, `Mutex` and `Barrier`
  18 module pthreads is
  19         cflags "-pthread"
  20         ldflags "-pthread"
  21         pkgconfig "bdw-gc"
  22         new_annotation threaded
  23 end
  24
  25 #
  26 ## Native part
  27 #
  28 # Nity part at the bottom of the module.
  29 #
  30
  31 in "C Header" `{
  32         #include <pthread.h>
  33 `}
  34
  35 in "C" `{
  36         // TODO protect with: #ifdef WITH_LIBGC
  37         // We might have to add the next line to gc_chooser.c too, especially
  38         // if we get an error like "thread not registered with GC".
  39         #ifndef ANDROID
  40                 #define GC_THREADS
  41                 #include <gc.h>
  42         #endif
  43 `}
  44
  45 redef class Sys
  46
  47         # `NativePthread` for running thread
  48         private fun native_pthread_self: NativePthread `{
  49                 pthread_t *id = malloc(sizeof(pthread_t));
  50                 *id = pthread_self();
  51                 return id;
  52         `}
  53
  54         private var self_thread_key = new NativePthreadKey
  55
  56         private var main_thread_cache: nullable MainThread = null
  57         private var main_thread_mutex = new Mutex
  58
  59         # Handle to the program's main thread
  60         fun main_thread: MainThread
  61         do
  62                 var cache = main_thread_cache
  63                 if cache != null then return cache
  64
  65                 main_thread_mutex.lock
  66
  67                 # Recheck if cache has been updated since lock has been unlocked/locked
  68                 cache = main_thread_cache
  69                 if cache != null then
  70                         main_thread_mutex.unlock
  71                         return cache
  72                 end
  73
  74                 # Create a `MainThread` exactly once
  75                 var thread = new MainThread
  76                 thread.native = sys.native_pthread_self
  77                 main_thread_cache = thread
  78
  79                 main_thread_mutex.unlock
  80                 return thread
  81         end
  82 end
  83
  84 private extern class NativePthread in "C" `{ pthread_t * `}
  85
  86         new create(nit_thread: Thread) import Thread.main_intern `{
  87                 pthread_attr_t attr;
  88                 pthread_attr_init(&attr);
  89
  90                 pthread_t thread;
  91                 int r = pthread_create(&thread, &attr, (void * (*)(void *))&Thread_main_intern, nit_thread);
  92
  93                 if (r == 0) {
  94                         pthread_t *pthread = malloc(sizeof(pthread_t));
  95                         memmove(pthread, &thread, sizeof(pthread_t));
  96                         return pthread;
  97                 }
  98                 return NULL;
  99         `}
 100
 101         new create_ex(nit_thread: Thread, attr: NativePthreadAttr) import Thread.main_intern `{
 102                 pthread_t thread;
 103                 int r = pthread_create(&thread, attr, (void * (*)(void *))&Thread_main_intern, nit_thread);
 104
 105                 if (r == 0) {
 106                         pthread_t *pthread = malloc(sizeof(pthread_t));
 107                         memmove(pthread, &thread, sizeof(pthread_t));
 108                         return pthread;
 109                 }
 110                 return NULL;
 111         `}
 112
 113         fun join: nullable Object `{
 114                 void *thread_return;
 115                 pthread_join(*self, &thread_return);
 116                 if(thread_return == NULL) thread_return = null_Object();
 117                 return (nullable_Object)thread_return;
 118         `}
 119
 120         fun equal(other: NativePthread): Bool `{ return pthread_equal(*self, *other); `}
 121
 122         fun kill(signal: Int) `{ pthread_kill(*self, signal); `}
 123 end
 124
 125 private extern class NativePthreadAttr in "C" `{ pthread_attr_t * `}
 126         new `{
 127                 pthread_attr_t attr;
 128                 int r = pthread_attr_init(&attr);
 129                 if (r == 0) {
 130                         pthread_attr_t *pattr = malloc(sizeof(pthread_attr_t));
 131                         memmove(pattr, &attr, sizeof(pthread_attr_t));
 132                         return pattr;
 133                 }
 134                 return NULL;
 135         `}
 136
 137         fun destroy `{
 138                 pthread_attr_destroy(self);
 139         `}
 140
 141         # Most features of this class are still TODO
 142         #
 143         # * pthread_attr_setaffinity_np(3)
 144         # * pthread_attr_setdetachstate
 145         # * pthread_attr_setguardsize
 146         # * pthread_attr_setinheritsched
 147         # * pthread_attr_setschedparam
 148         # * pthread_attr_setschedpolicy
 149         # * pthread_attr_setscope
 150         # * pthread_attr_setstack
 151         # * pthread_attr_setstackaddr
 152         # * pthread_attr_setstacksize
 153 end
 154
 155 private extern class NativePthreadMutex in "C" `{ pthread_mutex_t * `}
 156         new (attr: NativePthreadMutexAttr) `{
 157                 pthread_mutex_t *mutex = malloc(sizeof(pthread_mutex_t));
 158                 int res = pthread_mutex_init(mutex, attr);
 159                 return mutex;
 160         `}
 161
 162         fun destroy `{ pthread_mutex_destroy(self); `}
 163
 164         fun lock `{ pthread_mutex_lock(self); `}
 165         fun try_lock: Bool `{ return pthread_mutex_trylock(self); `}
 166         fun unlock `{ pthread_mutex_unlock(self); `}
 167 end
 168
 169 private extern class NativePthreadMutexAttr in "C" `{ pthread_mutexattr_t * `}
 170         new `{
 171                 pthread_mutexattr_t *attr = malloc(sizeof(pthread_mutexattr_t));
 172                 int res = pthread_mutexattr_init(attr);
 173                 return attr;
 174         `}
 175
 176         fun destroy `{ pthread_mutexattr_destroy(self); `}
 177
 178         fun set_type_normal `{ pthread_mutexattr_settype(self, PTHREAD_MUTEX_NORMAL); `}
 179         fun set_type_recursive `{ pthread_mutexattr_settype(self, PTHREAD_MUTEX_RECURSIVE); `}
 180         fun set_type_errorcheck `{ pthread_mutexattr_settype(self, PTHREAD_MUTEX_ERRORCHECK); `}
 181
 182         # pthread_mutexattr_setpshared
 183         # pthread_mutexattr_setprotocol
 184         # pthread_mutexattr_setproceiling
 185         # pthread_mutexattr_setrobust_np
 186 end
 187
 188 private extern class NativePthreadKey in "C" `{ pthread_key_t * `}
 189         new `{
 190                 pthread_key_t *key = malloc(sizeof(pthread_key_t));
 191                 int res = pthread_key_create(key, NULL);
 192                 return key;
 193         `}
 194
 195         fun get: nullable Object `{
 196                 void *val = pthread_getspecific(*self);
 197                 if (val == NULL) val = null_Object();
 198                 return val;
 199         `}
 200
 201         fun set(val: nullable Object) `{
 202                 pthread_setspecific(*self, val);
 203         `}
 204 end
 205
 206 private extern class NativePthreadCond in "C" `{ pthread_cond_t * `}
 207         new `{
 208                 pthread_cond_t cond;
 209                 int r = pthread_cond_init(&cond, NULL);
 210                 if (r == 0) {
 211                         pthread_cond_t *pcond = malloc(sizeof(pthread_cond_t));
 212                         memmove(pcond, &cond, sizeof(pthread_cond_t));
 213                         return pcond;
 214                 }
 215                 return NULL;
 216         `}
 217
 218         fun destroy `{ pthread_cond_destroy(self); `}
 219
 220         fun signal `{ pthread_cond_signal(self); `}
 221
 222         fun broadcast `{ pthread_cond_broadcast(self);  `}
 223
 224         fun wait(mutex: NativePthreadMutex) `{ pthread_cond_wait(self, mutex); `}
 225 end
 226
 227 #
 228 ## Nity part
 229 #
 230 # Cannot be extracted from this module because of the callback from C to `Thread::run`
 231 #
 232
 233 # Handle to a thread
 234 #
 235 # Instances of this class are each used to launch and control a thread.
 236 abstract class Thread
 237         super Finalizable
 238
 239         # Type returned by `main`
 240         type E : nullable Object
 241
 242         private var native: nullable NativePthread = null
 243
 244         # Is this thread finished ? True when main returned
 245         var is_done = false
 246
 247         # Main method of this thread
 248         #
 249         # The returned valued is passed to the caller of `join`.
 250         fun main: E do return null
 251
 252         private fun main_intern: E
 253         do
 254                 # Register thread local data
 255                 sys.self_thread_key.set self
 256                 var r = main
 257                 self.is_done = true
 258                 return r
 259         end
 260
 261         # Start executing this thread
 262         #
 263         # Will launch `main` on a different thread.
 264         fun start
 265         do
 266                 if native != null then return
 267                 native = new NativePthread.create(self)
 268         end
 269
 270         # Join this thread to the calling thread
 271         #
 272         # Blocks until the method `main` returns or the target thread calls
 273         # `Sys::thread_exit`. Returns the object returned from the other thread.
 274         #
 275         # Stats the thread if now already done by a call to `start`.
 276         fun join: E
 277         do
 278                 if native == null then start
 279                 var r = native.join
 280                 native = null
 281                 return r.as(E)
 282         end
 283
 284         redef fun finalize
 285         do
 286                 if native == null then return
 287                 native.free
 288                 native = null
 289         end
 290 end
 291
 292 # The main thread of the program
 293 class MainThread
 294         super Thread
 295
 296         private init do end
 297 end
 298
 299 # Exit current thread and return `value` to caller of `Thread::join`
 300 fun exit_thread(value: nullable Object) `{ pthread_exit(value); `}
 301
 302 # Returns the handle to the running `Thread`
 303 fun thread: Thread
 304 do
 305         var key = sys.self_thread_key
 306         var val = key.get
 307         if val == null then
 308                 # This is the original thread, get `Sys::main_thread` and store it
 309                 var thread = sys.main_thread
 310                 key.set thread
 311                 return thread
 312         end
 313
 314         assert val isa Thread
 315         return val
 316 end
 317
 318 # Mutual exclusion synchronization tool
 319 #
 320 # Instances of this class can only be acquired by a single thread at any one
 321 # point in time. Uses the recursive protocol so they can be locked many time by
 322 # the same thread, must then be unlocked as many time.
 323 class Mutex
 324         super Finalizable
 325
 326         private var native: nullable NativePthreadMutex is noinit
 327
 328         init
 329         do
 330                 var attr = new NativePthreadMutexAttr
 331                 attr.set_type_recursive
 332                 native = new NativePthreadMutex(attr)
 333                 attr.destroy
 334                 attr.free
 335         end
 336
 337         # Acquire this lock, wait until it is available
 338         fun lock do native.lock
 339
 340         # Acquire this lock only if it is available
 341         #
 342         # Returns `true` if the lock has been acquired.
 343         fun try_lock: Bool do return native.try_lock
 344
 345         # Release this lock, unblocking all callers of `lock`
 346         fun unlock do native.unlock
 347
 348         redef fun finalize
 349         do
 350                 var native = self.native
 351                 if native != null then
 352                         native.destroy
 353                         native.free
 354                 end
 355                 self.native = null
 356         end
 357 end
 358
 359 # Barrier synchronization tool
 360 #
 361 # Ensures that `count` threads call and block on `wait` before releasing them.
 362 class Barrier
 363         super Finalizable
 364
 365         private var mutex = new Mutex
 366         private var cond: nullable NativePthreadCond = new NativePthreadCond
 367
 368         # Number of threads that must be waiting for `wait` to unblock
 369         var count: Int
 370
 371         private var threads_waiting = 0
 372
 373         # Wait at this barrier and block until there are a `count` threads waiting
 374         fun wait
 375         do
 376                 mutex.lock
 377                 threads_waiting += 1
 378                 if threads_waiting == count then
 379                         threads_waiting = 0
 380                         cond.broadcast
 381                 else
 382                         cond.wait(mutex.native.as(not null))
 383                 end
 384                 mutex.unlock
 385         end
 386
 387         redef fun finalize
 388         do
 389                 var cond = self.cond
 390                 if cond != null then
 391                         cond.destroy
 392                         cond.free
 393                 end
 394                 self.cond = null
 395         end
 396 end
 397
 398 # Print `object` and '\n' with the same system call
 399 redef fun print(object)
 400 do
 401         sys.stdout.write(object.to_s+"\n")
 402 end