Problema de lógica de equipo

Question

Considere una computadora multinivel en la que todos los niveles son diferentes. Cada nivel tiene instrucciones que son m veces más potentes que las del nivel debajo de él; es decir, una instrucción de nivel r puede hacer el trabajo de m nivel r - 1 instrucciones. Si un programa de nivel 1 requiere k segundos para ejecutarse, ¿cuánto tiempo tomarían los programas equivalentes en los niveles 2, 3 y 4, asumiendo n instrucciones de nivel r? son necesarios para interpretar una sola instrucción r + 1?

Esta es la solución que se me ocurrió. ¿Alguien puede confirmar o comentar?

Esta es la solución que acabo de encontrar. ¿Alguien puede verificar o comentar?

Level (r)  Level-1 Instructions (m)   Time 
4    m^3        t(q) ==(m^3q+n+nm+nm^2) (k/q) 
3    m^2      t(q) =(m^2q+n+nm)(k/q) 
2    m        t(q) = (mq+n)(k/q) 
1    1        t(q) = k 

el fin de calcular el tiempo de ejecución t (q) para un programa dado que contiene Q de nivel 1 instrucciones, hay que tener en cuenta tanto la exponencialmente creciente número de instrucciones de nivel-1 cada instrucción nivel R representa (mostrado como m^(r-1)) y el número adicional de instrucciones de nivel 1 requerido para la interpretación de cada capa en la que se ejecuta el programa (se muestra como nm^(r-1)). Las instrucciones adicionales de nivel 1 utilizadas para la interpretación por los niveles inferiores también se deben agregar a las ecuaciones finales para r> 2. Finalmente, para cada ecuación podemos determinar la cantidad de segundos que tarda el programa en multiplicar el número total de instrucciones de nivel 1 utilizadas por el tiempo de ejecución de un ciclo de nivel 1, calculado por (k/q).

Descargo de responsabilidad: Esto es tarea, la tarea ya ha sido entregada. Simplemente no puedo obtener la semántica de este problema, y ​​realmente me gustaría entenderlo.

Answer 1

Problema simplemente establece que si se lleva a k unidad de tiempo en el nivel 1 entonces las unidades k/m es Ll dar en segundo nivel como tal ...

Answer 2

Es sólo una función recursiva:

t(q, r) = q*k if r == 1 
t(q, r) = q*t(m, r-1) + t(n, r-1) 

Ahora se explica:

This is obvious since it was stated in the question (I parameterized k as the elementary unit, k is the time for one level 1 instruction): 
t(q, r) = q*k if r == 1 

The amount of time it takes to execute a function with q r-1 instructions 
t(q, r) = 
      q times the amount of the time it takes for m level r-1 instruction 
      q*t(m, r-1) 
         plus the time it takes for n level r-1 instructions 
         + t(n, r-1) 

Answer 3

No estoy seguro de la definición de tarea está completa porque si es que no veo ninguna otra manera sana para resolverlo que simplificándolo.

Así que aquí están algunas cosas que me gustaría suponer:

1. t (q, 1) = k (que tienen la tarea de encontrar t (q, r)) => t (1,1) = q/k, ¿por qué? Porque si no asumimos que el tiempo depende solo del número de instrucciones más que del tipo de instrucciones, en realidad estamos donde esta tarea no se puede resolver. En tal caso, q no se consideraría como un número y no podemos suponer que otro conjunto de instrucciones tomaría menos o más tiempo en función del número de instrucciones. En conclusión, en lo que respecta a mi lectura en esta tarea, relacionan el tiempo solo con el número de instrucciones.
2. si el programa es nativo en un nivel 'r', tomaría n instrucciones de otro nivel para interpretarlas (hacerlas nativas). No hay nada en la definición de tarea (como se presenta aquí) que lo obligue a interpretar solo instrucciones de nivel r + 1. En realidad, dado que comenzamos desde el nivel uno, "n instrucciones de nivel r son necesarias para interpretar una sola instrucción de r + 1" sería inútil si no podemos asumir lo que digo arriba.
3. también instrucciones de nivel q X después de ser interpretada siempre debe convertirse al nivel q instrucciones Y, otro tornillo de banco que nunca se puede saber el tiempo de ejecución de otro nivel, porque el número de instrucciones que puede variar mucho (como en el mundo real)

así que aquí es la respuesta a estas condiciones previas:

q=number of level one program instructions 
t(q, r)=time necessary to execute q **level 1** instructions on level r comp 
t(1, r)=time necessaty to execute one instruction on level r comp 
t(1, 1)=time necessary to execute one instruction on level 1 comp 
t(q, 1)/m^(r-1)=time to execute q **native** instructions on level r comp 

t(q, 1)=k 
t(1, 1)=k/q 
t(q,r)=(time to interpret q non-native instructions/convert them to native) + (time to actually execute the code) 
t(q,r)=t(qn, 1)/m^(r-1) + t(q, 1)/m^(r-1) 
t(q,r)=(time to execute qn native instructions) + (time to execute q native instructions) 
t(q,r)=nt(q, 1)/m^(r-1) + t(q, 1)/m^(r-1) 
t(q,r)=(n+1)t(q, 1)/m^(r-1) 
t(q,r)=(n+1)k/m^(r-1) 

Si cualquiera de los 3 supuestos están equivocados, es necesario introducir nuevas funciones desconocidas por lo que la respuesta llegaría a ser justamente una ecuación de funciones desconocidas que sería inútil, sino mucho más inútil que este. Este es simplemente más bonito :)

Btw necesita ver sus ejercicios en la universidad para ver cómo se han resuelto tareas similares para asegurarse de que el enfoque al problema sea correcto.

Answer 4

Creo que todos están haciendo esto demasiado complicado. El enunciado del problema dice, en otras palabras, que cada capa corre m veces más rápido que la capa superior. Por lo tanto, la capa 2 completa los programas en 1/m el tiempo, la capa 3 en 1/m * 1/my así sucesivamente. Así la ecuación final es sólo:

t (q) = k/(m ** q)