GNU Tools Cauldron 2019

<< GNU Tools Cauldron 2018 | GNU Tools Cauldron 2020 >>

group_photo_2019.jpg


Sponsors

As always, the GNU Cauldron is only possible thanks to the generous support from sponsors. They allow to the Cauldron to remain free to attend, and therefore as accessible as possible. If you would like to sponsor this year's event, please email tools-cauldron-admin@googlegroups.com.

This year's edition is organized by EfficiOS and Embecosm. It is sponsored by:

mentor-logo.png

adacore-logo.png

redhat-logo.png

facebook-logo.png

arm-logo.png

intel-logo.png

ibm-logo.png

efficios-logo.png

embecosm-logo.png

* Intel and the Intel logo are trademarks of Intel Corporation in the U.S. and/or other countries.

Slides and Videos

The videos are currently available on YouTube. We are in the process of uploading them to another platform, the links will be available below when they are ready.

Talk

Slides

Video

20+ years after EGCS, rethinking GCC development processes

A New Debug Server to support modern GDB on embedded platforms

A year of experience with broad based continuous testing with GCC

ABI and Implementation Issues for Coexistant TOC-Based and PC-Relative Addressing

slides

Adding Linux restartable sequence (rseq) support in glibc

slides

AMD GCN GPU Port Update

slides

Annobin - A Tale of A GCC Plugin's Lows & Highs

slides

Annotating std::string with AddressSanitizer

slides

c++ coroutines, function and implementation in GCC

slides

C++ hardware_constructive/destructive_interference_size

C++ Modules & Tooling

CGEN for RISC-V

slides

Common-base store/load with RISC-V GCC

slides

Compact C Type Format Support in the GNU Toolchain

slides

Compact storage and analysis of DejaGNU test logs

slides

eBPF support in the GNU Toolchain

Function address significance and nop+fallthrough aliases

slides

GCC/LLVM Collaboration BoF

slides

GDB on s390x: To-dos and challenges

slides

GDB tests, CI & Buildbot BoF

slides

GDB: Tab-completion & command options - frameworks for usability improvements

slides

glibc development workflows

glibc support for Unikernel/LibraryOS

slides

GNU poke, an extensible editor for structured binary data

GNU Toolchain Advocacy BoF

Inline expansion of string and memory instructions to improve performance on PPC64LE

slides

OpenACC/OpenMP/offloading (OMP, Offloading and Multi Processing) BoF

Optimising SPEC CPU 2017 with GCC

slides

Parallelizing GCC: Status and Expectations

slides

Power ISA transactional memory registers in GDB (Cancelled)

Project Ranger: On demand, precise value ranges. Overview, status, & plans for gcc-10 and beyond.

slides

Register allocation

slides

Reproducible Toolchains For The Win!

slides

RISC-V bit manipulation extension

slides

rs6000/PowerPC/Power

Signaling floating point comparisons

Status update on reworking OpenACC 'kernels' support in GCC: automatic parallelization of loop nests

slides

Supporting upcoming extensions to the IBM mainframe

slides

The Arm / AArch64 BoF

slides

The elfutils debuginfo server

slides

The GDB BoF

slides

The GNU C Library BoF

The LTO/IPA BoF

The RISC-V BoF

slides

Truly inter-procedural IPA-SRA pass

slides

Tweaking the compiler for fewer false negatives in -Wuninitialized

slides

Using combined elimination with GCC to minimize compiled code size: A case study

Using Embench to measure the performance of GCC for deeply embedded targets

slides

Mailing lists

  1. Abstract submissions, registration, administrivia questions: tools-cauldron-admin@googlegroups.com

  2. Announcements and discussions related to the conference: gcc@gcc.gnu.org

Workshop description

We are pleased to announce another gathering of GNU tools developers. The format of this meeting will be similar to the previous meetings. The purpose of this workshop is to gather all GNU tools developers, discuss current/future work, coordinate efforts, exchange reports on ongoing efforts, discuss development plans for the next 12 months, developer tutorials and any other related discussions.

This year, the GNU Tools Cauldron crosses the Atlantic Ocean and lands in Montréal, Canada.

We are inviting every developer working in the GNU toolchain: GCC, GDB, binutils, runtimes, etc. In addition to discussion topics selected at the conference, we are looking for advance submissions.

Registration

If you intend to participate (even if not presenting), please let us know. Send a message to tools-cauldron-admin@googlegroups.com stating your intent to participate. Please indicate:

Please tell us as soon as possible if you need a letter of invitation in order to secure a visa (see below).

Visa and Electronic Travel Authorization

You can use this tool to determine if you need a visa or Electronic Travel Authorization to enter Canada as a business visitor. If you need a letter of invitation to apply for a visa, please let us know as soon as possible.

The process to get an Electronic Travel Authorization is simpler than a visa, but it is still recommended to not wait until the last minute to apply for one.

Travel Grants for Students

The GNU Tools Fund sponsors student travel to attend the GNU Cauldron. Travel grants cover some or all of travel related expenses. This program is open to full time undergraduate and graduate students.

Students should email information about their participation in the GNU Toolchain, interests, experience, an estimated budget, and any sponsors in the GNU Toolchain community to tools-cauldron-admin@googlegroups.com.

The deadline to submit a request is 31 July 2019.

Submitting talks/BoFs/tutorials

If you have a topic that you would like to present, please submit an abstract describing what you plan to present. We are accepting four types of submissions:

Note that we will not be doing in-depth reviews of the presentations. Mainly we are looking for applicability and to decide scheduling. There will be time at the conference to add other topics of discussion, similarly to previous meetings.

To register your abstract, send e-mail to tools-cauldron-admin@googlegroups.com .

Your submission should contain the following information:

Code of Conduct

All participants are expected to by the conference Code of Conduct. As in 2018, we shall use the British Computer Society Open Source Special-ist Group Code of Conduct.

GDPR compliance

The personal information we hold on you is your name, email address, affiliation, dietary preferences, T-shirt size. This information will only be used to contact you about the arrangements for the GNU Tools Cauldron 2019, including a follow-up questionnaire after the event. The data is held securely on outsourced secure servers where the data is encrypted. The data is only accessible by the organisers of the GNU Tool Cauldron 2019. All the data will be destroyed shortly after the GNU Tools Cauldron, once the follow-up questionnaire has been sent out.

Please contact the Data Officer if you would like to know the information we hold on you, wish to have that information deleted, or for any other queries related to GDPR.

Schedule

Conference

Last update: 2019-08-13 11:40:21 (EDT)

Friday, 13 September

Time

Auditorium

Room M.450

Room M.460

9:00 - 10:00

Registration, tea & coffee

10:00 - 11:00

GNU poke, an extensible editor for structured binary data

Update on reworking OpenACC 'kernels' support in GCC: automatic parallelization of loop nests

Project Ranger: On demand, precise value ranges. Overview, status, & plans for gcc-10 and beyond

11:00 - 12:00

The elfutils debuginfo server

c++ coroutines, function and implementation in GCC

glibc support for Unikernel/LibraryOS BoF

12:00 - 13:00

Lunch

13:00 - 14:00

Lightning talks 1

- AMD GCN GPU Port Update
- Function address significance and nop+fallthrough aliases
- Tweaking the compiler for fewer false negatives in -Wuninitialized
- Compact storage and analysis of DejaGNU test logs
- A New Debug Server to support modern GDB on embedded platforms

Signaling floating point comparisons (BoF)

glibc development workflows

14:00 - 15:00

eBPF support in the GNU Toolchain

Inline expansion of string and memory instructions to improve performance on PPC64LE

Register allocation BoF

15:00 - 15:30

Afternoon tea & coffee

15:30 - 16:30

ABI and Implementation Issues for Coexistant TOC-Based and PC-Relative Addressing

The Arm / AArch64 BoF

C++ Modules & Tooling BoF

16:30 - 17:30

Reproducible Toolchains For The Win!

Parallelizing GCC: Status and Expectations

OpenACC/OpenMP/offloading (OMP, Offloading and Multi Processing) BoF

Saturday, 14 September

Time

Auditorium

Room M.450

Room M.460

9:30 - 10:00

Registration, tea & coffee

10:00 - 11:00

GCC Steering Committee Q&A

11:00 - 12:00

GNU Toolchain Advocacy BoF

C++ hardware_constructive/destructive_interference_size BoF.

12:00 - 13:00

Lunch

13:00 - 14:00

Truly inter-procedural IPA-SRA pass

GDB: Tab-completion & command options - frameworks for usability improvements

14:00 - 15:00

20+ years after EGCS, rethinking GCC development processes BoF

GDB on s390x: To-dos and challenges

15:00 - 15:30

Afternoon tea & coffee

15:30 - 16:30

A year of experience with broad based continuous testing with GCC

The GNU C Library BoF

The GDB BoF

16:30 - 17:30

Annobin - A Tale of A GCC Plugin's Lows & Highs

rs6000/PowerPC/Power BoF

GDB tests, CI & Buildbot BoF

Sunday, 15 September

Time

Auditorium

Room M.450

Room M.460

9:30 - 10:00

Registration, tea & coffee

10:00 - 11:00

Lightning talks 2

- Using Embench to measure the performance of GCC for deeply embedded targets
- Using combined elimination with GCC to minimize compiled code size: A case study
- CGEN for RISC-V
- RISC-V bit manipulation extension
- Common-base store/load with RISC-V GCC

The LTO/IPA BoF

11:00 - 12:00

Annotating std::string with AddressSanitizer

Compact C Type Format Support in the GNU Toolchain

The RISC-V BoF

12:00 - 13:00

Lunch

13:00 - 14:00

Supporting upcoming extensions to the IBM mainframe

Optimising SPEC CPU 2017 with GCC BoF

14:00 - 15:00

Adding Linux restartable sequence (rseq) support in glibc

GCC/LLVM Collaboration BoF

Thursday night reception

If you are in town early enough the day before the conference (Thursday, September 12), you are invited to meet your fellow Cauldroners for a snack and some drinks.

We will be on their rooftop terrace, which you can access directly using these stairs. The conference offers attendees cocktail-style food and one drink, but you can of course get more at your own expense.

Saturday night dinner

Attendees are invited to the Cauldron dinner, the Saturday night of the conference.

The dinner will be held in the main hall of the museum. At some point during the night, we will have access to the museum's permanent exposition, which starts with a 17-minutes multimedia presentation about the history of Montreal.

The conference offers attendees the food as well two alcoholic beverages (non-alcoholic beverages are complimentary). A cash bar will be available afterwards.

Pointe-a-Calliere_02.jpg

(Photo by Jean Gagnon, distributed under CC BY-SA 3.0)

Abstracts

