[vmkit-commits] [vmkit] r136466 - in /vmkit/trunk: include/mvm/UTF8.h lib/J3/VMCore/JnjvmClassLoader.cpp lib/J3/VMCore/LockedMap.cpp lib/J3/VMCore/LockedMap.h
Nicolas Geoffray
nicolas.geoffray at lip6.fr
Fri Jul 29 09:44:36 PDT 2011
Author: geoffray
Date: Fri Jul 29 11:44:36 2011
New Revision: 136466
URL: http://llvm.org/viewvc/llvm-project?rev=136466&view=rev
Log:
Clean up LockedMap, and use DenseMap as much as possible.
Modified:
vmkit/trunk/include/mvm/UTF8.h
vmkit/trunk/lib/J3/VMCore/JnjvmClassLoader.cpp
vmkit/trunk/lib/J3/VMCore/LockedMap.cpp
vmkit/trunk/lib/J3/VMCore/LockedMap.h
Modified: vmkit/trunk/include/mvm/UTF8.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/mvm/UTF8.h?rev=136466&r1=136465&r2=136466&view=diff
==============================================================================
--- vmkit/trunk/include/mvm/UTF8.h (original)
+++ vmkit/trunk/include/mvm/UTF8.h Fri Jul 29 11:44:36 2011
@@ -19,10 +19,6 @@
return allocator.Allocate(sizeof(UTF8) + (n - 1) * sizeof(uint16), "UTF8");
}
- UTF8(sint32 n) {
- size = n;
- }
-
public:
/// size - The (constant) size of the array.
ssize_t size;
@@ -63,7 +59,10 @@
uint32_t hash() const {
return readerHasher(elements, size);
}
-
+
+ UTF8(sint32 n) {
+ size = n;
+ }
};
Modified: vmkit/trunk/lib/J3/VMCore/JnjvmClassLoader.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/JnjvmClassLoader.cpp?rev=136466&r1=136465&r2=136466&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/JnjvmClassLoader.cpp (original)
+++ vmkit/trunk/lib/J3/VMCore/JnjvmClassLoader.cpp Fri Jul 29 11:44:36 2011
@@ -551,7 +551,10 @@
}
UserCommonClass* JnjvmClassLoader::lookupClass(const UTF8* utf8) {
- return classes->lookup(utf8);
+ classes->lock.lock();
+ UserCommonClass* cl = classes->map.lookup(utf8);
+ classes->lock.unlock();
+ return cl;
}
UserCommonClass* JnjvmClassLoader::loadBaseClass(const UTF8* name,
@@ -604,12 +607,9 @@
UserClass* res = NULL;
lock.lock();
classes->lock.lock();
- ClassMap::iterator End = classes->map.end();
- ClassMap::iterator I = classes->map.find(name);
+ res = (UserClass*) classes->map.lookup(name);
classes->lock.unlock();
- if (I != End) {
- res = ((UserClass*)(I->second));
- } else {
+ if (res == NULL) {
TRY {
const UTF8* internalName = readerConstructUTF8(name->elements, name->size);
res = new(allocator, "Class") UserClass(this, internalName, bytes);
@@ -620,18 +620,18 @@
classes->lock.lock();
assert(res->getDelegatee() == NULL);
assert(res->getStaticInstance() == NULL);
- bool success = classes->map.insert(std::make_pair(internalName, res)).second;
+ assert(classes->map.lookup(internalName) == NULL);
+ classes->map[internalName] = res;
classes->lock.unlock();
- assert(success && "Could not add class in map");
} CATCH {
excp = JavaThread::get()->pendingException;
JavaThread::get()->clearException();
} END_CATCH;
}
+ lock.unlock();
if (excp != NULL) {
JavaThread::get()->throwException(excp);
}
- lock.unlock();
if (res->super == NULL) {
// java.lang.Object just got created, initialise VTs of arrays.
@@ -645,17 +645,14 @@
assert(baseClass && "constructing an array class without a base class");
assert(baseClass->classLoader == this &&
"constructing an array with wrong loader");
- classes->lock.lock();
- ClassMap::iterator End = classes->map.end();
- ClassMap::iterator I = classes->map.find(name);
UserClassArray* res = 0;
- if (I == End) {
+ classes->lock.lock();
+ res = (UserClassArray*) classes->map.lookup(name);
+ if (res == NULL) {
const UTF8* internalName = readerConstructUTF8(name->elements, name->size);
res = new(allocator, "Array class") UserClassArray(this, internalName,
baseClass);
classes->map.insert(std::make_pair(internalName, res));
- } else {
- res = ((UserClassArray*)(I->second));
}
classes->lock.unlock();
return res;
@@ -686,10 +683,10 @@
Typedef* JnjvmClassLoader::constructType(const UTF8* name) {
javaTypes->lock.lock();
- Typedef* res = javaTypes->lookup(name);
+ Typedef* res = javaTypes->map.lookup(name);
if (res == 0) {
res = internalConstructType(name);
- javaTypes->hash(name, res);
+ javaTypes->map[name] = res;
}
javaTypes->lock.unlock();
return res;
@@ -762,7 +759,7 @@
Signdef* JnjvmClassLoader::constructSign(const UTF8* name) {
javaSignatures->lock.lock();
- Signdef* res = javaSignatures->lookup(name);
+ Signdef* res = javaSignatures->map.lookup(name);
if (res == 0) {
std::vector<Typedef*> buf;
uint32 len = (uint32)name->size;
@@ -792,7 +789,7 @@
res = new(allocator, buf.size()) Signdef(name, this, buf, ret);
- javaSignatures->hash(name, res);
+ javaSignatures->map[name] = res;
}
javaSignatures->lock.unlock();
return res;
Modified: vmkit/trunk/lib/J3/VMCore/LockedMap.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/LockedMap.cpp?rev=136466&r1=136465&r2=136466&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/LockedMap.cpp (original)
+++ vmkit/trunk/lib/J3/VMCore/LockedMap.cpp Fri Jul 29 11:44:36 2011
@@ -15,10 +15,6 @@
using namespace j3;
-bool ltutf8::operator()(const UTF8* s1, const UTF8* s2) const {
- return s1->lessThan(s2);
-}
-
bool ltarray16::operator()(const ArrayUInt16* s1, const ArrayUInt16* s2) const {
llvm_gcroot(s1, 0);
llvm_gcroot(s2, 0);
Modified: vmkit/trunk/lib/J3/VMCore/LockedMap.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/LockedMap.h?rev=136466&r1=136465&r2=136466&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/LockedMap.h (original)
+++ vmkit/trunk/lib/J3/VMCore/LockedMap.h Fri Jul 29 11:44:36 2011
@@ -16,6 +16,8 @@
#ifndef JNJVM_LOCKED_MAP_H
#define JNJVM_LOCKED_MAP_H
+#include "llvm/ADT/DenseMap.h"
+
#include <map>
#include <cstring>
@@ -26,10 +28,28 @@
#include "mvm/Threads/Locks.h"
#include "UTF8.h"
-#include "JavaArray.h" // for comparing UTF8s
+namespace llvm {
+// Provide DenseMapInfo for UTF8.
+template<>
+struct DenseMapInfo<const j3::UTF8*> {
+ static inline const j3::UTF8* getEmptyKey() {
+ static j3::UTF8 emptyKey(0);
+ return &emptyKey;
+ }
+ static inline const j3::UTF8* getTombstoneKey() {
+ static j3::UTF8 tombstoneKey(0);
+ return &tombstoneKey;
+ }
+ static unsigned getHashValue(const j3::UTF8* PtrVal) {
+ return PtrVal->hash();
+ }
+ static bool isEqual(const j3::UTF8* LHS, const j3::UTF8* RHS) { return LHS->equals(RHS); }
+};
+}
namespace j3 {
+class ArrayUInt16;
class JavaString;
class JnjvmClassLoader;
class Signdef;
@@ -37,155 +57,95 @@
class UserCommonClass;
class UserClassArray;
-struct ltutf8 {
- bool operator()(const UTF8* s1, const UTF8* s2) const;
-};
-
struct ltarray16 {
bool operator()(const ArrayUInt16* s1, const ArrayUInt16* s2) const;
};
-class MapNoGC {
+class StringMap : public mvm::PermanentObject {
public:
- static void gcroot(void* val, void* unused)
- __attribute__ ((always_inline)) {}
-
-};
-
-class MapWithGC {
-public:
- static void gcroot(void* val, void* unused)
- __attribute__ ((always_inline)) {
- llvm_gcroot(val, unused);
- }
-
-};
-
+ typedef std::map<const ArrayUInt16*, JavaString*, ltarray16>::iterator iterator;
+ typedef JavaString* (*funcCreate)(const ArrayUInt16*& V, Jnjvm* vm);
-template<class Key, class Container, class Compare, class Meta, class TLock,
- class IsGC>
-class LockedMap : public mvm::PermanentObject {
-public:
- typedef typename std::map<const Key, Container, Compare>::iterator iterator;
- typedef Container (*funcCreate)(Key& V, Meta meta);
-
- TLock lock;
- std::map<const Key, Container, Compare,
- std::allocator<std::pair<const Key, Container> > > map;
+ mvm::LockNormal lock;
+ std::map<const ArrayUInt16*, JavaString*, ltarray16,
+ std::allocator<std::pair<const ArrayUInt16*, JavaString*> > > map;
- inline Container lookupOrCreate(Key& V, Meta meta, funcCreate func) {
- Container res = 0;
- IsGC::gcroot(res, 0);
- IsGC::gcroot((void*)V, 0);
+ inline JavaString* lookupOrCreate(const ArrayUInt16* array, Jnjvm* vm, funcCreate func) {
+ JavaString* res = 0;
+ llvm_gcroot(res, 0);
+ llvm_gcroot(array, 0);
lock.lock();
iterator End = map.end();
- iterator I = map.find(V);
+ iterator I = map.find(array);
if (I == End) {
- res = func(V, meta);
- map.insert(std::make_pair(V, res));
+ res = func(array, vm);
+ map.insert(std::make_pair(array, res));
lock.unlock();
return res;
} else {
lock.unlock();
- return ((Container)(I->second));
+ return ((JavaString*)(I->second));
}
}
- inline void remove(Key V) {
- IsGC::gcroot(V, 0);
- lock.lock();
- map.erase(V);
- lock.unlock();
- }
-
- inline void remove(Key V, Container C) {
- IsGC::gcroot(C, 0);
- IsGC::gcroot(V, 0);
+ inline void remove(const ArrayUInt16* array) {
+ llvm_gcroot(array, 0);
lock.lock();
- removeUnlocked(V, C);
+ map.erase(array);
lock.unlock();
}
- inline void removeUnlocked(Key V, Container C) {
- IsGC::gcroot(C, 0);
- IsGC::gcroot((void*)V, 0);
- iterator End = map.end();
- iterator I = map.find(V);
-
- if (I != End && I->second == C)
- map.erase(I);
- }
-
- inline Container lookup(Key V) {
- IsGC::gcroot((void*)V, 0);
+ inline JavaString* lookup(const ArrayUInt16* array) {
+ llvm_gcroot(array, 0);
lock.lock();
iterator End = map.end();
- iterator I = map.find(V);
+ iterator I = map.find(array);
lock.unlock();
- return I != End ? ((Container)(I->second)) : 0;
+ return I != End ? ((JavaString*)(I->second)) : 0;
}
- inline void hash(Key k, Container c) {
- IsGC::gcroot(c, 0);
- IsGC::gcroot(k, 0);
+ inline void hash(const ArrayUInt16* array, JavaString* str) {
+ llvm_gcroot(array, 0);
+ llvm_gcroot(str, 0);
lock.lock();
- map.insert(std::make_pair(k, c));
+ map.insert(std::make_pair(array, str));
lock.unlock();
}
- ~LockedMap() {}
-};
+ inline void removeUnlocked(const ArrayUInt16* array, JavaString* str) {
+ llvm_gcroot(str, 0);
+ llvm_gcroot(array, 0);
+ iterator End = map.end();
+ iterator I = map.find(array);
+
+ if (I != End && I->second == str) map.erase(I);
+ }
-class ClassMap :
- public LockedMap<const UTF8*, UserCommonClass*, ltutf8, JnjvmClassLoader*,
- mvm::LockRecursive, MapNoGC > {
+ ~StringMap() {}
+ void insert(JavaString* str);
};
-class StringMap :
- public LockedMap<const ArrayUInt16*, JavaString*, ltarray16, Jnjvm*,
- mvm::LockNormal, MapWithGC> {
+class ClassMap : public mvm::PermanentObject {
public:
- void insert(JavaString* str);
-
+ mvm::LockRecursive lock;
+ llvm::DenseMap<const UTF8*, UserCommonClass*> map;
+ typedef llvm::DenseMap<const UTF8*, UserCommonClass*>::iterator iterator;
};
class TypeMap : public mvm::PermanentObject {
public:
mvm::LockNormal lock;
-
- std::map<const UTF8*, Typedef*, ltutf8> map;
- typedef std::map<const UTF8*, Typedef*, ltutf8>::iterator iterator;
-
- inline Typedef* lookup(const UTF8* V) {
- iterator End = map.end();
- iterator I = map.find(V);
- return I != End ? I->second : 0;
- }
-
- inline void hash(const UTF8* k, Typedef* c) {
- map.insert(std::make_pair(k, c));
- }
+ llvm::DenseMap<const UTF8*, Typedef*> map;
+ typedef llvm::DenseMap<const UTF8*, Typedef*>::iterator iterator;
};
class SignMap : public mvm::PermanentObject {
public:
mvm::LockNormal lock;
-
- std::map<const UTF8*, Signdef*, ltutf8> map;
- typedef std::map<const UTF8*, Signdef*, ltutf8>::iterator iterator;
-
- inline Signdef* lookup(const UTF8* V) {
- iterator End = map.end();
- iterator I = map.find(V);
- return I != End ? I->second : 0;
- }
-
- inline void hash(const UTF8* k, Signdef* c) {
- map.insert(std::make_pair(k, c));
- }
-
+ llvm::DenseMap<const UTF8*, Signdef*> map;
+ typedef llvm::DenseMap<const UTF8*, Signdef*>::iterator iterator;
};
} // end namespace j3
More information about the vmkit-commits
mailing list