178 lines
3.5 KiB
C
178 lines
3.5 KiB
C
/* Copyright (C) 2004 MySQL AB
|
|
Copyright (C) 2004-2017 Alexey Kopytov <akopytov@gmail.com>
|
|
|
|
This program 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 2 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program 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 program; if not, write to the Free Software
|
|
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
|
*/
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
# include "config.h"
|
|
#endif
|
|
|
|
#ifdef STDC_HEADERS
|
|
# include <stdlib.h>
|
|
#endif
|
|
|
|
#ifdef HAVE_STRING_H
|
|
# include <string.h>
|
|
#endif
|
|
|
|
#include "sb_logger.h"
|
|
#include "sb_timer.h"
|
|
#include "sb_util.h"
|
|
|
|
/* Some functions for simple time operations */
|
|
|
|
/* initialize timer */
|
|
|
|
void sb_timer_init(sb_timer_t *t)
|
|
{
|
|
SB_COMPILE_TIME_ASSERT(sizeof(sb_timer_t) % CK_MD_CACHELINE == 0);
|
|
|
|
memset(&t->time_start, 0, sizeof(struct timespec));
|
|
memset(&t->time_end, 0, sizeof(struct timespec));
|
|
|
|
ck_spinlock_init(&t->lock);
|
|
|
|
sb_timer_reset(t);
|
|
}
|
|
|
|
/* Reset timer counters, but leave the current state intact */
|
|
|
|
void sb_timer_reset(sb_timer_t *t)
|
|
{
|
|
t->min_time = UINT64_MAX;
|
|
t->max_time = 0;
|
|
t->sum_time = 0;
|
|
t->events = 0;
|
|
t->queue_time = 0;
|
|
}
|
|
|
|
/* Clone a timer */
|
|
|
|
void sb_timer_copy(sb_timer_t *to, sb_timer_t *from)
|
|
{
|
|
memcpy(to, from, sizeof(sb_timer_t));
|
|
|
|
ck_spinlock_init(&to->lock);
|
|
}
|
|
|
|
/* check whether the timer is running */
|
|
|
|
bool sb_timer_running(sb_timer_t *t)
|
|
{
|
|
return TIMESPEC_DIFF(t->time_start, t->time_end) > 0;
|
|
}
|
|
|
|
/*
|
|
get time elapsed since the previous call to sb_timer_current() for the
|
|
specified timer without stopping it. The first call returns time elapsed
|
|
since the timer was started.
|
|
*/
|
|
|
|
uint64_t sb_timer_current(sb_timer_t *t)
|
|
{
|
|
struct timespec tmp;
|
|
uint64_t res;
|
|
|
|
SB_GETTIME(&tmp);
|
|
res = TIMESPEC_DIFF(tmp, t->time_start);
|
|
t->time_start = tmp;
|
|
|
|
return res;
|
|
}
|
|
|
|
/*
|
|
Atomically reset a given timer after copying its state into the timer pointed
|
|
to by 'old'.
|
|
*/
|
|
|
|
void sb_timer_checkpoint(sb_timer_t *t, sb_timer_t *old)
|
|
{
|
|
ck_spinlock_lock(&t->lock);
|
|
|
|
memcpy(old, t, sizeof(*old));
|
|
ck_spinlock_init(&old->lock);
|
|
|
|
sb_timer_reset(t);
|
|
|
|
ck_spinlock_unlock(&t->lock);
|
|
}
|
|
|
|
/* get average time per event */
|
|
|
|
|
|
uint64_t sb_timer_avg(sb_timer_t *t)
|
|
{
|
|
if(t->events == 0)
|
|
return 0; /* return zero if there were no events */
|
|
return (t->sum_time / t->events);
|
|
}
|
|
|
|
|
|
/* get total time for all events */
|
|
|
|
|
|
uint64_t sb_timer_sum(sb_timer_t *t)
|
|
{
|
|
return t->sum_time;
|
|
}
|
|
|
|
|
|
/* get minimum time */
|
|
|
|
|
|
uint64_t sb_timer_min(sb_timer_t *t)
|
|
{
|
|
if (t->events == 0)
|
|
return 0;
|
|
return t->min_time;
|
|
}
|
|
|
|
|
|
/* get maximum time */
|
|
|
|
|
|
uint64_t sb_timer_max(sb_timer_t *t)
|
|
{
|
|
return t->max_time;
|
|
}
|
|
|
|
|
|
/* sum data from several timers. used in summing data from multiple threads */
|
|
|
|
|
|
sb_timer_t sb_timer_merge(sb_timer_t *t1, sb_timer_t *t2)
|
|
{
|
|
sb_timer_t t;
|
|
|
|
/* Initialize to avoid warnings */
|
|
memset(&t, 0, sizeof(sb_timer_t));
|
|
|
|
t.sum_time = t1->sum_time+t2->sum_time;
|
|
t.events = t1->events+t2->events;
|
|
|
|
if (t1->max_time > t2->max_time)
|
|
t.max_time = t1->max_time;
|
|
else
|
|
t.max_time = t2->max_time;
|
|
|
|
if (t1->min_time<t2->min_time)
|
|
t.min_time = t1->min_time;
|
|
else
|
|
t.min_time = t2->min_time;
|
|
|
|
return t;
|
|
}
|