Linux GNU 11.4.0 Code Coverage Report

Directory: ./
Coverage: low: ≥ 0% medium: ≥ 75.0% high: ≥ 90.0%
Coverage Exec / Excl / Total
Lines: 0.0% 0 / 0 / 130
Functions: 0.0% 0 / 0 / 28
Branches: 0.0% 0 / 0 / 140
OMCompiler/SimulationRuntime/cpp/Core/Utils/extension/measure_time.cpp
Line Branch Exec Source
1 /*
2 * This file belongs to the OpenModelica Run-Time System
3 *
4 * Copyright (c) 1998-2026, Open Source Modelica Consortium (OSMC), c/o Linköpings
5 * universitet, Department of Computer and Information Science, SE-58183 Linköping, Sweden. All rights
6 * reserved.
7 *
8 * THIS PROGRAM IS PROVIDED UNDER THE TERMS OF THE BSD NEW LICENSE OR THE
9 * AGPL VERSION 3 LICENSE OR THE OSMC PUBLIC LICENSE (OSMC-PL) VERSION 1.8. ANY
10 * USE, REPRODUCTION OR DISTRIBUTION OF THIS PROGRAM CONSTITUTES RECIPIENT'S
11 * ACCEPTANCE OF THE BSD NEW LICENSE OR THE OSMC PUBLIC LICENSE OR THE AGPL
12 * VERSION 3, ACCORDING TO RECIPIENTS CHOICE.
13 *
14 * The OpenModelica software and the OSMC (Open Source Modelica Consortium) Public License
15 * (OSMC-PL) are obtained from OSMC, either from the above address, from the URLs:
16 * http://www.openmodelica.org or https://github.com/OpenModelica/ or
17 * http://www.ida.liu.se/projects/OpenModelica, and in the OpenModelica distribution. GNU
18 * AGPL version 3 is obtained from: https://www.gnu.org/licenses/licenses.html#GPL. The BSD NEW
19 * License is obtained from: http://www.opensource.org/licenses/BSD-3-Clause.
20 *
21 * This program is distributed WITHOUT ANY WARRANTY; without even the implied warranty of
22 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE, EXCEPT AS EXPRESSLY
23 * SET FORTH IN THE BY RECIPIENT SELECTED SUBSIDIARY LICENSE CONDITIONS OF
24 * OSMC-PL.
25 *
26 */
27
28 #include <Core/ModelicaDefine.h>
29 #include <Core/Modelica.h>
30 #include <Core/Utils/extension/measure_time.hpp>
31 #include <Core/Utils/extension/FactoryExport.h>
32 #include <Core/Utils/extension/logger.hpp>
33
34 MeasureTime * MeasureTime::_instance = NULL;
35 MeasureTime::file_map MeasureTime::_valuesToWrite;
36
37 ✗ MeasureTimeValues::MeasureTimeValues() : _numCalcs(0){}
38
39 ✗ MeasureTimeValues::~MeasureTimeValues()
40 {
41 ✗ }
42
43 ✗ void MeasureTimeValues::reset()
44 {
45 ✗ _numCalcs = 0;
46 ✗ }
47
48 ✗ MeasureTimeValuesSolver::MeasureTimeValuesSolver() : MeasureTimeValues(), _functionEvaluations(0), _errorTestFailures(0)
49 ✗ {}
50
51 ✗ MeasureTimeValuesSolver::MeasureTimeValuesSolver(unsigned long long functionEvaluations, unsigned long long errorTestFailures) :
52 ✗ MeasureTimeValues(), _functionEvaluations(functionEvaluations), _errorTestFailures(errorTestFailures)
53 ✗ {}
54
55 ✗ MeasureTimeValuesSolver::MeasureTimeValuesSolver(const MeasureTimeValuesSolver &timeValues) :
56 ✗ MeasureTimeValues(), _functionEvaluations(timeValues._functionEvaluations), _errorTestFailures(timeValues._errorTestFailures)
57 ✗ {}
58
59 ✗ MeasureTimeValuesSolver::~MeasureTimeValuesSolver() {}
60
61 ✗ std::string MeasureTimeValuesSolver::serializeToJson() const
62 {
63 ✗ std::stringstream ss;
64 ✗ ss << "\"functionEvaluations\":" << _functionEvaluations << ",\"errorTestFailures\":" << _errorTestFailures;
65 ✗ return ss.str();
66 ✗ }
67
68 ✗ void MeasureTimeValuesSolver::add(MeasureTimeValues *values)
69 {
70 MeasureTimeValuesSolver *val = static_cast<MeasureTimeValuesSolver*>(values);
71 ✗ _functionEvaluations += val->_functionEvaluations;
72 ✗ _errorTestFailures += val->_errorTestFailures;
73 ✗ }
74
75 ✗ void MeasureTimeValuesSolver::sub(MeasureTimeValues *values)
76 {
77 MeasureTimeValuesSolver *val = static_cast<MeasureTimeValuesSolver*>(values);
78 ✗ _functionEvaluations -= val->_functionEvaluations;
79 ✗ _errorTestFailures -= val->_errorTestFailures;
80 ✗ }
81
82 ✗ void MeasureTimeValuesSolver::div(int counter)
83 {
84 ✗ _functionEvaluations = _functionEvaluations / counter;
85 ✗ _errorTestFailures = _errorTestFailures / counter;
86 ✗ }
87
88 ✗ MeasureTimeValues* MeasureTimeValuesSolver::clone() const
89 {
90 ✗ return new MeasureTimeValuesSolver(*this);
91 }
92
93 ✗ void MeasureTimeValuesSolver::reset()
94 {
95 ✗ MeasureTimeValues::reset();
96 ✗ _functionEvaluations = 0;
97 ✗ _errorTestFailures = 0;
98 ✗ }
99
100 ✗ MeasureTimeData::MeasureTimeData() : _id(""), _sumMeasuredValues(MeasureTime::getZeroValues())
101 {
102
103 ✗ }
104
105 ✗ MeasureTimeData::MeasureTimeData(std::string id) : _id(id), _sumMeasuredValues(MeasureTime::getZeroValues())
106 {
107
108 ✗ }
109
110 ✗ MeasureTimeData::MeasureTimeData(const MeasureTimeData &data): _id(data._id), _sumMeasuredValues(data._sumMeasuredValues->clone())
111 {
112
113 ✗ }
114
115 ✗ MeasureTimeData::~MeasureTimeData()
116 {
117 ✗ if(_sumMeasuredValues != NULL)
118 ✗ delete _sumMeasuredValues;
119 ✗ }
120
121 ✗ std::string MeasureTimeData::serializeToJson() const
122 {
123 ✗ std::stringstream ss("");
124 ✗ ss << _sumMeasuredValues->serializeToJson();
125 ✗ return ss.str();
126 ✗ }
127
128 ✗ MeasureTime::MeasureTime() : _measuredOverhead(NULL) {}
129
130 ✗ MeasureTime::~MeasureTime()
131 {
132 ✗ for(file_map::iterator it = _valuesToWrite.begin(); it != _valuesToWrite.end(); it++)
133 {
134 ✗ for(block_map::iterator iter = it->second.begin(); iter != it->second.end(); iter++)
135 {
136 ✗ for(int i = 0; i < iter->second->size(); i++)
137 ✗ delete iter->second->at(i);
138
139 iter->second->clear();
140 ✗ delete iter->second;
141 }
142 it->second.clear();
143 }
144 _valuesToWrite.clear();
145
146 ✗ if(_measuredOverhead != NULL)
147 ✗ delete _measuredOverhead;
148
149 _measuredOverhead = NULL;
150 ✗ }
151
152 ✗ MeasureTime* MeasureTime::getInstance()
153 {
154 ✗ return _instance;
155 }
156
157 ✗ void MeasureTime::deinitialize()
158 {
159 ✗ if (_instance != NULL)
160 {
161 ✗ delete _instance;
162 }
163 ✗ _instance = NULL;
164 ✗ }
165
166 ✗ MeasureTimeValues* MeasureTime::getZeroValues()
167 {
168 ✗ if (_instance == NULL)
169 return NULL;
170
171 ✗ return _instance->getZeroValuesP();
172 }
173
174 ✗ MeasureTimeValues* MeasureTime::getOverhead()
175 {
176 ✗ if (_instance == NULL)
177 return NULL;
178
179 ✗ return _instance->_measuredOverhead;
180 }
181
182 ✗ void MeasureTime::setOverheadToZero()
183 {
184 ✗ if(_measuredOverhead != NULL)
185 ✗ delete _measuredOverhead;
186
187 ✗ _measuredOverhead = getZeroValuesP();
188 ✗ }
189
190 ✗ void MeasureTime::benchOverhead()
191 {
192 ✗ if(_measuredOverhead != NULL)
193 ✗ delete _measuredOverhead;
194
195 ✗ _measuredOverhead = getZeroValues();
196
197 ✗ MeasureTimeValues *overheadMeasureStart = getZeroValues();
198 ✗ MeasureTimeValues *overheadMeasureEnd = getZeroValues();
199
200 ✗ for(int i = 0; i < 10; i++) //warmup
201 {
202 MeasureTime::getTimeValuesStart(overheadMeasureStart);
203 MeasureTime::getTimeValuesEnd(overheadMeasureEnd);
204 }
205
206 ✗ for(int i = 0; i < 100; i++)
207 {
208 MeasureTime::getTimeValuesStart(overheadMeasureStart);
209 MeasureTime::getTimeValuesEnd(overheadMeasureEnd);
210 ✗ overheadMeasureEnd->sub(overheadMeasureStart);
211 ✗ _measuredOverhead->add(overheadMeasureEnd);
212 }
213 ✗ _measuredOverhead->div(100);
214
215 ✗ delete overheadMeasureStart;
216 ✗ delete overheadMeasureEnd;
217 ✗ }
218
219 ✗ void MeasureTime::addResultContentBlock(std::string modelName, std::string blockName, std::vector<MeasureTimeData*> *data)
220 {
221 ✗ _valuesToWrite[modelName][blockName] = data;
222 ✗ }
223
224 ✗ void MeasureTime::writeToJson()
225 {
226 ✗ std::stringstream date;
227 std::string tmpS;
228 ✗ date.str("");
229 ✗ time_t sec = time(NULL);
230 ✗ tm * date_t = localtime(&sec);
231 ✗ date << date_t->tm_year + 1900 << "-" << date_t->tm_mon + 1 << "-" << date_t->tm_mday << " " << date_t->tm_hour << ":" << date_t->tm_min << ":" << date_t->tm_sec;
232
233 ✗ for( file_map::iterator model = _valuesToWrite.begin() ; model != _valuesToWrite.end() ; ++model ) // iterate files
234 {
235 ✗ std::ofstream os;
236 ✗ os.open((model->first + std::string("_prof.json")).c_str());
237 ✗ os << "{\n\"name\":\"" << model->first << "\",\n";
238 ✗ os << "\"prefix\":\"" << model->first << "\",\n";
239 ✗ os << "\"date\":\"" << date.str() << "\",\n";
240
241 //write blocks:
242 bool isFirstBlock = true;
243 ✗ for( block_map::iterator block = model->second.begin() ; block != model->second.end() ; ++block ) // iterate blocks
244 {
245 ✗ std::vector<MeasureTimeData*> *data = block->second;
246
247 ✗ if(isFirstBlock) isFirstBlock = false;
248 else
249 {
250 ✗ os << ",\n";
251 }
252 ✗ os << "\"" << block->first << "\":[\n";
253
254 //write data
255 ✗ for (unsigned i = 0; i < (data->size() == 0 ? 1 : data->size()) - 1; ++i)
256 {
257 ✗ if((*data)[i] == NULL)
258 {
259 ✗ LOGGER_WRITE("Skipped a measured block in '" + block->first + "' because it is null.", LC_OUTPUT, LL_ERROR);
260 ✗ continue;
261 }
262 ✗ tmpS = (*data)[i]->serializeToJson();
263 ✗ if(tmpS != "")
264 ✗ os << "{\"id\":\"" << (*data)[i]->_id << "\"," << tmpS << "},\n";
265 }
266 ✗ if( data->size() > 0 ) os << "{\"id\":\"" << (*data)[data->size()-1]->_id << "\"," << (*data)[data->size()-1]->serializeToJson() << "}]";
267 ✗ else os << "]";
268
269 } // end blocks
270
271 ✗ os << "\n}\n";
272 ✗ os.close();
273
274 ✗ std::cout << "Profiling results written to " << (model->first + std::string("_prof.json")) << std::endl;
275
276 ✗ } // end files
277 ✗ }
278