Per-class memory and performance overhead?

[kjkrum]

I read this book a long time ago, and it's stuck with me that there's significant overhead for each class that's loaded. But I know that many of the recommendations in that book are now obsolete, and what was significant then may not be significant now.

I'm using Sun's CodeModel API to generate a client-server message library for a game. It would be easy to generate a subclass for each message type, making the library more type-safe and allowing method overloading. But what kind of impact would dozens (possibly hundreds) of small classes have on memory use and startup time?

If nobody knows, I might just have to run some experiments...

[kjkrum]

Did someone delete a comment?

To answer your question... yes, there is a is-a relationship.

If my generic Message class were an interface, it would look like this:

public interface Message {
     public long getTimestamp();
     public MessageType getType(); // MessageType is an enum
     void setParam(String key, int value);
     public int getInt(String key);
     // a bunch more package-private setters and public getters
}

If I extended it for every message type, I could do away with those public getters (and the fragility of needing to pass the right key for every value) and replace them with meaningful names, e.g., Message.getIntArray("warps") becomes SectorData.getWarps().

Edit: I've been thinking in terms of the representation of a Message. In that sense, a SectorData definitely is-a Message; it ought to be able to represent itself in forms suitable for logging, sending to a client, etc., just like a generic Message. But if I were to start extending Message, I could build more meaningful is-a relationships, like LocalSectorData is-a SectorData.

There are so many advantages to extending my generic Message, I'm thinking I should probably just do it. Performance might be an issue, but I'll never know unless I try it.

[kjkrum]

Okay, so I ran some tests. Perhaps someone can comment on the validity of this experiment.

I scripted the creation of 1000 empty classes (Class0 ... Class999). Then I scripted the creation of three test programs that reference 10, 100, or 1000 of those classes. Here's the 10 version:

package krum.manyclasses;


public class Load10 {


    public static void main(String[] args) {
        long started = System.currentTimeMillis();
        Class clazz = null;
        clazz = Class0.class;
        clazz = Class1.class;
        clazz = Class2.class;
        clazz = Class3.class;
        clazz = Class4.class;
        clazz = Class5.class;
        clazz = Class6.class;
        clazz = Class7.class;
        clazz = Class8.class;
        clazz = Class9.class;
        System.out.println("Loaded 10 classes in " + (System.currentTimeMillis() - started) + "ms");
        System.out.println("Pausing for dramatic effect.");
        while(true) { }
    }

}

The time to load the classes was pretty consistent between several runs. I inspected the JVM's memory usage in top while each program was "paused" (chewing on my CPU.) Here are the results:

10 classes: ~7ms, 1.7% of ~768mb
100 classes: ~122ms, 2.2%
1000 classes: ~660ms, 2.8%

This on a netbook with an AMD V105 CPU and a 5400 RPM platter drive. It appears my concerns were unfounded.

Edit: Would the class definitions be getting GCed? I don't think so... but even if they are, I'm reassured about potential performance issues.

[kjkrum]

I changed the test programs to use Class.forName(), and got almost identical results.

package krum.manyclasses;


public class Load10 {


    public static void main(String[] args) {
        long started = System.currentTimeMillis();
        try {
        Class class0 = Class.forName("krum.manyclasses.Class0");
        Class class1 = Class.forName("krum.manyclasses.Class1");
        Class class2 = Class.forName("krum.manyclasses.Class2");
        Class class3 = Class.forName("krum.manyclasses.Class3");
        Class class4 = Class.forName("krum.manyclasses.Class4");
        Class class5 = Class.forName("krum.manyclasses.Class5");
        Class class6 = Class.forName("krum.manyclasses.Class6");
        Class class7 = Class.forName("krum.manyclasses.Class7");
        Class class8 = Class.forName("krum.manyclasses.Class8");
        Class class9 = Class.forName("krum.manyclasses.Class9");
        System.out.println("Loaded 10 classes in " + (System.currentTimeMillis() - started) + "ms");
        System.out.println("Pausing for dramatic effect.");
        while(true) { Thread.sleep(100); }
        } catch(Exception e) { e.printStackTrace(); }
    }

}

I'll stop talking to myself now.

[Tolls]

It's a sign of madness, dontcha know...:)

Compared to the actual objects, classes are a small part of the footprint of your app.
However, do remember to ensure you have enough PermGen space, which will require some perfromance testing when you've finally built the thing.