/*

 * Copyright (c) 1997, 2011, 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.

 *

 */

#include "precompiled.hpp"

#include "classfile/classLoader.hpp"

#include "code/vtableStubs.hpp"

#include "gc_interface/collectedHeap.inline.hpp"

#include "interpreter/interpreter.hpp"

#include "memory/allocation.inline.hpp"

#include "memory/universe.inline.hpp"

#include "oops/oop.inline.hpp"

#include "oops/oop.inline2.hpp"

#include "oops/symbol.hpp"

#include "runtime/deoptimization.hpp"

#include "runtime/fprofiler.hpp"

#include "runtime/mutexLocker.hpp"

#include "runtime/stubCodeGenerator.hpp"

#include "runtime/stubRoutines.hpp"

#include "runtime/task.hpp"

#include "runtime/vframe.hpp"

#include "utilities/macros.hpp"

// Static fields of FlatProfiler

int               FlatProfiler::received_gc_ticks   = 0;

int               FlatProfiler::vm_operation_ticks  = 0;

int               FlatProfiler::threads_lock_ticks  = 0;

int               FlatProfiler::class_loader_ticks  = 0;

int               FlatProfiler::extra_ticks         = 0;

int               FlatProfiler::blocked_ticks       = 0;

int               FlatProfiler::deopt_ticks         = 0;

int               FlatProfiler::unknown_ticks       = 0;

int               FlatProfiler::interpreter_ticks   = 0;

int               FlatProfiler::compiler_ticks      = 0;

int               FlatProfiler::received_ticks      = 0;

int               FlatProfiler::delivered_ticks     = 0;

int*              FlatProfiler::bytecode_ticks      = NULL;

int*              FlatProfiler::bytecode_ticks_stub = NULL;

int               FlatProfiler::all_int_ticks       = 0;

int               FlatProfiler::all_comp_ticks      = 0;

int               FlatProfiler::all_ticks           = 0;

bool              FlatProfiler::full_profile_flag   = false;

ThreadProfiler*   FlatProfiler::thread_profiler     = NULL;

ThreadProfiler*   FlatProfiler::vm_thread_profiler  = NULL;

FlatProfilerTask* FlatProfiler::task                = NULL;

elapsedTimer      FlatProfiler::timer;

int               FlatProfiler::interval_ticks_previous = 0;

IntervalData*     FlatProfiler::interval_data       = NULL;

ThreadProfiler::ThreadProfiler() {

  // Space for the ProfilerNodes

  const int area_size = 1 * ProfilerNodeSize * 1024;

  area_bottom = AllocateHeap(area_size, "fprofiler");

  area_top    = area_bottom;

  area_limit  = area_bottom + area_size;

  // ProfilerNode pointer table

  table = NEW_C_HEAP_ARRAY(ProfilerNode*, table_size);

  initialize();

  engaged = false;

}

ThreadProfiler::~ThreadProfiler() {

  FreeHeap(area_bottom);

  area_bottom = NULL;

  area_top = NULL;

  area_limit = NULL;

  FreeHeap(table);

  table = NULL;

}

// Statics for ThreadProfiler

int ThreadProfiler::table_size = 1024;

int ThreadProfiler::entry(int  value) {

  value = (value > 0) ? value : -value;

  return value % table_size;

}

ThreadProfilerMark::ThreadProfilerMark(ThreadProfilerMark::Region r) {

  _r = r;

  _pp = NULL;

  assert(((r > ThreadProfilerMark::noRegion) && (r < ThreadProfilerMark::maxRegion)), "ThreadProfilerMark::Region out of bounds");

  Thread* tp = Thread::current();

  if (tp != NULL && tp->is_Java_thread()) {

    JavaThread* jtp = (JavaThread*) tp;

    ThreadProfiler* pp = jtp->get_thread_profiler();

    _pp = pp;

    if (pp != NULL) {

      pp->region_flag[r] = true;

    }

  }

}

ThreadProfilerMark::~ThreadProfilerMark() {

  if (_pp != NULL) {

    _pp->region_flag[_r] = false;

  }

  _pp = NULL;

}

// Random other statics

static const int col1 = 2;      // position of output column 1

static const int col2 = 11;     // position of output column 2

static const int col3 = 25;     // position of output column 3

static const int col4 = 55;     // position of output column 4

// Used for detailed profiling of nmethods.

class PCRecorder : AllStatic {

 private:

  static int*    counters;

  static address base;

  enum {

   bucket_size = 16

  };

  static int     index_for(address pc) { return (pc - base)/bucket_size;   }

  static address pc_for(int index)     { return base + (index * bucket_size); }

  static int     size() {

    return ((int)CodeCache::max_capacity())/bucket_size * BytesPerWord;

  }

 public:

  static address bucket_start_for(address pc) {

    if (counters == NULL) return NULL;

    return pc_for(index_for(pc));

  }

  static int bucket_count_for(address pc)  { return counters[index_for(pc)]; }

  static void init();

  static void record(address pc);

  static void print();

