| //===------- LockedMap.h - A thread-safe map implementation ---------------===// |
| // |
| // The VMKit project |
| // |
| // This file is distributed under the University of Illinois Open Source |
| // 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 |
| |
| |
| #include <map> |
| |
| #include <cstring> |
| |
| #include "types.h" |
| |
| #include "mvm/Allocator.h" |
| #include "mvm/MvmDenseMap.h" |
| #include "mvm/Threads/Locks.h" |
| #include "UTF8.h" |
| |
| namespace j3 { |
| |
| class ArrayUInt16; |
| class JavaString; |
| class JnjvmClassLoader; |
| class Signdef; |
| class Typedef; |
| class UserCommonClass; |
| class UserClassArray; |
| |
| struct ltarray16 { |
| bool operator()(const ArrayUInt16 *const s1, const ArrayUInt16 *const s2) const; |
| }; |
| |
| class StringMap : public mvm::PermanentObject { |
| public: |
| typedef std::map<const ArrayUInt16 *const, JavaString*, ltarray16>::iterator iterator; |
| typedef JavaString* (*funcCreate)(const ArrayUInt16 *const& V, Jnjvm* vm); |
| |
| mvm::LockNormal lock; |
| std::map<const ArrayUInt16 *const, JavaString*, ltarray16, |
| std::allocator<std::pair<const ArrayUInt16 *const, JavaString*> > > map; |
| |
| inline JavaString* lookupOrCreate(const ArrayUInt16 *const 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(array); |
| if (I == End) { |
| res = func(array, vm); |
| map.insert(std::make_pair(array, res)); |
| lock.unlock(); |
| return res; |
| } else { |
| lock.unlock(); |
| return ((JavaString*)(I->second)); |
| } |
| } |
| |
| inline void remove(const ArrayUInt16 *const array) { |
| llvm_gcroot(array, 0); |
| lock.lock(); |
| map.erase(array); |
| lock.unlock(); |
| } |
| |
| inline JavaString* lookup(const ArrayUInt16 *const array) { |
| llvm_gcroot(array, 0); |
| lock.lock(); |
| iterator End = map.end(); |
| iterator I = map.find(array); |
| lock.unlock(); |
| return I != End ? ((JavaString*)(I->second)) : 0; |
| } |
| |
| inline void hash(const ArrayUInt16 *const array, JavaString* str) { |
| llvm_gcroot(array, 0); |
| llvm_gcroot(str, 0); |
| lock.lock(); |
| map.insert(std::make_pair(array, str)); |
| lock.unlock(); |
| } |
| |
| inline void removeUnlocked(const ArrayUInt16 *const 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); |
| } |
| |
| ~StringMap() {} |
| |
| void insert(JavaString* str); |
| }; |
| |
| |
| class ClassMap : public mvm::PermanentObject { |
| public: |
| ClassMap() {} |
| ClassMap(mvm::MvmDenseMap<const mvm::UTF8*, UserCommonClass*>* precompiled) : map(*precompiled) {} |
| |
| mvm::LockRecursive lock; |
| mvm::MvmDenseMap<const mvm::UTF8*, UserCommonClass*> map; |
| typedef mvm::MvmDenseMap<const mvm::UTF8*, UserCommonClass*>::iterator iterator; |
| }; |
| |
| class TypeMap : public mvm::PermanentObject { |
| public: |
| mvm::LockNormal lock; |
| mvm::MvmDenseMap<const mvm::UTF8*, Typedef*> map; |
| typedef mvm::MvmDenseMap<const mvm::UTF8*, Typedef*>::iterator iterator; |
| }; |
| |
| class SignMap : public mvm::PermanentObject { |
| public: |
| mvm::LockNormal lock; |
| mvm::MvmDenseMap<const mvm::UTF8*, Signdef*> map; |
| typedef mvm::MvmDenseMap<const mvm::UTF8*, Signdef*>::iterator iterator; |
| }; |
| |
| } // end namespace j3 |
| |
| #endif |