What is hot reloading?

C++ development lifecycle consists of - coding and waiting for the compiler to compile and link. Sometimes, the compiler takes many minutes, sometimes, hours to generate a resultant executable. Precious development time is spent... waiting.

Photocredt: XKCD - Compiling

Before using Hot Reloading, you can avail of the following tips:

• Using a RAM drive means you have to put the whole C++ Build tool to RAM drive, all the libraries, and save the files back to NVME drive. This means your work will get accidentally wiped if your computer reboots.
• Moving code to PCH (Pre-compiled Headers), optimizing your code only goes so far before slow C++ compiler wears you down.
• Make sure your build process runs in Parallel. Set Ninja number of parallel jobs or set the number of parallel jobs Visual Studio

• In C++ Builder, there is Twine compiler enhancement which optimizes compile-time.

Live++ is easy to integrate with your code, and Live++ hot-patching modifies code-changes at run-time, greatly reducing debug and refactoring time.

Immense Time Savings

Adding Live++ is, simply linking to the Live++ SDK, and running the initialization process. When you want to recompile, use the Live++ hotkey - Ctrl+Alt+F11, as it patches the EXE with your updates, while your app is still running!

Whoa. As a development example, you load data from the database, and you update the code to generate report, without restarting the app.


Without using Live++, you would have to constantly reload data from the database, then debug the code to generate the report.

Image a situation where, you update code, and don't have to repeatedly reload data from database to generate the report? That would save lot of time, allow you to resolve bugs immediately.

Photocredit: Terminator 2 clip.

Reduce Build Times

An average build takes 7+ minutes. A full recompile may take 15 minutes.

If there are multiple dependencies, and, work needs to be done in auxiliary projects, Doing a final build could take longer than an hour.

After using Live++, I could go between 3 seconds to 3mins for a hot-reload, instead of a compile every 7-15 minutes. This immense time-saving means I can do work faster.

    lpp::LppDefaultAgent lppAgent = lpp::LppCreateDefaultAgent(nullptr, L"(Folder)");
    // bail out in case the agent is not valid
    if (!lpp::LppIsValidDefaultAgent(&lppAgent))
    {
        return 1;
    }
    // enable Live++ for all loaded modules
    lppAgent.EnableModule(lpp::LppGetCurrentModulePath(), lpp::LPP_MODULES_OPTION_NONE, nullptr, nullptr);

Do you have C++ QT projects which require developers, who work smart, fast and think beyond the AI box? Contact us.

What is Super Luminal?

Superluminal is a modern cutting-edge profiler, for Delphi's 64-bit and C++ Builder's ModernX 64-bit compiler. It is priced affordably, and one-time purchase if you are buying an individual license.

• Individuals: €59 (perpetual license),
• Businesses: €289 (per seat/per year).

Great feature set, and burn-down chart.

Superluminal Tutorial for Delphi

Superluminal is designed to profile 64-bit EXE files. If you are targeting Delphi 32-bit or C++ Builder 32-bit EXEs, you can easily switch your target platform to Delphi or C++ Builder Windows 64-bit.

Step 1. Map2PDB

Superluminal uses PDB files for profiling. However, Delphi generates TDS files. To bridge this gap, you can use a utility called map2pdb that converts MAP files into PDB format.

1. Download `map2pdb.exe` from Anders Melander's Github repository.

2. Copy `map2pdb.exe` to a folder included in your system's environment pat

The below paths are suggested directory for specific Delphi versions.

For Delphi 12.2, Delphi 12.3

C:>Users>Public>Documents>Embarcadero>Studio>23.0>Bpl

For Delphi 12.1:

C:>Users>Public>Documents>Embarcadero>Studio>22.0>Bpl

For Delphi 12.0:

C:>Users>Public>Documents>Embarcadero>Studio>21.0>Bpl

For Delphi 11.3:

C:>Users>Public>Documents>Embarcadero>Studio>20.0>Bpl

_Replace > to "" as Wordpress removes "backslash"._

Note: a Gist version of the above-mentioned paths is provided.

Step 2. Enable Map file output

You need to enable MAP file in Delphi and C++ Builder. By default, this is turned off.

Go to Project | Options, Building | Delphi Compiler | Linking, Map File. Change to Detailed.

For the next step, there are 2 approaches, to generate the MAP file via post-build event, or batch file.

Step 3A. Use Post-build event.

map2pdb.exe -pdb:(OUTPUTDIR)(OUTPUTFILENAME).pdb -bind:(OUTPUTDIR)(OUTPUTFILENAME) (OUTPUTDIR)(OUTPUTNAME).map

  Note: a Gist version of the above-mentioned paths is provided.  

Step 3B. Use a batch file

map2pdb.exe -pdb:.win64DebugProfilerSample1.pdb -bind:.win64DebugProfilerSample1.exe .win64DebugProfilerSample1.map

