GPU Day 2018

High-level .NET Software Implementations of the Unum Type I and Posit Floating-Point Number Types with Simultaneous FPGA Implementation Using Hastlayer

Zoltán Lehóczky¹, András Retzler¹, Richárd Tóth¹, Álmos Szabó¹, Márk Bartha¹, Benedek Farkas¹, Krisztián Somogyi

¹ Lombiq Technologies Ltd., Budapest, Hungary

The unum arithmetic framework has been proposed by Gustafson, D. J. to address the short-comings of the IEEE 754 Standard’s floating-point. In this talk, we present how unums compare to IEEE floating-point and why they are beneficial for scientific use-cases, and we showcase our software and hardware implementations of Type I and posit unums.

The software implementation is built on the .NET platform as an open source library written in the C# programming language. We automatically create hardware implementations using our .NET to FPGA converter tool called Hastlayer.

The amount of hardware resources needed for addition operations are quantified, and the performance of software and prototype hardware for posits are compared. We show that posits are significantly more hardware friendly than Type I unums. Furthermore, our posit FPGA implementation is about 2.04 times more efficient per clock cycle than its software implementation.

Quantum Computing: basic principles, present architectures, future possibilities

Zoltán Zimborás¹

¹ Wigner Research Centre for Physics of the Hungarian Academy of Sciences, Budapest, Hungary 

In recent years, we find almost every day news about the soon-to-be-built quantum computers and how they will open a new era by fundamentally changing today's information technology. In this talk we hope to shed light on these statements. First, we introduce the basic quantum physics principles that led to the idea of a quantum computer. Next, we review what tasks and how far classical computers are going to be surpassed by possible future large-scale quantum computers. Finally, we show some simple experiments on free cloud quantum computers: the IBM Quantum Experience Machines.

Parallelising the Modern C++ Standard Library

Christopher Di Bella¹

¹ Codeplay Software Ltd., Edinburgh, United Kingdom 

C++17 introduced parallel algorithms, but the current interface prevents heterogeneous systems -- such as personal computers and server nodes with GPUs, smartphones, and embedded System on a Chip -- from taking advantage of parallel computation. Through its clean, algorithmic composition, we believe that the Ranges TS and its proposed extensions offer solutions to these problems, and how well programs perform on heterogeneous platforms.

We will discuss why adopting Ranges will be beneficial for your programs, and once parallelised, how they naturally lend themselves to parallelising your code with minimal changes on your part.

OP2-Clang: A source-to-source translator using Clang/LLVM LibTooling

Gábor Dániel Balogh¹, Gihan R. Mudalige² and István Zoltán Reguly¹

¹ Pázmány Péter Catholic University, Information Technology and Bionics
² The University of Warwick, Department of Computer Science

Correspondence: [email protected]

Domain Specific Languages or Active Library frameworks have recently emerged as
an important method for gaining performance portability, where an application
can be efficiently executed on a wide range of HPC architectures without
significant manual modifications. Embedded DSLs such as OP2, provides an API
embedded in general purpose languages such as C/C++/Fortran. They rely on
source-to-source translation and code refactorization to translate the
higher-level API calls to platform specific parallel implementations. OP2 that
provides a high-level API for the solution of unstructured-mesh computations can
generate a wide range of parallel implantations for execution on architectures
such as CPUs, GPUs, distributed memory clusters and heterogeneous processors
making use of radical platform specific optimizations. Compiler tool-chains
supporting source-to-source translation of code written in mainstream languages
currently lacks the capabilities to carry out such wide-ranging code
transformations. Clang/LLVMís Tooling library (LibTooling) has long been touted
as having such capabilities but have only demonstrated its use in simple source
refactoring tasks.

In this talk we introduce OP2-Clang, a source-to-source translator based on
LibTooling, for OP2's C/C++ API, capable of generating target parallel
code based on SIMD, OpenMP, CUDA and their combinations with MPI. OP2-Clang is
designed to significantly reduce maintenance, particularly making it easy to be
extended to generate new paralleizations and optimizations for hardware
platforms. In this research, we demonstrate its capabilities including (1) the
use of LibToolingís AST matchers together with a novel strategy that use
parallelization templates or skeletons to significantly reduce the complexity of
generating radically different and transformed target code and (2) the
generation of optimized kernels for computation loops with indirections for two
industrial representative unstructured-mesh applications. We determine the
current limits of LibTooling to support the source-to-source translations in
eDSLs such as OP2 and provide recommendations for its future development to
facilitate code-generation requirements of such frameworks.

