Tags:
create new tag
, view all tags

2012 training events

Currently planned

Introduction to Beagle on Tuesday, May 28th, from 2 p.m. to 4 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 Tuesday, May 28th, from 2 to 4 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, May 28 @ Searle. Please include the name(s) of attendee(s).

Introduction to Beagle on Wednesday, November 14th, 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).

Workflow/pipeline management on the Cray XE6 Beagle: the Swift parallel scripting language April/May 2012

  • Trainer: The catalyst group from the Computation Institute
  • Outline: This practical hands on class is mainly intended for people who are using or are considering using Beagle to compute calculations that require multiple steps or scan a set of different scenarios or just require multiple calculations. It aims at first quickly going over Beagle's hardware and software architecture (e.g., compilation, submission), then familiarizing new users with the Swift parallel scripting language stressing its advantages when compared to the standard job management tools available. We plan to conclude the lecture with practical applications, ideally by helping users start converting their projects into Swift. Users are strongly invited to ask any questions about how to port their specific calculations and how to submit jobs. Feel free to ask questions not exactly directly related to Beagle.
  • Topics will include (depending upon users desires and abilities):
    • overview of Beagle's Cray XE6 system architecture
    • quick introduction about using compilers and applications and local and network filesystems
    • submitting jobs and scheduler operations
    • Practical introduction to the swift parallel scripting language: what you need to know to work on Beagle
    • Where to find other more in depth information about Swift
    • How to use swift to run a large number of matlab calculations
    • How to use Swift to run other applications (e.g., R, python)
    • How to turn your computations into a manageable swift script on Beagle
  • Time requirements: one hour (lecture) one hour (questions and hands on exercises).
  • When: TBD
  • 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: Swift on Beagle, April/May @ Searle. Please include the name(s) of attendee(s).

Completed

Getting started on the Cray XE6 Beagle on Tuesday, March 27th, 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 scheduler operations
    • Using our wiki
    • 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, March 27th, 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, Mar 27 @ Searle. Please include the name(s) of attendee(s).

Matlab on Beagle: compiling and scripting on the Cray XE6 Beagle on Wednesday, January 4th, 2012 from 10:30 to 12:30 PM

  • Trainer: The catalyst group from the Computation Institute
  • Outline: Have you wondered how hard bringing your Matlab calculations to a supercomputer like Beagle can be? In this presentation we hope to show you the simple steps necessary to make use of the power of a Cray XE6 without having to rewrite your programs in c or Fortran. Bring your Matlab programs, we will do our best to make them work right away (you need to have a user and project on Beagle to be able to do that—see HowToStart for details )! We will have to assume basic knowledge about how to operate a Cray XE6 at least in the presentation. However, no question will be considered too trivial or basic to be addressed (that is, unless the trainer does not know the answer). Please note that this is not a class about using Matlab and we will not provide instruction about how to write or debug Matlab code, but only how to move it to Beagle
  • Topics will include (depending upon users desires and abilities):
    • Why we use compiled Matlab files and not the GUI,
    • What (small) changes need to be included in Matlab source files before compiling them (changes will not affect behavior in the GUI)
    • Recommended compilation steps
    • Use of the runtine environment
    • [Maybe] How to use multiple threads.
    • How to prepare your data and run your simulations, both using a standard bash shell plus PBS (Portable Batch System, i.e., how to submit jobs) and the Swift parallel scripting language.
  • Time requirements: one to two hours, depending upon user needs.
  • When: on Wednesday, January 4th 2012, from 10:30 to 12:30 p.m
  • Where: Room 240A at the Computation Institute of the University of Chicago. 5735 South Ellis Avenue (Searle Chemistry Laboratory).
  • Requirements: Participants need to have access to Beagle to do exercises and work on submitting their codes. They should bring their laptop both 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 or ask questions about the training, send a message to beagle-support@ci.uchicago.edu, preferably with the following subject line: Using Matlab on Beagle presentation, Jan 4 @ Searle. Please include the name(s) of attendee(s).

Matlab on Beagle Lecture slides

Introduction to Swift on Beagle Lecture slides

Or take a look at the video lecture about swift http://www.youtube.com/watch?v=TZ14Q2aeNMQ

2011 training events

