Compartilhar via

Propriedades do pool de threads

O Analysis Services usa vários threadings para muitas operações, melhorando o desempenho geral do servidor executando vários trabalhos em paralelo. Para gerenciar threads com mais eficiência, o Analysis Services usa pools de threads para pré-alocar threads e facilitar a disponibilidade de threads para o próximo trabalho.

Cada instância do Analysis Services mantém seu próprio conjunto de pools de threads. Existem diferenças significativas em como as instâncias tabulares e multidimensionais utilizam pools de threads. A principal diferença é que apenas soluções multidimensionais usam o pool de threads IOProcess. Dessa forma, a PerNumaNode propriedade, descrita neste tópico, não é significativa para instâncias tabulares.

Este tópico contém as seguintes seções:

Observação

A implantação tabular em sistemas NUMA está fora do escopo deste tópico. Embora as soluções tabulares possam ser implantadas com êxito em sistemas NUMA, as características de desempenho da tecnologia de banco de dados na memória usada por modelos tabulares podem mostrar benefícios limitados em arquiteturas de alta escala. Para obter mais informações, consulte o estudo de caso do Analysis Services: usando modelos tabulares em soluções comerciais em larga escala e dimensionamento de hardware de uma solução tabular.

Gerenciamento de threads no Analysis Services

O serviço Analysis Services usa multithreading para tirar proveito dos recursos de CPU disponíveis, aumentando o número de tarefas que são executadas em paralelo. O mecanismo de armazenamento tem vários threads. Exemplos de tarefas multithreaded que são executadas no mecanismo de armazenamento incluem o processamento paralelo de objetos e o tratamento de consultas discretas que foram transferidas para o mecanismo de armazenamento, além do retorno de valores de dados solicitados por uma consulta. O mecanismo de fórmula, devido à natureza serial dos cálculos que avalia, é monothread. Cada consulta é executada principalmente em um único thread, solicitando e, muitas vezes, aguardando dados retornados pelo mecanismo de armazenamento. Os threads de consulta têm execuções mais longas e são liberados somente após a conclusão de toda a consulta.

Por padrão, nas versões SQL Server 2012 e posterior, o Analysis Services usará todos os processadores lógicos disponíveis, até 640 em sistemas que executam edições mais altas do Windows e do SQL Server. Após a inicialização, o processo de msmdsrv.exe será atribuído a um grupo de processadores específico, mas ao longo do tempo os threads podem ser agendados em qualquer processador lógico, em qualquer grupo de processadores.

Um efeito colateral do uso de um grande número de processadores é que às vezes você pode experimentar degradação de desempenho à medida que cargas de consulta e processamento são distribuídas por um grande número de processadores e a contenção para estruturas de dados compartilhadas aumentam. Isso pode ocorrer especialmente em sistemas high-end que usam a arquitetura NUMA, mas também em sistemas não NUMA que executam vários aplicativos com uso intensivo de dados no mesmo hardware.

Para aliviar esse problema, você pode definir afinidade entre tipos de operações do Analysis Services e um conjunto específico de processadores lógicos. A GroupAffinity propriedade permite criar máscaras de afinidade personalizadas que especificam qual recurso do sistema usar para cada um dos tipos de pool de threads gerenciados pelo Analysis Services.

A afinidade personalizada pode ser definida em qualquer um dos cinco pools de threads usados para várias cargas de trabalho do Analysis Services:

  • Análise \ Short é um pool de análise para solicitações curtas. As solicitações que se encaixam em uma única mensagem de rede são consideradas curtas.

  • Parsing \ Long é um conjunto de processamento para todas as outras solicitações que não se encaixam em uma única mensagem de rede.

    Observação

    Um thread de qualquer pool de análise pode ser usado para executar uma consulta. As consultas que são executadas rapidamente, como solicitações rápidas de Descoberta ou Cancelamento, às vezes são executadas imediatamente em vez de serem enfileiradas no pool de threads de consultas.

  • Query é o pool de threads que executa todas as solicitações que não são tratadas pelo pool de threads de análise. Os threads nesse pool de threads executarão todos os tipos de operações, como os comandos Discovers, MDX, DAX, DMX e DDL.

  • IOProcess é usado para tarefas de E/S associadas a consultas do mecanismo de armazenamento do motor multidimensional. Espera-se que o trabalho feito por esses threads não tenha dependências em outros threads. Esses threads normalmente verificarão um único segmento de uma partição e executarão filtragem e agregação nos dados do segmento. IOProcess Os threads são particularmente sensíveis às configurações de hardware NUMA. Dessa forma, esse pool de threads tem a PerNumaNode propriedade de configuração que pode ser usada para ajustar o desempenho, se necessário.

  • Process é para trabalhos de mecanismo de armazenamento de maior duração, incluindo agregações, indexação e operações de confirmação. O modo de armazenamento ROLAP também usa threads do pool de threads de processamento.

Observação

