LLR multi-thread observation

[mackerel]

Over on PrimeGrid there is an upcoming challenge running PPS tasks, which are currently 192k FFT size. After another post, I decided to look at scaling. What I found interesting was that on very different CPUs, when running one task on 4 threads, the run times were very close.

i7-6700k, 4.0 GHz all core clock, 695s
i5-6600k, 3.6 GHz all core clock, 695s
i5-4570S, 3.2 GHz all core clock, 708s

I assume the thread work is done in gwnum, not by LLR, so I was wondering if there is something that might explain this observation? It if was doing the same thing as fast as it can, I would have expected some clock scaling (even ignoring architecture). That it doesn't seem to be clock scaling, is there some other mechanism for dividing the work that is a limiting factor?

BTW the throughput of running such a small task with so many threads wasn't great, but it was still interesting as it made the slowest CPU above look like it was scaling better (or least worse) with more threads than the faster ones.

[ATH]

George said a few times that the benefit of multithreading is very low at very low FFT sizes:

http://www.mersenneforum.org/showpos...4&postcount=35

http://www.mersenneforum.org/showpos...0&postcount=37

http://www.mersenneforum.org/showpos...50&postcount=6


Try running 1 instance for each core?

[mackerel]

1 per core was highest throughput. I know the performance sucks with one task on all threads, but the interesting point was that they were about the same on different hardware, and was looking to understand that. Intuitively, you'd still expect higher clocks to run faster at a similar level of inefficiency. If it isn't limited by CPU clock, what is it being limited by?

[pepi37]

Originally Posted by mackerel

1 per core was highest throughput. I know the performance sucks with one task on all threads, but the interesting point was that they were about the same on different hardware, and was looking to understand that. Intuitively, you'd still expect higher clocks to run faster at a similar level of inefficiency. If it isn't limited by CPU clock, what is it being limited by?

1 per core was highest throughput.
It is true up to some degree. After that point performance going down