Subversion Repositories openrisc_me

// -*- C++ -*-

//

// Copyright (C) 2009, 2010 Free Software Foundation, Inc.

//

// This file is part of the GNU ISO C++ Library.  This library is free

// software; you can redistribute it and/or modify it under the terms

// of the GNU General Public License as published by the Free Software

// Foundation; either version 2, or (at your option) any later

// version.

// This library 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 for more details.

// You should have received a copy of the GNU General Public License

// along with this library; see the file COPYING.  If not, write to

// the Free Software Foundation, 59 Temple Place - Suite 330, Boston,

// MA 02111-1307, USA.

// As a special exception, you may use this file as part of a free

// software library without restriction.  Specifically, if other files

// instantiate templates or use macros or inline functions from this

// file, or you compile this file and link it with other files to

// produce an executable, this file does not by itself cause the

// resulting executable to be covered by the GNU General Public

// License.  This exception does not however invalidate any other

// reasons why the executable file might be covered by the GNU General

// Public License.

/** @file profile/impl/profiler_trace.h

 *  @brief Data structures to represent profiling traces.

 */

// Written by Lixia Liu and Silvius Rus.

#ifndef _GLIBCXX_PROFILE_PROFILER_TRACE_H

#define _GLIBCXX_PROFILE_PROFILER_TRACE_H 1

#ifdef __GXX_EXPERIMENTAL_CXX0X__

#include <cerrno>

#include <cstdint>

#include <cstdio>

#include <cstdlib>

#define _GLIBCXX_IMPL_UNORDERED_MAP std::_GLIBCXX_STD_PR::unordered_map

#include <unordered_map>

#else

#include <errno.h>

#include <stdint.h>

#include <stdio.h>

#include <stdlib.h>

#include <tr1/unordered_map>

#define _GLIBCXX_IMPL_UNORDERED_MAP std::tr1::unordered_map

#endif

#include <ext/concurrence.h>

#include <fstream>

#include <string>

#include <utility>

#include <bits/stl_heap.h> // for std::make_heap, std::sort_heap

#include "profile/impl/profiler_state.h"

#include "profile/impl/profiler_node.h"

namespace __gnu_profile

{

/** @brief Internal environment.  Values can be set one of two ways:

    1. In config file "var = value".  The default config file path is

       libstdcxx-profile.conf.

    2. By setting process environment variables.  For instance, in a Bash

       shell you can set the unit cost of iterating through a map like this:

       export __map_iterate_cost_factor=5.0.

    If a value is set both in the input file and through an environment

    variable, the environment value takes precedence.  */

typedef _GLIBCXX_IMPL_UNORDERED_MAP<std::string, std::string> __env_t;

_GLIBCXX_PROFILE_DEFINE_UNINIT_DATA(__env_t, __env);

/** @brief Master lock.  */

_GLIBCXX_PROFILE_DEFINE_UNINIT_DATA(__gnu_cxx::__mutex, __global_lock);

/** @brief Representation of a warning.  */

struct __warning_data

{

  float __magnitude;

  __stack_t __context;

  const char* __warning_id;

  const char* __warning_message;

  __warning_data()

  : __magnitude(0.0), __context(NULL), __warning_id(NULL),

    __warning_message(NULL) { }

  __warning_data(float __m, __stack_t __c, const char* __id,

                 const char* __msg)

  : __magnitude(__m), __context(__c), __warning_id(__id),

    __warning_message(__msg) { }

  bool

  operator>(const struct __warning_data& __other) const