Below is the list of confirmed talks, BoFs and Q&A sessions. If you would like to present a talk or lead a BoF/Q&A session, please see the instructions above.

  1. Talks

    1. A year of experience with broad based continuous testing with GCC

    2. ABI and Implementation Issues for Coexistant TOC-Based and PC-Relative Addressing

    3. Adding Linux restartable sequence (rseq) support in glibc

    4. Annobin - A Tale of A GCC Plugin's Lows & Highs

    5. Annotating std::string with AddressSanitizer

    6. c++ coroutines, function and implementation in GCC

    7. Compact C Type Format Support in the GNU Toolchain

    8. eBPF support in the GNU Toolchain

    9. GDB on s390x: To-dos and challenges

    10. GDB: Tab-completion & command options - frameworks for usability improvements

    11. glibc support for Unikernel/LibraryOS

    12. GNU poke, an extensible editor for structured binary data

    13. Inline expansion of string and memory instructions to improve performance on PPC64LE

    14. Parallelizing GCC: Status and Expectations

    15. Power ISA transactional memory registers in GDB (Cancelled)

    16. Reproducible Toolchains For The Win!

    17. Status update on reworking OpenACC 'kernels' support in GCC: automatic parallelization of loop nests

    18. Supporting upcoming extensions to the IBM mainframe

    19. The elfutils debuginfo server

    20. Truly inter-procedural IPA-SRA pass

  2. Lightning Talks

    1. A New Debug Server to support modern GDB on embedded platforms

    2. AMD GCN GPU Port Update

    3. CGEN for RISC-V

    4. Common-base store/load with RISC-V GCC

    5. Compact storage and analysis of DejaGNU test logs

    6. Function address significance and nop+fallthrough aliases

    7. RISC-V bit manipulation extension

    8. Tweaking the compiler for fewer false negatives in -Wuninitialized

    9. Using combined elimination with GCC to minimize compiled code size: A case study

    10. Using Embench to measure the performance of GCC for deeply embedded targets

  3. Birds of a Feather (BoFs)

    1. 20+ years after EGCS, rethinking GCC development processes

    2. C++ hardware_constructive/destructive_interference_size

    3. C++ Modules & Tooling

    4. GCC/LLVM Collaboration BoF

    5. GDB tests, CI & Buildbot BoF

    6. glibc development workflows

    7. GNU Toolchain Advocacy BoF

    8. OpenACC/OpenMP/offloading (OMP, Offloading and Multi Processing) BoF

    9. Optimising SPEC CPU 2017 with GCC

    10. Project Ranger: On demand, precise value ranges. Overview, status, & plans for gcc-10 and beyond.

    11. Register allocation

    12. rs6000/PowerPC/Power

    13. Signaling floating point comparisons

    14. The Arm / AArch64 BoF

    15. The GDB BoF

    16. The GNU C Library BoF

    17. The LTO/IPA BoF

    18. The RISC-V BoF

  4. Q&A Sessions

    1. GCC Steering Committee Q&A

Talks

A year of experience with broad based continuous testing with GCC

Speaker: Jeff Law (Red Hat)

In 2018 I brought up a continuous testing system for GCC focused on finding generic issues by performing testing across a broad spectrum of targets. We will discuss the basics of the testing currently done, experiences (good and bad) as well as future directions.

ABI and Implementation Issues for Coexistant TOC-Based and PC-Relative Addressing

Speaker: Michael Meissner, Bill Schmidt (IBM)

slides

Existing 64-bit ABIs for the POWER processor use a table-of-contents (TOC) pointer for access to static and global data. In a future version of the POWER architecture, we plan to introduce new instructions to provide PC-relative addressing. In this talk, we will discuss how we are modifying the ABI to permit either TOC or PC-relative addressing to access static and global data, including programs that contain both types of references. We will also discuss the changes we are making to the GCC compiler to support PC-relative addressing.

Adding Linux restartable sequence (rseq) support in glibc

Speaker: Mathieu Desnoyers (EfficiOS)

slides

Restartable Sequences, a system call speeding up user-space operations on per-CPU data, made its way into the 4.18 Linux kernel.

This talk describes the basics of the rseq algorithm, going through the integration proposed for glibc 2.31. It presents the use-cases covered by the rseq system call, including memory allocators, per-CPU ring buffers, or just speeding up getting the current CPU number. Integration needed within GDB and emulators will also be discussed.

A discussion follows on the limitations of the current rseq system call, presenting missing pieces of kernel infrastructure required to cover additional use-cases.

Annobin - A Tale of A GCC Plugin's Lows & Highs

Speaker: Nick Clifton (Red Hat)

slides

The annobin plugin for gcc has proved to be an effective component in a suite of tools designed to help system builders monitor how packages are built and verify that the necessary security options are being used. But its development and deployment has not been easy.

This talk will cover some of the trials faced whilst developing the plugin, the fixes used to overcome the harder obstabcles and some thoughts on the future of gcc plugins in general.

You will laugh, you will cry, you will wonder why you came into the presentation at all.

Annotating std::string with AddressSanitizer

Speaker: Kashkarov Mikhail, Vyacheslav Barinov (Samsung R&D Russia)

slides

One kind of bugs that AddressSanitizer can find with the help of code annotations is "container-overflow": Given std::basic_string v a container-overflow is a memory access inside the range `[v.end(), v.begin() + v.capacity())`, i.e. inside the allocated heap region but outside of the current container bounds. Std::vector is already annotated in both libstc++/libc++, std::string is not upstreamed yet.

We'll discuss standard library sanitization process for std::string and how we applied it to the whole operation system.

c++ coroutines, function and implementation in GCC

Speaker: Iain Sandoe

slides

Coroutines are actually one of the older computer science tools, with the term originally coined in the middle of the last century (in the early days of modern computing). This programming device is a generalisation of the concept of a function; where the generalisation is that, rather than a single entry and exit, a coroutine can be entered, paused and resumed (non-preemptively, and with retention of current state).

A formalisation of the coroutine will be a part of C++20; it was accepted into the working draft for the next International Standard at the February 2019 Working Group 21 meeting.

With the sponsorship of Facebook I have been constructing an implementation of currently proposed facility for inclusion in the GCC C++ front end (and with the necessary middle end support).

The content for the talk is in three areas:

  • A basic discussion of the properties of coroutines and some (necessarily simple) examples.
  • The current design of the implementation for GCC, and the drivers to that.
  • The status of the implementation and plans for the next few months.

Compact C Type Format Support in the GNU Toolchain

Speaker: Indu Bhagat, Nick Alcock, Wei-min Pan (Oracle)

slides

Compact C Type Format (CTF) is a reduced form of debugging information whose main purpose is to describe the type of C entities such as structures, unions, typedefs and function arguments etc.

CTF originated in the Solaris kernel and it has been ported to Linux as part of the DTrace for Linux project. It's been used (via the libdtrace-ctf utility before the support in the GNU toolchain was available) to reduce the size of the debugging information for the Linux kernel and for use in DTrace.

There are many advantages to using CTF, due to its compactness, for many kinds of programs such as stack tracers and unwinders. Usually these programs can't rely on DWARF. DWARF's design (and evolution) strives for generality and expressive power, at the cost of being a rather heavy format to decode and use. For example, evaluating DWARF expressions requires a little interpreter for a stack-based machine. This, which is not problematic for typical "off-line" debugging programs such as symbolic debuggers (GDB), may be inconvenient for "on-line" debugging programs such as unwinders and stack tracers, due to efficiency and security concerns. CTF is a promising format that helps maintain some level of debuggability, even when the size of the executable is an issue and the DWARF info is being stripped out.

For such reasons it's useful to integrate CTF in the GNU toolchain on Linux. This talk will explain how CTF is structured, how we added CTF generation capabilites to gcc, how GDB consumes the CTF information and the role of linker in CTF de-duplication. binutils object file manipulation utilities have been expanded to understand and process this new format.

We believe CTF provides the right foundations for expressing the information needed by programs that need to do "on-line debugging", in a most convenient way.

Note: since the speaker for this talk can't make it to the conference, this presentation will be done remotely.

eBPF support in the GNU Toolchain

Speaker: Jose E. Marchesi (GNU, Oracle)

This talk covers the ongoing effort about adding eBPF support to the GNU Toolchain. eBPF is a virtual machine running within the Linux kernel; initially intended for user-level packet capture and filtering, eBPF has since been generalized to also serve as a general-purpose infrastructure for non-networking purposes.

Binutils support is already upstream. This includes a CGEN cpu description, assembler, disassembler and linker. By the time of the conference a simulator will be available as well, along with GDB support. A GCC backend will be submitted for inclusion upstream before September.

The first part of the talk will be a brief general description of the project, its components, what motivated us to start working on it, and an update on the project's status at the time of the conference.

Then we will discuss the particular challenges of supporting a target like eBPF:

On one hand, the kernel virtual machine has some unique characteristics that have a definitive impact on the tooling, like the in-kernel validator and the specialized contexts in which eBPF programs run. We will show how the tools can help improving the eBPF programmer's experience.

On the other hand, the exact shape of compiled eBPF code is still subject to change, and is in fact rapidly changing and evolving. Initially quite simple in terms of toolchain needs (single compilation units, no linking) this is changing as more kernel systems are being changed/written to be based on eBPF, and as the in-kernel validator is becoming more and more sophisticated. Along with bigger and more complex programs comes the need for more abstraction, hence modularity and code reuse. Kernel hackers are already discussing about bpf-to-bpf calls, run-time linking, and so on. This increased level of ambition and sophistication imposes additional requirements on the tools.

Finally, interoperability with clang/llvm (the other available toolchain supporting eBPF) will be also discussed, in the more general context of ABI and conventions for compiled eBPF, which are still to be (well) defined and documented.

GDB on s390x: To-dos and challenges

Speaker: Andreas Arnez (IBM)

slides

While GDB on s390x is used successfully by many developers, some open issues still remain, usually induced by specialties in the ISA and/or ABI. This talk picks a few that might be of broader interest and outlines the problem, possible solution, and challenges for each.

GDB: Tab-completion & command options - frameworks for usability improvements

Speaker: Pedro Alves (Red Hat)

slides

In the past few releases, a number of frameworks emerged within GDB with the aim of improving GDB's CLI usability. I'll talk about two: TAB-completion, and command options ("print -OPT", etc.).

  • TAB-completion:
    • GDB 8.1 (2018) introduced a new single-pass mechanism to write GDB command completers. I'll explain what requirements led to the new design, how all the pieces fit together (completion_tracker, handle_brkchars, readline, etc.), talk about the user-visible improvements that have meanwhile been built on top since 8.1, and talk about future direction.
  • Command options:
    • Up until recently, each and every GDB command implemented support for command options on its own, leading to user-visible inconsistencies all over the place. Also, GDB did not support TAB-completion for command options at all. The upcoming GDB 8.3 release introduces a new command option framework (gdb::option) that allows adding options to commands like "print -OPTIONS", in a GDB-ish-way, with full support for TAB-completion. I'll go over the framework's design, how all the pieces fit together, and show how to convert an existing command to use the new framework. I'll also show the "print -OPT" options, which were the first usage of the framework, the new "with" command, and more.

