Speicher läuft voll bei WMI....

[delphin06]

Verdammte kacke es ist wirklich das setlength()

Hier is die problematische Funktion in der WMI.pas:

Delphi-Quellcode:

 Function TWMIClass.Query(Const Query: WideString): Boolean;
    Var WMIObjectSet: ISWbemObjectSet;
      WMIProp: ISWbemProperty;
      Enum, PropEnum: IEnumVariant;
      WMIObject: OleVariant;
      Instance, Prop: Integer;
      W: LongWord;

    Begin
      Result := True;
      ClearResults;
      Try
        If CompareStringW(LOCALE_USER_DEFAULT, NORM_IGNORECASE, 'SELECT', 6, PWideChar(Query), 6) <> 2 Then
          WMIObjectSet := _WMIServices.InstancesOf(Query, wbemFlagReturnImmediately or wbemQueryFlagShallow, nil)
        Else WMIObjectSet := _WMIServices.ExecQuery(Query, 'WQL', wbemFlagReturnImmediately, nil);
        SetLength(_WMIResults.Instance, WMIObjectSet.Count);
        If _WMIResults.Instance = nil Then Exit;
        Enum := (WMIObjectSet._NewEnum) as IEnumVariant;
        Instance := 0;
        While Enum.Next(1, WMIObject, W) = S_OK do Begin
          PropEnum := ISWbemPropertySet((IUnknown(WMIObject) as ISWbemObject).Properties_)._NewEnum as IEnumVariant;
          Prop := 0;
          If Instance > 0 Then SetLength(_WMIResults.Instance[Instance].PropValue, Length(_WMIResults.PropName));
          While PropEnum.Next(1, WMIObject, W) = S_OK do Begin
            WMIProp := IUnknown(WMIObject) as ISWbemProperty;
            If Instance = 0 Then Begin
              SetLength(_WMIResults.PropName, Prop + 1);
              SetLength(_WMIResults.Instance[Instance].PropValue, Prop + 1);
              _WMIResults.PropName[Prop] := WMIProp.Name;
            End;
            _WMIResults.Instance[Instance].PropValue[Prop] := WMIProp;
            Inc(Prop);
          End;
          Inc(Instance);
        End;
      Except
        Result := False;
        If ExceptObject is Exception Then _LastError := Exception(ExceptObject).Message
        Else _LastError := 'Unknown Error: ' + ExceptObject.ClassName;
      End;
    End;

3 mal ein aufruf von setlength() und jedesmal wenn setlength() aufgerufen wird erhöt sich der speicherbedarf und wir nicht wieder frei! Es muss doch eine möglichkeit geben das zu beheben!

[EDIT] Hab mich geirrt! nur bei dem ersten aufruf von setlegth steigt bei mir der speicher...kommt schon leute helft mir^^

[RWarnecke]

Ich habe mir das ganze gerade mal angeschaut. Nicht nur der erste SetLength - Befehl schnappt bei mir mehr Speicher weg (ca. 8KB bis 20 KB), sondern auch die beiden while-Schleifen.

Nur warum das ganze so ist, verstehe ich auch nicht.

[Luckie]

SetLength(_WMIResults.PropName, Prop + 1); Du vergrößerst das dynamische Array immer um eins. Das ist schlecht, weil intern passiert folgendes: Es wird neuer Soeicher alloziiert und dann der Inhalt des alten Arrays in den neuen Speicherbereich kopert. Der Speicherbereich des alten Arrays gibt der Speichermanager von Delphi aber nicht frei. Deswegen möglichst vor der Schleife das Array so groß machen wie nötig und nicht in der Schleife immer um eins vergrößern. Ist das Array zu klein, gleich um ca. 20% vergrößern und noch mal probieren, ob es passt. Und am Ende dann auf die tatsächich benötigte Größe zurücksetzen. Das erspart eine unnötige Speicherreservierung.

[delphin06]

Stimmt du hast recht.

[EDIT] hab mal n bisschen rumprobiert mit festen größen und so aber irgendwo kommt da immer wieder speicher hinzu...
Könnte ich den kompletten WMI Teil nicht in eine extra anwendung packen und diese dann nach dem aufruf wieder beenden? dann wäre ja der speicher komplett freigegeben oder?

[RWarnecke]

