Comprendre la mise en cache des routes IPv4 sous Linux

Vincent Bernat

Avis d’ob­so­lescence

Les in­for­ma­tions de cet ar­ticle sont dé­sor­mais pé­ri­mées étant donné que le cache des routes a été re­tiré de Li­nux 3.6. L’ar­ticle « Fonc­tion­ne­ment de la table de rou­tage IPv4 sous Li­nux » pro­pose une ana­lyse per­ti­nente pour les noyaux plus récents.

Afin d’amé­lio­rer les per­for­mances lors de la consul­ta­tion des tables de rou­tage, Li­nux main­tient un cache des routes. Dans le cadre d’un rou­teur, l’in­ef­fi­ca­cité de ce cache peut en­gen­drer un im­pact im­por­tant sur les per­formances.

La do­cu­men­ta­tion de ce com­po­sant est très ré­duite. Il est dif­fi­cile de trou­ver des ex­pli­ca­tions à jour sur le fonc­tion­ne­ment et l’op­ti­mi­sa­tion de ce cache. Le livre « Un­ders­tan­ding Li­nux Net­work In­ter­nals » édité par O’Reilly est une ex­cep­tion et contient de pré­cieuses in­for­ma­tions sur le su­jet. Même s’il a été écrit à l’époque du 2.6.12, la par­tie sur le cache des routes est tou­jours d’ac­tua­lité. Mal­heu­reu­se­ment, ce livre est orienté dé­ve­lop­peur et ne s’at­tarde pas sur l’ad­mi­nis­tra­tion du cache.

J’es­père four­nir ici une vue concise sur le cache des routes, tel qu’im­plé­menté dans Li­nux 3.11. Ce cache est dé­pen­dant du pro­to­cole sous-ja­cent2 et je ne couvre ici que la ver­sion IPv4.

Vue d’ensemble du cache des routes#

Lorsque le noyau doit prendre une dé­ci­sion sur com­ment rou­ter un pa­quet IP, il consulte ses tables de rou­tage. Bien que cela semble as­sez tri­vial, il doit ré­pondre à un cer­tain nombre de questions :

  • Est-ce que les adresses source et des­ti­na­tion semblent valides ?
  • Est-ce que l’adresse source est mar­tienne3 ?
  • Est-ce que l’adresse de des­ti­na­tion est por­tée par le sys­tème ou doit-il rou­ter le pa­quet vers un autre système ?
  • Quelle table de rou­tage faut-il utiliser ?
  • Est-ce que l’adresse de des­ti­na­tion cor­res­pond à cette route ? Ou à celle-là ?
  • Est-ce que la pas­se­relle à uti­li­ser est ac­tuel­le­ment dis­ponible ?

Toutes ces vé­ri­fi­ca­tions peuvent prendre du temps, y com­pris pour des tables de rou­tage ré­duites. Aussi, Li­nux tient à jour un cache des routes in­ter­rogé avant de consul­ter les tables de rou­tage et mis à jour après chaque consul­ta­tion. La com­mande ip -s route show cache per­met de vi­sua­li­ser ce cache :

$ ip -s route show cache
198.51.100.7 from 203.0.113.2 via 192.0.2.1 dev eth1
  cache used 7 age 2sec ipid 0x1fce rtt 131ms rttvar 45ms cwnd 10
198.51.100.17 from 203.0.113.15 via 192.0.2.1 dev eth1
  cache used 3 age 0sec ipid 0xc3bd
local 192.0.2.18 from 203.0.113.15 dev lo src 192.0.2.18
  cache <local> used 154 age 1sec iif eth0

Voici deux exemples :

  • Si Li­nux re­çoit un pa­quet de des­tiné 203.0.113.15 à 198.51.100.17, il va trou­ver le flux cor­res­pon­dant dans le cache. Il sait donc im­mé­dia­te­ment qu’il a be­soin de faire suivre ce pa­quet à la pas­se­relle 192.0.2.1. Au­cune vé­ri­fi­ca­tion n’est né­cessaire.
  • S’il re­çoit un pa­quet de 203.0.113.16 pour 198.51.100.17, il n’existe au­cune en­trée ap­pro­priée dans le cache et le sys­tème doit donc se ra­battre sur les tables de rou­tage clas­siques. Il est pro­bable que la même route que lorsque la source était 203.0.113.15 soit uti­li­sée, mais il est pos­sible qu’il existe une po­li­tique de rou­tage dif­fé­rente (im­pli­quant une autre table de rou­tage) ou que 203.0.113.16 soit une adresse por­tée par le sys­tème lui-même et sera donc consi­dé­rée comme martienne.

