2026 CI Mac distant : sccache vs ccache, matrice des hits de cache de compilation

Retenez un cache compilateur principal par classe de pipeline. Mélanger deux wrappers sans cloisonner CC, CXX et les lanceurs CMake, c’est inviter des statistiques faussées et des collisions silencieuses entre jobs. Les scénarios GitLab CI, GitHub Actions hébergées ou Jenkins sur Apple Silicon se rejoignent : la décision se joue sur la forme du stockage (objet clé-valeur vs répertoire POSIX), la latence vers le filer et la maturité de votre observabilité Redis.

Aucun outil ne remplace un pinning de toolchain discipliné : une montée de Xcode ou du driver Swift modifie les empreintes préprocesseur — reliez toujours les tableaux de taux de hit à votre matrice compilateur plutôt qu’à des KPI décoratifs. Pour un autre angle « caches déclaratifs », croisez avec la matrice Nix Flake et substituters.

Hygiène Redis : renseignez SCCACHE_REDIS_ENDPOINT en rediss:// lorsque le TLS se termine sur le broker ; séparez les secrets dans SCCACHE_REDIS_USERNAME et SCCACHE_REDIS_PASSWORD plutôt que dans l’URL ; limitez l’utilisateur ACL à un SCCACHE_REDIS_DB dédié. Documentez côté infra les timeout client et tcp-keepalive pour expliquer les stalls du wrapper. Associez chaque endpoint à un préfixe de clé via SCCACHE_REDIS_KEY_PREFIX (et éventuellement SCCACHE_NAMESPACE multi-backend) afin qu’une branche expérimentale n’écrase jamais les artefacts d’un pilote noyau.

Montages NFS pour ccache : privilégiez noatime, alignez rsize/wsize sur le guide du fournisseur, évitez l’océan pour les phases riches en métadonnées — exécutez un micro-benchmark compile avant de contractualiser un SLA. CCACHE_TEMPDIR doit toujours pointer vers un dossier job-local sur le SSD interne du Mac : les objets temporaires ne doivent pas toucher le filer.

Workers concurrents : plafonnez CMAKE_BUILD_PARALLEL_LEVEL ou Ninja -j par rapport à la RAM disponible ; chaque étape de link supplémentaire augmente le pic RSS et peut affamer le canal vers Redis. Sur un Mac distant partagé, commencez par ~50 % des cœurs performance, montez progressivement en surveillant les compteurs d’erreur de sccache --show-stats.

1. Runbook versionné : hôte Redis, port, index DB, nom ACL, procédure de rotation des secrets.
2. SCCACHE_REDIS_KEY_PREFIX encode produit, flux Xcode majeur et génération volontairement incompatible.
3. SCCACHE_DIR et CCACHE_DIR ne se recoupent pas entre locataires sans sous-répertoires distincts.
4. Exports NFS : snapshots / sauvegardes cohérents avec la politique d’éviction ; propriétaire identifié pour locks bloqués.
5. CI journalise sccache --show-stats ou ccache -s après la phase compile.
6. Seuils disque locaux et NAS avec alertes avant échec en plein link.

Copiez le bloc correspondant à votre pile, puis adaptez les noms d’hôte. Les secrets restent dans le coffre — les journaux ne gardent que des identifiants non sensibles.

