Dokuwiki

Cette page est en lecture seule. Vous pouvez afficher le texte source, mais ne pourrez pas le modifier. Contactez votre administrateur si vous pensez qu'il s'agit d'une erreur.
====== Tunning Kernel ======

__**Documentation officielle :**__ http://www.kernel.org/doc/Documentation/sysctl/

Voir toutes les valeurs du noyau :
  sysctl -a

===== virtual memory (vm) =====


  * **vm.dirty_background_ratio :** Pourcentage de dirty pages a partir duquel le pdflush doit commencer à écrire.
  * **vm.dirty_ratio :** : Pourcentage maxi de la mémoire totale qui peut être utilisé par les pages "sales" avant que le système force les processes à écrire eux-même physiquement au lieu de continuer à générer des écritures en mémoire. Il est à noter que tous les processes sont bloqués en écriture lorsque cela arrive et non pas seulement le process fautif.
  * **vm.swappiness :** (défaut 60) : La variable swappiness permet de faire varier l’utilisation de la mémoire vive par rapport à la swap. 0 permet de ne plus faire appel à la swap à la place de la RAM quand il reste encore de la mémoire.
  * **vm.dirty_background_bytes** : Idem que vm.dirty_background_ratio mais l'unité est en bytes au lieu qu'en pourcentage.
  * **vm.dirty_bytes** : Idem que vm.dirty_ratio mais l'unité est en bytes au lieu qu'en pourcentage.
  * **vm.dirty_writeback_centisecs** : Intervalle entre lequel le pdflush va se réveiller (100ths/sec) (Temps d'observation). Mettez 0 pour désactiver.
  * **vm.dirty_expire_centisecs** : Définit quand les données sont assez vieilles (100ths/sec) pour être interceptées par pdflush (temps d'attente).
  * **vm.drop_caches** : Mettre la valeur à 1 pour libérer les //pages mémoire//, à 2 pour libérer les //dentries// et les //inodes//, à 3 pour libérer les //pages mémoire//, les //dentries// et les //inodes//
  * **vm.swapiness** : Définit la gestion de la swap par le kernel. Plus la valeur est grande et plus le kernel aura tendance à swapper les pages mémoires les moins utilisées.
  * **vm.page-cluster** : Définit le nombre de pages mémoire consécutives à mettre dans la swap par passe. C'est 2 puissance fois la valeur définie et la valeur par défaut est 3. Cela signifie que lorsqu'un processus swap il mettra 2^3 pages en swap (c'est à dire 8).

===== kernel =====

<code>
root@debian:~# ipcs -l

------ Limites de la mémoire partagée --------
nombre maximal de segments = 4096                       // kernel.shmmni
taille maximale de segments (kilooctet) = 32768         // kernel.shmmax
total de mémoire partagée maximal (kilooctet) = 8388608 // kernel.shmall
taille minimale de segments (octet) = 1

------ Limites des sémaphores --------
nombre maximal de tableaux = 128                 // kernel.sem (4eme valeur)
nombre maximal de sémaphores par tableau = 250   // kernel.sem (1ere valeur)
nombre maximal de sémaphores système = 32000     // kernel.sem (2eme valeur)
nombre maximal d'opérations par appel semop = 32 // kernel.sem (3eme valeur)
valeur maximal de sémaphore = 32767

------ Limites de messages --------
nombre maximal de files système = 6040                // kernel.msgmni
taille maximale des messages (octets) = 8192          // kernel.msgmax
taille maximale par défaut des files (octets) = 16384 // kernel.msgmnb
</code>

  * **kernel.shmmax** : correspond à la taille maximale d'un segment de mémoire partagée 
  * **kernel.shmall** : correspond à l'attribution maximale de pages de mémoire partagée

===== net =====
<code>
man 7 socket
</code>

Les paramètres réseau de base des sockets sont accessibles en utilisant les fichiers du répertoire ///proc/sys/net/core///.

  * **net.core.rmem_default** : contient la taille en octets par défaut du tampon de réception.
  * **net.core.rmem_max** : contient la taille maximale en octets du tampon de réception qu'un utilisateur peut définir avec l'option //SO_RCVBUF// de la socket.
  * **net.core.wmem_default** : contient la taille en octets par défaut du tampon d'émission de la socket.
  * **net.core.wmem_max** : contient la taille maximale en octets du tampon d'émission qu'un utilisateur peut définir avec l'option //SO_SNDBUF// de la socket.
  * **net.core.message_cost** et **message_burst** : configurent le filtrage par jeton utilisé pour limiter la charge des messages d'avertissement dus aux événements réseau extérieurs.
  * **net.core.netdev_max_backlog** : contient le nombre maximal de paquets dans la file d'entrée globale.
  * **net.core.optmem_max** : contient la taille maximale par socket des données de service et des données de contrôle utilisateur comme les iovecs.

<code>
man tcp
man udp
</code>

  * **net.ipv4.tcp_rmem** : Il s'agit d'un vecteur de trois entiers : [min, défaut, max]. Ces paramètres sont utilisés par TCP pour régler la taille du tampon de réception. TCP ajuste dynamiquement la taille à partir de la valeur par défaut, dans l'intervalle de ces valeurs, en fonction de la mémoire disponible sur le système.
    * **min** : taille minimale du tampon de réception utilisée par chaque socket TCP. La valeur par défaut est la taille des pages du système (sous Linux 2.4, la valeur par défaut est de 4 Ko et descend à PAGE_SIZE octets sur les systèmes avec peu de mémoire). Cette valeur assure qu'en mode de mémoire chargée, les allocations en dessous de cette taille réussiront. Elle n'est pas utilisée pour limiter la taille du tampon de réception, déclarée en utilisant l'option //SO_RCVBUF// sur la socket.
    * **default** : la taille par défaut du tampon de réception pour une socket TCP. Cette valeur écrase la taille par défaut dans la valeur globale //net.core.rmem_default// définie pour tous les protocoles. La valeur par défaut est 87380 octets (sous Linux 2.4, elle descend à 43689 sur les systèmes avec peu de mémoire). Si une taille plus grande est désirée, il faut augmenter cette valeur (pour affecter toutes les sockets). Pour utiliser une grande fenêtre TCP, l'option //net.ipv4.tcp_window_scaling// doit être activée (par défaut).
    * **max** : la taille maximale du tampon de réception utilisé par chaque socket TCP. Cette valeur ne surcharge pas la valeur globale //net.core.rmem_max//. Elle ne permet pas de limiter la taille du tampon de réception déclarée avec l'option //SO_RCVBUF// sur la socket. La valeur par défaut est calculé par la formule : //max(87380, min(4MB, tcp_mem[1]*PAGE_SIZE/128))//
  * **net.ipv4.tcp_wmem** : Il s'agit d'un vecteur de trois entiers : [min, défaut, max]. Ces paramètres servent à TCP pour réguler la taille du tampon d'émission. La taille est ajustée dynamiquement à partir de la valeur par défaut, dans l'intervalle de ces valeurs, en fonction de la mémoire disponible.
    * **min** : La taille minimale du tampon d'émission utilisé par chaque socket TCP. La valeur par défaut est la taille des pages du système (sous Linux 2.4, la valeur par défaut est de 4 Ko). Cette valeur assure qu'en mode de mémoire chargée, les allocations en dessous de cette taille réussiront. Elle n'est pas utilisée pour limiter la taille du tampon de réception, déclarée en utilisant l'option //SO_SNDBUF// sur la socket.
    * **default** : La taille par défaut du tampon d'émission pour une socket TCP. Cette valeur surcharge la taille par défaut de valeur globale ///proc/sys/net/core/wmem_default// définie pour tous les protocoles. La valeur par défaut est 16 Ko. Si une taille plus grande est désirée, il faut augmenter cette valeur (pour affecter toutes les sockets). Pour utiliser une grande fenêtre TCP, ///proc/sys/net/ipv4/tcp_window_scaling// doit être positionné à une valeur non nulle (par défaut).
    * **max** : la taille maximale du tampon d'émission utilisé par chaque socket TCP. Cette valeur ne surcharge pas la valeur globale qui se trouve dans ///proc/sys/net/core/wmem_max//. Elle ne permet pas de limiter la taille du tampon de réception déclarée avec l'option //SO_SNDBUF// sur la socket. La valeur par défaut est calculée avec la formule : //max(65536, min(4MB, tcp_mem[1]*PAGE_SIZE/128))//
  * **net.ipv4.udp_mem** : (depuis Linux 2.6.25) C'est un vecteur de trois entiers qui contrôle le nombre de pages permises pour la queue de toutes les sockets UDP.
    * **min** : En  dessous  de  ce  nombre  de  pages, UDP ne se soucie pas de son appétit en mémoire. Quand la quantité de mémoire allouée par UDP dépasse cette valeur, UDP commence à limiter son utilisation mémoire.
    * **pressure** : Cette valeur a été introduite pour suivre le format de tcp_mem (voir tcp(7)).
    * **max** : Nombre de pages permises pour la queue de toutes les sockets UDP. Les valeurs par défaut pour ces trois éléments sont calculées au démarrage à partir de la quantité de mémoire disponible.
 **net.ipv4.udp_rmem_min** : (entier ; PAGE_SIZE par défaut ; depuis Linux 2.6.25) Taille minimale, en octets, des tampons de réception utilisés par les sockets UDP dans le mode de modération. Chaque socket UDP peut utiliser cette taille pour recevoir des données, même si le nombre total de pages pour les sockets UDP dépasse le seuil udp_mem.
  * **net.ipv4.udp_wmem_min** : (entier ; PAGE_SIZE par défaut ; depuis Linux 2.6.25) Taille minimale, en octets, du tampon d'émission utilisé par les sockets UDP dans le mode de modération. Chaque socket UDP peut utiliser cette taille pour envoyer des données, même si le nombre total de pages pour les sockets UDP dépasse le seuil udp_mem.
  * **tcp_low_latency** : (booléen ; désactivé par défaut ; depuis Linux 2.4.21/2.6) S'il est activé, la pile TCP prend des décisions qui favorisent une latence plus faible par opposition à un débit plus grand. Si cette  option est  désactivée,  un débit plus grand est préféré. Un cas où cette valeur par défaut devrait être changée est par exemple un cluster de calcul Beowulf.
  * **tcp_congestion_control** : (chaîne ; voir le texte pour la valeur par défaut ; depuis Linux 2.4.13) Définir l'algorithme de contrôle de congestion à utiliser pour les nouvelles connexions. L'algorithme « reno » est toujours disponible, mais des choix supplémentaires sont disponibles en fonction de la configuration du noyau. La valeur par défaut pour ce fichier est définie dans la configuration du noyau (cubic par défaut).
Voir les algo de congestions :
<code>
net.ipv4.tcp_allowed_congestion_control = cubic reno
net.ipv4.tcp_available_congestion_control = cubic reno
</code>

Exemple de tunning :
<code>
net.core.rmem_default = 16777216
net.core.rmem_max = 16777216
net.core.wmem_default = 16777216
net.core.wmem_max = 16777216
net.ipv4.tcp_rmem = 4096 87380 16777216
net.ipv4.tcp_wmem = 4096 65536 16777216
net.ipv4.tcp_mem = 4096 65536 16777216
net.core.netdev_max_backlog = 30000
</code>