Primero, el contexto
en la snapshot 34 de la beta 3 de ErickBinaryFormat implemente una tecnica llamada CukysCukysPtr ya les explico que es esta tecnica (esto no es una promocion, solo quiero saber que puedo hacer para mejorarlo)
CukysCukysPtr
esta tecnica consiste en que primero
como se maneja la ram en EBF
lo que pasa es que en vez de direccionar bytes individiuales cada slot es un entero de 16 bits con signo
ahora si que sabemos esto sigamos
el grano
como no sabia como hacer que dos casillas de memoria se junten y como no se como manejar un slot alto y bajo implemente la siguiente tecnica
mas alla de la memoria ram que tiene 2000000 casillas (4 megabytes , mas o menos como la nintendo ds, jaja , de hecho me inspire de ese tamaño por que es algo justo para hacer juegos complejos, xd) pero bueno, fuera de esa memoria hay una variable individual (ptr_memory_max) que es un entero de 64 bits sin signo (que puede direccionar 16 hexabytes de memoria) , este enterno no se puede modificar directamente pero tenemos una solucion se llama
CukysCukys
este nombre lo saque por que decian que alguien peinaba muy cuckys cuckys y la frase se me quedo asi que cuando porfin pude, implemente unas nuevas system_calls la 35 y 36
aqui esta el codigo de esas system_calls tomado directamente desde el codigo fuente de ErickBinaryFormat.h
///
/// 35 - "65K? Nahh 18,446,744,073,709,551,615 slots? yyaaayy"/ "the Cukys Cukys manipulator"
///
if (
p1 == 35
)
{
t16 ValueTo = memory_acces[p2 + 1];
t16 Operation = memory_acces[p2];
switch (Operation) {
/**
* 0 (Adding)
*
* add a val to the CukysCukys
*/
case 0:
ptr_memory_max += ValueTo;
break;
/**
* 1 (Substract)
*
* subs a val to the CukysCukys
*/
case 1:
ptr_memory_max -= ValueTo;
break;
/**
* 2 (mul)
*
* multipliques a val to the CukysCukys
*/
case 2:
ptr_memory_max *= ValueTo;
break;
/**
* 3 (div)
*
* divides a val to the CukysCukys
*/
case 3:
ptr_memory_max /= ValueTo;
break;
/**
* 4 (mov)
*
* moves a val to the CukysCukys
*/
case 4:
ptr_memory_max = ValueTo;
break;
default:
while (true); // colgate, ErickBinaryFormat merece lo mejor
// ajamk le hablaba al programa no lo hagas en casa
}
}
///
/// 36 - helper of CukysCukys
///
if (
p1 == 36
)
{
memory_acces[p2] = memory_acces[ptr_memory_max];
}
esto lo que hace resumidamente es
0 - la suma
le suma un valor a el ptr
1 - la resta
le resta un valor a el ptr
2 - la multiplicacion
le multiplica un valor a el ptr
3 - la divicion
le divide un valor a el ptr
4 - mover
le asigna un alor al ptr
ahora les pregunto yo
es buena tecnica hacer esto?, es ineficiente? , como lo puedo mejorar? los leo en las respuestas
seguro se preguntaran
- Por que es necesario?
r: esto por que un slot individual solo puede manejar hasta 32 mil slots de memoria y necesitamos acceder a mas memoria - es esto eficiente?
r: no lo se , para eso les pregunto
y acalrar algo
ya se que esto no tiene nada que ver con linux pero me estaba rompiendo la cabeza de si moverlo a Principiantes o Off Topic asi que como era para que me pidieran recomendaciones y feedback antes de tiempo , asi que lo puse en Principiantes
(edit : agregue la llamada 37 para editar el slot al que apunta el cukyscukys xd pero apenas lo hice)