&lt;!-- language-all: python --&gt;

I have recently installed tensorflow (Windows CPU version) and received the following message:

&gt; Successfully installed tensorflow-1.4.0 tensorflow-tensorboard-0.4.0rc2

Then when I tried to run

    import tensorflow as tf
    hello = tf.constant(&#39;Hello, TensorFlow!&#39;)
    sess = tf.Session()
    sess.run(hello)
    &#39;Hello, TensorFlow!&#39;
    a = tf.constant(10)
    b = tf.constant(32)
    sess.run(a + b)
    42
    sess.close()

(which I found through https://github.com/tensorflow/tensorflow)

I received the following message:

&gt; 2017-11-02 01:56:21.698935: I C:\tf_jenkins\home\workspace\rel-win\M\windows\PY\36\tensorflow\core\platform\cpu_feature_guard.cc:137] Your CPU supports instructions that this TensorFlow binary was not compiled to use: AVX AVX2

But when I ran 

    import tensorflow as tf
    hello = tf.constant(&#39;Hello, TensorFlow!&#39;)
    sess = tf.Session()
    print(sess.run(hello))

it ran as it should and output `Hello, TensorFlow!`, which indicates that the installation was successful indeed but there is something else that is wrong.

Do you know what the problem is and how to fix it?

Your CPU supports instructions that this TensorFlow binary was not compiled to use: AVX AVX2

I once had the task of determining the following performance parameters from inside a running application:

  - Total virtual memory available
  - Virtual memory currently used
  - Virtual memory currently used by my process&lt;hr&gt;
  - Total RAM available
  - RAM currently used
  - RAM currently used by my process&lt;hr&gt;
  - % CPU currently used
  - % CPU currently used by my process

The code had to run on Windows and Linux. Even though this seems to be a standard task, finding the necessary information in the manuals (WIN32 API, GNU docs) as well as on the Internet took me several days, because there&#39;s so much incomplete/incorrect/outdated information on this topic to be found out there.

In order to save others from going through the same trouble, I thought it would be a good idea to collect all the scattered information plus what I found by trial and error here in one place.




How to determine CPU and memory consumption from inside a process

I have this script, but I do not know how to get the last element in the printout:

    cat /proc/cpuinfo | awk &#39;/^processor/{print $3}&#39;

The last element should be the number of CPUs, minus 1.

How to obtain the number of CPUs/cores in Linux from the command line?

How can I get the current system status (current CPU, RAM, free disk space, etc.) in Python? Ideally, it would work for both Unix and Windows platforms.

There seems to be a few possible ways of extracting that from my search:

1. Using a library such as [PSI](http://www.psychofx.com/psi/trac/wiki/) (that currently seems not actively developed and not supported on multiple platforms) or something like [pystatgrab](http://www.i-scream.org/pystatgrab/) (again no activity since 2007 it seems and no support for Windows).

2. Using platform specific code such as using a `os.popen(&quot;ps&quot;)` or similar for the *nix systems and `MEMORYSTATUS` in `ctypes.windll.kernel32` (see [this recipe on ActiveState](http://code.activestate.com/recipes/511491/)) for the Windows platform. One could put a Python class together with all those code snippets.

It&#39;s not that those methods are bad but is there already a well-supported, multi-platform way of doing the same thing?


How to get current CPU and RAM usage in Python?

Let&#39;s say I have a 4-core CPU, and I want to run some process in the minimum amount of time. The process is ideally parallelizable, so I can run chunks of it on an infinite number of threads and each thread takes the same amount of time.

Since I have 4 cores, I don&#39;t expect any speedup by running more threads than cores, since a single core is only capable of running a single thread at a given moment. I don&#39;t know much about hardware, so this is only a guess.

**Is there a benefit to running a parallelizable process on more threads than cores? In other words, will my process finish faster, slower, or in about the same amount of time if I run it using 4000 threads rather than 4 threads?**

Optimal number of threads per core

I want to create a near 100% load on a Linux machine.  It&#39;s quad core system and I want all cores going full speed.  Ideally, the CPU load would last a designated amount of time and then stop.  I&#39;m hoping there&#39;s some trick in bash.  I&#39;m thinking some sort of infinite loop. 

How to create a CPU spike with a bash command

I am reading [an awesome OpenGL tutorial][1]. It&#39;s really great, trust me. The topic I am currently at is Z-buffer. Aside from explaining what&#39;s it all about, the author mentions that we can perform custom depth tests, such as GL_LESS, GL_ALWAYS, etc. He also explains that the actual meaning of depth values (which is top and which isn&#39;t) can also be customized. I understand so far. And then the author says something unbelievable:

&gt; The range zNear can be greater than the range zFar; if it is, then the
&gt; window-space values will be reversed, in terms of what constitutes
&gt; closest or farthest from the viewer.
&gt; 
&gt; Earlier, it was said that the window-space Z value of 0 is closest and
&gt; 1 is farthest. However, if our clip-space Z values were negated, the
&gt; depth of 1 would be closest to the view and the depth of 0 would be
&gt; farthest. Yet, if we flip the direction of the depth test (GL_LESS to
&gt; GL_GREATER, etc), we get the exact same result. So it&#39;s really just a
&gt; convention. ***Indeed, flipping the sign of Z and the depth test was once
&gt; a vital performance optimization for many games.***

If I understand correctly, performance-wise, flipping the sign of Z and the depth test is nothing but changing a `&lt;` comparison to a `&gt;` comparison. So, if I understand correctly and the author isn&#39;t lying or making things up, then changing `&lt;` to `&gt;` used to be ***a vital optimization*** for many games.

Is the author making things up, am I misunderstanding something, or is it indeed the case that once `&lt;` was slower (*vitally*, as the author says) than `&gt;`?

Thanks for clarifying this quite curious matter!

&lt;sub&gt;Disclaimer: I am fully aware that algorithm complexity is the primary source for optimizations. Furthermore, I suspect that nowadays it definitely wouldn&#39;t make any difference and I am not asking this to optimize anything. I am just extremely, painfully, maybe prohibitively curious.&lt;/sub&gt;

  [1]: https://paroj.github.io/gltut/Positioning/Tut05%20Overlap%20and%20Depth%20Buffering.html

Once upon a time, when &gt; was faster than &lt; ... Wait, what?

Once upon a time, to write x86 assembler, for example, you would have instructions stating &quot;load the EDX register with the value 5&quot;, &quot;increment the EDX&quot; register, etc.

With modern CPUs that have 4 cores (or even more), at the machine code level does it just look like there are 4 separate CPUs (i.e. are there just 4 distinct &quot;EDX&quot; registers) ?  If so, when you say &quot;increment the EDX register&quot;, what determines which CPU&#39;s EDX register is incremented? Is there a &quot;CPU context&quot; or &quot;thread&quot; concept in x86 assembler now?

How does communication/synchronization between the cores work?

If you were writing an operating system, what mechanism is exposed via hardware to allow you to schedule execution on different cores? Is it some special priviledged instruction(s)?

If you were writing an optimizing compiler/bytecode VM for a multicore CPU, what would you need to know specifically about, say, x86 to make it generate code that runs efficiently across all the cores?

What changes have been made to x86 machine code to support multi-core functionality?

What does multicore assembly language look like?

What is the difference between a core and a processor?

I&#39;ve already looked for it on Google, but I only get definitions for multi-core and multi-processor, which is not what I am looking for.


Difference between core and processor

I am wondering how you can get the system CPU usage and present it in percent using bash, for example.

Sample output:

    57%

In case there is more than one core, it would be nice if an average percentage could be calculated.

How to get overall CPU usage (e.g. 57%) on Linux

I would like to monitor the following system information in Java:

  - Current CPU usage** (percent)
  - Available memory* (free/total)
  - Available disk space (free/total)

 *Note that I mean overall memory available to the whole system, not just the JVM.

I&#39;m looking for a cross-platform solution (Linux, Mac, and Windows) that doesn&#39;t rely on my own code calling external programs or using JNI. Although these are viable options, I would prefer not to maintain OS-specific code myself if someone already has a better solution.

If there&#39;s a free library out there that does this in a reliable, cross-platform manner, that would be great (even if it makes external calls or uses native code itself).

Any suggestions are much appreciated.

To clarify, I would like to get the current CPU usage for the whole system, not just the Java process(es).

The SIGAR API provides all the functionality I&#39;m looking for in one package, so it&#39;s the best answer to my question so far. However, due it being licensed under the GPL, I cannot use it for my original purpose (a closed source, commercial product). It&#39;s possible that Hyperic may license SIGAR for commercial use, but I haven&#39;t looked into it. For my GPL projects, I will definitely consider SIGAR in the future.

For my current needs, I&#39;m leaning towards the following:

 *  For CPU usage, `OperatingSystemMXBean.getSystemLoadAverage() / OperatingSystemMXBean.getAvailableProcessors()` (load average per cpu)
 *  For memory, `OperatingSystemMXBean.getTotalPhysicalMemorySize()` and `OperatingSystemMXBean.getFreePhysicalMemorySize()`
 *  For disk space, `File.getTotalSpace()` and `File.getUsableSpace()`

Limitations:

The `getSystemLoadAverage()` and disk space querying methods are only available under Java 6. Also, some JMX functionality may not be available to all platforms (i.e. it&#39;s been reported that `getSystemLoadAverage()` returns -1 on Windows).

Although originally licensed under GPL, it [has been changed][2] to [Apache 2.0][1], which can generally be used for closed source, commercial products.

  [1]: http://support.hyperic.com/display/SIGAR/Home#Home-license
  [2]: http://forums.hyperic.com/jiveforums/thread.jspa?threadID=11426&amp;tstart=0


How do I monitor the computer&#39;s CPU, memory, and disk usage in Java?

A couple of questions regarding the x86 CPU privilege rings:

- Why aren&#39;t rings 1 and 2 used by most operating systems? Is it just to maintain code compatibility with other architectures, or is there a better reason?

- Are there any operating systems which actually use those rings? Or are they completely unused?

CPU Privilege Rings: Why rings 1 and 2 aren&#39;t used?

Question: Is there an emulator for a Geforce card that would allow me to program and test CUDA without having the actual hardware?

___

Info:

I&#39;m looking to speed up a few simulations of mine in CUDA, but my problem is that I&#39;m not always around my desktop for doing this development. I would like to do some work on my netbook instead, but my netbook doesn&#39;t have a GPU. Now as far as I know, you need a CUDA capable GPU to run CUDA. Is there a way to get around this? It would seem like the only way is a GPU emulator (which obviously would be painfully slow, but would work). But whatever way there is to do this I would like to hear.

I&#39;m programming on Ubuntu 10.04 LTS.

GPU Emulator for CUDA programming without the hardware

I&#39;m trying to get a deeper understanding of how the low level operations of programming languages work and especially how they interact with the OS/CPU. I&#39;ve probably read every answer in every stack/heap related thread here on Stack&amp;nbsp;Overflow, and they are all brilliant. But there is still one thing that I didn&#39;t fully understand yet.

Consider this function in pseudo code which tends to be valid Rust code ;-)

    fn foo() {
        let a = 1;
        let b = 2;
        let c = 3;
        let d = 4;
        
        // line X
        
        doSomething(a, b);
        doAnotherThing(c, d);
    }

This is how I assume the stack to look like on line X:

    Stack

    a +-------------+
      | 1           | 
    b +-------------+     
      | 2           |  
    c +-------------+
      | 3           | 
    d +-------------+     
      | 4           | 
      +-------------+ 
                      
Now, everything I&#39;ve read about how the stack works is that it strictly obeys LIFO rules (last in, first out). Just like a stack datatype in .NET, Java or any other programming language.

But if that&#39;s the case, then what happens after line X? Because obviously, the next thing we need is to work with `a` and `b`, but that would mean that the OS/CPU (?) has to pop out `d` and `c` first to get back to `a` and `b`. But then it would shoot itself in the foot, because it needs `c` and `d` in the next line.

So, I wonder what **exactly** happens behind the scenes?

Another related question. Consider we pass a reference to one of the other functions like this:

    fn foo() {
        let a = 1;
        let b = 2;
        let c = 3;
        let d = 4;
        
        // line X
        
        doSomething(&amp;a, &amp;b);
        doAnotherThing(c, d);
    }

From how I understand things, this would mean that the parameters in `doSomething` are essentially pointing to the same memory address like `a` and `b` in `foo`. But then again this means that there is no *pop up the stack until we get to `a` and `b`* happening.

Those two cases make me think that I haven&#39;t fully grasped how **exactly** the stack works and how it strictly follows the *LIFO* rules.


How exactly does the callstack work?

I need to check CPU and memory usage for the server in java, anyone know how it could be done?

How do I check CPU and Memory Usage in Java?

In Linux, what happens to the state of a process when it needs to read blocks from a disk? Is it blocked? If so, how is another process chosen to execute?

Linux Process States

* What does `rep; nop` mean?
* Is it the same as `pause` instruction?
* Is it the same as `rep nop` (without the semi-colon)?
* What&#39;s the difference to the simple `nop` instruction?
* Does it behave differently on AMD and Intel processors?
* (bonus) Where is the official documentation for these instructions?

-----

### Motivation for this question ###

After some discussion in the comments of [another question][1], I realized that I don&#39;t know what `rep; nop;` means in x86 (or x86-64) assembly. And also I couldn&#39;t find a good explanation on the web.

I know that `rep` is a prefix that means *&quot;repeat the next instruction `cx` times&quot;* (or at least it was, in old 16-bit x86 assembly). According to this [summary table at Wikipedia][2], it seems `rep` can only be used with `movs`, `stos`, `cmps`, `lods`, `scas` (but maybe this limitation was removed on newer processors). Thus, I would think `rep nop` (without semi-colon) would repeat a `nop` operation `cx` times.

However, after further searching, I got even more confused. It seems that `rep; nop` and `pause` [map to the exactly same opcode][3], and `pause` has a bit different behavior than just `nop`. Some [old mail from 2005][4] said different things:

* *&quot;try not to burn too much power&quot;*
* *&quot;it is equivalent to &#39;nop&#39; just with 2 byte encoding.&quot;*
* *&quot;it is magic on intel. Its like &#39;nop but let the other HT sibling run&#39;&quot;*
* *&quot;it is pause on intel and fast padding on Athlon&quot;*

With these different opinions, I couldn&#39;t understand the correct meaning.

It&#39;s being used in Linux kernel (on both [i386][linux32] and [x86_64][linux64]), together with this comment: `/* REP NOP (PAUSE) is a good thing to insert into busy-wait loops. */` It is also [being used in BeRTOS][bertos], with the same comment.

[1]: https://stackoverflow.com/questions/7083482/how-to-prevent-compiler-optimization-on-a-small-piece-of-code
[2]: http://en.wikipedia.org/wiki/X86_instruction_listings#Original_8086.2F8088_instructions
[3]: https://stackoverflow.com/questions/2589447/is-it-necessary-that-each-machine-code-can-only-map-to-one-assembly-code/2589462#2589462
[4]: http://www.x86-64.org/pipermail/discuss/2005-March/005800.html

[linux64]: http://www.cs.fsu.edu/~baker/devices/lxr/http/source/linux/arch/um/sys-x86_64/asm/processor.h#L20
[linux32]: http://www.cs.fsu.edu/~baker/devices/lxr/http/source/linux/arch/um/sys-i386/asm/processor.h#L53
[bertos]: http://doc.bertos.org/2.6/attr_8h_source.html#l00096

What does &quot;rep; nop;&quot; mean in x86 assembly? Is it the same as the &quot;pause&quot; instruction?

Could you explain more about &quot;user CPU time&quot; and &quot;system CPU time&quot;? I have read a lot, but I couldn&#39;t understand it well.

User CPU time vs System CPU time?

On my desktop, I have a little widget that tells me my current CPU usage. It also shows the usage for each of my two cores. 

I always wondered, how does the CPU calculate how much of its processing power is being used? Also, if the CPU is hung up doing some intense calculations, how can it (or whatever handles this activity) examine the usage, without getting hung up as well?


How is CPU usage calculated?

I don&#39;t want to optimize anything, I swear, I just want to ask this question out of curiosity.
I know that on most hardware there&#39;s an assembly command of bit-shift (e.g. `shl`, `shr`), which is a single command. But does it matter (nanosecond-wise, or CPU-tact-wise) how many bits you shift. In other words, is either of the following faster on any CPU?

    x &lt;&lt; 1;

and

    x &lt;&lt; 10;

And please don&#39;t hate me for this question. :)

Which is faster:  x&lt;&lt;1  or  x&lt;&lt;10?

I read somewhere that setInterval is CPU intensive. I created a script that uses setInterval and monitored the CPU usage but didn&#39;t notice a change. I want to know if there is something I missed.

What the code does is check for changes to the hash in the URL (content after #) every 100 milliseconds and if it has changed, load a page using AJAX. If it has not changed, nothing happens. Would there be any CPU issues with that.

Is setInterval CPU intensive?

From the 11th Chapter(*Performance and Scalability*) and the section named *Context Switching* of the [JCIP book][1]:

&gt; When a new thread is switched in, the data it needs is unlikely to be
&gt; in the local processor cache, so a context-switch causes a flurry of
&gt; cache misses, and thus threads run a little more slowly when they are
&gt; first scheduled.

 1. Can someone explain in an easy to understand way the concept of *cache miss* and its probable opposite (*cache hit*)?
 2. Why context-switching would cause a lot of cache miss?

[1]:http://jcip.net.s3-website-us-east-1.amazonaws.com/

What is a cache hit and a cache miss? Why would context-switching cause cache miss?

It&#39;s a question which has been asked many times, however there is no well supported answer I could find.

Many people suggest the use of top command, but if you run top once (because you have a script for example collecting Cpu usage every 1 second) it will always give the same Cpu usage result ([example 1][1], [example 2][2]).

A more accurate way to calculate CPU usage, is by reading the values from `/proc/stat`, but most of the answers use only the first 4 fields from `/proc/stat` to calculate it (one example [here][2]).

`/proc/stat/` has 10 fields per CPU core as of Linux kernel 2.6.33!

I also found this https://stackoverflow.com/questions/5514119/accurately-calculating-cpu-utilization-in-linux-using-proc-stat question which is pointing out the same issue, -that most other questions only take into consideration 4 out of the many fields- but still the answer given here starts with &quot;I think&quot; (not certain), and except that, it is only concerned about the first 7 fields (out of 10 in `/proc/stat/`)

[This][3] perl script uses all of the fields to calculate the CPU usage, which again I do not think is correct after some further investigation.

After taking a quick look into the kernel code [here][4], it looks like, for example, `guest_nice` and `guest fields` are always increasing together with `nice` and `user` (so they should not be included in the cpu usage calculation, since they are included in `nice` and `user` fields already)

    /*
     * Account guest cpu time to a process.
     * @p: the process that the cpu time gets accounted to
     * @cputime: the cpu time spent in virtual machine since the last update
     * @cputime_scaled: cputime scaled by cpu frequency
     */
    static void account_guest_time(struct task_struct *p, cputime_t cputime,
    			       cputime_t cputime_scaled)
    {
    	u64 *cpustat = kcpustat_this_cpu-&gt;cpustat;
    
    	/* Add guest time to process. */
    	p-&gt;utime += cputime;
    	p-&gt;utimescaled += cputime_scaled;
    	account_group_user_time(p, cputime);
    	p-&gt;gtime += cputime;
    
    	/* Add guest time to cpustat. */
    	if (task_nice(p) &gt; 0) {
    		cpustat[CPUTIME_NICE] += (__force u64) cputime;
    		cpustat[CPUTIME_GUEST_NICE] += (__force u64) cputime;
    	} else {
    		cpustat[CPUTIME_USER] += (__force u64) cputime;
    		cpustat[CPUTIME_GUEST] += (__force u64) cputime;
    	}
    }

So to sum up, what is an accurate way to calculate the CPU usage in Linux and which fields should be considered in the calculations and how (which fields are attributed to the idle time and which fields to non-idle time)?


  [1]: https://unix.stackexchange.com/questions/69185/getting-cpu-usage-same-every-time
  [2]: https://unix.stackexchange.com/questions/27076/how-can-i-receive-top-like-cpu-statistics-from-the-shell
  [3]: https://gist.github.com/creaktive/781248
  [4]: http://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/tree/kernel/sched/cputime.c?h=v4.8#n169

Accurate calculation of CPU usage given in percentage in Linux?

Several years ago, the &#39;next big thing&#39; was clockless computers.  The idea behind it was that without a clock, the processors would run significantly faster.

That was then, this is now and I can&#39;t find any info on how it&#39;s been coming along or if the idea was a bust...

Anyone know?

For reference:

http://www.cs.columbia.edu/~nowick/technology-review-article-10-01.pdf

What happened to clockless computer chips?

How are GPUs more faster then CPUs? I&#39;ve read articles that talk about how GPU&#39;s are much faster in breaking passwords than CPUs. If thats the case then why can&#39;t CPUs be designed in the same way as GPUs to be even in speed?

Why are GPUs more powerful than CPUs

Let&#39;s say your Java program is taking 100% CPU. It has 50 threads. You need to find which thread is guilty. I have not found a tool that can help. Currently I use the following very time consuming routine:

1. Run `jstack &lt;pid&gt;`, where pid is the process id of a Java process. The easy way to find it is to run another utility included in the JDK - `jps`. It is better to redirect jstack&#39;s output to a file.
2. Search for &quot;runnable&quot; threads. Skip those that wait on a socket (for some reason they are still marked runnable).
3. Repeat steps 1 and 2 a couple of times and see if you can locate a pattern.

Alternatively, you could attach to a Java process in Eclipse and try to suspend threads one by one, until you hit the one that hogs CPU. On a one-CPU machine, you might need to first reduce the Java process&#39;s priority to be able to move around. Even then, Eclipse often isn&#39;t able to attach to a running process due to a timeout.

I would have expected Sun&#39;s `visualvm` tool to do this.

Does anybody know of a better way?


Which Java thread is hogging the CPU?

Is there an API to get the number of CPUs available in Linux?
I mean, without using /proc/cpuinfo or any other sys-node file...

I&#39;ve found this implementation using sched.h:

    int GetCPUCount()
    {
     cpu_set_t cs;
     CPU_ZERO(&amp;cs);
     sched_getaffinity(0, sizeof(cs), &amp;cs);
    
     int count = 0;
     for (int i = 0; i &lt; 8; i++)
     {
      if (CPU_ISSET(i, &amp;cs))
       count++;
     }
     return count;
    }

But, isn&#39;t there anything more higher level using common libraries?


How to get the number of CPUs in Linux using C?

Is there any way in Linux to assign one CPU core to a particular given process and there should not be any other processes or interrupt handlers to be scheduled on this core?

I have read about process affinity in Linux **Binding Processes to CPUs using the taskset utility** but that&#39;s not solving my problem because **it just try to affine the given process to that core but it is possible that other processes may be scheduled on this core** and this is what I want to avoid.

Should we change the kernel code for scheduling?

Whole one core dedicated to single process

I&#39;ve been searching all over for a consistent and clear explanation of what &#39;self time&#39; actually refers to in the VisualVM context and how does it differ to &#39;self time (cpu)&#39;. Also does &#39;self time [%]&#39; refer to self time or self time cpu. 

There doesn&#39;t appear to be much documentation on this or at least I haven&#39;t found it. So any thoughts/input will be appreciated.

VisualVM and Self Time

Ok, I have been reading the following Qs from SO regarding x86 CPU fences (`LFENCE`, `SFENCE` and `MFENCE`):

 - https://stackoverflow.com/questions/20316124/does-it-make-any-sense-instruction-lfence-in-processors-x86-x86-64

 - https://stackoverflow.com/questions/20326280/what-is-the-impact-sfence-and-lfence-to-caches-of-neighboring-cores/20329574#20329574

 - https://stackoverflow.com/questions/27522190/is-the-mesi-protocol-enough-or-are-memory-barriers-still-required-intel-cpus

and:

 - http://www.puppetmastertrading.com/images/hwViewForSwHackers.pdf

 - https://onedrive.live.com/view.aspx?resid=4E86B0CF20EF15AD!24884&amp;app=WordPdf&amp;authkey=!AMtj_EflYn2507c

and I must be honest I am still not totally sure when a fence is required. I am trying to understand from the perspective of removing fully-blown locks and trying to use more fine-granular locking via fences, to minimise latency delays.

Firstly here are two specific questions I do not understand:

Sometimes when doing a store a CPU will write to its store buffer instead of the L1 cache. I do not however understand the terms on which a CPU will do this?

CPU2 may wish to load a value which has been written in to CPU1&#39;s store buffer. As I understand it, the problem is CPU2 cannot see the new value in CPU1&#39;s store buffer. Why can&#39;t the MESI protocol just include flushing store buffers as part of its protocol??

More generally, could somebody please attempt to describe the overall scenario and help explain when `LFENCE`/`MFENCE` and `SFENCE` instructions are required?

NB One of the problems reading around this subject is the number of articles written &quot;generally&quot; for multiple CPU architectures, when I am only interested in the Intel x86-64 architecture specifically.


When are x86 LFENCE, SFENCE and MFENCE instructions required?

I&#39;d like to specify the cpu-affinity of a particular pthread. All the references I&#39;ve found so far deal with setting the cpu-affinity of a process (pid\_t) not a thread (pthread\_t). I tried some experiments passing pthread\_t&#39;s around and as expected they fail. Am I trying to do something impossible? If not, can you send a pointer please? Thanks a million.

how to set CPU affinity of a particular pthread?

I&#39;m confused on how many flops per cycle per core can be done with Sandy-Bridge and Haswell.
As I understand it with SSE it should be 4 flops per cycle per core for SSE and 8 flops per cycle per core for AVX/AVX2.  

This seems to be verified here,
https://stackoverflow.com/questions/8389648/how-to-achieve-4-flops-per-cycle
,and here,
https://stackoverflow.com/questions/12027922/sandy-bridge-cpu-specification.

However the link below seems to indicate that Sandy-bridge can do 16 flops per cycle per core and Haswell 32 flops per cycle per core
http://www.extremetech.com/computing/136219-intels-haswell-is-an-unprecedented-threat-to-nvidia-amd.

Can someone explain this to me?

Edit:
I understand now why I was confused.  I thought the term FLOP only referred  to single floating point (SP).  I see now that the test at https://stackoverflow.com/questions/8389648/how-to-achieve-4-flops-per-cycle are actually on double floating point (DP) so they achieve 4 DP FLOPs/cycle for SSE and 8 DP FLOPs/cycle for AVX.  It would be interesting to redo these test on SP.

FLOPS per cycle for sandy-bridge and haswell SSE2/AVX/AVX2

The first time I ran Genymotion virtual device, it had worked. But when I tried running it today, I got this error message

![enter image description here][1]


  [1]: http://i.stack.imgur.com/s3lYt.png

What may have changed from the last time I used it? Will be grateful for any solutions that I can get. Thanks.

My Device Info:
Dell XPS L502X
Sandy Bridge motherboard
Intel Core i5-2410M @2.30 GHz
Windows 7 Professional 64-bit

Unable to start Genymotion virtual device, incompatible CPU

I hear this statement quite often, that multiplication on modern hardware is so optimized that it actually is at the same speed as addition. Is that true?

I never can get any authoritative confirmation. My own research only adds questions. The speed tests usually show data that confuses me. Here is an example:

	#include &lt;stdio.h&gt;
	#include &lt;sys/time.h&gt;

	unsigned int time1000() {
	    timeval val;
	    gettimeofday(&amp;val, 0);
	    val.tv_sec &amp;= 0xffff;
	    return val.tv_sec * 1000 + val.tv_usec / 1000;
	}

	int main() {
		unsigned int sum = 1, T = time1000();
		for (int i = 1; i &lt; 100000000; i++) {
		    sum += i + (i+1); sum++;
		}
		printf(&quot;%u %u\n&quot;, time1000() - T, sum);
		sum = 1;
		T = time1000();
		for (int i = 1; i &lt; 100000000; i++) {
		    sum += i * (i+1); sum++;
		}
		printf(&quot;%u %u\n&quot;, time1000() - T, sum);
	}

The code above can show that multiplication is faster:

    clang++ benchmark.cpp -o benchmark
    ./benchmark
    746 1974919423
    708 3830355456

But with other compilers, other compiler arguments, differently written inner loops, the results can vary and I cannot even get an approximation.



Is integer multiplication really done at the same speed as addition on a modern CPU?

I mean: how can I measure time my CPU spent on function execution and wall clock time it takes to run my function? (Im interested in Linux/Windows and both x86 and x86_64). See what I want to do (Im using C++ here but I would prefer C solution):

    int startcputime, endcputime, wcts, wcte;
    
    startcputime = cputime();
    function(args);
    endcputime = cputime();
    
    std::cout &lt;&lt; &quot;it took &quot; &lt;&lt; endcputime - startcputime &lt;&lt; &quot; s of CPU to execute this\n&quot;;
    
    wcts = wallclocktime();
    function(args);
    wcte = wallclocktime();
    
    std::cout &lt;&lt; &quot;it took &quot; &lt;&lt; wcte - wcts &lt;&lt; &quot; s of real time to execute this\n&quot;;

**Another important question: is this type of time measuring architecture independent or not?**

How can I measure CPU time and wall clock time on both Linux/Windows?

I am interested in forcing a CPU cache flush in Windows (for benchmarking reasons, I want to emulate starting with no data in CPU cache), preferably a basic C implementation or Win32 call.

Is there a known way to do this with a system call or even something as sneaky as doing say a large `memcpy`?

Intel i686 platform (P4 and up is okay as well). 

How can I do a CPU cache flush in x86 Windows?

According to Wikipedia, x86 is a CISC design, but I also have heard/read that it is RISC. What is correct? I&#39;d to also like to know __why__ it is CISC or RISC. What determines if a design is RISC or CISC? Is it _just_ the number of machine language instruction a microprocessors has or are there any other characteristics that determine the architecture?

All Cpu Solutions on Gang of Coders

Total of 37 Cpu Solutions