Le schéma ci-des­sous in­dique com­ment est im­plé­menté ce cache dans Li­nux4. Il uti­lise une table de ha­chage à la dif­fé­rence des sys­tèmes BSD qui gardent le cache dans la table de rou­tage. Chaque en­trée est une liste chaî­née où chaque élé­ment est une en­trée du cache.

Schéma de la table de hachage utilisé pour le cache des routes
Vue partielle avec trois entrées de la table de hachage utilisée par le cache des routes

Une fois qu’une en­trée se trouve dans le cache, elle peut être re­ti­rée par di­vers mé­ca­nismes. La plu­part des en­trées sont re­ti­rées par le ra­masse-miettes (gar­bage col­lec­tor) qui par­court le cache à la re­cherche d’en­trées in­va­lides ou trop vieilles. Il est ac­tivé quand le cache est plein ou, à in­ter­valles ré­gu­liers, passé un cer­tain seuil.

Réglages disponibles#

Il existe plu­sieurs ré­glages pour mo­di­fier le com­por­te­ment du cache. La plu­part d’entre eux sont dis­po­nibles via la com­mande sysctl.

  • rhash_​entries est la taille de la table de ha­chage5. Si sa va­leur n’est pas spé­ci­fiée sur la ligne de com­mande du noyau, elle est cal­cu­lée au dé­mar­rage du sys­tème se­lon la mé­moire dis­po­nible. Il est pos­sible de la connaître en cher­chant, dans les jour­naux du noyau, quelque chose comme IP route cache hash table entries: 262144 (order: 9, 2097152 bytes).
  • net.​ipv4.​route.​max_​size est le nombre maxi­mum d’en­trées dans le cache. Ex­cepté en des cir­cons­tances ex­cep­tion­nelles, cette va­leur ne peut ja­mais être dépassée.
  • net.​ipv4.​route.​gc_​elasticity re­pré­sente la taille moyenne des listes chaî­nées dans la table de ha­chage. Le ra­masse-miettes va se mon­trer plus agres­sif lorsque cette taille est dé­pas­sée. Cela si­gni­fie que le pro­duit de cette va­leur avec rhash_​entries cor­res­pond au nombre d’en­trées que le ra­masse-miettes va ten­ter de conser­ver dans le cache.
  • net.​ipv4.​route.​gc_​min_​interval_ms est le dé­lai mi­ni­mal entre deux exé­cu­tions du ra­masse-miettes. Ce dé­lai n’est pas res­pecté si le cache est plein. La va­leur par dé­faut convient dans la grande ma­jo­rité des cas.
  • net.​ipv4.​route.​gc_​thresh est le seuil de dé­clen­che­ment du ra­masse-miettes. Ce­lui s’exé­cute alors toutes les net.​ipv4.​route.​gc_​min_​interval_ms mil­li­secondes.
  • net.​ipv4.​route.​gc_​timeout est la va­leur de base uti­li­sée pour dé­ter­mi­ner si une en­trée est suf­fi­sam­ment an­cienne pour être re­ti­rée. Quelle que soit la va­leur de ce pa­ra­mètre, le ra­masse-miettes ten­tera d’en­le­ver le même nombre d’en­trées. Tou­te­fois, cette va­leur peut in­fluen­cer son ef­fi­ca­cité. Nous ver­rons cela plus en dé­tail par la suite.

Il existe deux ré­glages que l’on re­trouve sou­vent dans les do­cu­men­ta­tions mais qui sont dé­sor­mais ob­solètes :

  • net.​ipv4.​route.​secret_​interval a été re­tiré de Li­nux 2.6.35 ; il per­met­tait de vi­dan­ger le cache à in­ter­valles ré­gu­liers pour évi­ter qu’il ne se remplisse.
  • net.​ipv4.​route.​gc_​interval a été re­tiré de Li­nux 2.6.38. Il est tou­jours pré­sent jusqu’à la ver­sion 3.2 mais sans ef­fet. Il per­met­tait de dé­clen­cher un net­toyage ré­gu­lier du cache. Le ra­masse-miettes est dé­sor­mais ca­pable de se dé­brouiller seul.

