Menu ▼
  • Upcoming Events 2015

Lectures:

lectures_overview
***Please note that this are tentative dates.

Introduction to Beagle-2 lectures

  • Outline: This introductory class is mainly intended for people who have just started working on the Cray XE6 Beagle-2 or are considering using it. It aims at familiarizing new users with the hardware and software architecture (e.g., compilation, submission). Cray’s performance analysis tools will briefly be introduced as well. We plan to include small practical exercises about compilation, data transfer and submission of jobs. Users are strongly invited to ask specific questions about how to port their specific calculations to Beagle2 and how to submit jobs.
  • Topics will include:
    • What is the Computation Institute and what it is going to do for Beagle-2 users. Role of CRI.
    • Hardware details (first lecture focusing on differences with Beagle, e.g. GPUs)
    • The work environment
    • Data transfers
    • Job submission & monitoring
  • Parallel scripting lectures

  • Topics will include:
    • Why we need to pack jobs on Beagle: data location hierarchies and types of parallel problems
    • How to write pbs/bash scripts that run many applications sequentially: Megaseq
    • How to write swift scripts that run many applications sequentially and in parallel : SwiftSeq
    • Quick introduction to Hadoop (do we have it?)
    • Hands on user problem solution (if there are any)
  • HPC on Beagle: CPUs and GPUs

    • Beagle hardware in more detail
    • HPC and parallel processing: data location hierarchies and movement
    • HPC problems on Beagle:
    • °Embarrassing parallel tasks (see parallel scripting lecture): bash or Swift

      °Threaded applications: OpenMP

      °GPU applications: options

      °Large scale distributed applications: MPI

      °Mixed applications

    • Compilers, how to use them basic options
    • Parallel debugger
    • Parallel profiler
    • Hands on user problem solution (if there are any)

    HPC Python lecture

  • Topics will include:
    • Get a better grasp of Numpy, Cython, MPI for Python, and profilers
    • Learn how Python abstracts the underlying computer architecture
    • Use profiling to find bottlenecks in CPU time and memory usage
    • Write efficient programs by choosing appropriate data structures
    • Speed up matrix and vector computations
    • Use tools to compile Python down to machine code
    • Manage multiple I/O and computational operations concurrently
    • Convert multiprocessing code to run on a local or remote cluster
    • Solve large problems while using less RAM
  • Upcoming Events 2013
Python for High Performance Computing

Wednesday, December 4th, 2013, 10AM

  • Trainer: The catalyst group from the Computation Institute
  • Outline: This introductory class is mainly intended for people who already know Python, basics of NumPY, SciPy and Matplotlib and would like to hear a few useful tips on efficient use Python on Beagle.
  • Topics will include:
    • Techniques for improving Python performance
    • Overview of MPI4PY, NumPy, Scipy, Matplotlib
    • Python & packing jobs
    • Python & multiprocessing
    • Python & MPI
  • To learn more about Python on Beagle
  • Time requirements: two hours.
  • When: on Wednesday, December 4th, 10AM
  • Where: Room 240A at the Computation Institute of the University of Chicago. 5735 South Ellis Avenue (Searle Chemistry Laboratory).
  • Requirements: Open to every Beagle user and people interested into becoming users; users need to have access to Beagle and should bring their laptop to do the exercises and to read the slides that will be distributed electronically to the users that RSVP.

RSVP is required. If you would like to attend, send a message to beagle-support@ci.uchicago.edu, preferably with the following subject line: Python on Beagle, December 4 @ Searle. Please include the name(s) of attendee(s).

Introduction to Beagle presentation

