1 /*

     2  * Copyright 2001-2005 Sun Microsystems, Inc.  All Rights Reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.

     8  *

     9  * This code is distributed in the hope that it will be useful, but WITHOUT

    10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    12  * version 2 for more details (a copy is included in the LICENSE file that

    13  * accompanied this code).

    14  *

    15  * You should have received a copy of the GNU General Public License version

    16  * 2 along with this work; if not, write to the Free Software Foundation,

    17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    18  *

    19  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

    20  * CA 95054 USA or visit www.sun.com if you need additional information or

    21  * have any questions.

    22  *

    23  */

    24 

    25 class VoidClosure;

    26 

    27 // A SuspendibleThreadSet is (obviously) a set of threads that can be

    28 // suspended.  A thread can join and later leave the set, and periodically

    29 // yield.  If some thread (not in the set) requests, via suspend_all, that

    30 // the threads be suspended, then the requesting thread is blocked until

    31 // all the threads in the set have yielded or left the set.  (Threads may

    32 // not enter the set when an attempted suspension is in progress.)  The

    33 // suspending thread later calls resume_all, allowing the suspended threads

    34 // to continue.

    35 

    36 class SuspendibleThreadSet {

    37   Monitor* _m;

    38   int      _async;

    39   bool     _async_stop;

    40   int      _async_stopped;

    41   bool     _initialized;

    42   double   _suspend_all_start;

    43 

    44   void initialize_work();

    45 

    46  public:

    47   SuspendibleThreadSet() : _initialized(false) {}

    48 

    49   // Add the current thread to the set.  May block if a suspension

    50   // is in progress.

    51   void join();

    52   // Removes the current thread from the set.

    53   void leave();

    54   // Returns "true" iff an suspension is in progress.

    55   bool should_yield() { return _async_stop; }

    56   // Suspends the current thread if a suspension is in progress (for

    57   // the duration of the suspension.)

    58   void yield(const char* id);

    59   // Return when all threads in the set are suspended.

    60   void suspend_all();

    61   // Allow suspended threads to resume.

    62   void resume_all();

    63   // Redundant initializations okay.

    64   void initialize() {

    65     // Double-check dirty read idiom.

    66     if (!_initialized) initialize_work();

    67   }

    68 };

    69 

    70 

    71 class ConcurrentGCThread: public NamedThread {

    72   friend class VMStructs;

    73 

    74 protected:

    75   static bool _should_terminate;

    76   static bool _has_terminated;

    77 

    78   enum CGC_flag_type {

    79     CGC_nil           = 0x0,

    80     CGC_dont_suspend  = 0x1,

    81     CGC_CGC_safepoint = 0x2,

    82     CGC_VM_safepoint  = 0x4

    83   };

    84 

    85   static int _CGC_flag;

    86 

    87   static bool CGC_flag_is_set(int b)       { return (_CGC_flag & b) != 0; }

    88   static int set_CGC_flag(int b)           { return _CGC_flag |= b; }

    89   static int reset_CGC_flag(int b)         { return _CGC_flag &= ~b; }

    90 

    91   void stopWorldAndDo(VoidClosure* op);

    92 

    93   // All instances share this one set.

    94   static SuspendibleThreadSet _sts;

    95 

    96   // Create and start the thread (setting it's priority high.)

    97   void create_and_start();

    98 

    99   // Do initialization steps in the thread: record stack base and size,

   100   // init thread local storage, set JNI handle block.

   101   void initialize_in_thread();

   102 

   103   // Wait until Universe::is_fully_initialized();

   104   void wait_for_universe_init();

   105 

   106   // Record that the current thread is terminating, and will do more

   107   // concurrent work.

   108   void terminate();

   109 

   110 public:

   111   // Constructor

   112 

   113   ConcurrentGCThread();

   114   ~ConcurrentGCThread() {} // Exists to call NamedThread destructor.

   115 

   116   // Tester

   117   bool is_ConcurrentGC_thread() const          { return true;       }

   118 

   119   static void safepoint_synchronize();

   120   static void safepoint_desynchronize();

   121 

   122   // All overridings should probably do _sts::yield, but we allow

   123   // overriding for distinguished debugging messages.  Default is to do

   124   // nothing.

   125   virtual void yield() {}

   126 

   127   bool should_yield() { return _sts.should_yield(); }

   128 

   129   // they are prefixed by sts since there are already yield() and

   130   // should_yield() (non-static) methods in this class and it was an

   131   // easy way to differentiate them.

   132   static void stsYield(const char* id);

   133   static bool stsShouldYield();

   134   static void stsJoin();

   135   static void stsLeave();

   136 

   137 };

   138 

   139 // The SurrogateLockerThread is used by concurrent GC threads for

   140 // manipulating Java monitors, in particular, currently for

   141 // manipulating the pending_list_lock. XXX

   142 class SurrogateLockerThread: public JavaThread {

   143   friend class VMStructs;

   144  public:

   145   enum SLT_msg_type {

   146     empty = 0,           // no message

   147     acquirePLL,          // acquire pending list lock

   148     releaseAndNotifyPLL  // notify and release pending list lock

   149   };

   150  private:

   151   // the following are shared with the CMSThread

   152   SLT_msg_type  _buffer;  // communication buffer

   153   Monitor       _monitor; // monitor controlling buffer

   154   BasicLock     _basicLock; // used for PLL locking

   155 

   156  public:

   157   static SurrogateLockerThread* make(TRAPS);

   158 

   159   SurrogateLockerThread();

   160 

   161   bool is_hidden_from_external_view() const     { return true; }

   162 

   163   void loop(); // main method

   164 

   165   void manipulatePLL(SLT_msg_type msg);

   166 

   167 };