Some more work

Author: olabetskyi

cli/cppcheckexecutor.cpp

@@ -260,7 +260,6 @@ namespace {
 
 int CppCheckExecutor::check(int argc, const char* const argv[])
 {
-    Timer realTimeClock("", SHOWTIME_MODES::SHOWTIME_SUMMARY);
     Settings settings;
     CmdLineLoggerStd logger;
     Suppressions supprs;
@@ -272,16 +271,15 @@ int CppCheckExecutor::check(int argc, const char* const argv[])
         return EXIT_SUCCESS;
     }
 
+    Timer realTimeClock("Summary", settings.showtime);
+
     settings.loadSummaries();
 
     mFiles = parser.getFiles();
     mFileSettings = parser.getFileSettings();
 
     const int ret = check_wrapper(settings, supprs);
 
-    if (settings.showtime == SHOWTIME_MODES::SHOWTIME_NONE)
-        realTimeClock.cancelRealTimeMeasurement();
-
     return ret;
 }
 

lib/cppcheck.cpp

@@ -895,9 +895,7 @@ unsigned int CppCheck::checkInternal(const FileWithDetails& file, const std::str
     if (Settings::terminated())
         return mLogger->exitcode();
 
-    Timer WholeFileTimer{file.spath()};
-    if (mSettings.showtime != SHOWTIME_MODES::SHOWTIME_FILE_TOTAL)
-        WholeFileTimer.cancelRealTimeMeasurement();
+    Timer WholeFileTimer{file.spath(), mSettings.showtime};
 
     if (!mSettings.quiet) {
         std::string fixedpath = Path::toNativeSeparators(file.spath());

lib/timer.cpp

@@ -29,7 +29,7 @@ namespace {
     using dataElementType = std::pair<std::string, TimerResultsData>;
     bool more_second_sec(const dataElementType& lhs, const dataElementType& rhs)
     {
-        return lhs.second.seconds() > rhs.second.seconds();
+        return lhs.second.getSeconds() > rhs.second.getSeconds();
     }
 
     // TODO: remove and print through (synchronized) ErrorLogger instead
@@ -42,8 +42,6 @@ void TimerResults::showResults(SHOWTIME_MODES mode) const
 {
     if (mode == SHOWTIME_MODES::SHOWTIME_NONE || mode == SHOWTIME_MODES::SHOWTIME_FILE_TOTAL)
         return;
-
-    TimerResultsData overallData;
     std::vector<dataElementType> data;
 
     {
@@ -61,35 +59,20 @@ void TimerResults::showResults(SHOWTIME_MODES mode) const
 
     size_t ordinal = 1; // maybe it would be nice to have an ordinal in output later!
     for (auto iter=data.cbegin(); iter!=data.cend(); ++iter) {
-        const double sec = iter->second.seconds();
+        const double sec = iter->second.getSeconds().count();
         const double secAverage = sec / static_cast<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_FILE && mode != SHOWTIME_MODES::SHOWTIME_TOP5_SUMMARY) || (ordinal<=5)) {
             std::cout << iter->first << ": " << sec << "s (avg. " << secAverage << "s - " << iter->second.mNumberOfResults  << " result(s))" << std::endl;
         }
         ++ordinal;
     }
 }
 
-void TimerResults::addResults(const std::string& str, std::clock_t clocks)
+void TimerResults::addResults(const std::string& str, Duration duration)
 {
     std::lock_guard<std::mutex> l(mResultsSync);
 
-    mResults[str].mClocks += clocks;
+    mResults[str].mDuration += duration;
     mResults[str].mNumberOfResults++;
 }
 
@@ -102,15 +85,7 @@ void TimerResults::reset()
 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)
-    , mStartTimePoint(Clock::now())
-{}
-
-Timer::Timer(std::string str)
-    : mStr(std::move(str))
-    , mShowTimeMode(SHOWTIME_MODES::SHOWTIME_FILE_TOTAL)
     , mStartTimePoint(Clock::now())
 {}
 
@@ -121,49 +96,35 @@ Timer::~Timer()
 
 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 = static_cast<double>(diff) / CLOCKS_PER_SEC;
-            std::lock_guard<std::mutex> l(stdCoutLock);
-            std::cout << mStr << ": " << sec << "s" << std::endl;
-        } else if (mShowTimeMode == SHOWTIME_MODES::SHOWTIME_FILE_TOTAL && mStartTimePoint != TimePoint{}) {
+    if ((mShowTimeMode != SHOWTIME_MODES::SHOWTIME_NONE) && mStartTimePoint != TimePoint{}) {
+        Duration diff = std::chrono::duration_cast<Duration>(Clock::now() - mStartTimePoint);
+        if (!mTimerResults) {
             std::lock_guard<std::mutex> l(stdCoutLock);
-            std::cout << "Check time: " << mStr << ": " << getRealTimePassed() << std::endl;
+            std::cout << (mStr == "Summary" ? "Overall time: " : "Check time: " + mStr + ": ")<< durationToString(diff) << std::endl;
         } else {
-            if (mTimerResults)
-                mTimerResults->addResults(mStr, diff);
-            else if (mStr.empty() && mStartTimePoint != TimePoint{}) { // Get real time
-                std::lock_guard<std::mutex> l(stdCoutLock);
-                std::cout << "Overall time: " << getRealTimePassed() << std::endl;
-            }
+            mTimerResults->addResults(mStr, diff);
         }
     }
-
-    mStopped = true;
 }
 
