The Virtual Brain (TVB) is a large-scale brain simulator. With a community of thousands of users around the world, TVB has become a validated, popular and standard choice for the simulation of whole brain activity. TVB users can create simulations using neural mass models which can produce outputs for different analysis and modalities. TVB allows scientists to explore and analyze both simulated and experimental data. It contains analytic tools for evaluating relevant scientific parameters in light of that data. The current implementation of TVB is written in Python, with limited large-scale parallelization over different parameters. The objective of TVB-HPC is to enable large-scale parallelization of TVB simulations by making use of high performance computing to explore large parameter spaces for the models. With this approach, neuroscientists can define their models in a domain specific language based on NeuroML and automatically generate code which can run either on GPUs or on CPUs with different architectures and optimizations. The result is a framework that hides the complexity of writing robust parallel code and offers neuroscientists a fast and efficient access to high performance computing. TVB-HPC is publicly available on GitHub and, at the end of HBP project phase SGA2, it will be possible to launch large parameter simulations using code automatically generated with this framework via the HBP Collaboratory.
The in situ pipeline consists of a set of libraries that can be integrated into neuronal network simulators developed by the HBP to enable live visual analysis during the runtime of the simulation. The library called ‘nesci’ (neuronal simulator conduit interface) stores the raw simulation data into a common conduit format and the library called ‘contra’ (conduit transport) transports the serialized data from one endpoint to another using a variety of different (network) protocols. The pipeline currently works with NEST and Arbor. Support for TVB is currently in development.
Prototypical implementation into the HPAC Platform finalised in February 2019.
Date of release
First released in July 2018 with continuous updates (see also above)
Science has driven the development of the NEST simulator for the past 20 years. Originally created to simulate the propagation of synfire chains using single-processor workstations, we have pushed NEST’s capabilities continuously to address new scientific questions and computer architectures. Prominent examples include studies on spike-timing dependent plasticity in large simulations of cortical networks, the verification of mean-field models, models of Alzheimer’s and Parkinson’s disease and tinnitus. Recent developments include a significant reduction in memory requirements, as demonstrated by a record-breaking simulation of 1.86 billion neurons connected by 11.1 trillion synapses on the Japanese K supercomputer, paving the way for brain-scale simulations.
Running on everything from laptops to the world’s largest supercomputers, NEST is configured and controlled by high-level Python scripts, while harnessing the power of C++ under the hood. An extensive testsuite and systematic quality assurance ensure the reliability of NEST.
The development of NEST is driven by the demands of neuroscience and carried out in a collaborative fashion at many institutions around the world, coordinated by the non-profit member-based NEST Initiative. NEST is released under GNU Public License version 2 or later.
How NEST has been improved in HBP
Continuous dynamics
The continuous dynamics code in NEST enables simulations of rate- based model neurons in the event-based simulation scheme of the spiking simulator NEST. The technology was included and released with NEST 2.14.0.
Furthermore, additional rate-based models for the Co-Design Project “Visuo-Motor Integration” (CDP4) have been implemented and scheduled for NEST release 2.16.0.
NESTML is a domain-specific language that supports the specification of neuron models in a precise and concise syntax, based on the syntax of Python. Model equations can either be given as a simple string of mathematical notation or as an algorithm written in the built-in procedural language. The equations are analyzed by NESTML to compute an exact solution if possible, or use an appropriate numeric solver otherwise.
This technology couples the simulation software NEST and UG4 by means of the MUSIC library. NEST can only send spike trains where spiking occurs; UG4 receives those in form of events arriving at synapses (timestamps). The time course of the extracellular potential in a cube (representing a piece of tissue) is simulated based on the arriving spike data.The evolution of the membrane potential in space and time is described by the Xylouris-Wittum model.
Link to this release (2017): https://github.com/UG4
The development of ZeroBuf was co-funded by the HBP during the Ramp-up Phase. This page is kept for reference but will no longer be updated. ZeroBuf implements zero-copy, zero-serialize, zero-hassle protocol buffers. It is a replacement for FlatBuffers, resolving the following shortcomings:
Direct get and set functionality on the defined data members
A single memory buffer storing all data members, which is directly serializable
Usable, random read and write access to the the data members
Zero copy of the data used by the (C++) implementation from and to the network
The development of Monsteer was co-funded by the HBP during the Ramp-up Phase. This page is kept for reference but will no longer be updated.
Monsteer is a library for Interactive Supercomputing in the neuroscience domain. Monsteer facilitates the coupling of running simulations (currently NEST) with interactive visualization and analysis applications. Monsteer supports streaming of simulation data to clients (currenty only spikes) as well as control of the simulator from the clients (also kown as computational steering). Monsteer’s main components are a C++ library, an MUSIC-based application and Python helpers.
Minimum configuration to configure using cmake, compile and run Monsteer:
A Linux box,
GCC compiler 4.8+,
CMake 2.8+,
Boost 1.54,
MPI (OpenMPI, mvapich2, etc),
NEST simulator 2.4.2,
MUSIC 1.0.7,
Python 2.6,
See also: http://bluebrain.github.io/Monsteer-0.3/_user__guide.html#Compilation
NeuroLOTs is a set of tools and libraries that allow creating neuronal meshes from a minimal skeletal description. It generates soma meshes using FEM deformation and allows to interactively adapt the tessellation level using different criteria (user-defined, camera distance, etc.)
NeuroTessMesh provides a visual environment for the generation of 3D polygonal meshes that approximate the membrane of neuronal cells, starting from the morphological tracings that describe neuronal morphologies. The 3D models can be tessellated at different levels of detail, providing either a homogeneous or an adaptive resolution of the model. The soma shape is recovered from the incomplete information of the tracings, applying a physical deformation model that can be interactively adjusted. The adaptive refinement process performed in the GPU generates meshes, that allow good visual quality geometries at an affordable computational cost, both in terms of memory and rendering time. NeuroTessMesh is the front-end GUI to the NeuroLOTs framework.
The development of VisNEST was co-funded by the HBP during the Ramp-up Phase. This page is kept for reference but will no longer be updated.
VisNEST is a tool for visualizing neural network simulations of the macaque visual cortex. It allows for exploring mean activity rates, connectivity of brain areas and information exchange between pairs of areas. In addition, it allows exploration of individual populations of each brain area and their connectivity used for simulation.
VisNEST screenshot
Date of release
Information available on demand.
Version of software
Information available on demand.
Version of documentation
Information available on demand.
Software available
Not publicly available yet. Please contact the developers in case of interest.
Documentation
Reference paper:
Nowke, Christian, Maximilian Schmidt, Sacha J. van Albada, Jochen M. Eppler, Rembrandt Bakker, Markus Diesrnann, Bernd Hentschel, and Torsten Kuhlen. "VisNEST—Interactive analysis of neural activity data." In Biological Data Visualization (BioVis), 2013 IEEE Symposium on, pp. 65-72. IEEE, 2013.
The development of DLB was co-funded by the HBP during the second project phase (SGA1). This page is kept for reference but will no longer be updated.
DLB is a library devoted to speedup hybrid parallel applications. And at the same time DLB improves the efficient use of the computational resources inside a computing node. The DLB library will improve the load balance of the outer level of parallelism by redistributing the computational resources at the inner level of parallelism. This readjustment of resources will be done at dynamically at runtime. This dynamism allows DLB to react to different sources of imbalance: Algorithm, data, hardware architecture and resource availability among others.
The first version that was integrated in the HPAC Platform was v1.1.
Used on MareNostrum IV supercomputer for some applications
The development of HCFFT was co-funded by the HBP during the Ramp-up Phase. This page is kept for reference but will no longer be updated.
HCFFT (Hyperbolic Cross Fast Fourier Transform) is a software package to efficiently treat high-dimensional multivariate functions. The implementation is based on the fast Fourier transform for arbitrary hyperbolic cross / sparse grid spaces.
The development of T-Storm was co-funded by the HBP during the Ramp-up Phase. This page is kept for reference but will no longer be updated.
T-Storm is a platform for supporting scalable real-time analytics of massive sets of voluminous time-series. The platform is constructed over the Storm parallel dataflow engine, and supports both vertical scalability (fully utilizing high-end servers and multi-core systems) and horizontal scalability (scaling across a cluster of physical machines or even incorporating virtual cloud resources). The current version enables efficient maintenance of the highly correlated time-series in linear space and near-linear computational complexity (in practice, computational complexity depends on the input time-series). This functionality is, for example, useful to identify the pairs of neurons that fire in a correlated manner.
T-Storm is distributed as a prepared virtual machine. To use the platform, the user needs to 1) deploy and configure the required number of virtual machines, depending on the number of time series to monitor, and their velocity; 2) configure the virtual machines so that they have network access and can talk to each other; 3) provide the input in the documented format. Full instructions are provided with the virtual machine.
The development of MonetDB was co-funded by the HBP during the Ramp-up Phase. This page is kept for reference but will no longer be updated.
When a database grows into millions of records spread over many tables and business intelligence or science becomes the prevalent application domain, a column-store database management system (DBMS) is called for. Unlike traditional row-stores, such as MySQL and PostgreSQL, a column-store provides a modern and scalable solution without calling for substantial hardware investments.
MonetDB pioneered column-store solutions for high-performance data warehouses for business intelligence and eScience since 1993. It achieves its goal by innovations at all layers of a DBMS, e.g. a storage model based on vertical fragmentation, modern CPU-tuned query execution architecture, automatic and adaptive indices, run-time query optimization, and a modular software architecture. It is based on the SQL 2003 standard with full support of foreign keys, joins, views, triggers, and stored procedures. It is fully ACID compliant and supports a rich spectrum of programming interfaces (JDBC, ODBC, PHP, Python, RoR, C/C++, Perl).
The current version provides the following new features as compared to the version that was part of the HBP-internal Platform Release in M18:
The development of ZeroEQ was co-funded by the HBP during the second project phase (SGA1). This page is kept for reference but will no longer be updated.
ZeroEQ is a cross-platform C++ library to publish and subscribe for events. It provides the following major features:
Efficient serialization of events using flatbuffers
The main intention of ZeroEQ is to allow the linking of applications using automatic discovery. Linking can be used to connect multiple visualization applications, or to connect simulators with analysis and visualization codes to implement streaming and steering. One example of the former is the interoperability of NeuroScheme with RTNeuron, and one for the latter is the streaming and steering between NEST and RTNeuron. Both were reported previously, whereas the current extensions focus on the implementation of the request-reply interface.
The development of PyCOMPSs was co-funded by the HBP during the Ramp-up Phase. This page is kept for reference but will no longer be updated, apart from release notes.
PyCOMPSs is the Python binding of COMPSs, (COMP Superscalar) a coarse-grained programming model oriented to distributed environments, with a powerful runtime that leverages low-level APIs (e.g. Amazon EC2) and manages data dependencies (objects and files). From a sequential Python code, it is able to run in parallel and distributed.
COMPSs screenshot
Releases
PyCOMPSs is based on COMPSs. COMPSs version 1.3 was released in November 2015, version 1.4 in May 2016 and version 2.0 in November 2016.
New features in COMPSs v1.3
Runtime
Persistent workers: workers can be deployed on computing nodes and persist during all the application lifetime, thus reducing the runtime overhead. The previous implementation of workers based on a per task process is still supported.
Enhanced logging system
Interoperable communication layer: different inter-nodes communication protocol is supported by implementing the Adaptor interface (JavaGAT and NIO implementations already included)
Simplified cloud connectors interface
JClouds connector
Python/PyCOMPSs
Added constraints support
Enhanced methods support
Lists accepted as a tasks’ parameter type
Support for user decorators
Tools
New monitoring tool: with new views, as workload and possibility of visualizing information about previous runs
Enhanced tracing mechanism
Simplified execution scripts
Simplified installation on supercomputers through better scripts
New features in COMPSs v1.4
Runtime
Added support for Docker
Added support for Chameleon Cloud
Object cache for persistent workers
Improved error management
Added connector for submitting tasks to MN supercomputer from external COMPSs applications
Bug-fixes
Python/PyCOMPSs
General bug-fixes
Tools
Enhanced Tracing mechanism:
Reduced overhead using native Java API
Added support for communications instrumentation added
Added support for PAPI hardware counters
Known Limitations
When executing Python applications with constraints in the cloud the initial VMs must be set to 0
New features in COMPSs v2.0 (released November 2016)
Runtime:
Upgrade to Java 8
Support to remote input files (input files already at workers)
Integration with Persistent Objects
Elasticity with Docker and Mesos
Multi-processor support (CPUs, GPUs, FPGAs)
Dynamic constraints with environment variables
Scheduling taking into account the full tasks graph (not only ready tasks)
Support for SLURM clusters
Initial COMPSs/OmpSs integration
Replicated tasks: Tasks executed in all the workers
Explicit Barrier
Python:
Python user events and HW counters tracing
Improved PyCOMPSs serialization. Added support for lambda and generator parameters.
C:
Constraints support
Tools:
Improved current graph visualization on COMPSs Monitor
Improvements:
Simplified Resource and Project files (NO retrocompatibility)
Improved binding workers execution (use pipes instead of Java Process Builders)
Simplifies cluster job scripts and supercomputers configuration
Several bug fixes
Known Limitations:
When executing python applications with constraints in the cloud the initial VMs must be set to 0
New features in PyCOMPSs/COMPSs v2.1 (released June 2017)
New features:
Runtime:
New annotations to simplify tasks that call external binaries
Integration with other programming models (MPI, OmpSs,..)
Support for Singularity containers in Clusters
Extension of the scheduling to support multi-node tasks (MPI apps as tasks)
Support for Grid Engine job scheduler in clusters
Language flag automatically inferred in runcompss script
New schedulers based on tasks’ generation order
Core affinity and over-subscribing thread management in multi-core cluster queue scripts (used with MKL libraries, for example)
Python:
@local annotation to support simpler data synchronizations in master (requires to install guppy)
Support for args and kwargs parameters as task dependencies
Task versioning support in Python (multiple behaviors of the same task)
New Python persistent workers that reduce overhead of Python tasks
Support for task-thread affinity
Tracing extended to support for Python user events and HW counters (with known issues)
C:
Extension of file management API (compss_fopen, compss_ifstream, compss_ofstream, compss_delete_file)
Support for task-thread affinity
Tools:
Visualization of not-running tasks in current graph of the COMPSs Monitor
Improvements
Improved PyCOMPSs serialization
Improvements in cluster job scripts and supercomputers configuration
Several bug fixes
Known Limitations
When executing Python applications with constraints in the cloud the <InitialVMs> property must be set to 0
Tasks that invoke Numpy and MKL may experience issues if tasks use a different number of MKL threads. This is due to the fact that MKL reuses threads in the different calls and it does not change the number of threads from one call to another.
New features in PyCOMPSs/COMPSs v2.3 (released June 2018)
Runtime
Persistent storage API implementation based on Redis (distributed as default implementation with COMPSs)
Support for FPGA constraints and reconfiguration scripts
Support for PBS Job Scheduler and the Archer Supercomputer
Java
New API call to delete objects in order to reduce application memory usage
Python
Support for Python 3
Support for Python virtual environments (venv)
Support for running PyCOMPSs as a Python module
Support for tasks returning multiple elements (returns=#)
Automatic import of dummy PyCOMPSs AP
C
Persistent worker with Memory-to-memory transfers
Support for arrays (no serialization required)
Improvements
Distribution with docker images
Source Code and example applications distribution on Github
Automatic inference of task return
Improved obsolete object cleanup
Improved tracing support for applications using persistent memory
Improved finalization process to reduce zombie processes
Several bug fixes
Known limitations
Tasks that invoke Numpy and MKL may experience issues if a different MKL threads count is used in different tasks. This is due to the fact that MKL reuses threads in the different calls and it does not change the number of threads from one call to another.
New features in PyCOMPSs/COMPSs v2.5 (released June 2019)
Runtime:
New Concurrent direction type for task parameter.
Multi-node tasks support for native (Java, Python) tasks. Previously, multi-node tasks were only posible with @mpi or @decaf tasks.
@Compss decorator for executing compss applications as tasks.
New runtime api to synchronize files without opening them.
Customizable task failure management with the “onFailure” task property.
Enabled master node to execute tasks.
Python:
Partial support of numba in tasks.
Support for collection as task parameter.
Supported task inheritance.
New persistent MPI worker mode (alternative to subprocess).
Support to ARM MAP and DDT tools (with MPI worker mode).
C:
Support for task without parameters and applications without src folder.
Improvements:
New task property “targetDirection” to indicate direction of the target object in object methods. Substitutes the “isModifier” task property.
Warnings for deprecated or incorrect task parameters.
Improvements in Jupyter for Supercomputers.
Upgrade of runcompss_docker script to docker stack interface.
Several bug fixes.
Known Limitations:
Tasks that invoke Numpy and MKL may experience issues if a different MKL threads count is used in different tasks. This is due to the fact that MKL reuses threads in the different calls and it does not change the number of threads from one call to another.
C++ Objects declared as arguments in a coarse-grain tasks must be passed in the task methods as object pointers in order to have a proper dependency management.
Master as worker is not working for executions with persistent worker in C++.
Coherence and concurrent writing in parameters annotated with the “Concurrent” direction must be managed by the underlaying distributed storage system.
Delete file calls for files used as input can produce a significant synchronization of the main code.
PyCOMPSs/COMPSs PIP installation package
This is a new feature available since January 2017.
Installation:
Check the dependencies in the PIP section of the PyCOMPSs installation manual (available at the documentation section of compss.bsc.es). Be sure that the target machine satisfies the mentioned dependencies.
The installation can be done in various alternative ways:
Use PIP to install the official PyCOMPSs version from the pypi live repository:
sudo -E python2.7 -m pip install pycompss -v
Use PIP to install PyCOMPSs from a pycompss.tar.gz
The development of OmpSs was co-funded by the HBP during the Ramp-up Phase. This page is kept for reference but will no longer be updated.
OmpSs is a fine-grained programming model oriented to shared memory environments, with a powerful runtime that leverages low-level APIs (e.g. CUDA/OpenCL) and manages data dependencies (memory regions). It exploits task level parallelism and supports asynchronicity, heterogeneity and data movement.
The new version 15.06 provides the following new features as compared to version 15.04 that was part of the HBP-internal Platform Release in M18:
Socket aware (scheduling taking into account processor socket)
Reductions (mechanism to accumulate results of tasks more efficiently)
Work sharing (persistence of data in the worker) mechanisms
The development of Equalizer was co-funded by the HBP during the Ramp-up Phase. This page is kept for reference but will no longer be updated.
Equalizer is a parallel rendering framework to create and deploy parallel, scalable OpenGL applications. It provides the following major features to facilitate the development and deployment of scalable OpenGL applications:
Runtime Configurability: An Equalizer application is configured automatically or manually at runtime and can be deployed on laptops, multi-GPU workstations and large-scale visualization clusters without recompilation.
Runtime Scalability: An Equalizer application can benefit from multiple graphics cards, processors and computers to scale rendering performance, visual quality and display size.
Distributed Execution: Equalizer applications can be written to support cluster-based execution. Equalizer uses the Collage network library, a cross-platform C++ library for building heterogeneous, distributed applications.
Support for Stereo and Immersive Environments: Equalizer supports stereo rendering head tracking, head-mounted displays and other advanced features for immersive Virtual Reality installations.
The development of Deflect Client Library was co-funded by the HBP during the Ramp-up Phase. This page is kept for reference but will no longer be updated.
Deflect is a C++ library to develop applications that can send and receive pixel streams from other Deflect-based applications, for example DisplayCluster. The following applications are provided which make use of the streaming API:
DesktopStreamer: A small utility that allows the user to stream the desktop.
SimpleStreamer: A simple example to demonstrate streaming of an OpenGL application.
The development of Score-P was co-funded by the HBP during the Ramp-up Phase. This page is kept for reference but will no longer be updated.
The Score-P measurement infrastructure is a highly scalable and easy-to-use tool suite for profiling, event tracing, and online analysis of HPC applications. Score-P is developed under a BSD 3-Clause (Open Source) License and governed by a meritocratic governance model.
Score-P offers the user a maximum of convenience by supporting a number of analysis tools. Currently, it works with Periscope, Scalasca, Vampir, and Tau and is open for other tools. Score-P comes together with the new Open Trace Format Version 2, the Cube4 profiling format and the Opari2 instrumenter.
Score-P is part of a larger set of tools for parallel performance analysis and debugging developed by the “Virtual Institute – High Productivity Supercomputing” (VI-HPS) consortium. Further documentation, training and support are available through VI-HPS.
The new version 1.4.2 provides the following new features (externally funded) as compared to version 1.4 that was part of the HBP-internal Platform Release in M18:
The development of Scalasca was co-funded by the HBP during the Ramp-up Phase. This page is kept for reference but will no longer be updated.
Scalasca is a software tool that supports the performance optimisation of parallelprograms by measuring and analysing their runtime behaviour. The analysis identifies potential performance bottlenecks – in particular those concerning communication and synchronization – and offers guidance in exploring their causes.
Scalasca targets mainly scientific and engineering applications based on the programming interfaces MPI and OpenMP, including hybrid applications based on a combination of the two. The tool has been specifically designed for use on large-scale systems including IBM Blue Gene and Cray XT, but is also well suited for small- and medium-scale HPC platforms. The software is available for free download under the New BSD open-source license.
Scalasca is part of a larger set of tools for parallel performance analysis and debugging developed by the “Virtual Institute – High Productivity Supercomputing” (VI-HPS) consortium. Further documentation, training and support are available through VI-HPS.
The new version 2.2.2 provides the following new features (externally funded) as compared to version 2.2 that was part of the HBP-internal Platform Release in M18:
The development of RTNeuron in the HPAC Platform was co-funded by the HBP during the second project phase (SGA1). This page is kept for reference but will no longer be updated.
RTNeuron is a scalable real-time rendering tool for the visualisation of neuronal simulations based on cable models. Its main utility is twofold: the interactive visual inspection of structural and functional features of the cortical column model and the generation of high quality movies and images for presentations and publications. The package provides three main components:
A high level C++ library.
A Python module that wraps the C++ library and provides additional tools.
The Python application script rtneuron-app.py
A wide variety of scenarios is covered by rtneuron-app.py. In case the user needs a finer control of the rendering, such as in movie production or to speed up the exploration of different data sets, the Python wrapping is the way to go. The Python wrapping can be used through an IPython shell started directly from rtneuron-app.py or importing the module rtneuron into own Python programs. GUI overlays can be created for specific use cases using PyQt and QML.
RTNeuron is available on the pilot system JULIA and on JURECA as environment module.
RTNeuron in aixCAVENeuron rendered by RTNeuronVisual representation of cell dyesSimulation playbackInteractive circuit slicingConnection browsing
Date of release
February 2018
Version of software
2.13.0
Version of documentation
2.13.0
Software available
https://developer.humanbrainproject.eu/docs/projects/RTNeuron/2.11/index.html; Open sourcing scheduled for June 2018
The development of Paraver was co-funded by the HBP Ramp-up Phase. This page is kept for reference but will no longer be updated.
Paraver is a very flexible data browser. The metrics used are not hardwired on the tool but can be programmed. To compute them, the tool offers a large set of time functions, a filter module, and a mechanism to combine two timelines. This approach allows displaying a huge number of metrics with the available data. The analysis display allows computing statistics over any timeline and selected region, what allows correlating the information of up to three different time functions. To capture the expert’s knowledge, any view or set of views can be saved as a Paraver configuration file. Therefore, re-computing the same view with new data is as simple as loading the saved file. The tool has been demonstrated to be very useful for performance analysis studies, giving much more details about the applications behaviour than most performance tools available.
Screenshot of Paraver
The new version 4.6.0 (3rd February 2016) provides the following new features (externally funded) as compared to version 4.5.6 (February 2015) that was part of the HBP-internal Platform Release in M18:
Automatic workspaces on trace loading
Scalability improvements for traces with more than 64K rows
Support for wxWidgets 3
Traces with same hierarchy can be combined to analyze
External tools integration
The new version 4.6.3 (16th November 2016) provides the following new features:
Added punctual information view to timelines
Added external tool Run->Spectral from timelines
Trace load time reduced by 25%
Histogram new features: show only totals and short/long column labels
Run app dialog usability improvements
Date of release
16th of November 2016
Version of software
4.6.3
Version of documentation
3.1 (Old, year 2001) But Tutorials available for newer versions
The development of CUBE: Score-P / Scalasca was co-funded by the HBP during the Ramp-up Phase. This page is kept for reference but will no longer be updated.
Cube, which is used as performance report explorer for Scalasca and Score-P, is a generic tool for displaying a multi-dimensional performance space consisting of the dimensions
Performance metric,
Call path, and
System resource.
Each dimension can be represented as a tree, where non-leaf nodes of the tree can be collapsed or expanded to achieve the desired level of granularity. In addition, Cube can display multi-dimensional Cartesian process topologies.
The Cube 4.x series report explorer and the associated Cube4 data format is provided for Cube files produced with the Score-P performance instrumentation and measurement infrastructure or with Scalasca version 2.x trace analyzer (and other compatible tools). However, for backwards compatibility, Cube 4.x can also read and display Cube 3.x data.
Cube is part of a larger set of tools for parallel performance analysis and debugging developed by the “Virtual Institute – High Productivity Supercomputing” (VI-HPS) consortium. Further documentation, training and support are available through VI-HPS:
The new version 4.3.3 provides the following new features (externally funded) as compared to version 4.3.1 that was part of the HBP-internal Platform Release in M18:
The development of Extrae was co-funded by the HBP during the Ramp-up Phase. This page is kept for reference but will no longer be updated.
Extrae is an instrumentation and measurement system gathering time stamped information of the events of an application. It is the package devoted to generate Paraver trace files for a post-mortem analysis of a code run. It uses different interposition mechanisms to inject probes into the target application in order to gather information about the application performance.
The new version 3.2.1 (3rd November 2015) provides the following new features as compared to version 3.1.0 that was part of the HBP-internal Platform Release in M18:
Support for MPI3 immediate collectives
Use Intel PEBS to sample memory references.
The new version 3.4.1 (23th September 2016) provides the following new features:
Extended Java support through AspectJ and JVMTI
Improved CUDA and OpenCL support
Improved support for MPI-IO operations
Added instrumentation for system I/O and other system calls
Dependencies: libxml2 2.5.0; libunwind for Linux x86/x86-64/IA64/ARM. Optional: PAPI; DynInst; liberty and libbfd; MPI; OpenMP
Target system(s)
Any Unix/Linux system (supercomputers, clusters, servers, workstations, laptops …)
This website describes the results of the “High Performance Analytics and Computing” (HPAC) Platform of the Human Brain Project (HBP) from the first three project phases (Ramp-up Phase 10/2013-03/2016, SGA1 04/2016-03/2018 and SGA2 04/2018-03/2020).
Due to a major project-internal reorganisation, this website will no longer be updated after March 2020.
More recent information can be found on humanbrainproject.eu and ebrains.eu.
Information about the Fenix Research Infrastructure and the ICEI project, including resource access, are available on their website.
Follow EBRAINS Computing Services@HBPHighPerfComp and Fenix RI@Fenix_RI_eu on Twitter to learn about the most recent developments and to get to know about upcoming opportunities for calls and collaborations!
The Virtual Brain (TVB) is a large-scale brain simulator. With a community of thousands of users around the world, TVB has become a validated, popular and standard choice for the simulation of whole brain activity. TVB users can create simulations using neural mass models which can produce outputs for different analysis and modalities. TVB allows scientists to explore and analyze both simulated and experimental data. It contains analytic tools for evaluating relevant scientific parameters in light of that data. The current implementation of TVB is written in Python, with limited large-scale parallelization over different parameters. The objective of TVB-HPC is to enable large-scale parallelization of TVB simulations by making use of high performance computing to explore large parameter spaces for the models. With this approach, neuroscientists can define their models in a domain specific language based on NeuroML and automatically generate code which can run either on GPUs or on CPUs with different architectures and optimizations. The result is a framework that hides the complexity of writing robust parallel code and offers neuroscientists a fast and efficient access to high performance computing. TVB-HPC is publicly available on GitHub and, at the end of HBP project phase SGA2, it will be possible to launch large parameter simulations using code automatically generated with this framework via the HBP Collaboratory.
Science has driven the development of the NEST simulator for the past 20 years. Originally created to simulate the propagation of synfire chains using single-processor workstations, we have pushed NEST’s capabilities continuously to address new scientific questions and computer architectures. Prominent examples include studies on spike-timing dependent plasticity in large simulations of cortical networks, the verification of mean-field models, models of Alzheimer’s and Parkinson’s disease and tinnitus. Recent developments include a significant reduction in memory requirements, as demonstrated by a record-breaking simulation of 1.86 billion neurons connected by 11.1 trillion synapses on the Japanese K supercomputer, paving the way for brain-scale simulations.
to create and deploy parallel, scalable OpenGL applications. It provides the following major features to facilitate the development and deployment of scalable OpenGL applications:
