Nits

Author: olabetskyi

cli/cppcheckexecutor.cpp

@@ -260,7 +260,7 @@ namespace {
 
 int CppCheckExecutor::check(int argc, const char* const argv[])
 {
-    auto startTime{Timer::now()};
+    Timer realTimeClock("", SHOWTIME_MODES::SHOWTIME_SUMMARY);
     Settings settings;
     CmdLineLoggerStd logger;
     Suppressions supprs;
@@ -279,8 +279,8 @@ int CppCheckExecutor::check(int argc, const char* const argv[])
 
     const int ret = check_wrapper(settings, supprs);
 
-    if (settings.showtime != SHOWTIME_MODES::SHOWTIME_NONE)
-        Timer::calculateAndOutputTimeDiff(startTime, Timer::now());
+    if (settings.showtime == SHOWTIME_MODES::SHOWTIME_NONE)
+        realTimeClock.cancelRealTimeMeasurement();
 
     return ret;
 }

lib/cppcheck.cpp

@@ -895,7 +895,9 @@ unsigned int CppCheck::checkInternal(const FileWithDetails& file, const std::str
     if (Settings::terminated())
         return mLogger->exitcode();
 
-    const Timer fileTotalTimer(mSettings.showtime == SHOWTIME_MODES::SHOWTIME_FILE_TOTAL, file.spath());
+    Timer WholeFileTimer{file.spath()};
+    if (mSettings.showtime != SHOWTIME_MODES::SHOWTIME_FILE_TOTAL)
+        WholeFileTimer.cancelRealTimeMeasurement();
 
     if (!mSettings.quiet) {
         std::string fixedpath = Path::toNativeSeparators(file.spath());
@@ -1311,8 +1313,7 @@ unsigned int CppCheck::checkInternal(const FileWithDetails& file, const std::str
     // TODO: clear earlier?
     mLogger->clear();
 
-    if (mSettings.showtime == SHOWTIME_MODES::SHOWTIME_FILE || mSettings.showtime == SHOWTIME_MODES::SHOWTIME_TOP5_FILE)
-        printTimerResults(mSettings.showtime);
+    printTimerResults(mSettings.showtime);
 
     return mLogger->exitcode();
 }

lib/timer.cpp

@@ -105,11 +105,13 @@ Timer::Timer(std::string str, SHOWTIME_MODES showtimeMode, TimerResultsIntf* tim
     , mStart(std::clock())
     , mShowTimeMode(showtimeMode)
     , mStopped(showtimeMode == SHOWTIME_MODES::SHOWTIME_NONE || showtimeMode == SHOWTIME_MODES::SHOWTIME_FILE_TOTAL)
+    , mStartTimePoint(Clock::now())
 {}
 
-Timer::Timer(bool fileTotal, std::string filename)
-    : mStr(std::move(filename))
-    , mStopped(!fileTotal)
+Timer::Timer(std::string str)
+    : mStr(std::move(str))
+    , mShowTimeMode(SHOWTIME_MODES::SHOWTIME_FILE_TOTAL)
+    , mStartTimePoint(Clock::now())
 {}
 
 Timer::~Timer()
@@ -127,22 +129,25 @@ void Timer::stop()
             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) {
-            const double sec = static_cast<double>(diff) / CLOCKS_PER_SEC;
+        } else if (mShowTimeMode == SHOWTIME_MODES::SHOWTIME_FILE_TOTAL && mStartTimePoint != TimePoint{}) {
             std::lock_guard<std::mutex> l(stdCoutLock);
-            std::cout << "Check time: " << mStr << ": " << sec << "s" << std::endl;
+            std::cout << "Check time: " << mStr << ": " << getRealTimePassed() << 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;
+            }
         }
     }
 
     mStopped = true;
 }
 
-void Timer::calculateAndOutputTimeDiff(const tp& start, const tp& end)
+std::string Timer::getRealTimePassed()
 {
-    auto diff = std::chrono::duration_cast<std::chrono::microseconds>(end - start);
+    auto diff = std::chrono::duration_cast<std::chrono::microseconds>(Clock::now() - mStartTimePoint);
 
     // Extract hours
     auto hours = std::chrono::duration_cast<std::chrono::hours>(diff);
@@ -160,8 +165,5 @@ void Timer::calculateAndOutputTimeDiff(const tp& start, const tp& end)
         ellapsedTime += std::to_string(hours.count()) + "h ";
     if (minutes.count() > 0)
         ellapsedTime += std::to_string(minutes.count()) + "m ";
-    ellapsedTime += std::to_string(seconds) + "s ";
-
-    std::lock_guard<std::mutex> l(stdCoutLock);
-    std::cout << "Overall time: " << ellapsedTime << std::endl;
+    return (ellapsedTime + std::to_string(seconds) + "s ");
 }

lib/timer.h

@@ -74,33 +74,36 @@ class CPPCHECKLIB TimerResults : public TimerResultsIntf {
 class CPPCHECKLIB Timer {
 public:
     Timer(std::string str, SHOWTIME_MODES showtimeMode, TimerResultsIntf* timerResults = nullptr);
-    Timer(bool fileTotal, std::string filename);
+    Timer(std::string str);
     ~Timer();
 
     Timer(const Timer&) = delete;
     Timer& operator=(const Timer&) = delete;
 
-    using tp = std::chrono::time_point<std::chrono::high_resolution_clock>;
-
-    static tp now() {
-        return std::chrono::high_resolution_clock::now();
-    }
-
-    static void calculateAndOutputTimeDiff(const tp& start, const tp& end);
+    using Clock = std::chrono::high_resolution_clock;
+    using TimePoint = std::chrono::time_point<Clock>;
 
     void stop();
 
+    void cancelRealTimeMeasurement() {
+        mStartTimePoint = TimePoint{};
+    }
+
     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{};
 };
 
 //---------------------------------------------------------------------------