O Google usa tecnologia de IA na tradução de conteúdos para seu idioma de preferência. As traduções com IA podem ter erros.

Trabalhar com o Onload

Nesta página, descrevemos como usar o Onload com instâncias do Compute Engine U4.

Sobre o Onload

Onload é uma pilha de rede de alta performance para aplicativos sensíveis à latência que exigem latência ultrabaixa, instabilidade mínima e performance consistente. O Onload oferece uma implementação de TCP/IP que ignora o kernel do sistema operacional e é executada diretamente no espaço do usuário, permitindo que os aplicativos usem APIs de soquete BSD padrão.

O uso do Onload com a solução ULL inclui suporte para o seguinte:

Direcionamento de fluxo: é possível ignorar o hash de escalonamento do lado de recebimento (RSS, na sigla em inglês) padrão direcionando fluxos de tráfego específicos diretamente para uma fila de recebimento (RX, na sigla em inglês) designada. O direcionamento de fluxo de três tuplas é compatível (protocolo, endereço IP de destino, porta de destino).

Antes de começar

Antes de trabalhar com o Onload em instâncias do Compute Engine U4, você precisa atender aos seguintes requisitos.

Criar uma instância U4

Se ainda não fez isso, crie uma instância do Compute Engine U4 usando um dos procedimentos a seguir, que incluem a configuração necessária para o Onload:

Para criar uma instância bare metal U4P ou U4C, consulte Criar instâncias do Compute Engine ULL.
Para criar uma instância de máquina virtual (VM) U4S, consulte Criar instâncias do Compute Engine não ULL para cargas de trabalho auxiliares.

Conectar-se à instância usando SSH

Se ainda não fez isso, conecte-se à instância usando SSH.

Mudar para o usuário raiz

Os comandos e scripts nos procedimentos a seguir modificam as configurações no nível do sistema, os parâmetros do kernel e as interfaces de rede. Para executá-los com sucesso, é necessário executá-los como usuário raiz. É possível mudar para um shell raiz executão sudo su, ou adicionar sudo antes de executar comandos conforme necessário.

Configurar o Onload

Esta seção descreve as etapas necessárias para configurar o Onload em uma instância U4.

Instalar dependências

Se você estiver usando o Rocky Linux, ative o repositório do CodeReady Builder (CRB). Se você estiver usando o Red Hat Enterprise Linux (RHEL), pule esta etapa.
```
dnf -y config-manager --enable crb
```

Instale as dependências necessárias para o Onload:

dnf -y install git clang \
   python3-setuptools \
   linuxptp \
   libcap-devel libbpf-devel libxdp-devel

Extrair a origem do Onload

Para extrair o repositório onload com as mudanças necessárias, execute os seguintes comandos:

umask 0022
mkdir -p /usr/src/

git clone https://github.com/Xilinx-CNS/onload /usr/src/onload

# 9.2.0.43 / 9.2.1, origin/v9_2 as of May 18, 2026
git -C /usr/src/onload checkout origin/v9_2

# Pull Google-specific Onload changes not yet merged as of v9_2
curl -L https://github.com/Xilinx-CNS/onload/pull/279.patch | git -C /usr/src/onload am -3
curl -L https://github.com/Xilinx-CNS/onload/pull/282.patch | git -C /usr/src/onload am -3
curl -L https://github.com/Xilinx-CNS/onload/pull/325.patch | git -C /usr/src/onload am -3
curl -L https://github.com/Xilinx-CNS/onload/pull/327.patch | git -C /usr/src/onload am -3

Criar o Onload

Para criar o Onload, execute os seguintes comandos:

cd /usr/src/onload
USEONLOADEXT=1 ./scripts/onload_install --no-sfc

pushd ./src/tools/bpf_link_helper
clang xdp_onload_prepare.c  -lbpf -o xdp_onload_prepare
clang -target bpf -O2 -g -c xdp_tstamp.c -o ./xdp_tstamp.o
popd

Desativar o rastreamento de ramificação indireta (IBT)

O IBT precisa ser desativado para usar o Onload, conforme descrito em Incompatibilidade do rastreamento de ramificação indireta (IBT) .