Thursday, November 21st, 2013, 10AM

  • Trainer: The catalyst group from the Computation Institute
  • Outline: This introductory class is mainly intended for people who have just started working on the Cray XE6 Beagle or are considering using it. It aims at familiarizing new users with the hardware and software architecture (e.g., compilation, submission). Cray’s performance analysis tools will briefly be introduced as well. We plan to include small practical exercises about compilation, data transfer and submission of jobs. Users are strongly invited to ask specific questions about how to port their specific calculations to Beagle and how to submit jobs.
  • Topics will include (depending upon users desires and abilities):
    • General overview of Beagle’s team and the computational institute
    • overview of Beagle’s Cray XE6 system architecture
    • basic access and navigation operations
    • using compilers and applications
    • appropriate use of local and network filesystems
    • submitting jobs and monitoring jobs
    • data transfer
    • Specific topics requested by users (e.g., using R or Matlab on Beagle)
  • Time requirements: one hour and fifteen minutes (lecture) 45 minutes (questions).
  • When: on Thursday, November 21st, 10AM
  • Where: Room 240A at the Computation Institute of the University of Chicago. 5735 South Ellis Avenue (Searle Chemistry Laboratory).
  • Requirements: Open to every Beagle user and people interested into becoming users; users need to have access to Beagle and should bring their laptop to do the exercises and to read the slides that will be distributed electronically to the users that RSVP.

RSVP is required. If you would like to attend, send a message to beagle-support@ci.uchicago.edu, preferably with the following subject line: Introduction to Beagle presentation, November 21 @ Searle. Please include the name(s) of attendee(s).

Introduction to Beagle presentation

Tuesday, May 28th,2013 from 2 PM to 4 PM

  • Trainer: The catalyst group from the Computation Institute
  • Outline: This introductory class is mainly intended for people who have just started working on the Cray XE6 Beagle or are considering using it. It aims at familiarizing new users with the hardware and software architecture (e.g., compilation, submission). Cray’s performance analysis tools will briefly be introduced as well. We plan to include small practical exercises about compilation, data transfer and submission of jobs. Users are strongly invited to ask specific questions about how to port their specific calculations to Beagle and how to submit jobs.
  • Topics will include (depending upon users desires and abilities):
    • General overview of Beagle’s team and the computational institute
    • overview of Beagle’s Cray XE6 system architecture
    • basic access and navigation operations
    • using compilers and applications
    • appropriate use of local and network filesystems
    • submitting jobs and monitoring jobs
    • data transfer
    • Specific topics requested by users (e.g., using R or Matlab on Beagle)
  • Time requirements: one hour and fifteen minutes (lecture) 45 minutes (questions).
  • When: on Tuesday, May 28th, from 2 PM to 4 PM
  • Where: Room 240A at the Computation Institute of the University of Chicago. 5735 South Ellis Avenue (Searle Chemistry Laboratory).
  • Requirements: Open to every Beagle user and people interested into becoming users; users need to have access to Beagle and should bring their laptop to do the exercises and to read the slides that will be distributed electronically to the users that RSVP.

RSVP is required. If you would like to attend, send a message to beagle-support@ci.uchicago.edu, preferably with the following subject line: Introduction to Beagle presentation, May 28 @ Searle. Please include the name(s) of attendee(s).

Day of the Beagle Symposium

“Scientific Discovery on the Computation Institute/BSD Cray ‘Beagle’ Supercomputer”

April 23, 2013
8:30 AM – 5:00 PM
Searle 240, University of Chicago

RVSP by April 17, 2013
ninfa@ci.uchicago.edu

Description:
For Charles Darwin, the HMS Beagle was the ship for the historic voyage in 1831 that inspired his later work on the origin of species. For the University of Chicago, “Beagle” is an 18,000-core Cray XE6 supercomputer that is one of the most powerful supercomputers dedicated to biomedical research. Since its launch in early 2011, Beagle has supported over 80 research projects, more than 300 users and has resulted in over 30 publications. On April 23rd, a “Day of the Beagle” symposium will discuss the innovative research made possible to date by Beagle, with speakers representing the fields of genomics, neurobiology, molecular biology and medicine.

Day of the Beagle Symposium Poster

Day of the Beagle Symposium schedule:

8:30 – 9:00 Continental breakfast

