yetangitu/recoll
1
0
Fork 0
Code Issues Pull requests Releases Wiki Activity

housekeeping: separated out the chrono utility

Browse source
This commit is contained in:
Jean-Francois Dockes 2015-10-14 09:18:26 +02:00
parent 28aeb4fd64
commit cc73d47cb0
18 changed files with 376 additions and 201 deletions
Download patch file Download diff file Expand all files Collapse all files

2
.hgignore
View file

@ -117,3 +117,5 @@ tests/xattr/mimeview
website/usermanual/*
website/idxthreads/forkingRecoll.html
website/idxthreads/xapDocCopyCrash.html
website/pages/recoll-mingw.html
website/pages/recoll-windows.html

2
src/Makefile.am
View file

@ -182,6 +182,8 @@ utils/appformime.h \
utils/base64.cpp \
utils/base64.h \
utils/cancelcheck.h \
utils/chrono.h \
utils/chrono.cpp \
utils/circache.cpp \
utils/circache.h \
utils/closefrom.cpp \

3
src/index/fsindexer.cpp
View file

@ -39,6 +39,7 @@
#include "debuglog.h"
#include "internfile.h"
#include "smallut.h"
#include "chrono.h"
#include "wipedir.h"
#include "fileudi.h"
#include "cancelcheck.h"
@ -239,7 +240,7 @@ bool FsIndexer::index(int flags)
}
m_config->storeMissingHelperDesc(missing);
}
LOGINFO(("fsindexer index time: %d mS\n", chron.ms()));
LOGINFO(("fsindexer index time: %d mS\n", chron.millis()));
return true;
}

1
src/index/recollindex.cpp
View file

@ -40,6 +40,7 @@ using namespace std;
#include "rclinit.h"
#include "indexer.h"
#include "smallut.h"
#include "chrono.h"
#include "pathut.h"
#include "rclmon.h"
#include "x11mon.h"

1
src/qtgui/preview_w.cpp
View file

@ -51,6 +51,7 @@
#include "recoll.h"
#include "plaintorich.h"
#include "smallut.h"
#include "chrono.h"
#include "wipedir.h"
#include "cancelcheck.h"
#include "preview_w.h"

1
src/query/plaintorich.cpp
View file

@ -35,6 +35,7 @@ using std::set;
#include "textsplit.h"
#include "utf8iter.h"
#include "smallut.h"
#include "chrono.h"
#include "plaintorich.h"
#include "cancelcheck.h"
#include "unacpp.h"

1
src/query/recollq.cpp
View file

@ -38,6 +38,7 @@
#include "transcode.h"
#include "textsplit.h"
#include "smallut.h"
#include "chrono.h"
#include "base64.h"
using namespace std;

4
src/rcldb/expansiondbs.cpp
View file

@ -18,10 +18,12 @@
#include "autoconfig.h"
#include MEMORY_INCLUDE
#include "debuglog.h"
#include "utf8iter.h"
#include "smallut.h"
#include MEMORY_INCLUDE
#include "chrono.h"
#include "textsplit.h"
#include "xmacros.h"
#include "rcldb.h"

1
src/rcldb/rclabstract.cpp
View file

@ -29,6 +29,7 @@
#include "searchdata.h"
#include "utf8iter.h"
#include "hldata.h"
#include "chrono.h"
using namespace std;

1
src/rcldb/rcldb.cpp
View file

@ -43,6 +43,7 @@ using namespace std;
#include "conftree.h"
#include "pathut.h"
#include "smallut.h"
#include "chrono.h"
#include "utf8iter.h"
#include "searchdata.h"
#include "rclquery.h"

1
src/rcldb/rclquery.cpp
View file

@ -34,6 +34,7 @@
#include "rclquery_p.h"
#include "conftree.h"
#include "smallut.h"
#include "chrono.h"
#include "searchdata.h"
#include "unacpp.h"

6
src/utils/Makefile
View file

@ -14,6 +14,12 @@ pxattr: $(PXATTROBJS)
trpxattr.o : pxattr.cpp
$(CXX) -c $(CXXFLAGS) -DTEST_PXATTR -o $@ pxattr.cpp
CHRONOOBJS = trchrono.o chrono.o
trchrono: $(CHRONOOBJS)
$(CXX) -o chrono $(CHRONOOBJS)
trchrono.o : chrono.cpp
$(CXX) -c $(CXXFLAGS) -DTEST_CHRONO -o $@ chrono.cpp
PTMUTEXOBJS = ptmutex.o
ptmutex: $(PTMUTEXOBJS)
$(CXX) -o ptmutex $(PTMUTEXOBJS) $(LIBRECOLL)

289
src/utils/chrono.cpp Normal file
View file

@ -0,0 +1,289 @@
/* Copyright (C) 2014 J.F.Dockes
* 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.,
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef TEST_CHRONO
#include "autoconfig.h"
#include <time.h>
#include <iostream>
#include "chrono.h"
using namespace std;
#ifndef CLOCK_REALTIME
typedef int clockid_t;
#define CLOCK_REALTIME 1
#endif
#define SECONDS(TS1, TS2) \
(float((TS2).tv_sec - (TS1).tv_sec) + \
float((TS2).tv_nsec - (TS1).tv_nsec) * 1e-9)
#define MILLIS(TS1, TS2) \
((long long)((TS2).tv_sec - (TS1).tv_sec) * 1000LL + \
((TS2).tv_nsec - (TS1).tv_nsec) / 1000000)
#define MICROS(TS1, TS2) \
((long long)((TS2).tv_sec - (TS1).tv_sec) * 1000000LL + \
((TS2).tv_nsec - (TS1).tv_nsec) / 1000)
#define NANOS(TS1, TS2) \
((long long)((TS2).tv_sec - (TS1).tv_sec) * 1000000000LL + \
((TS2).tv_nsec - (TS1).tv_nsec))
// Using clock_gettime() is nice because it gives us ns res and it helps with
// computing threads work times, but it's also a pita because it forces linking
// with -lrt. So keep it non-default, special development only.
// #define USE_CLOCK_GETTIME
// And wont' bother with gettime() on these.
#if defined(__APPLE__) || defined(_WIN32)
#undef USE_CLOCK_GETTIME
#endif
#ifdef _WIN32
#define WIN32_LEAN_AND_MEAN
#include <Windows.h>
#include <stdint.h> // portable: uint64_t MSVC: __int64
// MSVC defines this in winsock2.h!?
typedef struct timeval {
long tv_sec;
long tv_usec;
} timeval;
int gettimeofday(struct timeval * tp, struct timezone * tzp)
{
// Note: some broken versions only have 8 trailing zero's, the
// correct epoch has 9 trailing zero's
static const uint64_t EPOCH = ((uint64_t) 116444736000000000ULL);
SYSTEMTIME system_time;
FILETIME file_time;
uint64_t time;
GetSystemTime( &system_time );
SystemTimeToFileTime( &system_time, &file_time );
time = ((uint64_t)file_time.dwLowDateTime ) ;
time += ((uint64_t)file_time.dwHighDateTime) << 32;
tp->tv_sec = (long) ((time - EPOCH) / 10000000L);
tp->tv_usec = (long) (system_time.wMilliseconds * 1000);
return 0;
}
#else // -> Not _WIN32
#ifndef USE_CLOCK_GETTIME
// Using gettimeofday then, needs struct timeval
#include <sys/time.h>
#endif
#endif
// We use gettimeofday instead of clock_gettime for now and get only
// uS resolution, because clock_gettime is more configuration trouble
// than it's worth
static void gettime(int
#ifdef USE_CLOCK_GETTIME
clk_id
#endif
, Chrono::TimeSpec *ts)
{
#ifdef USE_CLOCK_GETTIME
struct timespec mts;
clock_gettime(clk_id, &mts);
ts->tv_sec = mts.tv_sec;
ts->tv_nsec = mts.tv_nsec;
#else
struct timeval tv;
gettimeofday(&tv, 0);
ts->tv_sec = tv.tv_sec;
ts->tv_nsec = tv.tv_usec * 1000;
#endif
}
///// End system interface
// Note: this not protected against multithread access and not
// reentrant, but this is mostly debug code, and it won't crash, just
// show bad results. Also the frozen thing is not used that much
Chrono::TimeSpec Chrono::o_now;
void Chrono::refnow()
{
gettime(CLOCK_REALTIME, &o_now);
}
Chrono::Chrono()
{
restart();
}
// Reset and return value before rest in milliseconds
long Chrono::restart()
{
TimeSpec now;
gettime(CLOCK_REALTIME, &now);
long ret = MILLIS(m_orig, now);
m_orig = now;
return ret;
}
long Chrono::urestart()
{
TimeSpec now;
gettime(CLOCK_REALTIME, &now);
long ret = MICROS(m_orig, now);
m_orig = now;
return ret;
}
// Get current timer value, milliseconds
long Chrono::millis(bool frozen)
{
if (frozen) {
return MILLIS(m_orig, o_now);
} else {
TimeSpec now;
gettime(CLOCK_REALTIME, &now);
return MILLIS(m_orig, now);
}
}
//
long Chrono::micros(bool frozen)
{
if (frozen) {
return MICROS(m_orig, o_now);
} else {
TimeSpec now;
gettime(CLOCK_REALTIME, &now);
return MICROS(m_orig, now);
}
}
long long Chrono::amicros() const
{
TimeSpec ts;
ts.tv_sec = 0;
ts.tv_nsec = 0;
return MICROS(ts, m_orig);
}
//
long long Chrono::nanos(bool frozen)
{
if (frozen) {
return NANOS(m_orig, o_now);
} else {
TimeSpec now;
gettime(CLOCK_REALTIME, &now);
return NANOS(m_orig, now);
}
}
float Chrono::secs(bool frozen)
{
if (frozen) {
return SECONDS(m_orig, o_now);
} else {
TimeSpec now;
gettime(CLOCK_REALTIME, &now);
return SECONDS(m_orig, now);
}
}
#else
///////////////////// test driver
#include <stdio.h>
#include <signal.h>
#include <unistd.h>
#include <stdlib.h>
#include <iostream>
#include "chrono.h"
using namespace std;
static char *thisprog;
static void
Usage(void)
{
fprintf(stderr, "Usage : %s \n", thisprog);
exit(1);
}
Chrono achrono;
Chrono rchrono;
void
showsecs(long msecs)
{
fprintf(stderr, "%3.5f S", ((float)msecs) / 1000.0);
}
void
sigint(int sig)
{
signal(SIGINT, sigint);
signal(SIGQUIT, sigint);
fprintf(stderr, "Absolute interval: ");
showsecs(achrono.millis());
fprintf(stderr, ". Relative interval: ");
showsecs(rchrono.restart());
cerr << " Abs micros: " << achrono.amicros() <<
" Relabs micros: " << rchrono.amicros() - 1430477861905884LL
<< endl;
fprintf(stderr, ".\n");
if (sig == SIGQUIT) {
exit(0);
}
}
int main(int argc, char **argv)
{
thisprog = argv[0];
argc--;
argv++;
if (argc != 0) {
Usage();
}
for (int i = 0; i < 50000000; i++);
cerr << "Start secs: " << achrono.secs() << endl;
fprintf(stderr, "Type ^C for intermediate result, ^\\ to stop\n");
signal(SIGINT, sigint);
signal(SIGQUIT, sigint);
achrono.restart();
rchrono.restart();
while (1) {
pause();
}
}
#endif /*TEST_CHRONO*/

