Subversion Repositories openrisc

// -*- C++ -*-

// Testing performance utilities for the C++ library testsuite.

//

// Copyright (C) 2003, 2004, 2005, 2007, 2008, 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 3, 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 COPYING3.  If not see

// <http://www.gnu.org/licenses/>.

//

#ifndef _GLIBCXX_PERFORMANCE_H

#define _GLIBCXX_PERFORMANCE_H

#include <sys/times.h>

#include <sys/resource.h>

#include <cstdlib>

#include <cstring>

#include <string>

#include <fstream>

#include <iomanip>

#include <typeinfo>

#include <stdexcept>

#include <sstream>

#include <cxxabi.h>

#include <testsuite_common_types.h>

#ifdef __linux__

#include <malloc.h>

#elif defined (__FreeBSD__)

extern "C"

{

  struct mallinfo

  {

    int uordblks;

    int hblkhd;

  };

  struct mallinfo

  mallinfo(void)

  {

    struct mallinfo m = { (((std::size_t) sbrk (0) + 1023) / 1024), 0 };

    return m;

  }

}

#elif !defined (__hpux__)

extern "C"

{

  struct mallinfo

  {

    int uordblks;

    int hblkhd;

  };

  struct mallinfo empty = { 0, 0 };

  struct mallinfo

  mallinfo(void)

  { return empty; }

}

#endif

namespace __gnu_test

{

  class time_counter

  {

  private:

    clock_t     elapsed_begin;

    clock_t     elapsed_end;

    tms         tms_begin;

    tms         tms_end;

  public:

    explicit

    time_counter() : elapsed_begin(), elapsed_end(), tms_begin(), tms_end()

    { }

    void

    clear() throw()

    {

      elapsed_begin = clock_t();

      elapsed_end = clock_t();

      tms_begin = tms();

      tms_end = tms();

    }

    void

    start()

    {

      this->clear();

      elapsed_begin = times(&tms_begin);

      const clock_t err = clock_t(-1);

      if (elapsed_begin == err)

        std::__throw_runtime_error("time_counter::start");

    }

    void

    stop()

    {

      elapsed_end = times(&tms_end);

      const clock_t err = clock_t(-1);

      if (elapsed_end == err)

        std::__throw_runtime_error("time_counter::stop");

    }

    std::size_t

    real_time() const

    { return elapsed_end - elapsed_begin; }

    std::size_t

    user_time() const

    { return tms_end.tms_utime - tms_begin.tms_utime; }

    std::size_t

    system_time() const

    { return tms_end.tms_stime - tms_begin.tms_stime; }

  };

  class resource_counter

  {

    int                 who;

    rusage              rusage_begin;

    rusage              rusage_end;

    struct mallinfo     allocation_begin;

    struct mallinfo     allocation_end;

  public:

    resource_counter(int i = RUSAGE_SELF) : who(i)

    { this->clear(); }

    void

    clear() throw()

    {

      memset(&rusage_begin, 0, sizeof(rusage_begin));

      memset(&rusage_end, 0, sizeof(rusage_end));

      memset(&allocation_begin, 0, sizeof(allocation_begin));

      memset(&allocation_end, 0, sizeof(allocation_end));

    }

    void

    start()

    {

      if (getrusage(who, &rusage_begin) != 0 )

        memset(&rusage_begin, 0, sizeof(rusage_begin));

      malloc(0); // Needed for some implementations.

      allocation_begin = mallinfo();

    }

    void

    stop()

    {

      if (getrusage(who, &rusage_end) != 0 )

        memset(&rusage_end, 0, sizeof(rusage_end));

      allocation_end = mallinfo();

    }

    int

    allocated_memory() const

    { return ((allocation_end.uordblks - allocation_begin.uordblks)

              + (allocation_end.hblkhd - allocation_begin.hblkhd)); }

    long

    hard_page_fault() const

    { return rusage_end.ru_majflt - rusage_begin.ru_majflt; }

    long

    swapped() const

    { return rusage_end.ru_nswap - rusage_begin.ru_nswap; }

  };

  inline void

  start_counters(time_counter& t, resource_counter& r)

  {

    t.start();

    r.start();

  }

  inline void

  stop_counters(time_counter& t, resource_counter& r)

  {

    t.stop();

    r.stop();

  }

  inline void

  clear_counters(time_counter& t, resource_counter& r)

  {

    t.clear();

    r.clear();

  }

  void

  report_performance(const std::string file, const std::string comment,

                     const time_counter& t, const resource_counter& r)

  {

    const char space = ' ';

    const char tab = '\t';

    const char* name = "libstdc++-performance.sum";

    std::string::const_iterator i = file.begin() + file.find_last_of('/') + 1;

    std::string testname(i, file.end());

    std::ofstream out(name, std::ios_base::app);

#ifdef __GTHREADS

    if (__gthread_active_p())

      testname.append("-thread");

#endif

    out.setf(std::ios_base::left);

    out << std::setw(25) << testname << tab;

    out << std::setw(25) << comment << tab;

    out.setf(std::ios_base::right);

    out << std::setw(4) << t.real_time() << "r" << space;

    out << std::setw(4) << t.user_time() << "u" << space;

    out << std::setw(4) << t.system_time() << "s" << space;

    out << std::setw(8) << r.allocated_memory() << "mem" << space;

    out << std::setw(4) << r.hard_page_fault() << "pf" << space;

    out << std::endl;

    out.close();

  }

  void

  report_header(const std::string file, const std::string header)

  {

    const char space = ' ';

    const char tab = '\t';

    const char* name = "libstdc++-performance.sum";

    std::string::const_iterator i = file.begin() + file.find_last_of('/') + 1;

    std::string testname(i, file.end());

    std::ofstream out(name, std::ios_base::app);

#ifdef __GTHREADS

    if (__gthread_active_p ())

      testname.append("-thread");

#endif

    out.setf(std::ios_base::left);

    out << std::setw(25) << testname << tab;

    out << std::setw(40) << header << tab;

    out << std::endl;

    out.close();

  }

} // namespace __gnu_test

// Ah, we wish it wasn't so...

bool first_container = false;

extern const char* filename;

typedef std::string::size_type (*callback_type) (std::string&);

template<typename Container, int Iter, bool Thread>

  void

  write_viz_container(callback_type find_container, const char* filename)

  {

    typedef std::string string;

    // Create title.

    {

      const char ws(' ');

      std::ostringstream title;

      std::string titlename(filename);

      std::string::size_type n = titlename.find('.');

      if (n != string::npos)

        titlename = std::string(titlename.begin(), titlename.begin() + n);

      title << titlename;

      title << ws;

      title << Iter;

      title << ws;

#if 0

      title << "thread<";

      std::boolalpha(title);

      title << Thread;

      title << '>';

#endif

      titlename += ".title";

      std::ofstream titlefile(titlename.c_str());

      if (!titlefile.good())

        throw std::runtime_error("write_viz_data cannot open titlename");

      titlefile << title.str() << std::endl;

    }

    // Create compressed type name.

    Container obj;

    int status;

    std::string type(abi::__cxa_demangle(typeid(obj).name(), 0, 0, &status));

    // Extract fully-qualified typename.

    // Assumes "set" or "map" are uniquely determinate.

    string::iterator beg = type.begin();

    string::iterator end;

    string::size_type n = (*find_container)(type);

    // Find start of fully-qualified name.

    // Assume map, find end.

    string::size_type nend = type.find('<', n);

    if (nend != string::npos)

      end = type.begin() + nend;

    string compressed_type;

    compressed_type += '"';

    compressed_type += string(beg, end);

    compressed_type += '<';

#if 0

    typename Container::key_type v;

    compressed_type += typeid(v).name();

#else

    compressed_type += "int";

#endif

    compressed_type += ", A>";

    // XXX

    if (Thread == true)

      compressed_type += " thread";

    compressed_type += '"';

    std::ofstream file(filename, std::ios_base::app);

    if (!file.good())

      throw std::runtime_error("write_viz_data cannot open filename");

    file << compressed_type;

    first_container = false;

  }

