Line data    Source code

       1             : /****************************************************************************/
       2             : // Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
       3             : // Copyright (C) 2020-2024 German Aerospace Center (DLR) and others.
       4             : // This program and the accompanying materials are made available under the
       5             : // terms of the Eclipse Public License 2.0 which is available at
       6             : // https://www.eclipse.org/legal/epl-2.0/
       7             : // This Source Code may also be made available under the following Secondary
       8             : // Licenses when the conditions for such availability set forth in the Eclipse
       9             : // Public License 2.0 are satisfied: GNU General Public License, version 2
      10             : // or later which is available at
      11             : // https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
      12             : // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
      13             : /****************************************************************************/
      14             : /// @file    StopWatch.h
      15             : /// @author  Michael Behrisch
      16             : /// @date    2020-09-09
      17             : ///
      18             : // A stop watch for keeping time,
      19             : // based on https://github.com/vukis/Cpp-Utilities/tree/master/ThreadPool
      20             : /****************************************************************************/
      21             : #pragma once
      22             : #include <config.h>
      23             : 
      24             : #include <vector>
      25             : #include <chrono>
      26             : #include <numeric>
      27             : 
      28             : template < typename TimeT = std::chrono::milliseconds, typename ClockT =
      29             : #if defined(_MSC_VER) && _MSC_VER == 1800
      30             :            std::chrono::system_clock
      31             : #else
      32             :            std::chrono::steady_clock
      33             : #endif
      34             :            >
      35     5172798 : class StopWatch {
      36             : public:
      37     5240772 :     StopWatch(const bool calibrate = false) : myTimingCost(0) {
      38     5240772 :         if (calibrate) {
      39           0 :             myStart = ClockT::now();
      40           0 :             for (int i = 0; i < 1000; i++) {
      41           0 :                 myEnd = ClockT::now();
      42             :             }
      43           0 :             myTimingCost = std::chrono::duration_cast<TimeT>(myEnd - myStart) / 1000;
      44             :         }
      45             :         start();
      46     5240772 :     }
      47             : 
      48             :     void start() {
      49     5240772 :         myStart = myEnd = ClockT::now();
      50             :     }
      51             : 
      52             :     long long int stop() {
      53             :         myEnd = ClockT::now();
      54             :         return elapsed();
      55             :     }
      56             : 
      57             :     long long int elapsed() const {
      58             :         const TimeT& delta = std::chrono::duration_cast<TimeT>(myEnd - myStart) - (2 * myTimingCost);
      59             :         myHistory.push_back(delta);
      60             :         return (long long int)delta.count();
      61             :     }
      62             : 
      63             :     void add(const StopWatch<TimeT, ClockT>& other) {
      64             :         myHistory.insert(myHistory.end(), other.myHistory.begin(), other.myHistory.end());
      65             :     }
      66             : 
      67             :     const std::vector<TimeT>& getHistory() const {
      68             :         return myHistory;
      69             :     }
      70             : 
      71             :     long long int getAverage() const {
      72             :         return (long long int)(std::accumulate(myHistory.begin(), myHistory.end(), TimeT{}) / myHistory.size()).count();
      73             :     }
      74             : 
      75             :     long long int getTotal() const {
      76             :         return (long long int)(std::accumulate(myHistory.begin(), myHistory.end(), TimeT{})).count();
      77             :     }
      78             : 
      79             : private:
      80             :     std::chrono::time_point<ClockT> myStart;
      81             :     std::chrono::time_point<ClockT> myEnd;
      82             :     TimeT myTimingCost;
      83             :     mutable std::vector<TimeT>      myHistory;
      84             : };