On Software and Languages: 2019

You might perhaps know that I recently wrote a book (and blogged about it here). In its second chapter, where we discuss profiling and profilers, I mentioned Intel's VTune Amplifier, but because the book only uses open source tools I just wrote that:

"The commercial Intel performance suite comprises of VTune Amplifier, Intel Advisor, and Intel Inspector. VTune Amplifier is an advanced sampling profiler using hardware and OS counters, providing information on CPU, threading, memory, cache, and storage…"

Admittedly, there was some free version of VTune at the time, but you had to request it and you could use it only for a limited time for evaluation (if my memory serves me right), so I just classified it as a commercial tool.

But this week I learned, that there is a free version of VTune 2019 everybody can use. I didn’t believe that but I went to VTune’s homepage to check it – and indeed, an entirely free versions is available there. The commercial version simply comes with commercial-level support, and there are no other differences AFAICS.

Stress-Test with MinGW

So I downloaded the free version and wanted to try it. I knew that Intel tools integrate tightly with Visual Studio, and that Intel’s compiler is (still is?) binary compatible with Microsoft’s compilers, so I was interested if VTune would be able to understand MinGW’s symbol information. I know for sure, that in the past VTune only could understand Microsoft’s debug info format.

I wanted to test it out, because in my book I am using the standard Qt distribution for Windows (at the time of writing it was Qt 5.9) and this distribution is using MinGW as compiler. This also means that the provided Qt DLLs contained symbol information is stored in the MinGW format (i.e. Dwarf2).

To test VTune's support for various debug info format I profiled a following application of mine:

  +-----------------+
  |                 |          +-------------+
  |                 |          |             |
  |     QML GUI     +--------->+   QProcess  |
  |                 |          |             |
  |     (MinGW)     |          +---+----^-+--+
  |                 |              |    | |
  +-----------------+        start |    | | cin, cout, cerr
                                   |    | |
                                   |    | |
                                   |    | |
                            +------v----+-v---------+
                            |                       |        +------------------+
                            |                       |        |                  |
                            | "Backend" Executable  +--------+   Some SDK DLLs  |
                            |                       |        |                  |
                            |    (Visual Studio)    |        |      (MinGW)     |
                            |                       |        +------------------+
                            +-----------------------+

As you can see, it’s rather a complicated situation where a MinGW-based GUI is starting a Visual Studio-base executable that is loading some SDK DLLs that export a plain C API, but are internally using MinGW! So let have a try and see how VTune will cope with that mess.

Surprisingly, when I started VTune and let my example application be started and profiled by it I saw the following picture:

We see that VTune can indeed see and understand symbols from Qt’s QML libraries, as well as from my own C++ code in some QML extension modules, which were also compiled with MinGW. A great hooray! But that’s not enough – on closer inspection I found out, that also the “backend” executable symbols (Microsoft format) were visible in profile data, and then even one step further, i.e. the internal symbols of the SDK DLL it is using (MinGW format again)!

Surprise, surprise, it seems to be working rather neatly. Nice one! It turned out that in a new profiling project the "Analyze child processes" option is turned on by default. I had only to provide the location of my sources, everything else just worked!

Summing Up

As an addendum (or call it correction) to the book, I can say that the VTune Amplifier is another option when profiling Qt applications on Windows!

Besides the traditional profiling to find execution hotspots, VTune has a very nice support for diagnosing multithreaded performance, visualizing lock contentions, it can help with the Intel CPUs by showing cache misses and pipeline stalls, it can diagnose memory access bottlenecks and also profile entire system with multiple applications. You’ll admit it’s quite a mighty* tool!

--
* Want to see ho to use all these features? There is a video guiding you around the GUI here, and here is an article about "Thread, Memory, and Vector Optimizations" using VTune and Intel Advisor, showing how to diagnose and improve usage of the available cores, optimize cache usage and introduce vectorization.

I always wanted to say that since I saw Raymond Chen's blog, and now. at last, I can! The title of the book is "Hands-On High Performance Programming with Qt 5" and you can get it from Amazon (here) or Packt Publishing (here). The book's cover looks like that:

I have to say that I rather like the look of it!

TL;DR

A new book About Qt's and C++ performance. Uses Qt 5.9 - 5.12 on Windows. Guides the reader from an intermediate to the (lower) advanced level. 4 of 5 stars 😉.

