Estoy haciendo un análisis recursivo.Es una pila falsa más rápida que una pila real
Actualmente tengo una pila falsa, donde almaceno estados para mi máquina de estados finitos, así que cuando profundizo recursivamente, presiono el estado en el que estaba, y lo explico más tarde después de haber terminado de procesar el fragmento de texto recursivo .
¿Sería más rápido para tener una "Identificación del estado de pila como:
int* stack = 0
int top = 0;
// ...
// drill down bit
if (stack == 0)
stack = (int*)malloc(STACK_JUMP_SIZE);
else if (top % STACK_JUMP_SIZE == 0)
stack = (int*)realloc(stack, (top+STACK_JUMP_SIZE) * sizeof(int));
stack[top++] = currentState;
// ...
// pop up later
{currentState = stack[--top]; {
if (top == 0) {
free(stack);
stack = 0;
} else if ((top+1) % STACK_JUMP_SIZE == 0) {
stack = (int*)realloc(stack, (top+1)*sizeof(int));
}
o sería más rápido para dividir la cosa arriba en funciones propias y dejar que C++ preocuparse por la pila.
(Sé que alguien me dirá 'eso es C, no es C++', por lo que respondo de manera preventiva, el C++ de mi programa pero tiene mucha c).
Personalmente, esperaba que las funciones normales fueran más rápidas ... pero alguien que ha pensado mucho más que yo pensó que esta pila falsa es más rápida. Ahora me gustaría ver más opiniones de personas que creen más que yo :) – matiu
@matu Depende de la máquina. En una Sparc, una llamada de función requiere cero accesos de memoria, y puede ser considerablemente más rápida. En un Intel, terminas guardando tu dirección de retorno y el puntero de marco en la memoria, más cualquier argumento que la función requiera: eso puede ser muy costoso. –