Discussion :

[Repti]

Bonjour,

Voilà je développe actuellement une application de type VNC, avec affichage d'écran à distance. J'avais déjà un problème au niveau de la gestion mémoire serveur, mais maintenant c'est au niveau du client (celui qui affiche les images à distance) où la taille du processus en mémoire augmente constamment.

Donc en fait mes images sont envoyées d'un Composant StreamServer vers un StreamClient (NMStrm) . Quand celui-ci reçoit des données on execute ce code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
Affichage *thread_affiche = new Affichage(false,strm);
delete strm,thread_affiche;

Donc en fait j'ai modifié le constructeur du thread afin de passer en paramètre le flux entrant. Et voici le code du thread en lui même :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
TMemoryStream *flux;
 
 
 
__fastcall Affichage::Affichage(bool CreateSuspended,TStream *strm)
        : TThread(CreateSuspended)
{
FreeOnTerminate=true;
flux = new TMemoryStream();
flux->LoadFromStream(strm);
delete strm;
 
}
 
__fastcall Affichage::Affichage(bool CreateSuspended)
        : TThread(CreateSuspended)
{
}
 
 
void __fastcall Affichage::Execute()
 
{
TJPEGImage *affiche = new TJPEGImage();
affiche->LoadFromStream(flux);
delete flux;
Form12->PaintBox1->Canvas->Draw(0,0,affiche);
delete affiche;
Terminate();
 
}

Donc en fait le flux rentrant est chargé dans un objet de type JPG et ensuite affiché dans un Paintbox. je pense avoir bien libéré la mémoire a chaque étape quelqu'un aurait donc t-il une solution svp ? Merci d'avance !!

[DjmSoftware]

bonjour dans ton code,
il faut modifier plusieurs choses
ton thread se détruisant tout seul il n'est donc pas nécessaire de le détruire une seconde fois

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
Affichage *thread_affiche = new Affichage(false,strm); 
//delete strm,thread_affiche; // pas nécessaire car l thread se détruit tout seul

le problème avec la classe thread est que si dans le constructeur de ta nouvelle classe Thread le temps pasé dans le constructeur est plus grand que le temps dans le constructeur de la classe TThread ,la méthode Execute sera appelée avant la fin de la construction du constructeur de ta classe Affichage

la solution est de créer ta classe Affichage avec le paramètre CreateSuspended positionné à true

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
Affichage *thread_affiche = new Affichage(true,strm); 
delete strm;

dans la méthode Execute j'ai relevé 2 erreurs
la première est que tu appelles directement une méthode du Thread VCL Principal sans te soucier de la synchornisation cela peut provoquer de nombreuses erreurs
la seconde il n'est pas nécessaire d'appeler Terminate qui est une méthode qui va forcer le thread a sortir de la méthode Execute
d'autre part il est préférable pour des soucis de clareté de libérer la mémoire dans un destructeur
le code serait donc le suivant

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
 
 constructeur du thread
__fastcall Affichage::Affichage(bool CreateSuspended,TStream *strm) 
        : TThread(CreateSuspended) 
{ 
FreeOnTerminate=true; 
flux = new TMemoryStream(); 
flux->LoadFromStream(strm); 
Resume();  / la méthode execute est appellée
} 
 
void __fastcall Affichage::Execute() 
{ 
 TJPEGImage *affiche = new TJPEGImage(); 
 affiche->LoadFromStream(flux); 
 Synchronize(UpdateMAinForm);
}
 
void __fastcall Affichage::UpdateMAinForm()
{
  Form12->PaintBox1->Canvas->Draw(0,0,affiche); 
} 
 
fastcall Affichage::~Affichage()
{
    delete flux; 
}

cordialement

[Repti]

je te remercie pour ta réponse très complète et je vais tester tout ça Merci encore

[Repti]

Ca compile correctement, mais apparemment ce problème de mémoire n'est pas résolu car elle augmente incroyablement vite .

J'ai pourtant a priori bien détruit les objets et je ne vois pas trop d'où ça peut venir Est-ce que la destruction de ces objets peut être trop lente par rapport a l'execution d'un nouveau thread et qu'à force ça "s'empile" en mémoire ?

Encore merci pour votre aide.

[Repti]

Oki merci pour ta précision, mais je vais encore t'ennuyer malheureusement le TStream ne possède pas la methode Clear(), Commetn puis-je donc libérer la mémoire de l'objet strm ? je pense que le problème vient maintenant plus que de lui. Merci encore,

