Turning Sieve benchmarks into Enso benchmarks

lib/scala/bench-processor/src/main/java/org/enso/benchmarks/processor/BenchProcessor.java

@@ -231,7 +231,7 @@ private void generateClassForGroup(
         "      throw new IllegalStateException(\"Project root directory does not exist or cannot be read: \" + Objects.toString(projectRootDir));");
     out.println("    }");
     out.println("    File languageHomeOverride = Utils.findLanguageHomeOverride();");
-    out.println("    var ctx = Context.newBuilder(LanguageInfo.ID)");
+    out.println("    var ctx = Context.newBuilder()");
     out.println("      .allowExperimentalOptions(true)");
     out.println("      .allowIO(IOAccess.ALL)");
     out.println("      .allowAllAccess(true)");

test/Benchmarks/data/sieve.js

@@ -0,0 +1,56 @@
+function Natural() {
+    this.x = 2;
+};
+Natural.prototype.next = function() {
+    return this.x++;
+};
+
+function Filter(number) {
+    this.number = number;
+    this.next = null;
+    this.last = this;
+}
+Filter.prototype.acceptAndAdd = function(n) {
+  var filter = this;
+  var sqrt = Math.sqrt(n);
+  for (;;) {
+      if (n % filter.number === 0) {
+          return false;
+      }
+      if (filter.number > sqrt) {
+          break;
+      }
+      filter = filter.next;
+  }
+  var newFilter = new Filter(n);
+  this.last.next = newFilter;
+  this.last = newFilter;
+  return true;
+};
+
+function Primes(natural) {
+    this.natural = natural;
+    this.filter = null;
+}
+Primes.prototype.next = function() {
+    for (;;) {
+        var n = this.natural.next();
+        if (this.filter === null) {
+            this.filter = new Filter(n);
+            return n;
+        }
+        if (this.filter.acceptAndAdd(n)) {
+            return n;
+        }
+    }
+};
+
+function globalPrimes(upto) {
+    var primes = new Primes(new Natural());
+    for (var cnt = 1;; cnt++) {
+        res = primes.next();
+        if (cnt >= upto) {
+            return res;
+        }
+    }
+}

test/Benchmarks/src/Main.enso

@@ -29,6 +29,7 @@ import project.Natural_Order_Sort
 import project.Number_Parse
 import project.Numeric
 import project.Range
+import project.Sieve
 import project.Sum
 import project.Startup.Startup
 import project.Runtime.Panics_And_Errors
@@ -86,6 +87,7 @@ all_benchmarks =
     builder.append Panics_And_Errors.collect_benches
 
     builder.append Startup.collect_benches
+    builder.append Sieve.Main.collect_benches
 
     builder.to_vector
 

test/Benchmarks/src/Sieve/Main.enso

@@ -0,0 +1,35 @@
+from Standard.Base import all
+
+from Standard.Test import Bench
+
+import project.Sieve.Sieve_Original
+import project.Sieve.Sieve_Ascribed
+import project.Sieve.Sieve_Without_Types
+import project.Sieve.Sieve_Java_Script
+
+# execute as
+# sbt:enso> runEngineDistribution --run test/Benchmarks Sieve
+# or as
+# sbt:enso> std-benchmarks/benchOnly Sieve
+
+options = Bench.options . set_warmup (Bench.phase_conf 3 5) . set_measure (Bench.phase_conf 3 3)
+
+collect_benches = Bench.build builder->
+    assert_prime nth =
+        if nth==1299709 . not then Panic.throw "Wrong prime number: "+nth.to_text
+
+    builder.group "Sieve" options group_builder->
+        group_builder.specify "Original" <|
+            assert_prime <| Sieve_Original.compute_nth_prime 100000
+        group_builder.specify "Ascribed" <|
+            assert_prime <| Sieve_Ascribed.compute_nth_prime 100000
+        group_builder.specify "Without_Types" <|
+            assert_prime <| Sieve_Without_Types.compute_nth_prime 100000
+        group_builder.specify "Java_Script_File" <|
+            assert_prime <| Sieve_Java_Script.compute_nth_prime_from_js_file 100000
+        group_builder.specify "Java_Script_All" <|
+            assert_prime <| Sieve_Java_Script.all_in_java_script 100000
+        group_builder.specify "Java_Script_Natural" <|
+            assert_prime <| Sieve_Java_Script.compute_nth_prime_natural_in_js 100000
+        group_builder.specify "Java_Script_Filter" <|
+            assert_prime <| Sieve_Java_Script.compute_nth_prime_filter_in_js 100000

