The Real Housewives of D.C. | Bigoudis et permanente FRENCH DVDRIP 2018 | lesbo clip

Costo de variables?

OP

Khyze

Muchos merecen morir!
Colaborador
Mensajes
4.417
Calificaciones
2K 22
Puntos
325
Ubicación
Patria, patria, patria querida!
#1
Ando fastidiando mucho con estas cosas xD, perdon >.<, pues, las variables son las que hacen un buen juego, lo veia como la "base", ya que sin ellas no harias nada, siempre tuve miedo de utilizarlas en exeso, pense que tiraria error o algo, pero resulta que en lo ultimo que estoy haciendo estoy utilizando muchas arrays de 1600x1600=2.560.000 y pensaba utilizar mas. Tambien pense en leerlas en un archivo y utilizarlas para no almacenarlas en variables, pero abri el GM8 y me puse a probar esto

Código:
v=0; repeat(32000)
{
    val[v]=32000;
    v+=1;
}

v=0; repeat(32000)
{
    val2[v]=32000;
    v+=1;
}

v=0; repeat(32000)
{
    val3[v]=32000;
    v+=1;
}

v=0; repeat(32000)
{
    val4[v]=32000;
    v+=1;
}

v=0; repeat(32000)
{
    val5[v]=32000;
    v+=1;
}

v=0; repeat(32000)
{
    val6[v]=32000;
    v+=1;
}
Cada array de 32000 cuesta 1.000kb aprox (1mb) en la memoria ram, no note mas nada, su costo es solo de la memoria ram? (O creo que la mayoria?), creo que esta duda no solo va para GM :p

Aunque estoy usando arrays 2D val[v,v2], supongo que su costo equivaldria igual? :O
 
Mensajes
365
Calificaciones
149 1
Puntos
60
#2
Usa todas las variables que quieras xD. Claro que usar menos significa que el juego consumirá menos RAM pero como dijo una vez uno de mis profesores en la uni: primero asegurate de que el programa funcione, luego optimiza.

Leer valores de un archivo externo no suena buena idea, el disco duro es mucho más lento que la RAM, pero todo depende del uso que le des. Si los valores se leerán pocas veces (por ejemplo valores de configuración o un archivo de guardado) se pueden guardar en un archivo externo y luego asignar los valores a variables.

Con respecto al tamaño... Si GM8 maneja las arrays como en los lenguajes compilados entonces tiene que guardar en la RAM cada valor (en GM8 los números son decimales de 64 bits) y meta-data de la array como la dirección en memoria del primer valor, que pesa 32 bits, el tamaño de la array, etc.: eso significa que en teoría lo mínimo que consume una array de 32000 es 32,000*64=2,048,000 (y eso que las arrays de GM son dinámicas, deberían consumir mucho más que eso).

No comprendo la mágia negra que usa GM para hacer que las arrays consuman la mitad de lo que deberían, tal vez como todos sus valores son iguales, cada celda del array apunta a la misma dirección en la memoria. No creo que esto en serio esté ocurriendo pero trata de llenarla de valores diferentes, a ver si pesa más.
 
OP

Khyze

Muchos merecen morir!
Colaborador
Mensajes
4.417
Calificaciones
2K 22
Puntos
325
Ubicación
Patria, patria, patria querida!
#3
Usa todas las variables que quieras xD. Claro que usar menos significa que el juego consumirá menos RAM pero como dijo una vez uno de mis profesores en la uni: primero asegurate de que el programa funcione, luego optimiza.
Usualmente siempre funciona como yo quiero (A exepcion de cuando viene mucha matematica que aun me pierdo >.<), por suerte siempre me he limitado a usar pocas variables xD

Leer valores de un archivo externo no suena buena idea, el disco duro es mucho más lento que la RAM, pero todo depende del uso que le des. Si los valores se leerán pocas veces (por ejemplo valores de configuración o un archivo de guardado) se pueden guardar en un archivo externo y luego asignar los valores a variables.
Es para el sistema de mapeo que estoy haciendo (Me faltan unas cuantas optimizaciones), la cosa es que son "5 capas" (Dos bajo el pj, dos sobre el pj y "variables"), las primeras cuatro tienen una "id" de un tile y la ultima de momento o es -1 o es 0
Código:
//Variables del mundo
global.xsize=160; //Numero de casillas horizontales (valor*32 equivale al tamaño)
global.ysize=160; //Numero de casillas verticales
global.msize=global.xsize*global.ysize; //Para los repeats defaults

