makepp_build_cache_control - Online en la nube

PROGRAMA:

NOMBRE

makepp_build_cache - Cómo configurar y usar las memorias caché de compilación

DESCRIPCIÓN

C: limpiar,
crear, M: makepp_build_cache_control,
MPPBCC, S: espectáculo,
estadísticas

A build cache es un directorio que contiene copias de destinos anteriores que makepp ya
construido. Cuando se le pide a makepp que cree un nuevo objetivo, ve si ya lo ha creado
en otro lugar bajo las mismas condiciones, y si es así, simplemente lo vincula o lo copia en lugar de
reconstruirlo.

Una memoria caché de compilación puede resultar útil en las siguientes circunstancias:

· Estás trabajando en un programa y lo compilas optimizado. Entonces descubres un error
y recompilar todo en modo de depuración. Encontraste el error y ahora quieres
recompilarlo en modo optimizado. La mayoría de los archivos serán idénticos. Si usaste un
crear caché en todas sus compilaciones, makepp simplemente extraerá los archivos sin cambios
fuera de la caché de compilación en lugar de volver a compilarlos.

Una situación similar es si normalmente trabaja en una arquitectura pero cambia brevemente a
una arquitectura diferente, y luego vuelves a cambiar. Si los archivos antiguos todavía están en el
construir caché, makepp no ​​tendrá que recompilar nada.

· Ha extraído varias copias de un programa en particular desde su control de versiones
sistema y han realizado diferentes cambios en cada jerarquía de directorios. (Por ejemplo, eres
resolviendo diferentes errores en diferentes jerarquías de directorios.) La mayoría de los archivos serán
idéntico en las dos jerarquías de directorios. Si construye ambos con un caché de compilación, el
construir en la segunda jerarquía de directorios podrá simplemente copiar los archivos de la
crear caché en lugar de volver a compilar archivos que sean iguales.

· Tiene varios desarrolladores trabajando en el mismo conjunto de fuentes. Cada desarrollador es
realizando cambios, pero la mayoría de los archivos son idénticos entre desarrolladores. Si todo el
los desarrolladores comparten un caché de compilación, entonces, si la compilación de un desarrollador compila un archivo, cualquier
compilación de otro desarrollador que tiene que compilar el archivo idéntico (con el mismo
incluye, etc.) puede simplemente copiar el archivo en caché en lugar de volver a ejecutar la compilación.

Una caché de compilación puede ayudar si se cumplen todas las siguientes condiciones:

· Tiene mucho espacio en disco. Por lo general, makepp terminará almacenando en caché muchas copias de
cada archivo que está cambiando, porque no tiene idea de cuáles se utilizarán realmente.
Puede desactivar la caché de compilación para ciertos archivos, pero si la caché de compilación va a
sea ​​útil en absoluto, probablemente tendrá que contener muchos archivos.

· Sus archivos tardan mucho más en compilarse que en copiar. Si el caché de compilación está en el
mismo sistema de archivos, makepp intentará utilizar enlaces físicos en lugar de copiar el archivo.
Makepp tiene que vincular o copiar el archivo en la caché cuando se crea el archivo, y luego
tiene que vincular o copiar el archivo de la caché cuando se requiera nuevamente. Es más,
Hay una pequeña sobrecarga involucrada en verificar si el archivo necesario está realmente en
la caché de compilación y copiando la información de compilación sobre el archivo, así como el archivo
misma.

Puede encontrar, por ejemplo, que usar un caché de compilación no vale la pena para compilar muy
pequeños módulos. Es casi seguro que no valga la pena que los comandos hagan una estática
biblioteca (un archivo de almacenamiento, libxyz.a), excepto si usa enlaces para ahorrar espacio en disco.

· Existe una alta probabilidad de que algunos archivos se necesiten nuevamente en otra
Compilacion. Si solo compila una pieza de software una vez, los cachés de compilación pueden
solo ralentiza las cosas.

El uso de una caché de compilación requiere un poco de trabajo de configuración y mantenimiento. Por favor no
intente usar un caché de compilación hasta que comprenda cómo funcionan, cómo crearlos y cómo
evitar que crezcan continuamente y consuman todo el espacio en disco disponible en su
.

Cómo a build cache funciona
Si habilita una caché de compilación, cada vez que se compila un archivo, makepp almacena una copia en un
crear caché. El nombre del archivo es una clave que es un hash de las sumas de comprobación de todos los
entradas y el comando de compilación y la arquitectura. La próxima vez que makepp quiera reconstruir
el archivo, ve si ya hay un archivo con las mismas sumas de comprobación en la memoria caché de compilación.
Si es así, el archivo se copia del caché de compilación.

Para mayor eficiencia, si la caché de compilación se encuentra en el mismo sistema de archivos que la compilación, makepp
en realidad no copiará el archivo; en su lugar, creará un vínculo físico. Esto es más rápido y
no utiliza ningún espacio extra en disco. Del mismo modo, cuando makepp quiere extraer un archivo de
la caché de compilación, utilizará un enlace físico si es posible, o lo copiará si es necesario.

ADVERTENCIA: Makepp nunca elimina archivos de una memoria caché de compilación a menos que se solicite explícitamente.
Esto significa que sus cachés de compilación continuarán creciendo sin límites a menos que limpie
periódicamente (consulte los detalles a continuación).

Construcción caches y repositorios

La creación de cachés y repositorios (consulte makepp_repositories) puede resolver problemas similares. Para
En algunas situaciones, un repositorio es más apropiado, mientras que para otras, un caché de compilación es más
apropiado.