Improving Locality of Unstructured Mesh Algorithms on GPUs

András Attila Sulyok¹, Gábor Dániel Balogh¹, István Zoltán Reguly¹ and Gihan R. Mudalige²

¹ Pázmány Péter Catholic University, Information Technology and Bionics
² The University of Warwick, Department of Computer Science

Correspondence: [email protected]

To most efficiently utilize modern parallel architectures, the memory access
patterns of algorithms must make heavy use of the cache architecture:
successively accessed data must be close in memory (spatial locality) and
one piece of data must be reused as many times as possible (temporal
locality).

Unstructured mesh algorithms are notoriously difficult in this sense,
especially due to computations that indirectly modify data, leading to race
conditions. In this work we address this problem through a number of
optimisations on GPUs, specifically the use of the shared memory and a
two-layered colouring strategy to cache the data. We also look at different
block layouts to analyse the trade-off between data reuse and the amount of
synchronisation.

We developed a standalone library that can transparently reorder the
operations done and data accessed by a kernel, without modifications to the
algorithm by the user. Using this, we performed measurements on relevant
scientific kernels from different applications, such as Airfoil, Volna,
Bookleaf, Lulesh and miniAero; using Nvidia Pascal and Volta GPUs. We
observed significant speedups (1.2--2.5x) compared to the
original codes.

Optimizing Linear Algebraic Operations for Improved Data-Locality

Dániel Berényi¹, András Leitereg², Gábor Lehel²

¹ Wigner Research Centre for Physics of the Hungarian Academy of Sciences, Budapest, Hungary
² Department of Informatics, Eötvös Loránd University, Budapest, Hungary 

In this talk we present a selection of higher-order functions that were chosen to compactly represent dense linear algebraic expressions (like matrix multiplication or tensor contraction) and are suitable for optimization. First, we show that these primitives have desirable algebraic properties and are closed under certain fusion laws. Second, we present subdivision rules for splitting the primitives, and exchange rules for the cases where a higher-order function is passed as a function argument to another. Such rules make it possible to start from naive forms of linear algebraic expressions, then generate permutations and different block rearrangements which have much better data locality and therefore performance compared to the naive version.

Modern applications of GPU assisted ray tracing

Attila Barsi¹

¹ Holografika Ltd., Budapest, Hungary

GPU ray tracing has been around since the advent of GPGPU rendering. Previous GPU architectures provided ray tracing solutions via compute shaders. Real hardware accelerated ray tracing on GPUs however has only been introduced recently.
In anticipation of GPU accelerated ray tracing becoming available for all consumers of GPUs, we will take a look at the existing ray tracing techniques and use cases. We would also like to give an overview of existing and upcoming APIs.

We would like to cover the following topics:

• Introduction to ray tracing
• Acceleration structures
• Generating primary rays for perspective and orthographic cameras
• Differences between CPU and GPU ray tracers
• Stackless traversal
• Forward, backward and hybrid ray tracing
• Use case: Whitted ray tracing
• Use case: Volume ray casting
• Other use cases (picking, ambient occlusion, etc.)
• Ray tracing via the NVIDIAÆ OptiXô
• Ray tracing via DirextXÆ Raytracing (DXR)
• Ray tracing via Radeon Rays (OpenCL 1.2)
• Ray tracing via OpenGL compute shaders
• Applications of ray tracing in light field rendering.

A functional photogrammetry library

Attila Szabo¹

¹ VRVis Research Center, Vienna, Austria

As part of a diploma thesis, a composable and reusable photogrammetry library was implemented from scratch. The computational and mathematical complexity involved is handled through a functional implementation. We present the necessary components for photogrammetry, outline an implementation, and discuss advantages of such a design.

Functional programming vs. Efficient Computer Graphics

Harald Steinlechner¹, Georg Haaser¹

¹ VRVis Research Center, Vienna, Austria

We provide an overview of the Aardvark Platform team and current interesting projects. The team works in High Performance Rendering, Data Acquisition and Computer Vision areas together with industry partners, aiming to create clean, production-quality software. Functional Programming and Declarative APIs greatly facilitate this process for small and scientific teams.

