/*
 * Copyright (c) 2017, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 *
 */

#ifndef SHARE_VM_GC_SHARED_REFERENCEPROCESSORPHASETIMES_HPP
#define SHARE_VM_GC_SHARED_REFERENCEPROCESSORPHASETIMES_HPP

#include "gc/shared/referenceProcessorStats.hpp"
#include "gc/shared/workerDataArray.hpp"
#include "memory/referenceType.hpp"
#include "utilities/ticks.hpp"

class DiscoveredList;
class GCTimer;

class ReferenceProcessorPhaseTimes : public CHeapObj<mtGC> {
public:
  // Detailed phases that has parallel work.
  enum RefProcParPhases {
    SoftRefPhase1,
    SoftRefPhase2,
    SoftRefPhase3,
    WeakRefPhase2,
    WeakRefPhase3,
    FinalRefPhase2,
    FinalRefPhase3,
    PhantomRefPhase2,
    PhantomRefPhase3,
    RefEnqueue,
    RefParPhaseMax
  };

  // Sub-phases that are used when processing each j.l.Reference types.
  // Only SoftReference has RefPhase1.
  enum RefProcPhaseNumbers {
    RefPhase1,
    RefPhase2,
    RefPhase3,
    RefPhaseMax
  };

private:
  static const int number_of_subclasses_of_ref = REF_PHANTOM - REF_OTHER; // 5 - 1 = 4

  // Records per thread information of each phase.
  WorkerDataArray<double>* _worker_time_sec[RefParPhaseMax];
  // Records elapsed time of each phase.
  double                   _par_phase_time_ms[RefParPhaseMax];

  // Total spent time for references.
  // e.g. _ref_proc_time_ms[0] = _par_phase_time_ms[SoftRefPhase1] +
  //                             _par_phase_time_ms[SoftRefPhase2] +
  //                             _par_phase_time_ms[SoftRefPhase3] + extra time.
  double                   _ref_proc_time_ms[number_of_subclasses_of_ref];

  double                   _total_time_ms;

  size_t                   _ref_cleared[number_of_subclasses_of_ref];
  size_t                   _ref_discovered[number_of_subclasses_of_ref];
  size_t                   _ref_enqueued[number_of_subclasses_of_ref];
  double                   _balance_queues_time_ms[number_of_subclasses_of_ref];

  bool                     _processing_is_mt;

  // Currently processing reference type.
  ReferenceType            _processing_ref_type;

  GCTimer*                 _gc_timer;

  double par_phase_time_ms(RefProcParPhases phase) const;
  double ref_proc_time_ms(ReferenceType ref_type) const;

  double total_time_ms() const { return _total_time_ms; }

  size_t ref_cleared(ReferenceType ref_type) const;
  size_t ref_enqueued(ReferenceType ref_type) const;

  double balance_queues_time_ms(ReferenceType ref_type) const;

  void print_reference(ReferenceType ref_type, uint base_indent) const;
  void print_phase(RefProcParPhases phase, uint indent) const;

public:
  ReferenceProcessorPhaseTimes(GCTimer* gc_timer, uint max_gc_threads);
  ~ReferenceProcessorPhaseTimes();

  static double uninitialized() { return -1.0; }

  WorkerDataArray<double>* worker_time_sec(RefProcParPhases phase) const;
  void set_par_phase_time_ms(RefProcParPhases phase, double par_phase_time_ms);

  void set_ref_proc_time_ms(ReferenceType ref_type, double ref_proc_time_ms);

  void set_total_time_ms(double total_time_ms) { _total_time_ms = total_time_ms; }

  void set_ref_cleared(ReferenceType ref_type, size_t count);
  size_t ref_discovered(ReferenceType ref_type) const;
  void set_ref_discovered(ReferenceType ref_type, size_t count);
  void set_ref_enqueued(ReferenceType ref_type, size_t count);

  void set_balance_queues_time_ms(ReferenceType ref_type, double time_ms);

  void set_processing_is_mt(bool processing_is_mt) { _processing_is_mt = processing_is_mt; }

