\documentclass[a4paper]{report} % Set page dimentions \usepackage[margin=35mm]{geometry} % Bibliography \usepackage[numbers]{natbib} % more bibliography options \usepackage[nottoc]{tocbibind} % add link to table of contents \bibliographystyle{plainnat} % more detailled plain bibliography % Packages for french documents \usepackage[french]{babel} % latex rules for french words \usepackage[utf8]{inputenc} % UTF-8 encoding for special chars \usepackage[T1]{fontenc} % T1 font for smooth render of special chars \usepackage{lmodern} % Latin modern font recommended by Vincent \DeclareUnicodeCharacter{202F}{\thinspace} % Define some colors \usepackage{xcolor} \definecolor{string}{RGB}{100, 200, 0} \definecolor{comment}{RGB}{150, 150, 150} \definecolor{identifier}{RGB}{100, 100, 200} % Source code style \usepackage{listings} \lstset{ basicstyle=\footnotesize\ttfamily, % sets font style for the code frame=single, % adds a frame around the code showstringspaces=false, % underline spaces within strings tabsize=4, % sets default tabsize to 2 spaces breaklines=true, % sets automatic line breaking breakatwhitespace=true, % sets if automatic breaks should only happen at whitespace keywordstyle=\color{magenta}, % sets color for keywords stringstyle=\color{string}, % sets color for strings commentstyle=\color{comment}, % sets color for comments emphstyle=\color{identifier}, % sets color for comments } % Graphics \usepackage{graphicx} % images and figures \usepackage{subcaption} % subcaption and subtables \graphicspath{ {assets} } % path containing images \usepackage{tikz} % to generate graphics \usetikzlibrary{arrows.meta} % setup arrows \usetikzlibrary{chains,decorations.pathreplacing} % tiks chains \tikzstyle{Arrow}=[-{Stealth[scale=1.5]}] % Complex tables \usepackage{multirow} \usepackage{tabularx} % Custom column types \usepackage{array} \newcolumntype{L}{>{\raggedright\arraybackslash}X} % Left-aligned auto-span columns \newcolumntype{R}{>{\raggedleft\arraybackslash}X} % Right-aligned auto-span columns % Localised number print (thousands, decimals, etc.) \usepackage{numprint} % Directory tree \usepackage{dirtree} % Acronyms \usepackage[printonlyused,footnote]{acronym} % Hyperlinks \usepackage{xurl} % allow word break for url wrapping \usepackage[ hidelinks, % invisible links pagebackref=true % linkback to citations from bibliography ]{hyperref} % create clickable links \usepackage{doi} % add links to doi urls % Backrefs in the bibliography for french \renewcommand{\backrefalt}[4]{ \ifcase #1 {} \or \emph{Cité page #2} \else \emph{Cité pages #2} \fi } % Backref separators for french \renewcommand{\backreftwosep}{ et~} \renewcommand{\backreflastsep}{, et~} % Style \setlength{\parskip}{.3em} % space between paragraphs % Custom commands \usepackage{xspace} % automatically add a space after the command if needed \newcommand{\etal}{\emph{et al.}\@\xspace} \newcommand{\fonts}[2][m]{{\fontseries{#1}\selectfont #2}} % select a font series for the given text \newcommand{\textb}{\fonts[b]} \newcommand{\btrfs}{BTRFS~\cite{rodeh2013btrfs}\@\xspace} \newcommand{\erofs}{EROFS~\cite{gao2019erofs}\@\xspace} \newcommand{\hptfs}{HPTFS~\cite{zhang2006hptfs}\@\xspace} \newcommand{\ltfs}{LTFS~\cite{pease2010linear}\@\xspace} \newcommand{\squashfs}{SquashFS~\cite{lougher2009squashfs}\@\xspace} \newcommand{\udf}{UDF~\cite{optical2003universal}\@\xspace} %--------------------------------------- Content ---------------------------------------% \title{Système de fichiers pour le stockage d’informations numériques sur ADN} \date{Octobre 2021} \author{Nicolas Peugnet} \begin{document} \pagenumbering{Roman} \begin{titlepage} \maketitle \end{titlepage} \pagenumbering{arabic} \tableofcontents \chapter{Introduction} Ce stage a été réalisé dans le cadre du projet DNA-Drive, un système développé par l'équipe de Stéphane Lemaire (\ac{lcqb}) visant à stocker des données numériques arbitraires via des molécules d'\ac{adn}. Notre rôle sera de proposer un \emph{système de fichiers} adapté aux spécificités de ce nouveau médium de stockage. \section{Systèmes de fichiers} Le but d'un \emph{système de fichiers} est d'organiser des données sur un support de stockage. En son absence, les différentes données d'un support seraient toutes écrites d'un seul tenant et il ne serait pas possible de savoir où commence et où s'arrête un morceau de données cohérent. Le système de fichiers offre donc la possibilité de répartir les données dans des segments nommés : les \emph{fichiers}. Ces fichiers peuvent être disposés au sein d'une arborescence de \emph{dossiers}, ce qui permet de les organiser de manière logique. Les informations de cette arborescence sont des métadonnées qui doivent donc être stockées en plus des données. En règle générale, les systèmes de fichiers récents stockent bien plus de métadonnées que simplement les noms des fichiers et des dossiers. Parmi celles-ci, on peut citer par exemple les dates de création et de modification, ou bien encore les permissions lorsqu'il s'agit d'un système POSIX. Grâce à cette structure d'arborescence de fichiers commune à tous les systèmes, on obtient une compatibilité de l'un à l'autre, ce qui offre à la couche supérieure une abstraction des supports de stockages. Pour stocker ou lire des données, un système de fichiers doit communiquer avec le matériel. Lorsqu'il s'agit d'un support de stockage classique respectant le \ac{lba}, comme c'est le cas des disques durs et des \ac{ssd}, le système de fichiers n'a pas besoin de connaitre le fonctionnement détaillé du périphérique. Il lui suffit de demander de lire ou écrire les données du bloc $n$ et c'est le contrôleur du périphérique lui-même qui se charge de retrouver l'emplacement physique de ce bloc logique. Dans le cas de supports plus spécifiques, il est assez fréquent que les systèmes de fichiers soient conçus exclusivement pour ceux-ci. C'est par exemple le cas pour les bandes magnétiques avec \hptfs et \ltfs ou les disques optiques avec \udf. Ces systèmes seront parfaitement adaptés à leur support et pourront donc pousser plus loin certaines optimisations. \subsection{Fonctionnalités et caractéristiques} En plus de son rôle d'abstraction des supports de stockage, un système de fichier peut proposer un grand nombre de fonctionnalités et de caractéristiques intéressantes. Nous n'introduirons ici que celles qui nous seront utiles à la compréhension de la suite de ce document. \paragraph{Type d'accès} Un système de fichiers peut être accessible soit en lecture uniquement (\ac{ro}), comme c'est le cas d'une bonne partie des systèmes compressés (\squashfs, \erofs,~etc.), soit en lecture et écriture (\ac{rw}) pour la grande majorité des autres systèmes. \paragraph{Compression} La compression peut avoir plusieurs intérêts pour un système de fichiers. Elle peut bien-sûr permettre de réduire l'espace occupé par les données sur le support et c'est ce cas d'utilisation que \squashfs tente d'optimiser. Mais elle peut aussi servir à accélérer les opérations de lecture et d'écriture lorsque la bande passante est un facteur limitant. Des systèmes plus généralistes, comme \btrfs, utilisent la compression à cette fin et d'autres systèmes de fichiers, comme \erofs, sont même entièrement basés sur ce principe. % TODO: quelles autres propriétés ? \section{Stocker des données sur ADN} L'information génétique des organismes vivants a pour support l'\ac{adn} (Acide DésoxyriboNucléique), et l'ensemble du matériel génétique d'un organisme constitue son génome. L'\ac{adn} est codé sous la forme d'une suite de molécules organiques que sont les \emph{nucléotides}. Il existe quatre nucléotides différents, représentés par quatre lettres : \textbf{A} pour Adénine, \textbf{T} pour Thymine, \textbf{G} pour Guanine, et \textbf{C} pour Cytosine. Les nucléotides s'associent deux à deux pour former un double brin d'\ac{adn}. Ainsi, l'Adénine est appariée à la Thymine et la Guanine à la Cytosine. Chaque brin d'\ac{adn} est alors complémentaire de l'autre. Il est donc possible d'établir un parallèle entre l'information génétique, codée par les 4 nucléotides formant l'\ac{adn}, en base~4, et la donnée informatique, codée par une suite de bits en base~2. Utiliser l'\ac{adn} comme support de stockage numérique pourrait avoir plusieurs intérêts. La densité d'information est assez importante ($10^{19}$~bit/cm$^3$ contre $10^{16}$ pour une mémoire flash) et la durée de vie de la molécule peut atteindre plusieurs centaines d'années, contre une cinquantaine d'années maximum pour les bandes magnétiques, le support le plus pérenne actuellement. Plusieurs démonstrations de faisabilité du stockage sur l’\ac{adn} ont déjà été réalisées ces dernières années. Les travaux publiés pour l’instant se basent essentiellement sur l’utilisation d’\emph{oligonucléotides}, qui sont des courts segments d’\ac{adn} contenant quelques dizaines de nucléotides. \subsection{Encodages} Les premières démonstrations significatives sur l’utilisation de ces oligonucléotides pour stocker des données remontent à seulement 2012 avec George Church~\cite{church2012next} qui réussit à stocker 658~ko sur \numprint{54898} oligonucléotides. Dans ses travaux, Church souhaite pouvoir contrôler le taux de GC et limiter les répétitions d’un même nucléotide. Le taux de GC est la proportion de nucléotides G et C dans une séquence donnée. Les appariements GC sont formées par trois liaisons hydrogène tandis que les appariements AT n'en ont que deux, les rendant moins stables. Un taux de GC élevé assure ainsi une meilleure stabilité, mais un taux trop élevé peut provoquer une autolyse (autodestruction) plus facilement. Il est donc préférable d’avoir un taux de GC équilibré. En ce qui concerne les longues répétitions d’un même nucléotide, elles produisent des erreurs lors du séquençage. Pour toutes ces raisons, Church va utiliser un encodage en base~2 : $A=C=0$ et $T=G=1$ pour avoir plus de flexibilité (Table~\ref{tab:church-encoding}). \begin{table}[ht] \centering \setlength{\tabcolsep}{.8em} \renewcommand\arraystretch{1.5} \begin{subtable}[t]{.45\textwidth} \centering \begin{tabular}{|c|c|c|c|} \hline \multirow{2}{*}{\textbf{Bit}} & \textbf{0} & A & C \\ \cline{2-4} & \textbf{1} & T & G \\ \hline \end{tabular} \caption{Encodage Church~\cite{church2012next}} \label{tab:church-encoding} \end{subtable} \hfill \begin{subtable}[t]{.54\textwidth} \centering \begin{tabular}{|c|c|c|c|} \cline{3-4} \multicolumn{2}{c|}{} & \multicolumn{2}{c|}{\textbf{Position}} \\ \cline{3-4} \multicolumn{2}{c|}{} & \textbf{Paire} & \textbf{Impaire} \\ \hline \multirow{2}{*}{\textbf{Bit}} & \textbf{0} & A & C \\ \cline{2-4} & \textbf{1} & T & G \\ \hline \end{tabular} \caption{Encodage BIODATA} \label{tab:biodata-encoding} \end{subtable} \caption{Différents encodages pour \ac{adn}} \label{tab:dna-encodings} \end{table} Suite à ces travaux, un certain nombre de nouvelles publications vont apporter des améliorations intéressantes aux techniques existantes, avec par exemple l'encodage de Goldman~\cite{goldman2013towards} qui propose l'utilisation d'une base~3 (Figure~\ref{fig:goldman-encoding}), plus performante en densité de stockage. \begin{figure}[ht] \centering \includegraphics[width=.6\textwidth]{goldman-encoding} \caption{Encodage de Goldman~\cite{goldman2013towards}} \label{fig:goldman-encoding} \end{figure} \subsection{Spécificités du DNA-Drive} \subsubsection{Spécificités biologiques} La spécificité principale de DNA-Drive par rapport à ses concurrents est d'utiliser la molécule d'\ac{adn} sous sa forme de double hélice, plutôt que sous la forme d'un simple brin. Cette forme a plusieurs avantages : premièrement, la molécule est plus stable sous cette forme, ce qui limite sa dégradation et permet donc d'augmenter sa durée de vie. Deuxièmement, il s'agit de la forme utilisée par l'ensemble des organismes vivants de notre planète\footnote{En considérant que les virus ne sont pas vivants}, ce qui nous permet donc de potentiellement profiter des mécanismes du vivant, tels que la réparation automatique de l’\ac{adn} pour corriger les erreurs, ou la division cellulaire qui va permettre une copie peu coûteuse et très rapide de grandes quantités de données. Cependant, faire en sorte qu'une molécule d'\ac{adn} soit compatible avec un être vivant ajoute des contraintes supplémentaires. En particulier, en plus de garantir un taux de GC équilibré, notre encodeur doit à tout prix éviter que les séquences de données, une fois encodées en ADN, ne soient interprétés par l'hôte comme des séquences codantes de son génome. Dans l'ADN d'un être vivant, ces parties codantes sont délimités par deux courtes séquences de nucléotides placées au début et à la fin de la zone à interpréter. Il s'agit des codons START et STOP. Le codon START indique le début d'une séquence à interpréter, c'est donc celui qu'il faut à tout prix éviter d'obtenir une fois les données encodées. Le codon STOP, au contraire, définit la fin d'une telle séquence, il est donc intéressant d'en insérer autant que possible pour limiter les effets néfastes dans l'éventualité où un codon START aurait malencontreusement été ajouté. En ce qui concerne la lecture des données, on utilise un séquenceur génétique portatif à nanopore tels que celui utilisé par l’équipe de H. Yadzi~\cite{yazdi2017portable} et présenté sur la Figure~\ref{fig:oxford-nanopore-minion}. Les séquenceurs en général ont un problème avec la lecture des homopolymères, c’est-à-dire des séquences de répétitions d’un même nucléotide. On interdit donc les séquences de plus de trois fois le même nucléotide pour éviter les erreurs de séquençage. \begin{figure}[ht] \centering \includegraphics[width=.6\textwidth]{oxford-nanopore-minion} \caption{Lecteur Oxford Nanopore MinION} \label{fig:oxford-nanopore-minion} \end{figure} BIODATA, l'encodage mis au point par Clémence Blachon (\ac{lcqb}) pour le DNA-Drive est justement chargé de faire respecter ces propriétés par les données encodées. Il est inspiré de celui de Church, auquel des contraintes supplémentaires viennent s'appliquer : Pour chaque bit, on fixe la valeur du nucléotide en fonction de sa valeur et de la parité de sa position (Table~\ref{tab:biodata-encoding}). De cette manière l'encodage est totalement contraint et le résultat est déterministe. Les valeurs choisies garantissent quelle que soit la séquence de bits que : \begin{itemize} \item Le taux de GC restera équilibré. \item Un nucléotide ne sera jamais répété plusieurs fois à la suite. \item Aucun codon START ne sera inséré. \item Des codons STOP seront insérés régulièrement. \end{itemize} Cet encodage permet donc, lorsqu'on encode des données, de s'abstraire totalement des problématiques biologiques sous-jacentes et laisse ainsi la possibilité de stocker des valeurs arbitraires. \subsubsection{Spécificités techniques} L'organisation physique des données du DNA-Drive est assez particulière et doit être prise en compte afin d'optimiser les lectures et les écritures. \paragraph{Track} Une \emph{track} est un segment de données, actuellement de 1024~octets. C'est la plus petite unité de stockage du système. Toutes les écritures devront donc être alignées sur la taille d'une track. Elles sont obtenues grâce à un assemblage MoClo~\cite{werner2012fast} sur 3 niveaux et sont refermées en un cercle pour former des \emph{plasmides}. Cette forme particulière de la molécule d'\ac{adn} comporte plusieurs avantages. Elle est tout d'abord plus pérenne grâce à sa structure circulaire, car c'est principalement par ses extrémités que la molécule se dégrade. Mais les plasmides profitent en plus de leur propre mécanisme d'auto-réplication autonome. Cependant, cette forme ne permet pas de les mettre bout-à-bout, il n'y a donc pas d'ordre naturel entre les tracks. C'est pour cette raison que chaque track contient un \emph{barcode} qui permet de les identifier et donc de les réordonner. \paragraph{Barcode} Le \emph{barcode} est un entier de 4~octets présent au tout début d'une track et permettant de l'identifier. \paragraph{Pool} Un \emph{pool} est une minicapsule contenant plusieurs tracks. Actuellement, un pool peut contenir \numprint{10000} tracks et les lectures sont réalisées par pool entier. Il est possible de lire plusieurs pools en même temps et même de fusionner des pools si les barcodes des tracks qu'ils contiennent ne se chevauchent pas. \paragraph{Array} Un \emph{array} est une plaque de 96~pools ($8\times12$) qui est traditionnellement utilisée en biologie. La taille maximum disponible pour des données d’un array est donc de \numprint{979.2}~Mo ($96\times\numprint{10000}\times\numprint{1020}$~octets). On peut multiplier les arrays afin d'obtenir une plus grande capacité de stockage. Les chiffres donnés ici sur l’organisation du disque de \numprint{1024} octets par track et \numprint{10000} tracks par pool sont limités respectivement par la complexité de l'assemblage MoClo et la précision limitée des techniques de séquençage actuelles. La capacité disponible est donc amenée à évoluer dans le futur avec l'arrivée de technologies plus performantes. % TODO: peut-être un schéma si j'ai le temps \section{Problématique} Il existe donc plusieurs techniques et encodages permettant de stocker des informations arbitraires sur la molécule d'\ac{adn}, mais, malgré les avantages de densité et de durabilité de cette molécule, toutes ont en commun quelques inconvénients majeurs. Ces inconvénients proviennent pour la plupart des limites actuelles des technologies de synthèse et de séquençage. Une expérience d'un système automatisé de transmission de données par \ac{adn} datant de 2019~\cite{takahashi2019demonstration} nous donne un ordre de grandeur des durées de lecture et d'écriture, bien qu'il ne serait pas étonnant que des techniques plus performantes fassent leur apparition dans un futur proche : La latence d'une opération d'écriture suivie d'une lecture d'une séquence de 12~octets est de 21~h, dont \numprint{20.4}~h pour l'écriture (\numprint{8.4}~h de synthèse à 305~s par base et 12~h de stabilisation) et les 36~min restantes pour la lecture (30~min de préparation et 6~min de séquençage et décodage). Les lectures ne sont donc déjà pas très rapides, mais le point le plus limitant provient très largement des écritures qui sont exceptionnellement lentes, sans même parler de leur coût. % TODO: revoir cette phrase Une autre inconvénient du DNA-Drive et de l'ensemble des initiatives de stockage de données sur \ac{adn} est l'impossibilité de supprimer ou de modifier des données une fois écrites. Ce point est particulièrement bloquant pour un système de fichiers \ac{rw} classique, qui se base sur ces deux propriétés pour mettre à jour les fichiers et leurs métadonnées ainsi que pour récupérer de l'espace lorsque des fichiers sont supprimés. Cette problématique se retrouve sur d'autres systèmes de stockages, comme les bandes magnétiques ou les disques optiques. Elle est résolue par leur système de fichiers respectif, \ltfs pour les bandes magnétiques et \udf pour les CD et DVD non-RW. Dans les deux cas le système est basé sur la réécriture complète des blocs modifiés des fichiers ainsi que de l'index dans le cas de \ltfs ou de la Virtual Allocation Table dans le cas de \udf. La difficulté principale était donc de réussir à implémenter cette fonctionnalité sur un médium de stockage qui n'a pas la capacité de modifier les données existantes, tout en limitant les écritures au strict nécessaire. \section{Réponse} La proposition qui suit s'inscrit dans le cadre d'une réponse à court terme au problème posé. Nous avons choisi de ne pas nous projeter trop loin dans le temps et avons donc basé l'ensemble de la réflexion sur les capacités actuelles des technologies de synthèse et de séquençage \ac{adn}. L'objectif principal du système d'archivage de fichiers proposé est de \emph{réduire la quantité de données écrites} et donc synthétisées. Cependant, il est tout de même important de minimiser la quantité de données à lire pour restaurer les fichiers. Toutes les contraintes citées précédemment nous ont incité à nous orienter vers un système de sauvegardes plutôt que vers un véritable système de fichiers. En effet, les vitesses et coûts d'écriture et de lecture ne permettent, pour le moment, absolument pas d'en faire un système de fichiers accessible ``à chaud''. Ce n'est par exemple pas la peine d'écrire un fichier s'il va être supprimé ou renommé quelques secondes plus tard. Les cas d'usage envisagés seront donc ceux de sauvegardes sur différentes plages de temps : journalières, hebdomadaires ou mensuelles. De cette manière, l'ensemble des opérations réalisés sur les fichiers pendant cette plage de temps seront factorisées dans un seul bloc de modification : la nouvelle version. Afin de minimiser la quantité de données écrites par version, celles-ci sont réalisées de manière incrémentale. Chaque nouvelle version est donc en quelque sorte une différence par rapport aux précédentes. Ce stockage incrémental est obtenu grâce à une utilisation conjointe de la déduplication et de l'encodage delta. Ainsi, comme aucune donnée ne peut être supprimée, nous en profitons pour réaliser un système versionné, qui nous laisse la possibilité d'accéder aux précédentes sauvegardes. \chapter{Présentation de DNA-Backup} DNA-Backup, notre proposition, ressemble plus à un système de sauvegardes qu'à un système de fichiers. Chaque nouvelle version vient s'ajouter à la précédente, car il est impossible de supprimer ou de modifier des données et on applique un \emph{pipeline} de compression sur les données de chaque version afin d'en minimiser la taille. \section{Pipeline de compression} Le pipeline est inspiré de celui de Philip Shilane \etal dans leur travail sur la réplication de sauvegardes à travers un lien de faible bande passante~\cite{shilane2012wan}. Il est composé d'un étage de \emph{déduplication}, suivi d'un étage d'\emph{encodage delta} et enfin d'un dernier étage de \emph{compression}. Ces trois techniques sont basées sur l'identification de similitudes entre différentes zones du flux de données. La déduplication permet de ne pas réécrire plusieurs fois le même bloc de données si ce bloc existe déjà. L'encodage delta permet de ne pas avoir à réécrire entièrement un bloc similaire à un bloc existant, en n'en écrivant que la différence. La compression est également basée sur ces deux principes, mais elle est appliquée à une plus petite échelle. Dans DNA-backup, la déduplication et l'encodage delta sont tous les deux appliqués sur des blocs d'une même taille fixe appelés \emph{chunks}. Afin d'appliquer de manière efficace les étapes de déduplication et d'encodage delta de notre pipeline, il nous faut être capable de rapidement retrouver des chunk identiques ou similaires. Nous utilisons pour cela deux fonctions de hachage qui fournissent des signatures aux propriétés particulières. L'une de ces signatures, appelée ici \emph{fingerprint} permet d'identifier des chunks identiques à dédupliquer, l'autre, appelée ici \emph{sketch} permet de trouver des chunks fortement similaires, lesquels feraient de bons candidats à l'encodage delta. De cette manière, pour appliquer le pipeline sur une nouvelle version, il nous suffit d'avoir ces deux informations en mémoire pour chaque chunk déjà écrit. Seule l'étape d'encodage delta nous forcera à aller chercher le contenu réel d'un chunk similaire, lorsqu'il aura été trouvé à l'aide de son sketch. \subsection{Fingerprint} La \emph{fingerprint} permet d'identifier un bloc de manière unique en fonction de son contenu. C'est ainsi que l'on peut savoir si deux chunks sont identiques et devraient donc être dédupliqués. Pour cette application, n'importe quelle fonction de hachage uniformément répartie pourrait convenir. Il faut simplement calibrer la taille de la signature en fonction du nombre de chunks que le support peut contenir afin d'éviter les collisions. Dans notre cas précis, nous avons tout de même besoin d'une fonction capable d'être d'appliquée sur une fenêtre glissante, appelée \emph{rolling hash}. En effet, lorsqu'une nouvelle version est traitée par le pipeline, il faut appliquer la fonction de hachage sur tous les chunks possibles, octet par octet, des données de cette version. Une fonction optimisée pour ce type de traitement apportera donc un gain de performances non négligeable. Nous avons choisi pour cet usage l'empreinte de Rabin~\cite{rabin1981fingerprinting}, car c'est une fonction de hachage sur fenêtre glissante efficiente et populaire et parce qu'elle sera également utilisée pour calculer le \emph{sketch} des chunks. \subsection{Sketch} Le \emph{sketch} est ce qu'on appelle un \emph{hash de ressemblance}. Il correspond en fait à une fonction de hachage dont la répartition n'est pas du tout uniforme, mais au contraire, fait correspondre la même signature à des données différentes si elles sont similaires. De manière intuitive, les sketches de similitude fonctionnent en identifiant des portions d'un chunk qui ne changeraient probablement pas si de faibles variations sont introduites ; on appelle ces portions des ``features''. Une des manières de procéder est d'utiliser une fonction de hachage sur une fenêtre glissante de petite taille (e.g. 32~octets) et de choisir la valeur maximale obtenue en tant que feature. En utilisant différentes fonctions de hash on peut ainsi obtenir plusieurs features. La méthode exacte utilisée est celle décrite par Philip Shilane \etal~\cite{shilane2012wan}. Elle s'appuie sur l'empreinte de Rabin~\cite{rabin1981fingerprinting} que l'on décline en différentes fonctions de hachage pour obtenir plusieurs features. Les features ainsi obtenues sont ensuite regroupées pour former un plus petit nombre de ``super-features''. La valeur d'une super-feature correspond au hash des features sous-jacentes, donc si deux chunks ont une super-feature en commun, alors toutes les features correspondantes sont également identiques. Regrouper les features de cette manière aide à réduire les faux-positifs et augmente le taux de similarité lorsqu'une correspondance est trouvée. Augmenter le nombre de features par super-feature augmente la qualité des correspondances, mais diminue aussi leur nombre. Augmenter les nombre de super-feature par sketch augmente le nombre de correspondances, mais nécessite plus d'espace mémoire. Nous utilisons pour le moment les valeurs choisies par Philip Shilane \etal au cours de leurs expérimentations~\cite{shilane2012wan}, soit 3 super-features par sketch et 4 features par super-features. Ces valeurs pourraient être ajustées une fois que de plus amples expériences sur des jeux de données plus variés auront été réalisés. \subsection{Index des signatures} Pour connaitre de manière efficace l'existence d'une fingerprint ou d'un sketch dans les données existantes du DNA-Drive, nous avons besoin de stocker leur valeur. En effet, autrement il faudrait les recalculer depuis les données, ce qui serait coûteux. Ces valeurs sont donc stockées dans deux index. L'un faisant l'association entre des fingerprints et leur chunk, l'autre entre des super-features et leurs chunks. Philip Shilane \etal travaillaient sur de très gros jeux de données et ne pouvaient pas se permettre de garder l'ensemble de ces index en mémoire, ils ont donc opté pour n'en garder qu'une partie à l'aide d'un cache~\cite{shilane2012wan}. Dans notre cas, la quantité de données est suffisamment faible pour qu'on puisse se permettre de garder la totalité des index en mémoire. De cette manière nous sommes certains de ne manquer aucune correspondance, ce qui maximise la qualité de déduplication et l'encodage Delta. Dans l'hypothèse où l'espace de stockage du DNA-Drive deviendrait beaucoup plus grand, il restera toujours la possibilité de ne garder qu'un cache en mémoire et d'utiliser un filtre de Bloom~\cite{bloom1970space} devant le reste de l'index qui serait stocké sur disque. En effet, même si le temps de recherche dans l'index s'en trouvera augmenté, il restera très faible par rapport au temps de synthèse. Cependant, les index de signatures seuls ne sont pas suffisants pour appliquer le pipeline. Nous avons également besoin du contenu des chunks lors de l'encodage delta. Or, les temps de lecture rédhibitoires du DNA-Drive nous empêchent de lire à la demande le contenu d'un chunk lorsque l'on en a besoin. C'est pour cela que nous avons finalement décidé de conserver sur un support de stockage classique une copie des informations stockées sur le DNA-Drive ; la capacité du DNA-Drive étant pour le moment bien inférieure à ce qui existe sur d'autres supports. \section{Fonctionnement général} Le système part du principe qu'on dispose, sur un support de stockage classique, d'une copie des données stockées en \ac{adn} appelée le \emph{repo} (Figure~\ref{fig:big-picture}). Sa raison d'être est d'accélérer la création et la restauration d'une version en fournissant un accès rapide aux données que contient le DNA-Drive. \begin{figure*}[ht] \centering \begin{tikzpicture} \draw (0,0) node[anchor=south west] {Ordinateur} rectangle (8, 3.5); \draw (.5,1) rectangle (3,3) node[midway] {Source}; \draw (5,1) rectangle (7.5,3) node[midway] {Repo}; \draw (10,1) rectangle (12.5,3) node[midway] {DNA-Drive}; \draw[Arrow] (3,2.3) -- (5,2.3) node[midway,above] {Commit}; \draw[Arrow] (7.5,2.3) -- (10,2.3) node[midway,above] {Export}; \draw[Arrow] (5,1.7) -- (3,1.7) node[midway,below] {Restore}; \draw[Arrow] (10,1.7) -- (7.5,1.7) node[midway,below] {Import}; \end{tikzpicture} \caption{Le repo est une zone intermédiaire entre le dossier source à sauvegarder et le DNA-Drive.} \label{fig:big-picture} \end{figure*} \subsection{Principe de base} Pour créer une nouvelle version ou en restaurer une existante, DNA-Backup n'utilise donc que le repo. Il est ensuite possible d'exporter les données du repo vers le DNA-Drive, ou bien de reconstruire le repo en important les données du DNA-Drive, par exemple dans le cas d'une défaillance ou bien d'une duplication. DNA-Backup stocke les données d'une version d'une manière assez particulière. Chaque version est en fait un \emph{disque virtuel} contenant les données des fichiers mis bout-à-bout. Ce disque virtuel ne contient aucune métadonnée, seulement le contenu des fichiers et c'est sur lui qu'on applique le pipeline de compression. Il n'est donc pas stocké sous la forme d'un segment continu, mais en tant qu'un ensemble de chunks. La liste des chunks qui le compose fait partie des métadonnées que DNA-Backup doit enregistrer. C'est à partir de cette liste et du contenu des chunks que l'on peut recréer le disque virtuel. Mais le disque virtuel à lui seul ne suffit pas à restaurer une version. En effet, il ne contient aucune métadonnée, il est donc impossible de savoir à quel fichier correspond une donnée. DNA-Backup doit donc également sauvegarder pour chaque version une liste de noms de fichiers, permettant de retrouver dans son disque virtuel où commence et où s'arrête chaque fichier. Pour restaurer une version, il faut donc dans un premier temps reconstruire en mémoire le disque virtuel à partir de sa liste de chunks, puis le découper en fichiers à partir de la liste des noms de fichiers. \subsection{Contenu du repo} Le repo est donc une zone intermédiaire qui devra contenir l'ensemble des données écrites sur le DNA-Drive. Mais contrairement à ce dernier, il est stocké sur un support classique. Il n'est donc pas nécessaire de l'optimiser autant en terme d'espace de stockage. D'autant plus qu'il faut que les données soient facilement accessibles pour augmenter l'efficacité des algorithmes du commit et du restore. Toutefois, afin de simplifier les imports et les exports avec le DNA-Drive, la plupart des données sont stockées de manière quasiment identique. Il ne faut pas non-plus que l'espace qu'il occupe soit trop important, la totalité de ses fichiers sont donc compressés. Le repo tire parti du système de fichier sur lequel il est stocké. Il organise ses données dans différents fichiers, chacun rangé dans le dossier de la version à laquelle il appartient. La Figure~\ref{fig:repo-dir-tree} montre un exemple d'arborescence de repo comportant deux versions. Un dossier de version est nommé par son numéro et contient trois fichiers de métadonnées : \verb|files|, \verb|hashes|, et \verb|recipe|, ainsi qu'un dossier \verb|chunks|. \begin{figure*}[ht] \centering \begin{subfigure}[c]{.34\textwidth} % \centering % centering ne fonctionne pas du tout avec le dirtree \dirtree{% .1 repo/. .2 00000/. .3 chunks/. .4 000000000000000. .4 000000000000001. .4 000000000000002. .4 000000000000003. .3 files. .3 hashes. .3 recipe. .2 00001/. .3 chunks/. .4 000000000000000. .4 000000000000001. .3 files. .3 hashes. .3 recipe. } \caption{Exemple d'arborescence d'un repo comportant deux versions.} \label{fig:repo-dir-tree} \end{subfigure} \hfill \begin{subtable}[c]{.55\textwidth} \centering \begin{tabular}{l r r} \verb|repo/00000/recipe| & 5076011 & 1.2\% \\ \verb|repo/00000/files| & 24664 & 0.1\% \\ \verb|repo/00000/hashes| & 3923672 & 0.9\% \\ \verb|repo/00000/chunks| & 412263137 & 97.8\% \\ \end{tabular} \caption{ Répartition des données d'un repo comportant une seule version pour une taille totale de 401 Mio. Ce repo a été obtenu à partir d'un dossier contenant un certain nombre de projets web, il s'agit donc d'un contenu assez hétéroclite, comportant notamment des images et autres fichiers déjà compressés. } \label{tab:repo-data-distribution} \end{subtable} \caption{Organisation du \emph{repo}.} \label{fig:repo-organisation} \end{figure*} \paragraph{Chunks} Le dossier \verb|chunks| contient l'ensemble des chunks ajoutés dans cette version. Chaque chunk est stocké dans un fichier séparé et compressé indépendamment des autres. De cette manière, il est très facile d'accéder au contenu d'un chunk précis. \paragraph{Files} Le fichier \verb|files| contient la liste des fichiers ainsi que leur taille. C'est grâce à lui qu'on est capable de retrouver à quel fichier appartient une donnée du disque virtuel d'une version. Il ne contient en réalité que la différence apportée à cette liste dans cette version par rapport à la précédente. Pour reconstruire la véritable liste de fichiers, il faut donc relire l'ensemble des fichiers \verb|files| et appliquer les différences les unes à la suite des autres. De plus, le contenu de ce fichier est finalement compressé avant d'être écrit sur le disque, afin d'encore économiser de l'espace. \paragraph{Recipe} C'est dans le fichier \verb|recipe| que le repo stocke la liste des chunks permettant de reconstruire le disque virtuel d'une version. Exactement comme pour le fichier \verb|files|, il est enregistré de manière incrémentale, en différence par rapport à la version précédente. Le même processus de reconstruction d'y applique donc. \paragraph{Hashes} Pour ne pas avoir à recalculer les signatures (fingerprints et sketches) de tous les chunks du repo lors d'un commit, on stocke ses valeurs dans un fichier \verb|hashes| séparé. Celui-ci ne sera pas synthétisé en \ac{adn}, car les données qu'il contient peuvent être recalculées à partir du contenu des chunks. \subsection{L'export vers le DNA-Drive} \label{sec:dna-export} Au lieu de voir le DNA-Drive comme une grille, on l'imagine comme une liste de \emph{pools} à une seule dimension (Figure~\ref{fig:data-layout}). De cette manière on peut répartir l'espace de stockage entre les deux principaux segments de données de DNA-Backup : les chunks et les métadonnées (recipe + files). Comme on peut le remarquer sur la Figure~\ref{tab:repo-data-distribution}, les métadonnées ont une taille bien inférieure à celle de l'ensemble des chunks, en particulier lorsque les fichiers sont grands. Cependant, il n'est pas possible de savoir à l'avance exactement quelle proportion sera utilisée par les métadonnées, car leur taille peut varier en fonction d'un certain nombre de paramètres (type de fichiers sauvegardés, fréquence de sauvegarde, quantité et taille des fichiers,~etc.). Pour garantir une utilisation maximale de l'espace disponible, on fait démarrer ces deux segments chacun à une extrémité du DNA-Drive et on les laisse grandir l'un vers l'autre, à la manière de la \emph{pile} et du \emph{tas} d'un processus. Contrairement à la manière dont ils sont stockés dans le repo, lors de l'export, les chunks ne sont pas compressés indépendamment, mais tous ensembles, par version. De cette manière on réduit encore l'espace occupé par les chunks, car l'algorithme de compression n'a pas à réécrire plusieurs fois son ``header'' et peut réutiliser les motifs de répétition trouvés dans un chunk à travers l'ensemble des chunks d'une version. Cette technique a pour inconvénient d'avoir besoin de décompresser (et donc lire) la totalité des chunks d'une version même si on ne veut en lire qu'un seul. \begin{figure}[ht] \centering \begin{tikzpicture}[ start chain = going right, node distance = 0, Box/.style={draw, minimum width=2em, minimum height=2em, outer sep=0, on chain}, Brace/.style={decorate,decoration={brace, amplitude=1em, raise=.5em, mirror}} ] \node[Box] (p0) {$0$}; \node[Box] (p1) {$1$}; \node[Box] (p2) {$2$}; \node[Box] (p3) {$3$}; \node[Box] (p4) {$4$}; \node[Box,minimum width=6em] (ellipsis) {$\cdots$}; \node[Box] (p93) {$93$}; \node[Box] (p94) {$94$}; \node[Box] (p95) {$95$}; \draw[Arrow] (p4.east) to +(2em,0); \draw[Arrow] (p93.west) to +(-2em,0); \node (ver) at (0,-3.2em) {version}; \draw[->] (p0.south) to (ver); \draw[Brace] (p1.south west) to node[black,midway,below=1.5em] {chunks} (p4.south east); \draw[Brace] (p93.south west) to node[black,midway,below=1.5em,align=center] {metadata\\(recipe+files)} (p95.south east); \end{tikzpicture} \caption{Disposition des données.} \label{fig:data-layout} \end{figure} Le tout premier pool du DNA-Dire (numéro 0) est réservé aux \emph{header} des versions et aux métadonnées globales du repo. Pour chaque version, il faut conserver la taille de ses trois segments (\verb|chunks|, \verb|recipe| et \verb|files|). De la même manière qu'il serait impossible de savoir à quel fichier appartient une donnée sans la liste de fichiers, il serait impossible sans ces informations, de savoir à quelle version et à quel segment de données appartient une track. Le header d'une version ne comptant que trois valeurs numériques, il ne remplira jamais une track. Pour éviter de gâcher l'espace restant des tracks de version, DNA-Backup le remplit avec le contenu des segments de métadonnées (\verb|recipe| + \verb|files|) jusqu'à ce qu'il soit plein ou que toutes les métadonnées aient été écrites. S'il reste encore des métadonnées, elles sont écrites à l'endroit prévu initialement. En ce qui concerne les métadonnées du repo, un \emph{superblock} serait ajouté dans la toute première track du premier pool. Celui-ci contiendrait les valeurs des paramètres de DNA-Backup, à savoir principalement la taille des chunks, mais aussi les paramètres de la fonction de sketch, l'algorithme utilisé pour la compression utilisé, celui pour les deltas,~etc. L'export est actuellement réalisé dans un dossier, dans lequel 96~fichiers représentant chacun un pool sont créés et remplis avec les données du repo. Les écritures sont alignées sur la taille d'une track, laquelle est configurable. Le repo n'a pas réellement de connaissances de ces valeurs en dehors de l'export. DNA-Backup est donc en grande partie indépendant du DNA-Drive et pourrait être utilisé avec d'autres supports de stockages, ou même en utilisant uniquement le repo, à la manière d'un logiciel de sauvegardes incrémentales classique. \subsection{Importer depuis le DNA-Drive} Les fonctions d'import n'ont pour le moment pas été implémentées. Ce qui suit décrit donc l'ensemble des fonctionnalités qui pourraient être implémentées à partir du format d'export décrit dans la section~\ref{sec:dna-export}. \subsubsection{Reconstruction complète du repo} En lisant la totalité du DNA-Drive, il est possible de reconstruire entièrement le repo. Une fois ce dernier reconstruit, n'importe quelle version peut être restaurée très rapidement. Afin de reconstruire le repo, il faut dans un premier temps lire le pool de version. Celui-ci contient en effet le superblock ainsi que les headers des versions, nécessaires à l'initialisation du repo et au découpage du reste des données en segments cohérents. Une fois ce pool séquencé et décodé, il est possible de savoir le nombre de pools qu'il faut maintenant lire pour récupérer les chunks et les métadonnées de chaque version. Pour réduire le temps total de lecture, il serait également possible, en même temps que de lire le pool de version, de séquencer en parallèle les premiers pools de chunks et de métadonnées. Ainsi, même si on ne peut pas immédiatement donner du sens aux données de ces pools, il sera possible de les décoder dès que les headers des versions seront restaurés. Cette opération est longue, mais n'est à réaliser que lorsque l'on veut restaurer la totalité du repo, par exemple après une défaillance ou lors d'une duplication. Si le but n'est que de récupérer la dernière version, il n'est pas nécessaire de reconstruire le repo en entier. \subsubsection{Restauration de la dernière version} Il est possible de ne restaurer qu'une version, sans avoir à lire la totalité des données présentes sur le DNA-Drive. L'opération commence de la même manière que pour la reconstruction complète du repo, il nous faut donc tout d'abord lire le pool de version ainsi que ceux des métadonnées. Comme le montre la Figure~\ref{tab:repo-data-distribution}, la taille des métadonnées est très faible par rapport à celle des chunks. Nous n'avons pas eu l'opportunité de réaliser suffisamment de tests afin d'évaluer le pourcentage maximum utilisé par les métadonnées, mais aux cours de nos tests sur des données fortement déduplicables et compressibles, les métadonnées ont atteint jusqu'à 15\% du volume total de données. Nous estimons qu'elles ne devraient pas dépasser 20\% de la totalité des données écrites. Une fois les pools de métadonnées séquencés, il est possible de reconstruire les véritables valeurs de la recipe et de la liste des fichiers, en appliquant les différences de chaque version les unes à la suite des autres. Avec ces informations, la liste des chunks permettant de reconstruire le disque virtuel de cette version est maintenant connue. L'étape suivante consiste donc à déterminer quels sont les pools de chunks qu'il va falloir lire. C'est malheureusement ici qu'on paie le prix de la compression réalisée lors de l'export. En effet, comme les chunks sont tous compressés en même temps, il n'est pas possible de sélectionner seulement les tracks composant un chunk lors d'une lecture. Il faut nécessairement lire la totalité du segment de chunks de cette version pour pouvoir le décompresser, et en extraire le chunk voulu. On obtient donc une forte amplification des lectures, car il faudra lire une quantité de données beaucoup plus grande que celles qui composent réellement la version. Nous ne pouvons pas réellement quantifier cette amplification des lectures pour le moment. Il faudrait pour cela réaliser des simulations du coût de restauration d'une version. Cela-dit, si la lecture est finalement un cas d'utilisation qui devient plus important, il reste toujours la possibilité, à la manière du repo, de compresser les chunks indépendamment lors de l'export vers le DNA-Drive, au détriment de l'espace utilisé. \subsubsection{Restauration d'un seul fichier} De manière assez similaire à la restauration d'une version complète, bien que la seule lecture des métadonnées nous permette d'obtenir les arborescences de chaque version, ainsi que de déterminer les chunks qu'il est nécessaire de lire afin de restaurer le contenu d'un fichier unique, la technique de compression utilisée lors de l'export diminue l'intérêt de ce cas d'utilisation. Les lectures seront une fois encore amplifiées, car tous les chunks d'une même version devront être lus. Toutefois, il est possible que les chunks du fichier en question fassent tous partie d'une petite et même version. Dans ce cas l'amplification de lecture restera contenue et potentiellement bien moindre que si on avait eu à restaurer la totalité de la version. \chapter{Détails techniques} \section{Spécificités d'implémentation} L'implémentation de DNA-Backup présentée ici a été réalisée sous la forme d'un programme en \ac{cli} codé en Go (L'Annexe~\ref{sec:documentation} donne quelques informations supplémentaires pour aider à la compilation et l'utilisation du programme). Ce langage a été choisi, car : \begin{itemize} \item Il propose un bon compromis entre performance et temps de développement. \item Il est très facilement compilable pour un grand nombre de systèmes d'exploitation et d'architectures. \item Le programme résultant n'est dépendant d'aucun runtime, ce qui permet de produire des logiciels ``cross-platform''. \item Par curiosité et envie de découvrir et d'apprendre ce langage. \end{itemize} \subsection{Choix techniques} Un certain nombre de choix techniques ont été dictées par le temps limité et la disponibilité de librairies efficaces. Notamment, l'encodeur par défaut du langage Go : \verb|gob|~\cite{pike2011gob}, a été utilisé à maintes reprises, du fait de sa simplicité de mise en œuvre et de sa relativement bonne efficacité en terme d'espace. Malheureusement, il n'est pas particulièrement interopérable car, malgré que la totalité de ses spécifications soient disponibles, il n'existe que très peu d'implémentations dans d'autres langages. De la même manière, les algorithmes de compression et d'encodage delta utilisés dans DNA-Backup n'ont pour le moment pas été choisis en fonction de leur efficacité, mais plutôt pour des raisons de facilité. En ce qui concerne la compression, le choix n'a pas tellement d'importance, car l'algorithme peut être facilement remplacé par un autre, plus performant. L'utilisation actuelle de \emph{Zlib}~\cite{rfc1950} basé sur DEFLATE~\cite{rfc1951} reste malgré tout intéressante, car il s'agit de l'algorithme utilisé par les autres systèmes auxquels nous allons nous comparer par la suite. Ainsi les résultats ne seront pas biaisés par l'utilisation d'un algorithme plus performant que les autres. Deux algorithmes ont été testés pour l'encodage delta. Tout d'abord \verb|bsdiff|~\cite{percival2003naive} qui est la référence actuelle quand il s'agit de produire des différences binaires d'une taille minimale. C'était par exemple l'algorithme utilisé par le projet Chromium pour distribuer ses mises-à-jour, jusqu'à ce qu'ils décident d'en créer un parfaitement adapté à leur besoin~\cite{chromium2012courgette}. Cependant, \verb|bsdiff| est optimisé pour des données binaires exécutables, ce qui en fait un algorithme trop peu généraliste. De plus, son fonctionnement inclut une passe de compression sur la différence qu'il crée, laquelle est redondante avec celle que nous appliquons nous-même sur les données que nous stockons. Nous choisissons finalement d'utiliser \verb|fdelta| le format de différence utilisé par le gestionnaire de version Fossil~\cite{hipp2006fdelta}. Celui-ci étant plus généraliste et produisant des différences d'une taille suffisamment réduite, tout en étant explicitement prévu pour être ensuite compressé avec l'algorithme de notre choix. \subsection{Structures de données du repo} \subsubsection{Files} Pour rappel, le fichier \verb|files| correspond aux métadonnées de l'arborescence du système de fichier. C'est là que sont stockés les données à propos des fichiers, comme leur nom et leur taille et c'est grâce à ce segment de données qu'on peut retrouver la position d'un fichier dans le disque virtuel. DNA-Backup stocke le contenu de ce fichier comme une liste de structures \verb|File| (Figure~\ref{fig:type-file-struct}), encodée avec \verb|gob|~\cite{pike2011gob}. Cette structure possède également un champ \verb|Link|. Celui-ci permet de supporter la fonction de liens symboliques des systèmes de fichiers POSIX. DNA-Backup conserve ainsi la valeur des liens et ne duplique pas le contenu des fichiers ou des dossiers. Si le lien est absolu, il sera correctement reformé lors de la restauration et les liens relatifs le restent une fois restaurés. Les autres métadonnées des fichiers comme les permissions et les dates de création ou de modification ne sont pas enregistrées. \subsubsection{Recipe} Le fichier \verb|recipe| est celui qui permet de reconstruire le disque virtuel. Go nous autorise à créer des listes de structures hétérogènes grâce aux interfaces, il s'agit donc concrètement d'une simple liste de structures de chunks (Figure~\ref{fig:type-chunks-struct}). Une fois encore, encodée à l'aide de \verb|gob|~\cite{pike2011gob}. Un chunk est référencé par son ID, dont la structure est visible Figure~\ref{fig:type-chunkid-struct}. \begin{figure}[ht] \centering \begin{subfigure}[t]{.45\textwidth} \begin{lstlisting}[language=Go] type File struct { Path string Size int Link string } \end{lstlisting} \caption{Structure File} \label{fig:type-file-struct} \hfill \begin{lstlisting}[language=Go] type ChunkId struct { Version int Index int } \end{lstlisting} \caption{Structure ChunkId} \label{fig:type-chunkid-struct} \end{subfigure} \hfil \begin{subfigure}[t]{.45\textwidth} \begin{lstlisting}[language=Go] type StoredChunk struct { Id ChunkId } type DeltaChunk struct { Source ChunkId Patch []byte Size int } type PartialChunk struct { Value []byte } \end{lstlisting} \caption{Structures des différents types de chunks\protect\footnotemark} \label{fig:type-chunks-struct} \end{subfigure} \caption{Structures de données du repo} \label{fig:repo-type-struct} \end{figure} \footnotetext{\lstinline{PartialChunk} s'appelle en réalité \lstinline{TempChunk} dans le code, pour le moment} Comme on peut le voir, les \verb|DeltaChunks| contiennent un champ \verb|Patch|. Il s'agit de la différence de ce chunk par rapport à celui référencé par le champ \verb|Source|. C'est donc la \verb|recipe| qui contient les deltas, mais aussi potentiellement des données d'une taille inférieure à la taille d'un chunk, par exemple le tout dernier chunk du disque virtuel. Le même algorithme d'encodage delta que celui utilisé pour les chunks, \verb|fdelta|~\cite{hipp2006fdelta}, permet de sauvegarder les informations de ces deux fichiers de manière incrémentale. Il est appliqué sur le résultat de l'encodage par \verb|gob|~\cite{pike2011gob} et sa sortie est compressée avant d'être stockée. \section{Algorithme du commit} \begin{enumerate} \item Chargement des métadonnées du repo afin de reconstruire en mémoire l'état de la dernière version : \begin{itemize} \item Reconstruction de la recipe à partir des deltas de chaque version. \item Reconstruction du listage des fichiers à partir des deltas de chaque version (fichier \verb|files|). \item Reconstruction en mémoire des index de \emph{fingerprints} et de \emph{sketches} à partir des fichiers \verb|hashes| de chaque version. \end{itemize} \item Listage des fichiers de la source. \item Concaténation de l'ensemble des fichiers de la source en un disque virtuel continu. \item Lecture de ce disque virtuel. Tant qu'il reste des données dans le disque virtuel : \begin{itemize} \item Application de l'empreinte de Rabin~\cite{rabin1981fingerprinting} sur les données du disque virtuel, avec une fenêtre glissante de la taille d'un chunk, afin de chercher des correspondances de \emph{fingerprint} avec l'index. \item Lorsqu'une fingerprint est trouvée, le chunk correspondant est alors stocké de manière dé-dupliquée, sous la forme d'un \verb|StoredChunk| (Figure~\ref{fig:type-chunks-struct}) contenant l'identifiant du chunk trouvé dans l'index. \item Si aucune correspondance n'est trouvé après avoir analysé l'équivalent de 3 chunks de données, alors le \emph{sketch} du premier chunk est calculé et cherché dans l'index pour tenter de le stocker en encodage delta, sous la forme d'un \verb|DeltaChunk| (Figure~\ref{fig:type-chunks-struct}). \item S'il n'est pas trouvé, il est alors stocké en tant que nouveau \verb|StoredChunk| et sa \emph{fingerprint} et son \emph{sketch} sont ajoutés aux index. \item Si une correspondance (de fingerprint ou de sketch) arrive entre le deuxième et le troisième chunk, alors, si possible, le reste du deuxième chunk est fusionné avec le premier pour tenter de l'encoder en tant qu'un seul \verb|DeltaChunk|. \end{itemize} \item Calcul des différences entre la nouvelle version et la précédente pour les métadonnées (files et recipe) et stockage des deltas ainsi obtenus. \end{enumerate} \section{Algorithme du restore} \begin{enumerate} \item Chargement des métadonnées du repo afin de reconstruire en mémoire l'état de la dernière version : \begin{itemize} \item Reconstruction de la recipe à partir des deltas de chaque version. \item Reconstruction du listage des fichiers à partir des deltas de chaque version. \end{itemize} \item À partir de la recipe, reconstruire le disque virtuel. \item Découper ce disque virtuel en fonction du listage des fichiers et réécrire les données dans les fichiers correspondants dans le répertoire destination. \end{enumerate} \chapter{Évaluation de performances} Nous comparons DNA-Backup à des systèmes existants afin de quantifier son potentiel intérêt. Les évaluations réalisées au cours de ce stage reste toutefois limitées. Seul l'espace occupé est pris en compte dans ce comparatif. De plus amples expériences pourraient aider à évaluer ce système, notamment en termes de coût des lectures. \section{Bases de comparaison} Quatre autres systèmes de stockage versionnés ont été choisis comme bases de comparaison (La Table~\ref{tab:recap-table} offre une vision d'ensemble pour comparer les différentes fonctionnalités de ces systèmes) : \begin{itemize} \item \textbf{Git diffs} \item \textbf{Git objects} \item \textbf{Tar.gz} \item \textbf{Taille réelle} \end{itemize} \subsection{Git diffs} Ce système utilise le delta généré par la commande \verb|git diff| pour sauvegarder une nouvelle version. Les données à stocker consistent donc en une somme de deltas. Pour les restaurer, il faut appliquer séquentiellement l'ensemble des deltas jusqu'à obtenir l'état de la version voulue. Le delta ainsi obtenu est ensuite compressé à l'aide de Gzip pour en diminuer la taille. Cette compression est assez efficace, car elle est réalisée d'un coup sur toutes les modifications. La commande utilisée pour générer ces différences est la suivante : \begin{lstlisting}[language=sh] git diff --minimal --binary --unified=0 -l0 | gzip \end{lstlisting} L'option \verb|--minimal| permet de faire en sorte que Git passe plus de temps à essayer de trouver le plus petit ensemble de différences. L'option \verb|--binary| est là pour forcer Git à calculer des différences pour les fichiers binaires. Avec \verb|--unified=0| on peut produire des diffs qui ne contiennent aucune contextualisation et \verb|-l0| désactive la limite du nombre de fichiers à prendre en compte pour la détection de renommage. Nous nous assurons avec toutes ces options de produire les deltas les plus petits possibles. Pour garantir que ces différences sont viables, elles sont, au cours de l'expérience, réappliquées au moins une fois et le résultat est comparé avec le dossier source. \subsection{Git objects} Il s'agit de la manière dont Git sauvegarde les données des fichiers d'un dépôt~\cite{straub2006git}. Le contenu de chaque fichier et de chaque dossier est hashé afin d'en obtenir une signature. Il est ensuite compressé et stocké sous la forme d'\emph{object} immuable, référencé par la signature obtenue. Si un fichier est modifié, il produira une signature différente et sera donc stocké sous la forme d'un nouvel \emph{object}. Par contre, si deux fichiers ont un contenu strictement identique, ils produiront alors la même signature et seront donc automatiquement dé-dupliqués. Les dossiers sont également stockés en tant qu'\emph{objects}, mais les fichiers qu'ils contiennent sont référencés non pas par leur nom, mais par leur signature. La modification d'un fichier entrainera donc l'ajout de nouveaux \emph{objects} pour l'ensemble des dossiers de la branche contenant ce fichier. C'est de cette manière que Git est capable de créer un système de fichiers modifiable à partir d'objets immuables. Cette base de comparaison simule un système de fichiers qui ne serait pas autorisé à modifier des données sur le support tout en gardant la possibilité de les mettre à jour. \subsection{Tar.gz} Une technique d'archivage assez classique à laquelle il peut être intéressant de nous comparer est de stocker chaque version en tant qu'une nouvelle archive Tar elle-même compressée à l'aide de Gzip. Cette technique produit des archives d'une taille très réduite, car la compression est appliquée à l'ensemble des fichiers d'un seul coup, contrairement à une compression fichier par fichier. Elle a cependant l'inconvénient de ne pas faire de dé-duplication ni d'encodage delta, et ne tire donc pas du tout parti des données déjà écrites sur le support. \subsection{Taille réelle} Cette base de comparaison n'est en réalité pas un système viable. Elle correspond à la taille que prend en réalité le dossier \emph{source} au moment de la sauvegarde. C'est un indicateur qui permet de se rendre compte du poids que prendrait la sauvegarde de multiples versions sans aucune déduplication ou compression. \begin{table*}[ht] \renewcommand\arraystretch{1.5} \small \begin{tabularx}{\textwidth}{@{}L|L|L|L|L|L@{}} & \textb{DNA-Backup} & \textb{Git diffs} & \textb{Git objects} & \textb{Tar.gz} & \textb{Taille réelle} \\ \hline \multirow{2}{=}{\textb{Dé\-du\-pli\-ca\-tion}} & Niveau chunk & \multirow{2}{=}{N/A} & Niveau fichier & \multirow{2}{=}{N/A} & \multirow{2}{=}{N/A} \\ \cline{2-2} \cline{4-4} & Transversal aux versions & & Transversal aux versions & \\ \hline \multirow{2}{=}{\textb{Delta-encoding}} & Niveau chunk & Niveau version & \multirow{2}{=}{N/A} & \multirow{2}{=}{N/A} & \multirow{2}{=}{N/A} \\ \cline{2-3} & Transversal aux versions & Par rapport à la précédente & & \\ \hline \textb{Com\-pres\-sion} & Niveau version & Niveau version & Niveau fichier & Niveau version & N/A \\ \hline \textb{Res\-tau\-ra\-tion de la dernière version} & Lecture des métadonnées puis des chunks de cette version (répartis dans différents pools) & Lecture de la totalité du DNA-Drive & Lecture récursive des différents objets composant la version (répartis dans différents pools) & Lecture de la zone correspondant à la dernière version & Lecture de la zone correspondant à la dernière version \\ \end{tabularx} \caption{Récapitulatif des systèmes de stockages versionnés comparés.} \label{tab:recap-table} \end{table*} \section{Quantité d'octets par version} Pour évaluer les performances du système DNA-Backup, on utilise le dépôt Git du noyau Linux comme base de donnée de test. Il s'agit en effet d'une bonne simulation de modification de dossiers, car l'historique contient toutes les modifications qui ont été apportées petit à petit à l'ensemble des fichiers. Un inconvénient de ce jeu de données, en plus de son unicité, est de n'être composé quasiment exclusivement que de fichiers texte. Ce type de fichier est très fortement compressible, ce qui augmente l'importance de l'étape de compression. Ce n'est pas spécialement cette étape qui sépare DNA-Backup des autres systèmes auxquels nous nous comparons. L'utilisation commune de Zlib~\cite{rfc1950} par toutes les solutions testés permet heureusement de ne pas trop avantager un système par rapport aux autres. \subsection{Protocole expérimental} Le protocole se base sur des dépôts Git comme base de données de dossiers dont le contenu évolue au cours du temps. Le dépôt sélectionné est dans un premier temps cloné avec son dossier \verb|.git| externalisé. Dans notre cas, il s'agit de celui du noyau Linux. Nous pouvons ensuite extraire une liste de commits en ordre chronologique. Laquelle est ensuite filtrée à l'aide de \verb|sort| pour n'en garder au maximum qu'un seul par jour. La commande utilisée est la suivante : \begin{lstlisting}[language=sh] git log --reverse --date-order --first-parent --pretty=tformat:"%H %as" | sort --unique --key=2 \end{lstlisting} L'utilisation de l'option \verb|--first-parent| est importante, car elle permet de ne suivre qu'une seule branche de l'historique et ainsi éviter le va-et-vient d'une branche à une autre entre deux commits. Pour les expérimentations simulant des commits hebdomadaires et mensuels, cette liste est filtrée à nouveau pour n'en garder respectivement qu'une ligne sur sept et une ligne sur 30. Chaque expérimentation va ensuite faire évoluer l'état du dossier du dépôt de celui d'un commit de cette liste au suivant. Tout en exécutant à chaque fois entre deux, les différents systèmes à comparer. Aucune autre valeur que l'espace de stockage n'est mesuré. Ce dernier est comptabilisé à l'aide de la commande \verb|du| et de son option \verb|--apparent-size|, car on ne veut surtout pas prendre en compte l'``overhead'' du système de fichier par-dessus lequel les tests sont réalisés. Tous les scripts permettant d'obtenir les résultats suivants sont disponibles et les expérimentations sont reproductibles. L'Annexe~\ref{sec:experimentations} apporte une aide minimale sur l'utilisation de ces scripts. \subsection{Résultats} \subsubsection{Méthode de compression des chunks} Dans un premier temps, nous comparons les performances de DNA-Backup entre l'espace utilisé par le repo et celui utilisé par l'export (Table~\ref{tab:commits-daily-repo}). Le but ici était principalement de quantifier la perte d'espace due à la compression indépendante des chunks. Le fichier \verb|hashes| n'est donc pas comptabilisé dans cette expérience. \begin{table*}[ht] \small \centering \begin{subtable}[t]{.65\textwidth} \centering \begin{tabular}{rrrr} \textb{Repo 4k} & \textb{Repo 8k} & \textb{DNA 4k} & \textb{DNA 8k} \\ \hline \input{assets/summary.daily.17.repo.tex} \end{tabular} \caption{ Comparaison entre la taille du repo (mis à part le fichier hashes) et l'espace pris par l'export DNA-Drive, avec des chunks de 4 et 8~ko. } \label{tab:commits-daily-repo} \end{subtable} \hfill \begin{subtable}[t]{.3\textwidth} \centering \begin{tabular}{r} \textb{Borg} \\ \hline \input{assets/summary.daily.17.borg.tex} \end{tabular} \caption{Logiciel de sauvegardes dédupliqués \emph{Borg}~\cite{waldmann2017borg}, avec le chiffrement désactivé.} \label{tab:commits-daily-borg} \end{subtable} \caption{Commits journaliers.} \label{tab:commits-daily-misc} \end{table*} La comparaison n'est pas tout à fait équitable, car lors de l'export, les segments des versions sont alignées à la taille d'une track, ici \numprint{1020}~octets. Les exports ont donc un handicap, car des bits de bourrage sont potentiellement ajoutés. Cependant, on remarque tout de même une très nette réduction d'espace lorsque les chunks sont compressés par version plutôt qu'indépendamment. Nous pouvons également remarquer que lorsque les chunks sont compressés tous ensemble, il devient plus intéressant d'en réduire la taille. En effet, plus les chunks sont petits, plus l'on perd d'efficacité avec les algorithmes de compression lorsqu'ils sont compressés indépendamment. Dans la suite des expériences, nous ne comptabiliseront pas l'espace occupé par le repo, mais uniquement celui occupé par les exports. \subsubsection{Comparaison avec Borg} \emph{Borg Backup}~\cite{waldmann2017borg} est un système de sauvegardes dédupliqué populaire au fonctionnement assez similaire à DNA-Backup en ce qui concerne la déduplication. Cependant, il n'implémente pas d'encodage delta. Nous ne l'avons pas ajouté au tableau comparatif parce qu'il a été ajouté au banc de test un peu trop tard. La Table~\ref{tab:commits-daily-borg} montre le résultat d'une exécution sur des commits journaliers. Nous nous attendions à un meilleur résultat, venant d'un système de sauvegarde incrémental dédié à cet usage. L'espace qu'il occupe est même supérieur aux Git Objects (Table~\ref{tab:commits-daily}). Cet écart provient peut-être de métadonnées que Borg pourrait ajouter, telles que des sommes de contrôle ou bien des index. Dans la suite des expérimentations, Borg ne sera pas ajouté au banc de tests. Nous ne nous sommes pas trop attardés sur les options que Borg propose. Il se peut que certaines permettent de réduire la taille des sauvegardes. Nous nous sommes contentés de désactiver l'option de chiffrement du dépôt, cette dernière ne pouvant que l'augmenter. \begin{table*}[ht] \small \centering \begin{tabularx}{\textwidth}{@{}RRRRRR} \textb{DNA 4k} & \textb{DNA 8k} & \textb{Git diffs} & \textb{Git objects} & \textb{Tar.gz} & \textb{Taille réelle} \\ \hline \input{assets/summary.daily.17.tex} \end{tabularx} \caption{Commits journaliers.} \label{tab:commits-daily} \end{table*} \subsubsection{Commits journaliers} La Table~\ref{tab:commits-daily} montre les résultats de l'expérience lorsqu'on crée un commit chaque jour. Le jeu de données de test étant un gros projet, les modifications réalisées en une journée sont déjà assez conséquentes. La colonne \textb{Git diffs} offre une bonne approximation de la quantité exacte de données qui ont été modifiées à chaque version. Dans notre comparatif, l'espace occupé par les diffs Git est considéré comme optimal, \begin{table*}[ht] \small \centering \begin{tabularx}{\textwidth}{@{}RRRRRR} \textb{DNA 4k} & \textb{DNA 8k} & \textb{Git diffs} & \textb{Git objects} & \textb{Tar.gz} & \textb{Taille réelle} \\ \hline \input{assets/summary.weekly.17.tex} \end{tabularx} \caption{Commits hebdomadaires.} \label{tab:commits-weekly} \end{table*} \subsubsection{Commits hebdomadaires} \begin{table*}[ht] \small \centering \begin{tabularx}{\textwidth}{@{}RRRRRR} \textb{DNA 4k} & \textb{DNA 8k} & \textb{Git diffs} & \textb{Git objects} & \textb{Tar.gz} & \textb{Taille réelle} \\ \hline \input{assets/summary.monthly.17.tex} \end{tabularx} \caption{Commits Mensuels.} \label{tab:commits-monthly} \end{table*} \subsubsection{Commits mensuels} % Bibliography \bibliography{doc.bib} % Annexes \appendix % Acronyms \include{assets/acronyms.tex} \chapter{Documentation technique} \section{Documentation du programme} \label{sec:documentation} Le code source de l'implémentation de DNA-Backup réalisée pendant ce stage est disponible sur GitHub à l'adresse suivante : \url{https://github.com/n-peugnet/dna-backup}. Ce programme est un logiciel libre ; vous pouvez le redistribuer ou le modifier suivant les termes de la GNU General Public License telle que publiée par la Free Software Foundation\footnote{\url{https://www.gnu.org/licenses/gpl-3.0.fr.html}} ; soit la version 3 de la licence, soit (à votre gré) toute version ultérieure. \subsection{Compilation} Le code doit compiler convenablement sur Linux, MacOS et Windows et les tests doivent passer sans problème sur ces trois plateformes. Pour nous en assurer, des tests sont lancés par les serveurs d'intégration de GitHub\footnote{\url{https://github.com/n-peugnet/dna-backup/actions/workflows/build.yml}}. \subsubsection{Pré-requis} \begin{itemize} \item Go >= 1.16 \end{itemize} \subsubsection{Instructions} \begin{lstlisting}[language=sh] # Build make build # Test make test # Run ./dna-backup commit \end{lstlisting} \subsection{Usage} DNA-Backup est un programme s'utilisant en \ac{cli}. Trois commandes sont disponibles : \begin{itemize} \item \verb|commit| : pour ajouter une nouvelle version au \emph{repo}. \item \verb|restore| : afin de restaurer la dernière version depuis le \emph{repo} \item \verb|export| : pour générer un export à partir des données du \emph{repo} \end{itemize} \subsection{Expérimentations} \label{sec:experimentations} Le dossier \verb|exp| contient les scripts permettant de reproduire les expériences. Les scripts ne sont prévus pour fonctionner que sur Linux, avec Bash et GNUMake. \subsubsection{Aide} \begin{lstlisting}[language=sh] # run experiences make [SKIP_COMMITS=] [SKIP_CHECK=] [MAX_VERSION=] [RANGE=] # clean results make mostlyclean # clean all make clean \end{lstlisting} \verb|| peut prendre l'une des valeurs suivantes : \begin{itemize} \item \verb|daily| \item \verb|weekly| \item \verb|monthly| \end{itemize} \subsubsection{Valeurs par défaut} \begin{lstlisting}[language=Make] SKIP_COMMITS = 0 SKIP_CHECK = 4 MAX_VERSION = 5 RANGE = daily \end{lstlisting} Il est aussi possible de sélectionner les tests qui seront exécutés et apparaitrons dans les résultats en modifiant leur dossier. Voilà les valeurs par défaut de chaque dossier : \begin{lstlisting}[language=Make] NOPACK = nopack BORG = TARGZ = targz REAL = real DIFFS = diffs \end{lstlisting} Par exemple, la commande suivante lancera l'expérience, en y ajoutant Borg et en retirant les diffs Git : \begin{lstlisting}[language=Make] make DIFFS= BORG=borg \end{lstlisting} \end{document}