graal-compiler: src/share/vm/memory/metaspace.cpp comparison

comparison src/share/vm/memory/metaspace.cpp @ 14190:ce86c36b8921

8029178: Parallel class loading test anonymous-simple gets SIGSEGV in Metaspace::contains Summary: Metaspace::contains cannot look at purged metaspaces while CMS concurrently deallocates them. Reviewed-by: mgerdin, sspitsyn, jmasa

author	coleenp
date	Tue, 07 Jan 2014 13:26:56 -0500
parents	11b116661830
children	db1ff6781ab4

comparison

equal deleted inserted replaced

-:1a899ea6b7ed
+:ce86c36b8921
 void dec_virtual_space_count();
 // Unlink empty VirtualSpaceNodes and free it.
 void purge(ChunkManager* chunk_manager);
-bool contains(const void *ptr);
 void print_on(outputStream* st) const;
 class VirtualSpaceListIterator : public StackObj {
 VirtualSpaceNode* _virtual_spaces;
 public:
 friend class Metaspace;
 friend class Metadebug;
 private:
-// protects allocations and contains.
+// protects allocations
 Mutex* const _lock;
 // Type of metadata allocated.
 Metaspace::MetadataType _mdtype;
 static Mutex* const _expand_lock;
 private:
 // Accessors
 Metachunk* chunks_in_use(ChunkIndex index) const { return _chunks_in_use[index]; }
-void set_chunks_in_use(ChunkIndex index, Metachunk* v) { _chunks_in_use[index] = v; }
+void set_chunks_in_use(ChunkIndex index, Metachunk* v) {
+// ensure lock-free iteration sees fully initialized node
+OrderAccess::storestore();
+_chunks_in_use[index] = v;
+}
 BlockFreelist* block_freelists() const {
 return (BlockFreelist*) &_block_freelists;
 }
 // debugging support.
 void dump(outputStream* const out) const;
 void print_on(outputStream* st) const;
 void locked_print_chunks_in_use_on(outputStream* st) const;
+bool contains(const void *ptr);
 void verify();
 void verify_chunk_size(Metachunk* chunk);
 NOT_PRODUCT(void mangle_freed_chunks();)
 #ifdef ASSERT
 delete new_entry;
 return false;
 } else {
 assert(new_entry->reserved_words() == vs_word_size,
 "Reserved memory size differs from requested memory size");
-// ensure lock-free iteration sees fully initialized node
-OrderAccess::storestore();
 link_vs(new_entry);
 return true;
 }
 }
 VirtualSpaceNode* node = iter.get_next();
 node->print_on(st);
 }
 }
 }
-bool VirtualSpaceList::contains(const void *ptr) {
-VirtualSpaceNode* list = virtual_space_list();
-VirtualSpaceListIterator iter(list);
-while (iter.repeat()) {
-VirtualSpaceNode* node = iter.get_next();
-if (node->reserved()->contains(ptr)) {
-return true;
-}
-}
-return false;
-}
 // MetaspaceGC methods
 // VM_CollectForMetadataAllocation is the vm operation used to GC.
 // Within the VM operation after the GC the attempt to allocate the metadata
 }
 return result;
 }
+// This function looks at the chunks in the metaspace without locking.
+// The chunks are added with store ordering and not deleted except for at
+// unloading time.
+bool SpaceManager::contains(const void *ptr) {
+for (ChunkIndex i = ZeroIndex; i < NumberOfInUseLists; i = next_chunk_index(i))
+{
+Metachunk* curr = chunks_in_use(i);
+while (curr != NULL) {
+if (curr->contains(ptr)) return true;
+curr = curr->next();
+}
+}
+return false;
+}
 void SpaceManager::verify() {
 // If there are blocks in the dictionary, then
 // verfication of chunks does not work since
 // being in the dictionary alters a chunk.
 if (block_freelists()->total_size() == 0) {
 class_vsm()->print_on(out);
 }
 }
 }
-bool Metaspace::contains(const void * ptr) {
+bool Metaspace::contains(const void* ptr) {
-if (MetaspaceShared::is_in_shared_space(ptr)) {
+if (vsm()->contains(ptr)) return true;
-return true;
+if (using_class_space()) {
-}
+return class_vsm()->contains(ptr);
-// This is checked while unlocked.  As long as the virtualspaces are added
+}
-// at the end, the pointer will be in one of them.  The virtual spaces
+return false;
-// aren't deleted presently.  When they are, some sort of locking might
-// be needed.  Note, locking this can cause inversion problems with the
-// caller in MetaspaceObj::is_metadata() function.
-return space_list()->contains(ptr) ||
-(using_class_space() && class_space_list()->contains(ptr));
 }
 void Metaspace::verify() {
 vsm()->verify();
 if (using_class_space()) {

Mercurial > hg > graal-compiler

comparison src/share/vm/memory/metaspace.cpp @ 14190:ce86c36b8921