  static void print_blobs(CodeBlob* cb);

};

int*    PCRecorder::counters = NULL;

address PCRecorder::base     = NULL;

void PCRecorder::init() {

  MutexLockerEx lm(CodeCache_lock, Mutex::_no_safepoint_check_flag);

  int s = size();

  counters = NEW_C_HEAP_ARRAY(int, s);

  for (int index = 0; index < s; index++) {

    counters[index] = 0;

  }

  base = CodeCache::first_address();

}

void PCRecorder::record(address pc) {

  if (counters == NULL) return;

  assert(CodeCache::contains(pc), "must be in CodeCache");

  counters[index_for(pc)]++;

}

address FlatProfiler::bucket_start_for(address pc) {

  return PCRecorder::bucket_start_for(pc);

}

int FlatProfiler::bucket_count_for(address pc) {

  return PCRecorder::bucket_count_for(pc);

}

void PCRecorder::print() {

  if (counters == NULL) return;

  tty->cr();

  tty->print_cr("Printing compiled methods with PC buckets having more than %d ticks", ProfilerPCTickThreshold);

  tty->print_cr("===================================================================");

  tty->cr();

  GrowableArray<CodeBlob*>* candidates = new GrowableArray<CodeBlob*>(20);

  int s;

  {

    MutexLockerEx lm(CodeCache_lock, Mutex::_no_safepoint_check_flag);

    s = size();

  }

  for (int index = 0; index < s; index++) {

    int count = counters[index];

    if (count > ProfilerPCTickThreshold) {

      address pc = pc_for(index);

      CodeBlob* cb = CodeCache::find_blob_unsafe(pc);

      if (cb != NULL && candidates->find(cb) < 0) {

        candidates->push(cb);

      }

    }

  }

  for (int i = 0; i < candidates->length(); i++) {

    print_blobs(candidates->at(i));

  }

}

void PCRecorder::print_blobs(CodeBlob* cb) {

  if (cb != NULL) {

    cb->print();

    if (cb->is_nmethod()) {

      ((nmethod*)cb)->print_code();

    }

    tty->cr();

  } else {

    tty->print_cr("stub code");

  }

}

class tick_counter {            // holds tick info for one node

 public:

  int ticks_in_code;

  int ticks_in_native;

  tick_counter()                     {  ticks_in_code = ticks_in_native = 0; }

  tick_counter(int code, int native) {  ticks_in_code = code; ticks_in_native = native; }

  int total() const {

    return (ticks_in_code + ticks_in_native);

  }

  void add(tick_counter* a) {

    ticks_in_code += a->ticks_in_code;

    ticks_in_native += a->ticks_in_native;

  }

  void update(TickPosition where) {

    switch(where) {

      case tp_code:     ticks_in_code++;       break;

      case tp_native:   ticks_in_native++;      break;

    }

  }

  void print_code(outputStream* st, int total_ticks) {

    st->print("%5.1f%% %5d ", total() * 100.0 / total_ticks, ticks_in_code);

  }

  void print_native(outputStream* st) {

    st->print(" + %5d ", ticks_in_native);

  }

};

class ProfilerNode {

 private:

  ProfilerNode* _next;

 public:

  tick_counter ticks;

 public:

  void* operator new(size_t size, ThreadProfiler* tp);

  void  operator delete(void* p);

  ProfilerNode() {

    _next = NULL;

  }

  virtual ~ProfilerNode() {

    if (_next)

      delete _next;

  }

  void set_next(ProfilerNode* n) { _next = n; }

  ProfilerNode* next()           { return _next; }

  void update(TickPosition where) { ticks.update(where);}

  int total_ticks() { return ticks.total(); }

  virtual bool is_interpreted() const { return false; }

  virtual bool is_compiled()    const { return false; }

  virtual bool is_stub()        const { return false; }

  virtual bool is_runtime_stub() const{ return false; }

  virtual void oops_do(OopClosure* f) = 0;

  virtual bool interpreted_match(methodOop m) const { return false; }

  virtual bool compiled_match(methodOop m ) const { return false; }

  virtual bool stub_match(methodOop m, const char* name) const { return false; }

  virtual bool adapter_match() const { return false; }

  virtual bool runtimeStub_match(const CodeBlob* stub, const char* name) const { return false; }

  virtual bool unknown_compiled_match(const CodeBlob* cb) const { return false; }

  static void print_title(outputStream* st) {

    st->print(" + native");

    st->fill_to(col3);

    st->print("Method");

    st->fill_to(col4);

    st->cr();

  }

  static void print_total(outputStream* st, tick_counter* t, int total, const char* msg) {

    t->print_code(st, total);

    st->fill_to(col2);

    t->print_native(st);

    st->fill_to(col3);

    st->print(msg);

    st->cr();

  }

  virtual methodOop method()         = 0;