Embora Msmdsrv.ini tenha configurações de pool de threads na seção VertiPaq, VertiPaq\ThreadPool\GroupAffinity e ThreadPool\CPUs são deliberadamente não documentadas. No momento, essas propriedades estão inoperantes e são reservadas para uso futuro.

Para solicitações de atendimento, o Analysis Services pode exceder o limite máximo do pool de threads, solicitando threads adicionais caso sejam necessários para executar o trabalho. No entanto, quando um thread termina de executar sua tarefa, se a contagem atual de threads for maior que o limite máximo, o thread será simplesmente encerrado, em vez de retornado ao pool de threads.

Observação

Exceder a contagem máxima do pool de threads é uma proteção invocada somente quando determinadas condições de deadlock surgem. Para impedir a criação de threads descontrolados além do máximo, os threads são criados gradualmente (após um pequeno atraso) após o limite máximo ter sido atingido. Exceder a contagem máxima de threads pode levar a uma desaceleração na execução da tarefa. Se os contadores de desempenho mostrarem que as contagens de threads estão regularmente além do tamanho máximo do pool de threads, você pode considerar isso como um indicador de que os tamanhos do pool de threads são muito pequenos para o grau de simultaneidade que está sendo solicitado do sistema.

Por padrão, o tamanho do pool de threads é determinado pelo Analysis Services e é baseado no número de núcleos. Você pode observar os valores padrão selecionados examinando o arquivo msmdsrv.log após a inicialização do servidor. Como exercício de otimização de desempenho, você pode optar por aumentar o tamanho do pool de threads, além de outras propriedades, para melhorar o desempenho de consulta ou processamento.

Referência de propriedade do pool de threads

Esta seção descreve as propriedades do pool de threads encontradas no arquivo msmdsrv.ini de cada instância do Analysis Services. Um subconjunto dessas propriedades também aparece no SQL Server Management Studio.

As propriedades são listadas em ordem alfabética.

Nome Tipo Descrição Padrão Orientação
IOProcess \ Concurrency duplo Um valor de ponto flutuante de precisão dupla que determina o algoritmo para definir um alvo para o número de threads que podem estar na fila ao mesmo tempo. 2.0 Uma propriedade avançada que você não deve alterar, exceto sob a orientação do suporte da Microsoft.

A simultaneidade é utilizada para inicializar pools de threads, os quais são implementados utilizando Portas de Conclusão de Entrada/Saída no Windows. Consulte as Portas de Conclusão de E/S para obter detalhes.

Aplica-se somente a modelos multidimensionais.
IOProcess \ GroupAffinity corda Uma matriz de valores hexadecimais que correspondem a grupos de processadores no sistema, é usada para definir a afinidade de threads no pool de threads do IOProcess com processadores lógicos em cada grupo de processadores. nenhum Você pode usar essa propriedade para criar afinidades personalizadas. A propriedade está vazia por padrão.

Consulte Configurar GroupAffinity para associar threads a processadores em um grupo de processadores para obter mais detalhes.

Aplica-se somente a modelos multidimensionais.
IOProcess \ MaxThreads int Um inteiro assinado de 32 bits que determina o número máximo de threads a ser incluído no pool de threads. 0 0 indica que o servidor determina os padrões. Por padrão, o servidor define esse valor como 64 ou 10 vezes o número de processadores lógicos, o que for maior. Por exemplo, em um sistema de 4 núcleos com hiperthreading, o máximo do pool de threads é de 80 threads.

Se você definir esse valor como um valor negativo, o servidor múltiploá esse valor pelo número de processadores lógicos. Por exemplo, quando definido como -10 em um servidor com 32 processadores lógicos, o máximo é de 320 threads.

O valor máximo está sujeito a processadores disponíveis por qualquer máscara de afinidade personalizada que você definiu anteriormente. Por exemplo, se você já definir a afinidade do pool de threads para usar 8 de 32 processadores e agora definir MaxThreads como -10, o limite superior no pool de threads será 10 vezes 8 ou 80 threads.

Os valores reais usados para essa propriedade do pool de threads são gravados no arquivo de log msmdsrv após a inicialização do serviço.

Mais informações sobre como ajustar as configurações do pool de threads podem ser encontradas no Guia de Operações do Analysis Services.

Aplica-se somente a modelos multidimensionais.
IOProcess \ MinThreads int Um inteiro de 32 bits assinado que especifica o número mínimo de threads a serem pré-alocados para o pool de threads. 0 0 indica que o servidor determina os padrões. Por padrão, o mínimo é 1.

Se você definir esse valor como um valor negativo, o servidor múltiploá esse valor pelo número de processadores lógicos.

Os valores reais usados para essa propriedade do pool de threads são gravados no arquivo de log msmdsrv após a inicialização do serviço.

Mais informações sobre como ajustar as configurações do pool de threads podem ser encontradas no Guia de Operações do Analysis Services.

Aplica-se somente a modelos multidimensionais.
IOProcess \ PerNumaNode int Um inteiro de 32 bits assinado que determina o número de pools de threads criados para o processo msmdsrv. -1 Os valores válidos são -1, 0, 1, 2