También puedes combinar los dos. Si tiene una estructura de directorio enorme con muchos
fuentes, de las que no desea que todos los desarrolladores tengan una copia, entonces puede proporcionarlas
como repositorio. Los archivos producidos, con distintas opciones de depuración, etc., se pueden
administrado de manera más flexible a través de un caché de compilación.

Las diferencias clave entre un caché de compilación y un repositorio son:

· Un caché de compilación solo puede almacenar archivos creados por el procedimiento de compilación. Un repositorio puede
también tienen archivos fuente originales.

· Los archivos de un repositorio deben no cambiar durante el transcurso de una construcción. Un caché de compilación
no tiene ninguna restricción de este tipo.

· Los archivos en un repositorio deben estar presentes en la misma posición relativa que los archivos en
el directorio de compilación. Por ejemplo, si makepp necesita el archivo subdir1 / subdir2 / xyz.abc, Entonces eso
solo mira raíz_repositorio / subdir1 / subdir2 / xyz.abc. Los archivos en una caché de compilación tienen
perdieron toda la información de la jerarquía de directorios y se buscan solo en función de las entradas
y el comando que se requirió para producirlos.

· Los archivos en un repositorio están vinculados por software a sus nuevas ubicaciones en la compilación
directorios. Los archivos en una caché de compilación se copian o se vinculan en su nuevo
ubicaciones. Si es necesaria una copia, un repositorio sin duda será más rápido.

· Crear cachés cuesta un poco de tiempo para colocar archivos en ellos. Un repositorio no tiene
cualquier costo adicional (para la ejecución actual, es decir, por supuesto, existía el costo de crear
de antemano), pero a menudo requiere un poco más de planificación previa.

En general, un repositorio es más útil si tiene una única compilación central que desea
todos los desarrolladores de donde tomar archivos. Un caché de compilación es lo que desea si tiene un
sistema descentralizado donde un desarrollador debe tomar prestados archivos compilados de cualquier otro
desarrollador.

Tanto los cachés de compilación como los repositorios pueden ayudar con las compilaciones variantes. Por ejemplo, si quieres
para compilar todas sus fuentes optimizadas, luego nuevamente con depuración, luego nuevamente optimizadas,
puede evitar volver a compilar todos los archivos optimizados utilizando un repositorio o un
crear caché. Para hacer esto con un repositorio, debe pensar en el futuro y decirle explícitamente
makepp para usar un repositorio para la compilación de depuración, o de lo contrario borrará su
compilación optimizada inicial. Con un caché de compilación, makepp sigue adelante y borra el
compilación optimizada inicial, pero puede recuperarla rápidamente.

Construcción cache agrupamiento
Un grupo es un acoplamiento flexible de cachés de compilación. Es suelto en el sentido de que makepp no
lidiar con él, para no ralentizar la gestión de la caché de compilación. Para beneficiarte de esto tú
tienes que usar la utilidad fuera de línea. En particular, el comando "limpiar" también realiza el
replicación. Si proporciona un criterio de limpieza poco realista, como "--mtime = + 1000", no
se produce la limpieza, solo la replicación.

La agrupación permite compartir archivos con más personas, especialmente si tiene sus cachés de compilación
en los discos de los desarrolladores, para beneficiarse de los enlaces duros, lo que ahorra tiempo de envío y
Espacio del disco. Sin embargo, el enlace duro solo está restringido a los beneficios por disco.

Con la agrupación, el archivo se replicará en algún momento después de que makepp lo haya enviado al
crear caché. Esto significa que el archivo se creará solo una vez para todos los discos juntos.

En sistemas de archivos que permiten enlaces duros a enlaces simbólicos, lo que parece restringido a
Linux y Solaris: el archivo también estará físicamente presente en un solo disco.
Además, permanece en cada disco en el que se creó antes de replicar, pero solo como
siempre que esté en uso en esos discos. En este escenario con enlaces simbólicos, puede elegir uno o
más sistemas de archivos en los que prefiere que estén físicamente sus archivos. Sé consciente de
Los archivos construidos con éxito pueden dejar de estar disponibles, si el disco en el que se encuentran va físicamente
desconectado. La reconstrucción remediará esto, y el impacto puede reducirse extendiendo el
archivos en varios discos preferidos.

La replicación tiene varios usos interesantes:

NFS (posible con copia también)
Tiene un servidor NFS central que proporciona la caché de compilación preferida. Cada maquina
y el disco del desarrollador tiene un caché de compilación local para un envío rápido. O montas de nuevo
todos los discos de desarrollador al servidor NFS, y realice la replicación y limpieza
centralmente, o usted replica localmente en cada máquina cliente NFS, tratando solo la parte
del grupo visible allí.

Disco inseguro (posible con copia también)
Si compila en un disco RAM (con suerte editando sus fuentes en un repositorio en un lugar seguro
disk), puede hacer que los discos seguros sean los preferidos. Entonces la replicacin
migrar los archivos a los discos seguros, donde sobreviven a un reinicio. Después de cada reinicio
Tendrá que volver a crear el caché de compilación del disco RAM y agregarlo al grupo (lo que
dar una advertencia, inofensiva en este caso, porque los otros miembros del grupo todavía recuerdan
eso).

Disco completo (enlace rígido solo a enlaces simbólicos)
Si uno de sus discos está muy lleno, puede crear cachés de compilación en todos los
se prefieren otros discos. De esa forma, la replicación migrará los archivos fuera del
disco completo, aleatoriamente a cualquiera de los demás.

Cómo a utilizan el a build cache
Cómo a les digas hacer pp a utilizan el las build cache

Una vez que se ha creado la caché de compilación, ahora está disponible para makepp. Hay varios
opciones que puede especificar durante la creación; consulte "Cómo administrar una memoria caché de compilación" para obtener más detalles.

