Hudson 3.1 has some performance optimizations that greatly reduces its memory footprint. Prior
to this Hudson used
to always hold the entire data model (all jobs and all builds) in memory which affected scalability. Some installations configured heap sizes in excess of 1GB
to counteract this. Hudson 3.1.x maintains an MRU cache and only loads jobs and builds as they are required. Because of the inability
to change existing APIs and be backward compatible with plugins, there were limits
to how far we could go with this approach.
Memory optimizations almost always come with a related cost, in this case its additional I/O that has
to be performed
to load data on request. On a small site that has frequent traffic, this is usually not noticeable since the MRU cache will usually hold on
to all the data. A large site with infrequent traffic might experience some delays when the first request hits the server after a long gap. If you have a large heap and are able
to allocate more memory, the cache settings can be adjusted
to take advantage of this and even go back
to pre-3.1 behavior.
All the cache settings can be passed as options
to the JVM container (Tomcat or the default Jetty container) using the -D option. There are two caches, independant of each other, one for Jobs and the other for Builds.
For the jobs cache:
hudson.jobs.cache.evict_in_seconds ( default=60 )
Seconds from last access (could be because of a servlet request or a background cron thread) a job should be purged from the cache.
Set this
to 0
to never purge based on time.
hudson.jobs.cache.initial_capacity ( default=1024 )
Initial number of jobs the cache can accomodate. Setting this
to the number of jobs you typically display on your Hudson landing page or home page will speed up consecutive access
to that page. If the default is too large you may consider downsizing and using that memory for the Builds cache instead.
hudson.jobs.cache.max_entries ( default=1024)
Maximum number of jobs in the cache. The default is large enough for most installations, but if you find I/O activity when always accessing the hudson home page you might consider increasing this, but first verify if the I/O is caused by frequent eviction (see above), rather than by the cache not being large enough.
For the builds cache:
The builds cache is used
to store Build objects as they are read from storage. Typically this happens when a user drills down into the details of a particular Job from the hudson hom epage. The cache is shared among builds for different jobs since in most installations all jobs are not accessed with the same frequency, so a per-job builds cache would be a waste of memory.
hudson.job.builds.cache.evict_in_seconds ( default=60 )
Same as the equivalent Job cache, applied
to Build.
hudson.job.builds.cache.initial_capacity" ( default=512 )
Same as equivalent Job cache setting. Note the smaller initial size. If your site stores a large number of builds and has frequent access
to more builds you might consider bumping this up.
hudson.job.builds.cache.max_entries ( default=10240 )
The default max is large enough for most installations, the builds cache has bigger sized objects, so be careful about increasing the upper limit on this. See section on monitoring below.
Sample usage:
java -jar hudson-war-3.1.2-SNAPSHOT.war -Dhudson.jobs.cache.evict_in_seconds=300 \
-Dhudson.job.builds.cache.evict_in_seconds=300
Monitoring cache usage
The 'jmap' tool that comes with the JDK can be used
to monitor cache performance in an indirect way by looking at the number of Job and Build objects in each cache.
Find the PID of the hudson instance and run
$ jmap -histo:live <pid | grep 'hudson.model.*Lazy.*Key$'
Here's a sample output:
num #instances #bytes class name
523: 28 896 hudson.model.RunMap$LazyRunValue$Key
1200: 3 96 hudson.model.LazyTopLevelItem$Key
These are the keys
to the Jobs (LazyTopLevelItem$Key) and Builds (RunMap$LazyRunValue$Key) in the caches, so counting the number of keys is a good indicator of the number of items in the cache at any given moment. The size in bytes can be ignored, they are just the size of the keys, not the actual sizes of the objects they hold. Those sizes can only be obtained with a profiler. With the output above we can conclude that there are 3 jobs and 28 builds in memory. The 28 builds can all be from 1 job or all 3 jobs. Over time on an idle system, these should get evicted and memory cache should be empty. In practice, because of background cron threads and triggers, jobs rarely fall down
to zero. Access of a job or a build by a cron thread resets the eviction timer.