-1 = O servidor seleciona uma estratégia alternativa para o Pool de Threads de E/S com base na quantidade de nós NUMA. Em sistemas com menos de 4 nós NUMA, o comportamento do servidor é o mesmo que 0 (um pool de threads IOProcess é criado para o sistema). Em sistemas com 4 ou mais nós, o comportamento é o mesmo que 1 (pools de threads IOProcess são criados para cada nó).

0 = Desabilita os grupos de threads do nó NUMA para que haja apenas um único grupo de threads IOProcess usado pelo processo msmdsrv.exe.

1 = Habilita um pool de threads de IOProcess para cada nó NUMA.

2 = Um pool de threads IOProcess por processador lógico. As threads em cada pool de threads são afinizadas com o nó NUMA do processador lógico, com o processador ideal definido como o processador lógico.

Consulte Definir PerNumaNode para afinitizar threads de E/S com processadores em um nó NUMA para obter detalhes.

Aplica-se somente a modelos multidimensionais.
IOProcess \ PriorityRatio int Um inteiro com sinal de 32 bits que pode ser usado para garantir que threads de prioridade mais baixa às vezes sejam executados mesmo quando uma fila de prioridade mais alta não estiver vazia. 2 Uma propriedade avançada que você não deve alterar, exceto sob a orientação do suporte da Microsoft.

Aplica-se somente a modelos multidimensionais.
IOProcess \ StackSizeKB int Um inteiro de 32 bits assinado que pode ser usado para ajustar a alocação de memória durante a execução do thread. 0 Uma propriedade avançada que você não deve alterar, exceto sob a orientação do suporte da Microsoft.

Aplica-se somente a modelos multidimensionais.
Análise \ Long \ Concurrency duplo Um valor de ponto flutuante de precisão dupla que determina o algoritmo para definir um alvo no número de threads que podem ser enfileirados de uma só vez. 2.0 Uma propriedade avançada que você não deve alterar, exceto sob a orientação do suporte da Microsoft.

A simultaneidade é usada para inicializar pools de threads, que são implementados usando portas de conclusão de E/S no Windows. Consulte as Portas de Conclusão de E/S para obter detalhes.
Análise \ Long \ GroupAffinity corda Uma matriz de valores hexadecimais que correspondem a grupos de processadores no sistema, utilizada para estabelecer a afinidade dos threads de parseamento com processadores lógicos em cada grupo de processadores. nenhum Você pode usar essa propriedade para criar afinidades personalizadas. A propriedade está vazia por padrão.

Consulte GroupAffinity para definir a afinidade de threads aos processadores em um grupo de processadores para obter mais detalhes.
Análise \ Long \ NumThreads int Uma propriedade de número inteiro assinado de 32 bits que define o número de threads que podem ser criados para comandos longos. 0 0 indica que o servidor determina os padrões. O comportamento padrão é definir NumThreads como um valor absoluto de 4 ou 2 vezes o número de processadores lógicos, o que for maior.

Se você definir esse valor como um valor negativo, o servidor múltiploá esse valor pelo número de processadores lógicos. Por exemplo, quando definido como -10 em um servidor com 32 processadores lógicos, o máximo é de 320 threads.

O valor máximo está sujeito a processadores disponíveis por qualquer máscara de afinidade personalizada que você definiu anteriormente. Por exemplo, se você já definir a afinidade do pool de threads para usar 8 de 32 processadores e agora definir NumThreads como -10, o limite superior no pool de threads será 10 vezes 8 ou 80 threads.

Os valores reais usados para essa propriedade do pool de threads são gravados no arquivo de log msmdsrv após a inicialização do serviço.
Análise \ Long \ PriorityRatio int Um inteiro assinado de 32 bits que pode ser utilizado para garantir que threads de menor prioridade possam ser executados mesmo quando uma fila de prioridade mais alta não estiver vazia. 0 Uma propriedade avançada que você não deve alterar, exceto sob a orientação do suporte da Microsoft.
Análise \ Long \ StackSizeKB int Um inteiro de 32 bits assinado que pode ser usado para ajustar a alocação de memória durante a execução do thread. 0 Uma propriedade avançada que você não deve alterar, exceto sob a orientação do suporte da Microsoft.
Análise \ Short \ Concurrency duplo Um valor de ponto flutuante de precisão dupla que determina o algoritmo para definir um destino no número de threads que podem ser enfileirados ao mesmo tempo. 2.0 Uma propriedade avançada que você não deve alterar, exceto sob a orientação do suporte da Microsoft.

A simultaneidade é usada para inicializar pools de threads, que são implementados usando portas de conclusão de E/S no Windows. Consulte as Portas de Conclusão de E/S para obter detalhes.
Análise \ Short \ GroupAffinity corda Uma matriz de valores hexadecimal que correspondem a grupos de processadores no sistema, usada para definir a afinidade de analisar threads para processadores lógicos em cada grupo de processadores. nenhum Você pode usar essa propriedade para criar afinidades personalizadas. A propriedade está vazia por padrão.

