path: root/pdf/doc.tex

\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{color}
\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.

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.

\section{Problématique}

Il existe donc plusieurs techniques et encodages permettant
de stocker des informations arbitraires sur la molécule d'\ac{adn},
mais 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.

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 réduire la quantité de données écrites,
tout en minimisant la quantité de données à lire pour récupérer les données.

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''.
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.
Ce n'est effectivement pas la peine d'écrire un fichier
s'il va être supprimé ou renommé quelques secondes plus tard.

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.
De plus, 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 donc 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 déduplication, suivi d'une étape d'encodage delta
et enfin d'un dernier étage de compression.
Ces trois techniques sont basées sur la découverte 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 compression 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 donc 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 à ce fichier 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 que chacun des 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 du 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.
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 grosse amplification des lectures,
car il faudra lire une quantité de données beaucoup plus grande de données que juste celles qui composent la version.

Nous n'avons pas eu le temps de réaliser des simulations du coût de restauration d'une version,
nous ne pouvons donc pas réellement quantifier cette amplification des lectures pour le moment.
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.
Ce langage a été choisi, car il propose un bon compromis entre performance et temps de développement.
De plus il est très facilement compilable pour un très grand nombre de systèmes d'exploitation et d'architectures
et le programme résultant n'est dépendant d'aucun runtime,
ce qui permet de produire des logiciels ``cross-plateform''.
Et finalement par curiosité et envie de découvrir et d'apprendre ce langage.

\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, l'utilisation de \emph{Zlib}~\cite{rfc1950} basé sur DEFLATE~\cite{rfc1951} reste 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,
avant qu'ils ne décident d'en créer un parfaitement adapté à leur besoin~\cite{chromium2012courgette}.
Cependant, \verb|bsdiff| est trop spécifique aux 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}.

\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 int64
    Link string
}
\end{lstlisting}
\caption{Structure File}
\label{fig:type-file-struct}
\hfill
\begin{lstlisting}[language=Go]
type ChunkId struct {
    Version int
    Index   uint64
}
\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.

% TODO: parler du stockage incrémental via fdelta

\section{Algorithme du commit}

\begin{enumerate}
\item
  Chargement des métadonnées du \emph{repo} afin de reconstruire en
  mémoire l'état de la dernière version :

  \begin{itemize}
  \item
    Reconstruction de la \emph{recipe} à partir des deltas de chaque
    version.
  \item
    Reconstruction du listage des fichiers à partir des deltas de chaque
    version (fichier \emph{files}).
  \item
    Reconstruction en mémoire des \emph{maps} de \emph{fingerprints} et
    de \emph{sketches} à partir des fichiers \emph{hashes} de chaque
    version.
  \end{itemize}
\item
  Listage des fichiers de la \emph{source}.
\item
  Concaténation de l'ensemble des fichiers de la source en un disque
  virtuel continu.
\item
  Lecture du \emph{stream} de ce disque virtuel et découpage en
  \emph{chunk} (de 8 Kio actuellement).
\item
  Pour chaque \emph{chunk} du \emph{stream} :

  \begin{enumerate}
  \item
    Calculer sa \emph{fingerprint} (hash classique), si elle est
    présente dans la \emph{map} : le stocker de manière dé-dupliquée
    (sous la forme d'identifiant faisant référence au \emph{chunk}
    trouvé dans la map).
  \item
    Sinon, calculer son \emph{sketch} (hash de ressemblance), s'il est
    présent dans la \emph{map}, le stocker sous la forme de delta
    (calcul de sa différence par rapport au \emph{chunk} trouvé dans la
    map).
  \item
    Sinon, le stocker sous la forme de nouveau bloc (ajout de sa
    \emph{fingerprint} et de son \emph{sketch} dans les \emph{maps} et
    stockage du contenu complet dans un nouveau \emph{chunk}).
  \end{enumerate}
\item
  Calcul des différences entre la nouvelle version et la précédente pour
  les métadonnées (\emph{files} et \emph{recipe}) et stockage des deltas
  ainsi obtenus.
\end{enumerate}

\section{Algorithme du restore}

\begin{enumerate}
\item
  Chargement des métadonnées du \emph{repo} afin de reconstruire en
  mémoire l'état de la dernière version :

  \begin{itemize}
  \item
    Reconstruction de la \emph{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 \emph{recipe}, reconstruire le disque virtuel (sous la
  forme d'un \emph{stream}).
\item
  Découper ce \emph{stream} en fonction du listage des fichiers
  (\emph{files}) et réécrire les données dans les fichiers
  correspondants dans le répertoire \emph{destination}.
\end{enumerate}



\chapter{Évaluation de performances}

Le dossier \verb|exp| contient les scripts permettant de reproduire
les expériences. Les scripts ne sont prévus pour fonctionner que sur
Linux.

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.

\section{Bases de comparaison}

Pour évaluer les performances du système DNA-Backup, quatre autres
systèmes de stockage versionnés ont été choisis comme base de
comparaison :

\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 restaurer les données, il faut
appliquer séquentiellement l'ensemble des deltas jusqu'à obtenir l'état
de la version voulue.

\subsection{Git objects}

Ce système nous permet de simuler un système de fichiers qui ne serait
pas autorisé à modifier des données sur le support tout en gardant la
possibilité de modifier les données. Il s'agit de la manière dont Git
sauvegarde les données des fichiers d'un dépôt. 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.

\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.

\subsection{Tableau récapitulatif}

\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{Tableau récapitulatif}
\label{tab:recap-table}
\end{table*}

\section{Nombre d'octets par version}

\subsection{Légende}

\begin{itemize}
\item
  \verb|4k_export| : le système DNA-Backup avec des blocs de 4 Kio.
\item
  \verb|8k_export| : le système DNA-Backup avec des blocs de 8 Kio.
\item
  \verb|diffs| : une somme de diffs Git minimales Gzippées.
\item
  \verb|nopack| : le dossier `objects de Git, contenant l'ensemble des
  données des fichiers et dossiers d'un dépôt.
\item
  \verb|targz| : une somme d'archives Tar Gzippées.
\item
  \verb|real| : le poids réel de chaque version et donc l'espace
  nécessaire à stocker l'ensemble des versions de manière
  non-dédupliquées.
\end{itemize}

\subsection{Résultats}


\begin{table*}[ht]
\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*}


\begin{table*}[ht]
\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*}


\begin{table*}[ht]
\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*}


% Bibliography
\bibliography{doc.bib}

% Annexes
\appendix

% Acronyms
\include{assets/acronyms.tex}

\chapter{Documentation de la CLI}

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}


\end{document}