--- /dev/null
+//===-- Support/ThreadSupport-NoSupport.h - Generic impl --------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file was developed by the LLVM research group and is distributed under
+// the University of Illinois Open Source License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines a generic ThreadSupport implementation used when there is
+// no supported threading mechanism on the current system. Users should never
+// #include this file directly!
+//
+//===----------------------------------------------------------------------===//
+
+// Users should never #include this file directly! As such, no include guards
+// are needed.
+
+#ifndef SUPPORT_THREADSUPPORT_H
+#error "Code should not #include Support/ThreadSupport-NoSupport.h directly!"
+#endif
+
+namespace llvm {
+ /// Mutex - This class allows user code to protect variables shared between
+ /// threads. It implements a "recursive" mutex, to simplify user code.
+ ///
+ /// Since there is no platform support for _creating threads_, the non-thread
+ /// implementation of this class is a noop.
+ ///
+ struct Mutex {
+ void acquire () {}
+ void release () {}
+ };
+}
-//===-- Support/Lock.h - Platform-agnostic mutual exclusion -----*- C++ -*-===//
+//===-- Support/ThreadSupport-PThreads.h - PThreads support -----*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
//
//===----------------------------------------------------------------------===//
//
-// This file contains classes that implement locks (mutual exclusion
-// variables) in a platform-agnostic way. Basically the user should
-// just call Lock::create() to get a Lock object of the correct sort
-// for the current platform, and use its acquire() and release()
-// methods, or a LockHolder, to protect critical sections of code for
-// thread-safety.
+// This file defines pthreads implementations of the generic threading
+// mechanisms. Users should never #include this file directly!
//
//===----------------------------------------------------------------------===//
-#ifndef SUPPORT_LOCK_H
-#define SUPPORT_LOCK_H
+// Users should never #include this file directly! As such, no include guards
+// are needed.
+
+#ifndef SUPPORT_THREADSUPPORT_H
+#error "Code should not #include Support/ThreadSupport/PThreads.h directly!"
+#endif
#include <pthread.h>
-#include <cstdlib>
namespace llvm {
-/// Lock - Abstract class that provides mutual exclusion (also known
-/// as a mutex.)
-///
-class Lock {
-protected:
- virtual ~Lock() {} // Derive from me
-public:
- virtual void acquire () { abort (); }
- virtual void release () { abort (); }
-
- /// create - Static method that returns a Lock of the correct class
- /// for the current host OS.
+ /// Mutex - This class allows user code to protect variables shared between
+ /// threads. It implements a "recursive" mutex, to simplify user code.
///
- static Lock create ();
-};
-
-/// POSIXLock - Specialization of Lock class implemented using
-/// pthread_mutex_t objects.
-///
-class POSIXLock : public Lock {
- pthread_mutex_t mutex;
-public:
- POSIXLock () { pthread_mutex_init (&mutex, 0); }
- virtual ~POSIXLock () { pthread_mutex_destroy (&mutex); }
- virtual void acquire () { pthread_mutex_lock (&mutex); }
- virtual void release () { pthread_mutex_unlock (&mutex); }
-};
-
-/// LockHolder - Instances of this class acquire a given Lock when
-/// constructed and hold that lock until destruction. Uncle Bjarne
-/// says, "Resource acquisition is allocation." Or is it the other way
-/// around? I never can remember.
-///
-class LockHolder {
- Lock &L;
-public:
- LockHolder (Lock &_L) : L (_L) { L.acquire (); }
- ~LockHolder () { L.release (); }
-};
-
+ class Mutex {
+ pthread_mutex_t mutex;
+ Mutex(const Mutex &); // DO NOT IMPLEMENT
+ void operator=(const Mutex &); // DO NOT IMPLEMENT
+ public:
+ Mutex() {
+ pthread_mutexattr_t Attr;
+ pthread_mutex_init(&mutex, &Attr);
+ }
+ ~Mutex() { pthread_mutex_destroy(&mutex); }
+ void acquire () { pthread_mutex_lock (&mutex); }
+ void release () { pthread_mutex_unlock (&mutex); }
+ };
} // end namespace llvm
-
-#endif // SUPPORT_LOCK_H
--- /dev/null
+//===-- Support/ThreadSupport.h - Generic threading support -----*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file was developed by the LLVM research group and is distributed under
+// the University of Illinois Open Source License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines platform-agnostic interfaces that can be used to write
+// multi-threaded programs. Autoconf is used to chose the correct
+// implementation of these interfaces, or default to a non-thread-capable system
+// if no matching system support is available.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SUPPORT_THREADSUPPORT_H
+#define SUPPORT_THREADSUPPORT_H
+
+// FIXME: We need autoconf support to detect pthreads!
+#if 0
+#include "Support/ThreadSupport-PThreads.h"
+#else
+#include "Support/ThreadSupport-NoSupport.h"
+#endif // If no system support is available
+
+namespace llvm {
+ /// LockHolder - Instances of this class acquire a given Lock when constructed
+ /// and hold that lock until destruction.
+ ///
+ class MutexLocker {
+ Mutex &M;
+ MutexLocker(const LockHolder &); // DO NOT IMPLEMENT
+ void operator=(const MutexLocker&); // DO NOT IMPLEMENT
+ public:
+ MutexLocker(Mutex &m) : M(m) { M.acquire(); }
+ ~MutexLocker() { M.release(); }
+ };
+}
+
+#endif // SUPPORT_THREADSUPPORT_H
--- /dev/null
+//===-- Support/ThreadSupport-NoSupport.h - Generic impl --------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file was developed by the LLVM research group and is distributed under
+// the University of Illinois Open Source License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines a generic ThreadSupport implementation used when there is
+// no supported threading mechanism on the current system. Users should never
+// #include this file directly!
+//
+//===----------------------------------------------------------------------===//
+
+// Users should never #include this file directly! As such, no include guards
+// are needed.
+
+#ifndef SUPPORT_THREADSUPPORT_H
+#error "Code should not #include Support/ThreadSupport-NoSupport.h directly!"
+#endif
+
+namespace llvm {
+ /// Mutex - This class allows user code to protect variables shared between
+ /// threads. It implements a "recursive" mutex, to simplify user code.
+ ///
+ /// Since there is no platform support for _creating threads_, the non-thread
+ /// implementation of this class is a noop.
+ ///
+ struct Mutex {
+ void acquire () {}
+ void release () {}
+ };
+}
-//===-- Support/Lock.h - Platform-agnostic mutual exclusion -----*- C++ -*-===//
+//===-- Support/ThreadSupport-PThreads.h - PThreads support -----*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
//
//===----------------------------------------------------------------------===//
//
-// This file contains classes that implement locks (mutual exclusion
-// variables) in a platform-agnostic way. Basically the user should
-// just call Lock::create() to get a Lock object of the correct sort
-// for the current platform, and use its acquire() and release()
-// methods, or a LockHolder, to protect critical sections of code for
-// thread-safety.
+// This file defines pthreads implementations of the generic threading
+// mechanisms. Users should never #include this file directly!
//
//===----------------------------------------------------------------------===//
-#ifndef SUPPORT_LOCK_H
-#define SUPPORT_LOCK_H
+// Users should never #include this file directly! As such, no include guards
+// are needed.
+
+#ifndef SUPPORT_THREADSUPPORT_H
+#error "Code should not #include Support/ThreadSupport/PThreads.h directly!"
+#endif
#include <pthread.h>
-#include <cstdlib>
namespace llvm {
-/// Lock - Abstract class that provides mutual exclusion (also known
-/// as a mutex.)
-///
-class Lock {
-protected:
- virtual ~Lock() {} // Derive from me
-public:
- virtual void acquire () { abort (); }
- virtual void release () { abort (); }
-
- /// create - Static method that returns a Lock of the correct class
- /// for the current host OS.
+ /// Mutex - This class allows user code to protect variables shared between
+ /// threads. It implements a "recursive" mutex, to simplify user code.
///
- static Lock create ();
-};
-
-/// POSIXLock - Specialization of Lock class implemented using
-/// pthread_mutex_t objects.
-///
-class POSIXLock : public Lock {
- pthread_mutex_t mutex;
-public:
- POSIXLock () { pthread_mutex_init (&mutex, 0); }
- virtual ~POSIXLock () { pthread_mutex_destroy (&mutex); }
- virtual void acquire () { pthread_mutex_lock (&mutex); }
- virtual void release () { pthread_mutex_unlock (&mutex); }
-};
-
-/// LockHolder - Instances of this class acquire a given Lock when
-/// constructed and hold that lock until destruction. Uncle Bjarne
-/// says, "Resource acquisition is allocation." Or is it the other way
-/// around? I never can remember.
-///
-class LockHolder {
- Lock &L;
-public:
- LockHolder (Lock &_L) : L (_L) { L.acquire (); }
- ~LockHolder () { L.release (); }
-};
-
+ class Mutex {
+ pthread_mutex_t mutex;
+ Mutex(const Mutex &); // DO NOT IMPLEMENT
+ void operator=(const Mutex &); // DO NOT IMPLEMENT
+ public:
+ Mutex() {
+ pthread_mutexattr_t Attr;
+ pthread_mutex_init(&mutex, &Attr);
+ }
+ ~Mutex() { pthread_mutex_destroy(&mutex); }
+ void acquire () { pthread_mutex_lock (&mutex); }
+ void release () { pthread_mutex_unlock (&mutex); }
+ };
} // end namespace llvm
-
-#endif // SUPPORT_LOCK_H
projects / oota-llvm.git / commitdiff