ELVIRA MIR 2D support

RELEASE-NOTES.md

@@ -24,7 +24,9 @@ The Axom project release numbers follow [Semantic Versioning](http://semver.org/
   MIR algorithms take Blueprint meshes with a matset and they use the matset's material information
   to split any input zones that contain multiple materials into zones that contain a single material.
   The Mir component provides an implementation of the Equi-Z MIR algorithm, which is a visualization-
-  oriented algorithm that produces smooth interfaces between zones and their neighbors.
+  oriented algorithm that produces smooth interfaces between zones and their neighbors. The Mir
+  component also provides a 2D ELVIRA algorithm, which reconstructs polygonal shapes and preserves
+  volume fractions.
 - Support in `quest::IntersectionShaper` for Blueprint mesh stored in a `conduit::Node`
   or `sidre::Group`.
 - Adds new CMake configuration options, `AXOM_ENABLE_ASAN` and `AXOM_ENABLE_UBSAN`, to enable/disable AddressSanitizer and UndefinedBehaviorSanitizer respectively in Axom. Default is OFF for both.

scripts/benchmarks/mir_concentric_circles.py

@@ -1,39 +1,73 @@
 import os, sys
+import argparse
 
+def flux_run(np):
+  return f"flux run -n {np}"
+
+def srun(np):
+  return f"srun -n {np}"
+
+def lrun(np):
+  return f"lrun -n {np}"
+
+# Parallel options use 4 ranks per node since that is how many GPUs there are.
 runs = {
-  "[email protected]_cuda-release" : ["seq", "omp", "cuda"],
-  "[email protected]" : ["seq", "omp"],
-  "[email protected]" : ["seq", "omp"],
-  "[email protected]" : ["seq", "omp"],
-  "[email protected]_hip-release" : ["seq", "hip"],
-  "[email protected]_hip-release" :["seq", "hip"]
+  "[email protected]_cuda-release" : {"policies":["seq", "omp", "cuda"], "launch":lrun},
+  "[email protected]" : {"policies":["seq", "omp"], "launch":srun},
+  "[email protected]" : {"policies":["seq", "omp"], "launch":srun},
+  "[email protected]" : {"policies":["seq", "omp"], "launch":srun},
+  "[email protected]_hip-release" : {"policies":["seq", "hip"], "launch":srun},
+  "[email protected]_hip-release" : {"policies":["seq", "hip"], "launch":srun},
+  "[email protected]_hip-release" :{"policies":["seq", "hip"], "launch":flux_run},
+  "[email protected]_hip-release" :{"policies":["seq", "hip"], "launch":flux_run}
 }
 
 sizes = (50, 100, 200, 500, 1000, 1500, 2000, 4000, 8000)
 
-def generate():
+def generate(params):
+  """
+  Generate scripts to run the program to create timings.
+  """
+  method = params["method"]
+
   for r in runs:
+    if not os.path.exists(r):
+      print(f"Skipping {r}.")
+      continue
     filename = os.path.join(r, "run_concentric_circles.bash")
     f = open(filename, "wt")
     f.write("#!/bin/bash\n\n")
-    f.write("CONCENTRIC_CIRCLES=./examples/mir_concentric_circles\n\n")
+    f.write("CONCENTRIC_CIRCLES=./examples/mir_concentric_circles\n")
+    f.write("CONCENTRIC_CIRCLES_MPI=./examples/mir_concentric_circles_mpi\n\n")
 
     for s in sizes:
       f.write(f"# Size {s}\n")
-      for policy in runs[r]:
-        f.write(f'echo "Running --gridsize {s} --numcircles 5 --policy {policy}"\n')
-        f.write(f'$CONCENTRIC_CIRCLES --gridsize {s} --numcircles 5 --policy {policy} > result_{policy}_{s}.txt\n\n')
+      if len(params["parallel"]) > 0:
+        # parallel
+        for np in params["parallel"]:
+          launch = runs[r]["launch"](np)
+          for policy in runs[r]["policies"]:
+            f.write(f'echo "Running {launch} $CONCENTRIC_CIRCLES_MPI --gridsize {s} --numcircles 5 --policy {policy} --method {method} --disable-write"\n')
+            f.write(f'{launch} $CONCENTRIC_CIRCLES_MPI --gridsize {s} --numcircles 5 --policy {policy} --method {method} --disable-write > result_{policy}_np{np}_s{s}.txt\n\n')
+      else:
+        # serial
+        for policy in runs[r]["policies"]:
+          f.write(f'echo "Running --gridsize {s} --numcircles 5 --policy {policy} --method {method} --disable-write"\n')
+          f.write(f'$CONCENTRIC_CIRCLES --gridsize {s} --numcircles 5 --policy {policy} --method {method} --disable-write > result_{policy}_s{s}.txt\n\n')
 
     f.close()
     os.chmod(filename, 0o700)
     print(f"Wrote {filename}")
 
-def read_timings(filename):
+def read_timings(filename, searchKey):
+  """
+  Read a single Caliper log and pull out the timings we want.
+  """
   retval = "" # no data
   try:
     lines = open(filename, "rt").readlines()
     for line in lines:
-      pos = line.find("runMIR")
+      pos = line.find(searchKey)
       if pos != -1:
         toks = [x for x in line.split() if x != '']
         retval = float(toks[2]) # timings (I)
@@ -42,25 +76,75 @@ def read_timings(filename):
     pass
   return retval
 
-def make_csv(outputfile):
+def make_columns(params):
+  """
+  Read the available timing files and make columns of data.
+  """
+  # I was measuring runMIR before, which includes device transfers and HDF5 output.
+  # I don't want that stuff in the timings because it is not relevant to timing MIR
+  # and it can vary wildly.
+
+  def is_selected(selections, name):
+    """
+    Checks whether a name is being selected.
+    """
+    selected = True
+    if len(selections) > 0:
+      selected = False
+      for s in selections:
+        if name.find(s) != -1:
+          selected = True
+          break
+    return selected 
+
+  # Measure just the MIR algorithm
+  searchKey = "EquiZAlgorithm"
+  if params["method"] == "elvira":
+    searchKey = "ElviraAlgorithm"
+
   columns = []
-  # Add sizes column
-  sc = ["Sizes"]
+  # Add NumZones column (nzones = s*s)
+  sc = ["NumZones"]
   for s in sizes:
-    sc.append(s)
+    sc.append(s*s)
   columns.append(sc)
 
   # Gather data.
   for r in sorted(runs.keys()):
-    for policy in runs[r]:
+    # Make sure r exists
+    if not os.path.exists(r):
+      continue
+
+    # Gather individual data files
+    for policy in runs[r]["policies"]:
       buildname = r[6:-8]
-      name = f"{buildname} {policy.upper()}"
-      data = [name]
-      for s in sizes:
-        filename = os.path.join(r, f"result_{policy}_{s}.txt")
-        value = read_timings(filename)
-        data.append(value)
-      columns.append(data)
+      if len(params["parallel"]) > 0:
+        for np in params["parallel"]:
+          name = f"{buildname} {policy.upper()} NP={np}"
+          # Check if this name is selected
+          if not is_selected(params["selections"], name):
+             continue
+          data = [name]
+          for s in sizes:
+            filename = os.path.join(r, f"result_{policy}_np{np}_s{s}.txt")
+            value = read_timings(filename, searchKey)
+            data.append(value)
+          columns.append(data)
+      else:
+        name = f"{buildname} {policy.upper()}"
+        data = [name]
+        for s in sizes:
+          filename = os.path.join(r, f"result_{policy}_s{s}.txt")
+          value = read_timings(filename, searchKey)
+          data.append(value)
+        columns.append(data)
+  return columns
+
+def make_csv(params, outputfile):
+  """
+  Read the available timing files and assemble a CSV file.
+  """
+  columns = make_columns(params)
 
   # Write data
   f = open(outputfile, "wt")
@@ -71,10 +155,138 @@ def make_csv(outputfile):
     f.write(f"{line}\n")
   f.close()
 
+def plot(params):
+  """
+  Read the available timing files and plot them.
+  """
+  def make_series(col1, col2):
+    n = len(col1)
+    x = []
+    y = []
+    for i in range(n):
+      try:
+        xv = float(col1[i])
+        yv = float(col2[i])
+        x.append(xv)
+        y.append(yv)
+      except ValueError:
+        # We probably did not get data. Stop processing.
+        break
+    return x,y
+
+  columns = make_columns(params)
+
+  import matplotlib.pyplot as plt
+  for c in range(1, len(columns)):
+    x, y = make_series(columns[0][1:], columns[c][1:])
+    if len(x) > 0:
+      plt.plot(x, y, marker='o', linestyle='-', label=columns[c][0])
+
+  # Add labels and title
+  plt.xlabel('Number of Zones', fontSize=18)
+  plt.ylabel('Time (s)', fontSize=18)
+  plt.title('MIR Timings', fontSize=24)
+  xlabels = make_series(columns[0][1:], columns[0][1:])[0]
+  plt.xticks(ticks=xlabels, labels=xlabels, fontsize=14) 
+  plt.yticks(fontsize=14) 
+
+  # Set x-axis to logarithmic scale
+  plt.xscale('log')
+
+  # Set y-axis to logarithmic scale
+  plt.yscale('log')
+
+  # Add a legend
+  plt.legend()
+
+  plt.tight_layout()
+
+  # Show the plot
+  plt.grid(True)
+  plt.show()
+
+def get_params():
+  """
+  Get arguments from the command line and return a dictionary.
+  """
+  parser = argparse.ArgumentParser(description="Parse args")
+  parser.add_argument(
+    "--parallel",
+    type=str,
+    help="Comma-separated list of integer values",
+    required=False
+  )
+
+  parser.add_argument(
+    "--generate",
+    action="store_true",
+    help="Boolean flag to indicate whether to generate scripts",
+    required=False
+  )
+
+  parser.add_argument(
+    "--plot",
+    action="store_true",
+    help="Boolean flag to indicate whether to plot",
+    required=False
+  )
+
+  parser.add_argument(
+    "--method",
+    type=str,
+    help="MIR method to use (e.g., 'equiz', 'elvira')",
+    required=False
+    )
+
+  parser.add_argument(
+    "--select",
+    type=str,
+    help="Comma-separated list of strings to select specific plot data",
+    required=False
+  )
+
+  args = parser.parse_args()
+
+  # Convert the comma-separated string into a tuple of integers
+  parallel = ()
+  if args.parallel is not None:
+    try:
+      parallel = tuple(int(value) for value in args.parallel.split(","))
+    except ValueError:
+      raise argparse.ArgumentTypeError("All values in --parallel must be integers.")
+
+  selections = ()
+  if args.select is not None:
+    selections = tuple(args.select.split(","))
+
+  params = {}
+  params["parallel"] = parallel
+  if args.method is not None:
+    params["method"] = args.method
+  else:
+    params["method"] = "elvira"
+  if args.generate is not None:
+    params["generate"] = args.generate
+  else:
+    params["generate"] = False
+  if args.plot is not None:
+    params["plot"] = args.plot
+    params["generate"] = False
+  else:
+    params["plot"] = False
+  params["selections"] = selections
+
+  return params
+
 def main():
-  if "--generate" in sys.argv:
-    generate()
+  params = get_params()
+
+  if params["generate"]:
+    generate(params)
+  elif params["plot"]:
+    plot(params)
   else:
-    make_csv("concentric_circle_timings.csv")
+    make_csv(params, "concentric_circle_timings.csv")
 
-main()
+if __name__ == "__main__":
+  main()