just need to move the work, we need to prevent blocking on our event-handling threads. void event_handler(){ auto handle=spawn_background_task(); handle.wait(); // no benefit }Aside: Non-Blocking vs Lock-free event handler Pass data to a dedicated background threadHow do we move work off the current thread? Possible ways to move the work off the current thread: Spawn a new thread for each event handler Pass thread? Possible ways to move the work off the current thread: Spawn a new thread for each event handler Pass data to a dedicated background thread Submit tasks to a generic thread pool Submit tasks to

std::vector dA{ … }, dB{ … }, dO{ … }; try { sycl::queue gpuQueue{sycl::gpu_selector_v, async_handler{}}; sycl::buffer bufA{dA.data(), sycl::range{dA.size()}}; sycl::buffer bufB{dB.data() size()}}; sycl::buffer bufO{dO.data(), sycl::range{dO.size()}}; gpuQueue.submit([&](sycl::handler &cgh){ sycl::accessor inA(bufA, cgh, sycl::read_only); sycl::accessor inB(bufB, cgh std::vector dA{ … }, dB{ … }, dO{ … }; try { sycl::queue gpuQueue{sycl::gpu_selector_v, async_handler{}}; sycl::buffer bufA{dA.data(), sycl::range{dA.size()}}; sycl::buffer bufB{dB.data()

logs a message to stdout & terminates contract_assert(false); // calls the contract-violation handler95 Copyright (c) Timur Doumler | @timur_audio | https://timur.audio What happens when to stdout & terminates contract_assert(false); // calls the contract-violation handler // -> default handler: // logs a message to stdout & terminates96 Copyright (c) Timur Doumler | the contract-violation handler • cassert: impossible • custom assertion macros: possible, but not across components • P2900 contracts: possible, you can define one handler for the entire program

363738Add simple debug handler namespace async_trace { template bool handled{}; 1 2 3 4 5 struct debug_handler { 6 template 14 inline auto async::injected_debug_handler<> = async_trace::debug_handler{}; 15 39Add simple debug handler namespace async_trace { template bool handled{}; 1 2 3 4 5 struct debug_handler { 6 template 7 constexpr auto signal(auto

expensive • 2 types of unwinding • Frame-based • Table-based Catching exceptions : • exception handler is from a point previously passed by the execution • Use RTTI to do polymorphic catching of exceptions unwinding, your program is terminated. • Caught by a matching handler, the exception is no longer in flight unless rethrown. • If no matching handler is found, the function std::terminate is invoked; whether in handler and rethrow Logging reported deep in stack instead of at handler site 2. Repackage the Exception as a different type with additional information and rethrow Logging reported at handler site

Ciura | @ciura_victor - Exceptional C++ 21 SEH 🤪 int * p = nullptr; *p = 5; SEH interrupt handler2021 Victor Ciura | @ciura_victor - Exceptional C++ 22 What's next? SEH 🔥 🚫 🚫 React / PEXCEPTION_REGISTRATION_RECORD Next; PEXCEPTION_DISPOSITION Handler; } EXCEPTION_REGISTRATION_RECORD Next * Handler MyHandler1()2021 Victor Ciura | @ciura_victor - Exceptional C++ 32 EXCEPTION_REGISTRATION_RECORD Next * Handler MyHandler1() EXCEPTION_REGISTRATION_RECORD Next * Handler MyHandler2() EXCEPTION_REGISTRATION_RECORD Next 0xFFFF'FFFF Handler MyHandler3()2021 Victor Ciura

CppCon 2023-10-03 21JSON SAX parser Idea: Parser invokes handler. auto parse_json(std::ranges::input_range auto json, json_handler& handler) -> std::optional; Jonathan Müller — @foonathan Express object_end Jonathan Müller — @foonathan Express your expectations CppCon 2023-10-03 23JSON handler struct json_handler { virtual void on_null() {} virtual void on_bool(bool v) {} virtual void on_number(std::int64_t SAX API class Reader { public: template Handler> bool Parse(InputStream& is, Handler& handler); }; Jonathan Müller — @foonathan Express your expectations CppCon 2023-10-03

to a compute resource (aka, scheduler) • A unit of lazy async work (aka, sender) • A completion handler (aka, receiver) • A small, initial set of generic async algorithms: • E.g., then, when_all, sync_wait ranges beg asynchronous range adaptors.102 Step 3: Model Ctrl-C as a sender103 struct ctrl_c_handler { struct pending { virtual void complete() = 0; virtual ~pending() {} }; static inline pending->complete(); } return TRUE; } ctrl_c_handler() { BOOL result = ::SetConsoleCtrlHandler(&consoleHandler,TRUE); assert(result); } ~ctrl_c_handler() { BOOL result = ::SetConsoleCtrlHa

8Completion Handler Storage Asynchronous operations must store the final completion handler Composed asynchronous operations store final completion handler in intermediate completion handler which is longer foist the responsibility for storage onto the next layer 9Completion Handler Storage Options Since completion handler could be of any invocable type must use type erased wrapper std::function boilerplate Returns correct type & value for completion token Initiation receives completion handler & trailing arguments Supports lazy/deferred initiation strategies 14async_wait template

0 码力 | 35 页 | 900.82 KB | 6 月前

3

return month_names[month-1]; } #ifndef NDEBUG #define pre(expr) do{ if(!(expr)){ violation_handler({#expr}); } } while(false) #else #define pre(expr) do{} while(false) #endifstd::string month_as_string(int return month_names[month-1]; } #ifndef NDEBUG #define pre(expr) do{ if(!(expr)){ violation_handler({#expr}); } } while(false) #else #define pre(expr) do{} while(false) #endifstruct ViolationInfo{ default_violation_handler(ViolationInfo const& info) { std::print("{}", info.make_message()); std::abort(); } auto violation_handler = &default_violation_handler;void throwing_violation_handler(ViolationInfo