diff --git a/doc/webdocs/docs/feature.md b/doc/webdocs/docs/feature.md index 2b811d72..21ac3fd1 100644 --- a/doc/webdocs/docs/feature.md +++ b/doc/webdocs/docs/feature.md @@ -31,10 +31,10 @@ APEX provides both *performance awareness* and *performance adaptation*. * Software can subsequently associate performance state with policy for feedback control * APEX introspection * OS: track system resources, utilization, job contention, overhead - * Runtime (HPX, HPX-5, OpenMP...): track threads, queues, concurrency, remote operations, parcels, memory management + * Runtime (e.g. HPX, OpenMP, CUDA, OpenACC, Kokkos...): track threads, queues, concurrency, remote operations, parcels, memory management * Application timer / counter observation -![Screenshot](img/APEX_diagram.pdf) +![Screenshot](img/APEX_arch.png) *Above: APEX architecture diagram (when linked with an HPX application). The application and runtime send events to the APEX instrumentation API, which updates the performance state. The Policy Engine executes policies that change application behavior based on rule outcomes.* @@ -44,16 +44,19 @@ APEX collects data through *inspectors*. The synchronous data collection uses an * Initialize, terminate, new thread * added to the HPX thread scheduler - * added to the HPX-5 thread scheduler * added to the OpenMP runtime using the OMPT interface * added to the pthread runtime by wrapping the pthread API calls * Timer start, stop, yield, resume * added to HPX task scheduler - * added to HPX-5 task scheduler * added to the OpenMP runtime using the OMPT interface * added to the pthread runtime by wrapping the pthread API calls + * added to the CUDA runtime by subscribing to CUPTI callbacks and asynchronous GPU activity + * added to the Kokkos runtime by registering for callbacks + * added to the OpenACC runtime by registering for callbacks * Sampled values - * counters from HPX, HPX-5 + * counters from HPX + * counters from OpenMP + * counters from CUPTI * Custom events (meta-events) * useful for triggering policies @@ -65,26 +68,31 @@ Asynchonous data collection does not rely on events, but occurs periodically. A * /proc/net/dev * /proc/self/status * lm_sensors -* power measurements +* power measurements +* counters from NVIDIA Monitoring Library (NVML) ## Event Listeners There are a number of listeners in APEX that are triggered by the events passed in through the API. For example, the **Profiling Listener** records events related to maintaining the performance state. * Start Event: records the name/address of the timer, gets a timestamp (using rdtsc), returns a profiler handle -* Stop Event: gets a timestamp, puts the profiler object in a queue for back-end processing and returns +* Stop Event: gets a timestamp, optionally puts the profiler object in a queue for back-end processing and returns * Sample Event: put the name & value in the queue -Internally to APEX, there is an asynchronous consumer thread that processes profiler objects and samples to build a performance profile (in HPX, this thread is processed/scheduled as an HPX thread/task). +Internally to APEX, there is an asynchronous consumer thread that processes profiler objects and samples to build a performance profile (in HPX, this thread is processed/scheduled as an HPX thread/task), construct task graphs, and scatterplots of sampled task times. -The TAU Listener (used for postmortem analysis) synchronously passes all measurement events to TAU to build an offline profile or trace. TAU will also capture any other events for which it is configured, including MPI, memory, file I/O, etc. +The **TAU Listener** (used for postmortem analysis) synchronously passes all measurement events to TAU to build an offline profile or trace. TAU will also capture any other events for which it is configured, including MPI, memory, file I/O, etc. -The concurrency listener (also used for postmortem analysis) maintains a timeline of total concurrency, periodically sampled from within APEX. +The **concurrency listener** (also used for postmortem analysis) maintains a timeline of total concurrency, periodically sampled from within APEX. * Start event: push timer ID on stack * Stop event: pop timer ID off stack -An asynchronous consumer thread periodically logs the current timer for each thread. This thread will output a concurrency data report and gnuplot script at APEX termination. +An asynchronous consumer thread periodically logs the current timer for each thread. This thread will output a concurrency data report and gnuplot script at APEX termination. + +The **OTF2 listener** will construct a full event trace and write the events out to an [OTF2](https://www.vi-hps.org/projects/score-p/) archive. OTF2 files can be visualized with tools like [Vampir](https://tu-dresden.de/zih/forschung/projekte/vampir/index?set_language=en) or [Traveler](https://github.com/hdc-arizona/traveler-integrated). Due to the constraints of OTF2 trace collection, tasks that start on one OS thread and end on another OS thread are not supported. Similarly, tasks/functions that are not perfectly nested are not supported by OTF2 tracing. For those types of tasks, we recommend the Trace Event listener. + +The **Trace Event listener** will construct a full event trace and write the events to one or more [Google Trace Event](https://docs.google.com/document/d/1CvAClvFfyA5R-PhYUmn5OOQtYMH4h6I0nSsKchNAySU/edit#) trace files. The files can be visualized with the Google Chrome web browser, by navigating to the `chrome://tracing` URL. Other tools can be used to visualize or analyze traces, like [Catapult](https://chromium.googlesource.com/catapult). ## Policy Listener diff --git a/doc/webdocs/docs/img/APEX_arch.pdf b/doc/webdocs/docs/img/APEX_arch.pdf new file mode 100644 index 00000000..77628bc6 Binary files /dev/null and b/doc/webdocs/docs/img/APEX_arch.pdf differ diff --git a/doc/webdocs/docs/img/APEX_arch.png b/doc/webdocs/docs/img/APEX_arch.png new file mode 100644 index 00000000..6dc5d9bb Binary files /dev/null and b/doc/webdocs/docs/img/APEX_arch.png differ diff --git a/doc/webdocs/docs/index.md b/doc/webdocs/docs/index.md index a18e3b17..c6aa45b9 100644 --- a/doc/webdocs/docs/index.md +++ b/doc/webdocs/docs/index.md @@ -3,16 +3,24 @@ # APEX: Autonomic Performance Environment for eXascale -One of the key components of the XPRESS project is a new approach to performance observation, measurement, analysis and runtime decision making in order to optimize performance. The particular challenges of accurately measuring the performance characteristics of ParalleX [[1]](#fn1) applications (as well as other asynchronous multitasking runtime architectures) requires a new approach to parallel performance observation. The standard model of multiple operating system processes and threads observing themselves in a first-person manner while writing out performance profiles or traces for offline analysis will not adequately capture the full execution context, nor provide opportunities for runtime adaptation within OpenX. The approach taken in the XPRESS project is a new performance measurement system, called (Autonomic Performance Environment for eXascale). APEX includes methods for information sharing between the layers of the software stack, from the hardware through operating and runtime systems, all the way to domain specific or legacy applications. The performance measurement components incorporate relevant information across stack layers, with merging of third-person performance observation of node-level and global resources, remote processes, and both operating and runtime system threads. For a complete academic description of APEX, see the publication "APEX: An Autonomic Performance Environment for eXascale" [[2]](#References). +One of the key components of the US Department of Energy funded *XPRESS* project was a new approach to performance observation, measurement, analysis and runtime decision making in order to optimize performance. The particular challenges of accurately measuring the performance characteristics of ParalleX [[1]](#fn1) (e.g. HPX) applications (as well as other asynchronous multitasking runtime architectures) requires a new approach to parallel performance observation. The traditional model of multiple operating system processes and threads observing themselves in a first-person manner while writing out performance profiles or traces for offline analysis will not adequately capture the full execution context, nor provide opportunities for runtime adaptation. The approach taken in the completed XPRESS project was a new performance measurement system, called (Autonomic Performance Environment for eXascale). APEX includes methods for information sharing between the layers of the software stack, from the hardware through operating and runtime systems, all the way to domain specific or legacy applications. The performance measurement components incorporate relevant information across stack layers, with merging of third-person performance observation of node-level and global resources, remote processes, and both operating and runtime system threads. For a complete design description of APEX, see the publication "APEX: An Autonomic Performance Environment for eXascale" [[3]](#References). Since it's original project, APEX has been extended to support multiple runtime systems. In short, APEX is an introspection and runtime adaptation library for asynchronous multitasking runtime systems. However, APEX is not *only* useful for AMT/AMR runtimes running on future exascale systems - it can be used by any application wanting to perform runtime adaptation to deal with heterogeneous and/or variable environments. ## Introspection -APEX provides an API for measuring actions within a runtime. The API includes methods for timer start/stop, as well as sampled counter values. APEX is designed to be integrated into a runtime, library and/or application and provide performance introspection for the purpose of runtime adaptation. While APEX *can* provide rudimentary post-mortem performance analysis measurement, there are many other performance measurement tools that perform that task much better (such as TAU http://tau.uoregon.edu). That said, APEX includes an event listener that integrates with the TAU measurement system, so APEX events can be forwarded to TAU and collected in a TAU profile and/or trace to be used for post-mortem performance anlaysis. +APEX provides an API for measuring actions within a runtime. The API includes methods for timer start/stop, as well as sampled counter values. APEX is designed to be integrated into a runtime, library and/or application and provide performance introspection for the purpose of runtime adaptation. While APEX *can* provide rudimentary post-mortem performance analysis measurement, there are many other performance measurement tools that perform that task more robustly (such as TAU http://tau.uoregon.edu). That said, APEX includes an event listener that integrates with the TAU measurement system, so APEX events can be forwarded to TAU and collected in a TAU profile and/or trace to be used for post-mortem performance anlaysis. ## Runtime Adaptation -APEX provides a mechanism for dynamic runtime behavior, either for autotuning or adaptation to changing environment. The infrastruture that provides the adaptation is the Policy Engine, which executes policies either periodically or triggered by events. The policies have access to the performance state as observed by the APEX introspection API. APEX is integrated with Active Harmony (http://www.dyninst.org/harmony) to provide dynamic search for autotuning. +APEX provides a mechanism for dynamic runtime behavior, either for autotuning or adaptation to changing environment. The infrastruture that provides the adaptation is the *Policy Engine*, which executes policies either periodically or triggered by events. The policies have access to the performance state as observed by the APEX introspection API. APEX is integrated with Active Harmony (http://www.dyninst.org/harmony) to provide dynamic search for autotuning. -## References +## References & APEX-related Publications 1. Thomas Sterling, Daniel Kogler, Matthew Anderson, and Maciej Brodowicz. "SLOWER: A performance model for Exascale computing". *Supercomputing Frontiers and Innovations*, 1:42–57, September 2014. -2. Kevin A. Huck, Allan Porterfield, Nick Chaimov, Hartmut Kaiser, Allen D. Malony, Thomas Sterling, Rob Fowler. "An Autonomic Performance Environment for eXascale", *Journal of Supercomputing Frontiers and Innovations*, 2015. \ No newline at end of file +2. Koniges, Alice, Jayashree Ajay Candadai, Hartmut Kaiser, Kevin Huck, Jeremy Kemp, Thomas Heller, Matthew Anderson et al. "HPX Applications and Performance Adaptation". No. SAND2015-8999C. Sandia National Lab.(SNL-NM), Albuquerque, NM (United States), 2015. +3. Kevin A. Huck, Allan Porterfield, Nick Chaimov, Hartmut Kaiser, Allen D. Malony, Thomas Sterling, Rob Fowler. "An Autonomic Performance Environment for eXascale", *Journal of Supercomputing Frontiers and Innovations*, 2015. +4. Grubel, Patricia, Hartmut Kaiser, Kevin Huck, and Jeanine Cook. "Using intrinsic performance counters to assess efficiency in task-based parallel applications." In *2016 IEEE International Parallel and Distributed Processing Symposium Workshops (IPDPSW)*, pp. 1692-1701. IEEE, 2016. +5. Bari, Md Abdullah Shahneous, Nicholas Chaimov, Abid M. Malik, Kevin A. Huck, Barbara Chapman, Allen D. Malony, and Osman Sarood. "Arcs: Adaptive runtime configuration selection for power-constrained openmp applications." In *2016 IEEE International Conference on Cluster Computing (CLUSTER)*, pp. 461-470. IEEE, 2016. +6. Tohid, R., Bibek Wagle, Shahrzad Shirzad, Patrick Diehl, Adrian Serio, Alireza Kheirkhahan, Parsa Amini et al. "Asynchronous execution of python code on task-based runtime systems." In 2018 IEEE/ACM 4th International Workshop on Extreme Scale Programming Models and Middleware (ESPM2), pp. 37-45. IEEE, 2018. +7. Heller, Thomas, Bryce Adelstein Lelbach, Kevin A. Huck, John Biddiscombe, Patricia Grubel, Alice E. Koniges, Matthias Kretz et al. "Harnessing billions of tasks for a scalable portable hydrodynamic simulation of the merger of two stars." The International Journal of High Performance Computing Applications 33, no. 4 (2019): 699-715. +8. Wagle, Bibek, Mohammad Alaul Haque Monil, Kevin Huck, Allen D. Malony, Adrian Serio, and Hartmut Kaiser. "Runtime adaptive task inlining on asynchronous multitasking runtime systems." In Proceedings of the 48th International Conference on Parallel Processing, pp. 1-10. 2019. +9. Daiß, Gregor, Parsa Amini, John Biddiscombe, Patrick Diehl, Juhan Frank, Kevin Huck, Hartmut Kaiser, Dominic Marcello, David Pfander, and Dirk Pfüger. "From piz daint to the stars: simulation of stellar mergers using high-level abstractions." In Proceedings of the International Conference for High Performance Computing, Networking, Storage and Analysis, pp. 1-37. 2019. +10. Steven R. Brandt, Alex Bigelow, Sayef Azad Sakin, Katy Williams, Katherine E. Isaacs, Kevin Huck, Rod Tohid, Bibek Wagle, Shahrzad Shirzad, and Hartmut Kaiser. 2020. JetLag: An Interactive, Asynchronous Array Computing Environment. In Practice and Experience in Advanced Research Computing (PEARC '20). Association for Computing Machinery, New York, NY, USA, 8–12. DOI: diff --git a/doc/webdocs/docs/install.md b/doc/webdocs/docs/install.md index 04f104f0..6bc0c5bc 100644 --- a/doc/webdocs/docs/install.md +++ b/doc/webdocs/docs/install.md @@ -1,13 +1,34 @@ -# Downloading APEX +# Installing APEX + +## Installation with HPX + +APEX is integrated into the [HPX runtime](https://hpx.stellar-group.org), and is integrated into the HPX build system. To enable APEX measurement with HPX, enable the following CMake flags: + +``` +-DHPX_WITH_APEX=TRUE +``` + +The `-DHPX_WITH_APEX_TAG=develop` can be used to indicate a specific release version of APEX, or to use a specific GitHub branch of APEX. We recommend using the default configured version that comes with HPX (currently `v2.2.0`) or the `develop` branch. Additional CMake flags include: + +* `-DAPEX_WITH_LM_SENSORS=TRUE` to enable [LM sensors](https://hwmon.wiki.kernel.org/lm_sensors) support (assumed to be installed in default system paths) +* `-DAPEX_WITH_PAPI=TRUE` and `-DPAPI_ROOT=...` to enable [PAPI](https://icl.utk.edu/papi/) support +* `-DAPEX_WITH_BFD=TRUE` and `-DBFD_ROOT=...` *or* `-DBUILD_BFD=TRUE` to enable [Binutils](https://www.gnu.org/software/binutils/) support for converting function/lambda/instruction pointers to human-readable code regions. For demangling of C++ symbols, `demangle.h` needs to be installed with the binutils headers (not typical in system installations). +* `-DAPEX_WITH_MSR=TRUE` to enable [libmsr](https://github.com/LLNL/libmsr) support for RAPL power measurement (typically not needed, as RAPL support is natively handled where available) +* `-DAPEX_WITH_OTF2=TRUE` and `-DOTF2_ROOT=...` to enable [OTF2 tracing](https://www.vi-hps.org/projects/score-p/index.html) support +* `-DHPX_WITH_HPXMP=TRUE` to enable HPX OpenMP support and OMPT measurement support from APEX +* `-DAPEX_WITH_ACTIVEHARMONY=TRUE` and `-DACTIVEHARMONY_ROOT=...` to enable [Active Harmony](https://www.dyninst.org/harmony) support +* `-DAPEX_WITH_CUDA=TRUE` to enable CUPTI and/or NVML support. This support requires a working `nvcc` compiler in your path. + +## Standalone Installation APEX is open source, and available on Github at . -For stability, most users will want to download the most recent release of APEX (for example, v0.5): +For stability, most users will want to download the most recent release of APEX (for example, v2.2.0): ```bash -wget https://github.com/khuck/xpress-apex/archive/v0.5.tar.gz -tar -xvzf v0.5.tar.gz -cd xpress-apex-0.5 +wget https://github.com/khuck/xpress-apex/archive/v2.2.0.tar.gz +tar -xvzf v2.2.0.tar.gz +cd xpress-apex-2.2.0 ``` Other users may want to work with the most recent code available, in which case you can clone the git repo: @@ -17,22 +38,18 @@ git clone https://github.com/khuck/xpress-apex.git cd xpress-apex ``` -# Installation Option 1: Configuring and building APEX with bootstrap scripts - -This option is useful for HPC resources where a configuration script already exists, such as Edison@NERSC, Cori@NERSC, Babbage@NERSC, etc. To use this option, copy and modify ./bootstrap-configs/bootstrap-$arch.sh as necessary, and run it. - -# Installation Option 2: Configuring and building APEX with CMake directly (recommended for most users) +### Configuring and building APEX with CMake APEX is built with CMake. The minimum CMake settings needed for APEX are: -* -DCMAKE_INSTALL_PREFIX= some path to an installation location -* -DCMAKE_BUILD_TYPE= one of Release, Debug, or RelWithDebInfo (recommended) +* `-DCMAKE_INSTALL_PREFIX=...` some path to an installation location +* `-DCMAKE_BUILD_TYPE=...` one of Release, Debug, or RelWithDebInfo (recommended) -When building on Intel Phi, Boost is required if the compiler toolset does not include the latest GNU C++11 support. +Boost is **NOT** required to install APEX. When building on Intel Phi, Boost is required if the compiler toolset does not include the latest GNU C++11 support. -* -DBOOST_ROOT= the path to a Boost installation, 1.54 or newer +* `-DBOOST_ROOT=...` the path to a Boost installation, 1.65 or newer -**Note:** *If the BOOST_ROOT environment variable is set to a working Boost installation directory, CMake will find it automatically. If Boost is not installed locally, use the -DBUILD_BOOST=TRUE option, which will automatically download and build Boost as a subproject of APEX.* +**Note:** *If the `BOOST_ROOT` environment variable is set to a working Boost installation directory, CMake will find it automatically.* The process for building APEX is: @@ -41,7 +58,7 @@ The process for building APEX is: 2) Enter the repo directory, make a build directory: ```bash -cd xpress-apex-0.5 +cd xpress-apex-2.2.0 mkdir build cd build ``` @@ -52,7 +69,7 @@ cd build cmake -DCMAKE_INSTALL_PREFIX= -DCMAKE_BUILD_TYPE=RelWithDebInfo .. ``` -If Boost is required (Intel Phi): +If Boost is required (Intel Phi **only**): ```bash cmake -DBOOST_ROOT= -DCMAKE_INSTALL_PREFIX= -DCMAKE_BUILD_TYPE=RelWithDebInfo .. @@ -67,22 +84,21 @@ make doc make install ``` -# Other CMake settings, depending on your needs/wants +### Other CMake settings, depending on your needs/wants **Note 1:** *The **recommended** packages include:* * **Active Harmony** - for autotuning policies * **OMPT** - if OpenMP support is required ([See the OpenMP use case](usecases.md#openmp-example) for an example) -* **Binutils/BFD** - if your runtime/application uses instruction addresses to identify timers, e.g. HPX-5 and OpenMP -* **TAU** *or* **PAPI** - if you want post-mortem performance analysis ([See the TAU use case](usecases.md#with-tau) for an example) or your policies will require hardware counters ([See the PAPI use case](usecases.md#with-papi) for an example) +* **Binutils/BFD** - if your runtime/application uses instruction addresses to identify timers, e.g. OpenMP +* **PAPI** - if you want hardware counter support ([See the PAPI use case](usecases.md#with-papi) for an example) * **JEMalloc/TCMalloc** - if your application is not already using a heap manager - see Note 2, below +* **CUDA** - if your application uses CUDA, APEX will use CUPTI/NVML to measure GPU activity -**Note 2:** *TCMalloc or JEMalloc will speed up memory allocations *significantly* in APEX (and in your application). HOWEVER, If your application already uses TCMalloc, JEMalloc or TBBMalloc, **DO NOT** configure APEX with TCMalloc or JEMalloc. They will be included at application link time, and may conflict with the version detected by and linked into APEX.* +**Note 2:** *TCMalloc or JEMalloc will potentially speed up memory allocations **significantly** in APEX (and in your application). HOWEVER, If your application already uses TCMalloc, JEMalloc or TBBMalloc, **DO NOT** configure APEX with TCMalloc or JEMalloc. They will be included at application link time, and may conflict with the version detected by and linked into APEX.* There are several utility libraries that provide additional functionality in APEX. Not all libraries are required, but some are recommended. For the following options, the default values are in *italics*. -* **-DBUILD\_BOOST=** - TRUE or *FALSE*. In the event that Boost isn't pre-installed on your system, this option forces CMake to download and build Boost as part of the APEX project. * **-DUSE\_ACTIVEHARMONY=** *TRUE* or FALSE. Active Harmony is a library that intelligently searches for parametric combinations to support adapting to heterogeneous and changing environments. For more information, see . APEX uses Active Harmony for runtime adaptation. * **-DACTIVEHARMONY\_ROOT=** @@ -90,7 +106,7 @@ There are several utility libraries that provide additional functionality in APE * **-DBUILD\_ACTIVEHARMONY=** TRUE or *FALSE*. Whether or not Active Harmony is installed on the system, this option forces CMake to automatically download and build Active Harmony as part of the APEX project. * **-DUSE\_OMPT=** - TRUE or *FALSE*. OMPT is a proposed standard for OpenMP runtimes to provide callback hooks to performance tools. For more information, see . APEX has support for most OMPT OpenMP trace events. See [the OpenMP use case](usecases.md#openmp-example) for an example. + TRUE or *FALSE*. OMPT is a proposed standard for OpenMP runtimes to provide callback hooks to performance tools. For more information, see the [OpenMP specification](https://www.openmp.org/specifications/) v5.0 or newer. APEX has support for most OMPT OpenMP trace events. See [the OpenMP use case](usecases.md#openmp-example) for an example. Some compilers (Clang 10+, Intel 19+, IBM XL 16+) include OMPT support already, and APEX will use the built-in support. For GCC, older Clang and older Intel Compilers, APEX can build and use the [LLVM OpenMP runtime](https://github.com/llvm-mirror/openmp) which provides KMP and GOMP API calls for those compilers. * **-DOMPT\_ROOT=** the path to OMPT, or set the OMPT_ROOT environment variable before running cmake. * **-DBUILD\_OMPT=** @@ -101,18 +117,6 @@ There are several utility libraries that provide additional functionality in APE path to Binutils, or set the BFD_ROOT environment variable. * **-DBUILD\_BFD=** TRUE or FALSE. Whether or not binutils is found by CMake, this option forces CMake to automatically download and build binutils as part of the APEX project. -* **-DUSE\_TAU=** - TRUE or *FALSE*. TAU (Tuning and Analysis Utilities) is a performance measurement and analysis framework for large scale parallel applications. For more information see . APEX uses TAU to generate profiles for post-mortem performance analysis. See [the TAU use case](usecases.md#tau-example) for an example. -* **-DTAU\_ROOT=** - path to TAU, or set the TAU_ROOT environment variable before running cmake. -* **-DTAU\_ARCH=** - the TAU architecture, like x86_64, craycnl, mic_linux, bgq, etc. -* **-DTAU\_OPTIONS=** - a TAU configuration with thread support, like -pthread or -icpc-pthread. -* **-DUSE\_RCR=** - TRUE or *FALSE*. RCR (Resource Centric Reflection) is a library for system monitoring of resources that require root access. For more information, see . APEX uses RCR to access 'uncore' counters and system health information such as power and energy counters. -* **-DRCR\_ROOT=** - the path to RCR, or set the RCR_ROOT environment variable. * **-DUSE\_TCMALLOC=** TRUE or *FALSE*. TCMalloc is a heap management library distributed as part of Google perftools. For more information, see . TCMalloc provides faster memory performance in multithreaded environments. * **-DGPERFTOOLS\_ROOT=** @@ -132,9 +136,9 @@ There are several utility libraries that provide additional functionality in APE * **-DBUILD\_TESTS=** *TRUE* or FALSE. Whether or not to build the APEX unit tests. * **-DCMAKE\_C\_COMPILER=** - *gcc* + *gcc* or the `CC` environment variable setting * **-DCMAKE\_CXX\_COMPILER=** - *g++* + *g++* or the `CXX` environment variable setting * **-DCMAKE\_BUILD\_TYPE=** Release, *Debug*, RelWithDebInfo. Unfortunately, the cmake default (when not specified) is Debug. For faster performance, configure APEX to build RelWithDebInfo or Release. * **-DBUILD\_SHARED\_LIBS=** diff --git a/doc/webdocs/mkdocs.yml b/doc/webdocs/mkdocs.yml index 133cc78d..f8826b2b 100644 --- a/doc/webdocs/mkdocs.yml +++ b/doc/webdocs/mkdocs.yml @@ -3,7 +3,7 @@ site_url: http://khuck.github.io/xpress-apex repo_url: http://github.com/khuck/xpress-apex site_description: Autonomic Performance Environment for eXascale site_author: Kevin Huck (khuck@cs.uoregon.edu) -copyright: (C) 2016 University of Oregon, All Rights Reserved +copyright: (C) 2014-2020 University of Oregon, All Rights Reserved pages: - Home: index.md - Feature Overview: feature.md