glibc support for Unikernel/LibraryOS

Speaker: Isaku Yamahata (Intel)

slides

Recently unikernel/LibraryOS is getting momentum and some technologies already have been deployed in the field. glibc enhancement to help unikenrel/LibraryOS will benefit much and glibc would gain more users. Especially how to hook syscall instruction in glibc shared library. In this session, requirements/possible solution/recommended proposal/future development is discussed for feedback.

Note: since the speaker for this talk can't make it to the conference, this presentation will be done remotely.

GNU poke, an extensible editor for structured binary data

Speaker: Jose E. Marchesi (GNU)

GNU poke is a new interactive editor for binary data. Not limited to editing basic entities such as bits and bytes, it provides a full-fledged procedural, interactive programming language designed to describe data structures and to operate on them. Once a user has defined a structure for binary data (usually matching some file format) she can search, inspect, create, shuffle and modify abstract entities such as ELF relocations, MP3 tags, DWARF expressions, partition table entries, and so on, with primitives resembling simple editing of bits and bytes. The program comes with a library of already written descriptions (or "pickles" in poke parlance) for many binary formats.

GNU poke is useful in many domains. It is very well suited to aid in the development of programs that operate on binary files, such as assemblers and linkers. This was in fact the primary inspiration that brought me to write it: easily injecting flaws into ELF files in order to reproduce toolchain bugs. Also, due to its flexibility, poke is also very useful for reverse engineering, where the real structure of the data being edited is discovered by experiment, interactively. It is also good for the fast development of prototypes for programs like linkers, compressors or filters, and it provides a convenient foundation to write other utilities such as diff and patch tools for binary files.

This talk (unlike Gaul) is divided into four parts. First I will introduce the program and show what it does: from simple bits/bytes editing to user-defined structures. Then I will show some of the internals, and how poke is implemented. The third block will cover the way of using Poke to describe user data, which is to say the art of writing "pickles". The presentation ends with a status of the project, a call for hackers, and a hint at future works.

Inline expansion of string and memory instructions to improve performance on PPC64LE

Speaker: Aaron Sawdey (IBM)

slides

This talk will describe the work I have done to improve inline expansion of strcmp/strncmp/memcmp and other string/memory functions for ppc/ppc64/ppc64le. I'll also discuss performance of inline expansion relative to glibc, and how it exposes the function expanded to all the optimization done in the back half of gcc.

Parallelizing GCC: Status and Expectations

Speaker: Giuliano Belinassi (University of São Paulo)

slides

During GSoC 2019, there was an effort to parallelize GCC internals in the hope of decreasing build times in many-core machines as well as tracking down global states in the compiler. In this presentation, I will show the results obtained so far and discuss what can be expected based on a projection of the current results on other parts of the compiler.

Power ISA transactional memory registers in GDB (Cancelled)

Speaker: Pedro Franco de Carvalho (IBM)

Note: this talk is cancelled due to the speaker not being able to attend the event.

GDB now has support for accessing hardware transactional memory registers on POWER processors. In this talk, I will give an introduction to how transactional memory works in POWER processors, and present how the access to these registers is implemented in GDB. I will also discuss some of the existing issues with debugging programs that use transactional memory in GDB.

Reproducible Toolchains For The Win!

Speaker: Vagrant Cascadian

slides

The Reproducible Builds project promotes a set of software development practices that create an independently-verifiable path from source to binary code, by providing bit-for-bit identical results.

A key component in building software are the toolchains used. Solving reproducibility issues at the toolchain level can sometimes fix thousands of bugs in a single place, rather than patching each individual affected package.

As an interesting side-effect, Reproducible Builds can also assist in verifying license compliance.

This talk will mention some of the past and current issues in toolchains needed to realize Reproducible Builds in the real world. Let's work together to fix outstanding issues and further these efforts!

https://reproducible-builds.org

Status update on reworking OpenACC 'kernels' support in GCC: automatic parallelization of loop nests

Speaker: Thomas Schwinge (Mentor)

slides

With the OpenACC 'parallel' construct (and similar to the OpenMP 'parallel' and other constructs), parallelizable loops nests are explicity marked up with 'loop' directives. In contrast, in the region attached to an OpenACC 'kernels' construct, the compiler is expected to categorize loop nests on its own, identifying and parameterizing those that are suitable for parallelization.

As discussed before, the current implementation of the OpenACC 'kernels' construct is based on GCC's 'parloops' pass (a.k.a. 'pass_parallelize_loops', or 'autopar'), originally created to "distribute iterations of loops into several threads", that is, transform suitable sequential code, annotating it with OpenMP 'parallel for' directives. This implementation, extended to synthesize the corresponding OpenACC directives, turned out to not satisfy the expectations. It is quite limited in the classes of loop nests it handles. While in the OpenMP context this is just a "nuisance" (because any 'parloops' parallelization only is a "bonus" anyway), for OpenACC 'kernels' construct usage this is a real problem: it is crucial for performance to be able to handle many classes of multi-level loop nests, and adequately map these to the levels of parallelism provided by OpenACC: 'gang', 'worker', and 'vector' dimensions.

We'll give an update on the changes implemented (in process of being integrated into GCC trunk) restructuring the compilation flow of OpenACC 'kernels' constructs, and then future work, with some questions to discuss interactively.

Supporting upcoming extensions to the IBM mainframe

Speaker: Andreas Krebbel (IBM)

slides

