By Yu-hsuan Shih, Garrett Wright, Joakim Andén, Johannes Blaschke, Alex H. Barnett

Nonuniform fast Fourier transforms dominate the computational cost in many applications including image reconstruction and signal processing. We thus present a general-purpose GPU-based CUDA library for type 1 (nonuniform to uniform) and type 2 (uniform to nonuniform) transforms in dimensions 2 and 3, in single or double precision. It achieves high performance for a given user-requested accuracy, regardless of the distribution of nonuniform points, via cache-aware point reordering, and load-balanced blocked spreading in shared memory. At low accuracies, this gives on-GPU throughputs around 10e9 nonuniform points per second, and (even including host-device transfer) is typically 4-10x faster than the latest parallel CPU code FINUFFT (at 28 threads). It is competitive with two established GPU codes, being up to 90x faster at high accuracy and/or type 1 clustered point distributions. Finally we demonstrate a 5-12x speedup versus CPU in an X-ray diffraction 3D iterative reconstruction task at 10e-12 accuracy, observing excellent multi-GPU weak scaling up to one rank per GPU.

Read the paper: https://doi.org/10.48550/arXiv.2102.08463

Intel Advisor is an optimization tool that helps the developers identify hot spots, performance issues and also provide recommendations for performance improvement. It has been installed at most of the Princeton research computing systems. Intel Advisor was part of the licensed Parallel Studio XE (PSXE) releases before. It is now included in the Intel OneAPI base toolkit, which is free to download. In this article, we will walk you through the process of collecting performance data remotely at Princeton Research Computing clusters using the Intel Advisor command line interface (CLI) and displaying the results on a local macOS system using the Intel Advisor graphical user interface (GUI).

Preparing Applications for Performance Analysis

For C/C++ and Fortran code (on Linux OS), it is recommended to setup the following compiler flags before running the performance analysis:

1. Request full debug information (compiler and linker): -g
2. Request moderate optimization: -O2 or higher 
3. Disable inter procedural optimization that may inhibit the profiler to collect performance data: -no-ipo
4. Produce compiler diagnostics: -qopt-report=5
5. Enable OpenMP directives: -qopenmp

See: https://software.intel.com/content/www/us/en/develop/documentation/advisor-user-guide/top.html

Intel(R) Advisor Command Line Tool
Copyright (C) 2009-2020 Intel Corporation. All rights reserved.

 Usage: advisor <--action> [--action-option] [--global-option] [[--] <target>
 [target options]] 

<action> is one of the following:
 
    collect          Run the specified analysis and collect data. Tip: Specify the search-dir when collecting data.
    command          Issue a command to a running collection.
    create-project   Create an empty project, if it does not already exist.
    help             Explain command line actions with corresponding options.
    import-dir       Import and finalize data collected on an MPI cluster.
    mark-up-loops    After running a Survey analysis and identifying loops of interest, select loops (by file and line number or criteria) for deeper analysis.
    report           Generate a report from data collected during a previous analysis.
    snapshot         Create a result snapshot.
    version          Display product version information. 
    workflow         Explain typical Intel Advisor user scenarios, with corresponding command lines. 

For help on a specific action, type: advisor --help <action>
 
Examples: 

 Perform a Survey analysis.
 
 	advisor --collect=survey --project-dir=./advi --search-dir src:r=./src -- ./bin/myApplication
 
 Generate a Survey report.
 
 	advisor --report=survey --project-dir=./advi --search-dir src:r=./src
 
 Display help for the collect action.
 
 	advisor --help collect

advisor --collect=survey --project-dir=./advi --search-dir src:r=./src   -- ./bin/myApplication

advisor --collect=tripcoutns -flop --project-dir=./advi --search-dir src:r=./src -- ./bin/myApplication

advisor --collect=roofline --project-dir=./advi --search-dir src:r=./src -- ./bin/myApplication

To view the results, you can copy the whole project directory to your local macOS. It is also recommended to first pack the analysis results in a snapshot and then copy the packed *.advixeexpz file. For example:

advisor --snapshot --project-dir=./advi --pack --cache-sources --cache-binaries -- ./advi_snapshot

Viewing Results on a Local macOS System

You can download the Intel Advisor for macOS from the oneAPI base toolkit. After launching the Intel Advisor GUI, you then go to File > Open > Project/Result and navigate the copied project directory/snapshot.

This article covers the following NEW in Intel Advisor version 2021.1:

1. Intel Advisor is included as part of the Intel OneAPI base toolkit 
2. The executables are renamed. advixe-cl is renamed to advisor. advixe-gui is renamed to advisor-gui
3. The roofline analysis is provided as a single command. In the earlier version, roofline analysis is done by first running a survey analysis followed by a tripcounts analysis. Now we can run the roofline in a single step using —collect=roofline option.

For a complete list of new update, please see https://software.intel.com/content/www/us/en/develop/documentation/advisor-user-guide/top/what-s-new.html.

References:

1. https://software.intel.com/content/www/us/en/develop/documentation/advisor-user-guide/top.html
2. https://software.intel.com/content/www/us/en/develop/documentation/advisor-cookbook/top/analyze-performance-remotely-and-visualize-results-on-macos.html

By Giovanni Petri, Sebastian Musslick, Biswadip Dey, Kayhan Özcimder, David Turner, Nesreen K. Ahmed, Theodore L. Willke & Jonathan D. Cohen

The ability to learn new tasks and generalize to others is a remarkable characteristic of both human brains and recent artificial intelligence systems. The ability to perform multiple tasks simultaneously is also a key characteristic of parallel architectures, as is evident in the human brain and exploited in traditional parallel architectures. Here we show that these two characteristics reflect a fundamental tradeoff between interactive parallelism, which supports learning and generalization, and independent parallelism, which supports processing efficiency through concurrent multitasking. Although the maximum number of possible parallel tasks grows linearly with network size, under realistic scenarios their expected number grows sublinearly. Hence, even modest reliance on shared representations, which support learning and generalization, constrains the number of parallel tasks. This has profound consequences for understanding the human brain’s mix of sequential and parallel capabilities, as well as for the development of artificial intelligence systems that can optimally manage the tradeoff between learning and processing efficiency.

Similar content being viewed by others

Read the paper: https://www.nature.com/articles/s41567-021-01170-x

I started working as a research software engineer for the Princeton Neuroscience Institute (PNI) in May 2017. At the end of my first week I received an email from Professor Mala Murthy and post-doc David Deutsch of the MurthyLab, asking if I would be interested in working on a project involving a “virtual reality environment for neural recording experiments”. The kid in me got very excited at the prospect of making video games. At the time I did not know the project was to develop a virtual reality simulation for flies!

Virtual reality experiments have a long history in neuroscience . They allow researchers to restrict the movement of animal subjects so that they can use advanced microscopy to image their brains in “naturalistic” environments. In the Murthy lab’s VR setup, the fly is fixed to the objective of a two photon microscope and suspended above a small sphere floating on a column of air. This small sphere is used as a sort of omni-directional treadmill. While the fly cannot actually move, it can move its legs, which in turn move the freely rotating sphere. The movement of the sphere is tracked with computer vision algorithms and thus a fictive path for the fly in a virtual world can be reconstructed. This setup allows a “moving” fly’s brain to be imaged with techniques that require it to be stationary. The two photon imaging system then provides a very flexible and powerful tool for studying changes in the fly’s brain activity over time of the experiment. Different spatial and temporal resolutions are available depending on the needs of the experimenter.