hyperthreading

I'm trying to determine the independent CPU's (specified with affinity ID's) for building ATLAS on a linux machine with 4 Intel CPU's with hyperthreading (ubuntu 12.04). The reason I'm doing this is that the ATLAS manual says to use only the physical cores on machines with hyper threading, on how to achieve this it says: "...you can tell ATLAS to use only the real cores if you learn a little about your machine. Unfortunately, ATLAS cannot presently autodetect these features, but if you experiment you can discover which affinity IDs are the separate cores,..." Further on a hint is given on how

I have written a project, which uses some basic functions in openssl such as RAND_bytes and des_ecb_encrypt . My computer has i7-2600(4 cores and 8 logic CPU). When I run my project with 4 threads, it will costs 10 seconds. When I run it with 8 threads, it also costs 10 seconds. What I mean is that hyper-threading doesn't give me any performance improvement. In Linux, the experiment result is same. I found here tells me that hyper-threading doesn't give me some improvement in some situations. Also, I found here give me some intuitive results. However, I have tried to write some simple tests

Is there some sample code that exemplifies Intel's Hyperthreading performance? Is it at all accessible from user space, or does that CPU do all the work transparently for the programmer? This is for C, Linux. Hyperthreading performance depends on many factors and is difficult to estimate. Just to shortly explain Hyperthreading: Each core has more then one register set, but no additional execution units The hyperthreads are scheduled more or less evenly So you only really get additional performance out of hyperthreads if the two threads running on the same core use different execution units and

I'm only asking this to try to understand what I've spent 24 hours trying to fix. My system: Ubuntu 12.04.2, Matlab R2011a, both of them 64-bit, Intel Xeon processor based on Nehalem. The problem is simply, Matlab allows OpenMP based programs to utilize all CPU cores with hyper-threading enabled but does not allow the same for TBB. When running TBB, I can launch only 4 threads, even when I change the maxNumCompThreads to 8. While with OpenMP I can use all the threads I want. Without Hyper-threading, both TBB and OpenMP utilize all 4 cores of course. I understand Hyper-threading and that its

I have a multithreaded program running on a quad-core Intel i7. When I execute Runtime.getRuntime.availableProcessors() , I get 8, and I know that hyperthreading is available on this CPU. However, when I create threads, my CPU levels are at 100% (i.e. non-zero) for 4 threads, meaning that 4 threads are unused. Is there any way to enable hyperthreading in Java? Hyperthreading is enabled by the fact that all modern JVMs use native threads, thus this is a OS/CPU config setting. However Hyperthreading does not give you extra cores, it permits fine grained timeshare of the four cpus that you have.

In Is OpenMP (parallel for) in g++ 4.7 not very efficient? 2.5x at 5x CPU , I determined that the performance of my programme varies between 11s and 13s (mostly always above 12s, and sometimes as slow as 13.4s) at around 500% CPU when using the default #pragma omp parallel for , and the OpenMP speed up is only 2.5x at 5x CPU w/ g++-4.7 -O3 -fopenmp , on a 4-core 8-thread Xeon. I tried using schedule(static) num_threads(4) , and noticed that my programme always completes in 11.5s to 11.7s (always below 12s) at about 320% CPU, e.g., runs more consistently, and uses less resources (even if the

The primary idea behind HT/SMT was that when one thread stalls, another thread on the same core can co-opt the rest of that core's idle time and run with it, transparently. In 2013 Intel dropped SMT in favor of out-of-order execution for its Silvermont processor cores, as they found this gave better performance. ARM no longer support SMT (for energy reasons). AMD never supported it. In the wild, we still have various processors that support it. From my perspective, if data and algorithms are built to avoid cache misses and subsequent processing stalls at all costs, surely HT is a redundant

I ran an OpenMP program to perform the Jacobi method, and it was working very well, 2 threads performed slightly over 2x 1 thread, and 4 threads 2x faster than 1 thread. I felt everything was working perfectly... until I reached exactly 20, 22, and 24 threads. I kept breaking it down until I had this simple program #include <stdio.h> #include <omp.h> int main(int argc, char *argv[]) { int i, n, maxiter, threads, nsquared, execs = 0; double begin, end; if (argc != 4) { printf("4 args\n"); return 1; } n = atoi(argv[1]); threads = atoi(argv[2]); maxiter = atoi(argv[3]); omp_set_num_threads