room_width=global.xsize*32; //Suponiendo que las casillas son 32x32, el room se hara equivalente a estos datos
room_height=global.ysize*32;

v=0; v2=0; repeat(global.msize)
{global.tiletype[v,v2]=-1; v+=1; if v>=global.xsize {v=0; v2+=1;}}

v=0; v2=0; repeat(global.msize)
{global.tile1[v,v2]=0; v+=1; if v>=global.xsize {v=0; v2+=1;}}

v=0; v2=0; repeat(global.msize)
{global.tile2[v,v2]=0; v+=1; if v>=global.xsize {v=0; v2+=1;}}

v=0; v2=0; repeat(global.msize)
{global.tile3[v,v2]=0; v+=1; if v>=global.xsize {v=0; v2+=1;}}

v=0; v2=0; repeat(global.msize)
{global.tile4[v,v2]=0; v+=1; if v>=global.xsize {v=0; v2+=1;}}
De momento la actualizacion de surfaces da bajones de fps, ya tengo una idea para "disimular" esos bajones. Es simple, en lugar de actualizar todas las capas en un solo step, agregare variables para regarlas en varios steps, su precio me metio a la mente usar aun mas sin problemas xD

Creo que por su cantidad no es buena idea usar archivos de textos :p

Con respecto al tamaño... Si GM8 maneja las arrays como en los lenguajes compilados entonces tiene que guardar en la RAM cada valor (en GM8 los números son decimales de 64 bits) y meta-data de la array como la dirección en memoria del primer valor, que pesa 32 bits, el tamaño de la array, etc.: eso significa que en teoría lo mínimo que consume una array de 32000 es 32,000*64=2,048,000 (y eso que las arrays de GM son dinámicas, deberían consumir mucho más que eso).

No comprendo la mágia negra que usa GM para hacer que las arrays consuman la mitad de lo que deberían, tal vez como todos sus valores son iguales, cada celda del array apunta a la misma dirección en la memoria. No creo que esto en serio esté ocurriendo pero trata de llenarla de valores diferentes, a ver si pesa más.
No sabia que la RAM era para eso xD (Ni sabia para que era e.e)

Entonces sera '32,000*32=1,024,000"

Puse randoms de 10 a 32000 y consume exactamente lo mismo :O (Sin importar cuantas veces reinicie, sip, probe con randomize), si acaso cambia por algunos kb, de 1 a 20 aprox
Código:
v=0; repeat(32000)
{
    val[v]=irandom_range(10,32000);
    v+=1;
}

v=0; repeat(32000)
{
    val2[v]=irandom_range(10,32000);
    v+=1;
}

v=0; repeat(32000)
{
    val3[v]=irandom_range(10,32000);
    v+=1;
}

v=0; repeat(32000)
{
    val4[v]=irandom_range(10,32000);
    v+=1;
}

v=0; repeat(32000)
{
    val5[v]=irandom_range(10,32000);
    v+=1;
}

v=0; repeat(32000)
{
    val6[v]=irandom_range(10,32000);
    v+=1;
}
 
Mensajes
365
Calificaciones
149 1
Puntos
60
#4
De momento la actualizacion de surfaces da bajones de fps, ya tengo una idea para "disimular" esos bajones. Es simple, en lugar de actualizar todas las capas en un solo step, agregare variables para regarlas en varios steps, su precio me metio a la mente usar aun mas sin problemas xD

Creo que por su cantidad no es buena idea usar archivos de textos :p
Me gusta esa idea. También estaba trabajando en un sistema de edición hace tiempo, si vuelvo a trabajar en él no te enojes si te robo la idea xD.

No sabia que la RAM era para eso xD (Ni sabia para que era e.e)

Entonces sera '32,000*32=1,024,000"

Puse randoms de 10 a 32000 y consume exactamente lo mismo :O (Sin importar cuantas veces reinicie, sip, probe con randomize), si acaso cambia por algunos kb, de 1 a 20 aprox
Sip, en la RAM se guarda la info de los programas que están en ejecución. Por cierto ahora que reviso mi cálculo anterior me di cuenta de que estoy calculando bits no bytes :_

32,000*64 = 2,048,000 bits, convertido esto da 2,048,000/8 = 256,000 bytes ahora tiene más sentido, en GM consumen 1 mega porque son arrays dinámicas y pesan más que las fijas.