1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
|
// DO NOT EDIT !
// This file is generated using the MantaFlow preprocessor (prep generate).
/******************************************************************************
*
* MantaFlow fluid solver framework
* Copyright 2011 Tobias Pfaff, Nils Thuerey
*
* This program is free software, distributed under the terms of the
* Apache License, Version 2.0
* http://www.apache.org/licenses/LICENSE-2.0
*
* Plugin timing
*
******************************************************************************/
#ifndef _TIMING_H
#define _TIMING_H
#include "manta.h"
#include <map>
namespace Manta {
class TimingData {
private:
TimingData();
public:
static TimingData &instance()
{
static TimingData a;
return a;
}
void print();
void saveMean(const std::string &filename);
void start(FluidSolver *parent, const std::string &name);
void stop(FluidSolver *parent, const std::string &name);
protected:
void step();
struct TimingSet {
TimingSet() : num(0), updated(false)
{
cur.clear();
total.clear();
}
MuTime cur, total;
int num;
bool updated;
std::string solver;
};
bool updated;
int num;
MuTime mPluginTimer;
std::string mLastPlugin;
std::map<std::string, std::vector<TimingSet>> mData;
};
// Python interface
class Timings : public PbClass {
public:
Timings() : PbClass(0)
{
}
static int _W_0(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
{
PbClass *obj = Pb::objFromPy(_self);
if (obj)
delete obj;
try {
PbArgs _args(_linargs, _kwds);
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
pbPreparePlugin(0, "Timings::Timings", !noTiming);
{
ArgLocker _lock;
obj = new Timings();
obj->registerObject(_self, &_args);
_args.check();
}
pbFinalizePlugin(obj->getParent(), "Timings::Timings", !noTiming);
return 0;
}
catch (std::exception &e) {
pbSetError("Timings::Timings", e.what());
return -1;
}
}
void display()
{
TimingData::instance().print();
}
static PyObject *_W_1(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
{
try {
PbArgs _args(_linargs, _kwds);
Timings *pbo = dynamic_cast<Timings *>(Pb::objFromPy(_self));
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
pbPreparePlugin(pbo->getParent(), "Timings::display", !noTiming);
PyObject *_retval = 0;
{
ArgLocker _lock;
pbo->_args.copy(_args);
_retval = getPyNone();
pbo->display();
pbo->_args.check();
}
pbFinalizePlugin(pbo->getParent(), "Timings::display", !noTiming);
return _retval;
}
catch (std::exception &e) {
pbSetError("Timings::display", e.what());
return 0;
}
}
void saveMean(std::string file)
{
TimingData::instance().saveMean(file);
}
static PyObject *_W_2(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
{
try {
PbArgs _args(_linargs, _kwds);
Timings *pbo = dynamic_cast<Timings *>(Pb::objFromPy(_self));
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
pbPreparePlugin(pbo->getParent(), "Timings::saveMean", !noTiming);
PyObject *_retval = 0;
{
ArgLocker _lock;
std::string file = _args.get<std::string>("file", 0, &_lock);
pbo->_args.copy(_args);
_retval = getPyNone();
pbo->saveMean(file);
pbo->_args.check();
}
pbFinalizePlugin(pbo->getParent(), "Timings::saveMean", !noTiming);
return _retval;
}
catch (std::exception &e) {
pbSetError("Timings::saveMean", e.what());
return 0;
}
}
public:
PbArgs _args;
}
#define _C_Timings
;
} // namespace Manta
#endif
|