Consulte Defina GroupAffinity para associar threads com processadores dentro de um grupo de processadores para obter detalhes.
Análise \ Short \ NumThreads int Uma propriedade inteira de 32 bits assinada que define o número de threads que podem ser criados para comandos de curta duração. 0 0 indica que o servidor determina os padrões. O comportamento padrão é definir NumThreads como um valor absoluto de 4 ou 2 vezes o número de processadores lógicos, o que for maior.

Se você definir esse valor como um valor negativo, o servidor múltiploá esse valor pelo número de processadores lógicos. Por exemplo, quando definido como -10 em um servidor com 32 processadores lógicos, o máximo é de 320 threads.

O valor máximo está sujeito a processadores disponíveis por qualquer máscara de afinidade personalizada que você definiu anteriormente. Por exemplo, se você já definir a afinidade do pool de threads para usar 8 de 32 processadores e agora definir NumThreads como -10, o limite superior no pool de threads será 10 vezes 8 ou 80 threads.

Os valores reais usados para essa propriedade do pool de threads são gravados no arquivo de log msmdsrv após a inicialização do serviço.
Análise \ Short \ PriorityRatio int Um inteiro com sinal de 32 bits que pode ser usado para garantir que threads de prioridade mais baixa às vezes sejam executados mesmo quando uma fila de prioridade mais alta não estiver vazia. 0 Uma propriedade avançada que você não deve alterar, exceto sob a orientação do suporte da Microsoft.
Análise \ Short \ StackSizeKB int Um inteiro de 32 bits assinado que pode ser usado para ajustar a alocação de memória durante a execução do thread. 64 * processadores lógicos Uma propriedade avançada que você não deve alterar, exceto sob a orientação do suporte da Microsoft.
Process \ Concurrency duplo Um valor de ponto flutuante de precisão dupla que determina o algoritmo para estabelecer uma meta no número de threads que podem ser colocados em fila ao mesmo tempo. 2.0 Uma propriedade avançada que você não deve alterar, exceto sob a orientação do suporte da Microsoft.

A simultaneidade é usada para inicializar pools de threads, que são implementados usando portas de conclusão de E/S no Windows. Consulte as Portas de Conclusão de E/S para obter detalhes.
Process \ GroupAffinity corda Um conjunto de valores hexadecimais que correspondem a grupos de processadores no sistema, usados para definir a afinidade dos threads de processamento a processadores lógicos em cada grupo de processadores. nenhum Você pode usar essa propriedade para criar afinidades personalizadas. A propriedade está vazia por padrão.

Consulte GroupAffinity para definir a afinidade de threads com processadores em um grupo de processadores para obter detalhes.
Process \ MaxThreads int Um inteiro com sinal de 32 bits que especifica o número máximo de threads a serem incluídos no pool de threads. 0 0 indica que o servidor determina os padrões. Por padrão, o servidor define esse valor como um valor absoluto de 64 ou o número de processadores lógicos, o que for maior. Por exemplo, em um sistema de 64 núcleos com hiperthreading habilitado (resultando em 128 processadores lógicos), o máximo do pool de threads é de 128 threads.

Se você definir esse valor como um valor negativo, o servidor múltiploá esse valor pelo número de processadores lógicos. Por exemplo, quando definido como -10 em um servidor com 32 processadores lógicos, o máximo é de 320 threads.

O valor máximo está sujeito a processadores disponíveis por qualquer máscara de afinidade personalizada que você definiu anteriormente. Por exemplo, se você já definir a afinidade do pool de threads para usar 8 de 32 processadores e agora definir MaxThreads como -10, o limite superior no pool de threads será 10 vezes 8 ou 80 threads.

Os valores reais usados para essa propriedade do pool de threads são gravados no arquivo de log msmdsrv após a inicialização do serviço.

Mais informações sobre como ajustar as configurações do pool de threads podem ser encontradas no Guia de Operações do Analysis Services.
Process \ MinThreads int Um inteiro de 32 bits assinado que especifica o número mínimo de threads a serem pré-alocados para o pool de threads. 0 0 indica que o servidor determina os padrões. Por padrão, o mínimo é 1.

Se você definir esse valor como um valor negativo, o servidor múltiploá esse valor pelo número de processadores lógicos.

Os valores reais usados para essa propriedade do pool de threads são gravados no arquivo de log msmdsrv após a inicialização do serviço.

Mais informações sobre como ajustar as configurações do pool de threads podem ser encontradas no Guia de Operações do Analysis Services.
Process \ PriorityRatio int Um inteiro com sinal de 32 bits que pode ser usado para garantir que threads de prioridade mais baixa às vezes sejam executados mesmo quando uma fila de prioridade mais alta não estiver vazia. 2 Uma propriedade avançada que você não deve alterar, exceto sob a orientação do suporte da Microsoft.
Process \ StackSizeKB int Um inteiro de 32 bits assinado que pode ser usado para ajustar a alocação de memória durante a execução do thread. 0 Uma propriedade avançada que você não deve alterar, exceto sob a orientação do suporte da Microsoft.
Query \ Concurrency duplo Um valor de ponto flutuante de precisão dupla que determina o algoritmo para definir um alvo para o número de threads que podem ser enfileirados ao mesmo tempo. 2.0 Uma propriedade avançada que você não deve alterar, exceto sob a orientação do suporte da Microsoft.

