Stack Overflow al declarar arrays

[jularaXD]

Buenaas

Pos mirad, estoy creando arrays de un gran tamaño, ya que tengo ficheros con registros que quiero cargar y procesar.
Para cargar todos los registros, deberia crear un array del siguiente tamaño:

Código Delphi [-]
 ADatos                    : Array[0..49999, 0..5] of string[10];

el problema es que a la hora de crear el array, me salta un error de stack overflow. Mirando el array en el modo debug puedo apreciar que en las últimas filas hay datos que no están vacíos, supongo que es porque está esta cogiendo direcciones de memoria ya usadas por otro programa o por el mismo...

Como podría solucionar este problema??

Saludos y gracias de antemano

[Casimiro Notevi]

¿Para qué necesitas cargar tantos datos en memoria?, ¿no puedes procesarlos de otra forma?

[jularaXD]

Empezado por Casimiro Notevi

¿Para qué necesitas cargar tantos datos en memoria?, ¿no puedes procesarlos de otra forma?

Los archivos que creo son de monitorización, osea, que cada minuto me crea un registro. Separo los archivos por meses, por lo que serian unos 45.000 registros al mes

Podría mirar de hacerlo de otro modo, pero de esta forma puedo buscar datos en concreto dentro del archivo sin tener que leer el archivo de principio a fin todo el rato, además, si en otra situación me surge un problema parecido, saber como solventarlo.

salu2

[Casimiro Notevi]

Hola, no entiendo bien lo que estás haciendo, pero si es un archivo de texto donde tienes que buscar una palabra o algo, será mejor hacer la búsqueda que no cargar en memoria todo el archivo, y menos aún en un array fijo de tamaño.
Pero, repito, habría que saber exactamente el proceso para dar una opinión.

[[Lepe]]

Lista dinámica. Solo usará la memoria que necesite el fichero.

Reservar todo desde un principio es un gasto tremendo, además de limitar a ese tamaño.

Yo no uso registros nunca, siempre objetos, pero bueno, podrías tirar por:
- array of string[10] y luego con SetLength ir añadiendo los registros.

- Crear un descendiente de TList y cargar ahí cada registro. La ventaja es que puedes ordenar los datos con el TList de forma rápida, los algoritmos de ordenación están ya creados. Las funciones de insert, delete, indexof, etc, ya las tienes implementadas.

- Usar un TFileStream que es acceso directo a fichero. Es lo que usan notepad++ para abrir ficheros de textos de muchos megas en pocos segundos. Si son registros de tamaño fijo como veo, puedes calcular qué registro quieres leer y acceder solo a ese. Hoy día los discos son muy rápidos. Yo voto por este método si no necesitas ordenar los datos, comparar, etc.

También puedes tirar de TObjectList y si usas los nuevos XE, de Templates, que son Listas de fácil implementación.

Son casi 2 Megas de RAM (suponiendo cada carácter es 1 byte)...


Perdón, no he respondido a tu pregunta. Stack Overflow es porque los datos lo estás cargando en la pila de la aplicación y se queda corta para pasar todos esos datos ¿lo pasas por parámetro a otras funciones?. La solución guarra es aumentar el tamaño de la pila en Delphi para tu proyecto (Opciones del proyecto).

Saludos.

[[duilioisola]]

Dependiendo de la estructura de los archivos, también podrías tratarlos como una base de datos.
Creo que era algo asi:

Código Delphi [-]
var
  f : file of string[10];
  Registro : string[10];
  Registros : integer;
begin
  Assign(f, 'datos.dat');
  Reset(f);
  Registros := FilseSize(f); // No recuerdo si era en bytes o en el tamaño del registro
  Seek(123); // Me posiciono en el registro 123
  Registro := Read(f, s); // Leo el registro
  CloseFile(f); // Cierro el archivo
end;

[mamcx]

Y pasa lo mismo si lo ejecutas en 64 bits?

Podrias mostrar un ejemplo de que datos estas manejando?

[[nlsgarcia]]

jularaXD,

Empezado por jularaXD

...estoy creando arrays de un gran tamaño, ya que tengo ficheros con registros que quiero cargar y procesar...Los archivos que creo son de motorización, osea, que cada minuto me crea un registro (45.000 registros al mes)...Podría mirar de hacerlo de otro modo...

Te comento:

1- Revisa los Msg #35, #36 y #37 del hilo Tail -f en Delphi.

2- El Msg #35 contiene un programa que permite detectar cambios en un directorio a nivel de sus archivos y del directorio en si mismo, se puede utilizar para detectar cambios en un archivo y de esta forma realizar las acciones que sean pertinentes.

3- El Msg #36 es una especialización del programa del Msg#35 para detectar las líneas adicionadas a un archivo, el Msg #37 es una mejora del código del Msg #36.

La idea es la siguiente:

1- Detectar que archivos han tenido cambios en un directorio.

2- Cargar uno a uno los archivos en memoria que tuvieron cambios.

3- Realizar las acciones correspondientes en los archivos cargados y liberar el archivo de memoria.

Para el procesamiento de los archivos te sugiero procesarlos por medio de la clase TFileStream, es muy versátil para el manejo de archivos.

Nota: En términos generales, es conveniente procesar los archivos por registros, esto consume menos memoria y permite el manejo de archivos independientemente de su tamaño (El tamaño solo queda restringido por las limitaciones del Sistema Operativo y el Hardware).

Revisa esta información:

Trabajando con archivos de texto y binarios (II)

Espero sea útil

Nelson.

[ecfisa]

Hola jularaXD.

Mas allá del tamaño de tu arreglo en memoria (50000*6*11 = 33.14713 Mb), podría suceder que mas adelante se les ocurra pedirte que obtengas el valor de una monitorización de un año atrás... Entonces tendrás para manejar 397,69 Mb aprox.

Como sugirió Lepe, lo podes gestionar de manera sencilla usando listas dinámicas como en este esbozo al vuelo:

Código Delphi [-]
...
uses contnrs;

type
  TStr10 = string[10];
  TClase = class
    v: array[0..5] of TStr10;
  end;

var
  List: TObjectList;

procedure TForm1.FormCreate(Sender: TObject);
var
  i: Integer;
  C: TClase;
begin
  List:= TObjectList.Create;
  for i:= 0 to 100 do
  begin
    C:= TClase.Create;
    C.v[0]:= 'cero';
    C.v[1]:= 'uno';
    C.v[2]:= 'dos';
    c.v[3]:= 'tres';
    c.v[4]:= 'cuatro';
    c.v[5]:= 'cinco';
    List.Add(TObject(C));
  end;
end;

procedure TForm1.Button1Click(Sender: TObject);
var
  col,row: Integer;
  s: string;
begin
  for row:= 0 to 100 do
  begin
    s:= IntToStr(row)+') ';
    for col:= 0 to 5 do s:= s + TClase(List[row]).v[col] + ',';
    SetLength(s,Length(s)-1);
    ListBox1.Items.Add(s);
  end;
end;
...

también con un árbol binario de búsqueda o un arreglo de apuntadores, cada una con sus pros y contras. Estas soluciones han sido (y son), usadas como las mejores en los procesamientos de arreglos casi vacíos, vg.: planillas de cálculo.

O también,como sugirió duiliosola, mediante un archivo de acceso directo :

Código Delphi [-]
unit Directo;

interface

type
  TStr10     = string[10];
  TDataClass = class
  private
    FData    : array[0..5] of TStr10;
    FFileName: string;
    function  GetDatos(Index: Integer): TStr10;
    procedure SetDatos(Index: Integer; const Value: TStr10);
    function  GetSize: Integer;
  public
    property  FileName: string read FFileName write FFileName;
    property  Data[Index: Integer]: TStr10 read GetDatos write SetDatos; default;
    procedure Open;
    property  Size: Integer read GetSize;
    procedure ReadData(const Posic: Integer);
    procedure SaveData(const Posic: Integer);
    procedure AppendData;
    procedure Close;
    //...
  end;

implementation

uses SysUtils;

type
  TRegData = packed record
    VData: array[0..5] of TStr10;
  end;
  TFileReg = file of TRegData;

var
  RegData : TRegData;
  FileReg: TFileReg;

procedure TDataClass.Open;
begin
  if FFileName = EmptyStr then
    raise Exception.Create('Falta el nombre de archivo');
  AssignFile(FileReg, FFileName);
  try
    Reset(FileReg);
  except
    Rewrite(FileReg);
  end;
end;

function TDataClass.GetDatos(Index: Integer): TStr10;
begin
  Result:= FData[Index];
end;

procedure TDataClass.SetDatos(Index: Integer; const Value: TStr10);
begin
  FData[Index]:= Value;
end;

function TDataClass.GetSize: Integer;
begin
  Result:= FileSize(FileReg);
end;

