elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.

 

 


Tema destacado: ¿Eres nuevo? ¿Tienes dudas acerca del funcionamiento de la comunidad? Lee las Reglas Generales


+  Foro de elhacker.net
|-+  Programación
| |-+  Programación C/C++ (Moderadores: Eternal Idol, Littlehorse, K-YreX)
| | |-+  [Código fuente][C] Máquina virtual		0 Usuarios y 1 Visitante están viendo este tema.
Páginas: [1] Ir Abajo Respuesta Imprimir
Autor Tema: [Código fuente][C] Máquina virtual  (Leído 3,390 veces)
Miky Gonzalez

Desconectado Desconectado

Mensajes: 87

http://mikygonzalez.comule.com/blog/


Ver Perfil WWW
[Código fuente][C] Máquina virtual
« en: 30 Septiembre 2013, 18:30 pm »
Adjunto el código fuente de una máquina simple que he estado haciendo, pero no tengo más tiempo para continuarla ni tampoco para terminar el ensamblador. Actualmente dispone de las siguientes funciones:


Set de instrucciones:
0x00haltdetiene el cpu
0x01litcargar en acumulador un valor inmediato
0x02loadcargar en acumulador valor de un registro
0x03storealmacenar valor acumulador en un registro
0x04incincrementar por 1 el acumulador
0x05decdecrementar por 1 el acumulador
0x06putlponer en memoria un valor inmediato
0x07putrponer en registro un valor de memoria
0x08getacargar en acumulador un valor de memoria
0x09getrcargar en registro un valor de memoria
0x0Acmplcomparar acumulador con valor inmediado. establece flag
0x0Bcmprcomparar acumulador con valor registro. establece flag
0x0Cjmpsaltar a direccion de codigo (inicio == 0x00)
0x0Djmplsaltar a direccion de codigo si flag == 1 ( < )
0x0Ejmpesaltar a direccion de codigo si flag == 2 ( = )
0x0Fjmpg    saltar a direccion de codigo si flag == 3 ( > )

Especificaciones técnicas:
El CPU consta de 4 registros de usuario, un registro flag y el registro acumulador. La máquina dispone de memoria a modo de pila (tengo otra versión con memoria dinámica, en vez de usar una pila); también se dispone de una memoria de sólo lectura para el código.


