The Chapel Parallel Programming Language


Archived Chapel Presentations (reverse chronologically)

Cosmological Particle Mesh Simulations in Chapel, 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: 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 Lanugage 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.