1 /*
   2  * Copyright (c) 1998, 2016, Oracle and/or its affiliates. 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 #ifndef SHARE_VM_RUNTIME_VMTHREAD_HPP
  26 #define SHARE_VM_RUNTIME_VMTHREAD_HPP
  27 
  28 #include "runtime/perfData.hpp"
  29 #include "runtime/thread.hpp"
  30 #include "runtime/vm_operations.hpp"
  31 
  32 //
  33 // Prioritized queue of VM operations.
  34 //
  35 // Encapsulates both queue management and
  36 // and priority policy
  37 //
  38 class VMOperationQueue : public CHeapObj<mtInternal> {
  39  private:
  40   enum Priorities {
  41      SafepointPriority, // Highest priority (operation executed at a safepoint)
  42      MediumPriority,    // Medium priority
  43      nof_priorities
  44   };
  45 
  46   // We maintain a doubled linked list, with explicit count.
  47   int           _queue_length[nof_priorities];
  48   int           _queue_counter;
  49   VM_Operation* _queue       [nof_priorities];
  50   // we also allow the vmThread to register the ops it has drained so we
  51   // can scan them from oops_do
  52   VM_Operation* _drain_list;
  53 
  54   // Double-linked non-empty list insert.
  55   void insert(VM_Operation* q,VM_Operation* n);
  56   void unlink(VM_Operation* q);
  57 
  58   // Basic queue manipulation
  59   bool queue_empty                (int prio);
  60   void queue_add_front            (int prio, VM_Operation *op);
  61   void queue_add_back             (int prio, VM_Operation *op);
  62   VM_Operation* queue_remove_front(int prio);
  63   void queue_oops_do(int queue, OopClosure* f);
  64   void drain_list_oops_do(OopClosure* f);
  65   VM_Operation* queue_drain(int prio);
  66   // lock-free query: may return the wrong answer but must not break
  67   bool queue_peek(int prio) { return _queue_length[prio] > 0; }
  68 
  69  public:
  70   VMOperationQueue();
  71 
  72   // Highlevel operations. Encapsulates policy
  73   bool add(VM_Operation *op);
  74   VM_Operation* remove_next();                        // Returns next or null
  75   VM_Operation* remove_next_at_safepoint_priority()   { return queue_remove_front(SafepointPriority); }
  76   VM_Operation* drain_at_safepoint_priority() { return queue_drain(SafepointPriority); }
  77   void set_drain_list(VM_Operation* list) { _drain_list = list; }
  78   bool peek_at_safepoint_priority() { return queue_peek(SafepointPriority); }
  79 
  80   // GC support
  81   void oops_do(OopClosure* f);
  82 
  83   void verify_queue(int prio) PRODUCT_RETURN;
  84 };
  85 
  86 
  87 //
  88 // A single VMThread (the primordial thread) spawns all other threads
  89 // and is itself used by other threads to offload heavy vm operations
  90 // like scavenge, garbage_collect etc.
  91 //
  92 
  93 class VMThread: public NamedThread {
  94  private:
  95   static ThreadPriority _current_priority;
  96 
  97   static bool _should_terminate;
  98   static bool _terminated;
  99   static Monitor * _terminate_lock;
 100   static PerfCounter* _perf_accumulated_vm_operation_time;
 101 
 102   static const char* _no_op_reason;
 103 
 104   static bool no_op_safepoint_needed(bool check_time);
 105 
 106   void evaluate_operation(VM_Operation* op);
 107 
 108  public:
 109   // Constructor
 110   VMThread();
 111 
 112   // No destruction allowed
 113   ~VMThread() {
 114     guarantee(false, "VMThread deletion must fix the race with VM termination");
 115   }
 116 
 117 
 118   // Tester
 119   bool is_VM_thread() const                      { return true; }
 120   bool is_GC_thread() const                      { return true; }
 121 
 122   // The ever running loop for the VMThread
 123   void loop();
 124 
 125   // Called to stop the VM thread
 126   static void wait_for_vm_thread_exit();
 127   static bool should_terminate()                  { return _should_terminate; }
 128   static bool is_terminated()                     { return _terminated == true; }
 129 
 130   // Execution of vm operation
 131   static void execute(VM_Operation* op);
 132 
 133   // Returns the current vm operation if any.
 134   static VM_Operation* vm_operation()             { return _cur_vm_operation; }
 135 
 136   // Returns the current vm operation name or set reason
 137   static const char* vm_safepoint_description()   { return _cur_vm_operation != NULL ? _cur_vm_operation->name() : _no_op_reason; };
 138 
 139   // Returns the single instance of VMThread.
 140   static VMThread* vm_thread()                    { return _vm_thread; }
 141 
 142   // GC support
 143   void oops_do(OopClosure* f, CodeBlobClosure* cf);
 144 
 145   void verify();
 146 
 147   // Performance measurement
 148   static PerfCounter* perf_accumulated_vm_operation_time()               { return _perf_accumulated_vm_operation_time; }
 149 
 150   // Entry for starting vm thread
 151   virtual void run();
 152 
 153   // Creations/Destructions
 154   static void create();
 155   static void destroy();
 156 
 157  private:
 158   // VM_Operation support
 159   static VM_Operation*     _cur_vm_operation;   // Current VM operation
 160   static VMOperationQueue* _vm_queue;           // Queue (w/ policy) of VM operations
 161 
 162   // Pointer to single-instance of VM thread
 163   static VMThread*     _vm_thread;
 164 };
 165 
 166 #endif // SHARE_VM_RUNTIME_VMTHREAD_HPP