main.c:
Código
  1. /*!
  2. 	Miky Gonzalez Virtual Machine
  3. 	Contact: mikygonzalez95@gmail.com
  4.  
  5. 	Miky Gonzalez Virtual Machine por Miky Gonzalez se encuentra bajo una
  6. 	Licencia Creative Commons Atribución-NoComercial-CompartirIgual 3.0 
  7. 	Unported. Más información: 
  8. 	http://creativecommons.org/licenses/by-nc-sa/3.0/deed.es
  9. */
  10.  
  11. #include <stdio.h>
  12. #include <string.h>
  13. #include <stdlib.h>
  14. //#include <inttypes.h>
  15. //#include <time.h>
  16.  
  17. #include "pila.h"
  18.  
  19. /* MVM - Estructura de la MV */
  20. typedef struct CPU {
  21. 	short int registro[4];
  22. 	short int acumulador;
  23. 	unsigned int inst_pointer;
  24. 	unsigned char *memoria_codigo;
  25. 	unsigned char flag;
  26. 	pila_ pila;
  27. } cpu_t;
  28.  
  29. unsigned int crear_cpu(cpu_t *cpu, unsigned char *memoria_codigo) {
  30. 	if(!memoria_codigo || !cpu) return 0;
  31.  
  32. 	//memset(cpu->registro, 0, sizeof(cpu->registro) / sizeof(*cpu->registro));
  33. 	unsigned short int i = 0;
  34. 	for(; i < 4; i++)
  35. 		cpu->registro[i] = 0;
  36. 	cpu->acumulador = 0;
  37. 	cpu->inst_pointer = 0;
  38. 	cpu->memoria_codigo = memoria_codigo;
  39. 	cpu->flag = 0;
  40. 	cpu->pila = NULL;
  41.  
  42. 	return 1;
  43. }
  44.  
  45. void ejecutar_cpu(cpu_t *cpu) {
  46. 	if(!cpu) {
  47. 		printf("[MVM] Error al ejecutar CPU...\n");
  48. 		return;
  49. 	}
  50. 	while(1) {
  51. 		switch(cpu->memoria_codigo[cpu->inst_pointer]) {
  52. 			case 0x00: /*! halt */
  53. 				printf("halt\n");
  54. 				return;
  55. 			case 0x01: /*! lit */
  56. 				cpu->acumulador = cpu->memoria_codigo[++cpu->inst_pointer];
  57. 				printf("lit %d\n", cpu->memoria_codigo[cpu->inst_pointer]);
  58. 				break;
  59. 			case 0x02: /*! load */
  60. 				if(cpu->memoria_codigo[++cpu->inst_pointer] > 0x03) {
  61. 					printf("[CPU] Desbordamiento en numero de registro.\n");
  62. 					return;
  63. 				}
  64. 				cpu->acumulador = cpu->registro[cpu->memoria_codigo[cpu->inst_pointer]];
  65. 				printf("load r%d\n", cpu->memoria_codigo[cpu->inst_pointer]);
  66. 				break;
  67. 			case 0x03: /*! store */
  68. 				if(cpu->memoria_codigo[++cpu->inst_pointer] > 0x03) {
  69. 					printf("[CPU] Desbordamiento en numero de registro.\n");
  70. 					return;
  71. 				}
  72. 				cpu->registro[cpu->memoria_codigo[cpu->inst_pointer]] = cpu->acumulador;
  73. 				printf("store r%d\n", cpu->memoria_codigo[cpu->inst_pointer]);
  74. 				break;
  75. 			case 0x04: /*! inc */
  76. 				cpu->acumulador++;
  77. 				printf("inc\n");
  78. 				break;
  79. 			case 0x05: /*! dec */
  80. 				cpu->acumulador--;
  81. 				printf("dec\n");
  82. 				break;
  83. 			case 0x06: /*! pushl */
  84. 				push(&cpu->pila, cpu->memoria_codigo[++cpu->inst_pointer]);
  85. 				printf("pushl %d\n", cpu->memoria_codigo[cpu->inst_pointer]);
  86. 				break;
  87. 			case 0x07: /*! pushr */
  88. 				if(cpu->memoria_codigo[++cpu->inst_pointer] > 0x03) {
  89. 					printf("[CPU] Desbordamiento en numero de registro.\n");
  90. 					return;
  91. 				}
  92. 				push(&cpu->pila, cpu->registro[cpu->memoria_codigo[cpu->inst_pointer]]);
  93. 				printf("pushr r%d\n", cpu->memoria_codigo[cpu->inst_pointer]);
  94. 				break;
  95. 			case 0x08: /*! pop */
  96. 				if(pila_vacia(&cpu->pila)) {
  97. 					printf("[CPUSTACK] No hay elemento en pila.\n");
  98. 					return;
  99. 				}
  100. 				pop(&cpu->pila);
  101. 				printf("pop\n");
  102. 				break;
  103. 			case 0x09: /*! loadt */
  104. 				if(pila_vacia(&cpu->pila)) {
  105. 					printf("[CPUSTACK] No hay elemento en pila.\n");
  106. 					return;
  107. 				}
  108. 				cpu->acumulador = pop(&cpu->pila);
  109. 				printf("loadt\n");
  110. 				break;
  111. 			case 0x0A: /*! cmpl */
  112. 				if(cpu->acumulador < cpu->memoria_codigo[++cpu->inst_pointer])
  113. 					cpu->flag = 1;
  114. 				else if(cpu->acumulador == cpu->memoria_codigo[cpu->inst_pointer])
  115. 					cpu->flag = 2;
  116. 				else if(cpu->acumulador > cpu->memoria_codigo[cpu->inst_pointer])
  117. 					cpu->flag = 3;
  118. 				printf("cmpl %d\n", cpu->memoria_codigo[cpu->inst_pointer]);
  119. 				break;
  120. 			case 0x0B: /*! cmpr */
  121. 				if(cpu->acumulador < cpu->registro[cpu->memoria_codigo[++cpu->inst_pointer]])
  122. 					cpu->flag = 1;
  123. 				else if(cpu->acumulador == cpu->registro[cpu->memoria_codigo[cpu->inst_pointer]])
  124. 					cpu->flag = 2;
  125. 				else if(cpu->acumulador > cpu->registro[cpu->memoria_codigo[cpu->inst_pointer]])
  126. 					cpu->flag = 3;
  127. 				printf("cmpr r%d\n", cpu->memoria_codigo[cpu->inst_pointer]);
  128. 				break;
  129. 			case 0x0C: /*! jmp */
  130. 				printf("jmp %d\n", cpu->memoria_codigo[++cpu->inst_pointer]);
  131. 				cpu->inst_pointer = cpu->memoria_codigo[cpu->inst_pointer] - 1;
  132. 				break;
  133. 			case 0x0D: /*! jmpl */
  134. 				printf("jmpl %d\n", cpu->memoria_codigo[++cpu->inst_pointer]);
  135. 				if(cpu->flag == 1)
  136. 					cpu->inst_pointer = cpu->memoria_codigo[cpu->inst_pointer] - 1;
  137. 				break;
  138. 			case 0x0E: /*! jmpe */
  139. 				printf("jmpe %d\n", cpu->memoria_codigo[++cpu->inst_pointer]);
  140. 				if(cpu->flag == 2)
  141. 					cpu->inst_pointer = cpu->memoria_codigo[cpu->inst_pointer] - 1;
  142. 				break;
  143. 			case 0x0F: /*! jmpg */
  144. 				printf("jmpg %d\n", cpu->memoria_codigo[++cpu->inst_pointer]);
  145. 				if(cpu->flag == 3)
  146. 					cpu->inst_pointer = cpu->memoria_codigo[cpu->inst_pointer] - 1;
  147. 				break;
  148. 			default:
  149. 				printf("[CPU] Instruccion desconocida. Cerrando proceso CPU.\n");
  150. 				return;
  151. 		}
  152. 		cpu->inst_pointer++;
  153. 		printf("r0: %d\tr1: %d\tr2: %d\tr3: %d\tac: %d\n", cpu->registro[0], cpu->registro[1], cpu->registro[2], cpu->registro[3], cpu->acumulador);
  154. 		contar_nodos(cpu->pila);
  155. 	}
  156. }
  157.  
  158. int main(int argc, char *argv[]) {
  159. 	/* Inicializar datos y comprobar argumentos */
  160. 	if(argc < 2) {
  161. 		printf("Uso: %s <archivo>\n", argv[0]);
  162. 		return 0;
  163. 	}
  164. 	FILE *codigo_archivo = fopen(argv[1], "rb");
  165. 	if(!codigo_archivo) {
  166. 		printf("[MVM] Fallo al abrir el archivo %s\n", argv[1]);
  167. 		return 0;
  168. 	}
  169.  
  170. 	/* Calcular tamaño (volumen) del código */
  171. 	unsigned int codigo_volumen;
  172. 	fseek(codigo_archivo, 0, SEEK_END);
  173. 	codigo_volumen = ftell(codigo_archivo);
  174. 	rewind(codigo_archivo);
  175. 	if(!codigo_volumen) {
  176. 		printf("[MVM] No hay instrucciones...\n");
  177. 		fclose(codigo_archivo);
  178. 		return 0;
  179. 	}
  180.  
  181. 	/* Reservar el espacio necesario para almacenar 
  182. 	 * el código en memoria. Si existe, copiarlo. */
  183. 	unsigned char *codigo = (unsigned char *)malloc(codigo_volumen);
  184. 	if(!fread(codigo, 1, codigo_volumen, codigo_archivo)) {
  185. 		printf("[MVM] Error en lectura de archivo...\n");
  186. 		fclose(codigo_archivo);
  187. 		return 0;
  188. 	} else fclose(codigo_archivo);
  189.  
  190. 	/* Crear CPU e inicializar los datos */
  191. 	cpu_t cpu;
  192. 	if(!crear_cpu(&cpu, codigo)) {
  193. 		printf("[MVM] Error al crear CPU...\n");
  194. 		return 0;
  195. 	}
  196.  
  197. 	/* Ejecutar CPU hasta instrucción fin o error */
  198. 	ejecutar_cpu(&cpu);
  199. 	printf("r0: %d\tr1: %d\tr2: %d\tr3: %d\tac: %d\n", cpu.registro[0], cpu.registro[1], cpu.registro[2], cpu.registro[3], cpu.acumulador);
  200. 	contar_nodos(cpu.pila);
  201. 	eliminar_pila(&cpu.pila);
  202. 	free(codigo);
  203.  
  205. 	return 0;
  206. }

