Aumentar work_mem e shared_buffers no Postgres 9.2 reduz significativamente as consultas

Eu tenho uma instância do PostgreSQL 9.2 em execução no RHEL 6.3, máquina de 8 núcleos e 16 GB de RAM. O servidor é dedicado a este banco de dados. Dado que o postgresql.conf padrão é bastante conservador em relação às configurações de memória, pensei que seria uma boa idéia permitir que o Postgres usasse mais memória. Para minha surpresa, seguir os conselhos em wiki.postgresql.org/wiki/Tuning_Your_PostgreSQL_Server diminuiu significativamente praticamente todas as consultas que eu executo, mas é obviamente mais perceptível nas consultas mais complexas.

Também tentei executar o pgtune, que deu a seguinte recomendação com mais parâmetros ajustados, mas isso não mudou nada. Ele sugere compartilhamentos de 1/4 do tamanho da RAM, o que parece estar de acordo com os conselhos em outros lugares (e no PG wiki em particular).

default_statistics_target = 50
maintenance_work_mem = 960MB
constraint_exclusion = on
checkpoint_completion_target = 0.9
effective_cache_size = 11GB
work_mem = 96MB
wal_buffers = 8MB
checkpoint_segments = 16
shared_buffers = 3840MB
max_connections = 80

Tentei reindexar todo o banco de dados depois de alterar as configurações (usando reindex database), mas isso também não ajudou. Eu brinquei com shared_buffers e work_mem. Alterá-los gradualmente dos valores padrão muito conservadores (128k / 1MB) diminuiu gradualmente o desempenho.

Fiz EXPLAIN (ANALYZE,BUFFERS)algumas consultas e o culpado parece ser que o Hash Join é significativamente mais lento. Não está claro para mim o porquê.

Para dar um exemplo específico, tenho a seguinte consulta. Ele é executado em ~ 2100ms na configuração padrão e ~ 3300ms na configuração com tamanhos de buffer aumentados:

select count(*) from contest c
left outer join contestparticipant cp on c.id=cp.contestId
left outer join teammember tm on tm.contestparticipantid=cp.id
left outer join staffmember sm on cp.id=sm.contestparticipantid
left outer join person p on p.id=cp.personid
left outer join personinfo pi on pi.id=cp.personinfoid
where pi.lastname like '%b%' or pi.firstname like '%a%';

EXPLAIN (ANALYZE,BUFFERS) para a consulta acima:

• Buffers padrão: http://explain.depesz.com/s/xaHJ
• Buffers maiores: http://explain.depesz.com/s/Plk

A questão é por que estou observando uma diminuição no desempenho ao aumentar o tamanho do buffer? A máquina definitivamente não está ficando sem memória. A alocação se a memória compartilhada no sistema operacional for ( shmmaxe shmall) estiver definida com valores muito grandes, isso não deve ser um problema. Também não estou recebendo nenhum erro no log do Postgres. Estou executando o vácuo automático na configuração padrão, mas não espero que tenha algo a ver com isso. Todas as consultas foram executadas na mesma máquina com alguns segundos de diferença, apenas com a configuração alterada (e o PG reiniciado).

Edit: Acabei de encontrar um fato particularmente interessante: quando eu executo o mesmo teste no meu iMac de meados de 2010 (OSX 10.7.5) também com Postgres 9.2.1 e 16GB de RAM, não sinto a lentidão. Especificamente:

set work_mem='1MB';
select ...; // running time is ~1800 ms
set work_mem='96MB';
select ...' // running time is ~1500 ms

Quando faço exatamente a mesma consulta (a acima) com exatamente os mesmos dados no servidor, recebo 2100 ms com work_mem = 1MB e 3200 ms com 96 MB.

O Mac tem SSD, portanto é compreensivelmente mais rápido, mas apresenta um comportamento que eu esperaria.

Veja também a discussão de acompanhamento sobre o pgsql-performance .

Primeiro, lembre-se de que work_mem é por operação e, portanto, pode ser excessivo rapidamente. Em geral, se você não está tendo problemas com a classificação lenta, deixaria o work_mem em paz até que você precise.

Observando seus planos de consulta, uma coisa que me impressiona é que os acertos do buffer são muito diferentes, observando os dois planos, e que mesmo as varreduras seqüenciais são mais lentas. Suspeito que o problema tenha a ver com o cache de leitura antecipada e com menos espaço para isso. O que isso significa é que você está influenciando a memória para reutilizar índices e contra a leitura de tabelas no disco.