procedure TDataClass.ReadData(const Posic: Integer);
begin
  if Posic >= Size then
    raise Exception.Create('Índice fuera de rango');
  Seek(FileReg, Posic);
  Read(FileReg, RegData);
  Move(RegData.VData, FData, SizeOf(FData));
end;

procedure TDataClass.SaveData(const Posic: Integer);
begin
  if Posic >= Size then
    raise Exception.Create('Índice fuera de rango');
  Move(FData, RegData.VData, SizeOf(RegData.VData));
  Seek(FileReg, Posic);
  Write(FileReg, RegData);
end;

procedure TDataClass.AppendData;
begin
  Move(FData, RegData.VData, SizeOf(RegData.VData));
  Seek(FileReg, FileSize(FileReg));
  Write(FileReg, RegData);
end;

procedure TDataClass.Close;
begin
  CloseFile(FileReg);
end;
//...
end.

Pero en términos de simpleza, fiabilidad y escalabilidad pienso que almacenar esos valores de monitorización como campos de una tabla de una base de datos tampoco es mala idea.

Saludos

[jularaXD]

Muchas gracias a todos por vuestras respuestas y disculpad el retraso, que este fin de semana he estado muy liado...
Ahora me voy a poner a rehacer el código a ver con que método me quedare, supongo con el de las listas dinámicas, ya que me iría bien un algoritmo de ordenación, pero la verdad es que todos me van a servir en algún momento u otro.

Salu2

[[nlsgarcia]]

jularaXD,

Empezado por jularaXD

...estoy creando arrays de un gran tamaño...Mirando el array en el modo debug puedo apreciar que en las últimas filas hay datos que no están vacíos...¿Como podría solucionar este problema?...

Revisa este código:

Código Delphi [-]
procedure TForm1.Button1Click(Sender: TObject);
var
   A1 : Array[0..49999, 0..5] of String[10];
begin
   FillChar(A1, SizeOf(A1),' ');
end;

El código anterior inicializa a blancos un arreglo de dos dimensiones de tipo String[10].

Espero sea útil

Nelson.

[[nlsgarcia]]

jularaXD,

Empezado por jularaXD

...estoy creando arrays de un gran tamaño, ya que tengo ficheros con registros que quiero cargar y procesar...de esta forma puedo buscar datos en concreto dentro del archivo sin tener que leer el archivo de principio a fin...

Revisa este código:

Código Delphi [-]
unit Unit1;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls;

type
  TForm1 = class(TForm)
    Button1: TButton;
    procedure Button1Click(Sender: TObject);
  private
    { Private declarations }
  public
    { Public declarations }
  end;

  TMonitor = record
     CodMon : Array[0..9] of Char;
     FecMon : Array[0..9] of Char;
     DesMon : Array[0..29] of Char;
     CRLF : Array[0..1] of Char;
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

procedure ProcessFile(FileName , CodMon : String);
var
   M : TMemoryStream;
   Buffer : TMonitor;

begin

   try

      M := TMemoryStream.Create;
      M.LoadFromFile(FileName);
      M.Seek(0,soFromBeginning);
      while M.Position < M.Size do
      begin
         M.Read(Buffer, SizeOf(Buffer));
         if Buffer.CodMon = CodMon then
         begin
            ShowMessage('Proceso a Realizar');
         end;
      end;

      MessageDlg('Archivo Procesado',mtInformation,[mbOK],0)

   except

      MessageDlg('Error en Procesamiento de Archivo',mtError,[mbOK],0)

   end;

   M.Free;

end;

procedure TForm1.Button1Click(Sender: TObject);
var
   FileName : String;
   CodMon : String;
begin
   FileName := 'FileMon.txt';
   CodMon := '0000100000';
   ProcessFile(FileName, CodMon);
end;

end.

El código anterior permite cargar dinámicamente un archivo en disco a memoria utilizando solo la memoria mínima requerida, procesar el mismo y liberar la memoria al finalizar el proceso, esto es una alternativa al concepto de un arreglo de registros. En el caso de querer procesar un registro particular, por ejemplo el número 11 (Los registros se numeran de 0 a n) se puede ir directamente a este por medio del siguiente código:

Código Delphi [-]
begin
   M.Seek(SizeOf(Buffer)*10,soFromBeginning);
end;

Nota: El código sugerido fue probado con un archivo de texto de 100.000 Registros con un tiempo de proceso en el orden de las milésimas de segundos.

Espero sea útil

Nelson.