Una caché de compilación se especifica con la opción de línea de comando --build-cache, con la
declaración build_cache dentro de un archivo MAKE, o con el modificador de regla: build_cache.

Las formas más útiles que he encontrado hasta ahora para trabajar con memorias caché de compilación son:

· Establezca la ruta de la caché de compilación en la variable de entorno MAKEPPFLAGS, así (primero
variante para Korn Shell o bash, segundo para csh):

exportar MAKEPPFLAGS = - build-cache = / ruta / a / build / cache
setenv MAKEPPFLAGS --build-cache = / ruta / a / compilación / caché

Ahora, cada compilación que ejecute siempre usará esta caché de compilación, y no es necesario
modificar cualquier otra cosa.

· Especifica el caché de compilación en tus archivos MAKE con una línea como esta:

BUILD_CACHE: = / ruta / a / build_cache
build_cache $ (BUILD_CACHE)

Tienes que poner esto en todos los archivos MAKE que usan un caché de compilación (o en un include común
archivo que utilizan todos los archivos MAKE). O pon esto en tu Archivo RootMakepp:

BUILD_CACHE: = / ruta / a / build_cache
caché_de_construcción global $ (BUILD_CACHE)

En una máquina multiusuario, puede configurar una caché de compilación por disco doméstico para tomar
ventaja de los enlaces. Puede que le resulte más conveniente utilizar una declaración como esta:

build_cache $ (find_upwards our_build_cache)

que busca hacia arriba desde el directorio actual en el sistema de archivos actual hasta que
encuentra un directorio llamado nuestra_construcción_caché. Esta puede ser la misma declaración para todos.
usuarios y aún apuntan individualmente a la caché en su disco.

Solaris 10 puede volver a montar de forma elegante los directorios de inicio. Tu hogar lo hará
aparentemente ser un punto de montaje propio, llamado /casa/$ LOGNAME, cuando de hecho está en
uno de los / exportar / inicio * discos junto con los de otros usuarios. Porque no es
realmente un sistema de archivos separado, los enlaces aún funcionan. Pero no puedes buscar hacia arriba.
En su lugar, puede hacer:

BUILD_CACHE: = $ {makeperl }

Construcción caches y firmas

Makepp busca archivos en el caché de compilación de acuerdo con sus firmas. Si esta usando
el método de firma predeterminado (fecha de archivo + tamaño), makepp solo extraerá archivos del
crear caché si la fecha del archivo de los archivos de entrada es idéntica. Dependiendo de cómo se construya
funciona, es posible que las fechas del archivo nunca sean idénticas. Por ejemplo, si desprotege archivos en
dos jerarquías de directorios diferentes, es probable que las fechas de los archivos sean las
los archivos fuera, no la hora en que se registraron (dependiendo, por supuesto, de su
software de control de versiones).

Lo que probablemente desee es extraer archivos de la caché de compilación si el archivo contenido en
idéntico, independientemente de la fecha. Si este es el caso, debería utilizar algún tipo de
una firma basada en contenido. Makepp hace esto de forma predeterminada para las compilaciones de C y C ++, pero
utiliza fechas de archivo para cualquier otro tipo de archivo (por ejemplo, archivos de objeto o cualquier otro archivo en
el proceso de compilación no se reconoce específicamente como una fuente C o un archivo de inclusión). Si quieres
otros tipos de archivos para trabajar con el caché de compilación (es decir, si desea que funcione con
cualquier otra cosa que no sean los comandos de compilación de C / C ++), entonces podría poner una declaración como esta
en algún lugar cerca de la parte superior de su archivo MAKE:

firma md5

forzar a makepp a usar firmas basadas en el contenido de los archivos en lugar de su fecha.

Cómo no a cache a ciertos archivos

Puede haber ciertos archivos que sabe que nunca querrá almacenar en caché. Por ejemplo, si
incrusta una marca de fecha en un archivo, sabe que nunca, bajo ninguna circunstancia
desea obtener una copia anterior del archivo fuera de la caché de compilación, porque el sello de fecha
es diferente. En este caso, es solo una pérdida de tiempo y espacio en disco copiarlo en el
crear caché.

O puede pensar que es muy poco probable que desee almacenar en caché el ejecutable final.
Es posible que desee almacenar en caché objetos individuales u objetos compartidos que intervienen en la creación de
ejecutable, pero a menudo es poco probable que cree un exactamente idéntico
ejecutable a partir de entradas idénticas. Nuevamente, en este caso, usar un caché de compilación es un desperdicio de
espacio en disco y tiempo, por lo que tiene sentido deshabilitarlo.

A veces, un archivo puede ser extremadamente rápido de generar y es un desperdicio ponerlo en
la caché de compilación, ya que se puede generar tan rápido como se copia. Es posible que desee
deshabilite selectivamente el almacenamiento en caché de estos archivos.

Puede desactivar la caché de compilación para reglas específicas especificando ": build_cache none" en
una regla, como esta:

our_executable: dateStamp.o main.o * / *. entonces
: build_cache ninguno
$ (CC) $ (LDFLAGS) $ (entradas) -o $ (salida)

Esta bandera significa que las salidas de esta regla en particular nunca se colocarán en el
build cache, y makepp nunca intentará sacarlos del build cache tampoco.

Cómo a gestionan a build cache
makepp_build_cache_control comando ...
mpbbcc comando ...

makepp_build_cache_control, mpbbcc es una utilidad que administra las memorias caché de compilación para makepp.
¿ makepp_build_cache_control lo que hace está determinado por la primera palabra de su argumento.