Getting started on the Cray XE6 Beagle on Wednesday, November 30th, from 1:15 p.m. to 2:30 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. 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
    • submitting jobs and scheduler operations
  • Time requirements: one hour and fifteen minutes.
  • When: on Wednesday, November 30th, from 1:15 to 2:30 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; 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 30 @ Searle [Beagle ticket #17278:]. Please include the name(s) of attendee(s).*

Getting started on the Cray XE6 Beagle and parallel scripting with Swift on Wednesday, September 14, from 9 to 11 a.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. 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.
  • When: on Wednesday, September 14, from 9 to 11 a.m
  • 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.

Getting started on the Cray XE6 Beagle -- on July 27th 2011

  • 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. 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
    • In passing: why do we have catalysts and system administrators and why is this relevant to users
    • 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 a half hours.
  • When: Wednesday July 27th 2011 from 10 to 11:30 AM.
  • 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.
RSVP is required to beagle-support@ci.uchicago.edu

Introduction to Beagle Lecture slides

Parallel scripting on the Cray XE6 Beagle, starting on July 27th 2011

Introduction to Parallel Scripting Lecture slides

Project specific Application Programming and Optimization on XE6 machine June 16th

  • Trainer: Dave Strenski from Cray
  • Outline: For people who work on specific applications for our Cray XE computer system. We will analyze specific performance issues with the groups that either develop or use software on Beagle. We will also look in more detail at performance issues with the Gemini Interconnect and the Mc-12 processors.
  • Time requirements: By appointment, possibly with a general class on the Cray XE6 and future architectures.
  • Where: At the Computation Institute of the University of Chicago. 5735 South Ellis Avenue.
  • Requirements: Only prearranged and approved (because we need to prepare for them) specific issues will be discussed. If arranged, the general class will be open to everyone, constrained to space availability.
  • RSVP is required to beagle-support@ci.uchicago.edu
In addition Dave will give us a talk entitled "Cray Technology Update" in room 240A at At the Computation Institute of the University of Chicago. 5735 South Ellis Avenue. He will be talking about the current architecture of Beagle, the Cray XE6 just acquired by the University of Chicago. He will also give an overview of the latest generation of Cray machines: the GPU based machine — the Cray XK6; and the uniquely designed database, graph and analytics machine — the Cray XMT. He will also give an overview of what we can expect from Cray in the future.

Specifications about the three machines can be found at:

XE6 - http://www.cray.com/Products/XE/CrayXE6System.aspx

XK6 - http://www.cray.com/Products/XK6/KX6.aspx

XMT - http://www.cray.com/products/XMT.aspx

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.
  • RSVP by Friday April 1st (No, it is not a joke.)
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: Rich 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.
    • Topics will include (depending upon users desires and abilities):
      • Hardware concepts and terminology that are relevant to the programmer
      • Launch of a parallel application
      • Operating system components that a parallel application uses
      • Use of the batch environment
      • Job monitoring
      • Modules environment
      • Use of the compilers (C, C++, and Fortran), loader, and libraries
      • Use of the application debugger
      • MPI environment variables
      • I/O on the Cray XT and Cray XE system
      • Use of available performance analysis tools
      • Single-processor optimization for the Opteron processor
    • See also Agenda XEPO training
  • Schedule: 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:
    • Experience with UNIX shells and commands such as ls, grep, and man.
    • Working knowledge of C, C++, or Fortran programming language and the ability to write, compile, and execute programs on a UNIX system.
    • Previous experience with at least one parallel programming style and one multiprocessor computer architecture is advantageous.
    • This training accepts only a limited number of participants, all or most from the Beagle core groups.
Topic attachments
I Attachment Action Size Date Who Comment
Unknown file formatpptx CI.pptx manage 3031.5 K 2011-07-27 - 19:38 LorenzoPesce  
Unknown file formatpptx Intro_Beagle_Matlab.pptx manage 2990.3 K 2012-01-04 - 18:17 LorenzoPesce  
PDFpdf U_Chicago_Agenda_XEPO.pdf manage 28.4 K 2011-04-21 - 16:08 LorenzoPesce Description of the XEPO training on may 23rd 2011
Unknown file formatpptx bgl-swift.pptx manage 466.2 K 2011-07-27 - 19:38 LorenzoPesce  
Unknown file formatpptx swift_main.pptx manage 392.4 K 2012-01-04 - 18:57 LorenzoPesce  
Topic revision: r68 - 2013-08-07 - DavidEForero
 
This site is powered by the TWiki collaboration platformCopyright © 2008-2014 by the contributing authors. All material on this collaboration platform is the property of the contributing authors.
Ideas, requests, problems regarding CI Wiki? Send feedback