← Back to branch summary

~paparazzi-uav/paparazzi/v5.0-manual

« back to all changes in this revision

Viewing changes to sw/ext/opencv_bebop/opencv/samples/gpu/performance/performance.h

  • Committer: Paparazzi buildbot
  • Date: 2016-05-18 15:00:29 UTC
  • Revision ID: felix.ruess+docbot@gmail.com-20160518150029-e8lgzi5kvb4p7un9
Manual import commit 4b8bbb730080dac23cf816b98908dacfabe2a8ec from v5.0 branch.

Show diffs side-by-side

added added

removed removed

Lines of Context:
sw/ext/opencv_bebop/opencv/samples/gpu/performance/performance.h
 
1
#ifndef OPENCV_CUDA_SAMPLE_PERFORMANCE_H_
 
2
#define OPENCV_CUDA_SAMPLE_PERFORMANCE_H_
 
3
 
 
4
#include <iostream>
 
5
#include <cstdio>
 
6
#include <vector>
 
7
#include <numeric>
 
8
#include <string>
 
9
#include <opencv2/core/utility.hpp>
 
10
 
 
11
#define TAB "    "
 
12
 
 
13
class Runnable
 
14
{
 
15
public:
 
16
    explicit Runnable(const std::string& nameStr): name_(nameStr) {}
 
17
    virtual ~Runnable() {}
 
18
 
 
19
    const std::string& name() const { return name_; }
 
20
 
 
21
    virtual void run() = 0;
 
22
 
 
23
private:
 
24
    std::string name_;
 
25
};
 
26
 
 
27
 
 
28
class TestSystem
 
29
{
 
30
public:
 
31
    static TestSystem& instance()
 
32
    {
 
33
        static TestSystem me;
 
34
        return me;
 
35
    }
 
36
 
 
37
    void setWorkingDir(const std::string& val) { working_dir_ = val; }
 
38
    const std::string& workingDir() const { return working_dir_; }
 
39
 
 
40
    void setTestFilter(const std::string& val) { test_filter_ = val; }
 
41
    const std::string& testFilter() const { return test_filter_; }
 
42
 
 
43
    void setNumIters(int num_iters) { num_iters_ = num_iters; }
 
44
 
 
45
    void addInit(Runnable* init) { inits_.push_back(init); }
 
46
    void addTest(Runnable* test) { tests_.push_back(test); }
 
47
    void run();
 
48
 
 
49
    // It's public because OpenCV callback uses it
 
50
    void printError(const std::string& msg);
 
51
 
 
52
    std::stringstream& startNewSubtest()
 
53
    {
 
54
        finishCurrentSubtest();
 
55
        return cur_subtest_description_;
 
56
    }
 
57
 
 
58
    bool stop() const { return cur_iter_idx_ >= num_iters_; }
 
59
 
 
60
    void cpuOn() { cpu_started_ = cv::getTickCount(); }
 
61
    void cpuOff()
 
62
    {
 
63
        int64 delta = cv::getTickCount() - cpu_started_;
 
64
        cpu_times_.push_back(delta);
 
65
        ++cur_iter_idx_;
 
66
    }
 
67
    void cpuComplete()
 
68
    {
 
69
        cpu_elapsed_ += meanTime(cpu_times_);
 
70
        cur_subtest_is_empty_ = false;
 
71
        cur_iter_idx_ = 0;
 
72
    }
 
73
 
 
74
    void gpuOn() { gpu_started_ = cv::getTickCount(); }
 
75
    void gpuOff()
 
76
    {
 
77
        int64 delta = cv::getTickCount() - gpu_started_;
 
78
        gpu_times_.push_back(delta);
 
79
        ++cur_iter_idx_;
 
80
    }
 
81
    void gpuComplete()
 
82
    {
 
83
        gpu_elapsed_ += meanTime(gpu_times_);
 
84
        cur_subtest_is_empty_ = false;
 
85
        cur_iter_idx_ = 0;
 
86
    }
 
87
 
 
88
    bool isListMode() const { return is_list_mode_; }
 
89
    void setListMode(bool value) { is_list_mode_ = value; }
 
90
 
 
91
private:
 
92
    TestSystem():
 
93
            cur_subtest_is_empty_(true), cpu_elapsed_(0),
 
94
            gpu_elapsed_(0), speedup_total_(0.0),
 
95
            num_subtests_called_(0), is_list_mode_(false),
 
96
            num_iters_(10), cur_iter_idx_(0)
 
97
    {
 
98
        cpu_times_.reserve(num_iters_);
 
99
        gpu_times_.reserve(num_iters_);
 
100
    }
 
101
 
 
102
    void finishCurrentSubtest();
 
103
    void resetCurrentSubtest()
 
104
    {
 
105
        cpu_elapsed_ = 0;
 
106
        gpu_elapsed_ = 0;
 
107
        cur_subtest_description_.str("");
 
108
        cur_subtest_is_empty_ = true;
 
109
        cur_iter_idx_ = 0;
 
110
        cpu_times_.clear();
 
111
        gpu_times_.clear();
 
112
    }
 
113
 
 
114
    double meanTime(const std::vector<int64> &samples);
 
115
 
 
116
    void printHeading();
 
117
    void printSummary();
 
118
    void printMetrics(double cpu_time, double gpu_time, double speedup);
 
119
 
 
120
    std::string working_dir_;
 
121
    std::string test_filter_;
 
122
 
 
123
    std::vector<Runnable*> inits_;
 
124
    std::vector<Runnable*> tests_;
 
125
 
 
126
    std::stringstream cur_subtest_description_;
 
127
    bool cur_subtest_is_empty_;
 
128
 
 
129
    int64 cpu_started_;
 
130
    int64 gpu_started_;
 
131
    double cpu_elapsed_;
 
132
    double gpu_elapsed_;
 
133
 
 
134
    double speedup_total_;
 
135
    int num_subtests_called_;
 
136
 
 
137
    bool is_list_mode_;
 
138
 
 
139
    int num_iters_;
 
140
    int cur_iter_idx_;
 
141
    std::vector<int64> cpu_times_;
 
142
    std::vector<int64> gpu_times_;
 
143
};
 
