memReporter.hpp

/*
 * Copyright (c) 2012 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_SERVICES_MEM_REPORTER_HPP
#define SHARE_VM_SERVICES_MEM_REPORTER_HPP

#include "runtime/mutexLocker.hpp"
#include "services/memBaseline.hpp"
#include "services/memTracker.hpp"
#include "utilities/ostream.hpp"

/*
 * MemBaselineReporter reports data to this outputer class,
 * ReportOutputer is responsible for format, store and redirect
 * the data to the final destination.
 */
class BaselineOutputer : public StackObj {
 public:
  // start to report memory usage in specified scale.
  // if report_diff = true, the reporter reports baseline comparison
  // information.

  virtual void start(size_t scale, bool report_diff = false) = 0;
  // Done reporting
  virtual void done() = 0;

  /* report baseline summary information */
  virtual void total_usage(size_t total_reserved,
                           size_t total_committed) = 0;
  virtual void num_of_classes(size_t classes) = 0;
  virtual void num_of_threads(size_t threads) = 0;

  virtual void thread_info(size_t stack_reserved_amt, size_t stack_committed_amt) = 0;

  /* report baseline summary comparison */
  virtual void diff_total_usage(size_t total_reserved,
                                size_t total_committed,
                                int reserved_diff,
                                int committed_diff) = 0;
  virtual void diff_num_of_classes(size_t classes, int diff) = 0;
  virtual void diff_num_of_threads(size_t threads, int diff) = 0;

  virtual void diff_thread_info(size_t stack_reserved, size_t stack_committed,
        int stack_reserved_diff, int stack_committed_diff) = 0;


  /*
   * memory summary by memory types.
   * for each memory type, following summaries are reported:
   *  - reserved amount, committed amount
   *  - malloc'd amount, malloc count
   *  - arena amount, arena count
   */

  // start reporting memory summary by memory type
  virtual void start_category_summary() = 0;

  virtual void category_summary(MEMFLAGS type, size_t reserved_amt,
                                size_t committed_amt,
                                size_t malloc_amt, size_t malloc_count,
                                size_t arena_amt, size_t arena_count) = 0;

  virtual void diff_category_summary(MEMFLAGS type, size_t cur_reserved_amt,
                                size_t cur_committed_amt,
                                size_t cur_malloc_amt, size_t cur_malloc_count,
                                size_t cur_arena_amt, size_t cur_arena_count,
                                int reserved_diff, int committed_diff, int malloc_diff,
                                int malloc_count_diff, int arena_diff,
                                int arena_count_diff) = 0;

  virtual void done_category_summary() = 0;

  /*
   *  Report callsite information
   */
  virtual void start_callsite() = 0;
  virtual void malloc_callsite(address pc, size_t malloc_amt, size_t malloc_count) = 0;
  virtual void virtual_memory_callsite(address pc, size_t reserved_amt, size_t committed_amt) = 0;

  virtual void diff_malloc_callsite(address pc, size_t cur_malloc_amt, size_t cur_malloc_count,
              int malloc_diff, int malloc_count_diff) = 0;
  virtual void diff_virtual_memory_callsite(address pc, size_t cur_reserved_amt, size_t cur_committed_amt,
              int reserved_diff, int committed_diff) = 0;

  virtual void done_callsite() = 0;

  // return current scale in "KB", "MB" or "GB"
  static const char* memory_unit(size_t scale);
};

/*
 * This class reports processed data from a baseline or
 * the changes between the two baseline.
 */
class BaselineReporter : public StackObj {
 private:
  BaselineOutputer&  _outputer;
  size_t             _scale;

 public:
  // construct a reporter that reports memory usage
  // in specified scale
  BaselineReporter(BaselineOutputer& outputer, size_t scale = K):
    _outputer(outputer) {
    _scale = scale;
  }
  virtual void report_baseline(const MemBaseline& baseline, bool summary_only = false);
  virtual void diff_baselines(const MemBaseline& cur, const MemBaseline& prev,
                              bool summary_only = false);

  void set_scale(size_t scale);
  size_t scale() const { return _scale; }

 private:
  void report_summaries(const MemBaseline& baseline);
  void report_callsites(const MemBaseline& baseline);

  void diff_summaries(const MemBaseline& cur, const MemBaseline& prev);
  void diff_callsites(const MemBaseline& cur, const MemBaseline& prev);