De hecho, este pequeño script es un contenedor del siguiente comando, que quizás desee
llame directamente en sus trabajos cron, donde la ruta a "makeppbuiltin" podría ser necesaria:

comando makeppbuiltin -MMpp :: BuildCacheControl ...

También puede usar estos comandos desde un archivo MAKE después de cargarlos, con un prefijo "&" como
sigue para el ejemplo de "crear":

perl {use Mpp :: BuildCacheControl} # Es un módulo de Perl, así que use en lugar de incluir.

mi_caché:
& create $ (CACHE_OPTIONS) $ (salida) # Llamar a un builtin cargado.

build_cache $ (precompilar my_cache)

Los comandos válidos, que también toman algunas de las opciones estándar descritas en
makepp_builtins, son:

Para crear [opción ...] ruta / a / caché ...
Crea las memorias caché de compilación con las opciones dadas. Las opciones válidas son:

Opciones estándar: "-A, --args-file, --arguments-file = filename, -v, --verbose"

-e grupo de XNUMX
--extend =grupo de XNUMX
--extend-group =grupo de XNUMX
Agregue la nueva caché de compilación al "grupo". Esta puede haber sido una sola
crear caché hasta ahora.

-f
--fuerza
Esto permite crear la caché incluso si ruta / a / caché ya existía. Si era
un archivo se elimina. Si era un directorio, se reutiliza, con lo que sea
contenido que tenía.

-p
--privilegiado
Esta opción solo es significativa si tiene memorias caché de compilación en el grupo, que permiten
enlaces duros a enlaces simbólicos. En ese caso, la limpieza migrará los miembros a la
disco preferido. Puede crear varios cachés dentro de un grupo con esta opción, en
en cuyo caso los archivos se migrarán aleatoriamente a ellos.

-s n1, n2, ...
--subdir-chars =n1, n2, ...
Controla cuántos niveles de subdirectorios se crean para contener los archivos en caché,
y cuántos archivos habrá en cada subdirectorio. El primero n1 personajes de la
nombre de archivo forma el nombre del directorio de nivel superior y los caracteres de n1 a n2 formulario
el nombre del directorio de segundo nivel, y así sucesivamente.

Los archivos en el caché de compilación se nombran usando hash MD5 de datos que usa makepp, por lo que
cada nombre de archivo tiene 22 dígitos base64 más el nombre de archivo original. Si un caché de compilación
el nombre del archivo es 0123456789abcdef012345_module.o, en realidad se almacena en la compilación
caché como 01/23/456789abcdef012345_module.o si especifica "--subdir-chars 2,4".
De hecho, "--subdir-chars 2,4" es el valor predeterminado, que es para un caché de compilación gigantesco
de un máximo de 4096 dirs con 416777216 subdirectorios. Incluso "--subdir-chars 1,2" o
"--subdir-chars 1" te llevará bastante lejos. En un sistema de archivos optimizado para grandes
directorios en los que incluso podría decir "-s ''" o "--subdir-chars =" para almacenar todos los archivos en
el nivel superior.

-m perms
--mode =perms
--access-permissions =perms
Especifica los permisos de acceso al directorio cuando se agregan archivos a la compilación
cache. Si desea que otras personas coloquen archivos en su caché de compilación, debe hacer
se puede escribir en grupo o en el mundo. Los permisos deben especificarse mediante notación octal.

Como estos son permisos de directorio, si otorga algún acceso, también debe otorgar
ejecute el acceso, o obtendrá un montón de fallas extrañas. Es decir, 0700 significa que
solo este usuario puede tener acceso a esta caché de compilación. 0770 significa que este usuario y
cualquier persona del grupo puede tener acceso de escritura a la memoria caché de compilación. 0777 significa que
cualquiera puede tener acceso al caché de compilación. Los dígitos octales sensibles son 7
(escribir), 5 (leer) o 0 (ninguno). 3 (escribir) o 1 (leer) también es posible, lo que permite
la caché que se va a utilizar, pero no a navegar, es decir, sería más difícil para un
usuario malintencionado para encontrar nombres de archivos para manipular.

En un grupo de cachés de compilación, cada uno tiene su propio valor para esto, por lo que puede hacer cumplir
diferentes permisos de escritura en diferentes discos.

Si no especifica los permisos, sus permisos de umask en el momento de la creación
se aplican a lo largo de la vida útil de la caché de compilación.

limpia [opción ...] / ruta / a / caché ...
Limpia el caché. Makepp nunca elimina archivos del caché de compilación; es tu decision
para eliminar los archivos con este comando. Para cachés multiusuario, el operador del sistema puede hacer esto.

Solo se eliminan los archivos con un recuento de enlaces de 1 (porque de lo contrario, el archivo no se
eliminado físicamente de todos modos; simplemente eliminaría de la caché un archivo que aparentemente alguien
todavía interesado, por lo que alguien más podría estarlo también). Los criterios que da pertenecen a
los archivos en caché reales. Cada archivo de información de compilación se eliminará cuando su archivo principal sea.
No se dejarán directorios vacíos. Independientemente del recuento de enlaces y las opciones que
dar, cualquier archivo que no coincida con su archivo de información de compilación se eliminará, si es más antiguo
que un margen de seguridad de 10 minutos.

Las siguientes opciones toman una especificación de tiempo como argumento. Las especificaciones de tiempo comienzan con
un "+" que significa hace más tiempo, un "-" que significa más recientemente o ningún significado entre los
número que das, y uno más. Los números, que pueden ser fraccionarios, son días predeterminados.
Pero pueden ir seguidos de una de las letras "w" (semanas), "d" (días, el valor predeterminado),
"h" (horas), "m" (minutos) o "s" (segundos). Tenga en cuenta que los días son simplemente 24 horas reales.
ignorando cualquier cambio entre el horario de verano y el de invierno. Ejemplos:

1 hace entre 24 y 48 horas
24h entre 24 y 25 horas atrás
Hace 0.5d entre 12 y 36 horas
1 semana entre 7 y 14 veces hace 24 horas
-2 hace menos de 48 horas
+ 30m hace más de 30 minutos

Todas las siguientes opciones se combinan con "y". Si quieres varios juegos de
combinaciones con "o", debe llamar a este comando repetidamente con diferentes conjuntos de
opciones. Primero, haga los que espera la mayor cantidad de eliminaciones, luego los demás pueden
se más rápido.

Opciones estándar: "-A, --args-file, --arguments-file = filename, -v, --verbose"

-a especulación
--un momento especulación
--tiempo de acceso especulación
La última vez que se leyó el archivo. Para un archivo vinculado, esto puede suceder en cualquier momento.
De lo contrario, esta es la última vez que se copió el archivo. En sistemas con mal comportamiento
también podría ser la última copia de seguridad en cinta o la hora de creación del índice de búsqueda. Tú podrías
intente excluir el caché de tales operaciones.

Algunos sistemas de archivos no admiten el campo atime, e incluso si el sistema de archivos
lo hace, a veces las personas desactivan el tiempo de acceso en sus sistemas de archivos porque agrega
una gran cantidad de E / S de disco adicionales que pueden ser dañinas en los portátiles que funcionan con batería o en
Optimización de la velocidad del disco. (Pero esto es potencialmente solucionable; consulte el
Comentario UTIME_ON_IMPORT en Mpp / BuildCache.pm.)

-b
--mezcla
- grupos de mezcla
Por lo general cada / ruta / a / caché que especifique tratará por separado el grupo de construcción
cachés a los que pertenece. Cada grupo recibe tratamiento solo una vez, incluso si especifica
varios pathes del mismo grupo. Con esta opción, mezcla temporalmente todos
los grupos que especifique en un grupo.

Hacer esto para limpiar puede tener efectos no deseados, si puede hacer un enlace duro a los enlaces simbólicos,
porque puede migrar miembros de un grupo a otro. Posterior no mezclado
limpia, luego puede limpiarlos del grupo original antes de tiempo.

-c especulación
- hora especulación
--cambio de hora especulación
La última hora de cambio del inodo del archivo. En una situación de vinculación, esto podría ser
el momento en que el último usuario recreó el archivo de manera diferente, cortando su enlace a
el caché. Este también podría ser el momento en que la opción "--set-user" a continuación
cambiar el usuario. En sistemas que se comportan bien, este también podría ser el momento en que
La última copia de seguridad en cinta o la creación del índice de búsqueda cubrió sus marcas restableciendo el
un momento.

-m especulación
--mtime especulación
- tiempo de modificación especulación
La última hora de modificación del archivo. Como se explica en otra parte, se desaconseja
hacer que makepp actualice un archivo. Entonces, la última modificación generalmente será la hora
de la creación. (Pero en el futuro, makepp puede actualizar opcionalmente el mtime cuando
eliminar archivos. Esto es para que los enlaces en sistemas de archivos o copias sin tiempo puedan ser
rastreado.)

-g grupo de XNUMX
--newgrp =grupo de XNUMX
--nuevo-grupo =grupo de XNUMX
Establezca la identificación de grupo efectiva y real en grupo (nombre o numérico). Solo la raíz puede ser
capaz de hacer esto. Esto es necesario cuando usa cachés de compilación agrupados, y
proporcionar acceso de escritura a las cachés en función de la identificación del grupo. Por lo general, eso no será
el grupo raíz y, por lo tanto, la replicación crearía directorios que no se pueden escribir sin esto
.

Esta opción lleva el nombre de la utilidad equivalente "newgrp" que, lamentablemente, no puede
ser utilizado en trabajos "cron" o configuraciones similares.

-i
--información de construcción
--construir-información-comprobar
Compruebe que la información de la compilación coincida con el miembro. Esta prueba es bastante cara, por lo que
podría considerar no dar esta opción durante el día.

-l
--comprobación de enlace simbólico
- verificación-enlace-simbólico
Esta opción hace que se lea "limpio" todos los enlaces simbólicos que no tienen hardware externo
enlaces para verificar que apunta al miembro deseado. Como esto es algo
caro, se sugiere hacerlo solo por la noche.

-M especulación
--en-mtime especulación
- hora-de-modificación-entrante especulación
La última hora de modificación de los archivos en el directorio entrante. Este directorio es
utilizado para archivos temporales con nombres específicos del proceso que se pueden escribir sin
acceso concurrente y luego renombrado en la parte activa de la caché de forma atómica.
Los archivos normalmente viven aquí solo durante el tiempo que sea necesario para escribirlos, pero pueden
quedar huérfanos si el proceso que los está escribiendo termina anormalmente antes de que
puede eliminarlos. Esta parte de la caché se limpia primero, porque el enlace cuenta
en la parte activa de la caché pueden verse afectados incorrectamente por archivos huérfanos.

La especificación de tiempo para "--incoming-modified-time" debe comenzar con "+" y los valores predeterminados
a "+ 2h" (se supone que los archivos con al menos 2 horas de antigüedad han quedado huérfanos).

-w
--días laborables
Esto influye en cómo cuentan las opciones de tiempo. Los fines de semana se ignoran, como si
no estaban allí. Una excepción es si ofrece esta opción durante un fin de semana. Entonces eso
el fin de semana cuenta normalmente. Entonces puedes usarlo en cronjobs que se ejecutan desde el martes.
hasta el sábado. Se ignora el verano. Entonces los fines de semana de verano pueden ir desde el sábado
1:00 al lunes 1:00, o fines de semana de invierno del hemisferio sur desde el viernes 23:00 a
Domingo 23:00 o por mucho que cambie su zona horaria. Las vacaciones también son
no se tiene en cuenta.

