Configurazione delle pagine HugeTLB

Descrive come richiedere pagine HugeTLB con parametri di boot del kernel, impostazioni sysfs e procedure basate su NUMA.

È possibile configurare le pagine HugeTLB utilizzando i seguenti tipi di parametri:

Parametri di boot del kernel
Parametri di configurazione basati su file

Le sezioni seguenti descrivono i parametri in modo più dettagliato.

Parametri di avvio del kernel per le pagine HugeTLB

Le opzioni di boot del kernel consentono di specificare valori quali la dimensione e il numero di pagine da riservare nel pool del kernel. L'utilizzo dei parametri di boot del kernel è il metodo più affidabile per richiedere pagine di grandi dimensioni.

Nella tabella seguente vengono descritti i parametri di boot del kernel disponibili per l'impostazione della pagina HugeTLB.

Parametri della riga di comando di boot del kernel per la richiesta di pagine HugeTLB
Parametri	Scopo	Opzione valore accettato nell'architettura x86_64
`default_hugepagesz`	Definisce la dimensione predefinita delle pagine di grandi dimensioni persistenti configurate nel kernel in fase di boot.	`2M` (impostazione predefinita), `1G`
`hugepagesz` e `hugepages`	Il parametro di dimensione `hugepagesz` viene utilizzato con il parametro di quantità `hugepages` per riservare un pool di dimensioni e quantità di pagina specificate. Ad esempio, per richiedere un pool di 1500 pagine di dimensione 2 MB, le opzioni della riga di comando sono le seguenti: `hugepagesz=2M hugepages=1500` Se sono supportate più dimensioni di pagine di grandi dimensioni, la coppia "`hugepagesz=<size> hugepages=<qty>`" può essere specificata più volte, una volta per ogni dimensione della pagina. Ad esempio, è possibile utilizzare le seguenti opzioni della riga di comando per richiedere un pool di quattro pagine di 1 GB di dimensione e un secondo pool di 1500 pagine di 2 MB di dimensione: `hugepagesz=1G hugepages=4 hugepagesz=2M hugepages=1500`	`Hugepagesz`: `2M`, `1G` `hugepages`: `0` o versione successiva

Nota

In un sistema NUMA, le pagine riservate con le opzioni della riga di comando del kernel, come mostrato nella tabella precedente, sono divise equamente tra i nodi NUMA.

Se il requisito è di avere un numero diverso di pagine su ogni nodo, è possibile utilizzare i parametri HugeTLB basati su file nel file system sysfs. Vedere Parametri di configurazione basati su file per le pagine HugeTLB e Configurazione delle pagine HugeTLB mediante i parametri specifici dei nodi NUMA nelle prime fasi del processo di boot.

Parametri di configurazione basati su file per le pagine HugeTLB

I parametri di configurazione basati su file forniscono l'accesso runtime alle impostazioni di configurazione.

Nota

Oltre ad accedere alle impostazioni in fase di esecuzione, è anche possibile inizializzare i parametri all'inizio del processo di avvio, ad esempio creando uno script bash di avvio o impostando i parametri in uno script rc init locale.

È possibile configurare più istanze di ciascun parametro basato su file in un sistema. Ad esempio, in un sistema in grado di gestire sia 2 MB che 1 GB di dimensioni di pagina HugeTLB, possono esistere diverse impostazioni nr_hugepages. Questo parametro definisce il numero di pagine in un pool, tra cui:

File /sys/kernel/mm/hugepages/hugepages-2048kB/nr_hugepages per il numero di pagine nel pool di pagine da 2 MB.
File /sys/kernel/mm/hugepages/hugepages-1048576kB/nr_hugepages per il numero di pagine nel pool di pagine da 1 GB.

Nella tabella seguente vengono descritti i parametri di configurazione HugeTLB comunemente utilizzati e le istanze di file multiple che è possibile trovare per ciascun parametro.

