Windows reduce velocidad de ejecucion.

[Danielㅤ]

Hola, tal vez usando Virtual List mejores la velocidad de carga:

https://www.google.com/search?q=Virtual+list+en+c

Por otro lado podes usar Threads, por ejemplo que tú programa cree un hilo/thread por cada 100/300/500 mil filas.

La razón de porque el programa trabaja cada vez más lento cuando va cargando las filas, puede ser porque está cargando constantemente en memoria los datos sin ser liberada, deberías liberar memoria después del volcado de datos, mira aquí que interesante esto:



https://www.google.com/search?q=liberar+memoria+free+c

Vos tenés problema con la función malloc() y existe la función free() para justamente liberar memoria.


Saludos

[Eternal Idol]

marax: de nada, me alegro de que lo hayas solucionado.

Danielㅤ: super intersante, tambien estan los operadores new y delete.

[Serapis]

Iba a señalar que me perdía, porque por un lado habladas de cargar el fichero de 20 mb. y luego en otro mensaje decías que lo cargadas inmediato (que es lo lógico)... y también que usabas 11mill millones de filas... que no entendía de donde salían sobre 20Mb. (salvo combinaciones con dichos elementos, pero que no explicaba explicitamente, pues se hablabas de estructuras,registros) ... pero el tema parece finalmente aclarado, así que así no tiene sentdo darle más vueltas.

Solo indicarte que las listas enlazadas son una estructura interesante cuando de lo que se trata es de hacer añadido dinámico y de antemano no se sabe cuanto ha de ser dicho tamaño.
Pero solo es útil finalmente si el resorrido que se precisa usar es secuencial, si el recorrido preciso es aleatorio, entonces la listas enlazadas tienen un pobre rendimiento, porque para ir hasta el índice 20millones cuando hay mill millones de items, requiere ser recorrido uno a uno desde el nodo raíz o desde el nodo final (si es doblemente enlazada).
Si tiras de estructuras que provee el lenguaje, se le supone un rendimiento eficaz (digamos que estará optimizado), si en cambio es una implementación propia, al caso conviene cuando menos mantener un item 'actual', de modo que un salto a otro punto distante pueda verificarse desde que punto queda más cerca: raiz, final o actual y la dirección de avance, para hacer el recorrido lo más óptimo posible en ese aspecto.
Mantener un item 'actual', complica el diseño de la implementación porque debe mantenerse con cada operación que lo afecte, así el costo del resto de operaciones aumenta a cambio de ser más óptimo en acceso.

En definitiva  tienes que tener claro si la lista enlazada es la mejor estructura que precisas en tus pesquisas. Cada estructura de datos tiene su fuerte y ninguna es óptima en cada punto.

[Usuario887]

Hola, tal vez usando Virtual List mejores la velocidad de carga:

https://www.google.com/search?q=Virtual+list+en+c

Por otro lado podes usar Threads, por ejemplo que tú programa cree un hilo/thread por cada 100/300/500 mil filas.

La razón de porque el programa trabaja cada vez más lento cuando va cargando las filas, puede ser porque está cargando constantemente en memoria los datos sin ser liberada, deberías liberar memoria después del volcado de datos, mira aquí que interesante esto:



https://www.google.com/search?q=liberar+memoria+free+c

Vos tenés problema con la función malloc() y existe la función free() para justamente liberar memoria.


Saludos

Hola Daniel, gracias por tu respuesta.

El problema era este: Mira la funcion que usaba para añadir entradas en la lista enlazada:

Código (c) [Seleccionar] Expandir