Para desativar o IBT, execute os seguintes comandos:

grubby --args="ibt=off" --update-kernel=ALL
reboot

Carregar o Onload

Esta seção descreve como carregar o Onload na sua instância.

Carregar o Onload em uma instância U4P ou U4C

Para carregar o Onload em uma instância bare metal U4P ou U4C, use o script a seguir.

IFNAMES=($( find /sys/class/net -type l -not -lname '*virtual*' -printf '%l %f\n' | sort | awk '{print $2}'))

for IFNAME in "${IFNAMES[@]}"; do
  ethtool -L "${IFNAME}" rx 16 tx 16
  ethtool -G "${IFNAME}" rx 1024 rx-buf-len 2048
  ethtool -K "${IFNAME}" ntuple on
  echo 0 > "/sys/class/net/${IFNAME}/threaded"
  /usr/src/onload/src/tools/bpf_link_helper/xdp_onload_prepare \
    "${IFNAME}" /usr/src/onload/src/tools/bpf_link_helper/xdp_tstamp.o
done

setenforce 0
numactl --cpunodebind=0,2 onload_tool reload --onload-only
for IFNAME in "${IFNAMES[@]}"; do
  echo "${IFNAME}" 16 > /sys/module/sfc_resource/afxdp/register
  until [[ $(cat "/sys/class/net/${IFNAME}/carrier") == 1 ]]; do
    sleep 1
  done
  hwstamp_ctl -i "${IFNAME}" -r 1
done

echo 1 > /sys/module/sfc_resource/parameters/enable_af_xdp_flow_filters
echo 256 > /sys/module/onload/parameters/xdp_headroom
echo -1 > /sys/module/onload/parameters/inject_kernel_gid

Carregar o Onload em uma instância U4S

Para carregar o Onload em uma instância de VM U4S, use o script a seguir.

IFNAME=NIC_NAME
ALLOCATED_QUEUES=ALLOCATED_QUEUES

ethtool -L "$IFNAME" rx "${ALLOCATED_QUEUES}" tx "${ALLOCATED_QUEUES}"
ethtool -G "$IFNAME" rx 1024 rx-buf-len 2048
ethtool -K "$IFNAME" ntuple on
echo 0 > "/sys/class/net/${IFNAME}/threaded"
/usr/src/onload/src/tools/bpf_link_helper/xdp_onload_prepare "$IFNAME" \
  /usr/src/onload/src/tools/bpf_link_helper/xdp_tstamp.o

setenforce 0
numactl --cpunodebind=0 onload_tool reload --onload-only

echo "${IFNAME} ${ALLOCATED_QUEUES}" | tee /sys/module/sfc_resource/afxdp/register
until [[ $(cat "/sys/class/net/${IFNAME}/carrier") == 1 ]]; do
    sleep 1
done
hwstamp_ctl -i "$IFNAME" -r 1

echo 1 > /sys/module/sfc_resource/parameters/enable_af_xdp_flow_filters
echo 256 > /sys/module/onload/parameters/xdp_headroom
echo -1 > /sys/module/onload/parameters/inject_kernel_gid

Substitua:

NIC_NAME: o nome do SO da interface de rede, como enp22s0f0.
ALLOCATED_QUEUES: o número de filas de recebimento (RX) e transmissão (TX) a serem alocadas para o Onload na interface de rede. Defina esse valor como metade do número total de filas RX ou TX atribuídas à vNIC.

Para instâncias U4S, a contagem total de filas (para filas RX ou TX, respectivamente) é igual a num_vcpus / num_vnics, até um máximo de 16 filas por vNIC. Por exemplo, se a vNIC tiver 4 filas TX totais, defina esse valor como 2. Se a vNIC tiver 16 filas TX totais, defina esse valor como 8.

Para mais informações sobre a alocação de filas padrão, consulte Filas de recebimento e transmissão.

Configurar flags do Onload

Para otimizar a performance e ajudar a reduzir a latência, use o conjunto de variáveis de ambiente e flags a seguir ao executar seus aplicativos com o Onload. Esta seção inclui configurações recomendadas que podem ser ajustadas conforme necessário para seus aplicativos.

