
Zapcc – A caching C++ compiler based on clang - turrini
https://github.com/yrnkrn/zapcc
======
whitten
Could someone give us more of the story around ZAPCC ? I see that it is a C++
compiler that is based on clang, and that it only works well on Linux. Could
someone (perhaps turrini) share some comparison tables of the relative speed,
size, disk usage, of this compiler compared to clang and gcc ?

~~~
mbel
Explanation why fork of clang was required (as opposed to just improving
clang) would also be interesting.

~~~
hendzen
I evaluated zapcc at one point. Its a fork of clang because the changes are
very intrusive to clang, and probably would have had a hard time getting
accepted in to trunk without a ton of debate. I believe it actually daemonizes
in to a long running server process (zapccs) that then holds the instantiated
templates in memory, communicating with the zapcc compiler process over IPC. I
think that most clang maintainers would have found that radical of a
rearchitecting kind of controversial especially from an outsider to the
project.

~~~
loup-vaillant
> _especially from an outsider to the project._

That should really not be a criterion.

~~~
epilk
How else will the project know that the major changes will be maintained?
Having code in a project without an owner will just lead to bugs and bit rot.

~~~
loup-vaillant
So now not only projects have to be maintained, we also have to maintain
_changes_? I'm seriously getting sick at the notion that nothing can ever be
finished.

Bugs? That will be those introduced by the change, nothing more. If there is
any bug left, that's only because nobody discovered them yet. Having a
maintainer won't change that, only _usage_ reveals bugs. (Unless of course the
"maintainer" is instead tasked with finding bugs in the first place).

Bit rot? That's only an issue when the environment _around_ the code changes.
Clang is a _compiler_ , there's not much it cares about its environment. And
if you're talking about changes _within_ Clang that could have an effect, and
those are well within the maintainer's control. We shouldn't need a maintainer
for every patch.

This change in particular doesn't seem to introduce any new feature. I'm
guessing it only allows Clang to run faster. The new code path _replaces_ the
old, so it shouldn't require much more maintenance.

\---

More generally, we should do away with the notion that everything should be
maintained, forever. We should be able to code correct programs. We should
have environments stable enough to preserve that correctness. And we should
stop believing we need so much code in the first place. Let's not kid
ourselves, programs "require maintenance" (euphemism for "aren't finished"),
mainly because they're so damn big. We can do better, really.

[http://vpri.org/work/ifnct.htm](http://vpri.org/work/ifnct.htm)

[http://www.projectoberon.com/](http://www.projectoberon.com/)

[https://www.youtube.com/watch?v=kZRE7HIO3vk](https://www.youtube.com/watch?v=kZRE7HIO3vk)

------
qyron
Does ZapCC provide libclang.so which utilizes this caching?

I noticed that parsing heavy-templated files with clang-based tools is also
very slow which probably means that some kind of template instantiation (or
other processing step) is being made. These tools could greatly benefit from
any speedup.

While reported 2x average speed-up may be not big enough for me to consider
ZapCC for offline compilation, 2x less time to get list of completions in
Clang-based IDE is something I would be very happy to get!

------
floatboth
> in-memory compilation cache

I'd like to see a persistent cache. In-memory doesn't work well for the
"occasionally recompile Firefox, LLVM/clang, WebKitGTK, etc." desktop use
case...

~~~
lorenzhs
Isn't that what ccache provides? Admittedly it's not perfect but it sounds
like it might help your use case.
[https://ccache.samba.org](https://ccache.samba.org)

~~~
floatboth
This new zapcc thing seems to be more granular than ccache, it caches
individual template instantiations

------
jwilk
How is zapcc better than ccache?

~~~
sanxiyn
ccache does not speed up full build. zapcc does.

~~~
jwilk
What do you mean by "full build"?

~~~
jcelerier
zapcc speeds up the build even if you changed a #define across the whole
project or added a line to a header that you use everywhere leading to
recompiling of all your .cpp files.

------
rurban
Thanks for the open source release! I tested it with their commercial version
before and it was great for C++ projects.

------
Hello71
How does this differ from PCH?

~~~
lallysingh
Disk I/O. This stays in memory between compilations.