test/Benchmarks/src/Sieve/Sieve_Java_Script.enso

@@ -0,0 +1,129 @@
+from Standard.Base import all
+
+import project.Sieve.Sieve_Without_Types
+
+foreign js natural_in_js = """
+    class Gen {
+        constructor() {
+            this.n = 2
+        }
+
+        n() {
+            return this.n
+        }
+
+        next() {
+            this.n++
+            return this
+        }
+    }
+    return new Gen()
+
+compute_nth_prime_natural_in_js = Sieve_Without_Types.compute_nth_prime gen=natural_in_js
+
+foreign js filter_in_js = """
+    function Filter(number) {
+        this.number = number;
+        this.next = null;
+        this.last = this;
+    }
+    Filter.prototype.acceptAndAdd = function(n) {
+        var filter = this;
+        var sqrt = Math.sqrt(n);
+        while (filter != null) {
+            if (filter.number) {
+                if (n % filter.number === 0) {
+                    return null;
+                }
+                if (filter.number > sqrt) {
+                    break;
+                }
+            }
+            filter = filter.next;
+        }
+        var newFilter = new Filter(n);
+        this.last.next = newFilter;
+        this.last = newFilter;
+        return this;
+    };
+    return new Filter(null);
+
+compute_nth_prime_filter_in_js = Sieve_Without_Types.compute_nth_prime fil=filter_in_js
+
+compute_nth_prime_from_js_file n =
+    script = enso_project.data/"sieve.js"
+    bench_external_file script.to_text n
+
+foreign js bench_external_file script n = """
+    if (!globalThis.globalPrimes) {
+        Polyglot.evalFile("js", script.toString());
+    }
+    return globalPrimes(n);
+
+type Primes
+    Alg generator filter
+
+Primes.next self = case self of
+    Primes.Alg g f ->
+        filter = f.acceptAndAdd g.n
+        new_primes = Primes.Alg g.next filter
+        if Meta.is_same_object filter f then @Tail_Call new_primes.next else new_primes
+
+Primes.last_prime self = case self of
+    Primes.Alg g _ -> g.n - 1
+
+foreign js all_in_java_script n = """
+    function Natural() {
+        this.x = 2;
+    };
+    Natural.prototype.next = function() {
+        return this.x++;
+    };
+
+    function Filter(number) {
+        this.number = number;
+        this.next = null;
+        this.last = this;
+    }
+    Filter.prototype.acceptAndAdd = function(n) {
+        var filter = this;
+        var sqrt = Math.sqrt(n);
+        for (;;) {
+            if (n % filter.number === 0) {
+                return false;
+            }
+            if (filter.number > sqrt) {
+                break;
+            }
+            filter = filter.next;
+        }
+        var newFilter = new Filter(n);
+        this.last.next = newFilter;
+        this.last = newFilter;
+        return true;
+    };
+
+    function Primes(natural) {
+        this.natural = natural;
+        this.filter = null;
+    }
+    Primes.prototype.next = function() {
+        for (;;) {
+            var n = this.natural.next();
+            if (this.filter === null) {
+                this.filter = new Filter(n);
+                return n;
+            }
+            if (this.filter.acceptAndAdd(n)) {
+                return n;
+            }
+        }
+    };
+
+    var res = -1;
+    let primes = new Primes(new Natural());
+    for (let i = 0; i < n; i++) {
+        res = primes.next();
+    }
+    return res;
+

engine/runtime/src/bench/resources/org/enso/interpreter/bench/benchmarks/semantic/sieveWithoutTypes.enso → test/Benchmarks/src/Sieve/Sieve_Without_Types.enso

@@ -38,16 +38,17 @@ type Primes
 Primes.next self = case self of
     Primes.Alg g f ->
         filter = f.acceptAndAdd g.n
-        new_primes = Primes.Alg g.next filter
-        if Meta.is_same_object filter f then @Tail_Call new_primes.next else new_primes
+        nf = if filter.is_nothing then f else filter
+        new_primes = Primes.Alg g.next nf
+        if filter.is_nothing || Meta.is_same_object filter f then @Tail_Call new_primes.next else new_primes
 
 Primes.last_prime self = case self of
     Primes.Alg g _ -> g.n - 1
 
 
-compute_nth_prime n =
+compute_nth_prime n gen=natural fil=Filter.Empty =
     loop p n = if n == 0 then p else
         pn = p.next
         @Tail_Call loop pn n-1
-    p = Primes.Alg natural Filter.Empty
+    p = Primes.Alg gen fil
     loop p n . last_prime