É necessário especificar esses parâmetros antes dos comandos do aplicativo. Por exemplo, para executar um aplicativo com essas configurações, use o seguinte formato:

env EF_NO_FAIL=0 \
  EF_POLL_USEC=100000 \
  EF_RX_TIMESTAMPING=3 \
  EF_MAX_ENDPOINTS=1048576 \
  EF_WODA_SINGLE_INTERFACE=1 \
  EF_UL_EPOLL=3 \
  EF_USE_HUGE_PAGES=0 \
  EF_EPOLL_CTL_HANDOFF=0 \
  EF_FDS_MT_SAFE=0 \
  EF_NONAGLE_INFLIGHT_MAX=-1 \
  EF_RXQ_SIZE=4096 \
  EF_TCP_RCVBUF_ESTABLISHED_DEFAULT=65536 \
  EF_MAX_PACKETS=65536 \
  EF_PREFAULT_PACKETS=65536 \
  EF_EVS_PER_POLL=256 \
  onload -v --profile=latency APPLICATION_COMMAND

Descarregar o Onload

Para descarregar o Onload, use o script a seguir.

IFNAMES=($( find /sys/class/net -type l -not -lname '*virtual*' -printf '%l %f\n' | sort | awk '{print $2}'))

for IFNAME in "${IFNAMES[@]}"; do
  rm -f "/sys/fs/bpf/onload_xdp_xsk_${IFNAME}"
done

onload_tool unload --onload-only

for IFNAME in "${IFNAMES[@]}"; do
  # (optional) Disable threaded busypolling in case it's up. See busypolling
  # section
  echo 0 > "/sys/class/net/${IFNAME}/threaded"

  ip link set dev "${IFNAME}" xdp off
done

Configurar um serviço `systemd` que inicia o Onload automaticamente

Para iniciar o Onload automaticamente quando a instância for inicializada, registre-o como um systemd serviço. Crie um arquivo de serviço usando o seguinte modelo:

[Unit]
Description=ULL Solution -- Loading & instance tuning for Onload
After=network-online.target
After=google-guest-agent-manager.service google-guest-agent.service
Before=multi-user.target
Before=sshd.service

[Service]
Type=oneshot
RemainAfterExit=yes
ExecStart=START_SCRIPT_PATH
ExecStartPost=OPTIMIZATION_SCRIPT_PATH
ExecStop=STOP_SCRIPT_PATH

[Install]
WantedBy=multi-user.target

Substitua:

START_SCRIPT_PATH: o caminho para o script que inicia o Onload, como um dos scripts em Carregar o Onload.
OPTIMIZATION_SCRIPT_PATH: o caminho para o script opcional que aplica configurações de otimização. Se quiser, crie um script que inclua suas otimizações de performance e inclua o aqui. Caso contrário, remova a linha que inclui essa variável.
STOP_SCRIPT_PATH: o caminho para o script que interrompe o Onload, como o script em Descarregar o Onload.

Configurar a pesquisa ocupada

Esta seção fornece exemplos de como configurar a pesquisa ocupada na sua instância.

A pesquisa ocupada verifica continuamente novos pacotes de rede em vez de esperar interrupções do dispositivo, o que ajuda a reduzir a latência e a instabilidade. Para mais informações sobre a pesquisa ocupada, consulte Pesquisa ocupada na documentação do kernel do Linux.

Receber a fila RX que uma pilha do Onload está usando

Para receber a fila RX que uma pilha do Onload está usando, faça o seguinte:

Receba o ID da pilha do Onload executando onload_stackdump:
```
onload_stackdump
```

Como o ID da pilha do Onload e o ID da fila NAPI nem sempre correspondem, use o script a seguir para receber o nome da interface, o índice e o ID da fila correspondentes de um ID de pilha.

ONLOAD_STACK=ONLOAD_STACK_ID

