long long performance

[Rob Willis]

Benjamin,

I've attached the source and assembly code.  You'll probably need to
adjust the LOOP_MAX constant for your system.

I compiled with the following:

c++ -o test testIntVsFloat.cpp

As i mentioned previously, i'm running on a P3/600 redhat 6.2 using
egcs-20000612.tgz.  The performance for the "long long" multiply and the
static_cast<long long> is terrible.

You'll need to manually subtract the baseline from each timing if you
want the most accurate result (its obvious where the problems are
without doing this though).  Also to improve accuracy, you may want to
subtract out the "equal" time from the mulitply and static_cast
operations.  Again, not really necessary to see the problem.

Let me know if you need anything else.

-Rob

Benjamin Kosnik wrote:
> 
> can you please post your testsuite, and generated assembly (use -S) to
> this list please?
> 
> I haven't really benchmarked this stuff.
> 
> thanks,
> benjamin

-- 
Rob Willis
rob@e-critical.com


#include <iostream>
#include <sys/time.h>

class TimeStamp
{
public:

  TimeStamp( unsigned long sec = 0, unsigned long usec = 0 ) 
    : _sec(sec), _usec(usec) {}

	static const TimeStamp  getCurrentTime();

	TimeStamp & operator-= (const TimeStamp & rts );
	friend TimeStamp operator-(const TimeStamp & ltv, const TimeStamp & rts);
  friend std::ostream & operator<< ( std::ostream & os, const TimeStamp & ts );

private:

	unsigned long _sec;
	unsigned long _usec;
};


const TimeStamp TimeStamp::getCurrentTime()
{
	struct timeval tv;
	gettimeofday( &tv, NULL );
	return TimeStamp( tv.tv_sec, tv.tv_usec ); 
}

TimeStamp & TimeStamp::operator-= (const TimeStamp & rts )
{
	_sec -= rts._sec;
	if ( _usec >= rts._usec )
	{
		_usec -= rts._usec;
	}
	else
	{
		_sec--;
		_usec = 1000000 - ( rts._usec - _usec );
	}
	return *this;
}

TimeStamp operator-(const TimeStamp & lts, const TimeStamp & rts)
{
	TimeStamp tmp( lts );
	tmp -= rts;
	return tmp;
}

std::ostream & operator<< ( std::ostream & os, const TimeStamp & ts )
{
  os << ts._sec;
  os << " / ";
  os << ts._usec;
  os << " ";
  return os;
}





#define LOOP_MAX  10000000



