rev 6902 : 8062036: ConcurrentMarkThread::slt may be invoked before ConcurrentMarkThread::makeSurrogateLockerThread causing intermittent crashes
Summary: Suppress gc_alot during VM init, improve error for SLT uninitialized.
Reviewed-by: jmasa, brutisso, tschatzl

          --- old/hotspot/src/share/vm/gc_implementation/shared/concurrentGCThread.hpp
          +++ new/hotspot/src/share/vm/gc_implementation/shared/concurrentGCThread.hpp

   1    1  /*
   2    2   * Copyright (c) 2001, 2013, Oracle and/or its affiliates. All rights reserved.
   3    3   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4    4   *
   5    5   * This code is free software; you can redistribute it and/or modify it
   6    6   * under the terms of the GNU General Public License version 2 only, as
   7    7   * published by the Free Software Foundation.
   8    8   *
   9    9   * This code is distributed in the hope that it will be useful, but WITHOUT
  10   10   * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11   11   * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12   12   * version 2 for more details (a copy is included in the LICENSE file that
  13   13   * accompanied this code).
  14   14   *
  15   15   * You should have received a copy of the GNU General Public License version
  16   16   * 2 along with this work; if not, write to the Free Software Foundation,
  17   17   * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18   18   *
  19   19   * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20   20   * or visit www.oracle.com if you need additional information or have any
  21   21   * questions.
  22   22   *
  23   23   */
  24   24  
  25   25  #ifndef SHARE_VM_GC_IMPLEMENTATION_SHARED_CONCURRENTGCTHREAD_HPP
  26   26  #define SHARE_VM_GC_IMPLEMENTATION_SHARED_CONCURRENTGCTHREAD_HPP
  27   27  
  28   28  #include "utilities/macros.hpp"
  29   29  #include "gc_implementation/shared/suspendibleThreadSet.hpp"
  30   30  #include "runtime/thread.hpp"
  31   31  
  32   32  class ConcurrentGCThread: public NamedThread {
  33   33    friend class VMStructs;
  34   34  
  35   35  protected:
  36   36    bool _should_terminate;
  37   37    bool _has_terminated;
  38   38  
  39   39    enum CGC_flag_type {
  40   40      CGC_nil           = 0x0,
  41   41      CGC_dont_suspend  = 0x1,
  42   42      CGC_CGC_safepoint = 0x2,
  43   43      CGC_VM_safepoint  = 0x4
  44   44    };
  45   45  
  46   46    static int _CGC_flag;
  47   47  
  48   48    static bool CGC_flag_is_set(int b)       { return (_CGC_flag & b) != 0; }
  49   49    static int set_CGC_flag(int b)           { return _CGC_flag |= b; }
  50   50    static int reset_CGC_flag(int b)         { return _CGC_flag &= ~b; }
  51   51  
  52   52    // Create and start the thread (setting it's priority high.)
  53   53    void create_and_start();
  54   54  
  55   55    // Do initialization steps in the thread: record stack base and size,
  56   56    // init thread local storage, set JNI handle block.
  57   57    void initialize_in_thread();
  58   58  
  59   59    // Wait until Universe::is_fully_initialized();
  60   60    void wait_for_universe_init();
  61   61  
  62   62    // Record that the current thread is terminating, and will do more
  63   63    // concurrent work.
  64   64    void terminate();
  65   65  
  66   66  public:
  67   67    // Constructor
  68   68  
  69   69    ConcurrentGCThread();
  70   70    ~ConcurrentGCThread() {} // Exists to call NamedThread destructor.
  71   71  
  72   72    // Tester
  73   73    bool is_ConcurrentGC_thread() const          { return true;       }
  74   74  };
  75   75  
  76   76  // The SurrogateLockerThread is used by concurrent GC threads for
  77   77  // manipulating Java monitors, in particular, currently for
  78   78  // manipulating the pending_list_lock. XXX
  79   79  class SurrogateLockerThread: public JavaThread {
  80   80    friend class VMStructs;
  81   81   public:
  82   82    enum SLT_msg_type {
  83   83      empty = 0,           // no message
  84   84      acquirePLL,          // acquire pending list lock
  85   85      releaseAndNotifyPLL  // notify and release pending list lock

  86   86    };
  87   87   private:
  88   88    // the following are shared with the CMSThread
  89   89    SLT_msg_type  _buffer;  // communication buffer
  90   90    Monitor       _monitor; // monitor controlling buffer
  91   91    BasicLock     _basicLock; // used for PLL locking
  92   92  
  93   93   public:
  94   94    static SurrogateLockerThread* make(TRAPS);
  95   95  
       96 +  // Terminate VM with error message that SLT needed but not yet created.
       97 +  static void report_missing_slt();
       98 +
  96   99    SurrogateLockerThread();
  97  100  
  98  101    bool is_hidden_from_external_view() const     { return true; }
  99  102  
 100  103    void loop(); // main method
 101  104  
 102  105    void manipulatePLL(SLT_msg_type msg);
 103  106  
 104  107  };
 105  108  
 106  109  #endif // SHARE_VM_GC_IMPLEMENTATION_SHARED_CONCURRENTGCTHREAD_HPP
    

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX