Accelerator BOF at GNU Tools Cauldron

[Torvald Riegel <triegel at redhat dot com>]

We will have a BOF on accelerators at GNU Tools Cauldron: Sunday July
14, 11:30am.  Below is an abstract.  If you have any comments in
advance, for example further suggestions about what to discuss at his
BOF or at Cauldron, please let me know.


In this BOF, we will discuss how we can support accelerators (e.g.,
GPGPUs) in GCC.  This is a rather wide problem and raises questions
ranging from which programming abstractions to support (e.g., OpenMP 4.0
accelerator extensions, OpenACC, and others) to which accelerator
(virtual) ISAs to support -- and everything in between.  Therefore, the
primary goal of this BOF is to start the discussion about how to
approach this problem and which initial steps we might take.

Possible sub-topics for discussion include:
* Front-end issues: Which programming abstractions for parallelization
  on accelerators at the programming-language level do we target first? 
  OpenMP 4.0 will include accelerator abstractions; OpenACC has similar
  features.  Are there features that are shared across several
  programming abstractions (e.g., ways to put constraints on regions of
  code so that it can indeed be executed on a particular accelerator)?
* Which infrastructure do we need in the middle-end to support different
  language-level abstractions without a lot of duplicated code?  Which
  GCC-internal abstractions do we need?  Can we have a single shared
  internal representation of accelerator code?  How do we deal with
  issues such as heterogeneous accelerator hardware or separate address
  spaces on accelerators?  How do we represent communication between
  hosts and accelerators?  Is the current SIMD support sufficient for
  accelerator code too?
* Back-end questions: Which (virtual) architectures do we want to target
  first?  Should we target low-level programming abstractions such as
  OpenCL, too?  Which additional runtimes do we want to -- or need to --
  bind to?  Can/should we target existing runtimes, or do we need to
  build our own (glue) layers?
* Testing: Do we need anything special to test all of this?
* Other GNU tools:  What do we need to do in other tools such as GDB?


Torvald