Enkonsierto, un regalito para que trabajes

[mortimor]

Eso que mencionas se debe a la funcion clone() que duplica el arbol completo y se utiliza en append(). Bien esa funcion no se utiliza ya al cargar ficheros, ahora utiliza una funcion llamada add que evita todo eso y tambien evita los releases que requieren despues.

De todos modos le echare un vistazo.

[chui]

Ya me imaginaba que algunas cosas ya estaria mejorao, pero creo que el debug/profiler este puede venir muy bien para el PROBLEMA que me tiene loco


¡¡¡ SUERTE !!!!

[chui]

Morti, este codigo parece tener el mismo sintoma que ML_Lib.

void gr_fill_nearest_table()
{
        int n ;
        SDL_Color c ;
        register fillpoint * ptr ;
        fillpoint * next ;

dime("gfnt 0");
        for (n = 1 ; n < 256 ; n++)
        {
                c = palette[n] ;
                c.r /= 8 ;
                c.g /= 8 ;
                c.b /= 8 ;
                add_filling (c.r, c.g, c.b, n, DRIGHT) ;
                if (c.r < 31) add_filling (c.r+1, c.g,   c.b,   n, DRIGHT) ;
                if (c.r > 0)  add_filling (c.r-1, c.g,   c.b,   n, DLEFT) ;
                if (c.g < 31) add_filling (c.r,   c.g+1, c.b,   n, DDOWN) ;
                if (c.g > 0)  add_filling (c.r,   c.g-1, c.b,   n, DUP) ;
                if (c.b < 31) add_filling (c.r,   c.g,   c.b+1, n, DIN) ;
                if (c.b > 0)  add_filling (c.r,   c.g,   c.b-1, n, DOUT) ;
        }

dime("gfnt 1");
n=0;
        while (filling)
        {
dimeNum("N",n++);
int i=0;
                ptr = filling ;
                while (ptr)
                {
i++;
                        if (ptr->r < 31) add_filling(ptr->r+1, ptr->g,   ptr->b,   ptr->color, DRIGHT) ;
                        if (ptr->r > 0)  add_filling(ptr->r-1, ptr->g,   ptr->b,   ptr->color, DLEFT) ;
                        if (ptr->g < 31) add_filling(ptr->r,   ptr->g+1, ptr->b,   ptr->color, DUP) ;
                        if (ptr->g > 0)  add_filling(ptr->r,   ptr->g-1, ptr->b,   ptr->color, DDOWN) ;
                        if (ptr->b < 31) add_filling(ptr->r,   ptr->g,   ptr->b+1, ptr->color, DIN) ;
                        if (ptr->b > 0)  add_filling(ptr->r,   ptr->g,   ptr->b-1, ptr->color, DOUT) ;
                        next = ptr->next ;
                        del_filling (ptr) ;
                        ptr = next ;
                }
dimeNum("I",i);
        }
dime("gfnt 2");
}

static inline fillpoint * add_filling(int r, int g, int b, int color, int dir)
{
        fillpoint * n ;

        if (nearest_table[r*2][g*2][b*2] != 0)
                return 0 ;

        //printf ("%02d %02d %02d -> %d\n", r, g, b, color) ;

        nearest_table[r*2+0][g*2+0][b*2+0] = color ;
        nearest_table[r*2+0][g*2+0][b*2+1] = color ;
        nearest_table[r*2+0][g*2+1][b*2+0] = color ;
        nearest_table[r*2+0][g*2+1][b*2+1] = color ;
        nearest_table[r*2+1][g*2+0][b*2+0] = color ;
        nearest_table[r*2+1][g*2+0][b*2+1] = color ;
        nearest_table[r*2+1][g*2+1][b*2+0] = color ;
        nearest_table[r*2+1][g*2+1][b*2+1] = color ;

        n = malloc(sizeof(fillpoint)) ;
        n->r = r ;
        n->g = g ;
        n->b = b ;
        n->color = color ;
        n->dir = dir ;
        n->next = filling ;
        if (filling)
                filling->prev = n ;
        n->prev = 0 ;
        return filling = n ;
}

static inline void del_filling(fillpoint * n)
{
        if (n->prev)
                n->prev->next = n->next ;
        else
                filling = n->next ;
        if (n->next)
                n->next->prev = n->prev ;
        free (n) ;
}

El problema esta en el while doble de gr_fill_nearest_table: son 32703 iteracciones del while interior en total, tarda 4.1055 milisegundos la GP32 por iteraccion.... total casi 2 minutos.

Te adjunto todo el codigo, estas funciones se encuentran en src/g_pal.c

[mortimor]

Estoy en ello. A ver si comparando algoritmos puedo ver que problema tiene la GP32.