fix: do not expose to native scala-allocated object since they may be collected and cause segfaults

Author: tassiluca

scafi3-integration/src/test/resources/c/main.template.c

@@ -32,8 +32,7 @@ bool on_result(const void* result) {
 int main(void) {
     Neighborhood neighbors = Neighborhood_empty();
     {{ neighbors }}
-    ConnectionOrientedNetworkManager network = socket_network(device({{ deviceId }}), {{ port }}, neighbors);
-    engine(network, aggregate_program, on_result);
+    engine(device({{ deviceId }}), {{ port }}, neighbors, aggregate_program, on_result);
     printf("%s", field_to_str((const Field*) last_round_result));
     return 0;
 }

scafi3-integration/src/test/resources/js/app.template.mjs

@@ -9,11 +9,10 @@ const { Runtime, returning, returnSending } = await import("./main.mjs");
 const deviceId = {{ deviceId }};
 const port = {{ port }};
 const neighbors = new Map({{ neighbors }});
-const network = Runtime.socketNetwork(deviceId, port, neighbors);
 
 let lastResult = null;
 let iterations = 10;
-await Runtime.engine(network, lang => aggregateProgram(lang), async result => {
+await Runtime.engine(deviceId, port, neighbors, lang => aggregateProgram(lang), async result => {
     lastResult = result;
     await sleep(1_000);
     return iterations-- > 0;

scafi3-mp-api/js-jvm/src/main/scala/it/unibo/scafi/runtime/NoMemorySafeContext.scala

@@ -1,4 +1,5 @@
 package it.unibo.scafi.runtime
+import it.unibo.scafi.types.MemorySafeContext
 
 /**
  * A context where memory safety is enforced by construction by the underlying platform (e.g., JVM, JavaScript).

scafi3-mp-api/js/src/main/scala/it/unibo/scafi/runtime/JSScafiRuntime.scala

@@ -13,11 +13,11 @@ import io.github.iltotore.iron.refineUnsafe
 import scafi.context.xc.ExchangeAggregateContext
 import scafi.message.UniversalCodable
 import scafi.message.JSBinaryCodable.jsBinaryCodable
-import scafi.runtime.bindings.{ ScafiEngineBinding, ScafiNetworkBinding }
+import scafi.runtime.bindings.ScafiEngineBinding
 import scafi.libraries.FullLibrary
 
 @SuppressWarnings(Array("scalafix:DisableSyntax.asInstanceOf"))
-object JSScafiRuntime extends PortableRuntime with ScafiNetworkBinding with ScafiEngineBinding with JSTypes:
+object JSScafiRuntime extends PortableRuntime with ScafiEngineBinding with JSTypes:
 
   given ExecutionContext = scalajs.concurrent.JSExecutionContext.Implicits.queue
 
@@ -44,5 +44,5 @@ object JSScafiRuntime extends PortableRuntime with ScafiNetworkBinding with Scaf
     override def library[ID](using Arena): ExchangeAggregateContext[ID] ?=> FullLibrary = FullLibrary()
 
   @JSExportTopLevel("Runtime")
-  object JSAPI extends Api with NetworkBindings with EngineBindings with JSRequirements
+  object JSAPI extends Api with EngineBindings with JSRequirements
 end JSScafiRuntime

scafi3-mp-api/native/src/main/resources/include/runtime.h

@@ -4,23 +4,17 @@
 #include <stdbool.h>
 #include "libraries.h"
 
-typedef struct ConnectionOrientedNetworkManagerImpl* ConnectionOrientedNetworkManager;
-
 struct Endpoint {
     char* address;
     int port;
 };
 
 MAP_OF(Neighborhood, DeviceId, struct Endpoint*)
 
-ConnectionOrientedNetworkManager socket_network(
+void engine(
     const BinaryCodable* device_id,
     int port, 
-    const Neighborhood neighbors
-);
-
-void engine(
-    const ConnectionOrientedNetworkManager network_manager,
+    const Neighborhood neighbors,
     const void* (*aggregate_program)(const AggregateLibrary* library),
     bool (*on_result)(const void* result)
 );

scafi3-mp-api/native/src/main/scala/it/unibo/scafi/runtime/NativeMemoryContext.scala

@@ -2,6 +2,8 @@ package it.unibo.scafi.runtime
 
 import scala.scalanative.unsafe.Zone
 
+import it.unibo.scafi.types.MemorySafeContext
+
 /**
  * A memory-safe context implementation for native platforms using `Zone` for scoped memory management.
  */

scafi3-mp-api/native/src/main/scala/it/unibo/scafi/runtime/NativeScafiRuntime.scala

@@ -16,14 +16,14 @@ import it.unibo.scafi.nativebindings.structs.{
   BinaryCodable as CBinaryCodable,
   Endpoint as CEndpoint,
 }
-import it.unibo.scafi.runtime.bindings.{ ScafiEngineBinding, ScafiNetworkBinding }
-import it.unibo.scafi.runtime.network.sockets.{ ConnectionOrientedNetworkManager, InetTypes }
+import it.unibo.scafi.runtime.bindings.ScafiEngineBinding
+import it.unibo.scafi.runtime.network.sockets.InetTypes
 import it.unibo.scafi.types.{ EqWrapper, NativeTypes }
 
 import io.github.iltotore.iron.refineUnsafe
 
 @SuppressWarnings(Array("scalafix:DisableSyntax.asInstanceOf"))
-object NativeScafiRuntime extends PortableRuntime with ScafiNetworkBinding with ScafiEngineBinding with NativeTypes:
+object NativeScafiRuntime extends PortableRuntime with ScafiEngineBinding with NativeTypes:
 
   given ExecutionContext = ExecutionContext.fromExecutor(Executors.newCachedThreadPool())
 
@@ -50,19 +50,14 @@ object NativeScafiRuntime extends PortableRuntime with ScafiNetworkBinding with
 
     override def library[ID](using Arena): ExchangeAggregateContext[ID] ?=> AggregateLibrary = FullLibrary().asNative
 
-  object NativeApi extends Api with NativeAdts with NetworkBindings with EngineBindings with NativeRequirements:
+  object NativeApi extends Api with NativeAdts with EngineBindings with NativeRequirements:
 
-    @exported("socket_network")
-    def nativeSocketNetwork(
+    @exported("engine")
+    def nativeEngine(
         deviceId: CVoidPtr,
         port: CInt,
         neighbors: Map[CVoidPtr, Endpoint],
-    ): ConnectionOrientedNetworkManager[DeviceId] = socketNetwork[CVoidPtr](deviceId, port, neighbors)
-
-    @exported("engine")
-    def nativeEngine(
-        network: ConnectionOrientedNetworkManager[DeviceId],
         program: Function1[AggregateLibrary, CVoidPtr],
         onResult: Function1[CVoidPtr, Outcome[Boolean]],
-    ): Outcome[Unit] = engine(network, program, onResult)
+    ): Outcome[Unit] = engine(deviceId, port, neighbors, program, onResult)
 end NativeScafiRuntime

scafi3-mp-api/shared/src/main/scala/it/unibo/scafi/runtime/PortableRuntime.scala

@@ -1,11 +1,9 @@
 package it.unibo.scafi.runtime
 
-import it.unibo.scafi
-import it.unibo.scafi.types.PortableTypes
-
-import scafi.context.xc.ExchangeAggregateContext
-import scafi.message.UniversalCodable
-import scafi.runtime.network.sockets.ConnectionOrientedNetworkManager
+import it.unibo.scafi.context.xc.ExchangeAggregateContext
+import it.unibo.scafi.message.UniversalCodable
+import it.unibo.scafi.runtime.network.sockets.InetTypes
+import it.unibo.scafi.types.{ MemorySafeContext, PortableTypes }
 
 /**
  * Portable runtime API entry point.
@@ -27,8 +25,8 @@ trait PortableRuntime:
     /** A network endpoint consisting of an [[address]] and a [[port]]. */
     type Endpoint
 
-    /** Endpoint is isomorphic to [[scafi.runtime.network.sockets.InetTypes.Endpoint]]. */
-    given toInetEndpoint: Conversion[Endpoint, scafi.runtime.network.sockets.InetTypes.Endpoint] = compiletime.deferred
+    /** Endpoint is isomorphic to [[InetTypes.Endpoint]]. */
+    given toInetEndpoint: Conversion[Endpoint, InetTypes.Endpoint] = compiletime.deferred
 
   /** The requirements that must be satisfied by any concrete implementation of the runtime. */
   trait Requirements extends MemorySafeContext:
@@ -44,22 +42,25 @@ trait PortableRuntime:
   trait Api:
     self: Requirements & Adts =>
 
-    /** @return a socket-based network working on [[port]] with statically assigned [[neighbors]] and [[deviceId]]. */
+    /**
+     * Portable entry point for Scafi3 aggregate programs in a distributed environment with socket-based networking.
+     * @param deviceId
+     *   the unique identifier of the device
+     * @param port
+     *   the port on which the device listens for incoming messages
+     * @param neighbors
+     *   a map of neighboring device IDs to their network endpoints
+     * @param program
+     *   the aggregate program to run on the device
+     * @param onResult
+     *   a callback to handle the result of the program execution returning an Outcome of Boolean indicating whether to
+     *   continue or stop
+     */
     @JSExport
-    def socketNetwork[ID](
+    def engine[ID, Result](
         deviceId: ID,
         port: Int,
         neighbors: Map[ID, Endpoint],
-    ): ConnectionOrientedNetworkManager[DeviceId]
-
-    /**
-     * Runs the given aggregate [[program]] on the device with the given [[deviceId]], using the provided [[network]].
-     * The result of the program is passed to the [[onResult]] callback, which should return an [[Outcome]] indicating
-     * whether the execution needs to continue or stop.
-     */
-    @JSExport
-    def engine[Result](
-        network: ConnectionOrientedNetworkManager[DeviceId],
         program: Function1[AggregateLibrary, Result],
         onResult: Function1[Result, Outcome[Boolean]],
     ): Outcome[Unit]

scafi3-mp-api/shared/src/main/scala/it/unibo/scafi/runtime/bindings/ScafiEngineBinding.scala

@@ -5,9 +5,11 @@ import scala.util.{ Failure, Try }
 
 import it.unibo.scafi.context.xc.ExchangeAggregateContext.exchangeContextFactory
 import it.unibo.scafi.runtime.{ PortableRuntime, ScafiEngine }
-import it.unibo.scafi.runtime.network.sockets.ConnectionOrientedNetworkManager
+import it.unibo.scafi.runtime.network.sockets.{ ConnectionConfiguration, SocketNetworkManager }
 import it.unibo.scafi.types.PortableTypes
 
+import io.github.iltotore.iron.refineUnsafe
+
 /**
  * Provides a concrete implementation of the portable runtime API for the ScaFi engine.
  */
@@ -19,11 +21,15 @@ trait ScafiEngineBinding extends PortableRuntime:
 
     /* WARNING: Inline is needed here for native platform to ensure function pointers are correctly handled at
      * call site. Removing it does not lead to compilation errors but to runtime segfaults! */
-    inline override def engine[Result](
-        network: ConnectionOrientedNetworkManager[DeviceId],
+    inline override def engine[ID, Result](
+        deviceId: ID,
+        port: Int,
+        neighbors: Map[ID, Endpoint],
         program: Function1[AggregateLibrary, Result],
         onResult: Function1[Result, Outcome[Boolean]],
     ): Outcome[Unit] =
+      deviceIdCodable.register(deviceId)
+      val network = socketNetwork(deviceId, port, neighbors)
       network
         .start()
         .flatMap: _ =>
@@ -32,6 +38,11 @@ trait ScafiEngineBinding extends PortableRuntime:
         .andThen(_ => Future(network.close()))
         .andThen(reportAnyFailure)
 
+    private def socketNetwork[ID](deviceId: ID, port: Int, neighbors: Map[ID, Endpoint]) =
+      given ConnectionConfiguration = ConnectionConfiguration.basic
+      val devicesNet = neighbors.view.map((id, e) => (id: DeviceId, toInetEndpoint(e))).toMap
+      SocketNetworkManager.withFixedNeighbors(deviceId: DeviceId, port.refineUnsafe, devicesNet)
+
     private val reportAnyFailure: PartialFunction[Try[Unit], Unit] =
       case Failure(err) => Console.err.println(s"Error occurred: ${err.getMessage}")
   end EngineBindings