Aller au contenu
Criée

Journaliser et rejouer une séance

Un journal en ajout seul, un rejeu jusqu’à l’instant t, des empreintes, et l’instantané qui oublie le compteur de rangs.

Leçon 1111 min

À la fin de cette leçon

  • Reconstruire le carnet à un instant donné en rejouant le journal
  • Comparer deux séances par leur empreinte, où l’ordre des exécutions compte
  • Expliquer pourquoi le journal et l’instantané doivent garder les rangs
Dans cette leçon6

La leçon Les invariants d'un moteur a posé le déterminisme : la même suite d'entrées produit toujours la même suite de sorties. Cette propriété a une conséquence pratique. Si vous gardez chaque entrée, dans l'ordre, vous n'avez plus besoin de sauvegarder le carnet : vous pouvez le reconstruire à n'importe quel instant de la séance. Cette leçon construit ce journal, le rejoue, et montre l'endroit précis où une reprise peut se tromper.

Journal d'événements

Liste ordonnée, en ajout seul, des entrées reçues par le moteur, qui suffit à reconstruire son état.

Ce que disent les textes

Deux règles du marché vont dans ce sens. Tout ordre est horodaté dès sa réception par la société de bourse (RG BVMAC 2025, art. 150). Le projet de règles de marché de 2008 donnait à chaque ordre un accusé de réception et « un numéro d'ordre séquentiel par titre » (Instruction n°2, 2008, section 3). Côté messages, une session FIX numérote ses messages en série continue depuis 1 et prévoit leur resynchronisation (FIX Session Layer).

Nous n'avons trouvé aucune source fiable décrivant comment une plateforme réelle journalise, prend des instantanés ou rejoue une séance. Tout ce qui suit (format du journal, rejeu, empreintes, reprise) est un choix de conception du moteur pédagogique, présenté pour son raisonnement.

Un journal autour du moteur

Le moteur @criee/marche ne journalise rien. On l'enveloppe dans une classe qui écrit chaque événement avant de l'appliquer :

import { Carnet, type Execution, type Ordre } from '@criee/marche'

type Evenement =
  | { n: number; type: 'passer'; ordre: Omit<Ordre, 'rang'>; rang: number }
  | { n: number; type: 'annuler'; id: string }

class MoteurJournalise {
  readonly journal: Evenement[] = []
  private readonly carnet: Carnet
  private dernierRang = 0

  constructor(prixReference: number) {
    this.carnet = new Carnet(prixReference)
  }

  passer(ordre: Omit<Ordre, 'rang'>): Execution[] {
    const ev: Evenement = { n: this.journal.length + 1, type: 'passer', ordre: { ...ordre }, rang: ++this.dernierRang }
    this.journal.push(ev)                                // écrire d'abord
    return this.carnet.passer({ ...ordre, rang: ev.rang }) // appliquer ensuite
  }

  annuler(id: string): boolean {
    this.journal.push({ n: this.journal.length + 1, type: 'annuler', id })
    return this.carnet.annuler(id)
  }
}

Trois décisions sont visibles. Le numéro n ordonne tous les événements, ordres et annulations confondus. Le rang est attribué par l'enveloppe et écrit dans le journal, au lieu d'être laissé au compteur interne du Carnet. Et { ...ordre } copie l'ordre : si l'appelant modifie son objet plus tard, le journal ne bouge pas.

Rejouer jusqu'à l'instant t

Rejouer, c'est appliquer les événements du journal, dans l'ordre, à un carnet neuf. L'état à l'instant t est le rejeu des t premiers événements.

function rejouer(journal: readonly Evenement[], prixReference: number, jusqua = journal.length) {
  const carnet = new Carnet(prixReference)
  const executions: Execution[] = []
  for (const ev of journal.slice(0, jusqua)) {
    if (ev.type === 'passer') executions.push(...carnet.passer({ ...ev.ordre, rang: ev.rang }))
    else carnet.annuler(ev.id)
  }
  return { carnet, executions }
}

Rejeu

Nouvelle application des événements d'un journal à un moteur neuf, pour reconstruire un état ou vérifier des sorties.

Une séance de sept événementsFictif

Achat a1 de 20 à 10 000, vente v1 de 30 à 10 100, achat a2 de 15 à 10 000, vente v2 de 10 à 10 000, annulation de v1, achat a3 de 10 à 10 000, vente v3 de 30 à 10 000.

rejouer(journal, 10000, 4).carnet.vue() donne, à l'instant 4 : côté achats un niveau à 10 000 pour 25 titres (a1 réduit à 10, plus a2), côté ventes v1 à 10 100 pour 30. Le rejeu complet renvoie quatre exécutions : a1 et v2 pour 10, puis a1, a2 et a3 face à v3 pour 10, 15 et 5.

De mémoire : l'état du carnet à l'instant t est-il une donnée à sauvegarder, ou un calcul ?

Empreintes : comparer d'un coup d'œil

Pour vérifier qu'un rejeu retrouve la séance d'origine, comparer des listes d'exécutions est lourd. On les résume en une empreinte : une valeur courte, calculée de façon déterministe.

/** FNV-1a sur 32 bits : rapide et stable, mais pas cryptographique. */
function empreinte(valeur: unknown): string {
  const texte = JSON.stringify(valeur)
  let h = 0x811c9dc5
  for (let k = 0; k < texte.length; k++) {
    h ^= texte.charCodeAt(k)
    h = Math.imul(h, 0x01000193) >>> 0
  }
  return h.toString(16).padStart(8, '0')
}