A future revision of the IBM mainframe architecture will provide several extensions to the instruction set.

In this talk I'll give an overview of the potential hardware changes and explain how we plan to exploit those in GCC and Glibc together with the challenges we are still facing with that.

The elfutils debuginfo server

Speaker: Frank Ch. Eigler, Aaron Merey (Red Hat)

slides

Debugging data is a necessary evil. It is necessary for running debuggers in situ, some tracing tools, or for coredump analysis. It is evil because it is big - potentially many times the size of the binaries. Therefore, software distributions have conflicting needs to generate & keep this data but not burden everyone with its storage.

We will review some degrees of freedom for debugging data distribution, across compiled languages and OS distributions, identifying some of the best practices. We will identify the remaining shortcomings that necessitate exploring yet another way of making debuginfo data available needed.

We will present the elfutils debuginfo-server prototype, where a web service offers a lightweight, build-id-indexed lookup of debuginfo-related data on demand. This service is designed to run on a nearby host, private or shared within teams, or even by OS distributions. Clients built into various debugging type tools will be demonstrated.

Truly inter-procedural IPA-SRA pass

Speaker: Martin Jambor (SUSE)

slides

The "Early IPA-SRA pass" introduced to GCC in 2009 is inter-procedural in the sense that it modified also the callers of the function it operated on but it scheduled as an early intra-procedural pass and this cannot handle recursion and cannot take advantage of LTO. This talk will describe its proposed replacement with a truly IPA pass, scheduled in the IPA pipe-line and operating on the whole call graph. Apart from explaining how the pass makes decisions, it will also discuss changes necessary to the call graphs clone infrastructure to actually carry out IPA-SRA decisions at the gimple level.

Lightning Talks

A New Debug Server to support modern GDB on embedded platforms

Speaker: Simon Cook (Embecosm)

GDB is now very flexible in its ability to debug modern heterogenous multi-core systems. Inferiors do not need to all be the same architecture, complex memory maps can be managed and there is flexibility on when cores and threads run. This all works well on application class platforms, where GDB can be run native, or talk remotely to the Linux gdbserver application.

However GDB servers for embedded platforms have not kept pace. Whilst tools like OpenOCD can provide a basic GDB server interface, they lack the functionality for more complex systems.

In this talk I'll present a new free debug server, capable of unleashing the full power of GDB for embedded heterogenous multicore platforms, whether those platforms are real hardware or pre-silicon simulations. The server can even support "lockstep execution", where two targets, such as a simulation and a hardware implementation are run in parallel to check for any divergence.

AMD GCN GPU Port Update

Speaker: Andrew Stubbs, Thomas Schwinge, (Mentor/CodeSourcery)

slides

The GCN backend was introduced in GCC 9, but that only provides means for running a single thread on the GPU. Since then we've been working on preparing the OpenMP and OpenACC support for upstream. Here we present an update on the current state of the project and future plans for upstreaming.

CGEN for RISC-V

Speaker: Mary Bennett (Embecosm)

slides

(This talk could form part of the RISC-V BoF)

This will review the current state of CGEN for RISC-V. It now supports all the standard instruction set extensions for generation of both assembler/disassember and simulation. By the time of the Cauldron it should also support the draft bit manipulation extension and have initial support for the draft 0.7 vector extension.

(Mary is unable to attend in person. This talk will be presented on her behalf by Jeremy Bennett).

Common-base store/load with RISC-V GCC

Speaker: Nidal Faour (Western Digital)

slides

We have a patch to GCC for RISC-V which should improve code size with -Os. By using an alternative base register, short instructions can be more widely used to load and store values.

We expected this approach to yield significant benefit, and we do see modest improvements in some of our in-house programs, on the other hand the results are not significant but we don’t have any regressions. In this short talk we will summarize the approach we have taken and seek the community support to apply the patch because the benefit in some benchmarks are small, and on other test cases it show big improvements, and it is a clearly a benefit to embedded controller systems.

Compact storage and analysis of DejaGNU test logs

Speaker: Serhei Makarov, Frank Ch Eigler (Red Hat)

slides

Upstream projects must be tested regularly on a variety of system configurations. It is easy to set up an automated testing system. It is much harder to make sense of the enormous volume of test results. When the volume of test results exceeds the developers' capacity to examine them, analysis of test results must be automated.

We will show how to use a Git repo to compress, index, and analyze a large collection of log files from a DejaGNU testsuite. The result is a small and portable dataset (e.g. ~88GB of log files compress to a ~1.4GB Git repo, including an index in JSON format). The indexed log files can be filtered and analyzed with simple Python scripts to detect problems and regressions.

We will summarize some experiments on test results collected from the DejaGNU testsuites of the SystemTap and GDB projects.

Function address significance and nop+fallthrough aliases

Speaker: Alexander Monakov (ISP RAS)

slides

Occasionally GCC needs to emit very short functions that almost immediately branch to another function. In particular, they arise from C++ thunks and also from trivial wrappers created by the ICF (identical code folding) pass when creating function aliases is not possible. GCC places such wrappers and thunks after the branched-to function, which is suboptimal. Ideally function deduplication could use "nop" instructions to separate initial labels of duplicate functions when their addresses are significant.

RISC-V bit manipulation extension

Speaker: Maxim Blinov (Embecosm)

slides

(This talk could form part of the RISC-V BoF)

During this summer I have worked with Jim Wilson and Clifford Wolf to complete support for the draft bit manipulation instruction set extension in GCC. I'll present the result of that work, along with benchmark results using Embench.