INTF_HWPORT_MAP=($(onload_stackdump "${ONLOAD_STACK}" netif_extra | grep -oP "intf_i_to_hwport=\K.*$" | tr ',' '\n'))
HWPORT_IFINDEX_MAP=($(onload_stackdump "${ONLOAD_STACK}" hwport_to_base_ifindex | grep -oP "\d+$"))
while read -r INTF_ID QUEUE_ID; do
 HW_PORT="${INTF_HWPORT_MAP[INTF_ID]}"
 IFINDEX="${HWPORT_IFINDEX_MAP[HW_PORT]}"
 IFNAME=$(ip -j link | jq -r ".[] | select(.ifindex == ${IFINDEX}) | .ifname")
 echo "ifname=${IFNAME} ifindex=${IFINDEX} queue_id=${QUEUE_ID}"
done < <(onload_stackdump "${ONLOAD_STACK}" netif | grep -oP "((intf|vi)=)\K\d+" | xargs -n 2)

Substitua ONLOAD_STACK_ID pelo ID da pilha para a qual você quer ativar ou desativar a pesquisa ocupada.

Grave os valores a serem usados ao ativar ou desativar a pesquisa ocupada nas seções a seguir.

Ativar a pesquisa ocupada em uma fila RX

Esta seção fornece um exemplo de como ativar a pesquisa ocupada em uma fila RX específica que uma pilha do Onload está usando.

Execute o script bash a seguir no terminal. A função enable_single_queue faz o seguinte:

Recebe o napi_id que corresponde a uma fila RX usando o netlink (ynl)
Define a propriedade threaded: busy-poll no napi_id
Recebe o kthread_pid da linha de execução que está pesquisando o napi_id
Usa taskset para vincular o kthread_pid a uma CPU específica

readonly NETDEV_YAML=${NETDEV_YAML:-"/usr/share/ynl/specs/netdev.yaml"}

call_ynl() {
  ynl --spec "${NETDEV_YAML}" "$@"
}

enable_single_queue() {
  local -r interface="$1"
  local -r ifindex=$(cat "/sys/class/net/${interface}/ifindex")
  local -r q_id="$2"
  local -r cpu="$3"

  local napi_id
  napi_id=$(call_ynl --output-json --do queue-get \
    --json "{\"ifindex\": ${ifindex}, \"id\": ${q_id}, \"type\": \"rx\"}" | \
    jq -r '."napi-id"')

  if [[ -z "${napi_id}" || "${napi_id}" == "null" ]]; then
    echo "Error: No napi_id found for queue ${q_id} on interface ${interface}" >&2
    exit 1
  fi

  echo "Enabling busypolling for queue ${q_id} (NAPI ${napi_id}) on CPU ${cpu}"
  call_ynl --do napi-set --json "{\"id\": \"${napi_id}\", \"threaded\": \"busy-poll\"}" >/dev/null

  local napi_kthread_pid
  napi_kthread_pid=$(call_ynl --do napi-get --output-json \
    --json "{\"id\": \"${napi_id}\"}" | jq -r '."pid" // empty')

  if [[ -z "${napi_kthread_pid}" ]]; then
    echo "Error: Could not get PID for NAPI ${napi_id}" >&2
    exit 1
  fi

  taskset -pc "${cpu}" "${napi_kthread_pid}" >/dev/null
}

Execute o comando a seguir para invocar a função enable_single_queue:
```
enable_single_queue NIC_NAME QUEUE_ID CPU_ID
```
Substitua:
- NIC_NAME: o nome do SO da interface de rede, como ens8f0.
- QUEUE_ID: o ID da fila que você recebeu anteriormente.
- CPU_ID: o ID da CPU em que a linha de execução de pesquisa ocupada será executada, como 5.
Planeje eventos de recriação de linhas de execução que possam afetar a configuração de pesquisa ocupada.

Planejar eventos de recriação de linhas de execução

Quando o kernel recria uma linha de execução, as configurações associadas não são mantidas, como a máscara de afinidade da CPU e a política de programação. Eventos como os seguintes fazem com que o kernel recrie uma linha de execução que está pesquisando o NAPI:

Flaps/redefinições de link
Anexos de programas XDP (por exemplo, ao executar os scripts para carregar o Onload ou anexar programas XDP personalizados)
Mudanças de parâmetros de anel (ethtool -G)
Mudanças na contagem de filas (ethtool -L)

