Tester la copie sur écriture de Swift sur un Mac cloud

Tester la copie sur écriture de Swift sur un Mac cloud

Tester la copie sur écriture de Swift sur un Mac cloud

Vous venez de modifier la couche de données sous Windows et vous confiez le projet à un Mac cloud pour lancer les tests : la liste d’origine n’a pas été modifiée directement, mais l’instantané destiné à l’annulation change lui aussi. L’enquête révèle que, malgré une structure Swift en façade, le conteneur renferme une instance de classe. L’affectation copie les champs de la structure, pas l’ensemble du graphe d’objets. Nous allons reproduire le problème et vérifier la copie sur écriture dans un fichier autonome, sans interface graphique, réseau ni configuration de signature.

Définir d’abord le contrat de sémantique de valeur

Le conteneur présenté ici ne stocke que des entiers. Son contrat est le suivant : après une copie, toute écriture par indice ou tout ajout dans l’une des copies doit laisser le contenu des autres inchangé. Des modifications successives d’une même copie ne doivent pas non plus altérer les instantanés enregistrés auparavant.

Cela n’impose pas de copier toutes les données dès chaque affectation. Le stockage peut rester partagé pendant les lectures, à condition d’effectuer la séparation nécessaire avant toute écriture. Les tests doivent vérifier les résultats observables, sans imposer d’adresses d’objets, de nombres de références ou de nombres d’allocations comme résultats attendus.

La copie sur écriture est une stratégie d’implémentation ; l’isolation des modifications est le contrat public. Des tests réussis valident les comportements couverts, mais ne prouvent pas l’absence de tout problème d’aliasing.

Si vous avez simplement besoin d’une liste d’entiers, mieux vaut utiliser un tableau standard. Une couche de stockage personnalisée se justifie si le conteneur gère aussi des index, des statistiques ou un état de compression. Il faut alors prévoir les vérifications nécessaires à chaque point d’entrée permettant une modification.

Séparer le stockage avant toute modification

Depuis la ligne de commande du Mac distant, créez CowCheck.swift et ajoutez-y l’implémentation suivante. Nous nous limitons d’abord aux entiers pour ne pas mêler au problème la sémantique de référence des éléments eux-mêmes.

struct IntBuffer {
    private final class Storage {
        var values: [Int]

        init(_ values: [Int]) {
            self.values = values
        }
    }

    private var storage: Storage

    init(_ values: [Int]) {
        storage = Storage(values)
    }

    var snapshot: [Int] {
        storage.values
    }

    private mutating func detachIfNeeded() {
        if !isKnownUniquelyReferenced(&storage) {
            storage = Storage(storage.values)
        }
    }

    subscript(index: Int) -> Int {
        get {
            storage.values[index]
        }
        set {
            detachIfNeeded()
            storage.values[index] = newValue
        }
    }

    mutating func append(_ value: Int) {
        detachIfNeeded()
        storage.values.append(value)
    }
}

L’ordre est essentiel : vérifier d’abord si le stockage est partagé, puis effectuer la modification. Copier uniquement à l’initialisation, ou séparer le stockage après la modification, ne protège pas les copies existantes. Ici, nous créons une nouvelle enveloppe de stockage ; le tableau qu’elle contient peut encore s’appuyer sur sa propre copie sur écriture pour différer la copie effective des éléments.

snapshot renvoie une valeur de type tableau sans exposer l’enveloppe de stockage. Ne rendez pas cette enveloppe mutable publique pour faciliter le débogage : le code appelant pourrait alors contourner les points d’écriture du conteneur. Si vous ajoutez ensuite des opérations de suppression, de tri ou de mise à jour par lot, elles devront elles aussi commencer par la même étape de séparation.

Couvrir les chemins d’écriture avec plusieurs alias

Ajoutez le code suivant à la fin du même fichier. Nous utilisons precondition pour éviter la suppression des vérifications que peut subir un simple assert dans une compilation optimisée. N’utilisez pas de mode d’optimisation sans vérifications qui désactiverait ces contrôles.

let original = IntBuffer([1, 2])
var first = original
var second = original
let saved = first.snapshot

first[0] = 9
precondition(original.snapshot == [1, 2])
precondition(second.snapshot == [1, 2])
precondition(first.snapshot == [9, 2])

first.append(3)
second.append(4)
precondition(first.snapshot == [9, 2, 3])
precondition(second.snapshot == [1, 2, 4])
precondition(original.snapshot == [1, 2])
precondition(saved == [1, 2])

var independent = first
independent[1] = 8
first[0] = 7
precondition(independent.snapshot == [9, 8, 3])
precondition(first.snapshot == [7, 2, 3])

