Que le jeu commence : Henry Cavill met Googlebook à l’épreuve

Que le jeu commence : Henry Cavill met Googlebook à l’épreuve

Source primaire : « Game on: Henry Cavill is putting Googlebook to the test » — Google AI Blog, 29 septembre 2026. Lire la source. Niveau de preuve A : la source primaire est accessible et a été vérifiée.

Ce que la source établit réellement

Commençons par l’inventaire honnête, car il est plus court que ne le suggère le titre. La source est un billet de blog Google annonçant qu’Henry Cavill met Googlebook à l’épreuve dans un contexte de jeu vidéo. Voilà le contenu vérifiable : une personnalité publique nommée, un appareil nommé et un scénario de jeu, publié le 29 septembre 2026.

La source ne publie pas de protocole de test. Elle ne publie pas de distributions de temps de frame, de percentiles de latence, de cibles de résolution ou de rafraîchissement, de comportement thermique, de conditions réseau, de consommation électrique, ni de référence comparative avec un autre appareil. Elle ne dit pas quel jeu, quels réglages, ni combien de temps a duré la session. Elle n’indique pas si le test a été orchestré par Google, par Cavill ou par un tiers.

Si vous êtes arrivé en espérant un tableau de benchmark, ce n’est pas le bon article qui va vous décevoir — et, plus important encore, ce n’est pas la bonne source qui va vous décevoir. Une annonce produit et un rapport de mesure sont des genres différents, avec des obligations différentes. La question d’ingénierie intéressante n’est pas « Cavill a-t-il aimé ? », mais « que faudrait-il pour transformer cette démonstration en preuve ? »

C’est ce que construit le reste de cet article : un banc de mesure local et reproductible que vous pouvez exécuter vous-même, plus un compte rendu lucide de ce qu’un tel banc peut et ne peut pas prouver au sujet d’un appareil que vous n’avez pas conçu.

Pourquoi une démonstration n’est pas un benchmark

Une démonstration répond à une question marketing : est-ce que cela peut être fait, et est-ce que cela a l’air bon pendant que c’est fait ? Un benchmark répond à une question d’ingénierie : dans des conditions énoncées, comment cela se comporte-t-il, et cela tient-il quand les conditions changent ?

Trois variables séparent les deux, et toutes les trois sont invisibles dans la source.

Qui a choisi le test. Quand un vendeur ou un partenaire célèbre sélectionne le titre, les réglages et la durée de session, les conditions sont organisées. Ce n’est pas une accusation de malhonnêteté ; c’est une description de la fonction d’une annonce.

Ce qui a été mesuré. « Mettre Googlebook à l’épreuve » est un cadrage, pas une métrique. La régularité des frames, la latence entrée-photon, les blocages de décodage, la tolérance à la gigue réseau et la performance soutenue après saturation thermique sont six mesures différentes qui peuvent diverger fortement sur le même matériel.

Si cela se reproduit. Une session unique, sur une unité unique, sur un réseau que personne n’a documenté, est une anecdote. Les anecdotes sont utiles pour générer des hypothèses. Elles ne sont pas utiles pour les trancher.

Rien de tout cela ne signifie que la source est trompeuse. Cela signifie que la source est incomplète par conception, et c’est dans cet écart que votre propre instrumentation a sa place.

Prérequis

Le banc ci-dessous est délibérément générique. Il suppose que vous avez l’unité Googlebook en main et que vous fournissez votre propre environnement de test — aucun de ces composants n’est décrit dans la source, et aucun des seuils ci-dessous n’est une affirmation sur l’appareil.

Matériel

• Appareil testé — l’unité Googlebook.
• Hôte de capture — une seconde machine que vous contrôlez, utilisée pour l’enregistrement d’écran et l’analyse. Garder la capture hors de l’appareil testé compte : l’enregistrement consomme du CPU, du GPU et de l’énergie, et contaminera vos propres chiffres.
• Caméra haute vitesse — un téléphone filmant à 240 fps ou mieux. C’est la seule façon honnête d’obtenir un proxy pour la latence entrée-photon sans matériel de laboratoire.
• Un réseau que vous contrôlez — un routeur où vous pouvez changer de bande, activer la QoS ou limiter le débit. Vous ne pouvez pas caractériser la gigue sur un réseau que vous ne pouvez pas configurer.
• Liaison filaire lorsque c’est possible — pour tout ce qui n’est pas l’appareil lui-même.