Delphi-Quellcode:

        While Enum.Next(1, WMIObject, W) = S_OK do Begin
          PropEnum := ISWbemPropertySet((IUnknown(WMIObject) as ISWbemObject).Properties_)._NewEnum as IEnumVariant;
          Prop := 0;
          If Instance > 0 Then SetLength(_WMIResults.Instance[Instance].PropValue, Length(_WMIResults.PropName));
          While PropEnum.Next(1, WMIObject, W) = S_OK do Begin
            WMIProp := IUnknown(WMIObject) as ISWbemProperty;
            If Instance = 0 Then Begin
              SetLength(_WMIResults.PropName, Prop + 1);
              SetLength(_WMIResults.Instance[Instance].PropValue, Prop + 1);
              _WMIResults.PropName[Prop] := WMIProp.Name;
            End;
            _WMIResults.Instance[Instance].PropValue[Prop] := WMIProp;
            Inc(Prop);
          End;
          Inc(Instance);
        End;

Beim ersten Durchlauf wird die Anzahl der Properties ermittelt. Denn beim zweiten Durchlauf werden die beiden SetLength-Befehl nichtmehr ausgeführt. Es muss doch eine andere Möglichkeit geben an die Anzahl der Properties zu kommen.

Edit:
Ich habe die While-Schleife mal so abgeändert :

Delphi-Quellcode:

        While Enum.Next(1, WMIObject, W) = S_OK do Begin
          PropEnum := ISWbemPropertySet((IUnknown(WMIObject) as ISWbemObject).Properties_)._NewEnum as IEnumVariant;
          Prop := 0;
          SetLength(_WMIResults.PropName, ISWbemPropertySet((IUnknown(WMIObject) as ISWbemObject).Properties_).Count);
          SetLength(_WMIResults.Instance[Instance].PropValue, ISWbemPropertySet((IUnknown(WMIObject) as ISWbemObject).Properties_).Count);
          While PropEnum.Next(1, WMIObject, W) = S_OK do Begin
            WMIProp := IUnknown(WMIObject) as ISWbemProperty;
            _WMIResults.PropName[Prop] := WMIProp.Name;
            _WMIResults.Instance[Instance].PropValue[Prop] := WMIProp;
            Inc(Prop);
          End;
          Inc(Instance);
        End;

Funktionieren tut es genauso, wie die anderen beiden While-Schleife. Ich hatte aber gedacht, dass wenn ich von Anfang an einen festen Wert zuweise das Speicherproblem gelöst wäre. Ist aber nicht so.

Edit 2:
Sourcecode aus Edit 1 korrigiert.

[OldGrumpy]

Zitat von Luckie:

Es wird neuer Soeicher alloziiert und dann der Inhalt des alten Arrays in den neuen Speicherbereich kopert. Der Speicherbereich des alten Arrays gibt der Speichermanager von Delphi aber nicht frei.

Dumme Frage: Kann man das Speicherleck irgendwie "manuell" stopfen?

[delphin06]

Ich versteh das alles nich mehr...ich habe den WMI teil jez mal in eine DLL gepackt, die ich dann nachher wieder lade aber irgendwie hat sich nichts geändert...warum?

Hier mal der code der dll:

Delphi-Quellcode:

library WMICall_DLL;

uses
  Sharemem, SysUtils,
  Classes,
  WMIfunctions in 'WMIfunctions.pas';

type 
  Twmistring = array [0..30] of array [0..7] of String;

{$R *.res}

function getwmiinfo(comp, namespace, username, pass, query: String; vista: Boolean):Twmistring;
Var WMIResults: TWMIInfo;
    i, i2: Integer;
    wmidrives:Twmistring;
begin
  {
  Instance
  Caption
  DeviceID
  Partitions
  SerialNumber
  Signature
  Size
  }

  if not WMIGetInfo(comp, namespace, username, pass, Trim(query), WMIResults) then
    begin
      wmidrives[0,0] := 'ERROR';
      Exit;
    end;

  wmidrives[0,0] := '';

  if WMIResults.Instance = nil then
    begin
      Exit;
    end;

  
  //WMIResults.Instance: Anzahl der Instanzen (Laufwerke) (Spalten)
  //WMIResults.PropName: Anzahl der Querys (in dem Fall 6) (Zeilen)

  For i := 0 to Length(WMIResults.Instance) do
    If i = 0 Then
      wmidrives[i, 0] := 'Instance'
    Else
      wmidrives[i, 0] := IntToStr(i);

  if vista then
    begin
      For i2 := 0 to High(WMIResults.PropName) do
        Begin
          wmidrives[0, i2 + 1] := WMIResults.PropName[i2]; //6
          For i := 0 to High(WMIResults.Instance) do
            begin
              wmidrives[i + 1, i2 + 1] := WMIRead(WMIResults, i, i2);
            end;
        End;
    end
  else
    begin
      For i2 := 0 to High(WMIResults.PropName) do
        Begin
          if i2 >= 3 then
            begin
              wmidrives[0, i2 + 2] := WMIResults.PropName[i2];
              For i := 0 to High(WMIResults.Instance) do
                wmidrives[i + 1, i2 + 2] := WMIRead(WMIResults, i, i2);
            end
          else
            begin
              wmidrives[0, i2 + 1] := WMIResults.PropName[i2];
              For i := 0 to High(WMIResults.Instance) do
                wmidrives[i + 1, i2 + 1] := WMIRead(WMIResults, i, i2);
            end;
        End;
    end;

  for i := 1 to Length(WMIResults.Instance) do
    begin
      if wmidrives[i, 6] = 'NULL' then //Size
        wmidrives[i, 6]:='0';
      if wmidrives[i, 3] = 'NULL' then //Partitions
        wmidrives[i, 3]:='0';
      if length(wmidrives[i, 5])<=1 then //Sig
        wmidrives[i, 5]:='-';
      if length(wmidrives[i, 4])<=1 then//Serial
        wmidrives[i, 4]:='-';
    end;

end;


exports
  getwmiinfo;

begin
end.

natürlich ist die WMI.pas da mit eingebunden!

Aufruf dann aus hauptprogramm über:

Delphi-Quellcode:

type
  Twmistring = array [0..30] of array [0..7] of String;

type
  Tgetwmiinfo = function(comp, namespace, username, pass, query: String; vista: Boolean):Twmistring;




...




function getwmidriveinfo(comp, namespace, username, pass, query: String; vista: Boolean):Twmistring;
var WMIFunktion: Tgetwmiinfo;
    Handle: THandle;
begin
  Handle := LoadLibrary(PChar(ExtractFilePath(ParamStr(0))+'WMICall_DLL.dll'));
  if Handle <> 0 then
  begin
    @WMIFunktion := GetProcAddress(Handle, 'getwmiinfo');
    if @WMIFunktion <> nil then
      begin
        result:=WMIFunktion(comp, namespace, username, pass, query, vista);
      end;
    FreeLibrary(Handle);
  end;
end;


...

Was mache ich nur falsch? nach dem laden der dll erhöht sich der speicherbedarf (is ja klar) aber nach dem freigeben wird dieser nicht komplett wieder frei! Warum nicht?

[Centrii]

Moin moin

Stimmt das Problem mit dem Speicher wollt ich ja auch noch angreifen, hab eben nochmal reingeschaut und bin nach wie vor der Meinung das es mit den Interfaces zu tun hat.
Hast du dir mal die Handles von deinem Programm angeschaut? bei mir steigen die ständig, warum das so ist hab ich immer noch nicht rausgefunden....

Gruß Ruben

[Centrii]

so, nach langer suche bin ich mit Hilfe fündig geworden. Du hast in deiner While-Schleife ein WMIObject vom Typ OleVariant, richtig?
das musst bei jedem Schleifen-Durchlauf mit
VarClear(WMIObject); "freigeben".
Bei mir hat das das Problem behoben. Müsste also bei dir auch gehen...

Bitte lass mich wissen ob es bei dir auch funktioniert hat....

Gruß Ruben

[delphin06]

Echt super! der Speicherverbrauch in der WMIClass.Query() Funktion bleibt jetzt tatsächlich konstant! Allerding habe ich ein zweites speicherleck in der WMI.pas gefunden (die unit is wohl voll mit speicherlecks^^)
und zwar in der WMIClass.Connect() Funktion.

Hier mal der code:

Delphi-Quellcode:

Function TWMIClass.Connect(Const Comp, NameSpace, User, Pass: WideString): Boolean;
    Begin
      If _WMILocator = nil Then _WMILocator := TSWbemLocator.Create(Nil);
      Try
        _WMIServices := _WMILocator.ConnectServer(Comp, NameSpace, User, Pass, '', '', 0, nil);
        Result := True;
      Except
        Result := False;
        _WMIServices := nil;
        If ExceptObject is Exception Then
          _LastError := Exception(ExceptObject).Message
        Else _LastError := 'Unknown Error: ' + ExceptObject.ClassName;
      End;
    End;

Hmm...ich hab grad nochmal nachgeguckt...ab und zu kommen auch in der query funktion noch n paar kb hinzu...aber nur noch ganz selten. genauso mit der connect funktion, wobei diese fast immer speicher hinzunimmt. Alles sehr schwankend. Das is wirklich merkwürdig.

Mein export der ganzen geschichte in eine dll hat auch nicht wirklich was gebracht. ich habe die sache mit der übergabe von strings in die dll rausgenommen, weil ich dachte es lag evtl daran aber trotzdem steigt der speicherbedarf. Ich versteh das nicht, wenn ich eine dll wieder freigebe, dann müsste doch auch der speicher den die dll gebraucht hat wieder frei werden...
Naja ich werd mcih da nochmal n bisschen mit beschäftigen vieleicht finde ich ja noch das problem