Tag: programming

HPX – A C++ Library for Parallelism and Concurrency – Hartmut Kaiser – CppCon 2022

  • Lobby
  • Tag Archives: programming

https://cppcon.org/
---

HPX - A C++ Library for Parallelism and Concurrency - Hartmut Kaiser - CppCon 2022
https://github.com/CppCon/CppCon2022

With the advent of modern computer architectures characterized by -- amongst other things -- many-core nodes, deep and complex memory hierarchies, heterogeneous subsystems, and power-aware components, it is becoming increasingly difficult to achieve best possible application scalability and satisfactory parallel efficiency. The community is experimenting with new programming models that rely on finer-grain parallelism, and flexible and lightweight synchronization, combined with work-queue-based, message-driven computation. The recently growing interest in the C++ programming language in industry and in the wider community increases the demand for libraries implementing those programming models for the language.

In this talk, we present HPX -- A C++ Standards Library for Parallelism and Concurrency that is built around lightweight tasks and mechanisms to orchestrate massively parallel (and -- if needed -- distributed) execution. We also implement a full set of standard parallel algorithms and related asynchronous extensions to those. The library enables an asynchronous execution model that uses the concept of (Standard C++) futures to make data dependencies explicit, employs explicit and implicit asynchrony to hide latencies and to improve utilization, and manages finer-grain parallelism with a work-stealing scheduling system enabling automatic load balancing of tasks. Lately we have been experimenting with the new sender/receiver model that is currently being discussed as part of the C++ standardization process.

HPX is a C++ library exposing a higher-level parallelism API that is fully conforming to the existing C++11/14/17/20 standards and is aligned with the ongoing standardization work. This API and programming model has shown to enable writing highly efficient parallel applications for heterogeneous resources with excellent performance and scaling characteristics. This talk will highlight the implemented extensions to the C++ standard parallel algorithms and shows recent performance results.
---

Hartmut Kaiser

Hartmut is a research professor at Louisiana State Universities Center for Computation and Technology (CCT). He is probably best known for his involvement in open-source software projects, such as being the author of several C++ libraries he has contributed to Boost, which are in use by thousands of developers worldwide. His current research is focused on leading the STE||AR group at CCT working on the practical design and implementation of future execution models and programming methods. His research interests are focused on the complex interaction of compiler technologies, runtime systems, active libraries, and modern system's architectures. His goal is to enable the creation of a new generation of scientific applications in powerful, though complex environments, such as high-performance computing, distributed and grid computing, spatial information systems, and compiler technologies.
__

Videos Filmed & Edited by Bash Films: http://www.BashFilms.com
YouTube Channel Managed by Digital Medium Ltd https://events.digital-medium.co.uk

#cppcon #programming #parallelism

Filed under: UncategorizedTagged with: , , , , , , ,

import CMake, CMake and C++20 Modules – Bill Hoffman – CppCon 2022

  • Lobby
  • Tag Archives: programming

https://cppcon.org/
---

import CMake, CMake and C++20 Modules - Bill Hoffman - CppCon 2022
https://github.com/CppCon/CppCon2022

Originally developed as part of the National Institutes of Health (NIH) open source medical segmentation and registration toolkit ITK in 1999, CMake has grown to take on a vital role in the C++ ecosystem. Bill Hoffman, a founder of Kitware (www.kitware.com), and the creator of CMake will talk about where CMake is in 2022. The talk will start with a brief history of CMake and how it fits into the world of C++. It will then talk about recent developments to support C++20 modules.

For most of CMake's history, CMake has played catch up and implemented new features as compilers and IDEs have been released. With C++ modules, CMake developers have engaged the standards committee and compiler vendors to help craft the standard in such a way that CMake and other build systems can more seamlessly implement C++ modules. CMake has worked with Fortran modules for many years and has updated the ninja build tool to be able to dynamically update dependency information as it is discovered. To do this CMake requires a Fortran parser built into CMake. For obvious reasons CMake does not want to get into having its own C++ parser. This is the main driving force for pushing this work into the compilers. This talk will go over the road map for CMake C++ module support.

In addition to the history of CMake, C++ module support, this talk will include material covering important CMake features supporting the seamless building, testing and deployment of C++ across most computing platforms. In summary, listeners will learn about CMake origins, the roadmap of C++ module support in CMake and get an overview of the current set of features in CMake.
---

Bill Hoffman

Mr. Hoffman is a founder of Kitware and currently serves as Chairman of the Board, Vice President, and Chief Technical Officer (CTO). He is the original author and a lead architect of CMake, an open source, cross-platform build and configuration tool that is used by hundreds of projects around the world, and he is the co-author of the accompanying text, Mastering CMake. Using his 20+ years of experience with large software systems development, Mr. Hoffman is also a major technical contributor to Kitware’s Visualization Toolkit, Insight Toolkit, and ParaView projects

Mr. Hoffman received a B.S. in Computer Science from the University of Central Florida and an M.S. in Computer Science from Rensselear Polytechnic Institute (RPI). Prior to the formation of Kitware, he spent nine years at the General Electric Corporate Research and Development center, working in the Computer Vision Group. He has planned and taught several graduate-level courses at RPI as well as a course in object-oriented programming at New York University.
__

Videos Filmed & Edited by Bash Films: http://www.BashFilms.com
YouTube Channel Managed by Digital Medium Ltd https://events.digital-medium.co.uk

#cppcon #programming #cmake

Filed under: UncategorizedTagged with: , , , , , , ,

Back to Basics: C++ Move Semantics – Andreas Fertig – CppCon 2022

  • Lobby
  • Tag Archives: programming

https://cppcon.digital-medium.co.uk/tag/cppcon/">cppcon.org/
---

Back to Basics: C++ Move Semantics - Andreas Fertig - CppCon 2022
https://github.com/CppCon/CppCon2022

Move semantics is a topic that feels hard to understand. This talk will give you a good understanding, demystifying some myths out there using a new and unique way of talking about moving.

For example, you've heard those move operations should be noexcept. In this talk, you will learn the why while we write things like an efficient move constructor and a move assignment operator.

During this talk, we will look at rules for when to use std::move and when to use std::forward.

There is one topic we have to discuss as well, what is a moved-from object, and what can you do with such an object?

You're eager to squeeze out the last drop of performance? Then we should talk about the ref-qualifiers. Why waste performance?

At the end of this talk, you have a solid understanding of move semantics, enabling you to write competitive performant code.
---

Andreas Fertig

Andreas Fertig, CEO of Unique Code GmbH, is an experienced trainer and lecturer for C++ for standards 11 to 20.

Andreas is involved in the C++ standardization committee, in which the new standards are developed. At international conferences, he presents how code can be written better. He publishes specialist articles, e.g., for iX magazine, and has published several textbooks on C++.

With C++ Insights (https://cppinsights.io), Andreas has created an internationally recognized tool that enables users to look behind the scenes of C++ and thus to understand constructs even better.

Before working as a trainer and consultant, he worked for Philips Medizin Systeme GmbH for ten years as a C++ software developer and architect focusing on embedded systems.

You can find Andreas online at
andreasfertig.com
__

Videos Streamed, Edited, and YouTube Channel Managed by Digital Medium: http://online.digital-medium.co.uk

#cppcon.digital-medium.co.uk/tag/cppcon/">cppcon #cppcon.digital-medium.co.uk/tag/programming/">programming #cpp

Filed under: UncategorizedTagged with: , , , , , ,

C++ Performance Portability – Decade of Challenges Developing Kokkos – Christian Trott – CppCon 2022

  • Lobby
  • Tag Archives: programming

https://cppcon.org/
---

C++ Performance Portability - Decade of Challenges Developing Kokkos - Christian Trott - CppCon 2022
https://github.com/CppCon/CppCon2022

Over the last decade, scientific computing had to deal with a diversifying hardware and programming model environment. Today’s scientific software engineers have to account for at least four vendor provided eco-systems: CUDA (NVIDIA), HIP (AMD), SYCL (Intel - OneAPI) and OpenMP. Performance Portability solutions attempt to relieve domain experts from the need to become experts in all of these, by providing an interface which enables developers to write their code once, and then execute it efficiently on any HPC platform.
This talk will discuss lessons learned from the last 10 years of developing and deploying Kokkos, a C++ based Performance Portability EcoSystem which is arguably the most widely used non-vendor solution for writing single source performance portable scientific applications. We will dive into some of the key challenges for designing performance portable software, and how to address them through appropriate API design. The talk will also show how some of the fundamental concepts for performance portability are getting introduced into the ISO C++ standard through upcoming features.
---

Christian Trott

Christian Trott is a high performance computing expert working at the Sandia National Laboratories. He leads the multi-institutional Kokkos C++ Performance Portability Programming Model development team and is member of the ISO C++ Standards Committee focusing on future C++ capabilities for parallel and heterogeneous computing. Christian is currently focused on making sure that Kokkos is ready for the exa-scale era high performance computing architectures. He also leads the mdspan proposal for the C++23 standard, which will provide multidimensional array views with configurable data layouts and data access functions.

His prior scientific work focused on computational material research using ab-initio calculations, molecular dynamic simulations and monte carlo methods for investigations of ion-conducting glass materials.
---

Videos Filmed & Edited by Bash Films: http://www.BashFilms.com
YouTube Channel Managed by Digital Medium Ltd https://events.digital-medium.co.uk

#cppcon #programming #software

Filed under: UncategorizedTagged with: , , , , , , , , , , , ,

Taking a Byte Out of C++ – Avoiding Punning by Starting Lifetimes – Robert Leahy – CppCon 2022

  • Lobby
  • Tag Archives: programming

https://cppcon.org/
---

Taking a Byte Out of C++ - Avoiding Punning by Starting Lifetimes - Robert Leahy - CppCon 2022
https://github.com/CppCon/CppCon2022

Marshaling raw bytes into objects is a perennial problem in C++. Bytes may exist in memory, we may know they’re of the correct form to back a C++ object, but the abstract virtual machine says none of the desired objects exist at that location. The temptation to type pun and hope that happens to work, and continues to do so, runs strong.

What if we had start_lifetime_as? We could synthesize objects backed directly by bytes without superfluous calls to memcpy/memmove and prayers to the optimizer. What would that world look like? What sort of patterns could we use to work efficiently and correctly in that world?

This talk answers such questions against the backdrop of a database engine which makes use of this proposed functionality. Analysis will move from raw bytes, to C++ objects, to heterogeneous streams of such objects with discussion of the sharp edges at each level. End to end zero copy will be shown to be both possible and correct.
---

Robert Leahy

Robert is a graduate of the University of Victoria where he specialized in graphics, gaming, and digital geometry processing. After spending 4.5 years in full stack web development he pivoted to financial infrastructure in early 2016 and now works on next generation market data storage and retrieval mechanisms. In 2019 he became involved in the ISO C++ committee with a particular focus on library evolution.
---

Videos Filmed & Edited by Bash Films: http://www.BashFilms.com
YouTube Channel Managed by Digital Medium Ltd https://events.digital-medium.co.uk

#cppcon #programming #byte

Filed under: UncategorizedTagged with: , , , , , , ,

C++ Dependencies Don’t Have To Be Painful – Why You Should Use a Package Manager – Augustin Popa – CppCon 2022

  • Lobby
  • Tag Archives: programming

https://cppcon.org/
---

C++ Dependencies Don’t Have To Be Painful - Why You Should Use a Package Manager - Augustin Popa - CppCon 2022
https://github.com/CppCon/CppCon2022

According to recent surveys from the Standard C++ Foundation, a majority of C++ developers are manually managing their library dependencies. Curiously, one of the top pain points cited in these surveys was also “managing libraries”. I believe these two points are correlated.

In this talk, I will discuss how different types of package managers address these pain points, from system package managers like apt and Homebrew to build system centric package managers like NuGet and language package managers like vcpkg and Conan. There are pros and cons to every solution, and some package managers are more effective in some workflows than others. Managing libraries doesn’t have to be painful. If you configure your workflow right, you will save time not having to maintain additional git submodules, source code, or reading build instructions on GitHub.

I’ll also talk about a few scenarios related to dependency management: acquiring open-source libraries vs. private libraries, automatically building libraries from source, using libraries locally and in CI, using libraries with different build systems and operating systems, and acquiring developer tools from a package manager. You will come out of this talk with an understanding of how a package manager can rid you of your dependency woes.
---

Augustin Popa

Augustin is a Product Manager on the C++ team at Microsoft, working on vcpkg and Visual Studio setup. In the past he has worked on the Visual Studio productivity and getting started experiences.
__

Videos Filmed & Edited by Bash Films: http://www.BashFilms.com
YouTube Channel Managed by Digital Medium Ltd https://events.digital-medium.co.uk

#cppcon #programming #dependencies

Filed under: UncategorizedTagged with: , , , , , , ,

How Microsoft Uses C++ to Deliver Office – Huge Size, Small Components – Zachary Henkel – CppCon 2022

  • Lobby
  • Tag Archives: programming

https://cppcon.org/
---

How Microsoft Uses C++ to Deliver Office - Huge Size, Small Components - Zachary Henkel - CppCon 2022
https://github.com/CppCon/CppCon2022

Office is one of the largest and longest-lived C++ codebases in the world. Over 40 years Office has evolved from a single application written in C for DOS to a product containing over 100M lines of C++ code targeting more than a dozen platforms. What are the implications of growing to this size and what sort of engineering is required? In this talk I’ll give a glimpse behind the curtain on the C++ engineering and architecture in Office. In addition to sharing some details on the scale of Office, I’ll describe the design and coding standards used to create well-factored components that we have termed liblets.
---

Zachary Henkel

Zachary is a Principal Software Engineer on the Core Architecture Team in Office. He is focused on codebase health and sustainability. He relishes the challenge of evolving the C++ code of a product as large and long-lived as Office. As much as Zachary likes writing new code, he’s happiest when deleting unused or duplicate code.
__

Videos Filmed & Edited by Bash Films: http://www.BashFilms.com
YouTube Channel Managed by Digital Medium Ltd https://events.digital-medium.co.uk

#cppcon #programming #microsoft

Filed under: UncategorizedTagged with: , , , ,

Back to Basics: Templates in C++ – Nicolai Josuttis – CppCon 2022

  • Lobby
  • Tag Archives: programming

https://cppcon.org/
---

Back to Basics: Templates in C++ - Nicolai Josuttis - CppCon 2022
https://github.com/CppCon/CppCon2022

Templates are among the most powerful features of C++, but they remain misunderstood and underutilized, even as the C++ language and development community have advanced. This talk shows when and how to use modern templates to build software that's cleaner, faster, more efficient, and easier to maintain. We will cover all basic aspects of templates you have to know when programming generic code in Modern C++
---

Nicolai Josuttis

Nicolai Josuttis is well-known in the community for his authoritative books and talks. For more than 20 years he has been a member of the C++ Standard Committee. He is the author of several worldwide best-sellers, including:

- C++20: The Complete Guide
- C++17: The Complete Guide
- C++ Move Semantics: The Complete Guide
- The C++ Standard Library: A tutorial and Reference
- C++ Templates: The Complete Guide (w/ David Vandevoorde & Doug Gregor)
__

Videos Filmed & Edited by Bash Films: http://www.BashFilms.com
YouTube Channel Managed by Digital Medium Ltd https://events.digital-medium.co.uk

#cppcon #programming #template

Filed under: UncategorizedTagged with: , , , , , ,

Back to Basics: Debugging – Mike Shah – CppCon 2022

  • Lobby
  • Tag Archives: programming

https://cppcon.org/
---

Back to Basics: Debugging - Mike Shah - CppCon 2022
https://github.com/CppCon/CppCon2022

I always tell my students, the debugger is your 'get out of jail free card' when working on a project. I say the same thing to professionals, debuggers are your 'get out of free jail card'. The reality is that programmers spend the majority of their time debugging as opposed to writing new code. Unfortunately many programmers do not learn how to use a debugger, or otherwise how they should approach debugging. In this talk I am going to show you how to debug C++ code, starting from the very basics and then demonstrating how a debugger like GDB can be used to help you track errors in CPU code. Attendees at this talk will learn names of debugging techniques (e.g. delta debugging), and I will demonstrate several debugging tools (stepping through code, capturing backtraces, conditional breakpoints, scripting, and even time traveling!) to demonstrate the power of debuggers. This is a beginner friendly talk where we are going to start from the beginning, but I suspect I may show a trick or two that folks with prior experience will appreciate.
---

Mike Shah

Mike Shah is an Associate Teaching Professor at Northeastern University in the Khoury College of Computer Sciences. His primary teaching interests are in computer systems, computer graphics, and software engineering. His research interests are related to performance engineering (dynamic analysis), software visualization, and computer graphics. Along with teaching and research work, he have juggled occasional consulting work as a 3D Senior Graphics Engineer in C++.

Mike discovered computer science at the age of 13 when googling ”how do I make games”. From that google search, Mike has worked as a freelance game developer, worked in industry for Intel, Sony Playstation, Oblong Industries, and researched at The Ohio Supercomputer Center to name a few. Mike cares about building tools to help programmers monitor and improve the performance of realtime applications– especially games. In Michael’s spare time he is a long distance runner, weight lifter, and amateur pizza maker.
__

Videos Filmed & Edited by Bash Films: http://www.BashFilms.com
YouTube Channel Managed by Digital Medium Ltd https://events.digital-medium.co.uk

#cppcon #programming #debugging

Filed under: UncategorizedTagged with: , , , ,

Functional Composable Operations with Unix-Style Pipes in C++ – Ankur Satle – CppCon 2022

  • Lobby
  • Tag Archives: programming

https://cppcon.digital-medium.co.uk/tag/cppcon/">cppcon.org/
---

Functional Composable Operations with Unix-Style Pipes in C++ - Ankur Satle - CppCon 2022
https://github.com/CppCon/CppCon2022

Let's write C++ code like this shaking off all the verbosity and with 100% domain code and ~0% syntax! Do we really need to explicitly state whether a function is a continuation or a transform?

return get_env("KafkaConsumerConfigFile")
| get_file_contents
| make_client
| connect
| subscribe;
Unix commands seamlessly compose, piping into each other to form a clear train of operations in one line! Similarly in C++, we moved away from non-composable, multi-step processing of ranges using algorithm. We embraced the composable ranges using pipes. This reduced time & space complexity, improved performance, provided clarity & reduced cognitive load when working with ranges.

But, when NOT dealing with std::ranges, can one work with such easy composability? Why not pipe operations to work with application/business entities! YES, of course, I say! Let's pipe application logic operations & get declarative! HOW HARD COULD IT BE!

With just C++11, we achieve piping operations for any generic T & a Callable. We address Error handling, Resource management, Customizations and Variations like chaining functions taking more than 1 argument or invoking a member function operation instead of free function. Supporting C++20, we make sure our pipe implementation does NOT interfere with std::ranges operations.

Finally, we address the proposed C++23 Monadic interface functions (and_then, transform, or_else) of std::optional and present how we can implement the same without having to explicitly state the verbose and_then, transform, or_else to work with optional. We encounter a surprise on the way & correct overload resolution by employing a concept.

We also discuss critique & compromises of this approach.
---

Ankur Satle

Ankur is an avid (natural) language learner, but C++ is his mother tongue!
His mantra is: "Effective, Efficient & Elegant". He leverages the power of the small to build large-scale systems. As Smart Data Platform Architect at EXFO, he builds High-performance, Scalable, Telecom Products for 4G/5G Core. He loves working in constrained environments.
He was the Organizer & Host of CppIndiaCon, since inception. His dream came true when he hosted the AMA with Bjarne Stroustrup!
He is the Core Organizer at CppIndia, India's C++ User Group, the most active C++ user group.
He has presented at CppCon 2020 & CppCon 2021, CppIndiaCon 2021 & CppIndiaCon 2022
__

Videos Streamed, Edited, and YouTube Channel Managed by Digital Medium: http://online.digital-medium.co.uk

#cppcon.digital-medium.co.uk/tag/cppcon/">cppcon #cppcon.digital-medium.co.uk/tag/programming/">programming #cpp

Filed under: UncategorizedTagged with: , , , , , ,