  { return __magnitude > __other.__magnitude; }

};

typedef std::_GLIBCXX_STD_PR::vector<__warning_data> __warning_vector_t;

// Defined in profiler_<diagnostic name>.h.

class __trace_hash_func;

class __trace_hashtable_size;

class __trace_map2umap;

class __trace_vector_size;

class __trace_vector_to_list;

class __trace_list_to_slist;

class __trace_list_to_vector;

void __trace_vector_size_init();

void __trace_hashtable_size_init();

void __trace_hash_func_init();

void __trace_vector_to_list_init();

void __trace_list_to_slist_init();

void __trace_list_to_vector_init();

void __trace_map_to_unordered_map_init();

void __trace_vector_size_report(FILE*, __warning_vector_t&);

void __trace_hashtable_size_report(FILE*, __warning_vector_t&);

void __trace_hash_func_report(FILE*, __warning_vector_t&);

void __trace_vector_to_list_report(FILE*, __warning_vector_t&);

void __trace_list_to_slist_report(FILE*, __warning_vector_t&);

void __trace_list_to_vector_report(FILE*, __warning_vector_t&);

void __trace_map_to_unordered_map_report(FILE*, __warning_vector_t&);

struct __cost_factor

{

  const char* __env_var;

  float __value;

};

typedef std::_GLIBCXX_STD_PR::vector<__cost_factor*> __cost_factor_vector;

_GLIBCXX_PROFILE_DEFINE_DATA(__trace_hash_func*, _S_hash_func, NULL);

_GLIBCXX_PROFILE_DEFINE_DATA(__trace_hashtable_size*, _S_hashtable_size, NULL);

_GLIBCXX_PROFILE_DEFINE_DATA(__trace_map2umap*, _S_map2umap, NULL);

_GLIBCXX_PROFILE_DEFINE_DATA(__trace_vector_size*, _S_vector_size, NULL);

_GLIBCXX_PROFILE_DEFINE_DATA(__trace_vector_to_list*, _S_vector_to_list, NULL);

_GLIBCXX_PROFILE_DEFINE_DATA(__trace_list_to_slist*, _S_list_to_slist, NULL);

_GLIBCXX_PROFILE_DEFINE_DATA(__trace_list_to_vector*, _S_list_to_vector, NULL);

_GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __vector_shift_cost_factor,

                             {"__vector_shift_cost_factor", 1.0});

_GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __vector_iterate_cost_factor,

                             {"__vector_iterate_cost_factor", 1.0});

_GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __vector_resize_cost_factor,

                             {"__vector_resize_cost_factor", 1.0});

_GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __list_shift_cost_factor,

                             {"__list_shift_cost_factor", 0.0});

_GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __list_iterate_cost_factor,

                             {"__list_iterate_cost_factor", 10.0});

_GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __list_resize_cost_factor,

                             {"__list_resize_cost_factor", 0.0});

_GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __map_insert_cost_factor,

                             {"__map_insert_cost_factor", 1.5});

_GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __map_erase_cost_factor,

                             {"__map_erase_cost_factor", 1.5});

_GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __map_find_cost_factor,

                             {"__map_find_cost_factor", 1});

_GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __map_iterate_cost_factor,

                             {"__map_iterate_cost_factor", 2.3});

_GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __umap_insert_cost_factor,

                             {"__umap_insert_cost_factor", 12.0});

_GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __umap_erase_cost_factor,

                             {"__umap_erase_cost_factor", 12.0});

_GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __umap_find_cost_factor,

                             {"__umap_find_cost_factor", 10.0});

_GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __umap_iterate_cost_factor,

                             {"__umap_iterate_cost_factor", 1.7});

_GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor_vector*, __cost_factors, NULL);

_GLIBCXX_PROFILE_DEFINE_DATA(const char*, _S_trace_file_name,

                             _GLIBCXX_PROFILE_TRACE_PATH_ROOT);

_GLIBCXX_PROFILE_DEFINE_DATA(size_t, _S_max_warn_count,

                             _GLIBCXX_PROFILE_MAX_WARN_COUNT);

_GLIBCXX_PROFILE_DEFINE_DATA(size_t, _S_max_stack_depth,

                             _GLIBCXX_PROFILE_MAX_STACK_DEPTH);

_GLIBCXX_PROFILE_DEFINE_DATA(size_t, _S_max_mem,

                             _GLIBCXX_PROFILE_MEM_PER_DIAGNOSTIC);

inline size_t __stack_max_depth()

{

  return _GLIBCXX_PROFILE_DATA(_S_max_stack_depth);

}

inline size_t __max_mem()

{

  return _GLIBCXX_PROFILE_DATA(_S_max_mem);

}

