advisor: Update advisor with oneAPI 2025

Author: George Bisbas

benchmarks/user/advisor/README.md

@@ -2,35 +2,50 @@ Example runs:
 
 * `python3 run_advisor.py --name isotropic --path <path-to-devito>/examples/seismic/acoustic/acoustic_example.py`
 * `python3 run_advisor.py --name tti_so8 --path <path-to-devito>/examples/seismic/tti/tti_example.py --exec-args "-so 8"`
-* `python3 run_advisor.py --name iso_ac_so6 --path <path-to-devito>/benchmarks/user/benchmark.py --exec-args "bench -P acoustic -so 6 --tn 200 -d 100 100 100 --autotune off -x 1"`
+* `python3 run_advisor.py --name iso_ac_so4 --path <path-to-devito>/benchmarks/user/benchmark.py --exec-args "run -P acoustic -so 4 --tn 200 -d 100 100 100"`
 
-After the run has finished you should be able to plot a roofline with the results and export roofline data to JSON using:
+After the run has finished you should be able to save a .json and plot the
+roofline with the results:
 * `python3 roofline.py --name Roofline --project <advisor-project-name>`
 
 To create a read-only snapshot for use with Intel Advisor GUI, use:
 * `advixe-cl --snapshot --project-dir=<advisor-project-name> pack -- /<new-snapshot-name>`
 
 Prerequisites:
-* Support guaranteed only for Intel Advisor as installed with Intel Parallel Studio v 2020 Update 2
-  and Intel oneAPI 2021; earlier years may not work; other 2020/2021 versions, as well as later years,
-  may or may not work.
+* Support is guaranteed only for Intel oneAPI 2025; earlier versions may not work.
+You may download Intel oneAPI [here](https://www.intel.com/content/www/us/en/developer/tools/oneapi/base-toolkit-download.html?packages=oneapi-toolkit&oneapi-toolkit-os=linux&oneapi-lin=apt).
+
+* Add Advisor (advixe-cl) and compilers (icx) in the path. It should be along the lines of:
+```sh
+source /opt/intel/oneapi/advisor/latest/env/vars.sh
+source /opt/intel/oneapi/compiler/latest/env/vars.sh
+```
+depending on where you installed oneAPI
+
 * In Linux systems you may need to enable system-wide profiling by setting:
-  - `/proc/sys/kernel/yama/ptrace_scope` to `0`
-  - `/proc/sys/kernel/perf_event_paranoid` to `1`
 
-* `numactl` must be available on the system. If not available, install with:
-	`sudo apt-get install numactl`
+```sh
+/proc/sys/kernel/yama/ptrace_scope to 0
+/proc/sys/kernel/perf_event_paranoid to 1
+```
+
+* `numactl` must be available on the system. If not available, install using:
+```sh
+sudo apt-get install numactl
+```
 * Install `pandas` and `matplotlib`. They are not included in the core Devito installation.
+```sh
+pip install pandas matplotlib
+```
 
 Limitations:
 
 * Untested with more complicated examples.
-* Untested on Intel KNL (we might need to ask `numactl` to bind to MCDRAM).
-* Running the `tripcounts` analysis takes a lot, despite starting in paused
+* Running the `tripcounts` analysis is time-consuming, despite starting in paused
   mode. This analysis, together with the `survey` analysis, is necessary to
   generate a roofline. Both are run by `run_advisor.py`.
-* Requires python3, untested in earlier versions of python and conda environments
-* Currently requires download of repository and running `pip3 install .`, the scripts
+* Requires Python3, untested in conda environments
+* Currently requires download of repository and running `pip install .`, the scripts
   are currently not included as a package with the user installation of Devito
 
 TODO:

benchmarks/user/advisor/roofline.py

@@ -18,23 +18,22 @@
 import sys
 import os
 
-from benchmarks.user.advisor.advisor_logging import check, err, log
+from advisor_logging import check, err, log
 
 
 try:
     import advisor
 except ImportError:
     check(False, 'Error: Intel Advisor could not be found on the system,'
           ' make sure to source environment variables properly. Information can be'
-          ' found at https://software.intel.com/content/www/us/en/develop/'
-          'documentation/advisor-user-guide/top/launch-the-intel-advisor/'
-          'intel-advisor-cli/setting-and-using-intel-advisor-environment-variables.html')
+          ' found at https://www.intel.com/content/www/us/en/docs/advisor/'
+          'user-guide/2024-2/set-up-environment-variables.html')
     sys.exit(1)
 
 
 matplotlib.use('Agg')
 # Use fancy plot colors
-plt.style.use('seaborn-darkgrid')
+plt.style.use('ggplot')
 
 
 @click.command()
@@ -65,21 +64,25 @@
 def roofline(name, project, scale, precision, mode, th):
     pd.options.display.max_rows = 20
 
-    log('Opening project...')
+    log(f'Opening project {project}...')
     project = advisor.open_project(str(project))
 
     if not project:
-        err('Could not open project %s.' % project)
+        err(f'Could not open project {project}.')
     log('Loading data...')
 
     data = project.load(advisor.SURVEY)
     rows = [{col: row[col] for col in row} for row in data.bottomup]
     roofs = data.get_roofs()
 
+    # Following deprecation solution from here:
+    # https://github.com/pandas-dev/pandas/issues/57734
+    pd.set_option('future.no_silent_downcasting', True)
     full_df = pd.DataFrame(rows).replace('', np.nan)
 
     # Narrow down the columns to those of interest
     try:
+        analysis_columns = ['loop_name', 'self_ai', 'self_gflops', 'self_time']
         df = full_df[analysis_columns].copy()
     except KeyError:
         err('Could not read data columns from profiling. Not enough data has been '
@@ -169,7 +172,7 @@ def roofline(name, project, scale, precision, mode, th):
             label_y = row.self_gflops
             ax.text(label_x, label_y,
                     'Time: %.2fs\n'
-                    'Incidence: %.0f%%' % (row.self_time, row.percent_weight),
+                    'Peak pct: %.0f%%' % (row.self_time, row.percent_weight),
                     bbox={'boxstyle': 'round', 'facecolor': 'white'}, fontsize=8)
         top_loops_data = [{'ai': row.self_ai,
                            'gflops': row.self_gflops,
@@ -198,19 +201,17 @@ def roofline(name, project, scale, precision, mode, th):
     legend = plt.legend(loc='center left', bbox_to_anchor=(1, 0.5),
                         prop={'size': 7}, title='Rooflines')
 
-    # saving the chart in PNG format
-    plt.savefig('%s.png' % name, bbox_extra_artists=(legend,), bbox_inches='tight')
+    # saving the chart in PDF format
+    plt.savefig('%s.pdf' % name, bbox_extra_artists=(legend,), bbox_inches='tight')
     figpath = os.path.realpath(__file__).split(os.path.basename(__file__))[0]
-    log('Figure saved in %s%s.png.' % (figpath, name))
+    log('\nFigure saved in %s%s.pdf.' % (figpath, name))
 
     # Save the JSON file
     with open('%s.json' % name, 'w') as f:
         f.write(json.dumps(roofline_data))
 
-    log('JSON file saved as %s.json.' % name)
-
-
-analysis_columns = ['loop_name', 'self_ai', 'self_gflops', 'self_time']
+    log('\nJSON file saved as %s.json.' % name)
+    log('Done!')
 
 if __name__ == '__main__':
     roofline()

benchmarks/user/advisor/run_advisor.py

@@ -1,16 +1,14 @@
+import click
 import datetime
 import logging
 import os
+import sys
+
 from pathlib import Path
 from subprocess import check_output, PIPE, Popen
-import sys
 from tempfile import gettempdir, mkdtemp
 
-import click
-
-
-from benchmarks.user.advisor.advisor_logging import (check, log, progress,
-                                                     log_process)
+from advisor_logging import (check, log, progress, log_process)
 
 
 @click.command()
@@ -49,21 +47,21 @@ def run_with_advisor(path, output, name, exec_args):
         output = Path(output).joinpath(name)
         output.mkdir(parents=True, exist_ok=True)
 
-    # Intel Advisor and Intel compilers must be available through either Intel Parallel
-    # Studio or Intel oneAPI (currently tested versions include IPS 2020 Update 2 and
-    # oneAPI 2021 beta08)
+    # Intel Advisor and Intel compilers must be available through either
+    # Intel oneAPI (tested with Intel oneAPI 2025.1)
     try:
         ret = check_output(['advixe-cl', '--version']).decode("utf-8")
     except FileNotFoundError:
         check(False, "Error: Couldn't detect `advixe-cl` to run Intel Advisor.")
 
     try:
-        ret = check_output(['icc', '--version']).decode("utf-8")
+        ret = check_output(['icx', '--version']).decode("utf-8")
+        log("Found icx version: %s" % ret.strip())
     except FileNotFoundError:
-        check(False, "Error: Couldn't detect Intel Compiler (icc).")
+        check(False, "Error: Couldn't detect Intel Compiler (icx).")
 
     # All good, Intel compiler and advisor are available
-    os.environ['DEVITO_ARCH'] = 'intel'
+    os.environ['DEVITO_ARCH'] = 'icx'
 
     # Tell Devito to instrument the generated code for Advisor
     os.environ['DEVITO_PROFILING'] = 'advisor'
@@ -73,7 +71,7 @@ def run_with_advisor(path, output, name, exec_args):
     if devito_logging is None:
         os.environ['DEVITO_LOGGING'] = 'WARNING'
 
-    with progress('Setting up multi-threading environment'):
+    with progress('Setting up multi-threading environment with OpenMP'):
         # Roofline analyses are recommended with threading enabled
         os.environ['DEVITO_LANGUAGE'] = 'openmp'
 
@@ -90,14 +88,14 @@ def run_with_advisor(path, output, name, exec_args):
 
         # Prevent NumPy from using threads, which otherwise leads to a deadlock when
         # used in combination with Advisor. This issue has been described at:
-        #     `software.intel.com/en-us/forums/intel-advisor-xe/topic/780506`
+        #   `software.intel.com/en-us/forums/intel-advisor-xe/topic/780506`
         # Note: we should rather sniff the BLAS library used by NumPy, and set the
         # appropriate env var only
         os.environ['OPENBLAS_NUM_THREADS'] = '1'
         os.environ['MKL_NUM_THREADS'] = '1'
         # Note: `Numaexpr`, used by NumPy, also employs threading, so we shall disable
         # it too via the corresponding env var. See:
-        #     `stackoverflow.com/questions/17053671/python-how-do-you-stop-numpy-from-multithreading`  # noqa
+        #   `stackoverflow.com/questions/17053671/python-how-do-you-stop-numpy-from-multithreading`  # noqa
         os.environ['NUMEXPR_NUM_THREADS'] = '1'
 
     # To build a roofline with Advisor, we need to run two analyses back to
@@ -130,8 +128,8 @@ def run_with_advisor(path, output, name, exec_args):
     ]
     py_cmd = [sys.executable, str(path)] + exec_args.split()
 
-    # Before collecting the `survey` and `tripcounts` a "pure" python run to warmup the
-    # jit cache is preceded
+    # Before collecting the `survey` and `tripcounts` a "pure" python run
+    # to warmup the jit cache is preceded
 
     log('Starting Intel Advisor\'s `roofline` analysis for `%s`' % name)
     dt = datetime.datetime.now()
@@ -147,6 +145,9 @@ def run_with_advisor(path, output, name, exec_args):
     advixe_handler.setFormatter(advixe_formatter)
     advixe_logger.addHandler(advixe_handler)
 
+    log("Project folder: %s" % str(output))
+    log("Logging progress in: `%s`" % str(advixe_handler))
+    
     with progress('Performing `cache warm-up` run'):
         try:
             p_warm_up = Popen(py_cmd, stdout=PIPE, stderr=PIPE)
@@ -175,6 +176,8 @@ def run_with_advisor(path, output, name, exec_args):
     log('python3 roofline.py --name %s --project %s --scale %f'
         % (name, str(output), n_sockets))
 
+    log('\nTo open the roofline using advixe-gui: ')
+    log('advixe-gui %s' % str(output))
 
 if __name__ == '__main__':
     run_with_advisor()

devito/arch/compiler.py

@@ -769,6 +769,20 @@ def __init_finalize__(self, **kwargs):
             self.__init_intel_mpi__()
             self.__init_intel_mpi_flags__()
 
+        if configuration['profiling'] == 'advisor':
+            # Locate the Intel Advisor installation and
+            # add the necessary flags to the compiler
+            from devito.operator.profiling import locate_intel_advisor
+            path = locate_intel_advisor()
+            self.add_include_dirs(path.joinpath('include').as_posix())
+
+            _default_libs = ['ittnotify']
+            self.add_libraries(_default_libs)
+
+            libdir = path.joinpath('lib64').as_posix()
+            self.add_library_dirs(libdir)
+            self.add_ldflags('-Wl,-rpath,%s' % libdir)
+
     def __init_intel_mpi__(self, **kwargs):
         # Make sure the MPI compiler uses an Intel compiler underneath,
         # whatever the MPI distro is

devito/operator/profiling.py

@@ -353,7 +353,7 @@ class AdvancedProfilerVerbose2(AdvancedProfilerVerbose):
 class AdvisorProfiler(AdvancedProfiler):
 
     """
-    Rely on Intel Advisor ``v >= 2020`` for performance profiling.
+    Rely on Intel Advisor 2025.1 for performance profiling.
     Tested versions of Intel Advisor:
     - As contained in Intel Parallel Studio 2020 v 2020 Update 2
     - As contained in Intel oneAPI 2021 beta08
@@ -367,19 +367,13 @@ class AdvisorProfiler(AdvancedProfiler):
     _ext_calls = [_api_resume, _api_pause]
 
     def __init__(self, name):
-        self.path = locate_intel_advisor()
-        if self.path is None:
+        path = locate_intel_advisor()
+        if path is None:
             self.initialized = False
         else:
-            super().__init__(name)
-            # Make sure future compilations will get the proper header and
-            # shared object files
-            compiler = configuration['compiler']
-            compiler.add_include_dirs(self.path.joinpath('include').as_posix())
-            compiler.add_libraries(self._default_libs)
-            libdir = self.path.joinpath('lib64').as_posix()
-            compiler.add_library_dirs(libdir)
-            compiler.add_ldflags('-Wl,-rpath,%s' % libdir)
+            super(AdvisorProfiler, self).__init__(name)
+
+        return
 
     def analyze(self, iet):
         return