0N/A

0N/Aclass ConcurrentMarkSweepGeneration;

0N/Aclass CMSCollector;

0N/A

0N/Aclass ConcurrentMarkSweepThread: public ConcurrentGCThread {

0N/A friend class VMStructs;

0N/A friend class ConcurrentMarkSweepGeneration; // XXX should remove friendship

0N/A friend class CMSCollector;

0N/A public:

0N/A virtual void run();

0N/A

0N/A private:

0N/A static ConcurrentMarkSweepThread* _cmst;

0N/A static CMSCollector* _collector;

0N/A static SurrogateLockerThread* _slt;

0N/A static SurrogateLockerThread::SLT_msg_type _sltBuffer;

0N/A static Monitor* _sltMonitor;

0N/A

0N/A ConcurrentMarkSweepThread* _next;

0N/A

0N/A static bool _should_terminate;

0N/A

0N/A enum CMS_flag_type {

0N/A CMS_nil = NoBits,

0N/A CMS_cms_wants_token = nth_bit(0),

0N/A CMS_cms_has_token = nth_bit(1),

0N/A CMS_vm_wants_token = nth_bit(2),

0N/A CMS_vm_has_token = nth_bit(3)

0N/A };

0N/A

0N/A static int _CMS_flag;

0N/A

0N/A static bool CMS_flag_is_set(int b) { return (_CMS_flag & b) != 0; }

0N/A static bool set_CMS_flag(int b) { return (_CMS_flag |= b) != 0; }

0N/A static bool clear_CMS_flag(int b) { return (_CMS_flag &= ~b) != 0; }

0N/A void sleepBeforeNextCycle();

0N/A

0N/A // CMS thread should yield for a young gen collection, direct allocation,

0N/A // and iCMS activity.

0N/A static char _pad_1[64 - sizeof(jint)]; // prevent cache-line sharing

0N/A static volatile jint _pending_yields;

0N/A static volatile jint _pending_decrements; // decrements to _pending_yields

0N/A static char _pad_2[64 - sizeof(jint)]; // prevent cache-line sharing

0N/A

0N/A // Tracing messages, enabled by CMSTraceThreadState.

0N/A static inline void trace_state(const char* desc);

0N/A

0N/A static volatile bool _icms_enabled; // iCMS enabled?

0N/A static volatile bool _should_run; // iCMS may run

0N/A static volatile bool _should_stop; // iCMS should stop

0N/A

0N/A // debugging

0N/A void verify_ok_to_terminate() const PRODUCT_RETURN;

0N/A

0N/A public:

0N/A // Constructor

0N/A ConcurrentMarkSweepThread(CMSCollector* collector);

0N/A

0N/A static void makeSurrogateLockerThread(TRAPS);

0N/A static SurrogateLockerThread* slt() { return _slt; }

0N/A

0N/A // Tester

0N/A bool is_ConcurrentGC_thread() const { return true; }

0N/A

0N/A static void threads_do(ThreadClosure* tc);

0N/A

0N/A // Printing

0N/A void print_on(outputStream* st) const;

0N/A void print() const { print_on(tty); }

0N/A static void print_all_on(outputStream* st);

0N/A static void print_all() { print_all_on(tty); }

0N/A

0N/A // Returns the CMS Thread

0N/A static ConcurrentMarkSweepThread* cmst() { return _cmst; }

0N/A static CMSCollector* collector() { return _collector; }

0N/A

0N/A // Create and start the CMS Thread, or stop it on shutdown

0N/A static ConcurrentMarkSweepThread* start(CMSCollector* collector);

0N/A static void stop();

0N/A static bool should_terminate() { return _should_terminate; }

0N/A

0N/A // Synchronization using CMS token

0N/A static void synchronize(bool is_cms_thread);

0N/A static void desynchronize(bool is_cms_thread);

0N/A static bool vm_thread_has_cms_token() {

0N/A return CMS_flag_is_set(CMS_vm_has_token);

0N/A }

0N/A static bool cms_thread_has_cms_token() {

0N/A return CMS_flag_is_set(CMS_cms_has_token);

0N/A }

0N/A static bool vm_thread_wants_cms_token() {

0N/A return CMS_flag_is_set(CMS_vm_wants_token);

0N/A }

0N/A static bool cms_thread_wants_cms_token() {

0N/A return CMS_flag_is_set(CMS_cms_wants_token);

0N/A }

0N/A

0N/A // Wait on CMS lock until the next synchronous GC

0N/A // or given timeout, whichever is earlier.

0N/A void wait_on_cms_lock(long t); // milliseconds

0N/A

0N/A // The CMS thread will yield during the work portion of it's cycle

0N/A // only when requested to. Both synchronous and asychronous requests

0N/A // are provided. A synchronous request is used for young gen

0N/A // collections and direct allocations. The requesting thread increments

0N/A // pending_yields at the beginning of an operation, and decrements it when

0N/A // the operation is completed. The CMS thread yields when pending_yields

0N/A // is positive. An asynchronous request is used by iCMS in the stop_icms()

0N/A // operation. A single yield satisfies the outstanding asynch yield requests.

0N/A // The requesting thread increments both pending_yields and pending_decrements.

0N/A // After yielding, the CMS thread decrements both by the amount in

0N/A // pending_decrements.

0N/A // Note that, while "_pending_yields >= _pending_decrements" is an invariant,

0N/A // we cannot easily test that invariant, since the counters are manipulated via

0N/A // atomic instructions without explicit locking and we cannot read

0N/A // the two counters atomically together: one suggestion is to

0N/A // use (for example) 16-bit counters so as to be able to read the

0N/A // two counters atomically even on 32-bit platforms. Notice that

0N/A // the second assert in acknowledge_yield_request() does indeed

0N/A // check a form of the above invariant, albeit indirectly.

0N/A

0N/A static void increment_pending_yields() {

0N/A Atomic::inc(&_pending_yields);

0N/A assert(_pending_yields >= 0, "can't be negative");

0N/A }

0N/A static void decrement_pending_yields() {

0N/A Atomic::dec(&_pending_yields);

0N/A assert(_pending_yields >= 0, "can't be negative");

0N/A }

0N/A static void asynchronous_yield_request() {

0N/A increment_pending_yields();

0N/A Atomic::inc(&_pending_decrements);

0N/A assert(_pending_decrements >= 0, "can't be negative");

0N/A }

0N/A static void acknowledge_yield_request() {

0N/A jint decrement = _pending_decrements;

0N/A if (decrement > 0) {

0N/A // Order important to preserve: _pending_yields >= _pending_decrements

0N/A Atomic::add(-decrement, &_pending_decrements);

0N/A Atomic::add(-decrement, &_pending_yields);

0N/A assert(_pending_decrements >= 0, "can't be negative");

0N/A assert(_pending_yields >= 0, "can't be negative");

0N/A }

0N/A }

0N/A static bool should_yield() { return _pending_yields > 0; }

0N/A

0N/A // CMS incremental mode.

0N/A static void start_icms(); // notify thread to start a quantum of work

0N/A static void stop_icms(); // request thread to stop working

0N/A void icms_wait(); // if asked to stop, wait until notified to start

0N/A

0N/A // Incremental mode is enabled globally by the flag CMSIncrementalMode. It

0N/A // must also be enabled/disabled dynamically to allow foreground collections.

0N/A static inline void enable_icms() { _icms_enabled = true; }

0N/A static inline void disable_icms() { _icms_enabled = false; }

0N/A static inline void set_icms_enabled(bool val) { _icms_enabled = val; }

0N/A static inline bool icms_enabled() { return _icms_enabled; }

0N/A};

