- HP_TIMING_DIFF: compute difference between two times and store it
in a third. Source and destination might overlap.
- - HP_TIMING_ACCUM: add time difference to another variable. This might
- be a bit more complicated to implement for some platforms as the
- operation should be thread-safe and 64bit arithmetic on 32bit platforms
- is not.
-
- - HP_TIMING_ACCUM_NT: this is the variant for situations where we know
- there are no threads involved.
+ - HP_TIMING_ACCUM_NT: add time difference to another variable, without
+ being thread-safe.
- HP_TIMING_PRINT: write decimal representation of the timing value into
the given string. This operation need not be inline even though
/* It's simple arithmetic for us. */
#define HP_TIMING_DIFF(Diff, Start, End) (Diff) = ((End) - (Start))
-/* ??? Don't bother, since we're only used for ld.so. */
-#define HP_TIMING_ACCUM(Sum, Diff) not implemented
-
-/* No threads, no extra work. */
#define HP_TIMING_ACCUM_NT(Sum, Diff) (Sum) += (Diff)
/* Print the time value. */
- HP_TIMING_DIFF: compute difference between two times and store it
in a third. Source and destination might overlap.
- - HP_TIMING_ACCUM: add time difference to another variable. This might
- be a bit more complicated to implement for some platforms as the
- operation should be thread-safe and 64bit arithmetic on 32bit platforms
- is not.
-
- - HP_TIMING_ACCUM_NT: this is the variant for situations where we know
- there are no threads involved.
+ - HP_TIMING_ACCUM_NT: add time difference to another variable, without
+ being thread-safe.
- HP_TIMING_PRINT: write decimal representation of the timing value into
the given string. This operation need not be inline even though
#define HP_TIMING_NOW(var)
#define HP_TIMING_DIFF_INIT()
#define HP_TIMING_DIFF(Diff, Start, End)
-#define HP_TIMING_ACCUM(Sum, Diff)
#define HP_TIMING_ACCUM_NT(Sum, Diff)
#define HP_TIMING_PRINT(Buf, Len, Val)
- HP_TIMING_DIFF: compute difference between two times and store it
in a third. Source and destination might overlap.
- - HP_TIMING_ACCUM: add time difference to another variable. This might
- be a bit more complicated to implement for some platforms as the
- operation should be thread-safe and 64bit arithmetic on 32bit platforms
- is not.
-
- - HP_TIMING_ACCUM_NT: this is the variant for situations where we know
- there are no threads involved.
+ - HP_TIMING_ACCUM_NT: add time difference to another variable, without
+ being thread-safe.
- HP_TIMING_PRINT: write decimal representation of the timing value into
the given string. This operation need not be inline even though
/* It's simple arithmetic for us. */
#define HP_TIMING_DIFF(Diff, Start, End) (Diff) = ((End) - (Start))
-/* We have to jump through hoops to get this correctly implemented. */
-#define HP_TIMING_ACCUM(Sum, Diff) \
- do { \
- int __not_done; \
- hp_timing_t __oldval = (Sum); \
- hp_timing_t __diff = (Diff) - GLRO(dl_hp_timing_overhead); \
- do \
- { \
- hp_timing_t __newval = __oldval + __diff; \
- int __temp0, __temp1; \
- __asm__ __volatile__ ("xchgl %0, %%ebx\n\t" \
- "lock; cmpxchg8b %1\n\t" \
- "sete %%bl\n\t" \
- "xchgl %0, %%ebx" \
- : "=SD" (__not_done), "=m" (Sum), \
- "=A" (__oldval), "=c" (__temp0) \
- : "m" (Sum), "2" (__oldval), \
- "3" ((unsigned int) (__newval >> 32)), \
- "0" ((unsigned int) __newval)); \
- } \
- while ((unsigned char) __not_done); \
- } while (0)
-
-/* No threads, no extra work. */
#define HP_TIMING_ACCUM_NT(Sum, Diff) (Sum) += (Diff)
/* Print the time value. */
- HP_TIMING_DIFF: compute difference between two times and store it
in a third. Source and destination might overlap.
- - HP_TIMING_ACCUM: add time difference to another variable. This might
- be a bit more complicated to implement for some platforms as the
- operation should be thread-safe and 64bit arithmetic on 32bit platforms
- is not.
-
- - HP_TIMING_ACCUM_NT: this is the variant for situations where we know
- there are no threads involved.
+ - HP_TIMING_ACCUM_NT: add time difference to another variable, without
+ being thread-safe.
- HP_TIMING_PRINT: write decimal representation of the timing value into
the given string. This operation need not be inline even though
/* It's simple arithmetic for us. */
#define HP_TIMING_DIFF(Diff, Start, End) (Diff) = ((End) - (Start))
-/* We have to jump through hoops to get this correctly implemented. */
-#define HP_TIMING_ACCUM(Sum, Diff) \
- do { \
- hp_timing_t __oldval; \
- hp_timing_t __diff = (Diff) - GLRO(dl_hp_timing_overhead); \
- hp_timing_t __newval; \
- do \
- { \
- __oldval = (Sum); \
- __newval = __oldval + __diff; \
- } \
- while (! __sync_bool_compare_and_swap (&Sum, __oldvar, __newval)); \
- } while (0)
-
-/* No threads, no extra work. */
#define HP_TIMING_ACCUM_NT(Sum, Diff) (Sum) += (Diff)
/* Print the time value. */
- HP_TIMING_DIFF: compute difference between two times and store it
in a third. Source and destination might overlap.
- - HP_TIMING_ACCUM: add time difference to another variable. This might
- be a bit more complicated to implement for some platforms as the
- operation should be thread-safe and 64bit arithmetic on 32bit platforms
- is not.
-
- - HP_TIMING_ACCUM_NT: this is the variant for situations where we know
- there are no threads involved.
+ - HP_TIMING_ACCUM_NT: add time difference to another variable, without
+ being thread-safe.
- HP_TIMING_PRINT: write decimal representation of the timing value into
the given string. This operation need not be inline even though
/* It's simple arithmetic in 64-bit. */
#define HP_TIMING_DIFF(Diff, Start, End) (Diff) = ((End) - (Start))
-/* We need to insure that this add is atomic in threaded environments. We use
- __arch_atomic_exchange_and_add_64 from atomic.h to get thread safety. */
-#define HP_TIMING_ACCUM(Sum, Diff) \
- do { \
- hp_timing_t __diff = (Diff) - GLRO(dl_hp_timing_overhead); \
- __arch_atomic_exchange_and_add_64 (&(Sum), __diff); \
- } while (0)
-
-/* No threads, no extra work. */
#define HP_TIMING_ACCUM_NT(Sum, Diff) (Sum) += (Diff)
/* Print the time value. */
- HP_TIMING_DIFF: compute difference between two times and store it
in a third. Source and destination might overlap.
- - HP_TIMING_ACCUM: add time difference to another variable. This might
- be a bit more complicated to implement for some platforms as the
- operation should be thread-safe and 64bit arithmetic on 32bit platforms
- is not.
-
- - HP_TIMING_ACCUM_NT: this is the variant for situations where we know
- there are no threads involved.
+ - HP_TIMING_ACCUM_NT: add time difference to another variable, without
+ being thread-safe.
- HP_TIMING_PRINT: write decimal representation of the timing value into
the given string. This operation need not be inline even though
/* It's simple arithmetic in 64-bit. */
#define HP_TIMING_DIFF(Diff, Start, End) (Diff) = ((End) - (Start))
-/* We need to insure that this add is atomic in threaded environments. We use
- __arch_atomic_exchange_and_add_64 from atomic.h to get thread safety. */
-#define HP_TIMING_ACCUM(Sum, Diff) \
- do { \
- hp_timing_t __diff = (Diff) - GLRO(dl_hp_timing_overhead); \
- __arch_atomic_exchange_and_add_64 (&(Sum), __diff); \
- } while (0)
-
-/* No threads, no extra work. */
#define HP_TIMING_ACCUM_NT(Sum, Diff) (Sum) += (Diff)
/* Print the time value. */
#define HP_TIMING_DIFF(Diff, Start, End) (Diff) = ((End) - (Start))
-#define HP_TIMING_ACCUM(Sum, Diff) \
-do { \
- hp_timing_t __diff = (Diff) - GLRO(dl_hp_timing_overhead); \
- __asm__ __volatile__("srl %L0, 0, %%g1\n\t" \
- "sllx %H0, 32, %%g6\n\t" \
- "or %%g1, %%g6, %%g1\n\t" \
- "1: ldx [%1], %%g5\n\t" \
- "add %%g5, %%g1, %%g6\n\t" \
- "casx [%1], %%g5, %%g6\n\t" \
- "cmp %%g5, %%g6\n\t" \
- "bne,pn %%xcc, 1b\n\t" \
- " nop" \
- : /* no outputs */ \
- : "r" (__diff), "r" (&(Sum)) \
- : "memory", "g1", "g5", "g6"); \
-} while(0)
-
#define HP_TIMING_ACCUM_NT(Sum, Diff) (Sum) += (Diff)
#define HP_TIMING_PRINT(Buf, Len, Val) \
#define HP_TIMING_DIFF(Diff, Start, End) (Diff) = ((End) - (Start))
-#define HP_TIMING_ACCUM(Sum, Diff) \
-do { \
- hp_timing_t __diff = (Diff) - GLRO(dl_hp_timing_overhead); \
- hp_timing_t tmp1, tmp2; \
- __asm__ __volatile__("1: ldx [%3], %0\n\t" \
- "add %0, %2, %1\n\t" \
- "casx [%3], %0, %1\n\t" \
- "cmp %0, %1\n\t" \
- "bne,pn %%xcc, 1b\n\t" \
- " nop" \
- : "=&r" (tmp1), "=&r" (tmp2) \
- : "r" (__diff), "r" (&(Sum)) \
- : "memory", "g1", "g5", "g6"); \
-} while(0)
-
#define HP_TIMING_ACCUM_NT(Sum, Diff) (Sum) += (Diff)
#define HP_TIMING_PRINT(Buf, Len, Val) \
asm volatile ("rdtsc" : "=a" (_lo), "=d" (_hi)); \
(Var) = ((unsigned long long int) _hi << 32) | _lo; })
-/* The funny business for 32-bit mode is not required here. */
-# undef HP_TIMING_ACCUM
-# define HP_TIMING_ACCUM(Sum, Diff) \
- do { \
- hp_timing_t __diff = (Diff) - GLRO(dl_hp_timing_overhead); \
- __asm__ __volatile__ ("lock; addq %1, %0" \
- : "=m" (Sum) : "r" (__diff), "m" (Sum)); \
- } while (0)
-
#endif /* hp-timing.h */
projects / platform / upstream / glibc.git / commitdiff