Added fearless FFI!

Verdagon · Verdagon · commit f6ff79d29426 · 2022-04-26T15:15:58.000-04:00
diff --git a/Backend/src/function/expressions/externs.cpp b/Backend/src/function/expressions/externs.cpp
@@ -281,16 +281,26 @@ Ref buildExternCall(
       buildFlare(FL(), globalState, functionState, builder, "Return ptr! ", ptrToIntLE(globalState, builder, localPtrLE));
       hostArgsLE.insert(hostArgsLE.begin(), localPtrLE);
 
-      auto resultLE =
-          buildSideCall(
-              globalState, hostReturnRefLT, builder, sideStackI8PtrLE, externFuncL, hostArgsLE);
-      assert(LLVMTypeOf(resultLE) == LLVMVoidTypeInContext(globalState->context));
-
+      if (globalState->opt->enableSideCalling) {
+        auto resultLE =
+            buildSideCall(
+                globalState, LLVMVoidTypeInContext(globalState->context), builder, sideStackI8PtrLE, externFuncL,
+                hostArgsLE);
+        assert(LLVMTypeOf(resultLE) == LLVMVoidTypeInContext(globalState->context));
+      } else {
+        auto resultLE = buildCall(globalState, builder, externFuncL, hostArgsLE);
+        assert(LLVMTypeOf(resultLE) == LLVMVoidTypeInContext(globalState->context));
+      }
       hostReturnLE = LLVMBuildLoad(builder, localPtrLE, "hostReturn");
       buildFlare(FL(), globalState, functionState, builder, "Loaded the return! ", LLVMABISizeOfType(globalState->dataLayout, LLVMTypeOf(hostReturnLE)));
     } else {
-      hostReturnLE =
-          buildSideCall(globalState, hostReturnRefLT, builder, sideStackI8PtrLE, externFuncL, hostArgsLE);
+      if (globalState->opt->enableSideCalling) {
+        hostReturnLE =
+            buildSideCall(globalState, hostReturnRefLT, builder, sideStackI8PtrLE, externFuncL, hostArgsLE);
+      } else {
+        hostReturnLE =
+            buildCall(globalState, builder, externFuncL, hostArgsLE);
+      }
     }
 
     buildFlare(FL(), globalState, functionState, builder, "Done calling function ", prototype->name->name);
diff --git a/Backend/src/function/expressions/shared/shared.cpp b/Backend/src/function/expressions/shared/shared.cpp
@@ -675,7 +675,7 @@ LLVMValueRef buildSideCall(
       //buildPrint(globalState, entryBuilder, "\n");
     }
   } else {
-    callResultAfterReturnLE = makeVoid(globalState);
+    callResultAfterReturnLE = LLVMGetUndef(LLVMVoidTypeInContext(globalState->context));
   }
 
   //buildPrint(globalState, entryBuilder, "Done!\n");
