Optimising GNOME

Following a suggestion on ddl I have created an optimization subsection on developer.gnome.org. Contributions and criticism are more than welcome.

Currently the content consists of a single article by myself on using Massif. There is also a brief, and to-the-point, piece from Rob Love on disk seeks that I will upload this evening. In the meantime you can read it right here because it is short, and you should read it:



                         Disk Seeks Considered Harmful

                                  Robert Love
                                
                                  26 Sept 2004


Dear GNOME Hackers,

Disk seeks are one of the most expensive operations you can possibly perform.
You might not know this from looking at how many of them we perform, but trust
me, they are.  They suck.  Consequently, please refrain from the following
suboptimal behavior:

        (a) Placing lots of small files all over the disk.
        (b) Opening, stating, and reading lots of files all over the disk
        (c) Doing the above on files that are laid out at different times,
            so as to ensure that they are fragmented and cause even more
            seeking.
        (d) Doing the above on files that are in different directories,
            so as to ensure that they are in different cylinder groups and
            and cause even more seeking.
        (e) Repeatedly doing the above when it only needs to be done once.

Ways in which you can optimize your code to be seek-friendly:

        (a) Consolidate data into a single file.
        (b) Keep data together in the same directory.
        (c) Cache data so as to not need to reread constantly.
        (d) Share data so as not to have to reread it from disk when each
            application loads.
        (d) Consider caching all of the data in a single binary file that
            is properly aligned and can be mmaped.

The trouble with disk seeks are compounded for reads, which is unfortunately
what we are doing.  Remember, reads are generally synchronous while writes
are asynchronous.  This only compounds the problem, serializing each read, and
contributing to program latency.

Thanks!


Posted

in

by

Tags: