Cache

[Bombastisk]

I have checked out the Twing project. Quite nice! I have one question though. Is there any way to completely turn off internal caching for the templates. So that they are loaded from scratch every time?

[ericmorand]

Hi @Bombastisk,

Thank you for your question.

It is not currently possible to disable TwingEnvironment internal cache. But more importantly, it is not recommended. Let me explain why.

There are two levels of cache: the low-level one and the high-level one. The low-level cache is the one you are talking about - the internal cache of the environment. The high-level caches are provided by TwingCacheInterface implementations and are passed to the environment constructor via the options parameter.

The low-level cache is expected to live as long as the time needed for the template to be compiled and executed.
The high-level caches are expected to have way longer life-cycles. For example, the provided TwingCacheFilesystem implementation uses the filesystem as cache and has a potentially infinite lifetime.

The low-level cache is extremely important for performance: it is in-memory, so it is the fastest possible cache at our disposal, but more importantly it is used to cache the sub-templates that the template we are compiling depends on. Let's take the following template index.html.twig as an example:

{% for i in 1..10 %}
    {{ include('partial.htlm.twig') }}
{% endfor %}

When that template is executed, the partial.html.twig template needs to be compiled for every loop iteration. Depending on the content of that template, this operation can be expensive. To mitigate this potential issue, the environment will compile partial.html.twig just once, store the compiled template into its internal low-level cache, and reuse that cached template for the other loop iterations.

Basically, the low-level cache serves this only purpose: speeding the compilation of a template by caching the result of the compilation of all the templates it depends on, in case they need to be reused.

The high-level cache steps in when Twing needs to compile a template - in other words when it did not find it already in the low-level cache. In the case of our example, the high-level cache would only be used on the first iteration. The high-level cache will check if a compiled template exists for the path partial.html.twig and if so, will return that compiled template that would in-turn be cached by the low-level cache.

In a nutshell:

• No cache available for a template: compilation from scratch (lexing, parsing, compilation) - SLOW
• High-level cache available for a template: reading from the high-level cache - MODERATELY FAST (think here about a filesystem cache: reading from the filesystem is faster than compiling from scratch but slower than reading from in-memory)
• Low-level cache available for a template: reading from the low-level cache - FASTEST POSSIBLE

The issue that may arise with the low-level cache is that if you plan to reuse an environment multiple times, you will hit the low-level cache all the time even if partial.html.twig content did change. This is by design: the low-level cache needs to be the fastest possible and doesn't perform any check outside of "is there a template named partial.html.twig here?". Cache "freshness" is provided by the high-level cache via the getTimestamp method.

It means that, would you reuse the same environment for subsequent compilation, you would certainly not get the expected result if one of the included templates did change.

That's why you should always create a fresh environment, whenever you need to compile a template. The low-level cache would then be empty and the high-level cache would provide freshness support, ensuring that a file that has been modified isn't served.