void

write_viz_data(__gnu_test::time_counter& time, const char* filename)

{

  std::ofstream file(filename, std::ios_base::app);

  if (!file.good())

    throw std::runtime_error("write_viz_data cannot open filename");

  // Print out score in appropriate column.

  const char tab('\t');

  int score = time.real_time();

  file << tab << score;

}

void

write_viz_endl(const char* filename)

{

  std::ofstream file(filename, std::ios_base::app);

  if (!file.good())

    throw std::runtime_error("write_viz_endl cannot open filename");

  file << std::endl;

}

// Function template, function objects for the tests.

template<typename TestType>

  struct value_type : public std::pair<const TestType, TestType>

  {

    inline value_type& operator++()

    {

      ++this->second;

      return *this;

    }

    inline operator TestType() const { return this->second; }

  };

template<typename Container, int Iter>

  void

  do_loop();

template<typename Container, int Iter>

  void*

  do_thread(void* p = 0)

  {

    do_loop<Container, Iter>();

    return p;

  }

template<typename Container, int Iter, bool Thread>

  void

  test_container(const char* filename)

  {

    using namespace __gnu_test;

    time_counter time;

    resource_counter resource;

    {

      start_counters(time, resource);

      if (!Thread)

        {

          // No threads, so run 4x.

          do_loop<Container, Iter * 4>();

        }

      else

        {

#if defined (_GLIBCXX_GCC_GTHR_POSIX_H) && !defined (NOTHREAD)

          pthread_t  t1, t2, t3, t4;

          pthread_create(&t1, 0, &do_thread<Container, Iter>, 0);

          pthread_create(&t2, 0, &do_thread<Container, Iter>, 0);

          pthread_create(&t3, 0, &do_thread<Container, Iter>, 0);

          pthread_create(&t4, 0, &do_thread<Container, Iter>, 0);

          pthread_join(t1, 0);

          pthread_join(t2, 0);

          pthread_join(t3, 0);

          pthread_join(t4, 0);

#endif

        }

      stop_counters(time, resource);

      // Detailed text data.

      Container obj;

      int status;

      std::ostringstream comment;

      comment << "type: " << abi::__cxa_demangle(typeid(obj).name(),

                                                 0, 0, &status);

      report_header(filename, comment.str());

      report_performance("", "", time, resource);

      // Detailed data for visualization.

      std::string vizfilename(filename);

      vizfilename += ".dat";

      write_viz_data(time, vizfilename.c_str());

    }

  }

template<bool Thread>

  struct test_sequence

  {

    test_sequence(const char* filename) : _M_filename(filename) { }

    template<class Container>

      void

      operator()(Container)

      {

        const int i = 20000;

        test_container<Container, i, Thread>(_M_filename);

      }

  private:

    const char* _M_filename;

  };

inline std::string::size_type

sequence_find_container(std::string& type)

{

  const std::string::size_type npos = std::string::npos;

  std::string::size_type n1 = type.find("vector");

  std::string::size_type n2 = type.find("list");

  std::string::size_type n3 = type.find("deque");

  std::string::size_type n4 = type.find("string");

  if (n1 != npos || n2 != npos || n3 != npos || n4 != npos)

    return std::min(std::min(n1, n2), std::min(n3, n4));

  else

    throw std::runtime_error("sequence_find_container not found");

}

inline std::string::size_type

associative_find_container(std::string& type)

{

  using std::string;

  string::size_type n1 = type.find("map");

  string::size_type n2 = type.find("set");

  if (n1 != string::npos || n2 != string::npos)

    return std::min(n1, n2);

  else

    throw std::runtime_error("associative_find_container not found");

}

#endif // _GLIBCXX_PERFORMANCE_H