tdactor: remove actor2
GitOrigin-RevId: bcf3e8687088353cb83b32bfcddc6f2a4acf14d8
This commit is contained in:
Arseny Smirnov
parent
4594885e61
commit
5999b98fa7
@ -7,8 +7,6 @@ set(TDACTOR_SOURCE
|
|||||||
td/actor/MultiPromise.cpp
|
td/actor/MultiPromise.cpp
|
||||||
td/actor/Timeout.cpp
|
td/actor/Timeout.cpp
|
||||||
|
|
||||||
td/actor/impl2/Scheduler.cpp
|
|
||||||
|
|
||||||
td/actor/impl/Actor-decl.h
|
td/actor/impl/Actor-decl.h
|
||||||
td/actor/impl/Actor.h
|
td/actor/impl/Actor.h
|
||||||
td/actor/impl/ActorId-decl.h
|
td/actor/impl/ActorId-decl.h
|
||||||
@ -29,16 +27,9 @@ set(TDACTOR_SOURCE
|
|||||||
td/actor/SleepActor.h
|
td/actor/SleepActor.h
|
||||||
td/actor/Timeout.h
|
td/actor/Timeout.h
|
||||||
td/actor/actor.h
|
td/actor/actor.h
|
||||||
|
|
||||||
td/actor/impl2/ActorLocker.h
|
|
||||||
td/actor/impl2/ActorSignals.h
|
|
||||||
td/actor/impl2/ActorState.h
|
|
||||||
td/actor/impl2/Scheduler.h
|
|
||||||
td/actor/impl2/SchedulerId.h
|
|
||||||
)
|
)
|
||||||
|
|
||||||
set(TDACTOR_TEST_SOURCE
|
set(TDACTOR_TEST_SOURCE
|
||||||
${CMAKE_CURRENT_SOURCE_DIR}/test/actors_impl2.cpp
|
|
||||||
${CMAKE_CURRENT_SOURCE_DIR}/test/actors_main.cpp
|
${CMAKE_CURRENT_SOURCE_DIR}/test/actors_main.cpp
|
||||||
${CMAKE_CURRENT_SOURCE_DIR}/test/actors_simple.cpp
|
${CMAKE_CURRENT_SOURCE_DIR}/test/actors_simple.cpp
|
||||||
${CMAKE_CURRENT_SOURCE_DIR}/test/actors_workers.cpp
|
${CMAKE_CURRENT_SOURCE_DIR}/test/actors_workers.cpp
|
||||||
|
|||||||
@ -1,117 +0,0 @@
|
|||||||
//
|
|
||||||
// Copyright Aliaksei Levin (levlam@telegram.org), Arseny Smirnov (arseny30@gmail.com) 2014-2018
|
|
||||||
//
|
|
||||||
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
|
||||||
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
|
||||||
//
|
|
||||||
#pragma once
|
|
||||||
|
|
||||||
#include "td/actor/impl2/ActorSignals.h"
|
|
||||||
#include "td/actor/impl2/ActorState.h"
|
|
||||||
|
|
||||||
#include "td/utils/logging.h"
|
|
||||||
|
|
||||||
#include <atomic>
|
|
||||||
|
|
||||||
namespace td {
|
|
||||||
namespace actor2 {
|
|
||||||
class ActorLocker {
|
|
||||||
public:
|
|
||||||
struct Options {
|
|
||||||
Options() {
|
|
||||||
}
|
|
||||||
bool can_execute_paused = false;
|
|
||||||
bool is_shared = true;
|
|
||||||
Options &with_can_execute_paused(bool new_can_execute_paused) {
|
|
||||||
can_execute_paused = new_can_execute_paused;
|
|
||||||
return *this;
|
|
||||||
}
|
|
||||||
Options &with_is_shared(bool new_is_shared) {
|
|
||||||
is_shared = new_is_shared;
|
|
||||||
return *this;
|
|
||||||
}
|
|
||||||
};
|
|
||||||
explicit ActorLocker(ActorState *state, Options options = {})
|
|
||||||
: state_(state), flags_(state->get_flags_unsafe()), new_flags_{}, options_{options} {
|
|
||||||
}
|
|
||||||
bool try_lock() {
|
|
||||||
CHECK(!own_lock());
|
|
||||||
while (!can_try_add_signals()) {
|
|
||||||
new_flags_ = flags_;
|
|
||||||
new_flags_.set_locked(true);
|
|
||||||
new_flags_.clear_signals();
|
|
||||||
if (state_->state_.compare_exchange_strong(flags_.raw_ref(), new_flags_.raw(), std::memory_order_acq_rel)) {
|
|
||||||
own_lock_ = true;
|
|
||||||
return true;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
bool try_unlock(ActorState::Flags flags) {
|
|
||||||
CHECK(!flags.is_locked());
|
|
||||||
CHECK(own_lock());
|
|
||||||
// can't unlock with signals set
|
|
||||||
//CHECK(!flags.has_signals());
|
|
||||||
|
|
||||||
flags_ = flags;
|
|
||||||
//try unlock
|
|
||||||
if (state_->state_.compare_exchange_strong(new_flags_.raw_ref(), flags.raw(), std::memory_order_acq_rel)) {
|
|
||||||
own_lock_ = false;
|
|
||||||
return true;
|
|
||||||
}
|
|
||||||
|
|
||||||
// read all signals
|
|
||||||
flags.set_locked(true);
|
|
||||||
flags.clear_signals();
|
|
||||||
do {
|
|
||||||
flags_.add_signals(new_flags_.get_signals());
|
|
||||||
} while (!state_->state_.compare_exchange_strong(new_flags_.raw_ref(), flags.raw(), std::memory_order_acq_rel));
|
|
||||||
new_flags_ = flags;
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
|
|
||||||
bool try_add_signals(ActorSignals signals) {
|
|
||||||
CHECK(!own_lock());
|
|
||||||
CHECK(can_try_add_signals());
|
|
||||||
new_flags_ = flags_;
|
|
||||||
new_flags_.add_signals(signals);
|
|
||||||
return state_->state_.compare_exchange_strong(flags_.raw_ref(), new_flags_.raw(), std::memory_order_acq_rel);
|
|
||||||
}
|
|
||||||
bool add_signals(ActorSignals signals) {
|
|
||||||
CHECK(!own_lock());
|
|
||||||
while (true) {
|
|
||||||
if (can_try_add_signals()) {
|
|
||||||
if (try_add_signals(signals)) {
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
} else {
|
|
||||||
if (try_lock()) {
|
|
||||||
flags_.add_signals(signals);
|
|
||||||
return true;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
bool own_lock() const {
|
|
||||||
return own_lock_;
|
|
||||||
}
|
|
||||||
ActorState::Flags flags() const {
|
|
||||||
return flags_;
|
|
||||||
}
|
|
||||||
bool can_execute() const {
|
|
||||||
return flags_.is_shared() == options_.is_shared && (options_.can_execute_paused || !flags_.is_pause());
|
|
||||||
}
|
|
||||||
|
|
||||||
private:
|
|
||||||
ActorState *state_{nullptr};
|
|
||||||
ActorState::Flags flags_;
|
|
||||||
ActorState::Flags new_flags_;
|
|
||||||
bool own_lock_{false};
|
|
||||||
Options options_;
|
|
||||||
|
|
||||||
bool can_try_add_signals() const {
|
|
||||||
return flags_.is_locked() || (flags_.is_in_queue() && !can_execute());
|
|
||||||
}
|
|
||||||
};
|
|
||||||
} // namespace actor2
|
|
||||||
} // namespace td
|
|
||||||
@ -1,84 +0,0 @@
|
|||||||
//
|
|
||||||
// Copyright Aliaksei Levin (levlam@telegram.org), Arseny Smirnov (arseny30@gmail.com) 2014-2018
|
|
||||||
//
|
|
||||||
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
|
||||||
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
|
||||||
//
|
|
||||||
#pragma once
|
|
||||||
|
|
||||||
#include "td/utils/common.h"
|
|
||||||
|
|
||||||
namespace td {
|
|
||||||
namespace actor2 {
|
|
||||||
class ActorSignals {
|
|
||||||
public:
|
|
||||||
ActorSignals() = default;
|
|
||||||
uint32 raw() const {
|
|
||||||
return raw_;
|
|
||||||
}
|
|
||||||
bool empty() const {
|
|
||||||
return raw_ == 0;
|
|
||||||
}
|
|
||||||
bool has_signal(uint32 signal) const {
|
|
||||||
return (raw_ & (1u << signal)) != 0;
|
|
||||||
}
|
|
||||||
void add_signal(uint32 signal) {
|
|
||||||
raw_ |= (1u << signal);
|
|
||||||
}
|
|
||||||
void add_signals(ActorSignals signals) {
|
|
||||||
raw_ |= signals.raw();
|
|
||||||
}
|
|
||||||
void clear_signal(uint32 signal) {
|
|
||||||
raw_ &= ~(1u << signal);
|
|
||||||
}
|
|
||||||
uint32 first_signal() {
|
|
||||||
if (!raw_) {
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
#if TD_MSVC
|
|
||||||
int res = 0;
|
|
||||||
int bit = 1;
|
|
||||||
while ((raw_ & bit) == 0) {
|
|
||||||
res++;
|
|
||||||
bit <<= 1;
|
|
||||||
}
|
|
||||||
return res;
|
|
||||||
#else
|
|
||||||
return __builtin_ctz(raw_);
|
|
||||||
#endif
|
|
||||||
}
|
|
||||||
enum Signal : uint32 {
|
|
||||||
// Signals in order of priority
|
|
||||||
Wakeup = 1,
|
|
||||||
Alarm = 2,
|
|
||||||
Kill = 3, // immediate kill
|
|
||||||
Io = 4, // move to io thread
|
|
||||||
Cpu = 5, // move to cpu thread
|
|
||||||
StartUp = 6,
|
|
||||||
TearDown = 7,
|
|
||||||
// Two signals for mpmc queue logic
|
|
||||||
//
|
|
||||||
// PopSignal is set after actor is popped from queue
|
|
||||||
// When processed it should set InQueue and Pause flags to false.
|
|
||||||
//
|
|
||||||
// MessagesSignal is set after new messages was added to actor
|
|
||||||
// If owner of actor wish to delay message handling, she should set InQueue flag to true and
|
|
||||||
// add actor into mpmc queue.
|
|
||||||
Pop = 8, // got popped from queue
|
|
||||||
Message = 9, // got new message
|
|
||||||
};
|
|
||||||
|
|
||||||
static ActorSignals one(uint32 signal) {
|
|
||||||
ActorSignals res;
|
|
||||||
res.add_signal(signal);
|
|
||||||
return res;
|
|
||||||
}
|
|
||||||
|
|
||||||
private:
|
|
||||||
uint32 raw_{0};
|
|
||||||
friend class ActorState;
|
|
||||||
explicit ActorSignals(uint32 raw) : raw_(raw) {
|
|
||||||
}
|
|
||||||
};
|
|
||||||
} // namespace actor2
|
|
||||||
} // namespace td
|
|
||||||
@ -1,166 +0,0 @@
|
|||||||
//
|
|
||||||
// Copyright Aliaksei Levin (levlam@telegram.org), Arseny Smirnov (arseny30@gmail.com) 2014-2018
|
|
||||||
//
|
|
||||||
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
|
||||||
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
|
||||||
//
|
|
||||||
#pragma once
|
|
||||||
|
|
||||||
#include "td/actor/impl2/ActorSignals.h"
|
|
||||||
#include "td/actor/impl2/SchedulerId.h"
|
|
||||||
|
|
||||||
#include "td/utils/common.h"
|
|
||||||
|
|
||||||
#include <atomic>
|
|
||||||
|
|
||||||
namespace td {
|
|
||||||
namespace actor2 {
|
|
||||||
class ActorState {
|
|
||||||
public:
|
|
||||||
class Flags {
|
|
||||||
public:
|
|
||||||
Flags() = default;
|
|
||||||
uint32 raw() const {
|
|
||||||
return raw_;
|
|
||||||
}
|
|
||||||
uint32 &raw_ref() {
|
|
||||||
return raw_;
|
|
||||||
}
|
|
||||||
SchedulerId get_scheduler_id() const {
|
|
||||||
return SchedulerId{static_cast<uint8>(raw_ & SchedulerMask)};
|
|
||||||
}
|
|
||||||
void set_scheduler_id(SchedulerId id) {
|
|
||||||
raw_ = (raw_ & ~SchedulerMask) | id.value();
|
|
||||||
}
|
|
||||||
|
|
||||||
bool is_shared() const {
|
|
||||||
return check_flag(SharedFlag);
|
|
||||||
}
|
|
||||||
void set_shared(bool shared) {
|
|
||||||
set_flag(SharedFlag, shared);
|
|
||||||
}
|
|
||||||
|
|
||||||
bool is_locked() const {
|
|
||||||
return check_flag(LockFlag);
|
|
||||||
}
|
|
||||||
void set_locked(bool locked) {
|
|
||||||
set_flag(LockFlag, locked);
|
|
||||||
}
|
|
||||||
|
|
||||||
bool is_migrate() const {
|
|
||||||
return check_flag(MigrateFlag);
|
|
||||||
}
|
|
||||||
void set_migrate(bool migrate) {
|
|
||||||
set_flag(MigrateFlag, migrate);
|
|
||||||
}
|
|
||||||
|
|
||||||
bool is_pause() const {
|
|
||||||
return check_flag(PauseFlag);
|
|
||||||
}
|
|
||||||
void set_pause(bool pause) {
|
|
||||||
set_flag(PauseFlag, pause);
|
|
||||||
}
|
|
||||||
|
|
||||||
bool is_closed() const {
|
|
||||||
return check_flag(ClosedFlag);
|
|
||||||
}
|
|
||||||
void set_closed(bool closed) {
|
|
||||||
set_flag(ClosedFlag, closed);
|
|
||||||
}
|
|
||||||
|
|
||||||
bool is_in_queue() const {
|
|
||||||
return check_flag(InQueueFlag);
|
|
||||||
}
|
|
||||||
void set_in_queue(bool in_queue) {
|
|
||||||
set_flag(InQueueFlag, in_queue);
|
|
||||||
}
|
|
||||||
|
|
||||||
bool has_signals() const {
|
|
||||||
return check_flag(SignalMask);
|
|
||||||
}
|
|
||||||
void clear_signals() {
|
|
||||||
set_flag(SignalMask, false);
|
|
||||||
}
|
|
||||||
void set_signals(ActorSignals signals) {
|
|
||||||
raw_ = (raw_ & ~SignalMask) | (signals.raw() << SignalOffset);
|
|
||||||
}
|
|
||||||
void add_signals(ActorSignals signals) {
|
|
||||||
raw_ = raw_ | (signals.raw() << SignalOffset);
|
|
||||||
}
|
|
||||||
ActorSignals get_signals() const {
|
|
||||||
return ActorSignals{(raw_ & SignalMask) >> SignalOffset};
|
|
||||||
}
|
|
||||||
|
|
||||||
private:
|
|
||||||
uint32 raw_{0};
|
|
||||||
|
|
||||||
friend class ActorState;
|
|
||||||
Flags(uint32 raw) : raw_(raw) {
|
|
||||||
}
|
|
||||||
|
|
||||||
bool check_flag(uint32 mask) const {
|
|
||||||
return (raw_ & mask) != 0;
|
|
||||||
}
|
|
||||||
void set_flag(uint32 mask, bool flag) {
|
|
||||||
raw_ = (raw_ & ~mask) | (flag * mask);
|
|
||||||
}
|
|
||||||
};
|
|
||||||
|
|
||||||
Flags get_flags_unsafe() {
|
|
||||||
return Flags(state_.load(std::memory_order_relaxed));
|
|
||||||
}
|
|
||||||
void set_flags_unsafe(Flags flags) {
|
|
||||||
state_.store(flags.raw(), std::memory_order_relaxed);
|
|
||||||
}
|
|
||||||
|
|
||||||
private:
|
|
||||||
friend class ActorLocker;
|
|
||||||
std::atomic<uint32> state_{0};
|
|
||||||
enum : uint32 {
|
|
||||||
SchedulerMask = 255,
|
|
||||||
|
|
||||||
// Actors can be shared or not.
|
|
||||||
// If actor is shared, than any thread may try to lock it
|
|
||||||
// If actor is not shared, than it is owned by its scheduler, and only
|
|
||||||
// its scheduler is allowed to access it
|
|
||||||
// This flag may NOT change during the lifetime of an actor
|
|
||||||
SharedFlag = 1 << 9,
|
|
||||||
|
|
||||||
// Only shared actors need lock
|
|
||||||
// Lock if somebody is going to unlock it eventually.
|
|
||||||
// For example actor is locked, when some scheduler is executing its mailbox
|
|
||||||
// Or it is locked when it is in Mpmc queue, so someone will pop it eventually.
|
|
||||||
LockFlag = 1 << 10,
|
|
||||||
|
|
||||||
// While actor is migrating from one scheduler to another no one is allowed to change it
|
|
||||||
// Could not be set for shared actors.
|
|
||||||
MigrateFlag = 1 << 11,
|
|
||||||
|
|
||||||
// While set all messages are delayed
|
|
||||||
// Dropped from flush_maibox
|
|
||||||
// PauseFlag => InQueueFlag
|
|
||||||
PauseFlag = 1 << 12,
|
|
||||||
|
|
||||||
ClosedFlag = 1 << 13,
|
|
||||||
|
|
||||||
InQueueFlag = 1 << 14,
|
|
||||||
|
|
||||||
// Signals
|
|
||||||
SignalOffset = 15,
|
|
||||||
Signal = 1 << SignalOffset,
|
|
||||||
WakeupSignalFlag = Signal << ActorSignals::Wakeup,
|
|
||||||
AlarmSignalFlag = Signal << ActorSignals::Alarm,
|
|
||||||
KillSignalFlag = Signal << ActorSignals::Kill, // immediate kill
|
|
||||||
IoSignalFlag = Signal << ActorSignals::Io, // move to io thread
|
|
||||||
CpuSignalFlag = Signal << ActorSignals::Cpu, // move to cpu thread
|
|
||||||
StartUpSignalFlag = Signal << ActorSignals::StartUp,
|
|
||||||
TearDownSignalFlag = Signal << ActorSignals::TearDown,
|
|
||||||
MessageSignalFlag = Signal << ActorSignals::Message,
|
|
||||||
PopSignalFlag = Signal << ActorSignals::Pop,
|
|
||||||
|
|
||||||
SignalMask = WakeupSignalFlag | AlarmSignalFlag | KillSignalFlag | IoSignalFlag | CpuSignalFlag |
|
|
||||||
StartUpSignalFlag | TearDownSignalFlag | MessageSignalFlag | PopSignalFlag
|
|
||||||
};
|
|
||||||
};
|
|
||||||
} // namespace actor2
|
|
||||||
} // namespace td
|
|
||||||
@ -1,11 +0,0 @@
|
|||||||
//
|
|
||||||
// Copyright Aliaksei Levin (levlam@telegram.org), Arseny Smirnov (arseny30@gmail.com) 2014-2018
|
|
||||||
//
|
|
||||||
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
|
||||||
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
|
||||||
//
|
|
||||||
#include "td/actor/impl2/Scheduler.h"
|
|
||||||
|
|
||||||
namespace td {
|
|
||||||
namespace actor2 {}
|
|
||||||
} // namespace td
|
|
||||||
File diff suppressed because it is too large
Load Diff
@ -1,32 +0,0 @@
|
|||||||
//
|
|
||||||
// Copyright Aliaksei Levin (levlam@telegram.org), Arseny Smirnov (arseny30@gmail.com) 2014-2018
|
|
||||||
//
|
|
||||||
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
|
||||||
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
|
||||||
//
|
|
||||||
#pragma once
|
|
||||||
|
|
||||||
#include "td/utils/common.h"
|
|
||||||
#include "td/utils/logging.h"
|
|
||||||
|
|
||||||
namespace td {
|
|
||||||
namespace actor2 {
|
|
||||||
class SchedulerId {
|
|
||||||
public:
|
|
||||||
SchedulerId() : id_(-1) {
|
|
||||||
}
|
|
||||||
explicit SchedulerId(uint8 id) : id_(id) {
|
|
||||||
}
|
|
||||||
bool is_valid() const {
|
|
||||||
return id_ >= 0;
|
|
||||||
}
|
|
||||||
uint8 value() const {
|
|
||||||
CHECK(is_valid());
|
|
||||||
return static_cast<uint8>(id_);
|
|
||||||
}
|
|
||||||
|
|
||||||
private:
|
|
||||||
int32 id_{0};
|
|
||||||
};
|
|
||||||
} // namespace actor2
|
|
||||||
} // namespace td
|
|
||||||
@ -1,534 +0,0 @@
|
|||||||
//
|
|
||||||
// Copyright Aliaksei Levin (levlam@telegram.org), Arseny Smirnov (arseny30@gmail.com) 2014-2018
|
|
||||||
//
|
|
||||||
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
|
||||||
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
|
||||||
//
|
|
||||||
#include "td/actor/impl2/ActorLocker.h"
|
|
||||||
#include "td/actor/impl2/Scheduler.h"
|
|
||||||
|
|
||||||
#include "td/utils/format.h"
|
|
||||||
#include "td/utils/logging.h"
|
|
||||||
#include "td/utils/port/thread.h"
|
|
||||||
#include "td/utils/Slice.h"
|
|
||||||
#include "td/utils/StringBuilder.h"
|
|
||||||
#include "td/utils/tests.h"
|
|
||||||
#include "td/utils/Time.h"
|
|
||||||
|
|
||||||
#include <array>
|
|
||||||
#include <atomic>
|
|
||||||
#include <deque>
|
|
||||||
#include <memory>
|
|
||||||
|
|
||||||
using td::actor2::ActorLocker;
|
|
||||||
using td::actor2::ActorSignals;
|
|
||||||
using td::actor2::ActorState;
|
|
||||||
using td::actor2::SchedulerId;
|
|
||||||
|
|
||||||
TEST(Actor2, signals) {
|
|
||||||
ActorSignals signals;
|
|
||||||
signals.add_signal(ActorSignals::Wakeup);
|
|
||||||
signals.add_signal(ActorSignals::Cpu);
|
|
||||||
signals.add_signal(ActorSignals::Kill);
|
|
||||||
signals.clear_signal(ActorSignals::Cpu);
|
|
||||||
|
|
||||||
bool was_kill = false;
|
|
||||||
bool was_wakeup = false;
|
|
||||||
while (!signals.empty()) {
|
|
||||||
auto s = signals.first_signal();
|
|
||||||
if (s == ActorSignals::Kill) {
|
|
||||||
was_kill = true;
|
|
||||||
} else if (s == ActorSignals::Wakeup) {
|
|
||||||
was_wakeup = true;
|
|
||||||
} else {
|
|
||||||
UNREACHABLE();
|
|
||||||
}
|
|
||||||
signals.clear_signal(s);
|
|
||||||
}
|
|
||||||
CHECK(was_kill && was_wakeup);
|
|
||||||
}
|
|
||||||
|
|
||||||
TEST(Actors2, flags) {
|
|
||||||
ActorState::Flags flags;
|
|
||||||
CHECK(!flags.is_locked());
|
|
||||||
flags.set_locked(true);
|
|
||||||
CHECK(flags.is_locked());
|
|
||||||
flags.set_locked(false);
|
|
||||||
CHECK(!flags.is_locked());
|
|
||||||
flags.set_pause(true);
|
|
||||||
|
|
||||||
flags.set_scheduler_id(SchedulerId{123});
|
|
||||||
|
|
||||||
auto signals = flags.get_signals();
|
|
||||||
CHECK(signals.empty());
|
|
||||||
signals.add_signal(ActorSignals::Cpu);
|
|
||||||
signals.add_signal(ActorSignals::Kill);
|
|
||||||
CHECK(signals.has_signal(ActorSignals::Cpu));
|
|
||||||
CHECK(signals.has_signal(ActorSignals::Kill));
|
|
||||||
flags.set_signals(signals);
|
|
||||||
CHECK(flags.get_signals().raw() == signals.raw()) << flags.get_signals().raw() << " " << signals.raw();
|
|
||||||
|
|
||||||
auto wakeup = ActorSignals{};
|
|
||||||
wakeup.add_signal(ActorSignals::Wakeup);
|
|
||||||
|
|
||||||
flags.add_signals(wakeup);
|
|
||||||
signals.add_signal(ActorSignals::Wakeup);
|
|
||||||
CHECK(flags.get_signals().raw() == signals.raw());
|
|
||||||
|
|
||||||
flags.clear_signals();
|
|
||||||
CHECK(flags.get_signals().empty());
|
|
||||||
|
|
||||||
CHECK(flags.get_scheduler_id().value() == 123);
|
|
||||||
CHECK(flags.is_pause());
|
|
||||||
}
|
|
||||||
|
|
||||||
TEST(Actor2, locker) {
|
|
||||||
ActorState state;
|
|
||||||
|
|
||||||
ActorSignals kill_signal;
|
|
||||||
kill_signal.add_signal(ActorSignals::Kill);
|
|
||||||
|
|
||||||
ActorSignals wakeup_signal;
|
|
||||||
kill_signal.add_signal(ActorSignals::Wakeup);
|
|
||||||
|
|
||||||
ActorSignals cpu_signal;
|
|
||||||
kill_signal.add_signal(ActorSignals::Cpu);
|
|
||||||
|
|
||||||
{
|
|
||||||
ActorLocker lockerA(&state);
|
|
||||||
ActorLocker lockerB(&state);
|
|
||||||
ActorLocker lockerC(&state);
|
|
||||||
|
|
||||||
CHECK(lockerA.try_lock());
|
|
||||||
CHECK(lockerA.own_lock());
|
|
||||||
auto flagsA = lockerA.flags();
|
|
||||||
CHECK(lockerA.try_unlock(flagsA));
|
|
||||||
CHECK(!lockerA.own_lock());
|
|
||||||
|
|
||||||
CHECK(lockerA.try_lock());
|
|
||||||
CHECK(!lockerB.try_lock());
|
|
||||||
CHECK(!lockerC.try_lock());
|
|
||||||
|
|
||||||
CHECK(lockerB.try_add_signals(kill_signal));
|
|
||||||
CHECK(!lockerC.try_add_signals(wakeup_signal));
|
|
||||||
CHECK(lockerC.try_add_signals(wakeup_signal));
|
|
||||||
CHECK(!lockerC.add_signals(cpu_signal));
|
|
||||||
CHECK(!lockerA.flags().has_signals());
|
|
||||||
CHECK(!lockerA.try_unlock(lockerA.flags()));
|
|
||||||
{
|
|
||||||
auto flags = lockerA.flags();
|
|
||||||
auto signals = flags.get_signals();
|
|
||||||
bool was_kill = false;
|
|
||||||
bool was_wakeup = false;
|
|
||||||
bool was_cpu = false;
|
|
||||||
while (!signals.empty()) {
|
|
||||||
auto s = signals.first_signal();
|
|
||||||
if (s == ActorSignals::Kill) {
|
|
||||||
was_kill = true;
|
|
||||||
} else if (s == ActorSignals::Wakeup) {
|
|
||||||
was_wakeup = true;
|
|
||||||
} else if (s == ActorSignals::Cpu) {
|
|
||||||
was_cpu = true;
|
|
||||||
} else {
|
|
||||||
UNREACHABLE();
|
|
||||||
}
|
|
||||||
signals.clear_signal(s);
|
|
||||||
}
|
|
||||||
CHECK(was_kill && was_wakeup && was_cpu);
|
|
||||||
flags.clear_signals();
|
|
||||||
CHECK(lockerA.try_unlock(flags));
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
{
|
|
||||||
ActorLocker lockerB(&state);
|
|
||||||
CHECK(lockerB.try_lock());
|
|
||||||
CHECK(lockerB.try_unlock(lockerB.flags()));
|
|
||||||
CHECK(lockerB.add_signals(kill_signal));
|
|
||||||
CHECK(lockerB.flags().get_signals().has_signal(ActorSignals::Kill));
|
|
||||||
auto flags = lockerB.flags();
|
|
||||||
flags.clear_signals();
|
|
||||||
ActorLocker lockerA(&state);
|
|
||||||
CHECK(!lockerA.add_signals(kill_signal));
|
|
||||||
CHECK(!lockerB.try_unlock(flags));
|
|
||||||
CHECK(!lockerA.add_signals(kill_signal)); // do not loose this signal!
|
|
||||||
CHECK(!lockerB.try_unlock(flags));
|
|
||||||
CHECK(lockerB.flags().get_signals().has_signal(ActorSignals::Kill));
|
|
||||||
CHECK(lockerB.try_unlock(flags));
|
|
||||||
}
|
|
||||||
|
|
||||||
{
|
|
||||||
ActorLocker lockerA(&state);
|
|
||||||
CHECK(lockerA.try_lock());
|
|
||||||
auto flags = lockerA.flags();
|
|
||||||
flags.set_pause(true);
|
|
||||||
CHECK(lockerA.try_unlock(flags));
|
|
||||||
//We have to lock, though we can't execute.
|
|
||||||
CHECK(lockerA.add_signals(wakeup_signal));
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
#if !TD_THREAD_UNSUPPORTED
|
|
||||||
TEST(Actor2, locker_stress) {
|
|
||||||
ActorState state;
|
|
||||||
|
|
||||||
constexpr size_t threads_n = 5;
|
|
||||||
auto stage = [&](std::atomic<int> &value, int need) {
|
|
||||||
value.fetch_add(1, std::memory_order_release);
|
|
||||||
while (value.load(std::memory_order_acquire) < need) {
|
|
||||||
td::this_thread::yield();
|
|
||||||
}
|
|
||||||
};
|
|
||||||
|
|
||||||
struct Node {
|
|
||||||
std::atomic<td::uint32> request{0};
|
|
||||||
td::uint32 response = 0;
|
|
||||||
char pad[64];
|
|
||||||
};
|
|
||||||
std::array<Node, threads_n> nodes;
|
|
||||||
auto do_work = [&]() {
|
|
||||||
for (auto &node : nodes) {
|
|
||||||
auto query = node.request.load(std::memory_order_acquire);
|
|
||||||
if (query) {
|
|
||||||
node.response = query * query;
|
|
||||||
node.request.store(0, std::memory_order_relaxed);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
};
|
|
||||||
|
|
||||||
std::atomic<int> begin{0};
|
|
||||||
std::atomic<int> ready{0};
|
|
||||||
std::atomic<int> check{0};
|
|
||||||
std::vector<td::thread> threads;
|
|
||||||
for (size_t i = 0; i < threads_n; i++) {
|
|
||||||
threads.push_back(td::thread([&, id = i] {
|
|
||||||
for (size_t i = 1; i < 1000000; i++) {
|
|
||||||
ActorLocker locker(&state);
|
|
||||||
auto need = static_cast<int>(threads_n * i);
|
|
||||||
auto query = static_cast<td::uint32>(id + need);
|
|
||||||
stage(begin, need);
|
|
||||||
nodes[id].request = 0;
|
|
||||||
nodes[id].response = 0;
|
|
||||||
stage(ready, need);
|
|
||||||
if (locker.try_lock()) {
|
|
||||||
nodes[id].response = query * query;
|
|
||||||
} else {
|
|
||||||
auto cpu = ActorSignals::one(ActorSignals::Cpu);
|
|
||||||
nodes[id].request.store(query, std::memory_order_release);
|
|
||||||
locker.add_signals(cpu);
|
|
||||||
}
|
|
||||||
while (locker.own_lock()) {
|
|
||||||
auto flags = locker.flags();
|
|
||||||
auto signals = flags.get_signals();
|
|
||||||
if (!signals.empty()) {
|
|
||||||
do_work();
|
|
||||||
}
|
|
||||||
flags.clear_signals();
|
|
||||||
locker.try_unlock(flags);
|
|
||||||
}
|
|
||||||
|
|
||||||
stage(check, need);
|
|
||||||
if (id == 0) {
|
|
||||||
CHECK(locker.add_signals(ActorSignals{}));
|
|
||||||
CHECK(!locker.flags().has_signals());
|
|
||||||
CHECK(locker.try_unlock(locker.flags()));
|
|
||||||
for (size_t thread_id = 0; thread_id < threads_n; thread_id++) {
|
|
||||||
CHECK(nodes[thread_id].response ==
|
|
||||||
static_cast<td::uint32>(thread_id + need) * static_cast<td::uint32>(thread_id + need))
|
|
||||||
<< td::tag("thread", thread_id) << " " << nodes[thread_id].response << " "
|
|
||||||
<< nodes[thread_id].request.load();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}));
|
|
||||||
}
|
|
||||||
for (auto &thread : threads) {
|
|
||||||
thread.join();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
namespace {
|
|
||||||
const size_t BUF_SIZE = 1024 * 1024;
|
|
||||||
char buf[BUF_SIZE];
|
|
||||||
td::StringBuilder sb(td::MutableSlice(buf, BUF_SIZE - 1));
|
|
||||||
} // namespace
|
|
||||||
|
|
||||||
TEST(Actor2, executor_simple) {
|
|
||||||
using namespace td;
|
|
||||||
using namespace td::actor2;
|
|
||||||
struct Dispatcher : public SchedulerDispatcher {
|
|
||||||
void add_to_queue(ActorInfoPtr ptr, SchedulerId scheduler_id, bool need_poll) override {
|
|
||||||
queue.push_back(std::move(ptr));
|
|
||||||
}
|
|
||||||
void set_alarm_timestamp(const ActorInfoPtr &actor_info_ptr, Timestamp timestamp) override {
|
|
||||||
UNREACHABLE();
|
|
||||||
}
|
|
||||||
SchedulerId get_scheduler_id() const override {
|
|
||||||
return SchedulerId{0};
|
|
||||||
}
|
|
||||||
std::deque<ActorInfoPtr> queue;
|
|
||||||
};
|
|
||||||
Dispatcher dispatcher;
|
|
||||||
|
|
||||||
class TestActor : public Actor {
|
|
||||||
public:
|
|
||||||
void close() {
|
|
||||||
stop();
|
|
||||||
}
|
|
||||||
|
|
||||||
private:
|
|
||||||
void start_up() override {
|
|
||||||
sb << "StartUp";
|
|
||||||
}
|
|
||||||
void tear_down() override {
|
|
||||||
sb << "TearDown";
|
|
||||||
}
|
|
||||||
};
|
|
||||||
ActorInfoCreator actor_info_creator;
|
|
||||||
auto actor = actor_info_creator.create(
|
|
||||||
std::make_unique<TestActor>(), ActorInfoCreator::Options().on_scheduler(SchedulerId{0}).with_name("TestActor"));
|
|
||||||
dispatcher.add_to_queue(actor, SchedulerId{0}, false);
|
|
||||||
|
|
||||||
{
|
|
||||||
ActorExecutor executor(*actor, dispatcher, ActorExecutor::Options());
|
|
||||||
CHECK(executor.can_send());
|
|
||||||
CHECK(executor.can_send_immediate());
|
|
||||||
CHECK(sb.as_cslice() == "StartUp") << sb.as_cslice();
|
|
||||||
sb.clear();
|
|
||||||
executor.send(ActorMessageCreator::lambda([&] { sb << "A"; }));
|
|
||||||
CHECK(sb.as_cslice() == "A") << sb.as_cslice();
|
|
||||||
sb.clear();
|
|
||||||
auto big_message = ActorMessageCreator::lambda([&] { sb << "big"; });
|
|
||||||
big_message.set_big();
|
|
||||||
executor.send(std::move(big_message));
|
|
||||||
CHECK(sb.as_cslice() == "") << sb.as_cslice();
|
|
||||||
executor.send(ActorMessageCreator::lambda([&] { sb << "A"; }));
|
|
||||||
CHECK(sb.as_cslice() == "") << sb.as_cslice();
|
|
||||||
}
|
|
||||||
CHECK(dispatcher.queue.size() == 1);
|
|
||||||
{ ActorExecutor executor(*actor, dispatcher, ActorExecutor::Options().with_from_queue()); }
|
|
||||||
CHECK(dispatcher.queue.size() == 1);
|
|
||||||
dispatcher.queue.clear();
|
|
||||||
CHECK(sb.as_cslice() == "bigA") << sb.as_cslice();
|
|
||||||
sb.clear();
|
|
||||||
{
|
|
||||||
ActorExecutor executor(*actor, dispatcher, ActorExecutor::Options());
|
|
||||||
executor.send(
|
|
||||||
ActorMessageCreator::lambda([&] { static_cast<TestActor &>(ActorExecuteContext::get()->actor()).close(); }));
|
|
||||||
}
|
|
||||||
CHECK(sb.as_cslice() == "TearDown") << sb.as_cslice();
|
|
||||||
sb.clear();
|
|
||||||
CHECK(!actor->has_actor());
|
|
||||||
{
|
|
||||||
ActorExecutor executor(*actor, dispatcher, ActorExecutor::Options());
|
|
||||||
executor.send(
|
|
||||||
ActorMessageCreator::lambda([&] { static_cast<TestActor &>(ActorExecuteContext::get()->actor()).close(); }));
|
|
||||||
}
|
|
||||||
CHECK(dispatcher.queue.empty());
|
|
||||||
CHECK(sb.as_cslice() == "");
|
|
||||||
}
|
|
||||||
|
|
||||||
using namespace td::actor2;
|
|
||||||
using td::uint32;
|
|
||||||
static std::atomic<int> cnt;
|
|
||||||
class Worker : public Actor {
|
|
||||||
public:
|
|
||||||
void query(uint32 x, ActorInfoPtr master);
|
|
||||||
void close() {
|
|
||||||
stop();
|
|
||||||
}
|
|
||||||
};
|
|
||||||
class Master : public Actor {
|
|
||||||
public:
|
|
||||||
void on_result(uint32 x, uint32 y) {
|
|
||||||
loop();
|
|
||||||
}
|
|
||||||
|
|
||||||
private:
|
|
||||||
uint32 l = 0;
|
|
||||||
uint32 r = 100000;
|
|
||||||
ActorInfoPtr worker;
|
|
||||||
void start_up() override {
|
|
||||||
worker = detail::create_actor<Worker>(ActorOptions().with_name("Master"));
|
|
||||||
loop();
|
|
||||||
}
|
|
||||||
void loop() override {
|
|
||||||
l++;
|
|
||||||
if (l == r) {
|
|
||||||
if (!--cnt) {
|
|
||||||
SchedulerContext::get()->stop();
|
|
||||||
}
|
|
||||||
detail::send_closure(*worker, &Worker::close);
|
|
||||||
stop();
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
detail::send_lambda(*worker,
|
|
||||||
[x = l, self = get_actor_info_ptr()] { detail::current_actor<Worker>().query(x, self); });
|
|
||||||
}
|
|
||||||
};
|
|
||||||
|
|
||||||
void Worker::query(uint32 x, ActorInfoPtr master) {
|
|
||||||
auto y = x;
|
|
||||||
for (int i = 0; i < 100; i++) {
|
|
||||||
y = y * y;
|
|
||||||
}
|
|
||||||
detail::send_lambda(*master, [result = y, x] { detail::current_actor<Master>().on_result(x, result); });
|
|
||||||
}
|
|
||||||
|
|
||||||
TEST(Actor2, scheduler_simple) {
|
|
||||||
auto group_info = std::make_shared<SchedulerGroupInfo>(1);
|
|
||||||
Scheduler scheduler{group_info, SchedulerId{0}, 2};
|
|
||||||
scheduler.start();
|
|
||||||
scheduler.run_in_context([] {
|
|
||||||
cnt = 10;
|
|
||||||
for (int i = 0; i < 10; i++) {
|
|
||||||
detail::create_actor<Master>(ActorOptions().with_name("Master"));
|
|
||||||
}
|
|
||||||
});
|
|
||||||
while (scheduler.run(1000)) {
|
|
||||||
}
|
|
||||||
Scheduler::close_scheduler_group(*group_info);
|
|
||||||
}
|
|
||||||
|
|
||||||
TEST(Actor2, actor_id_simple) {
|
|
||||||
auto group_info = std::make_shared<SchedulerGroupInfo>(1);
|
|
||||||
Scheduler scheduler{group_info, SchedulerId{0}, 2};
|
|
||||||
sb.clear();
|
|
||||||
scheduler.start();
|
|
||||||
|
|
||||||
scheduler.run_in_context([] {
|
|
||||||
class A : public Actor {
|
|
||||||
public:
|
|
||||||
A(int value) : value_(value) {
|
|
||||||
sb << "A" << value_;
|
|
||||||
}
|
|
||||||
void hello() {
|
|
||||||
sb << "hello";
|
|
||||||
}
|
|
||||||
~A() {
|
|
||||||
sb << "~A";
|
|
||||||
if (--cnt <= 0) {
|
|
||||||
SchedulerContext::get()->stop();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
private:
|
|
||||||
int value_;
|
|
||||||
};
|
|
||||||
cnt = 1;
|
|
||||||
auto id = create_actor<A>("A", 123);
|
|
||||||
CHECK(sb.as_cslice() == "A123");
|
|
||||||
sb.clear();
|
|
||||||
send_closure(id, &A::hello);
|
|
||||||
});
|
|
||||||
while (scheduler.run(1000)) {
|
|
||||||
}
|
|
||||||
CHECK(sb.as_cslice() == "hello~A");
|
|
||||||
Scheduler::close_scheduler_group(*group_info);
|
|
||||||
sb.clear();
|
|
||||||
}
|
|
||||||
|
|
||||||
TEST(Actor2, actor_creation) {
|
|
||||||
auto group_info = std::make_shared<SchedulerGroupInfo>(1);
|
|
||||||
Scheduler scheduler{group_info, SchedulerId{0}, 1};
|
|
||||||
scheduler.start();
|
|
||||||
|
|
||||||
scheduler.run_in_context([]() mutable {
|
|
||||||
class B;
|
|
||||||
class A : public Actor {
|
|
||||||
public:
|
|
||||||
void f() {
|
|
||||||
check();
|
|
||||||
stop();
|
|
||||||
}
|
|
||||||
|
|
||||||
private:
|
|
||||||
void start_up() override {
|
|
||||||
check();
|
|
||||||
create_actor<B>("Simple", actor_id(this)).release();
|
|
||||||
}
|
|
||||||
|
|
||||||
void check() {
|
|
||||||
auto &context = *SchedulerContext::get();
|
|
||||||
CHECK(context.has_poll());
|
|
||||||
context.get_poll();
|
|
||||||
}
|
|
||||||
|
|
||||||
void tear_down() override {
|
|
||||||
if (--cnt <= 0) {
|
|
||||||
SchedulerContext::get()->stop();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
};
|
|
||||||
|
|
||||||
class B : public Actor {
|
|
||||||
public:
|
|
||||||
B(ActorId<A> a) : a_(a) {
|
|
||||||
}
|
|
||||||
|
|
||||||
private:
|
|
||||||
void start_up() override {
|
|
||||||
auto &context = *SchedulerContext::get();
|
|
||||||
CHECK(!context.has_poll());
|
|
||||||
send_closure(a_, &A::f);
|
|
||||||
stop();
|
|
||||||
}
|
|
||||||
void tear_down() override {
|
|
||||||
if (--cnt <= 0) {
|
|
||||||
SchedulerContext::get()->stop();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
ActorId<A> a_;
|
|
||||||
};
|
|
||||||
cnt = 2;
|
|
||||||
create_actor<A>(ActorOptions().with_name("Poll").with_poll()).release();
|
|
||||||
});
|
|
||||||
while (scheduler.run(1000)) {
|
|
||||||
}
|
|
||||||
scheduler.stop();
|
|
||||||
Scheduler::close_scheduler_group(*group_info);
|
|
||||||
}
|
|
||||||
|
|
||||||
TEST(Actor2, actor_timeout_simple) {
|
|
||||||
auto group_info = std::make_shared<SchedulerGroupInfo>(1);
|
|
||||||
Scheduler scheduler{group_info, SchedulerId{0}, 2};
|
|
||||||
sb.clear();
|
|
||||||
scheduler.start();
|
|
||||||
|
|
||||||
scheduler.run_in_context([] {
|
|
||||||
class A : public Actor {
|
|
||||||
public:
|
|
||||||
void start_up() override {
|
|
||||||
set_timeout();
|
|
||||||
}
|
|
||||||
void alarm() override {
|
|
||||||
double diff = td::Time::now() - expected_timeout_;
|
|
||||||
CHECK(-0.001 < diff && diff < 0.1) << diff;
|
|
||||||
if (cnt_-- > 0) {
|
|
||||||
set_timeout();
|
|
||||||
} else {
|
|
||||||
stop();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
void tear_down() override {
|
|
||||||
SchedulerContext::get()->stop();
|
|
||||||
}
|
|
||||||
|
|
||||||
private:
|
|
||||||
double expected_timeout_;
|
|
||||||
int cnt_ = 5;
|
|
||||||
void set_timeout() {
|
|
||||||
auto wakeup_timestamp = td::Timestamp::in(0.1);
|
|
||||||
expected_timeout_ = wakeup_timestamp.at();
|
|
||||||
alarm_timestamp() = wakeup_timestamp;
|
|
||||||
}
|
|
||||||
};
|
|
||||||
create_actor<A>(ActorInfoCreator::Options().with_name("A").with_poll()).release();
|
|
||||||
});
|
|
||||||
while (scheduler.run(1000)) {
|
|
||||||
}
|
|
||||||
Scheduler::close_scheduler_group(*group_info);
|
|
||||||
sb.clear();
|
|
||||||
}
|
|
||||||
#endif //!TD_THREAD_UNSUPPORTED
|
|
||||||
Reference in New Issue
Block a user