/** @brief Base class for all trace producers.  */

template <typename __object_info, typename __stack_info>

class __trace_base

{

 public:

  __trace_base();

  virtual ~__trace_base() {}

  void __add_object(__object_t object, __object_info __info);

  __object_info* __get_object_info(__object_t __object);

  void __retire_object(__object_t __object);

  void __write(FILE* f);

  void __collect_warnings(__warning_vector_t& __warnings);

 private:

  __gnu_cxx::__mutex __object_table_lock;

  __gnu_cxx::__mutex __stack_table_lock;

  typedef _GLIBCXX_IMPL_UNORDERED_MAP<__object_t,

                                      __object_info> __object_table_t;

  typedef _GLIBCXX_IMPL_UNORDERED_MAP<__stack_t, __stack_info, __stack_hash,

                                      __stack_hash> __stack_table_t;

  __object_table_t __object_table;

  __stack_table_t __stack_table;

  size_t __stack_table_byte_size;

 protected:

  const char* __id;

};

template <typename __object_info, typename __stack_info>

void __trace_base<__object_info, __stack_info>::__collect_warnings(

    __warning_vector_t& __warnings)

{

  typename __stack_table_t::iterator __i = __stack_table.begin();

  for ( ; __i != __stack_table.end(); ++__i )

  {

    __warnings.push_back(__warning_data((*__i).second.__magnitude(),

                                        (*__i).first,

                                        __id,

                                        (*__i).second.__advice()));

  }

}

template <typename __object_info, typename __stack_info>

__trace_base<__object_info, __stack_info>::__trace_base()

{

  // Do not pick the initial size too large, as we don't know which diagnostics

  // are more active.

  __object_table.rehash(10000);

  __stack_table.rehash(10000);

  __stack_table_byte_size = 0;

  __id = NULL;

}

template <typename __object_info, typename __stack_info>

void __trace_base<__object_info, __stack_info>::__add_object(

    __object_t __object, __object_info __info)

{

  if (__max_mem() == 0

      || __object_table.size() * sizeof(__object_info) <= __max_mem()) {

    this->__object_table_lock.lock();

    __object_table.insert(

        typename __object_table_t::value_type(__object, __info));

    this->__object_table_lock.unlock();

  }

}

template <typename __object_info, typename __stack_info>

__object_info* __trace_base<__object_info, __stack_info>::__get_object_info(

    __object_t __object)

{

  // XXX: Revisit this to see if we can decrease mutex spans.

  // Without this mutex, the object table could be rehashed during an

  // insertion on another thread, which could result in a segfault.

  this->__object_table_lock.lock();

  typename __object_table_t::iterator __object_it =

      __object_table.find(__object);

  if (__object_it == __object_table.end()){

    this->__object_table_lock.unlock();

    return NULL;

  } else {

    this->__object_table_lock.unlock();

    return &__object_it->second;

  }

}

template <typename __object_info, typename __stack_info>

void __trace_base<__object_info, __stack_info>::__retire_object(

    __object_t __object)

{

  this->__object_table_lock.lock();

  this->__stack_table_lock.lock();

  typename __object_table_t::iterator __object_it =

      __object_table.find(__object);

  if (__object_it != __object_table.end()){

    const __object_info& __info = __object_it->second;

    const __stack_t& __stack = __info.__stack();

    typename __stack_table_t::iterator __stack_it =

        __stack_table.find(__stack);

    if (__stack_it == __stack_table.end()) {

      // First occurence of this call context.

      if (__max_mem() == 0 || __stack_table_byte_size < __max_mem()) {

        __stack_table_byte_size +=

            (sizeof(__instruction_address_t) * __size(__stack)

             + sizeof(__stack) + sizeof(__stack_info));

        __stack_table.insert(make_pair(__stack, __stack_info(__info)));

      }

    } else {

      // Merge object info into info summary for this call context.

      __stack_it->second.__merge(__info);

      delete __stack;

    }

    __object_table.erase(__object);

  }

  this->__object_table_lock.unlock();

  this->__stack_table_lock.unlock();

}

