I'm using Microsoft R Open on a GCE instance that has two vCPUs. Here are its specs.
$ lscpu
Architecture: x86_64
CPU op-mode(s): 32-bit, 64-bit
Byte Order: Little Endian
CPU(s): 2
On-line CPU(s) list: 0,1
Thread(s) per core: 2
Core(s) per socket: 1
Socket(s): 1
NUMA node(s): 1
Vendor ID: GenuineIntel
CPU family: 6
Model: 63
Model name: Intel(R) Xeon(R) CPU # 2.30GHz
Stepping: 0
CPU MHz: 2300.000
BogoMIPS: 4600.00
Hypervisor vendor: KVM
Virtualization type: full
L1d cache: 32K
L1i cache: 32K
L2 cache: 256K
L3 cache: 46080K
NUMA node0 CPU(s): 0,1
Flags: fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush
mmx fxsr sse sse2 ss ht syscall nx pdpe1gb rdtscp lm constant_tsc rep_good nopl xtopology nonstop_tsc
eagerfpu pni pclmulqdq ssse3 fma cx16 sse4_1 sse4_2 x2apic movbe popcnt aes xsave avx f16c rdrand hyp
ervisor lahf_lm abm fsgsbase tsc_adjust bmi1 avx2 smep bmi2 erms xsaveopt
Even though I have two cores, Microsoft R Open seems to recognize only one of them, so I'm not taking full advantage of my computing capacity. I can't set the numbers of threads manually either.
Microsoft R Open 3.3.2
The enhanced R distribution from Microsoft
Microsoft packages Copyright (C) 2016 Microsoft Corporation
Using the Intel MKL for parallel mathematical computing(using 1 cores).
Default CRAN mirror snapshot taken on 2016-11-01.
See: https://mran.microsoft.com/.
> getMKLthreads()
[1] 1
> setMKLthreads(2)
Number of threads at maximum: no change has been made.
Here's a graph showing CPU usage. It never uses more than 50% of CPU power.
So, what should I do so I can use all my cores with MRO?
you are running Xeon which is hyper threaded . You have 1 cpu with hyper threading,the os treats it as 2 cpus but there is only one physical cpu. MRO uses the physical cores only(without hyper threading)
You can use this:
library(doParallel)
no_cores <- detectCores() - 1
registerDoParallel(cores=no_cores)
It will one core less than the actual cores you have. It leaves one core for OS operations. Try it out.
Related
I am running a server at my workplace with specs as follows:
Architecture: x86_64
CPU op-mode(s): 32-bit, 64-bit
Byte Order: Little Endian
CPU(s): 56
On-line CPU(s) list: 0-55
Thread(s) per core: 2
Core(s) per socket: 14
Socket(s): 2
NUMA node(s): 2
Vendor ID: GenuineIntel
CPU family: 6
Model: 63
Model name: Intel(R) Xeon(R) CPU E5-2683 v3 # 2.00GHz
Stepping: 2
CPU MHz: 2000.000
BogoMIPS: 4004.58
Virtualization: VT-x
L1d cache: 32K
L1i cache: 32K
L2 cache: 256K
L3 cache: 35840K
NUMA node0 CPU(s): 0-13,28-41
NUMA node1 CPU(s): 14-27,42-55
With the OS information:
Transient hostname: some-server-gs
Icon name: computer-server
Chassis: server
Operating System: CentOS Linux 7 (Core)
Kernel: Linux 3.10.0-514.el7.x86_64
Architecture: x86-64
I'm starting with the "Parallel" package but is there any GUI based way to use parallel computing?
I just tried running the command "parallel" but it did not work!
Ubuntu 20.04 LTS. Note (unknown type) reported:
$ cpuid | less
CPU 0:
vendor_id = "GenuineIntel"
version information (1/eax):
processor type = primary processor (0)
family = 0x6 (6)
model = 0xe (14)
stepping id = 0xd (13)
extended family = 0x0 (0)
extended model = 0x9 (9)
(family synth) = 0x6 (6)
(model synth) = 0x9e (158)
(simple synth) = Intel Core (unknown type) (Kaby Lake / Coffee Lake) {Skylake}, 14nm
.
.
.
(uarch synth) = Intel Coffee Lake {Skylake}, 14nm
(synth) = Intel Xeon E-2200 (Coffee Lake R0) {Skylake}, 14nm
cat /proc/cpuinfo
processor : 0
vendor_id : GenuineIntel
cpu family : 6
model : 158
model name : Intel(R) Xeon(R) E-2278G CPU # 3.40GHz
stepping : 13
microcode : 0xea
cpu MHz : 3400.000
cache size : 16384 KB
physical id : 0
siblings : 16
core id : 0
cpu cores : 8
apicid : 0
initial apicid : 0
fpu : yes
fpu_exception : yes
cpuid level : 22
. . .
So what is this processor? Kaby? Coffee? or Skylake? I ask because I am doing PMU programming. I want to be sure to do the right thing depending on what the architecture is.
This is the http://www.etallen.com/cpuid.html version of the cpuid command, rather than the one that's part of the msr-tools package.
According to Intel's web site, "Intel(R) Xeon(R) E-2278G" is a Coffee Lake, as your cpuid shell command figured out from other CPUID info, perhaps including the brand string.
Specifically, according to wikichip, it's a Coffee Lake Refresh iteration of Coffee Lake E (the Xeon-badged versions of "client" cores), so Coffee Lake ER.
Being Coffee Lake means the IA cores are microarchitecturally identical to Skylake (and Kaby Lake), although it has a newer GPU and has memory controllers rated for higher speeds.
For the CPU cores, the improvement is just a refinement of the silicon process (14nm++).
Except maybe for some hardware fix for vulnerabilities like Meltdown, and L1TF or other related things. And maybe refinement of the Spectre mitigations. But not yet fixing the bug that required disabling the LSD (loop buffer) in microcode, or the JCC erratum, so both those performance problems are still self-inflicted by its microcode to ensure correctness even in corner cases.
The PMU hardware is AFAIK identical in SKL, KBL, and CFL, except perhaps(?) some errata being fixed. The event IDs are all the same, I assume.
Understanding command-line cpuid output:
version information (1/eax):
... family/model/stepping/...
(simple synth) = Intel Core (unknown type) (Kaby Lake / Coffee Lake) {Skylake}, 14nm
I'm guessing that this is saying that the family/model/stepping and extended-model/family fields don't distinguish between KBL and CFL (thus unknown type), but do imply one or the other. And {Skylake} is reminding you that KBL and CFL are both iterations of Skylake.
The "(unknown type)" is probably saying it doesn't know whether it's an i3/5/7/9 or Pentium or Celeron.
On my i7-6700k Skylake desktop, I get this. From cpuid version 20170122 from an old Arch Linux AUR install, which is still over a year after the CPU itself was released, which may be an older version than you have.
version information (1/eax):
processor type = primary processor (0)
family = Intel Pentium Pro/II/III/Celeron/Core/Core 2/Atom, AMD Athlon/Duron, Cyrix M2, VIA C3 (6)
model = 0xe (14)
stepping id = 0x3 (3)
extended family = 0x0 (0)
extended model = 0x5 (5)
(simple synth) = Intel Core i3-6000 / i5-6000 / i7-6000 / Pentium G4000 / Celeron G3900 / Xeon E3-1200 (Skylake), 14nm
So yeah, (simple synth) is probably what it was able to divine from just the things in that leaf, not the brand string.
From the latest version of the tool, version 20220224,
version information (1/eax):
processor type = primary processor (0)
family = 0x6 (6)
model = 0xe (14)
...
(family synth) = 0x6 (6)
(model synth) = 0x5e (94)
(simple synth) = Intel Core (unknown type) (Skylake-H R0) {Skylake}, 14nm
...
(uarch synth) = Intel Skylake {Skylake}, 14nm
(synth) = Intel Core i*-6000 (Skylake-H R0) {Skylake}, 14nm
So the (unknown type) seems perfectly normal, just a consequence of Intel not varying the family, model, stepping numbers across i3/5/7.
The version of cpuid in your Ubuntu 20.04 LTS does seem to know about Coffee Lake, though. Perhaps not new enough to know about Coffee Lake Refresh, since yours said "R0" for yours, same as "R0" for my Skylake (which is not a "refresh"; there weren't new iterations of CPUs released as Skylake. They moved straight on to Kaby Lake after SKL.)
Anyway, your version of cpuid does eventually get to a correct and fully accurate description of your CPU, synthesized from various pieces of information.
(synth) = Intel Xeon E-2200 (Coffee Lake R0) {Skylake}, 14nm
I'm not sure exactly what cpuid means by R0. Perhaps "revision 0", which would make sense if it didn't know about "Coffee Lake Refresh". I wonder if a newer cpuid would report R1 or spell out "Refresh"?
It is indeed an E-22xx series Xeon of the Coffee Lake family. The CPU cores are basically identical to Skylake, and it's built in a 14nm(++) process. IDK if Intel tweaked anything at all inside the cores between CFL and CFL-refresh, so for programming it you have all the info you need.
Other instances of "R" show up in CPUID output that mean "registered trademark" like in "Intel(R) Xeon(R)" in the brand string Intel(R) Xeon(R) E-2278G CPU # 3.40GHz that Linux pulls directly out of the CPU via the EAX=0017h leaf of the CPUID machine instruction with different ECX inputs. But I think the R0 is probably being used to mean "first iteration" (0th refresh?), since it's not just copying strings like "Xeon(R)".
My server cpu is Intel(R) Xeon(R) Silver 4214 CPU # 2.20GHz The detail
I wonder why this CPU support TEE but don't support Intel SGX? whta's the point? is there any way I can install SGX by myself or run SGX program on this server?
Your CPU supports TXT (Trusted Execution Technology), not TEE (Trusted execution environment).
TXT is a different technology. You can read it up here.
I'm new to NATS, I first bench the NATS with nats-bench
quanlm#quanlm2:~/go/src/github.com/nats-io/nats.go/examples/nats-bench$ go run main.go -np 1 -n 100000000 -ms 1600000 -csv test foo
Starting benchmark [msgs=100000000, msgsize=1600000, pubs=1, subs=0]
Pub stats: 20,848,474 msgs/sec ~ 30.34 TB/sec
Saved metric data in csv file test
My computer setup:
"Intel(R) Xeon(R) CPU E5-2630 v4 # 2.20GHz CPU(s): 16
On-line CPU(s) list: 0-15
Thread(s) per core: 1
Core(s) per socket: 1
Socket(s): 16
CPU MHz: 2199.996"
Memory: 24GB
SSD
I have no idea how nat-bench work to reach that 30.34 TB/sec
Is this just a bug or I did somethings wrong ?
Btw: what does msgsize count in: bits/byte ?
Sorry for the delay. You are publishing 100 million messages, each of 1600000 bytes (about 1.5 MB). The bench utility reports that it was able to send 20,848,474 messages per second, and since one message is 1600000 bytes, that is: 20,848,474 * 1600000 = 33357558400000 bytes per second, which is about 30.34 TB per second.
Do you know if there is a UNIX command that will tell me what the CPU configuration for my Sun OS UNIX machine is? I am also trying to determine the memory configuration. Is there a UNIX command that will tell me that?
There is no standard Unix command, AFAIK. I haven't used Sun OS, but on Linux, you can use this:
cat /proc/cpuinfo
Sorry that it is Linux, not Sun OS. There is probably something similar though for Sun OS.
The nproc command shows the number of processing units available:
$ nproc
Sample outputs: 4
lscpu gathers CPU architecture information form /proc/cpuinfon in human-read-able format:
$ lscpu
Sample outputs:
Architecture: x86_64
CPU op-mode(s): 32-bit, 64-bit
Byte Order: Little Endian
CPU(s): 8
On-line CPU(s) list: 0-7
Thread(s) per core: 1
Core(s) per socket: 4
CPU socket(s): 2
NUMA node(s): 1
Vendor ID: GenuineIntel
CPU family: 6
Model: 15
Stepping: 7
CPU MHz: 1866.669
BogoMIPS: 3732.83
Virtualization: VT-x
L1d cache: 32K
L1i cache: 32K
L2 cache: 4096K
NUMA node0 CPU(s): 0-7
Try psrinfo to find the processor type and the number of physical processors installed on the system.
Firstly, it probably depends which version of Solaris you're running, but also what hardware you have.
On SPARC at least, you have psrinfo to show you processor information, which run on its own will show you the number of CPUs the machine sees. psrinfo -p shows you the number of physical processors installed. From that you can deduce the number of threads/cores per physical processors.
prtdiag will display a fair bit of info about the hardware in your machine. It looks like on a V240 you do get memory channel info from prtdiag, but you don't on a T2000. I guess that's an architecture issue between UltraSPARC IIIi and UltraSPARC T1.
I think you can use prtdiag or prtconf on many UNIXs
My favorite is to look at the boot messages. If it's been recently booted try running /etc/dmesg. Otherwise find the boot messages, logged in /var/adm or some place in /var.