A simultaneidade é usada para inicializar pools de threads, que são implementados usando portas de conclusão de E/S no Windows. Consulte as Portas de Conclusão de E/S para obter detalhes.
Query \ GroupAffinity corda Uma matriz de valores hexadecimais que corresponde aos grupos de processadores no sistema, utilizada para definir a afinidade de threads de processamento aos processadores lógicos em cada grupo de processadores. nenhum Você pode usar essa propriedade para criar afinidades personalizadas. A propriedade está vazia por padrão.

Consulte Defina GroupAffinity para afinizar threads a processadores em um grupo de processadores para obter detalhes.
Query \ MaxThreads int Um inteiro com sinal de 32 bits que especifica o número máximo de threads a serem incluídos no pool de threads. 0 0 indica que o servidor determina os padrões. Por padrão, o servidor define esse valor como um valor absoluto de 10 ou 2 vezes o número de processadores lógicos, o que for maior. Por exemplo, em um sistema de 4 núcleos com hiperthreading, a contagem máxima de threads é 16.

Se você definir esse valor como um valor negativo, o servidor múltiploá esse valor pelo número de processadores lógicos. Por exemplo, quando definido como -10 em um servidor com 32 processadores lógicos, o máximo é de 320 threads.

O valor máximo está sujeito a processadores disponíveis por qualquer máscara de afinidade personalizada que você definiu anteriormente. Por exemplo, se você já definir a afinidade do pool de threads para usar 8 de 32 processadores e agora definir MaxThreads como -10, o limite superior no pool de threads será 10 vezes 8 ou 80 threads.

Os valores reais usados para essa propriedade do pool de threads são gravados no arquivo de log msmdsrv após a inicialização do serviço.

Mais informações sobre como ajustar as configurações do pool de threads podem ser encontradas no Guia de Operações do Analysis Services.
Query \ MinThreads int Um inteiro de 32 bits assinado que especifica o número mínimo de threads a serem pré-alocados para o pool de threads. 0 0 indica que o servidor determina os padrões. Por padrão, o mínimo é 1.

Se você definir esse valor como um valor negativo, o servidor múltiploá esse valor pelo número de processadores lógicos.

Os valores reais usados para essa propriedade do pool de threads são gravados no arquivo de log msmdsrv após a inicialização do serviço.

Mais informações sobre como ajustar as configurações do pool de threads podem ser encontradas no Guia de Operações do Analysis Services.
Query \ PriorityRatio int Um inteiro com sinal de 32 bits que pode ser usado para garantir que threads de prioridade mais baixa às vezes sejam executados mesmo quando uma fila de prioridade mais alta não estiver vazia. 2 Uma propriedade avançada que você não deve alterar, exceto sob a orientação do suporte da Microsoft.
Query \ StackSizeKB int Um inteiro de 32 bits assinado que pode ser usado para ajustar a alocação de memória durante a execução do thread. 0 Uma propriedade avançada que você não deve alterar, exceto sob a orientação do suporte da Microsoft.

Definir GroupAffinity para atribuir afinidade de threads aos processadores em um grupo de processadores

GroupAffinity é fornecido para fins avançados de ajuste. Você pode usar a GroupAffinity propriedade para definir a afinidade entre pools de threads do Analysis Services e processadores específicos; no entanto, para a maioria das instalações, o Analysis Services tem o melhor desempenho quando pode usar todos os processadores lógicos disponíveis. Assim, a afinidade de grupo não é especificada por padrão.

Se o teste de desempenho indicar a necessidade de otimização da CPU, você poderá considerar uma abordagem de nível mais alto, como usar o Gerenciador de Recursos do Windows Server para definir a afinidade entre processadores lógicos e um processo de servidor. Essa abordagem pode ser mais simples de implementar e gerenciar do que definir afinidades personalizadas para pools de threads individuais.

Se essa abordagem for insuficiente, você poderá obter maior precisão definindo afinidades personalizadas para pools de threads. A personalização das configurações de afinidade é geralmente recomendada em sistemas grandes e multi-núcleo (sejam eles NUMA ou não NUMA) que apresentam degradação de desempenho devido a pools de threads distribuídos por uma gama ampla demais de processadores. Embora você possa definir GroupAffinity em sistemas com menos de 64 processadores lógicos, o benefício é insignificante e pode até prejudicar o desempenho.

Observação

