Writing a very heavy operation in c++ for testing

Question

This may be the opposite of most questions, but for testing purposes I want to create a predicate that uses some very slow operations that do not create data races. I need to test a parallel implementation compared to a sequential implementation and would like to do so without creating massively sized vectors. I currently use this predicate:

[](std::size_t& v){
    v = 42; //some random number...
}

but in order to see any real results my vectors need to be massive in terms of size, I would rather have a smaller size and greater predicate execution time... what sort of lamba function should I write that is very time consuming so I can test my implementations?

Something like an infinite loop should increase the execution time. — Mysticial, Jun 09 '14 at 19:18
@Mysticial I'm not looking for *infinite* execution time here, I'd like to see the results this century — Syntactic Fructose, Jun 09 '14 at 19:19
Loops are most often optimized out, so that probably won't help, unless you write some data in your vector. — Alexis Wilke, Jun 09 '14 at 19:19
@Mysticial an infinite loop will most likely increase the execution time, for sure +1 for the laugh. — 101010, Jun 09 '14 at 19:21
@AlexisWilke Once trick that I sometimes use is to write a loop that conditionally prints something at the end. Except that you make it so that the condition is never satisfied. The compiler won't know that so it's forced to keep the print in there along with the entire loop. — Mysticial, Jun 09 '14 at 19:22
What about a simple class that acts like a Vector and whose indexes are the results of something like a Fibonacci sequence. You could start the sequence at say 30 (so i = 0 is 30, i = 1 is 31, etc.). This will give you the illusion of lots of data and take time to compute. You can change out the computation based on the amount of time needed. — Sean Perry, Jun 09 '14 at 19:22
Possibly related: http://stackoverflow.com/questions/10767131/expecting-googlemock-calls-from-another-thread/10783201#10783201 — πάντα ῥεῖ, Jun 09 '14 at 19:22
As mentioned a `sleep()` along with my wait action proposed above, should do the job. — πάντα ῥεῖ, Jun 09 '14 at 19:26

score 0 · Answer 1 · answered Jun 09 '14 at 22:35

Just an idea, force a number of repeated read-modify-writes:

std::size_t volatile& vv = v;
vv = 0;
for (int i = 0; i != 100; ++i) { vv +=1; }

Since the compiler may not optimize this, it will involve quite a few real reads of v. That said, you'll probably still hit cache.

If that's to be avoided too, you need std::atomic_store

Writing a very heavy operation in c++ for testing

1 Answers1