Quick Q: What container should I use to reduce fragmentation caused by lots of small allocations?

By Adrien Hamelin | Oct 22, 2015 01:51 PM | Tags: intermediate

Quick A: The only one matching the requirements is a std::deque, but it might be worth to consider using a memory pool.

Recently on SO:

What C++ std container should I use to reduce fragmentation caused by lots of small allocations?

Since you're asking specifically for a standard container, std::deque is the most promising option given your requirements. As long as you only add elements, the existing ones are not relocated, and references/pointers (but not iterators) remain valid. When removing elements, you may however need to leave gaps or swap the element to remove with the last element.

std::vector is not stable, and std::list, std::forward_list as well as all the associative containers are fragmented.

Looking at Boost.Container, you have additional options, however with other trade-offs:

boost::flat_map provides contiguous storage (like std::vector), but with it the stability problem
boost::stable_vector offers element stability at the cost of contiguity.
Alternatively, you can have a look at pool allocators (like Boost.Pool). They provide low fragmentation and fast allocation, and the container in front of it can still be used like a normal container.

Bitesize Modern C++ : Smart pointers--Glennan Carnie

By Adrien Hamelin | Oct 22, 2015 01:43 PM | Tags: c++11 basics

Do you know about smart pointers?

Bitesize Modern C++ : Smart pointers

by Glennan Carnie

From the article:

The dynamic creation and destruction of objects was always one of the bugbears of C. It required the programmer to (manually) control the allocation of memory for the object, handle the object’s initialisation then ensure that the object was safely cleaned-up after use and its memory returned to the heap. Because many C programmers weren’t educated in the potential problems (or were just plain lazy or delinquent in their programming) C got a reputation in some quarters for being an unsafe, memory-leaking language...

CppCon 2015: Last online videos (5)

By Adrien Hamelin | Oct 22, 2015 01:39 PM | Tags: community

The videos of CppCon 2015 are coming online. You can see them all here: Youtube or Channel 9

Here are the most recent ones:

• CLANG + C2 - Engineering/Futures/Measurements
• C++ devirtualization in clang
• Algorithmic Differentiation: C++ & Extremum Estimation

CLANG + C2 - Engineering/Futures/Measurements by James Radigan

The talk will cover the CLANG + c2.dll compiler for the Microsoft platform. It will contain parts of the talk given at //Build 2015 that can be found on line: "Compiling Objective-C Using the Visual Studio 2015 C++ Code Generation that Builds Windows, SQL, .Net, and Office". The focus this time will be on C++.

The talk will disclose the architecture of how we tied the CLANG open source front end with the Microsoft optimizing backends (several configurations are needed) and how far we are from providing a CTP for public consumption targeting 4 different architectures. Included in this section will be a disclosure of data on compile time, memory consumption, conformance and correctness.

In addition the talk will cover the nuts and bolts of several key innovative compiler and runtime technologies we will be delivering in the Visual Studio 2015 updates (Fall, Winter and Spring). New investments in the compiler and runtime space include: Improved optimization and auto-vectorization, more secure code generation, incremental whole program compilation, and new asynchronous C++ code generation.

C++ devirtualization in clang by Piotr Padlewski

Lightning Talk

Algorithmic Differentiation: C++ & Extremum Estimation by Matt P. Dziubinski

Lightning Talk

CppCon 2015: Last online videos (4)

By Adrien Hamelin | Oct 21, 2015 02:12 PM | Tags: community

The videos of CppCon 2015 are coming online. You can see them all here: Youtube or Channel 9

Here are the most recent ones:

• CLANG + C2 - Engineering/Futures/Measurements
• C++ devirtualization in clang
• Algorithmic Differentiation: C++ & Extremum Estimation
• Indian C++: Curry for your Functions
• CLion Tips & Tricks
• and seventeen more lightning talks!

CLANG + C2 - Engineering/Futures/Measurements by James Radigan