Parametri HugeTLB basati su file comunemente utilizzati
Parametro	Scopo	Percorsi file per istanze diverse
`nr_hugepages`	Ogni istanza di `nr_hugepages` definisce il numero corrente di pagine di grandi dimensioni nel pool associato a tale istanza. Può essere modificato in runtime. Comando di esempio: `echo 20 \| sudo tee /proc/sys/vm/nr_hugepages` Il valore predefinito è `0`.	I formati del percorso file per le diverse istanze di `nr_hugepages` sono i seguenti: Posizione del file: `/proc/sys/vm/nr_hugepages` (presente su tutti i sistemi). Posizione del file: `/sys/kernel/mm/hugepages/hugepages-<SIZE>kB/nr_hugepages` (presente sui sistemi che supportano più di una dimensione di pagina enorme). Posizione del file: `/sys/devices/system/node/node{0,1,2...n}/hugepages/hugepages-<SIZE>kB/nr_hugepages` (presente solo sui sistemi NUMA). Utilizzare il formato del percorso specifico del nodo NUMA se è necessario richiedere il supporto di quantità diverse di pagine di dimensioni diverse su nodi NUMA specifici. Se si utilizza un altro formato di percorso (ad esempio, `/proc/sys/vm/nr_hugepages`) per richiedere pagine HugeTLB, le pagine vengono divise equamente tra i nodi NUMA.
`nr_overcommit_hugepages`	Ogni istanza di `nr_overcommit_hugepages` definisce il numero aggiuntivo di pagine di grandi dimensioni superiore alla quantità specificata da `nr_hugepages`. Può essere creato dal sistema in fase di esecuzione tramite sovraccarico della memoria. Man mano che queste enormi pagine aggiuntive diventano inutilizzate, vengono liberate e restituite al normale pool di pagine del kernel. Comando di esempio: `echo 20 \| sudo tee /proc/sys/vm/nr_overcommit_hugepages`	I formati del percorso file per le diverse istanze di `nr_overcommit_hugepages` sono i seguenti: Posizione del file `/proc/sys/vm/nr_overcommit_hugepages` (presente su tutti i sistemi). Posizione del file: `/sys/kernel/mm/hugepages/hugepages-<SIZE>kB/nr_overcommit_hugepages` (presente nei sistemi che supportano più di una dimensione di pagina enorme). Il parametro `nr_overcommit_hugepages` non è definito a livello di singolo nodo, pertanto non esiste alcun file specifico di nodo per questa impostazione.
`free_hugepages`	Parametro in sola lettura. Ogni istanza di `free_hugepages` restituisce il numero di pagine di grandi dimensioni nel pool di pagine associato che devono ancora essere allocate.	I formati del percorso file per le diverse istanze di `free_hugepages` sono i seguenti: Posizione del file: `/sys/kernel/mm/hugepages/hugepages-<SIZE>kB/free_hugepages` (presente sui sistemi che supportano più di una dimensione di pagina enorme). Posizione del file: `/sys/devices/system/node/node{0,1,2...n}/hugepages/hugepages-<SIZE>kB/ free_hugepages` (presente solo sui sistemi NUMA).
`surplus_hugepages`	Parametro in sola lettura. Ogni istanza di `surplus_hugepages` restituisce il numero di pagine di grandi dimensioni sottoposte a commit in eccesso dal pool di pagine associato.	I formati del percorso file per le diverse istanze di `surplus_hugepages` sono i seguenti: Posizione del file: `/sys/kernel/mm/hugepages/hugepages-<SIZE>kB/surplus_hugepages` (presente nei sistemi che supportano più di una dimensione di pagina enorme). Posizione del file: `/sys/devices/system/node/node{0,1,2...n}/hugepages/hugepages-<SIZE>kB/surplus_hugepages` (presente solo sui sistemi NUMA).

Le sezioni seguenti mostrano le diramazioni di file in cui vengono memorizzate diverse istanze dei parametri HugeTLB:

/proc/sys/vm

Tutti i sistemi che supportano pagine enormi statiche contengono file di parametri HugeTLB in /proc/sys/vm.

Nota

In molti sistemi, inclusi molti database server Oracle, il file system procfs è il set di parametri principale utilizzato.

Il parametro sysctl vm.nr_hugepages comunemente inizializzato negli script che richiedono pagine di grandi dimensioni scrive anche nel file procfs /proc/sys/vm/nr_hugepages.

Di seguito sono riportate le cartelle di esempio nella diramazione /proc/sys/vm.

    ├── ...
    ├── ...
    ├── nr_hugepages
    ├── ...
    ├── nr_overcommit_hugepages
    ├── ...
    ├── ...

/sys/kernel/mm/hugepages/

I sistemi che supportano più pool di dimensioni contengono file di parametri HugeTLB in cartelle specifiche per dimensioni in /sys/kernel/mm/hugepages/.

Di seguito sono riportate le cartelle di esempio nella diramazione /sys/kernel/mm/hugepages/.

└── hugepages-2048kB
    ├── free_hugepages
    ├── nr_hugepages
    ├── ...
    ├── nr_overcommit_hugepages
    ├── ...
    └── surplus_hugepages

└── hugepages-1048576kB
    ├── free_hugepages
    ├── nr_hugepages
    ├── ...
    ├── nr_overcommit_hugepages
    ├── ...
    └── surplus_hugepages

/sys/devices/system/node/

Solo i sistemi NUMA contengono file di parametri HugeTLB in /sys/devices/system/node/.

Di seguito sono riportate le cartelle di esempio nella diramazione /sys/devices/system/node.

      ├─  ...
      ├── node0
      │   ├── ...
      │   ├──hugepages
      │          hugepages-2048kB
      │              ├── free_hugepages
      │              ├── nr_hugepages
      │              └── surplus_hugepages
      │   
      │          hugepages-1048576kB
      │              ├── free_hugepages
      │              ├── nr_hugepages
      │              └── surplus_hugepages
      ├── node1
          ├── ...
          ├──hugepages
                 hugepages-2048kB
                     ├── free_hugepages
                     ├── nr_hugepages
                     └── surplus_hugepages
          
                 hugepages-1048576kB
                     ├── free_hugepages
                     ├── nr_hugepages
                     └── surplus_hugepages

Configurazione delle pagine HugeTLB mediante i parametri kernel in fase di boot

Utilizzare il comando grubby per configurare le opzioni della riga di comando del kernel utilizzate al momento del boot per impostare le pagine HugeTLB.

La procedura riportata di seguito mostra come impostare le opzioni predefinite della riga di comando del kernel nella configurazione di GRUB 2 per specificare due pool di pagine HugeTLB e una dimensione di pagina predefinita in un sistema che gestisce più dimensioni di pagina di grandi dimensioni. In questa procedura sono richiesti i seguenti elementi:

Una dimensione di pagina predefinita di 1 GB.
Un pool con quattro pagine HugeTLB di 1 GB di dimensione.
Un pool di 1500 pagine HugeTLB di 2 MB di dimensione.

Prima di iniziare la procedura riportata di seguito, assicurarsi di disporre dei privilegi di amministrazione necessari.

Per ulteriori informazioni sulla configurazione delle opzioni della riga di comando del kernel e di GRUB 2, vedere Managing Kernels and System Boot on Oracle Linux.

Utilizzare il comando grubby per aggiungere gli argomenti della riga di comando del kernel richiesti.
Ad esempio, specificare 1 GB di dimensione per il parametro di boot del kernel default_hugepagesz e 2 coppie di parametri "hugepagesz=<Size_num>G hugepages=Qty_num" per i due pool di pagine di grandi dimensioni.
```
sudo grubby --update-kernel=ALL --args="default_hugepagesz=1G hugepagesz=1G hugepages=4 hugepagesz=2M hugepages=1500"
```
Quando si esegue grubby con la parola chiave ALL per aggiornare il kernel, le modifiche si applicano a tutti i kernel e aggiornano anche il file di configurazione /etc/default/grub.
Verificare che la configurazione sia aggiornata.
```
sudo grubby --info ALL
```
Eseguire il reboot del sistema per rendere effettive le modifiche.

Verificare che la nuova configurazione sia attiva sul sistema.

cat /sys/kernel/mm/hugepages/hugepages-1048576kB/nr_hugepages
cat /sys/kernel/mm/hugepages/hugepages-2048kB/nr_hugepages

Configurazione delle pagine HugeTLB mediante i parametri specifici dei nodi NUMA nelle prime fasi del processo di boot

Fornisce un flusso di lavoro basato su systemd per riservare diverse allocazioni HugeTLB su nodi NUMA specifici durante l'avvio.

Il modo preciso per richiedere pagine enormi al momento dell'avvio dipende dalle esigenze del sistema. La procedura riportata di seguito fornisce alcune indicazioni ma non è esclusiva di altri approcci alla configurazione delle opzioni di boot.