Tweaking the compiler for fewer false negatives in -Wuninitialized

Speaker: Vladislav Ivanishin (ISP RAS)

slides

The analysis of uninitialized variables in GCC is known to both produce spurious warnings and fail to report true uninitialized uses. We experimented with adjusting its implementation to reduce false negative rate.

Another objective was having the warning work regardless of the optimization level. To achieve both these goals we moved the pass very early in the pipeline. This indeed uncovered some warnings the mainline compiler misses on some real software (all of them due to the CCP pass folding an undefined value and a constant into that constant) -- but predictably at the cost of raising many more spurious warnings. The rest of the effort was spent suppressing those, mainly via adding essential transformation passes before the warning pass.

This work also uncovered some latent bugs in the predicate aware uninitialized variable analysis, improvements were submitted upstream.

Using combined elimination with GCC to minimize compiled code size: A case study

Speaker: Craig Blackmore (Embecosm)

Combined elimination is a type of iterative compilation. It is not as comprehensive as an exhaustive search (which is intractable), but can yield large improvements, while being quick enough to run with real projects.

I'll present the results of using Combined Elimination with GCC to minimize the size of code compiled for 32-bit RISC-V.

Using Embench to measure the performance of GCC for deeply embedded targets

Speaker: David Patterson (UC Berkeley), Jeremy Bennett (Embecosm, presenter), Cesare Garlati (Hex Five), Palmer Dabbelt (SiFive)

slides

Embench is a GPL licensed benchmark suite developed by a team under the leadership of David Patterson at Berkeley. Embench is derived from BEEBS, which in turn derives from a number of other free benchmarks suites. In its initial form it is aimed at deeply embedded platforms, with up to 64kB of RAM and 64kB of ROM, such as are widely used in IoT devices.

I'll present the results of using Embench to compare GCC performance for several popular embedded architectures, and look at what conclusions can be drawn from the results.

Birds of a Feather (BoFs)

20+ years after EGCS, rethinking GCC development processes

Led by: Jeff Law (Red Hat)

20+ years ago the EGCS project was unveiled in an effort to jump start GCC development. The time has come to evaluate our development practices to help ensure a viable development community in the future. Maintainers vs consensus, patches vs pull requests, regression testing vs continuous testing, development schedules, release criteria, coding conventions, automated tools, etc it's all up for discussion. Ideally we will leave with 3-5 concrete ideas to experiment with to reduce friction for GCC developers.

C++ hardware_constructive/destructive_interference_size

Led by: Thomas Rodgers (Red Hat)

C++17 introduced two new constants:

  • std::hardware_destructive_interference_size
  • std::hardware_constructive_interference_size

