tqcq/sled
1
0
Fork 0
Code Issues Pull Requests Actions Projects Releases Wiki Activity

feat update
Some checks failed
linux-x64-gcc / linux-gcc (Release) (push) Failing after 1m28s
Details
linux-x64-gcc / linux-gcc (Debug) (push) Failing after 51s
Details

Browse Source
This commit is contained in:
tqcq 2024-03-23 09:03:00 +08:00
parent 03a62901f2
commit e08d8b7984
4 changed files with 26 additions and 9 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
include/sled/task_queue/pending_task_safety_flag.h
View File

@ -4,12 +4,13 @@
* @license : MIT * @license : MIT
**/ **/
#pragma once
#ifndef SLED_TASK_QUEUE_PENDING_TASK_SAFETY_FLAG_H #ifndef SLED_TASK_QUEUE_PENDING_TASK_SAFETY_FLAG_H
#define SLED_TASK_QUEUE_PENDING_TASK_SAFETY_FLAG_H #define SLED_TASK_QUEUE_PENDING_TASK_SAFETY_FLAG_H
#pragma once
#include "sled/ref_counted_base.h" #include "sled/ref_counted_base.h"
#include "sled/scoped_refptr.h" #include "sled/scoped_refptr.h"
#include "sled/synchronization/sequence_checker.h"
#include <functional> #include <functional>
namespace sled { namespace sled {
@ -31,6 +32,7 @@ protected:
private: private:
static sled::scoped_refptr<PendingTaskSafetyFlag> CreateInternal(bool alive); static sled::scoped_refptr<PendingTaskSafetyFlag> CreateInternal(bool alive);
bool alive_ = true; bool alive_ = true;
SequenceChecker main_sequence_;
}; };
class ScopedTaskSafety final { class ScopedTaskSafety final {

6
include/sled/timer/task_queue_timeout.h
View File

@ -1,8 +1,9 @@
#pragma once
#include "sled/scoped_refptr.h"
#ifndef SLED_TIMER_QUEUE_TIMEOUT_H #ifndef SLED_TIMER_QUEUE_TIMEOUT_H
#define SLED_TIMER_QUEUE_TIMEOUT_H #define SLED_TIMER_QUEUE_TIMEOUT_H
#pragma once
#include "sled/scoped_refptr.h"
#include "sled/synchronization/sequence_checker.h"
#include "sled/task_queue/pending_task_safety_flag.h" #include "sled/task_queue/pending_task_safety_flag.h"
#include "sled/task_queue/task_queue_base.h" #include "sled/task_queue/task_queue_base.h"
#include "sled/timer/timeout.h" #include "sled/timer/timeout.h"
@ -45,6 +46,7 @@ private:
scoped_refptr<PendingTaskSafetyFlag> safety_flag_; scoped_refptr<PendingTaskSafetyFlag> safety_flag_;
}; };
sled::SequenceChecker thread_checker_;
sled::TaskQueueBase &task_queue_; sled::TaskQueueBase &task_queue_;
const std::function<TimeMs()> get_time_; const std::function<TimeMs()> get_time_;
const std::function<void(TimeoutID)> on_expired_; const std::function<void(TimeoutID)> on_expired_;

11
src/task_queue/pending_task_safety_flag.cc
View File