Cordialement

[DjmSoftware]

bonjour,
regarde ce code d'exemple

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
 
//---------------------------------------------------------------------------
// le .h de la Form Principale
#ifndef Unit1H
#define Unit1H
//---------------------------------------------------------------------------
#include <Classes.hpp>
#include <Controls.hpp>
#include <StdCtrls.hpp>
#include <Forms.hpp>
#include <ExtCtrls.hpp>
//---------------------------------------------------------------------------
class TForm1 : public TForm
{
__published:	// Composants gérés par l'EDI
        TPaintBox *PaintBox1;
        TButton *Button1;
        void __fastcall Button1Click(TObject *Sender);
private:
        void __fastcall CreateImage();	// Déclarations de l'utilisateur
public:		// Déclarations de l'utilisateur
        __fastcall TForm1(TComponent* Owner);
};
//---------------------------------------------------------------------------
extern PACKAGE TForm1 *Form1;
//---------------------------------------------------------------------------
#endif
// l'implémentation
 
//---------------------------------------------------------------------------
 
#include <vcl.h>
#pragma hdrstop
 
#include "Unit1.h"
#include "Unit2.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
        : TForm(Owner)
{
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Button1Click(TObject *Sender)
{
  Button1->Enabled=false;
  CreateImage();
}
//---------------------------------------------------------------------------
 
void __fastcall TForm1::CreateImage()
{
  TMemoryStream* Stm= new TMemoryStream(); // creation du Stream
  Stm->LoadFromFile("d:\\download\\bac.jpg"); // chargement d'une Immage
  TAffiche* Affiche= new TAffiche(true,Stm);// création et exécution de la classe Taffche
  delete Stm;// suppression du Thread
}
 
// le .h de la classe TAffiche
//---------------------------------------------------------------------------
 
#ifndef Unit2H
#define Unit2H
//---------------------------------------------------------------------------
#include <Classes.hpp>
#include <Jpeg.hpp>
//---------------------------------------------------------------------------
class TAffiche : public TThread
{            
private:
    TMemoryStream * Fflux;
    TJPEGImage *Faffiche;
    void __fastcall UpdateMainForm();
protected:
        void __fastcall Execute();
public:
        __fastcall TAffiche(bool CreateSuspended,TStream *strm);
        __fastcall ~TAffiche();
};
//---------------------------------------------------------------------------
#endif
 
// son Implémentation
//---------------------------------------------------------------------------
 
#include <vcl.h>
#pragma hdrstop
 
#include "Unit2.h"
#include "Unit1.h"
#pragma package(smart_init)
//---------------------------------------------------------------------------
 
//   Important : les méthodes et les propriétés des objets de la VCL ne peuvent être
//   utilisées que dans une méthode appelée en utilisant Synchronize, comme :
//
//      Synchronize(UpdateCaption);
//
//   où UpdateCaption serait de la forme :
//
//      void __fastcall TAffiche::UpdateCaption()
//      {
//        Form1->Caption = "Mise à jour dans un thread";
//      }
//---------------------------------------------------------------------------
 
__fastcall TAffiche::TAffiche(bool CreateSuspended,TStream *strm)
        : TThread(CreateSuspended)
{
  FreeOnTerminate=true;
  Fflux = new TMemoryStream();
  Fflux->LoadFromStream(strm);
  Resume();
}
//---------------------------------------------------------------------------
void __fastcall TAffiche::Execute()
{
 Faffiche = new TJPEGImage();
 Faffiche->LoadFromStream(Fflux);
 Synchronize(UpdateMainForm);
}
//---------------------------------------------------------------------------
void __fastcall TAffiche::UpdateMainForm()
{
  Form1->PaintBox1->Canvas->Draw(0,0,Faffiche);
  Form1->Button1->Enabled=true;
}
 
//---------------------------------------------------------------------------
 
__fastcall TAffiche::~TAffiche()
{
  delete Fflux;
  delete Faffiche;      //TODO: Add your source code here
}

La classe TStream est la classe de Base des Stream elle comporte des méthodes virtuelles
tu employe un TMemoryStream qui est un descendant de cette classe

concernant mon post précédent j'ai eu des problèmes de mémoires sur mon PC

JEG a parfaitement raison le fait de détruire le TMemoryStream libére la mémoire associée
cordialement

[Repti]

Oki parfait j'ai testé ça marche merci pour toutes ces réponses c'est super cool !