Le module pg_prewarm fournit un moyen pratique
  de charger des données des relations dans le cache de données du système
  d'exploitation ou dans le cache de données de
  PostgreSQL. Ce préchargement
  peut être lancé manuellement avec la fonction pg_prewarm,
  ou automatiquement en incluant pg_prewarm dans
  shared_preload_libraries.
  Dans ce dernier cas, le système exécutera un processus d'arrière-plan
  (background worker)
  qui enregistrera périodiquement le contenu des shared buffers
  dans un fichier nommé autoprewarm.blocks puis,
  après un redémarrage rechargera ces blocs en utilisant deux
  background workers.
 
pg_prewarm(regclass, mode text default 'buffer', fork text default 'main',
           first_block int8 default null,
           last_block int8 default null) RETURNS int8
  
   Le premier argument est la relation qui doit être préchargée. Le
   second est la méthode de préchargement à utiliser,
   comme décrit plus bas. Le troisième argument correspond au type de
   fichier à précharger (généralement main). Le quatrième
   argument est le numéro du premier bloc à précharger
   (NULL est accepté comme synonyme de zéro). Le cinquième
   argument correspond au dernier numéro de bloc à précharger
   (NULL signifie que l'on précharge jusqu'au dernier bloc
   dans la relation). La valeur retournée correspond au nombre de blocs
   préchargés.
  
   Il y a trois méthodes de préchargement disponibles.
   prefetch envoie une requête de prélecture asynchrone au
   système d'exploitation si celui-ci le supporte ou sinon renvoie une erreur.
   read lit l'intervalle de blocs demandé. Contrairement à
   prefetch, toutes les plateformes et options de compilation
   le supportent, mais cette méthode peut être plus lente.
   buffer lit l'intervalle de blocs demandé pour le charger
   dans le cache de données de la base.
  
   Il est à noter qu'avec n'importe laquelle de ces méthodes, tenter de
   précharger plus de blocs qu'il n'est possible de mettre en cache  --  par
   le système d'exploitation en utilisant prefetch ou
   read, ou par PostgreSQL en
   utilisant buffer  --  aura probablement pour effet
   d'expulser du cache les blocs des numéros inférieurs au fur et à mesure que
   les blocs des numéros supérieurs seront lus. De plus, les données
   préchargées ne bénéficient d'aucune protection spécifique contre l'éviction
   du cache. Il est donc possible que d'autres activités du
   système d'exploitation puissent évincer du cache les données fraîchement
   préchargées peu après leur lecture. Pour toutes ces
   raisons, le préchargement est typiquement plus utile au démarrage, quand
   les caches sont majoritairement vides.
  
autoprewarm_start_worker() RETURNS void
Lance autoprewarm, le worker principal. Normalement cela est automatique, mais ce peut être utile si le préchauffage automatique n'était pas configuré au démarrage du serveur et que vous voulez démarrer le worker plus tard.
autoprewarm_dump_now() RETURNS int8
   Met à jour autoprewarm.blocks immédiatement. Ce peut
   être utile si le worker autoprewarm worker ne fonctionne pas mais que vous
   prévoyez de le lancer après le prochain redémarrage.
   La valeur retournée est le nombre d'enregistrements écrits dans
   autoprewarm.blocks.
  
   Ces paramètres doivent être configurés dans le fichier
   postgresql.conf. Un cas d'usage typique serait :
  
# postgresql.conf shared_preload_libraries = 'pg_prewarm' pg_prewarm.autoprewarm = true pg_prewarm.autoprewarm_interval = 300s
   Robert Haas <rhaas@postgresql.org>