I'm working on a Flex project that has 28 modules, and 1 main SWF. Compiling everything takes 18 minutes total. I'm using load-externs to load a link-report from my main SWF - that works great. The file size of the modules is minimal. But link-checking still occurs for each individual module, increasing the compile time dramatically.
So say I edit a file in my main SWF that a module uses. mxmlc basically performs link-checking for the same file in that module. Even when -incremental=true. When I edit a file that ALL of the modules reference (which happens frequently), ALL of the modules perform link-checking. This has the effect of basically compiling the main SWF 28 times.
This is frustrating, because link checking occurs when I compile my first SWF. It should not have to reoccur for every module. I tried using fcsh, which would hopefully store these links in memory, but that had no effect.
Maybe it would help to compile a SWC of my main SWF, and use that for link-checking instead?
Here are the commands I use to build:
mxmlc -link-report=report.xml -strict=true -debug=false -optimize=true -incremental=true Project.mxml
mxmlc -load-externs=report.xml -strict=true -debug=false -optimize=true -incremental=true ModuleXX.mxml # 28 times
I haven't found a solution for this problem and it's hindering the development of my project. Any help would be greatly appreciated.
Thank you!
Jimmie
I agree that 18 minutes is a very long build time, but this kind of module size optimization should only be necessary on a release build. So my simple recommendations are
Don't use compiler optimization during development time
Only recompile the modules you are working on
Upgrade your hardware
Upgrade your software (the Flex 4 compiler should be faster than Flex 3)
Related
We're converting quite a large Flex project from a monolithic web application project type to multiple projects where most of the existing files (~2000) will newly live under a Library project and there will be multiple runnable projects beside it (like web version and a desktop version).
What concerns us is the compilation time. It used to be something like a minute (already more that we would have liked) but now it easily takes ~10 minutes which is unacceptable.
Is it expected to see such a big difference when moving from MXMLC compiler to COMPC? I know MXMLC optimizes its usage and will skip files that are not used in the application it is expected that the COMPC build would be slightly slower as it compiles more files but I don't think the difference should be 10 fold, should it?
I've noticed that, recently, builds in FlexBuilder have been taking much, much longer than they used to (30 or 40 seconds, as opposed to 3 or 4). What is the simplest way of profiling these builds to figure out what is taking so much time?
Did you try cleaning your project? ( Project--> Clean )
From the Adobe Live Docs: Performing a clean build
After a project has been built, subsequent builds affect only the resources that have been added
or modified. To force the Flex Builder compiler to rebuild all resources in a project, you can
perform a clean build. You might perform a clean build if, for example, you want to eliminate all
potential sources of a problem you encountered when testing your application.
1. Select Project > Clean from the main menu.
2. Select the project (or projects) whose build files you want to discard and rebuild from scratch.
3. Click OK.
I have found that when Flex Builder reaches a java heap space of, say 500M, the builds slows way down, try restarting Flex Builder whenever that happens. Also, add the heap monitor to the status bar by going to Window->Preferences, type "heap space" in the filter and check the box that says "Show heap status".
I've also found that embeds slows the builds down very much, so does having a lot of stuff in your html-template folder. I suggest moving all embeds to a separate module, like described here.
Evenrything in your html-template folder will get copied to bin-debug during build, so that will be slow too. How to solve this depends on your project, but removing any .svn or .cvs folders from html-template is a start.
FlashBuilder is just an eclipse and eclipse is Java. You can profile eclipse itself with JProfiler. so much for the first question.
To trakc down, waht actually makes the build process so slow is much harder and profiling may not be what you want. Additionally to the adives above, there is also the
-incremental=true
compiler argument.
Make sure your "-Xms" entry equals your "-Xmx" entry.
And there's more than heap. You can also set the -XX:PermSize= and -XXMaxPermSize= parameters wisely. But that would need some understanding of the GC process, as the ratio between heap and permspace is crucial here.
And if you play with these variables, always make sure they are actually used. It happens more than easy to put them somewhere (batch file, exlipse.ini) with them having any effect.
Our application has over 15 different top-level mxml files to create individual controls that are used in our pages.
We are using Ant to do our automated builds, and are calling the mxmlc task for each mxml file separately (See question 78230 similar example). Running the compiler separately for each mxml file, however, is already adding up to a considerable amount of time. Our build time is approaching 10 minutes, 5 minutes for compiling our flex apps, and 5 minutes for compiling hundreads of java classes, building jars, installer etc. Each flex compile run is reasonably quick (15-20 seconds), but they add up.
Is there a way to compile all of them with one call to mxmlc?
One way to speed it up a bit is to compile everything but the top-level classes into one big SWC using compc, then compiling the top-level classes and using the SWC as a library. That way classes that are used by more than one application will only be compiled once.
However, a large contributor to the time it takes to compile a Flex application is the JVM startup time, and each compile will start up it's own JVM (plus one for the Ant process). One way to avoid this is to use the Flex Compiler Shell (fcsh) instead of Ant, but that has it's downsides of course. Another way is to try HellFire, which runs the compiler in a separate always-on process, meaning no more waiting for the JVM to start.
Why not use Flex Builder to compile everything automatically?
Are the mxml files components and/or modules? I think that mxmlc compiles them automatically it they're linked to by the main application, but I'm not sure...
I've got a decent computer. ( something with dual-core in the name and a lot of ram ).
Sometime FlexBuilder prompt the "builder project" loading bar only when i open a simple mxml file.
It's look like he does some difficult jobs... i don't ask for anything fancy. I just want the file open, in text mode.
Every time i hit ctrl+s, i fear the "building project who take forever" thing. I've disable the automatic build, but it's not convenient.
Another thing, more understandable. I'v got a Ant task who compile our code with the flexBuilderSdk. It's take forever ( like 2 min for 100 .as file and 20 .mxml file ).
For the two question : Is that normal ? Can i do something ? Because it's killing my productivity ! ( no, seriously ;-) )
Flex compiler performance is known to be pretty slow. They are making an effort to improve compiler performance for Flex 4. See the developer notes here:
http://opensource.adobe.com/wiki/display/flexsdk/Notes+on+Compiler+Performance+Improvements
Compiling a Flex application is a 2-step process. First, the MXML files are compiled into the equivalent ActionScript classes. If you add the "-keep" compiler parameter, you'll be able to see all these files in a folder called "generated." After the AS3 classes are created, then the AS compiler turns these into bytecode in the form of a .SWF file.
If you have a slow hard disk (say a 5400 RPM laptop drive) that will also affect the performance of compilation. I would definitely recommend disabling "Build Automatically" and just press CTRL-B when you want to build. It's not very difficult to do that when you want to build, much better than waiting for a compile every time you change a file.
The above mentioned improvements have also been backported to the Flex 3 SDK by Brian Deitte. You can try this out at his blog. It is way faster.
There are some tweaks you can do with the Flex Builder Configuration
More here:
Link
Use the settings in [How can I reduce Eclipse Ganymede's memory use? and read the article calderas sent.
anirudhsasikumar mark a point : Improvement of the Flex4 SDK have been backported.
http://www.deitte.com/archives/2008/10/a%5Ffaster%5Fflex%5F3.htm
It's a little bit faster, but i encounter some problem with firefox then. ( Dont ask why ! )
The issue : The result SWF work on IE7, but not on Firefox ( unlimited waiting at the loading )
But a real improvement of the building is to use FCSH, to avoid compile the same file two time. It's improve the performance drasticly.
http://wildwinter.blogspot.com/2008/04/fcsh-wrapper-for-ant.html
I run Flex Builder 3 on a mac and as my project grows - the compile time gets longer and longer and longer. I am using some SWC's and there is a fair amount of code but it shouldn't take minutes to build and crash daily should it?
First of all, comments on some of the response:
There is no need to explicitly specify -incremental in Flex Builder because it uses incremental compilation by default.
-keep-generated-actionscript is a performance killer because it instructs the compiler to write out AS3 codes generated for MXML components in the middle of the compilation. File I/O in the middle of a compilation means unnecessary pauses and low CPU utilizations.
-optimize slows down linking because it instructs the linker to produce smaller SWFs. Note that -optimize=true|false doesn't have any effect on building SWCs because SWCs are libraries and have to be unoptimized.
I rarely mess with JVM settings because JVM knows its jobs well and tunes itself quite well at runtime. Most people make matter worse by setting various GC tuning parameters. That said, there are 3 settings most people understand and set correctly for their usage:
-Xmx (max heap size)
-server or -client (HotSpot Server or Client VM)
-XX:+UseSerialGC or -XX:+UseParallelGC (or other non-serial GC)
-server consistently outperforms -client by about 30% when running the Flex compiler.
-XX:+UseParallelGC turns on the parallel garbage collector. ideal for multicore computer and when the computer still has CPU cycles to spare.
You may also want to check out HellFire Compiler Daemon (http://bytecode-workshop.com/). It uses multiple processor cores to compile multiple Flex applications at the same time. You can also run the compiler on a second machine via sockets (assuming that your second machine has faster CPUs and more memory).
In my opinion, use more modules than libraries and use HFCD.
Hope this helps.
-Clement
There's no need to use mxmlc on the command line just to be able to add compiler flags. Right click your project in the Flex Navigator, select Properties and then Flex Compiler in the dialog that appears. There you can add any extra compiler flags.
Not sure that there's very much to do though, more code means more compile time, that's just the way it is. If you're not doing a release build (or whatever it's called in Flex Builder) it's unlikely that your compiler settings include optimize to begin with. Better choices to try would be -incremental (which only recompiles the parts that have changed) and -keep-generated-actionscript (which stops the compiler from deleting the ActionScript files it has generated from your application's MXML files).
I very much prefer using mxmlc on the command line (by way of Ant) compared to Flex Builder. Although I don't think that the latter compiles any slower, it feels more sluggish in every way. Using Ant also makes it possible to do more than just compilation when building, and conditional compilation (only compile a SWF or SWC if the source code has actually changed). Check out a blog post of mine for more info on that.
What you could try is the Flex Compiler Shell, another command line tool that can speed things up. Basically it tries to keep as much as possible in memory between builds, so no need to wait for things like the JVM starting up (the Flex compiler is a Java application). On the other hand this is sort of what Flex Builder does anyway.
In addition to the suggestions already mentioned, close any projects that you have open that you are not using.
Rich click on the Project in the Navigator view and select "Close Unrelated Projects".
Depending on how many projects you have open, this can lead to a significant improvements in compile time, as well as all around performance.
mike chambers
mesh#adobe.com
Slow compile time is most often caused by having large numbers of embedded resources ([Embed] or #Embed).
Option 2 on this article might help you: [http://www.rogue-development.com/blog2/2007/11/slow-flex-builder-compile-and-refresh-solution-modules/]
I created RAM Disk with workspace and it gives up to 10% of better compilation time. Not much, but something.
You want at least 4 gigs on your computer if possible, and make sure to override the default memory settings that eclipse/flexbuilder gives to the application.
If you're not sure how to do this, you can find the flexbuilder app in /Applications, right click and choose "Show Package Contents". Then go into the contents file and edit the eclipse.ini file. Edit that file have memory settings of at least:
-vmargs -Xms768m -Xmx768m -XX:PermSize=128m -XX:MaxPermSize=128m
It's also worthwhile to go into the eclipse/flexbuilder preferences and to check the "Show heap status" box under Windows->Preferences->General (This is in eclipse with the FB plugin, I'm assuming it's also there for standalone FB).
This shows the current memory in the lower right of the window and has a little trash icon so you can force garbage collection.
I'd also suggest turning off automatic building of the project when your files change (you can force a build with cmd-B).
We had a huge project with quite a few modules files and performance in FlexBuilder 3 was decent with these steps.
Go to Project->Properties->Flex Applications. All of the applications listed are compiled each time (even though you have a default set). If you remove everything but the default (don't worry, it won't delete the actual files), it only compiles the default app. This resulted in a significant speed up for me. If you change your default app, it ADDs it to the Flex Applications list - adding to your compile time. You will need to maintain this list to get the quickest compile.
I always disable "automatic compile" for Flex. It compiles too much, takes too long, and so interrupts my work.
If you have many different project files and all of those needs to be recompiled, but you also have other projects open and don't want to close them always you're doing a build, you can also use Eclipse Working Sets.
Unfortunately, the default Flex Navigator does not support working sets. But you can open the Package Explorer with Window / Show View / .... Click on the little white downward arrow to the topright and select Top Level Elements: Working Sets. You can then add Working Sets (aka groups of projects). Each project needs to be in at least one working set ("Other Projects" being the default), but can be in several.
Now with Project / Build Working Set / ... you can instruct Eclipse to build all the projects in this working set, but none of the others. This is especially useful if you suspect your project references to be sometimes broken - otherwise building the 'topmost' project should trigger subsequent builds automatically.
As Clement said, use the HellFire Compiler Daemon. If you have multiple modules and more CPU cores on your machine it can compile them in parallel. Another option is to use IntelliJ (the commercial version) which offers the same feature.
The SDK 4.x.x introduced silly bug (see Adobe bugsystem, issue FB-27440), which causes projects with SVN or CVS meta data compile much slower than with SDK 3.x.x. On how it can be fixed, see here.
You may want to explore the command-line compiler found in the Flex SDK, mxmlc. As I recall, Flex Builder 3 seems to hide all the compiler details, but perhaps there are arguments you can append that will help you speed up the compilation.
For example, you may want to set optimize=false which will skip the step of optimizing the bytecode (perhaps reducing compilation time)? This of course comes at the price of performance and file size of the actual application.
More documentation on mxmlc can be found at: http://livedocs.adobe.com/flex/3/html/compilers_13.html.
Good luck!
I don't use Flex Builder, but I use the Flex SDK compiler everyday and I was wasting tons of time waiting for the MXMLC compiler to do its job until I found Flex Compiler SHell:
http://blog.zarate.tv/2008/12/07/theres-something-called-flex-compiler-shell/
Although in theory Flex Builder already uses this optimizations, might be worth checking.
You can use WORKING SETS to compile just a set of your components that are part of the application that you are changing and not the whole project
http://livedocs.adobe.com/flex/3/html/help.html?content=build_6.html
Usually the first build takes the longest, and then it's pretty quick after that. That's using Vista x64 w/ core 2 duo.
Otherwise, I am nearly certain a Intel Core i7 Extreme Edition 965 3.2GHz upgrade processor would speed your Flex building up nicely .. :) :) :)