Coroutines in Clang trunk
The future is near!
Coroutines in Clang trunk
From the tweet:
Coroutines are now in Clang Trunk! Working on the Libc++ implementation now. Thanks to @GorNishanov for all the hard work!
November 14-16, Berlin, Germany
November 18-23, Wrocław, Poland
November 25, Wrocław, Poland
February 10-15, Hagenberg, Austria
March 19-21, Madrid, Spain
April 1-4, Bristol, UK
June 16-21, Sofia, Bulgaria
By Adrien Hamelin | May 31, 2017 12:54 PM | Tags: experimental community
The future is near!
Coroutines in Clang trunk
From the tweet:
Coroutines are now in Clang Trunk! Working on the Libc++ implementation now. Thanks to @GorNishanov for all the hard work!
By Adrien Hamelin | May 31, 2017 12:45 PM | Tags: performance c++11
Have you registered for CppCon 2017 in September? Don’t delay – Registration is open now.
While we wait for this year’s event, we’re featuring videos of some of the 100+ talks from CppCon 2016 for you to enjoy. Here is today’s feature:
Game engine using STD C++ 11
by Jason Jurecka
Summary of the talk:
This session is going to give an account of the process and features used to create a game engine focusing on using std C++11 features and concurrency. We will go through the architecture of the engine design and the specifics of the C++11 features being used. We will also go through optimization choices and design mentalities that are being used to keep the code base simple, but powerful in game usage. The engine architecture we will be going through will be using parallelism as a way to distribute work and get performance out of the available hardware that can scale into the future.
While completing a full engine with cutting edge graphics techniques and a game to push the engine to its limits will take a while this session will go over the current state of the project and lessons learned. The ultimate goal of the project is to show the validity of using C++11 (and beyond) features in game engines to simplify code and improve stability while maintaining the performance and memory usage games demand.
By Jason Turner | May 30, 2017 02:09 PM | Tags: c++11 basics
Episode 65 of C++ Weekly.
C++11's std::fmin
by Jason Turner
About the show:
Jason covers C++11's std::fmin function: why it exists and what it is good for. He then demonstrates how an efficient variadic version of it can be implemented.
By Adrien Hamelin | May 29, 2017 12:55 PM | Tags: experimental efficiency
Have you registered for CppCon 2017 in September? Don’t delay – Registration is open now.
While we wait for this year’s event, we’re featuring videos of some of the 100+ talks from CppCon 2016 for you to enjoy. Here is today’s feature:
Channels - An alternative to callbacks and futures
by John Bandela
Summary of the talk:
Currently in the C++ Networking TS and Concurrency TS, callbacks and futures are the means for communicating an asynchronous value. However, there are disadvantages with both. Callbacks are low overhead, but hard to compose. Futures are easy to compose, but have increased overhead. In this talk we will consider channels as a third alternatives that can have lower overhead than futures while still being easy to compose
By Adrien Hamelin | May 26, 2017 01:06 PM | Tags: performance efficiency
Have you registered for CppCon 2017 in September? Don’t delay – Registration is open now.
While we wait for this year’s event, we’re featuring videos of some of the 100+ talks from CppCon 2016 for you to enjoy. Here is today’s feature:
Rich Code for Tiny Computers: A Simple Commodore 64 Game in C++17
by Jason Turner
Summary of the talk:
The Commodore 64 was released in 1982 and is the best selling computer model of all time. At 34 years old, even the most simple embedded processor today outperforms it. Join me on an exploration of how C++17 techniques can be utilized to write expressive, high performance, high level code for simple computers. Together we will create a game for this aging system.
You'll leave the talk with a better understanding of what your compiler is capable of and be able to apply these ideas to create better code on modern systems.
By robwirving | May 26, 2017 07:00 AM | Tags: None
Episode 102 of CppCast the only podcast for C++ developers by C++ developers. In this episode Rob and Jason are joined by Niall Douglas to talk about Google Summer of Code, Boost and his proposed Outcome library.
CppCast Episode 102: Boost Outcome with Niall Douglas
by Rob Irving and Jason Turner
About the interviewee:
Niall Douglas is a consultant for hire, is one of the authors of the proposed Boost.AFIO v2 and Boost Outcome, he is also currently the primary Google Summer of Code administrator for Boost.
By Adrien Hamelin | May 25, 2017 11:37 AM | Tags: community
Did you ever use them?
C++ Online Compilers
by Arne Mertz
From the article:
Online compilers can be useful tools to quickly compile a snippet of code without having to install a proper compiler on our computer. They can be especially useful to play with the newest language features, to share code snippets online or to compare different compilers...
By Adrien Hamelin | May 25, 2017 11:35 AM | Tags: experimental community
Interesting library
corsl - Coroutine support library
by Alexander Bessonov
From the article:
corsl
stands for "Coroutine Support Library" and consists of a number of utility classes and functions that simplify asynchronous programming in Windows. It is inspired by an amazingcppwinrt
library, developed by Microsoft.
cppwinrt
was created as a language projection for Windows Runtime, which is supported by Windows 8 or later operating systems. It is impossible to use in prior Windows versions.One of the goals of
corsl
library was being able to use it under Windows Vista or later operating system...
By Adrien Hamelin | May 25, 2017 11:30 AM | Tags: performance c++14
How to do a pool?
A self-contained Pool in C++14
by Jens Weller
From the article:
During C++Now I started writing a small application, that plays around with dlibs face recognition features. More on this later, the program uses the QThreadPool, and some researched showed that calling dlib::get_frontal_face_detector() is a very expensive operation. So I decided to write a thread safe pool to share the face detection object between threads, only loading as many as needed. The main thread owns the pool which owns the detection objects...
By TartanLlama | May 24, 2017 01:13 PM | Tags: performance
A post on writing GPGPU code in C++ using the SYCL standard from the Khronos group.
Accelerating your C++ on GPU with SYCL
By Simon Brand
From the article:
Leveraging the power of graphics cards for compute applications is all the rage right now in fields such as machine learning, computer vision and high-performance computing. Technologies like OpenCL expose this power through a hardware-independent programming model, allowing you to write code which abstracts over different architecture capabilities. The dream of this is “write once, run anywhere”, be it an Intel CPU, AMD discrete GPU, DSP, etc. Unfortunately, for everyday programmers, OpenCL has something of a steep learning curve; a simple Hello World program can be a hundred or so lines of pretty ugly-looking code. However, to ease this pain, the Khronos group have developed a new standard called SYCL, which is a C++ abstraction layer on top of OpenCL. Using SYCL, you can develop these general-purpose GPU (GPGPU) applications in clean, modern C++ without most of the faff associated with OpenCL.