Accélérer le téléchargement de fichiers

Qui n'a jamais trouvé le téléchargement d'un fichier de plusieurs dizaines de mégas extrêmement long malgré une connexion Internet haut débit ? Vous ? Moi ?… Tout le monde !

Ce tutoriel va vous expliquer comment en accélérer le téléchargement à l'aide de plusieurs connexions simultanées en multi-threads et d'un fichier mappé.

Remarque :

Il ne s'agit pas de transformer un accès Internet à 15 Mb/s en un à 25 (faut pas rêver) mais simplement de passer outre la limitation de bande passante définie par l'hébergeur du site visé. Il faut par conséquent que le débit descendant de votre connexion soit supérieur à la limite en place. Dans le cas contraire, vous ne remarquerez aucune différence !

Ce tutoriel n'a pas pour but d'expliquer tous les détails du mappage de fichier. En voici seulement une courte introduction.

Un fichier mappé est l'association entre le contenu d'un fichier et une zone de la mémoire virtuelle d'un ou de plusieurs processus. C'est un pont entre le fichier et les processus.

Une vue est la portion de la zone de mémoire virtuelle qu'un processus utilise pour accéder au contenu du fichier. Elle peut représenter le fichier complet ou une partie seulement. En d'autres termes, une vue est un pointeur sur un fragment du fichier chargé dans la mémoire du processus.

Sans grande surprise, le but va être de lancer plusieurs connexions Internet simultanément et à travers chacune d'elles de télécharger un fragment du fichier.

Chaque connexion est réalisée dans un thread séparé (TViewDownloadThread). Ils sont créés au démarrage et synchronisés par Events.

Un thread principal (TDownloadThread) se charge de répartir le travail en fonction de l'occupation des threads de téléchargement.

Le téléchargement est réalisé à l'aide du composant INDY : TIdHttp.

Le nombre de tâches peut être supérieur au nombre de processeurs de la machine. On peut en effet partir du principe que le dialogue client/serveur à travers Internet est lent et que chaque thread passera un certain temps à attendre des réponses.

Il y a cependant certaines limitations qu'il serait inutile de dépasser :

• une vue ne peut pas commencer à n'importe quel endroit d'un fichier mappé, elle doit respecter un alignement déterminé par le système. Cet alignement est récupéré à l'aide de l'API GetNativeSystemInfo. Il correspond à la « granularité d'allocation » et est normalement de 64 kB sous Windows.
  Dès lors, le nombre de threads ne devrait excéder : la taille du fichier à télécharger div 64 kB + 1. Si le fichier faisait 200 kB, le nombre de threads utilisés serait de quatre, même si on en créait dix.
  Dans notre exemple, la taille d'un bloc sera fixée à 15 fois l'allocation minimale. Un thread téléchargera donc environ 975 kB ce qui est un bon compromis entre l'alignement obligatoire des vues et le temps de latence. Il faudra cependant réduire ce multiplicateur si le débit de la connexion Internet est inférieur à 15 Mb/s.
  
  Voici comment récupérer la taille d'allocation minimale :

var
  SystemInfo :TSystemInfo;
  AllocSize  :Int64;
 
begin
  GetNativeSystemInfo(SystemInfo);
  AllocSize := SystemInfo.dwAllocationGranularity;
end;

• la vitesse de la connexion Internet (downstream). 10 Mb/s permettraient dans le meilleur des cas une quinzaine de threads si 64 kB était utilisé ;
• la qualité du service fourni par l'hébergeur du site. Limite de bande passante et du nombre de connexions concurrentes, temps de latence, etc. Certains serveurs n'acceptent tout simplement pas le téléchargement par fragment !

Créer plus de tâches que nécessaire a cependant un impact négligeable sur la fonction proposée ci-dessous. Les inutilisées sont placées en mode attente infinie par WaitForSingleObject(INFINITE) et ne consomment par conséquent aucun temps processeur.

