Mercurial > hg > graal-compiler
view src/share/vm/services/memTrackWorker.cpp @ 6210:1e26f61bbb52 jdk8-b48
Added tag hs24-b16 for changeset 66b0450071c1
author | amurillo |
---|---|
date | Fri, 13 Jul 2012 14:06:34 -0700 |
parents | d2a62e0f25eb |
children | 4acebbe310e1 |
line wrap: on
line source
/* * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License version 2 only, as * published by the Free Software Foundation. * * This code is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License * version 2 for more details (a copy is included in the LICENSE file that * accompanied this code). * * You should have received a copy of the GNU General Public License version * 2 along with this work; if not, write to the Free Software Foundation, * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. * * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA * or visit www.oracle.com if you need additional information or have any * questions. * */ #include "precompiled.hpp" #include "runtime/threadCritical.hpp" #include "services/memTracker.hpp" #include "services/memTrackWorker.hpp" #include "utilities/decoder.hpp" #include "utilities/vmError.hpp" MemTrackWorker::MemTrackWorker() { // create thread uses cgc thread type for now. We should revisit // the option, or create new thread type. _has_error = !os::create_thread(this, os::cgc_thread); set_name("MemTrackWorker", 0); // initial generation circuit buffer if (!has_error()) { _head = _tail = 0; for(int index = 0; index < MAX_GENERATIONS; index ++) { _gen[index] = NULL; } } NOT_PRODUCT(_sync_point_count = 0;) NOT_PRODUCT(_merge_count = 0;) NOT_PRODUCT(_last_gen_in_use = 0;) } MemTrackWorker::~MemTrackWorker() { for (int index = 0; index < MAX_GENERATIONS; index ++) { MemRecorder* rc = _gen[index]; if (rc != NULL) { delete rc; } } } void* MemTrackWorker::operator new(size_t size) { assert(false, "use nothrow version"); return NULL; } void* MemTrackWorker::operator new(size_t size, const std::nothrow_t& nothrow_constant) { return allocate(size, false, mtNMT); } void MemTrackWorker::start() { os::start_thread(this); } /* * Native memory tracking worker thread loop: * 1. merge one generation of memory recorders to staging area * 2. promote staging data to memory snapshot * * This thread can run through safepoint. */ void MemTrackWorker::run() { assert(MemTracker::is_on(), "native memory tracking is off"); this->initialize_thread_local_storage(); this->record_stack_base_and_size(); MemSnapshot* snapshot = MemTracker::get_snapshot(); assert(snapshot != NULL, "Worker should not be started"); MemRecorder* rec; while (!MemTracker::shutdown_in_progress()) { NOT_PRODUCT(_last_gen_in_use = generations_in_use();) { // take a recorder from earliest generation in buffer ThreadCritical tc; rec = _gen[_head]; if (rec != NULL) { _gen[_head] = rec->next(); } assert(count_recorder(_gen[_head]) <= MemRecorder::_instance_count, "infinite loop after dequeue"); } if (rec != NULL) { // merge the recorder into staging area bool result = snapshot->merge(rec); assert(result, "merge failed"); debug_only(_merge_count ++;) MemTracker::release_thread_recorder(rec); } else { // no more recorder to merge, promote staging area // to snapshot if (_head != _tail) { { ThreadCritical tc; if (_gen[_head] != NULL || _head == _tail) { continue; } // done with this generation, increment _head pointer _head = (_head + 1) % MAX_GENERATIONS; } // promote this generation data to snapshot snapshot->promote(); } else { snapshot->wait(1000); ThreadCritical tc; // check if more data arrived if (_gen[_head] == NULL) { _gen[_head] = MemTracker::get_pending_recorders(); } } } } assert(MemTracker::shutdown_in_progress(), "just check"); // transites to final shutdown MemTracker::final_shutdown(); } // at synchronization point, where 'safepoint visible' Java threads are blocked // at a safepoint, and the rest of threads are blocked on ThreadCritical lock. // The caller MemTracker::sync() already takes ThreadCritical before calling this // method. // // Following tasks are performed: // 1. add all recorders in pending queue to current generation // 2. increase generation void MemTrackWorker::at_sync_point(MemRecorder* rec) { NOT_PRODUCT(_sync_point_count ++;) assert(count_recorder(rec) <= MemRecorder::_instance_count, "pending queue has infinite loop"); bool out_of_generation_buffer = false; // check shutdown state inside ThreadCritical if (MemTracker::shutdown_in_progress()) return; // append the recorders to the end of the generation if( rec != NULL) { MemRecorder* cur_head = _gen[_tail]; if (cur_head == NULL) { _gen[_tail] = rec; } else { while (cur_head->next() != NULL) { cur_head = cur_head->next(); } cur_head->set_next(rec); } } assert(count_recorder(rec) <= MemRecorder::_instance_count, "after add to current generation has infinite loop"); // we have collected all recorders for this generation. If there is data, // we need to increment _tail to start a new generation. if (_gen[_tail] != NULL || _head == _tail) { _tail = (_tail + 1) % MAX_GENERATIONS; out_of_generation_buffer = (_tail == _head); } if (out_of_generation_buffer) { MemTracker::shutdown(MemTracker::NMT_out_of_generation); } } #ifndef PRODUCT int MemTrackWorker::count_recorder(const MemRecorder* head) { int count = 0; while(head != NULL) { count ++; head = head->next(); } return count; } int MemTrackWorker::count_pending_recorders() const { int count = 0; for (int index = 0; index < MAX_GENERATIONS; index ++) { MemRecorder* head = _gen[index]; if (head != NULL) { count += count_recorder(head); } } return count; } #endif