int QuotesMemAddEnd (struct __quotesmem **qm, struct __quotesmem qmData)
{
   struct __quotesmem *aux=(struct __quotesmem *)malloc(sizeof(struct __quotesmem));
   struct __quotesmem **base;
   if(aux==NULL)
   {
       return MTERR_NOT_ENOUGH_MEMORY;
   }

   memcpy((struct __quotesmem *) aux,
          (struct __quotesmem *) &qmData,
          sizeof (struct __quotesmem));

   aux->next=NULL;

   if(*qm==NULL)
   {
       aux->last=NULL;
       *qm=aux;
   }
   else
   {
       base=qm;
       while((*base)->next!=NULL)
       {
           base=&((*base)->next);
       }

       aux->last=*base;
       (*base)->next=aux;
   }

   return 0;
}

Este programa lo hice con el fin de lidiar con muchos datos, y las pruebas del mismo las hacia precisamente con pocos datos, para no enrollarme en la depuracion. La cuestion fue algo muy curioso... Precisamente porque usaba pocos datos para probarlo, no me di cuenta del problema: Nunca me gusto usar el concepto de cabeza en mis listas enlazadas, siempre me parecio una perdida de tiempo porque nunca lidie con mas de diez kilobytes en una lista enlazada (y esto ya es monumental).

No se si te fijaste en que la lista recorre cada elemento hasta llegar a la cabeza para entonces añadir el siguiente. Lo que pasa es que cuando son demasiadas entradas el programa tiene que recorrer tantas cuantas sean, tantas cuantas sean veces. Es decir, en "Tiempo parabolico" (El tiempo se elevaria al cuadrado, mas o menos) Y por eso justamente la funcion era cada segundo mas lenta, porque iba recorriendo mas millones de entradas a medida que se añadian, basicamente lanzando el rendimiento por la borda  

Ni malloc, ni nada... Pura pereza de programador...

De todas formas alojar memoria para todo el archivo de una vez me vino mejor. Lo seguire haciendo.

Iba a señalar que me perdía, porque por un lado habladas de cargar el fichero de 20 mb. y luego en otro mensaje decías que lo cargadas inmediato (que es lo lógico)... y también que usabas 11mill millones de filas... que no entendía de donde salían sobre 20Mb. (salvo combinaciones con dichos elementos, pero que no explicaba explicitamente, pues se hablabas de estructuras,registros) ... pero el tema parece finalmente aclarado, así que así no tiene sentdo darle más vueltas.

Solo indicarte que las listas enlazadas son una estructura interesante cuando de lo que se trata es de hacer añadido dinámico y de antemano no se sabe cuanto ha de ser dicho tamaño.
Pero solo es útil finalmente si el resorrido que se precisa usar es secuencial, si el recorrido preciso es aleatorio, entonces la listas enlazadas tienen un pobre rendimiento, porque para ir hasta el índice 20millones cuando hay mill millones de items, requiere ser recorrido uno a uno desde el nodo raíz o desde el nodo final (si es doblemente enlazada).
Si tiras de estructuras que provee el lenguaje, se le supone un rendimiento eficaz (digamos que estará optimizado), si en cambio es una implementación propia, al caso conviene cuando menos mantener un item 'actual', de modo que un salto a otro punto distante pueda verificarse desde que punto queda más cerca: raiz, final o actual y la dirección de avance, para hacer el recorrido lo más óptimo posible en ese aspecto.
Mantener un item 'actual', complica el diseño de la implementación porque debe mantenerse con cada operación que lo afecte, así el costo del resto de operaciones aumenta a cambio de ser más óptimo en acceso.

En definitiva  tienes que tener claro si la lista enlazada es la mejor estructura que precisas en tus pesquisas. Cada estructura de datos tiene su fuerte y ninguna es óptima en cada punto.

Que preciso  
Diste en el blanco, Serapis.

[MinusFour]

Podrías haber simplemente haber guardado una referencia a la cola para que la inserción no sea O(n)...

[Usuario887]

Podrías haber simplemente haber guardado una referencia a la cola para que la inserción no sea O(n)...

Lo se. En la proxima modificacion eso hare... Y cambiare a malloc por HeapAlloc. Me imagino que es poca la diferencia de tiempo entre las dos pero como es un factor proporcional al final compensa.

Gracias.

Buenas noches.