now using erease_if in scheduler where usable

more branch predictor hints

Author: BestITUserEUW

include/oryx/chron/scheduler.hpp

@@ -25,7 +25,7 @@ class Scheduler {
 
     auto AddSchedule(std::string name, std::string_view cron_expr, TaskFn work) -> bool {
         auto task = MakeTask(std::move(name), cron_expr, std::move(work));
-        if (!task) {
+        if (!task) [[unlikely]] {
             return false;
         }
 
@@ -36,18 +36,20 @@ class Scheduler {
     }
 
     template <typename F>
-    auto AddScheduleBatch(F&& fn, std::optional<size_t> num_tasks = std::nullopt) -> bool {
+    auto AddScheduleBatch(F&& fn, std::optional<std::size_t> num_tasks = {}) -> bool {
         std::vector<Task> tasks;
         if (num_tasks) tasks.reserve(num_tasks.value());
         auto add_schedule = [this, &tasks](std::string name, std::string_view cron_expr, TaskFn work) -> bool {
             auto task = MakeTask(std::move(name), cron_expr, work);
-            if (!task) return false;
+            if (!task) [[unlikely]] {
+                return false;
+            }
             tasks.emplace_back(std::move(task.value()));
             return true;
         };
 
         std::invoke(fn, std::move(add_schedule));
-        if (tasks.empty()) {
+        if (tasks.empty()) [[unlikely]] {
             return false;
         }
 
@@ -63,23 +65,19 @@ class Scheduler {
         tasks_.clear();
     }
 
-    void RemoveSchedule(const std::string& name) {
+    void RemoveSchedule(std::string_view name) {
         std::lock_guard lock{tasks_mtx_};
-        auto it = std::ranges::find_if(tasks_, [&name](const Task& to_compare) { return name == to_compare; });
-        if (it != tasks_.end()) {
-            tasks_.erase(it);
-        }
+        std::erase_if(tasks_, [name](const Task& t) { return t == name; });
     }
 
     void RecalculateSchedules() {
         std::lock_guard lock{tasks_mtx_};
         for (auto& task : tasks_) task.CalculateNext(clock_.Now() + std::chrono::seconds(1));
     }
 
-    auto Tick(TimePoint now) -> size_t {
+    auto Tick(TimePoint now) -> std::size_t {
         std::lock_guard lock{tasks_mtx_};
 
-        size_t executed_count{};
         if (!first_tick_) [[likely]] {
             auto diff = now - last_tick_;
 
@@ -96,21 +94,19 @@ class Scheduler {
 
         last_tick_ = now;
         if (tasks_.empty()) {
-            return executed_count;
+            return 0;
         }
 
-        for (auto& task : tasks_) {
-            if (task.IsExpired(now)) {
-                task.Execute(now);
-                if (!task.CalculateNext(now + std::chrono::seconds(1))) {
-                    auto it = std::ranges::find_if(tasks_, [&task](const Task& t) { return task.GetName() == t; });
-                    if (it != tasks_.end()) {
-                        tasks_.erase(it);
-                    }
-                }
-                ++executed_count;
+        std::size_t executed_count{};
+        std::erase_if(tasks_, [&executed_count, now](Task& task) {
+            if (!task.IsExpired(now)) {
+                return false;
             }
-        }
+
+            task.Execute(now);
+            executed_count++;
+            return !task.CalculateNext(now + std::chrono::seconds(1));
+        });
 
         if (executed_count > 0) {
             UnsafeSortTasks();
@@ -119,19 +115,23 @@ class Scheduler {
         return executed_count;
     }
 
-    auto Tick() -> size_t { return Tick(clock_.Now()); }
+    auto Tick() -> std::size_t { return Tick(clock_.Now()); }
 
     auto TimeUntilNext() const -> Duration {
         std::lock_guard lock{tasks_mtx_};
         if (tasks_.empty()) {
-            return std::chrono::minutes::max();
+            return Duration::max();
         }
         return tasks_[0].TimeUntilExpiry(clock_.Now());
     }
 
     auto GetClock() -> ClockType& { return clock_; }
     auto GetParser() -> ParserType& { return parser_; }
-    auto GetNumTasks() const -> size_t { return tasks_.size(); }
+
+    auto GetNumTasks() const -> std::size_t {
+        std::lock_guard lock{tasks_mtx_};
+        return tasks_.size();
+    }
 
     auto GetTasksStatus() const -> std::vector<std::string> {
         std::vector<std::string> status{};
@@ -148,12 +148,12 @@ class Scheduler {
 private:
     auto MakeTask(std::string name, std::string_view cron_expr, TaskFn work) const -> std::optional<Task> {
         auto data = parser_(cron_expr);
-        if (!data) {
+        if (!data) [[unlikely]] {
             return std::nullopt;
         }
 
         Task task(std::move(name), Schedule(std::move(data.value())), std::move(work));
-        if (!task.CalculateNext(clock_.Now())) {
+        if (!task.CalculateNext(clock_.Now())) [[unlikely]] {
             return std::nullopt;
         }
         return task;

include/oryx/chron/task.hpp

@@ -19,7 +19,6 @@ class Task {
 public:
     Task(std::string name, Schedule schedule, TaskFn task);
 
-    auto operator=(const Task &) -> Task & = default;
     auto operator>(const Task &other) const -> bool { return next_schedule_ > other.next_schedule_; }
     auto operator<(const Task &other) const -> bool { return next_schedule_ < other.next_schedule_; }
 

src/parser.cpp

@@ -22,14 +22,15 @@ auto ExpressionParser::operator()(std::string_view cron_expression) const -> std
 
     if (!cron_expression.empty() && cron_expression[0] == '@') {
         auto it = std::ranges::find(kShortcuts, cron_expression, &DollarExprPair::expr);
-        if (it != kShortcuts.end()) {
+        if (it != kShortcuts.end()) [[likely]] {
             cron_expression = it->cron;
         }
     }
 
     bool valid{};
     ChronData data{};
-    if (auto match = ctre::match<R"#(^\s*(.*?)\s+(.*?)\s+(.*?)\s+(.*?)\s+(.*?)\s+(.*?)\s*$)#">(cron_expression)) {
+    if (auto match = ctre::match<R"#(^\s*(.*?)\s+(.*?)\s+(.*?)\s+(.*?)\s+(.*?)\s+(.*?)\s*$)#">(cron_expression))
+        [[likely]] {
         valid = details::Parser::ValidateNumeric<Seconds>(match.get<1>().to_view(), data.seconds);
         valid &= details::Parser::ValidateNumeric<Minutes>(match.get<2>().to_view(), data.minutes);
         valid &= details::Parser::ValidateNumeric<Hours>(match.get<3>().to_view(), data.hours);
@@ -41,7 +42,7 @@ auto ExpressionParser::operator()(std::string_view cron_expression) const -> std
         valid &= details::Parser::ValidateDateVsMonths(data);
     }
 
-    if (!valid) {
+    if (!valid) [[unlikely]] {
         return std::nullopt;
     }
     return data;

src/randomization.cpp

@@ -129,8 +129,9 @@ auto Randomization::Parse(std::string_view cron_schedule) -> std::optional<std::
     std::set<Months> month_range{};
     if (selected_value == kSelectedValueNone) {
         // Month is not specific, get the range.
-        bool success = details::Parser::ConvertFromStringRangeToNumberRange(match.get<5>().to_view(), month_range);
-        if (!success) return std::nullopt;
+        if (!details::Parser::ConvertFromStringRangeToNumberRange(match.get<5>().to_view(), month_range)) [[unlikely]] {
+            return std::nullopt;
+        }
     } else {
         month_range.emplace(static_cast<Months>(selected_value));
     }

src/task.cpp

@@ -52,7 +52,7 @@ auto Task::IsExpired(TimePoint now) const -> bool { return valid_ && now >= last
 auto Task::GetStatus(TimePoint now) const -> std::string {
     auto dt = Schedule::ToCalendarTime(next_schedule_);
     auto expires_in = duration_cast<milliseconds>(TimeUntilExpiry(now));
-    return std::format("'{}' expires in => {}-{}-{} {}:{}:{}", GetName(), expires_in, dt.year, dt.month, dt.day,
-                       dt.hour, dt.min, dt.sec);
+    return std::format("'{}' expires in => {}-{}-{} {}:{}:{}", name_, expires_in, dt.year, dt.month, dt.day, dt.hour,
+                       dt.min, dt.sec);
 }
 }  // namespace oryx::chron