  // calculate memory size in current memory scale
  size_t amount_in_current_scale(size_t amt) const;
  // diff two unsigned values in current memory scale
  int    diff_in_current_scale(size_t value1, size_t value2) const;
  // diff two unsigned value
  int    diff(size_t value1, size_t value2) const;
};

/*
 * tty output implementation. Native memory tracking
 * DCmd uses this outputer.
 */
class BaselineTTYOutputer : public BaselineOutputer {
 private:
  size_t         _scale;

  size_t         _num_of_classes;
  size_t         _num_of_threads;
  size_t         _thread_stack_reserved;
  size_t         _thread_stack_committed;

  int            _num_of_classes_diff;
  int            _num_of_threads_diff;
  int            _thread_stack_reserved_diff;
  int            _thread_stack_committed_diff;

  outputStream*  _output;

 public:
  BaselineTTYOutputer(outputStream* st) {
    _scale = K;
    _num_of_classes = 0;
    _num_of_threads = 0;
    _thread_stack_reserved = 0;
    _thread_stack_committed = 0;
    _num_of_classes_diff = 0;
    _num_of_threads_diff = 0;
    _thread_stack_reserved_diff = 0;
    _thread_stack_committed_diff = 0;
    _output = st;
  }

  // begin reporting memory usage in specified scale
  void start(size_t scale, bool report_diff = false);
  // done reporting
  void done();

  // total memory usage
  void total_usage(size_t total_reserved,
                   size_t total_committed);
  // report total loaded classes
  void num_of_classes(size_t classes) {
    _num_of_classes = classes;
  }

  void num_of_threads(size_t threads) {
    _num_of_threads = threads;
  }

  void thread_info(size_t stack_reserved_amt, size_t stack_committed_amt) {
    _thread_stack_reserved = stack_reserved_amt;
    _thread_stack_committed = stack_committed_amt;
  }

  void diff_total_usage(size_t total_reserved,
                        size_t total_committed,
                        int reserved_diff,
                        int committed_diff);

  void diff_num_of_classes(size_t classes, int diff) {
    _num_of_classes = classes;
    _num_of_classes_diff = diff;
  }

  void diff_num_of_threads(size_t threads, int diff) {
    _num_of_threads = threads;
    _num_of_threads_diff = diff;
  }

  void diff_thread_info(size_t stack_reserved_amt, size_t stack_committed_amt,
               int stack_reserved_diff, int stack_committed_diff) {
    _thread_stack_reserved = stack_reserved_amt;
    _thread_stack_committed = stack_committed_amt;
    _thread_stack_reserved_diff = stack_reserved_diff;
    _thread_stack_committed_diff = stack_committed_diff;
  }

  /*
   * Report memory summary categoriuzed by memory types.
   * For each memory type, following summaries are reported:
   *  - reserved amount, committed amount
   *  - malloc-ed amount, malloc count
   *  - arena amount, arena count
   */
  // start reporting memory summary by memory type
  void start_category_summary();
  void category_summary(MEMFLAGS type, size_t reserved_amt, size_t committed_amt,
                               size_t malloc_amt, size_t malloc_count,
                               size_t arena_amt, size_t arena_count);

  void diff_category_summary(MEMFLAGS type, size_t cur_reserved_amt,
                          size_t cur_committed_amt,
                          size_t cur_malloc_amt, size_t cur_malloc_count,
                          size_t cur_arena_amt, size_t cur_arena_count,
                          int reserved_diff, int committed_diff, int malloc_diff,
                          int malloc_count_diff, int arena_diff,
                          int arena_count_diff);

  void done_category_summary();

  /*
   *  Report callsite information
   */
  void start_callsite();
  void malloc_callsite(address pc, size_t malloc_amt, size_t malloc_count);
  void virtual_memory_callsite(address pc, size_t reserved_amt, size_t committed_amt);

  void diff_malloc_callsite(address pc, size_t cur_malloc_amt, size_t cur_malloc_count,
              int malloc_diff, int malloc_count_diff);
  void diff_virtual_memory_callsite(address pc, size_t cur_reserved_amt, size_t cur_committed_amt,
              int reserved_diff, int committed_diff);

  void done_callsite();
};


#endif // SHARE_VM_SERVICES_MEM_REPORTER_HPP