Which are supposed to be the minimum size/alignment to avoid (encourage) false-sharing (see https://en.cppreference.com/w/cpp/thread/hardware_destructive_interference_size).

While we could certainly default these values to '64' and that would work well for many of the targets that GCC supports, some intrinsics support from the compiler to get the appropriate size would be a better alternative.

This BoF proposal is to discuss how we might support this, particularly for architectures like ARM where the size may be either 32 or 64.

C++ Modules & Tooling

Led by: Nathan Sidwell (Facebook)

C++20 will have a module system. This places new constraints on the order of source file compilation. Preprocessing as a separate step becomes complex. Compiler bug reporting will not be a simple as providing preprocessed output. How can build systems, from Make onwards, adjust? What changes might be needed for compiler bug fixing?

GCC/LLVM Collaboration BoF

Led by: Jeremy Bennett (Embecosm)

slides

The goal of this BOF is to discuss the current state of and ways to improve collaboration between the gcc and LLVM projects. Proposed topics to discuss include: Collaboration on issues related to language standards, changes to existing standards or implementing new ones. Maintaining ABI compatibility between the compilers. Interoperability between tools and libraries e.g. building with clang and libstdc++ or building with gcc and linking with lld. As well as communication channels for developers via bugzilla or mailing lists.

GDB tests, CI & Buildbot BoF

Led by: Sergio Durigan Junior (Red Hat)

slides

Even though we require a testcase for every new non-trivial patch, and despite expecting that each contributor will run the testsuite and make sure no regressions happen, the reality is that we are usually chasing regressions more often than not, especially if you are responsible for a downstream GDB release. In my experience, much of the regressions introduced are already being caught and reported by our Buildbot, but gdb-testers is currently just serving as a justification for Sourceware admins to buy more disk, so it's hard to keep track of them.

In this BoF the GDB community will be able to get together and discuss the current state of our testsuite, ideas to improve our Buildbot infrastructure and how to be increase the quality of our Continuous Integration efforts.

glibc development workflows

Led by: Florian Weimer (Red Hat)

glibc upstream developers show each other how they develop new patches and tests.

GNU Toolchain Advocacy BoF

Led by: David Edelsohn (IBM)

Discussion about promoting and sustaining the GNU Toolchain projects

OpenACC/OpenMP/offloading (OMP, Offloading and Multi Processing) BoF

Led by: Thomas Schwinge (Mentor)

This is an interactive BoF to discuss all things OMP (Offloading and Multi Processing): from front ends (programming abstractions: OpenACC, OpenMP, CPLEX (C Parallel Language Extensions), modern C++, others?) to multicore or heterogeneous offload targets/GCC back ends (Nvidia PTX, AMD GCN, others? -- ..., and what's going on with Intel MIC, HSA/HSAIL?) -- and everything in between: middle end abstractions. Optimizations, such as automatic vectorization/parallelization (parloops/autopar, graphite, polly, others?). Compilation flow in GCC (LTO model vs. HSAIL model). Issues with non-trivial GCC offloading build configuration, problems for packagers, GNU/Linux distributions.

Optimising SPEC CPU 2017 with GCC

Led by: Kyrylo Tkachov, (Arm toolchain performance team)

slides

Optimising the SPECCPU 2017 benchmarks with GCC is of interest to many GNU community members.

In this BoF we'll present some of the more high gain opportunities we (the Arm toolchain performance team) have identified and invite fellow community members interested in SPEC to present on their findings.

This is an opportunity to set up a collaborative roadmap of optimisations, discuss, and gather feedback on how to make them versatile enough to integrate into trunk.

Project Ranger: On demand, precise value ranges. Overview, status, & plans for gcc-10 and beyond.

Led by: Andrew Macleod, Aldy Hernandez, Jeff Law (Red Hat)

slides

Ranger is an on-demand infrastructure for computing ranges of SSA_NAMEs at a given statement. The on-demand nature allows passes which only need ranges for a subset of SSA_NAMEs to get those ranges much more efficiently than using an embedded EVRP analyzer. Ranger performs comparably to EVRP when computing ranges for all SSA_NAMEs in the IL. Ranger generally provides ranges that are as good as or better than VRP/EVRP.

We'll be discussing the current state of the ranger work, integration plans, how it can be used to improve optimization, how it can be used to improve warning precision or avoid false positives, future plans, etc.

Register allocation

Led by: Peter Bergner (IBM)

slides

This BoF is intended to allow the GCC community and interested parties to come together and discuss topics relevant to IRA and LRA. I will discuss work I have done recently as well as potential work items. This is your chance to interact with RA developers, so please bring your thoughts, pain points, wishes and ideas for all of us to discuss.

rs6000/PowerPC/Power

Led by: Segher Boessenkool (IBM)

The place to discuss anything Power.

Signaling floating point comparisons

Led by: Segher Boessenkool (IBM)

All floating point comparisons should exist in both a signaling and a quiet form. Languages say which of those to use when. Currently, neither in GIMPLE nor in RTL we represent this properly, making it hard or impossible to do various simple optimisations. It is also harder than needed for backends to support it.

Let's talk about how to make things better.

The Arm / AArch64 BoF

Led by: Ramana Radhakrishnan (Arm)

slides

The Arm and AArch64 BoF is an open session for discussing your issues and concerns on anything Arm related in the GNU toolchain. There is no fixed agenda!

We'll probably start with a brief overview of the work done in the past year and then focus on whatever seems to be the most interesting items within the group. If you have specific issues or questions that you wish to raise, it might help if you can notify us in advance so that we can try to ensure that there is time to cover it.

The GDB BoF

Led by: Pedro Alves (Red Hat)

slides

An opportunity for the GDB community to meet to discuss all things related to the GNU Debugger project.

The GNU C Library BoF

Led by: Carlos O'Donell, Florian Weimer (Red Hat)

The GNU C Library is used as the C library in the GNU systems and most systems with the Linux kernel. The library is primarily designed to be a portable and high performance C library.It follows all relevant standards including ISO C11 and POSIX.1-2008. It is also internationalized and has one of the most complete internationalization interfaces known.

This BOF aims to bring together developers of other components that have dependencies on glibc and glibc developers to talk about the following topics:

  • Planning for glibc 2.31 and what work needs to be done between August 2019 and January 2020.
  • Planning for glibc 2.32 and what work needs to be done between January 2020 and July 2020.

... and more.

The LTO/IPA BoF

Led by: Jan Hubicka (Suse)

Discussion about recent LTO and IPA developments in GCC.

The RISC-V BoF

Led by: Palmer Dabbelt (SiFive), Jeremy Bennett (Embecosm)

slides

A session discussing all things RISC-V related.

Q&A Sessions

GCC Steering Committee Q&A

Led by: David Edelsohn

Do you have questions? We may have answers. Or maybe not.

Venues

Grande Bibliothèque

The Grande Bibliothèque is a building of Québec's National Library and Archives. It is conveniently located downtown, next to Montréal's main metro station (Berri-UQAM).

Attendees are welcome to arrive as early as 9:00 (presentations are at 10:00). Since this is earlier than the opening hours of the library, you'll need to enter using the entrance on the Berri street (Google StreetView):

entree-grande-biblio.png

We will have access to the auditorium and the adjacent M.450 room for our two tracks. Another smaller room will also be available for improvised meetings, discussions and presentations.

Travel

By Air

Montréal is served by the Pierre Elliott Trudeau International Airport, with connections to many major cities worldwide.

Traveling from the airport to downtown can be done by:

Public transit

It shouldn't be hard to find a hotel that is within walking distance from the venue, but should you need to go a bit further, Montréal's metro system is quite efficient.

Public transit fares are the following (valid for bus and metro):

You can buy all of these from fare vending machines or booths at any metro station, with credit/debit card or cash. You can also buy the 1 trip ticket directly on a bus with the exact change.

This is the logo you need to look for when looking for a metro station:

metro-logo.svg

You'll find more information on the STM (Société de Transport de Montréal - Montreal Transit Corporation) website.

Accommodation

There are a few hotels nearby the conference venue, here are some example:

Nearby restaurants

There is no shortage of restaurants nearby, especially on the St-Denis street stretch close to the main venue.

Here are some random picks that are particularly fancied by the organizing committee:

None: cauldron2019 (last edited 2020-01-23 14:22:58 by SimonMarchi)