Skip to main content
Redhat Developers  Logo
  • Products

    Platforms

    • Red Hat Enterprise Linux
      Red Hat Enterprise Linux Icon
    • Red Hat AI
      Red Hat AI
    • Red Hat OpenShift
      Openshift icon
    • Red Hat Ansible Automation Platform
      Ansible icon
    • View All Red Hat Products

    Featured

    • Red Hat build of OpenJDK
    • Red Hat Developer Hub
    • Red Hat JBoss Enterprise Application Platform
    • Red Hat OpenShift Dev Spaces
    • Red Hat OpenShift Local
    • Red Hat Developer Sandbox

      Try Red Hat products and technologies without setup or configuration fees for 30 days with this shared Openshift and Kubernetes cluster.
    • Try at no cost
  • Technologies

    Featured

    • AI/ML
      AI/ML Icon
    • Linux
      Linux Icon
    • Kubernetes
      Cloud icon
    • Automation
      Automation Icon showing arrows moving in a circle around a gear
    • View All Technologies
    • Programming Languages & Frameworks

      • Java
      • Python
      • JavaScript
    • System Design & Architecture

      • Red Hat architecture and design patterns
      • Microservices
      • Event-Driven Architecture
      • Databases
    • Developer Productivity

      • Developer productivity
      • Developer Tools
      • GitOps
    • Automated Data Processing

      • AI/ML
      • Data Science
      • Apache Kafka on Kubernetes
    • Platform Engineering

      • DevOps
      • DevSecOps
      • Ansible automation for applications and services
    • Secure Development & Architectures

      • Security
      • Secure coding
  • Learn

    Featured

    • Kubernetes & Cloud Native
      Openshift icon
    • Linux
      Rhel icon
    • Automation
      Ansible cloud icon
    • AI/ML
      AI/ML Icon
    • View All Learning Resources

    E-Books

    • GitOps Cookbook
    • Podman in Action
    • Kubernetes Operators
    • The Path to GitOps
    • View All E-books

    Cheat Sheets

    • Linux Commands
    • Bash Commands
    • Git
    • systemd Commands
    • View All Cheat Sheets

    Documentation

    • Product Documentation
    • API Catalog
    • Legacy Documentation
  • Developer Sandbox

    Developer Sandbox

    • Access Red Hat’s products and technologies without setup or configuration, and start developing quicker than ever before with our new, no-cost sandbox environments.
    • Explore Developer Sandbox

    Featured Developer Sandbox activities

    • Get started with your Developer Sandbox
    • OpenShift virtualization and application modernization using the Developer Sandbox
    • Explore all Developer Sandbox activities

    Ready to start developing apps?

    • Try at no cost
  • Blog
  • Events
  • Videos

March 2018 ISO C++ Meeting Trip Report (SG1: Concurrency and Parallelism)

April 30, 2018
Thomas Rodgers
Related topics:
Developer Tools
Related products:
Developer Tools

Share:

    This year's Winter ISO C++ Standard Committee meeting was held in March in Jacksonville, Florida. A number of larger features, for which there is substantial interest but which are also difficult to get right, were discussed:

    • Concepts, along with Concept types from the Ranges TS; see P0898 and n4685
    • Modules; see n4689
    • Coroutines; see n4723
    • Networking; see n4711
    • Executors; see p0443

    Jason Merrill's recently published trip report covers the core language topics. This report focuses on the topics of interest to the Concurrency and Parallelism Study Group (SG1).  The "big ticket" items discussed in SG1 during the week were:

    • Executors
    • Networking
    • Coroutines
    • Futures

    Much of the discussion involved how Executors interact with Networking and Coroutines. Separately there is an effort to bring new types similar to std::future to the Standard and determine what impact, if any, that work has on Executors.

    Executors

    The Executors paper's authors and SG1 are fairly happy with the state of the current proposal. The LEWG discussion centered mainly around "how would you use this API?" The Executors proposal authors plan to submit papers for Rapperswil addressing the usage of the executors interface with existing and proposed related features of the standard library (networking, parallel algorithms, std::async, etc.) in order to advance the LEWG discussions.

    Coroutines

    The SG1 discussion around Coroutines largely centered on whether or not the Coroutines language facility had any dependency on Executors. The decision was that it doesn't, but there was a desire to see more concrete examples of library facilities including those dependent on Executors using Coroutines. There was additional EWG discussion around this proposal. Google has experimented with the Coroutines TS and has reported several limitations and points where it thinks the features in the TS can be improved. The Coroutines proposal did not move to the C++20 IS at this meeting. Additional papers are expected for the June meeting in Rapperswil.

    Networking

    SG1 decided that Networking was dependent on Executors, and advancing Networking without proper integration with Executors would yield an unsatisfactory result.

    Futures

    The current std::future/std::promise pair is a fairly heavyweight construct that doesn't map well to other kinds of executors (for example, GPGPUs). Other executor-like libraries expose lighter future concepts that are "executor-aware." One outstanding question was whether Executors are dependent on specifying these new Future types. The Executors proposal authors agreed that Executors are not dependent on this work, but that since there is substantial overlap in the authorship of the proposals, the Executors authors will proceed with the assumption that when the work on a new Futures proposal is published it will just "do the right thing" with respect to Executors.

    At the Saturday Plenary, the SG1 Chair presented this synopsis of the week's discussions:

    IS'20 (barely possible)

    • Executors
    • Networking

    IS'23

    • Executors
    • Networking
    • Additional algorithm policies
    • Revised Futures
    • Better async programming support

    New Features

    Several smaller new features were voted out of SG1 for the C++20 draft standard at this meeting:

    • Fixing atomic initialization, see: p0883.
      This specifies atomic<T> to have a default initialized value of T{}, rather than the current uninitialized behavior.
    • The Curious Case of Padding Bits, Featuring Atomic Compare-and-Exchange; see p0528.
      The crux of the issue is that an atomic CAS observes the bit pattern of the type being operated on, and that type will include padding bits if it's a struct. This is currently broken, but it should "just work." EWG's guidance was to fix this with compiler magic. There was a fair bit of discussion on this topic and there will be some revised wording in the post-meeting  mailing as a result.
    • Support C atomics in C++; see p0943.
      The goal here is to make C++ code that includes C atomic definitions work.
    • Revising the C++ Memory Model; see: p0668.
      The paper proposes to address issues that have been found subsequent to publishing C++11's
      memory model that affect Power, Arm, and certain GPU architectures.
    • Efficient waiting for C++20; see p0514.
      Support for efficient atomic waiting and semaphores.
    • Improving atomic_flag; see d0995.
      This fell out of discussion earlier in the week on p0514r3. The current atomic_flag is not particularly useful, and a proposal to deprecate it was mooted. After ongoing discussions during  the week, a new proposal came out that improves the existing atomic_flag. This is small enough that it is likely to see the light of day in C++20.
    • Concurrency TS v2.

    There was consensus to move a couple of long-languishing papers on distributed counters and concurrent queues to LEWG for inclusion in a Concurrency TS v2. See:

    • Distributed Counters: P0261
    • Concurrent Queues: P0260
    Last updated: March 23, 2023

    Recent Posts

    • Profiling vLLM Inference Server with GPU acceleration on RHEL

    • Network performance in distributed training: Maximizing GPU utilization on OpenShift

    • Clang bytecode interpreter update

    • How Red Hat has redefined continuous performance testing

    • Simplify OpenShift installation in air-gapped environments

    Red Hat Developers logo LinkedIn YouTube Twitter Facebook

    Platforms

    • Red Hat AI
    • Red Hat Enterprise Linux
    • Red Hat OpenShift
    • Red Hat Ansible Automation Platform
    • See all products

    Build

    • Developer Sandbox
    • Developer Tools
    • Interactive Tutorials
    • API Catalog

    Quicklinks

    • Learning Resources
    • E-books
    • Cheat Sheets
    • Blog
    • Events
    • Newsletter

    Communicate

    • About us
    • Contact sales
    • Find a partner
    • Report a website issue
    • Site Status Dashboard
    • Report a security problem

    RED HAT DEVELOPER

    Build here. Go anywhere.

    We serve the builders. The problem solvers who create careers with code.

    Join us if you’re a developer, software engineer, web designer, front-end designer, UX designer, computer scientist, architect, tester, product manager, project manager or team lead.

    Sign me up

    Red Hat legal and privacy links

    • About Red Hat
    • Jobs
    • Events
    • Locations
    • Contact Red Hat
    • Red Hat Blog
    • Inclusion at Red Hat
    • Cool Stuff Store
    • Red Hat Summit
    © 2025 Red Hat

    Red Hat legal and privacy links

    • Privacy statement
    • Terms of use
    • All policies and guidelines
    • Digital accessibility

    Report a website issue