[vmkit-commits] [vmkit] r57443 - in /vmkit/trunk: include/mvm/ include/mvm/Threads/ lib/JnJVM/Classpath/ lib/JnJVM/VMCore/
Nicolas Geoffray
nicolas.geoffray at lip6.fr
Mon Oct 13 09:39:00 PDT 2008
Author: geoffray
Date: Mon Oct 13 11:38:59 2008
New Revision: 57443
URL: http://llvm.org/viewvc/llvm-project?rev=57443&view=rev
Log:
Use LLVM's BumpPtrAllocator to allocate memory for a class loader.
Modified:
vmkit/trunk/include/mvm/Allocator.h
vmkit/trunk/include/mvm/Threads/Thread.h
vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMObject.cpp
vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThrowable.cpp
vmkit/trunk/lib/JnJVM/VMCore/JavaArray.cpp
vmkit/trunk/lib/JnJVM/VMCore/JavaArray.h
vmkit/trunk/lib/JnJVM/VMCore/JavaCache.cpp
vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp
vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h
vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp
vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.h
vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp
vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp
vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp
vmkit/trunk/lib/JnJVM/VMCore/JavaString.cpp
vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp
vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h
vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp
vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h
vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp
vmkit/trunk/lib/JnJVM/VMCore/LockedMap.h
vmkit/trunk/lib/JnJVM/VMCore/Zip.cpp
vmkit/trunk/lib/JnJVM/VMCore/Zip.h
Modified: vmkit/trunk/include/mvm/Allocator.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/mvm/Allocator.h?rev=57443&r1=57442&r2=57443&view=diff
==============================================================================
--- vmkit/trunk/include/mvm/Allocator.h (original)
+++ vmkit/trunk/include/mvm/Allocator.h Mon Oct 13 11:38:59 2008
@@ -12,7 +12,10 @@
#include <cstdlib>
+#include "llvm/Support/Allocator.h"
+
#include "MvmGC.h"
+#include "mvm/Threads/Locks.h"
#ifdef MULTIPLE_GC
#define allocator_new(alloc, cl) collector_new(cl, alloc.GC)
@@ -58,10 +61,26 @@
}
};
+class BumpPtrAllocator {
+private:
+ LockNormal TheLock;
+ llvm::BumpPtrAllocator Allocator;
+public:
+ void* Allocate(size_t sz) {
+ TheLock.lock();
+ void* res = Allocator.Allocate(sz, sz % 4 ? sizeof(void*) : 1);
+ TheLock.unlock();
+ return res;
+ }
+
+ void Deallocate(void* obj) {}
+};
+
+
class PermanentObject {
public:
- void* operator new(size_t sz, Allocator* allocator) {
- return allocator->allocatePermanentMemory(sz);
+ void* operator new(size_t sz, BumpPtrAllocator& allocator) {
+ return allocator.Allocate(sz);
}
void operator delete(void* ptr) {
Modified: vmkit/trunk/include/mvm/Threads/Thread.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/mvm/Threads/Thread.h?rev=57443&r1=57442&r2=57443&view=diff
==============================================================================
--- vmkit/trunk/include/mvm/Threads/Thread.h (original)
+++ vmkit/trunk/include/mvm/Threads/Thread.h Mon Oct 13 11:38:59 2008
@@ -13,11 +13,11 @@
#include "types.h"
#include "MvmGC.h"
-#include "mvm/Allocator.h"
#include "mvm/JIT.h"
#include "mvm/Threads/Key.h"
+class Allocator;
class Collector;
namespace mvm {
Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMObject.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMObject.cpp?rev=57443&r1=57442&r2=57443&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMObject.cpp (original)
+++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMObject.cpp Mon Oct 13 11:38:59 2008
@@ -41,7 +41,7 @@
size = cl->getVirtualSize();
}
JavaObject* res = (JavaObject*)
- vm->allocator->allocateManagedObject(size, src->getVirtualTable());
+ vm->gcAllocator.allocateManagedObject(size, src->getVirtualTable());
memcpy(res, src, size);
res->lock = 0;
return (jobject)res;
Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThrowable.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThrowable.cpp?rev=57443&r1=57442&r2=57443&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThrowable.cpp (original)
+++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThrowable.cpp Mon Oct 13 11:38:59 2008
@@ -39,7 +39,7 @@
jobject throwable) {
Jnjvm* vm = JavaThread::get()->isolate;
int** stack =
- (int**)vm->allocator->allocateTemporaryMemory(sizeof(int*) * 100);
+ (int**)vm->gcAllocator.allocateTemporaryMemory(sizeof(int*) * 100);
int real_size = mvm::MvmModule::getBacktrace((void**)stack, 100);
stack[real_size] = 0;
JavaObject* vmThrowable = vm->upcalls->newVMThrowable->doNew(vm);
@@ -116,7 +116,7 @@
}
}
jobject res = (jobject)recGetStackTrace((int**)(uint32**)stack, first, 0);
- vm->allocator->freeTemporaryMemory(stack);
+ vm->gcAllocator.freeTemporaryMemory(stack);
return res;
}
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaArray.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaArray.cpp?rev=57443&r1=57442&r2=57443&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaArray.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaArray.cpp Mon Oct 13 11:38:59 2008
@@ -108,12 +108,8 @@
#endif
}
-void* UTF8::operator new(size_t sz, mvm::Allocator* allocator, sint32 size) {
- return allocator->allocatePermanentMemory(sz + size * sizeof(uint16));
-}
-
const UTF8* UTF8::acons(sint32 n, UserClassArray* cl,
- mvm::Allocator* allocator) {
+ mvm::BumpPtrAllocator& allocator) {
assert(n >= 0 && "Creating an UTF8 with a size < 0");
assert(n <= JavaArray::MaxArraySize &&
"Creating an UTF8 with a size too big");
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaArray.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaArray.h?rev=57443&r1=57442&r2=57443&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaArray.h (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaArray.h Mon Oct 13 11:38:59 2008
@@ -117,7 +117,7 @@
/// acons - Allocates an UTF8 in permanent memory. The class argument must be
/// JavaArray::ofChar.
static const UTF8* acons(sint32 n, UserClassArray* cl,
- mvm::Allocator* allocator);
+ mvm::BumpPtrAllocator& allocator);
/// internalToJava - Creates a copy of the UTF8 at its given offset and size
/// woth all its '.' replaced by '/'. The JVM bytecode reference classes in
@@ -165,7 +165,10 @@
/// operator new - Redefines the new operator of this class to allocate
/// its objects in permanent memory, not with the garbage collector.
- void* operator new(size_t sz, mvm::Allocator* allocator, sint32 size);
+ void* operator new(size_t sz, mvm::BumpPtrAllocator& allocator,
+ sint32 size) {
+ return allocator.Allocate(sz + size * sizeof(uint16));
+ }
};
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaCache.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaCache.cpp?rev=57443&r1=57442&r2=57443&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaCache.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaCache.cpp Mon Oct 13 11:38:59 2008
@@ -29,9 +29,11 @@
Enveloppe::~Enveloppe() {
CacheNode* cache = firstCache;
CacheNode* next = firstCache;
+ mvm::BumpPtrAllocator& allocator = ctpInfo->classDef->classLoader->allocator;
while(next) {
next = cache->next;
- delete cache;
+ cache->~CacheNode();
+ allocator.Deallocate(cache);
cache = next;
}
}
@@ -47,7 +49,7 @@
}
Enveloppe::Enveloppe(UserConstantPool* ctp, uint32 i) {
- mvm::Allocator* allocator = ctp->classDef->classLoader->allocator;
+ mvm::BumpPtrAllocator& allocator = ctp->classDef->classLoader->allocator;
firstCache = new(allocator) CacheNode(this);
ctpInfo = ctp;
index = i;
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp?rev=57443&r1=57442&r2=57443&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp Mon Oct 13 11:38:59 2008
@@ -90,7 +90,7 @@
CommonClass::~CommonClass() {
- delete display;
+ classLoader->allocator.Deallocate(display);
}
CommonClass::CommonClass() {
@@ -110,47 +110,57 @@
for (std::vector<Attribut*>::iterator i = attributs.begin(),
e = attributs.end(); i!= e; ++i) {
Attribut* cur = *i;
- delete cur;
+ cur->~Attribut();
+ classLoader->allocator.Deallocate(cur);
}
for (field_iterator i = staticFields.begin(),
e = staticFields.end(); i!= e; ++i) {
JavaField* cur = i->second;
- delete cur;
+ cur->~JavaField();
+ classLoader->allocator.Deallocate(cur);
}
for (field_iterator i = virtualFields.begin(),
e = virtualFields.end(); i!= e; ++i) {
JavaField* cur = i->second;
- delete cur;
+ cur->~JavaField();
+ classLoader->allocator.Deallocate(cur);
}
for (method_iterator i = virtualMethods.begin(),
e = virtualMethods.end(); i!= e; ++i) {
JavaMethod* cur = i->second;
- delete cur;
+ cur->~JavaMethod();
+ classLoader->allocator.Deallocate(cur);
}
for (method_iterator i = staticMethods.begin(),
e = staticMethods.end(); i!= e; ++i) {
JavaMethod* cur = i->second;
- delete cur;
+ cur->~JavaMethod();
+ classLoader->allocator.Deallocate(cur);
}
-
- delete ctpInfo;
- free(staticVT);
+
+ if (ctpInfo) {
+ ctpInfo->~JavaConstantPool();
+ classLoader->allocator.Deallocate(ctpInfo);
+ }
+
+ classLoader->allocator.Deallocate(staticVT);
// Currently, only regular classes have a heap allocated virtualVT.
// Array classes have a C++ allocated virtualVT and primitive classes
// do not have a virtualVT.
- free(virtualVT);
+ classLoader->allocator.Deallocate(virtualVT);
}
JavaField::~JavaField() {
for (std::vector<Attribut*>::iterator i = attributs.begin(),
e = attributs.end(); i!= e; ++i) {
Attribut* cur = *i;
- delete cur;
+ cur->~Attribut();
+ classDef->classLoader->allocator.Deallocate(cur);
}
}
@@ -159,13 +169,15 @@
for (std::vector<Attribut*>::iterator i = attributs.begin(),
e = attributs.end(); i!= e; ++i) {
Attribut* cur = *i;
- delete cur;
+ cur->~Attribut();
+ classDef->classLoader->allocator.Deallocate(cur);
}
for (std::vector<Enveloppe*>::iterator i = caches.begin(),
e = caches.end(); i!= e; ++i) {
Enveloppe* cur = *i;
- delete cur;
+ cur->~Enveloppe();
+ classDef->classLoader->allocator.Deallocate(cur);
}
}
@@ -273,8 +285,7 @@
uint32 nb) :
CommonClass(loader, n, false) {
- display = (CommonClass**)
- loader->allocator->allocatePermanentMemory(sizeof(CommonClass*));
+ display = (CommonClass**)loader->allocator.Allocate(sizeof(CommonClass*));
display[0] = this;
primitive = true;
status = ready;
@@ -303,8 +314,7 @@
super = ClassArray::SuperArray;
interfaces = ClassArray::InterfacesArray;
depth = 1;
- display = (CommonClass**)
- loader->allocator->allocatePermanentMemory(2 * sizeof(CommonClass*));
+ display = (CommonClass**)loader->allocator.Allocate(2 * sizeof(CommonClass*));
display[0] = ClassArray::SuperArray;
display[1] = this;
access = ACC_FINAL | ACC_ABSTRACT | ACC_PUBLIC;
@@ -333,17 +343,30 @@
else if (n > JavaArray::MaxArraySize)
vm->outOfMemoryError(n);
- return doNew(n, vm->allocator);
+ return doNew(n, vm->gcAllocator);
+}
+
+JavaArray* UserClassArray::doNew(sint32 n, mvm::Allocator& allocator) {
+ UserCommonClass* cl = baseClass();
+ assert(cl && virtualVT && "array class not resolved");
+
+ uint32 primSize = cl->isPrimitive() ? cl->virtualSize : sizeof(JavaObject*);
+ uint32 size = sizeof(JavaObject) + sizeof(sint32) + n * primSize;
+ JavaArray* res = (JavaArray*)allocator.allocateManagedObject(size,
+ virtualVT);
+ res->initialise(this);
+ res->size = n;
+ return res;
}
-JavaArray* UserClassArray::doNew(sint32 n, mvm::Allocator* allocator) {
+JavaArray* UserClassArray::doNew(sint32 n, mvm::BumpPtrAllocator& allocator) {
UserCommonClass* cl = baseClass();
assert(cl && virtualVT && "array class not resolved");
uint32 primSize = cl->isPrimitive() ? cl->virtualSize : sizeof(JavaObject*);
uint32 size = sizeof(JavaObject) + sizeof(sint32) + n * primSize;
- JavaArray* res = (JavaArray*)allocator->allocateManagedObject(size,
- virtualVT);
+ JavaArray* res = (JavaArray*)allocator.Allocate(size);
+ ((void**)res)[0] = virtualVT;
res->initialise(this);
res->size = n;
return res;
@@ -484,8 +507,8 @@
assert(this && "No class when allocating.");
assert(this->isReady() && "Uninitialized class when allocating.");
JavaObject* res =
- (JavaObject*)vm->allocator->allocateManagedObject(getVirtualSize(),
- getVirtualVT());
+ (JavaObject*)vm->gcAllocator.allocateManagedObject(getVirtualSize(),
+ getVirtualVT());
res->classOf = this;
return res;
}
@@ -679,14 +702,14 @@
if (superUTF8 == 0) {
depth = 0;
display = (CommonClass**)
- classLoader->allocator->allocatePermanentMemory(sizeof(CommonClass*));
+ classLoader->allocator.Allocate(sizeof(CommonClass*));
display[0] = this;
} else {
super = classLoader->loadName(superUTF8, true, true);
depth = super->depth + 1;
- mvm::Allocator* allocator = classLoader->allocator;
+ mvm::BumpPtrAllocator& allocator = classLoader->allocator;
display = (CommonClass**)
- allocator->allocatePermanentMemory(sizeof(CommonClass*) * (depth + 1));
+ allocator.Allocate(sizeof(CommonClass*) * (depth + 1));
memcpy(display, super->display, depth * sizeof(UserCommonClass*));
display[depth] = this;
}
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h?rev=57443&r1=57442&r2=57443&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h Mon Oct 13 11:38:59 2008
@@ -522,8 +522,8 @@
static UserClassPrimitive* byteIdToPrimitive(char id, Classpath* upcalls);
- void* operator new(size_t sz, mvm::Allocator* allocator) {
- return allocator->allocatePermanentMemory(sz);
+ void* operator new(size_t sz, mvm::BumpPtrAllocator& allocator) {
+ return allocator.Allocate(sz);
}
};
@@ -714,7 +714,8 @@
private:
/// doNew - Allocate a new array with the given allocator.
///
- JavaArray* doNew(sint32 n, mvm::Allocator* allocator);
+ JavaArray* doNew(sint32 n, mvm::BumpPtrAllocator& allocator);
+ JavaArray* doNew(sint32 n, mvm::Allocator& allocator);
public:
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp?rev=57443&r1=57442&r2=57443&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp Mon Oct 13 11:38:59 2008
@@ -186,10 +186,11 @@
}
-void* JavaConstantPool::operator new(size_t sz, mvm::Allocator* allocator,
- uint32 ctpSize) {
+void*
+JavaConstantPool::operator new(size_t sz, mvm::BumpPtrAllocator& allocator,
+ uint32 ctpSize) {
uint32 size = sz + ctpSize * (sizeof(void*) + sizeof(sint32) + sizeof(uint8));
- return allocator->allocatePermanentMemory(size);
+ return allocator.Allocate(size);
}
JavaConstantPool::JavaConstantPool(Class* cl, Reader& reader, uint32 size) {
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.h?rev=57443&r1=57442&r2=57443&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.h (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.h Mon Oct 13 11:38:59 2008
@@ -60,7 +60,8 @@
/// operator new - Redefine the operator to allocate the arrays of a
/// constant pool inline.
- void* operator new(size_t sz, mvm::Allocator* allocator, uint32 ctpSize);
+ void* operator new(size_t sz, mvm::BumpPtrAllocator& allocator,
+ uint32 ctpSize);
/// CtpReaderClass - Reads a class entry.
static uint32 CtpReaderClass(JavaConstantPool* ctp, Reader& reader,
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp?rev=57443&r1=57442&r2=57443&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp Mon Oct 13 11:38:59 2008
@@ -87,9 +87,7 @@
}
#endif
- mvm::Allocator* allocator = new mvm::Allocator();
- JnjvmBootstrapLoader* JCL = bootstrapLoader =
- gc_new(JnjvmBootstrapLoader)(allocator);
+ JnjvmBootstrapLoader* JCL = bootstrapLoader = gc_new(JnjvmBootstrapLoader)(0);
// Create the name of char arrays.
const UTF8* utf8OfChar = JCL->asciizConstructUTF8("[C");
@@ -248,8 +246,7 @@
ServiceDomain* vm = ServiceDomain::allocateService();
vm->startExecution();
#else
- mvm::Allocator* allocator = new mvm::Allocator();
- Jnjvm* vm = gc_new(Jnjvm)(allocator);
+ Jnjvm* vm = gc_new(Jnjvm)(0);
#endif
return vm;
}
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp?rev=57443&r1=57442&r2=57443&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp Mon Oct 13 11:38:59 2008
@@ -2018,7 +2018,7 @@
#ifndef ISOLATE_SHARING
// ok now the cache
- mvm::Allocator* allocator = compilingClass->classLoader->allocator;
+ mvm::BumpPtrAllocator& allocator = compilingClass->classLoader->allocator;
Enveloppe* enveloppe =
new(allocator) Enveloppe(compilingClass->ctpInfo, index);
compilingMethod->caches.push_back(enveloppe);
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp?rev=57443&r1=57442&r2=57443&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp Mon Oct 13 11:38:59 2008
@@ -269,7 +269,8 @@
JavaThread* th = JavaThread::get();
jmp_buf* buf = th->sjlj_buffers.back();
th->sjlj_buffers.pop_back();
- free(buf);
+ mvm::Allocator& allocator = th->isolate->gcAllocator;
+ allocator.freeTemporaryMemory(buf);
if (JavaThread::get()->pendingException) {
th->throwPendingException();
}
@@ -277,8 +278,8 @@
extern "C" void* getSJLJBuffer() {
JavaThread* th = JavaThread::get();
- mvm::Allocator* allocator = th->isolate->allocator;
- void** buf = (void**)allocator->allocatePermanentMemory(sizeof(jmp_buf));
+ mvm::Allocator& allocator = th->isolate->gcAllocator;
+ void** buf = (void**)allocator.allocateTemporaryMemory(sizeof(jmp_buf));
th->sjlj_buffers.push_back((jmp_buf*)buf);
return (void*)buf;
}
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaString.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaString.cpp?rev=57443&r1=57442&r2=57443&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaString.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaString.cpp Mon Oct 13 11:38:59 2008
@@ -18,8 +18,7 @@
JavaString* JavaString::stringDup(const UTF8*& utf8, Jnjvm* vm) {
UserClass* cl = vm->upcalls->newString;
- JavaString* res =
- (JavaString*)vm->allocator->allocatePermanentMemory(cl->getVirtualSize());
+ JavaString* res = (JavaString*)vm->allocator.Allocate(cl->getVirtualSize());
#ifdef ISOLATE_SHARING
/// Do this for now, but we will have to change it to duplicate the UTF8.
/// UTF8 that dont have a class are shared UTF8.
Modified: vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp?rev=57443&r1=57442&r2=57443&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp Mon Oct 13 11:38:59 2008
@@ -121,8 +121,8 @@
PRINT_DEBUG(JNJVM_LOAD, 0, COLOR_NORMAL, "%s\n", printString());
JavaObject* val =
- (JavaObject*)vm->allocator->allocateManagedObject(cl->getStaticSize(),
- cl->getStaticVT());
+ (JavaObject*)vm->gcAllocator.allocateManagedObject(cl->getStaticSize(),
+ cl->getStaticVT());
val->initialise(cl);
CommonClass::field_map* map = cl->getStaticFields();
for (CommonClass::field_iterator i = map->begin(), e = map->end(); i!= e;
@@ -355,11 +355,11 @@
Jnjvm::~Jnjvm() {
if (hashStr) {
hashStr->~StringMap();
- allocator->freePermanentMemory(hashStr);
+ allocator.Deallocate(hashStr);
}
if (hashUTF8) {
hashUTF8->~UTF8Map();
- allocator->freePermanentMemory(hashUTF8);
+ allocator.Deallocate(hashUTF8);
}
}
@@ -422,7 +422,7 @@
else end += index;
sint32 length = end - index - 1;
- char* name = (char*)vm->allocator->allocatePermanentMemory(length + 1);
+ char* name = (char*)vm->allocator.Allocate(length + 1);
memcpy(name, &(ptr[index]), length);
name[length] = 0;
return name;
@@ -435,7 +435,7 @@
int i) {
char* jarFile = argv[i];
uint32 size = 2 + strlen(vm->classpath) + strlen(jarFile);
- char* temp = (char*)vm->allocator->allocatePermanentMemory(size);
+ char* temp = (char*)vm->allocator.Allocate(size);
sprintf(temp, "%s:%s", vm->classpath, jarFile);
vm->setClasspath(temp);
@@ -810,9 +810,8 @@
}
}
-Jnjvm::Jnjvm(mvm::Allocator* A) {
+Jnjvm::Jnjvm(uint32 memLimit) {
- allocator = A;
classpath = getenv("CLASSPATH");
if (!classpath) classpath = ".";
Modified: vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h?rev=57443&r1=57442&r2=57443&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h Mon Oct 13 11:38:59 2008
@@ -87,7 +87,8 @@
public:
/// allocator - Memory allocator of this JVM.
///
- mvm::Allocator* allocator;
+ mvm::BumpPtrAllocator allocator;
+ mvm::Allocator gcAllocator;
#ifdef ISOLATE_SHARING
UserClass* throwable;
#endif
@@ -326,7 +327,7 @@
/// Jnjvm - Allocates a new JVM.
///
- Jnjvm(mvm::Allocator* allocator);
+ Jnjvm(uint32 memLimit);
/// runApplication - Runs the application with the given command line.
/// User-visible function, inherited by the VirtualMachine class.
Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp?rev=57443&r1=57442&r2=57443&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp Mon Oct 13 11:38:59 2008
@@ -38,9 +38,8 @@
extern const char* GNUClasspathGlibj;
extern const char* GNUClasspathLibs;
-JnjvmBootstrapLoader::JnjvmBootstrapLoader(mvm::Allocator* A) {
+JnjvmBootstrapLoader::JnjvmBootstrapLoader(uint32 memLimit) {
- allocator = A;
JnjvmModule::initialise();
TheModule = new JnjvmModule("Bootstrap JnJVM");
TheModuleProvider = new JnjvmModuleProvider(TheModule);
@@ -71,7 +70,6 @@
TheModule = new JnjvmModule("Applicative loader");
TheModuleProvider = new JnjvmModuleProvider(TheModule);
bootstrapLoader = JCL.bootstrapLoader;
- allocator = new mvm::Allocator();
hashUTF8 = new(allocator) UTF8Map(allocator,
bootstrapLoader->upcalls->ArrayOfChar);
@@ -403,10 +401,27 @@
}
JnjvmClassLoader::~JnjvmClassLoader() {
- delete classes;
- delete hashUTF8;
- delete javaTypes;
- delete javaSignatures;
+
+ if (classes) {
+ classes->~ClassMap();
+ allocator.Deallocate(classes);
+ }
+
+ if (hashUTF8) {
+ hashUTF8->~UTF8Map();
+ allocator.Deallocate(hashUTF8);
+ }
+
+ if (javaTypes) {
+ javaTypes->~TypeMap();
+ allocator.Deallocate(javaTypes);
+ }
+
+ if (javaSignatures) {
+ javaSignatures->~SignMap();
+ allocator.Deallocate(javaSignatures);
+ }
+
delete TheModuleProvider;
}
@@ -432,7 +447,7 @@
stat(rp, &st);
if ((st.st_mode & S_IFMT) == S_IFDIR) {
unsigned int len = strlen(rp);
- char* temp = (char*)allocator->allocatePermanentMemory(len + 2);
+ char* temp = (char*)allocator.Allocate(len + 2);
memcpy(temp, rp, len);
temp[len] = Jnjvm::dirSeparator[0];
temp[len + 1] = 0;
Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h?rev=57443&r1=57442&r2=57443&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h Mon Oct 13 11:38:59 2008
@@ -101,7 +101,7 @@
/// allocator - Reference to the memory allocator, which will allocate UTF8s,
/// signatures and types.
///
- mvm::Allocator* allocator;
+ mvm::BumpPtrAllocator allocator;
/// hashUTF8 - Tables of UTF8s defined by this class loader. Shared
@@ -273,7 +273,7 @@
/// createBootstrapLoader - Creates the bootstrap loader, first thing
/// to do before any execution of a JVM.
///
- JnjvmBootstrapLoader(mvm::Allocator*);
+ JnjvmBootstrapLoader(uint32 memLimit);
JnjvmBootstrapLoader() {}
/// upcalls - Upcall classes, fields and methods so that C++ code can call
Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp?rev=57443&r1=57442&r2=57443&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp Mon Oct 13 11:38:59 2008
@@ -197,9 +197,8 @@
CommonClass::method_iterator meths) {
if (meths == cl->virtualMethods.end()) {
uint64 size = cl->virtualTableSize;
- mvm::Allocator* allocator = cl->classLoader->allocator;
- VirtualTable* VT = (VirtualTable*)
- allocator->allocatePermanentMemory(size * sizeof(void*));
+ mvm::BumpPtrAllocator& allocator = cl->classLoader->allocator;
+ VirtualTable* VT = (VirtualTable*)allocator.Allocate(size * sizeof(void*));
if (!VT) JavaThread::get()->isolate->outOfMemoryError(size * sizeof(void*));
if (cl->super) {
Class* super = (Class*)cl->super;
@@ -265,8 +264,8 @@
#ifndef WITHOUT_VTABLE
if (stat) {
#endif
- mvm::Allocator* allocator = cl->classLoader->allocator;
- res = (VirtualTable*)allocator->allocatePermanentMemory(VT_SIZE);
+ mvm::BumpPtrAllocator& allocator = cl->classLoader->allocator;
+ res = (VirtualTable*)allocator.Allocate(VT_SIZE);
memcpy(res, JavaObject::VT, VT_SIZE);
#ifndef WITHOUT_VTABLE
} else {
Modified: vmkit/trunk/lib/JnJVM/VMCore/LockedMap.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/LockedMap.h?rev=57443&r1=57442&r2=57443&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/LockedMap.h (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/LockedMap.h Mon Oct 13 11:38:59 2008
@@ -6,6 +6,12 @@
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
+//
+// This file defines thread-safe maps that must be deallocated by the owning
+// object. For example a class loader is responsible for deallocating the
+// types stored in a TypeMap.
+//
+//===----------------------------------------------------------------------===//
#ifndef JNJVM_LOCKED_MAP_H
#define JNJVM_LOCKED_MAP_H
@@ -96,7 +102,7 @@
typedef std::multimap<const uint32, const UTF8*>::iterator iterator;
mvm::LockNormal lock;
- mvm::Allocator* allocator;
+ mvm::BumpPtrAllocator& allocator;
UserClassArray* array;
std::multimap<const uint32, const UTF8*> map;
const UTF8* lookupOrCreateAsciiz(const char* asciiz);
@@ -104,14 +110,13 @@
const UTF8* lookupAsciiz(const char* asciiz);
const UTF8* lookupReader(const uint16* buf, uint32 size);
- UTF8Map(mvm::Allocator* A, UserClassArray* cl) {
- allocator = A;
+ UTF8Map(mvm::BumpPtrAllocator& A, UserClassArray* cl) : allocator(A) {
array = cl;
}
~UTF8Map() {
for (iterator i = map.begin(), e = map.end(); i!= e; ++i) {
- allocator->freePermanentMemory((void*)i->second);
+ allocator.Deallocate((void*)i->second);
}
}
@@ -126,26 +131,11 @@
};
class ClassMap :
- public LockedMap<const UTF8*, UserCommonClass*, ltutf8, JnjvmClassLoader* > {
-public:
-
- ClassMap() {}
-
- ~ClassMap() {}
-
+ public LockedMap<const UTF8*, UserCommonClass*, ltutf8, JnjvmClassLoader* > {
};
class StringMap :
public LockedMap<const UTF8*, JavaString*, ltutf8, Jnjvm*> {
-public:
-
- StringMap() {}
-
- ~StringMap() {
- for (iterator i = map.begin(), e = map.end(); i!= e; ++i) {
- free(i->second);
- }
- }
};
class TypeMap : public mvm::PermanentObject {
@@ -164,15 +154,6 @@
inline void hash(const UTF8* k, Typedef* c) {
map.insert(std::make_pair(k, c));
}
-
- TypeMap() {}
-
- ~TypeMap() {
- for (iterator i = map.begin(), e = map.end(); i!= e; ++i) {
- delete i->second;
- }
- }
-
};
class SignMap : public mvm::PermanentObject {
@@ -192,14 +173,6 @@
map.insert(std::make_pair(k, c));
}
- SignMap() {}
-
- ~SignMap() {
- for (iterator i = map.begin(), e = map.end(); i!= e; ++i) {
- delete i->second;
- }
- }
-
};
} // end namespace jnjvm
Modified: vmkit/trunk/lib/JnJVM/VMCore/Zip.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Zip.cpp?rev=57443&r1=57442&r2=57443&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/Zip.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/Zip.cpp Mon Oct 13 11:38:59 2008
@@ -17,9 +17,8 @@
using namespace jnjvm;
-ZipArchive::ZipArchive(ArrayUInt8* bytes, mvm::Allocator* allocator) {
+ZipArchive::ZipArchive(ArrayUInt8* bytes, mvm::BumpPtrAllocator& A) : allocator(A) {
this->bytes = bytes;
- this->allocator = allocator,
findOfscd();
if (ofscd > -1) addFiles();
}
@@ -146,8 +145,7 @@
(reader.max - temp) < ptr->filenameLength)
return;
- ptr->filename =
- (char*)allocator->allocatePermanentMemory(ptr->filenameLength + 1);
+ ptr->filename = (char*)allocator.Allocate(ptr->filenameLength + 1);
memcpy(ptr->filename, &(reader.bytes->elements[temp]), ptr->filenameLength);
ptr->filename[ptr->filenameLength] = 0;
Modified: vmkit/trunk/lib/JnJVM/VMCore/Zip.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Zip.h?rev=57443&r1=57442&r2=57443&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/Zip.h (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/Zip.h Mon Oct 13 11:38:59 2008
@@ -36,7 +36,7 @@
friend class JnjvmBootstrapLoader;
private:
- mvm::Allocator* allocator;
+ mvm::BumpPtrAllocator& allocator;
struct ltstr
{
@@ -61,14 +61,14 @@
~ZipArchive() {
for (table_iterator I = filetable.begin(), E = filetable.end(); I != E;
++I) {
- allocator->freePermanentMemory((void*)I->first);
+ allocator.Deallocate((void*)I->first);
I->second->~ZipFile();
- allocator->freePermanentMemory((void*)I->second);
+ allocator.Deallocate((void*)I->second);
}
}
int getOfscd() { return ofscd; }
- ZipArchive(ArrayUInt8* bytes, mvm::Allocator* allocator);
+ ZipArchive(ArrayUInt8* bytes, mvm::BumpPtrAllocator& allocator);
ZipFile* getFile(const char* filename);
int readFile(ArrayUInt8* array, const ZipFile* file);
More information about the vmkit-commits
mailing list