Logiciels

• ffmpeg et ffprobe pour la capture et l’extraction des horodatages de frame.
• iperf3 pour le débit, mtr ou ping pour le comportement du chemin.
• Python 3.10+ avec numpy, pandas, matplotlib et opencv-python-headless.

Installation pas à pas

1. Installer les outils système

Sur Debian ou Ubuntu, installez l’outillage de capture et de réseau en une seule passe.

sudo apt update && sudo apt install -y ffmpeg iperf3 mtr-tiny python3-venv python3-pip

Sur macOS avec Homebrew, l’ensemble équivalent est :

brew install ffmpeg iperf3 mtr python@3.12

2. Créer un environnement Python isolé

Garder la pile d’analyse dans un environnement virtuel évite la dérive de versions entre les exécutions de test.

python3 -m venv .venv && source .venv/bin/activate

Mettez pip à jour, puis installez les bibliothèques d’analyse.

pip install --upgrade pip && pip install numpy pandas matplotlib opencv-python-headless

3. Vérifier la chaîne d’outils de capture

Confirmez que ffmpeg est dans le chemin et signale une compilation avec les encodeurs dont vous avez besoin.

ffmpeg -version | head -n 1 && ffprobe -version | head -n 1

Créez un espace de travail avec un répertoire d’exécution horodaté pour que chaque session s’auto-documente.

mkdir -p runs && RUN_ID="$(date -u +%Y%m%dT%H%M%SZ)" && mkdir -p "runs/$RUN_ID" && echo "$RUN_ID"

4. Confirmer la source de capture

Listez les périphériques d’entrée exposés par votre hôte de capture, puis ajustez l’argument -i ci-dessous en conséquence.

ffmpeg -hide_banner -devices | grep -Ei 'x11grab|avfoundation|gdigrab'

Pour une session X11, une capture d’écran à 60 fps limitée à 20 minutes ressemble à ceci. Notez qu’une capture à 60 fps convient pour l’analyse de la régularité des frames et est inutile pour la latence — l’intervalle d’échantillonnage est de 16,7 ms, ce qui est du même ordre de grandeur que ce que vous essayez de mesurer.

ffmpeg -f x11grab -framerate 60 -video_size 1920x1080 -i :0.0 \
  -c:v libx264 -preset ultrafast -crf 18 -t 1200 "runs/$RUN_ID/session.mp4"

Pour la latence, utilisez plutôt la caméra haute vitesse, pointée vers l’écran avec le dispositif d’entrée dans le champ.

5. Construire l’échantillonneur réseau

Ce script effectue un ping vers une cible une fois par seconde et écrit un CSV que vous pourrez analyser plus tard. Pointez LAT_TARGET vers le point de terminaison que vous avez choisi de caractériser — une passerelle locale pour le comportement LAN, ou une adresse anycast publique pour le comportement étendu.

# network_sampler.py
import os, re, subprocess, time, csv
from datetime import datetime, timezone

TARGET = os.environ.get("LAT_TARGET", "1.1.1.1")
SAMPLES = 600        # ~10 minutes à 1 Hz
INTERVAL = 1.0

with open("network_samples.csv", "w", newline="") as fh:
    writer = csv.writer(fh)
    writer.writerow(["ts", "seq", "rtt_ms", "status"])
    for seq in range(SAMPLES):
        t0 = time.perf_counter()
        proc = subprocess.run(
            ["ping", "-c", "1", "-W", "1", TARGET],
            capture_output=True, text=True
        )
        elapsed = time.perf_counter() - t0
        match = re.search(r"time=([\d.]+)\s*ms", proc.stdout)
        writer.writerow([
            datetime.now(timezone.utc).isoformat(),
            seq,
            match.group(1) if match else "",
            "ok" if match else "lost",
        ])
        time.sleep(max(0.0, INTERVAL - elapsed))

Une note de portabilité : ping -W est interprété en secondes sous Linux et en millisecondes sous macOS. Si vous l’exécutez sur un Mac, utilisez -W 1000.

Exécutez-le dans un second terminal pendant toute la durée de la session de jeu.

LAT_TARGET=1.1.1.1 python network_sampler.py

Exemples d’utilisation

Exemple 1 : une session de référence unique

L’objectif est une exécution contrôlée et entièrement documentée. Notez le libellé, la durée et les conditions dans le répertoire d’exécution pour qu’un futur lecteur sache ce qu’il regarde.

RUN_ID="$(date -u +%Y%m%dT%H%M%SZ)"
mkdir -p "runs/$RUN_ID"
printf 'label: baseline-wired\nconditions: wired capture host, 60fps, 1080p\n' > "runs/$RUN_ID/meta.txt"
ffmpeg -f x11grab -framerate 60 -video_size 1920x1080 -i :0.0 \
  -c:v libx264 -preset ultrafast -crf 18 -t 1200 "runs/$RUN_ID/session.mp4"

Exemple 2 : extraire le timing des frames

ffprobe écrit un horodatage de présentation par frame. C’est la matière première de toute affirmation sur la régularité des frames que vous pourriez vouloir faire.

ffprobe -v error -select_streams v:0 -show_entries frame=pts_time \
  -of csv=p=0 "runs/$RUN_ID/session.mp4" > "runs/$RUN_ID/frame_times.csv"

Calculez ensuite les intervalles inter-frames et comptez les blocages. Un blocage est ici défini comme tout intervalle supérieur à 1,5× la médiane — une heuristique délibérément permissive, pas un standard.

import numpy as np, pandas as pd

t = pd.read_csv("runs/RUN_ID/frame_times.csv", header=None, names=["pts"])["pts"].astype(float)
dt_ms = np.diff(t.values) * 1000
nominal = np.median(dt_ms)
stalls = dt_ms[dt_ms > nominal * 1.5]

print(f"frames: {len(t)}")
print(f"nominal interval: {nominal:.2f} ms")
print(f"p50: {np.percentile(dt_ms, 50):.2f} ms | p95: {np.percentile(dt_ms, 95):.2f} ms | p99: {np.percentile(dt_ms, 99):.2f} ms")
print(f"stalls >1.5x nominal: {len(stalls)} ({100*len(stalls)/len(dt_ms):.2f}%)")

Exemple 3 : un proxy de latence à partir d’une séquence haute vitesse

Ceci ne mesure pas la vraie latence entrée-photon — cela nécessite un horodatage matériel. Cela mesure l’intervalle entre l’événement d’entrée visible et la réponse visible à l’écran, à la fréquence d’images que votre caméra fournit.

import cv2, numpy as np

cap = cv2.VideoCapture("runs/RUN_ID/highspeed.mp4")
fps = cap.get(cv2.CAP_PROP_FPS)
means = []
while True:
    ok, frame = cap.read()
    if not ok:
        break
    means.append(cv2.resize(frame, (160, 90)).mean())
cap.release()

means = np.asarray(means)
thr = means.mean() + 3 * means.std()
edges = np.where((means[1:] > thr) & (means[:-1] <= thr))[0] + 1

print(f"capture fps: {fps}")
print(f"detected events: {len(edges)}")
print(f"inter-event intervals (ms): {np.round(np.diff(edges) / fps * 1000, 2)}")

Exemple 4 : résumer le comportement réseau

Exécutez ceci après la session pour obtenir perte, gigue et latence de queue en une seule passe.

import pandas as pd

net = pd.read_csv("network_samples.csv")
ok = net[net["status"] == "ok"].copy()
ok["rtt_ms"] = ok["rtt_ms"].astype(float)

