int main(int argc, char **argv) {
correrAsignar();
correrDefinirVariables();
correrImprimir();
correrImprimirTexto();
correrFinalizar();
correrSalto();
correrRetornar();
correrFunction();
printf(" El numero de instrucciones del codigo completo es '%d'\n",metadata_desde_literal(CODIGO_COMPLETO)->instrucciones_size);
t_intructions * instrucciones = metadata_desde_literal(CODIGO_COMPLETO)->instrucciones_serializado;
printf("primera instruccion inicio:%d\n", instrucciones[0].start);
printf("primera instruccion offset:%d\n", instrucciones->offset);
printf("segunda instruccion inicio:%d\n", (instrucciones+1)->start);
printf("SP de primera instruccion:%d\n", metadata_desde_literal(CODIGO_COMPLETO)->instruccion_inicio);
return 0;
}
int main (void) {
char *programita = "begin\nvariables f, A, g \n A = 0 \n!Global = 1+A\n print !Global \n jnz !Global Siguiente \n:Proximo\n \n f = 8 \ng <- doble !Global \n io impresora 20\n :Siguiente \n imprimir A \ntextPrint Hola Mundo! \n\n sumar1 &g \n print g \n\n sinParam \n \nend\n\nfunction sinParam\n textPrint Bye\nend\n\n#Devolver el doble del\n#primer parametro\nfunction doble\nvariables f \n f = $0 + $0 \n return fvend\n\nfunction sumar1\n *$0 = 1 + *$0\nend\n\nfunction imprimir\n wait mutexA\n print $0+1\n signal mutexB\nend\n\n";
t_metadata_program *estructura = metadata_desde_literal(programita);
char* buffer = (char*) calloc(1,SIZEOF_PCB) ;
serialize_t_metadata_program(estructura, &buffer);
puts(buffer);
return 0;
}
void print_instrucciones_size () {
char * prog1 = "begin \n variables a, b, c \n a = b + 12 \n print b \n textPrint foo\n end\"";
char * prog2 = "begin \n print b \n end";
char * prog3 = "begin\nend";
char * prog4 = "end";
char * prog5 = "begin";
t_metadata_program * meta1 = metadata_desde_literal(prog1);
t_metadata_program * meta2 = metadata_desde_literal(prog2);
t_metadata_program * meta3 = metadata_desde_literal(prog3);
t_metadata_program * meta4 = metadata_desde_literal(prog4);
t_metadata_program * meta5 = metadata_desde_literal(prog5);
printf("instrucciones_size prog1 :%d\n", meta1->instrucciones_size);
printf("instrucciones_size prog2 :%d\n", meta2->instrucciones_size);
printf("instrucciones_size prog3 :%d\n", meta3->instrucciones_size);
printf("instrucciones_size prog4 :%d\n", meta4->instrucciones_size);
printf("instrucciones_size prog5 :%d\n", meta5->instrucciones_size);
}
int main(int argc, char **argv) {
printf("Ejecutando\n");
char *programa = strdup(PROGRAMA);
t_metadata_program *metadata = metadata_desde_literal(programa);
int programCounter = 0;
while(!terminoElPrograma()){
char* const linea = conseguirDatosDeLaMemoria(programa,
metadata->instrucciones_serializado[programCounter].start,
metadata->instrucciones_serializado[programCounter].offset);
printf("\t Evaluando -> %s", linea);
analizadorLinea(linea, &functions, &kernel_functions);
free(linea);
programCounter++;
}
metadata_destruir(metadata);
printf("================\n");
return EXIT_SUCCESS;
}
void
atenderProgramaEntrante(t_datosEnviar* paquete, int socketCliente,
int * PIDActual)
{
if (paquete->codigo_Operacion == HANDSHAKE)
{
destruirPaquete(paquete);
t_datosEnviar *paqueteEscribir;
void *dataGenerica;
paquete = pedirPaquete("K", PLP_PROGRAMA_CONFIRMAR_CONECCION, 2);
common_send(socketCliente, paquete, NULL );
destruirPaquete(paquete);
paquete = common_receive(socketCliente, NULL );
if (paquete->codigo_Operacion == ENVIAR_SCRIPT)
{
debugTrackPLP(
"[Achievement] Programa autenticado, recibiendo script");
char* programa = malloc(paquete->data_size);
memcpy(programa, paquete->data, paquete->data_size);
t_metadata_program * metadataDelPrograma;
metadataDelPrograma = metadata_desde_literal((const char*) programa);
int peso;
peso = metadataDelPrograma->cantidad_de_funciones * 3
+ metadataDelPrograma->cantidad_de_etiquetas * 5
+ metadataDelPrograma->instrucciones_size;
int error = 0;
t_pcb * pcbNuevo = malloc(sizeof(t_pcb));
pcbNuevo->pid = generarPid(PIDActual);
int direccionStack, direccionCodigo, direccionIndiceEtiquetas,
direccionIndiceCodigo;
destruirPaquete(paquete);
error = 0;
debugTrackPLP("[Accion] Pidiendo segmentos en a la UMV");
direccionCodigo = pedirSegmento(&error, strlen(programa) + 1,
pcbNuevo->pid);
direccionStack = pedirSegmento(&error, configuration.tamanio_pila,
pcbNuevo->pid);
direccionIndiceEtiquetas = pedirSegmento(&error,
metadataDelPrograma->etiquetas_size, pcbNuevo->pid);
direccionIndiceCodigo = pedirSegmento(&error,
metadataDelPrograma->instrucciones_size * sizeof(t_intructions),
pcbNuevo->pid);
if (error == 1)
{
debugTrackPLP(
"[Error] No se pudo crear la totalidad de segmentos");
paquete = pedirPaquete("A", PLP_PROGRAMA_NO_SE_PUDO_CREAR, 2);
common_send(socketCliente, paquete, NULL );
destruirPaquete(paquete);
void * pidMomentaneo = malloc(sizeof(int));
memcpy(pidMomentaneo, &(pcbNuevo->pid), sizeof(int));
paquete = pedirPaquete(pidMomentaneo,
KERNEL_DESTRUIR_SEGMENTOS_PROGRAMA, sizeof(int));
common_send(socketUMV, paquete, NULL );
debugTrackPLP(
"[Accion] Eliminando el resto de los segmentos pedidos");
PIDActual--;
destruirPaquete(paquete);
free(pidMomentaneo);
}
else
{
debugTrackPLP(
"[PID:%d]-[Achievement] Se pudo alocar todos los segmentos para el proceso ",
pcbNuevo->pid);
pcbNuevo->codeIndex = direccionIndiceCodigo;
pcbNuevo->codeSegment = direccionCodigo;
pcbNuevo->indiceEtiquetas = direccionIndiceEtiquetas;
pcbNuevo->programCounter =
metadataDelPrograma->instruccion_inicio;
pcbNuevo->tamanioIndiceEtiquetas =
metadataDelPrograma->etiquetas_size;
pcbNuevo->currentStack.base = direccionStack;
pcbNuevo->currentStack.contextSize = 0;
pcbNuevo->currentStack.size = configuration.tamanio_pila;
pcbNuevo->currentStack.stack_pointer = direccionStack;
if (pcbNuevo->codeSegment != -1)
{
debugTrackPLP(
"[PID:%d]-[Achievement] Alocado segmento de codigo en la direccion virtual %d",
pcbNuevo->pid, pcbNuevo->codeSegment);
dataGenerica = malloc(
3 * sizeof(uint32_t) + strlen(programa) + 1);
int tamanioData = strlen(programa) + 1;
memcpy(dataGenerica, &(pcbNuevo->pid), sizeof(uint32_t));
memcpy(dataGenerica + sizeof(uint32_t), &tamanioData,
sizeof(uint32_t));
memcpy(dataGenerica + 2 * sizeof(uint32_t),
&(pcbNuevo->codeSegment), sizeof(uint32_t));
memcpy(dataGenerica + 3 * sizeof(uint32_t), programa,
tamanioData);
paqueteEscribir = pedirPaquete(dataGenerica,
KERNEL_ESCRIBIR_SEGMENTO_UMV,
3 * sizeof(uint32_t) + strlen(programa) + 1);
common_send(socketUMV, paqueteEscribir, NULL );
destruirPaquete(paqueteEscribir);
paqueteEscribir = common_receive(socketUMV, NULL );
free(dataGenerica);
destruirPaquete(paqueteEscribir);
}
if (pcbNuevo->codeIndex != -1)
{
debugTrackPLP(
"[PID:%d]-[Achievement] Alocado segmento de indice de codigo en la direccion virtual %d",
pcbNuevo->pid, pcbNuevo->codeIndex);
int tamanioData = metadataDelPrograma->instrucciones_size
* sizeof(t_intructions);
paqueteEscribir = pedirPaquete(&(pcbNuevo->pid),
KERNEL_ESCRIBIR_SEGMENTO_UMV, sizeof(int));
aniadirAlPaquete(paqueteEscribir, &(tamanioData),
sizeof(int));
aniadirAlPaquete(paqueteEscribir, &(pcbNuevo->codeIndex),
sizeof(int));
aniadirAlPaquete(paqueteEscribir,
metadataDelPrograma->instrucciones_serializado,
tamanioData);
common_send(socketUMV, paqueteEscribir, NULL );
destruirPaquete(paqueteEscribir);
paqueteEscribir = common_receive(socketUMV, NULL );
destruirPaquete(paqueteEscribir);
}
if (pcbNuevo->indiceEtiquetas != -1)
{
debugTrackPLP(
"[PID:%d]-[Achievement] Alocado segmento de indice de etiquetas en la direccion virtual %d",
pcbNuevo->pid, pcbNuevo->indiceEtiquetas);
int tamanioData = metadataDelPrograma->etiquetas_size;
dataGenerica = malloc(
(tamanioData + 1) * sizeof(char) + 3 * sizeof(int));
memcpy(dataGenerica, &(pcbNuevo->pid), sizeof(int));
memcpy(dataGenerica + sizeof(int), &tamanioData, sizeof(int));
memcpy(dataGenerica + 2 * sizeof(int),
&(pcbNuevo->indiceEtiquetas), sizeof(int));
memcpy(dataGenerica + 3 * sizeof(int),
metadataDelPrograma->etiquetas, tamanioData);
paqueteEscribir = pedirPaquete(dataGenerica,
KERNEL_ESCRIBIR_SEGMENTO_UMV, (tamanioData + 1) * sizeof(char) + 3 * sizeof(int));
common_send(socketUMV, paqueteEscribir, NULL );
destruirPaquete(paqueteEscribir);
paqueteEscribir = common_receive(socketUMV, NULL );
destruirPaquete(paqueteEscribir);
free(dataGenerica);
}
debugTrackPLP("[PID:%d]-[Achievement] PCB listo para encolarse",
pcbNuevo->pid);
paquete = pedirPaquete("A", PLP_PROGRAMA_ENCOLADO, 2);
common_send(socketCliente, paquete, NULL );
free(programa);
encolarPCB(pcbNuevo, peso, socketCliente);
}
}
else
{
destruirPaquete(paquete);
pedirPaquete("NK", PROGRAMA_CERRAR, 3);
puts("No Validado");
common_send(socketCliente, paquete, NULL );
destruirPaquete(paquete);
}
}
}
t_metadata_program *getMetadataExample() {
puts("\nThis is a fake ansisop program (hardcoded)\n");
char *programa = "begin\nvariables f, A, g \n A = 0 \n!Global = 1+A\n print !Global \n jnz !Global Siguiente \n:Proximo\n \n f = 8 \ng <- doble !Global \n io impresora 20\n :Siguiente \n imprimir A \ntextPrint Hola Mundo! \n\n sumar1 &g \n print g \n\n sinParam \n \nend\n\nfunction sinParam\n textPrint Bye\nend\n\n#Devolver el doble del\n#primer parametro\nfunction doble\nvariables f \n f = $0 + $0 \n return fvend\n\nfunction sumar1\n *$0 = 1 + *$0\nend\n\nfunction imprimir\n wait mutexA\n print $0+1\n signal mutexB\nend\n\n";
//print_instrucciones_size ();
return metadata_desde_literal(programa); // get metadata from the program
}
//testeada
pcb* crearNuevoPcb(Socket* consola, char * programaAnsisop, int tamanioArchivo) {
t_medatada_program* metaNuevoPrograma = metadata_desde_literal(
programaAnsisop);
t_intructions* instrucciones = metaNuevoPrograma->instrucciones_serializado;
t_size cantidadInstrucciones = metaNuevoPrograma->instrucciones_size;
pcb* pcbNuevoPrograma = malloc(sizeof(pcb));
idProgramas = idProgramas + 1;
puts("hola");
pcbNuevoPrograma->consola = consola;
pcbNuevoPrograma->cpu=consola;
pcbNuevoPrograma->id = idProgramas;
pcbNuevoPrograma->tamanioArchivoOriginal = tamanioArchivo;
pcbNuevoPrograma->cantPagCod=calcularCantPagCod(tamanioArchivo);
pcbNuevoPrograma->programCounter = metaNuevoPrograma->instruccion_inicio;
pcbNuevoPrograma->cantElementsStack = 0;
//todo fijarse que tengo que pedirle a la memoria
//pcbNuevoPrograma->paginasDeCodigo = cantidadPaginas(tamanioPaginas,tamanioArchivo);
pcbNuevoPrograma->paginasDeCodigo = cantidadPaginasArchivo(tamanioArchivo);
//pcbNuevoPrograma.indiceDeCodigo = crearIndiceCodigo(cantidadInstrucciones, instrucciones);
arrayBidimensional * array = (arrayBidimensional*) malloc(
cantidadInstrucciones * sizeof(arrayBidimensional));
int i = 0;
for (i = 0; i < cantidadInstrucciones; i++) {
array[i].comienzo = instrucciones[i].start;
array[i].longitud = (instrucciones[i].offset);
}
pcbNuevoPrograma->indiceDeCodigo = (arrayBidimensional*) malloc(
cantidadInstrucciones * sizeof(arrayBidimensional));
for (i = 0; i < cantidadInstrucciones; i++) {
memcpy(&(pcbNuevoPrograma->indiceDeCodigo[i]), &array[i],
sizeof(arrayBidimensional));
}
//free(array);
pcbNuevoPrograma->indiceDeCodigoSize = cantidadInstrucciones
* sizeof(arrayBidimensional);
if (metaNuevoPrograma->etiquetas != NULL) {
pcbNuevoPrograma->indiceDeEtiquetas = malloc(
sizeof(char) * (metaNuevoPrograma->etiquetas_size));
memcpy((pcbNuevoPrograma->indiceDeEtiquetas), metaNuevoPrograma->etiquetas, (metaNuevoPrograma->etiquetas_size));
pcbNuevoPrograma->indiceDeEtiquetasSize = strlen(
metaNuevoPrograma->etiquetas) + 1;
pcbNuevoPrograma->etiquetaSize = metaNuevoPrograma->etiquetas_size;
} else {
pcbNuevoPrograma->indiceDeEtiquetas = "MUERTE A WINDOWS";
pcbNuevoPrograma->indiceDeEtiquetasSize = 17;
pcbNuevoPrograma->etiquetaSize=17;
}
pcbNuevoPrograma->instruccionesTotales =
metaNuevoPrograma->instrucciones_size;
pcbNuevoPrograma->instruccionesRestantes =
metaNuevoPrograma->instrucciones_size;
pcbNuevoPrograma->estado = 0; //NEW
pcbNuevoPrograma->indiceDelStack = list_create();
pthread_mutex_lock(mutexColaNew);
list_add(listaNew, pcbNuevoPrograma);
pthread_mutex_unlock(mutexColaNew);
return pcbNuevoPrograma;
}
