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