# --- sccache + Redis (TLS ; secrets via variables dédiées) ---
export SCCACHE_REDIS_ENDPOINT="rediss://sccache-redis.internal:6379"
export SCCACHE_REDIS_USERNAME="ci-sccache"
export SCCACHE_REDIS_PASSWORD="${SCCACHE_REDIS_PASSWORD_SECRET}"  # injecter depuis le coffre
export SCCACHE_REDIS_DB="0"
export SCCACHE_REDIS_KEY_PREFIX="acme/mobile/xcode-16-3/"
export SCCACHE_REDIS_EXPIRATION="2592000"    # option : TTL 30 jours (secondes)
export SCCACHE_NAMESPACE="acme-ci"           # option : espace global multi-backend
export SCCACHE_DIR="${CI_PROJECT_DIR}/.sccache-staging"
export SCCACHE_IDLE_TIMEOUT="1800"           # secondes ; augmenter si link > 15 min
export SCCACHE_CACHE_SIZE="64G"              # plafond disque local des morceaux sccache
export RUSTC_WRAPPER="$(command -v sccache)"
export CARGO_BUILD_RUSTC_WRAPPER="${RUSTC_WRAPPER}"
export CMAKE_C_COMPILER_LAUNCHER="$(command -v sccache)"
export CMAKE_CXX_COMPILER_LAUNCHER="$(command -v sccache)"
mkdir -p "${SCCACHE_DIR}"

# --- ccache + APFS (par job) + taille bornée ---
export CCACHE_DIR="${CI_PROJECT_DIR}/.ccache"
export CCACHE_TEMPDIR="${TMPDIR:-/tmp}/ccache-${CI_JOB_ID:-local}"
export CCACHE_MAXSIZE="32G"
export CCACHE_LIMIT_MULTIPLE="0.85"
export CCACHE_COMPRESS="1"
export CCACHE_COMPRESSLEVEL="6"
export CCACHE_SLOPPINESS="pch_defines,time_macros"
export CMAKE_C_COMPILER_LAUNCHER="$(command -v ccache)"
export CMAKE_CXX_COMPILER_LAUNCHER="$(command -v ccache)"
mkdir -p "${CCACHE_DIR}" "${CCACHE_TEMPDIR}"

# --- Échelle de retry pour transport wrapper fragile (après exports) ---
# Seuils recommandés : max=4 tentatives, délais 2s → 4s → 8s (dernière pause 8s)
run_with_cache_retries() {
  local attempt=1 max=4 delay=2
  while [ "${attempt}" -le "${max}" ]; do
    echo "phase compile tentative ${attempt}/${max}"
    if "$@"; then return 0; fi
    sleep "${delay}"
    delay=$((delay * 2))
    attempt=$((attempt + 1))
  done
  return 1
}
# Exemple : run_with_cache_retries cmake --build build --parallel "${CMAKE_BUILD_PARALLEL_LEVEL:-8}"

Timeouts : alignez la durée d’inactivité sccache sur votre unité de link la plus lente ; si Redis coupe à neuf minutes mais que le link dure douze, augmenter SCCACHE_IDLE_TIMEOUT prime sur l’ajout aveugle de -j. Pour le stockage HTTP secondaire de ccache 4.x, calquez-vous sur les défauts éditeur pour connect/read, puis validez avec un build froid depuis chaque région supportée.

sccache remplace-t-il distcc ? Non : sccache met en cache des résultats de compilation ; il n’orchestre pas une ferme distribuée. Ce guide cible l’économie des hits, pas la topologie distcc.

Faut-il activer toutes les options de « sloppiness » ccache pour le hit ? Seulement celles acceptées par la revue sécurité : chaque flag échange reproductibilité contre taux de hit — documentez le jeu exact à côté de la politique SBOM.

Que faire si Redis évincie des entrées chaudes en plein sprint ? Traitez l’éviction comme normale ; élargissez les namespaces seulement lorsque vous voulez isoler. Planifiez un job nocturne qui réchauffe les dix cibles dominantes pour lisser l’expérience développeur.

Où placer DerivedData Xcode ? Couche distincte des wrappers compilateur ; pour des pipelines iOS complets, croisez avec un guide DerivedData dédié lorsque vous optimisez la fin de chaîne.

Redis saturé alors que le CPU compile encore : premier levier ? Baissez CMAKE_BUILD_PARALLEL_LEVEL ou le parallélisme Ninja avant d’augmenter les timeouts : le wrapper devient souvent le goulot d’étranglement réseau, pas le compilateur.