Prise en charge de l'allocation dynamique – Détection de fuites et schéma de conception Observateur

Imaginons que nous ayons un singleton responsable de la comptabilité de la mémoire allouée dynamiquement. Cet objet est en mesure d'offrir un certain nombre de services intéressants à un programme, mais il est impossible de prévoir a priori tous les usages envisageables par tous les programmes possibles.

Il est possible, par exemple, qu'un éventuel programme désire vérifier si certaines allocations dynamiques de mémoire dépassent un certain seuil. Si un programme est conçu de manière telle qu'il ne soit pas supposé d'y apparaître de requêtes d'allocation dynamique de mémoire dépassant 1 Ko, alors on voudrait pouvoir réagir aux demandes d'allocation dynamique de mémoire et détecter celles qui ne nous conviennent pas.

En acceptant que nous ne pouvons pas prévoir au préalable tous les besoins éventuels de tous les programmes sujets à être clients de nos serveurs, il nous faut examiner des stratégies pour que le code client puisse s'abonner aux services de notre serveur et être informé de l'occurrence d'événements lui semblant pertinents.

Le schéma de conception Observateur

Le schéma de conception Observateur remplit ce mandat. Nous verrons ici comment il serait possible de l'appliquer à notre système de comptabilité.

Son objectif est de permettre à des objets clients de s'abonner pour être informés lors de l'occurrence d'événements dans un objet serveur.

Ses éléments clés sont :

• La présence d'au moins une interface de signalement. Tout client désireux d'être informé de l'occurrence d'un événement supporté par le serveur devra dériver de cette interface (le rappel fait par le serveur sera alors polymorphique et permettra à tout client de réagir comme bon lui semble)
• L'intégration à un serveur d'un mécanisme d'abonnement et de désabonnement, ce qui permettra à un client de s'abonner et de se désabonner du service au moment lui semblant opportun
• L'intégration à un serveur d'au moins un conteneur pour se souvenir des abonnés à rappeler
• L'ajout dans les méthodes réagissant à un événement côté serveur d'une séquence de rappel des méthodes appropriées chez les abonnés

Les dangers du schéma de conception Observateur tiennent de la relation organique entre serveur et clients. Le serveur rappelant les clients, ses performances sont a priori dépendantes de la qualité du code client dans les méthodes rappelées.

Modifications apportées à Allocation.h

#ifndef ALLOCATION_H
#define ALLOCATION_H

#include <vector>
#include <algorithm>
#include <cassert>

void* operator new(std::size_t);
void* operator new[](std::size_t);
void operator delete(void*);
void operator delete[](void*);

class ComptableMemoire {
public:
   ComptableMemoire(const ComptableMemoire&) = delete;
   ComptableMemoire& operator=(const ComptableMemoire&) = delete;
   using value_type = long long;
   struct Rappelable {
      virtual void sur_allocation(size_t) {
      }
      virtual void sur_deallocation(size_t) {
      }
      virtual ~Rappelable() = default;
   };

Remarquez la présence d'un destructeur virtuel dans l'interface ComptableMemoire::Rappelable. Comme il se doit avec des classes à vocation polymorphique (donc exposant au moins une méthode virtuelle), donc sujettes à servir de devanture polymorphiques pour des instances de classes en dérivant, il est sage de définir un destructeur virtuel pour assurer la bonne libération des ressources lors de l'éventuelle destruction des abonnés.

Remarquez aussi le choix fait de définir des corps par défaut pour les méthodes de cette interface plutôt que de les laisser abstraites. L'idée ici est qu'il est tout à fait envisageable qu'un dérivé de ComptableMemoire::Rappelable souhaite surveiller les allocations de mémoire mais ne soit pas préoccupé par les libérations de mémoire; ainsi, en offrant des corps par défaut, on offre aussi un comportement par défaut (ne rien faire) ce qui allège la tâche des développeurs.

private:
   std::vector<Rappelable *> abonnes;
   static ComptableMemoire singleton;
   value_type alloue = {};
   ComptableMemoire() = default;
   void fuite();
   void surliberation();

// ...
   class RappelerAllocation {
      size_t qte;
   public:
      RappelerAllocation(size_t qte) noexcept : qte{ qte } {
      }
      void operator()(Rappelable *p) {
         p->sur_allocation(qte);
      }
   };
   class RappelerDeallocation {
      size_t qte;
   public:
      RappelerDeallocation(size_t qte) noexcept : qte{ qte } {
      }
      void operator()(Rappelable *p) {
         p->sur_deallocation(qte);
      }
   };

public:
   void abonner(Rappelable *p) {
      assert(p);
      abonnes.push_back(p);
   }
   void desabonner(Rappelable *p) {
      using namespace std;
      assert(p);
      abonnes.erase(find(begin(abonnes), end(abonnes), p));
      // abonnes.shrink_to_fit(); // si besoin est
   }

   void allocation(size_t n) {
      using namespace std;
      alloue += n;
      for(auto p : abonnes_)
         p->sur_allocation(n);
   }
   void deallocation(size_t n) {
      using namespace std;
      for(auto p : abonnes_)
         p->sur_deallocation(n);
      alloue -= n;
      if (combien() < 0) surliberation();
   }
   value_type combien() const noexcept {
      return alloue;
   }
   static ComptableMemoire &get() noexcept {
      return singleton;
   }
   ~ComptableMemoire() {
      if (combien()) fuite();
   }
   class TraceurLocalSimplet {
      value_type avant;
   public:
      TraceurLocalSimplet() noexcept : avant{ComptableMemoire::get().combien()} {
      }
      ~TraceurLocalSimplet();
   };
};

#endif

Mise en application

#include "Allocation.h"
#include <iostream>
class SignalGrosseAllocation : public ComptableMemoire::Rappelable {
   size_t seuil;
   size_t tolerance() const noexcept {
      return seuil;
   }
public:
   SignalGrosseAllocation(size_t seuil) : seuil{ seuil } {
   }
   void sur_allocation(size_t n) {
      using namespace std;
      if (n > tolerance())
         cout << "Allocation suspecte de " << n << " bytes (tolérance: "
              << tolerance() << " bytes)." << endl;
   }
};

int main() {
   SignalGrosseAllocation sga{ 100 };
   ComptableMemoire::get().abonner(&sga);
   {
      ComptableMemoire::TraceurLocalSimplet tr;
      int *temp = new int[5];
      int *temp2 = new int{4};
      delete temp2;
   }
   int *p = new int{3};
   int *q = new int[50];
   delete p;
   ComptableMemoire::get().desabonner(&sga);
}

En pratique, il est parfois possible de ne pas se désabonner d'un service. Dans ce programme de démonstration, toutefois, ne pas se désabonner serait dangereux : l'abonné (la variable sga) mourra à l'accolade fermante de main() mais le singleton ComptableMemoire sera quant à lui détruit beaucoup plus tard et pourrait chercher à rappeler sga après que cette dernière ait été détruite.