Delimited continuations manipulate the control flow of programs. Similar to control structures like conditionals or loops they allow to deviate from a sequential flow of control.
We use exception handling as another example for control flow manipulation and later show how to implement it using delimited continuations. Finally, we show that nondeterminism can also be expressed using delimited continuations.
| #define _CRT_SECURE_NO_DEPRECATE | |
| #include <stdio.h> | |
| #include <string.h> | |
| #include <Windows.h> | |
| // This allocates a "magic ring buffer" that is mapped twice, with the two | |
| // copies being contiguous in (virtual) memory. The advantage of this is | |
| // that this allows any function that expects data to be contiguous in | |
| // memory to read from (or write to) such a buffer. It also means that |
| #include <stdio.h> | |
| #define STR2(x) #x | |
| #define STR(x) STR2(x) | |
| #ifdef _WIN32 | |
| #define INCBIN_SECTION ".rdata, \"dr\"" | |
| #else | |
| #define INCBIN_SECTION ".rodata" | |
| #endif |
| struct Xeno_Win64CallContext { | |
| void *function_pointer; | |
| uint64_t integer_return_value; | |
| uint64_t floating_point_return_value; | |
| uint64_t register_arguments[4]; | |
| uint64_t *stack_arguments; | |
| size_t stack_arguments_count; | |
| }; | |
| extern "C" void Xeno_Win64Call(Xeno_Win64CallContext *context); |
| typedef int task_t; // Lower bits as table index, upper bits as generation counter for use-after-free detection. | |
| typedef void (*task_function_t)(void *task_data); | |
| task_t task_create(task_function_t task_function, void *task_data); | |
| void task_depends(task_t task, task_t dependency); | |
| void task_start(task_t task); | |
| Upon completion, tasks signal their dependencies and are released. | |
| Memory requirements for a minimal implementation: 16/24 bytes per task and 8 bytes per dependency edge. | |
| Even so, you still don't want to have one task instance for every array entry in a gigabyte array. Always assign |
| NOTE: I'm not necessarily advocating this as the way to make your compiler go fast. Priority 1 is to make | |
| full recompilation as fast as possible, ideally on the order of 100 MB/s per core with everything in memory. | |
| Once you get it that fast, there's probably no need for incremental techniques, even if you want to | |
| recompile entire files in real-time as the programmer types in code. But these incremental algorithms are | |
| interesting computer science, so you should learn about them, and they are certainly applicable elsewhere. | |
| After watching an interview with Anders Hejlsberg last year in which he mentioned the incremental | |
| compilation techniques they used in their new C# and TypeScript compilers, I spent a bit of time studying | |
| their open source code (and it's great that MS now makes this stuff available for people to peruse). |
Note: a lot of programmers talk about UI without mentionning the user even once, as if it was entirely a programming problem. I wonder what we’re leaving off the table when we do that.
| typedef struct { | |
| char *address; | |
| char *reference; | |
| } label_t; | |
| void emit_label_reference(label_t *label) { | |
| if (label->address) { | |
| emit4(label->address - emit_pointer); | |
| } else { | |
| char *reference = emit_pointer; |
I've been trying to get clarity on to what extent the position-independent data structure tricks in Gob (https://gist.github.com/pervognsen/c25a039fcf8c256141ef0778a1b32a88) are legal or illegal according to the C standard. I always had the impression it would run afoul of strict aliasing or pointer casting restrictions, but I've been digging into the standard, and now I'm no longer so sure. It might be perfectly legal after all?
Here's section 6.3.2.3 on pointer conversions from the C99 draft standard. I'll be referencing the C99 standard throughout this article, but I've verified that the C11 standard hasn't changed in the relevant areas.
"5 An integer may be converted to any pointer type. Except as previously specified, the result is implementation-defined, might not be correctly aligned, might not point to an entity of the referenced type, and might be a trap representation. [56]
6 Any pointer type may be converted to an integer type. Except as previously specified, the result is implementation-defined
An inline image version of Matt Walker's translation of CEDEC 2017 talks by Nintendo. (I've added italic content.)
Covers four talks:
