Databases
StackOverflow2013
Postsdbo
PO
 

Note that there are some explanatory texts on larger screens.

plurals
  1. PO
    primarykey
    data
    text
    <p>I think you're seeing the difference, but it's just the function call overhead. Branch misprediction, memory access and the trig functions are the same in both cases. Compared to those, it's just not that big a deal, though the function pointer case was definitely a bit quicker when I tried it.</p> <p>If this is representative of your larger program, this is a good demonstration that this type of microoptimization is sometimes just a drop in the ocean, and at worst futile. But leaving that aside, for a clearer test, the functions should perform some simpler operation, that is different for each function:</p> <pre><code>void function_not( double *d ) { *d = 1.0; } void function_and( double *d ) { *d = 2.0; } </code></pre> <p>And so on, and similarly for the virtual functions.</p> <p>(Each function should do something different, so that they don't get elided and all end up with the same address; that would make the branch prediction work unrealistically well.)</p> <p>With these changes, the results are a bit different. Best of 4 runs in each case. (Not very scientific, but the numbers are broadly similar for larger numbers of runs.) All timings are in cycles, running on my laptop. Code was compiled with VC++ (only changed the timing) but gcc implements virtual function calls in the same way so the relative timings should be broadly similar even with different OS/x86 CPU/compiler.</p> <p>Function pointers: 2,052,770</p> <p>Virtuals: 3,598,039</p> <p>That difference seems a bit excessive! Sure enough, the two bits of code aren't quite the same in terms of their memory access behaviour. The second one should have a table of 4 A *s, used to fill in base, rather than new'ing up a new one for each entry. Both examples will then have similar behaviour (1 cache miss/N entries) when fetching the pointer to jump through. For example:</p> <pre><code>A *tbl[4] = { new A1, new A2, new A3, new A4 }; for ( long int i = 0; i &lt; 100000; ++i ) { array[i] = ( double )( rand() / 1000 ); base[i] = tbl[ rand() % 4 ]; } </code></pre> <p>With this in place, still using the simplified functions:</p> <p>Virtuals (as suggested here): 2,487,699</p> <p>So there's 20%, best case. Close enough?</p> <p>So perhaps your colleague was right to at least consider this, but I suspect that in any realistic program the call overhead won't be enough of a bottleneck to be worth jumping through hoops over. </p>
    singulars
    1. This table or related slice is empty.
    1. POWhere is the virtual function call overhead?
      singulars
      1. PTQuestion
    1. PTAnswer
    1. This table or related slice is empty.
    1. This table or related slice is empty.
    plurals
    1. This table or related slice is empty.
    1. This table or related slice is empty.
    1. POWhere is the virtual function call overhead?
      singulars
      1. PTQuestion
    1. This table or related slice is empty.
    1. VO
      singulars
      1. PO
      1. This table or related slice is empty.
      1. VTAcceptedByOriginator
    2. VO
      singulars
      1. PO
      1. This table or related slice is empty.
      1. VTUpMod
    3. VO
      singulars
      1. PO
      1. This table or related slice is empty.
      1. VTUpMod
    1. COWhile most is clear, I still fail to see any branches in the benchmarked section of the code for both variants. Is it the trigonometrical functions? And I didn't know anything about the differences between allocating A's this or that way, will have to look into that. There are have two more variants, one with a switch inside the measured code and one with member function pointers. The last one is the fastest, though I'll have to check with simplified functions. As far as 20% go, that's exactly what the article said, can't find it though, that was a PDF somewhere on the internet.
      singulars
      1. PO
      1. USiksemyonov
    2. COThe branch here is the place where the target function is called - "index_array[i]( &array[i] );", "base[i]->calculate( &array[i] );". On modern x86 CPUs these benefit from prediction (albeit of a slightly different kind) just like conditional branches. Sorry if my terminology was a bit confusing.
      singulars
      1. PO
      1. This table or related slice is empty.
    3. COAlso the speed difference between the two ways of allocating A is down to the data cache. See http://www.agner.org/optimize/, "Optimizing C++" pdf, there's a section about it in there.
      singulars
      1. PO
      1. This table or related slice is empty.
 

Querying!

 
Guidance
A row detail

Detail views are divided into sections. All the information in the data section comes from columns in the selected row. The other sections display data from other, related rows.

Related data can be related in a to-one or a to-many fashion. Captions of data related in a to-many fashion link to a list view showing a filtered view of the table.

Try moving around until you find a non-empty to-many entry and click on the label to get to one. You can move back to the root by clicking on the database name in the header.

SQuiL has stopped working due to an internal error.

If you are curious you may find further information in the browser console, which is accessible through the devtools (F12).

Reload