diff --git a/Backend/src/globalstate.cpp b/Backend/src/globalstate.cpp
@@ -116,6 +116,8 @@ IRegion* GlobalState::getRegion(RegionId* regionId) {
     return rcImm;
   } else if (regionId == metalCache->linearRegionId) {
     return linearRegion;
+  } else if (regionId == metalCache->mutRegionId) {
+    return mutRegion;
 //  } else if (regionId == metalCache->unsafeRegionId) {
 //    return unsafeRegion;
 //  } else if (regionId == metalCache->assistRegionId) {
diff --git a/Backend/src/mainFunction.cpp b/Backend/src/mainFunction.cpp
@@ -223,17 +223,23 @@ LLVMValueRef makeEntryFunction(
   LLVMBuildStore(entryBuilder, numArgsLE, globalState->numMainArgs);
   LLVMBuildStore(entryBuilder, argsLE, globalState->mainArgs);
 
-  LLVMBuildStore(
-      entryBuilder,
-      buildCall(globalState, entryBuilder, globalState->externs->malloc, {
-          constI64LE(globalState, STACK_SIZE)
-      }),
-      globalState->sideStack);
+  if (globalState->opt->enableSideCalling) {
+    LLVMBuildStore(
+        entryBuilder,
+        buildCall(
+            globalState, entryBuilder, globalState->externs->malloc,
+            { constI64LE(globalState, STACK_SIZE) }),
+        globalState->sideStack);
+  }
 
   auto calleeUserFunction = globalState->lookupFunction(valeMainPrototype);
   auto resultLE = buildCall(globalState, entryBuilder, calleeUserFunction, {});
 
-  buildPrint(globalState, entryBuilder, "Done!\n");
+  if (globalState->opt->enableSideCalling) {
+    buildCall(
+        globalState, entryBuilder, globalState->externs->free,
+        { LLVMBuildLoad(entryBuilder, globalState->sideStack, "") });
+  }
 
   LLVMBuildRet(entryBuilder, resultLE);
   LLVMDisposeBuilder(entryBuilder);
diff --git a/Backend/src/vale.cpp b/Backend/src/vale.cpp
@@ -847,7 +847,7 @@ void compileValeCode(GlobalState* globalState, std::vector<std::string>& inputFi
       globalState->mutRegion = new Assist(globalState);
       break;
     case RegionOverride::NAIVE_RC:
-      globalState->mutRegion = new NaiveRC(globalState, globalState->metalCache->rcImmRegionId);
+      globalState->mutRegion = new NaiveRC(globalState, globalState->metalCache->mutRegionId);
       break;
     case RegionOverride::FAST:
       globalState->mutRegion = new Unsafe(globalState);
diff --git a/Backend/src/valeopts.cpp b/Backend/src/valeopts.cpp
@@ -49,6 +49,7 @@ enum
     OPT_OVERRIDE_KNOWN_LIVE_TRUE,
     OPT_PRINT_MEM_OVERHEAD,
     OPT_ENABLE_REPLAYING,
+    OPT_ENABLE_SIDE_CALLING,
     OPT_CENSUS,
     OPT_REGION_OVERRIDE,
     OPT_FILENAMES,
@@ -95,6 +96,7 @@ static opt_arg_t args[] =
     { "override_known_live_true", '\0', OPT_ARG_NONE, OPT_OVERRIDE_KNOWN_LIVE_TRUE },
     { "print_mem_overhead", '\0', OPT_ARG_OPTIONAL, OPT_PRINT_MEM_OVERHEAD },
     { "enable_replaying", '\0', OPT_ARG_OPTIONAL, OPT_ENABLE_REPLAYING },
+    { "enable_side_calling", '\0', OPT_ARG_OPTIONAL, OPT_ENABLE_SIDE_CALLING },
     { "census", '\0', OPT_ARG_OPTIONAL, OPT_CENSUS },
     { "region_override", '\0', OPT_ARG_REQUIRED, OPT_REGION_OVERRIDE },
     { "ir", '\0', OPT_ARG_NONE, OPT_IR },
@@ -278,14 +280,25 @@ int valeOptSet(ValeOptions *opt, int *argc, char **argv) {
           case OPT_ENABLE_REPLAYING: {
             if (!s.arg_val) {
               opt->enableReplaying = true;
-            } else if (s.arg_val == std::string("on")) {
+            } else if (s.arg_val == std::string("true")) {
               opt->enableReplaying = true;
-            } else if (s.arg_val == std::string("off")) {
+            } else if (s.arg_val == std::string("false")) {
               opt->enableReplaying = false;
             } else assert(false);
             break;
           }
 
+          case OPT_ENABLE_SIDE_CALLING: {
+            if (!s.arg_val) {
+              opt->enableSideCalling = true;
+            } else if (s.arg_val == std::string("true")) {
+              opt->enableSideCalling = true;
+            } else if (s.arg_val == std::string("false")) {
+              opt->enableSideCalling = false;
+            } else assert(false);
+            break;
+          }
+
         case OPT_CENSUS: {
           if (!s.arg_val) {
             opt->census = true;
diff --git a/Backend/src/valeopts.h b/Backend/src/valeopts.h
@@ -49,6 +49,7 @@ struct ValeOptions {
     bool overrideKnownLiveTrue = false;    // Enables generational heap
     bool printMemOverhead = false;    // Enables generational heap
     bool enableReplaying = false;    // Enables deterministic replaying
+    bool enableSideCalling = false;    // Enables side calling, used for fearless FFI
 
     RegionOverride regionOverride = RegionOverride::ASSIST;
 };
diff --git a/Backend/test/tethercrash.vale b/Backend/test/tethercrash.vale
@@ -3,7 +3,7 @@ import stdlib.*;
 struct Spaceship {
   fuel int;
 }
-func main() int export {
+exported func main() int {
   print("Starting...\n");
   s = Spaceship(73);
   b = &s;
diff --git a/Coordinator/src/build.vale b/Coordinator/src/build.vale
@@ -146,6 +146,12 @@ func build_stuff(compiler_dir &Path, all_args &Array<imm, str>) {
           "Whether to enable recording and replaying.",
           "false",
           "If true, the program will be able to make recordings, such that we can deterministically replay them."),
+        Flag(
+          "--enable_side_calling",
+          FLAG_BOOL(),
+          "Whether to enable fearless FFI and green threads.",
+          "false",
+          "If true, the program will be able to make temporary stacks without firing up threads, saving space and making extern calls a bit safer."),
         Flag(
           "--run_backend",
           FLAG_BOOL(),
@@ -232,6 +238,7 @@ func build_stuff(compiler_dir &Path, all_args &Array<imm, str>) {
   run_clang = parsed_flags.get_bool_flag("--run_clang", true);
   sanity_check = parsed_flags.get_bool_flag("--sanity_check", true);
   enable_replaying = parsed_flags.get_bool_flag("--enable_replaying", false);
+  enable_side_calling = parsed_flags.get_bool_flag("--enable_side_calling", false);
   output_vpst = parsed_flags.get_bool_flag("--output_vpst", true);
   no_std = parsed_flags.get_bool_flag("--no_std", false);
 
@@ -391,6 +398,7 @@ func build_stuff(compiler_dir &Path, all_args &Array<imm, str>) {
           verify,
           llvm_ir,
           enable_replaying,
+          enable_side_calling,
           print_mem_overhead,
           elide_checks_for_known_live,
           override_known_live_true);
diff --git a/Coordinator/src/midas.vale b/Coordinator/src/midas.vale
@@ -12,6 +12,7 @@ func invoke_backend(
   verify bool,
   llvm_ir bool,
   enable_replaying bool,
+  enable_side_calling bool,
   print_mem_overhead bool,
   elide_checks_for_known_live bool,
   override_known_live_true bool)
@@ -54,6 +55,9 @@ Subprocess {
   if (enable_replaying) {
     command_line_args.add("--enable_replaying");
   }
+  if (enable_side_calling) {
+    command_line_args.add("--enable_side_calling=true");
+  }
   if (print_mem_overhead) {
     command_line_args.add("--print_mem_overhead");
   }
diff --git a/Frontend/Highlighter/src/dev/vale/highlighter/Spanner.scala b/Frontend/Highlighter/src/dev/vale/highlighter/Spanner.scala
@@ -135,6 +135,7 @@ object Spanner {
   def forStructContent(c: IStructContent): Span = {
     c match {
       case m @ NormalStructMemberP(_, _, _, _) => forMember(m)
+      case m @ VariadicStructMemberP(_, _, _) => forVariadicMember(m)
       case StructMethodP(f) => forFunction(f)
     }
   }
@@ -149,6 +150,15 @@ object Spanner {
         forTemplex(tyype)))
   }
 
+  def forVariadicMember(member: VariadicStructMemberP): Span = {
+    val VariadicStructMemberP(range, _, tyype) = member
+    makeSpan(
+      Memb,
+      range,
+      Vector(
+        forTemplex(tyype)))
+  }
+
   def forFunctionAttribute(functionAttributeP: IAttributeP): Span = {
     functionAttributeP match {
       case ExternAttributeP(range) => makeSpan(Ext, range)
diff --git a/Tester/src/main.vale b/Tester/src/main.vale
@@ -419,6 +419,8 @@ Subprocess {
   build_args.add(region);
   build_args.add("--llvm_ir");
   build_args.add("true");
+  build_args.add("--enable_side_calling");
+  build_args.add("true");
   build_args.add("--no_std");
   build_args.add("true");
 
diff --git a/docs/DeterministicReplayabilityNotes.md b/docs/DeterministicReplayabilityNotes.md
@@ -0,0 +1,91 @@
+
+These are possible improvements and considered alternatives to parts of [DeterministicReplayability](DeterministicReplayability.md).
+
+
+# Possible Improvement: File-specific AssumeDeterministic
+
+It would be nice to specify which files we can assume will be the same, and which we can assume will be different.
+
+
+
+# Possible Improvement: More Flexible Channels
+
+It would be nice if we could be a little bit resilient in the case of one green thread sending a bunch of messages to another green thread. Not sure if that's possible though.
+
+
+# Possible Improvement: Using Pointers as Hash Keys
+
+It would be pretty nice to be able to hash heap-allocated objects, keyed by their address.
+
+However, it's unclear how to do this in a deterministic way.
+
+We *could* just make it deterministic in recording mode, but even then it's not clear that it will be resilient enough; if we even just touch this map the wrong way, change its order of anything, we'll moot our recording.
+
+
+
+# Alternative Considered: Deterministic Malloc
+
+For a while, considered having a "relatively deterministic" allocator (even made one!) where it would always return the same addresses.
+
+Fun fact: that's not possible, because of ASLR. We also [probably can't force it](https://stackoverflow.com/questions/6446101/how-do-i-choose-a-fixed-address-for-mmap).
+
+But, by making the allocator use 64kb slabs, we could still control the last 16 bits of the address. We could then have the recording file write down the addresses of each slab it allocates. When releasing memory to the OS, it `MADV_FREE`s it instead of `munmap`ping it, and keeps the virtual address range for future reuse.
+
+Also considered forking mimalloc to make it do this.
+
+However, this approach wouldn't be as resilient to code changes. A preferable approach would allow us to add print statements, pure function calls, and even refactor the internals of the program, as long as we don't change any interaction with the FFI boundary.
+
+For that reason, we went with the Object Index Map approach.
+
+
+# Alternative Considered: Epochs
+
+An alternative to the message ID / mutex version number scheme. We would hold all writes until all reads are done and the program stalls. Then, we would allow every thread one mutable mutex unlock, and will flush all pending messages in any channels.
+
+Not sure if it would cause deadlocks though.
+
+
+# Alternative Considered: Swap out the library
+
+We could specify a different set of .c files when doing deterministic replayability, ones that specifically make themselves act deterministically.
+
+
+# Alternative Considered: Extern Mapping
+
+Let's say we have these functions:
+
+```
+exported func OpenFile(filepath str) int;
+exported func ReadFile(fd int) str;
+exported func CloseFile(fd int);
+```
+
+It might return a different file descriptor on a different run, so it's deterministic.
+
+However, we can wrap that integer in a specialized type, and add some annotations:
+
+```
+#Mapped
+exported struct FileDescriptor {
+  fd int;
+}
+
+#Deterministic
+exported func OpenFile(filepath str) ^FileDescriptor;
+
+#Deterministic
+exported func ReadFile(fd &FileDescriptor) str;
+
+#Deterministic
+exported func CloseFile(fd ^FileDescriptor);
+```
+
+Now, when we're recording:
+
+ * When we call `OpenFile`, after writing it to the file, we'll add this object to the Object Index Map and the Object Index Vector, as if we're sending it to C.
+ * When we call `ReadFile`, it will:
+    * Write object's index to the file, as it normally would.
+    * Translate it to the original value.
+ * When we call `CloseFile`, after writing it to the file, we'll remove this object from the Object Index Map and the Object Index Vector, as normally happens when we destroy an object.
+
+But, it's hard to say how we'll get the original `fd` back. TODO: Figure that out.
diff --git a/docs/FearlessFFI.md b/docs/FearlessFFI.md
@@ -0,0 +1,27 @@
+
+A "Foreign Function Interface" is how a language can call into code written in another language. Vale can call into C code, as shown in [Externs](https://vale.dev/guide/externs).
+
+[Safety in Vale](https://vale.dev/fearless) describes how we can prevent any accidental problems in C from corrupting our Vale objects. This is **Fearless FFI**, and it's heckin' difficult to implement!
+
+This page describes the design, not necessarily how it's implemented.
+
+# Vale FFI Relevant Background
+
+## Immutable Objects
+
+There are two ways Vale can receive immutable objects from C:
+
+ * Vale calls a C function, which returns an immutable object.
+ * C calls a Vale function, passing an immutable object argument.
+
+In both cases, we'll write those objects to e.g. `recording.vale.bin` (the actual filename depends on various other factors).
+
+### Immutable Objects are Hierarchical
+
+We know the structure of the data C is sending, because these structs are `exported`. We use that knowledge to recursively copy the data into Vale's memory.
+
+# How Fearless FFI Works
+
+See https://verdagon.dev/blog/fearless-ffi
+
+(TODO: copy it into here once it's published)
diff --git a/docs/metadata.md b/docs/metadata.md
@@ -0,0 +1,21 @@
+# Metadata
+
+Every vale object has some metadata:
+
+If managed by HGM:
+
+ * bits 0-31: generation.
+ * bits 32-47: scope tethering bits innards
+ * bits 48-61: unused, tbd!
+ * bit 62: Exported bit, see DeterministicReplayability.
+ * bit 63: 0
+
+If managed by a special allocator:
+
+ * bits 0-31: type id ^ Region Kind ID
+ * bits 32-47: scope tethering bits innards
+ * bits 48-61: unused, tbd!
+ * bit 62: Exported bit, see DeterministicReplayability.
+ * bit 63: 1
+
+The various Region Kind IDs: see "Planned Allocators" in "Tracking Allocator Per-Object" doc.

Original file line number	Diff line number	Diff line change
`@@ -675,7 +675,7 @@ LLVMValueRef buildSideCall(`
`675`	`675`	`//buildPrint(globalState, entryBuilder, "\n");`
`676`	`676`	`}`
`677`	`677`	`} else {`
`678`		`- callResultAfterReturnLE = makeVoid(globalState);`
	`678`	`+ callResultAfterReturnLE = LLVMGetUndef(LLVMVoidTypeInContext(globalState->context));`
`679`	`679`	`}`
`680`	`680`
`681`	`681`	`//buildPrint(globalState, entryBuilder, "Done!\n");`
Original file line number	Diff line number	Diff line change
`@@ -3,7 +3,7 @@ import stdlib.*;`
`3`	`3`	`struct Spaceship {`
`4`	`4`	`fuel int;`
`5`	`5`	`}`
`6`		`-func main() int export {`
	`6`	`+exported func main() int {`
`7`	`7`	`print("Starting...\n");`
`8`	`8`	`s = Spaceship(73);`
`9`	`9`	`b = &s;`