coggins@coggins.cs.unc.edu (Dr. James Coggins) (11/01/88)
Managing C++ Libraries: Using +e0 and +e1 Greg Bollella and James Coggins Computer Science UNC-Chapel Hill Libraries are essential productivity aids that multiply the advantages of object-oriented design by making possible the reuse of separately compiled code. When we began using AT&T cfront 1.2.1 with a large research library, we found that the library generated a huge .a file (about 2MB for 10K lines of code) and most programs linked with the library yielded unacceptably large executable (a.out) files. Another library for similar purposes but written in C produces executable files of 150K or less. The exorbitant size of the C++ executables made the language unacceptable for routine use. The cfront release notes describe the operation of a new compiler option, +e. Basically, +e controls whether virtual function tables are created separately for each .c file or shared among all of the .c files. Unfortunately, the release notes do not describe how to use it effectively. This option is crucial for library developers and users since it produces massive reduction in the size of executable files, and as side benefits it yields significant decreases in the time required for library creation and for linking. We have heard that the AT&T cfront Version 2 is rather smarter about such allocations and that +e will have a much smaller effect when using the new translator. We reproduce below the description of the +e option from the C++ Translator Release 1.2 Addendum to the Release Notes. What is lacking in them is the simple description of how to use +e for managing C++ libraries. The critical insight is as follows: -------------------------------------------------------------- ! Compile all of the routines in your library with +e0, and ! ! compile programs using the library with +e1. ! !------------------------------------------------------------! On Dr. Coggins' COOL library of about 60 classes supporting computer graphics and image pattern recognition, the use of +e caused the .a file to decrease from about 2MB to about 200KB - an order of magnitude reduction! Programs linked with the library decreased in some cases from 1.5MB to 500K or less, with an average of 30% reduction even for simple programs using only a few primitive classes. Significant reductions have been observed in the time required to create the library from .o files, to execute ranlib(1) on the library, and to link programs using the library. The use of the +e option transformed COOL from an interesting curiosity to a usable tool. The following description of the operation of the +e option is reproduced from an Addendum to the Release Notes of AT&T cfront 1.2. >>>>BEGIN QUOTE>>>>>>>>>>>>>>> CC +e Option There is a new compiler option, +e. It works as follows: 1. CC +e1 causes virtual tables to be external and defined, that is, initialized. 2. CC +e0 causes virtual tables to be external but only declared, that is, unitialized. 3. CC causes virtual tables to be local to a file (static) and defined. For example, given a header file, SUPER.h, with the class definition class SUPER { public: virtual size(); virtual is_equal(); virtual grow(); }; each separately compiled executable component with a #include of SUPER.h will normally generate a static virtual jump table. Using +e allows you to optimize a program by ensuring that only one virtual table is generated per class. This can save 25 percent of object files size, a.out size, link time, and (in the case of cross-compilation) download time. For example, suppose our executable is composed of t0.c, t1.c, t2.c and t3.c, each containing a #include of SUPER.h. The target portion of out makefile would look as follows: foo: $(OBJECTS) $(CC) -o foo $(CCFLAGS) $(OBJECTS) t0.o: SUPER.h $(CC) $(CCFLAGS) -c t0.c t1.o: SUPER.h $(CC) $(CCFLAGS) -c t1.c t2.o: SUPER.h $(CC) $(CCFLAGS) -c t2.c t3.o: SUPER.h $(CC) $(CCFLAGS) -c t3.c To generate only one instance of the SUPER class virtual table, the makefile would be changed as follows: foo: $(OBJECTS) $(CC) -o foo $(CCFLAGS) $(OBJECTS) t0.o: SUPER.h $(CC) $(CCFLAGS) -c +e1 t0.c t1.o: SUPER.h $(CC) $(CCFLAGS) -c +e0 t1.c t2.o: SUPER.h $(CC) $(CCFLAGS) -c +e0 t2.c t3.o: SUPER.h $(CC) $(CCFLAGS) -c +e0 t3.c The +e1 option in the t0.o file suppresses the static scope specifier in the generated t0.o object. The +e0 option in the other targets suppresses the generation of the SUPER class virtual tables. >>>>>>>> END OF QUOTE >>>>>>>>>>>>>>