Rename and fix tests

Author: phischu

effekt/jvm/src/test/scala/effekt/ChezSchemeTests.scala

@@ -37,6 +37,7 @@ abstract class ChezSchemeTests extends EffektTests {
     examplesDir / "benchmarks" / "input_output" / "small_files.effekt",
     examplesDir / "benchmarks" / "input_output" / "interleave_promises.effekt",
     examplesDir / "benchmarks" / "input_output" / "financial_format.effekt",
+    examplesDir / "benchmarks" / "input_output" / "server_client.effekt",
 
     // unsafe continuations are not yet supported in our Chez backend
     examplesDir / "pos" / "unsafe_cont.effekt",

effekt/jvm/src/test/scala/effekt/JavaScriptTests.scala

@@ -37,6 +37,8 @@ class JavaScriptTests extends EffektTests {
   override def ignored: Set[File] = super.ignored ++ Set(
     // unsafe cont
     examplesDir / "pos" / "propagators.effekt",
+    // tcp server and client
+    examplesDir / "benchmarks" / "input_output" / "server_client.effekt",
   )
 }
 

examples/benchmarks/input_output/server_client.check

@@ -1 +1 @@
-110
+55

examples/benchmarks/input_output/server_client.effekt

@@ -1,26 +1,27 @@
+import examples/benchmarks/runner
+
 import io
 import io/error
 import io/network
-import io/time
 import bytearray
 
-def main() = {
+def run(n: Int) = {
   with on[IOError].panic
-  val listener = listen("127.0.0.1", 8080);
+
+  val listener = bind("127.0.0.1", 8080);
   spawn(box {
     with on[IOError].panic
-    accept(listener, box { connection =>
+    listen(listener, box { connection =>
       with on[IOError].panic
       val message = "hello world"
       var buffer = bytearray::fromString(message)
       write(connection, buffer, 0, buffer.size())
       close(connection)
   })});
 
-  val results = array::build(10) { i =>
+  val results = array::build(n) { i =>
     promise(box {
       with on[IOError].result
-      wait(1000)
       val connection = connect("127.0.0.1", 8080)
       var buffer = bytearray::allocate(4096)
       val number = read(connection, buffer, 0, 4096)
@@ -36,5 +37,7 @@ def main() = {
 
   shutdown(listener)
 
-  println(total)
+  return total
 }
+
+def main() = benchmark(5){run}

libraries/common/io/network.effekt

@@ -24,11 +24,11 @@ def close(handle: Connection): Unit / Exception[IOError] = {
 /// A tcp listener. Should not be inspected.
 type Listener = Int
 
-def listen(host: String, port: Int): Listener / Exception[IOError] =
-  internal::checkResult(internal::listen(host, port))
+def bind(host: String, port: Int): Listener / Exception[IOError] =
+  internal::checkResult(internal::bind(host, port))
 
-def accept(listener: Listener, handler: Connection => Unit at {io, async, global}): Unit / Exception[IOError] = {
-  internal::checkResult(internal::accept(listener, handler)); ()
+def listen(listener: Listener, handler: Connection => Unit at {io, async, global}): Unit / Exception[IOError] = {
+  internal::checkResult(internal::listen(listener, handler)); ()
 }
 
 def shutdown(listener: Listener): Unit / Exception[IOError] = {
@@ -42,8 +42,8 @@ namespace internal {
     declare void @c_tcp_read(%Int, %Pos, %Int, %Int, %Stack)
     declare void @c_tcp_write(%Int, %Pos, %Int, %Int, %Stack)
     declare void @c_tcp_close(%Int, %Stack)
-    declare void @c_tcp_listen(%Pos, %Int, %Int, %Stack)
-    declare void @c_tcp_accept(%Int, %Pos, %Stack)
+    declare void @c_tcp_bind(%Pos, %Int, %Int, %Stack)
+    declare void @c_tcp_listen(%Int, %Pos, %Stack)
     declare void @c_tcp_shutdown(%Int, %Stack)
   """
 
@@ -73,15 +73,15 @@ namespace internal {
       ret void
     """
 
-  extern async def listen(host: String, port: Int): Int =
+  extern async def bind(host: String, port: Int): Int =
     llvm """
-      call void @c_tcp_listen(%Pos ${host}, %Int ${port}, %Stack %stack)
+      call void @c_tcp_bind(%Pos ${host}, %Int ${port}, %Stack %stack)
       ret void
     """
 
-  extern async def accept(listener: Int, handler: Int => Unit at {io, async, global}): Int =
+  extern async def listen(listener: Int, handler: Int => Unit at {io, async, global}): Int =
     llvm """
-      call void @c_tcp_accept(%Int ${listener}, %Pos ${handler}, %Stack %stack)
+      call void @c_tcp_listen(%Int ${listener}, %Pos ${handler}, %Stack %stack)
       ret void
     """
 

libraries/llvm/io.c

@@ -317,7 +317,7 @@ void c_tcp_close(Int handle, Stack stack) {
     uv_close(uv_handle, c_tcp_close_cb);
 }
 
-void c_tcp_listen(String host, Int port, Stack stack) {
+void c_tcp_bind(String host, Int port, Stack stack) {
     // TODO make non-async
     char* host_str = c_bytearray_into_nullterminated_string(host);
     erasePositive(host);
@@ -355,16 +355,16 @@ void c_tcp_listen(String host, Int port, Stack stack) {
 typedef struct {
     Stack stack;
     struct Pos handler;
-} tcp_accept_closure_t;
+} tcp_listen_closure_t;
 
-void c_tcp_accept_cb(uv_stream_t* server, int status) {
-    tcp_accept_closure_t* accept_closure = (tcp_accept_closure_t*)server->data;
+void c_tcp_listen_cb(uv_stream_t* server, int status) {
+    tcp_listen_closure_t* listen_closure = (tcp_listen_closure_t*)server->data;
 
     if (status < 0) {
         // TODO resume last
-        erasePositive(accept_closure->handler);
-        resume_Int(accept_closure->stack, status);
-        free(accept_closure);
+        erasePositive(listen_closure->handler);
+        resume_Int(listen_closure->stack, status);
+        free(listen_closure);
         server->data = NULL;
         return;
     }
@@ -375,9 +375,9 @@ void c_tcp_accept_cb(uv_stream_t* server, int status) {
     if (result < 0) {
         // TODO resume last
         free(client);
-        erasePositive(accept_closure->handler);
-        resume_Int(accept_closure->stack, result);
-        free(accept_closure);
+        erasePositive(listen_closure->handler);
+        resume_Int(listen_closure->stack, result);
+        free(listen_closure);
         server->data = NULL;
         return;
     }
@@ -386,28 +386,28 @@ void c_tcp_accept_cb(uv_stream_t* server, int status) {
     if (result < 0) {
         // TODO resume last
         uv_close((uv_handle_t*)client, (uv_close_cb)free);
-        erasePositive(accept_closure->handler);
-        resume_Int(accept_closure->stack, result);
-        free(accept_closure);
+        erasePositive(listen_closure->handler);
+        resume_Int(listen_closure->stack, result);
+        free(listen_closure);
         server->data = NULL;
         return;
     }
 
-    sharePositive(accept_closure->handler);
-    run_Int(accept_closure->handler, (int64_t)client);
+    sharePositive(listen_closure->handler);
+    run_Int(listen_closure->handler, (int64_t)client);
 }
 
-void c_tcp_accept(Int listener, struct Pos handler, Stack stack) {
+void c_tcp_listen(Int listener, struct Pos handler, Stack stack) {
     uv_stream_t* server = (uv_stream_t*)listener;
 
-    tcp_accept_closure_t* accept_closure = malloc(sizeof(tcp_accept_closure_t));
-    accept_closure->stack = stack;
-    accept_closure->handler = handler;
-    server->data = accept_closure;
+    tcp_listen_closure_t* listen_closure = malloc(sizeof(tcp_listen_closure_t));
+    listen_closure->stack = stack;
+    listen_closure->handler = handler;
+    server->data = listen_closure;
 
-    int result = uv_listen(server, SOMAXCONN, c_tcp_accept_cb);
+    int result = uv_listen(server, SOMAXCONN, c_tcp_listen_cb);
     if (result < 0) {
-        free(accept_closure);
+        free(listen_closure);
         erasePositive(handler);
         resume_Int(stack, result);
         return;
@@ -417,13 +417,13 @@ void c_tcp_accept(Int listener, struct Pos handler, Stack stack) {
 void c_tcp_shutdown(Int handle, Stack stack) {
     uv_handle_t* uv_handle = (uv_handle_t*)handle;
 
-    tcp_accept_closure_t* accept_closure = (tcp_accept_closure_t*)uv_handle->data;
-    if (accept_closure) {
+    tcp_listen_closure_t* listen_closure = (tcp_listen_closure_t*)uv_handle->data;
+    if (listen_closure) {
         // TODO what to resume with
         // TODO resume last
-        resume_Int(accept_closure->stack, 0);
-        erasePositive(accept_closure->handler);
-        free(accept_closure);
+        resume_Int(listen_closure->stack, 0);
+        erasePositive(listen_closure->handler);
+        free(listen_closure);
     }
 
     uv_handle->data = stack;