Community
Participate
Working Groups
We're using the batch compiler and would like an option to cache jar files. We know that during the running of our system, the relevant jar files do not change at all, but take a considerable amount of the compilation time. Is there an option for caching them? If not, how hard would it be to add and where might it go?
Are you running several instances of the compiler in a row with the same JVM ? Are you customizing any of the compiler (internal) API, such as the name environment ?
Yes. We create 1 Main object and call compile over and over in the same JVM. We haven't done any customization yet.
Would be good if we could come up with a strategy benefitting also the Java builder scenario (could be unrelated).
How did you measure the amount of time to read the jar files ? How many files are passed to the batch compiler each time its called ? Are any the files repeated in another call later or are they only compiled once ?
The measurement came from a rough profiler we have. We only pass 1 file at a time to the compiler. Once a file is compiled, its never compiled again.
I'm curious now... why only 1 file at a time? What percentage of the compile time did reading the jar files take? Reading the same jar files would not be much of an issue if you passed 100-1000 files to the batch compiler at a time. Is there a reason that you only pass 1 file at a time?
Its 1 file at a time because the compilation is kind of iterative. We don't know what files we're going to need next until we compile the first one. jar reading is about 40% of the total compilation time. It might be theoretically possible to re-architect so we could compile more than 1 file at once, but I'm not sure.
> Its 1 file at a time because the compilation is kind of iterative. > We don't know what files we're going to need next until we compile the first > one. But if the first file references 10 other classes, then we must compile all of their files at the same time, so there is no point recompiling those 10 files. And if those 10 additional files need 50 other classes... and so on. The batch compiler notices when a requested type's source file has been changed more recently than its .class file & recompiles the source file. In other words, we do not use old .class files when the source file has been updated. How many .class files are created when you compile your first type? If your first type is a major type with references to numerous other types, then its possible that most files were compiled when the first source file was given to the batch compiler.
So how many .class files are created when you compile your first type ? Can you please explain why you need to compile each file individually ?
So do you still need to compile each file individually ? Or can we close this since you're now compiling more files at once ?
We still often need to compile files individually. For example if a single file changes (which happens often) we need to just compile that one file and would like it to be as fast as possible.
But changing & compiling 1 file will not benefit from a jar cache, unless you're going to keep the batch compiler instance around forever. And that is definitely not recommended since it can hold onto quite a bit of memory.
right - we understand that. for our application its better for us to use that memory to save compilation time.
Changing Version tag to something more believable. Note that this is not a statement about when the enhancement request will be addressed (the Target Milestone field is used for that); the Version tag should be set to the version of Eclipse you were using when you saw the need for the enhancement.
