Make coroutine_finish private and never free any memory

The memory is going to be deallocated by the OS anyway. We already
reuse the memory of dead coroutines anyway. Not care about deallocation
greatly simplifies the code.

Author: rexim

coroutine.c

@@ -198,31 +198,18 @@ void coroutine_switch_context(void *rsp, Sleep_Mode sm, int fd)
     coroutine_restore_context(contexts.items[active.items[current]].rsp);
 }
 
+// TODO: think how to get rid of coroutine_init() call at all
 void coroutine_init(void)
 {
     if (contexts.count != 0) return;
     da_append(&contexts, (Context){0});
     da_append(&active, 0);
 }
 
-void coroutine_finish(void)
+void coroutine__finish_current(void)
 {
-    if (contexts.count == 0) return;
     if (active.items[current] == 0) {
-        for (size_t i = 1; i < contexts.count; ++i) {
-            munmap(contexts.items[i].stack_base, STACK_CAPACITY);
-        }
-        free(contexts.items);
-        free(active.items);
-        free(dead.items);
-        free(polls.items);
-        free(asleep.items);
-        memset(&contexts,  0, sizeof(contexts));
-        memset(&active,    0, sizeof(active));
-        memset(&dead,      0, sizeof(dead));
-        memset(&polls,     0, sizeof(polls));
-        memset(&asleep,    0, sizeof(asleep));
-        return;
+        UNREACHABLE("Main Coroutine with id == 0 should never reach this place");
     }
 
     da_append(&dead, active.items[current]);
@@ -264,7 +251,7 @@ void coroutine_go(void (*f)(void*), void *arg)
 
     void **rsp = (void**)((char*)contexts.items[id].stack_base + STACK_CAPACITY);
     // @arch
-    *(--rsp) = coroutine_finish;
+    *(--rsp) = coroutine__finish_current;
     *(--rsp) = f;
     *(--rsp) = arg; // push rdi
     *(--rsp) = 0;   // push rbx

coroutine.h

@@ -37,11 +37,6 @@ extern "C" {
 // TODO: Allow calling it twice, 'cause why not?!
 void coroutine_init(void);
 
-// Finish the currently running coroutine. When called in the main coroutine
-// with id = 0 uninitializes the whole runtime of the library, deallocating all
-// the memory, and killing all the currently running coroutines.
-void coroutine_finish(void);
-
 // Switch to the next coroutine. The execution will continue starting from
 // coroutine_yield() (or any other flavor of it like coroutine_sleep_read() or
 // coroutine_sleep_write) call of another coroutine.

examples/counter.c

@@ -17,9 +17,8 @@ void counter(void *arg)
 int main()
 {
     coroutine_init();
-        coroutine_go(&counter, (void*)5);
-        coroutine_go(&counter, (void*)10);
-        while (coroutine_alive() > 1) coroutine_yield();
-    coroutine_finish();
+    coroutine_go(&counter, (void*)5);
+    coroutine_go(&counter, (void*)10);
+    while (coroutine_alive() > 1) coroutine_yield();
     return 0;
 }

examples/counter.c3

@@ -13,9 +13,8 @@ fn void counter(void* arg) {
 
 fn void main() {
     coroutine::init();
-    defer coroutine::finish();
     coroutine::go(fn void(void *arg) {
-        io::printfn("[%d], Hello from C3 Lambda", coroutine::id());
+        io::printfn("[%d] Hello from C3 Lambda", coroutine::id());
     });
     coroutine::go(&counter, (void*)5);
     coroutine::go(&counter, (void*)10);

examples/counter.cpp

@@ -20,6 +20,5 @@ int main()
     coroutine_go(counter, reinterpret_cast<void*>(5));
     coroutine_go(counter, reinterpret_cast<void*>(10));
     while (coroutine_alive() > 1) coroutine_yield();
-    coroutine_finish();
     return 0;
 }

examples/counter.jai

@@ -6,7 +6,6 @@ coroutine_sleep_read :: (fd: int) #foreign coroutine;
 coroutine_sleep_write :: (fd: int) #foreign coroutine;
 coroutine_wake_up :: (id: int) #foreign coroutine;
 coroutine_init :: () #foreign coroutine;
-coroutine_finish :: () #foreign coroutine;
 coroutine_yield :: () #foreign coroutine;
 coroutine_go :: (f: (*void) #c_call, arg: *void = null) #foreign coroutine;
 coroutine_id :: () -> int #foreign coroutine;
@@ -24,7 +23,6 @@ counter :: (arg: *void) #c_call {
 
 main :: () {
     coroutine_init();
-    defer coroutine_finish();
     coroutine_go((arg: *void) #c_call {
         push_context {
             print("[%] Hello from Jai Lambda\n", coroutine_id());
@@ -45,7 +43,6 @@ main :: () {
     });
 
     coroutine_init();
-    defer coroutine_finish();
     coroutine_go((arg: *void) #c_call {
         push_context {
             for 0..5 {

examples/echo.c3

@@ -9,7 +9,6 @@ usz server_id = 0;
 
 fn void main() {
     coroutine::init();
-    defer coroutine::finish();
 
     server_id = coroutine::id();
 

examples/lexer.c

@@ -63,23 +63,20 @@ int main(int argc, char* argv[]){
     }
 
     coroutine_init();
-    {
-        coroutine_go(lex, argv[1]);
+    coroutine_go(lex, argv[1]);
 
-        // Consume those tokens
-        bool quit = false;
-        while(!quit && coroutine_alive() > 1){
-            // Yield control to the lexer.
-            // It will lex and yield control back to here.
-            coroutine_yield();
-            switch(token_kind){
-                case TK_INT: { printf("TK_INT: %d\n", token_value.tk_int); } break;
-                case TK_OP:  { printf("TK_OP:  %c\n", token_value.tk_op); } break;
-                default:     { printf("Done!\n"); quit = true; } break;
-            }
+    // Consume those tokens
+    bool quit = false;
+    while(!quit && coroutine_alive() > 1){
+        // Yield control to the lexer.
+        // It will lex and yield control back to here.
+        coroutine_yield();
+        switch(token_kind){
+            case TK_INT: { printf("TK_INT: %d\n", token_value.tk_int); } break;
+            case TK_OP:  { printf("TK_OP:  %c\n", token_value.tk_op); } break;
+            default:     { printf("Done!\n"); quit = true; } break;
         }
     }
-    coroutine_finish();
 
     return 0;
 }