144
 
 
145
 
 
146
#define GLOBAL_INIT(name) \
 
147
    struct name##_init: Runnable { \
 
148
        name##_init(): Runnable(#name) { \
 
149
            TestSystem::instance().addInit(this); \
 
150
        } \
 
151
        void run(); \
 
152
    } name##_init_instance; \
 
153
    void name##_init::run()
 
154
 
 
155
 
 
156
#define TEST(name) \
 
157
    struct name##_test: Runnable { \
 
158
        name##_test(): Runnable(#name) { \
 
159
            TestSystem::instance().addTest(this); \
 
160
        } \
 
161
        void run(); \
 
162
    } name##_test_instance; \
 
163
    void name##_test::run()
 
164
 
 
165
#define SUBTEST TestSystem::instance().startNewSubtest()
 
166
 
 
167
#define CPU_ON \
 
168
    while (!TestSystem::instance().stop()) { \
 
169
        TestSystem::instance().cpuOn()
 
170
#define CPU_OFF \
 
171
        TestSystem::instance().cpuOff(); \
 
172
    } TestSystem::instance().cpuComplete()
 
173
 
 
174
#define CUDA_ON \
 
175
    while (!TestSystem::instance().stop()) { \
 
176
        TestSystem::instance().gpuOn()
 
177
#define CUDA_OFF \
 
178
        TestSystem::instance().gpuOff(); \
 
179
    } TestSystem::instance().gpuComplete()
 
180
 
 
181
// Generates a matrix
 
182
void gen(cv::Mat& mat, int rows, int cols, int type, cv::Scalar low,
 
183
         cv::Scalar high);
 
184
 
 
185
// Returns abs path taking into account test system working dir
 
186
std::string abspath(const std::string& relpath);
 
187
 
 
188
#endif // OPENCV_CUDA_SAMPLE_PERFORMANCE_H_