LabVIEW
Intel i7 processor with hyper-threading (only every second core is used)
Solved!
@ghighuphu wrote:
I expect that all the eight logical processors (= threads) will be engaged, when the algorithm allows for it.
Hi,
I guess your algorithm is not utlize all eight cores. You should adapt is to multicore PC.
Do pretty simple test - put 8 while loops without any delays and see how many cores will be utlized. Then you should see something like that (in my case I have 2 CPUs each with 6 cores and hyperthreading is enabled - therefore 24 while-loops):
As you can see - overall 100% cpu load.
Andrey.
@ghighuphu wrote:
Next I've ran the "4 Calculate N Digits of Pi.vi" with N set to 10000 (ten thousand). The result was, that only four cores out of eight were engaged. Do you get similar or different results please? KR, M
OK, I had a glance at the code and it is NOT optimized for multiple processors at all. What makes you think it is???
There is a place where 4 reentrant "series" subVIs are called in parallel, so there will be some mild parallelization with an upper limit of 4x.
Some simple profiling shows that significant effort is spent in the "powers of two" subVI. Once you disable debugging and inline it, this code will be folded and will take 0 time, overall speeding the calculations dramatically. There are quite a few other places where significant optimization is possible. Please try. I have not.
OK, I did a benchmark on my old non-hyperthreaded 4 core machine (Intel Q9300) before and after my 2 minute modifications mentioned above and here are the results for 10000 digits:
stock: 304 seconds, ~75% CPU utilization
my modification: 43 seconds, ~88% CPU utilization
As you can see, a few trivial changes can speed up things by more than a factor of 7 and this is only the tip of the iceberg salad! We can tell that in the stock implementation, a huge percentage of the CPU is just pumping hot air (thread swapping, other overhead, etc.) instead of doing real work. There is no telling what's possible if the entire thing is rearchitected from scratch to optimize for multiprocessor use. There is no upper limit, because the problem can be split into an infinite number of seperate calcaluations. Try it!
@Andrey_Dmitriev wrote:
Do pretty simple test - put 8 while loops without any delays and see how many cores will be utlized. Then you should see something like that (in my case I have 2 CPUs each with 6 cores and hyperthreading is enabled - therefore 24 while-loops):
... and don't forget to keep the fire extinguisher nearby. 😄
altenbach wrote:stock: 304 seconds, ~75% CPU utilization
my modification: 43 seconds, ~88% CPU utilization
This also tells you that core utilization is NOT a useful tool to assess the quality of the code. The goal should be to do it quickest with the least CPU effort. The only measure that counts is the elapsed time to achieve the task. If you have inefficient parallel code that burns 100% of all CPUs, and a better serial algorithm that can get the same result in 10% of the time using a single core, you should go with the latter.
Maxing out all cores at 100% is never the primary goal. It also has disadvantages, such as placing high demands on the thermal management of the computer as well as impacting everything else you are trying to do on the computer at the same time. For a quick test, run Andrey's code above, then try to browse the web or watch a youtube clip. 😮