62
src/utils/chrono.h Normal file
View file

@ -0,0 +1,62 @@
/* Copyright (C) 2014 J.F.Dockes
* 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.,
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef _CHRONO_H_INCLUDED_
#define _CHRONO_H_INCLUDED_
#include <time.h>
/** Easy interface to measuring time intervals */
class Chrono {
public:
/** Initialize, setting the origin time */
Chrono();
/** Re-store current time and return mS since init or last call */
long restart();
/** Re-store current time and return uS since init or last call */
long urestart();
/** Snapshot current time to static storage */
static void refnow();
/** Return interval value in various units.
*
* If frozen is set this gives the time since the last refnow call
* (this is to allow for using one actual system call to get
values from many chrono objects, like when examining timeouts
in a queue
*/
long long nanos(bool frozen = false);
long micros(bool frozen = false);
long millis(bool frozen = false);
float secs(bool frozen = false);
/** Return the absolute value of the current origin */
long long amicros() const;
struct TimeSpec {
time_t tv_sec; /* Time in seconds */
long tv_nsec; /* And nanoseconds (< 10E9) */
};
private:
TimeSpec m_orig;
static TimeSpec o_now;
};
#endif /* _CHRONO_H_INCLUDED_ */

2
src/utils/circache.cpp
View file

@ -29,6 +29,8 @@
#include <memory.h>
#include <zlib.h>
#include "chrono.h"
#ifndef _WIN32
#include <sys/uio.h>
#else

175
src/utils/smallut.cpp
View file

@ -745,181 +745,6 @@ string breakIntoLines(const string& in, unsigned int ll,
return oq;
}
////////////////////
#if 0
// Internal redefinition of system time interface to help with dependancies
struct m_timespec {
time_t tv_sec;
long tv_nsec;
};
#endif
#ifndef CLOCK_REALTIME
typedef int clockid_t;
#define CLOCK_REALTIME 1
#endif
#define MILLIS(TV) ( (long)(((TV).tv_sec - m_secs) * 1000L + \
((TV).tv_nsec - m_nsecs) / 1000000))
#define MICROS(TV) ( (long)(((TV).tv_sec - m_secs) * 1000000L + \
((TV).tv_nsec - m_nsecs) / 1000))
#define NANOS(TV) ( (long long)(((TV).tv_sec - m_secs) * 1000000000LL + \
((TV).tv_nsec - m_nsecs)))
// Using clock_gettime() is nice because it gives us ns res and it helps with
// computing threads work times, but it's also a pita because it forces linking
// with -lrt. So keep it optional. And not on the mac anyway
// #define USE_CLOCK_GETTIME
#ifdef __APPLE__
#undef USE_CLOCK_GETTIME
#endif
#ifdef WIN32
#include "safewindows.h"
// Note: struct timespec is defined by pthread.h (from pthreads-w32)
#ifndef CLOCK_REALTIME
#define CLOCK_REALTIME 0
#endif
LARGE_INTEGER getFILETIMEoffset()
{
SYSTEMTIME s;
FILETIME f;
LARGE_INTEGER t;
s.wYear = 1970;
s.wMonth = 1;
s.wDay = 1;
s.wHour = 0;
s.wMinute = 0;
s.wSecond = 0;
s.wMilliseconds = 0;
SystemTimeToFileTime(&s, &f);
t.QuadPart = f.dwHighDateTime;
t.QuadPart <<= 32;
t.QuadPart |= f.dwLowDateTime;
return (t);
}
int clock_gettime(int X, struct timespec *tv)
{
LARGE_INTEGER t;
FILETIME f;
double microseconds;
static LARGE_INTEGER offset;
static double frequencyToMicroseconds;
static int initialized = 0;
static BOOL usePerformanceCounter = 0;
if (!initialized) {
LARGE_INTEGER performanceFrequency;
initialized = 1;
usePerformanceCounter = QueryPerformanceFrequency(&performanceFrequency);
if (usePerformanceCounter) {
QueryPerformanceCounter(&offset);
frequencyToMicroseconds = (double)performanceFrequency.QuadPart / 1000000.;
}
else {
offset = getFILETIMEoffset();
frequencyToMicroseconds = 10.;
}
}
if (usePerformanceCounter) QueryPerformanceCounter(&t);
else {
GetSystemTimeAsFileTime(&f);
t.QuadPart = f.dwHighDateTime;
t.QuadPart <<= 32;
t.QuadPart |= f.dwLowDateTime;
}
t.QuadPart -= offset.QuadPart;
microseconds = (double)t.QuadPart / frequencyToMicroseconds;
t.QuadPart = (long long)microseconds;
tv->tv_sec = t.QuadPart / 1000000;
tv->tv_nsec = (t.QuadPart % 1000000) * 1000;
return (0);
}
#define USE_CLOCK_GETTIME
#else /* -> !_WIN32 */
#ifndef USE_CLOCK_GETTIME
#include <sys/time.h>
#endif
#endif
static void gettime(clockid_t clk_id, struct timespec *ts)
{
#ifndef USE_CLOCK_GETTIME
struct timeval tv;
gettimeofday(&tv, 0);
ts->tv_sec = tv.tv_sec;
ts->tv_nsec = tv.tv_usec * 1000;
#else
clock_gettime(clk_id, ts);
#endif
}
///// End system interface
// Note: this not protected against multithread access and not reentrant, but
// this is mostly debug code, and it won't crash, just show bad results. Also
// the frozen thing is not used that much
static timespec frozen_tv;
void Chrono::refnow()
{
gettime(CLOCK_REALTIME, &frozen_tv);
}
Chrono::Chrono()
{
restart();
}
// Reset and return value before rest in milliseconds
time_t Chrono::restart()
{
struct timespec tv;
gettime(CLOCK_REALTIME, &tv);
time_t ret = MILLIS(tv);
m_secs = tv.tv_sec;
m_nsecs = tv.tv_nsec;
return ret;
}
// Get current timer value, milliseconds
time_t Chrono::millis(int frozen)
{
return nanos() / 1000000;
}
//
time_t Chrono::micros(int frozen)
{
return nanos() / 1000;
}
time_t Chrono::nanos(int frozen)
{
if (frozen) {
return NANOS(frozen_tv);
} else {
struct timespec tv;
gettime(CLOCK_REALTIME, &tv);
return NANOS(tv);
}
}
double Chrono::secs(int frozen)
{
struct timespec tv;
gettime(CLOCK_REALTIME, &tv);
double secs = (double)(frozen?frozen_tv.tv_sec:tv.tv_sec - m_secs);
double nsecs = (double)(frozen?frozen_tv.tv_nsec:tv.tv_nsec - m_nsecs);
return secs + nsecs * 1e-9;
}
// Date is Y[-M[-D]]
static bool parsedate(vector<string>::const_iterator& it,
vector<string>::const_iterator end, DateInterval *dip)

24
src/utils/smallut.h
View file

@ -158,30 +158,6 @@ void catstrerror(string *reason, const char *what, int _errno);
struct tm;
time_t portable_timegm(struct tm *tm);
/** Compute times to help with perf issues */
class Chrono {
public:
Chrono();
/** Reset origin */
time_t restart();
/** Snapshot current time */
static void refnow();
/** Get current elapsed since creation or restart
*
* @param frozen give time since the last refnow call (this is to
* allow for using one actual system call to get values from many
* chrono objects, like when examining timeouts in a queue)
*/
time_t millis(int frozen = 0);
time_t ms() {return millis();}
time_t micros(int frozen = 0);
time_t nanos(int frozen = 0);
double secs(int frozen = 0);
private:
time_t m_secs;
time_t m_nsecs;
};
/** Temp buffer with automatic deallocation */
struct TempBuf {
TempBuf()

1
src/windows/qmkrecoll/librecoll.pro
View file

@ -79,6 +79,7 @@ SOURCES += \
../../unac/unac.cpp \
../../utils/appformime.cpp \
../../utils/base64.cpp \
../../utils/chrono.cpp \
../../utils/circache.cpp \
../../utils/conftree.cpp \
../../utils/copyfile.cpp \