pedido_crear_hilo_t* deserializar_pedido_crear_hilo_t(char* chorro)
{
pedido_crear_hilo_t* pedido = malloc(sizeof(pedido_crear_hilo_t));
uint32_t offset = 0;
memcpy(&pedido->flag, chorro + offset, sizeof(flag_t));
offset += sizeof(flag_t);
pedido->tcb = malloc(sizeof(tcb_t));
memcpy(pedido->tcb, deserializar_tcb(chorro + offset), sizeof(tcb_t));
return pedido;
}
pedido_bloquear_t* deserializar_pedido_bloquear_t(char* chorro)
{
pedido_bloquear_t* pedido = malloc(sizeof(pedido_bloquear_t));
uint32_t offset = 0;
memcpy(&pedido->flag, chorro + offset, sizeof(flag_t));
offset += sizeof(flag_t);
memcpy(&pedido->identificador_de_recurso, chorro + offset, sizeof(uint32_t));
offset += sizeof(uint32_t);
pedido->tcb = malloc(sizeof(tcb_t));
memcpy(pedido->tcb, deserializar_tcb(chorro + offset), sizeof(tcb_t));
return pedido;
}
pedido_interrupcion_t* deserializar_pedido_interrupcion_t(char* chorro)
{
pedido_interrupcion_t* pedido = malloc(sizeof(pedido_interrupcion_t));
uint32_t offset = 0;
memcpy(&pedido->flag, chorro + offset, sizeof(flag_t));
offset += sizeof(flag_t);
memcpy(&pedido->direccion_de_memoria, chorro + offset, sizeof(direccion));
offset += sizeof(direccion);
pedido->tcb = malloc(sizeof(tcb_t));
memcpy(pedido->tcb, deserializar_tcb(chorro + offset), sizeof(tcb_t));
return pedido;
}
respuesta_de_nuevo_tcb_t* deserializar_respuesta_de_nuevo_tcb_t(char* chorro)
{
respuesta_de_nuevo_tcb_t* rta_nuevo_tcb = malloc(
sizeof(respuesta_de_nuevo_tcb_t));
uint32_t offset = 0;
memcpy(&rta_nuevo_tcb->flag, chorro + offset, sizeof(flag_t));
offset += sizeof(flag_t);
memcpy(&rta_nuevo_tcb->quantum, chorro + offset, sizeof(uint32_t));
offset += sizeof(uint32_t);
rta_nuevo_tcb->tcb = malloc(sizeof(tcb_t));
memcpy(rta_nuevo_tcb->tcb, deserializar_tcb(chorro + offset),
sizeof(tcb_t));
return rta_nuevo_tcb;
}
int main(void) {
int i;
t_hilo hilo,hilo2;
uint16_t quantum = 27,quantum2 = 0;
hilo.base_stack = 17632785;
hilo.cola = READY;
hilo.cursor_stack = 127;
hilo.kernel_mode = 0;
hilo.pid = 1147;
hilo.puntero_instruccion = 2;
for (i = 0; i < 5; ++i)
hilo.registros[i] = 13 + i;
hilo.segmento_codigo = 38155741;
hilo.segmento_codigo_size = 1024;
hilo.tid = 0;
char* stream = serializar_tcb(&hilo,quantum);
quantum2 = (uint16_t) *stream;
deserializar_tcb(&hilo2,(stream + 2));
printf("Quantum Valor: %8d\n", quantum2);
printf("Registro PID Valor: %8d\n", hilo2.pid);
printf("Registro TID Valor: %8d\n", hilo2.tid);
printf("Registro KM Valor: %8d\n", hilo2.kernel_mode);
printf("Registro CS Valor: %8d\n", hilo2.segmento_codigo);
printf("Registro CS_Size Valor: %8d\n", hilo2.segmento_codigo_size);
printf("Registro IP Valor: %8d\n", hilo2.puntero_instruccion);
printf("Registro Stack Valor: %8d\n", hilo2.base_stack);
printf("Registro Stack_Size Valor: %8d\n", hilo2.cursor_stack);
for(i = 0;i < 5; ++i)
printf("Registro %c. Valor: %8d\n",('A'+i), hilo2.registros[i]);
printf("Registro COLA: %8d\n", hilo2.cola);
puts("\n");
return 0;
}
pedido_con_resultado_t* deserializar_pedido_con_resultado_t(char* chorro)
{
pedido_con_resultado_t* pedido_con_resultado = malloc(sizeof(pedido_con_resultado_t));
uint32_t offset = 0;
memcpy(&pedido_con_resultado->flag, chorro + offset, sizeof(flag_t));
offset += sizeof(flag_t);
memcpy(&pedido_con_resultado->informacion, chorro + offset, sizeof(int32_t));
offset += sizeof(int32_t);
memcpy(&pedido_con_resultado->resultado, chorro + offset, sizeof(resultado_t));
offset += sizeof(resultado_t);
pedido_con_resultado->tcb = malloc(sizeof(tcb_t));
tcb_t* tcb = deserializar_tcb(chorro + offset);
memcpy(pedido_con_resultado->tcb, tcb, sizeof(tcb_t));
free(tcb);
return pedido_con_resultado;
}