-p código perl
--perl =código perl
--predicate =código perl
TODO: ¡adapta esta descripción a los cambios de grupo!

Este es el cuchillo del oficial suizo. los código perl se llama en contexto escalar una vez
para cada entrada de caché (es decir, excluyendo directorios y archivos de metainformación). Está
llamado en una función "Archivo :: Buscar" "buscado", así que vea allí las variables que puede
usar. Se ha realizado un "lstat", por lo que puede utilizar el identificador de archivo "_".

If código perl devuelve "undef" es como si no estuviera allí, es el otro
las opciones deciden. Si devuelve verdadero, el archivo se elimina. Si devuelve falso, el
el archivo se conserva.

-s especulación
--Talla especulación
La especificación de tamaño de archivo funciona igual que las especificaciones de tiempo, con "+" para
mayor que o "-" para menor que, excepto que las unidades deben ser "c" (bytes, el
predeterminado), "k" (kilobytes), "M" (megabytes) o "G" (gigabytes).

-u usuario
--user =usuario
--set-user =usuario
Esta opción es muy diferente. No dice cuándo eliminar un archivo. En lugar de eso
se aplica a los archivos que no se eliminan. Tenga en cuenta que en muchos sistemas solo root
se permite establecer el usuario de un archivo. Consulte la sección "Advertencias sobre el trabajo con build
cachés "por qué es posible que deba cambiar la propiedad a algún usuario neutral si usa
cuotas de disco.

Esta estrategia solo funciona si puede confiar en que sus usuarios no subvertirán la compilación
caché para almacenar archivos arbitrarios (es decir, que no son de desarrollo) más allá de su cuota de disco.
La propiedad del archivo de metadatos asociado se conserva, por lo que siempre puede ver
que almacenó en caché un archivo. Si necesita esta opción, es posible que deba proporcionarle varias
veces durante el día.

Existen diferentes estrategias posibles, dependiendo del espacio del que dispongas y de
si la caché de compilación contiene archivos vinculados o si los usuarios solo tienen copias.
Se pueden combinar varias estrategias, llamándolas una tras otra o en diferentes
veces. El comando "mostrar" está destinado a ayudarlo a encontrar una estrategia adecuada.

Una ejecución nocturna (de martes a sábado) puede especificar "--atime +2" (o "--mtime"
si no tiene una hora), eliminar todos los archivos que nadie ha leído durante dos días.

Si usa enlaces, también puede prevenir el crecimiento rápido e inútil que ocurre cuando
los sucesivos cambios de encabezado, que nunca se controlan la versión, conducen a muchos objetos
siendo creado rápidamente. Algo como una carrera por hora con "--mtime = -2h --ctime = + 1h"
durante el día capturará a los tipos que el creador eliminó en menos de una hora,
y nadie más ha querido desde entonces.

Mostrar [opción ...] / ruta / a / caché ...
Es una especie de comando recursivo "ls -l" o "stat", que muestra el propietario original
también, para cuando se haya cambiado el propietario del archivo en caché y el archivo de metadatos
retiene el propietario original (según "clean --set-user"). Muestra los archivos dados, o
todo bajo los directorios dados.

Los campos son, en el estándar corto y en la forma detallada larga:

MODO, modo
El modo octal del archivo en caché, que generalmente es el que se instaló, menos el
escribir bits.

EL, enlaces externos
El número de enlaces físicos externos que hay para todos los miembros del grupo combinados.
Solo cuando este es 0, el archivo es elegible para limpieza.

