Como faço para usar e gerenciar a alocação de memória do Amazon Redshift WLM?

Breve descrição

Use um dos métodos a seguir para configurar o WLM para gerenciar recursos com eficiência:

• WLM automático: O Amazon Redshift gerencia o nível de simultaneidade das filas e a alocação de memória para cada consulta enviada. A consulta enviada permite que você defina a prioridade de consulta do workload ou dos usuários para cada uma das filas de consulta.
• WLM manual: Você tem mais controle sobre o nível de simultaneidade e a alocação de memória para as filas. Como resultado, consultas com maior consumo de recursos podem ser executadas em filas com mais alocação de recursos.

É uma prática recomendada usar o WLM automático porque ele usa machine learning para prever a quantidade de memória para atribuir as consultas. Se você estiver usando o WLM manual e quiser migrar para o WLM automático, consulte Migrando do WLM manual para o WLM automático.

Observação: Para definir limites de desempenho baseados em métricas, use uma regra de monitoramento de consultas (QMR) com sua configuração do WLM.

Resolução

Para verificar o nível de simultaneidade e a alocação do WLM para as filas, execute as seguintes ações:

• Verifique a configuração atual do WLM do seu cluster Amazon Redshift.
• Crie uma configuração de teste do WLM e especifique a distribuição e o nível de simultaneidade da fila de consultas.
• (Opcional) Se você usar o WLM manual, determine como a memória é distribuída entre as contagens de slots.

Verifique a configuração atual do WLM e o uso da memória

Use a tabela STV_WLM_SERVICE_CLASS_CONFIG para verificar a configuração atual do WLM do seu cluster Amazon Redshift.

Exemplo de configuração do WLM:

[
  {
    "query_concurrency": 2,
    "memory_percent_to_use": 30,
    "query_group": [],
    "query_group_wild_card": 0,
    "user_group": [
      "user_group1"
    ],
    "user_group_wild_card": 0,
    "rules": [
      {
        "rule_name": "BlockstoDiskSpill",
        "predicate": [
          {
            "metric_name": "query_temp_blocks_to_disk",
            "operator": ">",
            "value": 50
          }
        ],
        "action": "abort"
      }
    ]
  },
  {
    "query_concurrency": 5,
    "memory_percent_to_use": 40,
    "query_group": [],
    "query_group_wild_card": 0,
    "user_group": [
      "user_group2"
    ],
    "user_group_wild_card": 0
  },
  {
    "query_concurrency": 5,
    "memory_percent_to_use": 10,
    "query_group": [],
    "query_group_wild_card": 0,
    "user_group": [],
    "user_group_wild_card": 0,
    "rules": [
      {
        "rule_name": "abort_query",
        "predicate": [
          {
            "metric_name": "scan_row_count",
            "operator": ">",
            "value": 1000
          }
        ],
        "action": "abort"
      }
    ]
  },
  {
    "query_group": [],
    "query_group_wild_card": 0,
    "user_group": [],
    "user_group_wild_card": 0,
    "auto_wlm": false
  },
  {
    "short_query_queue": false
  }
]

Observação: o exemplo anterior de configuração WLM está no formato JSON e usa o QMR, Fila 1. No exemplo, memory_percent_to_use é a quantidade real de memória de trabalho atribuída à classe de serviço.

O Amazon Redshift aloca memória do grupo de recursos compartilhados em seu cluster. A fila 1 tem uma alocação de memória de 30% que é dividida em dois slots iguais porque a simultaneidade é definida como 2. Cada slot recebe uma parcela igual de 15% da alocação de memória atual.

A fila 2 tem uma alocação de memória de 40% que é dividida em cinco slots iguais porque a simultaneidade é definida como 5. Cada slot recebe 8% da alocação de memória. A fila padrão usa 10% da alocação de memória com um nível de simultaneidade de fila de 5.

Use a consulta a seguir para verificar a configuração da classe de serviço:

select rtrim(name) as name,
num_query_tasks as slots,
query_working_mem as mem,
max_execution_time as max_time,
user_group_wild_card as user_wildcard,
query_group_wild_card as query_wildcard
from stv_wlm_service_class_config
where service_class > 4;

Exemplo de saída:

                        name                        | slots | mem | max_time | user_wildcard | query_wildcard
----------------------------------------------------+-------+-----+----------+---------------+----------------
 Service class for super user                       |     1 | 297 |        0 | false         | false
 Queue 1                                            |     2 | 522 |        0 | false         | false
 Queue 2                                            |     5 | 278 |        0 | false         | false
 Default queue                                      |     5 |  69 |        0 | false         | false
 Service class for vacuum/analyze                   |     0 |   0 |        0 | false         | false

A fila 1 tem uma contagem de slots de 2 e a memória alocada para cada slot, ou nó, é de 522 MB. A alocação de memória atribuída à classe de serviço é a quantidade real de memória de trabalho atual em MB por slot para cada nó.

Observação: se todos os slots de consulta forem usados, o Amazon Redshift gerenciará a memória não alocada. Quando uma fila solicita memória adicional, o sistema fornece temporariamente memória não alocada à fila.