Aardvark Platform is an open source rendering and visual computing library powering multiple state of the art industry applications. The core component Aardvark.Rendering is a lazy incremental renderer which compiles render commands down to efficient GPU instructions using a dependency tracking system. An adaptive scenegraph provides a declarative scene specification API. We walk through the implementation of such a rendering backend and demonstrate difficult use cases handled quickly and concisely.

A functional Shader library

Georg Haaser¹

¹ VRVis Research Center, Vienna, Austria 

We provide an overview of the Aardvark Platform team and current interesting projects. The team works in High Performance Rendering, Data Acquisition and Computer Vision areas together with industry partners, aiming to create clean, production-quality software. Functional Programming and Declarative APIs greatly facilitate this process for small and scientific teams. 

FShade is a library for composable shaders. Using a declarative language, shader modules are defined independently and then compiled efficiently into a shader pipeline, which is then emitted as shader code.

Features:

- easy shader variation and reordering
- automatic VR shaders
- shader caching through expression tree serialization
- live shader editor

Functional Programming in the Wild

Harald Steinlechner¹

¹ VRVis Research Center, Vienna, Austria  

We provide an overview of the Aardvark Platform team and current interesting projects. The team works in High Performance Rendering, Data Acquisition and Computer Vision areas together with industry partners, aiming to create clean, production-quality software. Functional Programming and Declarative APIs greatly facilitate this process for small and scientific teams. 

Building large, complex, and heavily underspecified research applications with small teams. Aardvark.Media is an ELM-style application declaration library. It provides a declarative API, of which an efficient mutable implementation is compiled in the background. We demonstrate some examples implemented with Aardvark.Rendering and Aardvark.Media, including an efficient Volume Renderer, a large-scale level of detail system used with Point Clouds, and VR apps.

Landscape Heatmap Simulation

Gernot Ziegler¹

¹ Geofront e.U., Austria 

We demonstrate how shadow mapping, a standard method for surface shadow computations in computer games, can be applied to this 3D model to compute the landscape¥s exposure to sunlight using plain WebGL running in a browser. WebGL has become a very useful tool to bring data visualization and game graphics to end users on a PC, smartphone or tablet without having to install executables, allowing for quick deployment.Photogrammetry software has progressed to such a degree that usable 3D models can be computed from a set of photos that a consumer drone has obtained during a single flight, without any additional laser scans necessary in addition.

We further demonstrate how GPGPU techniques can extend this shadowing simulation to create a "heatmap" of the landscape for sun exposure over a given timespan.

Landscape heatmaps can be useful in various situations of construction planning, such as solar panel construction (where maximum sun exposure at a good panel angle is desired), and architectural planning (where a minimum sun exposure per day is required for every window of the building). Your suggestions on additional application areas are welcomed.

LambdaCube 3D - A purely functional API for GPU graphics

Csaba Hruska¹

¹ Freelancer

At its heart, the graphics pipeline is simply a configurable data-flow network. The main input of the network arrives as a stream of vertex descriptions, and additional data can be provided in various slots, which are constant during a rendering pass: uniforms of basic types and samplers (textures with some attached logic). After some processing steps, the final output is one or more raster images.

We can look at this data-flow network as a mathematical function that maps scene descriptions to bitmaps. The internal structure of this function can be defined in terms of smaller building blocks that correspond to various stages of the pipeline. Even the programmable pipeline has a more or less fixed global structure, but the transformations within the main stages can be freely defined through shaders, which suggests that the pipeline can be naturally modelled as a higher-order function.

I'll present LambdaCube 3D, a Haskell-like purely functional domain specific language for GPU programming. The purpose of this tool is to provide a platform and host language independent graphics API. It allows the programmer to define the rendering pipeline with a single language, which is compiled into shaders and CPU-side setup code.

The basic motivation for creating LambdaCube is really simple: it represents the perfect intersection of different fields that have excited us for a long time – pure functional programming, computer graphics, and compiler research. We intend to explore a totally new branch of the design space for authoring and developer tools.

I saw the future. It's Mixed Reality!

Márk Szabó¹

¹ Partner Technical Strategist & HoloLens Champ, Microsoft

Microsoft HoloLens is the world's first self-contained holographic computer, enabling you to engage with your digital content and interact with holograms in the world around you.

