up timer

Scheaven

2021-07-27 84171fea33e983a956ab362b606a69805495318d

up timer

 src/core/ari_manager.cpp

@@ -57,10 +57,7 @@


    // cv::imshow("img",image0);

    // cv::waitKey(0);

    Timer timer;

    timer.reset();

    this->detector->detect(batch_img, batch_res);

    timer.out("detect");



    t_result.targets = (Target*)malloc(sizeof(Target)*batch_res[0].size());

    // 将算法结果转化为标准的格式（以目标检测为例）


 src/detecter_tools/model.h

@@ -13,7 +13,7 @@
#include <stdint.h>
#include <string>
#include <vector>
#include "../utils/timer_utils.hpp"
#include "../utils/time_util.h"
#include "../config.h"
#include "opencv2/opencv.hpp"


 src/h_interface.cpp

@@ -16,6 +16,7 @@
    CLog::Initialize("../config/log4cplus.properties");

    ReadJsonFromFile(conf);

    AriManager *handle = new AriManager();

    Timer::getInstance()->reset();

    return handle;

}



@@ -25,7 +26,10 @@
    AriManager *h = (AriManager*)handle;

    TResult *t_result = (TResult*)malloc(sizeof(TResult));

    init_TResult(t_result);



    Timer::getInstance()->out("eveTime before yolo");

    h->single_SDK(chan, img, *t_result);

    Timer::getInstance()->out("eveTime runing yolo");

    return t_result;

}




 src/utils/time_util.cpp

New file
@@ -0,0 +1,134 @@
//

// Created by Scheaven on 2020/5/14.

//



#include "time_util.h"



#include <stdio.h>

#include <memory.h>

#include <iostream>

#include <ctime>

#include <string>

#include "stdlib.h"

#include <sys/time.h>

#include <time.h>

#include <unistd.h>



using namespace std;



int get_run_time(struct timeval *result, struct timeval *begin, struct timeval * end)

{

    if(begin->tv_sec > end->tv_sec)  return -1;

    if((begin->tv_sec == end->tv_sec) && (begin->tv_usec > end->tv_usec))  return -2;

    result->tv_sec = end->tv_sec - begin->tv_sec;

    result->tv_usec = end->tv_usec - begin->tv_usec;



    if(result->tv_usec<0)

    {

        result->tv_sec--;

        result->tv_usec += 1000000;

    }

    return 0;

}



time_t strTime2unix(char* timeStamp)

{

    struct tm tm;

    memset(&tm, 0, sizeof(tm));



    sscanf(timeStamp, "%d-%d-%d %d:%d:%d",

           &tm.tm_year, &tm.tm_mon, &tm.tm_mday,

           &tm.tm_hour, &tm.tm_min, &tm.tm_sec);



    tm.tm_year -= 1900;

    tm.tm_mon--;



    return mktime(&tm);

}



long char_2_unix(char* str1)

{

    char str[100];

//    std::cout<< "==char_2_unix=%s：" << str1<< std::endl;



    strcpy(str, str1);

    const char *mySplit = ".";

    char *p;

    char *p1;

    char *p2;



    p1 = strtok(str, mySplit);

    p2 = strtok(NULL, mySplit);

//    std::cout<< "--p1=：" << p1 << " : " << p2 << std::endl;

    time_t t = strTime2unix(p1);



//    std::cout<< "char_2_unix=t=%s：" << t << std::endl;

    return t*1000+atoi(p2);

}





char* fa_getSysTime()

{

    struct timeval tv;

    gettimeofday(&tv,NULL);

    struct tm* pTime;

    pTime = localtime(&tv.tv_sec);



    static char sTemp[30] = "0";

    snprintf(sTemp, sizeof(sTemp), "%04d-%02d-%02d %02d:%02d:%02d:%03d", pTime->tm_year+1900, \

            pTime->tm_mon+1, pTime->tm_mday, pTime->tm_hour, pTime->tm_min, pTime->tm_sec, \

            tv.tv_usec/1000);

    char* TP = sTemp;

    return TP;

}



string random_int(size_t length)

{

    long seed = (unsigned)time(NULL) + (unsigned)clock();

    srand(seed);

    auto randchar= []() ->char

    {

        const char  charset[] = "0123456789";

        const size_t max_index = (sizeof(charset) - 1);

        return charset[rand()%max_index];

    };

    std::string str(length,0);

    std::generate_n(str.begin(),length,randchar);

    //SLOG::getInstance()->addLog(0, str + "------seed and id--init-----id:" + to_string(seed));

    return str;

}





Timer* Timer::instance = NULL;

Timer* Timer::getInstance()

{

    if (instance==NULL)

    {

        instance = new Timer();

    }

    return instance;

}



Timer::Timer():beg_(clock_::now()){}

void Timer::reset()

{

    beg_ = clock_::now();

}



double Timer::elapsed() const

{

    return std::chrono::duration_cast<second_>(clock_::now() - beg_).count();

}



void Timer::out(std::string message)

{

    double t = elapsed();

    // std::cout << message << " elasped time:" << t << "ms" << std::endl;

    DEBUG((boost::format("%e: %f ms")%message %t).str());

    reset();

}



double Timer::get_duration() const

{

    return elapsed();

}


 src/utils/time_util.h

New file
@@ -0,0 +1,49 @@
//

// Created by Scheaven on 2020/5/14.

//



#ifndef DEMO_TIME_UTIL_H

#define DEMO_TIME_UTIL_H



#include <sys/time.h>

#include <cstdio>

#include <time.h>

#include <stdlib.h>

#include <string>

#include <algorithm>

#include <sstream>



int get_run_time(struct timeval *result, struct timeval *begin, struct timeval *end);



time_t strTime2unix(char* timeStamp);



long char_2_unix(char* str1);



char* fa_getSysTime();



std::string random_int(size_t length);



#include <chrono>

#include "log_util.h"

#include <boost/format.hpp>



class Timer

{

    public:

        static Timer* instance;

        static Timer* getInstance();



        Timer();

    public:

        void reset();

        double elapsed() const;

        void out(std::string message="");

        // DEBUG((boost::format("nhao%d")%1).str());

        double get_duration() const;

    private:

        using clock_ = std::chrono::high_resolution_clock;

        using second_=std::chrono::duration<double,std::milli>;

        std::chrono::time_point<clock_>beg_;

};



#endif //DEMO_TIME_UTIL_H


 src/utils/timer_utils.hpp

File was deleted