Implement script level cache

[cosmo-kramer]

Program flow is like:

Speed improvement is achieved by making processModule cache anything( scripts, predefs, imports including $ivy and $file,etc.) it processes at script level( at block level it already gets) and tries to retrieve from cache next time it is asked to process same code.

Process Module checks if the script is available in cacheFolder i.e. scriptCaches. If it is not found, processModule0 is called which keeps the rest of program flow same as before this diff but passes back importHooks and other imports accumulated in processCorrectScript function. This data is stored by classFilesListSave which takes list of pkgName concatenated with wrapperName and hash values of blocks along with imports and stores them.

If script is found in cache, classFilesListLoad reads the list of names and hash values of blocks and loads those blocks from their cache folders made by compileCacheLoad function. Loaded import hooks are resolved by resolveSingleImportHook. Along with retrieved imports this data is passed to eval.evalCacheClassFiles which loads each classFile and evals the main function thus executing the code.

The final imports are returned by processModule function whether evaled or loaded from cache, thus processModule is opaque from outside whether cache HIT or MISS, it behaves in exactly same way in return as well as side effects except cache save.

[cosmo-kramer]

starting point for running scripts
Tries to load from cache else calls runscript

[lihaoyi]

Great that you got tests passing!

Some high level feedback:

• Would it be possible to move all the logic into the processModule function or some helper called by it? It seems you are duplicating a bunch of logic between runScriptLevelCache and cachedModule, as called through loadModule and load.module. Given that all these code paths end up going through processModule0 anyway, this would help keep the logic in one place.
• If we did that, we could probably get rid of runScriptLevelCache entirely, since runScript will eventuall call processModule0 which will take care of the caching etc.. After all, the "first" script you run is no different from any other script you load.module; they all go through processModule0
• We could probably get rid of the withCompiler flag; if all the script-caching logic is included as part of processModule0, check like https://github.com/lihaoyi/Ammonite/pull/403/files#diff-bcdb6a0282e047eba770bc309743e114R126 become un-necessary since that code calls processModule0, which should do the right thing by default

That's the high-level review; your code looks great. Leaving some other feedback in-line. Now that you've got this working and tests passing, let's iterate on this diff until it's great!

[lihaoyi]

Try not to re-format irrelevant things as part of this diff.

Things like this, and this (adding indentation to the whole for-comprehension) may or may not be the "right" formatting, but they have no place in an already-very-large diff like this one. Given that this diff is already large and hard to review for correctness, you should aim to avoid all this sort of minor/irrelevant changes so we can focus on the script-level-caching. If we care enough, we can put these changes into a separate diff later.

[lihaoyi]

@CoderAbhishek bump

[lihaoyi]

We should need to asInstanceOf to check if something is a Storage.Folder; instead, Storage should has classfilesListLoad and classfilesListLoad as part of it's interface, and Storage.InMemory should just keep things in an in-memory Map or something when saved and read from that Map on load

[lihaoyi]

The unit tests aren't testing the right thing. Our goal isn't to get the compilationCount to zero, but instead it is to ensure that the compiler is never initialized.

Realistically, what you should do is:

• Introduce a new compilerInitialized boolean on the Interpreter that starts as false and gets set to true when/every-time the compiler is initialized
• Move the tests from integration tests into "normal" unit tests, in the repl/ project
• Extract the body of runScript into runScriptInternal, with runScriptInternal private[ammonite] since it's only to be used for tests and not part of the public API
• Make runScriptInternal return a Res[(Seq[ImportData], Boolean)] with the boolean coming from the `compilerInitialized
• Make runScript call runScriptInternal, and discard the boolean.
• Make your unit tests instantiate the REPL and call scripts through the normal Main() call, except calling runScriptInternal rather than runScript, and validating that the second time (?) the same script is run, the compilerInitialized: Boolean that gets returned is false

[lihaoyi]

What happens if loadClass or evalMain fail? You should probably use Res.map on this to propagate the Res[_] from each individual loadClass into a big Res[List[...]], and make evalCachedClassFiles return a Res[_] to represent the possibility of failure