Les tâches de téléchargement sont en charge de récupérer un fragment du fichier. Elles pourraient être créées uniquement lorsqu'un nouveau bloc est requis. Ici, elles sont créées une fois pour toutes au démarrage et synchronisées par Events.

Type
  TViewDownloadThread = class(TThread)
  private
    URL         :string;
    MapFile     :THandle;
    View        :TViewInfo;
 
    Stream      :TMemoryStream;
    Http        :TIdHttp;
    RunEvent    :THandle;
    ReadyEvent  :Thandle;
  end;

• URL est le fichier à télécharger.
• MapFile est le fichier mappé auquel nous appliquerons une vue.
• View est une structure contenant l'offset et la taille du bloc à télécharger.
• Stream est le buffer de téléchargement.
• Http est un TidHttp en charge de la connexion au serveur.
• RunEvent est un Event local ordonnant le démarrage de la fonction en attente.
• ReadyEvent est un Event fourni par le thread principal et signifie la fin du téléchargement du bloc et l'état prêt pour une nouvelle commande.

TViewInfo est déclaré ainsi :

  TViewInfo = record
    Size :int64;
 
    case byte of
      0 : (Offset :int64);
      1 : (LoOffset, HiOffset :integer);
  end;

Size est la taille du bloc à télécharger. Le case permet de lire/écrire l'offset sous forme d'un int64 ou de deux entiers LowInteger et HighInteger sans devoir appliquer de transformation. MapViewOfFile que nous utiliserons bientôt requiert la deuxième forme.

V-A. Création et destruction▲

constructor TViewDownloadThread.Create(aURL :string; aMapFile, aReadyEvent :THandle; aOnTerminate :TNotifyEvent);
begin
  inherited Create;
 
  URL         := aURL;
  MapFile     := aMapFile;
  ReadyEvent  := aReadyEvent;
  OnTerminate := aOnTerminate;
 
  RunEvent    := CreateEvent(nil, TRUE, FALSE, nil);
  Stream      := TMemoryStream.Create;
  Http        := TIdHTTP.Create(nil);
 
  HTTP.Request.Connection := 'keep-alive';
  Http.Request.UserAgent  := UserAgent;
 
  //Libération automatique
  FreeOnTerminate := TRUE;
end;

destructor TViewDownloadThread.Destroy;
begin
  CloseHandle(RunEvent);
  Stream.Free;
  Http.Free;
 
  inherited;
end;

V-B. Start▲

procedure TViewDownloadThread.Start(aOffset, aSize: int64);
begin
  View.Offset := aOffset;
  View.Size   := aSize;
 
  //Occupé et démarré
  ResetEvent(ReadyEvent);
  SetEvent(RunEvent);
end;

V-C. Stop▲

procedure TViewDownloadThread.Stop;
begin
  Terminate;
  SetEvent(RunEvent);
end;

V-D. Execute▲

procedure TViewDownloadThread.Execute;
var
  Data :pointer;
 
begin
  while not Terminated do
  begin
    //Attente infinie de l'ordre de démarrage
    WaitForSingleObject(RunEvent, INFINITE);
 
    if not Terminated then
    try
      ReturnValue := ERROR_FILE_NOT_FOUND;
 
      Stream.Clear;
 
      //Télécharge un bloc
      Http.Request.Range := Format('%d-%d',[View.Offset, View.Offset +View.Size -1]);
      Http.Get(URL, Stream);
 
      //Ouvre en écriture la vue correspondante du fichier local
      Data := MapViewOfFile(MapFile, FILE_MAP_WRITE, View.HiOffset, View.LoOffset, View.Size);
 
      if not Assigned(Data) then
      begin
        ReturnValue := GetLastError;
        Exit;
      end;
 
      //Copie les données et libère la vue
      CopyMemory(Data, Stream.Memory, View.Size);
      UnmapViewOfFile(Data);
 
      ReturnValue := ERROR_SUCCESS;
 
    finally
      //Arrêté et prêt
      ResetEvent(RunEvent);
      SetEvent(ReadyEvent);
    end;
  end;
