Coroutine: görevler için bir zamanlayıcı – Bölüm 2, Dian-Lun Li
Bu blog yazısı, bir planlayıcı hakkındaki mini serinin ikinci kısmıdır ve önceki “Yazılım Geliştirme: Dian-Lun Li’nin Coroutines’e Kompakt Bir Giriş” makalesine dayanmaktadır.
Duyuru
C++ eşyordamları için tek iş parçacıklı bir zamanlayıcı
Bu bölümde eşyordamları planlamak için tek iş parçacıklı bir zamanlayıcı uyguluyorum. Arayüzle başlayalım:
Task TaskA(Scheduler& sch) {
std::cout << "Hello from TaskAn";
co_await sch.suspend();
std::cout << "Executing the TaskAn";
co_await sch.suspend();
std::cout << "TaskA is finishedn";
}
Task TaskB(Scheduler& sch) {
std::cout << "Hello from TaskBn";
co_await sch.suspend();
std::cout << "Executing the TaskBn";
co_await sch.suspend();
std::cout << "TaskB is finishedn";
}
int main() {
Scheduler sch;
sch.emplace(TaskA(sch).get_handle());
sch.emplace(TaskB(sch).get_handle());
std::cout << "Start scheduling...n";
sch.schedule();
Birlikte TaskA birlikte TaskB bunlar eşyordamlardır. İçinde mainişlevinde, bir zamanlayıcı oluşturuyorum ve iki görevi (ortak rutin tutamaçları) zamanlayıcıya ekliyorum. Sonra ararım schedule iki aktiviteyi planlamak. Görev, aşağıdaki şekilde tanımlanan bir Coroutine nesnesidir:
struct Task {
struct promise_type {
std::suspend_always initial_suspend() noexcept { return {}; }
std::suspend_always final_suspend() noexcept { return {}; }
Task get_return_object() {
return std::coroutine_handle<promise_type>::from_promise(*this);
}
void return_void() {}
void unhandled_exception() {}
};
Task(std::coroutine_handle<promise_type> handle): handle{handle} {}
auto get_handle() { return handle; }
std::coroutine_handle<promise_type> handle;
};
Her iki fonksiyona da sahip olduğum unutulmamalıdır. initial_suspend hem de operasyonda final_suspend std::suspend_always geri dönmek. Bu gerekli çünkü eşyordamın tüm yürütülmesini zamanlayıcıya devretmek istiyorum. Ben gelene kadar eşyordamlar yürütülmez schedule Aramalar. Zamanlayıcı şu şekilde tanımlanır:
class Scheduler {
//std::queue<std::coroutine_handle<>> _tasks;
std::stack<std::coroutine_handle<>> _tasks;
public:
void emplace(std::coroutine_handle<> task) {
_tasks.push(task);
}
void schedule() {
while(!_tasks.empty()) {
//auto task = _tasks.front();
auto task = _tasks.top();
_tasks.pop();
task.resume();
if(!task.done()) {
_tasks.push(task);
}
else {
task.destroy();
}
}
}
auto suspend() {
return std::suspend_always{};
}
};
Zamanlayıcıda görevleri bir yığında saklıyorum ve dağıtıyorum emplace-Üye işlevi, kullanıcıların bir görevi yığına aktarabilmesini sağlar. İçinde schedule-Üyelik İşlevi Her zaman bir görevi yığından kaldırırım. Bir göreve devam ettiğimde görevin tamamlanıp tamamlanmadığını kontrol ederim. Değilse, daha sonra planlamak üzere görevi tekrar yığına iterim. Aksi halde bitmiş ödevi yok edeceğim. Programı çalıştırdıktan sonra aşağıdaki sonuçlar elde edilir:
Zamanlayıcı, görevleri depolamak için bir yığın (son giren ilk çıkar) kullanır. Yığını bir kuyrukla değiştirirsem (ilk giren ilk çıkar), görevlerin yürütülme sırası değişir:
Bütünlüğü sağlamak adına her iki program da burada tekrar özetlenmiştir:
// stackScheduler.cpp
#include <coroutine>
#include <iostream>
#include <stack>
struct Task {
struct promise_type {
std::suspend_always initial_suspend() noexcept { return {}; }
std::suspend_always final_suspend() noexcept { return {}; }
Task get_return_object() {
return std::coroutine_handle<promise_type>::from_promise(*this);
}
void return_void() {}
void unhandled_exception() {}
};
Task(std::coroutine_handle<promise_type> handle): handle{handle} {}
auto get_handle() { return handle; }
std::coroutine_handle<promise_type> handle;
};
class Scheduler {
std::stack<std::coroutine_handle<>> _tasks;
public:
void emplace(std::coroutine_handle<> task) {
_tasks.push(task);
}
void schedule() {
while(!_tasks.empty()) {
auto task = _tasks.top();
_tasks.pop();
task.resume();
if(!task.done()) {
_tasks.push(task);
}
else {
task.destroy();
}
}
}
auto suspend() {
return std::suspend_always{};
}
};
Task TaskA(Scheduler& sch) {
std::cout << "Hello from TaskAn";
co_await sch.suspend();
std::cout << "Executing the TaskAn";
co_await sch.suspend();
std::cout << "TaskA is finishedn";
}
Task TaskB(Scheduler& sch) {
std::cout << "Hello from TaskBn";
co_await sch.suspend();
std::cout << "Executing the TaskBn";
co_await sch.suspend();
std::cout << "TaskB is finishedn";
}
int main() {
std::cout << 'n';
Scheduler sch;
sch.emplace(TaskA(sch).get_handle());
sch.emplace(TaskB(sch).get_handle());
std::cout << "Start scheduling...n";
sch.schedule();
std::cout << 'n';
}
// queueScheduler.cpp
#include <coroutine>
#include <iostream>
#include <queue>
struct Task {
struct promise_type {
std::suspend_always initial_suspend() noexcept { return {}; }
std::suspend_always final_suspend() noexcept { return {}; }
Task get_return_object() {
return std::coroutine_handle<promise_type>::from_promise(*this);
}
void return_void() {}
void unhandled_exception() {}
};
Task(std::coroutine_handle<promise_type> handle): handle{handle} {}
auto get_handle() { return handle; }
std::coroutine_handle<promise_type> handle;
};
class Scheduler {
std::queue<std::coroutine_handle<>> _tasks;
public:
void emplace(std::coroutine_handle<> task) {
_tasks.push(task);
}
void schedule() {
while(!_tasks.empty()) {
auto task = _tasks.front();
_tasks.pop();
task.resume();
if(!task.done()) {
_tasks.push(task);
}
else {
task.destroy();
}
}
}
auto suspend() {
return std::suspend_always{};
}
};
Task TaskA(Scheduler& sch) {
std::cout << "Hello from TaskAn";
co_await sch.suspend();
std::cout << "Executing the TaskAn";
co_await sch.suspend();
std::cout << "TaskA is finishedn";
}
Task TaskB(Scheduler& sch) {
std::cout << "Hello from TaskBn";
co_await sch.suspend();
std::cout << "Executing the TaskBn";
co_await sch.suspend();
std::cout << "TaskB is finishedn";
}
int main() {
std::cout << 'n';
Scheduler sch;
sch.emplace(TaskA(sch).get_handle());
sch.emplace(TaskB(sch).get_handle());
std::cout << "Start scheduling...n";
sch.schedule();
std::cout << 'n';
}
Sıradaki ne?
Dian-Lun Li’nin bu makalesi eşyordamlar için basit bir zamanlayıcı gösteriyor. Bir sonraki yazımda daha ileri deneyler için Dian-Lun’un zamanlayıcısını kullanacağım.
(harita)
Haberin Sonu
Bu blog yazısı, bir planlayıcı hakkındaki mini serinin ikinci kısmıdır ve önceki “Yazılım Geliştirme: Dian-Lun Li’nin Coroutines’e Kompakt Bir Giriş” makalesine dayanmaktadır.
Duyuru
C++ eşyordamları için tek iş parçacıklı bir zamanlayıcı
Bu bölümde eşyordamları planlamak için tek iş parçacıklı bir zamanlayıcı uyguluyorum. Arayüzle başlayalım:
Task TaskA(Scheduler& sch) {
std::cout << "Hello from TaskAn";
co_await sch.suspend();
std::cout << "Executing the TaskAn";
co_await sch.suspend();
std::cout << "TaskA is finishedn";
}
Task TaskB(Scheduler& sch) {
std::cout << "Hello from TaskBn";
co_await sch.suspend();
std::cout << "Executing the TaskBn";
co_await sch.suspend();
std::cout << "TaskB is finishedn";
}
int main() {
Scheduler sch;
sch.emplace(TaskA(sch).get_handle());
sch.emplace(TaskB(sch).get_handle());
std::cout << "Start scheduling...n";
sch.schedule();
Birlikte TaskA birlikte TaskB bunlar eşyordamlardır. İçinde mainişlevinde, bir zamanlayıcı oluşturuyorum ve iki görevi (ortak rutin tutamaçları) zamanlayıcıya ekliyorum. Sonra ararım schedule iki aktiviteyi planlamak. Görev, aşağıdaki şekilde tanımlanan bir Coroutine nesnesidir:
struct Task {
struct promise_type {
std::suspend_always initial_suspend() noexcept { return {}; }
std::suspend_always final_suspend() noexcept { return {}; }
Task get_return_object() {
return std::coroutine_handle<promise_type>::from_promise(*this);
}
void return_void() {}
void unhandled_exception() {}
};
Task(std::coroutine_handle<promise_type> handle): handle{handle} {}
auto get_handle() { return handle; }
std::coroutine_handle<promise_type> handle;
};
Her iki fonksiyona da sahip olduğum unutulmamalıdır. initial_suspend hem de operasyonda final_suspend std::suspend_always geri dönmek. Bu gerekli çünkü eşyordamın tüm yürütülmesini zamanlayıcıya devretmek istiyorum. Ben gelene kadar eşyordamlar yürütülmez schedule Aramalar. Zamanlayıcı şu şekilde tanımlanır:
class Scheduler {
//std::queue<std::coroutine_handle<>> _tasks;
std::stack<std::coroutine_handle<>> _tasks;
public:
void emplace(std::coroutine_handle<> task) {
_tasks.push(task);
}
void schedule() {
while(!_tasks.empty()) {
//auto task = _tasks.front();
auto task = _tasks.top();
_tasks.pop();
task.resume();
if(!task.done()) {
_tasks.push(task);
}
else {
task.destroy();
}
}
}
auto suspend() {
return std::suspend_always{};
}
};
Zamanlayıcıda görevleri bir yığında saklıyorum ve dağıtıyorum emplace-Üye işlevi, kullanıcıların bir görevi yığına aktarabilmesini sağlar. İçinde schedule-Üyelik İşlevi Her zaman bir görevi yığından kaldırırım. Bir göreve devam ettiğimde görevin tamamlanıp tamamlanmadığını kontrol ederim. Değilse, daha sonra planlamak üzere görevi tekrar yığına iterim. Aksi halde bitmiş ödevi yok edeceğim. Programı çalıştırdıktan sonra aşağıdaki sonuçlar elde edilir:
Zamanlayıcı, görevleri depolamak için bir yığın (son giren ilk çıkar) kullanır. Yığını bir kuyrukla değiştirirsem (ilk giren ilk çıkar), görevlerin yürütülme sırası değişir:
Bütünlüğü sağlamak adına her iki program da burada tekrar özetlenmiştir:
// stackScheduler.cpp
#include <coroutine>
#include <iostream>
#include <stack>
struct Task {
struct promise_type {
std::suspend_always initial_suspend() noexcept { return {}; }
std::suspend_always final_suspend() noexcept { return {}; }
Task get_return_object() {
return std::coroutine_handle<promise_type>::from_promise(*this);
}
void return_void() {}
void unhandled_exception() {}
};
Task(std::coroutine_handle<promise_type> handle): handle{handle} {}
auto get_handle() { return handle; }
std::coroutine_handle<promise_type> handle;
};
class Scheduler {
std::stack<std::coroutine_handle<>> _tasks;
public:
void emplace(std::coroutine_handle<> task) {
_tasks.push(task);
}
void schedule() {
while(!_tasks.empty()) {
auto task = _tasks.top();
_tasks.pop();
task.resume();
if(!task.done()) {
_tasks.push(task);
}
else {
task.destroy();
}
}
}
auto suspend() {
return std::suspend_always{};
}
};
Task TaskA(Scheduler& sch) {
std::cout << "Hello from TaskAn";
co_await sch.suspend();
std::cout << "Executing the TaskAn";
co_await sch.suspend();
std::cout << "TaskA is finishedn";
}
Task TaskB(Scheduler& sch) {
std::cout << "Hello from TaskBn";
co_await sch.suspend();
std::cout << "Executing the TaskBn";
co_await sch.suspend();
std::cout << "TaskB is finishedn";
}
int main() {
std::cout << 'n';
Scheduler sch;
sch.emplace(TaskA(sch).get_handle());
sch.emplace(TaskB(sch).get_handle());
std::cout << "Start scheduling...n";
sch.schedule();
std::cout << 'n';
}
// queueScheduler.cpp
#include <coroutine>
#include <iostream>
#include <queue>
struct Task {
struct promise_type {
std::suspend_always initial_suspend() noexcept { return {}; }
std::suspend_always final_suspend() noexcept { return {}; }
Task get_return_object() {
return std::coroutine_handle<promise_type>::from_promise(*this);
}
void return_void() {}
void unhandled_exception() {}
};
Task(std::coroutine_handle<promise_type> handle): handle{handle} {}
auto get_handle() { return handle; }
std::coroutine_handle<promise_type> handle;
};
class Scheduler {
std::queue<std::coroutine_handle<>> _tasks;
public:
void emplace(std::coroutine_handle<> task) {
_tasks.push(task);
}
void schedule() {
while(!_tasks.empty()) {
auto task = _tasks.front();
_tasks.pop();
task.resume();
if(!task.done()) {
_tasks.push(task);
}
else {
task.destroy();
}
}
}
auto suspend() {
return std::suspend_always{};
}
};
Task TaskA(Scheduler& sch) {
std::cout << "Hello from TaskAn";
co_await sch.suspend();
std::cout << "Executing the TaskAn";
co_await sch.suspend();
std::cout << "TaskA is finishedn";
}
Task TaskB(Scheduler& sch) {
std::cout << "Hello from TaskBn";
co_await sch.suspend();
std::cout << "Executing the TaskBn";
co_await sch.suspend();
std::cout << "TaskB is finishedn";
}
int main() {
std::cout << 'n';
Scheduler sch;
sch.emplace(TaskA(sch).get_handle());
sch.emplace(TaskB(sch).get_handle());
std::cout << "Start scheduling...n";
sch.schedule();
std::cout << 'n';
}
Sıradaki ne?
Dian-Lun Li’nin bu makalesi eşyordamlar için basit bir zamanlayıcı gösteriyor. Bir sonraki yazımda daha ileri deneyler için Dian-Lun’un zamanlayıcısını kullanacağım.
(harita)
Haberin Sonu