pila.c:
Código
  1. /*!
  2. 	Miky Gonzalez Virtual Machine
  3. 	Contact: mikygonzalez95@gmail.com
  4.  
  5. 	Miky Gonzalez Virtual Machine por Miky Gonzalez se encuentra bajo una
  6. 	Licencia Creative Commons Atribución-NoComercial-CompartirIgual 3.0 
  7. 	Unported. Más información: 
  8. 	http://creativecommons.org/licenses/by-nc-sa/3.0/deed.es
  9. */
  10.  
  11. /*! Implementación de una pila para memoria de datos MVM */
  12.  
  13. #include <stdio.h>
  14. #include <stdlib.h>
  15. #include "pila.h"
  16.  
  17. void push(pila_ *pila, int valor) { 
  18. 	nodo_ nodo = (nodo_)malloc(sizeof(nodo_t));
  19.  
  20. 	if(nodo != NULL) {
  21. 		nodo->valor = valor;
  22. 		nodo->nodo_siguiente = *pila;
  23. 		*pila = nodo;
  24. 	}
  25. }
  26.  
  27. int pop(pila_ *pila) {
  28. 	nodo_ nodo;
  29. 	int valor = 0;
  30.  
  31. 	nodo = *pila;
  32. 	valor = (*pila)->valor;
  33. 	*pila = (*pila)->nodo_siguiente;
  34.  
  35. 	free(nodo);
  36. 	return valor;
  37. }
  38.  
  39. //#define pila_vacia(a) *a == NULL ? 1:0;
  40. unsigned short int pila_vacia(pila_ *pila) {
  41. 	return (*pila == NULL ? 1 : 0);
  42. }
  43.  
  44. unsigned short int contar_nodos(nodo_ nodo) {
  45. 	if(nodo == NULL) return 0;
  46.  
  47. 	unsigned short int nodos = 0;
  48. 	while(nodo != NULL) {
  49. 		nodos++;
  50. 		printf("n%d: %d\t", nodos, nodo->valor);
  51. 		nodo = nodo->nodo_siguiente;
  52. 	}
  53. 	printf("\n");
  54.  
  55. 	return nodos;	
  56. }
  57.  
  58. // #define eliminar_pila(a) {if(pila_vacia(a))return;while(!pila_vacia(a))pop(a);}
  59. void eliminar_pila(pila_ *pila) {
  60. 	if(pila_vacia(pila)) return;
  61. 	while(!pila_vacia(pila)) pop(pila);
  62. 	return;
  63. }

pila.h:
Código
  1. /*!
  2. 	Miky Gonzalez Virtual Machine
  3. 	Contact: mikygonzalez95@gmail.com
  4.  
  5. 	Miky Gonzalez Virtual Machine por Miky Gonzalez se encuentra bajo una
  6. 	Licencia Creative Commons Atribución-NoComercial-CompartirIgual 3.0 
  7. 	Unported. Más información: 
  8. 	http://creativecommons.org/licenses/by-nc-sa/3.0/deed.es
  9. */
  10.  
  11. #ifndef MVM_PILA
  12. #define MVM_PILA
  13.  
  14. /* Estructura de nodos de pila */
  15. typedef struct NODO {
  16. 	int valor;
  17. 	struct NODO *nodo_siguiente;
  18. } nodo_t;
  19.  
  20. typedef nodo_t *nodo_;
  21. typedef nodo_t *pila_;
  22.  
  23. void push(pila_ *pila, int valor);
  24. int pop(pila_ *pila);
  25. unsigned short int pila_vacia(pila_ *pila);
  26. unsigned short int contar_nodos(nodo_ nodo);
  27. void eliminar_pila(pila_ *pila);
  28.  
  29. #endif

Actualmente no dispongo de tiempo para terminar el ensamblador, así que tendrán que crear los ejecutables editandolos hexadecimalmente, hice un programa para facilitarme el trabajo de prueba:

Código
  1. #include <stdio.h>
  2.  
  3. int main(int argc, char **argv) {
  4. 	char codigo[] = {0x00};
  5. 	FILE *fd;
  6. 	fd = fopen("test", "wb");
  7. 	if(!fd) return 0;
  8. 	fwrite(codigo, sizeof(char), sizeof(codigo), fd);
  9. 	fclose(fd);
  10. 	return 0;
  11. }