end;

Le thread principal se charge de l'accès au fichier local, de la gestion des threads de téléchargement et de la notification d'avancement.

Voici la déclaration de ses propriétés :

type
  TDownloadThread = class(TThread)
  private
    Wnd         :hWnd;
    Message     :Cardinal;
    URL         :string;
    FileName    :TFileName;
    FileSize    :int64;
    AllocSize   :int64;
    ThreadCount :integer;
    Error       :boolean;
end;

• Wnd et Message vont nous permettre d'envoyer des informations sur l'état du téléchargement par PostMessage. Message peut correspondre à une constante WM_USER ou à un message enregistré par RegisterWindowMessage.
• URL est bien entendu le fichier à télécharger et FileName le fichier local. L'URL doit commencer par « http:// ».
• FileSize est la taille totale du fichier.
• AllocSize est la taille d'un fragment de ce fichier.
• ThreadCount est le nombre de threads à utiliser.
• Error est un booléen passant à VRAI si une erreur est rencontrée dans la tâche principale ou dans celles de téléchargement.

En plus de ces propriétés, la variable TThread.ReturnValue est utilisée et contient l'état du téléchargement. ERROR_SUCCESS en cas de réussite, le code d'erreur d'une API ayant échoué ou ERROR_FILE_NOT_FOUND si le fichier distant n'a pu être localisé. ReturnValue est utilisé pour notifier l'erreur à l'utilisateur.

VI-A. Création▲

constructor TDownloadThread.Create(aWnd :hWnd; aMessage :Cardinal; aURL :string; aFileName :TFileName; aThreadCount :integer);
var
  SystemInfo :TSystemInfo;
 
begin
  inherited Create;
 
  Wnd      := aWnd;
  URL      := aURL;
  Message  := aMessage;
  FileName := aFileName;
  Error    := FALSE;
 
  //Fixe le nombre de threads à utiliser
  if aThreadCount > 0
  then ThreadCount := aThreadCount
  else ThreadCount := CPUCount *2;
 
  //Fixe la taille d'allocation minimale définie par le système
  GetNativeSystemInfo(SystemInfo);
  AllocSize := SystemInfo.dwAllocationGranularity *15;
 
  //Libération automatique
  FreeOnTerminate := TRUE;
end;

VI-B. Notification▲

type
  TFastURLDownloadState = (dsStart, dsIncrement, dsError, dsSuccess);
 
procedure TDownloadThread.Notify(aState: TFastURLDownloadState; aLParam: LParam);
begin
  PostMessage(Wnd, Message, WParam(aState), aLParam);
end;

VI-C. OnTerminate▲

procedure TDownloadThread.OnThreadTerminate(Sender: TObject);
begin
  with TThread(Sender) do
    if ReturnValue <> ERROR_SUCCESS then
    begin
      Error := TRUE;
      Notify(dsError, ReturnValue);
    end;
end;

VI-D. Informations sur le fichier et serveur distants▲

procedure TDownloadThread.GetFileInfo;
begin
  //Récupère la taille du fichier et la capacité du serveur
  //en ne téléchargeant que l'entête
  try
    with TIdHTTP.Create(nil) do
    try
      Request.UserAgent := UserAgent;
      Head(Self.URL);
 
      FileSize     := Response.ContentLength;
      AcceptRanges := Response.AcceptRanges = 'bytes';
    finally
      Free;
    end;
  except
    Notify(dsError, ERROR_FILE_NOT_FOUND);
    Raise;
  end;
end;

VI-E. Téléchargement simple▲

procedure TDownloadThread.SingleDownload;
var
  Stream :TFileStream;
 
begin
  //Création du fichier local. "Accès refusé" si impossible
  try
    Stream := TFileStream.Create(FileName, fmCreate);
  except
    Notify(dsError, ERROR_ACCESS_DENIED);
    Raise;
  end;
 
  //Téléchargement
  try
    with TIdHTTP.Create(nil) do
    try
      Request.UserAgent := UserAgent;
      Get(Self.URL, Stream);
    finally
      Stream.Free;
      Free;
    end;
 
  except
    Notify(dsError, ERROR_FILE_NOT_FOUND);
    Raise;
  end;
end;

VI-F. Téléchargement multiple▲

procedure TDownloadThread.MultiDownload;
var
  FHandle    :hFile;
  hMap       :THandle;
  Offset     :int64;
  Size       :int64;
  Position   :int64;
  WaitState  :dword;
  i          :integer;
 
  ThreadList :array of TViewDownloadThread;
  ReadyList  :array of THandle;

FHandle := CreateFile(PChar(FileName), FILE_READ_DATA or FILE_WRITE_DATA, 0, nil, CREATE_ALWAYS, 0, 0);
 
SetFilePointerEx(FHandle, FileSize, nil, FILE_BEGIN);
SetEndOfFile(FHandle);
 
hMap := CreateFileMapping(FHandle, nil, PAGE_READWRITE, 0, 0, nil);

SetLength(ReadyList, ThreadCount);
SetLength(ThreadList, ThreadCount);
 
for i := 0 to ThreadCount -1 do
begin
  ReadyList[i]  := CreateEvent(nil, TRUE, TRUE, nil);
  ThreadList[i] := TViewDownloadThread.Create(URL, hMap, ReadyList[i], OnThreadTerminate);
end;

while not (Terminated or Error) do
begin
  WaitState := WaitForMultipleObjects(ThreadCount, @ReadyList[0], FALSE, 1000);
 
  if WaitState <> WAIT_TIMEOUT then
  begin
    i    := WaitState -WAIT_OBJECT_0;
    Size := Min(FileSize -Offset, AllocSize);
 
    if Size > 0 then
    begin
      ThreadList[i].Start(Offset, Size);
      inc(Position, Size);
      Notify(dsIncrement, Position);
    end;
 
    if Size < AllocSize
    then Break
    else inc(Offset, AllocSize);
  end;
end;

WaitForMultipleObjects(ThreadCount, @ReadyList[0], TRUE, INFINITE);

for i := 0 to ThreadCount -1 do
begin
  ThreadList[i].Stop;
  CloseHandle(ReadyList[i]);
end;
 
CloseHandle(hMap);
CloseHandle(FHandle);
 
if Error then
  DeleteFile(FileName);

procedure TDownloadThread.MultiDownload;
var
  FHandle    :hFile;
  hMap       :THandle;
  Offset     :int64;
  Size       :int64;
  Position   :int64;
  WaitState  :dword;
  i          :integer;
 
  ThreadList :array of TViewDownloadThread;
  ReadyList  :array of THandle;
 
  //-----------------------------------
  procedure CheckError(aCheck :boolean);
  begin
    if not aCheck then
    begin
      Notify(dsError, GetLastError);
      Abort;
    end;
  end;
  //-----------------------------------
 
begin
  Offset   := 0;
  Position := 0;
 
  //Création du fichier local
  FHandle := CreateFile(PChar(FileName), FILE_READ_DATA or FILE_WRITE_DATA, 0, nil, CREATE_ALWAYS, 0, 0);
  CheckError(FHandle <> INVALID_HANDLE_VALUE);
 
  try
    //Fixe sa taille à la taille finale
    CheckError(SetFilePointerEx(FHandle, FileSize, nil, FILE_BEGIN));
    CheckError(SetEndOfFile(FHandle));
 
    //Création du fichier mappé
    hMap := CreateFileMapping(FHandle, nil, PAGE_READWRITE, 0, 0, nil);
    CheckError(hMap <> 0);
 
    try
      //Création des Threads et Events de téléchargement
      SetLength(ReadyList, ThreadCount);
      SetLength(ThreadList, ThreadCount);
 
      for i := 0 to ThreadCount -1 do
      begin
        ReadyList[i]  := CreateEvent(nil, TRUE, TRUE, nil);
        ThreadList[i] := TViewDownloadThread.Create(URL, hMap, ReadyList[i], OnThreadTerminate);
      end;
 
      try
        //Téléchargement
        while not (Terminated or Error) do
        begin
          //Attend qu'au moins un Thread soit à l'état prêt
          WaitState := WaitForMultipleObjects(ThreadCount, @ReadyList[0], FALSE, 1000);
 
          if WaitState <> WAIT_TIMEOUT then
          begin
            i    := WaitState -WAIT_OBJECT_0;
            Size := Min(FileSize -Offset, AllocSize);
 
            //Le redémarre avec le prochain bloc
            if Size > 0 then
            begin
              ThreadList[i].Start(Offset, Size);
              inc(Position, Size);
              Notify(dsIncrement, Position);
            end;
 
            //Si la taille est plus petite que la taille d'allocation
            //=> fin du téléchargement
            if Size < AllocSize
            then Break
            else inc(Offset, AllocSize);
          end;
        end;
 
        //Attend que tous les Threads aient terminé
        if not Error then
          WaitForMultipleObjects(ThreadCount, @ReadyList[0], TRUE, INFINITE);
 
      finally
        //Libération des Threads et Events
        for i := 0 to ThreadCount -1 do
        begin
          ThreadList[i].Stop;
          CloseHandle(ReadyList[i]);
        end;
      end;
 
    finally
      //Libération du fichier mappé
      CloseHandle(hMap);
    end;
 
  finally
    //Libération du fichier local
    CloseHandle(FHandle);
 
    //Efface le fichier incomplet en cas d'erreur
    if Error then
      DeleteFile(FileName);
  end;
end;

VI-G. Execute▲

procedure TDownloadThread.Execute;
var
  StartTime :Cardinal;
 
begin
  //Informations sur le fichier et la capacité du serveur
  GetFileInfo;
 
  //Contrôle le nombre de Threads à utiliser
  if ThreadCount > 1 then
  begin
    if AcceptRanges and (FileSize > AllocSize)
    then ThreadCount := Min(ThreadCount, FileSize div AllocSize)
    else ThreadCount := 1;
  end;
 
  Notify(dsStart, FileSize);
 
  StartTime := GetTickCount;
 
  //Téléchargement
  if ThreadCount > 1
  then MultiDownload
  else SingleDownload;
 
  //Si pas eu d'erreur avant
  Notify(dsSuccess, GetTickCount -StartTime);
end;

FastURLDownload est la procédure accessible depuis l'extérieur de l'unité utilisée pour lancer le téléchargement.

procedure FastURLDownload(aWnd :hWnd; aMessage :Cardinal; aURL :string; aFileName :TFileName; aThreadCount :integer = 0);

• aWnd est la fenêtre devant recevoir les notifications d'avancement.
• aMessage est le message à envoyer. Cela peut être une constante WM_USER ou un message enregistré par RegisterWindowMessage.
• aURL est le fichier à télécharger. aURL doit commencer par « http:// »
• aFileName est le fichier local.
• aThreadCount est le nombre de tâches de téléchargement simultanées désirées. Si 0, il correspond au nombre de processeurs disponibles sur la machine x 2.

Et voici comment appeler cette procédure dans votre application.

procedure TForm1.Button1Click(Sender: TObject);
begin
  FastURLDownload(Handle, WM_USER, 'http://www.domaine.com/fichier.exe', 'c:\RépertoireLocal\fichier.exe', CPUCount *3);
end;

Et pour recevoir les notifications, une fiche contenant un mémo et une barre de progression.

type
  TForm1 = class(TForm)
    Memo1: TMemo;
    ProgressBar1: TprogressBar;
  protected
    procedure WMFastDownloadNotify(var Message :TMessage); message WM_USER;
  end;
 
