Slow compile times

[user529481]

The compile times are quite slow for directly including Quill into the project. I have a small program which takes about a second to compile but with Quill it takes 10 seconds, that's without calling any logging functions. Even some of my heavily templated programs don't take this long. Could compile times be further improved?

[odygrd]

You can build the backend part of the library as a static library, then you only need to include two headers for logging LogMarcos.h and Logger.h

See https://github.com/odygrd/quill/tree/master/examples/recommended_usage

quill/examples/recommended_usage/recommended_usage.cpp

Line 24 in 2e86f46

// We need only those two headers in order to log

These headers will also add minimal includes to your translation units. We are very careful what we are including in these two headers for that reason.

With this approach you will only have compile the quill static library once and not every time you change your files.

We have a compile time benchmark using that approach here

https://github.com/odygrd/quill/blob/master/benchmarks/compile_time/compile_time_bench.cpp

This is similar setup to recommended usage just simplified

https://github.com/odygrd/quill/tree/master/benchmarks/compile_time

[user529481]

Thanks! That worked. I ran an initial test by replacing all existing printf with LOG_INFO defined in overwrite_macros.h and making appropriate formatting changes (eg. %d with {}, etc.), but I'm getting reduced data processing throughput while logging to console. With printf I was able to process about 24 hours worth of data in 60 seconds, but with LOG_INFO I only managed to process about 10 hours worth in the same timeframe. Is there a setting I missed?

[odygrd]

With Quill, when you call LOG_INFO(...), your message is not immediately written to the console or file on the same thread.

Instead, Quill’s front-end (the thread where your code runs) enqueues the log message into a lock-free queue, then returns almost immediately.

The actual “heavy lifting” — fully formatting the message and writing it to the console or files — happens in Quill’s background logging thread.

That’s where more logic runs compared to a simple printf, but it all happens off the caller’s critical path.

In short, it’s not really comparable to synchronous printf logging — Quill is designed to minimize overhead on your hot path while asynchronously handling the logging work in the background.

You can easily verify this by timing a printf call versus a LOG_INFO call — you’ll see that the LOG_INFO return time is significantly lower, since most of the work is offloaded to the background thread.

Also try using a FileSink instead of ConsoleSink— it will generally improve your overall processing throughput.

[user529481]

Thank you!