[llvm-commits] CVS: llvm/include/Support/ThreadSupport.h ThreadSupport-NoSupport.h ThreadSupport-PThreads.h
Chris Lattner
lattner at cs.uiuc.edu
Sat Jan 17 13:55:22 PST 2004
Changes in directory llvm/include/Support:
ThreadSupport.h added (r1.1)
ThreadSupport-NoSupport.h added (r1.1)
ThreadSupport-PThreads.h updated: 1.1 -> 1.2
---
Log message:
Revision of Brian's threading support library to be a bit more generic and
platform independent. This code is completely untested (but never used),
and needs autoconf support for detecting pthreads, but it's a start, and
deletes two emails from my inbox. :)
---
Diffs of the changes: (+99 -51)
Index: llvm/include/Support/ThreadSupport.h
diff -c /dev/null llvm/include/Support/ThreadSupport.h:1.1
*** /dev/null Sat Jan 17 13:54:39 2004
--- llvm/include/Support/ThreadSupport.h Sat Jan 17 13:54:29 2004
***************
*** 0 ****
--- 1,41 ----
+ //===-- 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
Index: llvm/include/Support/ThreadSupport-NoSupport.h
diff -c /dev/null llvm/include/Support/ThreadSupport-NoSupport.h:1.1
*** /dev/null Sat Jan 17 13:54:39 2004
--- llvm/include/Support/ThreadSupport-NoSupport.h Sat Jan 17 13:54:29 2004
***************
*** 0 ****
--- 1,34 ----
+ //===-- 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 () {}
+ };
+ }
Index: llvm/include/Support/ThreadSupport-PThreads.h
diff -u llvm/include/Support/ThreadSupport-PThreads.h:1.1 llvm/include/Support/ThreadSupport-PThreads.h:1.2
--- llvm/include/Support/ThreadSupport-PThreads.h:1.1 Mon Dec 1 15:33:29 2003
+++ llvm/include/Support/ThreadSupport-PThreads.h Sat Jan 17 13:54:29 2004
@@ -1,4 +1,4 @@
-//===-- Support/Lock.h - Platform-agnostic mutual exclusion -----*- C++ -*-===//
+//===-- Support/ThreadSupport-PThreads.h - PThreads support -----*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
@@ -7,63 +7,36 @@
//
//===----------------------------------------------------------------------===//
//
-// 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
More information about the llvm-commits
mailing list