diff options
19 files changed, 59 insertions, 127 deletions
diff --git a/storage/src/tests/storageframework/clock/timetest.cpp b/storage/src/tests/storageframework/clock/timetest.cpp index 0f18dc9ed3a..17625b4bf45 100644 --- a/storage/src/tests/storageframework/clock/timetest.cpp +++ b/storage/src/tests/storageframework/clock/timetest.cpp @@ -8,7 +8,6 @@ namespace storage::framework::defaultimplementation { TEST(TimeTest, testBasics) { - MicroSecTime timeMicros(1000*1000); MicroSecTime timeMicros2 = timeMicros; @@ -26,7 +25,8 @@ TEST(TimeTest, testCreatedFromClock) defaultimplementation::FakeClock clock; clock.setAbsoluteTimeInSeconds(600); - EXPECT_EQ(MicroSecTime(600 * 1000 * 1000), MicroSecTime(clock)); + EXPECT_EQ(vespalib::system_time(600s), clock.getSystemTime()); + EXPECT_EQ(vespalib::steady_time(600s), clock.getMonotonicTime()); } TEST(TimeTest, canAssignMicrosecondResolutionTimeToFakeClock) @@ -34,8 +34,9 @@ TEST(TimeTest, canAssignMicrosecondResolutionTimeToFakeClock) defaultimplementation::FakeClock clock; clock.setAbsoluteTimeInMicroSeconds(1234567); // 1.234567 seconds + EXPECT_EQ(vespalib::system_time(1234567us), clock.getSystemTime()); + EXPECT_EQ(vespalib::steady_time(1234567us), clock.getMonotonicTime()); // All non-microsec time points must necessarily be truncated. - EXPECT_EQ(MicroSecTime(1234567), MicroSecTime(clock)); } } diff --git a/storage/src/tests/visiting/visitormanagertest.cpp b/storage/src/tests/visiting/visitormanagertest.cpp index 7bf79bb19fa..a03e1437797 100644 --- a/storage/src/tests/visiting/visitormanagertest.cpp +++ b/storage/src/tests/visiting/visitormanagertest.cpp @@ -47,7 +47,7 @@ protected: std::unique_ptr<TestVisitorMessageSessionFactory> _messageSessionFactory; std::unique_ptr<TestServiceLayerApp> _node; std::unique_ptr<DummyStorageLink> _top; - VisitorManager* _manager; + VisitorManager* _manager{}; VisitorManagerTest() : _node(), _top(), _manager(nullptr) {} ~VisitorManagerTest() override; diff --git a/storage/src/vespa/storage/distributor/bucketgctimecalculator.cpp b/storage/src/vespa/storage/distributor/bucketgctimecalculator.cpp index 792530514b5..b1d8d61c173 100644 --- a/storage/src/vespa/storage/distributor/bucketgctimecalculator.cpp +++ b/storage/src/vespa/storage/distributor/bucketgctimecalculator.cpp @@ -2,20 +2,21 @@ #include "bucketgctimecalculator.h" +using vespalib::count_s; + namespace storage::distributor { bool BucketGcTimeCalculator::shouldGc(const document::BucketId& b, - std::chrono::seconds currentTime, - std::chrono::seconds lastRunAt) const + vespalib::duration currentTime, + vespalib::duration lastRunAt) const { - if (_checkInterval.count() == 0) { + if (count_s(_checkInterval) == 0) { return false; } - std::chrono::seconds gcPoint(_hasher.hash(b) % _checkInterval.count()); - std::chrono::seconds currentPeriodStart(currentTime - - (currentTime % _checkInterval)); - std::chrono::seconds newestValid(currentPeriodStart + gcPoint); + std::chrono::seconds gcPoint(_hasher.hash(b) % count_s(_checkInterval)); + vespalib::duration currentPeriodStart(currentTime - (currentTime % _checkInterval)); + vespalib::duration newestValid(currentPeriodStart + gcPoint); // Should GC have been started in current period? if (currentTime >= newestValid && lastRunAt < newestValid) { diff --git a/storage/src/vespa/storage/distributor/bucketgctimecalculator.h b/storage/src/vespa/storage/distributor/bucketgctimecalculator.h index f8d30b6e526..54abebc4152 100644 --- a/storage/src/vespa/storage/distributor/bucketgctimecalculator.h +++ b/storage/src/vespa/storage/distributor/bucketgctimecalculator.h @@ -1,8 +1,8 @@ // Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. #pragma once -#include <chrono> #include <vespa/document/bucket/bucketid.h> +#include <vespa/vespalib/util/time.h> namespace storage::distributor { @@ -35,19 +35,19 @@ public: }; BucketGcTimeCalculator(const BucketIdHasher& hasher, - std::chrono::seconds checkInterval) + vespalib::duration checkInterval) : _hasher(hasher), _checkInterval(checkInterval) { } bool shouldGc(const document::BucketId&, - std::chrono::seconds currentTime, - std::chrono::seconds lastRunAt) const; + vespalib::duration currentTime, + vespalib::duration lastRunAt) const; private: const BucketIdHasher& _hasher; - std::chrono::seconds _checkInterval; + vespalib::duration _checkInterval; }; } diff --git a/storage/src/vespa/storage/distributor/maintenance/node_maintenance_stats_tracker.h b/storage/src/vespa/storage/distributor/maintenance/node_maintenance_stats_tracker.h index 0e6c2bb23c2..deeef118685 100644 --- a/storage/src/vespa/storage/distributor/maintenance/node_maintenance_stats_tracker.h +++ b/storage/src/vespa/storage/distributor/maintenance/node_maintenance_stats_tracker.h @@ -1,11 +1,9 @@ // Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. #pragma once -#include <chrono> #include <unordered_map> -#include <iosfwd> -#include <stdint.h> #include <vespa/document/bucket/bucketspace.h> +#include <vespa/vespalib/util/time.h> namespace storage::distributor { @@ -53,7 +51,7 @@ public: private: PerNodeStats _node_stats; NodeMaintenanceStats _total_stats; - std::chrono::seconds _max_observed_time_since_last_gc; + vespalib::duration _max_observed_time_since_last_gc; static const NodeMaintenanceStats _emptyNodeMaintenanceStats; @@ -86,7 +84,7 @@ public: ++_total_stats.total; } - void update_observed_time_since_last_gc(std::chrono::seconds time_since_gc) noexcept { + void update_observed_time_since_last_gc(vespalib::duration time_since_gc) noexcept { _max_observed_time_since_last_gc = std::max(time_since_gc, _max_observed_time_since_last_gc); } @@ -116,7 +114,7 @@ public: return _total_stats; } - std::chrono::seconds max_observed_time_since_last_gc() const noexcept { + vespalib::duration max_observed_time_since_last_gc() const noexcept { return _max_observed_time_since_last_gc; } diff --git a/storage/src/vespa/storage/distributor/pendingclusterstate.cpp b/storage/src/vespa/storage/distributor/pendingclusterstate.cpp index b9639f54469..bea2cef5475 100644 --- a/storage/src/vespa/storage/distributor/pendingclusterstate.cpp +++ b/storage/src/vespa/storage/distributor/pendingclusterstate.cpp @@ -212,7 +212,7 @@ PendingClusterState::requestNode(BucketSpaceAndNode bucketSpaceAndNode) PendingClusterState::Summary::Summary(const std::string& prevClusterState, const std::string& newClusterState, - uint32_t processingTime) + vespalib::duration processingTime) : _prevClusterState(prevClusterState), _newClusterState(newClusterState), _processingTime(processingTime) @@ -306,7 +306,7 @@ PendingClusterState::getSummary() const { return Summary(getPrevClusterStateBundleString(), getNewClusterStateBundleString(), - (_clock.getTimeInMicros().getTime() - _creationTimestamp)); + std::chrono::microseconds(vespalib::count_us(_clock.getSystemTime().time_since_epoch()) - _creationTimestamp)); } PendingBucketSpaceDbTransition& diff --git a/storage/src/vespa/storage/distributor/pendingclusterstate.h b/storage/src/vespa/storage/distributor/pendingclusterstate.h index 8af08e1ba4d..a72fd185600 100644 --- a/storage/src/vespa/storage/distributor/pendingclusterstate.h +++ b/storage/src/vespa/storage/distributor/pendingclusterstate.h @@ -6,7 +6,6 @@ #include "clusterinformation.h" #include <vespa/storageapi/message/bucket.h> #include <vespa/storageapi/message/state.h> -#include <vespa/storageframework/generic/clock/clock.h> #include <vespa/vdslib/state/cluster_state_bundle.h> #include <vespa/vespalib/util/xmlserializable.h> #include <vespa/vespalib/stllike/hash_map.h> @@ -14,6 +13,8 @@ #include <unordered_map> #include <deque> +namespace storage::framework { struct Clock; } + namespace storage::distributor { class BucketSpaceStateMap; @@ -30,16 +31,16 @@ public: using OutdatedNodes = dbtransition::OutdatedNodes; using OutdatedNodesMap = dbtransition::OutdatedNodesMap; struct Summary { - Summary(const std::string& prevClusterState, const std::string& newClusterState, uint32_t processingTime); + Summary(const std::string& prevClusterState, const std::string& newClusterState, vespalib::duration processingTime); Summary(const Summary &); Summary & operator = (const Summary &); - Summary(Summary &&) = default; - Summary & operator = (Summary &&) = default; + Summary(Summary &&) noexcept = default; + Summary & operator = (Summary &&) noexcept = default; ~Summary(); std::string _prevClusterState; std::string _newClusterState; - uint32_t _processingTime; + vespalib::duration _processingTime; }; static std::unique_ptr<PendingClusterState> createForClusterStateChange( diff --git a/storage/src/vespa/storage/distributor/statechecker.cpp b/storage/src/vespa/storage/distributor/statechecker.cpp index 91acd494a7a..eaff1f0b780 100644 --- a/storage/src/vespa/storage/distributor/statechecker.cpp +++ b/storage/src/vespa/storage/distributor/statechecker.cpp @@ -72,8 +72,7 @@ StateChecker::Context::Context(const DistributorNodeContext& node_ctx_in, pending_cluster_state(op_ctx_in.pending_cluster_state_or_null(bucket_.getBucketSpace())), distributorConfig(op_ctx_in.distributor_config()), distribution(distributorBucketSpace.getDistribution()), - gcTimeCalculator(op_ctx_in.bucket_id_hasher(), - std::chrono::duration_cast<std::chrono::seconds>(distributorConfig.getGarbageCollectionInterval())), + gcTimeCalculator(op_ctx_in.bucket_id_hasher(), distributorConfig.getGarbageCollectionInterval()), node_ctx(node_ctx_in), op_ctx(op_ctx_in), db(distributorBucketSpace.getBucketDatabase()), diff --git a/storage/src/vespa/storage/distributor/statecheckers.cpp b/storage/src/vespa/storage/distributor/statecheckers.cpp index 14cc2509cab..f9c26bf113e 100644 --- a/storage/src/vespa/storage/distributor/statecheckers.cpp +++ b/storage/src/vespa/storage/distributor/statecheckers.cpp @@ -1130,7 +1130,7 @@ GarbageCollectionStateChecker::garbage_collection_disabled(const Context& c) noe } bool -GarbageCollectionStateChecker::needs_garbage_collection(const Context& c, std::chrono::seconds time_since_epoch) +GarbageCollectionStateChecker::needs_garbage_collection(const Context& c, vespalib::duration time_since_epoch) { if (c.entry->getNodeCount() == 0) { return false; @@ -1148,20 +1148,18 @@ GarbageCollectionStateChecker::check(Context& c) const if (garbage_collection_disabled(c)) { return Result::noMaintenanceNeeded(); } - const std::chrono::seconds now(c.node_ctx.clock().getTimeInSeconds().getTime()); + const vespalib::duration now(c.node_ctx.clock().getSystemTime().time_since_epoch()); const std::chrono::seconds last_run_at(c.entry->getLastGarbageCollectionTime()); c.stats.update_observed_time_since_last_gc(now - last_run_at); if (needs_garbage_collection(c, now)) { - auto op = std::make_unique<GarbageCollectionOperation>( - c.node_ctx, - BucketAndNodes(c.getBucket(), c.entry->getNodes())); + auto op = std::make_unique<GarbageCollectionOperation>(c.node_ctx, BucketAndNodes(c.getBucket(), c.entry->getNodes())); vespalib::asciistream reason; reason << "[Needs garbage collection: Last check at " << c.entry->getLastGarbageCollectionTime() << ", current time " - << now.count() + << vespalib::count_s(now) << ", configured interval " << vespalib::to_s(c.distributorConfig.getGarbageCollectionInterval()) << "]"; diff --git a/storage/src/vespa/storage/distributor/statecheckers.h b/storage/src/vespa/storage/distributor/statecheckers.h index c1579cb5eda..b6cd5ba0534 100644 --- a/storage/src/vespa/storage/distributor/statecheckers.h +++ b/storage/src/vespa/storage/distributor/statecheckers.h @@ -88,7 +88,7 @@ public: const char* getName() const noexcept override { return "GarbageCollection"; } private: static bool garbage_collection_disabled(const Context& c) noexcept; - static bool needs_garbage_collection(const Context& c, std::chrono::seconds time_since_epoch); + static bool needs_garbage_collection(const Context& c, vespalib::duration time_since_epoch); }; } diff --git a/storage/src/vespa/storage/distributor/top_level_bucket_db_updater.cpp b/storage/src/vespa/storage/distributor/top_level_bucket_db_updater.cpp index 16be7733c1a..45d7bfc992c 100644 --- a/storage/src/vespa/storage/distributor/top_level_bucket_db_updater.cpp +++ b/storage/src/vespa/storage/distributor/top_level_bucket_db_updater.cpp @@ -493,7 +493,7 @@ TopLevelBucketDBUpdater::report_xml_status(vespalib::xml::XmlOutputStream& xos, xos << XmlTag("change") << XmlAttribute("from", i->_prevClusterState) << XmlAttribute("to", i->_newClusterState) - << XmlAttribute("processingtime", i->_processingTime) + << XmlAttribute("processingtime", vespalib::count_us(i->_processingTime)) << XmlEndTag(); } xos << XmlEndTag() diff --git a/storage/src/vespa/storage/persistence/types.h b/storage/src/vespa/storage/persistence/types.h index 60de7dea4fd..c3d7f9eab6d 100644 --- a/storage/src/vespa/storage/persistence/types.h +++ b/storage/src/vespa/storage/persistence/types.h @@ -1,29 +1,18 @@ // Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. #pragma once -#include <iosfwd> -#include <vespa/document/bucket/bucketid.h> -#include <vespa/document/base/documentid.h> -#include <vespa/storage/bucketdb/storbucketdb.h> #include <vespa/storageapi/buckets/bucketinfo.h> -#include <vespa/storageapi/defs.h> -#include <vespa/vespalib/stllike/string.h> -#include <vespa/storageframework/generic/clock/time.h> +#include <memory> namespace storage { class MessageTracker; struct Types { - using BucketId = document::BucketId; - using DocumentId = document::DocumentId; - using GlobalId = document::GlobalId; - using Timestamp = framework::MicroSecTime; - using String = vespalib::string; using BucketInfo = api::BucketInfo; using MessageTrackerUP = std::unique_ptr<MessageTracker>; protected: - ~Types() {} // Noone should refer to objects as Types objects + ~Types() = default; // Noone should refer to objects as Types objects }; } // storage diff --git a/storage/src/vespa/storageframework/defaultimplementation/clock/fakeclock.cpp b/storage/src/vespa/storageframework/defaultimplementation/clock/fakeclock.cpp index 331b2113838..5221d8a112e 100644 --- a/storage/src/vespa/storageframework/defaultimplementation/clock/fakeclock.cpp +++ b/storage/src/vespa/storageframework/defaultimplementation/clock/fakeclock.cpp @@ -3,20 +3,20 @@ namespace storage::framework::defaultimplementation { -FakeClock::FakeClock(Mode m, framework::MicroSecTime startTime) +FakeClock::FakeClock(Mode m, vespalib::duration startTime) : _mode(m), _absoluteTime(startTime), _cycleCount(0) { } -framework::MicroSecTime +int64_t FakeClock::getTimeInMicros() const { std::lock_guard guard(_lock); - if (_mode == FAKE_ABSOLUTE) return _absoluteTime; - MicroSecTime tmp(_absoluteTime); - tmp += framework::MicroSecTime(1000000 * _cycleCount++); - return tmp; + if (_mode == FAKE_ABSOLUTE) return vespalib::count_us(_absoluteTime); + vespalib::duration tmp(_absoluteTime); + tmp += std::chrono::seconds(_cycleCount++); + return vespalib::count_us(tmp); } } diff --git a/storage/src/vespa/storageframework/defaultimplementation/clock/fakeclock.h b/storage/src/vespa/storageframework/defaultimplementation/clock/fakeclock.h index b97c2bd92c1..ed41014c443 100644 --- a/storage/src/vespa/storageframework/defaultimplementation/clock/fakeclock.h +++ b/storage/src/vespa/storageframework/defaultimplementation/clock/fakeclock.h @@ -22,13 +22,12 @@ struct FakeClock : public framework::Clock { private: Mode _mode; - framework::MicroSecTime _absoluteTime; + vespalib::duration _absoluteTime; mutable time_t _cycleCount; mutable std::mutex _lock; public: - FakeClock(Mode m = FAKE_ABSOLUTE, - framework::MicroSecTime startTime = framework::MicroSecTime(1)); + explicit FakeClock(Mode m = FAKE_ABSOLUTE, vespalib::duration startTime = 1us); void setMode(Mode m) { std::lock_guard guard(_lock); @@ -38,39 +37,39 @@ public: virtual void setAbsoluteTimeInSeconds(uint32_t seconds) { std::lock_guard guard(_lock); - _absoluteTime = framework::MicroSecTime(seconds * uint64_t(1000000)); + _absoluteTime = std::chrono::seconds(seconds); _cycleCount = 0; _mode = FAKE_ABSOLUTE; } virtual void setAbsoluteTimeInMicroSeconds(uint64_t usecs) { std::lock_guard guard(_lock); - _absoluteTime = framework::MicroSecTime(usecs); + _absoluteTime = std::chrono::microseconds(usecs); _cycleCount = 0; _mode = FAKE_ABSOLUTE; } virtual void addMilliSecondsToTime(uint64_t ms) { std::lock_guard guard(_lock); - _absoluteTime += framework::MicroSecTime(ms * 1000); + _absoluteTime += std::chrono::milliseconds(ms); } virtual void addSecondsToTime(uint32_t nr) { std::lock_guard guard(_lock); - _absoluteTime += framework::MicroSecTime(nr * uint64_t(1000000)); + _absoluteTime += std::chrono::seconds(nr); } - framework::MicroSecTime getTimeInMicros() const override ; + int64_t getTimeInMicros() const; framework::SecondTime getTimeInSeconds() const override { - return getTimeInMicros().getSeconds(); + return SecondTime(vespalib::count_s(getSystemTime().time_since_epoch())); } vespalib::system_time getSystemTime() const override { // For simplicity, assume fake monotonic time follows fake wall clock. - return vespalib::system_time(std::chrono::microseconds(getTimeInMicros().getTime())); + return vespalib::system_time(std::chrono::microseconds(getTimeInMicros())); } vespalib::steady_time getMonotonicTime() const override { // For simplicity, assume fake monotonic time follows fake wall clock. - return vespalib::steady_time(std::chrono::microseconds(getTimeInMicros().getTime())); + return vespalib::steady_time(std::chrono::microseconds(getTimeInMicros())); } }; diff --git a/storage/src/vespa/storageframework/defaultimplementation/clock/realclock.cpp b/storage/src/vespa/storageframework/defaultimplementation/clock/realclock.cpp index 2e2894de9d5..d26e6a43ed0 100644 --- a/storage/src/vespa/storageframework/defaultimplementation/clock/realclock.cpp +++ b/storage/src/vespa/storageframework/defaultimplementation/clock/realclock.cpp @@ -5,17 +5,10 @@ namespace storage::framework::defaultimplementation { -MicroSecTime -RealClock::getTimeInMicros() const { - struct timeval mytime; - gettimeofday(&mytime, 0); - return MicroSecTime(mytime.tv_sec * 1000000llu + mytime.tv_usec); -} - SecondTime RealClock::getTimeInSeconds() const { struct timeval mytime; - gettimeofday(&mytime, 0); + gettimeofday(&mytime, nullptr); return SecondTime(mytime.tv_sec); } diff --git a/storage/src/vespa/storageframework/defaultimplementation/clock/realclock.h b/storage/src/vespa/storageframework/defaultimplementation/clock/realclock.h index dc4884b4439..a1f455f13a6 100644 --- a/storage/src/vespa/storageframework/defaultimplementation/clock/realclock.h +++ b/storage/src/vespa/storageframework/defaultimplementation/clock/realclock.h @@ -14,7 +14,6 @@ namespace storage::framework::defaultimplementation { struct RealClock : public Clock { - MicroSecTime getTimeInMicros() const override; SecondTime getTimeInSeconds() const override; vespalib::steady_time getMonotonicTime() const override; vespalib::system_time getSystemTime() const override; diff --git a/storage/src/vespa/storageframework/generic/clock/clock.h b/storage/src/vespa/storageframework/generic/clock/clock.h index 21d6bc589a6..2e431ba8a17 100644 --- a/storage/src/vespa/storageframework/generic/clock/clock.h +++ b/storage/src/vespa/storageframework/generic/clock/clock.h @@ -23,12 +23,11 @@ struct Clock { virtual ~Clock() = default; - virtual MicroSecTime getTimeInMicros() const = 0; - virtual SecondTime getTimeInSeconds() const = 0; + [[nodiscard]] virtual SecondTime getTimeInSeconds() const = 0; // Time point resolution is intentionally not defined here. - virtual vespalib::steady_time getMonotonicTime() const = 0; - virtual vespalib::system_time getSystemTime() const = 0; + [[nodiscard]] virtual vespalib::steady_time getMonotonicTime() const = 0; + [[nodiscard]] virtual vespalib::system_time getSystemTime() const = 0; }; } diff --git a/storage/src/vespa/storageframework/generic/clock/time.cpp b/storage/src/vespa/storageframework/generic/clock/time.cpp index f5426901e4c..64434779c91 100644 --- a/storage/src/vespa/storageframework/generic/clock/time.cpp +++ b/storage/src/vespa/storageframework/generic/clock/time.cpp @@ -74,12 +74,6 @@ getTimeString(uint64_t microSecondTime, TimeFormat format) return ost.str(); } -uint64_t -getRawMicroTime(const Clock& clock) -{ - return clock.getTimeInMicros().getTime(); -} - template std::ostream& operator<< <MicroSecTime, 1>(std::ostream&, const Time<MicroSecTime, 1> &); template std::ostream& operator<< <SecondTime, 1000000>(std::ostream&, const Time<SecondTime, 1000000> &); diff --git a/storage/src/vespa/storageframework/generic/clock/time.h b/storage/src/vespa/storageframework/generic/clock/time.h index 6f7cb490355..8e2a654b3ed 100644 --- a/storage/src/vespa/storageframework/generic/clock/time.h +++ b/storage/src/vespa/storageframework/generic/clock/time.h @@ -34,10 +34,6 @@ vespalib::string getTimeString(uint64_t microSecondTime, TimeFormat format); // TODO deprecate framework time point and duration classes in favor of // using std::chrono. -// As this class can't include clock, this utility function can be used in -// header implementation to get actual time. -uint64_t getRawMicroTime(const Clock&); - /** * Class containing common functionality for the various time instances. Try to * make time instances as easy to use as possible, without creating risk of @@ -54,8 +50,6 @@ protected: public: [[nodiscard]] uint64_t getTime() const { return _time; } - void setTime(uint64_t t) { _time = t; } - [[nodiscard]] bool isSet() const { return (_time != 0); } Type& operator-=(const Type& o) { _time -= o._time; return static_cast<Type&>(*this); } Type& operator+=(const Type& o) { _time += o._time; return static_cast<Type&>(*this); } @@ -72,30 +66,15 @@ public: } static Type max() { return Type(std::numeric_limits<uint64_t>::max()); } - static Type min() { return Type(0); } }; -template<typename Type, typename Number> -Type& operator/(Type& type, Number n) { - type.setTime(type.getTime() / n); - return type; -} - -template<typename Type, typename Number> -Type& operator*(Type& type, Number n) { - type.setTime(type.getTime() * n); - return type; -} - template<typename Type, int MPU> std::ostream& operator<<(std::ostream& out, const Time<Type, MPU>& t); template<typename Type, int MPU> vespalib::asciistream& operator<<(vespalib::asciistream& out, const Time<Type, MPU>& t); -struct MicroSecTime; - /** * \class storage::framework::SecondTime * \ingroup clock @@ -108,8 +87,6 @@ struct MicroSecTime; */ struct SecondTime : public Time<SecondTime, 1000000> { explicit SecondTime(uint64_t t = 0) : Time<SecondTime, 1000000>(t) {} - explicit SecondTime(const Clock& clock) - : Time<SecondTime, 1000000>(getRawMicroTime(clock) / 1000000) {} }; /** @@ -124,24 +101,8 @@ struct SecondTime : public Time<SecondTime, 1000000> { */ struct MicroSecTime : public Time<MicroSecTime, 1> { explicit MicroSecTime(uint64_t t = 0) : Time<MicroSecTime, 1>(t) {} - explicit MicroSecTime(const Clock& clock) - : Time<MicroSecTime, 1>(getRawMicroTime(clock)) {} [[nodiscard]] SecondTime getSeconds() const { return SecondTime(getTime() / 1000000); } }; -inline MicroSecTime -operator + (MicroSecTime a, MicroSecTime b) { - MicroSecTime result(a); - result += b; - return result; -} - -inline MicroSecTime -operator - (MicroSecTime a, MicroSecTime b) { - MicroSecTime result(a); - result -= b; - return result; -} - } |