empreinte(sortiesEnDirect) === empreinte(rejouer(m.journal, 10000).executions) // true

Empreinte

Valeur courte calculée à partir d'un état ou d'une suite de sorties, pour comparer deux exécutions d'un coup d'œil.

L'empreinte dépend de l'ordre : empreinte([1, 2]) diffère de empreinte([2, 1]). C'est voulu. Deux séances qui produisent les mêmes exécutions dans un autre ordre ne sont pas la même séance.

Instantané et reprise : le compteur oublié

Rejouer depuis le début devient long quand le journal grandit. La parade habituelle est l'instantané : on copie l'état à un instant donné, puis on ne rejoue que la suite.

Instantané

Copie de l'état du moteur à un instant donné, à partir de laquelle on rejoue la suite du journal.

Le moteur pédagogique rend ce geste piégeux. ordres() expose les ordres en attente avec leur rang, prix expose le dernier cours, mais rien n'expose le compteur interne qui numérotera le prochain ordre. Un carnet restauré repart à 1. Choisissez un mode ci-dessous, puis avancez jusqu'aux événements 6 et 7.

Journal, instantané, rejeu1/8
  1. 1. a1 A 20@10 000
  2. 2. v1 V 30@10 100
  3. 3. a2 A 15@10 000
  4. 4. v2 V 10@10 000
  5. 5. annuler v1
  6. 6. a3 A 10@10 000
  7. 7. v3 V 30@10 000

Achats

vide

Ventes

vide

#741638a5

new Carnet(10000)

t = 0 : carnet vide

Avancez dans le journal : l’état du carnet à l’instant t est le rejeu des t premiers événements, rien de plus.

Le calcul, pas à pas, pour le mode « rangs non journalisés » :

// Instantané après l'événement 5 : a1 (10, rang 1), a2 (15, rang 3), dernier prix 10 000
const r = new Carnet(10000)
r.passer({ id: 'a1', sens: 'achat', quantite: 10, limite: 10000, rang: 1 })
r.passer({ id: 'a2', sens: 'achat', quantite: 15, limite: 10000, rang: 3 })

r.passer({ id: 'a3', sens: 'achat', quantite: 10, limite: 10000 }) // compteur à 1 : a3 reçoit le rang 1
r.passer({ id: 'v3', sens: 'vente', quantite: 30, limite: 10000 })
// [ { a1, v3, 10000, 10 }, { a3, v3, 10000, 10 }, { a2, v3, 10000, 10 } ]
// séance d'origine : a1 pour 10, a2 pour 15, a3 pour 5

À l'événement 6, rien ne se voit : la vue agrégée et les exécutions sont identiques. La divergence est déjà là, dans un rang que l'écran n'affiche pas, et elle sort à l'événement 7. C'est pourquoi MoteurJournalise écrit le rang dans le journal : la reprise n'a plus besoin du compteur.

Plus loin

Un journal en ajout seul. On ne corrige pas un événement écrit ; on en ajoute un autre, une annulation par exemple. Le marché applique ce principe à ses publications : le Bulletin officiel de la cote ne peut être rectifié qu'en cas d'omission ou d'erreur, avec mention explicite de l'information originelle (RG BVMAC 2025, art. 132). Côté base de données, cela se traduit par des droits d'insertion sans droits de modification ni de suppression.

Les refus se rejouent aussi. MoteurJournalise.passer écrit l'événement avant d'appeler le moteur. Un ordre de quantité 0 reste donc dans le journal, et rejouer lève la même exception au même endroit. C'est cohérent, à une condition : le rejeu doit attraper et compter les refus comme le direct, sinon il s'arrête là où la séance a continué. L'autre choix, valider avant d'écrire, garde un journal sans refus mais perd la trace des tentatives.

L'heure est une donnée. L'horodatage de réception (art. 150) entre dans le journal comme un champ. Le moteur ne lit jamais l'horloge pendant un rejeu, sinon deux rejeux divergent, comme dans la leçon sur les invariants avec Date.now().

Le coût. Un rejeu complet coûte N appels à passer, chacun en O(n log n) pour n ordres en attente dans ce moteur. Un instantané tous les k événements borne la reprise à k appels, au prix d'une copie de l'état. Et un rejeu par une nouvelle version du moteur peut produire d'autres sorties : journaliser la version du moteur utilisée est une décision à prendre.

De mémoire, en reliant à la leçon sur FIX : la session FIX et le journal numérotent tous deux leurs éléments depuis 1. À quoi sert ce numéro dans chaque cas ?

À toi de jouer

Pour reconstruire le carnet à l'instant t, il faut...

1Pour reconstruire le carnet à l'instant t, il faut...

Pourquoi MoteurJournalise écrit-il le rang dans le journal ?

2Pourquoi MoteurJournalise écrit-il le rang dans le journal ?

Deux séances ont les mêmes exécutions dans un autre ordre. Leurs empreintes...

3Deux séances ont les mêmes exécutions dans un autre ordre. Leurs empreintes...

Un événement du journal se révèle faux. Que faites-vous ?

4Un événement du journal se révèle faux. Que faites-vous ?

À l'événement 6, la reprise sans rangs donne la même vue. Le rejeu est-il juste ?

5À l'événement 6, la reprise sans rangs donne la même vue. Le rejeu est-il juste ?

À lire ensuite : FIX Trading Community, FIX Session Layer

Une question ? Posez-la à votre enseignant, ou à un assistant IA en lui donnant le titre de cette leçon.

Partager :WhatsAppLinkedIn

Pour aller plus loin