template <typename __object_info, typename __stack_info>

void __trace_base<__object_info, __stack_info>::__write(FILE* __f)

{

  typename __stack_table_t::iterator __it;

  for (__it = __stack_table.begin(); __it != __stack_table.end(); __it++) {

    if (__it->second.__is_valid()) {

      fprintf(__f, __id);

      fprintf(__f, "|");

      __gnu_profile::__write(__f, __it->first);

      fprintf(__f, "|");

      __it->second.__write(__f);

    }

  }

}

inline size_t __env_to_size_t(const char* __env_var, size_t __default_value)

{

  char* __env_value = getenv(__env_var);

  if (__env_value) {

    long int __converted_value = strtol(__env_value, NULL, 10);

    if (errno || __converted_value < 0) {

      fprintf(stderr, "Bad value for environment variable '%s'.\n", __env_var);

      abort();

    } else {

      return static_cast<size_t>(__converted_value);

    }

  } else {

    return __default_value;

  }

}

inline void __set_max_stack_trace_depth()

{

  _GLIBCXX_PROFILE_DATA(_S_max_stack_depth) = __env_to_size_t(

      _GLIBCXX_PROFILE_MAX_STACK_DEPTH_ENV_VAR,

      _GLIBCXX_PROFILE_DATA(_S_max_stack_depth));

}

inline void __set_max_mem()

{

  _GLIBCXX_PROFILE_DATA(_S_max_mem) = __env_to_size_t(

      _GLIBCXX_PROFILE_MEM_PER_DIAGNOSTIC_ENV_VAR,

      _GLIBCXX_PROFILE_DATA(_S_max_mem));

}

inline int __log_magnitude(float __f)

{

  const float __log_base = 10.0;

  int __result = 0;

  int __sign = 1;

  if (__f < 0) {

    __f = -__f;

    __sign = -1;

  }

  while (__f > __log_base) {

    ++__result;

    __f /= 10.0;

  }

  return __sign * __result;

}

inline FILE* __open_output_file(const char* __extension)

{

  // The path is made of _S_trace_file_name + "." + extension.

  size_t __root_len = strlen(_GLIBCXX_PROFILE_DATA(_S_trace_file_name));

  size_t __ext_len = strlen(__extension);

  char* __file_name = new char[__root_len + 1 + __ext_len + 1];

  memcpy(__file_name, _GLIBCXX_PROFILE_DATA(_S_trace_file_name), __root_len);

  *(__file_name + __root_len) = '.';

  memcpy(__file_name + __root_len + 1, __extension, __ext_len + 1);

  FILE* __out_file = fopen(__file_name, "w");

  if (__out_file) {

    return __out_file;

  } else {

    fprintf(stderr, "Could not open trace file '%s'.\n", __file_name);

    abort();

  }

}

/** @brief Final report method, registered with @b atexit.

 *

 * This can also be called directly by user code, including signal handlers.

 * It is protected against deadlocks by the reentrance guard in profiler.h.

 * However, when called from a signal handler that triggers while within

 * __gnu_profile (under the guarded zone), no output will be produced.

 */

inline void __report(void)