GroupAffinity é restringido por edições que limitam o número de núcleos usados pelo Analysis Services. Na inicialização, o Analysis Services usa informações de edição e as GroupAffinity propriedades para calcular máscaras de afinidade para cada um dos 5 pools de threads por ele gerenciados. A edição Standard pode usar no máximo 16 núcleos. Se você instalar a edição padrão do Analysis Services em um sistema de vários núcleos grande com mais de 16 núcleos, o Analysis Services usará apenas 16 deles. Se você atualizar uma instância enterprise de uma versão anterior, será limitado a 20 núcleos. Para obter mais informações sobre edições e licenciamento, consulte a Visão geral de licenciamento do SQL Server 2012.

Sintaxe

O valor é hexadecimal para cada grupo de processadores, e o hexadecimal representa os processadores lógicos que o Analysis Services tenta usar primeiro ao alocar threads para um determinado pool de threads.

Máscara de bits para processadores lógicos

Você pode ter até 64 processadores lógicos em um único grupo de processadores. A máscara de bits é 1 (ou 0) para cada processador lógico no grupo usado (ou não usado) por um pool de threads. Depois de calcular a máscara de bits, você então calcula o valor hexadecimal que será usado para GroupAffinity.

Vários grupos de processadores

Os grupos de processadores são determinados na inicialização do sistema. GroupAffinity aceita valores hexadecimal para cada grupo de processadores em uma lista delimitada por vírgula. Considerando vários grupos de processadores (até 10 em sistemas de extremidade superior), você pode ignorar grupos individuais especificando 0x0. Por exemplo, em um sistema com quatro grupos de processadores (0, 1, 2, 3), você pode excluir os grupos 0 e 2 inserindo 0x0 para o primeiro e o terceiro valores.

<GroupAffinity>0x0, 0xFF, 0x0, 0xFF</GroupAffinity>

Etapas para calcular a máscara de afinidade do processador

Você pode definir GroupAffinity em msmdsrv.ini ou em páginas de propriedades do servidor no SQL Server Management Studio.

  1. Determinar o número de processadores e grupos de processadores

    Você pode baixar o utilitário Coreinfo de winsysinternals.

    Execute coreinfo para obter essas informações da seção do Processador Lógico para o Mapa de Grupo. Uma linha separada é gerada para cada processador lógico.

  2. Sequenciar os processadores da direita para a esquerda: 7654 3210

    O exemplo mostra apenas 8 processadores (0 a 7), mas um grupo de processadores pode ter no máximo 64 processadores lógicos e pode haver até 10 grupos de processadores em um servidor Windows de classe empresarial.

  3. Computar a máscara de bits para os grupos de processadores que você deseja usar

    7654 3210

    Substitua o número por um 0 ou 1, dependendo se você deseja excluir ou incluir o processador lógico. Em um sistema que tem oito processadores, seu cálculo pode ter esta aparência se você quiser usar processadores 7, 6, 5, 4 e 1 para o Analysis Services:

    1111 0010

  4. Converter o número binário em um valor Hex

    Usando uma calculadora ou ferramenta de conversão, converta o número binário em seu equivalente hexadecimal. Em nosso exemplo, 1111 0010 converte em 0xF2.

  5. Insira o valor hex na propriedade GroupAffinity

    No msmdsrv.ini ou na página de propriedades do servidor no Management Studio, defina GroupAffinity como o valor calculado na etapa 4.

Importante

A configuração GroupAffinity é uma tarefa manual que abrange várias etapas. Ao calcular GroupAffinity, verifique os cálculos com cuidado. Embora o Analysis Services retorne um erro se a máscara inteira for inválida, uma combinação de configurações válidas e inválidas resulta em Analysis Services ignorando a propriedade. Por exemplo, se a máscara de bits incluir valores extras, o Analysis Services ignorará a configuração, usando todos os processadores no sistema. Não há nenhum erro ou aviso para alertá-lo quando essa ação ocorrer, mas você pode verificar o arquivo msmdsrv.log para saber como as afinidades são realmente definidas.

Defina PerNumaNode para ajustar a afinidade dos threads de E/S aos processadores em um nó NUMA

Para instâncias multidimensionais do Analysis Services, você pode definir PerNumaNode no pool de threads para otimizar ainda mais o agendamento e a execução de threads. Considerando que GroupAffinity identifica qual conjunto de processadores lógicos usar para um determinado pool de threads, PerNumaNode vai além, especificando se deve criar múltiplos pools de threads, ainda mais especificamente afinados para algum subconjunto dos processadores lógicos permitidos.

Observação

No Windows Server 2012, use o Gerenciador de Tarefas para exibir o número de nós NUMA no computador. No Gerenciador de Tarefas, na guia Desempenho, selecione CPU e clique com o botão direito do mouse na área do grafo para exibir nós NUMA. Como alternativa, baixe o utilitário Coreinfo do Windows Sysinternals e execute coreinfo -n para retornar nós NUMA e processadores lógicos em cada nó.

Os valores válidos para PerNumaNode são -1, 0, 1, 2 - conforme descrito na seção Referência de Propriedade do Pool de Threads deste tópico.

