Book Image

Hands-On High Performance Programming with Qt 5

By : Marek Krajewski
5 (1)
Book Image

Hands-On High Performance Programming with Qt 5

5 (1)
By: Marek Krajewski

Overview of this book

Achieving efficient code through performance tuning is one of the key challenges faced by many programmers. This book looks at Qt programming from a performance perspective. You'll explore the performance problems encountered when using the Qt framework and means and ways to resolve them and optimize performance. The book highlights performance improvements and new features released in Qt 5.9, Qt 5.11, and 5.12 (LTE). You'll master general computer performance best practices and tools, which can help you identify the reasons behind low performance, and the most common performance pitfalls experienced when using the Qt framework. In the following chapters, you’ll explore multithreading and asynchronous programming with C++ and Qt and learn the importance and efficient use of data structures. You'll also get the opportunity to work through techniques such as memory management and design guidelines, which are essential to improve application performance. Comprehensive sections that cover all these concepts will prepare you for gaining hands-on experience of some of Qt's most exciting application fields - the mobile and embedded development domains. By the end of this book, you'll be ready to build Qt applications that are more efficient, concurrent, and performance-oriented in nature

Related Content you might be interested in

Current Title:

Small book image
Hands-On High Performance Programming with Qt 5
Marek Krajewski
Jan, 2019 | 384 pages
Small book image
Cross-Platform Development with Qt 6 and Modern C++
Nibedit Dey
Jun, 2021 | 442 pages
Small book image
Application Development with Qt Creator
Lee Zhi Eng | Ray Rischpater
Jan, 2020 | 426 pages
Small book image
Game Programming using Qt 5 Beginner's Guide
Pavel Vladimirovich Strakhov
Apr, 2018 | 714 pages
Table of Contents (14 chapters)
Preface
Preface
Who this book is for
What this book covers
To get the most out of this book
Get in touch
Free Chapter
1
Understanding Performant Programs
Understanding Performant Programs
Why performance is important
Traditional wisdom and basic guidelines
Modern processor architectures
Summary
Questions
Further reading
2
Profiling to Find Bottlenecks
Profiling to Find Bottlenecks
Types of profilers
Platform and tools
Profiling CPU usage
Investigating memory usage
Manual instrumentation and benchmarks
Further advanced tools
Summary
Questions
3
Deep Dive into C++ and Performance
Deep Dive into C++ and Performance
C++ philosophy and design
Traditional C++ optimizations
C++11/14/17 and performance
What your compiler can do for you
Optimization tools beyond compiler
Summary
Questions
Further reading
4
Using Data Structures and Algorithms Efficiently
Using Data Structures and Algorithms Efficiently
Algorithms, data structures, and performance
Using Qt containers
Qt algorithms, iterators, and gotchas
Working with strings
Optimizing with algorithms and data structures
Summary
Questions
Further reading
5
An In-Depth Guide to Concurrency and Multithreading
An In-Depth Guide to Concurrency and Multithreading
Concurrency, parallelism, and multithreading
Threading support classes in Qt
Threads, events, and QObjects
Higher level Qt concurrency mechanisms
Multithreading and performance
Beyond threading
Summary
Questions
Further reading
6
Performance Failures and How to Overcome Them
Performance Failures and How to Overcome Them
Linear search storm
Results dialog window opening very slowly
Increasing HTTP file transfer times
Loading SVGs
Quadratic algorithm trap
Stalls when displaying widget with QML contents
Too many items in view
Two program startup stories
Hardware shutting down after an error message
Overly generic design
Other examples
Summary
Questions
Further reading
7
Understanding I/O Performance and Overcoming Related Problems
Understanding I/O Performance and Overcoming Related Problems
Reading and writing files in Qt
Parsing XML and JSON at the speed of light
Connecting databases
More about operating system interactions
Summary
Questions
Further reading
8
Optimizing Graphical Performance
Optimizing Graphical Performance
Introduction to graphics performance
Qt graphics architecture and its history
Qt Widget's performance
QML performance
Other modules
Summary
Questions
Further reading
9
Optimizing Network Performance
Optimizing Network Performance
Introduction to networking
Qt networking classes
Improving network performance
Advanced networking themes
Summary
Questions
Further reading
10
Qt Performance on Embedded and Mobile Platforms
Qt Performance on Embedded and Mobile Platforms
Challenges in embedded and mobile development
Qt usage in embedded and mobile worlds
Embedded Linux and Qt performance
Mobile-specific performance concerns
Summary
Questions
Further reading
11
Testing and Deploying Qt Applications
Testing and Deploying Qt Applications
Testing of Qt code
Deploying Qt applications
Summary
Questions
Further reading
12
Assessments
Assessments
Chapter 1
Chapter 2
Chapter 3
Chapter 4
Chapter 5
Chapter 6
Chapter 7
Chapter 8
Chapter 9
Chapter 10
Chapter 11
13
Other Books You May Enjoy
Other Books You May Enjoy
Leave a review - let other readers know what you think

Questions

As in previous chapters, here are some questions so that you can test your understanding of the discussed topics:

  1. What did Linus say about C++ performance?
  2. What is an arena?
  3. What are PGO, FDO, LTO, LTCG, and WPO and what do they have in common?
  1. Have you looked into the compiler optimization example code from this book? Do you know what scalar replacement of aggregates is now?
  2. What do you think? How big is the overhead of a function call?
  3. What is dead stack pinning? Wasn't it a movie? Or was that dead stack walking?
  4. What is RTTI and is it expensive or not?
  5. What would change in the mutatingFunc() example discussed in the section about compiler optimization tricks, if it were defined in the same compilation unit?
  6. What is register pressure? Hint—it has to do with one of a compiler's main tasks, that is, register allocation.
...
Previous Section
End of Section 8
Next Section