9:00 – 9:30 Ian Foster & Conrad Gilliam
Overview of the Cray Beagle and Diversity of Science on Beagle

9:30 – 10:15 Kazutaka Takahashi & Nicholas Hatsopoulos (PI)
Computation and analysis of time varying large-scale networks of spiking neurons in primary motor cortex using massively-parallel supercomputers

10:15 – 10:30 Coffee Break

10:30 – 11:15 Yves Lussier (PI) & Haiquan Li
Intergenic DNA’s role in complex disease unveiled by supercomputer-obligated analyses of BIG data

11:15 – 12:00 Greg Tietjen & Ka Yee Lee (PI)
Elucidating the molecular details of phosphatidylserine membrane recognition in immune response

12:00 – 13:00 Lunch

12:45 – 13:00 Esmael Jafari Haddadian
Using Beagle in an actual undergraduate biology course

13:00 – 13:45 Benoit Roux (PI)
Theoretical studies of biomolecular systems on Beagle: highly-scalable computational strategies

13:45 – 14:30 Edwin Munro (PI), TaeYoon Kim
Using agent-based models and supercomputing to probe self-organized contractility and stress dissipation in active cytoskeletal networks

14:30 – 14:45 Coffee Break

14:45 – 15:30 Jason J. Pitt, Chai Bandlamudi & Kevin White (PI)
Genome sequence analysis workflows

15:30 – 16:15 Elizabeth McNally (PI), Megan Puckelwartz & Lorenzo Pesce
Supercomputing for the parallelization of whole genome sequence analysis

16:15 – 16:45 Carlos Sosa (Cray)
Cray Supercomputers – Life Sciences

16:45 – 17:00 Ian Foster – Closing Remarks & Future Directions

  • Past Events

Supercomputing in Plain English: Spring 2013

A High Performance Computing Workshop Series:
High Throughput Computing
March 26th, from 2 pm to 3:30 pm CT
room 236, Searle building

Supercomputing in Plain English: Spring 2013

A High Performance Computing Workshop Series:
High Throughput Computing
March 26th, from 2 pm to 3:30 pm CT
room 236, Searle building

Supercomputing in Plain English: Spring 2013

A High Performance Computing Workshop Series:
Multicore Madeness
March 12th, from 2 pm to 3:30 pm CT
room 236, Searle building

Supercomputing in Plain English: Spring 2013

A High Performance Computing Workshop Series:
Applications and Types of Parallelism
March 5th, from 2 pm to 3:30 pm CT
room 236, Searle building

Supercomputing in Plain English: Spring 2013

A High Performance Computing Workshop Series:
Distributed Multiprocessing
February 26th, from 2 pm to 3:30 pm CT
room 236, Searle building

Supercomputing in Plain English: Spring 2013

A High Performance Computing Workshop Series:
Shared Memory Multithreading
February 19th, from 2 pm to 3:30 pm CT
room 236, Searle building

Supercomputing in Plain English: Spring 2013

A High Performance Computing Workshop Series:
Stupid Compiler Tricks
February 12th, from 2 pm to 3:30 pm CT
room 236, Searle building

Supercomputing in Plain English: Spring 2013

A High Performance Computing Workshop Series:
Instruction Level Parallelism
February 5th, from 2 pm to 3:30 pm CT
room 236, Searle building

Supercomputing in Plain English: Spring 2013

A High Performance Computing Workshop Series:
The Tyranny of the Storage Hierarchy
January 29th, from 2 pm to 4 pm CT
room 236, Searle building

SWIFT Intro

February 20th, 2013 from 1 pm to 3 pm
room 240A, Searle building

Supercomputing in Plain English: Spring 2013

A High Performance Computing Workshop Series starts on:
January 22nd, from 2 pm to 4 pm. CT (4:00pm Atlantic, 3:00pm Eastern, 1:00pm Mountain, 12:00noon Pacific)

For FREE registration:
Send e-mail to: hneeman@ou.edu
Live via videoconferencing (scroll down): Overview: What the Heck Is Supercomputing?