Algunos ejemplos ya programados, con sus respectivos opcodes:

Código:
#========================================
# CALCULAR RESTA DE DOS NUMEROS
#========================================
# Usando 2 registros se pueden hacer
# funciones de resta de números.
# resultado: r0
#========================================

# Inicializacion de los datos

lit 25		# ac: 25
store r0	# r0: 25
lit 17		# ac: 17
store r1	# r1: 17
lit 0		# ac: 0

# Bucles

load r1		# ac: r1
dec		# ac: ac--
store r1	# r1: ac
load r0		# ac: r0
dec		# ac: ac--
store r0	# r0: ac

lit 1		# ac: 1
cmpr r1		# comparar ac & r1
jmpg 16		# ac > r1 --> jmp 16
jmp 6 		# jmp 6

halt		# stop

# 0x01 25 0x03 0x00 0x01 17 0x03 0x01 0x01 0x00 0x02 0x01 0x05
# 0x03 0x01 0x02 0x00 0x05 0x03 0x00 0x01 0x01 0x0B 0x01 0x0F 28
# 0x0C 10 0x00

Código:
#========================================
# CALCULAR SUMA DE DOS NUMEROS
#========================================
# Usando 2 registros se pueden hacer
# funciones de suma de números.
# resultado: r0
#========================================

# Inicializacion de los datos

lit 17		# ac: 17
store r0	# r0: 17
lit 25		# ac: 25
store r1	# r1: 25
lit 0		# ac: 0

# Bucles

load r1		# ac: r1
dec		# ac: ac--
store r1	# r1: ac
load r0		# ac: r0
inc		# ac: ac++
store r0	# r0: ac

lit 1		# ac: 1
cmpr r1		# comparar ac & r1
jmpg 16		# ac > r1 --> jmp 16
jmp 6 		# jmp 6

halt		# stop
# 0x01 25 0x03 0x00 0x01 17 0x03 0x01 0x01 0x00 0x02 0x01 0x05
# 0x03 0x01 0x02 0x00 0x04 0x03 0x00 0x01 0x01 0x0B 0x01 0x0F 28
# 0x0C 10 0x00

Código:
#========================================
# CALCULAR MULTIPLICACION DE DOS NUMEROS
#========================================
# Utilizando 3 registros (incluso menos) se
# pueden hacer funciones de multiplicación
# de números.
# resultado: r2.
#========================================

# Inicialización de los datos

lit 10		# ac: 10
store r0	# r0: 10
lit 3		# ac: 3
store r1	# r1: 3
lit 0		# ac: 0


# Bucles
	
load r1		# ac: r1
dec		# ac: ac--
store r1	# r1: ac
cmpl 0		# comparar ac & 0
jmpe 23		# ac == 0 --> jmp 23

lit 10		# ac: 10
store r0	# r0: 10

load r2		# ac: r2
inc		# ac: ac++
store r2	# r2: ac
load r0		# ac: r0
dec		# ac: ac--
store r0	# r0: ac
lit 0		# ac: 0
cmpr r0		# comparar ac & r0
jmpl 13		# ac < r0 --> jmp 13
jmp 6		# jmp 6

lit 0		# ac: 0
store r1	# r1: 0

halt		# stop
#0x01 0x0A 0x03 0x00 0x01 0x03 0x03 0x01 0x01 0x00			   
#0x02 0x01 0x05 0x03 0x01 0x0A 0x00 0x0D 0x29 0x01
#0x0A 0x03 0x00 0x02 0x02 0x04 0x03 0x02 0x02 0x00
#0x05 0x03 0x00 0x01 0x00 0x0B 0x00 0x0D 23 0x0C 10
#0x01 0x00 0x03 0x01 0x00

Espero que este proyecto les guste, y si alguien puede continuarlo, espero que lo haga y tenga buenas ideas, tal vez aunque no puedo no seria malo proponerlas, nunca se sabe si volvere a continuar con la máquina virtual.

Saludos,
  Miky Gonzalez
En línea
Mi blog personal, con información acerca de programación, seguridad, desarrollo y electrónica:


EN CONSTRUCCIÓN
eferion


Desconectado Desconectado

Mensajes: 1.248


Ver Perfil
Re: [Código fuente][C] Máquina virtual
« Respuesta #1 en: 30 Septiembre 2013, 20:35 pm »
Deberías plantearte empezar a subdividir el código de la cpu. Conforme vayas añadiendo instrucciones tu código va a empezar a ser un poco caótico.

Si te atreves a migrar el código a C++ avísame y te comento algunas ideas.

Si no, una opción para liquidar ese switch que va a acabar siendo infernal es que te crees un array de punteros a funciones... en la posición 0 pones un puntero a la función que va a ejecutar la instrucción 0x00, en la posición 1 la correspondiente a la instrucción 0x01... Cuando te llegue una instrucción ejecutas la función que corresponda dado el índice de la instrucción y listo. Además ganarás velocidad.

Ten en cuenta que con este diseño tendrás que pasar como parámetro un puntero a la estructura cpu, para poder acceder a los acumuladores, registros y demás.

Si hay huecos puedes definir un valor que determine que la instrucción en concreto no existe... para mostrar mensajes de error por ejemplo.

Este nuevo diseño te va a permitir mantener un código más limpio y ordenado, con funciones pequeñas y fáciles de depurar.

Por lo demás, tiene buena pinta.

Enhorabuena.
En línea
Miky Gonzalez

Desconectado Desconectado

Mensajes: 87

http://mikygonzalez.comule.com/blog/


Ver Perfil WWW
Re: [Código fuente][C] Máquina virtual
« Respuesta #2 en: 30 Septiembre 2013, 21:24 pm »
En primer lugar, gracias por comentar eferion. Soy consciente que con más instrucciones y más funciones el código será "sucio" y poco optimizable, pero para empezar, me parece que está claro.

Decidí programar la máquina virtual en C, porque no soy amigo de C++, aunque la programación orientada a objetos sería una buena idea, incluso tal vez mas editable.

En cambiar el switch por un array, o una estructura ya lo pensé, pero decidí no implementarlo por no tener que cambiar el código, aunque en implementarlo no se tardaría mucho, tan solo sería separar cada instrucción como una función del programa. Sería un paso a hacer si se continuara el proyecto añadiendo más instrucciones y funciones.

Estuve buscando cómo implementar y hacer funciones más rápidas y de hecho tengo una versión que podría proporcionar perfectamente libre de licencia, pero con un código mal organizado y poco ordenado, pero está bastante más optimizado comparandolo con este código.

Otro de los pasos a hacer si continuara el proyecto sería terminar el ensamblador, publicar la versión con uso de memoria y punteros en vez de una pila de datos; entre otras cosas, añadir 'labeles' para hacer saltos relativos en el código, de este manera, el problema actual de tener que cambiar de salto por cada nueva instrucción añadida se solventaría, convirtiendo los saltos relativos a saltos absolutos (esto lo haría el ensamblador).

Saludos,
  Miky Gonzalez
En línea
Mi blog personal, con información acerca de programación, seguridad, desarrollo y electrónica:


EN CONSTRUCCIÓN
x64core


Desconectado Desconectado

Mensajes: 1.908


Ver Perfil
Re: [Código fuente][C] Máquina virtual
« Respuesta #3 en: 30 Septiembre 2013, 22:31 pm »
Esto es más bien emulacion de codigo y no una maquina virtual ya que se tendria que virtualizar el entorno también.
En línea
Karcrack


Desconectado Desconectado

Mensajes: 2.416


Se siente observado ¬¬'


Ver Perfil
Re: [Código fuente][C] Máquina virtual
« Respuesta #4 en: 1 Octubre 2013, 09:46 am »
Me gustan mucho este tipo de códigos :P Yo me hice un emulador para un set de instrucciones reducizo del MIPS cuando lo dí en la universidad ;D

Cita de: eferion en 30 Septiembre 2013, 20:35 pm
Si no, una opción para liquidar ese switch que va a acabar siendo infernal es que te crees un array de punteros a funciones... en la posición 0 pones un puntero a la función que va a ejecutar la instrucción 0x00, en la posición 1 la correspondiente a la instrucción 0x01... Cuando te llegue una instrucción ejecutas la función que corresponda dado el índice de la instrucción y listo. Además ganarás velocidad.
Los compiladores modernos ya hacen esa optimización de forma automática. (http://en.wikipedia.org/wiki/Branch_table)
En línea
eferion


Desconectado Desconectado

Mensajes: 1.248


Ver Perfil
Re: [Código fuente][C] Máquina virtual
« Respuesta #5 en: 1 Octubre 2013, 09:53 am »
Cita de: Karcrack en  1 Octubre 2013, 09:46 am
Me gustan mucho este tipo de códigos :P Yo me hice un emulador para un set de instrucciones reducizo del MIPS cuando lo dí en la universidad ;D

Los compiladores modernos ya hacen esa optimización de forma automática. (http://en.wikipedia.org/wiki/Branch_table)

Las optimizaciones de los procesadores están bien... pero no puedes depender de ellas para hacer un código optimizado. Entre otras cosas las optimizaciones son condicionales, ya que no siempre pueden aplicarse, además cada compilador aplica sus propias optimizaciones, luego la optimización final varía de un compilador a otro.

Además, por muchas optimizaciones que haga el compilador, el mantenimiento del código fuente siempre te va a tocar a ti, por lo que te interesa que ese código, al margen de posibles optimizaciones del compilador ) sea lo más legible y sencillo posible... y si no intenta tu pegarte con un bug en una función de 2484 líneas de código, 20 parámetros y punteros y variables sin inicializar ( sí, yo me he encontrado con eso y con cosas peores ).
En línea
Karcrack


Desconectado Desconectado

Mensajes: 2.416


Se siente observado ¬¬'


Ver Perfil
Re: [Código fuente][C] Máquina virtual
« Respuesta #6 en: 1 Octubre 2013, 22:26 pm »
Completamente de acuerdo pero a no ser que uses un compilador de los 90 tu intento de optimizar puede no ser tan óptimo como el que haría el compilador...
En línea
eferion


Desconectado Desconectado

Mensajes: 1.248


Ver Perfil
Re: [Código fuente][C] Máquina virtual
« Respuesta #7 en: 2 Octubre 2013, 08:35 am »
Cita de: Karcrack en  1 Octubre 2013, 22:26 pm
Completamente de acuerdo pero a no ser que uses un compilador de los 90 tu intento de optimizar puede no ser tan óptimo como el que haría el compilador...

No me refería exactamente a eso.

Tu piensa que, en función de cómo configures el compilador, el mismo compilador, puede proporcionarte unas optimizaciones u otras. El mismo código fuente puede servir para generar varias decenas de códigos binarios distintos... dependiendo de las optimizaciones que se vayan a aplicar.

Además hay optimizaciones incompatibles entre sí, como pueden ser algunas relativas a velocidad de ejecución y las de tamaño del ejecutable.

A lo que yo iba es que, independientemente de eso, el código fuente es algo que tiene que mantener el programador, por lo que merece la pena invertir el tiempo y el dinero en tener un código limpio, manejable y escalable. A corto, medio y largo plazo merece la pena.
En línea
Miky Gonzalez

Desconectado Desconectado

Mensajes: 87

http://mikygonzalez.comule.com/blog/


Ver Perfil WWW
Re: [Código fuente][C] Máquina virtual
« Respuesta #8 en: 2 Octubre 2013, 14:01 pm »
Totalmente de acuerdo con todos ustedes, si continuo el proyecto, intentaré implementar lo mejor posible para optimizar en velocidad.
  Saludos
En línea
Mi blog personal, con información acerca de programación, seguridad, desarrollo y electrónica:


EN CONSTRUCCIÓN
Páginas: [1] Ir Arriba Respuesta Imprimir 

Ir a:  

Mensajes similares
Asunto Iniciado por Respuestas Vistas Último mensaje
pregunta sobre Maquina virtual-virtual pc
Software 		T0rete 4 2,913 Último mensaje 5 Octubre 2011, 16:10 pm
por zosemu
¿Cuál es la diferencia entre código objeto, código máquina y código binario?
Programación General 		Aikanáro Anário 9 29,014 Último mensaje 23 Diciembre 2010, 15:19 pm
por pucheto
Código de una máquina virtual simple
Programación C/C++ 		Miky Gonzalez 7 2,835 Último mensaje 7 Marzo 2013, 20:08 pm
por Miky Gonzalez
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines