Adapt Benchmarks to the new ConnectablePort

1. Adapt Sieve by simply using ConnectablePort
2. Adapt Online Facility Location by using ConnectablePort *and* making necessary changes to reflect the actual logic, as discussed with @lhstrh. In this case, two sources: an OutPort (port A), and a mutation, wants to write to an OutPort (port B), but at different times. The correct thing to do, then, will be to make the mutation have its own OutPort (port C) to write to, and when it wants to write to port B, it disconnects A->B, makes connection C->B, and write to C.

Author: Kagamihara Nadeshiko

src/benchmark/FacilityLocation.ts

@@ -4,7 +4,7 @@
  *
  * @author Hokeun Kim ([email protected])
  */
-import type {WritablePort} from "../core/internal";
+import type {IOPort} from "../core/internal";
 import {
   Log,
   TimeValue,
@@ -428,6 +428,7 @@ export class Quadrant extends Reactor {
   childrenBoundaries = new State<Box[]>(new Array<Box>());
 
   totalCost = new State<number>(0);
+  trollPort = new OutPort<ConfirmExitMsg>(this);
 
   constructor(
     parent: Reactor,
@@ -525,14 +526,19 @@ export class Quadrant extends Reactor {
         this.writable(this.toSecondChild),
         this.writable(this.toThirdChild),
         this.writable(this.toFourthChild),
-        this.writable(this.toAccumulator),
+        this.toFirstChild.asConnectable(),
+        this.toSecondChild.asConnectable(),
+        this.toThirdChild.asConnectable(),
+        this.toFourthChild.asConnectable(),
+        this.toAccumulator.asConnectable(),
         this.localFacilities,
         this.knownFacilities,
         this.maxDepthOfKnownOpenFacility,
         this.supportCustomers,
         this.hasChildren,
         this.childrenBoundaries,
-        this.totalCost
+        this.totalCost,
+        this.writable(this.trollPort)
       ],
       function (
         this,
@@ -544,20 +550,26 @@ export class Quadrant extends Reactor {
         depth,
         fromProducer,
         toProducer,
-        toFirstChild,
-        toSecondChild,
-        toThirdChild,
-        toFourthChild,
-        toAccumulator,
+        toFirstChildW,
+        toSecondChildW,
+        toThirdChildW,
+        toFourthChildW,
+        toFirstChildC,
+        toSecondChildC,
+        toThirdChildC,
+        toFourthChildC,
+        toAccumulatorC,
         localFacilities,
         knownFacilities,
         maxDepthOfKnownOpenFacility,
         supportCustomers,
         hasChildren,
         childrenBoundaries,
-        totalCost
+        totalCost,
+        trollPort
       ) {
         const thisReactor = this.getReactor();
+        const toAccumulatorUpstreams: Array<IOPort<ConfirmExitMsg>> = [];
 
         // Helper functions for mutation reaction.
         const notifyParentOfFacility = function (p: Point): void {
@@ -622,11 +634,12 @@ export class Quadrant extends Reactor {
 
           // console.log(`Children boundaries: ${childrenBoundaries.get()[0]}, ${childrenBoundaries.get()[1]}, ${childrenBoundaries.get()[2]}, ${childrenBoundaries.get()[3]}`)
           const accumulator = new Accumulator(thisReactor);
-          const toAccumulatorOfQuadrant = (
-            toAccumulator as unknown as WritablePort<Msg>
-          ).getPort();
           // Connect Accumulator's output to Quadrant's output.
-          this.connect(accumulator.toNextAccumulator, toAccumulatorOfQuadrant);
+          toAccumulatorUpstreams.push(accumulator.toNextAccumulator);
+          this.connect(
+            accumulator.toNextAccumulator.asConnectable(),
+            toAccumulatorC
+          );
 
           const firstChild = new Quadrant(
             thisReactor,
@@ -640,11 +653,11 @@ export class Quadrant extends Reactor {
             maxDepthOfKnownOpenFacility.get(),
             Point.arrayClone(supportCustomers.get())
           );
-          const toFirstChildPort = (
-            toFirstChild as unknown as WritablePort<Msg>
-          ).getPort();
-          this.connect(toFirstChildPort, firstChild.fromProducer);
-          this.connect(firstChild.toAccumulator, accumulator.fromFirstQuadrant);
+          this.connect(toFirstChildC, firstChild.fromProducer.asConnectable());
+          this.connect(
+            firstChild.toAccumulator.asConnectable(),
+            accumulator.fromFirstQuadrant.asConnectable()
+          );
 
           const secondChild = new Quadrant(
             thisReactor,
@@ -658,13 +671,13 @@ export class Quadrant extends Reactor {
             maxDepthOfKnownOpenFacility.get(),
             Point.arrayClone(supportCustomers.get())
           );
-          const toSecondChildPort = (
-            toSecondChild as unknown as WritablePort<Msg>
-          ).getPort();
-          this.connect(toSecondChildPort, secondChild.fromProducer);
           this.connect(
-            secondChild.toAccumulator,
-            accumulator.fromSecondQuadrant
+            toSecondChildC,
+            secondChild.fromProducer.asConnectable()
+          );
+          this.connect(
+            secondChild.toAccumulator.asConnectable(),
+            accumulator.fromSecondQuadrant.asConnectable()
           );
 
           const thirdChild = new Quadrant(
@@ -679,11 +692,11 @@ export class Quadrant extends Reactor {
             maxDepthOfKnownOpenFacility.get(),
             Point.arrayClone(supportCustomers.get())
           );
-          const toThirdChildPort = (
-            toThirdChild as unknown as WritablePort<Msg>
-          ).getPort();
-          this.connect(toThirdChildPort, thirdChild.fromProducer);
-          this.connect(thirdChild.toAccumulator, accumulator.fromThirdQuadrant);
+          this.connect(toThirdChildC, thirdChild.fromProducer.asConnectable());
+          this.connect(
+            thirdChild.toAccumulator.asConnectable(),
+            accumulator.fromThirdQuadrant.asConnectable()
+          );
 
           const fourthChild = new Quadrant(
             thisReactor,
@@ -697,13 +710,13 @@ export class Quadrant extends Reactor {
             maxDepthOfKnownOpenFacility.get(),
             Point.arrayClone(supportCustomers.get())
           );
-          const toFourthChildPort = (
-            toFourthChild as unknown as WritablePort<Msg>
-          ).getPort();
-          this.connect(toFourthChildPort, fourthChild.fromProducer);
           this.connect(
-            fourthChild.toAccumulator,
-            accumulator.fromFourthQuadrant
+            toFourthChildC,
+            fourthChild.fromProducer.asConnectable()
+          );
+          this.connect(
+            fourthChild.toAccumulator.asConnectable(),
+            accumulator.fromFourthQuadrant.asConnectable()
           );
 
           supportCustomers.set(new Array<Point>());
@@ -733,16 +746,16 @@ export class Quadrant extends Reactor {
                 if (childrenBoundaries.get()[i].contains(point)) {
                   switch (i) {
                     case 0:
-                      toFirstChild.set(msg);
+                      toFirstChildW.set(msg);
                       break;
                     case 1:
-                      toSecondChild.set(msg);
+                      toSecondChildW.set(msg);
                       break;
                     case 2:
-                      toThirdChild.set(msg);
+                      toThirdChildW.set(msg);
                       break;
                     case 3:
-                      toFourthChild.set(msg);
+                      toFourthChildW.set(msg);
                       break;
                   }
                   break;
@@ -754,18 +767,23 @@ export class Quadrant extends Reactor {
           case RequestExitMsg:
             if (!hasChildren.get()) {
               // No children, number of facilities will be counted on parent's side.
-              toAccumulator.set(
+              toAccumulatorUpstreams.forEach((val) => {
+                this.disconnect(val, toAccumulatorC.getPort());
+              });
+              this.connect(trollPort.getPort().asConnectable(), toAccumulatorC);
+
+              trollPort.set(
                 new ConfirmExitMsg(
                   0, // facilities
                   supportCustomers.get().length, // supportCustomers
                   1 // quadrantReactors
                 )
               );
             } else {
-              toFirstChild.set(msg);
-              toSecondChild.set(msg);
-              toThirdChild.set(msg);
-              toFourthChild.set(msg);
+              toFirstChildW.set(msg);
+              toSecondChildW.set(msg);
+              toThirdChildW.set(msg);
+              toFourthChildW.set(msg);
             }
             break;
           default:

src/benchmark/Sieve.ts

@@ -1,5 +1,4 @@
 import {
-  type WritablePort,
   Parameter,
   InPort,
   OutPort,
@@ -66,11 +65,12 @@ class Filter extends Reactor {
       [
         this.inp,
         this.writable(this.out),
+        this.out.asConnectable(),
         this.startPrime,
         this.hasChild,
         this.localPrimes
       ],
-      function (this, inp, out, prime, hasChild, localPrimes) {
+      function (this, inp, outW, outC, prime, hasChild, localPrimes) {
         const p = inp.get();
         if (p !== undefined) {
           const seen = localPrimes.get();
@@ -96,14 +96,13 @@ class Filter extends Reactor {
                 // let x = this.create(Filter, [this.getReactor(), p])
                 // console.log("CREATED: " + x._getFullyQualifiedName())
                 // FIXME: weird hack. Maybe just accept writable ports as well?
-                const port = (out as unknown as WritablePort<number>).getPort();
-                this.connect(port, n.inp);
+                this.connect(outC, n.inp.asConnectable());
                 // FIXME: this updates the dependency graph, but it doesn't redo the topological sort
                 // For a pipeline like this one, it is not necessary, but in general it is.
                 // Can we avoid redoing the entire sort?
                 hasChild.set(true);
               } else {
-                out.set(p);
+                outW.set(p);
               }
             }
           }