Em sistemas com nós NUMA, recomendamos usar a configuração padrão de PerNumaNode=-1, permitindo que o Analysis Services ajuste o número de pools de threads e sua afinidade de thread com base na contagem de nós. Se o sistema tiver menos de 4 nós, o Analysis Services implementará os comportamentos descritos por PerNumaNode=0, enquanto PerNumaNode=1 será usado em sistemas com 4 ou mais nós.

Escolhendo um valor

Você também pode substituir o padrão para usar outro valor válido.

Configurando PerNumaNode=0

Nós de NUMA são ignorados. Existirá apenas um pool de threads IOProcess e todos os threads nele serão afinados com todos os processadores lógicos. Por padrão (em que PerNumaNode=-1), essa é a configuração operacional se o computador tiver menos de 4 nós NUMA.

Numa, processador e correspondência do pool de threads

Configurando PerNumaNode=1

Os pools de threads do IOProcess são criados para cada nó NUMA. Ter pools de threads separados melhora o acesso coordenado aos recursos locais, como o cache local em um nó NUMA.

Numa, correspondência entre processador e pool de threads

Configurando PerNumaNode=2

Essa configuração é para sistemas de ponta que executam cargas de trabalho intensivas do Analysis Services. Essa propriedade define a afinidade do pool de threads do IOProcess em seu nível mais granular, criando e afinizando pools de threads separados no nível do processador lógico.

No exemplo a seguir, em um sistema com 4 nós NUMA e 32 processadores lógicos, a configuração PerNumaNode como 2 resultaria em 32 pools de threads IOProcess. Os threads nos primeiros 8 pools de threads seriam afinidadedos com todos os processadores lógicos no nó NUMA 0, mas com o processador ideal definido como 0, 1, 2, até 7. Os próximos 8 pools de threads seriam afinizados a todos os processadores lógicos no nó NUMA 1, com o processador ideal configurado para 8, 9, 10 até 15, e assim sucessivamente.

Numa, processador e correspondência do pool de threads

Nesse nível de afinidade, o escalonador tenta consistentemente usar o processador lógico ideal antes de qualquer outro, dentro do nó preferencial de NUMA. Se o processador lógico não estiver disponível, o agendador escolherá outro processador dentro do mesmo nó ou dentro do mesmo grupo de processadores se nenhum outro thread estiver disponível. Para obter mais informações e exemplos, consulte as configurações do Analysis Services 2012 (Blog do Wordpress).

Distribuição de trabalho entre threads do IOProcess

Ao considerar se a PerNumaNode propriedade deve ser definida, saber como IOProcess os threads são usados pode ajudá-lo a tomar uma decisão mais informada.

Lembre-se de que IOProcess é usado para tarefas de E/S associadas a consultas feitas pelo mecanismo de armazenamento no mecanismo multidimensional.

Quando um segmento é escaneado, o mecanismo identifica a partição à qual o segmento pertence e tenta enfileirar a tarefa do segmento para o pool de threads utilizado pela partição. Em geral, todos os segmentos que pertencem a uma partição enfileirarão suas tarefas no mesmo pool de threads. Em sistemas NUMA, esse comportamento é particularmente vantajoso porque todas as varreduras de uma partição usarão memória no cache do sistema de arquivos que é alocada localmente para esse nó NUMA.

Os cenários a seguir sugerem ajustes que às vezes podem melhorar o desempenho da consulta em sistemas NUMA:

  • Para grupos de medidas subparticionados (por exemplo, com uma única partição), aumente o número de partições. Usar apenas uma partição fará com que o mecanismo sempre enfileira tarefas para um pool de threads (pool de threads 0). Adicionar mais partições permite que o mecanismo use pools de threads adicionais.

    Como alternativa, se você não puder criar partições adicionais, tente definir PerNumaNode=0 como uma maneira de aumentar o número de threads disponíveis para o pool de threads 0.

  • Para bancos de dados nos quais as verificações de segmento são distribuídas uniformemente entre várias partições, a configuração PerNumaNode como 1 ou 2 pode melhorar o desempenho da consulta porque aumenta o número geral de pools de IOProcess threads usados pelo sistema.

  • Para soluções que têm várias partições, mas apenas uma é fortemente verificada, tente definir PerNumaNode=0 para ver se melhora o desempenho.

Embora tanto os scans de partição quanto os scans de dimensão usem o pool de threads IOProcess, os scans de dimensão usam exclusivamente o pool de threads 0. Isso pode resultar em uma carga ligeiramente desigual nesse pool de threads, mas o desequilíbrio deve ser temporário, pois as verificações de dimensão tendem a ser muito rápidas e pouco frequentes.

Observação

Ao alterar uma propriedade de servidor, lembre-se de que a opção de configuração se aplica a todos os bancos de dados em execução na instância atual. Escolha as configurações que beneficiam os bancos de dados mais importantes ou o maior número de bancos de dados. Não é possível definir a afinidade do processador no nível do banco de dados nem definir afinidade entre partições individuais e processadores específicos.