procedure TForm1.WMFastDownloadNotify(var Message: TMessage);
begin
  with Message do
    case TFastURLDownloadState(WParam) of
      dsStart     : //Démarrage
                    begin
                      Memo1.Lines.Add('Téléchargement commencé à ' +DateTimeToStr(Now));
                      Memo1.Lines.Add(Format('Taille du fichier : %d octets', [LParam]));
                      ProgressBar1.Max := LParam;
                      ProgressBar1.Position := 0;
                    end;
 
      dsIncrement : //Incrémentation
                    ProgressBar1.Position := LParam;
 
      dsError     : //Erreur
                    Memo1.Lines.Add(Format('Erreur %d : %s', [LParam, SysErrorMessage(LParam)]));
 
      dsSuccess   : //Terminé avec succès
                    Memo1.Lines.Add(Format('Téléchargement terminé en %fs', [LParam /1000]));
    end;
end;

Simple non ?

Voici quelques mesures réalisées à partir de deux sites différents. Le fichier est identique et correspond à la version Delphi 6 Perso. Sa taille est de 146 646 147 octets.

Le premier site est bien sûr Developpez.net. Le deuxième est hébergé chez Infomaniak.

Ces mesures sont faites sur une modeste machine bicœur tournant à 2 GHz et le débit descendant de la connexion Internet est de 50 Mb/s.

Les tableaux indiquent :

• le nombre de tâches utilisées, soit le nombre de connexions concurrentes ;
• la charge moyenne du système (en pour cent) ;
• le débit Internet maximum (en Mb/s) ;
• le temps total (en secondes).

Une tâche équivaut au téléchargement « simple ». Deux et plus au téléchargement « multiple ».

Accrochez-vous, ça va décoiffer !

Infomaniak :

Quatre tâches suffisent pour atteindre le débit maximum de 50 Mb/s.

Voici les graphiques de l'activité des processeurs et du débit :

Deux tâches	Quatre tâches (débit max)

Developpez.net :

La bande passante est plus limitée sur le site de DVP. Douze tâches sont nécessaires pour atteindre le débit maximum et l'activité des cœurs est proche de la saturation.

Les graphiques correspondants :

Deux tâches	Douze tâches (débit max)

Ces mesures permettent de constater que la limitation se situe principalement au niveau du débit descendant mais confirment également, si on en doutait encore, que la charge CPU dépend fortement du nombre de tâches en cours.

Elles permettent aussi accessoirement de constater les différences entre hébergeurs ; la qualité de leurs services. Alors qu'il ne faut que quatre tâches chez Infomaniak pour atteindre le débit maximum, douze sont nécessaires chez l'hébergeur DVP. À certaines heures, il a même fallu monter à vingt-six (je le rappelle, sur un PC bicœur) ! Le temps de téléchargement par un seul thread était alors de 499 secondes, mais… il était toujours possible de télécharger à 50 Mb/s !

Nous remarquons également que les connexions multiples ne sont d'aucune utilité chez Infomaniak si vous ne disposez que d'un accès Internet à 10 Mb/s puisque la limite de débit est supérieure à 12.

À noter encore qu'un test chez free.fr s'est révélé catastrophique ! L'impossibilité d'avoir plus de trois tâches concurrentes et un temps de latence exécrable rendent le téléchargement monothread plus rapide !

Nous arrivons au bout de ce tutoriel.

Le principe évoqué ici pourrait bien sûr encore être amélioré avec création des threads en fonction du débit mesuré et inclure des fonctions Suspend/Resume avec sauvegarde de l'avancement pour une reprise après redémarrage ou une plus grande tolérance aux erreurs. Un véritable Download Manager !

La source de l'unité FastURLDownload.pas est téléchargeable au format zip.

FastURLDownloads.zip

Sur ce et en espérant vous avoir intéressé, Andnotor vous souhaite le bonjour ;-)

Un grand merci à ClaudeLELOUP pour la relecture orthographique.

DVP : HTTP, le protocole du Web passé en revue - Transactions partielles (par Julien Pauli)

MSDN : File Mapping

MSDN : Events

MSDN : SetFilePointerEx

MSDN : SetEndOfFile