graal-compiler: src/share/vm/code/codeCache.cpp comparison

comparison src/share/vm/code/codeCache.cpp @ 14704:b51e29501f30

Merged with jdk9/dev/hotspot changeset 9486a41de3b7

author	twisti
date	Tue, 18 Mar 2014 20:19:10 -0700
parents	d8041d695d19 480b0109db65
children	92aa6797d639

comparison

equal deleted inserted replaced

-:8f483e200405
+:b51e29501f30
 (address)_heap->high() - (address)_heap->low_boundary());
 }
 }
 maxCodeCacheUsed = MAX2(maxCodeCacheUsed, ((address)_heap->high_boundary() -
 (address)_heap->low_boundary()) - unallocated_capacity());
-verify_if_often();
 print_trace("allocation", cb, size);
 return cb;
 }
 void CodeCache::free(CodeBlob* cb) {
 assert_locked_or_safepoint(CodeCache_lock);
-verify_if_often();
 print_trace("free", cb);
 if (cb->is_nmethod()) {
 _number_of_nmethods--;
 if (((nmethod *)cb)->has_dependencies()) {
 }
 _number_of_blobs--;
 _heap->deallocate(cb);
-verify_if_often();
 assert(_number_of_blobs >= 0, "sanity check");
 }
 void CodeCache::commit(CodeBlob* cb) {
 _number_of_adapters++;
 }
 // flush the hardware I-cache
 ICache::invalidate_range(cb->content_begin(), cb->content_size());
-}
-void CodeCache::flush() {
-assert_locked_or_safepoint(CodeCache_lock);
-Unimplemented();
 }
 // Iteration over CodeBlobs
 // looked up (i.e., one that has been marked for deletion). It only dependes on the _segmap to contain
 // valid indices, which it will always do, as long as the CodeBlob is not in the process of being recycled.
 CodeBlob* CodeCache::find_blob(void* start) {
 CodeBlob* result = find_blob_unsafe(start);
 if (result == NULL) return NULL;
-// We could potientially look up non_entrant methods
+// We could potentially look up non_entrant methods
 guarantee(!result->is_zombie() || result->is_locked_by_vm() || is_error_reported(), "unsafe access to zombie method");
 return result;
 }
 nmethod* CodeCache::find_nmethod(void* start) {
 event.set_fullCount(_codemem_full_count);
 event.commit();
 }
 }
+void CodeCache::print_memory_overhead() {
+size_t wasted_bytes = 0;
+CodeBlob *cb;
+for (cb = first(); cb != NULL; cb = next(cb)) {
+HeapBlock* heap_block = ((HeapBlock*)cb) - 1;
+wasted_bytes += heap_block->length() * CodeCacheSegmentSize - cb->size();
+}
+// Print bytes that are allocated in the freelist
+ttyLocker ttl;
+tty->print_cr("Number of elements in freelist: %d",    freelist_length());
+tty->print_cr("Allocated in freelist:          %dkB",  bytes_allocated_in_freelist()/K);
+tty->print_cr("Unused bytes in CodeBlobs:      %dkB",  (int)(wasted_bytes/K));
+tty->print_cr("Segment map size:               %dkB",  allocated_segments()/K); // 1 byte per segment
+}
 //------------------------------------------------------------------------------------------------
 // Non-product version
 #ifndef PRODUCT
-void CodeCache::verify_if_often() {
-if (VerifyCodeCacheOften) {
-_heap->verify();
-}
-}
 void CodeCache::print_trace(const char* event, CodeBlob* cb, int size) {
 if (PrintCodeCache2) {  // Need to add a new flag
 ResourceMark rm;
 if (size == 0)  size = cb->size();
 int nmethodNotEntrant = 0;
 int nmethodZombie = 0;
 int nmethodUnloaded = 0;
 int nmethodJava = 0;
 int nmethodNative = 0;
-int maxCodeSize = 0;
+int max_nm_size = 0;
 ResourceMark rm;
 CodeBlob *cb;
 for (cb = first(); cb != NULL; cb = next(cb)) {
 total++;
 if(nm->is_alive()) { nmethodAlive++; }
 if(nm->is_not_entrant()) { nmethodNotEntrant++; }
 if(nm->is_zombie()) { nmethodZombie++; }
 if(nm->is_unloaded()) { nmethodUnloaded++; }
-if(nm->is_native_method()) { nmethodNative++; }
+if(nm->method() != NULL && nm->is_native_method()) { nmethodNative++; }
 if(nm->method() != NULL && nm->is_java_method()) {
 nmethodJava++;
-if (nm->insts_size() > maxCodeSize) {
+max_nm_size = MAX2(max_nm_size, nm->size());
-maxCodeSize = nm->insts_size();
-}
 }
 } else if (cb->is_runtime_stub()) {
 runtimeStubCount++;
 } else if (cb->is_deoptimization_stub()) {
 deoptimizationStubCount++;
 bufferBlobCount++;
 }
 }
 int bucketSize = 512;
-int bucketLimit = maxCodeSize / bucketSize + 1;
+int bucketLimit = max_nm_size / bucketSize + 1;
 int *buckets = NEW_C_HEAP_ARRAY(int, bucketLimit, mtCode);
-memset(buckets,0,sizeof(int) * bucketLimit);
+memset(buckets, 0, sizeof(int) * bucketLimit);
 for (cb = first(); cb != NULL; cb = next(cb)) {
 if (cb->is_nmethod()) {
 nmethod* nm = (nmethod*)cb;
 if(nm->is_java_method()) {
-buckets[nm->insts_size() / bucketSize]++;
+buckets[nm->size() / bucketSize]++;
 }
 }
 }
 tty->print_cr("Code Cache Entries (total of %d)",total);
 tty->print_cr("-------------------------------------------------");
 tty->print_cr("nmethods: %d",nmethodCount);
 tty->print_cr("\talive: %d",nmethodAlive);
 tty->print_cr("\tnot_entrant: %d",nmethodNotEntrant);
 tty->print_cr("%d",buckets[i]);
 }
 }
 FREE_C_HEAP_ARRAY(int, buckets, mtCode);
+print_memory_overhead();
 }
 #endif // !PRODUCT
 void CodeCache::print() {

Mercurial > hg > graal-compiler

comparison src/share/vm/code/codeCache.cpp @ 14704:b51e29501f30