truffle: src/share/vm/memory/metaspace.cpp comparison

comparison src/share/vm/memory/metaspace.cpp @ 17935:7384f6a12fc1

8038212: Method::is_valid_method() check has performance regression impact for stackwalking Summary: Only prune metaspace virtual spaces at safepoint so walking them is safe outside a safepoint. Reviewed-by: mgerdin, mgronlun, hseigel, stefank

author	coleenp
date	Thu, 15 May 2014 18:23:26 -0400
parents	270d7cb38f40
children	78bbf4d43a14

comparison

equal deleted inserted replaced

-:366c198c896d
+:7384f6a12fc1
 // Convenience functions for logical bottom and end
 MetaWord* bottom() const { return (MetaWord*) _virtual_space.low(); }
 MetaWord* end() const { return (MetaWord*) _virtual_space.high(); }
+bool contains(const void* ptr) { return ptr >= low() && ptr < high(); }
 size_t reserved_words() const  { return _virtual_space.reserved_size() / BytesPerWord; }
 size_t committed_words() const { return _virtual_space.actual_committed_size() / BytesPerWord; }
 bool is_pre_committed() const { return _virtual_space.special(); }
 void inc_committed_words(size_t v);
 void dec_committed_words(size_t v);
 void inc_virtual_space_count();
 void dec_virtual_space_count();
+bool contains(const void* ptr);
 // Unlink empty VirtualSpaceNodes and free it.
 void purge(ChunkManager* chunk_manager);
 void print_on(outputStream* st) const;
 private:
 // Accessors
 Metachunk* chunks_in_use(ChunkIndex index) const { return _chunks_in_use[index]; }
 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;
 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
 void verify_allocated_blocks_words();
 // Walk the list of VirtualSpaceNodes and delete
 // nodes with a 0 container_count.  Remove Metachunks in
 // the node from their respective freelists.
 void VirtualSpaceList::purge(ChunkManager* chunk_manager) {
+assert(SafepointSynchronize::is_at_safepoint(), "must be called at safepoint for contains to work");
 assert_lock_strong(SpaceManager::expand_lock());
 // Don't use a VirtualSpaceListIterator because this
 // list is being changed and a straightforward use of an iterator is not safe.
 VirtualSpaceNode* purged_vsl = NULL;
 VirtualSpaceNode* prev_vsl = virtual_space_list();
 prev_vsl = vsl;
 }
 }
 #ifdef ASSERT
 if (purged_vsl != NULL) {
 // List should be stable enough to use an iterator here.
 VirtualSpaceListIterator iter(virtual_space_list());
 while (iter.repeat()) {
 VirtualSpaceNode* vsl = iter.get_next();
 assert(vsl != purged_vsl, "Purge of vsl failed");
 }
 }
 #endif
+}
+// This function looks at the mmap regions in the metaspace without locking.
+// The chunks are added with store ordering and not deleted except for at
+// unloading time during a safepoint.
+bool VirtualSpaceList::contains(const void* ptr) {
+// List should be stable enough to use an iterator here because removing virtual
+// space nodes is only allowed at a safepoint.
+VirtualSpaceListIterator iter(virtual_space_list());
+while (iter.repeat()) {
+VirtualSpaceNode* vsn = iter.get_next();
+if (vsn->contains(ptr)) {
+return true;
+}
+}
+return false;
 }
 void VirtualSpaceList::retire_current_virtual_space() {
 assert_lock_strong(SpaceManager::expand_lock());
 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;
 }
 }
 }
 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) {
 }
 }
 }
 bool Metaspace::contains(const void* ptr) {
-if (vsm()->contains(ptr)) return true;
+if (UseSharedSpaces && MetaspaceShared::is_in_shared_space(ptr)) {
-if (using_class_space()) {
+return true;
-return class_vsm()->contains(ptr);
+}
-}
-return false;
+if (using_class_space() && get_space_list(ClassType)->contains(ptr)) {
+return true;
+}
+return get_space_list(NonClassType)->contains(ptr);
 }
 void Metaspace::verify() {
 vsm()->verify();
 if (using_class_space()) {
 void TestVirtualSpaceNode_test() {
 TestVirtualSpaceNodeTest::test();
 TestVirtualSpaceNodeTest::test_is_available();
 }
 #endif

Mercurial > hg > truffle

comparison src/share/vm/memory/metaspace.cpp @ 17935:7384f6a12fc1