Mise à jour (12.2011)

Le pa­ra­mètre net.​ipv4.​route.​gc_​interval est de re­tour dans Li­nux 3.2. Il est en ef­fet né­ces­saire pour évi­ter d’en­rayer le ra­masse-miette du cache ARP grâce à un net­toyage pé­rio­dique (contrai­re­ment au ra­masse-miette qui se dé­clenche uni­que­ment passé un cer­tain seuil). Il est pré­fé­rable de lais­ser ce pa­ra­mètre à sa va­leur par dé­faut qui est 60.

Statistiques & surveillance#

Li­nux main­tient un cer­tain nombre de sta­tis­tiques sur le cache des routes. Celles-ci sont si­tuées dans /proc/​net/​stat/​rt_​cache. La com­mande lnstat per­met de les af­fi­cher de ma­nière conviviale :

$ lnstat -s1 -i1 -c-1 -f rt_cache
rt_cache|rt_cache|rt_cache|rt_cache|rt_cache|rt_cache|rt_cache|rt_cache|rt_cache|rt_cache|rt_cache|rt_cache|rt_cache|rt_cache|rt_cache|rt_cache|rt_cache|
 entries|  in_hit|in_slow_|in_slow_|in_no_ro|  in_brd|in_marti|in_marti| out_hit|out_slow|out_slow|gc_total|gc_ignor|gc_goal_|gc_dst_o|in_hlist|out_hlis|
        |        |     tot|      mc|     ute|        |  an_dst|  an_src|        |    _tot|     _mc|        |      ed|    miss| verflow| _search|t_search|
 3096848|   42309|     686|       0|       0|       0|       0|       0|       3|       0|       0|     674|     672|       0|       0|   27644|       8|
 3096984|   41405|     636|       0|       0|       0|       0|       0|       3|       0|       0|     623|     621|       0|       0|   28189|       8|
 3097160|   42483|     700|       0|       0|       0|       0|       0|       5|       0|       0|     694|     692|       0|       0|   29506|      12|

À l’ex­cep­tion de la pre­mière co­lonne, toutes les va­leurs af­fi­chées sont en uni­tés par se­conde. Voyons ce que si­gni­fient cer­taines d’entre elles :

  • rt_​cache_​entries est le nombre d’en­trées ac­tuel­le­ment dans le cache. Cette va­leur est à com­pa­rer avec net.​ipv4.​route.​max_​size pour s’as­su­rer que le cache n’est ja­mais plein et évi­ter ainsi le dé­clen­che­ment continu du ra­masse-miettes.
  • rt_​cache_​in_​hit et rt_​cache_​out_​hit re­pré­sentent le nombre de fois où une route a été trou­vée dans le cache pour les pa­quets en­trants et sor­tants, res­pec­ti­ve­ment. Quand un sys­tème est uti­lisé comme rou­teur, la route est dé­ter­mi­née lorsque le pa­quet ar­rive sur le sys­tème. Ces va­leurs sont à com­pa­rer avec rt_​cache_​in_​slow_​tot et rt_​cache_​in_​out_​slow_​tot qui sont le nombre de fois où les tables de rou­tage clas­siques ont dû être consul­tées. Sur ce sys­tème, l’ef­fi­ca­cité du cache est de plus de 98 %.
  • rt_​cache_​gc_​total in­dique com­bien de fois le ra­masse-miettes a été sol­li­cité tan­dis que rt_​cache_​gc_​ignored cor­res­pond au nombre de fois où il n’a fi­na­le­ment rien fait car il a été dé­marré peu de temps au­pa­ra­vant (moins de net.​ipv4.​route.​gc_​min_​interval_ms mil­li­se­condes). La dif­fé­rence entre ces deux va­leurs doit être faible afin de s’as­su­rer que le ra­masse-miettes ne se dé­clenche pas plus de quelques fois par seconde.
  • rt_​cache_​gc_​goal_​miss in­dique com­bien de fois le ra­masse-miettes n’a pas été ca­pable d’en­le­ver les en­trées qu’il au­rait sou­haité re­ti­rer. Cette va­leur doit être ra­re­ment dif­fé­rente de 0.
  • rt_​cache_​gc_​dst_​overflow est le nombre de fois où le cache est plus gros que le maxi­mum au­to­risé. Cela ne doit ja­mais ar­ri­ver, sauf lorsque la taille du cache est changée.
  • rt_​cache_​in_​hlist_​search et rt_​cache_​out_​hlist_​search in­dique com­bien de fois il a été né­ces­saire d’avan­cer dans une liste chaî­née de la table de ha­chage : à chaque fois que Li­nux doit suivre le poin­teur next, un de ces comp­teurs est in­cré­menté. Ces va­leurs sont à com­pa­rer avec le nombre de re­quêtes uti­li­sant le cache (que celles-ci aient réussi ou non).

