GNU Tools Cauldron 2017

<< GNU Tools Cauldron 2016 | GNU Tools Cauldron 2018 >>

Contents

  1. GNU Tools Cauldron 2017
    1. Organizers
    2. Sponsors
    3. Video recordings and slides
      1. Talks
      2. BoFs
      3. Q&A Session
    4. Schedule
    5. Abstracts
      1. Talks
      2. BOFs
    6. Slides and Notes
    7. Mailing lists
    8. Workshop description
    9. Accommodation

Organizers

Organizing committee:

Sponsors

group_photo_2017.jpg

Aaron Sawdey took number of great photos during the event

Video recordings and slides

Video recordings are now ready. Slides will appear soon - I would welcome if someone helps me attaching them to the webpage and adding links.

Talks

BoFs

Q&A Session

Schedule

Abstracts

Talks

Trace-based performance evaluation tools for ppc64

Speakers: Aaron Sawdey

In this talk I will present an overview of the trace-based performance evaluation tools for PPC. This includes trace collection with valgrind itrace, the sim_ppc timing simulator, the pipestat tool for analyzing instruction traces and timing simulator event traces, and the timing simulator event trace viewer tools. I will describe how to use these tools to identify user and library code issues as well places where the compiler generates sub-optimal code.

Supporting variable register sizes for the ARM Scalable Vector Extension (SVE) in GDB

Speakers: Alan Hayward

SVE for Aarch64 poses challenges for GDB due to the register size being unknown until runtime, with the added complexity that register sizes may change during runtime. After a brief introduction to SVE, this talk will show how variable register sizes will be supported in GDB. In addition, we’ll touch on other interface changes such as Linux ptrace and DWARF support.

Speakers: Alexandre Oliva

When users of source-level debugging and monitoring programs choose to inspect the state of the program at a certain line number, it is desirable that effects of logically prior source statements be in the picture presented to the user, and that effects of subsequent statements not be in it. However, as optimizations change, drop and reorder code fragments, concerted effort is required of the compiler and the debug information consumer to select appropriate inspection points, and to reconstruct coherent pictures for the user.

We introduce SFN (Statement Frontier Notes), a robust method for the compiler to select and annotate meaningful, consistent inspection points; and LVU (Location Views), debug information extensions to support multiple coherent pictures at a single program location. They enable debug information consumers to stop at inspection points that could not be identified or represented otherwise, and to advance to the user-visible states of subsequent source lines, even in the absence of intervening executable instructions.

In this updated speech, years after the idea was first devised, we describe the implementation recently contributed to GCC and GAS, the proposed extension to DWARF, and invite debug information consumers to join in and enjoy the benefits.

Update on GDB's Linux kernel debug support

Speakers: Andreas Arnez

While GDB contains special support for the user-space runtime, such as for the threading library and for the dynamic loader, analogous functionality was long lacking for the Linux kernel runtime. On the GNU Tools Cauldron 2015 we discussed adding such Linux kernel debug support to GDB. Since then, various discussions have taken place and various patches have been proposed/submitted. This talk gives an overview of the current state and outlook.

Supporting the upcoming model of the IBM mainframe

Speakers: Andreas Krebbel

The upcoming model of the IBM z Systems line of mainframe computers will provide several extensions to the instruction set. Most importantly this model will have support for single and extended precision floating point values in the vector unit.

In this talk I'll give an overview of the architecture changes in the new machine model, in particular the vector instruction set extensions. I'll also describe how the language extensions will be enhanced to support the new features.

Finally, I'll report on where we stand in implementing those new features in the GNU toolchain, and address a couple of challenges that still need to be resolved.

GCC IA16 backend

Speakers: Andrew Jenner

IA16 is an obsolete predecessor of the ubiquitous IA32 architecture. Rask Ingemann Lambsertsen submitted an IA16 backend in 2007, but it was not accepted. This backend has now been updated for modern GCCs and many problems with it were fixed. This talk explains the steps that were taken, techniques used and lessons learned from the project.

Revisit the loop optimization infrastructure in GCC

Speakers: Bin Cheng

I would like to give a talk on current status of high level loop optimizations in GCC, current improvements ongoing and possible future improvements. It consists of three parts. The first part gives brief idea about current loop optimization infrastructure. The second part describes enhancements we have finished recently to loop optimizations. I will briefly go through recent improvements and describe some of them in detail, for example, loop split, rewrite of loop ivopts, introduction of tree level register pressure estimate for loop, enhanced loop distribution/predcom, etc.. The third part covers future work I would like to do, for example, loop interchange, pass optimization info to later passes as well as better interaction and organization among different optimizations. I may be able to start some of these works before the event of Cauldron, so will update it depending on future progress.

GCC diagnostics and location-tracking improvements for GCC 8

Speakers: David Malcolm

I've got a number of proposals for improving diagnostics and how we track source locations in GCC, which I'd like to present at Cauldron; extending location-tracking to cover:

(a) all expressions (including constants, and uses of a decl), not just compound expressions

(b) other syntactic elements (e.g. for implementing IDE integration)

I also want to discuss how we might help advanced users track how GCC is optimizing their code via some kind of hybrid of the dump_file and diagnostics subsystems.

I plan for most of the session to be interactive, hence this feels like something of a "diagnostics and location-tracking BoF".

glibc 3.0

Speakers: Florian Weimer

This session intends to provide a forum for glibc developers to discuss current pain points and past mistakes leading to them. We want to see if we can correct at least some of them with a slight risk to full backwards compatibility. Some examples of what we might want to remove:

My preferred format would be a short talk (maybe 15 minutes) followed by collecting audience feedback for about 30 minutes.

GNU Toolchain Performance for AArch64 targets

Speakers: James Greenhalgh

The GNU Toolchain team at ARM focuses on three areas; enabling ARM's latest intellectual property, maintaining the quality of the ARM and AArch64 ports of the GNU Tools, and improving the performance of code generated using the GNU Toolchain.

In this talk, we will discuss our performance work over recent years. We will explain our performance tracking methodology, based on the LNT platform maintained by the LLVM project, and how we use that infrastructure to identify performance opportunities for our toolchain engineers to investigate.

We will share data showing improvements in the performance of important enterprise benchmarks and workloads, such as Spec2000 and Spec2006, on AArch64, and highlight which work from the community and from our team resulted in those gains.

Finally, we will discuss our ongoing work and our plans for the coming year, including improvements we've identified to GLIBC math functions, and our ideas for enhancements to GCC's traditional loop optimizers.

While we'll run this as a presentation, we'll be sure to leave time for discussion and comments on our plans, and to listen to what other teams with an interest in the performance of code generated for AArch64 are currently working on.

Security Enhancing Compilation for Use in Real Environments

Speakers: Jeremy Bennett

We have a proliferation of small, networked devices, rich in sensors - "the Internet of Things". Recent events have shown how such devices are vulnerable to attack. We have seen children's dolls hacked remotely to spout profanities, internet connected light bulbs which can be used to hijack a home network and the Mirai botnet using IoT devices to mount DDoS attacks.

We need to make it easy for professional software engineers to write secure code for such devices. Beyond the trivial system failings (lack of passwords, use of open communication protocols), we need to be able to protect against attacks based on information leakage and make is easy to implement defensive programming techniques.

Security is a system wide issue, and the compiler is the one tool which gets to look at all the code. SECURE is a one year research project led by Embecosm and supported by Innovate UK, which aims to extend popular open source compilers to help in writing secure code. We can do this in two ways.

1. We can warn the user of dangerous code constructs, for example when a critical variable is used to control program flow, thus leaking information.

2. We can provide features to assist the program, for example by wiping the stack on return from a function to avoid leaving data in memory.

We'll be submitting patches to add such features, using ARM and RISC-V architectures as demonstrator. In this talk I'll describe the progress with GCC in the first two months of the project. I'll also look at the system we are using to test the effectiveness of these techniques.

Switch lowering improvements

Speakers: Martin Liška

Switch lowering is well observed area and subject of many technical papers. The talk will provide various interesting statistics collected on thousands of packages in openSUSE distribution. These numbers provide clue about which optimizations should be selected and added to the compiler. Apart from that I would like to present results of an experimental branch where the GCC can make decisions based on profile feedback in order to generate fast code of switch statements.

Red Hat GCC 8 Projects - TBC

Speakers: Martin Sebor

Implementing C++ Modules

Speakers: Nathan Sidwell

C++ modules-ts[1] proposes a module system, with defined interfaces, implementations and importing. I shall outline the new semantics and discuss the, in-progress, implementation in G++.

[1] JTC1/SC22/WG21/n4681, 'Working Draft, Extensions to C++ for Modules', 2017-07-14, Gabriel Dos Reis

