As mentioned before, since the Compiler module operates on a file-based granularity level, it is possible that the density of functions per source file could have an effect on the performance of the continuous compiler. To test this, we generated two programs which are similar in most characteristics but differ in the number of functions defined in each source file.
Table 6.20: User File Parameters of the Many-Functions-per-File
Program
Table 6.20 and Table 6.21 list the parameters that were used to generate the ``many-per-file'' program.
Most of the parameters are the same as those used in the ``equal'' program in Section 6.6. However, the parameters to pay attention to here are the number of source files, the number of functions per file, and the number of lines per file.
Table 6.21: Library File Parameters of the Many-Functions-per-File
Program
Table 6.22: User File Parameters of the One-Function-per-File
Program
The ``many-per-file'' program has 20 user source files with an average of 20 functions per file, for a total of around 400 functions. To duplicate this number of functions in the ``one-per-file'' program, we used 400 source files with one function per file. Table 6.22 lists the parameters for the user files in the ``one-per-file'' program. The parameters for the library files are exactly the same as those used by the ``many-per-file'' program.
The other parameter that differs between the ``many-per-file'' and ``one-per-file'' programs is the number of lines per file. This value has to be adjusted to keep the number of lines per function approximately equal for both programs. The ``many-per-file'' program has an average of 20 functions per source file with an average of 500 lines per file. This gives a value of 25 lines per function (on average). To duplicate this, the number of lines per file for the ``one-per-file'' program was modified to have an average of 25.
Table 6.23 summarizes the performance of the continuous compilation system on the ``many-per-file'' and ``one-per-file'' programs.
Table 6.23: Variation of Functions per Source File
When we compare the performance of replace-at-call and replace-preemptive, we again see little difference. Once again, as described in Section 6.6, this is most likely an artifact of the way ProGenitor generates the programs. The more interesting comparison is between the performance of the ``many-per-file'' and ``one-per-file'' programs themselves. As expected, the ``one-per-file'' program does perform better than the ``many-per-file'' program. When using the longest-overall compilation strategy, the speedup is greater than 20%.