  ReferenceType processing_ref_type() const { return _processing_ref_type; }
  void set_processing_ref_type(ReferenceType processing_ref_type) { _processing_ref_type = processing_ref_type; }

  // Returns RefProcParPhases calculated from phase_number and _processing_ref_type.
  RefProcParPhases par_phase(RefProcPhaseNumbers phase_number) const;

  GCTimer* gc_timer() const { return _gc_timer; }

  // Reset all fields. If not reset at next cycle, an assertion will fail.
  void reset();

  void print_enqueue_phase(uint base_indent = 0, bool print_total = true) const;
  void print_all_references(uint base_indent = 0, bool print_total = true) const;
};

// Updates working time of each worker thread.
class RefProcWorkerTimeTracker : public StackObj {
protected:
  WorkerDataArray<double>* _worker_time;
  double                   _start_time;
  uint                     _worker_id;

public:
  RefProcWorkerTimeTracker(ReferenceProcessorPhaseTimes::RefProcPhaseNumbers number,
                           ReferenceProcessorPhaseTimes* phase_times,
                           uint worker_id);
  RefProcWorkerTimeTracker(ReferenceProcessorPhaseTimes::RefProcParPhases phase,
                           ReferenceProcessorPhaseTimes* phase_times,
                           uint worker_id);
  ~RefProcWorkerTimeTracker();
};

class RefProcPhaseTimeBaseTracker : public StackObj {
protected:
  const char*                   _title;
  ReferenceProcessorPhaseTimes* _phase_times;
  Ticks                         _start_ticks;
  Ticks                         _end_ticks;

  Ticks end_ticks();
  double elapsed_time();
  ReferenceProcessorPhaseTimes* phase_times() const { return _phase_times; }
  // Print phase elapsed time with each worker information if MT processed.
  void print_phase(ReferenceProcessorPhaseTimes::RefProcParPhases phase, uint indent);

public:
  RefProcPhaseTimeBaseTracker(const char* title,
                              ReferenceProcessorPhaseTimes* phase_times);
  ~RefProcPhaseTimeBaseTracker();
};

// Updates queue balance time at ReferenceProcessorPhaseTimes and
// save it into GCTimer.
class RefProcBalanceQueuesTimeTracker : public RefProcPhaseTimeBaseTracker {
public:
  RefProcBalanceQueuesTimeTracker(ReferenceProcessorPhaseTimes* phase_times);
  ~RefProcBalanceQueuesTimeTracker();
};

// Updates phase time at ReferenceProcessorPhaseTimes and save it into GCTimer.
class RefProcParPhaseTimeTracker : public RefProcPhaseTimeBaseTracker {
  ReferenceProcessorPhaseTimes::RefProcPhaseNumbers _phase_number;

public:
  RefProcParPhaseTimeTracker(ReferenceProcessorPhaseTimes::RefProcPhaseNumbers phase_number,
                             ReferenceProcessorPhaseTimes* phase_times);
  ~RefProcParPhaseTimeTracker();
};

// Updates phase time related information.
// - Each phase processing time, cleared/discovered reference counts and stats for each working threads if MT processed.
class RefProcPhaseTimesTracker : public RefProcPhaseTimeBaseTracker {
  ReferenceProcessor* _rp;

public:
  RefProcPhaseTimesTracker(ReferenceType ref_type,
                           ReferenceProcessorPhaseTimes* phase_times,
                           ReferenceProcessor* rp);
  ~RefProcPhaseTimesTracker();
};

// Updates enqueue time related information.
// - Enqueueing time, enqueued reference count and stats for each working thread if MT processed.
class RefProcEnqueueTimeTracker : public RefProcPhaseTimeBaseTracker {
public:
  RefProcEnqueueTimeTracker(ReferenceProcessorPhaseTimes* phase_times,
                            ReferenceProcessorStats& stats);
  ~RefProcEnqueueTimeTracker();
};

#endif // SHARE_VM_GC_SHARED_REFERENCEPROCESSORPHASETIMES_HPP