{

  _GLIBCXX_PROFILE_DATA(__global_lock).lock();

  __warning_vector_t __warnings;

  FILE* __raw_file = __open_output_file("raw");

  __trace_vector_size_report(__raw_file, __warnings);

  __trace_hashtable_size_report(__raw_file, __warnings);

  __trace_hash_func_report(__raw_file, __warnings);

  __trace_vector_to_list_report(__raw_file, __warnings);

  __trace_list_to_slist_report(__raw_file, __warnings);

  __trace_list_to_vector_report(__raw_file, __warnings);

  __trace_map_to_unordered_map_report(__raw_file, __warnings);

  fclose(__raw_file);

  // Sort data by magnitude.

  // XXX: instead of sorting, should collect only top N for better performance.

  size_t __cutoff = std::min(_GLIBCXX_PROFILE_DATA(_S_max_warn_count),

                             __warnings.size());

  std::make_heap(__warnings.begin(), __warnings.end(),

                 std::greater<__warning_vector_t::value_type>());

  std::sort_heap(__warnings.begin(), __warnings.end(),

                 std::greater<__warning_vector_t::value_type>());

  __warnings.resize(__cutoff);

  FILE* __warn_file = __open_output_file("txt");

  for (__warning_vector_t::iterator __it = __warnings.begin();

       __it != __warnings.end(); ++__it)

    {

      fprintf(__warn_file,  __it->__warning_id);

      fprintf(__warn_file, ": improvement = %d",

              __log_magnitude(__it->__magnitude));

      fprintf(__warn_file, ": call stack = ");

      __gnu_profile::__write(__warn_file, __it->__context);

      fprintf(__warn_file, ": advice = %s\n", __it->__warning_message);

      free(const_cast<void*>(reinterpret_cast<const void*>

                             (__it->__warning_message)));

    }

  fclose(__warn_file);

  _GLIBCXX_PROFILE_DATA(__global_lock).unlock();

}

inline void __set_trace_path()

{

  char* __env_trace_file_name = getenv(_GLIBCXX_PROFILE_TRACE_ENV_VAR);

  if (__env_trace_file_name) {

    _GLIBCXX_PROFILE_DATA(_S_trace_file_name) = __env_trace_file_name;

  }

  // Make sure early that we can create the trace file.

  fclose(__open_output_file("txt"));

}

inline void __set_max_warn_count()

{

  char* __env_max_warn_count_str = getenv(

      _GLIBCXX_PROFILE_MAX_WARN_COUNT_ENV_VAR);

  if (__env_max_warn_count_str) {

    _GLIBCXX_PROFILE_DATA(_S_max_warn_count) = static_cast<size_t>(

        atoi(__env_max_warn_count_str));

  }

}

inline void __read_cost_factors()

{

  std::string __conf_file_name(_GLIBCXX_PROFILE_DATA(_S_trace_file_name));

  __conf_file_name += ".conf";

  std::ifstream __conf_file(__conf_file_name.c_str());

  if (__conf_file.is_open())

    {

      std::string __line;

      while (getline(__conf_file, __line))

        {

          std::string::size_type __i = __line.find_first_not_of(" \t\n\v");

          if (__line.length() <= 0 || __line[__i] == '#') {

            // Skip empty lines or comments.

            continue;

          }

          // Trim.

          if (__line.begin() != __line.end())

            {

              // A simple remove operation.

              std::string::iterator __first = __line.begin();

              std::string::iterator __result = __first;

              ++__first;

              for(; __first != __line.end(); ++__first)

                if(!(*__first == ' '))

                  {

                    *__result = *__first;

                    ++__result;

                  }

              __line.erase(__result, __line.end());

            }

          std::string::size_type __pos = __line.find("=");

          std::string __factor_name = __line.substr(0, __pos);

          std::string::size_type __end = __line.find_first_of(";\n");

          std::string __factor_value = __line.substr(__pos + 1, __end - __pos);

          _GLIBCXX_PROFILE_DATA(__env)[__factor_name] = __factor_value;

        }

    }

}

inline void __write_cost_factors()

{

  FILE* __file = __open_output_file("conf.out");

  for (__decltype(_GLIBCXX_PROFILE_DATA(__cost_factors)->begin()) __it

         = _GLIBCXX_PROFILE_DATA(__cost_factors)->begin();

       __it != _GLIBCXX_PROFILE_DATA(__cost_factors)->end(); ++__it)

    fprintf(__file, "%s = %f\n", (*__it)->__env_var, (*__it)->__value);

  fclose(__file);

}

inline void __set_cost_factors()

