Implement Sieve.lf

Author: Wonseo-C

TS/src/Sieve.lf

@@ -0,0 +1,105 @@
+/**
+ * Copyright (C) 2022 Hanyang University
+ * 
+ * refer to https://github.com/lf-lang/reactor-ts/blob/master/src/benchmark/Sieve.ts
+ * 
+ * @author Wonseo Choi
+ */
+ 
+
+ target TypeScript {
+    fast: true
+    #logging: DEBUG
+};
+
+import BenchmarkRunner from "BenchmarkRunner.lf";
+
+
+reactor Ramp(totalNumber:number(100000), period:time(1 nsec)) {
+    input start: boolean;
+    output value: number;
+    output end: boolean;
+
+    logical action next(period): number;
+
+    reaction (start) -> next {=
+        actions.next.schedule(0, 2);
+    =}
+
+    reaction (next) -> next, value, end {=
+        const n: number = next as number;
+
+        if (n <= totalNumber) {
+            actions.next.schedule(0, n+1);
+            value = n;
+        } else{
+            end = true;
+        }
+
+    =}
+
+}
+
+reactor Filter(primeStart: number(2), primeNumber: number(1000)) {
+
+    input inp: number;
+    output out: number;
+
+    state localPrimes: {=Array<number>=}({= [] =});
+    state hasChild: boolean(false);
+
+    mutation (inp) -> out {=
+        let div = false;
+        const size = localPrimes.length;
+        const p = inp as number;
+
+        for (const q of localPrimes) {
+            if (Number.isInteger(p / q)) {
+                div = true;
+                break
+            }
+        }
+
+        if (!div) {
+            if (size < primeNumber) {
+                localPrimes.push(p);
+                // Print finded prime number if want
+                // console.log("New prime number : " + p);
+            }  else {
+                // Potential prime found.
+                if (!hasChild) {                            
+                    let n = new Filter(this.getReactor(), p, primeNumber);
+                    //this.start(n)
+                    // console.log("CREATING...")
+                    // let x = this.create(Filter, [this.getReactor(), p])
+                    // console.log("CREATED: " + x._getFullyQualifiedName())
+                    // util.getPort(out) -> __out.getPort()
+                    var port = __out.getPort();
+                    this.connect(port, n.inp);
+                    // 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 = true;
+                } else {
+                    out = p;
+                }
+            }
+        }
+    =}
+}
+
+
+main reactor Sieve(numIterations:number(12), totalNumber:number(100), primeStart: number(2), primeNumber: number(10), period: time(1 nsec)) {
+    runner = new BenchmarkRunner(num_iterations=numIterations);
+    source = new Ramp(totalNumber=totalNumber, period=period);
+    filter = new Filter(primeStart=primeStart, primeNumber=primeNumber);
+
+    reaction (startup) {=
+        console.log("Start Sieve of Eratosthenes LF Benchmark!");
+    =}
+
+    runner.start -> source.start;
+    source.value -> filter.inp;
+    source.end -> runner.finish;
+
+}