-std::string Timer::getRealTimePassed()
+std::string Timer::durationToString(Duration duration)
 {
-    auto diff = std::chrono::duration_cast<std::chrono::microseconds>(Clock::now() - mStartTimePoint);
-
     // Extract hours
-    auto hours = std::chrono::duration_cast<std::chrono::hours>(diff);
-    diff -= hours; // Subtract the extracted hours
+    auto hours = std::chrono::duration_cast<std::chrono::hours>(duration);
+    duration -= hours; // Subtract the extracted hours
 
     // Extract minutes
-    auto minutes = std::chrono::duration_cast<std::chrono::minutes>(diff);
-    diff -= minutes; // Subtract the extracted minutes
+    auto minutes = std::chrono::duration_cast<std::chrono::minutes>(duration);
+    duration -= minutes; // Subtract the extracted minutes
 
     // Extract seconds
-    auto seconds = static_cast<double>(diff.count()) / std::chrono::microseconds::period::den;
+    std::chrono::duration<double> seconds = std::chrono::duration_cast<std::chrono::duration<double>>(duration);
 
     std::string ellapsedTime;
     if (hours.count() > 0)
         ellapsedTime += std::to_string(hours.count()) + "h ";
     if (minutes.count() > 0)
         ellapsedTime += std::to_string(minutes.count()) + "m ";
-    return (ellapsedTime + std::to_string(seconds) + "s ");
+    std::string secondsStr{std::to_string(seconds.count())};
+    return (ellapsedTime + secondsStr.substr(0, secondsStr.length() - 3) + "s ");
 }

lib/timer.h

@@ -31,6 +31,10 @@
 #include <string>
 #include <utility>
 
+using Clock = std::chrono::high_resolution_clock;
+using TimePoint = std::chrono::time_point<Clock>;
+using Duration = std::chrono::milliseconds;
+
 enum class SHOWTIME_MODES : std::uint8_t {
     SHOWTIME_NONE,
     SHOWTIME_FILE,
@@ -44,16 +48,15 @@ class CPPCHECKLIB TimerResultsIntf {
 public:
     virtual ~TimerResultsIntf() = default;
 
-    virtual void addResults(const std::string& str, std::clock_t clocks) = 0;
+    virtual void addResults(const std::string& timerName, Duration duation) = 0;
 };
 
 struct TimerResultsData {
-    std::clock_t mClocks{};
+    Duration mDuration;
     long mNumberOfResults{};
 
-    double seconds() const {
-        const double ret = static_cast<double>(static_cast<unsigned long>(mClocks)) / static_cast<double>(CLOCKS_PER_SEC);
-        return ret;
+    std::chrono::duration<double> getSeconds() const {
+        return std::chrono::duration_cast<std::chrono::duration<double>>(mDuration);
     }
 };
 
@@ -62,7 +65,7 @@ class CPPCHECKLIB TimerResults : public TimerResultsIntf {
     TimerResults() = default;
 
     void showResults(SHOWTIME_MODES mode) const;
-    void addResults(const std::string& str, std::clock_t clocks) override;
+    void addResults(const std::string& str, Duration duration) override;
 
     void reset();
 
@@ -74,35 +77,24 @@ class CPPCHECKLIB TimerResults : public TimerResultsIntf {
 class CPPCHECKLIB Timer {
 public:
     Timer(std::string str, SHOWTIME_MODES showtimeMode, TimerResultsIntf* timerResults = nullptr);
-    Timer(std::string str);
     ~Timer();
 
     Timer(const Timer&) = delete;
     Timer& operator=(const Timer&) = delete;
 
-    using Clock = std::chrono::high_resolution_clock;
-    using TimePoint = std::chrono::time_point<Clock>;
-
     void stop();
 
-    void cancelRealTimeMeasurement() {
-        mStartTimePoint = TimePoint{};
-    }
+    static std::string durationToString(Duration duration);
 
     static void run(std::string str, SHOWTIME_MODES showtimeMode, TimerResultsIntf* timerResults, const std::function<void()>& f) {
         Timer t(std::move(str), showtimeMode, timerResults);
         f();
     }
 
 private:
-
-    std::string getRealTimePassed();
-
     const std::string mStr;
     TimerResultsIntf* mTimerResults{};
-    std::clock_t mStart = std::clock();
     const SHOWTIME_MODES mShowTimeMode = SHOWTIME_MODES::SHOWTIME_FILE_TOTAL;
-    bool mStopped{};
     TimePoint mStartTimePoint{};
 };
 

test/testtimer.cpp

@@ -33,12 +33,7 @@ class TestTimer : public TestFixture {
     }
 
     void result() const {
-        TimerResultsData t1;
-        t1.mClocks = ~static_cast<std::clock_t>(0);
-        ASSERT(t1.seconds() > 100.0);
-
-        t1.mClocks = CLOCKS_PER_SEC * 5 / 2;
-        ASSERT(std::fabs(t1.seconds()-2.5) < 0.01);
+        // TODO add some tests
     }
 };