lscpu | - lscpu for BSDs | Monitoring library

Intel Xeon E5-2620 is Sandy Bridge CPU which officially supports AVX and not AVX2.

DPDK 20.11 meson build, ninja -C build will generate code with AVX instructions and not AVX2. But (Based on the live debug) PKTGEN forces the compiler to add AVX2 to be inserted, thus causing illegal instruction.

Solution: edit meson.build in line 22

from

The pipe feature comes from the shell you are using. I thought it would work with runInShell but could not get it to work. Instead, you can do this which will explicit run your commands using /bin/sh:

(This might be better as a comment, feel free to remove this if a better answer comes up, as it's based on my experience using the libraries.)

I had a similar issue when multiprocessing parts of my code. The numpy/scipy libraries appear to spin up extra threads when you do vectorised operations if you compiled the libraries with BLAS or MKL (or if the conda repo you pulled them from also included a BLAS/MKL library), to accelerate certain calculations.

This is fine when running your script in a single process, since it will spawn threads up to the number specified by OPENBLAS_NUM_THREADS or MKL_NUM_THREADS (depending on if you have a BLAS library or MKL library - you can identify which by using numpy.__config__.show()), but if you are explicitly using a multiprocesing.Pool, then you likely want to control the number of processes in multiprocessing - in this case, it makes sense to set n=1 (before importing numpy & scipy), or some small number to make sure you are not oversubscribing:

Since the amalgamation file is a C file it should be:

The Cloud Run services run container on a non standard runtime environmen (named BORG internally at Google Cloud). It's possible that the low level info values are not relevants.

In addition, Cloud Run services run in a sandbox (gVisor) and system calls can be also filtered like that.

What did you look at with these test?

I performed tests to validate the multi-cpus capacity of Cloud Run and wrote an article about that. The multi cpu capacity is real!! Have a look on it.

There are plenty of reasons why a code can be slower with -march=native, although this is quite exceptional.

That being said, in your specific context, one possible scenario is the use of slower SIMD instructions, or more precisely different SIMD instructions finally making the program slower. Indeed, GCC vectorize loops with -O3 using the SSE instruction set on x86 processors such as yours (for backward compatibility). With -march=native, GCC will likely vectorize loops using the more advanced and more recent AVX instruction set (supported by your processor but not on many old x86 processors). While the use of AVX instruction should speed your program up, it is not always the case in few pathological cases (less efficient code generated by compiler heuristics, loops are too small to leverage AVX instructions, missing/slower AVX instructions available in SSE, alignment, transition penality, energy/frequency impact, etc.).

My guess is your program is memory bound and thus AVX instructions do not make your program faster.

You can confirm this hypothesis by enabling AVX manually using -mavx -mavx2 rather than -march=native and look if your performance issue is still there. I advise you to carefully benchmark your application using a tool like perf.

I finally found the solution. Because I am using an old AMV processor, I needed to use an ARM based image for the emulator and not a x86 image. I was then able to run it. Unfortunately my processor was not powerful enough and was lagging as hell when launching the android emulator. Had to buy a new computer.

How many threads can I call in one program?

You didn't specify any programming language or operating system but in most cases, there's no hard limit. The most important limit is how much memory is available for the thread stacks. It's harder to quantify how many threads it takes before they all spend more time competing with each other for resources than they spend doing any actual work.

the command lscpu returns: Thread(s) per core: 2, Core(s) per socket: 6, Socket(s): 1

That information tells how many threads the system can simultaneously execute. If your program has more than twelve threads that are ready to run then, at most twelve of them will actually be running at any given point in time, while the rest of them await their turns.

But note: In order for twelve threads to be "ready to run," they have to all be doing tasks that do not interfere with each other. That mostly means, doing computations on values that are already in memory. In your example program, all of the threads want to write to the same output stream. Assuming that the output stream is "thread safe," then that will be something that only one thread can do at a time. It doesn't matter how many cores your computer has.

how many thread can I call to make sure other programs run well?

That's hard to answer unless you know what all of the other programs need to do. And what does "run well" mean, anyway? If you want to be able to use office tools or programming tools to get work done while a large, compute-intensive program runs "in the background," then you'll pretty much have to figure out for yourself just how much work the background program can do while still allowing the "foreground" tools to respond to your typing.

What about this —