À titre d’illus­tra­tion, le gra­phique sui­vant montre les dif­fé­rentes sta­tis­tiques ex­po­sées ci-des­sus dans le cas d’un rou­teur re­ce­vant en­vi­ron un mil­lier de nou­velles routes par seconde :

Graphique montrant les diverses statistiques issues du cache des routes
Statistiques issues du cache des routes

rhash_​entries a comme va­leur 1 048 576, de même pour net.​ipv4.​route.​gc_​thresh. Ainsi, le ra­masse-miettes s’ac­tive à par­tir de ce seuil. Il n’est exé­cuté que deux fois par se­conde (la va­leur de net.​ipv4.​route.​gc_​interval_ms est 500) car le cache n’est pas plein. net.​ipv4.​route.​gc_​elasticity a comme va­leur 3. Cela ex­plique pour­quoi le ra­masse-miettes de­vient plus agres­sif lorsque le nombre d’en­trées at­teint 3 145 728.

Comme vous pou­vez le consta­ter, l’ef­fi­ca­cité du cache culmine constam­ment à près de 100 %. Le pour­cen­tage de col­li­sions cor­res­pond au rap­port de rt_​cache_​in_​hlist_​search avec la somme de rt_​cache_​in_​hit et rt_​cache_​in_​slow_tot.

Mise à jour (12.2011)

Le gra­phique ci-des­sus pro­vient de va­leurs ré­col­tées sur un noyau 2.6.39. Pour un noyau 2.6.35, 2.6.36, 2.6.37 ou 3.2 ou plus ré­cent, le net­toyage ef­fec­tué toutes les net.​ipv4.​route.​gc_​interval se­condes va re­ti­rer jusqu’à rhash_​entries en­trées. Si la vi­tesse à la­quelle les nou­velles routes sont ajou­tées dans le cache est in­fé­rieure à ce rythme, le nombre d’en­trées dans le cache peut dé­croître même si le seuil dé­fini par net.​ipv4.​route.​gc_​threshold n’est pas at­teint. À titre d’exemple, voici ce qu’on ob­tient sur un rou­teur équipé d’un noyau 2.6.35 et re­ce­vant en­vi­ron 2500 nou­velles routes par se­conde ; le seuil de 1 048 576 n’est ja­mais at­teint et le ra­masse-miette ne se dé­clenche donc jamais :

Graphique montrant les diverses statistiques issues du cache des routes sous influence de gc_interval
Statistiques issues du cache des routes avec un 2.6.35 pour lequel gc_interval est égal à 60

Optimisations#

Quelles sont les va­leurs à mo­di­fier ? Il faut se po­ser prin­ci­pa­le­ment deux questions :

  1. Quelle ef­fi­ca­cité veut-on ob­te­nir du cache ?
  2. Quelle quan­tité de mé­moire veut-on dé­dier au cache ?

Concer­nant la mé­moire, il faut comp­ter en­vi­ron 500 Mio pour deux mil­lions d’en­trées sur un sys­tème 64 bits. À par­tir de là, il est pos­sible de cal­cu­ler la consom­ma­tion moyenne et maxi­male à par­tir des va­leurs de net.​ipv4.​route.​max_​size, rhash_​entries et net.​ipv4.​route.​gc_​elasticity. Par exemple, si la table de ha­chage peut conte­nir 262 144 en­trées, que le nombre d’en­trées maxi­mal dans le cache est 4 194 304 et que la va­leur de net.​ipv4.​route.​gc_​elasticity est 8, le cache va uti­li­ser en moyenne 500 Mio et au maxi­mum 1 Gio. Si cela re­pré­sente trop de mé­moire, il faut mo­di­fier cer­taines valeurs.

Concer­nant l’ef­fi­ca­cité, la sec­tion pré­cé­dente in­dique com­ment la cal­cu­ler à par­tir des sta­tis­tiques ex­por­tées par Li­nux. En règle gé­né­rale, l’ef­fi­ca­cité est su­pé­rieure à 90 %. Pour l’amé­lio­rer, il peut être né­ces­saire d’aug­men­ter la taille du cache.

Pour dou­bler le nombre d’en­trées dans le cache, il faut dou­bler net.​ipv4.​route.​max_​size, net.​ipv4.​route.​gc_​thresh et rhash_​entries mais gar­der net.​ipv4.​route.​gc_​elasticity à 8.

Pour que le ra­masse-miettes soit ef­fi­cace, le cache ne doit pas se rem­plir trop vite. Le ra­masse-miettes peut nor­ma­le­ment s’adap­ter à cette si­tua­tion en ef­fec­tuant plu­sieurs passes pour re­ti­rer des en­trées mais cela im­pacte alors les per­for­mances. Il faut sur­veiller gc_​goal_​miss : si cette va­leur a ten­dance à ne pas res­ter nulle, il peut alors être sou­hai­table de di­mi­nuer net.​ipv4.​route.​gc_​timeout.

Mise à jour (12.2011)

Avec un noyau où le pa­ra­mètre net.​ipv4.​route.​gc_​interval a une in­fluence, les choses se com­pliquent. L’al­go­rithme de net­toyage va re­ti­rer des en­trées à in­ter­valles ré­gu­liers d’une fa­çon plus com­pli­quée à pré­dire. Le nombre moyen d’en­trées peut donc être plus faible que la va­leur théo­rique cal­cu­lée ci-des­sus à moins que le nombre de nou­velles en­trées par se­conde soit suf­fi­sam­ment élevé. La sur­veillance des dif­fé­rentes mé­triques est donc in­dis­pen­sable pour trou­ver les ré­glages ap­pro­priés. Si les en­trées semblent ex­pi­rer trop vite, il est pos­sible de dou­bler la va­leur de net.​ipv4.​route.​gc_​timeout.

Le ramasse-miettes en détails#

Pour mieux com­prendre les in­di­ca­tions don­nées au­pa­ra­vant, il est né­ces­saire d’exa­mi­ner le fonc­tion­ne­ment du ra­masse-miettes. Ce­lui-ci est prin­ci­pa­le­ment ac­tivé lorsqu’une nou­velle en­trée doit être ajou­tée au cache et que le nombre d’en­trées ac­tuel­le­ment en cache dé­passe le seuil net.​ipv4.​route.​gc_​thresh. Il est im­plé­menté dans la fonc­tion rt_​garbage_​collect(). Il ne fait rien s’il a déjà été ap­pelé il y a moins de net.​ipv4.​route.​gc_​interval_ms mil­li­se­condes, à moins que le cache ne soit plein (plus de net.​ipv4.​route.​max_​size entrées).

Choisir un but#

Le ra­masse-miettes va tout d’abord exa­mi­ner la si­tua­tion. Il com­pare le nombre d’en­trées ac­tuel­le­ment dans le cache avec le pro­duit de rhash_​entries et de net.​ipv4.​route.​gc_​elasticity:

  1. au-des­sous de cette li­mite, il en­lève au plus la moi­tié de la dif­férence ;
  2. dans le cas contraire, il va ten­ter d’en­le­ver au moins rhash_​entries entrées.

Si on exa­mine le gra­phique pré­cé­dent, il est aisé de consta­ter la dif­fé­rence quand le ra­masse-miettes est peu agres­sif (plus de 1 048 576 en­trées mais moins de 3 145 728) et quand il l’est (au-des­sus de 3 145 728 en­trées). En sup­po­sant que le ra­masse-miettes est ca­pable d’at­teindre son but, il est as­sez simple de si­mu­ler son al­gorithme:

Graphique montrant l'influence des divers paramètres sur le ramasse-miettes
Variations sur les différents paramètres du cache et leurs effets

La pre­mière courbe montre ce qu’il se passe si en­vi­ron 2000 nou­velles routes sont ajou­tées par se­conde avec rhash_​entries égal à 262 144 et net.​ipv4.​route.​gc_​elasticity égal à 8. Quand le seuil net.​ipv4.​route.​gc_​threshold est at­teint, le ra­masse-miettes n’a qua­si­ment au­cun ef­fet. Ce­pen­dant, quand le nombre d’en­trées at­teint 2 097 152, il re­tire 262 144 en­trées. À par­tir de là, le nombre d’en­trées os­cille aux en­vi­rons de deux millions.

Sur la se­conde courbe, rhash_​entries est dé­sor­mais égal à 1 048 576 mais net.​ipv4.​route.​gc_​elasticity vaut 2. Ainsi, le seuil à par­tir du­quel le ra­masse-miettes de­vient agres­sif est le même. Ce­pen­dant, il en­lève cette fois-ci quatre fois plus d’en­trées à chaque fois. Ce qui est ga­gné d’un côté (faire tour­ner moins sou­vent le ra­masse-miettes) est perdu de l’autre (plus d’en­trées à sup­pri­mer à chaque fois). Pour amé­lio­rer l’ef­fi­ca­cité du cache, il semble pré­fé­rable de gar­der net.​ipv4.​route.​gc_​elasticity à 8 ou éven­tuel­le­ment 4 pour rac­cour­cir la taille des chaînes (mais le gain semble es­sen­tiel­le­ment théo­rique dans ce cas).

Les autres courbes montrent ce qui se pro­duit quand il y a un sou­dain af­flux de routes ou au contraire lorsqu’il y a une pause.

Réalisation de l’objectif#

Main­te­nant que nous com­pre­nons bien com­ment rhash_​entries, net.​ipv4.​route.​gc_​elasticity et net.​ipv4.​route.​gc_​threshold in­ter­agissent, re­gar­dons net.​ipv4.​route.​gc_​timeout. Une fois que le ra­masse-miettes s’est fixé un ob­jec­tif, il doit choi­sir les en­trées à retirer.

Pour se faire, il par­court la table de ha­chage de­puis sa der­nière po­si­tion et re­tire les en­trées sé­lec­tion­nées jusqu’à at­teindre son ob­jec­tif. Si l’en­trée n’est plus à jour (par exemple, si l’in­ter­face ré­seau as­so­ciée a une confi­gu­ra­tion dif­fé­rente), elle est re­ti­rée. Dans le cas contraire, le sys­tème va consi­dé­rer à la fois son âge et sa po­si­tion dans la chaîne. Si l’en­trée est en pre­mière po­si­tion, elle n’est conser­vée que si son âge est in­fé­rieur à net.​ipv4.​route.​gc_​timeout. Si elle est en se­conde po­si­tion, elle n’est conser­vée que si son âge est in­fé­rieur à la moi­tié de net.​ipv4.​route.​gc_​timeout. En troi­sième po­si­tion, le seuil est le quart de net.​ipv4.​route.​gc_​timeout et ainsi de suite. Cela per­met au ra­masse-miettes de fa­vo­ri­ser les chaînes courtes.

Si après un par­cours com­plet de la table, le ra­masse-miettes n’a pas pu at­teindre son ob­jec­tif, il ef­fec­tue un nou­veau par­cours en agis­sant comme si net.​ipv4.​route.​gc_​timeout avait été di­visé par deux. Il fera au­tant de passes que né­ces­saire jusqu’à at­teindre l’ob­jec­tif ou jusqu’à l’im­pos­si­bi­lité de sup­pri­mer toute en­trée sup­plé­men­taire (ou en­core s’il a passé trop de temps). Une fois que le ra­masse-miettes se trouve dans ce mode agres­sif, il conserve ce com­por­te­ment sur plu­sieurs cycles en l’at­té­nuant à chaque passage.

Si net.​ipv4.​route.​gc_​timeout est très grand, le ra­masse-miettes va avoir beau­coup de mal à trou­ver des en­trées à re­ti­rer. Plu­sieurs passes se­ront né­ces­saires. Au contraire, si la va­leur est trop pe­tite, il va re­ti­rer très ra­pi­de­ment des en­trées alors qu’il existe de meilleurs can­di­dats plus tard dans la table.

Pour plus de dé­tails sur le fonc­tion­ne­ment du cache des routes, le cha­pitre 33 de « Un­ders­tan­ding Li­nux Net­work In­ter­nals » consti­tue une res­source in­con­tour­nable. Il faut tou­te­fois no­ter que le cache des routes mul­ti­path n’existe plus et que les net­toyages asyn­chrones (rt_​periodic_​timer) ont éga­le­ment été retirés.