Para evitar problemas, evite tarefas que causem eventos de recriação de linhas de execução durante as operações normais.

Para manter a configuração de pesquisa ocupada após a recriação de uma linha de execução, é necessário receber o novo ID do processo (PID) da linha de execução e vinculá-lo novamente à CPU. Para fazer isso, execute a enable_single_queue função novamente.

Desativar a pesquisa ocupada em uma fila RX

Esta seção fornece um exemplo de como desativar a pesquisa ocupada em uma fila RX específica que uma pilha do Onload está usando.

Receba a fila RX que uma pilha do Onload está usando executando onload_stackdump:
```
onload_stackdump
```

Execute o script bash a seguir no terminal. A função disable_single_queue faz o seguinte:

Recebe o napi_id que corresponde a uma fila RX usando o netlink (ynl)
Define a propriedade encadeada do napi_id como disabled

disable_single_queue() {
  local -r interface="$1"
  local -r ifindex=$(cat "/sys/class/net/${interface}/ifindex")
  local -r q_id="$2"

  local napi_id
  napi_id=$(call_ynl --output-json --do queue-get \
    --json "{\"ifindex\": ${ifindex}, \"id\": ${q_id}, \"type\": \"rx\"}" | \
    jq -r '."napi-id"')

  if [[ -z "${napi_id}" || "${napi_id}" == "null" ]]; then
    echo "Error: No napi_id found for queue ${q_id} on interface ${interface}" >&2
    exit 1
  fi

  echo "Disabling busypolling for queue ${q_id} (NAPI ${napi_id})"
  call_ynl --do napi-set --json "{\"id\": \"${napi_id}\", \"threaded\": \"disabled\"}" >/dev/null
}

Execute o comando a seguir para invocar a função disable_single_queue:
```
disable_single_queue NIC_NAME QUEUE_ID
```
Substitua:
- NIC_NAME: o nome do SO da interface de rede, como ens8f0.
- QUEUE_ID: o ID da fila que você recebeu anteriormente.

Receber o status de pesquisa ocupada de uma fila

Para verificar o status NAPI de uma fila e saber se ela está pesquisando, use os seguintes comandos:

IFNAME=NIC_NAME
QUEUE_ID=QUEUE_ID
QUEUE_TYPE=QUEUE_TYPE

IFINDEX=$(cat "/sys/class/net/${IFNAME}/ifindex")
NAPI_ID=$(ynl --spec /usr/share/ynl/specs/netdev.yaml \
  --output-json --do queue-get \
  --json '{"ifindex": '${IFINDEX}', "id": '${QUEUE_ID}', "type": "'${QUEUE_TYPE}'"}' | \
  jq '."napi-id"')
ynl --spec /usr/share/ynl/specs/netdev.yaml \
  --output-json --do napi-get \
  --json '{"id": '${NAPI_ID}'}' | jq -r '"status: \(.threaded)"'

Substitua:

NIC_NAME: o nome do SO da interface de rede, como ens8f0.
QUEUE_ID: o ID da fila que você quer verificar.
QUEUE_TYPE: rx ou tx.

Otimizar o desempenho

Esta seção fornece orientações gerais para otimizar a performance das instâncias bare metal U4 (U4P e U4C). Ajuste os exemplos nesta orientação conforme necessário para suas cargas de trabalho.

Analisar a topologia NUMA para instâncias bare metal U4

A tabela a seguir descreve quais interfaces de rede usam quais nós NUMA para instâncias bare metal U4:

NIC (Google Cloud nome)	NIC (nome do SO)	Nó NUMA	BDF PCIE
`nic0`	`enp22s0f0`	0	`0000:16:00.0`
`nic1`	`ens8f0`	0	`0000:27:00.0`
`nic2`	`ens48f0`	2	`0000:b8:00.0`

A tabela anterior inclui nomes de interface de rede atribuídos pelo SO típicos para RHEL. Os nomes reais podem ser diferentes.

Determinar um esquema de isolamento de CPU

Para alcançar o melhor desempenho, recomendamos que você isole o seguinte:

As CPUs usadas pelo aplicativo
As CPUs usadas para pesquisar as filas RX do Onload
As CPUs usadas para interrupções de kernel e driver

A tabela a seguir fornece um exemplo de como isolar CPUs em instâncias bare metal U4. Ajuste o mapeamento conforme necessário para suas cargas de trabalho. Por exemplo, talvez você queira mais CPUs de aplicativos.

Finalidade	CPUs
Interrupções gerais do kernel	0,1,30,31,60,61,90,91
Interrupções do driver `nic0` para filas 0-11	2
Interrupções do driver `nic1` para filas 0-11	3
Interrupções do driver `nic0` e `nic1` para filas 12-15	4
Pesquisa ocupada `nic1`	5-16
Linhas de execução de aplicativos `nic1` (Onload)	17-29
Pesquisa ocupada `nic0`	32-43
Linhas de execução de aplicativos `nic0` (Onload)	44-59
Interrupções do driver `nic2` para filas 0-11	62
Interrupções do driver `nic2` para filas 12-15	63
Pesquisa ocupada `nic2`	64-75
Linhas de execução de aplicativos `nic2` (Onload)	76-89

Instalar dependências para otimização de performance

Para instalar as dependências necessárias para otimização de performance, execute o seguinte comando:

dnf -y install numactl tuna jq

Configurar parâmetros de inicialização do kernel

Para isolar CPUs do agendamento do kernel, execute o seguinte comando. Isso também desativa a Intel QuickAssist Technology (QAT) para que ela não interfira nos núcleos isolados.

O comando de exemplo a seguir isola as CPUs 2-29, 32-59 e 62-89 e designa 0,1,30,31,60,61,90,91 para interrupções gerais do kernel. Esses valores correspondem ao esquema de isolamento de CPU de exemplo. Substitua os valores conforme necessário, dependendo do esquema de isolamento de CPU.

grubby --args="isolcpus=domain,managed_irq,2-29,32-59,62-89 nohz=on nohz_full=2-29,32-59,62-89 rcu_nocbs=2-29,32-59,62-89 irqaffinity=0,1,30,31,60,61,90,91 rcu_nocb_poll modprobe.blacklist=intel_qat,qat_4xxx" --update-kernel=ALL
reboot

Configurar o isolamento de CPU pós-inicialização

Para isolar CPUs após a inicialização, execute o seguinte comando. Os valores correspondem ao esquema de isolamento de CPU de exemplo. Substitua os valores conforme necessário, dependendo do esquema de isolamento de CPU.

tuna isolate -c 2-29,32-59,62-89

Atribuir interrupções de fila a CPUs específicas

Esta seção descreve como mover solicitações de interrupção de fila gve (IRQs) para CPUs específicas. O driver gve é usado pelo tipo de interface de rede GVNIC em Google Cloud.

Determine as IRQs para uma determinada interface de rede e intervalo de filas. Consulte o exemplo de bash a seguir, que define uma função irq_list.

