rev 2896 : 6484965: G1: piggy-back liveness accounting phase on marking
Summary: Remove the separate counting phase of concurrent marking by tracking the amount of marked bytes and the cards spanned by marked objects in marking task/worker thread local data structures, which are updated as individual objects are marked.
Reviewed-by: brutisso

          --- old/src/share/vm/gc_implementation/g1/concurrentMarkThread.hpp
          +++ new/src/share/vm/gc_implementation/g1/concurrentMarkThread.hpp

   1    1  /*
   2    2   * Copyright (c) 2001, 2010, 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_G1_CONCURRENTMARKTHREAD_HPP
  26   26  #define SHARE_VM_GC_IMPLEMENTATION_G1_CONCURRENTMARKTHREAD_HPP
  27   27  
  28   28  #include "gc_implementation/shared/concurrentGCThread.hpp"
  29   29  
  30   30  // The Concurrent Mark GC Thread (could be several in the future).
  31   31  // This is copied from the Concurrent Mark Sweep GC Thread
  32   32  // Still under construction.

  33   33  
  34   34  class ConcurrentMark;
  35   35  
  36   36  class ConcurrentMarkThread: public ConcurrentGCThread {
  37   37    friend class VMStructs;
  38   38  
  39   39    double _vtime_start;  // Initial virtual time.
  40   40    double _vtime_accum;  // Accumulated virtual time.
  41   41  
  42   42    double _vtime_mark_accum;
  43      -  double _vtime_count_accum;
  44   43  
  45   44   public:
  46   45    virtual void run();
  47   46  
  48   47   private:
  49   48    ConcurrentMark*                  _cm;
  50   49    volatile bool                    _started;
  51   50    volatile bool                    _in_progress;
  52   51  
  53   52    void sleepBeforeNextCycle();

  54   53  
  55   54    static SurrogateLockerThread*         _slt;
  56   55  
  57   56   public:
  58   57    // Constructor
  59   58    ConcurrentMarkThread(ConcurrentMark* cm);
  60   59  
  61   60    static void makeSurrogateLockerThread(TRAPS);

  62   61    static SurrogateLockerThread* slt() { return _slt; }
  63   62  
  64   63    // Printing
  65   64    void print_on(outputStream* st) const;
  66   65    void print() const;
  67   66  
  68   67    // Total virtual time so far.
  69   68    double vtime_accum();
  70   69    // Marking virtual time so far
  71   70    double vtime_mark_accum();
  72      -  // Counting virtual time so far.
  73      -  double vtime_count_accum() { return _vtime_count_accum; }
  74   71  
  75   72    ConcurrentMark* cm()     { return _cm; }
  76   73  
  77   74    void set_started()       { assert(!_in_progress, "cycle in progress"); _started = true;  }
  78   75    void clear_started()     { assert(_in_progress, "must be starting a cycle"); _started = false; }
  79   76    bool started()           { return _started;  }
  80   77  
  81   78    void set_in_progress()   { assert(_started, "must be starting a cycle"); _in_progress = true;  }
  82   79    void clear_in_progress() { assert(!_started, "must not be starting a new cycle"); _in_progress = false; }
  83   80    bool in_progress()       { return _in_progress;  }

  84   81  
  85   82    // This flag returns true from the moment a marking cycle is
  86   83    // initiated (during the initial-mark pause when started() is set)
  87   84    // to the moment when the cycle completes (just after the next
  88   85    // marking bitmap has been cleared and in_progress() is
  89   86    // cleared). While this flag is true we will not start another cycle
  90   87    // so that cycles do not overlap. We cannot use just in_progress()
  91   88    // as the CM thread might take some time to wake up before noticing
  92   89    // that started() is set and set in_progress().
  93   90    bool during_cycle()      { return started() || in_progress(); }
  94   91  
  95   92    // Yield for GC
  96   93    void            yield();
  97   94  
  98   95    // shutdown
  99   96    void stop();
 100   97  };
 101   98  
 102   99  #endif // SHARE_VM_GC_IMPLEMENTATION_G1_CONCURRENTMARKTHREAD_HPP

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX