Speicher läuft voll bei WMI....

[Centrii]

Hallo Delphianer

Hab ein Problem mit einer Function mit der ich Prozesse und was dazu gehört über WMI auslese. Es funktioniert alles wunderbar, nur läuft mir der Speicher voll und die "Handles" im Taskmanager erhöhen sich im Sekundentakt. Soweit erklärbar, ich komm sekündlich in der Function vorbei. Im folgenden Code passiert das in der while-Schleife, wenn ich die auskommentiere ist alles ok.

Delphi-Quellcode:

function TfProzesse.WMIEnumProcesses(Computer, User, Password: string): TPIArray;

  function GetCompName: string;
  var
    Buf        : array[0..MAX_COMPUTERNAME_LENGTH] of Char;
    Size       : DWORD;
  begin
    Size := SizeOf(Buf);
    if GetComputerName(Buf, Size) then
      Result := Buf
    else
      Result := '';
  end;

var
  FComputer: String;
  FUser: String;
  FPassword: String;
  Services     : ISWbemServices;
  ObjectDefinition: ISWbemObject;
  ObjectSet    : SWbemObjectSet;
  ObjectInstances: IEnumVariant;
  WMIObject    : ISWbemObject;
  PropertySet  : ISWbemPropertySet;
  WMIProperty  : ISWbemProperty;

  TempObj      : OleVariant;
  ObjValue     : Cardinal;
  i            : Integer;
resourcestring
  rsWMIError   = 'WMI-Fehler';
begin
  if AnsiUpperCase(GetCompName) = AnsiUpperCase(Computer) then
  begin
    FComputer := '';
    FUser := '';
    FPassword := '';
  end
  else
  begin
    FComputer := Computer;
    FUser := user;
    FPassword := Password;
  end;
  i := 0;
  //Locator := TSWbemLocator.Create(Nil);
  try
    try
      Services := Locator.ConnectServer(FComputer, 'root\CIMV2',FUser, FPassword, '', '', 0, nil);
     if Services <> nil then
      begin
        Services.Security_.Set_ImpersonationLevel(wbemImpersonationLevelImpersonate);
        Services.Security_.Privileges.Add(wbemPrivilegeDebug, True);
        ObjectDefinition := Services.Get('Win32_Process',
          wbemFlagUseAmendedQualifiers, nil);
        ObjectSet := ObjectDefinition.Instances_(0, nil);
        ObjectInstances := (ObjectSet._NewEnum) as IEnumVariant;
        while (ObjectInstances.Next(1, TempObj, ObjValue) = S_OK) do
        begin
            //hier werden die Prozesse ausgelesen
        end;
    end;
    finally
      Services := nil;
    end;
  except
    on e: Exception do
      raise e.Create(e.message);
  end;
end;

Nun die Frage, kann mir irgendjemand sagen wie ich das umgehe, oder was ich wieder freigeben muss um mein Problem zu beheben?

Ich bin mir ziemlich sicher das es daran liegt

Delphi-Quellcode:

while (ObjectInstances.Next(1, TempObj, ObjValue) = S_OK) do
begin

Über Vorschläge oder sogar Lösungen bin ich sehr Dankbar

Gruß Ruben

[Centrii]

Schade, scheinbar kann mir wieder keiner helfen :cry:

Gruß Ruben

[SirThornberry]

ich kenne die einzelnen Funktionen nicht aber ich sehe nirgends eine Funktion die irgendwas wieder frei gibt.

[Centrii]

genau das ist mein Problem, ich schaffs aber nicht die Objecte wieder frei zu geben. :?:

[Luckie]

Das sind ja alles Interfaces. Interfaces werden nicht freigegeben. Aber versuch mal sie wieder auf nil zu setzen.

[Bernhard Geyer]

Probier mal expliziet die Interfaces mit _Release freizugeben.

Sollte man eigentlich nicht machen/nötig sein, aber wenn ich ähnliche Codequalität wie beim IE vorraussetze ist das manchmal nötig um Fehler in der MS-Implementierung zu umgehen (sich selbst am Leben erhaltende Interface-Zeiger).

Aber bitte alle _relese-Aufrufe mit try..except sichern. Manchmal behebt MS auch Uraltfehler (wie z.B. beim IE).

[Centrii]

Ich hab jetzt mal versucht die Interfaces freizugeben. Mit nil bekomm ich keinen Fehler aber auch keine Verbesserung. Mit _release bekomm ich sofort Zugriffsverletzungen.
Ich hab das Programm mal ein wenig abgespeckt und stell es mal hier online, vielleicht kann ja einer von Euch "Wissenden" den Fehler finden...

Beim Programm auf Prozesse klicken und Username, Password und Server leer lassen wenn ihr auf Eurem PC die Prozesse sehen wollt. Remote halt Servername, Username, und Password eingeben.
Wenn das Programm läuft steigen sekündlich die handles von AutoCopy und somit auch der Speicher bis ins Nirvana

Thanks :thumb:

Gruß
Ruben

[salat]

Zitat:

Zitat von Centrii

Ich hab jetzt mal versucht die Interfaces freizugeben. Mit nil bekomm ich keinen Fehler aber auch keine Verbesserung.

Mir fehlen leider ettliche Komponenten - aber:

Delphi-Quellcode:

Locator := nil;

fehlt schon mal..

Nimm doch das von hier..

Grüße
Sascha

[Centrii]

Das mit dem Locator:=nil hab ich schon versucht, ich hab ja einen Locator im Form liegen, d.h. ich create mir keinen neuen wenn ich in die Function gehe. Wenn ich einen neuen in der Function create mach ich auch ein Locator:=nil, leider ohne Erfolg. Die "handels" und der Speicher erhöhen sich trotzdem. :cry:
Was für Komponenten fehlen dir denn??

Gruß

Ruben

[delphin06]

Hallo

Habe auch das Problem mit der WMI.
Ich habe die WMI.pas aus der WMI Demo mit in mein Projekt eingebunden und greife darauf zu. Doch bei jedem aufruf steigt der Speicher um 20-30KB an. Wenn man da nur ein oder zweimal drauf zugreift is das ja noch ok aber ich benötige mehrere zugriffe um änderungen festzustellen. und da steigt der speicherbedarf mit der zeit enorm.
Es liegt definitiv an der WMI.pas. die demo hat das selbe problem. also wird da irgendwo der speicher nicht wieder freigegeben.

Hier mal ein Teil code von mir wie ich auf die WMI zugreife:

Delphi-Quellcode:

comp:='.';
   namespace:='root\CIMV2';
   username:='';
   pass:='';
  if vistaplus then
     query:='    SELECT Caption, Size, Partitions, SerialNumber, Signature FROM Win32_DiskDrive'
  else
    query:='    SELECT Caption, Size, Partitions, Signature FROM Win32_DiskDrive';

  if not WMIGetInfo(comp, namespace, username, pass, Trim(query), WMIResults) then //Hier ist der erste Zugriff. und dieser 
    begin                                                                          //verursacht schon den speicheranstieg
      wmidrives[0,0] := 'ERROR';
      wmierror:=true;
      Exit;
    end
  else
    wmierror:=false;

  wmidrives[0,0] := '';

  if WMIResults.Instance = nil then
    begin
      wmierror:=true;
      Exit;
    end
  else
    wmierror:=false;

....

Wäre super wenn da jemand nachgucken könnte der sich damit auskennt. Ich könnte mir evtl vorstellen, dass das durch
setlength() ausgelöst wird. weil das ja auch verwendet wird darin. Aber ich weiß es nicht

Hier nochmal die WMI.pas im Anhang:

[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]

Delphi-Quellcode:

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:

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

Delphi-Quellcode:

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

[Centrii]

ja da hast du recht, irgendwo bleibt bei mir auch noch Speicher auf der Strecke. Bin auch grad dabei zu suchen wo das passiert.
Freu mich aber das der größte teil auch bei dir mit dem

Delphi-Quellcode:

VarClear(...)

behoben ist...

Gruß Ruben

[RWarnecke]

Zitat:

Zitat von 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

Delphi-Quellcode:

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

Hallo Ruben, das mit dem VarClear war ein guter Tipp. Ich bedanke mich dafür.

[Centrii]

Guten morgen Rolf

Ich freu mich das ich jetzt endlich mal jemand helfen konnte, nachdem mir hier schon so viel geholfen wurde... :P

Gruß Ruben

[Centrii]

Wenn einer von Euch rausfindet wie man das Speicherleck beim Connect() stopft, lasst es mich bitte wissen.
Ich finde im moment nicht an was das liegen kann. :?:

Gruß Ruben

[delphin06]

Ich glaube das ist hoffnungslos. Hab gerade nochmal den code verfolgt.

Irgendwann springt der in die system.pas und arbeitet nur noch Assembler-code ab. und da steigt dann langsam der speicher an. Mit assembler-code kenn ich mich nich wirklich aus und deshalb lass ich es.

Ich werde die wmi ganz einfach in eine externe anwendung packen, die mir in eine datei alles reinschreibt was ich brauche. danach beende ich das programm einfach wieder. dann is der speicher auch sicher freigegeben.

[BlackSeven]

Zitat:

Zitat von Centrii (Beitrag 661681)

Ich bin mir ziemlich sicher das es daran liegt

Delphi-Quellcode:

while (ObjectInstances.Next(1, TempObj, ObjValue) = S_OK) do
begin

Habe ein ähnliches Problem:

Beim Start eines Dienstes rufe ich verschiedene Informationen per WMI ab. Dieser bleibt allerdings hängen.
OS: Windows XP SP3

Delphi-Quellcode:

var

 SWbemLocator : OLEVariant;
 WMIService   : OLEVariant;
 WbemObjectSet: OLEVariant;
 WbemObject   : OLEVariant;
 oEnum        : IEnumvariant;
 iValue       : LongWord;

begin

  SWbemLocator  := CreateOleObject('WbemScripting.SWbemLocator');
  WMIService    := SWbemLocator.ConnectServer(WbemComputer, 'root\CIMV2', WbemUser, WbemPassword);
  WbemObjectSet := WMIService.ExecQuery('Select * From Win32_NetworkAdapter', 'WQL', wbemFlagForwardOnly);
  oEnum         := IUnknown(WbemObjectSet._NewEnum) as IEnumVariant;

  while oEnum.Next(1, WbemObject, iValue) = 0 do // <- scheint hier hängen zu bleiben
  begin

    Log('!'); // Zeile wird nicht mehr geloggt

  end;

  // ...