Para obter mais informações sobre o gerenciamento de memória não alocada, consulte Porcentagem de memória do WLM a ser usada.

Identifique parâmetros de ajuste de alto nível

Use a tabela SVL_QUERY_METRICS_SUMMARY para verificar a execução detalhada e a coluna query_queue_time para visualizar as consultas que estão na fila. A coluna query_queue_time mostra que a consulta está na fila para execução de um slot WLM.

Tabela de exemplo:

dev=# select userid, query, service_class, query_cpu_time, query_blocks_read, query_execution_time, query_cpu_usage_percent, query_temp_blocks_to_disk, query_queue_time  from SVL_QUERY_METRICS_SUMMARY where query=29608;

 userid | query | service_class | query_cpu_time | query_blocks_read | query_execution_time | query_cpu_usage_percent | query_temp_blocks_to_disk | query_queue_time
--------+-------+---------------+----------------+-------------------+----------------------+-------------------------+---------------------------+------------------
    100 | 29608 |                    8 |                       18 |                          942 |                                64 |                                   10.05 |                                               |
(1 row)


ev=# select query, step, rows, workmem, label, is_diskbased
from svl_query_summary
where query = 29608
order by workmem desc;

 query | step |   rows   | workmem  |                  label                  | is_diskbased
-------+------+----------+----------+-----------------------------------------+--------------
 29608 |    3 |    49999 | 54263808 | hash   tbl=714                          | f
 29608 |    2 |    49999 |        0 | project                                 | f
 29608 |    0 |    49999 |        0 | scan   tbl=255079 name=part             | f
 29608 |    1 |    49999 |        0 | project                                 | f
 29608 |    6 |  1561938 |        0 | return                                  | f
 29608 |    4 |  1561938 |        0 | project                                 | f
 29608 |    5 |  1561938 |        0 | project                                 | f
 29608 |    2 | 29995220 |        0 | project                                 | f
 29608 |    1 |  1561938 |        0 | return                                  | f
 29608 |    1 | 29995220 |        0 | project                                 | f
 29608 |    0 |  1561938 |        0 | scan   tbl=4893 name=Internal Worktable | f
 29608 |    3 |  1561938 |        0 | hjoin  tbl=714                          | f
 29608 |    0 | 29995220 |        0 | scan   tbl=255087 name=lineorder        | f
(13 rows)

Use a tabela SVL_QUERY_SUMMARY para verificar a alocação de recursos durante cada etapa da consulta.

Verifique as colunas is_diskbased e workmem para ver o uso do recurso. Para obter mais informações, consulte Análise do resumo da consulta.

Atualização das propriedades de configuração dinâmica do WLM

Use as propriedades de configuração dinâmica do WLM para se ajustar os workloads que mudam. É possível aplicar propriedades dinâmicas ao banco de dados sem reinicializar o cluster. No entanto, a mudança entre o WLM automático e o WLM manual é estática e requer uma reinicialização do cluster para entrar em vigor.

Para obter mais informações, consulte STV_WLM_SERVICE_CLASS_CONFIG.

Veja a seguir um exemplo de um cluster configurado com duas filas:

Queue    Concurrency    % Memory to Use            1        5              60%  
2        5              40%

Se o cluster tiver 200 GB de memória disponível, a alocação de memória atual para cada um dos slots da fila será semelhante ao exemplo a seguir:

Queue 1: (200 GB * 60% ) / 5 slots  = 24 GB
Queue 2: (200 GB * 40% ) / 5 slots  = 16 GB

Para atualizar suas propriedades de configuração do WLM para que sejam dinâmicas, modifique suas configurações. Veja o exemplo de modificação a seguir:

Queue    Concurrency    % Memory to Use            1        3              75%  
2        4              25%

Depois de modificar a configuração do WLM, a alocação de memória é atualizada para acomodar o workload alterado. Veja o exemplo de atualização a seguir:

Queue 1: (200 GB * 75% ) / 3 slots = 50 GB
Queue 2: (200 GB * 25% ) / 4 slots = 12.5 GB

Observação: se houver consultas na fila do WLM durante uma atualização de configuração dinâmica, o Amazon Redshift aguardará a conclusão das consultas. Depois que a consulta for concluída, o Amazon Redshift atualizará o cluster com as configurações atualizadas.

Use a tabela STV_WLM_SERVICE_CLASS_CONFIG ao fazer a transição para as propriedades dinâmicas de configuração do WLM.

Se os valores de num_query_tasks e target_num_query_tasks forem diferentes, então uma transição dinâmica do WLM está em andamento. Um valor de -1 mostra que o Auto WLM está configurado.

Identifique memória insuficiente alocada para a consulta

Se um plano de execução de consulta em SVL_QUERY_SUMMARY tiver o valor is_diskbased definido como verdadeiro, aloque mais memória para a consulta. Para alocar mais memória, aumente o número de slots de consulta.

Para obter mais informações, consulte wlm_query_slot_count.