Localizando os números de ID da CPU para usar com conjuntos de cpu

Question

O cara do cpuset não parece listar claramente como descobrir quais números mapeiam para quais unidades de processamento. Minha máquina atual tem dois Intel Xeon E5645 s, cada um com 6 núcleos e hyperthreading habilitado, então eu tenho 24 unidades de processamento totais às quais posso me referir com cpusets. Meus desafios são 1) determinar quais números de identificação de cpuset mapeiam para qual processador 2) determinar quais números de ID de cpuset estão emparelhados (por exemplo, irmãos em um núcleo)

Os números que lscpu geram os mesmos identificadores que eu deveria usar para se referir a processadores cpu set? Se assim for, parece que os números são alternados aqui, e isso responde (1) com "todos são um processador, as probabilidades são o outro processador", mas não tenho certeza se estou lendo corretamente.

$ lscpu
Architecture:          x86_64
CPU op-mode(s):        32-bit, 64-bit
Byte Order:            Little Endian
CPU(s):                24
On-line CPU(s) list:   0-23
Thread(s) per core:    2
Core(s) per socket:    6
Socket(s):             2
NUMA node(s):          2
Vendor ID:             GenuineIntel
CPU family:            6
Model:                 44
Stepping:              2
CPU MHz:               2393.964
BogoMIPS:              4788.01
Virtualization:        VT-x
L1d cache:             32K
L1i cache:             32K
L2 cache:              256K
L3 cache:              12288K
NUMA node0 CPU(s):     0,2,4,6,8,10,12,14,16,18,20,22
NUMA node1 CPU(s):     1,3,5,7,9,11,13,15,17,19,21,23

lstopo do pacote hwloc parece me mostrar a resposta para (2), e se eu estiver lendo a página man corretamente, os P#... bits são o identificador "usado pelo sistema operacional", que leva Eu acredito que estes são os que eu preciso passar para conjuntos de CPU. Portanto, limitar um processo aos processadores 0 e 12 seria permitir o uso de dois encadeamentos no mesmo núcleo, enquanto a limitação para os cpus 0 e 2 seria de dois encadeamentos em dois núcleos diferentes. Isso parece correto?

$ lstopo
Machine (35GB)
  NUMANode L#0 (P#0 18GB) + Socket L#0 + L3 L#0 (12MB)
    L2 L#0 (256KB) + L1d L#0 (32KB) + L1i L#0 (32KB) + Core L#0
      PU L#0 (P#0)
      PU L#1 (P#12)
    L2 L#1 (256KB) + L1d L#1 (32KB) + L1i L#1 (32KB) + Core L#1
      PU L#2 (P#2)
      PU L#3 (P#14)
    L2 L#2 (256KB) + L1d L#2 (32KB) + L1i L#2 (32KB) + Core L#2
      PU L#4 (P#4)
      PU L#5 (P#16)
    L2 L#3 (256KB) + L1d L#3 (32KB) + L1i L#3 (32KB) + Core L#3
      PU L#6 (P#6)
      PU L#7 (P#18)
    L2 L#4 (256KB) + L1d L#4 (32KB) + L1i L#4 (32KB) + Core L#4
      PU L#8 (P#8)
      PU L#9 (P#20)
    L2 L#5 (256KB) + L1d L#5 (32KB) + L1i L#5 (32KB) + Core L#5
      PU L#10 (P#10)
      PU L#11 (P#22)
  NUMANode L#1 (P#1 18GB) + Socket L#1 + L3 L#1 (12MB)
    L2 L#6 (256KB) + L1d L#6 (32KB) + L1i L#6 (32KB) + Core L#6
      PU L#12 (P#1)
      PU L#13 (P#13)
    L2 L#7 (256KB) + L1d L#7 (32KB) + L1i L#7 (32KB) + Core L#7
      PU L#14 (P#3)
      PU L#15 (P#15)
    L2 L#8 (256KB) + L1d L#8 (32KB) + L1i L#8 (32KB) + Core L#8
      PU L#16 (P#5)
      PU L#17 (P#17)
    L2 L#9 (256KB) + L1d L#9 (32KB) + L1i L#9 (32KB) + Core L#9
      PU L#18 (P#7)
      PU L#19 (P#19)
    L2 L#10 (256KB) + L1d L#10 (32KB) + L1i L#10 (32KB) + Core L#10
      PU L#20 (P#9)
      PU L#21 (P#21)
    L2 L#11 (256KB) + L1d L#11 (32KB) + L1i L#11 (32KB) + Core L#11
      PU L#22 (P#11)
      PU L#23 (P#23)
  HostBridge L#0
    PCIBridge
      PCI 14e4:163a
        Net L#0 "eth0"
      PCI 14e4:163a
        Net L#1 "eth1"
    PCIBridge
      PCI 102b:0532
    PCI 8086:2921
      Block L#2 "sda"
    PCI 8086:2926

    

Answer 1

use

cat /proc/cpuinfo

lá você terá cada hyperthread listado assim:

processor       : 0
physical id     : 0
core id         : 1

"processador" representa o "processador lógico", o que é apresentado ao sistema operacional como um processador. Se você tiver hyper threading ligado, você verá dois "processadores lógicos" por núcleo. O "ID físico" será o processador que você pode tocar (você tem dois deles).

Aqui está uma listagem do meu sistema com 1 processador de quatro núcleos com hyperthreading:

# cat /proc/cpuinfo|egrep "processor|core id|physical id"
processor       : 0
physical id     : 0
core id         : 0
processor       : 1
physical id     : 0
core id         : 1
processor       : 2
physical id     : 0
core id         : 2
processor       : 3
physical id     : 0
core id         : 3
processor       : 4
physical id     : 0
core id         : 0
processor       : 5
physical id     : 0
core id         : 1
processor       : 6
physical id     : 0
core id         : 2
processor       : 7
physical id     : 0
core id         : 3

    

Answer 2

lstopo --cpuset

Irá lhe dizer quais cpusets você deve usar para incluir cada processador lógico no formato da máscara.

Você pode converter isso no formato da lista de processadores para verificar a correspondência dos números do processador.

Ou se você é como eu e é preguiçoso, você pode fazer algo como

taskset 0x00800000 grep -i Cpus_allowed /proc/self/status

E você terá uma saída como

Cpus_allowed: 000,00800000
Cpus_allowed_list: 23

Que quando eu uso lstopo --cpuset em minha máquina de teste corresponde a

PU L#46 (P#23) cpuset=0x00800000

Portanto, você deve usar o número em (P # nn) quando estiver definindo um cpuset usando o formato de lista.