var empty = IntBuffer([])
let emptyCopy = empty
empty.append(5)
precondition(emptyCopy.snapshot.isEmpty)
precondition(empty.snapshot == [5])

Modifier séparément deux copies permet de repérer plus facilement les oublis qu’un simple test consistant à copier puis à modifier une seule fois. L’ajout dans un conteneur vide couvre le chemin de séparation en l’absence d’éléments. Copier à nouveau une copie déjà modifiée permet aussi de vérifier que l’implémentation ne considère pas à tort qu’un stockage « déjà séparé » le reste définitivement.

Il est conseillé de faire un test négatif : retirez temporairement l’appel de séparation du setter du subscript, vérifiez que le contrôle échoue, puis rétablissez le code. Si les tests passent encore après avoir introduit ce défaut, ils n’exercent pas le comportement visé.

Exécuter deux compilations sur le Mac cloud

Vérifiez d’abord la chaîne d’outils active, puis compilez et exécutez les deux variantes. Les commandes doivent être lancées depuis le répertoire contenant le fichier :

xcrun swiftc --version
xcrun swiftc -Onone CowCheck.swift -o cow-check-debug
./cow-check-debug
xcrun swiftc -O CowCheck.swift -o cow-check-release
./cow-check-release

Lorsque le programme se termine normalement, il ne produit aucune sortie et son code de retour est zéro. Si une condition n’est pas satisfaite, il s’interrompt avec un code non nul. Dans un pipeline, vérifiez le code de retour de chaque commande : une commande ultérieure réussie ne doit pas masquer un échec précédent.

Conservez la version de la chaîne d’outils, l’identifiant du commit du code source et la condition ayant échoué ; inutile d’enregistrer les adresses mémoire. Une fois les compilations de débogage et optimisée validées, transférez les mêmes entrées et valeurs attendues dans la cible de tests unitaires du projet, et exécutez-les à chaque modification de l’implémentation du conteneur.

Préciser les limites des références imbriquées et de la concurrence

Si vous remplacez ensuite les entiers par des instances de classe, copier le tableau ne copiera que les références aux éléments. Si vous récupérez un objet depuis une copie puis modifiez ses propriétés, le conteneur d’origine pourra encore observer ce changement. Cela ne contrevient pas automatiquement à la sémantique du tableau lui-même, mais peut rompre le contrat de vos instantanés métier.

Il faut alors choisir explicitement une stratégie : utiliser des objets immuables comme éléments, les convertir en types valeur, ou définir et tester un protocole de copie profonde. Ne promettez pas de manière générale qu’« une structure garantit l’indépendance de tout son contenu », et ne recourez pas à une copie d’objets sans règles précises pour masquer des états non copiables, comme des descripteurs de ressources.

isKnownUniquelyReferenced n’est pas non plus une primitive de synchronisation. Les tests de cet article ne valident que des accès séquentiels. Si plusieurs tâches lisent et modifient simultanément le même conteneur mutable, l’isolation des accès reste nécessaire. Un résultat indiquant une référence unique à un instant donné ne permet pas d’ignorer ensuite les accès concurrents.

La vérification finale doit porter sur trois questions : tous les points d’entrée de modification séparent-ils d’abord le stockage ? Les valeurs renvoyées exposent-elles des références mutables ? Les limites de copie des éléments figurent-elles dans le contrat ? Fixer ces trois points est bien plus fiable que de constater qu’une exécution donnée n’a « par chance, pas mélangé les données ».

Questions fréquentes

Une structure isole-t-elle automatiquement toutes les modifications ?

Non. Une instance de classe contenue dans une structure peut rester partagée. Il faut séparer le stockage mutable avant de le modifier pour garantir la sémantique de valeur attendue.

isKnownUniquelyReferenced remplace-t-il la synchronisation ?

Non. Les accès doivent déjà être correctement isolés. L'accès concurrent à une même variable mutable nécessite un acteur, un verrou ou un autre mécanisme de synchronisation.

Laissez votre projet déterminer le Mac à louer

Pour compiler en natif et déboguer avec le simulateur, louez un Mac dédié équipé d’une puce Apple Silicon pour vos tests. Si vous développez à temps plein sur le long terme et travaillez toujours au même endroit, l’achat mérite aussi d’être envisagé. La location à la journée offre plus de flexibilité pour tester ; pour une utilisation prolongée, optez plutôt pour un forfait mensuel ou trimestriel.

Louer un Mac à distance

Étape suivante : choisissez une offre selon l’avancement du projet

Comparez d’abord les modèles, les durées et les options de connexion avant de décider si vous souhaitez louer.