4168N/A * Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved. 3863N/A * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 3863N/A * This code is free software; you can redistribute it and/or modify it 3863N/A * under the terms of the GNU General Public License version 2 only, as 3863N/A * published by the Free Software Foundation. 3863N/A * This code is distributed in the hope that it will be useful, but WITHOUT 3863N/A * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 3863N/A * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 3863N/A * version 2 for more details (a copy is included in the LICENSE file that 3863N/A * You should have received a copy of the GNU General Public License version 3863N/A * 2 along with this work; if not, write to the Free Software Foundation, 3863N/A * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 3863N/A * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 3863N/A// walk all 'known' threads at NMT sync point, and collect their recorders 3863N/A// first phase of bootstrapping, when VM is still in single-threaded mode. 3863N/A // NMT is not supported with UseMallocOnly is on. NMT can NOT 3863N/A // handle the amount of malloc data without significantly impacting 3863N/A // runtime performance when this flag is on. 3863N/A// second phase of bootstrapping, when VM is about to or already entered multi-theaded mode. 3863N/A // create nmt lock for multi-thread execution 3863N/A // Native memory tracking is off from command line option 3863N/A // fail to start native memory tracking, shut it down 3863N/A * Shutting down native memory tracking. 3863N/A * We can not shutdown native memory tracking immediately, so we just 3863N/A * setup shutdown pending flag, every native memory tracking component 3863N/A * should orderly shut itself down. 3863N/A * 1. MemTracker::shutdown() sets MemTracker to shutdown pending state 3863N/A * 2. Worker thread calls MemTracker::final_shutdown(), which transites 3863N/A * MemTracker to final shutdown state. 3863N/A * 3. At sync point, MemTracker does final cleanup, before sets memory 3863N/A * tracking level to off to complete shutdown. 3863N/A // we still in single thread mode, there is not contention 3863N/A // we want to know who initialized shutdown 3863N/A // delete all pending recorders and pooled recorders 3863N/A // shared baseline and snapshot are the only objects needed to 3863N/A // cleanup baseline data and snapshot 3863N/A // shutdown shared decoder instance, since it is only 3863N/A // used by native memory tracking so far. 3863N/A // can not delete worker inside the thread critical 3863N/A// delete all pooled recorders 3863N/A // free all pooled recorders 3863N/A// delete all recorders in pending queue 3863N/A // free all pending recorders 3863N/A * retrieve per-thread recorder of specified thread. 3863N/A * if thread == NULL, it means global recorder 3863N/A * get a per-thread recorder from pool, or create a new one if 3863N/A * there is not one available. 3863N/A * retrieve all recorders in pending queue, and empty the queue 3863N/A * release a recorder to recorder pool. 3863N/A // we don't want to pool too many recorders 3863N/A// write a record to proper recorder. No lock can be taken from this method 3863N/A * enqueue a recorder to pending queue 3863N/A // we are shutting down, so just delete it 3863N/A * The method is called at global safepoint 3863N/A * during it synchronization process. 3863N/A * 1. enqueue all JavaThreads' per-thread recorders 3863N/A * 2. enqueue global recorder 3863N/A * 3. retrieve all pending recorders 3863N/A * 4. reset global sequence number generator 3863N/A // Some GC tests hit large number of safepoints in short period of time 3863N/A // without meaningful activities. We should prevent going to 3863N/A // sync point in these cases, which can potentially exhaust generation buffer. 3863N/A // Here is the factots to determine if we should go into sync point: 3863N/A // 1. not to overflow sequence number 3863N/A // 2. if we are in danger to overflow generation buffer 3863N/A // 3. how many safepoints we already skipped sync point 3863N/A // worker thread is not ready, no one can manage generation 3863N/A // buffer, so skip this safepoint 3863N/A // This method is running at safepoint, with ThreadCritical lock, 3863N/A // it should guarantee that NMT is fully sync-ed. 4559N/A // We can NOT execute NMT sync-point if there are pending tracking ops. 3897N/A // walk all JavaThreads to collect recorders 4311N/A // see if NMT has too many outstanding recorder instances, it usually 4311N/A // means that worker thread is lagging behind in processing them. 3863N/A // check _worker_thread with lock to avoid racing condition 3863N/A // now, it is the time to shut whole things off 3863N/A // walk all JavaThreads to delete all recorders 3897N/A // try at a later sync point to ensure MemRecorder instance drops to zero to 3863N/A * We need to collect a JavaThread's per-thread recorder 3863N/A// baseline current memory snapshot 3863N/A// print memory usage from current snapshot 4186N/A// Whitebox API for blocking until the current generation of NMT data has been merged 4186N/A // NMT can't be shutdown while we're holding _query_lock 4186N/A // the generation at query time, so NMT will spin till this generation is processed 4186N/A // if generation counter overflown 4186N/A // to overflow an unsigned long should take long time, so to_wrap check should be sufficient 4186N/A // if worker thread is idle, but generation is not advancing, that means 4186N/A // there is not safepoint to let NMT advance generation, force one. 4186N/A // We end up here if NMT is shutting down before our data has been merged 3863N/A// compare memory usage between current snapshot and baseline 4559N/A * This is a fairly complicated constructor, as it has to make two important decisions: 4559N/A * 1) Does it need to take ThreadCritical lock to write tracking record 4559N/A * 2) Does it need to pre-reserve a sequence number for the tracking record 4559N/A * The rules to determine if ThreadCritical is needed: 4559N/A * 1. When nmt is in single-threaded bootstrapping mode, no lock is needed as VM 4559N/A * still in single thread mode. 4559N/A * 2. For all threads other than JavaThread, ThreadCritical is needed 4559N/A * to write to recorders to global recorder. 4559N/A * 3. For JavaThreads that are no longer visible by safepoint, also 4559N/A * need to take ThreadCritical and records are written to global 4559N/A * recorders, since these threads are NOT walked by Threads.do_thread(). 4559N/A * 4. JavaThreads that are running in safepoint-safe states do not stop 4559N/A * for safepoints, ThreadCritical lock should be taken to write 4559N/A * 5. JavaThreads that are running in VM state do not need any lock and 4559N/A * records are written to per-thread recorders. 4559N/A * 6. For a thread has yet to attach VM 'Thread', they need to take 4559N/A * ThreadCritical to write to global recorder. 4559N/A * The memory operations that need pre-reserve sequence numbers: 4559N/A * The memory operations that "release" memory blocks and the 4559N/A * operations can fail, need to pre-reserve sequence number. They 4559N/A * are realloc, uncommit and release. 4559N/A * The reason for pre-reserve sequence number, is to prevent race condition: 4559N/A * if Thread 2 happens to obtain the memory address Thread 1 just released, 4559N/A * then NMT can mistakenly report the memory is free. 4559N/A * Noticeably, free() does not need pre-reserve sequence number, because the call 4559N/A * does not fail, so we can alway write "release" record before the memory is actaully 4559N/A * For realloc, uncommit and release, following coding pattern should be used: 4559N/A * MemTracker::Tracker tkr = MemTracker::get_realloc_tracker(); 4559N/A * MemTracker::Tracker tkr = MemTracker::get_virtual_memory_uncommit_tracker(); 4559N/A * MemTracker::Tracker tkr = MemTracker::get_virtual_memory_release_tracker(); 4559N/A * Since pre-reserved sequence number is only good for the generation that it is acquired, 4559N/A * when there is pending Tracker that reserved sequence number, NMT sync-point has 4559N/A * to be skipped to prevent from advancing generation. This is done by inc and dec 4559N/A * MemTracker::_pending_op_count, when MemTracker::_pending_op_count > 0, NMT sync-point is skipped. 4559N/A * Not all pre-reservation of sequence number will increment pending op count. For JavaThreads 4559N/A * that honor safepoints, safepoint can not occur during the memory operations, so the 4559N/A * pre-reserved sequence number won't cross the generation boundary. 4559N/A // figure out if ThreadCritical lock is needed to write this operation 4559N/A // don't use Thread::current(), since it is possible that 4559N/A // the calling thread has yet to attach to VM 'Thread', 4559N/A // which will result assertion failure 4559N/A // JavaThreads that are safepoint safe, can run through safepoint, 4559N/A // so ThreadCritical is needed to ensure no threads at safepoint create 4559N/A // new records while the records are being gathered and the sequence number is changing 4559N/A // see if we need to pre-reserve sequence number for this operation 4559N/A // for the threads that honor safepoints, no safepoint can occur 4559N/A // during the lifespan of tracker, so we don't need to increase 4559N/A // free old address, use pre-reserved sequence number 4559N/A // decrement MemTracker pending_op_count 4559N/A // free old address, use pre-reserved sequence number 4559N/A // a bit of hack here, add a small postive offset to arena 4559N/A // address for its size record, so the size record is sorted 4559N/A // right after arena record. 4559N/A // write memory tracking record