The Chapel Parallel Programming Language

 

Archived Chapel Presentations (reverse chronologically)

Chapel and Open Productive Parallel Computing at Scale [video], Michael Ferguson, Open Source Connector, Burlington VT (presented remotely), February 7, 2024.
This talk demonstrates how, as a parallel language, Chapel's standard library can easily support parallel implementations, permitting codes that are as succinct as other popular languages to outperform them by 10x–400x. It is also unique among the talks here in that it includes a live demo of programming using Chapel and Arkouda.
High-level, Vendor-Neutral GPU Programming Using Chapel, Engin Kayraklioglu, internal HPE talk (edited for public consumption), January 9, 2024.
This talk provides an in-depth introduction to Chapel's support for GPU programming from motivation to key concepts, applications, implementation approach, and ongoing work.
High-Performance Programming and Execution of a Coral Biodiversity Mapping Algorithm Using Chapel [paper], Scott Bachman, PAW-ATM 2023, Denver, CO, November 13, 2023.
This talk describes the use of Chapel to estimate the biodiversity of coral reefs using satellite image analysis.
Implementing Scalable Matrix-Vector Products for the Exact Diagonalization Methods in Quantum Many-Body Physics [paper], Tom Westerhout, PAW-ATM 2023, Denver, CO, November 13, 2023.
This talk describes the use of Chapel to compute exact diagonalization methods on distributed systems, as used when simulating small quantum systems.
Practical Examples of Productivity and Performance in Chapel, Brad Chamberlain, PASC'23, Davos, Switzerland (presented remotely), June 26, 2023.
This talk summarizes Chapel's use in CHAMPS and Arkouda, including some recent scaling results, and summarizes the use of traditional Chapel features to target GPUs in a vendor-neutral manner.
Introducing Chapel: A Programming Language for Productive Parallel Computing from Laptops to Supercomputers [video], Brad Chamberlain, LinuxCon / Open Source Summit North America 2023, Vancouver BC, May 11, 2023.
This introduction to Chapel provides the language's motivation and brief comparisons with familiar languages and HPC programming models. It then introduces some of Chapel's core features for parallelism and locality, showing how they have recently been extended to also support GPUs. It wraps up by providing a peek into some of the flagship applications that are using Chapel.
Arkouda: A High-Performance Data Analytics Framework, Michelle Strout, CUG 2023, Helsinki, Finland, May 10, 2023.
This is an introduction to the motivation, capabilities, and performance of Arkouda, supporting interactive data science for Python users at massive scales.
Parallel Programming with Chapel (or: Performance at any Cost? HPC and 24h of Le Mans) [video], Brad Chamberlain, PNW PLSE 2023, Seattle, WA, May 9, 2023.
This 10-minute talk provides a very brief introduction to Chapel, highlighting recent advances such as support for GPUs and user applications.
Application Examples of Leveraging Task Parallelism with Chapel [video], Michelle Strout, WAMTA 2023 keynote, Baton Rouge LA, February 15, 2023.
This keynote demonstrates how Chapel's support for task-parallelism is being used to express a wide variety of computations while also generating good performance and scalability.
Productive Parallel Programming Using Chapel [video], Brad Chamberlain, Nordic-RSE Seminar Series, online, November 30, 2022.
This Chapel overview talk provides background on Chapel, characterizes it at a high-level, shows its benefits in benchmarks and applications, and introduces some of its core features for productivity, parallelism, and locality.
Chapel Programming Language: Overview and Roadmap, Michelle Strout, Using Chapel to Develop Practical, Scalable Applications (BoF), SC22, Dallas TX, November 17, 2022.
This was a short introduction to Chapel for our BoF at SC22 before turning the floor over to users who spoke about their Chapel applications.
Introduction to Chapel, UPC++, and Charm++, Michelle Strout, PAW-ATM 2022 (a SC22 workshop), Dallas TX, November 14, 2022.
This was one of a few introductory talks at PAW-ATM, designed to survey some of the language technologies that would show up later in the day.
Chapel: Five Highlights Since CLSAC 2019, Brad Chamberlain, CLSAC 2022, Annapolis MD, October 26, 2022.
This lightning talk summarized five Chapel highlights achieved between CLSAC 2019 and 2022 ("the pandemic years"), including support for aggregators, GPUs, and improved performance and scalability.
Chapel Programming Languge Introduction, Lydia Duncan and Michelle Strout, GHC Open Source Day, online, September 6, 2022.
This is a brief introduction to Chapel for those participating in the GHC Open Source Day event.
Asynchronous Task-Based Aggregated Communication in Chapel, Elliot Ronaghan, AMTE 2022, online, August 23, 2022.
This talk describes the use of Chapel's task-based parallel features to optimize communication through compiler analysis and/or user-defined aggregation abstractions.
Productive Parallel Programming Using Chapel, Brad Chamberlain and Michelle Strout, NASA Langley, online, August 4, 2022.
This is a choose-your-own-adventure talk covering Chapel characterstics, benchmarks & applications, comparisons to standard practices for HPC programming, and a brief tour of language features. Backup slides highlight some recent work that has been done to target GPUs.
Rapid Prototyping by Example: Arkouda Argsort in Chapel, Brad Chamberlain, Rapid Prototyping for Exascale, ECP BoF Days, online, May 12, 2022.
This is a 5-minute opening statement about Chapel's role in supporting the rapid prototyping and scalability of Arkouda's Argsort operation, capable of sorting 72 TiB of data in half the time of the talk itself.
Making Parallel Computing as Easy as Py(thon), from Laptops to Supercomputers [video], Brad Chamberlain, HPE Dev Munch & Learn, online, April 20, 2022.
This talk provides background on Chapel, such as how it compares to other mainstream language and HPC programming models, along with some of its benefits in the Arkouda and CHAMPS applications.
Chapel: Recent Successes, Ongoing Challenges, Brad Chamberlain, DOE Programming Systems Research Forum, online, February 28, 2022.
This talk provides an update to the DOE community about recent Chapel progress, along with a retrospective about how we got here and some research challenges going forward.
Achieving Productivity at Scale with Chapel in User Applications, a SIAM PP22 Minisymposium, online, February 24, 2022
This session featured a series of talks about uses of Chapel in application codes developed in the community:
Generating GPU Kernels from Chapel's Features for Parallelism and Locality, Engin Kayraklioglu, SIAM PP22 minisymposium on Code Generation and Transformation in HPC on Heterogeneous Platforms, online, February 26, 2022.
This talk describes Chapel's recently added support for GPU programming, detailing the programming model and code generation strategy.
What's New With Chapel? Applications, Aggregators, and Accelerators [video], Brad Chamberlain, Northwest C++ Users' Group, online, January 19, 2022.
This talk provides an introduction to Chapel through some recent highlights from the project, including the Arkouda and CHAMPS applications, high-level support for aggregated communication, and nascent GPU programming capabilities.
Parallel Programming in Chapel: Overview and Ookami [video], Brad Chamberlain, Ookami User Community Webinar, online, January 13, 2022.
This talk covers Chapel's motivation and some key benchmarking and application results before doing a deep-dive overview of the language and how it compares to SPMD programming. Initial baseline results of Chapel on Ookami are presented, with possible avenues for improving them given.
What's New with Chapel: Applications, Aggregators, and Accelerators [video], Brad Chamberlain, 19th Annual Workshop on Charm++ and its Applications, online, October 18, 2021.
This talk is a quick tour through some recent highlights from the Chapel project, including the Arkouda and CHAMPS applications, high-level support for aggregated communication, and nascent GPU programming capabilities.
Separating Parallel Performance Concerns using Chapel [video], Michelle Strout, LCPC 2021, online, October 13, 2021.
This invited talk discusses the importance of separating concerns in High-Performance Computing, and the role of Chapel's multiresolution programming model in supporting such separation.
Multiresolution Support for Aggregated Communication in Chapel, Brad Chamberlain, OpenSHMEM 2021 keynote, online, September 16, 2021.
This keynote describes various forms of optimized and aggregated communications in Chapel for sparse communication patterns as exhibited by HPCC RA, Bale IndexGather, or Arkouda. Approaches include asynchronous fine-grain communications, manual copies expressed using Chapel's global namespace, and aggregation via user-level abstractions or compiler transformations.
Chapel: An Example of Language-Level PGAS Support, Lydia Duncan, Practical and Efficient Partitioned Global Address Space Support for Data Intensive Applications minisymposium, SIAM AN21, online, July 22, 2021.
This talk describes Chapel's use for data-intensive computing within the context of CHAMPS and Arkouda, highlighting some of the benefits that a language-based approach to PGAS can yield.
HPC Lessons from 30 Years of Practice in CFD Towards Aircraft Design and Analysis, [video], Éric Laurendeau, CHIUW 2021, online, June 4, 2021.
This CHIUW keynote describes CHAMPS, a ~48k-line framework written in Chapel for 3D unstructured computational fluid dynamics (CFD), while also providing an introduction to the role of HPC in Aerodynamics. The productivity benefits that Chapel brings to the CHAMPS team's work are made clear.
Compiling Chapel: Keys to Making Parallel Programming Productive at Scale [video], Brad Chamberlain, PACT'20, online, October 7, 2020.
This talk gives a peek into what's required to compile some of Chapel's key features, and describes a pair of optimizations that are made possible through its unique features.
Arkouda: Terascale Data Science at Interactive Rates, [video], Ben Albrecht, SciPy 2020, online, July 7, 2020.
This is an introductory talk describing Arkouda with some recent performance comparisons to NumPy.
Arkouda: Chapel-Powered, Interactive Supercomputing for Data Science [video|Q&A], William Reus, CHIUW 2020, online, May 22, 2020.
This talk describes Arkouda, a Python package that provides a NumPy-like interface implemented using a Chapel server that has scaled to dozens of Terabytes of data at interactive rates.
Arkouda: Data Science at Massive Scales and Interactive Rates, Brad Chamberlain, Puget Sound Programming Python meet-up (PuPPy), Seattle, WA, February 13, 2020.
This talk presents Arkouda from the Chapel team's perspective to a Python-based audience, leaning heavily on Bill Reus's slides from his CLSAC 2019 talk.
Arkouda: NumPy-like arrays at massive scale backed by Chapel [paper], Mike Merrill, PAW-ATM 2019, Denver CO, November 17, 2019.
This talk describes the role of Chapel in supporting Exploratory Data Analysis (EDA) in Arkouda.
Simulating Ultralight Dark Matter with Chapel: An Experience Report [paper], Nikhil Padmanabhan, PAW-ATM 2019, Denver CO, November 17, 2019.
This talk describes a use of Chapel to explore dark matter in cosmological models.
Chapel: A Parallel Language for Productivity at Scale, Brad Chamberlain, National Institute of Standards and Technology (NIST), October 11, 2019.
This is a Chapel overview talk that features a few notable recent use cases of Chapel including Arkouda.
Data Science Needs Interactive Supercomputing, Bill Reus, CLSAC 2019, Annapolis, MD, October 7–10, 2019.
This talk motivates and describes Arkouda, a Python package providing scalable NumPy interfaces implemented using Chapel.
Chapel Comes of Age: A Language for Productivity, Parallelism, and Performance [video], Brad Chamberlain, HPC Knowledge Meeting `19 (HPCKP`19), Barcelona, Spain, June 14, 2019.
This talk provides a brief overview of Chapel along with reports on recent performance improvements for the HPCC RA benchmark and on Arkouda, a Python library providing NumPy operations at scale on distributed Chapel arrays.
Chapel: Programmability, Parallelism, and Performance, Brad Chamberlain, CSC 2/458 (remote) lecture, University of Rochester Computer Science Department, March 18, 2019.
This is a Chapel overview talk which includes recent performance results enabled by a new optimization for asynchronous atomic operations.
Chapel's Language-based Approach to Performance Portability, Brad Chamberlain, SIAM CSE19, February 25, 2019.
This talk wrestles with the role that languages like Fortran have had, and ones like Chapel can have, w.r.t. performance portability on diverse or rapidly changing systems with unique features for improving performance.
Chapel: Programmability, Parallelism, and Performance, Brad Chamberlain, Puget Sound Programming Python Meetup (PuPPy), Seattle WA, December 12, 2018.
This talk is an overview of Chapel aimed at Python programmers.
Chapel: Programmability, Parallelism, and Performance, Brad Chamberlain, PuPPy (Puget Sound Programming Python) Scientific Computing SIG, Seattle WA, July 19, 2018.
This talk provides an overview of Chapel for programmers currently doing Scientific Computing in Python.
Chapel Comes of Age: Productive Parallelism at Scale [paper], Brad Chamberlain, CUG 2018, Stockholm Sweden, May 22, 2018.
This talk summarizes the progress that has been made with Chapel over the past five years since the HPCS program wrapped up.
Chapel Comes of Age: Productive Parallelism at Scale (a.k.a., Chapel: Niche or Quiche?) [video], Brad Chamberlain, PNW PLSE 2018, May 14, 2018.
This 10-minute talk provides a glimpse into how Chapel has improved over the past five years.
Chapel: Task-Based Communication in a Productive Language, Elliot Ronaghan, SIAM PP18, March 8, 2018.
This talk gives a brief introduction to Chapel's runtime support for tasking and communication using the HPCC RA benchmark as a running example.
Chapel’s Multiresolution Programming Model: Mixing High-level Parallel Abstractions with Lower-level Control [video], Brad Chamberlain, Northwest C++ Users Group, February 22, 2018.
This Chapel talk is augmented with: (1) more content about base language features for this C++ audience and (2) an introduction to multiresolution features that permit users to write high-level parallel abstractions such as parallel iterators and distributed array implementations.
Chapel: Overview and Features for Heterogeneity, Brad Chamberlain, Heterogeneous C++ Working Group, February 5, 2018.
This is an introduction to Chapel and its multiresolution features designed to show how its support for hierarchical locale models can enable programming for heterogeneous systems.
Chapel: Productive Programming at Scale, Michael Ferguson, UMBC course lecture, December 7, 2017.
This is a Chapel overview talk given as a guest lecture to UMBC students in their CMSC 441 course.
Chapel: A Parallel Language for Productive Scalable Computing, Brad Chamberlain, SeaLang Meetup, Bellevue WA, December 6, 2017.
This is a Chapel overview talk aimed at programming language enthusiasts.
Cosmological Particle Mesh Simulations in Chapel [poster], Nikhil Padmanabhan, PAW 2017 workshop at SC17, Denver Colorado, November 13, 2017.
This talk characterized Nikhil's recent uses of Chapel in his astrophysics research.
Chapel Update (SC17), Chapel Team, SC17, Denver CO, November 2017.
These slides give a short, general update on Chapel, prepared for briefings at SC17.
Chapel: Open-Source Productive Parallel Programming at Scale, Ben Albrecht and Brad Chamberlain, OpenSuCo 2017 workshop at SC17, Denver CO, November 12, 2017.
This was a lightning talk and demo for an SC17 workshop on open-source Supercomputing.
If the HPC Community were to create a truly productive language...[how] would we ever know?, Brad Chamberlain, keynote at Dagstuhl Seminar on Performance Portability in Extreme Scale Computing: Metrics, Challenges, Solutions, Wadern Germany, October 23-27, 2017.
This keynote provided a review of some of the productivity metrics that were pursued under the DARPA HPCS program, but then argued that productivity seems like a very personal/social decision and that it therefore should be studied in forums supporting personal/social decisions. Two specific proposals are made.
Enabling Parallel Computing in Chapel with Clang and LLVM, Michael Ferguson, 2017 US LLVM Developers' Meeting, San Jose CA, October 19, 2017.
This talk provides an introduction to the use of LLVM and Clang in the Chapel compiler architecture to support interoperability and optimizations.
Chapel's New Adventures in Data Locality, Brad Chamberlain, PADAL 2017, Chicago IL, August 2–4, 2017.
This short talk reviews key Chapel features for controlling locality and summarizes three recent locality-related efforts in Chapel for NUMA nodes and Intel Xeon Phi ("KNL").
Chapel: Productive Parallel Programming at Scale, Elliot Ronaghan, EAGE 2017, workshop on Programming on Modern HPC Architectures: Efficiency and Portability, Paris France, June 16, 2017.
This is a Chapel overview talk that was given to the EAGE community.
Chapel’s Home in the New Landscape of Scientific Frameworks (and what it can learn from the neighbours) [video | PDF slides], Jonathan Dursi, CHIUW 2017 keynote, Orlando FL, June 2, 2017.
This keynote by Jonathan Dursi presents a survey of modern parallel computing frameworks as seen through the filter of the speaker's applications background, and describes Chapel's unique position within that landscape.
CHIUW 2017: Welcome and State of the Project, Brad Chamberlain, CHIUW 2017, Orlando FL, June 2, 2017.
This talk gives a brief overview of the CHIUW 2017 program and then a more detailed overview of some of Chapel's most notable progress since CHIUW 2016.
CHIUW 2017 Presentations, various speakers, CHIUW 2017, June 2, 2017.
Presentations from CHIUW 2017—the fourth annual Chapel Implementers and Users Workshop—are available from the program page
A Language Designer's Perspective on Benchmarking Suites and Competitions, Brad Chamberlain, EMBRACE 2017 invited talk, Orlando FL, June 2, 2017
This talk surveys past approaches to benchmarking from a language designer's perspective, rating them along various axes of importance. It wraps up by advocating for an HPC equivalent to the Computer Language Benchmarks game.
The Audacity of Chapel: Scalable Parallel Programming Done Right [video | director's cut slides | playlist], Brad Chamberlain, ACCU 2017 keynote, Bristol UK, April 28, 2017.

This keynote talk argues that parallel computing, particularly at scale, is deserving of new programming languages such as the one we're building, Chapel. It also notes that even if you are a traditional programmer who doesn't care about scalable computing, the concerns of your world will likely increasingly resemble those of HPC in the coming years. In the end, it's your call which is more audacious: Chapel, or the fact that we don't already have such a language.

For context, the UK ACCU conference at which this keynote was given had a "rock" theme, which led to the idea of using song lyric trivia to introduce each section of the talk. During the talk, the lyrics slides were animated such that the artist and album weren't revealed until guesses had been made. To play along at home, put a sticky note in the lower right corner of your window. The playlist link above leads to a Spotify playlist with the featured songs.

Chapel: Productive Parallel Programming at Scale, Michael Ferguson, James Madison University (JMU), March 15, 2017.
This introductory Chapel talk was presented in a pair of class lectures.
Report on CHIUW / Recent Chapel Highlights, Brad Chamberlain, SC16 PGAS BoF, November 16, 2016.
This was a pair of lightning updates on the annual CHIUW workshop and on Chapel specifically.
The Chapel Language: Background and Status, SC16 Customer Briefing, November 14-17, 2016.
This is a high-level overview and status report on Chapel developed for use in customer briefings at SC16.
Chapel: Productive Parallel Programming at Scale [video], Brad Chamberlain, Northwest C++ Users Group, October 19, 2016.
This is an overview of Chapel aimed at non-HPC programmers.
One Parallel Language to Rule them All? Chapel for HPC, Data Analytics, Machine Learning, ..., Brad Chamberlain, UW PLSE Retreat, September 12, 2016.
This is a short talk calling for input on killer apps or features for evaluating Chapel's utility as a language for data analytics or deep learning.
Chapel: Productive, Multiresolution Parallel Programming [video], Brad Chamberlain, ATPESC 2016, August 3, 2016.
This is an overview of Chapel aimed at HPC programmers.
HPC Programmers Deserve Nice Things Too, Brad Chamberlain, ISC 2016 Panel: Parallel Programming, June 21, 2016.
This position statement argues for technical and social changes that would be useful for the adoption of language-based approaches to scalable parallel programming like Chapel.
Lessons Learned in Array Programming: from ZPL to Chapel, Brad Chamberlain, ARRAY 2016 keynote, June 14, 2016.
This keynote talk reflects on some of the successes of ZPL's support for data-parallel array-based programming, lists reasons that ZPL was ultimately limited, and how we addressed those limitations in Chapel's design.
Chapel in the (Cosmological) Wild [video], Nikhil Padmanabhan (Yale University), CHIUW 2016, May 27, 2016.
This was the keynote talk at CHIUW 2016, reporting on the personal experiences of an Astrophysics Professor who's been looking at using Chapel in his research.
CHIUW 2016 Presentations, CHIUW 2016, May 27, 2016.
CHIUW 2016—the third annual Chapel Implementers and Users Workshop—was held as part of IEEE IPDPS 2016. CHIUW presentations are available on its program page
Chapel: A Domain-Specific Language for Productive Parallel Programming at Scale, Brad Chamberlain, University of Washington CSEP 590c, May 9, 2016.
This is an ~hour-long Chapel overview talk aimed at students without a lot of HPC programming experience.
Communication Optimizations for the Chapel Programming Language, Michael Ferguson, University of Maryland, March 24, 2016.
This talk describes the Chapel memory consistency model and how it enables two communication optimizations that have been implemented for Chapel.
Chapel: Productive Parallel Programming from the Pacific Northwest, Brad Chamberlain, Pacific Northwest Programming Languages and Software Engineering Meeting 2016, March 15, 2016.
This is a 15-minute introduction to Chapel.
Chapel: Productive Programming at Scale (a whirlwind introduction), Brad Chamberlain, HPDC 2016 TPC workshop, March 10, 2016.
This is a 15-minute introduction to Chapel.
Chapel: Parallel Programmability from Desktops to Supercomputers, Brad Chamberlain, University of Copenhagen, February 4, 2016.
This is an hour-long Chapel overview talk
Chapel: A Productive Parallel Programming Language, Lydia Duncan, Women Techmakers Community Talks, January 19, 2016.
This is a short talk designed to provide a short introduction to Chapel in a community setting.
Chapel in Ten Minutes, Brad Chamberlain, NII Shonan Meeting 075: Putting Heterogeneous High-Performance Computing at the Fingertips of Domain Experts, November 17, 2015.
This is a whirlwind talk designed to introduce Chapel in ten short minutes.
Chapel: Making HPC Accessible, Michael Ferguson, Asymmetrik, November 10, 2015.
This talk describes recent work looking into the potential for using Chapel in service-oriented and data analytics settings along with a bit of Chapel introduction and overview.
Communication Optimization for the Chapel Programming Language, Michael Ferguson, Indiana University, October 23, 2015.
This talk describes the Chapel memory consistency model and how it enables two communication optimizations that have been implemented for Chapel.
Five Things You Should Do to Create a Future-Proof Exascale Language, Brad Chamberlain, PGAS 2015, Washington DC, September 17, 2015.
This talk was an editorial to the PGAS language community about things that should be done to create a successful language for exascale (or at all), combined with a summary of how we think Chapel is already achieving them.
Toward a Data-Centric Profiler for PGAS Applications [poster], Hui Zhang (University of Maryland), PGAS 2015, Washington DC, September 17, 2015.
This talk and poster describe work being undertaken by Hui Zhang and Jeff Hollingsworth at the University of Maryland to create a data-centric profiler for PGAS languages like Chapel in which hotspots are reported in terms of your program's data structures rather than simply its control flow.
Chapel: HPC Programmers Deserve Nice Things Too [video], Brad Chamberlain, ATPESC 2015, St. Charles, IL, August 6, 2015.
This is a recent Chapel overview talk given as part of Argonne's HPC bootcamp summer school.
CHIUW 2015 Presentations (available from the CHIUW 2015 program)
CHIUW 2015—the second annual Chapel Implementers and Users Workshop—was held as part of PLDI/FCRC 2015. CHIUW presentations are available from its program page
Chapel The Language for HPC/Parallelization, Brad Chamberlain, UW CSE 501, May 5.
This lecture, for UW's provides a broad introduction to Chapel with a bit of focus on compilation challenges.
PGAS Programming and Chapel, Brad Chamberlain, UW CSEP 524, April 28 and May 12, 2015.
This lecture, for UW's PMP course on Parallel Programming, described PGAS programming models in general and Chapel specifically.
Scripting Language Performance Through Interoperability, Simon Lund (University of Copenhagen), First Workshop on the High Performance Scripting Languages (HPSL), San Francisco CA, February 7, 2015.
This talk gives an overview of recent work to interoperate between Python and Chapel in order to take advantage of its performance advantages.
Chapel Users Group (CHUG) BoF, Brad Chamberlain, SC14, November 19, 2014.
This talk gives a brief introduction to Chapel followed by a run-down of current/recent events in the project.
Chapel: A Condensed Digest, Sung-Eun Choi, SC14 PGAS BoF, November 19, 2014.
This is a quick, one-slide overview of Chapel that was put together for the annual PGAS BoF at SC14
Orthogonal Scheduling of Stencil Computations with Chapel Iterators [poster] Ian Bertolacci (Colorado State University), SC14 ACM SRC Posters, November 18-19, 2014.
This poster and talk describe work being done by Ian Bertolacci to express complex tiling patterns productively and efficiently using Chapel iterators. It was awarded 3rd place in the ACM Student Research Competition Award for undergraduates.
Chapel Hierarchical Locales: Adaptable Portability for Exascale Node Architectures [poster], Greg Titus, SC14 Emerging Technologies Presentations, November 18, 2014.
This talk and poster provide an introduction to Chapel's hierarchical locales, a Chapel concept for making the language and user codes future-proof against future changes in node architecture.
Chapel Lightning Talks 2014, Sung-Eun Choi and Richard Barrett, SC14 BoF, November 18, 2014.
This is our annual series of 5-minute lightning talks highlighting work being done in Chapel around the community.
Chapel: Overview and Status, Brad Chamberlain, Intel Extreme Scale Technical Review Meeting, November 11, 2014.
This is a fairly dense, information-packed two-hour presentation on Chapel that covers background and motivation, a brief introduction to the language, coverage of its main multiresolution features, and some project status and current events.
Chapel: A Modern Language for Modern Architectures (and Modern Programmers), Sung-Eun Choi, LLNL Computational Chemistry and Materials Science Summer Institute, Livermore CA, August 21, 2014.
This talk covers Chapel's high-level themes and motivations and then describes its three key features for managing locality: domain maps, leader-follower iterators, and locale models.
Chapel: Productive, Multiresolution Parallel Programming, [video], Brad Chamberlain, ATPESC 2014, St. Charles IL, August 7th, 2014.
This was a reasonably standard Chapel overview talk for the students of Argonne's Extreme Scale Computing summer school. It features the resurrection of the Jacobi Iteration walkthrough slides.`
Reflections on Programming Environments and Productivity (based on experiences with HPCS and Chapel), Brad Chamberlain, ASCR Exascale Computing Systems Productivity Workshop, Gaithersburg MD, June 3rd, 2014.
This talk briefly summarizes productivity-oriented metrics work undertaken by the Cray Cascade project during the HPCS program, along with a few anecdotal instances of Chapel productivity. It also provides some of Brad's personal takeaways from the experience.
CHIUW 2014 Presentations
Talks from the Inaugural Chapel Implementers and Users Workshop
Seismic Wave Propagation on Heterogeneous Systems with Chapel, Alexey Gokhberg and Andreas Fichtner, European Geosciences Union General Assembly 2014, Vienna Austria, May 1st, 2014.
This is a short talk by our colleagues at ETH who are studying the expression of Seismic Wave Propagation computations in Chapel.
Three Language Concepts for Taming Data Locality (a.k.a., "Language Constructs for Data Locality: Moving Policy Decisions from Language Definition to User Space"), Brad Chamberlain, PADAL Workshop 2014, Lugano, Switzerland, April 28th, 2014.
This brief talk proposes that for increasingly locality-aware architectures, Chapel's domain maps, leader-follower iterators, and hierarchical locales are key concepts in that they provide end-user control while exposing the policies through high-level abstractions.
Chapel: Productive Parallel Programming (under the influence of jetlag), Brad Chamberlain, ETH Zurich, April 25th, 2014.
This is a general Chapel overview talk. The subtitle refers to the fact that it was given a few hours after flying into Europe.
Chapel: An Emerging Parallel Programming Language [video], Thomas Van Doren, Northwest C++ Users' Group, Redmond, WA, April 16th, 2014.
This talk provides a brief introduction to Chapel for a local C++ Users' Group Meeting
Using Chapel to Teach Parallel Concepts [supporting materials], David Bunde, CCSC: Central Plains 20th Annual Consortium for Computing Sciences in Colleges regional conference, Fulton, MO, April 4th, 2014.
This talk describes the use of Chapel in education to prepare undergraduates for a world in which parallel computation is ubiquitous.
Chapel, Life, the Universe [white paper], Brad Chamberlain, (SICM)**2 Parallel Computing Workshop, Manhattan NY, March 29th, 2014.
This talk and whitepaper were presented to the Computational Chemistry community in response to some questions about Exascale challenges that lie ahead and Chapel's position in that world.
Chapel: A Versatile Tool for Teaching Undergraduates Parallel Programming [supporting materials], David Bunde and Kyle Burke, SIGCSE 2014 workshop, Atlanta, GA, March 8th.
This workshop was given at SIGCSE to explain the virtues of Chapel that make it compelling for use in undergraduate education, include examples of how the presenters use it in their classrooms.
Co-Design Via Proxy Applications: MiniMD in Chapel, Brad Chamberlain and Ben Harshbarger, SIAM PP14, MS78, Portland OR, February 21st, 2014.
This talk provides an overview of recent work porting the MiniMD proxy application to Chapel, as well as some background material in the context of LULESH.
Chapel Language Features for Hierarchical Tiling and Exascale Architectures [audio+slides], Brad Chamberlain, SIAM PP14, MS10, Portland OR, February 19th, 2014.
This talk argues that user-specifiable Chapel features like iterators, domain maps, and hierarchical locale models support hierarchical tiling and code portability to exascale architectures better than conventional models.
High-level parallel programming using Chapel [hands-on exercises], David Bunde and Kyle Burke, SC13 HPC Educators Program, Denver CO, November 21, 2013
These slides describe how David Bunde and Kyle Burke teach with Chapel in their courses, providing an introduction to the language along the way.
Chapel Lightning Talks 2013, SC13 BoF, Denver CO, November 20, 2013
Talks from the broader Chapel community on a variety of recent developments with the language
Chapel: An Emerging Parallel Programming Language [ poster | booth slides | handout ], Brad Chamberlain, SC13 Emerging Technologies Booth, Denver CO, November 20, 2013
A talk, poster, rotating slide deck, and handout developed as part of our participation in the SC13 Emerging Technologies booth
Towards the Co-evolution of Auto-tuning and Parallel Languages (a semi-finalist in the ACM Student Research Competition), Ray Chen (University of Maryland), SC13 Technical Posters Session, Denver CO, November 19, 2013
This research poster by Ray Chen describes his work using auto-tuning techniques to find optimal execution configurations for Chapel programs
Hierarchical Locales: Exposing the Node Architecture in Chapel, Sung-Eun Choi, 2nd KIISE-KOCSEA SIG HPC Workshop, Denver CO, November 19, 2013
This talk gives an introduction to the hierarchical locales work that we're currently doing in Chapel to support intra-locale hierarchy and heterogeneity. It provides an introduction to Chapel along the way.
The Chapel Parallel Programming Language, Brad Chamberlain, PNWNAS 2013, Seattle WA, October 19, 2013.
This short talk motivates Chapel, describes some of its design themes, provides a brief tour of lanugage concepts, and gives a quick overview of project status.
Multiresolution Global-View Programming in Chapel [video], Brad Chamberlain, Argonne Training Program on Extreme Scale Computiong, St. Charles, IL, August 1, 2013.
This talk is a fairly comprehensive view of Chapel's themes, features, and status, taking advantage of the lecture-style setting to dive a bit further into details than the normal 1-hour talk permits.
Chapel: The Design and Implementation of a Multiresolution Language, Brad Chamberlain, Keynotes on HPC Languages, Lyon, France, June 30, 2013.
This talk is a fairly comprehensive overview of Chapel's themes, features, and status, with a bit more emphasis on the implementation and multiresolution design of the language than a typical talk allows for.
Chapel: A Next-Generation PGAS Language [video], Brad Chamberlain, UW Applied Math 483/583 Lecture, May 29, 2013
An inroduction to PGAS programming, traditional PGAS languages, and Chapel for an applied parallel computing course.
Hierarchical Locales: Exposing Node-Level Locality in Chapel, Brad Chamberlain, UIUC Seminar, May 16, 2013
A preview of some ongoing work to support compute nodes with sensitivities to locality by extending Chapel's locales to include hierarchy.
Chapel: Why yes, we're still here, Sung-Eun Choi, Salishan Conference on High-Speed Computing (Random Access Session), April 24, 2013
This short presentation provides a Chapel status check as we transition from the DARPA HPCS program to a post-HPCS world.
The Chapel Runtime, Greg Titus, Charm++ Workshop 2013, April 15, 2013
This presentation provides an introduction to the Chapel runtime architecture and capabilities
Chapel: Parallel Programmability from Desktops to Supercomputers, Brad Chamberlain, University of Bergen, April 11, 2013
A general overview of Chapel's themes, features, and user-definable features
Chapel Support for Heterogeneous Architectures via Hierarchical Locales, Brad Chamberlain, University of Bergen, April 12, 2013
A peek at some ongoing work to support next-generation architectures by extending Chapel's locales to include hierarchy.
Exploring Co-Design in Chapel Using LULESH, Greg Titus, SIAM CSE13, MS79: Using Application Proxies to Explore Co-Design Issues, February 26, 2013
This presentation gives an overview of our work to date studying the LULESH proxy application in Chapel.
Chapel HPC Challenge Entry: 2012, The 2012 HPC Challenge Awards BoF, SC12, November 13, 2012
Our 2012 presentation for the annual HPC Challenge competition.
Chapel Lightning Talks 2012 BoF, SC12, November 14, 2012
Talks from the broader Chapel community on a variety of recent developments with the language
An Overview of Chapel: A Productive Parallel Programming Language, Sung-Eun Choi, KIISE-KOCSEA HPC SIG Joint Workshop, SC12, November 14, 2012
An invited Chapel overview talk given at a workshop at the KISTI booth at SC12
Chapel LULESH: Episodes IV, V, and VI, Sung-Eun Choi, Using Application Proxies for Exascale Preparation BoF, SC12, November 14, 2012
A brief overview of our collaboration with LLNL to study the LULESH proxy application within the context of Chapel.
High-level Parallel Programming Using Chapel, David P. Bunde and Kyle Burke, HPC Educators Program, November 15, 2012
An overview of Chapel for educators interested in using it in their classes by two professors who have.
State of the Chapel Union: HPCS Reflections and Musing about the Future, Brad Chamberlain, PGAS 2012, Santa Barbara, CA, October 12th, 2012.
As Chapel's commitments to the HPCS program which spawned it wrap up, this talk captures a brief history of the Chapel project under HPCS, what we perceive to be its contributions and lessons learned, and a glimpse toward its future.
Chapel Support for Heterogeneous Architectures via Hierarchical Locales, Brad Chamberlain, PGAS-X 2012, Santa Barbara, CA, October 10th, 2012.
This talk provides a sketch of work that we are currently undertaking to extend Chapel's locale concept to support hierarchical and heterogeneous compute nodes, contrasting the work with previous approaches with Sequoia and Hierarchical Place Trees.
Multiresolution Parallel Programming with Chapel [video], Vassily Litvinov, HPC Advisory Council Conference, Malaga, Spain, September 13th, 2012.
Multiresolution Parallel Programming with Chapel, Vassily Litvinov, University of Malaga Dept. of Computer Architecture Seminar, September 11th, 2012
These talks provide a Chapel overview and highlight collaborative work with the University of Malaga on dynamic iterators and UIUC on targeting GPUs.
Exascale: Your Opportunity to Create a Decent HPC Language, Brad Chamberlain, PPME workshop, Portland OR, August 14th, 2012
This talk was created as a call to arms for the DOE Exascale community, arguing that rather than simply being a time of challenges, Exascale can also be a time to break free of traditional lower-level programming models and create the first truly decent HPC programming language.
Chapel: Multiresolution Parallel Programming, Brad Chamberlain, AMD Fusion Developer Summit, Bellevue WA, June 11th, 2012
A fairly standard Chapel overview talk for the AMD community, with some emphasis on support for next-generation compute nodes like AMD Fusion
Chapel: Parallel Programming Made Productive, Brad Chamberlain, Seattle University Seminar, May 2, 2012
This is an overview of Chapel aimed at undergraduates; as such, it starts with motivation for parallel programming and some basic terminology before going through Chapel's motivating themes and major concepts.
Chapel: Striving for Productivity at Petascale, Sanity at Exascale Brad Chamberlain, I2PC Seminar, UIUC, April 8, 2012
This talk provides an overview of Chapel and its background before diving into its support for user-defined domain maps and forall loops; it then talks about some of the challenges for exascale and why we believe Chapel is well-positioned to tackle them.
Chapel: Productivity at Petascale, Promise for Exascale, Brad Chamberlain, 40th SPEEDUP Workshop on High-Performance Computing, February 6, 2012
This talk provides an overview of Chapel and its motivating themes for current architectures and then goes on to outline its promise and challenges for next-generation architectures.
Chapel: Parallel Programmability for HPC (and your desktop too!) [audio/video], Brad Chamberlain, University of Washington, January 26, 2012
This talk is part motivation for Chapel, part overview of language features, part overview of recent research efforts in user-defined array types and parallel loop schedules. It also connects the dots between HPC concerns and emerging mainstream parallel computing concerns than most of our talks.
Chapel: Striving for Productivity at Petascale, Sanity at Exascale, Brad Chamberlain, LLNL, December 14, 2011.
This talk provides some background motivation for Chapel, gives examples from its feature set, and provides a brief introduction to user-defined domain maps and parallel iterators. It wraps up with some project status and next steps.
Exascale: An Opportunity to Atone for the Parallel Programming Models of the Past?, Brad Chamberlain, Punctuated Equilibrium at Exascale Panel/BoF, November 17th, 2011.
This is a panel talk arguing for programming models that are further abstracted from machine architecture and exascale as being an appropriate time for this change.
Chapel Lightning Talks BoF, November 16th, 2011.
This was a session that featured a number of 5-minute talks on Chapel-related activities from various members of the broad Chapel community
Chapel HPC Challenge Entry: 2011, HPC Challenge BoF, November 15th, 2011.
This is a brief overview of our 2011 HPC Challenge entry which won the "most elegant" award.
Chapel: Making Large-Scale Programming Productive, Brad Chamberlain, Google Technical Talk, August 10, 2011.
This talk starts with an example-oriented introduction to Chapel and then moves on to talk about its support for user-defined parallel iterators and data distributions.
Five Things About HPC Programming Models I Can Live Without, Sung-Eun Choi, DOE Workshop on Exascale Programming Challenges, July 27, 2011.
This talk lists some of the things that we think make HPC programming non-productive today and gives examples of how we are trying to address them in Chapel.
Programming Models and Chapel: Landscaping for Exascale Computing [podcast], Brad Chamberlain, INT Exascale Workshop, June 30, 2011.
This talk surveys current HPC programming models with respect to the petascale and exascale computing. It then goes on to describe the rationale for Chapel's design and how we think it is better-suited for exascale computing than the status quo.
Chapel's Data-Centric Approach to Parallelism and Locality, Brad Chamberlain, Future Approaches to Data-Centric Programming for Exascale Workshop (at IPDPS'11), May 20, 2011.
This talk argues that using higher-level, data-centric programming notations relaxes the constraints that a program places on the implementing compiler and runtime, permitting it to better exploit the asynchrony of exascale architectures.
Panel: Programming Models at Exascale: Are We Ready for the Challenges?, Brad Chamberlain, Future Approaches for Data-Centric Programming for Exascale, May 20, 2011.
This panel talk considers the readiness of the community's programming models for exascale programming.
Data-Oriented Programming Models with Asynchronous Tasks: Yielding Some Control in a Community of Control Freaks, Brad Chamberlain, Salishan Conference on High-Speed Computing, April 28, 2011.
This talk argues that using higher-level, data-centric programming notations relaxes the constraints that a program places on the implementing compiler and runtime, permitting it to better exploit the asynchrony of exascale architectures.
Chapel Meets Serious Applications: Evaluating a High Productivity Language, Jonathan Claridge (UW), Jonathan Turner (CU Boulder), John Lewis (Cray Inc.), SIAM CSE 2011 MiniSymposium MS65, March 2, 2011.
This was a series of talks providing an introduction to Chapel, much of it from the point of view of applied mathematicians in the context of some motivating computations.
Chapel's Downward-Facing Interfaces, Brad Chamberlain, March 2011.
This talk describes Chapel's downward-facing interfaces -- its runtime library interfaces and its user-defined domain map interfaces
Adaptive Mesh Refinement in Chapel: An Acid Test for High Productivity Programming, Jonathan Claridge (UW), Cray Inc. Technical Forum, December 2, 2010.
This talk reports on a summer intern's experiences writing Adaptive Mesh Refinement (AMR) code in Chapel based on no prior experience with Chapel but plenty with AMR computations (primarily serial).
Five Key Parallel Design Decisions (for Multicore, Petascale, and Beyond), Brad Chamberlain, Barcelona Multicore Workshop, October 22, 2010.
This talk considers five design decisions that parallel language designers should wrestle with and how Chapel's design deals with them.
A Comparison of a 1D Stencil Code in Co-Array Fortran, Unified Parallel C, X10, and Chapel, Steve Deitz, IDRIS, May 27, 2010.
This talk presents a head-to-head comparison of some common PGAS languages by implementing a 1D stencil computation in them.
PGAS, Global Arrays, and MPI-3: How do they fit together?, Brad Chamberlain, Global Arrays Workshop, May 7, 2010.
This talk provides a brief overview of PGAS languages in general and Global Arrays' place as a PGAS language specifically; the potential role of MPI-3 in supporting PGAS languages; and the relationship between GA and the HPCS languages.
HPC Programming Models: Current Practice, Emerging Promise, Brad Chamberlain, SIAM Conference on Parallel Processing for Scientific Computing (PP10), February 25, 2010.
This talk rants about the ongoing lack of truly productive HPC programming models while trying to provide rationale for some of the themes we are pursuing in Chapel.
Programming Models at the Exascale, Brad Chamberlain, Cross-cutting Technologies for Computing at the Exascale, February 2, 2010.
This was a plenary talk on the topic of programming model issues for exascale computing. It was a mix of reporting out from earlier DOE exascale workshops combined with some of my own opinions/insights.
An Example-Based Introduction to Global-view Programming in Chapel, Brad Chamberlain, User Experience and Advances in Bridging Multicore's Programmability Gap (SC09 workshop), November 16, 2009.
This talk provides a purely example-based introduction to Chapel's themes and features including stencils, graph-based computations, task parallelism, and some early GPU computing results.
Chapel: the Cascade High Productivity Language [video], Brad Chamberlain, Universitat Poitecnica de Catalunya, October 22, 2009.
This is a fairly standard overview of Chapel's motivating themes, features, and status.
Chapel: The Cascade High Productivity Language, Brad Chamberlain, Bridging Multicore's Programmability Gap, November 17, 2008
This is an overview of Chapel's motivating themes, features, and status with an emphasis on multicore programming.
Chapel: The Cascade High Productivity Language, Brad Chamberlain, UT Austin, June 3, 2008
an overview talk at UT Austin with an emphasis on code examples and ZPL
Chapel: Compiler Challenges, Steve Deitz, LCPC, October 21, 2005
These are slides from a panel presentation between the HPCS vendors held at LCPC. They give a brief overview of the language and then enumerate some of the compilation challenges that we anticipate (or are currently dealing with), given our language choices.

 

[Note: We haven't completed archiving other early Chapel talks by Brad Chamberlain, Steve Deitz, and David Callahan, but reach out if you're looking for something specific]