We're starting to make heavier use of GWT in our projects, and the performance of the GWT compiler is becoming increasingly annoying.
We're going to start altering our working practices to mitigate the problem, including a greater emphasis on the hosted-mode browser, which defers the need to run the GWT compiler until a later time, but that brings its own risks, particularly that of not catching issues with real browsers until much later than we'd like.
Ideally, we'd like to make the GWT compiler itself quicker - a minute to compile a fairly small application is taking the piss. However, we are using the compile if a fairly naive fashion, so I'm hoping we can make some quick and easy gains.
We're currently invoking com.google.gwt.dev.Compiler as a java application from ant Ant target, with 256m max heap and lots of stack space. The compiler is launched by Ant using fork=true and the latest Java 6 JRE, to try and take advantage of Java6's improved performance. We pass our main controller class to the compiler along with the application classpath, and off it goes.
What else can we do to get some extra speed? Can we give it more information so it spends less time doing discovery of what to do?
I know we can tell it to only compile for one browser, but we need to do multi-browser testing, so that's not really practical.
All suggestions welcome at this point.
This question is related to
java
performance
gwt
For GWT 2.x I just discovered that if you use
<set-property name="user.agent" value="ie6"/>
<extend-property values="ie8,gecko1_8" name="user.agent"/>
You can even specify more than one permutation.
Here is a list of user.agent values you can set it to.
(Adding this here because I keep ending up here when I search for what I should set to make it only produce a permutation for chrome. Answer is: <set-property name="user.agent" value="safari"/>
)
In the newer versions of GWT (starting either 2.3 or 2.4, i believe), you can also add
<collapse-all-properties />
to your gwt.xml for development purposes. That will tell the GWT compiler to create a single permutation which covers all locales and browsers. Therefore, you can still test in all browsers and languages, but are still only compiling a single permutation
You can add one option to your build for production:
-localWorkers 8
–
Where 8 is the number of concurrent threads that calculate permutations. All you have to do is to adjust this number to the number that is more convenient to you. See GWT compilation performance (thanks to Dennis Ich comment).
If you are compiling to the testing environment, you can also use:
-draftCompile
which enables faster, but less-optimized compilations
-optimize 0
which does not optimize your code (9 is the max optimization value)
Another thing that more than doubled the build and hosted mode performance was the use of an SSD disk (now hostedmode works like a charm). It's not an cheap solution, but depending on how much you use GWT and the cost of your time, it may worth it!
Hope this helps you!
The GWT compiler is doing a lot of code analysis so it is going to be difficult to speed it up. This session from Google IO 2008 will give you a good idea of what GWT is doing and why it does take so long.
My recommendation is for development use Hosted Mode as much as possible and then only compile when you want to do your testing. This does sound like the solution you've come to already, but basically that's why Hosted Mode is there (well, that and debugging).
You can speed up the GWT compile but only compiling for some browsers, rather than 5 kinds which GWT does by default. If you want to use Hosted Mode make sure you compile for at least two browsers; if you compile for a single browser then the browser detection code is optimised away and then Hosted Mode doesn't work any more.
An easy way to configure compiling for fewer browsers is to create a second module which inherits from your main module:
<module rename-to="myproject">
<inherits name="com.mycompany.MyProject"/>
<!-- Compile for IE and Chrome -->
<!-- If you compile for only one browser, the browser detection javascript
is optimised away and then Hosted Mode doesn't work -->
<set-property name="user.agent" value="ie6,safari"/>
</module>
If the rename-to
attribute is set the same then the output files will be same as if you did a full compile
Although this entry is quite old and most of you probably already know, I think it's worth mention that GWT 2.x includes a new compile flag which speeds up compiles by skipping optimizations. You definitely shouldn't deploy JavaScript compiled that way, but it can be a time saver during non-production continuous builds.
Just include the flag: -draftCompile to your GWT compiler line.
If you run the GWT compiler with the -localWorkers flag, the compiler will compile multiple permutations in parallel. This lets you use all the cores of a multi-core machine, for example -localWorkers 2 will tell the compiler to do compile two permutations in parallel. You won't get order of magnitudes differences (not everything in the compiler is parallelizable) but it is still a noticable speedup if you are compiling multiple permutations.
If you're willing to use the trunk version of GWT, you'll be able to use hosted mode for any browser (out of process hosted mode), which alleviates most of the current issues with hosted mode. That seems to be where the GWT is going - always develop with hosted mode, since compiles aren't likely to get magnitudes faster.
Source: Stackoverflow.com