irq_list() {
  local ifname=$1
  local queue_begin=$2
  local queue_end=$3

  pci_name=$(basename $(readlink /sys/class/net/${ifname}/device))
  rx_ntfy_blk_start=$(ethtool -l "${ifname}" | awk '
    /Pre-set maximums:/ { in_preset = 1 }
    /Current hardware settings:/ { in_preset = 0 }
    in_preset && $1 == "RX:" { rx = $2 }
    in_preset && $1 == "TX:" { tx = $2 }
    END { print int((rx + tx) / 2) }
  ')
  for i in $(seq "${queue_begin}" "${queue_end}"); do
    irq_tx="gve-ntfy-blk${i}@pci:${pci_name}"
    irq_rx="gve-ntfy-blk$(($i + rx_ntfy_blk_start))@pci:${pci_name}"
    # gve IRQ names are stored in a char[IFNAMSIZ + 16] so capped to 31 characters.
    echo "${irq_tx:0:31}"
    echo "${irq_rx:0:31}"
  done | paste -sd ','
}

Atribua IRQs à CPU apropriada com base no esquema de isolamento de CPU. O script de exemplo a seguir usa tuna e a função irq_list da etapa anterior:

tuna move -c 2 -q "$(irq_list enp22s0f0 0 11)"
tuna move -c 4 -q "$(irq_list enp22s0f0 12 15)"

tuna move -c 3 -q "$(irq_list ens8f0 0 11)"
tuna move -c 4 -q "$(irq_list ens8f0 12 15)"

tuna move -c 62 -q "$(irq_list ens48f0 0 11)"
tuna move -c 63 -q "$(irq_list ens48f0 12 15)"

Configurar o SO e as configurações do dispositivo

Execute o script a seguir para configurar as configurações que ajudam a minimizar a latência e impedem que os comportamentos padrão do SO interfiram nas configurações do Onload.

echo 0 > /proc/sys/net/core/busy_poll
echo 0 > /proc/sys/net/core/busy_read
echo 0 > /proc/sys/kernel/timer_migration
echo 0 > /proc/sys/net/core/rps_sock_flow_entries
echo -1 > /proc/sys/kernel/sched_rt_runtime_us

for IFNAME in "${IFNAMES[@]}"; do
  ethtool -C "${IFNAME}" rx-usecs 0 tx-usecs 0
  echo 0 > "/sys/class/net/${IFNAME}/napi_defer_hard_irqs"
  echo 15000 > "/sys/class/net/${IFNAME}/gro_flush_timeout"
done

Para direcionar o tráfego para fora das filas dedicadas às cargas de trabalho do Onload, use o RSS (ethtool -X). O script de exemplo a seguir é baseado nos valores no esquema de isolamento de CPU de exemplo. Como o Onload usa filas 0-11, o script direciona todo o tráfego para filas 12-15.
```
for IFNAME in "${IFNAMES[@]}"; do
  ethtool -X "${IFNAME}" weight 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1
done
```

Problemas conhecidos

Consulte os problemas conhecidos a seguir que podem ocorrer ao trabalhar com o Onload em instâncias U4:

A abertura e o fechamento de um soquete podem levar vários milissegundos. Esse atraso ocorre porque a configuração de direcionamento de fluxo necessária para AF_XDP é um processo de caminho de controle lento:
- Os operadores de exchange que gerenciam soquetes de listener podem contornar esse problema usando patches que o Google enviou para o repositório upstream do Onload (#335, #336). Certifique-se de incluir esses patches ao extrair a origem do Onload.
- Os participantes da exchange que estabelecem conexões de saída não exigem os patches anteriores e podem usar o recurso EF_TCP_SHARED_LOCAL_PORTS para ajudar a reduzir a latência.

A seguir

Para sincronizar o relógio do sistema da instância com o relógio da NIC física do seu servidor host, consulte Configurar a hora exata.

Trabalhar com o Onload

Sobre o Onload

Antes de começar

Criar uma instância U4

Conectar-se à instância usando SSH

Mudar para o usuário raiz

Configurar o Onload

Instalar dependências

Extrair a origem do Onload

Criar o Onload

Desativar o rastreamento de ramificação indireta (IBT)

Carregar o Onload

Carregar o Onload em uma instância U4P ou U4C

Carregar o Onload em uma instância U4S

Configurar flags do Onload

Descarregar o Onload

Configurar um serviço systemd que inicia o Onload automaticamente

Configurar a pesquisa ocupada

Receber a fila RX que uma pilha do Onload está usando

Ativar a pesquisa ocupada em uma fila RX

Planejar eventos de recriação de linhas de execução

Desativar a pesquisa ocupada em uma fila RX

Receber o status de pesquisa ocupada de uma fila

Otimizar o desempenho

Analisar a topologia NUMA para instâncias bare metal U4

Determinar um esquema de isolamento de CPU

Instalar dependências para otimização de performance

Configurar parâmetros de inicialização do kernel

Configurar o isolamento de CPU pós-inicialização

Atribuir interrupções de fila a CPUs específicas

Configurar o SO e as configurações do dispositivo

Problemas conhecidos

A seguir

Configurar um serviço `systemd` que inicia o Onload automaticamente