From a52eb4de9b389939aa4f6a756e9499f48fd6a4fa Mon Sep 17 00:00:00 2001 From: Louis-Arnaud Date: Thu, 3 Sep 2026 14:02:21 +0200 Subject: [PATCH 1/2] [Sync-En] ext/yac: add the Memory Management chapter and improve the examples --- reference/yac/book.xml | 9 +- reference/yac/configure.xml | 37 ----- reference/yac/constants.xml | 25 +++- reference/yac/ini.xml | 74 +++++----- reference/yac/memory.xml | 256 +++++++++++++++++++++++++++++++++++ reference/yac/yac/add.xml | 44 +++--- reference/yac/yac/delete.xml | 32 ++++- reference/yac/yac/dump.xml | 12 +- reference/yac/yac/get.xml | 30 +++- reference/yac/yac/info.xml | 12 +- reference/yac/yac/set.xml | 28 +++- 11 files changed, 437 insertions(+), 122 deletions(-) delete mode 100644 reference/yac/configure.xml create mode 100644 reference/yac/memory.xml diff --git a/reference/yac/book.xml b/reference/yac/book.xml index f41e936345..7c10d7d476 100644 --- a/reference/yac/book.xml +++ b/reference/yac/book.xml @@ -1,5 +1,5 @@ - + @@ -29,7 +29,8 @@ compartida. Como resultado, Yac es extremadamente rápida, con una latencia de lectura del orden de microsegundos, y su rendimiento puede escalar con el número de procesos de trabajo mientras las escrituras se - repartan entre distintas claves. + repartan entre distintas claves; véanse los + tests de rendimiento. Dado que Yac sacrifica garantías de corrección a cambio de velocidad y @@ -41,7 +42,8 @@ A partir de yac 2.4.0, los valores escalares pequeños — - NULL, booleanos, enteros, cadenas cortas de hasta + NULL, booleanos, la mayoría de los enteros (los que + caben en 60 bits con signo en compilaciones de 64 bits), cadenas de hasta 7 bytes y arrays vacíos — se almacenan directamente dentro de la ranura hash en lugar de en un bloque de valor separado («valores incrustados»), lo que elimina la reserva de memoria del valor y la @@ -60,6 +62,7 @@ &reference.yac.setup; + &reference.yac.memory; &reference.yac.constants; &reference.yac.yac; diff --git a/reference/yac/configure.xml b/reference/yac/configure.xml deleted file mode 100644 index 8be5b2c993..0000000000 --- a/reference/yac/configure.xml +++ /dev/null @@ -1,37 +0,0 @@ - - - - - -
- &reftitle.install; - - - &pecl.info; - &url.pecl.package;yac - - - -
- - - diff --git a/reference/yac/constants.xml b/reference/yac/constants.xml index a2ffcc8fa2..cd3d12f12f 100644 --- a/reference/yac/constants.xml +++ b/reference/yac/constants.xml @@ -1,6 +1,6 @@ - + @@ -15,6 +15,7 @@ + La versión de la extensión como cadena. @@ -25,7 +26,8 @@ - La longitud máxima de una clave podría ser, es de 48 bytes. + Longitud máxima de una clave en bytes: 48. El prefijo de una instancia + cuenta para este límite. @@ -36,6 +38,9 @@ + Longitud máxima de un valor antes de la serialización, en bytes: + 67 108 863 ((1 << 26) - 1). Los valores + mayores son rechazados. @@ -46,6 +51,8 @@ + Tamaño máximo de una entrada almacenada, en bytes: 1 048 576 (1M). Los + valores que no caben ni siquiera después de comprimirse son rechazados. @@ -56,7 +63,8 @@ - Usa php serialize como serializador + Utiliza el formato serialize de PHP como serializador (el valor por + omisión). @@ -67,7 +75,8 @@ - Usa json como serializador (requrie --enable-json) + Utiliza JSON como serializador. Requiere que la extensión se compile con + . @@ -78,7 +87,8 @@ - Usa igbinary como serializador (require --enable-igbinary) + Utiliza igbinary como serializador. Requiere que la extensión se compile + con . @@ -89,7 +99,8 @@ - Usa msgpack como serializador (require --enable-msgpack) + Utiliza msgpack como serializador. Requiere que la extensión se compile + con . @@ -100,7 +111,7 @@ - Qué serializador está yac usando + El serializador utilizado actualmente por la extensión. diff --git a/reference/yac/ini.xml b/reference/yac/ini.xml index 58c1b631ef..530cbe249a 100644 --- a/reference/yac/ini.xml +++ b/reference/yac/ini.xml @@ -1,5 +1,5 @@ - +
&reftitle.runtime; @@ -19,7 +19,7 @@ yac.compress_threshold - -1 + 4K INI_SYSTEM @@ -43,7 +43,7 @@ yac.keys_memory_size - 4M + 8M INI_SYSTEM @@ -76,11 +76,17 @@ Los valores serializados que superan este número de bytes se - comprimen antes de almacenarse (actualmente con LZ4). Se debe - establecer a -1 (el valor predeterminado) para - desactivar por completo la compresión. Comprimir valores grandes - ahorra memoria compartida a costa de algo de CPU tanto al almacenar - como al recuperar. + comprimen (con LZ4, desde Yac 2.4.0) antes de almacenarse. + Los valores que superan el límite de 1M por entrada + almacenada (YAC_MAX_RAW_COMPRESSED_LEN) se + comprimen siempre, sea cual sea esta directiva, porque no pueden + almacenarse sin comprimir. El valor por omisión de + 4K activa la compresión; -1 la + desactiva para los valores por debajo del límite por entrada + almacenada, y los demás valores positivos se ajustan al rango + 1024..1M. + Comprimir valores grandes ahorra memoria compartida a costa de algo de + CPU tanto al almacenar como al recuperar. @@ -130,13 +136,33 @@ - Cantidad de memoria compartida utilizada para las ranuras de la - tabla hash que contienen las claves y la información de control. - Cada ranura es una estructura de tamaño fijo, de modo que este - valor determina cuántos elementos pueden gestionarse a la vez. El - valor predeterminado es 4M. Yac divide esta - zona en segmentos; el tamaño de segmento es 4M, por lo que este - valor debe ser un múltiplo de 4M. + Cantidad de memoria compartida para la tabla de claves. Limita cuántas + entradas pueden existir a la vez: el valor por omisión de + 8M permite unas 65 536 entradas. Conviene aumentarlo + cuando la tasa de aciertos baja y kicks sube; véase + para saber cómo se comporta una + tabla llena y cuándo eso importa realmente. + + + + + + yac.values_memory_size + string + + + + Cantidad de memoria compartida para almacenar los valores. Los valores + se reservan mediante un asignador lineal sobre segmentos de 4M cada uno; + cuando ningún segmento tiene sitio para un valor nuevo, el cursor del + asignador vuelve al principio y los valores más antiguos se sobrescriben + silenciosamente («reciclados»). Sus lecturas pasan entonces a ser + fallos de caché, detectados por un control de integridad. Conviene + ampliarlo si recycles sube mientras las ranuras + todavía tienen sitio, o activar + yac.compress_threshold + para reducir las cargas útiles grandes. Véase + . @@ -159,23 +185,7 @@ - - - yac.values_memory_size - string - - - - Cantidad de memoria compartida utilizada para almacenar los - valores propiamente dichos. El valor predeterminado es - 64M. Yac reserva esta zona en segmentos de 4M - cada uno, por lo que este valor debe ser un múltiplo de - 4M. Cuando la zona está llena, las entradas - usadas menos recientemente se eliminan para hacer sitio a las - nuevas. - - - + diff --git a/reference/yac/memory.xml b/reference/yac/memory.xml new file mode 100644 index 0000000000..89cc2b0ec9 --- /dev/null +++ b/reference/yac/memory.xml @@ -0,0 +1,256 @@ + + + + + + Gestión de la memoria + + + Yac guarda sus datos en dos reservas de memoria compartida independientes, + configuradas con + yac.keys_memory_size + y + yac.values_memory_size. + Se llenan y se liberan de maneras distintas, por lo que conviene saber a qué + reserva pertenece un síntoma antes de tocar cualquiera de los dos ajustes. + + +
+ Qué contiene cada reserva + + Las dos reservas almacenan mitades distintas de una entrada. La reserva de + claves contiene las claves: una ranura por clave en caché, que lleva la + propia clave (hasta 48 bytes) junto con su hash, su TTL, su número de + aciertos y su fecha de último acceso; el valor solo se referencia mediante + un puntero a la reserva de valores. La reserva de valores contiene los + valores: cada valor almacenado ocupa un bloque de bytes serializados, en su + forma comprimida cuando la entrada ha pasado por + yac.compress_threshold. + + + La única excepción son los valores incrustados: los escalares pequeños + (&null;, &true;, &false;, la mayoría de los enteros —los que caben en + 60 bits con signo en compilaciones de 64 bits—, las cadenas de hasta + 7 bytes y los arrays vacíos) se almacenan directamente dentro de la ranura, + en el puntero que de otro modo referenciaría un bloque. Esos valores no + ocupan espacio alguno en la reserva de valores; solo lo hace su clave. + + + Como guía aproximada de dimensionamiento: + + + + la reserva de claves contiene unas 8 000 claves por MB, así que hay que + dimensionar + yac.keys_memory_size + como el número de claves distintas dividido entre 8 000 por MB, + redondeando al entero superior: el valor por omisión de + 8M contiene unas 64 000 claves; + + + + + la reserva de valores debe contener todos los valores que todavía puedan + leerse, así que hay que dimensionar + yac.values_memory_size + como el número de valores vivos multiplicado por su tamaño serializado + medio (después de la compresión), y prever aproximadamente el doble: la + reserva es un anillo, y un valor no muere hasta que el cursor del + asignador vuelve a pasar por encima de él. + + + + Los valores incrustados ocupan una ranura como cualquier otra entrada, pero + no consumen espacio en la reserva de valores, así que hay que dejarlos + fuera del segundo cálculo. + +
+ +
+ La reserva de claves (ranuras) + + yac.keys_memory_size + contiene una tabla de ranuras de tamaño fijo: el valor por omisión de + 8M proporciona unas 65 536 ranuras. Cada clave + almacenada ocupa exactamente una ranura, de modo que esta reserva limita el + número de entradas que pueden existir a la vez; a diferencia de la reserva + de valores, las ranuras nunca se liberan individualmente. Una ranura + caducada —más allá de su TTL, o el marcador de borrado que deja + Yac::delete— se recicla sin coste cuando una clave + nueva la necesita. Solo cuando las cuatro ranuras candidatas de un camino + de sondeo contienen entradas vivas se expulsa una de ellas para hacer + sitio: un kick (el contador + kicks de Yac::info). + + + La expulsión elige únicamente entre las cuatro candidatas vivas del camino + de sondeo en colisión: + + + + se expulsa la usada menos recientemente (el atime más + antiguo); + + + + + en caso de empate, la entrada con menos aciertos y, después, la primera + posición de sondeo. + + + + + + Un punto de confusión frecuente: que slots_used alcance + slots_size no es una condición de + error. Una caché cuyo conjunto de trabajo de claves sea mayor que la tabla + de ranuras simplemente funciona al 100 % de ocupación a partir de ese + momento, expulsando y reinsertando según haga falta. Lo único que indica si + la reserva de claves está bien dimensionada es la tasa de aciertos + (hits / (hits + miss), calculada sobre las diferencias + entre dos instantáneas de Yac::info y no sobre la + media desde el arranque). Un contador kicks alto no + significa por sí mismo que haya un problema: sencillamente la distribución + de las claves no es uniforme y algunos caminos de sondeo colisionan más que + otros. Solo cuando la tasa de aciertos y + kicks son ambos malos la tabla es demasiado pequeña para + el conjunto de claves, y el remedio es un + yac.keys_memory_size mayor. + + + Una segunda consecuencia de que las ranuras nunca se liberen: las entradas + sin TTL (ttl = 0) que ya no vuelven a leerse siguen + ocupando una ranura hasta que una expulsión da la casualidad de elegirlas. + Si una aplicación almacena grandes cantidades de datos de un solo uso, + conviene darles un TTL para que caduquen y puedan reciclarse sin desplazar + entradas vivas, o dimensionar la reserva de claves para el conjunto + completo de claves. + +
+ +
+ La reserva de valores (segmentos) + + yac.values_memory_size + se divide en segmentos de 4M cada uno, gestionados como anillos: las + escrituras hacen avanzar un cursor por segmento y el espacio nunca se + libera por entrada. Cuando una reserva ya no cabe, el cursor vuelve al + principio de un segmento: un recycle (el contador + recycles de Yac::info). Un + reciclado no invalida el segmento de inmediato: los valores sobrescritos + siguen siendo legibles hasta que el cursor que ha dado la vuelta los + sobrescribe realmente, momento en el que sus lecturas no superan el control + de integridad y se convierten en fallos de caché. + + + Para esta reserva importan dos tamaños: el total de + yac.values_memory_size + debe contener el conjunto de trabajo de los valores vivos, y una única + entrada puede ocupar como mucho 1 MB una vez almacenada + (YAC_MAX_RAW_COMPRESSED_LEN). Por eso los valores + mayores se comprimen siempre antes de almacenarse; un valor que no puede + reducirse por debajo de 1 MB —lo más habitual, porque son datos + aleatorios— es rechazado e incrementa el contador + fails. El límite absoluto sobre el valor en sí es mucho + más alto: los valores serializados por encima de 64 MB + (YAC_MAX_VALUE_RAW_LEN, es decir + (1 << 26) - 1 bytes) se rechazan de plano. + +
+ +
+ Dimensionamiento y qué vigilar + + Conviene empezar con los valores por omisión y vigilar los contadores de + Yac::info: se acumulan desde + start_time, así que hay que comparar dos instantáneas + tomadas con cierta separación en el tiempo: + + + + + tasa de aciertos saludable (por ejemplo >= 90 %): la caché está bien; + no hay nada que hacer, sea lo que sea que muestren los demás contadores; + + + + + tasa de aciertos baja y kicks en aumento: la reserva de + claves es demasiado pequeña para el conjunto de claves, las entradas vivas + se expulsan antes de volver a leerse. Hay que aumentar + yac.keys_memory_size; + + + + + recycles frecuentes: esto sí es un problema real, no un + contador inofensivo. Un reciclado significa que el asignador de valores ha + dado la vuelta y está a punto de sobrescribir entradas: todo lo + sobrescrito muere antes de poder volver a leerse, de modo que los bytes + gastados en almacenarlo se han desperdiciado y la tasa de aciertos se + resiente. La reserva de valores es demasiado pequeña para el volumen de + datos vivos. Por orden de impacto: + + + + dar un TTL a las entradas. Los valores escritos con + ttl = 0 siguen vivos para siempre, de modo que + ocupan la reserva y obligan al cursor a dar la vuelta antes. Un TTL + limita cuánto puede vivir cada entrada y reduce el conjunto de trabajo + vivo que la reserva debe contener; + + + + + aumentar + yac.values_memory_size + para que la reserva contenga todo el conjunto de valores vivos (hay que + recordar prever aproximadamente el doble de la huella viva: un valor no + muere hasta que el cursor vuelve a pasar por encima de él); + + + + + almacenar menos por entrada: bajar + yac.compress_threshold + si está por encima del mínimo de 1024, para que las + cargas útiles grandes se compriman, y recortar los valores que no + necesitan almacenarse por completo; + + + + + + + + fails en aumento: valores que no han podido + almacenarse, casi siempre un único valor mayor que el límite de 1 MB de + tamaño almacenado incluso después de comprimirlo; hay que dividir el + valor. + + + +
+ + + + diff --git a/reference/yac/yac/add.xml b/reference/yac/yac/add.xml index 78a4c294a1..3ae8c60b0e 100644 --- a/reference/yac/yac/add.xml +++ b/reference/yac/yac/add.xml @@ -1,5 +1,5 @@ - + @@ -11,7 +11,7 @@ &reftitle.description; public boolYac::add - stringarraykeys + stringarraykey mixedvalue intttl0 @@ -31,7 +31,7 @@ &reftitle.parameters; - keys + key Una clave de tipo string, o un array de pares @@ -45,7 +45,7 @@ El valor a almacenar. Puede almacenarse cualquier tipo de PHP excepto resource. Solo se utiliza en la forma de clave única; cuando - keys es un array, este argumento es en su lugar el + key es un array, este argumento es en su lugar el parámetro opcional ttl. @@ -69,22 +69,6 @@ también es rechazado (devolviendo &false;) cuando la clave ya existe y no ha expirado. - - - Yac almacena las entradas sin bloqueos. Bajo una fuerte contención, un - almacenamiento puede fallar de forma transitoria; si el valor debe acabar - siendo almacenado, hay que reintentarlo: - -add("key", "value")) { - // reintento en caso de fallo transitorio -} -?> -]]> - - - @@ -98,11 +82,31 @@ $yac = new Yac(); var_dump($yac->add("foo", "bar")); // bool(true) var_dump($yac->add("foo", "baz")); // bool(false): "foo" ya existe +?> +]]> + + + + Añadir una entrada con un TTL + +add("short-lived", "value", 5); sleep(6); var_dump($yac->get("short-lived")); // bool(false): expirado +?> +]]> + + + + Añadir varias entradas en una sola llamada + + valor en una sola llamada, con un ttl $yac->add(array("a" => 1, "b" => 2), 60); diff --git a/reference/yac/yac/delete.xml b/reference/yac/yac/delete.xml index 15f961fef4..ff7b6521d2 100644 --- a/reference/yac/yac/delete.xml +++ b/reference/yac/yac/delete.xml @@ -1,5 +1,5 @@ - + @@ -11,7 +11,7 @@ &reftitle.description; public boolYac::delete - stringarraykeys + stringarraykey intdelay0 @@ -38,7 +38,7 @@ &reftitle.parameters; - keys + key Una clave de tipo string, o un array de claves @@ -96,13 +96,33 @@ var_dump($yac->delete("never")); // bool(false): nunca fue almacenada var_dump($yac->info()["slots_used"]); // int(1) print_r($yac->dump()); // "foo" sigue apareciendo; su ttl // está en el pasado +?> +]]> + + + + Eliminación retardada + +set("tmp", "value"); var_dump($yac->delete("tmp", 60)); // bool(true) +?> +]]> + + + + Eliminar varias claves en una sola llamada + +set("tmp", "value"); -// eliminar varias claves a la vez devuelve true solo cuando todas las -// claves estaban presentes +// devuelve true solo cuando todas las claves estaban presentes var_dump($yac->delete(array("tmp", "nope"))); // bool(false): falta "nope" ?> ]]> diff --git a/reference/yac/yac/dump.xml b/reference/yac/yac/dump.xml index e7667e5e5f..b7024c5ab4 100644 --- a/reference/yac/yac/dump.xml +++ b/reference/yac/yac/dump.xml @@ -1,5 +1,5 @@ - + @@ -137,8 +137,9 @@ hits Un contador de aciertos por entrada, incrementado en cada - Yac::get con éxito, y reiniciado cuando la entrada - es sobrescrita, eliminada o expira (a partir de yac 2.4.0). + Yac::get con éxito y reiniciado cuando la entrada + es sobrescrita por un nuevo Yac::set o + Yac::add (a partir de yac 2.4.0). @@ -237,6 +238,11 @@ Array set("key$i", $i); +} + $page_size = 100; $page_num = 2; diff --git a/reference/yac/yac/get.xml b/reference/yac/yac/get.xml index d8fc130a4e..e9dd1536c0 100644 --- a/reference/yac/yac/get.xml +++ b/reference/yac/yac/get.xml @@ -1,5 +1,5 @@ - + @@ -11,7 +11,7 @@ &reftitle.description; public mixedYac::get - stringarraykeys + stringarraykey mixeddefault&null; @@ -23,7 +23,7 @@ &reftitle.parameters; - keys + key Una clave de tipo string, o un array de claves. @@ -82,6 +82,16 @@ $yac = new Yac(); $yac->set("foo", "bar"); var_dump($yac->get("foo")); // string(3) "bar" var_dump($yac->get("missing")); // bool(false): un fallo de caché +?> +]]> + + + + Distinguir un false almacenado de un fallo de caché + +get("flag")); // bool(false): el valor almacenado var_dump($yac->get("missing", false)); // bool(false): un fallo de caché, misma forma var_dump($yac->get("flag", "__NONE__")); // bool(false): el valor almacenado var_dump($yac->get("missing", "__NONE__")); // string(8) "__NONE__": un fallo de caché +?> +]]> + + + + Recuperar varias claves en una sola llamada + +set("foo", "bar"); $yac->set("foo2", "bar2"); + +// con un array de claves, solo las claves encontradas están presentes en el resultado var_dump($yac->get(array("foo", "foo2", "missing"))); // array(2) { ["foo"]=> string(3) "bar" ["foo2"]=> string(4) "bar2" } ?> diff --git a/reference/yac/yac/info.xml b/reference/yac/yac/info.xml index d61b58b3dd..136b749428 100644 --- a/reference/yac/yac/info.xml +++ b/reference/yac/yac/info.xml @@ -1,5 +1,5 @@ - + @@ -135,18 +135,18 @@ print_r($yac->info()); 46137344 - [slots_memory_size] => 4194304 - [values_memory_size] => 41943040 + [memory_size] => 75497472 + [slots_memory_size] => 8388608 + [values_memory_size] => 67108864 [segment_size] => 4194304 - [segment_num] => 10 + [segment_num] => 16 [miss] => 0 [hits] => 0 [fails] => 0 [kicks] => 0 [recycles] => 0 [start_time] => 1725955200 - [slots_size] => 32768 + [slots_size] => 65536 [slots_used] => 1 ) ]]> diff --git a/reference/yac/yac/set.xml b/reference/yac/yac/set.xml index 0ccd6bcb45..97ecd4c995 100644 --- a/reference/yac/yac/set.xml +++ b/reference/yac/yac/set.xml @@ -1,5 +1,5 @@ - + @@ -11,7 +11,7 @@ &reftitle.description; public boolYac::set - stringarraykeys + stringarraykey mixedvalue intttl0 @@ -30,7 +30,7 @@ &reftitle.parameters; - keys + key Una clave de tipo string, o un array de @@ -44,7 +44,7 @@ El valor que almacenar. Se puede almacenar cualquier tipo de PHP excepto resource. Solo se utiliza en la forma de clave única; cuando - keys es un array, este argumento es en su lugar el + key es un array, este argumento es en su lugar el parámetro opcional ttl. @@ -79,11 +79,31 @@ $yac = new Yac(); $yac->set("foo", "bar"); // almacena un único valor $yac->set("foo", "baz"); // sobrescribe la entrada existente +?> +]]> + + + + Almacenar una entrada con un TTL + +set("short-lived", "value", 5); sleep(6); var_dump($yac->get("short-lived")); // bool(false): ha expirado +?> +]]> + + + + Almacenar varias entradas en una sola llamada + + valor con una sola llamada $yac->set(array("a" => 1, "b" => 2)); From 7dbbae7651d1f1ea056c36032ac87127712bcc7b Mon Sep 17 00:00:00 2001 From: Louis-Arnaud Date: Thu, 3 Sep 2026 14:26:00 +0200 Subject: [PATCH 2/2] yac: apply the doc-es glossary, fix the allocation wording and the tuning advice tone --- reference/yac/constants.xml | 4 ++-- reference/yac/ini.xml | 4 ++-- reference/yac/memory.xml | 14 +++++++------- 3 files changed, 11 insertions(+), 11 deletions(-) diff --git a/reference/yac/constants.xml b/reference/yac/constants.xml index cd3d12f12f..b775232c9d 100644 --- a/reference/yac/constants.xml +++ b/reference/yac/constants.xml @@ -63,8 +63,8 @@ - Utiliza el formato serialize de PHP como serializador (el valor por - omisión). + Utiliza el formato serialize de PHP como serializador (el valor + predeterminado). diff --git a/reference/yac/ini.xml b/reference/yac/ini.xml index 530cbe249a..18d0481ebc 100644 --- a/reference/yac/ini.xml +++ b/reference/yac/ini.xml @@ -80,7 +80,7 @@ Los valores que superan el límite de 1M por entrada almacenada (YAC_MAX_RAW_COMPRESSED_LEN) se comprimen siempre, sea cual sea esta directiva, porque no pueden - almacenarse sin comprimir. El valor por omisión de + almacenarse sin comprimir. El valor predeterminado de 4K activa la compresión; -1 la desactiva para los valores por debajo del límite por entrada almacenada, y los demás valores positivos se ajustan al rango @@ -137,7 +137,7 @@ Cantidad de memoria compartida para la tabla de claves. Limita cuántas - entradas pueden existir a la vez: el valor por omisión de + entradas pueden existir a la vez: el valor predeterminado de 8M permite unas 65 536 entradas. Conviene aumentarlo cuando la tasa de aciertos baja y kicks sube; véase para saber cómo se comporta una diff --git a/reference/yac/memory.xml b/reference/yac/memory.xml index 89cc2b0ec9..953d90f692 100644 --- a/reference/yac/memory.xml +++ b/reference/yac/memory.xml @@ -44,7 +44,7 @@ dimensionar yac.keys_memory_size como el número de claves distintas dividido entre 8 000 por MB, - redondeando al entero superior: el valor por omisión de + redondeando al entero superior: el valor predeterminado de 8M contiene unas 64 000 claves; @@ -70,7 +70,7 @@ La reserva de claves (ranuras) yac.keys_memory_size - contiene una tabla de ranuras de tamaño fijo: el valor por omisión de + contiene una tabla de ranuras de tamaño fijo: el valor predeterminado de 8M proporciona unas 65 536 ranuras. Cada clave almacenada ocupa exactamente una ranura, de modo que esta reserva limita el número de entradas que pueden existir a la vez; a diferencia de la reserva @@ -134,7 +134,7 @@ yac.values_memory_size se divide en segmentos de 4M cada uno, gestionados como anillos: las escrituras hacen avanzar un cursor por segmento y el espacio nunca se - libera por entrada. Cuando una reserva ya no cabe, el cursor vuelve al + libera por entrada. Cuando una asignación ya no cabe, el cursor vuelve al principio de un segmento: un recycle (el contador recycles de Yac::info). Un reciclado no invalida el segmento de inmediato: los valores sobrescritos @@ -161,7 +161,7 @@
Dimensionamiento y qué vigilar - Conviene empezar con los valores por omisión y vigilar los contadores de + Conviene empezar con los valores predeterminados y vigilar los contadores de Yac::info: se acumulan desde start_time, así que hay que comparar dos instantáneas tomadas con cierta separación en el tiempo: @@ -193,7 +193,7 @@ - dar un TTL a las entradas. Los valores escritos con + hay que dar un TTL a las entradas. Los valores escritos con ttl = 0 siguen vivos para siempre, de modo que ocupan la reserva y obligan al cursor a dar la vuelta antes. Un TTL limita cuánto puede vivir cada entrada y reduce el conjunto de trabajo @@ -202,7 +202,7 @@ - aumentar + hay que aumentar yac.values_memory_size para que la reserva contenga todo el conjunto de valores vivos (hay que recordar prever aproximadamente el doble de la huella viva: un valor no @@ -211,7 +211,7 @@ - almacenar menos por entrada: bajar + hay que almacenar menos por entrada y bajar yac.compress_threshold si está por encima del mínimo de 1024, para que las cargas útiles grandes se compriman, y recortar los valores que no