So far, the SiPE workshops have reached roughly 1000 people at 166 institutions, agencies, companies and organizations in 42 US states and territories and 5 other countries:

  • 125 academic institutions;
  • 18 government agencies;
  • 16 private firms;
  • 7 not-for-profit organizations.

SiPE is targeted at an audience of not only computer scientists but especially scientists and engineers, including a mixture of undergraduates, graduate students, faculty and staff.

These workshops focus on fundamental issues of HPC as they relate to Computational and Data-enabled Science & Engineering, including:

  • the storage hierarchy;
  • instruction-level parallelism;
  • high performance compilers;
  • shared memory parallelism (e.g., OpenMP);
  • distributed parallelism (e.g., MPI);
  • HPC application types and parallel paradigms;
  • multicore optimization;
  • high throughput computing;
  • GPGPU computing;
  • scientific and I/O libraries;
  • scientific visualization.

The key philosophy of the SiPE workshops is that an HPC-based code should be maintainable, extensible and, most especially, portable across platforms, and should be sufficiently flexible that it can adapt to, and adopt, emerging HPC paradigms.

Introduction to High Performance Computing for Biology students

January 9th,2013 from 2:30 pm to 4 pm, room 401,
Biological Sciences Learning Center building

Introduction to Beagle

Wednesday, November 14th,2012 from 1 p.m. to 3 p.m

  • Trainer: The catalyst group from the Computation Institute
  • Outline: This introductory class is mainly intended for people who have just started working on the Cray XE6 Beagle or are considering using it. It aims at familiarizing new users with the hardware and software architecture (e.g., compilation, submission). Cray’s performance analysis tools will briefly be introduced as well. We plan to include small practical exercises about compilation, data transfer and submission of jobs. Users are strongly invited to ask specific questions about how to port their specific calculations to Beagle and how to submit jobs.
  • Topics will include (depending upon users desires and abilities):
    • General overview of Beagle’s team and the computational institute
    • overview of Beagle’s Cray XE6 system architecture
    • basic access and navigation operations
    • using compilers and applications
    • appropriate use of local and network filesystems
    • submitting jobs and monitoring jobs
    • data transfer
    • Specific topics requested by users (e.g., using R or Matlab on Beagle)
  • Time requirements: one hour and fifteen minutes (lecture) 45 minutes (questions).
  • When: on Wednesday, November 14th, from 1 to 3 p.m
  • Where: Room 240A at the Computation Institute of the University of Chicago. 5735 South Ellis Avenue (Searle Chemistry Laboratory).
  • Requirements: Open to every Beagle user and people interested into becoming users; users need to have access to Beagle and should bring their laptop to do the exercises and to read the slides that will be distributed electronically to the users that RSVP.

RSVP is required. If you would like to attend, send a message to beagle-support@ci.uchicago.edu, preferably with the following subject line: Introduction to Beagle presentation, Nov 14 @ Searle. Please include the name(s) of attendee(s).

2011 Training Events

