**First method – Easiest option- Check your Task Manager**

If you have Windows 10 or Windows 8 operating system, the easiest way to check is by opening up Task Manager-&gt;Performance Tab. You should see Virtualization as shown in the below screenshot. If it is enabled, it means that your CPU supports Virtualization and is currently enabled in BIOS. If it shows disabled, you need to enable it in BIOS. If you don’t see virtualization, it means that your CPU does not support virtualization. Read [here][1] for more information.
[![][2]][2]


  [1]: https://www.shaileshjha.com/how-to-find-out-if-intel-vt-x-or-amd-v-virtualization-technology-is-supported-in-windows-10-windows-8-windows-vista-or-windows-7-machine/
  [2]: https://i.stack.imgur.com/GkDPe.jpg

In PowerShell run:
```Get-ComputerInfo -property &quot;HyperV*&quot;```

    PS C:\temp&gt; Get-ComputerInfo -property &quot;HyperV*&quot;
    
    HyperVisorPresent                                 : True
    HyperVRequirementDataExecutionPreventionAvailable : True
    HyperVRequirementSecondLevelAddressTranslation    : True
    HyperVRequirementVirtualizationFirmwareEnabled    : True
    HyperVRequirementVMMonitorModeExtensions          : True

The line ```HyperVRequirementVirtualizationFirmwareEnabled    : True``` shows if virtualization is enabled in BIOS (firmware).

**Alternate Method**  
Right-click Start &gt; Run &gt; *msinfo32*

The first page shows whether virtualization is enabled in BIOS (firmware).

[![msinfo32 &quot;Hyper-V - Virtualization Enabled in Firmware   Yes&quot;][1]][1]


  [1]: https://i.stack.imgur.com/DPEpY.jpg

In Kotlin `open` is the same as not `final` in Java for classes and methods.

What does `open` give me in the following class for the field marked as `open`?

    @MappedSuperclass
    abstract class BaseEntity() : Persistable&lt;Long&gt; {
         open var id: Long? = null
    }

**updated**
this is not duplicate of https://stackoverflow.com/questions/49024200/what-is-the-difference-between-open-and-public-in-kotlin

I am interested in `open` keyword for properties 

**updated**

`open` class can be inherited.   
`open` fun can be overridden   
`val` property is `final` field in java

what about `open` property?



what is `open` keyword for fields in Kotlin?

I have a React component (React v15.5.4) that you can pass other components to:

    class CustomForm extends React.Component {
      ...
      render() {
        return (
          &lt;div&gt;
              {this.props.component}
          &lt;/div&gt;
        );
      }
    }

And I have a different component that uses it:

    class SomeContainer extends React.Component {
      ...
      render() {
        let someObjectVariable = {someProperty: &#39;someValue&#39;};
        return (
          &lt;CustomForm 
             component={&lt;SomeInnerComponent someProp={&#39;someInnerComponentOwnProp&#39;}/&gt;}
             object={someObjectVariable}
          /&gt;
        );
      }
    }

Everything renders fine, but I want to pass **someObjectVariable** prop to the child component inside **CustomForm** (in this case that&#39;ll be **SomeInnerComponent**), since in the actual code you can pass several components to it instead of just one like the example.

Mind you, I also need to pass **SomeInnerComponent** its own props.

Is there a way to do that?

React - How to pass props to a component passed as prop

I want to check if Intel virtualization is enabled in my laptop or not (Lenovo Thinkpad, Win 10 64 bit). Is there any way available to check it without going to BIOS?

How to check if Intel Virtualization is enabled without going to BIOS in Windows 10

<p>I want to check if Intel virtualization is enabled in my laptop or not (Lenovo Thinkpad, Win 10 64 bit). Is there any way available to check it without going to BIOS?</p>


When installing Subsystem for Linux and Ubuntu from store on his development machine I can switch (or start) to Ubuntu shell by simply

[![enter image description here][1]][1]


  [1]: https://i.stack.imgur.com/RgSmf.png

But the Ubuntu shell start in `/home/techsupp` folder by default. Is it possible to force it to start in same folder than the one I use my `Ubuntu` command?

So in my example I should be in 

    /mnt/h

Thank you.

**What I already tried:**

    H:\&gt;ubuntu help
    Launches or configures a linux distribution.
    
    Usage:
        &lt;no args&gt;
          - Launches the distro&#39;s default behavior. By default, this launches your default shell.
    
        run &lt;command line&gt;
          - Run the given command line in that distro, using the default configuration.
          - Everything after `run ` is passed to the linux LaunchProcess call.
    
        config [setting [value]]
          - Configure certain settings for this distro.
          - Settings are any of the following (by default)
            - `--default-user &lt;username&gt;`: Set the default user for this distro to &lt;username&gt;
    
        clean
          - Uninstalls the distro. The appx remains on your machine. This can be
            useful for &quot;factory resetting&quot; your instance. This removes the linux
            filesystem from the disk, but not the app from your PC, so you don&#39;t
            need to redownload the entire tar.gz again.
    
        help
          - Print this usage message.


I also discover this request on uservoice: https://wpdev.uservoice.com/forums/266908-command-prompt-console-windows-subsystem-for-l/suggestions/13421103-let-us-right-click-open-bash-here-from-explorer?tracking_code=8a8bc624c72a8336565fcd6d5737d712

Please vote for it.

Start WSL Ubuntu in specific or current folder on Windows

I use Docker toolbox for windows and i`m trying run private docker registry from this documentation https://docs.docker.com/registry/deploying/

But it`s not work for me. 
Error after this: 

    $ docker pull 192.168.99.100:5000/my-ubuntu
Error

    $ docker pull 192.168.99.100:5000/image
    Using default tag: latest
    Error response from daemon: Get https://192.168.99.100:5000/v2/: http: server gave HTTP response to HTTPS client
I`m thinking that error is something in my docker client.

For information this is my **docker info**

    Containers: 6
     Running: 4
     Paused: 0
     Stopped: 2
    Images: 19
    Server Version: 17.06.0-ce
    Storage Driver: aufs
     Root Dir: /mnt/sda1/var/lib/docker/aufs
     Backing Filesystem: extfs
     Dirs: 144
     Dirperm1 Supported: true
    Logging Driver: json-file
    Cgroup Driver: cgroupfs
    Plugins:
     Volume: local
     Network: bridge host macvlan null overlay
     Log: awslogs fluentd gcplogs gelf journald json-file logentries splunk syslog
    Swarm: inactive
    Runtimes: runc
    Default Runtime: runc
    Init Binary: docker-init
    containerd version: cfb82a876ecc11b5ca0977d1733adbe58599088a
    runc version: 2d41c047c83e09a6d61d464906feb2a2f3c52aa4
    init version: 949e6fa
    Security Options:
     seccomp
      Profile: default
    Kernel Version: 4.4.74-boot2docker
    Operating System: Boot2Docker 17.06.0-ce (TCL 7.2); HEAD : 0672754 - Thu Jun 29 00:06:31 UTC 2017
    OSType: linux
    Architecture: x86_64
    CPUs: 1
    Total Memory: 995.8MiB
    Name: default
    ID: ZMCX:NXC7:3BSV:ZNWV:MDZO:FW26:6MX5:UWI6:NVRL:XP56:AKGC:Z3TW
    Docker Root Dir: /mnt/sda1/var/lib/docker
    Debug Mode (client): false
    Debug Mode (server): true
     File Descriptors: 47
     Goroutines: 56
     System Time: 2018-04-05T13:43:42.856720067Z
     EventsListeners: 0
    Username: kacalek
    Registry: https://index.docker.io/v1/
    Labels:
     provider=virtualbox
    Experimental: false
    Insecure Registries:
     127.0.0.0/8
    Live Restore Enabled: false
If i try on mac so everythink is perfect.

Do you know how this error to **solve**?

Thank you so much for every answers!

Docker repository server gave HTTP response to HTTPS client

I&#39;ve installed openssh for windows and when I run `ssh localhost` I get 
&gt; Bad owner or permissions on C:\\Users\\gary/.ssh/config

I&#39;ve looked at these 2 questions https://superuser.com/questions/348694/bad-owner-or-permissions-error-using-cygwins-ssh-exe and https://serverfault.com/questions/253313/ssh-returns-bad-owner-or-permissions-on-ssh-config but none of the answers work for me.  sshd is running as a service as the Local System user.  I&#39;ve run `chmod 0600 C:\Users\gary\.ssh\config` and `chown gary C:\Users\gary\.ssh\config`.  I&#39;ve also cleared the ACL by running `setfacl -b C:\Users\gary\.ssh\config` and then `chmod 0600 C:\Users\gary\.ssh\config` again.  I&#39;ve also tried changing the owner to SYSTEM and got the same error.

I&#39;m not sure what else to do, is there anything wrong with my setup?  I also have git installed which installed mingw, I deleted ssh and sshd from my git installation so they wouldn&#39;t be on my path.

Other commands I&#39;ve run are
`icacls &quot;C:\Users\gary\.ssh\config&quot; /setowner gary`
`chown -R gary:1049089 C:\Users\gary\.ssh`

`ls -la C:\Users\gary\.ssh\config` shows 
&gt;-rw-r--r-- 1 gary 1049089 229 Jan  3 14:43 &#39;C:\Users\gary\.ssh\config&#39;

it keeps showing this even after changing the owner to SYSTEM, but in the file properties in file explorer it shows SYSTEM as the owner


openssh windows bad owner or permissions

I&#39;m getting &#39;access is denied&#39; when I&#39;m using nvm -v command in windows 10.
I have got the similar issue here 
https://stackoverflow.com/questions/48762782/nvm-is-access-denied

But he himself gave a solution which is not working for me. 

Is there any solution for this problem?


  [1]: https://stackoverflow.com/questions/48762782/nvm-is-access-denied

Access Denied issue with NVM in Windows 10

When I have hidden files, like *dotfiles* or a `.git` directory: 
How can I list those files and directories in Powershell?

Neither `Get-ChildItem`, `dir` nor `ls` seem to show them.

How to show hidden files (dotfiles) with windows powershell

I can&#39;t figure out how to install Windows 10 SDK for Visual Studio 2017.

I downloaded and ran the Windows 10 SDK installer, and it displays `Please find winsdksetup.exe in ....\Windows kits\10\WindowsSDK to install Windows Software Development Kit - Windows 10.0.17134.12.`

When I run `winsdksetup.exe`, it takes me through the same loop, where it downloads a bunch of executable installers into this directory and show the same exact message.

When I try to build a DirectX project in VS2017, I get the error:

    MSB8036	The Windows SDK version 10.0.16299.0 was not found. Install the required version of Windows SDK or change the SDK version in the project property pages or by right-clicking the solution and selecting &quot;Retarget solution&quot;.	

Do I need to install one of those installers? Which one do I need to run to build and debug DirectX projects for Visual Studio? Specifically to use VS2017 shader debugging functionality.

Thanks,

EDIT: 
Under VS2017 - Tools -&gt; Get Tools and Features
I have checked

Game Development with C++

and under Optional I have 

C++ Profiling tools
Windows 10 SDK (10.0.17134.0)

I&#39;m downloading 16299.0, this fixed the first error of not having the right SDK.

But now I get the runtime error `Failed Creating the Direct3D device` when running in Debug. I can still run samples in Release

How do I install Windows 10 SDK for use with Visual Studio 2017

I have a question about how and what is the version of OpenSSl that I must install in Windows to later create certificates.
Install a one version (openssl-1.0.2d-fips-2.0.10) found in SourceForge but it does not generate the files correctly.
There is also the official website https://www.openssl.org, but I do not know how to install it and how, so that when it comes to generating the keys and .pem file, it works.
Generate some environment variables that point to the folder where I unzipped the downloaded, I do not know if it is the correct way.

How to install OpenSSL in windows 10?

When I try to start the ssh-agent on Windows 10 via PowerShell (with elevated right or without) by entering `Start-Service ssh-agent` I get the error

&gt; unable to start ssh-agent service, error :1058

When I check of the service is running via `Get-Service ssh-agent` is returns that the service is stopped.

How can I get the ssh-agent running?

Starting ssh-agent on Windows 10 fails: &quot;unable to start ssh-agent service, error :1058&quot;

Today when I tried to run a simple code on Sublime Text 3, the following message appeared:

&gt; Python was not found but can be installed from the Microsoft Store: https://go.microsoft.com/fwlink?linkID=2082640

And when I type Python in CMD, it opens the Windows Store for me to download Python 3.7. This problem started today for no good reason, I didn&#39;t change or downloaded anything about Python and already tried reinstalling Python, and the Path is correct.

CMD opens window store when I type python

When moving from WSL1 to WSL2 many things change; apparently this applies to X11 forwarding as well.  
What steps do I need to make in order to use X11 forwarding with WSL2 on Windows 10 as I did with WSL1?

How to set up working X11 forwarding on WSL2

I&#39;ve been trying to understand assembly language code generated by GCC and frequently encounter this instruction at the start of many functions including `_start()`, but couldn&#39;t find any guide explaining its purpose:
```
31-0000000000001040 &lt;_start&gt;:
32:    1040:	f3 0f 1e fa          	endbr64 
33-    1044:	31 ed                	xor    ebp,ebp

What does the endbr64 instruction actually do?

Rust has 128-bit integers, these are denoted with the data type `i128` (and `u128` for unsigned ints):

    let a: i128 = 170141183460469231731687303715884105727;

How does Rust make these `i128` values work on a 64-bit system; e.g. how does it do arithmetic on these?

Since, as far as I know, the value cannot fit in one register of a x86-64 CPU, does the compiler somehow use two registers for one `i128` value? Or are they instead using some kind of big integer struct to represent them?

How does Rust&#39;s 128-bit integer `i128` work on a 64-bit system?

I believe I found a bug in GCC while implementing O&#39;Neill&#39;s PCG PRNG. ([Initial code on Godbolt&#39;s Compiler Explorer](https://c.godbolt.org/z/jzKUgG))

After multiplying ```oldstate``` by ```MULTIPLIER```, (result stored in rdi), GCC doesn&#39;t add that result to ```INCREMENT```, movabs&#39;ing ```INCREMENT``` to rdx instead, which then gets used as the return value of rand32_ret.state

A minimum reproducible example ([Compiler Explorer](https://gcc.godbolt.org/z/FCuEsg)):
```c
#include &lt;stdint.h&gt;

struct retstruct {
    uint32_t a;
    uint64_t b;
};

struct retstruct fn(uint64_t input)
{
    struct retstruct ret;

    ret.a = 0;
    ret.b = input * 11111111111 + 111111111111;

    return ret;
}
```
Generated assembly (GCC 9.2, x86_64, -O3):
```x86
fn:
  movabs rdx, 11111111111     # multiplier constant (doesn&#39;t fit in imm32)
  xor eax, eax                # ret.a = 0
  imul rdi, rdx
  movabs rdx, 111111111111    # add constant; one more 1 than multiplier
     # missing   add rdx, rdi   # ret.b=... that we get with clang or older gcc
  ret
# returns RDX:RAX = constant 111111111111 : 0
# independent of input RDI, and not using the imul result it just computed
```

Interestingly, modifying the struct to have the uint64_t as the first member [produces correct code](https://gcc.godbolt.org/z/dZsF4v), as does [changing both members to be uint64_t](https://gcc.godbolt.org/z/w6zxZU)

x86-64 System V does return structs smaller than 16 bytes in RDX:RAX, when they&#39;re trivially copyable.  In this case the 2nd member is in RDX because the high half of RAX is the padding for alignment or `.b` when `.a` is a narrower type.  (`sizeof(retstruct)` is 16 either way; we&#39;re not using `__attribute__((packed))` so it respects alignof(uint64_t) = 8.)

**Does this code contain any undefined behaviour that would allow GCC to emit the &quot;incorrect&quot; assembly?**

If not, this should get reported on https://gcc.gnu.org/bugzilla/

Possible GCC bug when returning struct from a function

A colleague showed me code that I thought wouldn&#39;t be necessary, but sure enough, it was. I would expect most compilers would see all three of these attempts at equality tests as equivalent:

```
#include &lt;cstdint&gt;
#include &lt;cstring&gt;

struct Point {
    std::int32_t x, y;
};

[[nodiscard]]
bool naiveEqual(const Point &amp;a, const Point &amp;b) {
    return a.x == b.x &amp;&amp; a.y == b.y;
}

[[nodiscard]]
bool optimizedEqual(const Point &amp;a, const Point &amp;b) {
    // Why can&#39;t the compiler produce the same assembly in naiveEqual as it does here?
    std::uint64_t ai, bi;
    static_assert(sizeof(Point) == sizeof(ai));
    std::memcpy(&amp;ai, &amp;a, sizeof(Point));
    std::memcpy(&amp;bi, &amp;b, sizeof(Point));
    return ai == bi;
}

[[nodiscard]]
bool optimizedEqual2(const Point &amp;a, const Point &amp;b) {
    return std::memcmp(&amp;a, &amp;b, sizeof(a)) == 0;
}


[[nodiscard]]
bool naiveEqual1(const Point &amp;a, const Point &amp;b) {
    // Let&#39;s try avoiding any jumps by using bitwise and:
    return (a.x == b.x) &amp; (a.y == b.y);
}
```

But to my surprise, only the ones with `memcpy` or `memcmp` get turned into a single 64-bit compare by GCC. Why?  (https://godbolt.org/z/aP1ocs)

Isn&#39;t it obvious to the optimizer that if I check equality on contiguous pairs of four bytes that that&#39;s the same as comparing on all eight bytes?

An attempt to avoid separately booleanizing the two parts compiles somewhat more efficiently (one fewer instruction and no false dependency on EDX), but still two separate 32-bit operations.

```
bool bithackEqual(const Point &amp;a, const Point &amp;b) {
    // a^b == 0 only if they&#39;re equal
    return ((a.x ^ b.x) | (a.y ^ b.y)) == 0;
}
```

---

GCC and Clang both have the same missed optimizations when passing the structs by *value* (so `a` is in RDI and `b` is in RSI because that&#39;s how x86-64 System V&#39;s calling convention packs structs into registers): https://godbolt.org/z/v88a6s.  The memcpy / memcmp versions both compile to `cmp  rdi, rsi`  / `sete  al`, but the others do separate 32-bit operations.

`struct alignas(uint64_t) Point` surprisingly still helps in the by-value case where arguments are in registers, optimizing both naiveEqual versions for GCC, but not the bithack XOR/OR.  (https://godbolt.org/z/ofGa1f). Does this give us any hints about GCC&#39;s internals? Clang isn&#39;t helped by alignment.





Why can&#39;t GCC generate an optimal operator== for a struct of two int32s?

I made a [bubble sort][1] implementation in C, and was testing its performance when I noticed that the `-O3` flag made it run even slower than no flags at all! Meanwhile `-O2` was making it run a lot faster as expected.

Without optimisations:

```none
time ./sort 30000

./sort 30000  1.82s user 0.00s system 99% cpu 1.816 total
```

`-O2`:

```none
time ./sort 30000

./sort 30000  1.00s user 0.00s system 99% cpu 1.005 total
```

`-O3`:

```none
time ./sort 30000

./sort 30000  2.01s user 0.00s system 99% cpu 2.007 total
```

The code:

```c
#include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;
#include &lt;stdbool.h&gt;
#include &lt;time.h&gt;

int n;

void bubblesort(int *buf)
{
    bool changed = true;
    for (int i = n; changed == true; i--) { /* will always move at least one element to its rightful place at the end, so can shorten the search by 1 each iteration */
        changed = false;

        for (int x = 0; x &lt; i-1; x++) {
            if (buf[x] &gt; buf[x+1]) {
                /* swap */
                int tmp = buf[x+1];
                buf[x+1] = buf[x];
                buf[x] = tmp;

                changed = true;
            }
        }
    }
}

int main(int argc, char *argv[])
{
    if (argc != 2) {
        fprintf(stderr, &quot;Usage: %s &lt;arraysize&gt;\n&quot;, argv[0]);
        return EXIT_FAILURE;
    }

    n = atoi(argv[1]);
    if (n &lt; 1) {
        fprintf(stderr, &quot;Invalid array size.\n&quot;);
        return EXIT_FAILURE;
    }

    int *buf = malloc(sizeof(int) * n);

    /* init buffer with random values */
    srand(time(NULL));
    for (int i = 0; i &lt; n; i++)
        buf[i] = rand() % n + 1;

    bubblesort(buf);

    return EXIT_SUCCESS;
}
```

The assembly language generated for `-O2` (from [godbolt.org][2]):

```none
bubblesort:
        mov     r9d, DWORD PTR n[rip]
        xor     edx, edx
        xor     r10d, r10d
.L2:
        lea     r8d, [r9-1]
        cmp     r8d, edx
        jle     .L13
.L5:
        movsx   rax, edx
        lea     rax, [rdi+rax*4]
.L4:
        mov     esi, DWORD PTR [rax]
        mov     ecx, DWORD PTR [rax+4]
        add     edx, 1
        cmp     esi, ecx
        jle     .L2
        mov     DWORD PTR [rax+4], esi
        mov     r10d, 1
        add     rax, 4
        mov     DWORD PTR [rax-4], ecx
        cmp     r8d, edx
        jg      .L4
        mov     r9d, r8d
        xor     edx, edx
        xor     r10d, r10d
        lea     r8d, [r9-1]
        cmp     r8d, edx
        jg      .L5
.L13:
        test    r10b, r10b
        jne     .L14
.L1:
        ret
.L14:
        lea     eax, [r9-2]
        cmp     r9d, 2
        jle     .L1
        mov     r9d, r8d
        xor     edx, edx
        mov     r8d, eax
        xor     r10d, r10d
        jmp     .L5
```

And the same for `-O3`:

```none
bubblesort:
        mov     r9d, DWORD PTR n[rip]
        xor     edx, edx
        xor     r10d, r10d
.L2:
        lea     r8d, [r9-1]
        cmp     r8d, edx
        jle     .L13
.L5:
        movsx   rax, edx
        lea     rcx, [rdi+rax*4]
.L4:
        movq    xmm0, QWORD PTR [rcx]
        add     edx, 1
        pshufd  xmm2, xmm0, 0xe5
        movd    esi, xmm0
        movd    eax, xmm2
        pshufd  xmm1, xmm0, 225
        cmp     esi, eax
        jle     .L2
        movq    QWORD PTR [rcx], xmm1
        mov     r10d, 1
        add     rcx, 4
        cmp     r8d, edx
        jg      .L4
        mov     r9d, r8d
        xor     edx, edx
        xor     r10d, r10d
        lea     r8d, [r9-1]
        cmp     r8d, edx
        jg      .L5
.L13:
        test    r10b, r10b
        jne     .L14
.L1:
        ret
.L14:
        lea     eax, [r9-2]
        cmp     r9d, 2
        jle     .L1
        mov     r9d, r8d
        xor     edx, edx
        mov     r8d, eax
        xor     r10d, r10d
        jmp     .L5
```

It seems like the only significant difference to me is the apparent attempt to use [SIMD][3], which *seems* like it should be a large improvement, but I also can&#39;t tell what on earth it&#39;s attempting with those `pshufd` instructions... is this just a failed attempt at SIMD? Or maybe the couple of extra instructions is just about edging out my instruction cache?

Timings were done on an AMD [Ryzen][4] 5 3600.

  [1]: https://en.wikipedia.org/wiki/Bubble_sort
  [2]: https://godbolt.org/z/5G5WzTrPf
  [3]: https://en.wikipedia.org/wiki/SIMD
  [4]: https://en.wikipedia.org/wiki/Ryzen




Bubble sort slower with -O3 than -O2 with GCC

I know that Numpy can use different backends like OpenBLAS or MKL. I have also read that MKL is heavily optimized for Intel, so usually people suggest to use OpenBLAS on AMD, right?

I use the following test code:
```python
import numpy as np

def testfunc(x):
    np.random.seed(x)
    X = np.random.randn(2000, 4000)
    np.linalg.eigh(X @ X.T)

%timeit testfunc(0)
```

I have tested this code using different CPUs:
- On **Intel Xeon E5-1650 v3**, this code performs in **0.7s** using **6 out of 12 cores**.
- On **AMD Ryzen 5 2600**, this code performs in **1.45s** using **all 12 cores**.
- On **AMD Ryzen Threadripper 3970X**, this code performs in **1.55s** using **all 64 cores**.

I am using the same Conda environment on all three systems. According to `np.show_config()`, the Intel system uses the MKL backend for Numpy (`libraries = [&#39;mkl_rt&#39;, &#39;pthread&#39;]`), whereas the AMD systems use OpenBLAS (`libraries = [&#39;openblas&#39;, &#39;openblas&#39;]`). The CPU core usage was determined by observing `top` in a Linux shell:

- For the **Intel Xeon E5-1650 v3** CPU (6 physical cores), it shows 12 cores (6 idling).
- For the **AMD Ryzen 5 2600** CPU (6 physical cores), it shows 12 cores (none idling).
- For the **AMD Ryzen Threadripper 3970X** CPU (32 physical cores), it shows 64 cores (none idling).

The above observations give rise to the following questions:

1. Is that normal, that linear algebra on up-to-date AMD CPUs using OpenBLAS is *that much slower* than on a six-year-old Intel Xeon? *(also addressed in Update 3)*
2. Judging by the observations of the CPU load, it looks like Numpy utilizes the multi-core environment in all three cases. How can it be that the Threadripper is even slower than the Ryzen 5, even though it has almost six times as many physical cores? *(also see Update 3)*
3. Is there anything that can be done to speed up the computations on the Threadripper? *(partially answered in Update 2)*

---

**Update 1:** The OpenBLAS version is 0.3.6. I read somewhere, that upgrading to a newer version might help, however, with OpenBLAS updated to 0.3.10, the performance for `testfunc` is still 1.55s on AMD Ryzen Threadripper 3970X.

---

**Update 2:** Using the MKL backend for Numpy in conjunction with the environment variable `MKL_DEBUG_CPU_TYPE=5` (as described [here][1]) reduces the run time for `testfunc` on AMD Ryzen Threadripper 3970X to only 0.52s, which is actually more or less satisfying. FTR, setting this variable via `~/.profile` did not work for me on Ubuntu 20.04. Also, setting the variable from within Jupyter did not work. So instead I put it into `~/.bashrc` which works now. Anyways, performing 35% faster than an old Intel Xeon, is this all we get, or can we get more out of it?

---

**Update 3:** I play around with the number of threads used by MKL/OpenBLAS:

[![run time by the number of threads and library][2]][2]

The run times are reported in seconds. The best result of each column is underlined. I used OpenBLAS 0.3.6 for this test. The conclusions from this test:
- **The single-core performance of the Threadripper using OpenBLAS is a bit better** than the single-core performance of the Xeon (11% faster), however, its single-core performance is even better when using MKL (34% faster).
- **The multi-core performance of the Threadripper using OpenBLAS is ridiculously worse** than the multi-core performance of the Xeon. What is going on here?
- **The Threadripper performs overall better than the Xeon**, when MKL is used (26% to 38% faster than Xeon). The overall best performance is achieved by the Threadripper using 16 threads and MKL (36% faster than Xeon).

---

**Update 4:** Just for clarification. No, I do not think that (a) [this][1] or (b) [that][3] answers this question. (a) suggests that *&quot;OpenBLAS does nearly as well as MKL&quot;*, which is a strong contradiction to the numbers I observed. According to my numbers, OpenBLAS performs ridiculously worse than MKL. The question is why. (a) and (b) both suggest using `MKL_DEBUG_CPU_TYPE=5` in conjunction with MKL to achieve maximum performance. This might be right, but it does neither explain *why* OpenBLAS is *that dead* slow. Neither it explains, why even with MKL and `MKL_DEBUG_CPU_TYPE=5` the **32-core Threadripper is only 36% faster than the six-year-old 6-core Xeon**.


  [1]: https://www.pugetsystems.com/labs/hpc/How-To-Use-MKL-with-AMD-Ryzen-and-Threadripper-CPU-s-Effectively-for-Python-Numpy-And-Other-Applications-1637/#TestsystemsAMDThreadripper3960x,Ryzen3900XandIntelXeon2175W
  [2]: https://i.stack.imgur.com/uVJV8.png
  [3]: https://stackoverflow.com/questions/63174453/when-you-have-an-amd-cpu-can-you-speed-up-code-that-uses-the-intel-mkl/63174454#63174454

Why is Numpy with Ryzen Threadripper so much slower than Xeon?

When talking about multi-threading, it often seems like threads are treated as equal - just the same as the main thread, but running next to it.

On some new processors, however, such as the [Apple &quot;M&quot; series][1] and the upcoming Intel [Alder Lake][2] series not all threads are equally as performant as these chips feature separate high-performance cores and high-efficiency, slower cores.

It’s not to say that there weren’t already things such as hyper-threading, but this seems to have a much larger performance implication.

Is there a way to query `std::thread`‘s properties and enforce on which cores they’ll run in C++?

  [1]: https://en.wikipedia.org/wiki/Apple_silicon#M_series
  [2]: https://en.wikipedia.org/wiki/Alder_Lake_(microprocessor)




How can I distinguish between high- and low-performance cores/threads in C++?

On my **Ubuntu 18.04**, I&#39;ve installed **VirtualBox 6.0** in order to have ***nested virtualization***. Virtualization is **enabled** in my bios.

However, when I open the settings of my (powered off) virtual machine and go to **System** -&gt; **Processor**, the option &quot;**Enable Nested VT-x/AMD-V**&quot; is greyed out and I cannot enable it.

[![enter image description here][1]][1]


  [1]: https://i.stack.imgur.com/RT2kA.png

Virtualbox enable nested vtx/amd-v greyed out

I am trying to figure out whether it is possible to run a Linux VM whose RAM is only backed by a single physical page.

To simulate this, I modified the nested page fault handler in KVM to remove
the present bit from all nested page table (NPT) entries,
except the one corresponding to the currently processed page fault.

While trying to start a Linux guest, I observed that assembly instructions that use memory operands, like
```
add [rbp+0x820DDA], ebp
```
lead to a page fault loop until I restore the present bit for the page containing the
instruction as well as for the page referenced in the operand (in this example `[rbp+0x820DDA]`).

I am wondering why this is the case. Shouldn&#39;t the CPU access the memory pages sequentially, i.e. first read the instruction and then access the memory operand?
Or does x86 require that the instruction page as well as all operand pages are accessible at the same time?

I am testing on AMD Zen 1.

Content Type	Original Author	Original Content on Stackoverflow
Question	Amol.Shaligram	View Question on Stackoverflow
Solution 1 - Windows	Samir Dangal	View Answer on Stackoverflow
Solution 2 - Windows	mrDev	View Answer on Stackoverflow

How to check if Intel Virtualization is enabled without going to BIOS in Windows 10

Windows Problem Overview

Windows Solutions

Solution 1 - Windows

Solution 2 - Windows

React - How to pass props to a component passed as prop

what is `open` keyword for fields in Kotlin?

Attributions