Merge branch 'feature/basic-logging' into 'master'

Add basic logging mechanics

See merge request !148

python/dune/perftool/compile.py

@@ -5,6 +5,14 @@ Should also contain the entrypoint methods.
 """
 from __future__ import absolute_import
 
+
+# Configure loggers
+import logging.config
+from os import path
+log_file_path = path.join(path.dirname(path.abspath(__file__)), 'logging.conf')
+logging.config.fileConfig(log_file_path)
+
+
 import loopy
 
 from ufl.algorithms import compute_form_data, read_ufl_file

python/dune/perftool/logging.conf

+[loggers]
+keys=root,dune.perftool.pdelab.localoperator
+
+[handlers]
+keys=consoleHandler
+
+[formatters]
+keys=simpleFormatter
+
+[logger_root]
+handlers=consoleHandler
+
+[logger_dune.perftool.pdelab.localoperator]
+level=INFO
+handlers=consoleHandler
+qualname=dune.perftool.pdelab.localoperator
+propagate=0
+
+[handler_consoleHandler]
+class=StreamHandler
+formatter=simpleFormatter
+args=(sys.stdout,)
+
+[formatter_simpleFormatter]
+format=%(asctime)s - %(name)s - %(levelname)s - %(message)s
+datefmt=

python/dune/perftool/pdelab/localoperator.py

 from __future__ import absolute_import
 from os.path import splitext
 
+import logging
+
 from dune.perftool.options import get_option
 from dune.perftool.generation import (backend,
                                       base_class,
@@ -411,15 +413,20 @@ def visit_integrals(integrals):
 
 
 def generate_kernel(integrals):
+    logger = logging.getLogger(__name__)
+
     # Visit all integrals once to collect information (dry-run)!
+    logger.debug('generate_kernel: visit_integrals (dry run)')
     with global_context(dry_run=True):
         visit_integrals(integrals)
 
     # Now perform some checks on what should be done
     from dune.perftool.sumfact.vectorization import decide_vectorization_strategy
+    logger.debug('generate_kernel: decide_vectorization_strategy')
     decide_vectorization_strategy()
 
     # Delete the cache contents and do the real thing!
+    logger.debug('generate_kernel: visit_integrals (no dry run)')
     from dune.perftool.generation import delete_cache_items
     delete_cache_items("kernel_default")
     visit_integrals(integrals)
@@ -645,6 +652,8 @@ def cgen_class_from_cache(tag, members=[]):
 
 
 def generate_localoperator_kernels(formdata, data):
+    logger = logging.getLogger(__name__)
+
     # Extract the relevant attributes of the form data
     form = formdata.preprocessed_form
 
@@ -688,9 +697,11 @@ def generate_localoperator_kernels(formdata, data):
     # Have a data structure collect the generated kernels
     operator_kernels = {}
 
+    logger.info("generate_localoperator_kernels: create residual methods")
     with global_context(form_type='residual'):
         # Generate the necessary residual methods
         for measure in set(i.integral_type() for i in form.integrals()):
+            logger.info("generate_localoperator_kernels: measure {}".format(measure))
             with global_context(integral_type=measure):
                 enum_pattern()
                 pattern_baseclass()
@@ -743,6 +754,7 @@ def generate_localoperator_kernels(formdata, data):
 
                 operator_kernels[(measure, 'residual')] = kernel
 
+    logger.info("generate_localoperator_kernels: create jacobian methods")
     # Generate the necessary jacobian methods
     if not get_option("numerical_jacobian"):
         from ufl import derivative