Getting started on the Cray XE6 Beagle and parallel scripting with Swift
  • Trainers: The catalysts and administrators  of Beagle team at the Computational Institute of the University of Chicago and Argonne National Laboratory.
  • When: on Wednesday, September 14, from 9 to 11 a.m
  • Outline: This introductory class is mainly intended for people who have just started working on the Cray XE6 Beagle. It aims at familiarizing new users with the hardware and software architecture (e.g., compilation, submission). Cray’s performance analysis tools will briefly be introduced as well. We will have a lecture which involves small practical exercises about compilation, data transfer and submission of jobs. Users are strongly invited to ask specific questions about how to port their specific calculations to Beagle and how to submit jobs.
  • Topics will include (depending upon users desires and abilities):
    • overview of Beagle’s Cray XE6 system architecture
    • basic access and navigation operations
    • using compilers and applications
    • appropriate use of local and network filesystems
    • Introduction to Parallel scripting with Swift (see also the paper “Swift: A language for distributed parallel scripting” for examples of using this parallel scripting language)
    • submitting jobs and scheduler operations
  • Time requirements: Two  hours
  • Where: room 1416 at the TCS Conference Center at Argonne National Laboratory.
  • Requirements: Open to every Beagle user, users need to have access to beagle and bring their laptop for the exercises and to read the slides that will be distributed electronically to the users that RSVP.
    If you would like to attend, send a message to beagle-support@ci.uchicago.edu, preferably with the following subject line:
    Introduction to Beagle presentation, Sep 14 @ TCS [Beagle ticket #16060]
    Please include (a) the name(s) of attendee(s) and (b) if you wish to attend the system tour.
Getting started on the Cray XE6 Beagle and parallel scripting with Swift
  • Trainers: The catalysts and administrators  of Beagle team at the Computational Institute of the University of Chicago and Argonne National Laboratory.
  • When: July 27th 2011, first class of the series
  • Outline: This introductory class is mainly intended for people who have just started working on the Cray XE6 Beagle. It aims at familiarizing new users with the hardware and software architecture (e.g., compilation, submission). Cray’s performance analysis tools will briefly be introduced as well. We will have a lecture which involves small practical exercises about compilation, data transfer and submission of jobs. Users are strongly invited to ask specific questions about how to port their specific calculations to Beagle and how to submit jobs.
  • Topics will include (depending upon users desires and abilities):
    • Beagle hardware concepts and terminology
    • Modules environment (with exercises)
    • Launch of a parallel application (with exercises)
    • Use of the batch environment (with exercises)
    • Job monitoring (with exercises)
    • Data transfer using Globus online
    • Use of the compilers (C, C++, and Fortran)
    • Introduction to the application debugger and profiler
    • Introduction to Parallel scripting with Swift (see also the paper “Swift: A language for distributed parallel scripting” for examples of using this parallel scripting language)
  • Time requirements: One and half  hours
  • Where: Room 240a at the Computation Institute of the University of Chicago. 5735 South Ellis Avenue (Searle Building).
  • Requirements: Open to every Beagle user, users need to have access to beagle and bring their laptop for the exercises and to read the slides that will be distributed electronically to the users that RSVP.
April 5th training
  • Trainer: Katie Antypas, from NERSC User Services Group. At NERSC, they have a (huge) XE 6 (Hopper II,  http://www.nersc.gov/nusers/systems/hopper2/) and it is already in production. The CI is very excited to have her share her expertise with our early users (and staff).
  • Outline: Cray XE6 workshop:
    • Getting started on Beagle, a new Cray XE6 system
    • Tips and tricks for running efficiently on Beagle
    • Using Beagle’s 24 cores per node effectively.
  • time requirements: half-day 12 noon to 5 PM and April 5th 2011
  • Where: At the Computation Institute of the University of Chicago. 5735 South Ellis Avenue.
  • Requirements: Knowledge of C or Fortran will be sufficient to follow the seminar.

Please let us know (beagle-support@ci.uchicago.edu) if you or members of your research groups are planning to participate.

XEPO: Cray XE Application Programming and Optimization on May 23rd
  • Trainer: Richard Slick, From Cray
  • Outline: This course is intended for people who work in applications support or development of Cray XT or Cray XE computer systems. It familiarizes students with the hardware and software architecture, Cray’s performance analysis tools, and optimization of user codes. Using lectures and practical laboratory exercises, the course provides sufficient instruction to enable inexperienced users to develop and optimize applications
  • Time requirements: Monday May 23, 2011 to Thursday May 26, 2011 — 4 days of all-day training
  • Where: At the Computation Institute of the University of Chicago. 5735 South Ellis Avenue.
  • Requirements: At least knowledge of C or Fortran will be sufficient to follow the seminar. This training accepts only a limited number of participants, all or most from the Beagle core groups.
  • For more information see the training section of the Beagle wiki

More information will be posted as soon as it is available