int main()
{
  std::cout << "=========== long long perf test ====" << std::endl; 


  {
    TimeStamp start = TimeStamp::getCurrentTime();
    for( int i = 0; i < LOOP_MAX; ++i )
    {
    }
    TimeStamp stop = TimeStamp::getCurrentTime();
    TimeStamp diff = stop-start;
    std::cout << "baseline:             " << diff << std::endl;
  }



  {
    TimeStamp start = TimeStamp::getCurrentTime();
    long long value = 0;
    long long test = 5236;
    for( int i = 0; i < LOOP_MAX; ++i )
    {
      value = test;
      value = test;
      value = test;
      value = test;
      value = test;
      value = test;
      value = test;
      value = test;
      value = test;
      value = test;
    }
    TimeStamp stop = TimeStamp::getCurrentTime();
    TimeStamp diff = stop-start;
    std::cout << "long long eq:         " << diff << std::endl;
  }


  {
    TimeStamp start = TimeStamp::getCurrentTime();
    double value = 0;
    double test = 5236;
    for( int i = 0; i < LOOP_MAX; ++i )
    {
      value = test;
      value = test;
      value = test;
      value = test;
      value = test;
      value = test;
      value = test;
      value = test;
      value = test;
      value = test;
    }
    TimeStamp stop = TimeStamp::getCurrentTime();
    TimeStamp diff = stop-start;
    std::cout << "double eq:            " << diff << std::endl;
  }

  
  {
    TimeStamp start = TimeStamp::getCurrentTime();
    long value = 0;
    long test = 5236;
    for( int i = 0; i < LOOP_MAX; ++i )
    {
      value = test;
      value = test;
      value = test;
      value = test;
      value = test;
      value = test;
      value = test;
      value = test;
      value = test;
      value = test;
    }
    TimeStamp stop = TimeStamp::getCurrentTime();
    TimeStamp diff = stop-start;
    std::cout << "long eq:              " << diff << std::endl;
  }


  {
    TimeStamp start = TimeStamp::getCurrentTime();
    long long value = 0;
    long long test = 5236;
    for( int i = 0; i < LOOP_MAX; ++i )
    {
      value = test*test;
      value = test*test;
      value = test*test;
      value = test*test;
      value = test*test;
      value = test*test;
      value = test*test;
      value = test*test;
      value = test*test;
      value = test*test;
    }
    TimeStamp stop = TimeStamp::getCurrentTime();
    TimeStamp diff = stop-start;
    std::cout << "long long mult:       " << diff << std::endl;
  }


  {
    TimeStamp start = TimeStamp::getCurrentTime();
    double value = 0;
    double test = 5236;
    for( int i = 0; i < LOOP_MAX; ++i )
    {
      value = test*test;
      value = test*test;
      value = test*test;
      value = test*test;
      value = test*test;
      value = test*test;
      value = test*test;
      value = test*test;
      value = test*test;
      value = test*test;
    }
    TimeStamp stop = TimeStamp::getCurrentTime();
    TimeStamp diff = stop-start;
    std::cout << "double mult:          " << diff << std::endl;
  }

  
  {
    TimeStamp start = TimeStamp::getCurrentTime();
    long value = 0;
    long test = 5236;
    for( int i = 0; i < LOOP_MAX; ++i )
    {
      value = test*test;
      value = test*test;
      value = test*test;
      value = test*test;
      value = test*test;
      value = test*test;
      value = test*test;
      value = test*test;
      value = test*test;
      value = test*test;
    }
    TimeStamp stop = TimeStamp::getCurrentTime();
    TimeStamp diff = stop-start;
    std::cout << "long mult:            " << diff << std::endl;
  }


  {
    TimeStamp start = TimeStamp::getCurrentTime();
    long long value = 0;
    double test = 5236.0;
    for( int i = 0; i < LOOP_MAX; ++i )
    {
      value = static_cast<long long>(test);
      value = static_cast<long long>(test);
      value = static_cast<long long>(test);
      value = static_cast<long long>(test);
      value = static_cast<long long>(test);
      value = static_cast<long long>(test);
      value = static_cast<long long>(test);
      value = static_cast<long long>(test);
      value = static_cast<long long>(test);
      value = static_cast<long long>(test);
    }
    TimeStamp stop = TimeStamp::getCurrentTime();
    TimeStamp diff = stop-start;
    std::cout << "long long cast:       " << diff << std::endl;
  }


  {
    TimeStamp start = TimeStamp::getCurrentTime();
    long value = 0;
    double test = 5236.0;
    for( int i = 0; i < LOOP_MAX; ++i )
    {
      value = static_cast<long >(test);
      value = static_cast<long >(test);
      value = static_cast<long >(test);
      value = static_cast<long >(test);
      value = static_cast<long >(test);
      value = static_cast<long >(test);
      value = static_cast<long >(test);
      value = static_cast<long >(test);
      value = static_cast<long >(test);
      value = static_cast<long >(test);
    }
    TimeStamp stop = TimeStamp::getCurrentTime();
    TimeStamp diff = stop-start;
    std::cout << "long cast:            " << diff << std::endl;
  }


  {
    TimeStamp start = TimeStamp::getCurrentTime();
    double value = 0;
    long long test = 5236;
    for( int i = 0; i < LOOP_MAX; ++i )
    {
      value = static_cast<double>(test);
      value = static_cast<double>(test);
      value = static_cast<double>(test);
      value = static_cast<double>(test);
      value = static_cast<double>(test);
      value = static_cast<double>(test);
      value = static_cast<double>(test);
      value = static_cast<double>(test);
      value = static_cast<double>(test);
      value = static_cast<double>(test);
    }
    TimeStamp stop = TimeStamp::getCurrentTime();
    TimeStamp diff = stop-start;
    std::cout << "double cast:          " << diff << std::endl;
  }


 
  std::cout << "=========== test done ====" << std::endl; 
}