Mise à jour (12.2011)

Comme in­di­qué pré­cé­dem­ment, le pa­ra­mètre net.​ipv4.​route.​gc_​interval a été ré­in­tro­duit dans Li­nux 3.2. L’al­go­rithme de net­toyage uti­lisé est dif­fé­rent de ce­lui du ra­masse-miette mais a de nom­breuses si­mi­litudes.

Il est exé­cuté toutes les net.​ipv4.​route.​gc_​interval se­condes, y com­pris si le seuil dé­fini par net.​ipv4.​route.​gc_​threshold n’est pas at­teint. Il dé­ter­mine un but pro­por­tion­nel à net.​ipv4.​route.​gc_​interval et in­ver­se­ment pro­por­tion­nel à net.​ipv4.​route.​gc_​timeout. Ce but ne peut dé­pas­ser rhash_​entries. Si net.​ipv4.​route.​gc_​interval et net.​ipv4.​route.​gc_​timeout sont égaux, le but est exac­te­ment rhash_​entries. Ce­lui-ci in­dique le nombre d’en­trées du cache qui se­ront exa­mi­nées (et non le nombre d’en­trées qui doivent être sup­pri­mées). Si une en­trée n’est plus va­lide ou suf­fi­sam­ment an­cienne (se­lon les mêmes cri­tères que pour le ra­masse-miette), elle est alors supprimée.

Un autre as­pect im­por­tant de cet al­go­rithme est qu’il dé­ter­mine la taille maxi­male au­to­ri­sée pour une chaîne. Ini­tia­le­ment, cette va­leur est de 20 mais à chaque exé­cu­tion, l’al­go­rithme la mo­di­fie comme étant la lon­gueur moyenne des chaînes qu’il a pu ob­ser­ver aug­menté de quatre fois la dé­via­tion stan­dard avec un maxi­mum égal à net.​ipv4.​route.​gc_​elasticity.

Lors de l’in­ser­tion d’une nou­velle en­trée dans le cache, une chaîne dont la lon­gueur dé­passe net.​ipv4.​route.​gc_​elasticity se verra re­ti­rer un élé­ment (le moins « pré­cieux »), si pos­sible. En­suite, si la chaîne est tou­jours plus longue que la va­leur au­to­ri­sée (soit plus longue que net.​ipv4.​route.​gc_​elasticity, soit trop longue par rap­port aux autres chaînes6), toutes les en­trées du cache cor­res­pon­dant à l’in­ter­face cou­rante sont in­validées.

Conclusion#

Lors de l’op­ti­mi­sa­tion du cache des routes, rhash_​entries, net.​ipv4.​route.​gc_​elasticity, net.​ipv4.​route.​max_​size et net.​ipv4.​route.​gc_​threshold sont liées et ne doivent donc pas être mo­di­fiées sé­pa­ré­ment. net.​ipv4.​route.​gc_​thresh doit être in­fé­rieur au pro­duit de net.​ipv4.​route.​gc_​elasticity et de rhash_​entries tan­dis que net.​ipv4.​route.​max_​size doit y être su­périeur.

Li­nux ex­pose un cer­tain nombre de mé­triques liées au cache des routes. Les sur­veiller per­met de vé­ri­fier l’ef­fi­ca­cité du cache mais éga­le­ment de dé­ce­ler des ano­ma­lies (ra­masse-miettes trop fré­quent, dif­fi­cul­tés à re­ti­rer des routes, …).

Le sys­tème de cache évo­lue tou­jours et cer­tains an­ciens com­por­te­ments sont dé­sor­mais ca­ducs. La meilleure do­cu­men­ta­tion est tou­jours le code étant donné que les do­cu­men­ta­tions tendent à de­ve­nir ob­solètes.

Mise à jour (12.2019)

Le ra­masse-miette pour le cache des routes IPv6 a un fonc­tion­ne­ment si­mi­laire à IPv4. La prin­ci­pale dif­fé­rence est que les en­trées du cache sont sto­ckées di­rec­te­ment parmi l’arbre des routes IPv6 et non dans une struc­ture dé­diée. De plus, de­puis Li­nux 4.2, seules les ex­cep­tions PMTU en­traînent la créa­tion d’une en­trée dans le cache.