Perf plot

flopcounts/x86/variant_AVX512_1.py

@@ -0,0 +1,100 @@
+# ADDs:  n_iter * n_p * 4 +
+#        n_iter * n_p * ceil(((double) (n_p - 7)) / 8) * (1 / (ceil(((double) (n_p - 7)) / 8))) * 7 * 14 +
+#        n_iter * n_p * ceil(((double) (n_p - 7)) / 8) * (1 - 1 / (ceil(((double) (n_p - 7)) / 8))) * 224 +
+#        n_iter * n_p * (n_p - floor((double) n_p / 8) * 8) * 14 +
+#        n_iter * n_p * board.n_obstacles * 12 +
+#        n_iter * n_p * 7
+
+# MULTs: n_iter * n_p * 4 +
+#        n_iter * n_p * ceil(((double) (n_p - 7)) / 8) * (1 / (ceil(((double) (n_p - 7)) / 8))) * 7 * 24 +
+#        n_iter * n_p * ceil(((double) (n_p - 7)) / 8) * (1 - 1 / (ceil(((double) (n_p - 7)) / 8))) * 352 +
+#        n_iter * n_p * (n_p - floor((double) n_p / 8) * 8) * 24 +
+#        n_iter * n_p * board.n_obstacles * 19 +
+#        n_iter * n_p * 17
+
+# DIVs:  n_iter * n_p * ceil(((double) (n_p - 7)) / 8) * (1 / (ceil(((double) (n_p - 7)) / 8))) * 7 +
+#        n_iter * n_p * ceil(((double) (n_p - 7)) / 8) * (1 - 1 / (ceil(((double) (n_p - 7)) / 8))) * 8 +
+#        n_iter * n_p * (n_p - floor((double) n_p / 8) * 8) +
+#        n_iter * n_p * board.n_obstacles +
+#        n_iter * n_p * 2
+
+# SQRTs: n_iter * n_p * ceil(((double) (n_p - 7)) / 8) * (1 / (ceil(((double) (n_p - 7)) / 8))) * 7 * 3 +
+#        n_iter * n_p * ceil(((double) (n_p - 7)) / 8) * (1 - 1 / (ceil(((double) (n_p - 7)) / 8))) * 24 +
+#        n_iter * n_p * (n_p - floor((double) n_p / 8) * 8) * 3 +
+#        n_iter * n_p * board.n_obstacles +
+#        n_iter * n_p * 3
+
+# EXPs:  n_iter * n_p * ceil(((double) (n_p - 7)) / 8) * (1 / (ceil(((double) (n_p - 7)) / 8))) * 7 +
+#        n_iter * n_p * (n_p - floor((double) n_p / 8) * 8) +
+#        n_iter * n_p * board.n_obstacles
+
+from math import ceil
+
+
+def adds(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  chunks = ceil((n_p - 7) / 8) if n_p > 7 else 0
+  remainder = n_p - int(n_p // 8) * 8
+  if chunks > 0:
+    term1 = n_iter * n_p * chunks * (1 / chunks) * 7 * 14
+    term2 = n_iter * n_p * chunks * (1 - 1 / chunks) * 224
+  else:
+    term1 = 0
+    term2 = 0
+  return int(n_iter * n_p * 4 + term1 + term2 + n_iter * n_p * remainder * 14 +
+             n_iter * n_p * n_obs * 12 + n_iter * n_p * 7)
+
+
+def mults(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  chunks = ceil((n_p - 7) / 8) if n_p > 7 else 0
+  remainder = n_p - int(n_p // 8) * 8
+  if chunks > 0:
+    term1 = n_iter * n_p * chunks * (1 / chunks) * 7 * 24
+    term2 = n_iter * n_p * chunks * (1 - 1 / chunks) * 352
+  else:
+    term1 = 0
+    term2 = 0
+  return int(n_iter * n_p * 4 + term1 + term2 + n_iter * n_p * remainder * 24 +
+             n_iter * n_p * n_obs * 19 + n_iter * n_p * 17)
+
+
+def divs(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  chunks = ceil((n_p - 7) / 8) if n_p > 7 else 0
+  remainder = n_p - int(n_p // 8) * 8
+  if chunks > 0:
+    term1 = n_iter * n_p * chunks * (1 / chunks) * 7
+    term2 = n_iter * n_p * chunks * (1 - 1 / chunks) * 8
+  else:
+    term1 = 0
+    term2 = 0
+  return int(n_iter * n_p * 4 + term1 + term2 + n_iter * n_p * remainder +
+             n_iter * n_p * n_obs + n_iter * n_p * 2)
+
+
+def sqrts(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  chunks = ceil((n_p - 7) / 8) if n_p > 7 else 0
+  remainder = n_p - int(n_p // 8) * 8
+  if chunks > 0:
+    term1 = n_iter * n_p * chunks * (1 / chunks) * 7 * 3
+    term2 = n_iter * n_p * chunks * (1 - 1 / chunks) * 24
+  else:
+    term1 = 0
+    term2 = 0
+  return int(n_iter * n_p * 4 + term1 + term2 + n_iter * n_p * remainder * 3 +
+             n_iter * n_p * n_obs + n_iter * n_p * 3)
+
+
+def exps(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  chunks = ceil((n_p - 7) / 8) if n_p > 7 else 0
+  remainder = n_p - int(n_p // 8) * 8
+  if chunks > 0:
+    term1 = n_iter * n_p * chunks * (1 / chunks) * 7
+  else:
+    term1 = 0
+  return int(n_iter * n_p * 4 + term1 + n_iter * n_p * remainder +
+             n_iter * n_p * n_obs + n_iter * n_p * 3)
+
+
+def total(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return adds(n_iter, n_p, n_obs) + mults(n_iter, n_p, n_obs) + divs(
+    n_iter, n_p, n_obs) + sqrts(n_iter, n_p,
+                                n_obs) + exps(n_iter, n_p, n_obs) * 30

flopcounts/x86/variant_baseline.py

@@ -0,0 +1,58 @@
+# ADDs: n_iter * (
+#   n_p * 4 +
+#   n_p * (n_p - 1) * 14 +
+#   n_p * board.n_obstacles * 10 +
+#   n_p * 7
+# )
+
+# MULTs: n_iter * (
+#   n_p * 4
+#   n_p * (n_p - 1) * 24 +
+#   n_p * board.n_obstacles * 13 +
+#   n_p * 16
+# )
+
+# DIVs: n_iter * (
+#   n_p * (n_p - 1) +
+#   n_p * board.n_obstacles +
+#   n_p * 2
+# )
+
+# SQRTs: n_iter * (
+#   n_p * (n_p - 1) * 3 +
+#   n_p * board.n_obstacles +
+#   n_p * 3
+# )
+
+# EXPs: n_iter * (
+#   n_p * (n_p - 1) +
+#   n_p * board.n_obstacles
+# )
+
+
+def adds(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * (n_p * 4 + n_p *
+                       (n_p - 1) * 14 + n_p * n_obs * 10 + n_p * 7))
+
+
+def mults(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * (n_p * 4 + n_p *
+                       (n_p - 1) * 24 + n_p * n_obs * 13 + n_p * 16))
+
+
+def divs(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * (n_p * (n_p - 1) + n_p * n_obs + n_p * 2))
+
+
+def sqrts(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * (n_p * (n_p - 1) * 3 + n_p * n_obs + n_p * 3))
+
+
+def exps(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * (n_p * (n_p - 1) + n_p * n_obs))
+
+
+def total(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return adds(n_iter, n_p, n_obs) + mults(n_iter, n_p, n_obs) + divs(
+    n_iter, n_p, n_obs) + sqrts(n_iter, n_p,
+                                n_obs) + exps(n_iter, n_p, n_obs) * 30

flopcounts/x86/variant_branchless.py

@@ -0,0 +1,27 @@
+# n_iter * [n_p ** 2 * (15 A + 24 M + 1 D + 4 S + 1 E) + n_p * (- 4 A - 4 M + 1 D - 1 S - 1 E) + n_obstacles * n_p * (13 A + 19 M + 1 D + 2 S + 1 E)]
+
+
+def adds(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * (n_p**2 * 15 + n_p * (-4) + n_obs * n_p * 13))
+
+
+def mults(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * (n_p**2 * 24 + n_p * (-4) + n_obs * n_p * 19))
+
+
+def divs(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * (n_p**2 * 1 + n_p * 1 + n_obs * n_p * 1))
+
+
+def sqrts(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * (n_p**2 * 4 + n_p * (-1) + n_obs * n_p * 2))
+
+
+def exps(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * (n_p**2 * 1 + n_p * (-1) + n_obs * n_p * 1))
+
+
+def total(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return adds(n_iter, n_p, n_obs) + mults(n_iter, n_p, n_obs) + divs(
+    n_iter, n_p, n_obs) + sqrts(n_iter, n_p,
+                                n_obs) + exps(n_iter, n_p, n_obs) * 30

flopcounts/x86/variant_branchless_sqrtfree.py

@@ -0,0 +1,27 @@
+# n_iter * [n_p ** 2 * (15 A + 25 M + 1 D + 3 S + 1 E) + n_p * (- 4 A - 5 M + 1 D - 1 E) + n_obstacles * n_p * (13 A + 20 M + 1 D + 1 S + 1 E)]
+
+
+def adds(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * (n_p**2 * 15 + n_p * (-4) + n_obs * n_p * 13))
+
+
+def mults(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * (n_p**2 * 25 + n_p * (-5) + n_obs * n_p * 20))
+
+
+def divs(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * (n_p**2 * 1 + n_p * 1 + n_obs * n_p * 1))
+
+
+def sqrts(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * (n_p**2 * 3 + n_obs * n_p * 1))
+
+
+def exps(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * (n_p**2 * 1 + n_p * (-1) + n_obs * n_p * 1))
+
+
+def total(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return adds(n_iter, n_p, n_obs) + mults(n_iter, n_p, n_obs) + divs(
+    n_iter, n_p, n_obs) + sqrts(n_iter, n_p,
+                                n_obs) + exps(n_iter, n_p, n_obs) * 30

flopcounts/x86/variant_cutoff.py

@@ -0,0 +1,27 @@
+# n_iter * [ n_p ** 2 * (14 A + 23 M + 1 D + 4 S + 1 E) + n_p * (- 3 A - 3 M + 1 D - 1 S - 1 E) + n_obstacles * n_p * (12 A + 18 M + 1 D + 2 S + 1 E) ]
+
+
+def adds(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * (n_p**2 * 14 + n_p * (-3) + n_obs * n_p * 12))
+
+
+def mults(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * (n_p**2 * 23 + n_p * (-3) + n_obs * n_p * 18))
+
+
+def divs(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * (n_p**2 * 1 + n_p * 1 + n_obs * n_p * 1))
+
+
+def sqrts(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * (n_p**2 * 4 + n_p * (-1) + n_obs * n_p * 2))
+
+
+def exps(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * (n_p**2 * 1 + n_p * (-1) + n_obs * n_p * 1))
+
+
+def total(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return adds(n_iter, n_p, n_obs) + mults(n_iter, n_p, n_obs) + divs(
+    n_iter, n_p, n_obs) + sqrts(n_iter, n_p,
+                                n_obs) + exps(n_iter, n_p, n_obs) * 30

flopcounts/x86/variant_cutoff_callsite.py

@@ -0,0 +1,27 @@
+# n_iter * [ n_p ** 2 * (14 A + 23 M + 1 D + 4 S + 1 E) + n_p * (- 3 A - 3 M + 1 D - 1 S - 1 E) + n_obstacles * n_p * (12 A + 18 M + 1 D + 2 S + 1 E) ]
+
+
+def adds(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * (n_p**2 * 14 + n_p * (-3) + n_obs * n_p * 12))
+
+
+def mults(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * (n_p**2 * 23 + n_p * (-3) + n_obs * n_p * 18))
+
+
+def divs(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * (n_p**2 * 1 + n_p * 1 + n_obs * n_p * 1))
+
+
+def sqrts(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * (n_p**2 * 4 + n_p * (-1) + n_obs * n_p * 2))
+
+
+def exps(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * (n_p**2 * 1 + n_p * (-1) + n_obs * n_p * 1))
+
+
+def total(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return adds(n_iter, n_p, n_obs) + mults(n_iter, n_p, n_obs) + divs(
+    n_iter, n_p, n_obs) + sqrts(n_iter, n_p,
+                                n_obs) + exps(n_iter, n_p, n_obs) * 30

flopcounts/x86/variant_float_baseline.py

@@ -0,0 +1,57 @@
+# ADDs: n_iter * (
+#   n_p * 4 +
+#   n_p * (n_p - 1) * 14 +
+#   n_p * board.n_obstacles * 10 +
+#   n_p * 7
+# )
+
+# MULTs: n_iter * (
+#   n_p * 4
+#   n_p * (n_p - 1) * 24 +
+#   n_p * board.n_obstacles * 13 +
+#   n_p * 16
+# )
+
+# DIVs: n_iter * (
+#   n_p * (n_p - 1) +
+#   n_p * board.n_obstacles +
+#   n_p * 2
+# )
+
+# SQRTs: n_iter * (
+#   n_p * (n_p - 1) * 3 +
+#   n_p * board.n_obstacles +
+#   n_p * 3
+# )
+
+# EXPs: n_iter * (
+#   n_p * (n_p - 1) +
+#   n_p * board.n_obstacles
+# )
+
+
+def adds(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * (n_p * 4 + n_p *
+                       (n_p - 1) * 14 + n_p * n_obs * 10 + n_p * 7))
+
+
+def mults(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * (n_p * 4 + n_p *
+                       (n_p - 1) * 24 + n_p * n_obs * 13 + n_p * 16))
+
+
+def divs(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * (n_p * (n_p - 1) + n_p * n_obs + n_p * 2))
+
+
+def sqrts(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * (n_p * (n_p - 1) * 3 + n_p * n_obs + n_p * 3))
+
+
+def exps(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * (n_p * (n_p - 1) + n_p * n_obs))
+
+
+def total(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return adds(n_iter, n_p, n_obs) + mults(n_iter, n_p, n_obs) + divs(
+    n_iter, n_p, n_obs) + sqrts(n_iter, n_p, n_obs) + exps(n_iter, n_p, n_obs)

flopcounts/x86/variant_float_inlining.py

@@ -0,0 +1,58 @@
+# ADDs: n_iter * (
+#   n_p * 4 +
+#   n_p * (n_p - 1) * 14 +
+#   n_p * board.n_obstacles * 10 +
+#   n_p * 7
+# )
+
+# MULTs: n_iter * (
+#   n_p * 4
+#   n_p * (n_p - 1) * 24 +
+#   n_p * board.n_obstacles * 13 +
+#   n_p * 17
+# )
+
+# DIVs: n_iter * (
+#   n_p * (n_p - 1) +
+#   n_p * board.n_obstacles +
+#   n_p * 2
+# )
+
+# SQRTs: n_iter * (
+#   n_p * (n_p - 1) * 3 +
+#   n_p * board.n_obstacles +
+#   n_p * 3
+# )
+
+# EXPs: n_iter * (
+#   n_p * (n_p - 1) +
+#   n_p * board.n_obstacles
+# )
+
+
+def adds(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * (n_p * 4 + n_p *
+                       (n_p - 1) * 14 + n_p * n_obs * 10 + n_p * 7))
+
+
+def mults(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * (n_p * 4 + n_p *
+                       (n_p - 1) * 24 + n_p * n_obs * 13 + n_p * 17))
+
+
+def divs(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * (n_p * (n_p - 1) + n_p * n_obs + n_p * 2))
+
+
+def sqrts(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * (n_p * (n_p - 1) * 3 + n_p * n_obs + n_p * 3))
+
+
+def exps(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * (n_p * (n_p - 1) + n_p * n_obs))
+
+
+def total(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return adds(n_iter, n_p, n_obs) + mults(n_iter, n_p, n_obs) + divs(
+    n_iter, n_p, n_obs) + sqrts(n_iter, n_p,
+                                n_obs) + exps(n_iter, n_p, n_obs) * 30

flopcounts/x86/variant_float_inlining_SoA.py

@@ -0,0 +1,58 @@
+# ADDs: n_iter * (
+#   n_p * 4 +
+#   n_p * (n_p - 1) * 14 +
+#   n_p * board.n_obstacles * 10 +
+#   n_p * 7
+# )
+
+# MULTs: n_iter * (
+#   n_p * 4
+#   n_p * (n_p - 1) * 24 +
+#   n_p * board.n_obstacles * 13 +
+#   n_p * 17
+# )
+
+# DIVs: n_iter * (
+#   n_p * (n_p - 1) +
+#   n_p * board.n_obstacles +
+#   n_p * 2
+# )
+
+# SQRTs: n_iter * (
+#   n_p * (n_p - 1) * 3 +
+#   n_p * board.n_obstacles +
+#   n_p * 3
+# )
+
+# EXPs: n_iter * (
+#   n_p * (n_p - 1) +
+#   n_p * board.n_obstacles
+# )
+
+
+def adds(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * (n_p * 4 + n_p *
+                       (n_p - 1) * 14 + n_p * n_obs * 10 + n_p * 7))
+
+
+def mults(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * (n_p * 4 + n_p *
+                       (n_p - 1) * 24 + n_p * n_obs * 13 + n_p * 17))
+
+
+def divs(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * (n_p * (n_p - 1) + n_p * n_obs + n_p * 2))
+
+
+def sqrts(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * (n_p * (n_p - 1) * 3 + n_p * n_obs + n_p * 3))
+
+
+def exps(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * (n_p * (n_p - 1) + n_p * n_obs))
+
+
+def total(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return adds(n_iter, n_p, n_obs) + mults(n_iter, n_p, n_obs) + divs(
+    n_iter, n_p, n_obs) + sqrts(n_iter, n_p,
+                                n_obs) + exps(n_iter, n_p, n_obs) * 30

flopcounts/x86/variant_float_inlining_SoA_AVX2.py

@@ -0,0 +1,41 @@
+# const int n_p_pad = (n_p + 7) & ~7;
+
+# flops per iteration (one pass of the outer time loop):
+# ADDs:   n_p * 22  +  n_p * n_p_pad * 15  +  n_p * board.n_obstacles * 10  +  n_p * 7
+# MULTs:  n_p * 4   +  n_p * n_p_pad * 24  +  n_p * board.n_obstacles * 13  +  n_p * 16
+# DIVs:              n_p * n_p_pad * 1  +  n_p * board.n_obstacles  +  n_p * 2
+# SQRTs:             n_p * n_p_pad * 3  +  n_p * board.n_obstacles  +  n_p * 3
+# EXPs:  n_p * n_p_pad * 1  +  n_p * board.n_obstacles
+
+
+def adds(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 7) & ~7
+  return int(n_iter *
+             (n_p * 22 + n_p * n_p_pad * 15 + n_p * n_obs * 10 + n_p * 7))
+
+
+def mults(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 7) & ~7
+  return int(n_iter *
+             (n_p * 4 + n_p * n_p_pad * 24 + n_p * n_obs * 13 + n_p * 16))
+
+
+def divs(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 7) & ~7
+  return int(n_iter * (n_p * n_p_pad * 1 + n_p * n_obs + n_p * 2))
+
+
+def sqrts(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 7) & ~7
+  return int(n_iter * (n_p * n_p_pad * 3 + n_p * n_obs + n_p * 3))
+
+
+def exps(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 7) & ~7
+  return int(n_iter * (n_p * n_p_pad * 1 + n_p * n_obs))
+
+
+def total(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return adds(n_iter, n_p, n_obs) + mults(n_iter, n_p, n_obs) + divs(
+    n_iter, n_p, n_obs) + sqrts(n_iter, n_p,
+                                n_obs) + exps(n_iter, n_p, n_obs) * 30

flopcounts/x86/variant_float_inlining_SoA_AVX2_polyexp.py

@@ -0,0 +1,41 @@
+# const int n_p_pad = (n_p + 7) & ~7;
+
+# flops per iteration (one pass of the outer time loop):
+# ADDs:   n_p * 22  +  n_p * n_p_pad * 29  +  n_p * board.n_obstacles * 10  +  n_p * 7
+# MULTs:  n_p * 4   +  n_p * n_p_pad * 40  +  n_p * board.n_obstacles * 13  +  n_p * 16
+# DIVs:              n_p * n_p_pad * 1  +  n_p * board.n_obstacles  +  n_p * 2
+# SQRTs:             n_p * n_p_pad * 3  +  n_p * board.n_obstacles  +  n_p * 3
+# EXPs:              n_p * board.n_obstacles
+
+
+def adds(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 7) & ~7
+  return int(n_iter *
+             (n_p * 22 + n_p * n_p_pad * 29 + n_p * n_obs * 10 + n_p * 7))
+
+
+def mults(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 7) & ~7
+  return int(n_iter *
+             (n_p * 4 + n_p * n_p_pad * 40 + n_p * n_obs * 13 + n_p * 16))
+
+
+def divs(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 7) & ~7
+  return int(n_iter * (n_p * n_p_pad * 1 + n_p * n_obs + n_p * 2))
+
+
+def sqrts(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 7) & ~7
+  return int(n_iter * (n_p * n_p_pad * 3 + n_p * n_obs + n_p * 3))
+
+
+def exps(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 7) & ~7
+  return int(n_iter * (n_p * n_obs))
+
+
+def total(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return adds(n_iter, n_p, n_obs) + mults(n_iter, n_p, n_obs) + divs(
+    n_iter, n_p, n_obs) + sqrts(n_iter, n_p,
+                                n_obs) + exps(n_iter, n_p, n_obs) * 30

flopcounts/x86/variant_float_inlining_SoA_AVX2_polyexp_rsqrt.py

@@ -0,0 +1,41 @@
+# const int n_p_pad = (n_p + 7) & ~7;
+
+# flops per iteration (one pass of the outer time loop):
+# ADDs:   n_p * 22  +  n_p * n_p_pad * 29  +  n_p * board.n_obstacles * 10  +  n_p * 7
+# MULTs:  n_p * 4   +  n_p * n_p_pad * 42  +  n_p * board.n_obstacles * 13  +  n_p * 16
+# DIVs:              n_p * n_p_pad * 3  +  n_p * board.n_obstacles  +  n_p * 2
+# SQRTs:             n_p * n_p_pad * 3  +  n_p * board.n_obstacles  +  n_p * 3
+# EXPs:              n_p * board.n_obstacles
+
+
+def adds(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 7) & ~7
+  return int(n_iter *
+             (n_p * 22 + n_p * n_p_pad * 29 + n_p * n_obs * 10 + n_p * 7))
+
+
+def mults(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 7) & ~7
+  return int(n_iter *
+             (n_p * 4 + n_p * n_p_pad * 42 + n_p * n_obs * 13 + n_p * 16))
+
+
+def divs(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 7) & ~7
+  return int(n_iter * (n_p * n_p_pad * 3 + n_p * n_obs + n_p * 2))
+
+
+def sqrts(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 7) & ~7
+  return int(n_iter * (n_p * n_p_pad * 3 + n_p * n_obs + n_p * 3))
+
+
+def exps(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 7) & ~7
+  return int(n_iter * (n_p * n_obs))
+
+
+def total(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return adds(n_iter, n_p, n_obs) + mults(n_iter, n_p, n_obs) + divs(
+    n_iter, n_p, n_obs) + sqrts(n_iter, n_p,
+                                n_obs) + exps(n_iter, n_p, n_obs) * 30

flopcounts/x86/variant_float_inlining_SoA_AVX2_polyexp_rsqrt_loopopt.py

@@ -0,0 +1,41 @@
+# const int n_p_pad = (n_p + 7) & ~7;
+
+# flops per iteration (one pass of the outer time loop):
+# ADDs:   n_p * 22  +  n_p * n_p_pad * 28  +  n_p * board.n_obstacles * 10  +  n_p * 7
+# MULTs:  n_p * 4   +  n_p * n_p_pad * 42  +  n_p * board.n_obstacles * 13  +  n_p * 16
+# DIVs:              n_p * n_p_pad * 3  +  n_p * board.n_obstacles  +  n_p * 2
+# SQRTs:             n_p * n_p_pad * 3  +  n_p * board.n_obstacles  +  n_p * 3
+# EXPs:              n_p * board.n_obstacles
+
+
+def adds(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 7) & ~7
+  return int(n_iter *
+             (n_p * 22 + n_p * n_p_pad * 28 + n_p * n_obs * 10 + n_p * 7))
+
+
+def mults(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 7) & ~7
+  return int(n_iter *
+             (n_p * 4 + n_p * n_p_pad * 42 + n_p * n_obs * 13 + n_p * 16))
+
+
+def divs(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 7) & ~7
+  return int(n_iter * (n_p * n_p_pad * 3 + n_p * n_obs + n_p * 2))
+
+
+def sqrts(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 7) & ~7
+  return int(n_iter * (n_p * n_p_pad * 3 + n_p * n_obs + n_p * 3))
+
+
+def exps(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 7) & ~7
+  return int(n_iter * (n_p * n_obs))
+
+
+def total(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return adds(n_iter, n_p, n_obs) + mults(n_iter, n_p, n_obs) + divs(
+    n_iter, n_p, n_obs) + sqrts(n_iter, n_p,
+                                n_obs) + exps(n_iter, n_p, n_obs) * 30

flopcounts/x86/variant_float_inlining_SoA_AVX512_polyexp.py

@@ -0,0 +1,62 @@
+# const int n_p_pad = (n_p + 15) & ~15;
+
+# ADDs: n_iter * (
+#   n_p * 36 +
+#   n_p * n_p_pad * 29 +
+#   n_p * board.n_obstacles * 10 +
+#   n_p * 7
+# )
+#
+# MULTs: n_iter * (
+#   n_p * 4 +
+#   n_p * n_p_pad * 40 +
+#   n_p * board.n_obstacles * 13 +
+#   n_p * 17
+# )
+#
+# DIVs: n_iter * (
+#   n_p * n_p_pad +
+#   n_p * board.n_obstacles +
+#   n_p * 2
+# )
+#
+# SQRTs: n_iter * (
+#   n_p * n_p_pad * 3 +
+#   n_p * board.n_obstacles +
+#   n_p * 3
+# )
+#
+# EXPs: n_iter * n_p * board.n_obstacles
+
+
+def adds(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 15) & ~15
+  return int(n_iter *
+             (n_p * 36 + n_p * n_p_pad * 29 + n_p * n_obs * 10 + n_p * 7))
+
+
+def mults(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 15) & ~15
+  return int(n_iter *
+             (n_p * 4 + n_p * n_p_pad * 40 + n_p * n_obs * 13 + n_p * 17))
+
+
+def divs(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 15) & ~15
+  return int(n_iter * (n_p * n_p_pad + n_p * n_obs + n_p * 2))
+
+
+def sqrts(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 15) & ~15
+  return int(n_iter * (n_p * n_p_pad * 3 + n_p * n_obs + n_p * 3))
+
+
+def exps(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 15) & ~15
+  return int(n_iter * n_p * n_obs)
+
+
+def total(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return adds(n_iter, n_p, n_obs) + mults(n_iter, n_p, n_obs) + divs(
+    n_iter, n_p, n_obs) + sqrts(n_iter, n_p,
+                                n_obs) + exps(n_iter, n_p, n_obs) * 30

flopcounts/x86/variant_float_inlining_SoA_AVX512_polyexp_fastinvsqrt.py

@@ -0,0 +1,61 @@
+# const int n_p_pad = (n_p + 15) & ~15;
+
+# ADDs: n_iter * (
+#   n_p * 36 +
+#   n_p * n_p_pad * 29 +
+#   n_p * board.n_obstacles * 10 +
+#   n_p * 11
+# )
+
+# MULTs: n_iter * (
+#   n_p * 4 +
+#   n_p * n_p_pad * 40 +
+#   n_p * board.n_obstacles * 13 +
+#   n_p * 30
+# )
+
+# DIVs: n_iter * (
+#   n_p * n_p_pad +
+#   n_p * board.n_obstacles
+# )
+
+# SQRTs: n_iter * (
+#   n_p * n_p_pad * 3 +
+#   n_p * board.n_obstacles +
+#   n_p
+# )
+
+# EXPs: n_iter * n_p * board.n_obstacles
+
+
+def adds(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 15) & ~15
+  return int(n_iter *
+             (n_p * 36 + n_p * n_p_pad * 29 + n_p * n_obs * 10 + n_p * 11))
+
+
+def mults(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 15) & ~15
+  return int(n_iter *
+             (n_p * 4 + n_p * n_p_pad * 40 + n_p * n_obs * 13 + n_p * 30))
+
+
+def divs(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 15) & ~15
+  return int(n_iter * (n_p * n_p_pad + n_p * n_obs))
+
+
+def sqrts(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 15) & ~15
+  return int(n_iter * (n_p * n_p_pad * 3 + n_p * n_obs + n_p))
+
+
+def exps(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 15) & ~15
+  return int(n_iter * n_p * n_obs)
+
+
+def total(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return adds(n_iter, n_p, n_obs) + mults(n_iter, n_p, n_obs) + divs(
+    n_iter, n_p, n_obs) + sqrts(n_iter, n_p,
+                                n_obs) + exps(n_iter, n_p, n_obs) * 30

flopcounts/x86/variant_float_inlining_SoA_AVX512_polyexp_moreavx.py

@@ -0,0 +1,62 @@
+# const int n_p_pad = (n_p + 15) & ~15;
+
+# ADDs: n_iter * (
+#   n_p * 36 +
+#   n_p * n_p_pad * 29 +
+#   n_p * board.n_obstacles * 10 +
+#   n_p_pad * 7
+# )
+
+# MULTs: n_iter * (
+#   n_p * 4 +
+#   n_p * n_p_pad * 40 +
+#   n_p * board.n_obstacles * 13 +
+#   n_p_pad * 15
+# )
+
+# DIVs: n_iter * (
+#   n_p * n_p_pad +
+#   n_p * board.n_obstacles +
+#   n_p_pad * 2
+# )
+
+# SQRTs: n_iter * (
+#   n_p * n_p_pad * 3 +
+#   n_p * board.n_obstacles +
+#   n_p_pad * 3
+# )
+
+# EXPs: n_iter * n_p * board.n_obstacles
+
+
+def adds(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 15) & ~15
+  return int(n_iter *
+             (n_p * 36 + n_p * n_p_pad * 29 + n_p * n_obs * 10 + n_p_pad * 7))
+
+
+def mults(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 15) & ~15
+  return int(n_iter *
+             (n_p * 4 + n_p * n_p_pad * 40 + n_p * n_obs * 13 + n_p_pad * 15))
+
+
+def divs(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 15) & ~15
+  return int(n_iter * (n_p * n_p_pad + n_p * n_obs + n_p_pad * 2))
+
+
+def sqrts(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 15) & ~15
+  return int(n_iter * (n_p * n_p_pad * 3 + n_p * n_obs + n_p_pad * 3))
+
+
+def exps(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 15) & ~15
+  return int(n_iter * n_p * n_obs)
+
+
+def total(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return adds(n_iter, n_p, n_obs) + mults(n_iter, n_p, n_obs) + divs(
+    n_iter, n_p, n_obs) + sqrts(n_iter, n_p,
+                                n_obs) + exps(n_iter, n_p, n_obs) * 30

flopcounts/x86/variant_float_inlining_SoA_AVX512_polyexp_moreavx_ilp_2.py

@@ -0,0 +1,62 @@
+# const int n_p_pad = (n_p + 31) & ~31;
+
+# ADDs: n_iter * (
+#   n_p * 68 +
+#   n_p * n_p_pad * 29 +
+#   n_p * board.n_obstacles * 10 +
+#   n_p_pad * 7
+# )
+
+# MULTs: n_iter * (
+#   n_p * 4 +
+#   n_p * n_p_pad * 40 +
+#   n_p * board.n_obstacles * 13 +
+#   n_p_pad * 15
+# )
+
+# SQRTs: n_iter * (
+#   n_p * n_p_pad * 3 +
+#   n_p * board.n_obstacles +
+#   n_p_pad * 3
+# )
+
+# DIVs: n_iter * (
+#   n_p * n_p_pad +
+#   n_p * board.n_obstacles +
+#   n_p_pad * 2
+# )
+
+# EXPs: n_iter * n_p * board.n_obstacles
+
+
+def adds(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 31) & ~31
+  return int(n_iter *
+             (n_p * 68 + n_p * n_p_pad * 29 + n_p * n_obs * 10 + n_p_pad * 7))
+
+
+def mults(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 31) & ~31
+  return int(n_iter *
+             (n_p * 4 + n_p * n_p_pad * 40 + n_p * n_obs * 13 + n_p_pad * 15))
+
+
+def divs(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 31) & ~31
+  return int(n_iter * (n_p * n_p_pad + n_p * n_obs + n_p_pad * 2))
+
+
+def sqrts(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 31) & ~31
+  return int(n_iter * (n_p * n_p_pad * 3 + n_p * n_obs + n_p_pad * 3))
+
+
+def exps(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 31) & ~31
+  return int(n_iter * n_p * n_obs)
+
+
+def total(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return adds(n_iter, n_p, n_obs) + mults(n_iter, n_p, n_obs) + divs(
+    n_iter, n_p, n_obs) + sqrts(n_iter, n_p,
+                                n_obs) + exps(n_iter, n_p, n_obs) * 30

flopcounts/x86/variant_float_inlining_SoA_AVX512_polyexp_moreavx_ilp_2_moreilp.py

@@ -0,0 +1,62 @@
+# const int n_p_pad = (n_p + 31) & ~31;
+
+# ADDs: n_iter * (
+#   n_p * 68 +
+#   n_p * n_p_pad * 29 +
+#   n_p * board.n_obstacles * 10 +
+#   n_p_pad * 7
+# )
+
+# MULTs: n_iter * (
+#   n_p * 4 +
+#   n_p * n_p_pad * 40 +
+#   n_p * board.n_obstacles * 13 +
+#   n_p_pad * 15
+# )
+
+# DIVs: n_iter * (
+#   n_p * n_p_pad +
+#   n_p * board.n_obstacles +
+#   n_p_pad * 2
+# )
+
+# SQRTs:  n_iter * (
+#   n_p * n_p_pad * 3 +
+#   n_p * board.n_obstacles +
+#   n_p_pad * 3
+# )
+
+# EXPs: n_iter * n_p * board.n_obstacles
+
+
+def adds(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 31) & ~31
+  return int(n_iter *
+             (n_p * 68 + n_p * n_p_pad * 29 + n_p * n_obs * 10 + n_p_pad * 7))
+
+
+def mults(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 31) & ~31
+  return int(n_iter *
+             (n_p * 4 + n_p * n_p_pad * 40 + n_p * n_obs * 13 + n_p_pad * 15))
+
+
+def divs(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 31) & ~31
+  return int(n_iter * (n_p * n_p_pad + n_p * n_obs + n_p_pad * 2))
+
+
+def sqrts(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 31) & ~31
+  return int(n_iter * (n_p * n_p_pad * 3 + n_p * n_obs + n_p_pad * 3))
+
+
+def exps(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 31) & ~31
+  return int(n_iter * n_p * n_obs)
+
+
+def total(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return adds(n_iter, n_p, n_obs) + mults(n_iter, n_p, n_obs) + divs(
+    n_iter, n_p, n_obs) + sqrts(n_iter, n_p,
+                                n_obs) + exps(n_iter, n_p, n_obs) * 30

flopcounts/x86/variant_float_inlining_SoA_AVX512_polyexp_moreavx_ilp_2_rsqrt.py

@@ -0,0 +1,62 @@
+# const int n_p_pad = (n_p + 31) & ~31;
+
+# ADDs: n_iter * (
+#   n_p * 68 +
+#   n_p * n_p_pad * 29
+#   n_p * board.n_obstacles * 10
+#   n_p_pad * 9
+# )
+
+# MULTs: n_iter * (
+#   n_p * 4 +
+#   n_p * n_p_pad * 40
+#   n_p * board.n_obstacles * 13
+#   n_p_pad * 17
+# )
+
+# DIVs: n_iter * (
+#   n_p * n_p_pad
+#   n_p * board.n_obstacles
+#   n_p_pad * 2
+# )
+
+# SQRTs: n_iter * (
+#   n_p * n_p_pad * 3
+#   n_p * board.n_obstacles
+#   n_p_pad * 3
+# )
+
+# EXPs: n_iter * n_p * board.n_obstacles
+
+
+def adds(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 31) & ~31
+  return int(n_iter *
+             (n_p * 68 + n_p * n_p_pad * 29 + n_p * n_obs * 10 + n_p_pad * 9))
+
+
+def mults(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 31) & ~31
+  return int(n_iter *
+             (n_p * 4 + n_p * n_p_pad * 40 + n_p * n_obs * 13 + n_p_pad * 17))
+
+
+def divs(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 31) & ~31
+  return int(n_iter * (n_p * n_p_pad + n_p * n_obs + n_p_pad * 2))
+
+
+def sqrts(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 31) & ~31
+  return int(n_iter * (n_p * n_p_pad * 3 + n_p * n_obs + n_p_pad * 3))
+
+
+def exps(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 31) & ~31
+  return int(n_iter * n_p * n_obs)
+
+
+def total(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return adds(n_iter, n_p, n_obs) + mults(n_iter, n_p, n_obs) + divs(
+    n_iter, n_p, n_obs) + sqrts(n_iter, n_p,
+                                n_obs) + exps(n_iter, n_p, n_obs) * 30

flopcounts/x86/variant_float_inlining_SoA_AVX512_polyexp_moreavx_ilp_2_rsqrt_morersqrt.py

@@ -0,0 +1,61 @@
+#  const int n_p_pad = (n_p + 31) & ~31;
+
+# ADDs: n_iter * (
+#   n_p * 68 +
+#   n_p * n_p_pad * 29 +
+#   n_p * board.n_obstacles * 10 +
+#   n_p_pad * 7
+# )
+
+# MULTs: n_iter * (
+#   n_p * 4 +
+#   n_p * n_p_pad * 42 +
+#   n_p * board.n_obstacles * 13 +
+#   n_p_pad * 16
+# )
+
+# DIVs: n_iter * (
+#   n_p * n_p_pad * 3 +
+#   n_p * board.n_obstacles +
+#   n_p_pad * 2
+# )
+
+# SQRTs: n_iter * (
+#   n_p * n_p_pad * 3 +
+#   n_p * board.n_obstacles +
+#   n_p_pad * 3
+# )
+
+# EXPs: n_iter * n_p * board.n_obstacles
+
+
+def adds(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 31) & ~31
+  return int(n_iter *
+             (n_p * 68 + n_p * n_p_pad * 29 + n_p * n_obs * 10 + n_p_pad * 7))
+
+
+def mults(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 31) & ~31
+  return int(n_iter *
+             (n_p * 4 + n_p * n_p_pad * 42 + n_p * n_obs * 13 + n_p_pad * 16))
+
+
+def divs(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 31) & ~31
+  return int(n_iter * (n_p * n_p_pad * 3 + n_p * n_obs + n_p_pad * 2))
+
+
+def sqrts(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 31) & ~31
+  return int(n_iter * (n_p * n_p_pad * 3 + n_p * n_obs + n_p_pad * 3))
+
+
+def exps(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 31) & ~31
+  return int(n_iter * n_p * n_obs)
+
+
+def total(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return adds(n_iter, n_p, n_obs) + mults(n_iter, n_p, n_obs) + divs(
+    n_iter, n_p, n_obs) + sqrts(n_iter, n_p, n_obs) + exps(n_iter, n_p, n_obs) * 30

flopcounts/x86/variant_float_inlining_SoA_AVX512_polyexp_moreavx_ilp_2_rsqrt_morersqrt_improved.py

@@ -0,0 +1,61 @@
+# const int n_p_pad = (n_p + 31) & ~31;
+
+# ADDs: n_iter * (
+#   n_p * 84 +
+#   n_p * n_p_pad * 29 +
+#   n_p * board.n_obstacles * 10 +
+#   n_p_pad * 7
+# )
+
+# MULTs: n_iter * (
+#   n_p * 4 +
+#   n_p * n_p_pad * 42 +
+#   n_p * board.n_obstacles * 13 +
+#   n_p_pad * 16
+# )
+
+# DIVs: n_iter * (
+#   n_p * n_p_pad * 3 +
+#   n_p * board.n_obstacles +
+#   n_p_pad * 2
+# )
+
+# SQRTs: n_iter * (
+#   n_p * n_p_pad * 3 +
+#   n_p * board.n_obstacles +
+#   n_p_pad * 3
+# )
+
+# EXPs: n_iter * n_p * board.n_obstacles
+
+
+def adds(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 31) & ~31
+  return int(n_iter *
+             (n_p * 84 + n_p * n_p_pad * 29 + n_p * n_obs * 10 + n_p_pad * 7))
+
+
+def mults(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 31) & ~31
+  return int(n_iter *
+             (n_p * 4 + n_p * n_p_pad * 42 + n_p * n_obs * 13 + n_p_pad * 16))
+
+
+def divs(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 31) & ~31
+  return int(n_iter * (n_p * n_p_pad * 3 + n_p * n_obs + n_p_pad * 2))
+
+
+def sqrts(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 31) & ~31
+  return int(n_iter * (n_p * n_p_pad * 3 + n_p * n_obs + n_p_pad * 3))
+
+
+def exps(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 31) & ~31
+  return int(n_iter * n_p * n_obs)
+
+
+def total(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return adds(n_iter, n_p, n_obs) + mults(n_iter, n_p, n_obs) + divs(
+    n_iter, n_p, n_obs) + sqrts(n_iter, n_p, n_obs) + exps(n_iter, n_p, n_obs) * 30

flopcounts/x86/variant_float_inlining_SoA_AVX512_polyexp_moreavx_ilp_2_rsqrt_morersqrt_improved_moreilp.py

@@ -0,0 +1,62 @@
+# const int n_p_pad = (n_p + 15) & ~15;
+
+# ADDs: n_iter * (
+#   n_p_pad * 7 +
+#   n_p_pad * n_p * 29 +
+#   n_p_pad * 2(=board.n_obstacles) * 24 +
+#   n_p_pad * 7
+# )
+
+# MULTs: n_iter * (
+#   n_p_pad * 4 +
+#   n_p_pad * n_p * 42 +
+#   n_p_pad * 2(=board.n_obstacles) * 31 +
+#   n_p_pad * 16
+# )
+
+# DIVs: n_iter * (
+#   n_p_pad * n_p * 3 +
+#   n_p_pad * 2(=board.n_obstacles) * 1 +
+#   n_p_pad * 2
+# )
+
+# SQRTs: n_iter * (
+#   n_p_pad * n_p * 3 +
+#   n_p_pad * 2(=board.n_obstacles) * 1 +
+#   n_p_pad * 3
+# )
+
+
+def adds(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 15) & ~15
+  return int(
+    n_iter *
+    (n_p_pad * 7 + n_p_pad * n_p * 29 + n_p_pad * n_obs * 24 + n_p_pad * 7))
+
+
+def mults(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 15) & ~15
+  return int(
+    n_iter *
+    (n_p_pad * 4 + n_p_pad * n_p * 42 + n_p_pad * n_obs * 31 + n_p_pad * 16))
+
+
+def divs(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 15) & ~15
+  return int(n_iter * (n_p_pad * n_p * 3 + n_p_pad * n_obs * 1 + n_p_pad * 2))
+
+
+def sqrts(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 15) & ~15
+  return int(n_iter * (n_p_pad * n_p * 3 + n_p_pad * n_obs * 1 + n_p_pad * 3))
+
+
+def exps(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 15) & ~15
+  return int(0)
+
+
+def total(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return adds(n_iter, n_p, n_obs) + mults(n_iter, n_p, n_obs) + divs(
+    n_iter, n_p, n_obs) + sqrts(n_iter, n_p,
+                                n_obs) + exps(n_iter, n_p, n_obs) * 30

flopcounts/x86/variant_float_inlining_SoA_AVX512_polyexp_moreavx_ilp_4.py

@@ -0,0 +1,62 @@
+# const int n_p_pad = (n_p + 63) & ~63;
+
+# ADDs: n_iter * (
+#   n_p * 132 +
+#   n_p * n_p_pad * 29 +
+#   n_p * board.n_obstacles * 10 +
+#   n_p_pad * 7
+# )
+
+# MULTs: n_iter * (
+#   n_p * 4 +
+#   n_p * n_p_pad * 40 +
+#   n_p * board.n_obstacles * 13 +
+#   n_p_pad * 15
+# )
+
+# DIVs: n_iter * (
+#   n_p * n_p_pad +
+#   n_p * board.n_obstacles +
+#   n_p_pad * 2
+# )
+
+# SQRTs: n_iter * (
+#   n_p * n_p_pad * 3 +
+#   n_p * board.n_obstacles +
+#   n_p_pad * 3
+# )
+
+# EXPs: n_iter * n_p * board.n_obstacles
+
+
+def adds(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 63) & ~63
+  return int(n_iter *
+             (n_p * 132 + n_p * n_p_pad * 29 + n_p * n_obs * 10 + n_p_pad * 7))
+
+
+def mults(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 63) & ~63
+  return int(n_iter *
+             (n_p * 4 + n_p * n_p_pad * 40 + n_p * n_obs * 13 + n_p_pad * 15))
+
+
+def divs(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 63) & ~63
+  return int(n_iter * (n_p * n_p_pad + n_p * n_obs + n_p_pad * 2))
+
+
+def sqrts(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 63) & ~63
+  return int(n_iter * (n_p * n_p_pad * 3 + n_p * n_obs + n_p_pad * 3))
+
+
+def exps(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 63) & ~63
+  return int(n_iter * n_p * n_obs)
+
+
+def total(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return adds(n_iter, n_p, n_obs) + mults(n_iter, n_p, n_obs) + divs(
+    n_iter, n_p, n_obs) + sqrts(n_iter, n_p,
+                                n_obs) + exps(n_iter, n_p, n_obs) * 30

flopcounts/x86/variant_float_inlining_SoA_symmetry.py

@@ -0,0 +1,69 @@
+# FLOPCOUNT (everything inside the t-loop). EXP kept as its own op (one real exp() per call).
+# section costs: overhead 4 ADD 4 MULT | distance pair 3 ADD 2 MULT 1 SQRT |
+#                ped-ped j 11 ADD 22 MULT 2 SQRT 1 DIV 1 EXP |
+#                obstacle 10 ADD 13 MULT 1 SQRT 1 DIV 1 EXP | update 7 ADD 17 MULT 3 SQRT 2 DIV
+
+# ADDs: n_iter * (
+#   n_p * 4 +
+#   0.5 * (n_p*n_p - n_p) * 3 +
+#   n_p * (n_p - 1) * 11 +
+#   n_p * board.n_obstacles * 10 +
+#   n_p * 7
+# )
+
+# MULTs: n_iter * (
+#   n_p * 4 +
+#   0.5 * (n_p*n_p - n_p) * 2 +
+#   n_p * (n_p - 1) * 22 +
+#   n_p * board.n_obstacles * 13 +
+#   n_p * 17
+# )
+
+# DIVs: n_iter * (
+#   n_p * (n_p - 1) +
+#   n_p * board.n_obstacles +
+#   n_p * 2
+# )
+
+# SQRTs: n_iter * (
+#   0.5 * (n_p*n_p - n_p) +
+#   n_p * (n_p - 1) * 2 +
+#   n_p * board.n_obstacles +
+#   n_p * 3
+# )
+
+# EXPs: n_iter * (
+#   n_p * (n_p - 1) +
+#   n_p * board.n_obstacles
+# )
+
+# total with EXP = 30: n_iter * ( 69 * n_p ** 2 - 32 * n_p + 55 * n_obstacles * n_p )
+
+
+def adds(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * (n_p * 4 + 0.5 * (n_p * n_p - n_p) * 3 + n_p *
+                       (n_p - 1) * 11 + n_p * n_obs * 10 + n_p * 7))
+
+
+def mults(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * (n_p * 4 + 0.5 * (n_p * n_p - n_p) * 2 + n_p *
+                       (n_p - 1) * 22 + n_p * n_obs * 13 + n_p * 17))
+
+
+def divs(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * (n_p * (n_p - 1) + n_p * n_obs + n_p * 2))
+
+
+def sqrts(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * (0.5 * (n_p * n_p - n_p) + n_p *
+                       (n_p - 1) * 2 + n_p * n_obs + n_p * 3))
+
+
+def exps(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * (n_p * (n_p - 1) + n_p * n_obs))
+
+
+def total(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return adds(n_iter, n_p, n_obs) + mults(n_iter, n_p, n_obs) + divs(
+    n_iter, n_p, n_obs) + sqrts(n_iter, n_p,
+                                n_obs) + exps(n_iter, n_p, n_obs) * 30

flopcounts/x86/variant_float_inlining_SoA_symmetry_ILP_16.py

@@ -0,0 +1,70 @@
+# FLOPCOUNT (everything inside the t-loop). EXP kept as its own op (one real exp() per call).
+# section costs: overhead 4 ADD 4 MULT (+ reductions 4*K = 64 ADD, K=16) |
+#                distance pair 3 ADD 2 MULT 1 SQRT |
+#                ped-ped j 11 ADD 22 MULT 2 SQRT 1 DIV 1 EXP |
+#                obstacle 10 ADD 13 MULT 1 SQRT 1 DIV 1 EXP | update 7 ADD 17 MULT 3 SQRT 2 DIV
+
+# ADDs: n_iter * (
+#   n_p * 68 +
+#   0.5 * (n_p*n_p - n_p) * 3 +
+#   n_p * (n_p - 1) * 11 +
+#   n_p * board.n_obstacles * 10 +
+#   n_p * 7
+# )
+
+# MULTs: n_iter * (
+#   n_p * 4 +
+#   0.5 * (n_p*n_p - n_p) * 2 +
+#   n_p * (n_p - 1) * 22 +
+#   n_p * board.n_obstacles * 13 +
+#   n_p * 17
+# )
+
+# DIVs: n_iter * (
+#   n_p * (n_p - 1) +
+#   n_p * board.n_obstacles +
+#   n_p * 2
+# )
+
+# SQRTs: n_iter * (
+#   0.5 * (n_p*n_p - n_p) +
+#   n_p * (n_p - 1) * 2 +
+#   n_p * board.n_obstacles +
+#   n_p * 3
+# )
+
+# EXPs: n_iter * (
+#   n_p * (n_p - 1) +
+#   n_p * board.n_obstacles
+# )
+
+# total with EXP = 30: n_iter * ( 69 * n_p ** 2 + 32 * n_p + 55 * n_obstacles * n_p )
+
+
+def adds(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * (n_p * 68 + 0.5 * (n_p * n_p - n_p) * 3 + n_p *
+                       (n_p - 1) * 11 + n_p * n_obs * 10 + n_p * 7))
+
+
+def mults(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * (n_p * 4 + 0.5 * (n_p * n_p - n_p) * 2 + n_p *
+                       (n_p - 1) * 22 + n_p * n_obs * 13 + n_p * 17))
+
+
+def divs(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * (n_p * (n_p - 1) + n_p * n_obs + n_p * 2))
+
+
+def sqrts(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * (0.5 * (n_p * n_p - n_p) + n_p *
+                       (n_p - 1) * 2 + n_p * n_obs + n_p * 3))
+
+
+def exps(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * (n_p * (n_p - 1) + n_p * n_obs))
+
+
+def total(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return adds(n_iter, n_p, n_obs) + mults(n_iter, n_p, n_obs) + divs(
+    n_iter, n_p, n_obs) + sqrts(n_iter, n_p,
+                                n_obs) + exps(n_iter, n_p, n_obs) * 30

flopcounts/x86/variant_float_inlining_SoA_symmetry_ILP_2.py

@@ -0,0 +1,70 @@
+# FLOPCOUNT (everything inside the t-loop). EXP kept as its own op (one real exp() per call).
+# section costs: overhead 4 ADD 4 MULT (+ reductions 4*K = 8 ADD, K=2) |
+#                distance pair 3 ADD 2 MULT 1 SQRT |
+#                ped-ped j 11 ADD 22 MULT 2 SQRT 1 DIV 1 EXP |
+#                obstacle 10 ADD 13 MULT 1 SQRT 1 DIV 1 EXP | update 7 ADD 17 MULT 3 SQRT 2 DIV
+
+# ADDs: n_iter * (
+#   n_p * 12 +
+#   0.5 * (n_p*n_p - n_p) * 3 +
+#   n_p * (n_p - 1) * 11 +
+#   n_p * board.n_obstacles * 10 +
+#   n_p * 7
+# )
+
+# MULTs: n_iter * (
+#   n_p * 4 +
+#   0.5 * (n_p*n_p - n_p) * 2 +
+#   n_p * (n_p - 1) * 22 +
+#   n_p * board.n_obstacles * 13 +
+#   n_p * 17
+# )
+
+# DIVs: n_iter * (
+#   n_p * (n_p - 1) +
+#   n_p * board.n_obstacles +
+#   n_p * 2
+# )
+
+# SQRTs: n_iter * (
+#   0.5 * (n_p*n_p - n_p) +
+#   n_p * (n_p - 1) * 2 +
+#   n_p * board.n_obstacles +
+#   n_p * 3
+# )
+
+# EXPs: n_iter * (
+#   n_p * (n_p - 1) +
+#   n_p * board.n_obstacles
+# )
+
+# total with EXP = 30: n_iter * ( 69 * n_p ** 2 - 24 * n_p + 55 * n_obstacles * n_p )
+
+
+def adds(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * (n_p * 12 + 0.5 * (n_p * n_p - n_p) * 3 + n_p *
+                       (n_p - 1) * 11 + n_p * n_obs * 10 + n_p * 7))
+
+
+def mults(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * (n_p * 4 + 0.5 * (n_p * n_p - n_p) * 2 + n_p *
+                       (n_p - 1) * 22 + n_p * n_obs * 13 + n_p * 17))
+
+
+def divs(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * (n_p * (n_p - 1) + n_p * n_obs + n_p * 2))
+
+
+def sqrts(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * (0.5 * (n_p * n_p - n_p) + n_p *
+                       (n_p - 1) * 2 + n_p * n_obs + n_p * 3))
+
+
+def exps(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * (n_p * (n_p - 1) + n_p * n_obs))
+
+
+def total(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return adds(n_iter, n_p, n_obs) + mults(n_iter, n_p, n_obs) + divs(
+    n_iter, n_p, n_obs) + sqrts(n_iter, n_p,
+                                n_obs) + exps(n_iter, n_p, n_obs) * 30

flopcounts/x86/variant_float_inlining_SoA_symmetry_ILP_4.py

@@ -0,0 +1,70 @@
+# FLOPCOUNT (everything inside the t-loop). EXP kept as its own op (one real exp() per call).
+# section costs: overhead 4 ADD 4 MULT (+ reductions 4*K = 16 ADD, K=4) |
+#                distance pair 3 ADD 2 MULT 1 SQRT |
+#                ped-ped j 11 ADD 22 MULT 2 SQRT 1 DIV 1 EXP |
+#                obstacle 10 ADD 13 MULT 1 SQRT 1 DIV 1 EXP | update 7 ADD 17 MULT 3 SQRT 2 DIV
+
+# ADDs: n_iter * (
+#   n_p * 20 +
+#   0.5 * (n_p*n_p - n_p) * 3 +
+#   n_p * (n_p - 1) * 11 +
+#   n_p * board.n_obstacles * 10 +
+#   n_p * 7
+# )
+
+# MULTs: n_iter * (
+#   n_p * 4 +
+#   0.5 * (n_p*n_p - n_p) * 2 +
+#   n_p * (n_p - 1) * 22 +
+#   n_p * board.n_obstacles * 13 +
+#   n_p * 17
+# )
+
+# DIVs: n_iter * (
+#   n_p * (n_p - 1) +
+#   n_p * board.n_obstacles +
+#   n_p * 2
+# )
+
+# SQRTs: n_iter * (
+#   0.5 * (n_p*n_p - n_p) +
+#   n_p * (n_p - 1) * 2 +
+#   n_p * board.n_obstacles +
+#   n_p * 3
+# )
+
+# EXPs: n_iter * (
+#   n_p * (n_p - 1) +
+#   n_p * board.n_obstacles
+# )
+
+# total with EXP = 30: n_iter * ( 69 * n_p ** 2 - 16 * n_p + 55 * n_obstacles * n_p )
+
+
+def adds(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * (n_p * 20 + 0.5 * (n_p * n_p - n_p) * 3 + n_p *
+                       (n_p - 1) * 11 + n_p * n_obs * 10 + n_p * 7))
+
+
+def mults(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * (n_p * 4 + 0.5 * (n_p * n_p - n_p) * 2 + n_p *
+                       (n_p - 1) * 22 + n_p * n_obs * 13 + n_p * 17))
+
+
+def divs(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * (n_p * (n_p - 1) + n_p * n_obs + n_p * 2))
+
+
+def sqrts(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * (0.5 * (n_p * n_p - n_p) + n_p *
+                       (n_p - 1) * 2 + n_p * n_obs + n_p * 3))
+
+
+def exps(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * (n_p * (n_p - 1) + n_p * n_obs))
+
+
+def total(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return adds(n_iter, n_p, n_obs) + mults(n_iter, n_p, n_obs) + divs(
+    n_iter, n_p, n_obs) + sqrts(n_iter, n_p,
+                                n_obs) + exps(n_iter, n_p, n_obs) * 30

flopcounts/x86/variant_float_inlining_SoA_symmetry_ILP_8.py

@@ -0,0 +1,70 @@
+# FLOPCOUNT (everything inside the t-loop). EXP kept as its own op (one real exp() per call).
+# section costs: overhead 4 ADD 4 MULT (+ reductions 4*K = 32 ADD, K=8) |
+#  distance pair 3 ADD 2 MULT 1 SQRT |
+#  ped-ped j 11 ADD 22 MULT 2 SQRT 1 DIV 1 EXP |
+#  obstacle 10 ADD 13 MULT 1 SQRT 1 DIV 1 EXP | update 7 ADD 17 MULT 3 SQRT 2 DIV
+
+# ADDs: n_iter * (
+#   n_p * 36 +
+#   0.5 * (n_p*n_p - n_p) * 3 +
+#   n_p * (n_p - 1) * 11 +
+#   n_p * board.n_obstacles * 10 +
+#   n_p * 7
+# )
+
+# MULTs: n_iter * (
+#   n_p * 4 +
+#   0.5 * (n_p*n_p - n_p) * 2 +
+#   n_p * (n_p - 1) * 22 +
+#   n_p * board.n_obstacles * 13 +
+#   n_p * 17
+# )
+
+# DIVs: n_iter * (
+#   n_p * (n_p - 1) +
+#   n_p * board.n_obstacles +
+#   n_p * 2
+# )
+
+# SQRTs: n_iter * (
+#   0.5 * (n_p*n_p - n_p) +
+#   n_p * (n_p - 1) * 2 +
+#   n_p * board.n_obstacles +
+#   n_p * 3
+# )
+
+# EXPs: n_iter * (
+#   n_p * (n_p - 1) +
+#   n_p * board.n_obstacles
+# )
+
+# total with EXP = 30: n_iter * ( 69 * n_p ** 2 + 55 * n_obstacles * n_p ) linear term cancels
+
+
+def adds(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * (n_p * 36 + 0.5 * (n_p * n_p - n_p) * 3 + n_p *
+                       (n_p - 1) * 11 + n_p * n_obs * 10 + n_p * 7))
+
+
+def mults(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * (n_p * 4 + 0.5 * (n_p * n_p - n_p) * 2 + n_p *
+                       (n_p - 1) * 22 + n_p * n_obs * 13 + n_p * 17))
+
+
+def divs(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * (n_p * (n_p - 1) + n_p * n_obs + n_p * 2))
+
+
+def sqrts(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * (0.5 * (n_p * n_p - n_p) + n_p *
+                       (n_p - 1) * 2 + n_p * n_obs + n_p * 3))
+
+
+def exps(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * (n_p * (n_p - 1) + n_p * n_obs))
+
+
+def total(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return adds(n_iter, n_p, n_obs) + mults(n_iter, n_p, n_obs) + divs(
+    n_iter, n_p, n_obs) + sqrts(n_iter, n_p,
+                                n_obs) + exps(n_iter, n_p, n_obs) * 30

flopcounts/x86/variant_inlining_7.py

@@ -0,0 +1,44 @@
+# ADDs: n_iter * n_p * 11 +
+#        n_iter * n_p * (n_p - 1) * 14 +
+#        n_iter * n_p * board.n_obstacles * 12
+
+# MULTs: n_iter * n_p * 21 +
+#        n_iter * n_p * (n_p - 1) * 24 +
+#        n_iter * n_p * board.n_obstacles * 19
+
+# DIVs: n_iter * n_p * 2 +
+#        n_iter * n_p * (n_p - 1) +
+#        n_iter * n_p * board.n_obstacles
+
+# SQRTs: n_iter * n_p * 3 +
+#        n_iter * n_p * (n_p - 1) * 3 +
+#        n_iter * n_p * board.n_obstacles
+
+# EXPs: n_iter * n_p * (n_p - 1) +
+#       n_iter * n_p * board.n_obstacles
+
+
+def adds(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * n_p * (11 + (n_p - 1) * 14 + n_obs * 12))
+
+
+def mults(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * n_p * (21 + (n_p - 1) * 24 + n_obs * 19))
+
+
+def divs(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * n_p * (2 + (n_p - 1) + n_obs))
+
+
+def sqrts(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * n_p * (3 + (n_p - 1) * 3 + n_obs))
+
+
+def exps(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * n_p * ((n_p - 1) + n_obs))
+
+
+def total(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return adds(n_iter, n_p, n_obs) + mults(n_iter, n_p, n_obs) + divs(
+    n_iter, n_p, n_obs) + sqrts(n_iter, n_p,
+                                n_obs) + exps(n_iter, n_p, n_obs) * 30

flopcounts/x86/variant_inlining_7_SoA.py

@@ -0,0 +1,44 @@
+# ADDs: n_iter * n_p * 11 +
+#        n_iter * n_p * (n_p - 1) * 14 +
+#        n_iter * n_p * board.n_obstacles * 12
+
+# MULTs: n_iter * n_p * 21 +
+#        n_iter * n_p * (n_p - 1) * 24 +
+#        n_iter * n_p * board.n_obstacles * 19
+
+# DIVs: n_iter * n_p * 2 +
+#        n_iter * n_p * (n_p - 1) +
+#        n_iter * n_p * board.n_obstacles
+
+# SQRTs: n_iter * n_p * 3 +
+#        n_iter * n_p * (n_p - 1) * 3 +
+#        n_iter * n_p * board.n_obstacles
+
+# EXPs: n_iter * n_p * (n_p - 1) +
+#       n_iter * n_p * board.n_obstacles
+
+
+def adds(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * n_p * (11 + (n_p - 1) * 14 + n_obs * 12))
+
+
+def mults(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * n_p * (21 + (n_p - 1) * 24 + n_obs * 19))
+
+
+def divs(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * n_p * (2 + (n_p - 1) + n_obs))
+
+
+def sqrts(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * n_p * (3 + (n_p - 1) * 3 + n_obs))
+
+
+def exps(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * n_p * ((n_p - 1) + n_obs))
+
+
+def total(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return adds(n_iter, n_p, n_obs) + mults(n_iter, n_p, n_obs) + divs(
+    n_iter, n_p, n_obs) + sqrts(n_iter, n_p,
+                                n_obs) + exps(n_iter, n_p, n_obs) * 30

flopcounts/x86/variant_inlining_7_SoA_AVX2.py

@@ -0,0 +1,41 @@
+# const int n_p_pad = (n_p + 3) & ~3;
+
+# flops per iteration (one pass of the outer time loop):
+# ADDs:   n_p * 12  +  n_p * n_p_pad * 15  +  n_p * board.n_obstacles * 12  +  n_p * 7
+# MULTs:  n_p * 4   +  n_p * n_p_pad * 24  +  n_p * board.n_obstacles * 19  +  n_p * 16
+# DIVs:              n_p * n_p_pad * 1  +  n_p * board.n_obstacles  +  n_p * 2
+# SQRTs:            n_p * n_p_pad * 3  +  n_p * board.n_obstacles  +  n_p * 3
+# EXPs:  n_p * n_p_pad * 1  +  n_p * board.n_obstacles
+
+
+def adds(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 3) & ~3
+  return int(n_iter *
+             (n_p * 12 + n_p * n_p_pad * 15 + n_p * n_obs * 12 + n_p * 7))
+
+
+def mults(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 3) & ~3
+  return int(n_iter *
+             (n_p * 4 + n_p * n_p_pad * 24 + n_p * n_obs * 19 + n_p * 16))
+
+
+def divs(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 3) & ~3
+  return int(n_iter * (n_p * n_p_pad * 1 + n_p * n_obs + n_p * 2))
+
+
+def sqrts(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 3) & ~3
+  return int(n_iter * (n_p * n_p_pad * 3 + n_p * n_obs + n_p * 3))
+
+
+def exps(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 3) & ~3
+  return int(n_iter * (n_p * n_p_pad * 1 + n_p * n_obs))
+
+
+def total(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return adds(n_iter, n_p, n_obs) + mults(n_iter, n_p, n_obs) + divs(
+    n_iter, n_p, n_obs) + sqrts(n_iter, n_p,
+                                n_obs) + exps(n_iter, n_p, n_obs) * 30

flopcounts/x86/variant_inlining_7_SoA_AVX2_polyexp.py

@@ -0,0 +1,41 @@
+# const int n_p_pad = (n_p + 3) & ~3;
+
+# flops per iteration (one pass of the outer time loop):
+# ADDs:   n_p * 12  +  n_p * n_p_pad * 29  +  n_p * board.n_obstacles * 12  +  n_p * 7
+# MULTs:  n_p * 4   +  n_p * n_p_pad * 40  +  n_p * board.n_obstacles * 19  +  n_p * 16
+# DIVs:              n_p * n_p_pad * 1  +  n_p * board.n_obstacles  +  n_p * 2
+# SQRTs:             n_p * n_p_pad * 3  +  n_p * board.n_obstacles  +  n_p * 3
+# EXPs:              n_p * board.n_obstacles
+
+
+def adds(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 3) & ~3
+  return int(n_iter *
+             (n_p * 12 + n_p * n_p_pad * 29 + n_p * n_obs * 12 + n_p * 7))
+
+
+def mults(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 3) & ~3
+  return int(n_iter *
+             (n_p * 4 + n_p * n_p_pad * 40 + n_p * n_obs * 19 + n_p * 16))
+
+
+def divs(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 3) & ~3
+  return int(n_iter * (n_p * n_p_pad * 1 + n_p * n_obs + n_p * 2))
+
+
+def sqrts(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 3) & ~3
+  return int(n_iter * (n_p * n_p_pad * 3 + n_p * n_obs + n_p * 3))
+
+
+def exps(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 3) & ~3
+  return int(n_iter * (n_p * n_obs))
+
+
+def total(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return adds(n_iter, n_p, n_obs) + mults(n_iter, n_p, n_obs) + divs(
+    n_iter, n_p, n_obs) + sqrts(n_iter, n_p,
+                                n_obs) + exps(n_iter, n_p, n_obs) * 30

flopcounts/x86/variant_inlining_7_symmetry_1.py

@@ -0,0 +1,27 @@
+# n_iter * [ n_p ** 2 * (12.5 ADD + 23 MULT + 1 DIV + 1 EXP + 2.5 SQRT) + n_p * (- 1.5 ADD + 0.5 SQRT - 2 MULT - 1 EXP + 1 DIV) + n_obstacles * n_p * (12 ADD + 19 MULT + 1 SQRT + 1 DIV + 1 EXP) ]
+
+
+def adds(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * (n_p**2 * 12.5 + n_p * (-1.5) + n_obs * n_p * 12))
+
+
+def mults(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * (n_p**2 * 23 + n_p * (-2) + n_obs * n_p * 19))
+
+
+def divs(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * (n_p**2 * 1 + n_p * 1 + n_obs * n_p * 1))
+
+
+def sqrts(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * (n_p**2 * 2.5 + n_p * 0.5 + n_obs * n_p * 1))
+
+
+def exps(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * (n_p**2 * 1 + n_p * (-1) + n_obs * n_p * 1))
+
+
+def total(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return adds(n_iter, n_p, n_obs) + mults(n_iter, n_p, n_obs) + divs(
+    n_iter, n_p, n_obs) + sqrts(n_iter, n_p,
+                                n_obs) + exps(n_iter, n_p, n_obs) * 30

flopcounts/x86/variant_inlining_7_symmetry_2.py

@@ -0,0 +1,27 @@
+# n_iter * [ n_p ** 2 * (12.5 ADD + 23 MULT + 1 DIV + 1 EXP + 2.5 SQRT) + n_p * (- 1.5 ADD + 0.5 SQRT - 2 MULT - 1 EXP + 1 DIV) + n_obstacles * n_p * (12 ADD + 19 MULT + 1 SQRT + 1 DIV + 1 EXP) ]
+
+
+def adds(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * (n_p**2 * 12.5 + n_p * (-1.5) + n_obs * n_p * 12))
+
+
+def mults(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * (n_p**2 * 23 + n_p * (-2) + n_obs * n_p * 19))
+
+
+def divs(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * (n_p**2 * 1 + n_p * 1 + n_obs * n_p * 1))
+
+
+def sqrts(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * (n_p**2 * 2.5 + n_p * 0.5 + n_obs * n_p * 1))
+
+
+def exps(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * (n_p**2 * 1 + n_p * (-1) + n_obs * n_p * 1))
+
+
+def total(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return adds(n_iter, n_p, n_obs) + mults(n_iter, n_p, n_obs) + divs(
+    n_iter, n_p, n_obs) + sqrts(n_iter, n_p,
+                                n_obs) + exps(n_iter, n_p, n_obs) * 30

flopcounts/x86/variant_inlining_7_symmetry_2_ilp_1.py

@@ -0,0 +1,27 @@
+# n_iter * [ n_p ** 2 * (12.5 A + 2.5 S + 23 M + 1 D + 1 E) + n_p * (6.5 A + 0.5 S - 2 M + 1 D - 1 E) + n_obstacles * n_p * (12 A + 19 M + 1 S + 1 D + 1 E)]
+
+
+def adds(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * (n_p**2 * 12.5 + n_p * 6.5 + n_obs * n_p * 12))
+
+
+def mults(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * (n_p**2 * 23 + n_p * (-2) + n_obs * n_p * 19))
+
+
+def divs(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * (n_p**2 * 1 + n_p * 1 + n_obs * n_p * 1))
+
+
+def sqrts(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * (n_p**2 * 2.5 + n_p * 0.5 + n_obs * n_p * 1))
+
+
+def exps(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * (n_p**2 * 1 + n_p * (-1) + n_obs * n_p * 1))
+
+
+def total(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return adds(n_iter, n_p, n_obs) + mults(n_iter, n_p, n_obs) + divs(
+    n_iter, n_p, n_obs) + sqrts(n_iter, n_p,
+                                n_obs) + exps(n_iter, n_p, n_obs) * 30

flopcounts/x86/variant_inlining_7_symmetry_2_ilp_2.py

@@ -0,0 +1,27 @@
+# n_iter * [ n_p ** 2 * (12.5 A + 23 M + 2.5 S + 1 D + 1 E) + n_p * (14.5 A - 2 M + 0.5 S + 1 D - 1 E) + n_obstacles * n_p * (12 A + 19 M + 1 S + 1 D + 1 E) ]
+
+
+def adds(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * (n_p**2 * 12.5 + n_p * 14.5 + n_obs * n_p * 12))
+
+
+def mults(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * (n_p**2 * 23 + n_p * (-2) + n_obs * n_p * 19))
+
+
+def divs(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * (n_p**2 * 1 + n_p * 1 + n_obs * n_p * 1))
+
+
+def sqrts(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * (n_p**2 * 2.5 + n_p * 0.5 + n_obs * n_p * 1))
+
+
+def exps(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * (n_p**2 * 1 + n_p * (-1) + n_obs * n_p * 1))
+
+
+def total(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return adds(n_iter, n_p, n_obs) + mults(n_iter, n_p, n_obs) + divs(
+    n_iter, n_p, n_obs) + sqrts(n_iter, n_p,
+                                n_obs) + exps(n_iter, n_p, n_obs) * 30

flopcounts/x86/variant_inlining_8.py

@@ -0,0 +1,44 @@
+# ADDs: n_iter * n_p * 11 +
+#        n_iter * n_p * (n_p - 1) * 14 +
+#        n_iter * n_p * board.n_obstacles * 10
+
+# MULTs: n_iter * n_p * 21 +
+#        n_iter * n_p * (n_p - 1) * 24 +
+#        n_iter * n_p * board.n_obstacles * 13
+
+# DIVs: n_iter * n_p * 2 +
+#        n_iter * n_p * (n_p - 1) +
+#        n_iter * n_p * board.n_obstacles
+
+# SQRTs: n_iter * n_p * 3 +
+#        n_iter * n_p * (n_p - 1) * 3 +
+#        n_iter * n_p * board.n_obstacles
+
+# EXPs: n_iter * n_p * (n_p - 1) +
+#       n_iter * n_p * board.n_obstacles
+
+
+def adds(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * n_p * (11 + (n_p - 1) * 14 + n_obs * 10))
+
+
+def mults(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * n_p * (21 + (n_p - 1) * 24 + n_obs * 13))
+
+
+def divs(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * n_p * (2 + (n_p - 1) + n_obs))
+
+
+def sqrts(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * n_p * (3 + (n_p - 1) * 3 + n_obs))
+
+
+def exps(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * n_p * ((n_p - 1) + n_obs))
+
+
+def total(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return adds(n_iter, n_p, n_obs) + mults(n_iter, n_p, n_obs) + divs(
+    n_iter, n_p, n_obs) + sqrts(n_iter, n_p,
+                                n_obs) + exps(n_iter, n_p, n_obs) * 30

flopcounts/x86/variant_inlining_8_SoA_AVX512_polyexp_fastinvsqrt.py

@@ -0,0 +1,49 @@
+# const int n_p_pad = (n_p + 7) & ~7;
+
+# ADDs: n_iter * n_p * 33 +
+#        n_iter * n_p * (n_p_pad / 8) * 232 +
+#        n_iter * n_p * board.n_obstacles * 10
+
+# MULTs: n_iter * n_p * 40 +
+#        n_iter * n_p * (n_p_pad / 8) * 320 +
+#        n_iter * n_p * board.n_obstacles * 13
+
+# DIVs: n_iter * n_p * (n_p_pad / 8) * 8 +
+#        n_iter * n_p * board.n_obstacles
+
+# SQRTs: n_iter * n_p +
+#        n_iter * n_p * (n_p_pad / 8) * 24 +
+#        n_iter * n_p * board.n_obstacles
+
+# EXPs: n_iter * n_p * board.n_obstacles
+
+
+def adds(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 7) & ~7
+  return int(n_iter * n_p * (33 + (n_p_pad // 8) * 232 + n_obs * 10))
+
+
+def mults(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 7) & ~7
+  return int(n_iter * n_p * (40 + (n_p_pad // 8) * 320 + n_obs * 13))
+
+
+def divs(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 7) & ~7
+  return int(n_iter * n_p * ((n_p_pad // 8) * 8 + n_obs))
+
+
+def sqrts(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 7) & ~7
+  return int(n_iter * n_p * (1 + (n_p_pad // 8) * 24 + n_obs))
+
+
+def exps(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 7) & ~7
+  return int(n_iter * n_p * n_obs)
+
+
+def total(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return adds(n_iter, n_p, n_obs) + mults(n_iter, n_p, n_obs) + divs(
+    n_iter, n_p, n_obs) + sqrts(n_iter, n_p,
+                                n_obs) + exps(n_iter, n_p, n_obs) * 30

flopcounts/x86/variant_inlining_8_SoA_AVX512_polyexp_fastinvsqrt_sr.py

@@ -0,0 +1,49 @@
+# const int n_p_pad = (n_p + 7) & ~7;
+
+# ADDs: n_iter * n_p * 33 +
+#        n_iter * n_p * (n_p_pad / 8) * 232 +
+#        n_iter * n_p * board.n_obstacles * 10
+
+# MULTs: n_iter * n_p * 40 +
+#        n_iter * n_p * (n_p_pad / 8) * 320 +
+#        n_iter * n_p * board.n_obstacles * 13
+
+# DIVs: n_iter * n_p * (n_p_pad / 8) * 8 +
+#        n_iter * n_p * board.n_obstacles
+
+# SQRTs: n_iter * n_p +
+#        n_iter * n_p * (n_p_pad / 8) * 24 +
+#        n_iter * n_p * board.n_obstacles
+
+# EXPs: n_iter * n_p * board.n_obstacles
+
+
+def adds(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 7) & ~7
+  return int(n_iter * n_p * (33 + (n_p_pad // 8) * 232 + n_obs * 10))
+
+
+def mults(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 7) & ~7
+  return int(n_iter * n_p * (40 + (n_p_pad // 8) * 320 + n_obs * 13))
+
+
+def divs(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 7) & ~7
+  return int(n_iter * n_p * ((n_p_pad // 8) * 8 + n_obs))
+
+
+def sqrts(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 7) & ~7
+  return int(n_iter * n_p * (1 + (n_p_pad // 8) * 24 + n_obs))
+
+
+def exps(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 7) & ~7
+  return int(n_iter * n_p * n_obs)
+
+
+def total(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return adds(n_iter, n_p, n_obs) + mults(n_iter, n_p, n_obs) + divs(
+    n_iter, n_p, n_obs) + sqrts(n_iter, n_p,
+                                n_obs) + exps(n_iter, n_p, n_obs) * 30

flopcounts/x86/variant_inlining_8_SoA_AVX512_polyexp_moreavx.py

@@ -0,0 +1,57 @@
+# const int n_p_pad = (n_p + 7) & ~7;
+
+# ADDs: n_iter * n_p * 20 +
+#        n_iter * n_p * (n_p_pad / 8) * 232 +
+#        n_iter * n_p * board.n_obstacles * 10 +
+#        n_iter * (n_p_pad / 8) * 56
+
+# MULTs: n_iter * n_p * 4 +
+#        n_iter * n_p * (n_p_pad / 8) * 320 +
+#        n_iter * n_p * board.n_obstacles * 13 +
+#        n_iter * (n_p_pad / 8) * 120
+
+# DIVs: n_iter * n_p * (n_p_pad / 8) * 8 +
+#        n_iter * n_p * board.n_obstacles +
+#        n_iter * (n_p_pad / 8) * 16
+
+# SQRTs: n_iter * n_p * (n_p_pad / 8) * 24 +
+#        n_iter * n_p * board.n_obstacles +
+#        n_iter * (n_p_pad / 8) * 24
+
+# EXPs: n_iter * n_p * board.n_obstacles
+
+
+def adds(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 7) & ~7
+  return int(n_iter *
+             (n_p * 20 + n_p * (n_p_pad // 8) * 232 + n_p * n_obs * 10 +
+              (n_p_pad // 8) * 56))
+
+
+def mults(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 7) & ~7
+  return int(n_iter * (n_p * 4 + n_p * (n_p_pad // 8) * 320 + n_p * n_obs * 13 +
+                       (n_p_pad // 8) * 120))
+
+
+def divs(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 7) & ~7
+  return int(n_iter * (n_p * (n_p_pad // 8) * 8 + n_p * n_obs +
+                       (n_p_pad // 8) * 16))
+
+
+def sqrts(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 7) & ~7
+  return int(n_iter * (n_p * (n_p_pad // 8) * 24 + n_p * n_obs +
+                       (n_p_pad // 8) * 24))
+
+
+def exps(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 7) & ~7
+  return int(n_iter * n_p * n_obs)
+
+
+def total(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return adds(n_iter, n_p, n_obs) + mults(n_iter, n_p, n_obs) + divs(
+    n_iter, n_p, n_obs) + sqrts(n_iter, n_p,
+                                n_obs) + exps(n_iter, n_p, n_obs) * 30

flopcounts/x86/variant_inlining_8_SoA_AVX512_polyexp_moreavx_ilp_2.py

@@ -0,0 +1,58 @@
+# const int n_p_pad = (n_p + 15) & ~15;
+
+# ADDs: n_iter * n_p * 36 +
+#        n_iter * n_p * (n_p_pad / 16) * 464 +
+#        n_iter * n_p * board.n_obstacles * 10 +
+#        n_iter * (n_p_pad / 8) * 56
+
+# MULTs: n_iter * n_p * 4 +
+#        n_iter * n_p * (n_p_pad / 16) * 640 +
+#        n_iter * n_p * board.n_obstacles * 13 +
+#        n_iter * (n_p_pad / 8) * 120
+
+# DIVs: n_iter * n_p * (n_p_pad / 16) * 16 +
+#        n_iter * n_p * board.n_obstacles +
+#        n_iter * (n_p_pad / 8) * 16
+
+# SQRTs: n_iter * n_p * (n_p_pad / 16) * 48 +
+#        n_iter * n_p * board.n_obstacles +
+#        n_iter * (n_p_pad / 8) * 24
+
+# EXPs: n_iter * n_p * board.n_obstacles
+
+
+def adds(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 15) & ~15
+  return int(n_iter *
+             (n_p * 36 + n_p * (n_p_pad // 16) * 464 + n_p * n_obs * 10 +
+              (n_p_pad // 8) * 56))
+
+
+def mults(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 15) & ~15
+  return int(n_iter *
+             (n_p * 4 + n_p * (n_p_pad // 16) * 640 + n_p * n_obs * 13 +
+              (n_p_pad // 8) * 120))
+
+
+def divs(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 15) & ~15
+  return int(n_iter * (n_p * (n_p_pad // 16) * 16 + n_p * n_obs +
+                       (n_p_pad // 8) * 16))
+
+
+def sqrts(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 15) & ~15
+  return int(n_iter * (n_p * (n_p_pad // 16) * 48 + n_p * n_obs +
+                       (n_p_pad // 8) * 24))
+
+
+def exps(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  n_p_pad = (n_p + 15) & ~15
+  return int(n_iter * n_p * n_obs)
+
+
+def total(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return adds(n_iter, n_p, n_obs) + mults(n_iter, n_p, n_obs) + divs(
+    n_iter, n_p, n_obs) + sqrts(n_iter, n_p,
+                                n_obs) + exps(n_iter, n_p, n_obs) * 30

flopcounts/x86/variant_lut_exp.py

@@ -0,0 +1,58 @@
+# ADDs: n_iter * (
+#   n_p * 4 +
+#   n_p * (n_p - 1) * 14 +
+#   n_p * board.n_obstacles * 12 +
+#   n_p * 7
+# )
+
+# MULTs: n_iter * (
+#   n_p * 4 +
+#   n_p * (n_p - 1) * 23 +
+#   n_p * board.n_obstacles * 18 +
+#   n_p * 16
+# )
+
+# DIVs: n_iter * (
+#   n_p * (n_p - 1) +
+#   n_p * board.n_obstacles +
+#   n_p * 2
+# )
+
+# SQRTs: n_iter * (
+#   n_p * (n_p - 1) * 4 +
+#   n_p * board.n_obstacles * 2 +
+#   n_p * 3
+# )
+
+# EXPs (fast_exp, LUT): n_iter * (
+#   n_p * (n_p - 1) +
+#   n_p * board.n_obstacles
+# )
+
+
+def adds(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * (n_p * 4 + n_p *
+                       (n_p - 1) * 14 + n_p * n_obs * 12 + n_p * 7))
+
+
+def mults(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * (n_p * 4 + n_p *
+                       (n_p - 1) * 23 + n_p * n_obs * 18 + n_p * 16))
+
+
+def divs(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * (n_p * (n_p - 1) + n_p * n_obs + n_p * 2))
+
+
+def sqrts(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * (n_p * (n_p - 1) * 4 + n_p * n_obs * 2 + n_p * 3))
+
+
+def exps(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return int(n_iter * (n_p * (n_p - 1) + n_p * n_obs))
+
+
+def total(n_iter: int, n_p: int, n_obs: int = 2) -> int:
+  return adds(n_iter, n_p, n_obs) + mults(n_iter, n_p, n_obs) + divs(
+    n_iter, n_p, n_obs) + sqrts(n_iter, n_p,
+                                n_obs) + exps(n_iter, n_p, n_obs) * 30