blob: 95c3f40414b3b1c8e6716a650fc96bf49354050e [file] [log] [blame]
/*******************************************************************************
* Copyright (c) 2016 CEA LIST.
*
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Arnault Lapitre (CEA LIST) arnault.lapitre@cea.fr
* - Initial API and implementation
******************************************************************************/
#define BODY_avm_tool_ExecutionTime 1
/***********************************************************
BODY OF THE ExecutionTime CLASS
***********************************************************/
#include "ExecutionTime.h"
#include <sstream>
#include <util/avm_string.h>
namespace sep
{
/**
* ExecutionTime::start_time
*
*/
void ExecutionTime::start_time()
{
#ifdef __AVM_UNIX__
gettimeofday(&start_t, NULL);
getrusage(0, &start_r);
clock();
#endif /* __AVM_UNIX__ */
t_depart = getClock();
t_start = std::time(NULL);
//!!! BOOST TODO
// time_start = boost::posix_time::microsec_clock::local_time();
}
/**
* ExecutionTime::finish_time
*
*/
void ExecutionTime::finish_time()
{
#ifdef __AVM_UNIX__
gettimeofday(&finish_t, NULL);
getrusage(0, &finish_r);
finish_clock = clock();
#endif /* __AVM_UNIX__ */
t_end = std::time(NULL);
t_fin = getClock();
//!!! BOOST TODO
// time_end =boost::posix_time::microsec_clock::local_time();
}
/**
* ExecutionTime::get_time_usage
*
*/
void ExecutionTime::get_time_usage(int * rtp, int * utp, int * stp)
{
#ifdef __AVM_UNIX__
#define TDIFF(f, s) \
(((f).tv_sec - (s).tv_sec) * 1000 + \
((f).tv_usec - (s).tv_usec + 500) / 1000)
*rtp = TDIFF(finish_t, start_t);
*utp = TDIFF(finish_r.ru_utime, start_r.ru_utime);
*stp = TDIFF(finish_r.ru_stime, start_r.ru_stime);
#endif /* __AVM_UNIX__ */
}
/**
* ExecutionTime::format_time_milli
*
*/
std::string ExecutionTime::format_time_milli(avm_uitime_t milliSecondes)
{
std::ostringstream osTime;
avm_uitime_t s = milliSecondes / 1000;
avm_uitime_t mn = s / 60;
avm_uitime_t h = mn / 60;
avm_uitime_t ms = milliSecondes % 1000;
s = s % 60;
mn = mn % 60;
if (h != 0)
{
osTime << h << "h";
}
if (mn != 0)
{
osTime << mn << "m";
}
if (s != 0)
{
osTime << s << "s";
}
if( (ms != 0) || (milliSecondes == 0) )
{
osTime << ms << "ms";
}
return( osTime.str() );
}
/**
* ExecutionTime::format_time_micro
*
*/
std::string ExecutionTime::format_time_micro(avm_uitime_t microSecondes)
{
std::ostringstream osTime;
avm_uitime_t ms = microSecondes / 1000;
avm_uitime_t s = ms / 1000;
avm_uitime_t mn = s / 60;
avm_uitime_t h = mn / 60;
avm_uitime_t us = microSecondes % 1000;
ms = ms % 1000;
s = s % 60;
mn = mn % 60;
if (h != 0)
{
osTime << h << "h";
}
if (mn != 0)
{
osTime << mn << "m";
}
if (s != 0)
{
osTime << s << "s";
}
if( ms != 0 )
{
osTime << ms << "ms";
}
if( (us) || (microSecondes == 0) )
{
osTime << us << "µs";
}
return( osTime.str() );
}
/**
* ExecutionTime::format_time_nano
*
*/
std::string ExecutionTime::format_time_nano(avm_uitime_t nanoSecondes)
{
std::ostringstream osTime;
avm_uitime_t us = nanoSecondes / 1000;
avm_uitime_t ms = us / 1000;
avm_uitime_t s = ms / 1000;
avm_uitime_t mn = s / 60;
avm_uitime_t h = mn / 60;
avm_uitime_t ns = nanoSecondes % 1000;
us = us % 1000;
ms = ms % 1000;
s = s % 60;
mn = mn % 60;
if (h != 0)
{
osTime << h << "h";
}
if (mn != 0)
{
osTime << mn << "m";
}
if (s != 0)
{
osTime << s << "s";
}
if( ms != 0 )
{
osTime << ms << "ms";
}
if( us != 0 )
{
osTime << us << "us";
}
if( (ns != 0) || (nanoSecondes == 0) )
{
osTime << ns << "ns";
}
return( osTime.str() );
}
/**
* ExecutionTime::print_time_stat
*
*/
std::string ExecutionTime::time_stat()
{
std::ostringstream osTime;
#ifdef __AVM_UNIX__
int rtime, utime, stime;
get_time_usage(&rtime, &utime, &stime);
// a cause de: typedef signed long clock_t
if ((utime + stime) > 2000000/*2147000*/)
{
finish_clock = utime + stime;
}
else
{
finish_clock = finish_clock / 1000;
}
osTime << "(realTime " << format_time_milli(rtime);
osTime << " cpuTime " << format_time_milli(finish_clock);
osTime << " userTime " << format_time_milli(utime);
osTime << " systemTime " << format_time_milli(stime) << ")";
// osTime << "(realTime " << rtime << " cpuTime " << (finish_clock / 1000)
// << " userTime " << utime << " systemTime " << stime << "")";
#endif /* __AVM_UNIX__ */
avm_ftime_t t_duree = (avm_ftime_t)(t_fin - t_depart);
// osTime << " => " << OS_FLOAT_PRECISION << t_duree;
// osTime << " --> " << format_time_micro( (avm_uitime_t)( t_duree * 1000000 ) );
osTime << " --> " << format_time_nano( (avm_uitime_t)( t_duree * 1000000000 ) );
//?? osTime << " ==> " << std::difftime(t_end, t_start) << "s";
//!!! BOOST TODO
// boost::posix_time::time_duration duration(time_end - time_start);
// osTime << " => " << duration;
// osTime << " --> " << format_time_micro( duration.total_microseconds() );
//!!! BOOST TODO
// osTime << " --> " << format_time_nano( duration.total_nanoseconds() );
// Date & Heure Courante
std::time_t t;
std::time(&t);
osTime << " @ " << ( std::ctime(&t) );
return( osTime.str() );
}
std::string ExecutionTime::current_time()
{
// Date & Heure Courante
time_t t;
time(&t);
return( sep::to_string(ctime(&t)) );
}
/*
* Recuperateur de temps :
*/
avm_ftime_t ExecutionTime::getClock ( void )
{
avm_ftime_t d = 0 ;
#ifndef __linux
#ifdef _WIN32
struct timeval tval ;
struct timezone * tz=(struct timezone *)NULL ;
timerclear(&tval);
if ( gettimeofday(&tval, tz) )
{
#ifdef VERBOSE
fprintf (stderr, "\nCLOCK ERROR !!!\n");
#endif
}
else
{
d = ((avm_ftime_t)(tval.tv_usec)/1000000.0) ;
d = (avm_ftime_t) tval.tv_sec + d ;
}
#else
struct timespec cur_time;
if (clock_gettime(CLOCK_REALTIME, &cur_time))
{
#ifdef VERBOSE
fprintf (stderr, "\nCLOCK ERROR !!!\n");
#endif
}
else
{
d = ((avm_ftime_t)(cur_time.tv_nsec) / (avm_ftime_t)(CLOCKS_PER_SEC)) / 1000000.0 ;
d = (avm_ftime_t) cur_time.tv_sec + d ;
}
#endif
#else
struct timeval tval ;
struct timezone * tz=(struct timezone *)NULL ;
timerclear(&tval);
if ( gettimeofday(&tval, tz) )
{
#ifdef VERBOSE
fprintf (stderr, "\nCLOCK ERROR !!!\n");
#endif
}
else
{
d = ((avm_ftime_t)(tval.tv_usec)/1000000.0) ;
d = (avm_ftime_t) tval.tv_sec + d ;
}
#endif
return d ;
}
/*
* Programme de test:
*/
//int main( void )
//{
// int i ;
// double t_depart, t_fin, t ;
// double duree_en_millisecondes ; /* 1000 pour une seconde, 3600000 pour une heure */
//
//
// /* Calcul temps de depart */
// t_depart = GetClock() ;
//
// t = 0.0 ;
//
// for ( i = 0 ; i < 500000000 ; ++i )
// t = t + 1.0 ;
//
// t_fin = GetClock() ;
//
// if ( (t_depart*t_fin) < 0.0 )
// fprintf ( stderr, "\n ATTENTION !!! Une erreur s'est produite\n");
// else
// fprintf ( stderr, "\n Temps écoulé %g secondes pour une boucle 500000000 : \n",(t_fin - t_depart));
//
// t_depart = t_fin ;
//
// t = 0.0 ;
//
// for ( i = 0 ; i < 5000000 ; ++i )
// t = t + 1.0 ;
//
// t_fin= GetClock() ;
//
// if ( (t_depart*t_fin) < 0.0 )
// fprintf ( stderr, "\n ATTENTION !!! Une erreur s'est produite\n");
// else
// fprintf ( stderr, "\n Temps écoulé %g secondes pour une boucle 500000 : \n",(t_fin - t_depart));
//
//
// return EXIT_SUCCESS ;
//}
}
/***END OF THE ExecutionTime CLASS BODY***/