Inheritance vs code generation for better performance?

I'm trying to get max performance from a piece of code that looks somewhat like this

interface DbStream {
    void writeInt(int x);
    void writeString(String s);
    // etc, somewhere around 20 different types
}

interface Writer {
    void write(DbStream stream, Object value);
}

Writer[] writers = new Writer[NUM_COLS];
DbStream stream;
Object[][] src = new Object[NUM_ROWS][NUM_COLS];

for (int row = 0; row < NUM_ROWS; row++) {
    for(int col = 0; col < NUM_COLS; col++) {
        writers[col].write(stream, src[row][col]);
    }
}

Each implementation of Writer interface does necessary conversions and calls proper method of DbStream. The code uses inheritance, so these calls aren't inlined. Will there be a performance improvement if the inner loop is manually unrolled to contain 200-300 calls to static methods? The program will use JDK 13, if it makes any difference.

> I'm trying to get max performance from a piece of code ...

That is typically the wrong approach. A better approach is to optimize the code that is demonstrably the performance bottleneck for your application. Also, "maximum" is not a good goal. A better goal is "good enough". (Up to a point, software developer time is more expensive than CPU time. And it is certainly a more scarce commodity!)

Here's what I recommend that you do.

1. Get your application feature complete and working.

2. Create a realistic benchmark that exercises this code using real data.

3. Profile the application running the benchmark to measure what percentage of time your application spends in this part of the code.

4. Estimate the potential performance you could get by optimizing. For example, if inlining these calls improves this code by 10%, and this code represents 5% of the total application CPU time, then you would get an overall CPU performance increase of 0.5% from this optimization.

5. Now decide:

   • Is the possible / likely performance increase worth the development effort?
   • Is it worth the (hypothetical) hit on system maintainability?

6. If yes: do the optimization and measure it.

   • Did you actually achieve the performance you expected?
   • Was the "damage" to maintainability worth it?

(If minimizing CPU time is not your goal, adjust the methodology accordingly. For example, if you want to minimize request times, then you also need to take account of the time taken by the backend database, etcetera.)

In this case, my gut feeling is that your proposed optimization would probably make a small performance difference. Manually inlining the calls could shave off a few (say 3 or 4) machine instructions per call. However, I doubt that it would be significant to the overall application performance.

The JDK specs make no particular promise about performance, nor do they proscribe a way in which these two concepts must function which is an obvious performance hole.

In other words: Depends on JDK version, edition, architecture, OS, and the phase of the moon.

Use something like JMH to get an actual result, run it as close to the actual 'real life' circumstances as you can manage (run it on the same hardware under a similar load and make sure the code you test is as similar as you can make it).

Given that this code seems to 'write to a DB', I bet none of it will matter, as the DB, or, alternatively the infrastructure around it (such as making TCP packets to send them to the DB, even if it is running locally and is an in-memory implementation), will be multiple orders of magnitude slower than any of this. I predict your JMH result will be very close (close enough that whatever difference you observe is statistical noise).