Specialized components ó like multiple sensors, advanced optics and a custom holographic processing unit ó enable us to go beyond the screen and bring people, places and objects from your physical and digital worlds together with Mixed reality.

Come and try out the future yourself!

ML/AI on Azure for students and organizations

Vivien Rajz¹

¹ Epam Ltd., Budapest, Hungary

Running ML and AI tasks can be computationally intensive, over or underutilized hardware resources could lead to frustration and financial burden as well. Microsoft Azure provides a scalable infrastructure for rapid prototyping or building end-to-end ML/AI architecture.

During the presentation will show how Azure offerings can help to extend or completely substitute on-premise infrastructure, which fits into enterprise environment or what it can offer for students. Will introduce you to various Azure resources such as Notebooks, Machine Learning Studio, Data Lake, Storage Services and integration points to an existing infrastructure.

At the end of the presentation, you will be familiar with Azure offerings, how to utilize them in a cost and time sensitive manner. 

Parallel evaluation of neural game value networks

István Borsos¹

¹ Institute for Technical Physics and Materials Science, Centre for Energy Research, Hungarian Academy of Sciences, P.O. Box 49, H-1525 Budapest, Hungary

During minimax evaluation of nodes of game value networks, a number of follow-up moves are generated and the values of the resulting positions are predicted by the network in order to compute a better estimation for the value of the original position. In parallel implementation of this problem multiple nodes (several hundreds when using a GPU) should be evaluated simultaneously, but the different number of follow-up moves or the early exits (like e.g. alpha cut-os) during the investigation of some of the nodes makes the direct parallelization less efficient. In this talk, we present a method to improve the efficiency of this computation.

Neural Network study on 2d scalar field theory

Kai Zhou¹

¹ Frankfurt Institute for Advanced Studies - Goethe-Universität, Frankfurt, Germany

We explore the perspectives of deep learning techniques in the context of quantum field theories. In particular, we discuss complex scalar field theory at nonzero temperature and chemical potential - a theory with a nontrivial phase diagram. With deep learning, a neural network is successfully trained to recognize the different phases of this system and predict the value of various physical observables (particle density and the squared field), based solely on the field configurations from Monte-Carlo generation. It's found that the network is robust and able to recognize patterns with limited training examples and can generalize well to different chemical potential, thus has the ability to do non-linear interpolation being in according with underlying physics from training. We then further explored the modern deep learning technique GAN (generative adversarial neural network) to help generating new configurations in the sense that typical thermal observables to be consistent with the Monte-Carlo generation. This method can bypass the conventional Markov-Chain Monte-Carlo process and thus computationally efficient and memory light compared to traditional approach.

In both physics (heavy-ion collisions) and valve-industy, we investigated using deep learning to detect bulk properties during a dynamical evolution process from final approachable observables or acoustic records.

In heavy-ion collisions, we devoted a new method using deep learning to construct an equation-of-state (EoS) emter to better understand QCD matter created from heavy-ion collisions provided the final pion's spectra. Withing hydrodynamical evolution which is simulating heavy-ion collisions we clearly demonstrated there do exist encoders from QCD transition information (cross-over or first order) onto the final particle spectra, and the deep convolutional neural network is capable of finding out this encoder and thus can disentangle different hidden correlations (from unknown physical factors like initial conditions, equilibrium time, transport coefficients and freeze-out temperatures) to efficiently provide mapping between the phase transition information during dynamics to the final output particle spectra. This thus can provide us an useful tool to unveil knowledge from highly implicit data of heavy-ion experiments.