{

  _GLIBCXX_PROFILE_DATA(__cost_factors) = new __cost_factor_vector;

  _GLIBCXX_PROFILE_DATA(__cost_factors)->push_back(

      &_GLIBCXX_PROFILE_DATA(__vector_shift_cost_factor));

  _GLIBCXX_PROFILE_DATA(__cost_factors)->push_back(

      &_GLIBCXX_PROFILE_DATA(__vector_iterate_cost_factor));

  _GLIBCXX_PROFILE_DATA(__cost_factors)->push_back(

      &_GLIBCXX_PROFILE_DATA(__vector_resize_cost_factor));

  _GLIBCXX_PROFILE_DATA(__cost_factors)->push_back(

      &_GLIBCXX_PROFILE_DATA(__list_shift_cost_factor));

  _GLIBCXX_PROFILE_DATA(__cost_factors)->push_back(

      &_GLIBCXX_PROFILE_DATA(__list_iterate_cost_factor));

  _GLIBCXX_PROFILE_DATA(__cost_factors)->push_back(

      &_GLIBCXX_PROFILE_DATA(__list_resize_cost_factor));

  _GLIBCXX_PROFILE_DATA(__cost_factors)->push_back(

      &_GLIBCXX_PROFILE_DATA(__map_insert_cost_factor));

  _GLIBCXX_PROFILE_DATA(__cost_factors)->push_back(

      &_GLIBCXX_PROFILE_DATA(__map_erase_cost_factor));

  _GLIBCXX_PROFILE_DATA(__cost_factors)->push_back(

      &_GLIBCXX_PROFILE_DATA(__map_find_cost_factor));

  _GLIBCXX_PROFILE_DATA(__cost_factors)->push_back(

      &_GLIBCXX_PROFILE_DATA(__map_iterate_cost_factor));

  _GLIBCXX_PROFILE_DATA(__cost_factors)->push_back(

      &_GLIBCXX_PROFILE_DATA(__umap_insert_cost_factor));

  _GLIBCXX_PROFILE_DATA(__cost_factors)->push_back(

      &_GLIBCXX_PROFILE_DATA(__umap_erase_cost_factor));

  _GLIBCXX_PROFILE_DATA(__cost_factors)->push_back(

      &_GLIBCXX_PROFILE_DATA(__umap_find_cost_factor));

  _GLIBCXX_PROFILE_DATA(__cost_factors)->push_back(

      &_GLIBCXX_PROFILE_DATA(__umap_iterate_cost_factor));

  for (__decltype(_GLIBCXX_PROFILE_DATA(__cost_factors)->begin()) __it

         = _GLIBCXX_PROFILE_DATA(__cost_factors)->begin();

       __it != _GLIBCXX_PROFILE_DATA(__cost_factors)->end(); ++__it)

    {

      const char* __env_cost_factor = getenv((*__it)->__env_var);

      if (!__env_cost_factor)

        {

          __env_t::iterator __found = _GLIBCXX_PROFILE_DATA(__env).find(

              (*__it)->__env_var);

          if (__found != _GLIBCXX_PROFILE_DATA(__env).end())

            __env_cost_factor = (*__found).second.c_str();

        }

      if (__env_cost_factor)

        (*__it)->__value = atof(__env_cost_factor);

    }

}

inline void __profcxx_init_unconditional()

{

  _GLIBCXX_PROFILE_DATA(__global_lock).lock();

  if (__is_invalid()) {

    __set_max_warn_count();

    if (_GLIBCXX_PROFILE_DATA(_S_max_warn_count) == 0) {

      __turn_off();

    } else {

      __set_max_stack_trace_depth();

      __set_max_mem();

      __set_trace_path();

      __read_cost_factors();

      __set_cost_factors();

      __write_cost_factors();

      __trace_vector_size_init();

      __trace_hashtable_size_init();

      __trace_hash_func_init();

      __trace_vector_to_list_init();

      __trace_list_to_slist_init();

      __trace_list_to_vector_init();

      __trace_map_to_unordered_map_init();

      atexit(__report);

      __turn_on();

    }

  }

  _GLIBCXX_PROFILE_DATA(__global_lock).unlock();

}

/** @brief This function must be called by each instrumentation point.

 *

 * The common path is inlined fully.

 */

inline bool __profcxx_init(void)

{

  if (__is_invalid()) {

    __profcxx_init_unconditional();

  }

  return __is_on();

}

} // namespace __gnu_profile

#endif /* _GLIBCXX_PROFILE_PROFILER_TRACE_H */