Porting and Benchmarking Chapel on Emerging RISC-V Hardware: An HPC Viability Study

summary

The gist

The paper discusses the porting and benchmarking of Chapel on RISC-V hardware to assess its viability for High Performance Computing (HPC) applications.

In short

The study ported Chapel and its Qthreads runtime to RISC-V hardware to assess its potential for High Performance Computing (HPC). Porting was straightforward, requiring minor assembly changes. Performance comparisons against established x86 and ARM systems showed RISC-V lagging in some benchmarks but highlighted lower cost and power consumption. The results suggest RISC-V is a promising future path for HPC if performance gaps can be closed.

Key concepts

Chapel
Chapel is an open-source parallel programming language designed to improve the productivity, portability, and scalability of high-performance computing applications. It uses a global-view programming model that allows programmers to express parallelism across shared-memory systems, distributed clusters, and accelerators.
Qthreads
Qthreads is the lightweight threading runtime used by Chapel. It handles multiplexing the work of many lightweight threads over available hardware resources. Its synchronization mechanism relies on flexible full-empty bit synchronization to manage thread interactions efficiently.
RISC-V Architecture
RISC-V is a relatively new Instruction Set Architecture (ISA) being explored for use in HPC. The paper tests its viability by porting Chapel to this architecture, noting that while current systems are preliminary, future server-class RISC-V chips could become competitive in the HPC market.
Performance Portability
This concept refers to the need for software to maintain good performance across different underlying hardware architectures. The paper stresses that adding new architectures is easier when using modern interfaces like C11 atomics, but closing performance gaps requires specific improvements, such as vectorization support.

Terminology used across episodes

This episode discusses

The paper

Porting and Benchmarking Chapel on Emerging RISC-V Hardware: An HPC Viability Study · Read on arXiv

Ian Henriksen, Chris Taylor, Patrick Diehl, Jade Abraham, Palmer Cox, Bradford L. Chamberlain, Stephen L. Olivier

Sandia National Laboratories · Tenstorrent Company Inc. · Los Alamos National Laboratory Los Alamos National Laboratory Los Alamos National Laboratory Hewlett Packard Enterprise Hewlett Packard Enterprise FiscalNote

The Chapel programming language recently added support for the RISC-V architecture. Here we discuss what changes were needed for Chapel to work on RISC-V as well as lessons learned from the porting process. We use some of Chapel's extensive benchmark suite to gain further insight into the suitability of the RISC-V architecture for future HPC use. We compare performance on SiFive P550 and Unmatched boards and a Sophon SG2042 with a variety of other recent HPC CPU platforms. Various portability and performance anomalies arose on different architectures and are discussed. While the RISC-V machines represent smaller preliminary offerings and not HPC-class hardware, these results still provide hope that RISC-V hardware can become viable for HPC in the near future.

Transcript

Introduction to the show: ident: Computer Science. The day in computer science: software, systems and theory on arXiv.

Tom: We're looking at the paper: "Porting and Benchmarking Chapel on Emerging RISC-V Hardware".

Jane: Here's the gist of the paper. The paper discusses the porting and benchmarking of Chapel on RISC-V hardware to assess its viability for High Performance Computing (HPC) applications.

Tom: The results suggest that while current RISC-V systems are not yet competitive with established architectures, they offer a promising path for future HPC use due to their lower cost and power consumption.

Jane: Porting Challenges and Modifications Porting Chapel and its Qthreads runtime to RISC-V was found to be straightforward, primarily because the codebase minimizes platform-specific assembly through modern interfaces like C11 atomics.

Tom: The main nontrivial code change involved adding a "RISC-V assembly implementation of fast context swaps to Qthreads".

Paper summary: Tom: So we're looking at this paper, "Porting and Benchmarking Chapel on Emerging RISC-V Hardware: An HPC Viability Study." The main point here is they tested if you could actually run Chapel on RISC-V for High Performance Computing and what the experience was like.

Jane: Right, so it starts by saying they ported the Chapel programming language, which uses a threading runtime called Qthreads, over to the RISC-V architecture. The big question is whether this effort was really straightforward or if it hit some major roadblocks.

Lu: What's interesting is that the authors found porting itself wasn't super hard because Chapel already minimizes platform specific assembly by using modern things like C11 atomics as a portability interface, but there was one key change they had to make for the Qthreads part.

Meng: What was that specific change? Was it something totally unexpected when you're dealing with a new instruction set architecture?

Tom: It was adding an assembly implementation for fast context swaps in Qthreads, which is pretty technical stuff but shows how much low level work is still required even with good interfaces.

Jane: And they didn't just stop there; they used Chapel’s whole benchmark suite to test it out on different chips, comparing performance across things like the SiFive P550 and Unmatched boards against some really established ARM and xeighty-six processors.

Lu: They compared these new RISC-V systems against server class machines like the Nvidia Grace Grace and Intel Granite Rapids, which is important because that's where you expect to see serious HPC performance.

Meng: So what did those comparisons actually show? Did the Chapel code run fast enough to be considered viable for real HPC work?

Tom: Well, they found that the cutting edge systems like Grace and Granite Rapids generally performed best in the Computer Language Benchmarking Game benchmarks, except when it came to synchronization benchmarks.

Jane: That's a big detail because synchronization is usually where you really test how well a parallel language handles all those threads working together.

Lu: For instance, on the Mandelbrot benchmark, they noted that the performance gap between the RISC-V machines and those state of the art Grace and Granite Rapids machines was quite pronounced in that specific test.

Meng: Okay, so it's slower in some areas then? What about synchronization benchmarks like Chameneos Redux, which tests how well threads communicate?

Tom: The results there were even more telling, showing that Grace performed far worse than even the Unmatched machine on those synchronization benchmarks.

Jane: This leads us to the cost and power aspect, which is a huge part of why people look at RISC-V in the first place—it’s much cheaper and uses less power than those top tier server systems.

Paper summary: Lu: The paper points out that adding a new architecture like this is modest effort, but maintaining performance on established architectures requires substantial ongoing work, and the cost difference between consumer and server class machines shows up dramatically in both cost and power usage.

Meng: If we're looking at deployment right now, what does that mean for someone trying to ship a model using Chapel? Is it practical?

Jane: The paper suggests that while current RISC-V systems aren't competitive with the absolute best, they are far less expensive, which is a major factor for future HPC use.

Tom: They express hope that recent announcements about server class RISC-V hardware could result in competitive performance and widespread adoption in the near future.

Lu: But they also flag some limitations that keep it from being ready right now, like the lack of commercial GPU runtime support on RISC-V and limited support for high performance communication layers like InfiniBand.

Meng: So, if I'm thinking about a real production workload today, what are those missing pieces that make it not ready?

Jane: The performance gaps they see in the benchmarks are largely likely due to things like the lack of vectorization because none of the tested RISC-V machines supported RVV version one point zero.

Tom: It really highlights a growing need for something called performance portability, not just traditional architecture portability, which means software needs to run well across different hardware even if they aren't perfect yet.

Lu: The authors stress that specific improvements, like hardware supporting the RVV extensions and new RISC-V chips targeting the server market, give them hope that those performance gaps can be closed.

Meng: So, to sum it up for someone in the industry, is this a green light for using RISC-V today?

Jane: Not quite yet; current systems are not competitive with state of the art machines like Grace or Granite Rapids, but they are significantly less expensive and power hungry.

Tom: The title of this paper, "Porting and Benchmarking Chapel on Emerging RISC-V Hardware: An HPC Viability Study," really frames it as a deep dive into whether this emerging architecture has the potential to compete in high performance computing.

Lu: They conclude that while the observed performance gaps are there now, those gaps can be closed with future server class RISC-V chips.

Meng: That's a lot of hope for tomorrow, but what about the immediate reality of deploying something like this?

Jane: The paper emphasizes that the effort needed to add a new architecture is modest when you use C11 atomics for portability, but getting the performance right still requires more specialized hardware support.

Tom: So, the main message is that we need more work on performance portability, and those new server class RISC-V chips are what will likely get us there.

Conclusion: Tom: So we've been looking at how they ported Chapel to RISC-V and benchmarked it against big systems like Grace and Granite Rapids, and now we're wrapping up with the conclusion of this paper.

Jane: Right, so this whole study is really about whether this new RISC-V hardware actually has a shot at High Performance Computing work.

Lu: It boils down to the fact that while the effort to port Chapel was manageable because they used C11 atomics, getting the actual performance numbers right still depends on specific hardware features.

Meng: So, what does this mean for someone who's trying to deploy a production workload using this language? Is it ready for real use today?

Tom: The paper says that current RISC-V systems aren't matching those top server machines yet, but they are way less expensive and use much less power.

Jane: They point out that the performance gaps they see right now are mostly due to things like a lack of vectorization because none of the tested RISC-V machines supported the RVV version one point zero instruction set.

Lu: That’s a major caveat, I think. The authors are hopeful that future server class RISC-V chips will bring those performance numbers up to where they can actually compete for real HPC jobs.

Tom: So the main message is that we need to keep pushing for performance portability, not just architecture portability, if we want this path to work out.

Jane: It seems like the whole point of this research isn't just showing what it *can* do now, but showing what kind of hardware announcements will make it viable in the near future.

Lu: Exactly. The authors are essentially saying that if they get better vector support and new server chips come out, those performance gaps they see today can be closed.

Meng: So it’s a long-term bet, then. We’re still looking at future hardware announcements to make this actually practical for production deployment right now.

Tom: Right. It sets the stage for what we need to watch next—specifically, those new server class RISC-V chips that might finally bring the performance up to speed on Chapel code.

More episodes

← Home