lib/Support/Threading.cpp

   1 //===-- llvm/Support/Threading.cpp- Control multithreading mode --*- C++ -*-==//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file implements llvm_start_multithreaded() and friends.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "llvm/Support/Threading.h"
  15 #include "llvm/Support/Atomic.h"
  16 #include "llvm/Support/Mutex.h"
  17 #include "llvm/Config/config.h"
  18 #include <cassert>
  19
  20 using namespace llvm;
  21
  22 static bool multithreaded_mode = false;
  23
  24 static sys::Mutex* global_lock = 0;
  25
  26 bool llvm::llvm_start_multithreaded() {
  27 #ifdef LLVM_MULTITHREADED
  28   assert(!multithreaded_mode && "Already multithreaded!");
  29   multithreaded_mode = true;
  30   global_lock = new sys::Mutex(true);
  31
  32   // We fence here to ensure that all initialization is complete BEFORE we
  33   // return from llvm_start_multithreaded().
  34   sys::MemoryFence();
  35   return true;
  36 #else
  37   return false;
  38 #endif
  39 }
  40
  41 void llvm::llvm_stop_multithreaded() {
  42 #ifdef LLVM_MULTITHREADED
  43   assert(multithreaded_mode && "Not currently multithreaded!");
  44
  45   // We fence here to insure that all threaded operations are complete BEFORE we
  46   // return from llvm_stop_multithreaded().
  47   sys::MemoryFence();
  48
  49   multithreaded_mode = false;
  50   delete global_lock;
  51 #endif
  52 }
  53
  54 bool llvm::llvm_is_multithreaded() {
  55   return multithreaded_mode;
  56 }
  57
  58 void llvm::llvm_acquire_global_lock() {
  59   if (multithreaded_mode) global_lock->acquire();
  60 }
  61
  62 void llvm::llvm_release_global_lock() {
  63   if (multithreaded_mode) global_lock->release();
  64 }
  65
  66 #if defined(LLVM_MULTITHREADED) && defined(HAVE_PTHREAD_H)
  67 #include <pthread.h>
  68
  69 struct ThreadInfo {
  70   void (*UserFn)(void *);
  71   void *UserData;
  72 };
  73 static void *ExecuteOnThread_Dispatch(void *Arg) {
  74   ThreadInfo *TI = reinterpret_cast<ThreadInfo*>(Arg);
  75   TI->UserFn(TI->UserData);
  76   return 0;
  77 }
  78
  79 void llvm::llvm_execute_on_thread(void (*Fn)(void*), void *UserData,
  80                                   unsigned RequestedStackSize) {
  81   ThreadInfo Info = { Fn, UserData };
  82   pthread_attr_t Attr;
  83   pthread_t Thread;
  84
  85   // Construct the attributes object.
  86   if (::pthread_attr_init(&Attr) != 0)
  87     return;
  88
  89   // Set the requested stack size, if given.
  90   if (RequestedStackSize != 0) {
  91     if (::pthread_attr_setstacksize(&Attr, RequestedStackSize) != 0)
  92       goto error;
  93   }
  94
  95   // Construct and execute the thread.
  96   if (::pthread_create(&Thread, &Attr, ExecuteOnThread_Dispatch, &Info) != 0)
  97     goto error;
  98
  99   // Wait for the thread and clean up.
 100   ::pthread_join(Thread, 0);
 101
 102  error:
 103   ::pthread_attr_destroy(&Attr);
 104 }
 105
 106 #else
 107
 108 // No non-pthread implementation, currently.
 109
 110 void llvm::llvm_execute_on_thread(void (*Fn)(void*), void *UserData,
 111                                   unsigned RequestedStackSize) {
 112   (void) RequestedStackSize;
 113   Fn(UserData);
 114 }
 115
 116 #endif