@ -18,30 +18,37 @@ PendingTaskSafetyFlag::Create()
sled::scoped_refptr<PendingTaskSafetyFlag> sled::scoped_refptr<PendingTaskSafetyFlag>
PendingTaskSafetyFlag::CreateDetached() PendingTaskSafetyFlag::CreateDetached()
{ {
return CreateInternal(true); scoped_refptr<PendingTaskSafetyFlag> safety_flag = CreateInternal(true);
safety_flag->main_sequence_.Detach();
return safety_flag;
} }
sled::scoped_refptr<PendingTaskSafetyFlag> sled::scoped_refptr<PendingTaskSafetyFlag>
PendingTaskSafetyFlag::CreateDetachedInactive() PendingTaskSafetyFlag::CreateDetachedInactive()
{ {
return CreateInternal(false); scoped_refptr<PendingTaskSafetyFlag> safety_flag = CreateInternal(false);
safety_flag->main_sequence_.Detach();
return safety_flag;
} }
void void
PendingTaskSafetyFlag::SetNotAlive() PendingTaskSafetyFlag::SetNotAlive()
{ {
SLED_DCHECK_RUN_ON(&main_sequence_);
alive_ = false; alive_ = false;
} }
void void
PendingTaskSafetyFlag::SetAlive() PendingTaskSafetyFlag::SetAlive()
{ {
SLED_DCHECK_RUN_ON(&main_sequence_);
alive_ = true; alive_ = true;
} }
bool bool
PendingTaskSafetyFlag::alive() const PendingTaskSafetyFlag::alive() const
{ {
SLED_DCHECK_RUN_ON(&main_sequence_);
return alive_; return alive_;
} }

14
src/timer/task_queue_timeout.cc
View File

@ -11,11 +11,16 @@ TaskQueueTimeoutFactory::TaskQueueTimeout::TaskQueueTimeout(TaskQueueTimeoutFact
safety_flag_(PendingTaskSafetyFlag::Create()) safety_flag_(PendingTaskSafetyFlag::Create())
{} {}
TaskQueueTimeoutFactory::TaskQueueTimeout::~TaskQueueTimeout() { safety_flag_->SetNotAlive(); } TaskQueueTimeoutFactory::TaskQueueTimeout::~TaskQueueTimeout()
{
SLED_DCHECK_RUN_ON(&parent_.thread_checker_);
safety_flag_->SetNotAlive();
}
void void
TaskQueueTimeoutFactory::TaskQueueTimeout::Start(DurationMs duration_ms, TimeoutID timeout_id) TaskQueueTimeoutFactory::TaskQueueTimeout::Start(DurationMs duration_ms, TimeoutID timeout_id)
{ {
SLED_DCHECK_RUN_ON(&parent_.thread_checker_);
ASSERT(timeout_expiration_ == std::numeric_limits<TimeMs>::max(), ""); ASSERT(timeout_expiration_ == std::numeric_limits<TimeMs>::max(), "");
timeout_expiration_ = parent_.get_time_() + duration_ms; timeout_expiration_ = parent_.get_time_() + duration_ms;
timeout_id_ = timeout_id; timeout_id_ = timeout_id;
@ -36,10 +41,9 @@ TaskQueueTimeoutFactory::TaskQueueTimeout::Start(DurationMs duration_ms, Timeout
precision_, precision_,
SafeTask(safety_flag_, SafeTask(safety_flag_,
[timeout_id, this]() { [timeout_id, this]() {
// if (timeout_id != this->timeout_id_) { return; }
LOGV("timer", "Timeout expired: {}", timeout_id); LOGV("timer", "Timeout expired: {}", timeout_id);
// FIXME: this is a bug, the posted_task_expiration_ should be reset to max SLED_DCHECK_RUN_ON(&parent_.thread_checker_);
ASSERT(posted_task_expiration_ != std::numeric_limits<TimeMs>::max(), ""); DCHECK(posted_task_expiration_ != std::numeric_limits<TimeMs>::max(), "");
posted_task_expiration_ = std::numeric_limits<TimeMs>::max(); posted_task_expiration_ = std::numeric_limits<TimeMs>::max();
if (timeout_expiration_ == std::numeric_limits<TimeMs>::max()) { if (timeout_expiration_ == std::numeric_limits<TimeMs>::max()) {
@ -67,6 +71,8 @@ TaskQueueTimeoutFactory::TaskQueueTimeout::Start(DurationMs duration_ms, Timeout
void void
TaskQueueTimeoutFactory::TaskQueueTimeout::Stop() TaskQueueTimeoutFactory::TaskQueueTimeout::Stop()
{ {
SLED_DCHECK_RUN_ON(&parent_.thread_checker_);
timeout_expiration_ = std::numeric_limits<TimeMs>::max(); timeout_expiration_ = std::numeric_limits<TimeMs>::max();
} }