500 lines
15 KiB
C++
500 lines
15 KiB
C++
|
|
#include <cstdlib>
|
|
#include <cassert>
|
|
|
|
#include "epicsInterrupt.h"
|
|
#include "epicsAtomic.h"
|
|
#include "epicsTime.h"
|
|
#include "epicsUnitTest.h"
|
|
#include "testMain.h"
|
|
|
|
using std :: size_t;
|
|
|
|
class RefCtr {
|
|
public:
|
|
RefCtr ();
|
|
~RefCtr ();
|
|
void reference ();
|
|
void unreference ();
|
|
private:
|
|
size_t m_cnt;
|
|
};
|
|
|
|
class Ownership {
|
|
public:
|
|
Ownership ();
|
|
Ownership ( RefCtr & refCtr );
|
|
Ownership ( const Ownership & );
|
|
~Ownership ();
|
|
Ownership & operator = ( const Ownership & );
|
|
private:
|
|
RefCtr * _pRefCtr;
|
|
static RefCtr m_noOwnership;
|
|
};
|
|
|
|
inline RefCtr :: RefCtr ()
|
|
{
|
|
epicsAtomicSetSizeT ( & m_cnt, 0 );
|
|
}
|
|
|
|
inline RefCtr :: ~RefCtr ()
|
|
{
|
|
unsigned cnt = epicsAtomicGetSizeT ( & m_cnt );
|
|
assert ( cnt == 0u );
|
|
}
|
|
|
|
inline void RefCtr :: reference ()
|
|
{
|
|
epicsAtomicIncrSizeT ( & m_cnt );
|
|
}
|
|
|
|
inline void RefCtr :: unreference ()
|
|
{
|
|
epicsAtomicDecrSizeT ( & m_cnt );
|
|
}
|
|
|
|
RefCtr Ownership :: m_noOwnership;
|
|
|
|
inline Ownership :: Ownership () :
|
|
_pRefCtr ( & m_noOwnership )
|
|
{
|
|
m_noOwnership.reference ();
|
|
}
|
|
|
|
inline Ownership :: Ownership ( RefCtr & refCtr ) :
|
|
_pRefCtr ( & refCtr )
|
|
{
|
|
refCtr.reference ();
|
|
}
|
|
|
|
inline Ownership :: Ownership ( const Ownership & ownership ) :
|
|
_pRefCtr ( ownership._pRefCtr )
|
|
{
|
|
_pRefCtr->reference ();
|
|
}
|
|
|
|
inline Ownership :: ~Ownership ()
|
|
{
|
|
_pRefCtr->unreference ();
|
|
}
|
|
|
|
inline Ownership & Ownership ::
|
|
operator = ( const Ownership & ownership )
|
|
{
|
|
RefCtr * const pOldRefCtr = _pRefCtr;
|
|
_pRefCtr = ownership._pRefCtr;
|
|
_pRefCtr->reference ();
|
|
pOldRefCtr->unreference ();
|
|
return *this;
|
|
}
|
|
|
|
inline Ownership retOwnership ( const Ownership & ownership )
|
|
{
|
|
return Ownership ( ownership );
|
|
}
|
|
|
|
inline Ownership recurRetOwner10 ( const Ownership & ownershipIn )
|
|
{
|
|
Ownership ownership =
|
|
retOwnership (
|
|
retOwnership (
|
|
retOwnership (
|
|
retOwnership (
|
|
retOwnership ( ownershipIn ) ) ) ) );
|
|
return retOwnership (
|
|
retOwnership (
|
|
retOwnership (
|
|
retOwnership (
|
|
retOwnership ( ownership ) ) ) ) );
|
|
}
|
|
|
|
inline Ownership recurRetOwner100 ( const Ownership & ownershipIn )
|
|
{
|
|
Ownership ownership =
|
|
recurRetOwner10 (
|
|
recurRetOwner10 (
|
|
recurRetOwner10 (
|
|
recurRetOwner10 (
|
|
recurRetOwner10 ( ownershipIn ) ) ) ) );
|
|
return recurRetOwner10 (
|
|
recurRetOwner10 (
|
|
recurRetOwner10 (
|
|
recurRetOwner10 (
|
|
recurRetOwner10 ( ownership ) ) ) ) );
|
|
}
|
|
|
|
inline Ownership recurRetOwner1000 ( const Ownership & ownershipIn )
|
|
{
|
|
Ownership ownership =
|
|
recurRetOwner100 (
|
|
recurRetOwner100 (
|
|
recurRetOwner100 (
|
|
recurRetOwner100 (
|
|
recurRetOwner100 ( ownershipIn ) ) ) ) );
|
|
return recurRetOwner100 (
|
|
recurRetOwner100 (
|
|
recurRetOwner100 (
|
|
recurRetOwner100 (
|
|
recurRetOwner100 ( ownership ) ) ) ) );
|
|
}
|
|
|
|
inline void passRefOwnership ( const Ownership & ownershipIn, Ownership & ownershipOut )
|
|
{
|
|
ownershipOut = ownershipIn;
|
|
}
|
|
|
|
inline void passRefOwnership10 ( const Ownership & ownershipIn, Ownership & ownershipOut )
|
|
{
|
|
Ownership ownershipTmp0;
|
|
passRefOwnership ( ownershipIn, ownershipTmp0 );
|
|
Ownership ownershipTmp1;
|
|
passRefOwnership ( ownershipTmp0, ownershipTmp1 );
|
|
Ownership ownershipTmp2;
|
|
passRefOwnership ( ownershipTmp1, ownershipTmp2 );
|
|
Ownership ownershipTmp3;
|
|
passRefOwnership ( ownershipTmp2, ownershipTmp3 );
|
|
Ownership ownershipTmp4;
|
|
passRefOwnership ( ownershipTmp3, ownershipTmp4 );
|
|
Ownership ownershipTmp5;
|
|
passRefOwnership ( ownershipTmp4, ownershipTmp5 );
|
|
Ownership ownershipTmp6;
|
|
passRefOwnership ( ownershipTmp5, ownershipTmp6 );
|
|
Ownership ownershipTmp7;
|
|
passRefOwnership ( ownershipTmp6, ownershipTmp7 );
|
|
Ownership ownershipTmp8;
|
|
passRefOwnership ( ownershipTmp7, ownershipTmp8 );
|
|
passRefOwnership ( ownershipTmp8, ownershipOut );
|
|
}
|
|
|
|
inline void passRefOwnership100 ( const Ownership & ownershipIn, Ownership & ownershipOut )
|
|
{
|
|
Ownership ownershipTmp0;
|
|
passRefOwnership10 ( ownershipIn, ownershipTmp0 );
|
|
Ownership ownershipTmp1;
|
|
passRefOwnership10 ( ownershipTmp0, ownershipTmp1 );
|
|
Ownership ownershipTmp2;
|
|
passRefOwnership10 ( ownershipTmp1, ownershipTmp2 );
|
|
Ownership ownershipTmp3;
|
|
passRefOwnership10 ( ownershipTmp2, ownershipTmp3 );
|
|
Ownership ownershipTmp4;
|
|
passRefOwnership10 ( ownershipTmp3, ownershipTmp4 );
|
|
Ownership ownershipTmp5;
|
|
passRefOwnership10 ( ownershipTmp4, ownershipTmp5 );
|
|
Ownership ownershipTmp6;
|
|
passRefOwnership10 ( ownershipTmp5, ownershipTmp6 );
|
|
Ownership ownershipTmp7;
|
|
passRefOwnership10 ( ownershipTmp6, ownershipTmp7 );
|
|
Ownership ownershipTmp8;
|
|
passRefOwnership10 ( ownershipTmp7, ownershipTmp8 );
|
|
passRefOwnership10 ( ownershipTmp8, ownershipOut );
|
|
}
|
|
|
|
inline void passRefOwnership1000 ( const Ownership & ownershipIn, Ownership & ownershipOut )
|
|
{
|
|
Ownership ownershipTmp0;
|
|
passRefOwnership100 ( ownershipIn, ownershipTmp0 );
|
|
Ownership ownershipTmp1;
|
|
passRefOwnership100 ( ownershipTmp0, ownershipTmp1 );
|
|
Ownership ownershipTmp2;
|
|
passRefOwnership100 ( ownershipTmp1, ownershipTmp2 );
|
|
Ownership ownershipTmp3;
|
|
passRefOwnership100 ( ownershipTmp2, ownershipTmp3 );
|
|
Ownership ownershipTmp4;
|
|
passRefOwnership100 ( ownershipTmp3, ownershipTmp4 );
|
|
Ownership ownershipTmp5;
|
|
passRefOwnership100 ( ownershipTmp4, ownershipTmp5 );
|
|
Ownership ownershipTmp6;
|
|
passRefOwnership100 ( ownershipTmp5, ownershipTmp6 );
|
|
Ownership ownershipTmp7;
|
|
passRefOwnership100 ( ownershipTmp6, ownershipTmp7 );
|
|
Ownership ownershipTmp8;
|
|
passRefOwnership100 ( ownershipTmp7, ownershipTmp8 );
|
|
passRefOwnership100 ( ownershipTmp8, ownershipOut );
|
|
}
|
|
|
|
time_t extTime = 0;
|
|
|
|
// tests the time it takes to perform a call to an external
|
|
// function and also increment an integer word. The
|
|
// epicsInterruptIsInterruptContext function is an
|
|
// out-of-line function implemented in a sharable library
|
|
// so hopefully it wont be optimized away.
|
|
inline void tenOrdinaryIncr ( size_t & target )
|
|
{
|
|
int result = 0;
|
|
result += epicsInterruptIsInterruptContext ();
|
|
result += epicsInterruptIsInterruptContext ();
|
|
result += epicsInterruptIsInterruptContext ();
|
|
result += epicsInterruptIsInterruptContext ();
|
|
result += epicsInterruptIsInterruptContext ();
|
|
result += epicsInterruptIsInterruptContext ();
|
|
result += epicsInterruptIsInterruptContext ();
|
|
result += epicsInterruptIsInterruptContext ();
|
|
result += epicsInterruptIsInterruptContext ();
|
|
result += epicsInterruptIsInterruptContext ();
|
|
target = static_cast < unsigned > ( result );
|
|
}
|
|
|
|
inline void oneHundredOrdinaryIncr ( size_t & target )
|
|
{
|
|
tenOrdinaryIncr ( target );
|
|
tenOrdinaryIncr ( target );
|
|
tenOrdinaryIncr ( target );
|
|
tenOrdinaryIncr ( target );
|
|
tenOrdinaryIncr ( target );
|
|
tenOrdinaryIncr ( target );
|
|
tenOrdinaryIncr ( target );
|
|
tenOrdinaryIncr ( target );
|
|
tenOrdinaryIncr ( target );
|
|
tenOrdinaryIncr ( target );
|
|
}
|
|
|
|
inline void oneThousandOrdinaryIncr ( size_t & target )
|
|
{
|
|
oneHundredOrdinaryIncr ( target );
|
|
oneHundredOrdinaryIncr ( target );
|
|
oneHundredOrdinaryIncr ( target );
|
|
oneHundredOrdinaryIncr ( target );
|
|
oneHundredOrdinaryIncr ( target );
|
|
oneHundredOrdinaryIncr ( target );
|
|
oneHundredOrdinaryIncr ( target );
|
|
oneHundredOrdinaryIncr ( target );
|
|
oneHundredOrdinaryIncr ( target );
|
|
oneHundredOrdinaryIncr ( target );
|
|
}
|
|
|
|
inline void tenAtomicIncr ( size_t & target )
|
|
{
|
|
epicsAtomicIncrSizeT ( & target );
|
|
epicsAtomicIncrSizeT ( & target );
|
|
epicsAtomicIncrSizeT ( & target );
|
|
epicsAtomicIncrSizeT ( & target );
|
|
epicsAtomicIncrSizeT ( & target );
|
|
epicsAtomicIncrSizeT ( & target );
|
|
epicsAtomicIncrSizeT ( & target );
|
|
epicsAtomicIncrSizeT ( & target );
|
|
epicsAtomicIncrSizeT ( & target );
|
|
epicsAtomicIncrSizeT ( & target );
|
|
}
|
|
|
|
inline void oneHundredAtomicIncr ( size_t & target )
|
|
{
|
|
tenAtomicIncr ( target );
|
|
tenAtomicIncr ( target );
|
|
tenAtomicIncr ( target );
|
|
tenAtomicIncr ( target );
|
|
tenAtomicIncr ( target );
|
|
tenAtomicIncr ( target );
|
|
tenAtomicIncr ( target );
|
|
tenAtomicIncr ( target );
|
|
tenAtomicIncr ( target );
|
|
tenAtomicIncr ( target );
|
|
}
|
|
|
|
inline void oneThousandAtomicIncr ( size_t & target )
|
|
{
|
|
oneHundredAtomicIncr ( target );
|
|
oneHundredAtomicIncr ( target );
|
|
oneHundredAtomicIncr ( target );
|
|
oneHundredAtomicIncr ( target );
|
|
oneHundredAtomicIncr ( target );
|
|
oneHundredAtomicIncr ( target );
|
|
oneHundredAtomicIncr ( target );
|
|
oneHundredAtomicIncr ( target );
|
|
oneHundredAtomicIncr ( target );
|
|
oneHundredAtomicIncr ( target );
|
|
}
|
|
|
|
inline void tenAtomicTestAndSet ( unsigned & target )
|
|
{
|
|
epicsAtomicTestAndSetUIntT ( & target );
|
|
epicsAtomicTestAndSetUIntT ( & target );
|
|
epicsAtomicTestAndSetUIntT ( & target );
|
|
epicsAtomicTestAndSetUIntT ( & target );
|
|
epicsAtomicTestAndSetUIntT ( & target );
|
|
epicsAtomicTestAndSetUIntT ( & target );
|
|
epicsAtomicTestAndSetUIntT ( & target );
|
|
epicsAtomicTestAndSetUIntT ( & target );
|
|
epicsAtomicTestAndSetUIntT ( & target );
|
|
epicsAtomicTestAndSetUIntT ( & target );
|
|
}
|
|
|
|
inline void oneHundredAtomicTestAndSet ( unsigned & target )
|
|
{
|
|
tenAtomicTestAndSet ( target );
|
|
tenAtomicTestAndSet ( target );
|
|
tenAtomicTestAndSet ( target );
|
|
tenAtomicTestAndSet ( target );
|
|
tenAtomicTestAndSet ( target );
|
|
tenAtomicTestAndSet ( target );
|
|
tenAtomicTestAndSet ( target );
|
|
tenAtomicTestAndSet ( target );
|
|
tenAtomicTestAndSet ( target );
|
|
tenAtomicTestAndSet ( target );
|
|
}
|
|
|
|
inline void oneThousandAtomicTestAndSet ( unsigned & target )
|
|
{
|
|
oneHundredAtomicTestAndSet ( target );
|
|
oneHundredAtomicTestAndSet ( target );
|
|
oneHundredAtomicTestAndSet ( target );
|
|
oneHundredAtomicTestAndSet ( target );
|
|
oneHundredAtomicTestAndSet ( target );
|
|
oneHundredAtomicTestAndSet ( target );
|
|
oneHundredAtomicTestAndSet ( target );
|
|
oneHundredAtomicTestAndSet ( target );
|
|
oneHundredAtomicTestAndSet ( target );
|
|
oneHundredAtomicTestAndSet ( target );
|
|
}
|
|
|
|
inline void tenAtomicSet ( size_t & target )
|
|
{
|
|
epicsAtomicSetSizeT ( & target, 0 );
|
|
epicsAtomicSetSizeT ( & target, 0 );
|
|
epicsAtomicSetSizeT ( & target, 0 );
|
|
epicsAtomicSetSizeT ( & target, 0 );
|
|
epicsAtomicSetSizeT ( & target, 0 );
|
|
epicsAtomicSetSizeT ( & target, 0 );
|
|
epicsAtomicSetSizeT ( & target, 0 );
|
|
epicsAtomicSetSizeT ( & target, 0 );
|
|
epicsAtomicSetSizeT ( & target, 0 );
|
|
epicsAtomicSetSizeT ( & target, 0 );
|
|
}
|
|
|
|
inline void oneHundredAtomicSet ( size_t & target )
|
|
{
|
|
tenAtomicSet ( target );
|
|
tenAtomicSet ( target );
|
|
tenAtomicSet ( target );
|
|
tenAtomicSet ( target );
|
|
tenAtomicSet ( target );
|
|
tenAtomicSet ( target );
|
|
tenAtomicSet ( target );
|
|
tenAtomicSet ( target );
|
|
tenAtomicSet ( target );
|
|
tenAtomicSet ( target );
|
|
}
|
|
|
|
inline void oneThousandAtomicSet ( size_t & target )
|
|
{
|
|
oneHundredAtomicSet ( target );
|
|
oneHundredAtomicSet ( target );
|
|
oneHundredAtomicSet ( target );
|
|
oneHundredAtomicSet ( target );
|
|
oneHundredAtomicSet ( target );
|
|
oneHundredAtomicSet ( target );
|
|
oneHundredAtomicSet ( target );
|
|
oneHundredAtomicSet ( target );
|
|
oneHundredAtomicSet ( target );
|
|
oneHundredAtomicSet ( target );
|
|
}
|
|
|
|
static const unsigned N = 10000;
|
|
|
|
void ordinaryIncrPerformance ()
|
|
{
|
|
epicsTime begin = epicsTime::getCurrent ();
|
|
size_t target;
|
|
epicsAtomicSetSizeT ( & target, 0 );
|
|
for ( unsigned i = 0; i < N; i++ ) {
|
|
oneThousandOrdinaryIncr ( target );
|
|
}
|
|
double delay = epicsTime::getCurrent () - begin;
|
|
testOk1 ( target == 0u );
|
|
delay /= N * 1000u; // convert to delay per call
|
|
delay *= 1e6; // convert to micro seconds
|
|
testDiag ( "raw incr and a NOOP function call takes %f microseconds", delay );
|
|
}
|
|
|
|
void epicsAtomicIncrPerformance ()
|
|
{
|
|
epicsTime begin = epicsTime::getCurrent ();
|
|
size_t target;
|
|
epicsAtomicSetSizeT ( & target, 0 );
|
|
for ( unsigned i = 0; i < N; i++ ) {
|
|
oneThousandAtomicIncr ( target );
|
|
}
|
|
double delay = epicsTime::getCurrent () - begin;
|
|
testOk1 ( target == N * 1000u );
|
|
delay /= N * 1000u; // convert to delay per call
|
|
delay *= 1e6; // convert to micro seconds
|
|
testDiag ( "epicsAtomicIncr() takes %f microseconds", delay );
|
|
}
|
|
|
|
void atomicCompareAndSetPerformance ()
|
|
{
|
|
epicsTime begin = epicsTime::getCurrent ();
|
|
unsigned target;
|
|
epicsAtomicSetUIntT ( & target, 0 );
|
|
testOk1 ( ! target );
|
|
for ( unsigned i = 0; i < N; i++ ) {
|
|
oneThousandAtomicTestAndSet ( target );
|
|
}
|
|
double delay = epicsTime::getCurrent () - begin;
|
|
testOk1 ( target );
|
|
delay /= N * 1000u; // convert to delay per call
|
|
delay *= 1e6; // convert to micro seconds
|
|
testDiag ( "epicsAtomicCompareAndSet() takes %f microseconds", delay );
|
|
}
|
|
|
|
void recursiveOwnershipRetPerformance ()
|
|
{
|
|
RefCtr refCtr;
|
|
epicsTime begin = epicsTime::getCurrent ();
|
|
for ( unsigned i = 0; i < N; i++ ) {
|
|
Ownership ownership ( refCtr );
|
|
recurRetOwner1000 ( ownership );
|
|
}
|
|
double delay = epicsTime::getCurrent () - begin;
|
|
delay /= N * 1000u; // convert to delay per call
|
|
delay *= 1e6; // convert to micro seconds
|
|
testDiag ( "retOwnership() takes %f microseconds", delay );
|
|
}
|
|
|
|
void ownershipPassRefPerformance ()
|
|
{
|
|
RefCtr refCtr;
|
|
epicsTime begin = epicsTime::getCurrent ();
|
|
for ( unsigned i = 0; i < N; i++ ) {
|
|
Ownership ownershipSrc ( refCtr );
|
|
Ownership ownershipDest;
|
|
passRefOwnership1000 ( ownershipSrc, ownershipDest );
|
|
}
|
|
double delay = epicsTime::getCurrent () - begin;
|
|
delay /= N * 1000u; // convert to delay per call
|
|
delay *= 1e6; // convert to micro seconds
|
|
testDiag ( "passRefOwnership() takes %f microseconds", delay );
|
|
}
|
|
|
|
void epicsAtomicSetPerformance ()
|
|
{
|
|
epicsTime begin = epicsTime::getCurrent ();
|
|
size_t target;
|
|
for ( unsigned i = 0; i < N; i++ ) {
|
|
oneThousandAtomicSet ( target );
|
|
}
|
|
double delay = epicsTime::getCurrent () - begin;
|
|
testOk1 ( target == 0u );
|
|
delay /= N * 1000u; // convert to delay per call
|
|
delay *= 1e6; // convert to micro seconds
|
|
testDiag ( "epicsAtomicSet() takes %f microseconds", delay );
|
|
}
|
|
|
|
MAIN(epicsAtomicPerform)
|
|
{
|
|
testPlan(5);
|
|
//
|
|
// The tests running here are measuring fast
|
|
// functions so they tend to be impacted
|
|
// by where the cache lines are wrt to the
|
|
// virtual pages perhaps
|
|
//
|
|
epicsAtomicSetPerformance ();
|
|
ordinaryIncrPerformance ();
|
|
epicsAtomicIncrPerformance ();
|
|
recursiveOwnershipRetPerformance ();
|
|
ownershipPassRefPerformance ();
|
|
atomicCompareAndSetPerformance ();
|
|
return testDone();
|
|
}
|