The talk will cover the CLANG + c2.dll compiler for the Microsoft platform. It will contain parts of the talk given at //Build 2015 that can be found on line: "Compiling Objective-C Using the Visual Studio 2015 C++ Code Generation that Builds Windows, SQL, .Net, and Office". The focus this time will be on C++.

The talk will disclose the architecture of how we tied the CLANG open source front end with the Microsoft optimizing backends (several configurations are needed) and how far we are from providing a CTP for public consumption targeting 4 different architectures. Included in this section will be a disclosure of data on compile time, memory consumption, conformance and correctness.

In addition the talk will cover the nuts and bolts of several key innovative compiler and runtime technologies we will be delivering in the Visual Studio 2015 updates (Fall, Winter and Spring). New investments in the compiler and runtime space include: Improved optimization and auto-vectorization, more secure code generation, incremental whole program compilation, and new asynchronous C++ code generation.

C++ devirtualization in clang by Piotr Padlewski

Lightning Talk

Algorithmic Differentiation: C++ & Extremum Estimation by Matt P. Dziubinski

Lightning Talk

Indian C++: Curry for your Functions by Andre Bergner

Lightning Talk

CLion Tips & Tricks by Dmitri Nesteruk

Lightning Talk

CppCon 2015: Last online videos (3)

By Adrien Hamelin | Oct 20, 2015 01:28 PM | Tags: community

The videos of CppCon 2015 are coming online. You can see them all here: Youtube or Channel 9

Here are the most recent ones:

• CopperSpice: A Pure C++ GUI Library
• C++ Metaprogramming: Journey from simple to insanity and back
• Birth of Study Group 14...
• C++11/14/17 atomics and memory model...
• On C++, Javascript and WebSockets
• C++ in Open Source Robotics
• From Functional to Parallel: Stochastic Modeling in C++

CopperSpice: A Pure C++ GUI Library by Barbara Geller & Ansel Sermersheim

CopperSpice is a collection of cross platform GUI libraries derived from Qt 4.8. Our libraries use current C++11 technology to implement Reflection, without requiring moc (a code generator) or any preprocessing. We will discuss what Reflection is, how this technology can be used, and why it can be difficult to implement.

The focus of this presentation is to show the core implementation of CopperSpice. Source code from CopperSpice will be shown to explain how we implemented Reflection using pure C++11. We will also demonstrate small samples of code which use the CopperSpice libraries.

Technologies covered in this presentation will include templates, variadic templates, and template specialization.

No prior knowledge of CopperSpice or Qt is required. A working knowledge of templates in C++11 would be helpful.

C++ Metaprogramming: Journey from simple to insanity and back by Fedor Pikus

Part I: Introduction to template metaprogramming. Template metaprogramming is a variant of generic programming, a technique that uses C++ template mechanism to perform computations at compilation time, usually to generate, from a single description, executable code that depends on the properties of the data types. It can be viewed as “programming with types”. In this example-driven class we start with the overview of the metaprogramming tools (everything you wanted to know about template specializations but were afraid to ask). We will apply these tools to simple examples, such as: how to sort a sequence in order of increasing values, unless it’s a sequence of pointers, in which case we want the values of what they point to. Part II: Advanced techniques and practical applications. Simple examples of metaprogramming are fun and useful, but once you master them you start chafing at the limitations. This is C++, where we don’t suffer limitations gladly. We therefore move on to the more advanced techniques, including SFINAE, and the appropriately more advanced examples. The journey takes us back to the beginning: after all, when sorting a sequence of values vs a sequence of pointers, you don’t really care whether the pointer is smart or dumb. What you really want to know is whether “*p” compiles or not. What you really need is an “if_compiles” metaprogramming function.

Birth of Study Group 14... by Nicolas Guillemot & Sean Middleditch

C++ is paramount for games development, and low-latency real-time applications everywhere. But has it recall improved since C++98/03? What features in C++ 11/14 has helped, and what else do we still need from C++ 17/22? In last year's CPPCon, there was clearly demand for even better support for this community as evidenced by the large number of games submission and an impromptu BoF.

