From 59e47e3ee10840beb57ece10af04a6f9bf3495e9 Mon Sep 17 00:00:00 2001 From: Brian Gaeke Date: Mon, 1 Dec 2003 21:33:31 +0000 Subject: [PATCH] Lock abstraction, introduced with a view toward making the JIT thread-safe. Eventually. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@10284 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/Support/ThreadSupport-PThreads.h | 69 +++++++++++++++++++ include/llvm/Support/ThreadSupport-PThreads.h | 69 +++++++++++++++++++ lib/Support/Mutex.cpp | 24 +++++++ 3 files changed, 162 insertions(+) create mode 100644 include/Support/ThreadSupport-PThreads.h create mode 100644 include/llvm/Support/ThreadSupport-PThreads.h create mode 100644 lib/Support/Mutex.cpp diff --git a/include/Support/ThreadSupport-PThreads.h b/include/Support/ThreadSupport-PThreads.h new file mode 100644 index 00000000000..2fcbe72a81c --- /dev/null +++ b/include/Support/ThreadSupport-PThreads.h @@ -0,0 +1,69 @@ +//===-- Support/Lock.h - Platform-agnostic mutual exclusion -----*- 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 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. +// +//===----------------------------------------------------------------------===// + +#ifndef SUPPORT_LOCK_H +#define SUPPORT_LOCK_H + +#include +#include + +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. + /// + 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 (); } +}; + +} // end namespace llvm + +#endif // SUPPORT_LOCK_H diff --git a/include/llvm/Support/ThreadSupport-PThreads.h b/include/llvm/Support/ThreadSupport-PThreads.h new file mode 100644 index 00000000000..2fcbe72a81c --- /dev/null +++ b/include/llvm/Support/ThreadSupport-PThreads.h @@ -0,0 +1,69 @@ +//===-- Support/Lock.h - Platform-agnostic mutual exclusion -----*- 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 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. +// +//===----------------------------------------------------------------------===// + +#ifndef SUPPORT_LOCK_H +#define SUPPORT_LOCK_H + +#include +#include + +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. + /// + 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 (); } +}; + +} // end namespace llvm + +#endif // SUPPORT_LOCK_H diff --git a/lib/Support/Mutex.cpp b/lib/Support/Mutex.cpp new file mode 100644 index 00000000000..6271797da47 --- /dev/null +++ b/lib/Support/Mutex.cpp @@ -0,0 +1,24 @@ +//===-- Support/Lock.cpp - Platform-agnostic mutual exclusion -------------===// +// +// 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. +// +//===----------------------------------------------------------------------===// +// +// Implementation of various methods supporting platform-agnostic lock +// abstraction. See Support/Lock.h for details. +// +//===----------------------------------------------------------------------===// + +#include "Support/Lock.h" + +using namespace llvm; + +Lock Lock::create () { + // Currently we only support creating POSIX pthread_mutex_t locks. + // In the future we might want to construct different kinds of locks + // based on what OS is running. + return POSIXLock (); +} -- 2.34.1