Register event
23 events found

Content provider: ELIXIR-SI eLearning Platfor...  or OpenRiskNet  or PRACE 

  • High-performance scientific computing in C++ @ JSC

    27 - 29 May 2019

    High-performance scientific computing in C++ @ JSC https://tess.elixir-europe.org/events/high-performance-scientific-computing-in-c-jsc-ee5bae79-ed57-4de5-bfad-0ca030797e59 Modern C++, with its support for procedural, objected oriented, generic and functional programming styles, offers many powerful abstraction mechanisms to express complexity at a high level while remaining very efficient. It is therefore the language of choice for many scientific projects. However, achieving high performance on contemporary computer hardware, with many levels of parallelism, requires understanding C++ code from a more performance centric viewpoint. In this course, the participants will learn how to write C++ programs which better utilize typical HPC hardware resources of the present day. The course is geared towards scientists and engineers, who are already familiar with C++14, and wish to develop maintainable and fast applications. They will learn to identify and avoid performance degrading characteristics, such as unnecessary memory operations, branch mispredictions, and unintentionally strong ordering assumptions. Two powerful open source libraries to help write structured parallel applications will also be introduced: Intel (R) Threading Building Blocks NVIDIA Thrust Prerequisites: Good working knowledge of C++, especially the C++14 standard. Please check with these questions whether your C++ knowlegde fulfills the requirements. Application Registrations are only considered until 1May 2019 due to available space, the maximal number of participants is limited. Applicants will be notified, whether they are accepted for participitation. Instructor: Dr. Sandipan Mohanty, JSC Contact For any questions concerning the course please send an e-mail to s.mohanty@fz-juelich.de https://events.prace-ri.eu/event/824/ 2019-05-27 07:00:00 UTC 2019-05-29 14:30:00 UTC [] [] [] workshops_and_courses [] []
  • Uncertainty quantification @MdlS

    27 - 29 May 2019

    Uncertainty quantification @MdlS https://tess.elixir-europe.org/events/uncertainty-quantification-mdls-8ab27eae-4c4e-457e-bc99-0ccf6ee93b78 Uncertainty in computer simulations, deterministic and probabilistic methods for quantifying uncertainty, OpenTurns software, Uranie software Content Uncertainty quantification takes into account the fact that most inputs to a simulation code are only known imperfectly. It seeks to translate this uncertainty of the data to improve the results of the simulation. This training will introduce the main methods and techniques by which this uncertainty propagation can be handled without resorting to an exhaustive exploration of the data space. HPC plays an important role in the subject, as it provides the computing power made necessary by the large number of simulations needed. The course will present the most important theoretical tools for probability and statistical analysis, and will illustrate the concepts using the OpenTurns software. Course Outline Day 1 - General methodology for handling uncertainty, presentation of a case study - Fundamental notions from probability and statistics - General introduction to the software tools: OpenTurns and Uranie   Day 2 - Statistical estimation: parametric and non-parametric, testing - Modeling with non-numerical data: expert judgement, entropy - Central trend: local and gloal sensitivity indices (design of experiments, sampling, Sobol indices) - computing the probability of rare events, simulation methods, FORM/SORM   Day 3 - Distributed computing: parallel solvers, batch jobs submission on a parallel computer, implementation within OpenTurns / Salome and Uranie - Introduction to meta-model building, least-squares, other response surface, Kriging, neural networks - Introduction to polynomial chaos Learning outcomes Learn to recognize when uncertainty quantification can bring new insight to simulations. Know the main tools and techniques to investigate uncertainty propagation. Gain familiarity with modern tools for actually carrying out the computations in a HPC context. Prerequisites Basic knowledge of probability will be useful, as will a basic familiarity with Linux. https://events.prace-ri.eu/event/815/ 2019-05-27 07:30:00 UTC 2019-05-29 15:00:00 UTC [] [] [] workshops_and_courses [] []
  • Use of Nextflow tool for toxicogenomics-based prediction and mechanism identification in OpenRiskNet e-infrastructure

    27 May 2019

    Use of Nextflow tool for toxicogenomics-based prediction and mechanism identification in OpenRiskNet e-infrastructure https://tess.elixir-europe.org/events/use-of-nextflow-tool-for-toxicogenomics-based-prediction-and-mechanism-identification-in-openrisknet-e-infrastructure Predictive toxicology and risk assessments increasingly rely on Big Data analyses for more informed decision making. Toxicogenomics uses transcriptomic readouts to predict the characteristics of compounds based on the gene-expression profiling of cells in response to exposure. These large genomic analysis place new computational demands on researchers with the handling of datasets, the combining of tools and the reproducible deployment of an analysis presenting significant challenges. This webinar highlights how these challenges can be overcome using the open source workflow management tool Nextflow within the OpenRiskNet e-infrastructure. Using the toxicogenomics example, we will show how a workflow can be created, deployed and shared across Kubernetes-based environments. 2019-05-27 16:00:00 UTC 2019-05-27 17:00:00 UTC OpenRiskNet Toxicology [] [] [] workshops_and_courses first_come_first_served toxicogenomics
  • Metadynminer webinar

    31 May 2019

    Elixir node event
    Metadynminer webinar https://tess.elixir-europe.org/events/metadynminer-webinar **Metadynminer** is an R package for analysis and visualization of metadynamics results. It can load results from Plumed, a popular open-source metadynamics package. We will show basic and advanced options how to use Metadynminer and present plans for a future version. **Agenda:** - 20 min presentation - 10 min discussion 2019-05-31 15:00:00 UTC 2019-05-31 15:30:00 UTC UCT Prague Statistics and probability UCT Prague Mr. Vojtech Spiwok, UCT Prague (Vojtech.Spiwok@vscht.cz) ELIXIR-CZ bioinformaticiansStatistics workshops_and_courses first_come_first_served metadynamics R-programmingWebinar
  • Deep Learning and GPU programming workshop @ LRZ

    3 - 6 June 2019

    Deep Learning and GPU programming workshop @ LRZ https://tess.elixir-europe.org/events/deep-learning-and-gpu-programming-workshop-lrz Overview Learn how to train and deploy a neural network to solve real-world problems, how to generate effective descriptions of content within images and video clips, how to effectively parallelize training of deep neural networks on Multi-GPUs and how to accelerate your applications with CUDA C/C++ and OpenACC. This new 4-days workshop offered for the first time at LRZ combines lectures about fundamentals of Deep Learning for Multiple Data Types and Multi-GPUs with lectures about Accelerated Computing with CUDA C/C++ and OpenACC. The lectures are interleaved with many hands-on sessions using Jupyter Notebooks. The exercises will be done on a fully configured GPU-accelerated workstation in the cloud. The workshop is co-organized by LRZ and NVIDIA Deep Learning Institute (DLI) for the Partnership for Advanced Computing in Europe (PRACE). Since 2012 LRZ as part of GCS is one of currently 10 PRACE Training Centres which serve as European hubs and key drivers of advanced high-quality training for researchers working in the computational sciences. NVIDIA DLI offers hands-on training for developers, data scientists, and researchers looking to solve challenging problems with deep learning.  All instructors are NVIDIA certified University Ambassadors. Agenda 1st day: Fundamentals of Deep Learning for Multiple Data Types This day explores how convolutional and recurrent neural networks can be combined to generate effective descriptions of content within images and video clips. Learn how to train a network using TensorFlow and the Microsoft Common Objects in Context (COCO) dataset to generate captions from images and video by: Implementing deep learning workflows like image segmentation and text generation Comparing and contrasting data types, workflows, and frameworks Combining computer vision and natural language processing Upon completion, you’ll be able to solve deep learning problems that require multiple types of data inputs. 2nd day: Fundamentals of Deep Learning for Multi-GPUs The computational requirements of deep neural networks used to enable AI applications like self-driving cars are enormous. A single training cycle can take weeks on a single GPU or even years for larger datasets like those used in self-driving car research. Using multiple GPUs for deep learning can significantly shorten the time required to train lots of data, making solving complex problems with deep learning feasible. On the 2nd day we will teach you how to use multiple GPUs to train neural networks. You'll learn: Approaches to multi-GPUs training Algorithmic and engineering challenges to large-scale training Key techniques used to overcome the challenges mentioned above Upon completion, you'll be able to effectively parallelize training of deep neural networks using TensorFlow. 3rd day: Fundamentals of Accelerated Computing with CUDA C/C++ The CUDA computing platform enables the acceleration of CPU-only applications to run on the world’s fastest massively parallel GPUs. On the 3rd day you experience C/C++ application acceleration by: Accelerating CPU-only applications to run their latent parallelism on GPUs Utilizing essential CUDA memory management techniques to optimize accelerated applications Exposing accelerated application potential for concurrency and exploiting it with CUDA streams Leveraging command line and visual profiling to guide and check your work Upon completion, you’ll be able to accelerate and optimize existing C/C++ CPU-only applications using the most essential CUDA tools and techniques. You’ll understand an iterative style of CUDA development that will allow you to ship accelerated applications fast. 4th day: Fundamentals of Accelerated Computing with OpenACC On the last day you learn the basics of OpenACC, a high-level programming language for programming on GPUs. Discover how to accelerate the performance of your applications beyond the limits of CPU-only programming with simple pragmas. You’ll learn: How to profile and optimize your CPU-only applications to identify hot spots for acceleration How to use OpenACC directives to GPU accelerate your codebase How to optimize data movement between the CPU and GPU accelerator Upon completion, you'll be ready to use OpenACC to GPU accelerate CPU-only applications. Important information You must bring your own laptop to this workshop! After you are accepted, please create an account under courses.nvidia.com/join . Ensure your laptop will run smoothly by going to http://websocketstest.com/ Make sure that WebSockets work for you by seeing under Environment, WebSockets is supported and Data Receive, Send and Echo Test all check Yes under WebSockets (Port 80).If there are issues with WebSockets, try updating your browser. If you have any questions, please contact Marjut Dieringer at mdieringer"at"nvidia.com.  PRACE Training and Education The mission of PRACE (Partnership for Advanced Computing in Europe) is to enable high-impact scientific discovery and engineering research and development across all disciplines to enhance European competitiveness for the benefit of society.  PRACE has an extensive education and training effort through seasonal schools, workshops and scientific and industrial seminars throughout Europe. Seasonal Schools target broad HPC audiences, whereas workshops are focused on particular technologies, tools or disciplines or research areas. NVIDIA Deep Learning Institute The NVIDIA Deep Learning Institute delivers hands-on training for developers, data scientists, and engineers. The program is designed to help you get started with training, optimizing, and deploying neural networks to solve real-world problems across diverse industries such as self-driving cars, healthcare, online services, and robotics. https://events.prace-ri.eu/event/860/ 2019-06-03 07:00:00 UTC 2019-06-06 15:00:00 UTC [] [] [] workshops_and_courses [] []
  • School on Scientific Data Analytics and Deep Learning @ Cineca

    10 - 14 June 2019

    School on Scientific Data Analytics and Deep Learning @ Cineca https://tess.elixir-europe.org/events/school-on-scientific-data-analytics-and-deep-learning-cineca Description: The increasing amount of scientific data collected through sensors or computational simulations can take advantage of new techniques for being processed in order to extract new insights out of raw data. The purpose of this one-week school is to present researchers and scientists with methods, tools and techniques for exploring and mining, large data sets using Cineca high performance resources. The school is an introductory set of lectures aimed at training beginner participants in the application of relevant statistical, machine and deep learning algorithms to create classification and predictive models using Cineca resources to execute efficient processing jobs. The school will consist of introductory lectures held by data scientists, and hands-on sessions. Skills: At the end of the course, the student will possess and know how to use the following skills: • Use of Cineca HPC resources • Machine Learning algorithms and libraries  • Deep Learning frameworks Target Audience: Young students, PhD, and researchers in computational sciences and scientific areas with different backgrounds, looking for new technologies and methods to process and analyse large amount of data. Prerequisites: Participants must have basic knowledge in statistics, on the fundamentals of computer programming with python and R and in using GNU/Linux-based systems. Grant The lunch for the five days will be offered to all the participants and some grants are available. The only requirement to be eligible is to be not funded by your institution to attend the course and to work or live in an institute outside the Roma area. The grant  will be 300 euros for students working and living outside Italy and 150 euros for students working and living in Italy. Some documentation will be required and the grant will be paid only after a certified presence of minimum 80% of the lectures. Further information about how to request the grant, will be provided at the confirmation of the course: about 3 weeks before the starting date. The number of participants is limited to 20 students. Applicants will be selected according to their experience, qualification and scientific interest BASED ON WHAT WRITTEN IN THE "Reason for participation" FIELD OF THE REGISTRATION FORM.    APPLICATION DEADLINE May 3rd, 2019.  STUDENTS WILL BE NOTIFIED ON THEIR ADMISSION OR NOT WITH AN EMAIL ON MONDAY MAY,13TH.  Attendance is FREE.    https://events.prace-ri.eu/event/832/ 2019-06-10 07:00:00 UTC 2019-06-14 16:00:00 UTC [] [] [] workshops_and_courses [] []
  • Fundamentals of Deep Learning for Computer Vision @ IT4Innovations

    11 June 2019

    Fundamentals of Deep Learning for Computer Vision @ IT4Innovations https://tess.elixir-europe.org/events/fundamentals-of-deep-learning-for-computer-vision-it4innovations Annotation Explore the fundamentals of deep learning by training neural networks and using results to improve performance and capabilities. During this day, you’ll learn the basics of deep learning by training and deploying neural networks. You’ll learn how to: Implement common deep learning workflows, such as image classification and object detection, Experiment with data, training parameters, network structure, and other strategies to increase performance and capability, Deploy your neural networks to start solving real-world problems. Upon completion, you’ll be able to start solving problems on your own with deep learning. NVIDIA Deep Learning Institute (DLI) offers hands-on training for developers, data scientists, and researchers looking to solve challenging problems with deep learning. This workshop contains lectures and hands-on exercises about fundamentals of Deep Learning for Computer Vision, to learn how to train and deploy a neural network to solve real-world problems. The lectures are interleaved with many hands-on sessions using Jupyter Notebooks. The exercises will be done on a fully configured GPU-accelerated workstation in the cloud. This workshop is organized by IT4Innovations which is a certified Nvidia DLI University Ambassador. Target audience and Purpose of the course Anyone interested in basics of deep learning. Upon completion, you’ll be able to start solving problems on your own with deep learning. This course is only offered to academia (see details below in section Capacity and Fees). About the tutor(s) Georg Zitzlsberger is a research specialist for Machine and Deep Learning. He recently received his certification from Nvidia as a University Ambassador of the Nvidia Deep Learning Institute (DLI) program. This certification allows him to offer Nvidia DLI courses to academic users of IT4Innovations' HPC services. NVIDIA Deep Learning Institute The NVIDIA Deep Learning Institute delivers hands-on training for developers, data scientists, and engineers. The program is designed to help you get started with training, optimizing, and deploying neural networks to solve real-world problems across diverse industries such as self-driving cars, healthcare, online services, and robotics. Acknowledgement This course is supported by the PRACE-5IP project – the European Union's Horizon 2020 research and innovation programme under grant agreement No. 730913 – and is sponsored by Nvidia as part of the Nvidia Deep Learning Institute (DLI) University Ambassador program. This work was also supported by The Ministry of Education, Youth and Sports from the Large Infrastructures for Research, Experimental Development and Innovations project ”IT4Innovations National Supercomputing Center – LM2015070”.   https://events.prace-ri.eu/event/878/ 2019-06-11 06:30:00 UTC 2019-06-11 15:15:00 UTC [] [] [] workshops_and_courses [] []
  • Introduction to High-Performance Machine Learning @SURFsara

    11 - 12 June 2019

    Introduction to High-Performance Machine Learning @SURFsara https://tess.elixir-europe.org/events/introduction-to-high-performance-machine-learning-surfsara-202d1ebb-8b23-4dc2-93c9-008a19a832eb In recent years machine learning and deep learning techniques in particular have developed tremendously. Neural networks are being used in more and more application domains going from computer vision to speech recognition, and even replacing parts of the compute pipeline for scientific HPC applications. IMPORTANT INFORMATION: WAITING LIST If the course gets fully booked, no more registrations are accepted through this website. However, you can be included in the waiting list: for that, please send an email to training@surfsara.nl and you'll be informed when a place becomes available. In this course you will start from the essential concepts up to the efficient use of HPC infrastructures to get the best performance out of different machine learning tools. Several hands-on sessions are set up to present general algorithms and some scalability challenges involved in when using both large-scale data and large-scale models. https://events.prace-ri.eu/event/870/ 2019-06-11 07:00:00 UTC 2019-06-12 15:30:00 UTC [] [] [] workshops_and_courses [] []
  • High-performance computing with Python @ JSC

    17 - 19 June 2019

    High-performance computing with Python @ JSC https://tess.elixir-europe.org/events/high-performance-computing-with-python-jsc-c53f1e62-685c-4f81-b928-50588f42c5b8 Python is increasingly used in high-performance computing projects. It can be used either as a high-level interface to existing HPC applications and libraries, as embedded interpreter, or directly. This course combines lectures and hands-on sessions. We will show how Python can be used on parallel architectures and how to optimize critical parts of the kernel using various tools. The following topics will be covered: Interactive parallel programming with IPython Profiling and optimization High-performance NumPy Just-in-time compilation with numba Distributed-memory parallel programming with Python and MPI Bindings to other programming languages and HPC libraries Interfaces to GPUs This course is aimed at scientists who wish to explore the productivity gains made possible by Python for HPC. Prerequisites: Good working knowledge of Python and NumPy Application Registrations are only considered until 15 May 2019 due to available space, the maximal number of participants is limited. Applicants will be notified, whether they are accepted for participitation. Instructors: Dr. Jan Meinke, Dr. Olav Zimmermann, JSC Contact For any questions concerning the course please send an e-mail to j.meinke@fz-juelich.de https://events.prace-ri.eu/event/825/ 2019-06-17 07:00:00 UTC 2019-06-19 14:30:00 UTC [] [] [] workshops_and_courses [] []
  • Parallel Programming with MPI and OpenMP @SURFsara

    17 - 19 June 2019

    Parallel Programming with MPI and OpenMP @SURFsara https://tess.elixir-europe.org/events/parallel-programming-with-mpi-and-openmp-surfsara-eeb96613-54d8-4840-afd9-9523550d25ce This 3-day course is focused on providing an introduction to parallel programming using the most widely used approaches: Message Passing Interface (MPI) and Open Multi-Processing (OpenMP).   As a participant, you have already some familiarity with C or Fortran programming, and the course will take you from the beginners level up to the point of being able to start your own parallel application developments. Each session during the first two and half days includes hands-on exercises to facilitate the understanding of the different constructs.   Do you already have some code that you need to parallelize or would you like to talk to the experts about how to go parallel? Then the last afternoon session you'll be having the support of SURFsara supercomputing advisors to guide you on how to develop your specific parallelization problem. Please bring your own requirements (or even your own code) for discussion and get direct support from the experts! https://events.prace-ri.eu/event/828/ 2019-06-17 07:00:00 UTC 2019-06-19 15:35:00 UTC [] [] [] workshops_and_courses [] []
  • Turbulence and Heat Transfer - Introduction to Code_Saturne @ EPCC at Manchester

    19 - 20 June 2019

    Turbulence and Heat Transfer - Introduction to Code_Saturne @ EPCC at Manchester https://tess.elixir-europe.org/events/introduction-to-code_saturne-epcc-at-manchester Turbulence and heat transfer applied to HPC-related civil nuclear phenomena. Introduction to Code_Saturne Electricity generation is fundamentally a thermodynamic process. In a nuclear power plant, the prediction of fluid flow and heat transfer is of vital importance for the plant performance and for safety compliance. This course will focus on the use of Computational Fluid Dynamics (CFD) for the prediction of fluid flow and heat transfer, including turbulence modelling, near wall modelling and conjugate heat transfer. The course will run for 2 days being a mixture of lectures and tutorials for nuclear internal flows. The open-source HPC software Code_Saturne will be used by the participants to run large scale simulations using the UK national facility ARCHER. This course is organised by the University of Manchester, University of Sheffield, EDF Energy and STFC Daresbury Laboratory, and has the support of the UKFN SIG - Nuclear Thermal Hydraulics. Timetable Wednesday 19th of June 2019 09:00 Registration 09:30 RANS Modelling of turbulent flows 10:25: Near wall turbulence 11:20 Coffee break 11:35 Turbulent heat transfer modelling and applications 12:30 Lunch 13:30 Introduction to Code_Saturne 14:00 Tutorial: Laminar tube bundles using the GUI 15:30 HPC presentation and introduction to ARCHER 16:00 Tutorial: LES of tube bundles 17:30 End of day Thursday 20th of June 2019 09:00 Tutorial: Post processing of LES results 09:30 Use of subroutines in Code_Saturne 10:00 Tutorial: LES of tube bundles using subroutines 11:00 Coffee break 11:15 Tutorial: adding heat transfer 12:30 Lunch 13:30 LES/DNS and hybrid methods 14:20 Best practice guidelines and errors in CFD 15:00 Coffee break 15:15 Novel methods: Coarse CFD for nuclear applications 16:00 End of day and course Location The course will be held at University of Manchester; rooming available soon. Interactive map.     https://events.prace-ri.eu/event/865/ 2019-06-19 08:00:00 UTC 2019-06-20 16:30:00 UTC [] [] [] workshops_and_courses [] []
  • 33rd VI-HPS Tuning Workshop @ JSC

    24 - 28 June 2019

    33rd VI-HPS Tuning Workshop @ JSC https://tess.elixir-europe.org/events/vi-hps-tuning-workshop-jsc This workshop organized by VI-HPS and JSC as a PRACE training event will: give an overview of the VI-HPS programming tools suite explain the functionality of individual tools, and how to use them effectively offer hands-on experience and expert assistance using the tools The detailed program will be available on the VI-HPS training web site. Presentations and hands-on sessions are planned on the following topics Setting up, welcome and introduction Score-P instrumentation and measurement Scalasca automated trace analysis TAU performance system Vampir interactive trace analysis Extra-P automated performance modeling Paraver/Extrae/Dimemas trace analysis and performance prediction MAQAO performance analysis & optimisation MUST runtime error detection for MPI ARCHER runtime error detection for OpenMP JUBE script-based workflow execution environment ... and potentially others to be added A brief overview of the capabilities of these and associated tools is provided in the VI-HPS Tools Guide. Prerequisites: Experience with MPI or OpenMP Application Registrations are only considered until 31 May 2019 due to available space, the maximal number of participants is limited. Applicants will be notified, whether they are accepted for participitation. Instructors: JSC staff members, members of the VI-HPS collaboration Contact For any questions concerning the course please send an e-mail to b.wylie@fz-juelich.de https://events.prace-ri.eu/event/827/ 2019-06-24 07:00:00 UTC 2019-06-28 14:30:00 UTC [] [] [] workshops_and_courses [] []
  • Introduction to PETSc @ MdlS/Idris

    24 - 25 June 2019

    Introduction to PETSc @ MdlS/Idris https://tess.elixir-europe.org/events/introduction-to-petsc-mdls-idris-ceefc072-008e-4229-9801-0874bcd22d31 The Portable, Extensible Toolkit for Scientific Computation (PETSc) is a suite of data structures and routines for the scalable (parallel) solution of scientific applications modeled by partial differential equations (www.mcs.anl.gov/petsc/). It enables researchers to delegate the linear algebra part of their applications to a specialized team, and to test various solution methods. The course will provide the necessary basis to get started with PETSc and give an overview of its possibilities. Presentations will alternate with hands-on sessions (in C or Fortran). Learning outcomes : On completion of this course, the participant should - Be able to build and solve simple PDE examples - Use and compare different solvers on these examples - Be familiar with using the on-line documentation - Be able to easily explore other PETsc possibilities relevant to his/her application. Prerequisites : C or Fortran programming. Notions of linear algebra, as well as notions of MPI, would be an asset. https://events.prace-ri.eu/event/816/ 2019-06-24 07:30:00 UTC 2019-06-25 15:00:00 UTC [] [] [] workshops_and_courses [] []
  • Advanced OpenMP @ EPCC at University of Manchester 25-27 June 2019

    25 - 27 June 2019

    Advanced OpenMP @ EPCC at University of Manchester 25-27 June 2019 https://tess.elixir-europe.org/events/advanced-openmp-epcc-at-university-of-manchester-25-27-june-2019 OpenMP is the industry standard for shared-memory programming, which enables serial programs to be parallelised using compiler directives.This course is aimed at programmers seeking to deepen their understanding of OpenMP and explore some of its more recent and advanced features. This 3-day course will cover topics including nested parallelism, OpenMP tasks, the OpenMP memory model, performance tuning, hybrid OpenMP + MPI, OpenMP implementations, and new features in OpenMP 4.0/4.5. Hands-on practical programming exercises make up a significant, and integral, part of this course. Attendees should be familiar with the basics of OpenMP, including parallel regions, data scoping, work sharing directives and synchronisation constructs. Access will be given to appropriate hardware for all the exercises, although many of them can also be performed on a standard Linux laptop.   Pre-course setup All attendees should bring their own wireless-enabled laptop set up with the standard software as detailed on our site http://www.archer.ac.uk/training/courses/software.php. The course tutor will be able to assist with settings to connect on the day. Practical exercises will be done using a guest account on ARCHER. . You should also have a web browser, a pdf reader and a simple text editor.   Timetable Day 1 09:00 - 11:00  Lectures: OpenMP basics: Parallel regions, Worksharing, Synchronisation 11:00 - 11:30  Coffee 11:30 - 13:00  Practical: Parallel regions 13:00 - 14:00  Lunch 14:00 - 15:30  Lectures: Multicore and multithreaded CPUs, Caches, Cache coherency, NUMA 15:30 - 16:00  Tea 16:00 - 17:00  Practicals: Streams, Coherency Day 2 09:00 - 11:00  Lectures: Tasks, Nested parallelism, Memory model 11:00 - 11:30  Coffee 11:30 - 13:00  Practicals: Mandelbrot with nested loops, collapse, and tasks 13:00 - 14:00  Lunch 14:00 - 15:30  Lectures: OpenMP + MPI 15:30 - 16:00  Tea 16:00 - 17:00  Practicals: OpenMP + MPI Day 3 09:00 - 11:00  Lectures: OpenMP tips, tricks and pitfalls, Performance issues 11:00 - 11:30  Coffee 11:30 - 13:00  Practicals: MD tuning 13:00 - 14:00  Lunch 14:00 - 15:30  OpenMP 4.0/4.5 features, alternative APIs 15:30 - 16:00  Tea 16:00 - 17:00  Consultancy session: bring your own code! Course Materials http://www.archer.ac.uk/training/course-material/2019/06/AdvOpenMP-manch/index.php    Location https://www.manchester.ac.uk/discover/maps/interactive-map/?id=1 https://events.prace-ri.eu/event/875/ 2019-06-25 08:00:00 UTC 2019-06-27 16:30:00 UTC [] [] [] workshops_and_courses [] []
  • Node-Level Performance Engineering @ HLRS

    27 - 28 June 2019

    Node-Level Performance Engineering @ HLRS https://tess.elixir-europe.org/events/node-level-performance-engineering-hlrs-9fa9fd8a-10c4-41bc-afab-5697ace21b4d Overview This course teaches performance engineering approaches on the compute node level. "Performance engineering" as we define it is more than employing tools to identify hotspots and bottlenecks. It is about developing a thorough understanding of the interactions between software and hardware. This process must start at the core, socket, and node level, where the code gets executed that does the actual computational work. Once the architectural requirements of a code are understood and correlated with performance measurements, the potential benefit of optimizations can often be predicted. We introduce a "holistic" node-level performance engineering strategy, apply it to different algorithms from computational science, and also show how an awareness of the performance features of an application may lead to notable reductions in power consumption.This course provides scientific training in Computational Science, and in addition, the scientific exchange of the participants among themselves. For further information and registration please visit the HLRS course page. https://events.prace-ri.eu/event/842/ 2019-06-27 07:00:00 UTC 2019-06-28 15:00:00 UTC [] [] [] workshops_and_courses [] []
  • Efficient Parallel Programming with GASPI @ HLRS

    1 - 2 July 2019

    Efficient Parallel Programming with GASPI @ HLRS https://tess.elixir-europe.org/events/concepts-of-gaspi-and-interoperability-with-other-communication-apis-hlrs Overview In this tutorial we present an asynchronous data flow programming model for Partitioned Global Address Spaces (PGAS) as an alternative to the programming model of MPI. GASPI, which stands for Global Address Space Programming Interface, is a partitioned global address space (PGAS) API. The GASPI API is designed as a C/C++/Fortran library and focused on three key objectives: scalability, flexibility and fault tolerance. In order to achieve its much improved scaling behaviour GASPI aims at asynchronous dataflow with remote completion, rather than bulk-synchronous message exchanges. GASPI follows a single/multiple program multiple data (SPMD/MPMD) approach and offers a small, yet powerful API (see also http://www.gaspi.de and http://www.gpi-site.com). GASPI is successfully used in academic and industrial simulation applications. Hands-on sessions (in C and Fortran) will allow users to immediately test and understand the basic constructs of GASPI. This course provides scientific training in Computational Science, and in addition, the scientific exchange of the participants among themselves. For further information and registration please visit the HLRS course page. https://events.prace-ri.eu/event/810/ 2019-07-01 07:00:00 UTC 2019-07-02 13:30:00 UTC [] [] [] workshops_and_courses [] []
  • Genome assembly and annotation course 5

    1 - 5 July 2019

    Milan, Italy

    Elixir node event
    Genome assembly and annotation course 5 https://tess.elixir-europe.org/events/genome-assembly-and-annotation-course-5 A **genome assembly and annotation course** will take place on **July 1-5, 2019** in **Milan, Italy**, hosted by the Italian ELIXIR Node in cooperation with other ELIXIR nodes that are involved in the ELIXIR-EXCELERATE task 10.3 “Capacity Building in Genome Assembly and Annotation”. Some of the most experienced assembly and annotation experts in Europe will be teaching at the course. The course is aimed at researchers interested in learning more about genome assembly and annotation. It will include information useful for both the beginner and the more advanced user. We will start by introducing general concepts and then continue with a step-by-step description of all major components of a genome assembly and annotation workflow, from raw data all the way to a final assembled and annotated genome. There will be a mix of lectures and hands-on practical exercises using Unix/Linux command line. After the course, the participants will have knowledge of commonly used assembly practices and tools. They will be able to run assembly and annotation projects on their own. **Prerequisites:** - **Working knowledge of Unix/Linux command line** - **As part of the course agenda, course participants will prepare a short presentation about their own projects.** Optionally, they may also bring their own data. **Instructions how to register for the course are available on the [ELIXIR-SI eLearning Platform (EELP)](https://elixir.mf.uni-lj.si/course/view.php?id=45).** You will be able to access the course after you register and your registration is approved by the course organizers. 2019-07-01 09:00:00 UTC 2019-07-05 17:00:00 UTC ELIXIR Italy University of Milano-Bicocca, Building U7, Lab 715, Milan, Italy University of Milano-Bicocca, Building U7, Lab 715 Milan Città Metropolitana di Milano Italy Genomics University of Milano-Bicocca, Italy General questions: gianluca.dellavedova@unimib.it Questions about the course agenda: henrik.lantz@nbis.se National Research Council of ItalyINRANBIS - National Bioinformatics Infrastructure SwedenELIXIR EXCELERATE life scientistsResearchersPhD students 24 workshops_and_courses registration_of_interest Genomics AssemblyTrainingeLearningEeLP
  • Introduction to GPU programming with OpenACC and OpenMP @ MdlS/Idris

    2 July 2019

    Introduction to GPU programming with OpenACC and OpenMP @ MdlS/Idris https://tess.elixir-europe.org/events/introduction-to-gpu-programming-with-openacc-and-openmp-mdls-idris As the use of GPUs in HPC is spreading fast, several models are now available to programmers. During the tutorial we will introduce the directive-based approach to GPU programming. While being quite simple to implement, it allows to reach performance similar to lower level paradigms. We will present the basic concepts of OpenACC and OpenMP-target models through several examples and hands-on sessions. The main pitfalls and good practice will be presented. We will also give some insights of the tools available to assess the performance. Learning Outcomes : - Ability to execute a piece of code on a GPU using OpenACC or OpenMP-target - Assessment of the performance of the code Requirements : Basic knowledge of Fortran and/or C and/or C++ No prior knowledge of OpenACC or OpenMP is required https://events.prace-ri.eu/event/884/ 2019-07-02 07:30:00 UTC 2019-07-02 16:00:00 UTC [] [] [] workshops_and_courses [] []
  • Introduction to Parallel Programming with HPX @ HLRS

    4 - 5 July 2019

    Introduction to Parallel Programming with HPX @ HLRS https://tess.elixir-europe.org/events/introduction-to-parallel-programming-with-hpx-hlrs Overview The aim of this course is to introduce participants to the HPX library (https://github.com/STEllAR-GROUP/hpx and http://stellar-group.org/) and demonstrate how it can be used to write task based programs. The HPX library implements a lightweight threading model that allows both concurrent, asynchronous, parallel and distributed programming constructs to coexist within the same application with a consistent API based on C++ standards and using futures to synchronize between tasks. The course is aimed at participants with a good understanding of C++. The material covered will include an introduction to the HPX programming model; asynchronous programming concepts, execution policies and executors; parallel algorithms using tasks (including the parallel STL); writing distributed applications with HPX; profiling and debugging and a final section introducing heterogeneous programming using targets for GPU devices. Objective: The attendee will gain an understanding of the HPX library and task based programming in general For further information and registration please visit the HLRS course page. https://events.prace-ri.eu/event/877/ 2019-07-04 07:00:00 UTC 2019-07-05 13:30:00 UTC [] [] [] workshops_and_courses [] []
  • Practical Software Development @ EPCC at Leeds 10-11 July 2019

    10 - 11 July 2019

    Practical Software Development @ EPCC at Leeds 10-11 July 2019 https://tess.elixir-europe.org/events/practical-software-development-epcc-at-leeds-10-11-july-2019 ARCHER, the UK's national supercomputing service, offers training in software development and high-performance computing to scientists and researchers across the UK. As part of our training service we will be running a 2 day ‘Practical Software Development’ training session. Writing code is just part of developing effective software - how do you get the best from working with others as part of a software team, incorporating existing work into your own, contributing back and producing code and software suites for others? Details Software development comprises a range of activities including writing code, requirements analysis, testing and product evaluation. This course introduces how software development projects can be approached to achieve high-quality software products. Introducing important ideas for both academic and industrial development such software sustainability, testing, adapting processes and communications. The course will introduce practical skills important for use in developing software for research and industrial purposes. Timetable Day 1: 0900 - 0930 : Welcome/Intro 0930 - 1100 : Structured Development 1110 - 1230 : Design Issues and Requirements 1230 - 1330 : Lunch 1330 - 1500 : Planning and Risks 1500 - 1530 : Coffee 1530 - 1700 : Prototyping and Usability   Day 2: 0900 - 0930 : Recap 0930 - 1100 : Testing 1110 - 1230 : Code Work: Analysis and Re-engineering 1230 - 1330 : Lunch 1330 - 1400 : Code Work Cont. 1400 - 1500 : Looking back and Learning 1500 - 1530 : Coffee 1530 - 1700 : Issues affecting Software Development This course is free to all academics. Intended learning outcomes On completion of this course students should be able to: Assess and articulate issues with design and code Evaluate and propose risk management for a project Estimate and justify a schedule for a project Create a testing process and articulate the reasoning for the types of tests Evaluate and critique a software project Structure The course will be delivered over two days in person. The course will interleave practical exercises, including teamwork, with short lectures and discussions. Pre-requisites There are no strict pre-requisites for this course, though familiarity with a programming language and concepts will be beneficial. Course Materials Course materials page https://events.prace-ri.eu/event/879/ 2019-07-10 08:00:00 UTC 2019-07-11 16:30:00 UTC [] [] [] workshops_and_courses [] []
  • Message-passing Programming with MPI @ EPCC

    17 - 19 July 2019

    Message-passing Programming with MPI @ EPCC https://tess.elixir-europe.org/events/message-passing-programming-with-mpi-epcc-006600da-45d1-4a1c-a1ef-455bc049d591 The world’s largest supercomputers are used almost exclusively to run applications which are parallelised using Message Passing. The course covers all the basic knowledge required to write parallel programs using this programming model, and is directly applicable to almost every parallel computer architecture. Parallel programming by definition involves co-operation between processes to solve a common task. The programmer has to define the tasks that will be executed by the processors, and also how these tasks are to synchronise and exchange data with one another. In the message-passing model the tasks are separate processes that communicate and synchronise by explicitly sending each other messages. All these parallel operations are performed via calls to some message-passing interface that is entirely responsible for interfacing with the physical communication network linking the actual processors together. This course uses the de facto standard for message passing, the Message Passing Interface (MPI). It covers point-to-point communication, non-blocking operations, derived datatypes, virtual topologies, collective communication and general design issues. The course is normally delivered in an intensive three-day format using EPCC’s dedicated training facilities. It is taught using a variety of methods including formal lectures, practical exercises, programming examples and informal tutorial discussions. This enables lecture material to be supported by the tutored practical sessions in order to reinforce the key concepts. If you are not already familiar with basic Linux commands,logging on to a remote machine using ssh and compiling and running a program on a remote machine then we would strongly encourage you to also attend the Hands-on Introduction to HPC course running immediately prior to this course. This course is free to all academics.  Intended Learning Outcomes On completion of this course students should be able to: Understand the message-passing model in detail. Implement standard message-passing algorithms in MPI. Debug simple MPI codes. Measure and comment on the performance of MPI codes. Design and implement efficient parallel programs to solve regular-grid problems. Pre-requisite Programming Languages: Fortran, C or C++. It is not possible to do the exercises in Java. Pre-requisite setup Attendees should bring their own laptop (Windows/Mac/Linux) and will need the required software installed:   Timetable Day 1 09:30  Message-Passing Concepts 10:15  Practical: Parallel Traffic Modelling 11:00  Break 11:30  MPI Programs 12:00  MPI on ARCHER 12:15  Practical: Hello World 13:00  Lunch 14:00  Point-to-Point Communication 14:30  Practical: Pi 15:30  Break 16:00  Communicators, Tags and Modes 16:45 Practical: Ping-Pong 17:30  Finish Day 2 09:30  Non-Blocking Communication 10:00  Practical: Message Round a Ring 11:00  Break 11:30  Collective Communicaton 12:00  Practical: Collective Communication 13:00  Lunch 14:00  Virtual Topologies 14:30  Practical: Message Round a Ring (cont.) 15:30  Break 16:00  Derived Data Types 16:45  Practical: Message Round a Ring (cont.) 17:30  Finish Day 3 09:30  Introduction to the Case Study 10:00  Practical: Case Study 11:00  Break 11:30  Practical: Case Study (cont.) 13:00  Lunch 14:00  Designing MPI Programs 15:00 Individual Consultancy Session 15:30  Finish Lunch and refreshments will NOT be provided but there are places locally where these can be purchased. Slides and Exercise materials will be available shortly. https://events.prace-ri.eu/event/864/ 2019-07-17 08:00:00 UTC 2019-07-19 16:30:00 UTC [] [] [] workshops_and_courses [] []
  • Advanced MPI @ EPCC at Oxford 22-23 Jul 2019

    22 - 23 July 2019

    Advanced MPI @ EPCC at Oxford 22-23 Jul 2019 https://tess.elixir-europe.org/events/advanced-mpi-epcc-at-oxford-22-23-jul-2019 Advanced MPI ARCHER, the UK's national supercomputing service, offers training in software development and high-performance computing to scientists and researchers across the UK. As part of our training service we will be running a 2-day Advanced MPI training session. Trainer David Henty David teaches on a wide range of EPCC's technical training courses, including MPI and OpenMP, and is overall course organiser for EPCC's MSc in High Performance Computing. Details This course is aimed at programmers seeking to deepen their understanding of MPI and explore some of its more recent and advanced features. We cover topics including communicator management, non-blocking and neighbourhood collectives, single-sided MPI and the new MPI memory model. We also look at performance aspects such as which MPI routines to use for scalability, overlapping communication and calculation and MPI internal implementation issues. Intended learning outcomes Understanding of how internal MPI implementation details affect performance Familiarity with neighbourhood collective operations in MPI Knowledge of MPI memory models for RMA operations Familiarity with MPI RMA operations and single-sided communication Understanding of best practice for MPI+OpenMP programming Pre-requisites Attendees should be familiar with MPI programming in C, C++ or Fortran, e.g. have attended the ARCHER MPI course. Pre-course setup All attendees should bring their own wireless-enabled laptop set up with the required software. Practical exercises will be done using a guest account on ARCHER. Draft Timetable (May be subject to change) All sessions will include hands-on practical exercises in addition to lectures material. Day 1: 30th July 09:00 - 09:30 Registration 09:30 - 10:00 Account setup 10:00 - 10:30 MPI Quiz 10:30 - 11:00 MPI Internals 11:00 - 11:30 Coffee 11:30 - 13:00 MPI Tools 13:00 - 14:00 Lunch 14:00 - 15:30 MPI Optimisations 15:30 - 16:00 Coffee 16:00 - 17:30 Advanced Collectives 17:30 CLOSE Day 2: 30st July 09:30 - 11:00 MPI + OpenMP (i) 11:00 - 11:30 Coffee 11:30 - 13:00 MPI + OpenMP (ii) 13:00 - 14:00 Lunch 14:00 - 15:30 New MPI shared-memory model 15:30 - 16:00 Coffee 16:00 - 17:00 Individual consultancy session 17:00 CLOSE Course Materials Slides and exercise material for this course will be available soon. https://events.prace-ri.eu/event/880/ 2019-07-22 08:00:00 UTC 2019-07-23 16:00:00 UTC [] [] [] workshops_and_courses [] []
  • Single Node Performance Optimisation @ EPCC at Imperial 30-31 July 2019

    30 - 31 July 2019

    Single Node Performance Optimisation @ EPCC at Imperial 30-31 July 2019 https://tess.elixir-europe.org/events/single-node-performance-optimisation-epcc-at-imperial-30-31-july-2019 This course covers techniques for improving the performance of applications on ARCHER by optimising of the code that runs within each node. Familiarity with a Unix or Linux environment is assumed. The course is open to all, but is mainly targeted at existing ARCHER users. Details Details: Modern HPC systems are being constructed using increasingly powerful nodes, with larger and larger numbers of cores and enhanced vector capabilities. To extract maximum performance from applications, it is therefore necessary to understand, and be able to overcome, on-node performance bottlenecks. This course will cover the main features of modern HPC nodes, including multiple cores, vector floating point units, deep cache hierarchies, and NUMA memory systems. We will cover techniques for efficient programming of these features, using batch processing options and compiler options as well as hand tuning of code. The course will also contain an introduction to the use of Cray performance analysis tools. Intended learning outcomes On completing this course, attendees should : Have an understanding of modern HPC node architectures and their implications for performance. Be equipped with a toolbox of techniques for extracting good single node performance from application codes. Have a basic knowledge of using Cray performance analysis tools. Prerequisites Programming Languages: Fortran, C or C++. Familiarity with a Unix or Linux environment is assumed. Timetable Day 1 09:00 Registration 09:30 Node Architecture, Profiling 11:00 BREAK 11:30 Practical: profiling 12:30 LUNCH 13:30 Optimising with the compiler 15:00 BREAK 15:30 Practical: optimisation 17:00 CLOSE Day 2 09:30 Vectorisation, Memory Hierarchy Optimisation 11:00 BREAK 11:30 Practical: memory and cache blocking 12:30 LUNCH 13:30 Hybrid Program Optimisation 15:00 BREAK 15:30 Practical: OpenMP optimisation 16:30 CLOSE Course materials :  http://www.archer.ac.uk/training/course-material/2019/07/sgl-node-imp/index.php Location : http://www.archer.ac.uk/training/locations/imperial.php https://events.prace-ri.eu/event/881/ 2019-07-30 08:00:00 UTC 2019-07-31 16:30:00 UTC [] [] [] workshops_and_courses [] []
Note, this map only displays events that have geolocation information in TeSS.
For the complete list of events in TeSS, click the grid tab.