There are also code examples illustrating some of the discussed concetps (to be found at https://github.com/PacktPublishing/Hands-On-High-performance-with-QT).

What this book is about.

This book is about many things. Judging from the title it's about performance optimization of Qt 5
(Qt 5.9 - Qt 5.12) programs. But because Qt's underlying language is C++ it is also about C++ optimizations and performance. Because C++ is a close-to-the-metal language (some would say low-level) we also discuss the hardware architectures. Also because Qt framework covers so many areas we also discuss data structures and algorithms, multithreading, file I/O and parsing, GUI and graphics, networking, and even mobile and embedded platforms.

Quite a mouthful, you'd say? Yes, it's true. But it also makes it interesting, and shows how many facets there are to the performance optimization.

Additionally, I decided to use Windows as the development platform for this book. Most Qt books use Linux, probably because Qt Creator IDE offers a much better tooling there. But because Windows is also a very popular platform I wanted to take the road less traveled and try to find out how to compensate the lack of the standard Linux performance tools on Windows.

We use only open-source or free tools, Qt Creator as development environment and Qt 5.9 LTE version for code examples (as it was the last LTE version at the time I started writing this book).

Why did I write it?

Well, because I always found performance optimization very interesting. And because I have been working with Qt for quite a long time now, nothing to say about C++! So, as the publishers approached me with a proposed book title I knew I could write rather a good book about it!

The second reason was that there wasn't a resource about performance optimization I would be content with. There area a couple of C++ performance books, but I wasn't entirely convinced by them. As of Qt and its specific problems there was nothing! Well, there was a host of information scattered in blogs, Stack Overflow, books, articles and Twitter threads. So I thought that before I forget it all, I'd better put it to paper!

I also wanted to write a book I'd have liked to read when I first started to learn about performance and optimizations, because there wasn't such a thing either. Thus I settled on a intermediate-level, approachable, but not trivial book.

What material is covered

This book was planned as an intermediate level read. If you can write some C++ and have learned to write basic Qt application then it is for you. No further knowledge is requires, as every topic (e.g. data structures, graphics, networking) will be introduced in a understandable and (I hope so) entertaining manner.

My initial plan for the book was:

Part I - Basics
Intro - basic performance wisdom and techniques, hardware architecture and its impact.
Profiling - performance tools and how to use them. As I said, we don't want to make it easy for us and look at the Windows platform!
C++ - how performant is C++ really? And what are optimizations the compiler (and linker) can do?
Part II - General Techniques
Data structures and algorithms - what is the performance of Qt containers and strings? Do we have to use them?
Multithreading - Qt's take on threading and how to speed up your program with concurrency.
Fails - some more memorable performance problems I encountered in my career
Part III - Selected Qt Modules
File I/O etc - Qt and file system performance, JSON and XML parsing. Also memory mapped files and caching.
Graphic - GUI, widget and QML performance. Probably the most interesting part of the book.
Networking - network performance and network support in Qt. Because we live in the ubiquitous connectivity era!

However, the editors wished two additional chapters, so I also added them (unfortunately, this made the three-part structure obsolete):

Mobile and embedded - how to use Qt on mobile and embedded (a kind of advanced chapter applying all we have learned before to two specific platforms)
Testing - a goodie chapter about testing techniques, GUI testing and performance regression tests. At the end this chapter turned out pretty interesting!

I really think that this book can do a good job to guide the reader from an intermediate to the (lower) advanced level!

Table of Contents

On the publisher's book page there is a TOC (here), but it is very high level, and doesn't really show the real contents of the book. It goes rather monotonously like "Some intro for topic", "Qt classes fro that", "Performance techniques for that", "Summary", "Questions" and "Further reading". I agree with you that one cannot judge the level and quality of the book from that. It could be everything - from horrible to superb.

For that reason I include here a complete TOC as it appears in the book, so you can have a better idea of themes covered. Without much further ado, here it is:

OK, I tried, but it's way too long, it follows at the end* of the post.

You can see from that more detailed TOC that there is a wealth of information and techniques in there! I really think that This book can do a good job to guide the reader from an intermediate to the (lower) advanced level!

The "Questions" and "Further Reading" sections

As unseemly as they look in the TOC, these sections were my secret personal favorites. The "Questions" sections contain, as you probably guessed, some questions to test your understanding of themes discussed in the given chapter, but they also will try to deepen your understanding and sometimes even to introduce new and interesting information! I enjoyed writhing them because it was fun trying to find out how could I keep an intelligent reader still interested after the real material was already introduced.

As this is an intermediate-level book, and because I didn't want to write a 500-600 pages tome, it couldn't go deep on every of the introduced themes. Because of that I also included the "Further Reading" sections, where more advanced materials are referenced. Qt covers so many areas, and some themes like networking, graphics, embedded or mobile are so deep, that you will definitely need to consult more books and articles! In hindsight I should have to include even more references, but you know, If I had more time etc...

Summary

If I had more time, this book could (of course) be much better. But even so I'm rather content with it, considering that I wrote it in half of a year only, in parallel with my normal working hours. I hope you will enjoy it!

PS: Maybe I will start some kind of online addendum/errata for this book, as there are quite many things I'm still leaning after I finished writing it.

--
* Here comes the TOC in its whole glory:

Preface

Chapter 1: Understanding Performant Programs 1

Why performance is important 1

The price of performance optimization 2

Traditional wisdom and basic guidelines 2

Avoiding repeated computation 4

Avoiding paying the high price 4

Avoiding copying data around 5

General performance optimization approach 6

Modern processor architectures 7

Caches 7

Pipelining 8

Speculative execution and branch prediction 10

Out-of-order execution 10

Multicore 11

Additional instruction sets 12

Impact on performance 13

Keeping your caches hot 14

Don't confuse your branch predictor 15

Parallelizing your application 16

Summary 16

Questions 17

Further reading 17

Chapter 2: Profiling to Find Bottlenecks 19

Types of profilers 20

Instrumenting profilers 20

Sampling profilers 21

External counters 22

Note on Read Time-Stamp Counter 22

Platform and tools 22

Development environment 23

Profiling tools 24

Just use gprof? 25

Windows system tools 25

Program profiling tools 27

Visualizing performance data 30

Memory tools 30

Profiling CPU usage 31

Poor man's sampling technique 31

Using Qt Creator's QML profiler 32

Using standalone CPU profilers 35

Reiterating on sampling profiling's limitations 39

Investigating memory usage 39

Poor man's memory profiling 40

Using Qt Creator's heob integration 41

Manual instrumentation and benchmarks 45

Debug outputs 45

Benchmarks 46

Benchmarks in regression testing 46

Manual instrumentation 47

Further advanced tools 48

Event Tracing for Windows (ETW) and xperf 48

Installation 48

Recording and visualizing traces 50

Conclusion 53

GammaRay 54

Building GammaRay 54

When can we use it? 56

Other tools 57

Graphic profilers 57

Commercial Intel tools 58

Visual Studio tools 58

Summary 59

Questions 59

Chapter 3: Deep Dive into C++ and Performance 61

C++ philosophy and design 61

Problems with exceptions 62

Run-time overheads 63

Non-determinism 63

RTTI 64

Conclusion 64

Virtual functions 64

Traditional C++ optimizations 65

Low-hanging fruit 65

Temporaries 66

Return values and RVO 66

Conversions 67

Memory management 68

Basic truths 68

Replacing the global memory manager 69

Custom memory allocators 70

Where they do make sense 71

Stack allocators 71

Conclusion 71

Custom STL allocators 72

Template trickery 73

Template computations 73

Expression templates 74

CRTP for static polymorphism 75
Removing branches 76

C++11/14/17 and performance 77

Move semantics 77

Passing by value fashionable again 78

Compile time computations 78

Other improvements 80

What your compiler can do for you 81

Examples of compiler tricks 81

On Software and Languages

Wednesday, 18 December 2019

No cursor in your embedded Qt-App on iMX-6?

Friday, 5 July 2019

VTune Amplifier and profiling MinGW on Windows

Sunday, 28 April 2019

For last 2 days - my book for $10 only!

Monday, 25 February 2019

Holy cow, I wrote a book!

Blog Archive

About Me

Popular Posts

Visitors

Featured post

Monads, who's afraid of Monads (and C++)?

Search This Blog