Skip to content
DaCe - Data Centric Parallel Programming
JavaScript Python Jupyter Notebook C++ CSS Cuda Other
Branch: master
Clone or download

Latest commit

Latest commit 7ac8582 May 29, 2020


Type Name Latest commit message Commit time
Failed to load latest commit information.
.github/ISSUE_TEMPLATE Delete labeler.yml Feb 25, 2020
dace Merge branch 'shift_registers' of into shift_reg… May 29, 2020
diode Merge branch 'master' into no-opt-cli May 28, 2020
doc Remove deprecated operator implementations (in favor of library nodes) May 21, 2020
samples Update jacobi FPGA samples May 27, 2020
tests Merge branch 'master' into shift_registers May 29, 2020
tutorials Getting started tutorial Mar 24, 2020
.clang-format Updates: May 10, 2019
.coveragerc Have coverage ignore defensive exceptions entirely May 21, 2020
.dockerignore DIODE web client cleanup (client -> webclient, moved DaceState) Nov 17, 2019
.gitignore Remove undefined_symbols/scalar_parameters in favor of global… May 23, 2020
.gitmodules Initial commit of DaCe and DIODE Mar 15, 2019
.style.yapf yapf style file May 28, 2020
.travis.yml Merge branch 'master' into no-opt-cli May 28, 2020 Create Nov 9, 2019
Jenkinsfile Do not reinstall already-installed packages but dace May 1, 2020
LICENSE Update year Jan 6, 2020 Update scripts to entry_points, add diode.__main__ Mar 28, 2020
codecov.yml Make codecov threshold less strict May 9, 2020
dace.svg Initial commit of DaCe and DIODE Mar 15, 2019
requirements.txt Move memlet propagation to dace.sdfg May 20, 2020 Use one build folder to optimize cmake initialization time (optional) May 1, 2020

Build Status Documentation Status PyPI version codecov

DaCe - Data-Centric Parallel Programming

Decoupling domain science from performance optimization.

DaCe compiles code in various programming languages and paradigms (Python/Numpy, MATLAB, TensorFlow) and maps it efficiently to CPUs, GPUs, and FPGAs with high utilization, on par with the state-of-the-art. The key feature driving DaCe is its Stateful DataFlow multiGraph (SDFG) data-centric intermediate representation: A transformable, interactive representation of code based on data movement. With data-centric parallel programming, we enable direct knowledge transfer of performance optimization, regardless of the scientific application or the target processor.

DaCe can be written inline in Python and transformed in the command-line/Jupyter Notebooks, or SDFGs can be interactively modified using the Data-centric Interactive Optimization Development Environment (DIODE, currently experimental).

For more information, see our paper.


Installation and Dependencies

To install: pip install dace

Runtime dependencies:

  • A C++14-capable compiler (e.g., gcc 5.3+)
  • Python 3.6 or newer
  • CMake 2.8.12 or newer (for Windows, CMake 3.15 is recommended)


Python scripts: Run DaCe programs (in implicit, explicit, or TensorFlow syntax) using Python directly.

SDFV (standalone SDFG viewer): To view SDFGs separately, run the sdfv installed script with the .sdfg file as an argument. Alternatively, you can use the link or open diode/sdfv.html directly and choose a file in the browser.

DIODE interactive development (experimental):: Either run the installed script diode, or call python3 -m diode from the shell. Then, follow the printed instructions to enter the web interface.

Octave scripts (experimental): .m files can be run using the installed script dacelab, which will create the appropriate SDFG file.

Jupyter Notebooks: DaCe is Jupyter-compatible. If a result is an SDFG or a state, it will show up directly in the notebook. See the tutorials for examples.

Note for Windows/Visual C++ users: If compilation fails in the linkage phase, try setting the following environment variable to force Visual C++ to use Multi-Threaded linkage:

X:\path\to\dace> set _CL_=/MT


If you use DaCe, cite us:

  author    = {Ben-Nun, Tal and de~Fine~Licht, Johannes and Ziogas, Alexandros Nikolaos and Schneider, Timo and Hoefler, Torsten},
  title     = {Stateful Dataflow Multigraphs: A Data-Centric Model for Performance Portability on Heterogeneous Architectures},
  year      = {2019},
  booktitle = {Proceedings of the International Conference for High Performance Computing, Networking, Storage and Analysis},
  series = {SC '19}


DaCe creates a file called .dace.conf in the user's home directory. It provides useful settings that can be modified either directly in the file (YAML), within DIODE, or overriden on a case-by-case basis using environment variables that begin with DACE_ and specify the setting (where categories are separated by underscores). The full configuration schema is located here.

Useful environment variable configurations include:

  • DACE_CONFIG (default: ~/.dace.conf): Override DaCe configuration file choice.

Context configuration:

  • DACE_compiler_use_cache (default: False): Uses DaCe program cache instead of re-optimizing and compiling programs.
  • DACE_debugprint (default: True): Print debugging information.

SDFG processing:

  • DACE_optimizer_interface (default: dace.transformation.optimizer.SDFGOptimizer): Controls the SDFG optimization process by choosing a Python handler. If empty or class name is invalid, skips process. By default, uses the transformation command line interface.


  • DACE_profiling (default: False): Enables profiling measurement of the DaCe program runtime in milliseconds. Produces a log file and prints out median runtime.
  • DACE_treps (default: 100): Number of repetitions to run a DaCe program when profiling is enabled.


DaCe is an open-source project. We are happy to accept Pull Requests with your contributions!


DaCe is published under the New BSD license, see LICENSE.

You can’t perform that action at this time.