Meu entendimento é que o PostgreSQL procurará no cache uma página antes de lê-la do disco, porque não sabe realmente se o cache do SO conterá essa página. Como as páginas ficam no cache e esse cache é mais lento que o cache do SO, isso altera os tipos de consultas mais rápidas do que as mais lentas. De fato, lendo os planos, além dos problemas do work_mem, parece que todas as suas informações de consulta vêm do cache, mas é uma questão de qual cache.

work_mem : quanta memória podemos alocar para uma operação de classificação ou junção relacionada. Isso é por operação, não por instrução ou por back-end, portanto, uma única consulta complexa pode usar muitas vezes essa quantidade de memória. Não está claro que você esteja atingindo esse limite, mas vale a pena notar e estar ciente disso. se você aumentar demais, perderá a memória que pode estar disponível para o cache de leitura e os buffers compartilhados.

shared_buffers : quanta memória alocar para a fila de páginas real do PostgreSQL. Agora, o ideal é que o conjunto interessante de seu banco de dados fique na memória armazenada em cache aqui e nos buffers de leitura. No entanto, o que isso faz é garantir que as informações usadas com mais freqüência em todos os back-end sejam armazenadas em cache e não liberadas para o disco. No Linux, esse cache é significativamente mais lento que o cache do disco do SO, mas oferece garantias de que o cache do disco do SO não é e é transparente para o PostgreSQL. Isto é claramente onde está o seu problema.

Então, o que acontece é que, quando temos uma solicitação, verificamos primeiro os buffers compartilhados, já que o PostgreSQL tem profundo conhecimento desse cache e procuramos as páginas. Se eles não estiverem lá, solicitamos ao sistema operacional que os abra do arquivo e, se o sistema operacional armazenou em cache o resultado, ele retornará a cópia em cache (isso é mais rápido que os buffers compartilhados, mas a Pg não pode dizer se está em cache ou disco, e como o disco é muito mais lento, o PostgreSQL normalmente não se arrisca). Lembre-se de que isso afeta também o acesso aleatório ou seqüencial à página. Portanto, você pode obter um melhor desempenho com as configurações mais baixas dos compartilhados.

Meu pressentimento é que você provavelmente obtém um desempenho melhor ou pelo menos mais consistente em ambientes de alta simultaneidade com configurações maiores de buffer compartilhado. Lembre-se também de que o PostgreSQL pega essa memória e a mantém; assim, se você tiver outras coisas em execução no sistema, os buffers de leitura manterão os arquivos lidos por outros processos. É um tópico muito grande e complexo. Configurações de buffer compartilhado maiores oferecem melhores garantias de desempenho, mas podem oferecer menos desempenho em alguns casos.

Além do efeito aparentemente paradoxal de que o aumento work_memdiminui o desempenho (o @Chris pode ter uma explicação), você pode melhorar sua função de pelo menos duas maneiras.

• Reescreva duas falsas LEFT JOINcom JOIN. Isso pode confundir o planejador de consultas e levar a planos inferiores.

SELECT count(*) AS ct
FROM   contest            c
JOIN   contestparticipant cp ON cp.contestId = c.id
JOIN   personinfo         pi ON pi.id = cp.personinfoid
LEFT   JOIN teammember    tm ON tm.contestparticipantid = cp.id
LEFT   JOIN staffmember   sm ON sm.contestparticipantid = cp.id
LEFT   JOIN person        p  ON p.id = cp.personid
WHERE (pi.firstname LIKE '%a%'
OR     pi.lastname  LIKE '%b%')

• Supondo que seus padrões de pesquisa reais sejam mais seletivos, use índices de trigramas pi.firstnamee pi.lastnamesuporte a LIKEpesquisas não ancoradas . (Padrões mais curtos, como também '%a%'são suportados, mas é provável que um índice não ajude para predicados não seletivos.):

CREATE INDEX personinfo_firstname_gin_idx ON personinfo USING gin (firstname gin_trgm_ops);
CREATE INDEX personinfo_lastname_gin_idx  ON personinfo USING gin (lastname gin_trgm_ops);

Ou um índice de várias colunas:

CREATE INDEX personinfo_name_gin_idx ON personinfo USING gin (firstname gin_trgm_ops, lastname gin_trgm_ops);

Deve tornar sua consulta um pouco mais rápida. Você precisa instalar o módulo adicional pg_trgm para isso. Detalhes sobre estas perguntas relacionadas:

• Como o LIKE é implementado?
• Correspondência de padrões com LIKE, SIMILAR TO ou expressões regulares no PostgreSQL

Além disso, você já tentou configurar work_mem localmente - apenas para a transação atual ?

SET LOCAL work_mem = '96MB';

Isso impede que as transações simultâneas também consumam mais RAM, possivelmente passando fome.