G++ Front End Symbol Tables

Speakers: Nathan Sidwell

G++'s symbol table management originated in the C front end. While functional, it is not the best design for a C++ front end. I shall discuss the improvements I have made and am making to the C++ front end.

Plugins: For Better or Worse ?

Speakers: Nick Clifton

A discussion about the role of plugins in the GNU Toolchain. Focusing on their support, or lack thereof, by the tools, and whether they should remain as isolated individual projects or brought into the fold.

Plugins are often seen as extraneous extras to the GNU toolchain, relegated to a second-class status, and ignored as part of any major release. There is very little documentation on how to create them or use them, or even what they do. There are no real testsuites for them, nor any official way to report bugs. But it does not have to be this way.

This BoF is an attempt to reach out to the developer community to see if there is interest in raising the profile of plugins. Should there be a formal specification of their interface(s) with the tools, and what they are and are not allowed to do ? Should there be an official place in the filesystem where plugins are installed ? How should they be documented and how can interested users find out about which plugins are available ?

If you are interested in this subject please come along and join in the discussion.

GDB: C++ conversion & dogfooding C++

Speakers: Pedro Alves

In this talk I'll give an update on the status of GDB's C++ conversion, and then talk about GDB's C++ debugging improvements developed as result of eating our own dog food. E.g.:

Implementing C++17 ParallelSTL Using GCC's HSAIL and Offloading Support

Speakers: Pekka Jääskeläinen

This presentation discusses the feasibility of implementing C++17 ParallelSTL on heterogeneous devices on top of GCC's HSAIL support and the offloading infrastructure. While my presentation provides the background, the current status and my findings so far, its purpose is to be an interactive session - a call for collaboration and advice from people currently working on the offloading infra.

Update on performance improvements in glibc for power processors

Speakers: Rajalakshmi Srinivasaraghavan

This talk gives an overview of current state and outlook of string, memory and math functions optimized for power processors in glibc in 2.25 and 2.26. Some of the methods used on these optimization and the methods used to identify low performing code sequence during the development phase will be discussed.

I will also talk about how we plan to make use of new power9 ISA instruction set in these functions, in particular overview of new vector instructions in POWER9 ISA that can be used for string/memory functions. I will also cover the plan for glibc 2.27 with respect to optimization.

Improving the Effectiveness and Generality of GCC Auto-vectorization : PoC.

Speakers: Sameera Deshpande

Vectorization of array manipulating programs uses knowledge of the order of array accesses. In many cases, permuting the array elements could lead to better vectorization. Identification of profitable permutation depends on the order of accesses in the program as well as the instructions available on the target architecture. GCC's approach of instruction selection based on standard pattern names fails to identify effective permutations because it takes a local view of the GIMPLE statements by considering them separately. Besides, the implementation strategy of SLP (Superword Level Parallelism) adopted by GCC enhances the effectiveness of vectorization in a limited manner. Finally, most of the times, these suboptimal vector instructions cannot be combined later in combiner pass to generate desired instructions as the vector instructions generated depend upon transformations the loop undergoes, which are irreversible at RTL level as loop information is lost by then.

We propose to improve auto-vectorization in GCC by facilitating examination of related GIMPLE statements in a loop together and utilizing the information so derived to transform the computations in two orthogonal ways: (a) We propose an alternative mechanism to implement SLP by coalescsing ASTs of independent computations. (b) We try to decide where and which permutations should be effected based on the knowledge of the available target instructions.

Our approach improves the generality of vectorization along three dimensions: Apart from being processor agnostic, it facilitates consideration of all possible permutations as against a small set of empirically observed permutations. It also generalizes the SLP transformations using a simple and generic intuition. This also increases the effectiveness vectorization because the generated program is more efficient.

Enhancing software security by enabling Control-flow Enforcement Technology in GCC

Speakers: Sebastian Peryt

Recently Intel® has published a specification for a new technology designed in cooperation with Microsoft® which is meant to detect and block malware at the processor level called Control-flow Enforcement Technology (CET). The new technology has been designed specifically to prevent against attempts of using Return-Oriented Programming (ROP) or Call/Jump-Oriented Programming (COP/JOP) in exploits design. Those techniques are used by attackers to tie together fragments of legitimate executable code into malicious sequences to perform new functions. ROP attacks are serious security threats against which current software-based detection and prevention techniques are not especially successful, when it comes to overcoming them. The new CET technology, thanks to its hardware level execution, is intended to fix those security flaws providing better resistance against malwares. CET introduces two new means to protect against ROP/JOP attacks: Shadow Stack and Indirect branch tracking. First one is designed to defend against ROP by introducing additional stack used only for storing the function return addresses. Second is used to secure against COP/JOP. This is achieved by utilizing processor pipeline to detect control flow violations and throwing exception if one is detected.

In this talk we will discuss work done across whole GCC compiler architecture to implement this feature, enabling its utilization with new architecture. The changes span across several tools and touch the compiler, its libraries, low-level system libraries and tools, like glibc, binutils and ld. The main part of the talk will be devoted to the compiler support, its high-level design and approaches taken. Additionally we will touch implementation details for propagation of tracking/notracking information as well as specifics of exception handling support, which is tricky part of the implementation given HW shadow stack. Finally we will cover the testing process, which is not evident as no existing HW supports the new technology. The OS level support is out of this talk’s scope.

Separate shrink-wrapping

Speakers: Segher Boessenkool

The -fshrink-wrap-separate sub-pass (new in GCC 7) places pieces of the prologue and epilogue in places where they will be executed less frequently. This talk will describe why this is useful, how this works, and what changes a target needs to make to hook this up. If there is time I'll also discuss some future work in this area.

Tunables: It is in glibc, now what?

Speakers: Siddhesh Poyarekar

The tunables finally made it into glibc after years of discussions and now it is time to build on it. I will start this BoF with a quick recap of the state of tunables at that moment and the roadmap we had roughly agreed on last year. Following that the floor will be open to discuss what the roadmap should *really* be based on present day realities.

Adding run-time type information to the GNU toolchain and run-time

Speakers: Stephen Kell

Run-time type information is of potential use to debuggers, run-time tracing or checking tools, dynamic linking, language interoperability techniques, garbage collectors and a variety of other tools and services. Our toolchains presently lack any common approach to this: in C there is no such notion, while in C++ and higher-level languages, each language or implementation invents its own. The result is a familiar catalogue of omissions and ad-hoc workarounds: conservative garbage collection, guesswork in debuggers, fragile manual approaches to interface description (consider strace or ltrace, or countless FFI systems), and plain old "doing without" useful features or checks (e.g. sanitizer-style tools could do greater checking given a notion of run-time type).

A relatively low-lying notion of run-time type, roughly at the ABI level, could add value in all these areas in a uniform, process-wide fashion. I'll describe my research work on liballocs, a runtime and toolchain extension embodying one approach to this. Currently the system consists of link-time tooling and a runtime library, with a little source-to-source tooling to support C (and some C++). The basic idea is to postprocess DWARF debugging information into optional, loadable "meta-DSOs" containing type definitions and other information (including about heap allocation sites) in an efficient representation. The liballocs runtime, which logically sits very close to the dynamic linker, exposes a process-wide meta-level protocol for in-memory objects and their allocators. Its primary operation allows clients to query what is on the end of an arbitrary pointer.

More generally, the protocol offers an abstract view of the address space in the form of "typed allocations". A key challenge is establishing what the memory objects are, given a multitude of allocators. For this, liballocs has a hierarchical model: top-level allocations are memory mappings, "leaf" allocations contain user data (malloc chunks, stack frames, data segments, etc.), and intermediate levels are allocator-owned. Allocators are pluggable, accommodating vastly differing metadata indexing methods in each case (e.g. heap versus stack) and also allowing for user allocators, although default implementations accommodate most custom heap allocators out-of-the-box. Currently, the overheads involved are usually (but not always) less than 10% of execution time and a modest cost in memory; these can undoubtedly be improved further.

Various applications have so far been prototyped on top of liballocs: instrumentation for dynamically checking pointer casts; run-time pointer queries during debugging; a metaprogramming-style interface description available to tracing tools; and for FFI-less interop with dynamic languages (prototyped in a hacked version of V8).

I'll give an overview of the system and existing applications, including some demos. I'll also detail some remaining rough edges and work needed, and discuss ideas for integrating it more closely into (most likely) gcc, glibc and gdb. I will be extremely keen to obtain feedback, explore overlap with other typeor checking-flavoured tooling (e.g. libabigail, sanitizers), and engage on the potential for ABI-level working standards for type information. The research work has been published at Onward! 15 [1] and OOPSLA '16 [2].

Precise target floating-point emulation in GDB

Speakers: Ulrich Weigand

New features available on some targets, in particular support for IEEE-compatible 128-bit floating-point arithmetic on Power (and Intel), are starting to expose long-standing GDB limitations. In particular, GDB currently performs all expression evaluation on floating-point types using host "long double" arithmetic. This may get very different results compared with actual target execution if the target data type has greater range and/or precision than the host's long double type.

In this talk, I'll discuss options how to fix this problem. In particular, I'll propose a solution to use floating-point emulation, similar to what is done by GCC for constant-folding, to precisely mirror target floating-point arithmetic.

Applying GNU GCC Address Sanitizer to whole Linux distribution

Speakers: Vyacheslav Barinov and Maxim Ostapenko

C/C++ programs often suffer from memory corruption bugs. Over the years, numerous tools were developed to help with their detection. A recent addition is Address Sanitizer (ASan) — an extraordinarily fast runtime checker with a good coverage of various types of bugs. The report describes our experience in integration of ASan technology into large-scale software products: Tizen distribution. The tool has already found around a hundred of serious memory bugs in various Tizen applications.

A flexible GDB target description for processor diversity

Speakers: Yao Qi

GDB target description is of XML format to describe the registers and types on a given architecture. As processor architectures exploit diversity, the inflexibility in GDB target description emerges. I'll present the work to address the inflexibility in GDB target description to better support various architectures, and their variants and extensions. I'll also present the current state of the project.

Outline for improving OpenACC kernels support in GCC: automatic parallelization of loop nests.

Speakers: Thomas Schwinge

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.

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 constructs.

This implementation, extended to generate the corresponding OpenACC constructs, turned out to not satisfy the expectations. It is quite limited in the classes of loop nests is 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 handle many classes of multi-level loop nests, and map these to the several levels of parallelism provided by OpenACC. Related to this, for example, also are potential aliasing issues of the memory objects accessed in the loop nests.

We're going to discuss some ideas about how to restructure the compilation flow of OpenACC kernel constructs, in order to parallelize more classes of loop nests, and how to schedule nested loops across the OpenACC gang, worker, and vector dimensions.

BOFs

Maintainer/Contributor BOF

Speakers: Alan Modra

All open source projects live or die by their contributors. This BOF will discuss ways of encouraging people to contribute to GCC, and to continue maintaining GCC and other parts of the toolchain. We will explore a number of questions, such as: What is the reward for contributing to GCC? Is patch review a thankless task, where so often it would be easier to write the patch yourself than explain things to someone else? How is patch review recognized? Are the current commit rules the best we can have? Is it best for GCC to obsolete ports without maintainers, or is a large number of targets one of GCC's strengths? Are too many of GCC's contributors beholden to corporate interests? How will GCC survive in the face of competing open source compilers, especially if the corporate support moves to a competing compiler?

This BOF will start with a very short talk on economics, to shed some light on what drives people to contribute and maintain free software.

The GNU C Library - runtimes.

Speakers: Carlos O'Donell

This BoF is part 1 of 2. The first part covering runtimes, and the second part covering infrastructure.

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.

The BoF aims to bring together developers of other components that have dependencies on glibc and glibc developers to talk about topics related to the runtime itself.

* Planning for glibc 2.27 and what work needs to be done

* Planning for glibc 2.28 and what work needs to be done

* Cancellation fixes. Next steps?

* ISO C11 threads.

* ... and other topics.

The GNU C Library - infrastructure.

Speakers: Carlos O'Donell

This BoF is part 2 of 2. The first part covering runtimes, and the second part (this part) covering infrastructure.

The BoF aims to bring together developers of other components that have dependencies on glibc and glibc developers to talk about topics related to the infrastructure surrounding glibc:

* Policy for ABI, vendor branches, and merging.

* Bug triage.

* Build bots.

* Test suite, and test suite support.

* Benchmarking.

* ... and other topics.

GCC Steering Committee Q&A

Speakers: David Edelsohn

Question and answer session and general discussion with members of the GCC Steering Committee in attendance about the direction of GCC and its interface with the Free Software Foundation, including the GNU Toolchain Fund.

?

Speakers: David Edelsohn

How can the GNU Toolchain Community engage more developers and volunteers? How can GCC utilize volunteers to approve Bugzilla accounts? How can the GNU Toolchain Community utilize the recently established GNU Toolchain Fund?

