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

[Nicolas Geoffray]

Author: geoffray
Date: Mon Oct 19 03:46:41 2009
New Revision: 84473

URL: http://llvm.org/viewvc/llvm-project?rev=84473&view=rev
Log:
Add a freelist cache for allocating JavaLocks.


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

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

==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h Mon Oct 19 03:46:41 2009
@@ -412,6 +412,10 @@
     static FatLock* allocate(UserCommonClass* cl) {
       return new(cl->classLoader->allocator, "Class fat lock") FatLock();
     }
+    
+    void deallocate() {
+      // Too bad, I can't deallocate it because it is in permanent memory.
+    }
 
     void acquire() {
       lockVar.lock();

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

==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaLocks.h (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaLocks.h Mon Oct 19 03:46:41 2009
@@ -26,6 +26,7 @@
 class JavaLock : public mvm::PermanentObject {
 
 friend class JavaObject;
+friend class LockSystem;
 
 private:
   mvm::LockRecursive internalLock;
@@ -33,6 +34,7 @@
   JavaThread* firstThread;
   JavaObject* associatedObject;
   uint32_t index;
+  JavaLock* nextFreeLock;
 
 public:
 
@@ -85,6 +87,7 @@
   }
 
   static JavaLock* allocate(JavaObject*);
+  void deallocate();
   
 };
 
@@ -94,6 +97,8 @@
 ///
 class LockSystem {
 public:
+  
+  // Fixed values. With these values, an index is on 18 bits.
   static const uint32_t GlobalSize = 128;
   static const uint32_t BitIndex = 11;
   static const uint32_t IndexSize = 1 << BitIndex;
@@ -110,7 +115,11 @@
   /// never decremented.
   ///
   uint32_t currentIndex;
-  
+ 
+  /// freeLock - The list of locks that are allocated and available.
+  ///
+  JavaLock* freeLock;
+ 
   /// threadLock - Spin lock to protect the currentIndex field.
   ///
   mvm::SpinLock threadLock;
@@ -122,11 +131,26 @@
   /// allocate - Allocate a JavaLock.
   ///
   JavaLock* allocate(JavaObject* obj); 
-  
+ 
+  /// deallocate - Put a lock in the free list lock.
+  ///
+  void deallocate(JavaLock* lock) {
+    lock->associatedObject = 0;
+    threadLock.lock();
+    lock->nextFreeLock = freeLock;
+    freeLock = lock;
+    threadLock.unlock();
+  }
+
   /// LockSystem - Default constructor. Initialize the table.
   ///
   LockSystem(Jnjvm* vm);
 
+  /// getLock - Get a lock from an index in the table.
+  ///
+  JavaLock* getLock(uint32_t index) {
+    return LockTable[index >> BitIndex][index & BitMask];
+  }
 };
 
 }

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

==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp Mon Oct 19 03:46:41 2009
@@ -1397,30 +1397,45 @@
   return res;
 }
 
+void JavaLock::deallocate() {
+  Jnjvm* vm = JavaThread::get()->getJVM();
+  vm->lockSystem.deallocate(this);
+}
+
 JavaLock* LockSystem::allocate(JavaObject* obj) { 
   
-// Get an index.
+  JavaLock* res = 0;
   threadLock.lock();
+
+  // Try the freeLock list.
+  if (freeLock) {
+    res = freeLock;
+    freeLock = res->nextFreeLock;
+    res->nextFreeLock = 0;
+    threadLock.unlock();
+    res->associatedObject = obj;
+  } else { 
+    // Get an index.
+    uint32_t index = currentIndex++;
+    if (index == MaxLocks) {
+      fprintf(stderr, "Ran out of space for allocating locks");
+      abort();
+    }
   
-  uint32_t index = currentIndex++;
-  if (index == MaxLocks) {
-    fprintf(stderr, "Ran out of space for allocating locks");
-    abort();
-  }
-  
-  JavaLock** tab = LockTable[index >> BitIndex];
+    JavaLock** tab = LockTable[index >> BitIndex];
   
-  if (tab == NULL) 
-    tab = (JavaLock**)associatedVM->allocator.Allocate(IndexSize,
-                                                       "Index LockTable");
-  threadLock.unlock();
+    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);
+    // Allocate the lock.
+    res = new(associatedVM->allocator, "Lock") JavaLock(index, obj);
     
-  // Add the lock to the table.
-  uint32_t internalIndex = index & BitMask;
-  tab[internalIndex] = res;
+    // Add the lock to the table.
+    uint32_t internalIndex = index & BitMask;
+    tab[internalIndex] = res;
+  }
     
   // Return the lock.
   return res;