C, copias (solo para cachés de compilación agrupados)
El número de copias del archivo idéntico, en todas las memorias caché de compilación. Idealmente esto
es uno de los sistemas que permiten enlaces duros a enlaces simbólicos, pero que puede
temporalmente no será posible, mientras haya enlaces externos a más de una copia
(en cuyo caso perderíamos el recuento de enlaces si lo elimináramos.

S, enlaces simbólicos (solo para cachés de compilación agrupados)
El número de enlaces simbólicos entre las memorias caché de compilación. Idealmente, este es el número de
construya cachés menos uno en sistemas que permitan enlaces duros a enlaces simbólicos.
Pero como se explicó en el campo anterior, puede haber más copias de las necesarias,
y por tanto menos enlaces.

UID El propietario del archivo en caché. Esto se puede cambiar con la opción "clean --user".

BI-UID
El propietario del archivo de información de compilación. Esto no se cambia por limpiar, permitiendo ver
quién creó el archivo por primera vez.

TAMAÑO
El tamaño (de una copia) en bytes.

un tiempo, m tiempo, c tiempo
En la forma larga y detallada, obtiene el tiempo de acceso (lectura) al archivo, la modificación
tiempo y el tiempo de cambio de inodo (por ejemplo, cuando algún usuario borró su enlace externo a
el archivo en caché). En el formulario estándar corto, solo obtiene una de las tres veces
en tres columnas separadas:

AD, MD, CD
El día de la semana del acceso, modificación o cambio de inodo.

A FECHA, M FECHA, C FECHA
La fecha del acceso, modificación o cambio de inodo.

A TIEMPO, MTIME, CTIME
La hora del día del acceso, modificación o cambio de inodo.

MIEMBROS
La ruta completa del archivo en caché, incluida la clave, desde la raíz del caché.

Con "-v, --verbose", la información que se muestra para cada comando le permite obtener un
Impresión de qué opciones dar al comando "limpiar". Los tiempos se muestran en
forma legible, así como la cantidad de días, horas o minutos la antigüedad de este archivo
acaba de superar. Si duplica la opción, obtendrá además la información de cada
miembro del grupo.

Opciones estándar: "-A, --args-file, --arguments-file = filename, -f, --force, -o,
--output = nombre de archivo, -O, --outfail, -v, --verbose "

-a
--un momento
--tiempo de acceso
Muestra la hora de acceso al archivo, en lugar de la hora de modificación del archivo en modo no detallado.

-b
--mezcla
- grupos de mezcla
Por lo general cada / ruta / a / caché que especifique tratará por separado el grupo de construcción
cachés a los que pertenece. Cada grupo recibe tratamiento solo una vez, incluso si especifica
varios pathes del mismo grupo. Con esta opción, mezcla temporalmente todos
los grupos que especifique en un grupo.

-c
- hora
--cambio de hora
Muestre la hora de cambio de información de inodo, en lugar de la hora de modificación del archivo en no detallado
modo.

-d
- suprimible
Muestra solo archivos borrables, es decir, aquellos con un recuento de enlaces externos de 0.

-p patrón
--pattern =patrón
Patrón de Costura ¿Se compara un patrón de nombre de archivo de estilo bash (es decir,?, *, [], {,,})
nombres de miembros después del guión bajo que los separa de la clave.

-s lista
--sort =lista
En el modo no detallado, cambie el orden de clasificación. La lista no distingue entre mayúsculas y minúsculas
Orden de títulos de columna separados por comas o espacios. Hay dos casos especiales:
"miembro" solo considera los nombres después de la clave, es decir, los nombres de los archivos tal como están
fuera del caché. Y hay un nombre especial "edad", que agrupa lo que sea
se muestra la fecha y la hora. Esta opción tiene como valor predeterminado "miembro, edad".

Si tiene un caché enorme para el que la clasificación lleva demasiado tiempo o necesita más
memoria de lo que están permitidos sus procesos, puede omitir la clasificación dando un vacío
lista.

estadísticas [opción ...] / ruta / a / caché ...
Esto genera varias tablas de estadísticas sobre el contenido de la caché de compilación. Cada mesa
se divide en tres grupos de columnas. La primera columna varía para cada tabla y es la
encabezado de fila. Los otros dos grupos pertenecen a la suma de TAMAÑO de archivos y número de ARCHIVOS
para ese título. Los directorios y los archivos de información de compilación no se cuentan, por lo que este es un
un poco menos para el tamaño que el uso real del disco y aproximadamente la mitad para la cantidad de archivos.

Cada uno de los dos últimos grupos consta de tres pares de columnas, una columna con un valor,
y uno para el porcentaje del total que representa ese valor. El primer par muestra
ya sea el tamaño de los archivos o el número de archivos. Los otros dos pares muestran el
Cumulación, una vez de menor a mayor y otra vez al revés.

Las primeras tres tablas, con una primera columna de AD, CD or MD mostrar tiempos de acceso, inodo
tiempos de cambio o tiempos de modificación agrupados por días. Los días son en realidad bloques de 24 horas.
contando hacia atrás desde la hora de inicio del comando stats. La fila "0" del primero
Por tanto, la tabla mostrará la suma de tamaños y el número de archivos a los que se accede menos de un día.
atrás. Si no se accedió a ningún archivo, no habrá fila "0". Fila "1" en la tercera
La tabla mostrará los archivos modificados (es decir, escritos en el caché de compilación) entre 24 y 48
horas atras.

La siguiente mesa, EL, muestra enlaces externos, es decir, cuántos árboles de compilación comparten un archivo desde
el caché de compilación. Ésta es una medida de utilidad de la caché de compilación. Por desgracia, solo
funciona cuando los desarrolladores tienen un caché Buld en su propio disco, de lo contrario, tienen que copiar
que no deja rastro global. Cuanto más contenido tenga mayor número de enlaces externos,
mayor es el beneficio de la caché de compilación.

La siguiente mesa, otra vez EL, muestra la misma información que la anterior, pero ponderada
por el número de enlaces externos. Cada byte o archivo con un enlace externo cuenta uno
cuenta como uno. Pero si la cuenta es diez, los valores se cuentan diez veces. Es por eso
los títulos cambian a *TALLA y * ARCHIVOS. Este es un valor hipotético, que muestra cómo
mucho uso del disco o cuántos archivos habría si los mismos árboles de compilación se hubieran usado
sin caché de compilación.

Una mesa mas C: S copias a enlaces simbólicos, pertenece solo a cachés agrupados. Idealmente todos
los miembros existen en una copia y uno menos enlaces simbólicos que cachés en el grupo.
Los enlaces simbólicos permanecen en "0" hasta que se haya replicado la limpieza. Puede haber más de una copia,
si varias personas crearon el archivo idéntico antes de que se replicara, o si
La replicación migró el archivo a un disco preferido, pero el archivo original todavía estaba en
usar. Las copias superfluas se convierten en enlaces simbólicos cuando la limpieza descubre que no tienen más
enlaces externos.

Opciones estándar: "-A, --args-file, --arguments-file = filename, -v, --verbose"

-h
--horas
Muestre las tres primeras tablas con una granularidad mucho más fina. Los encabezados de las columnas
cambiar AH, CH or MH en consecuencia.

-p patrón
--pattern =patrón
Patrón de Costura ¿Se compara un patrón de nombre de archivo de estilo bash (es decir,?, *, [], {,,})
nombres de miembros después del guión bajo que los separa de la clave. Todas las estadisticas
están limitados a archivos coincidentes.

Advertencias trabajando build caches
Las memorias caché de compilación no funcionarán bien en las siguientes circunstancias:

· Si el comando que ejecuta makepp para crear un archivo en realidad solo actualizaciones el archivo y
no lo construye nuevo, entonces debería NO utilizar un caché de compilación. (Un ejemplo es un
comando para actualizar un módulo en una biblioteca estática (un archivo de almacenamiento o un archivo con una
extensión de .a). Como se explica en makepp_cookbook, en las máquinas modernas es casi
Siempre es una mala idea actualizar un archivo comprimido; es mejor reconstruirlo desde cero
cada vez por una variedad de razones. Ésta es otra razón más para no actualizar un
archivo.) La razón es que si la caché de compilación se encuentra en el
mismo sistema de archivos, makepp crea un vínculo físico en lugar de copiar el archivo. Si tu entonces
posteriormente modifique el archivo, el archivo que makepp tiene en el caché de compilación
en realidad se modifique, y potencialmente podría arruinar la compilación de otra persona.
En la práctica, makepp normalmente puede detectar que un archivo ha sido modificado desde que fue
colocado en el caché de compilación y no lo usará, pero a veces puede que no
detectar la modificación.

· Por .o archivos, esto puede ser un poco incorrecto, porque pueden (dependiendo del compilador
y nivel de depuración) contienen la ruta a la fuente desde la que se crearon. Esto puede hacer
depurando duro. El depurador puede obligarle a editar la copia del creador original del
fuente, o puede que ni siquiera encuentre el archivo, si el creador ya no tiene una copia. Makepp
algún día puede ofrecer una opción para parchear la ruta, lo que por supuesto significará una copia,
en lugar de un enlace eficiente.

· Cualquier otro archivo que tenga una ruta codificada no debe colocarse en un caché de compilación
(si comparte su caché de compilación entre varias jerarquías de directorios o varias
desarrolladores). En este caso, el resultado de una compilación en un directorio diferente no es el
lo mismo que si estuviera en el mismo directorio, por lo que todo el concepto de la caché de compilación es
no aplica. Está bien si especifica la ruta del directorio en la línea de comando, como
modo:

& echo prog_path = $ (PWD) -o $ (salida)

porque entonces la línea de comando será diferente y makepp no ​​extraerá incorrectamente el
archivo fuera de la caché de compilación. Pero si la línea de comando no es diferente, entonces
podría ser un problema. Por ejemplo,

echo prog_path = `pwd`> $ (salida)

no funcionará correctamente.

· Al utilizar enlaces y con muchos desarrolladores activos del mismo proyecto en el mismo disco,
Las memorias caché de compilación pueden ahorrar mucho espacio en disco. Pero al mismo tiempo para usuarios individuales
lo contrario también puede ser cierto:

Imagine Chang es el primero en hacer una compilación completa. Viene Ching y obtiene un enlace a
todos esos archivos. Chang hace algunos cambios fundamentales que conducen a que la mayoría de las cosas sean
reconstruido. Él los registra, Chong los revisa y obtiene enlaces al caché de compilación.
Chang vuelve a hacer cambios, lo que lleva a un tercer conjunto de archivos.

En este escenario, no importa qué estrategia de limpieza utilice, no se eliminarán archivos,
porque todavía están en uso. El problema es que todos pertenecen a Chang,
que puede hacer que alcance su cuota de disco, y no hay nada que pueda hacer al respecto en
la mayoría de los sistemas. Consulte el comando "clean --set-user" en "Cómo administrar una caché de compilación"
sobre cómo el administrador del sistema podría cambiar los archivos a un propietario de caché sin cuotas.

· Si está utilizando firmas de marca de tiempo / tamaño para verificar el objetivo y su compilación
info (predeterminado), entonces es posible obtener un alias de firma, en el que no
los archivos correspondientes no serán detectados. Por ejemplo, el valor de información de construcción MD5_SUM
puede no coincidir con la suma de comprobación MD5 del objetivo. Esto no suele ser un problema, porque
en virtud del hecho de que las claves de la caché de compilación coinciden, el destino en la caché de compilación
es sustituible por el objetivo que habría correspondido al archivo de información de compilación.
Sin embargo, si tiene acciones de reglas que dependen de la información de compilación, esto podría
en problemas (así que no hagas eso). Si esto le preocupa, utilice la opción --md5-check-bc
.

Concurrente de la máquina
Los cachés de compilación deben admitir el acceso concurrente, lo que implica que la implementación debe
Sea tolerante con las razas. En particular, un archivo puede envejecer (eliminarse) entre el momento
makepp decide importar un destino y el momento en que se completa la importación.

Además, algunas personas utilizan memorias caché de compilación sobre NFS, lo que no es necesariamente coherente. En
En otras palabras, el orden de creación y eliminación de archivos por parte del escritor en un host no
coincidir necesariamente con el orden visto por un lector en otro host y, por lo tanto, las carreras no puede
ser resuelto prestando especial atención al orden de las operaciones de archivo. (Pero hay
por lo general, un tiempo de espera de caché NFS de aproximadamente 1 minuto, lo que garantiza que las escrituras no tomarán
más que esa cantidad de tiempo para propagarse a todos los lectores. Además, típicamente en
practica al menos el 99% de las escrituras son visibles en todas partes en 1 segundo).
debemos tolerar el caso en el que el destino en caché y su archivo de información de compilación parezcan no
corresponder. Además, existe una carrera peculiar que puede ocurrir cuando un archivo es
simultáneamente envejecido y reemplazado, en el que los archivos no se corresponden incluso después del NFS
descargas de caché. Esto parece inevitable.

Use makepp_build_cache_control en línea usando los servicios de onworks.net