Błąd Systemu. Kod: 8. Nie ma wystarczającej ilości miejsca do przetworzenia tego polecenia

W rzeczywistości jest to problem z tabelą ATOM. zgłosiłem ten problem do Embarcadero ponieważ sprawia mi to wiele zmartwień.

Jeśli monitorujesz globalną tabelę atomów, zobaczysz, że aplikacje Delphi wyciekają z atomów, pozostawiając identyfikator Twojej aplikacji bez upuszczania go z pamięci:

Zobaczysz mnóstwo następujących elementów:

**Delphi000003B4*

*Controlofs0040000000009C0**

Zasadniczo, ponieważ nie możesz zarejestrować więcej niż 0xFFFF różnych identyfikatorów wiadomości windows, gdy tylko poprosisz o inny, system będzie return " Błąd systemu. Kod: 8. Nie ma wystarczającej ilości pamięci do przetworzenia tego polecenia ". Wtedy nie będzie można uruchomić żadnej aplikacji, która tworzy okno.

Kolejny problem został zgłoszony w Embarcadero QC Central.

Ten problem pojawia się pod Windows 7 / Windows Server 2008. Fakt, że na Windows Server 2003 i przed jego uruchomieniem jest spowodowany niewłaściwą implementacją, która recyklinguje Atomy, gdy ich indeks zawija się wokół maksimum 16384 jednostki.

Zapraszam do korzystania z mojego Global Atom Monitor aby sprawdzić, czy aplikacje Delphi przeciekają, czy nie.

Aby to naprawić, potrzebujesz łatki z Embarcadero.

Szukam od 2 lat i dzięki Jordi Corbilla odpowiedz W końcu to mam!

W kilku słowach: źródło Delphi ma błędy, które powodują ten problem!

Let ' s understand what is going on:

Windows posiada obszar pamięci o nazwie "Atom table", który służy do komunikowania się aplikacji (Zobacz więcej ).

Również Windows ma inny "obszar pamięci", zwany "systemem wiadomości okien", który służy do tego samego celu (Zobacz więcej ).

Oba te obszary pamięci mają "16K slotów" każdy. W pierwszym z nich można usunąć atom, używając następującego interfejsu Windows API:

GlobalDeleteAtom // for removing an atom added by "GlobalAddAtom"

W drugim "obszarze", po prostunie możemy usunąć niczego!

Funkcja RegisterWindowMessage jest zwykle używana do rejestracji komunikaty do komunikacji między dwoma współpracującymi aplikacjami. Jeśli dwie różne aplikacje rejestrują ten sam ciąg wiadomości, aplikacje zwraca tę samą wartość wiadomości. wiadomość pozostaje rejestracja do zakończenia sesji .

Skompilowane Aplikacje Delphi (przynajmniej przez D7) umieszczają rekord w "obszarze wiadomości", a niektóre inne w "tabeli Atom" za każdym razem, gdy są uruchamiane. Aplikacja próbuje je usunąć, gdy aplikacja się zamyka, ale znalazłem wiele (i wiele) "przecieków atom", nawet po zamknięciu aplikacji.

W tym momencie możesz zobaczyć, że jeśli masz serwer, który uruchamia tysiące aplikacja dziennie, prawdopodobnie powinieneś wkrótce osiągnąć limit 16k i zaczyna się problem! Rozwiązanie w tym momencie? Tylko jeden restart.

Najpierw otwórz elementy sterujące.pas i zastąp następujący wiersz:

RM_GetObjectInstance := RegisterWindowMessage(PChar(ControlAtomString));

Dla:

RM_GetObjectInstance := RegisterWindowMessage('RM_GetObjectInstance');

A następnie przekompiluj Pakiety Delphi i swoje aplikacje.

Jak znalazłem przecieki atomu nawet po zamknięciu aplikacji utworzyłem aplikację, która garbage zbiera każdy atom pozostawiony. Po prostu uruchamia następujący kod co godzinę:

procedure GarbageCollectAtoms;
var i, len : integer;
    cstrAtomName: array [0 .. 1024] of char;
    AtomName, Value, procName: string;
    ProcID,lastError : cardinal;
    countDelphiProcs, countActiveProcs, countRemovedProcs, countCantRemoveProcs, countUnknownProcs : integer;

    // gets program's name from process' handle
    function getProcessFileName(Handle: THandle): string;
    begin
      Result := '';
      { not used anymore
      try
        SetLength(Result, MAX_PATH);
        if GetModuleFileNameEx(Handle, 0, PChar(Result), MAX_PATH) > 0 then
          SetLength(Result, StrLen(PChar(Result)))
        else
          Result := '';
        except
      end;
      }
    end;

    // gets the last 8 digits from the given atomname and try to convert them to and integer
    function getProcessIdFromAtomName(name:string):cardinal;
    var l : integer;
    begin
      result := 0;
      l := Length(name);
      if (l > 8) then
      begin
        try
          result := StrToInt64('$' + copy(name,l-7,8));
          except
            // Ops! That should be an integer, but it's not!
            // So this was no created by a 'delphi' application and we must return 0, indicating that we could not obtain the process id from atom name.
            result := 0;
        end;
      end;
    end;

    // checks if the given procID is running
    // results: -1: we could not get information about the process, so we can't determine if is active or not
    //           0: the process is not active
    //           1: the process is active
    function isProcessIdActive(id: cardinal; var processName: string):integer;
    var Handle_ID: THandle;
    begin
      result := -1;
      try
        Handle_ID := OpenProcess(PROCESS_QUERY_INFORMATION or PROCESS_VM_READ, false, id);
        if (Handle_ID = 0) then
        begin
          result := 0;
        end
        else
        begin
          result := 1;
          // get program's name
          processName := getProcessFileName(Handle_ID);
          CloseHandle(Handle_ID);
        end;
        except
          result := -1;
      end;
    end;

    procedure Log(msg:string);
    begin
      // Memo1.Lines.Add(msg);
    end;


begin

  // initialize the counters
  countDelphiProcs := 0;
  countActiveProcs := 0;
  countRemovedProcs := 0;
  countUnknownProcs := 0;

  // register some log
  Log('');
  Log('');
  Log('Searching Global Atom Table...');

  for i := $C000 to $FFFF do
  begin
    len := GlobalGetAtomName(i, cstrAtomName, 1024);
    if len > 0 then
    begin
      AtomName := StrPas(cstrAtomName);
      SetLength(AtomName, len);
      Value := AtomName;
      // if the atom was created by a 'delphi application', it should start with some of strings below
      if (pos('Delphi',Value) = 1) or
         (pos('ControlOfs',Value) = 1) or
         (pos('WndProcPtr',Value) = 1) or
         (pos('DlgInstancePtr',Value) = 1) then 
      begin
        // extract the process id that created the atom (the ProcID are the last 8 digits from atomname)
        ProcID := getProcessIdFromAtomName(value);
        if (ProcId > 0) then
        begin
          // that's a delphi process
          inc(countDelphiProcs);
          // register some log
          Log('');
          Log('AtomName: ' + value + ' - ProcID: ' + inttostr(ProcId) + ' - Atom Nº: ' + inttostr(i));
          case (isProcessIdActive(ProcID, procName)) of
            0: // process is not active
            begin
              // remove atom from atom table
              SetLastError(ERROR_SUCCESS);
              GlobalDeleteAtom(i);
              lastError := GetLastError();
              if lastError = ERROR_SUCCESS then
              begin
                // ok, the atom was removed with sucess
                inc(countRemovedProcs);
                // register some log
                Log('- LEAK! Atom was removed from Global Atom Table because ProcID is not active anymore!');
              end
              else
              begin
                // ops, the atom could not be removed
                inc(countCantRemoveProcs);
                // register some log
                Log('- Atom was not removed from Global Atom Table because function "GlobalDeleteAtom" has failed! Reason: ' + SysErrorMessage(lastError));
              end;
            end;
            1: // process is active
            begin
              inc(countActiveProcs);
              // register some log
              Log('- Process is active! Program: ' + procName);
            end;
            -1: // could not get information about process
            begin
              inc(countUnknownProcs);
              // register some log
              Log('- Could not get information about the process and the Atom will not be removed!');
            end;
          end;
        end;
      end;
    end;
  end;
  Log('');
  Log('Scan complete:');
  Log('- Delphi Processes: ' + IntTostr(countDelphiProcs) );
  Log('  - Active: ' + IntTostr(countActiveProcs) );
  Log('  - Removed: ' + IntTostr(countRemovedProcs) );
  Log('  - Not Removed: ' + IntTostr(countCantRemoveProcs) );
  Log('  - Unknown: ' + IntTostr(countUnknownProcs) );

  TotalAtomsRemovidos := TotalAtomsRemovidos + countRemovedProcs;

end;

(powyższy kod powstał na podstawie tego kodu )

Po tym, nigdy nie dostałem ten k * * błąd ponownie!

Późna Aktualizacja:

Również to jest źródło tego błędu: błąd aplikacji: adres błędu 0x00012afb

Możesz użyć Desktop Heap Monitor firmy Microsoft, aby wyświetlić statystyki sterty (użyj % itd.) i jest dostępny pod adresem:

Http://www.microsoft.com/downloads/details.aspx?familyid=5cfc9b74-97aa-4510-b4b9-b2dc98c8ed8b&displaylang=en

Zauważyłem ten błąd (Błąd systemu. Kod: 8. Za mało miejsca...) ostatnio, gdy używam jakiegoś kodu Twain, działo się to na moim komputerze, a nie na moim współpracowniku, a jedyną prawdziwą różnicą między naszymi maszynami jest to, że używam ekranu laptopa jako drugiego monitora, więc moje całkowite wymiary pulpitu są większe.

Znalazłem dokumentację problemu wskazanego powyżej przez Steve ' a Blacka, ale znalazłem sposób (który naprawił błąd na moim komputerze, przynajmniej), który nie wymaga edycji rejestr:

Stary kod używał

  DC := GetDC(Owner.VirtualWindow);
  // ...
  ReleaseDC(Owner.VirtualWindow, DC);

I okazało się, że zastąpienie go tym pozbyło się moich błędów

  DC := CreateCompatibleDC(Owner.VirtualWindow);
  // ...
  DeleteDC(DC);

Nie wiem, czy ma to związek z Twoim problemem, ale może być pomocne dla innych w przyszłości.

Mogą pojawić się błędy w kompilatorze, można się założyć, że to coś w Twojej aplikacji powoduje problem. Czy to możliwe, że Twoja aplikacja wycieka klamki okien lub jakiś inny obiekt GUI, taki jak długopisy / pędzle? To może być przyczyna.

Dla mnie to było tylko kilka tjpegimages dekompresji w sposób pokaz slajdów, że w końcu zabrakło pamięci.