0N/A

0N/Ainline void ConcurrentMarkSweepThread::trace_state(const char* desc) {

0N/A if (CMSTraceThreadState) {

0N/A char buf[128];

0N/A TimeStamp& ts = gclog_or_tty->time_stamp();

0N/A if (!ts.is_updated()) {

0N/A ts.update();

0N/A }

0N/A jio_snprintf(buf, sizeof(buf), " [%.3f: CMSThread %s] ",

0N/A ts.seconds(), desc);

0N/A buf[sizeof(buf) - 1] = '\0';

0N/A gclog_or_tty->print(buf);

0N/A }

0N/A}

0N/A

0N/Aclass CMSSynchronousYieldRequest: public StackObj {

0N/A public:

0N/A CMSSynchronousYieldRequest() {

0N/A ConcurrentMarkSweepThread::increment_pending_yields();

0N/A }

0N/A ~CMSSynchronousYieldRequest() {

0N/A ConcurrentMarkSweepThread::decrement_pending_yields();

0N/A }

0N/A};

0N/A

0N/Aclass CMSLoopCountWarn: public StackObj {

0N/A private:

0N/A const char* _src;

0N/A const char* _msg;

0N/A const intx _threshold;

0N/A intx _ticks;

0N/A

0N/A public:

0N/A inline CMSLoopCountWarn(const char* src, const char* msg,

0N/A const intx threshold) :

0N/A _src(src), _msg(msg), _threshold(threshold), _ticks(0) { }

0N/A

0N/A inline void tick() {

0N/A _ticks++;

0N/A if (CMSLoopWarn && _ticks % _threshold == 0) {

0N/A warning("%s has looped %d times %s", _src, _ticks, _msg);

0N/A }

0N/A }

0N/A};