From 469a822cc6d68feb5cf5c4e3fe4785e6d71fb64c Mon Sep 17 00:00:00 2001 From: Sebastian Ullrich Date: Fri, 4 Sep 2020 14:00:06 +0200 Subject: [PATCH] chore: checkInterrupted ~> checkCanceled, requestInterrupt ~> cancel --- src/include/lean/lean.h | 12 ++++++------ src/include/lean/object.h | 8 ++------ src/runtime/object.cpp | 20 ++++++++++---------- src/tests/util/object.cpp | 12 ++++++------ 4 files changed, 24 insertions(+), 28 deletions(-) diff --git a/src/include/lean/lean.h b/src/include/lean/lean.h index 9623bf2b07..a9a6d92121 100644 --- a/src/include/lean/lean.h +++ b/src/include/lean/lean.h @@ -211,7 +211,7 @@ typedef struct { struct lean_task * m_head_dep; struct lean_task * m_next_dep; unsigned m_prio; - uint8_t m_interrupted; + uint8_t m_canceled; // If true, task will not be freed until finished uint8_t m_keep_alive; uint8_t m_deleted; @@ -1189,13 +1189,13 @@ static inline lean_obj_res lean_task_get_own(lean_obj_arg t) { return r; } -/* primitive for implementing `IO.checkInterrupt : IO bool` */ -bool lean_io_check_interrupt_core(); -/* primitive for implementing `IO.requestInterrupt : Task a -> IO Unit` */ -void lean_io_request_interrupt_core(b_lean_obj_arg t); +/* primitive for implementing `IO.checkCanceled : IO Bool` */ +bool lean_io_check_canceled_core(); +/* primitive for implementing `IO.cancel : Task a -> IO Unit` */ +void lean_io_cancel_core(b_lean_obj_arg t); /* primitive for implementing `IO.hasFinished : Task a -> IO Unit` */ bool lean_io_has_finished_core(b_lean_obj_arg t); -/* primitive for implementing `IO.waitAny : List (Task a) -> IO (Task a) */ +/* primitive for implementing `IO.waitAny : List (Task a) -> IO (Task a)` */ b_lean_obj_res lean_io_wait_any_core(b_lean_obj_arg task_list); /* External objects */ diff --git a/src/include/lean/object.h b/src/include/lean/object.h index 49a8984b7c..906486ba00 100644 --- a/src/include/lean/object.h +++ b/src/include/lean/object.h @@ -304,13 +304,9 @@ inline obj_res task_bind(obj_arg x, obj_arg f, unsigned prio = 0, bool keep_aliv inline obj_res task_map(obj_arg f, obj_arg t, unsigned prio = 0, bool keep_alive = false) { return lean_task_map_with_prio(f, t, prio, keep_alive); } inline b_obj_res task_get(b_obj_arg t) { return lean_task_get(t); } -/* primitive for implementing `io.check_interrupt : io bool` */ -inline bool io_check_interrupt_core() { return lean_io_check_interrupt_core(); } -/* primitive for implementing `io.request_interrupt : task A -> io unit` */ -inline void io_request_interrupt_core(b_obj_arg t) { return lean_io_request_interrupt_core(t); } -/* primitive for implementing `io.has_finished : task A -> io unit` */ +inline bool io_check_canceled_core() { return lean_io_check_canceled_core(); } +inline void io_cancel_core(b_obj_arg t) { return lean_io_cancel_core(t); } inline bool io_has_finished_core(b_obj_arg t) { return lean_io_has_finished_core(t); } -/* primitive for implementing `io.wait_any : list (task A) -> io (task A) */ inline b_obj_res io_wait_any_core(b_obj_arg task_list) { return lean_io_wait_any_core(task_list); } // ======================================= diff --git a/src/runtime/object.cpp b/src/runtime/object.cpp index 8be6099cbe..bc5fcc2a80 100644 --- a/src/runtime/object.cpp +++ b/src/runtime/object.cpp @@ -623,7 +623,7 @@ static lean_task_imp * alloc_task_imp(obj_arg c, unsigned prio, bool keep_alive) imp->m_head_dep = nullptr; imp->m_next_dep = nullptr; imp->m_prio = prio; - imp->m_interrupted = false; + imp->m_canceled = false; imp->m_keep_alive = keep_alive; imp->m_deleted = false; return imp; @@ -772,8 +772,8 @@ class task_manager { lean_task_object * it = t->m_imp->m_head_dep; t->m_imp->m_head_dep = nullptr; while (it) { - if (t->m_imp->m_interrupted) - it->m_imp->m_interrupted = true; + if (t->m_imp->m_canceled) + it->m_imp->m_canceled = true; lean_task_object * next_it = it->m_imp->m_next_dep; it->m_imp->m_next_dep = nullptr; if (it->m_imp->m_deleted) { @@ -806,7 +806,7 @@ public: for (worker_info * info : m_workers) { if (info->m_task) { lean_assert(info->m_task->m_imp); - info->m_task->m_imp->m_interrupted = true; + info->m_task->m_imp->m_canceled = true; } } m_shutting_down = true; @@ -883,10 +883,10 @@ public: } } - void request_interrupt(lean_task_object * t) { + void cancel(lean_task_object * t) { unique_lock lock(m_mutex); if (t->m_imp) - t->m_imp->m_interrupted = true; + t->m_imp->m_canceled = true; } }; @@ -1032,18 +1032,18 @@ extern "C" obj_res lean_task_bind_with_prio(obj_arg x, obj_arg f, unsigned prio, } } -extern "C" bool lean_io_check_interrupt_core() { +extern "C" bool lean_io_check_canceled_core() { if (lean_task_object * t = g_current_task_object) { lean_assert(t->m_imp); // task is being executed - return t->m_imp->m_interrupted; + return t->m_imp->m_canceled; } return false; } -extern "C" void lean_io_request_interrupt_core(b_obj_arg t) { +extern "C" void lean_io_cancel_core(b_obj_arg t) { if (lean_to_task(t)->m_value) return; - g_task_manager->request_interrupt(lean_to_task(t)); + g_task_manager->cancel(lean_to_task(t)); } extern "C" bool lean_io_has_finished_core(b_obj_arg t) { diff --git a/src/tests/util/object.cpp b/src/tests/util/object.cpp index 89c7e465dd..f3dc49e0d5 100644 --- a/src/tests/util/object.cpp +++ b/src/tests/util/object.cpp @@ -200,7 +200,7 @@ void tst6() { obj_res task4_fn(obj_arg) { show_msg("task 4 started...\n"); - while (!io_check_interrupt_core()) { + while (!io_check_canceled_core()) { show_msg("task 4 loop...\n"); this_thread::sleep_for(std::chrono::milliseconds(10)); } @@ -215,7 +215,7 @@ void tst7() { std::cout << "task4 has finished: " << io_has_finished_core(task4.raw()) << "\n"; this_thread::sleep_for(std::chrono::milliseconds(100)); show_msg("request interrupt...\n"); - io_request_interrupt_core(task4.raw()); + io_cancel_core(task4.raw()); object * r = task_get(task4.raw()); std::cout << "task4 has finished after get: " << io_has_finished_core(task4.raw()) << "\n"; std::cout << "r: " << unbox(r) << "\n"; @@ -250,7 +250,7 @@ void tst8() { } obj_res loop_until_interrupt_fn(obj_arg) { - while (!io_check_interrupt_core()) { + while (!io_check_canceled_core()) { this_thread::sleep_for(std::chrono::milliseconds(1)); } return box(0); @@ -283,8 +283,8 @@ void tst9() { show_msg("wait_any returned...\n"); object * v = task_get(t); lean_assert(unbox(v) == 42); - io_request_interrupt_core(t1.raw()); - io_request_interrupt_core(t2.raw()); + io_cancel_core(t1.raw()); + io_cancel_core(t2.raw()); task_get(t1.raw()); task_get(t2.raw()); } @@ -315,7 +315,7 @@ void tst11() { static atomic g_finished; obj_res loop_until_interrupt_fn2(obj_arg) { - while (!io_check_interrupt_core()) { + while (!io_check_canceled_core()) { this_thread::sleep_for(std::chrono::milliseconds(1)); } g_finished = true;