91070ca794
This makes the code much more readable. It also makes it less prone to errors because we do not need to specify the length of the string to match and the returnvalue is clear. The code with the bad returnvalue check was never executed and I added a test to show that.
134 lines
4.5 KiB
C++
134 lines
4.5 KiB
C++
/*
|
|
* Cppcheck - A tool for static C/C++ code analysis
|
|
* Copyright (C) 2007-2023 Cppcheck team.
|
|
*
|
|
* 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 3 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, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include "timer.h"
|
|
|
|
#include "utils.h"
|
|
|
|
#include <algorithm>
|
|
#include <iostream>
|
|
#include <utility>
|
|
#include <vector>
|
|
/*
|
|
TODO:
|
|
- rename "file" to "single"
|
|
- add unit tests
|
|
- for --showtime (needs input file)
|
|
- for Timer* classes
|
|
*/
|
|
|
|
namespace {
|
|
using dataElementType = std::pair<std::string, struct TimerResultsData>;
|
|
bool more_second_sec(const dataElementType& lhs, const dataElementType& rhs)
|
|
{
|
|
return lhs.second.seconds() > rhs.second.seconds();
|
|
}
|
|
}
|
|
|
|
void TimerResults::showResults(SHOWTIME_MODES mode) const
|
|
{
|
|
if (mode == SHOWTIME_MODES::SHOWTIME_NONE || mode == SHOWTIME_MODES::SHOWTIME_FILE_TOTAL)
|
|
return;
|
|
|
|
std::cout << std::endl;
|
|
TimerResultsData overallData;
|
|
|
|
std::vector<dataElementType> data;
|
|
{
|
|
std::lock_guard<std::mutex> l(mResultsSync);
|
|
data.reserve(mResults.size());
|
|
data.insert(data.begin(), mResults.cbegin(), mResults.cend());
|
|
}
|
|
std::sort(data.begin(), data.end(), more_second_sec);
|
|
|
|
size_t ordinal = 1; // maybe it would be nice to have an ordinal in output later!
|
|
for (std::vector<dataElementType>::const_iterator iter=data.cbegin(); iter!=data.cend(); ++iter) {
|
|
const double sec = iter->second.seconds();
|
|
const double secAverage = sec / (double)(iter->second.mNumberOfResults);
|
|
bool hasParent = false;
|
|
{
|
|
// Do not use valueFlow.. in "Overall time" because those are included in Tokenizer already
|
|
if (startsWith(iter->first,"valueFlow"))
|
|
hasParent = true;
|
|
|
|
// Do not use inner timers in "Overall time"
|
|
const std::string::size_type pos = iter->first.rfind("::");
|
|
if (pos != std::string::npos)
|
|
hasParent = std::any_of(data.cbegin(), data.cend(), [iter,pos](const dataElementType& d) {
|
|
return d.first.size() == pos && iter->first.compare(0, d.first.size(), d.first) == 0;
|
|
});
|
|
}
|
|
if (!hasParent)
|
|
overallData.mClocks += iter->second.mClocks;
|
|
if ((mode != SHOWTIME_MODES::SHOWTIME_TOP5) || (ordinal<=5)) {
|
|
std::cout << iter->first << ": " << sec << "s (avg. " << secAverage << "s - " << iter->second.mNumberOfResults << " result(s))" << std::endl;
|
|
}
|
|
++ordinal;
|
|
}
|
|
|
|
const double secOverall = overallData.seconds();
|
|
std::cout << "Overall time: " << secOverall << "s" << std::endl;
|
|
}
|
|
|
|
void TimerResults::addResults(const std::string& str, std::clock_t clocks)
|
|
{
|
|
std::lock_guard<std::mutex> l(mResultsSync);
|
|
|
|
mResults[str].mClocks += clocks;
|
|
mResults[str].mNumberOfResults++;
|
|
}
|
|
|
|
Timer::Timer(std::string str, SHOWTIME_MODES showtimeMode, TimerResultsIntf* timerResults)
|
|
: mStr(std::move(str))
|
|
, mTimerResults(timerResults)
|
|
, mStart(std::clock())
|
|
, mShowTimeMode(showtimeMode)
|
|
, mStopped(showtimeMode == SHOWTIME_MODES::SHOWTIME_NONE || showtimeMode == SHOWTIME_MODES::SHOWTIME_FILE_TOTAL)
|
|
{}
|
|
|
|
Timer::Timer(bool fileTotal, std::string filename)
|
|
: mStr(std::move(filename))
|
|
, mStopped(!fileTotal)
|
|
{}
|
|
|
|
Timer::~Timer()
|
|
{
|
|
stop();
|
|
}
|
|
|
|
void Timer::stop()
|
|
{
|
|
if ((mShowTimeMode != SHOWTIME_MODES::SHOWTIME_NONE) && !mStopped) {
|
|
const std::clock_t end = std::clock();
|
|
const std::clock_t diff = end - mStart;
|
|
|
|
if (mShowTimeMode == SHOWTIME_MODES::SHOWTIME_FILE) {
|
|
const double sec = (double)diff / CLOCKS_PER_SEC;
|
|
std::cout << mStr << ": " << sec << "s" << std::endl;
|
|
} else if (mShowTimeMode == SHOWTIME_MODES::SHOWTIME_FILE_TOTAL) {
|
|
const double sec = (double)diff / CLOCKS_PER_SEC;
|
|
std::cout << "Check time: " << mStr << ": " << sec << "s" << std::endl;
|
|
} else {
|
|
if (mTimerResults)
|
|
mTimerResults->addResults(mStr, diff);
|
|
}
|
|
}
|
|
|
|
mStopped = true;
|
|
}
|