  virtual void print_method_on(outputStream* st) {

    int limit;

    int i;

    methodOop m = method();

    Symbol* k = m->klass_name();

    // Print the class name with dots instead of slashes

    limit = k->utf8_length();

    for (i = 0 ; i < limit ; i += 1) {

      char c = (char) k->byte_at(i);

      if (c == '/') {

        c = '.';

      }

      st->print("%c", c);

    }

    if (limit > 0) {

      st->print(".");

    }

    Symbol* n = m->name();

    limit = n->utf8_length();

    for (i = 0 ; i < limit ; i += 1) {

      char c = (char) n->byte_at(i);

      st->print("%c", c);

    }

    if( Verbose ) {

      // Disambiguate overloaded methods

      Symbol* sig = m->signature();

      sig->print_symbol_on(st);

    }

  }

  virtual void print(outputStream* st, int total_ticks) {

    ticks.print_code(st, total_ticks);

    st->fill_to(col2);

    ticks.print_native(st);

    st->fill_to(col3);

    print_method_on(st);

    st->cr();

  }

  // for hashing into the table

  static int hash(methodOop method) {

      // The point here is to try to make something fairly unique

      // out of the fields we can read without grabbing any locks

      // since the method may be locked when we need the hash.

      return (

          method->code_size() ^

          method->max_stack() ^

          method->max_locals() ^

          method->size_of_parameters());

  }

  // for sorting

  static int compare(ProfilerNode** a, ProfilerNode** b) {

    return (*b)->total_ticks() - (*a)->total_ticks();

  }

};

void* ProfilerNode::operator new(size_t size, ThreadProfiler* tp){

  void* result = (void*) tp->area_top;

  tp->area_top += size;

  if (tp->area_top > tp->area_limit) {

    fatal("flat profiler buffer overflow");

  }

  return result;

}

void ProfilerNode::operator delete(void* p){

}

class interpretedNode : public ProfilerNode {

 private:

   methodOop _method;

 public:

   interpretedNode(methodOop method, TickPosition where) : ProfilerNode() {

     _method = method;

     update(where);

   }

   bool is_interpreted() const { return true; }

   bool interpreted_match(methodOop m) const {

      return _method == m;

   }

   void oops_do(OopClosure* f) {

     f->do_oop((oop*)&_method);

   }

   methodOop method() { return _method; }

   static void print_title(outputStream* st) {

     st->fill_to(col1);

     st->print("%11s", "Interpreted");

     ProfilerNode::print_title(st);

   }

   void print(outputStream* st, int total_ticks) {

     ProfilerNode::print(st, total_ticks);

   }

   void print_method_on(outputStream* st) {

     ProfilerNode::print_method_on(st);

     if (Verbose) method()->invocation_counter()->print_short();

   }

};

class compiledNode : public ProfilerNode {

 private:

   methodOop _method;

 public:

   compiledNode(methodOop method, TickPosition where) : ProfilerNode() {

     _method = method;

     update(where);

  }

  bool is_compiled()    const { return true; }

  bool compiled_match(methodOop m) const {

    return _method == m;

  }

  methodOop method()         { return _method; }

  void oops_do(OopClosure* f) {

    f->do_oop((oop*)&_method);

  }

  static void print_title(outputStream* st) {

    st->fill_to(col1);

    st->print("%11s", "Compiled");

    ProfilerNode::print_title(st);

  }

  void print(outputStream* st, int total_ticks) {

    ProfilerNode::print(st, total_ticks);

  }

  void print_method_on(outputStream* st) {

    ProfilerNode::print_method_on(st);

  }

};

class stubNode : public ProfilerNode {

 private:

  methodOop _method;

  const char* _symbol;   // The name of the nearest VM symbol (for +ProfileVM). Points to a unique string

 public:

   stubNode(methodOop method, const char* name, TickPosition where) : ProfilerNode() {

     _method = method;

     _symbol = name;

     update(where);

   }

   bool is_stub() const { return true; }

   bool stub_match(methodOop m, const char* name) const {

     return (_method == m) && (_symbol == name);

   }

   void oops_do(OopClosure* f) {

     f->do_oop((oop*)&_method);

   }

   methodOop method() { return _method; }

   static void print_title(outputStream* st) {

     st->fill_to(col1);

     st->print("%11s", "Stub");

     ProfilerNode::print_title(st);

   }

   void print(outputStream* st, int total_ticks) {

     ProfilerNode::print(st, total_ticks);

   }

   void print_method_on(outputStream* st) {

     ProfilerNode::print_method_on(st);

     print_symbol_on(st);

   }

  void print_symbol_on(outputStream* st) {

    if(_symbol) {

      st->print("  (%s)", _symbol);

    }

  }

};

class adapterNode : public ProfilerNode {

 public:

   adapterNode(TickPosition where) : ProfilerNode() {

     update(where);

  }

  bool is_compiled()    const { return true; }

  bool adapter_match() const { return true; }

  methodOop method()         { return NULL; }

  void oops_do(OopClosure* f) {

    ;

  }

  void print(outputStream* st, int total_ticks) {

    ProfilerNode::print(st, total_ticks);

  }

  void print_method_on(outputStream* st) {

    st->print("%s", "adapters");

  }

};