The LTO/IPA BoF

Speakers: Jan Hubička

Discussion about recent LTO and IPA developments in GCC.

GNU tools for RISC-V BoF

Speakers: Jeremy Bennett, Andrew Burgess

Processors based on the open UC Berkeley RISC-V ISA specification are becoming more widespread. GCC and binutils for RISC-V is now upstream. GDB is still a work in progress.

This BoF is an opportunity for everyone in the GCC community working with RISC-V (or wishing to work with RISC-V) to share their experience. We will talk about our work on a CGEN based assembler/diassembler/simulator for RISC-V and our work contributing to the GDB implementation. We look forward to hearing from others working on RISC-V.

rs6000 / PowerPC / POWER ISA BoF

Speakers: Segher Boessenkool

ARM / AArch64 BoF

Speakers: Ramana Radhakrishnan / Richard Earnshaw (with the ARM GNU Toolchain Team)

BoF session for the ARM and AArch64 ports discussing progress, concerns and plans during the GCC 8 time frame.

The GDB BoF (+ 'GDB & Multi-target')

Speakers: Pedro Alves

Open for discussion of any topic relevant to GDB development.

Addendum: Per popular request, I gave a short talk+demo of GDB's upcoming multi-target support in the first half of the session. Multi-target refers to GDB being able to connect to multiple targets at once. For example, connect to multiple gdbservers at the same time, or mix native/remote/core debugging.

build-ids, symbols and debuginfo tooling BoF

Speakers: Mark Wielaard

GCC has become pretty good at generating debuginfo that is usable by profilers, tracers and debuggers even for optimized production code. But using and distributing the symbols, unwind tables and debuginfo for production binaries in distributions is somewhat different from using the same debuginfo during a compile-edit-debug cycle (where you can create special debug builds). I will present what I learned from hacking on elfutils, rpm and debugedit for Fedora. And give an overview of the tools involved (gcc/DWARF, rpm/debugedit, .gnu_debugdata, gdb/gdb-index, dwz, binutils/gold, elfutils/eu-strip). Then we can discuss how to make some of them work better together and new tools that we might need when switching to DWARF5.

Loop optimization BoF

Speakers: Richard Biener

Discussion about past and future changes in the loop optimization pipeline. More specifically addition of traditional loop nest transforms and their challenges and the increased use of versioning to enable transforms. Difficulties with modeling cost, esp. with respect to vectorization.'

OMP (Offloading and Multi Processing) BoF

Speakers: Thomas Schwinge

This is an interactive BoF to discuss all things OMP (Offloading and Multi Processing): from front ends (programming abstractions: OpenMP, OpenACC, maybe CPLEX (C Parallel Language Extensions)?, others?) to support for heterogeneous offload targets/GCC back ends (Intel MIC, Nvidia PTX, HSA/HSAIL, GCN, others?) -- and everything in between: middle end abstractions. Automatic vectorization, parallelization (parloops/autopar, graphite, polly, others?). Compilation flow in GCC (LTO model, HSAIL model). Issues with complex GCC build configuration, problems for packagers, GNU/Linux distributions.

Slides and Notes

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 basic 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 time We will meet again at the Lesser Town Campus of Charles University in Prague (Malostranske Namesti 25, Prague, Czech Republic map1, map2). (The same location as of GNU Tools Cauldorn 2015 and GNU Tools Cauldorn 2012).

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.

If you have a topic that you would like to present, please submit an abstract describing what you plan to present. We are accepting three 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 what we did at the previous meetings.

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

Your submission should contain the following information:

If you intend to participate, but not necessarily present, please let us know as well. Send a message to tools-cauldron-admin@googlegroups.com stating your intent to participate. Please indicate your affiliation, dietary requirements and t-shirt size.

Accommodation

The conference venue can be conveniently reached by the public transport, either by Metro (subway, underground train) line A (green line), to the station of Malostranská and then by a short walk, or by the tramway lines No. 12, 20 or 22 to the stop of Malostranské náměstí. The tramway stop is situated right across the square to the conference venue. A public traffic schemes can be downloaded at http://www.dpp.cz/en/transport-around-prague/transit-schematics/.

Because of the location just in the center of Prague, it is easy to check lodging options on common booking sites, like http://www.marys.cz/.

Some options in walking distance from the venue include:

None: cauldron2017 (last edited 2020-07-08 09:15:10 by TomDeVries)