print(f"loss: {100 * (1 - len(ok) / len(net)):.2f}%")
print(f"jitter (mean |Δrtt|): {ok['rtt_ms'].diff().abs().mean():.2f} ms")
print(f"p50 / p95 / p99: "
      f"{ok['rtt_ms'].quantile(.50):.2f} / "
      f"{ok['rtt_ms'].quantile(.95):.2f} / "
      f"{ok['rtt_ms'].quantile(.99):.2f} ms")

Exemple 5 : comparer deux conditions

Exécutez la référence, changez exactement une variable, exécutez à nouveau, puis comparez. Ne changez qu’une chose à la fois, sinon vous n’apprenez rien.

diff <(python summarize.py runs/baseline-wired) <(python summarize.py runs/baseline-wifi)

Lire les chiffres sans les surinterpréter

Tout ce qui précède produit des données sur votre installation : votre hôte de capture, votre réseau, votre session, votre caméra. Cela ne produit rien qui se généralise automatiquement à un autre Googlebook, un autre jeu ou un autre chemin réseau.

C’est la discipline centrale. Quand vous voyez une affirmation sur la performance d’un appareil, demandez à laquelle des trois questions de benchmark elle répond. « Henry Cavill met Googlebook à l’épreuve » répond à la question de démonstration — cela vous dit que le cas d’usage existe et qu’une personne notable s’y est intéressée. Cela ne répond pas comment, dans quelles conditions, ni avec quel résultat en termes mesurables.

Une affirmation bien formée issue de votre propre banc ressemble à ceci : sur un hôte de capture filaire en 1080p60, sur une session de 20 minutes, l’intervalle inter-frame p99 était de X ms et aucun blocage supérieur à 1,5× la médiane n’a été observé. Cette phrase est falsifiable. Vous pouvez la relancer, changer une variable et la voir casser. Une phrase comme « c’était fluide » ne peut pas casser — ce qui est précisément pourquoi elle n’a aucun poids.

Limites ouvertes

Plusieurs limites méritent d’être énoncées clairement plutôt qu’enfouies.

Aucun protocole dans la source. L’annonce ne fournit pas de méthodologie, il n’y a donc aucun moyen de reproduire ou de critiquer le test spécifique effectué par Cavill. Tous les chiffres que vous verriez attribués à cette session, dans cet article ou ailleurs, seraient inventés.

Aucune spécification d’appareil affirmée ici. Cet article ne fait aucune affirmation sur le matériel, le système d’exploitation, les caractéristiques d’affichage ou les capacités réseau de Googlebook. Rien de tout cela n’apparaît dans la source, et deviner serait pire que ne rien dire.

Les métriques proxy sont des proxies. La méthode de la caméra haute vitesse mélange fréquence d’images de la caméra, persistance de l’affichage et comportement de la chaîne de capture. Elle borne la latence ; elle ne l’isole pas. Traitez la sortie comme une vérification d’ordre de grandeur, pas comme une spécification.

Effets d’unité unique. Un appareil est un échantillon. La pâte thermique, la variation des dalles et l’état du firmware déplacent tous les résultats entre les unités.

Conclusion

Le billet de blog Google fait bien une chose : il signale que Googlebook est positionné dans un contexte de jeu, avec Henry Cavill comme personne réalisant le test. C’est une information légitime, et la source est une référence primaire propre et accessible pour cela.

Ce n’est pas, et cela ne prétend pas être, un rapport de performance. La distance entre « une personne notable teste ceci » et « voici ce que le test a montré » est comblée exactement par le type d’instrumentation esquissé ci-dessus — un hôte de capture, un échantillonneur réseau, une caméra haute vitesse et un peu de Python qui transforme tout cela en percentiles que vous pouvez défendre.

Construisez le banc. Changez une variable à la fois. Notez les conditions avant d’écrire la conclusion. Ensuite, quand quelqu’un vous dira comment l’appareil se comporte, vous saurez précisément à quelle question il a répondu — et lesquelles restent ouvertes.