Le pagine enormi richieste utilizzando i parametri di boot-time del kernel, come mostrato nell'esempio precedente, sono divise equamente tra i nodi NUMA.

Tuttavia, potrebbe essere necessario richiedere un numero diverso di pagine di grandi dimensioni per nodi specifici impostando i valori di configurazione in un percorso di file specifico del nodo. Il percorso del file viene definito come indicato di seguito.

/sys/devices/system/node/node{0,1,2...n}/hugepages/hugepages-<SIZE>kB/

La procedura seguente descrive come riservare 299 pagine di 2 MB di dimensione sul nodo 0 e 300 pagine di 2 MB di dimensione sul nodo 1 su un sistema NUMA. Questo approccio utilizza un servizio systemd personalizzato per eseguire uno script della shell dopo il boot, per impostare i parametri sysfs richiesti.

Prima di iniziare la procedura riportata di seguito, assicurarsi di disporre dei privilegi di amministrazione necessari per tutti i passi.

Per ulteriori informazioni sull'uso delle unità systemd, vedere Gestione del sistema con systemd.

Creare un file di script denominato hugetlb-reserve-pages.sh nella directory /usr/lib/systemd/ e aggiungere il contenuto seguente.

#!/bin/sh

nodes_path=/sys/devices/system/node/
if [ ! -d $nodes_path ]; then
    echo "ERROR: $nodes_path does not exist"
    exit 1
fi

#######################################################
#                                                     #
#     FUNCTION                                        #
#           reserve_pages <number_of_pages> <node_id> #
#                                                     #
####################################################### 

reserve_pages()
{
    echo $1 > $nodes_path/$2/hugepages/hugepages-2048kB/nr_hugepages
}

reserve_pages 299 node0    
reserve_pages 300 node1

Rendere eseguibile lo script:

sudo chmod +x /usr/lib/systemd/hugetlb-reserve-pages.sh

Creare un file di servizio denominato hugetlb-gigantic-pages.service nella directory /usr/lib/systemd/system/ e aggiungervi il contenuto seguente.

[Unit]
Description=HugeTLB Gigantic Pages Reservation
DefaultDependencies=no
Before=dev-hugepages.mount
ConditionPathExists=/sys/devices/system/node

[Service]
Type=oneshot
RemainAfterExit=yes
ExecStart=/usr/lib/systemd/hugetlb-reserve-pages.sh

[Install]
WantedBy=sysinit.target

Abilitare il file di servizio.

sudo systemctl enable hugetlb-gigantic-pages

Configurazione delle pagine HugeTLB per un nodo NUMA specifico in runtime

In alcuni casi, potrebbe essere necessario effettuare una richiesta per pagine di grandi dimensioni in runtime.

La procedura riportata di seguito mostra come richiedere 20 pagine HugeTLB di dimensioni 2048 kB per node2 in fase di esecuzione.

Prima di iniziare, assicurarsi di disporre dei privilegi di amministrazione necessari per tutti i passi. La procedura utilizza il comando numastat, disponibile nel pacchetto numactl. Potrebbe essere necessario installare questo pacchetto in anticipo.

Eseguire il comando numastat per visualizzare le statistiche di memoria relative ai nodi NUMA:

numastat -cm | egrep 'Node|Huge'| grep -v AnonHugePages

                 Node 0 Node 1 Node 2 Node 3  Total add
HugePages_Total       0      0      0      0      0
HugePages_Free        0      0      0      0      0
HugePages_Surp        0      0      0      0      0

Aggiungere il numero richiesto di pagine di grandi dimensioni di una dimensione specificata al nodo selezionato, ad esempio 20 pagine di dimensione di 2 MB sul nodo 2:
```
echo 20 | sudo tee /sys/devices/system/node/node2/hugepages/hugepages-2048kB/nr_hugepages
```

Eseguire di nuovo il comando numastat per assicurarsi che la richiesta sia riuscita e che la memoria richiesta (in questo esempio pagine da 20 x 2 MB = 40 MB) sia stata aggiunta a HugePages_Total per node2:

numastat -cm | egrep 'Node|Huge'| grep -v AnonHugePages

                 Node 0 Node 1 Node 2 Node 3  Total
HugePages_Total       0      0     40      0     40
HugePages_Free        0      0     40      0     40
HugePages_Surp        0      0      0      0      0

Documentazione dell'infrastruttura Oracle Cloud