pause

where: _win64DebugProfilerSample1.exe_ is your output project.

  Note: a Gist version of the above-mentioned paths is provided.  

Step 4. Profile!

Please see the github directory for 3 sample projects - in Delphi, C++ Builder and C++ Builder ModernX.

How to get your C++ ModernX project to work with Superluminal

Enable MAP file and set property to Detailed.

Profile! You should be able to see C++ Builder functions in Superluminal.

Alternate Profilers

To profile 32-bit EXEs, you can use Nexus Quality Suite, ProDelphi, Intel VTune, or Spider Profiler.

Enhance your App Performance using NQS

NexusDB's Nexus Quality Suite "NQS" is another excellent choice.

- -NQS includes CodeWatch, TestDriver and Coverage Analyst, invaluable tools to have in your toolchest.

- CodeWatch allows you to check memory-leaks, resource-leaks and API errors.

- TestDriver is a testing tool that records mouse and keyboard-strokes as scripts. TestDriver works with VCL and FMX.

- Coverage Analyst allows you to do code-coverage, to analyze which lines of code the profiler has hit. This allows you to check for redundant, dead-code, or create test-cases with conditions which execute all the lines in the resultant EXE or DLL.

Propel your Delphi app to new heights using ProDelphi

If you are using the Delphi part of RadStudio, ProDelphi is a CPU-cycles profiler. This works by isolating the code profiled, to only specific procedures and functions.

This works by isolating the code profiled, to only specific procedures and functions.

ProDelphi offers an alternative to traditional profiling, where it may be impractical to do whole-app profiling, due to copy-protection code interfering with the Profiler, or contains non-source DCUs or OBJ files, or interfaces third-party DLLs or non-Delphi DLLs which contains copy-protection

ProDelphi allows you to do drill-down profiling, where only certain parts of the application are profiled.

There is no correct way of doing profiling. Profiling is a process of sleuthing, finding bottlenecks and optimizing code.

Are you interested to get competitive priced updates, or need to update your Delphi apps? 
Contact us.

Article Corrections

1. Anders Bitbucket link updated to Github.

2. A Gist of the command-line statements are published on Gist. For some reason Wordpress keeps munching the slash for no reason.

Andy's VCL Fix Pack is a Delphi open-source unit that fixes VCL and RTL issues at runtime by patching the original functions.

Andy's Unit contains easy-to-use functions to update code that cannot be easily recompiled or changed.

If you try to change VCL sources (files in Source folder of your RadStudio, Delphi or C++ Builder installation) and attempt to recompile them within your project, you'll get multiple errors, such as: DCU mismatch, (file1.pas) is compiled with a newer version of (file2.pas). This occurs when source-code is compiled with a different file and needs to be fully recompiled.

The above errors may occur when source code is not present. This may occur, when a third-party library you brought, contains only DCU or DCP files.

Example

In the below example, I create a function. The code is redirected to another unit.

procedure TfrmSample.Update1; 
begin
  ShowMessage('Hello World');
end;

procedure TfrmSample.Button2Click(Sender: TObject);
begin
  Update1;
end; 

Using VCLFix.pas, I can redirect the TfrmSample.Update1 to another unit, so it shows "Bye World" instead!

Fixing QC15408

I'm using Andy's VCL Fix Pack to fix Delphi bug QC15408.

In Delphi QC15408, when VCL UI objects TButton, TEdit are disabled, hint is also disabled.

Seen below

In this fix, when the VCL UI objects TButton, TEdit are disabled, the hints are enabled.

This fix works by hooking code that's private in Controls.FindDragTarget and replacing it with code I've made.

Source code is at this git repository:

https://github.com/PolywickStudio/AndyVCLFIXPack

In this example, you can use Andy's VCLFixPack to create work-arounds for VCL bugs or resolve VCL issues.

QT Windows C++ Applications do not have a specific Windows Exception handler.

In MFC, there is a CodeProject project XCrashReport.

In QT, there isn't a specific SEH (Structured Exception Handler) so you need to add this manually.

QT Windows SEH Handler

In main.cpp file, before QT starts, add the following lines

#ifdef _WINDOWS
// This code is specific to Windows platform
#define NOMINMAX
#include <windows.h>
#undef NOMINMAX


LONG WINAPI unhandled_handler(struct _EXCEPTION_POINTERS *apExceptionInfo);
{
    // Create your SEH 
    create_minidump(apExceptionInfo);
    return EXCEPTION_CONTINUE_SEARCH;
}
#endif

int main(int argc, char *argv[])
{
#ifdef _WINDOWS
    SetUnhandledExceptionFilter(unhandled_handler);
#endif
    QApplication app(argc, argv);
    return app.exec();
}

The above code, paired with an on-line bug tracker and CI/CD environment, allows for fast bug triage for QT applications.