Para obter mais informações sobre a arquitetura do trabalho, consulte a seção 2.2 no Guia de Desempenho do SQL Server 2008 Analysis Services.

Conforme explicado na seção 2.4 do Guia de Operações do Analysis Services, se você aumentar o pool de threads de processamento, certifique-se de que as configurações CoordinatorExecutionMode e as configurações CoordinatorQueryMaxThreads tenham valores que permitam o uso completo do tamanho aumentado do pool de threads.

O Analysis Services usa um thread coordenador para coletar os dados necessários para concluir uma solicitação de processamento ou consulta. O coordenador primeiro enfileira um trabalho para cada partição que deve ser processada. Cada um desses trabalhos segue enfileirando mais trabalhos, dependendo do número total de segmentos que precisam ser escaneados na partição.

O valor padrão para CoordinatorExecutionMode é -4, o que significa um limite de 4 tarefas em paralelo por núcleo, restringindo o número total de tarefas de coordenação que podem ser executadas em paralelo por uma solicitação de subcubo no mecanismo de armazenamento.

O valor CoordinatorQueryMaxThreads padrão é 16, o que limita o número de trabalhos de segmento que podem ser executados em paralelo para cada partição.

Determinar as configurações atuais do pool de threads

Em cada inicialização de serviço, o Analysis Services gera as configurações atuais do pool de threads no arquivo msmdsrv.log, incluindo threads mínimos e máximos, máscara de afinidade do processador e simultaneidade.

O exemplo a seguir é um trecho do arquivo de log, mostrando as configurações padrão para o pool de threads de consulta (MinThread=0, MaxThread=0, Concurrency=2), em um sistema de 4 núcleos com hiper-threading habilitado. A máscara de afinidade é 0xFF, indicando 8 processadores lógicos. Observe que zeros à esquerda são anexados à máscara. Você pode ignorar os zeros à esquerda.

"10/28/2013 9:20:52 AM) Message: The Query thread pool now has 1 minimum threads, 16 maximum threads, and a concurrency of 16. Its thread pool affinity mask is 0x00000000000000ff. (Source: \\?\C:\Program Files\Microsoft SQL Server\MSAS11.MSSQLSERVER\OLAP\Log\msmdsrv.log, Type: 1, Category: 289, Event ID: 0x4121000A)"

Lembre-se de que o algoritmo para definir MinThread e MaxThread incorpora a configuração do sistema, especialmente o número de processadores. A postagem no blog a seguir oferece insights sobre como os valores são calculados: Configurações do Analysis Services 2012 (Blog do Wordpress). Observe que essas configurações e comportamentos estão sujeitos a ajustes nas versões subsequentes.

A lista a seguir mostra exemplos de outras configurações de máscara de afinidade, para diferentes combinações de processadores:

  • A afinidade para processadores 3-2-1-0 em um sistema de 8 núcleos resulta nessa máscara de bits: 00001111 e um valor hexadecimal: 0xF

  • A afinidade para processadores 7-6-5-4 em um sistema de 8 núcleos resulta nessa máscara de bits: 11110000 e um valor hexadecimal: 0xF0

  • A afinidade para processadores 5-4-3-2 em um sistema de 8 núcleos resulta nessa máscara de bits: 00111100 e um valor hexadecimal: 0x3C

  • A afinidade para processadores 7-6-1-0 em um sistema de 8 núcleos resulta nessa máscara de bits: 11000011 e um valor hexadecimal: 0xC3

Lembre-se de que em sistemas com vários grupos de processadores, uma máscara de afinidade separada é gerada para cada grupo, em uma lista separada por vírgulas.

Sobre MSMDSRV. INI

O arquivo msmdsrv.ini contém configurações para uma instância do Analysis Services, afetando todos os bancos de dados em execução nessa instância. Você não pode usar propriedades de configuração de servidor para otimizar o desempenho de apenas um banco de dados para a exclusão de todas as outras. No entanto, você pode instalar várias instâncias do Analysis Services e configurar cada instância para usar propriedades que beneficiam bancos de dados que compartilham características ou cargas de trabalho semelhantes.

Todas as propriedades de configuração do servidor são incluídas no arquivo msmdsrv.ini. Subconjuntos das propriedades mais propensas a serem modificadas também aparecem em ferramentas de administração, como o SSMS.

O conteúdo de msmdsrv.ini é idêntico para as instâncias tabulares e multidimensionais do Analysis Services. No entanto, algumas configurações se aplicam apenas a um modo. As diferenças de comportamento com base no modo do servidor são destacadas na documentação de referência de propriedades.

Observação

Para obter instruções sobre como definir propriedades, consulte Configurar propriedades do servidor no Analysis Services.

Consulte Também

Sobre processos e threadsVários ProcessadoresGrupos de ProcessadoresAlterações no Thread Pool de Analysis Services no SQL Server 2012Configurações de Configuração do Analysis Services 2012 (Blog do Wordpress)Suporte a sistemas que têm mais de 64 processadoresGuia de operações do SQL Server 2008 R2 Analysis Services

  • Last updated on