[vmkit-commits] [vmkit] r84472 - in /vmkit/trunk/lib/JnJVM/VMCore: JavaLocks.h Jnjvm.cpp Jnjvm.h

[Nicolas Geoffray]

Author: geoffray
Date: Mon Oct 19 03:07:02 2009
New Revision: 84472

URL: http://llvm.org/viewvc/llvm-project?rev=84472&view=rev
Log:
Add a LockSystem to implement JavaLock allocations.


Modified:
    vmkit/trunk/lib/JnJVM/VMCore/JavaLocks.h
    vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp
    vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h

Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaLocks.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaLocks.h?rev=84472&r1=84471&r2=84472&view=diff

==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaLocks.h (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaLocks.h Mon Oct 19 03:07:02 2009
@@ -21,6 +21,7 @@
 
 class JavaObject;
 class JavaThread;
+class Jnjvm;
 
 class JavaLock : public mvm::PermanentObject {
 
@@ -75,11 +76,11 @@
     return internalLock.getOwner();
   }
   
-  /// JavaLock - Empty constructor.
-  JavaLock(uint32_t i) {
+  /// JavaLock - Default constructor.
+  JavaLock(uint32_t i, JavaObject* a) {
     firstThread = 0;
     index = i;
-    associatedObject = 0;
+    associatedObject = a;
     waitingThread = 0;
   }
 
@@ -87,6 +88,47 @@
   
 };
 
+/// LockSystem - This class manages all Java locks used by the applications.
+/// Each JVM must own an instance of this class and allocate Java locks
+/// with it.
+///
+class LockSystem {
+public:
+  static const uint32_t GlobalSize = 128;
+  static const uint32_t BitIndex = 11;
+  static const uint32_t IndexSize = 1 << BitIndex;
+  static const uint32_t BitMask = IndexSize - 1;
+  static const uint32_t MaxLocks = GlobalSize * IndexSize;
+
+  /// LockTable - The global table that will hold the locks. The table is
+  /// a two-dimensional array, and only one entry is created, so that
+  /// the lock system does not eat up all memory on startup.
+  ///  
+  JavaLock* ** LockTable;
+  
+  /// currentIndex - The current index in the tables. Always incremented,
+  /// never decremented.
+  ///
+  uint32_t currentIndex;
+  
+  /// threadLock - Spin lock to protect the currentIndex field.
+  ///
+  mvm::SpinLock threadLock;
+  
+  /// associatedVM - The JVM associated with this lock system.
+  ///
+  Jnjvm* associatedVM;  
+
+  /// allocate - Allocate a JavaLock.
+  ///
+  JavaLock* allocate(JavaObject* obj); 
+  
+  /// LockSystem - Default constructor. Initialize the table.
+  ///
+  LockSystem(Jnjvm* vm);
+
+};
+
 }
 
 #endif

Modified: vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp?rev=84472&r1=84471&r2=84472&view=diff

==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp Mon Oct 19 03:07:02 2009
@@ -1269,7 +1269,7 @@
 }
 
 Jnjvm::Jnjvm(mvm::BumpPtrAllocator& Alloc, JnjvmBootstrapLoader* loader) : 
-  VirtualMachine(Alloc) {
+  VirtualMachine(Alloc), lockSystem(this) {
 
   classpath = getenv("CLASSPATH");
   if (!classpath) classpath = ".";
@@ -1393,7 +1393,44 @@
 
 JavaLock* JavaLock::allocate(JavaObject* obj) {
   Jnjvm* vm = JavaThread::get()->getJVM();
-  JavaLock* res = new(vm->allocator, "Lock") JavaLock(0);
-  res->associatedObject = obj;
+  JavaLock* res = vm->lockSystem.allocate(obj);  
   return res;
 }
+
+JavaLock* LockSystem::allocate(JavaObject* obj) { 
+  
+// Get an index.
+  threadLock.lock();
+  
+  uint32_t index = currentIndex++;
+  if (index == MaxLocks) {
+    fprintf(stderr, "Ran out of space for allocating locks");
+    abort();
+  }
+  
+  JavaLock** tab = LockTable[index >> BitIndex];
+  
+  if (tab == NULL) 
+    tab = (JavaLock**)associatedVM->allocator.Allocate(IndexSize,
+                                                       "Index LockTable");
+  threadLock.unlock();
+   
+  // Allocate the lock.
+  JavaLock* res = new(associatedVM->allocator, "Lock") JavaLock(index, obj);
+    
+  // Add the lock to the table.
+  uint32_t internalIndex = index & BitMask;
+  tab[internalIndex] = res;
+    
+  // Return the lock.
+  return res;
+}
+  
+LockSystem::LockSystem(Jnjvm* vm) {
+  associatedVM = vm;
+  LockTable = (JavaLock* **)
+    vm->allocator.Allocate(GlobalSize, "Global LockTable");
+  LockTable[0] = (JavaLock**)
+    vm->allocator.Allocate(IndexSize, "Index LockTable");
+  currentIndex = 0;
+}

Modified: vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h?rev=84472&r1=84471&r2=84472&view=diff

==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h Mon Oct 19 03:07:02 2009
@@ -20,6 +20,7 @@
 #include "mvm/Threads/Cond.h"
 #include "mvm/Threads/Locks.h"
 
+#include "JavaLocks.h"
 #include "JnjvmConfig.h"
 #include "JNIReferences.h"
 #include "LockedMap.h"
@@ -191,6 +192,10 @@
   ///
   ThreadSystem threadSystem;
   
+  /// lockSystem - The lock system to allocate and manage Java locks.
+  ///
+  LockSystem lockSystem;
+  
   /// argumentsInfo - The command line arguments given to the vm
   ///
   ClArgumentsInfo argumentsInfo;