But this industry has a demanding schedule and cannot freely attend ISO C++ standard meetings. So when the prophet cannot go to the mountain, the mountain has decided to come to the prophet!

This year, we like to announce the formation of an official SG14 that will go where the community is, at CppCon 2015 will be an official SG14 meeting followed by an SG14 meeting at GDC 2015 hosted by Sony.

This talk will describe the initial findings of the unofficial real time google group https://groups.google.com/forum/#!for... as described in: http://www.open-std.org/jtc1/sc22/wg2... where we considered improvements such as flat map, intrusive container, and other suggestions for better support for games development and low latency in ISO C++.

C++11/14/17 atomics and memory model... by Michael Wong

In 2011, C++11 atomics offered three memory models but 6 settings. Most compilers have started implementing most of these (relaxed, seq_cst, acquire, release, acq_rel) but not consume (For that you will need to see Paul's talk which naturally follows this talk.) For this, I will deep dive into what each memory model setting means (especially for Games Development and low latency, a new SG14 in the C++ Standard) and how C++11 atomics are used to improve handling of mutable shared state. We have improved on it in C++14 and have more crazy things planned for C++17. I will also look at how C++ atomics are a natural precursor to SG5's Transactional Memory which was approved in Lenexa for publication.

On C++, Javascript and WebSockets by Alex Fabijanic

Session presents Open Service Platform (OSP) - an application server engine inspired by OSGi, consisting of C++ and JavaScript runtime environments; OSP is based on the POCO C++ Libraries, with embedded Google V8 JavaScript engine.

A brief overview of the application server and underlying technologies will be given, followed by dissection of the most interesting implementation details - C++-to-JavaScript bridging mechanism and WebSocket-based messaging mechanism for transparent intra- and inter-process scalable communications. The language bridging mechanism exposes the C++ classes to JavaScript code without a need for manually written glue code or separate IDL constructs for interfaces. The messaging mechanism provides a unified, event-based interface for the in-process entities as well as those reachable over the network - be it TCP/HTTP server or a web browser.

Key design aspects, advantages, as well as trade-offs will be examined; a live example demonstrating key technologies in action will be presented.

C++ in Open Source Robotics by Jackie Kay & Louise Poubel

The robotics community is thriving in part due to flexible, powerful, accessible open source tools. The Open Source Robotics Foundation is a non-profit organization dedicated to the development, distribution, and adoption of open source software in robotics. We enable academics to focus on high-level research by re-using code, robotics startups to keep their development costs lean, and novice users to engage with powerful, complex robotics technology.

The first half of this talk centers around the future of ROS, the most widely used open source framework for robotics. After an overview of ROS transport, tools, capabilities, and the diverse ecosystem of ROS-compatible libraries, we will motivate the development of ROS 2: a major API change that targets new use cases for ROS, including embedded hardware, multi-robot systems, and real-time performance. Starting with an overview of the ROS 2 architecture, which includes a modern C++11 client library built on top of a generic DDS middleware interface, we will then focus on two core user code examples: publish/subscribe over a topic, and client request/service response. After this half of the presentation, attendees will understand C++ is a dominant language choice for robotics and why C++11 makes it easy to build a flexible, modular, Boost-free framework for communication and synchronization.

The second half of the talk focuses on Gazebo, a simulator for robotics that features support for multiple rigid body dynamics physics engines, high quality graphics, and a flexible C++ API. Simulation software like Gazebo is of utmost importance for developing controller algorithms, prototyping robot designs, and regression testing in challenging environments. It has been used in high­-stakes competitions such as the DARPA Robotics Challenge. This talk will delve into how different components of the simulator interact, from calculating the physical interactions between objects to rendering graphics with OGRE. We will also discuss upcoming features in Gazebo and the process of tailoring our development to our community.

From Functional to Parallel: Stochastic Modeling in C++ by Kevin Carpenter

Come with us as we take a legacy MFC financial modelling application that is largely function in design and transform it to something new. We will take a portion of this large financial simulation application and change its single threaded ways into parallel processing stochastic model. Transforming single class’s with a hodge-podge of functions into an object oriented parallel design using c++ amp and implementing Stochastic modelling methodology. Aside from focusing on the key portions of converting functional single threaded code to a parallel design we will also touch on some of the details of financial modeling for interest rate risk.

Do You Prefer Fast or Precise?--Jim Hogg

By Adrien Hamelin | Oct 20, 2015 12:26 PM | Tags: performance advanced

A nice article explaining the troubles of float numbers, and what effects it can have. It is talking in the case of Visual C++, but the problems are the same for other compilers.

Do You Prefer Fast or Precise?

by Jim Hogg

From the article:

Floating Point Basics

In C++, a float can store a value in the 3 (approximate) disjoint ranges { [-E+38, -E-38], 0, [E-38, E+38] }. Each float consumes 32 bits of memory. In this limited space, a float can only store approximately 4 billion different values. It does this in a cunning way, where adjacent values for small numbers lie close together; while adjacent values for big numbers lie far apart. You can count on each float value being accurate to about 7 decimal digits.

Floating Point Calculations

We all understand how a computer calculates with ints. But what about floats? One obvious effect is that if I add a big number and a small number, the small one may simply get lost. For example, E+20 + E-20 results in E+20 – there are not enough bits of precision within a float to represent the precise/exact/correct value...

CppCon 2015: Last online videos (2)

By Adrien Hamelin | Oct 20, 2015 12:42 AM | Tags: community

The videos of CppCon 2015 are coming online. You can see them all here: Youtube or Channel 9

Here are the most recent ones:

• A Crash Course in Open Source Licensing
• Testing Battle.net (before deploying to millions of players)
• Stop Teaching C
• A C++14 approach to dates and times
• What is Open Source, and Why Should You Care?
• Comparison is not simple, but it can be simpler
• Contracts for Dependable C++

A Crash Course in Open Source Licensing by Kevin P. Fleming

Open source software licenses are intended to provide a way for software authors to protect their own rights, and the rights of the users of their software, but many developers are unaware of how they work, why they are important, and how to apply them to their projects.

It may never have occurred to you, but software licenses are much like programs: they are developed to meet requirements, they live in a world of external influences and constraints, and they use documented techniques to solve problems.

In this session, the attendees will participate in a fun, interactive process to choose the components of a software license through real-world examples, with the goal of every attendee leaving with a basic understanding of the more important aspects of software licenses. Along the way they will learn the basics of copyrights and how they apply to software; what 'derivative work' and 'distribution' mean in these contexts; and many other useful concepts, including the most important differences between common licenses like the GNU General Public License family and the Apache 2 license.

Testing Battle.net (before deploying to millions of players) by Ben Deane

Battle.net is the online service that runs Blizzard's games. As such, it is a large scale distributed system with many interacting parts and dependencies on various services and data. While developing Battle.net servers, I needed a way to isolate and test functionality that I was working on.

In this talk I will cover my experience designing for testability of components in a distributed system, and practical ways to structure classes and data to facilitate testing. I will also present my solution to the problem of testing my code for correctness, performance and scalability without having to deploy a full-scale environment and spin up a million clients.

Stop Teaching C by Kate Gregory

To this day most people who set out to help others learn C++ start with "introduction to C" material. I think this actively contributes to bad C++ code in the world. For the past few years I've been teaching C++ (and making suggestions to folks who intend to teach themselves) in an entirely different way. No char* strings, no strlen, strcmp, strcpy, no printf, and no [] arrays. Pointers introduced very late. References before pointers, and polymorphism with references rather than with pointers. Smart pointers as the default pointer with raw pointers (whether from new or &) reserved for times they're needed. Drawing on the Standard Library sooner rather than later, and writing modern C++ from lesson 1.

In this session I want to talk about the specific advantages of teaching C++ this way – a way that’s very different from the way you almost certainly learned the language. You’ll be pleasantly surprised to see what you get to leave for later or never cover at all, what bad habits you don't later need to correct, what complicated concepts actually become accessible to beginners, and how you spend a lot less time dictating magic spells you can't explain yet, and more showing someone a comprehensive, sensible, and understandable language.

You don't have to be a trainer to come to this session. If you ever mentor other developers and show them your C++ code, if you ever help somebody choose a book or a course or other material to learn from, or even if you occasionally feel bad that you work in a language that's hard to learn, come and see how one philosophical shift can turn that very same language into one that's actually pretty easy to learn!

A C++14 approach to dates and times by Howard Hinnant

A new date and date/time library designed for C++14 is presented. This library stresses ease of use, easy-to-read code, catching common errors at compile time, and uncompromising run-time performance.

The design starts with the C++11 std::chrono library, and extends it into the realm of calendars, giving a seamless experience built upon chrono::system_clock::time_point, the durations you already know such as chrono::hours and nanoseconds. Functionality that allows easy and efficient conversions between the std::chrono types and year/month/day - hh::mm::ss data structures is presented.

When dates (and times) are known at compile-time (e.g. leap second transitions), all computations are available at compile time (constexpr). When only parts of a date are known at compile time, run-time efficiencies are still gained by compile-time computing parts of the date.

The syntax of the library is built around a few easy-to-learn rules, and strictly checked at compile time. This makes it easy to learn, and very forgiving for the novice.

What is Open Source, and Why Should You Care? by Kevin P. Fleming

In this session, Kevin will present a condensed history of open source software: its origins, motivations and effect on the world of software development. He'll then talk about open source *beyond* software, and various ways that students can get involved in open source projects to develop useful (and marketable) skills. These are skills which are not taught in most degree programs, but are very valuable for jobs in scientific and engineering disciplines.

Comparison is not simple, but it can be simpler by Lawrence Crowl

The standard's algorithms typically require a 'strict weak ordering'. I will explain what this really means and show that even simple uses of sort can have latent failures. Programmers can avoid the problems today with a bit of work. Changes to the standard will reduce errors and programming effort.

Contracts for Dependable C++ by Gabriel Dos Reis

One of the three major areas that C++17 is expected to address is “improving support for large-scale dependable software.” A general understanding of ‘dependable software’ is the notion that the product should reliably perform the task it was designed for, and when given erroneous inputs the program should not be allowed to blindly continue execution, thereby possibly causing serious harms. In another words, an abrupt program termination is preferable to an exploited program vulnerability.

“Contracts” are a language feature being considered by the ISO C++ standards committee for C++17. They offer a basic mitigation measure, and early containment mechanism, by allowing a C++ programmer express more formally (instead of just comments) in code the requirements of a function interface. They offer a complement to conventional static type checking, and move comments closer to mechanized scrutiny. This presentation will explore the design space, previous efforts, the importance of analysis tools (both static and dynamic), and how contracts provide greater integration and support.

Call for Class Proposals

By Adrien Hamelin | Oct 19, 2015 08:00 AM | Tags: c++14

A call for next CppCon:

Call for Class Proposals

From the article:

The conference is asking for instructors to submit proposals for classes to be taught in conjunction with next September’s CppCon 2016.

If you are interested in teaching such a class, please contact us at info@cppcon.org and we’ll send you an instructors’ prospectus and address any questions that you might have.

CppCon 2015: Last online videos

By Adrien Hamelin | Oct 19, 2015 01:01 AM | Tags: community

The videos of CppCon 2015 are coming online. You can see them all here: Youtube

Here are the most recent ones:

• Evolving Legacy Code
• Functional programming: functors and monads
• Benchmarking C++ Code
• Transactional Memory in Practice
• Declarative Control Flow

Evolving Legacy Code, by Rachel Cheng & Michael VanLoon

We will be presenting on the evolution of a legacy monitoring subsystem modernized to C++11 with enhanced interfaces and better programming techniques. The presentation will cover some abstracted example problem areas, the solutions, and talk about the strategy employed to modernize the code.

Functional programming: functors and monads, by Michał Dominiak

Following the 'Applying functional programming in code design' session from Wednesday, I'd like to conduct a 'crash course' on functors and monads, and why they are important - and useful - regardless of the language you are writing code in.

Benchmarking C++ Code, by Bryce Adelstein-Lelbach

With the ending of Moore's Law and the rise of multicore systems, programmers from across the industry are increasing forced to develop and maintain highly performance sensitive software. For C++, a language frequently used for performance sensitive projects, benchmarking and performance analysis is especially important. Developing good benchmarks can be tricky; gathering and analyzing data from benchmarks can be an even greater challenge.

This talk will discuss techniques and best practices for writing C++ benchmarks using facilities from the standard library and Boost. We'll also cover the development of performance unit/regression tests. We'll discuss the statistical best practices for gathering data, as well as techniques for benchmarking a variety of different metrics - time, memory, algorithmic complexity, etc.

The main topics which will be covered:

* Statistical Best Practices (dealing with uncertainty, achieving statistical confidence, how to sample)
* Time-Based Benchmarking (best practices for timing, derived time-based metrics)
* Non-Time-Based Benchmarking (memory, algorithmic complexity in time and space, etc)
* Techniques for C++-specific Performance Metrics (counting copies/moves, allocator tricks)
* Converting Benchmarks into Tests

Transactional Memory in Practice, by Brett Hall

Transactional memory has been held up as a panacea for concurrent programming in some quarters. The C++ standardization committee is even looking at including it in the standard. But is it really a panacea? Has anyone used it in a shipping piece of software? There are scattered examples, mostly from the high-performance and super-computing realms. On the other end of the spectrum, at Wyatt Technology we've been using transactional memory in a desktop application that does data acquisition and analysis for the light-scattering instruments we build. That application is called Dynamics and we've been using a software transactional memory system in it for four years now. This talk will detail how our system works, how well it worked, and what pitfalls we've run into. Prior experience with transactional memory will not be assumed, though it would help if you have experience programming threads with locks and an open mind about alternatives and why we're looking for them.

Declarative Control Flow, by Andrei Alexandrescu

Getting exception handling right is a perennial problem in C++ that has eluded systematization. Not for much longer. New language and library developments make it possible to handle exceptions in a declarative manner, leading to drastic code simplification.

This talk discusses an alternative approach to handling exceptional flow that eliminates the need for small ancillary RAII classes, try/catch statements that rethrow, and other cleanup mechanisms. The popular Scope Guard idiom gets a spectacular generalization. Statements specify in a declarative manner actions to be taken if the current scope is left normally or via an exception. The resulting code is simpler, smaller, and easier to maintain.

CppCast Episode 30: Stop Teaching C (When Teaching C++) with Kate Gregory

By robwirving | Oct 16, 2015 06:53 AM | Tags: None

Episode 30 of CppCast the only podcast for C++ developers by C++ developers. In this episode Rob and Jason are joined by Kate Gregory to talk about why we should stop teaching C (when teaching C++).

CppCast Episode 30: Stop Teaching C (When Teaching C++) with Kate Gregory

by Rob Irving and Jason Turner

About the interviewee:

Kate Gregory has been using C++ since before Microsoft had a C++ compiler, and has been paid to program since 1979. She loves C++ and believes that software should make our lives easier. That includes making the lives of developers easier! She'll stay up late arguing about deterministic destruction or how C++ these days is not the C++ you remember.

Kate runs a small consulting firm in rural Ontario and provides mentoring and management consultant services, as well as writing code every week. She has spoken all over the world, written over a dozen books, and helped thousands of developers to be better at what they do. Kate is a Microsoft Regional Director, a Visual C++ MVP, an Imagine Cup judge and mentor, and an active contributor to StackOverflow and other StackExchange sites. She develops courses for Pluralsight, primarily on C++ and Visual Studio. In 2014 and 2015 she was Open Content Chair for CppCon, the largest C++ conference ever held, where she also delivered sessions.