implementar ciaaPOSIX_stdlib about firmware_v1 HOT 8 CLOSED

Diego, en ciaaPOSIX_free me parece hay una inconsistencia. Cuando reservás, con malloc el lugar reservado es el "allocation_size = size + sizeof(ciaaPOSIX_chunk_header)" y esto mismo se quita de heap_available_size en ciaaPOSIX_init_next_chunk. Pero en el ciaaPOSIX_free lo volvés a agregar con heap_available_size += chunk_header->size; pero en realidad el chunk sigue ocupando memoria, con lo cual tenés disponible más memoria de la que realmente hay.
Además, en la siguiente reserva sobre este chunk liberado (supongamos inicialmente tenía 200B reservados), si el tamaño de reserva es menor (digamos 80B) se pisa el size y va a quedar de menor tamaño perdiendo definitivamente los 120B con la reserva original que ya no se recuperan
Propongo lo siguiente:
1- Definir quien puede modificar cada .c para no pisarnos
2- Incluir un campo que sea algo como Max_size, que tenga el valor inicial de ese chunk para que no se pierda el valor total por más que en alguna reserva temporal ese chunk que sub-aproveche
3- A la vez, creo podríamos implementar alguna manera inteligente y no muy complicada de evitar fraccionar tanto la memoria, por ejemplo, enlazar doblemente y cuando se libera un chunk "mirar" hacia los costados, o arrancando desde el último hacia atrás, e ir agrupando los chunks libres en uno solo más grande
4- Quizás esto lo podría hacer una especie de función para defragmentar memoria, si la reserva inicial falla, para no hacer lenta cada reserva.

from firmware_v1.

Hola Diego y Juan,

el feedback de Juan me parece muy bueno. De hecho podemos hacer un garbage collector como dice Juan en otra funcion que se corra desde una tarea background (para no perder tiempo). Cada vez que se hace un free se tiene que indicar que es necesario correr el "garbage collector". Si corre la tarea background sabe si debe hacerlo o no.

Si hay un malloc y no hay memoria suficiente libre y el flag esta indicado que el garbage collector no es necesario correrlo entonces se retorna enseguida con un error 👎 . en caso de que el garbage collector no corrio luego del ultimo free entonces ahi si perdemos tiempo y hay que correr el garbage collector desde la aplicación que llama al malloc...

from firmware_v1.

Hola Juan y Mariano,

Gracias por revisarlo, se me pasó lo de la inconsistencia del size, voy a
corregirlo.

Lo del garbage collector me parece muy buena idea, pero sería mejor que se
ejecute una tarea en background o se ejecute manualmente a través de una
función?

El 29 de mayo de 2014, 14:52, mcerdeiro [email protected] escribió:

Hola Diego y Juan,

el feedback de Juan me parece muy bueno. De hecho podemos hacer un garbage
collector como dice Juan en otra funcion que se corra desde una tarea
background (para no perder tiempo). Cada vez que se hace un free se tiene
que indicar que es necesario correr el "garbage collector". Si corre la
tarea background sabe si debe hacerlo o no.

Si hay un malloc y no hay memoria suficiente libre y el flag esta indicado
que el garbage collector no es necesario correrlo entonces se retorna
enseguida con un error [image: 👎] . en caso de que el garbage
collector no corrio luego del ultimo free entonces ahi si perdemos tiempo y
hay que correr el garbage collector desde la aplicación que llama al
malloc...

—
Reply to this email directly or view it on GitHub
#31 (comment).

from firmware_v1.

El garbage collector se ejecutaria normalmente en background salvo que no haya corrido todavia y no haya memoria disponible para un pedido de malloc. En ese caso se deberia correr dentro del mismo llamado a malloc para ver si tal vez haciendo un garbage collector si se encuentra luego memoria disponible. Pero tiene que ser una funcion interna aparte.

que les parece? no se como llamar a esta funcion ciaak_garbageCollector? ciaak por que seria una funcion del kernel claro...

from firmware_v1.

habría que agregar definir en otro header genérico, para no necesitarlo en cada header
#ifndef NULL
#define NULL (void*)0
#endif

from firmware_v1.

Propongo implementar una función ciaaPOSIX_garbageCollector dentro de ciaaPOSIX_stdlib.c de la forma:

  void ciaaPOSIX_garbageCollector(void)
  {
     ciaaPOSIX_chunk_header *chunk_header = first_chunk_header;

     while(chunk_header)
     {
        if(chunk_header->is_available == CIAA_POSIX_STDLIB_AVAILABLE)
        {
           ciaaPOSIX_chunk_header *next_chunk_header = chunk_header->next;

           while(next_chunk_header->is_available == CIAA_POSIX_STDLIB_AVAILABLE)
           {
              chunk_header->next = next_chunk_header->next;
              chunk_header->size += next_chunk_header->size + sizeof(ciaaPOSIX_chunk_header);

              ciaaPOSIX_heap_available_size += sizeof(ciaaPOSIX_chunk_header);

              next_chunk_header = chunk_header->next;
           }
        }
        chunk_header = chunk_header->next;
     }
  }

La misma tendría que ser llamada por un task en background cuando se levante un flag.
Que les parece?

from firmware_v1.

Hola Diego,

me parece bien. pero diria que la background task llama siempre y la funcion internamente decide si hay algo que hacer o no. además falta la parte de semaforos :)

ojo que yo hice el commit de un error y sigue adentro:
7a31129
chunk_header->next = (ciaaPOSIX_chunk_header*) (sizeof(chunk_header) + allocation_size);

Saludos.
Mariano.-

from firmware_v1.

done for 1.0.0, if needed new issue shall be opened.

from firmware_v1.