diff --git a/python/dune/perftool/compile.py b/python/dune/perftool/compile.py
index 9726396aa250cac3fe49ed3845bf833cf261877b..70d7a8a1ed580420f391143af592a351f59414b1 100644
--- a/python/dune/perftool/compile.py
+++ b/python/dune/perftool/compile.py
@@ -82,6 +82,9 @@ def compile_form():
kernels = generate_localoperator(form)
# TODO insert sophisticated analysis/feedback loops here
+ if get_option("interactive"):
+ from dune.perftool.interactive import start_interactive_session
+ start_interactive_session(kernels)
from dune.perftool.pdelab.localoperator import generate_localoperator_file
generate_localoperator_file(kernels)
diff --git a/python/dune/perftool/interactive.py b/python/dune/perftool/interactive.py
new file mode 100644
index 0000000000000000000000000000000000000000..c58d69e82825fc4889554af28704d08ff4419e30
--- /dev/null
+++ b/python/dune/perftool/interactive.py
@@ -0,0 +1,122 @@
+from __future__ import print_function
+from functools import partial
+
+# Use the builtin 'input' in python2 and 'raw_input' in python3
+try:
+ input = raw_input
+except:
+ pass
+
+
+def clear():
+ import os
+ os.system('cls' if os.name == 'nt' else 'clear')
+
+
+def kernel_name(v):
+ first = None
+ if v[1] == "residual":
+ first = "alpha"
+ if v[1] == "jacobian":
+ first = "jacobian"
+ assert first
+
+ second = None
+ if v[0] == "cell":
+ second = "volume"
+ if v[0] == "exterior_facet":
+ second = "boundary"
+ if v[0] == "interior_facet":
+ second = "skeleton"
+ assert second
+
+ return "{}_{}".format(first, second)
+
+
+def show_kernel(kernel):
+ clear()
+ print(kernel)
+ print("Press any key to return")
+ input()
+ return kernel
+
+
+def choose_transformation(which, kernel):
+ choice = None
+ while choice != "q":
+ clear()
+ keymap = {}
+ print("Choose one of the following transformations to apply to {}:\n".format(kernel_name(which)))
+
+ print("Transformations:")
+ from dune.perftool.loopy.transformations import get_loopy_transformations
+ for i, v in enumerate(get_loopy_transformations().values()):
+ print(" {}) {}".format(chr(ord('a') + i), v.name))
+ if v.description:
+ print(" {}".format(v.description))
+ keymap[chr(ord('a') + i)] = v
+
+ print("\n q) Return to kernel options")
+ print("\nYour choice:")
+
+ choice = input().lower()
+ try:
+ kernel = keymap[choice](kernel)
+ except KeyError:
+ pass
+
+ return kernel
+
+
+def optimize_kernel(which, kernels):
+ kernel = kernels[which]
+ choice = None
+
+ while choice != "q":
+ clear()
+ print("Optimizing kernel {}:\n".format(kernel_name(which)))
+
+ print("Available options:")
+ print(" a) Show the loopy kernel")
+ print(" b) Apply loopy transformation")
+
+ print("\n q) Return to the kernel overview")
+ print("\nYour choice:")
+
+ choice = input().lower()
+ try:
+ kernel = {'a': show_kernel,
+ 'b': partial(choose_transformation, which)
+ }[choice](kernel)
+ except KeyError:
+ pass
+
+ kernels[which] = kernel
+
+
+def kernel_choice(kernels):
+ choice = None
+ while choice != "q":
+ clear()
+ print("The following kernels are in the input. Pick one to optimize:")
+
+ keymap = {}
+ for i, k in enumerate(kernels.keys()):
+ print(" {}) {}".format(chr(ord('a') + i), kernel_name(k)))
+ keymap[chr(ord('a') + i)] = partial(optimize_kernel, k)
+
+ print("\n q) End this interactive session and proceed to code generation")
+
+ print("\nYour choice: ")
+ choice = input().lower()
+ try:
+ keymap[choice](kernels)
+ except KeyError:
+ pass
+
+
+def start_interactive_session(kernels):
+ clear()
+ print("Welcome to the dune-perftool interactive mode!\n")
+
+ kernel_choice(kernels)
diff --git a/python/dune/perftool/loopy/transformations/__init__.py b/python/dune/perftool/loopy/transformations/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..db43b04544a9d0852d9181843e2a0fd554ac2bb6
--- /dev/null
+++ b/python/dune/perftool/loopy/transformations/__init__.py
@@ -0,0 +1,35 @@
+""" Infrastructure for loopy transformations.
+These are registered to list them in interactive mode
+"""
+
+_loopy_trafo_registry = {}
+
+
+def get_loopy_transformations():
+ return _loopy_trafo_registry
+
+
+class LoopyTransformationWrapper(object):
+ def __init__(self, f, name=None, description=""):
+ self.func = f
+ self.name = name
+ self.description = description
+
+ assert name
+ assert name not in _loopy_trafo_registry
+
+ _loopy_trafo_registry[name] = self
+
+ def __call__(self, kernel):
+ return self.func(kernel)
+
+
+def loopy_transformation(_positional_arg=None, **kwargs):
+ assert not _positional_arg
+ return lambda f: LoopyTransformationWrapper(f, **kwargs)
+
+
+# Just for debugging purposes we add an identity transformation here.
+@loopy_transformation(name="identity", description='''Does not change the kernel. Proof of concept implementation''')
+def _identity(kernel):
+ return kernel
diff --git a/python/dune/perftool/options.py b/python/dune/perftool/options.py
index db59bb9e927de59f0a7e98aa2768f210aab1aa64..4816ce8ecf5b2be5e4f6fd139b1fa79f4efa61d8 100644
--- a/python/dune/perftool/options.py
+++ b/python/dune/perftool/options.py
@@ -12,6 +12,7 @@ def get_form_compiler_arguments():
parser.add_argument("--operator-file", type=str, help="The filename for the generated local operator header")
parser.add_argument('--version', action='version', version='%(prog)s 0.1')
parser.add_argument("--numerical-jacobian", action="store_true", help="use numerical jacobians (only makes sense, if uflpdelab for some reason fails to generate analytic jacobians)")
+ parser.add_argument("--interactive", action="store_true", help="whether the optimization process should be guided interactively (also useful for debugging)")
# These are the options that I deemed necessary in uflpdelab
# parser.add_argument("--param-class-file", type=str, help="The filename for the generated parameter class header")
diff --git a/python/dune/perftool/ufl/transformations/__init__.py b/python/dune/perftool/ufl/transformations/__init__.py
index d67f112bc8a1b8a34d7a6887d76cd548e4801449..006e44cd0de8c31ef9d7fbd99fec8a14f8e62007 100644
--- a/python/dune/perftool/ufl/transformations/__init__.py
+++ b/python/dune/perftool/ufl/transformations/__init__.py
@@ -1,6 +1,6 @@
""" Define the general infrastructure for debuggable UFL transformations"""
-class TransformationWrapper(object):
+class UFLTransformationWrapper(object):
def __init__(self, func, **kwargs):
# Store the decorated function
self.func = func
@@ -63,7 +63,7 @@ def ufl_transformation(_positional_arg=None, **kwargs):
""" A decorator for ufl transformations. It allows us to output the
result if needed. """
assert not _positional_arg
- return lambda f: TransformationWrapper(f, **kwargs)
+ return lambda f: UFLTransformationWrapper(f, **kwargs)
@ufl_transformation(name="print", printBefore=False)
def print_expression(e):
@@ -72,13 +72,13 @@ def print_expression(e):
def transform_integral(integral, trafo):
from ufl import Integral
assert isinstance(integral, Integral)
- assert isinstance(trafo, TransformationWrapper)
+ assert isinstance(trafo, UFLTransformationWrapper)
return integral.reconstruct(integrand=trafo(integral.integrand()))
def transform_form(form, trafo):
from ufl import Form
assert isinstance(form, Form)
- assert isinstance(trafo, TransformationWrapper)
+ assert isinstance(trafo, UFLTransformationWrapper)
return Form([transform_integral(i, trafo) for i in form.integrals()])