In valve-industy, we conducted 'Smart Valve' project with industry collaborators aiming at giving normal valve ability to communicate. In the first step we take similar strategy as above, using deep learning to analyze the working state (to detect cavitation/turbulent flow status, to estimate the flow velocity inside the valve, to tell if there's leakage) based on acoustic signal from valve. This can save a lot of manpower and help doing anomaly detection and safety insuring for valve/pipe plants like underground or large-scale industrial devise.

Application of machine learning in gravitational waves survey

Filip Morawski¹

¹ Nicolaus Copernicus Astronomical Center, Warsaw

Detection of gravitational waves is extremely complex task. Among many known and unknown noise sources, we would like to find very weak signals originating from very distant objects. Up to now, this was possible for only relatively strong signals. However, there are methods that might help us in this challenging task. Nowadays machine learning gains more and more attention in science. It might be especially useful in the domain of the weak signals characterization. I would like to present examples of my own research in the application of the machine learning in gravitational waves studies I did for the past few months concerning signal classification, artifact detection and detector characteristics.

Characterizing the chloride translocation pathway in the CFTR channel

Bianka Farkas^1,2,3, János Gera⁴, Hedvig Tordai¹, Gábor Paragi⁴, Tamás Hegedűs^1,2

¹ Department of Biophysics and Radiation Biology, Semmelweis University, Budapest, Hungary

² MTA-SE Molecular Biophysics Research Group, Hungarian Academy of Sciences, Budapest, Hungary

³ Faculty of Information Technology, Pázmány Péter Catholic University, Budapest, Hungary

⁴ MTA-SZTE Supramolecular and Nanostructured Materials Research Group, Szeged, Hungary

Cystic fibrosis (CF), a lethal monogenic disease, is caused by mutant variants of the CFTR chloride channel. Most of the CF mutations, including the most frequent ΔF508 deletion, affect protein folding and stability and lead to diminished apical anion conductance of epithelial cells. Although extensive efforts have been devoted for CF drug development, we still search for efficacious small molecules for correcting CFTR folding. This could be partly attributed to our limited knowledge on the CFTR structure. Recent advances in single molecule cryo-EM methods enabled the structural determination of full-length human and zebrafish CFTR, promoting structure-based studies. However, none of the structures shows an open pathway for chloride permeation. In addition, the degenerate ATP site-1, which binds ATP strongly without hydrolysis, is less compact compared to site-2. Therefore, we assessed the structural properties of CFTR protein based on experimental and homology models by molecular dynamics simulations. ATP-binding to site-1 and site-2 was calculated and compared using umbrella sampling technique. Biased molecular dynamics simulations were performed to test the ability of ATP-bound models to switch to a conducting conformation. Our results show that the site-1 in ATP-bound conformation does not remain in a tight contact and suggest that the interaction between the phosphate groups and the Walker A helix is responsible for the strong ATP binding at the degenerate site. We also analyze the potential chloride pathway highlighted by metadynamics simulations in the light of experimental datasets. In summary, our in silico investigations help to understand the properties of the CFTR chloride channel distinct from transporters, to interpret available structural information on CFTR, as well as to understand its mechanism of function.

Quad-tree Generation with RNN for Efficient Graph Visualization

Richárd Forster¹

¹ CERN

With a huge amount data getting collected every day, visual analytics is getting more important to help the users understand their data. The CERN developed Collaboration Spotting is a tool providing generic infrastructure to visualize different types of data. To achieve this a multistep process is computing the visual maps of the available data, that involves community detection and visual graph organization. In the current work the emphasis is on graph organization with the ForceAtlas algorithm. This method is responsible to assign coordinates in a 2D space for every node in such a way that they will not overlap on each other. As this algorithm is an n-body simulation between the nodes, the Barnes-Hut algorithm is used to generate a quad-tree to reduce the complexity of the computation. It is notable for having order O(n log n) compared to a direct-sum algorithm which would be O(n2).

In a recurrent neural network (RNN) the connections between neurons form a directed graph along a sequence. This allows it to exhibit dynamic temporal behavior for a time sequence. RNNs can use their internal state (memory) to process sequences of inputs.

Using RNN in the quad-tree generation, we can predict the sum of mass of all the nodes in each region. The usage of an RNN with Long Short-Term Memory is explored, how it affects the precision and overall performance of the algorithm relying on the massively parallel performance of the GPUs.

Efficient Correlation-Free Many-States Lattice Monte Carlo on GPUs

Jeffrey Kelling¹

¹ Helmholtz-Zentrum Dresden-Rossendorf, Department of Information Services and Computing, Dresden, Germany 

In this talk, we present a method for highly efficient lattice Monte Carlo simulations with correlation-free updates. Achieving freedom from erroneous correlations requires random selection of lattice sites for updates, which must be restricted by suitable domain decomposition to create parallelism. While approaches based on caching limit the number of allowed states, the multisurface-type approach presented here allows arbitrarily complex states. The effectiveness of the method is illustrated in the fact that it allowed solving a long standing dispute around surface growth under random kinetic deposition in the KPZ-universality class. The method has also been applied to Potts models and is suitable for spin-glass simulations, such as those required to test quantum annealers, like D-Wave.

GPU accelerated solution of large number of independent ODE systems

Ferenc Hegedűs¹

¹ Department of Hydrodynamic Systems, Budapest University of Technology and Economics, Budapest, Hungary

In many fields of science, the governing equations of a physical problem can be described by an ordinary differential equation system (ODEs). If the number and size of such a system is smaller, then exploiting the possibilities of massively parallel computing is not feasible, since the time marching of an initial value problem is serial in nature. However, if a large number of parameters are involved during an investigation, the whole problem can be decomposed into a large number of decoupled sub-problems where each parameter combination represents an individual and independent task. These problems are especially suitable for professional GPGPUs using the SIMT (single instruction multiple threads) paradigms. In the last years, many researchers have already implemented their numerical code capable to exploit the high processing powers of GPUs. These are usually specialized codes for the given field of science. General purpose, modular solvers are scarce in the literature. The main aim of the present study/talk is to fill this gap and propose a possible implementation of such a solution technique. An important requirement is the possibility to give the ODE system with as similar syntax as in MATLAB. The code is implemented in C++ and CUDA C software environment. The numerical schemes which can be selected are the 4th order explicit and adaptive Runge-Kutta-Cash-Karp method with 5th embedded error estimation and the well-known 4th order explicit Runge-Kutta technique with fixed time step. Because the code can handle millions of independent ODE systems, intermediate solutions during the integration are not stored. This is also mandatory from the performance point of view. To be able to extract different properties of a solution (e.g. maximum and minimum of a component, their time instance, etc.), a flexible event handling mechanism is implemented into the code. Moreover, non-smooth dynamics can also be handled easily and efficiently by providing equations describing the dynamics at a switching line (e.g. equations for the impact dynamics); therefore the integration does not have to be stopped.

Accelerated Particle in Cell with Monte Carlo Collisions (PIC/MCC) simulation for gas discharge modeling in realistic geometries.

Péter Hartmann¹, Zoltán Juhász², Zoltán Donkó¹

¹ Wigner Research Centre for Physics, Budapest, Hungary
² Dept. of Electrical Engineering and Information Systems, University of Pannonia, Veszprem, Hungary

In plasma physics Particle in Cell methods are among the few popular numerical schemes that are currently used to compute the properties of charged particle systems on the particle level. The adaptation of these algorithms to HPC infrastructure is of key importance in cases when realistic geometries are needed to be included, as those cannot be described by the most simple, numerically very efficient one-dimensional models. Massively parallel PIC simulations are already available for collision-less plasmas, where the particles interact only with the force fields. In most technological and laboratory gas discharges, however, the collisions of the charged particles with the background gas molecules are of crucial importance both for sustainment of the discharge and the desired plasma applications. The stochastic Monte Carlo type description of these elementary collision events heavily builds on random choices and features a high degree of code branching, this is difficult to implement efficiently on SIMD architecture. Recently we have developed a CUDA implementation of our 2D3V (2D in real-space and 3D in velocity-space) simulations for argon and neon gases in cylindrical and Cartesian coordinates for direct current and radio frequency excited low-pressure gas discharges. The simulation includes our own implementation of the parallel random number generator, which is significantly faster than CURAND, scaled physical quantities to fit the single precision floating point data type, and a black-red successive over-relaxation iterative solver for the electric field. This new implementation on Pascal architecture does reach a speedup factor of 100 compared to our earlier MPI implementation executed on 24 cores of a Xeon SMP node. Besides the implementation details, we present physical results for the PK-4 dusty plasma experiment that is currently in operation onboard the International Space Station (ISS).

Calculation of dissipative phase space corrections

Dénes Molnár¹

¹ Department of Physics and Astronomy, Purdue University, West Lafayette, IN 47907, USA

There is a lot of interest in heavy ion physics in systems that are near local thermal equilibrium. In such systems, particle distributions acquire nonthermal corrections (i.e., they are not Boltzmann). Hydrodynamic simulations of heavy-ion reactions use such corrected distributions to convert the hydrodynamic fields to particles at the end of the calculation. A self-consistent approach to relate dissipative phase space corrections to hydrodynamic fields (namely, the energy momentum tensor and conserved currents) is provided by linearized kinetic theory [1].

Mathematically, the problem boils down to solving a linear integral equation for the phase space corrections as a function of momentum, which is then recast as the maximization of some functional. Numerically, the maximization is done using a finite variational basis of functions. The most time consuming part is the calculation of numerous variational "matrix elements", which involve four-dimensional integrals. I will discuss how the integration is performed using an implementation of adaptive Gauss-Kronrod quadrature on GPUs, and present results calculated for a multi-species hadron gas with self-consistent shear viscous and bulk viscous corrections.

[1] D. Molnar and Z. Wolff, PRC 95, 024903 (2017) 

High-Energy Jet Interaction Monte Carlo for the Future Generations: HIJING++

Gábor Bíró¹, Gergely Gábor Barnaföldi¹, Gábor Papp^{1, 2}, Péter Lévai¹, Miklós Gyulassy^{1, 3, 4, 5}, Xinnian Wang^{3, 4}, Ben-wei Zhang³

¹ Wigner Research Centre for Physics of the Hungarian Academy of Sciences, Budapest, Hungary
² Institute for Physics, Eötvös Loránd University, Budapest, Hungary 
³ Institute of Particle Physics, Central China Normal University 
⁴ Nuclear Science Division, MS 70R0319, Lawrence Berkeley National Laboratory, Berkeley, California 94720 USA
⁵ Pupin Lab MS-5202, Department of Physics, Columbia University, New York, NY 10027, USA

During the approaching second Long Shutdown of the Large Hadron Collider (LHC) in 2019-2020, many technical improvements will occur in the accelerator complex, in the detector systems, and in the data acquisition systems. These will result in a huge increase of the number of expected collisions per second and as a consequence also the amount of measured data will grow rapidly. This period is the forerunner of the next generation of particle accelerators (HL-LHC, FCC), where we will accumulate experimental data in a higher rate than ever. In parallel, we need to improve also the numerical tools in order to be able to keep up the requirements of the high-precision era. The recently developed HIJING++ (Heavy Ion Jet Interaction Generator) will be the successor of the widely used original HIJING, developed almost three decades ago. While the old version was written in FORTRAN, the soon-to-be-published HIJING++ was completely rewritten in modern C++. During the development we keep in mind the requirements of the high-energy heavy-ion community: the new Monte Carlo software have a well designed modular framework, therefore any future improvement will be much easier. It contains all the improved physical models that were also present in its predecessor, but utilizing modern C++ features it also includes native thread-based parallelism, an easy-to-use analysis interface and a modular plugin system, which makes room for possible future improvements like GPU acceleration. In my talk, I present the current state of HIJING++ including the recent performance and benchmark tests.

Multi-GPU Simulations of the Infinite Universe

István Csabai^{1, 2}

¹ Wigner Research Centre for Physics of the Hungarian Academy of Sciences, Budapest, Hungary
² Institute for Physics, Eötvös Loránd University, Budapest, Hungary 

The StePS (Stereographically Projected Cosmological Simulations) is a new zoom-in cosmological direct N-body simulation method, that can simulate an infinite universe with unprecedented dynamic range for a given amount of memory, and in contrast of the traditional periodic simulations, its fundamental geometry and topology match observations. We present the Multi-GPU realisation of this algorithm with MPI-OpenMP-CUDA hybrid parallelisation, and show what parallelisation efficiency can be reached with our implementation. With our code, it is possible to run simulations with few a Gpc diameter and with $10^9M_{\odot}$ mass resolution in the center under days on the MARCC (Maryland Advanced Research Computing Center) GPU cluster or run extremely fast simulations with a reasonable resolution for fitting the cosmological parameters. These simulations can be used for the prediction needs of large surveys such as DES (Dark Energy Survey), Euclid or WFIRST (Wide-Field Infrared Survey Telescope).

Light curve modeling of eclipsing stellar systems

Gábor Marschalkó¹

¹ Baja Observatory of Szeged University

To study the light variations of eclipsing stellar systems it is necessary to create an ensemble of model light curves. The models of these systems contain numerous parameters and the denser the surface grid is the more accurate our results will be, so solving this problem needs significant computing resources, thus the parallelization seems quite obvious.

Continuing our ongoing work now we can calculate complex light curves of multiple stellar systems, the only missing component is the reflection effect. On the 8th GPU day, we will present the new features and the revised structure of our code.