t_puntero primitiva_definirVariable(t_nombre_variable variable){
t_puntero dirRetornada=-1; //---->indica ERROR ???
if(!g_expulsar){
t_size tamanio =sizeof(t_nombre_variable);
t_puntero base =g_pcb.segmento_pila;
t_size offset =dictionary_size(g_diccionario_var)*(sizeof(t_byte)+sizeof(t_palabra))+(g_pcb.cursor_de_pila-g_pcb.segmento_pila); //cada varibale ocupa 5 bytes(1byte:nombre+4bytes:contenido)
printf("***primitiva--->definir Varible***\n");
printf(" --->mandando a guardar var:%c base:%i offset:%i tamanio:%i<---\n",variable,base,offset,tamanio);
log_debug(g_logger,":::primitiva_definirVariable:::\n mandando a guardar la var:%c base:%i offset:%i tam:%i",variable,base,offset,tamanio);
//ENVIA MENSAJE A UMV CON: base+offset+tamaño+contenido a almacenar
if(escrituraUMV(base,offset,tamanio,(t_byte *)&variable)==-1){//=>segmentation fault?
//error--->segmento sobrepasado
printf("error de escritura de nombre de variable en umv -sEGMENTATIoN FAuLT-\n");
log_debug(g_logger,"Error en la escritura del nombre de una variable en umv...");
falloMemoria();
}else{
t_var *var_diccio =crearVarDiccio(variable,offset+1);
//printf("se guardara la variable var_diccio->nombre_var:%s var_diccio->dir:%i\n",var_diccio->nombre_var,var_diccio->direccion_var);
dictionary_put(g_diccionario_var,var_diccio->nombre_var,var_diccio);
g_pcb.tamanio_contexto_actual++;
dirRetornada=offset+1;
}
}
return dirRetornada;
}
void enviarPCB(pcb_t* pcb,int cpu, int quantum, int quantum_sleep){
//NO TESTEADO
serializablePCB aMandaCpu;
aMandaCpu.PID = *(pcb->PID);
aMandaCpu.PC= *(pcb->PC);
aMandaCpu.PCI = *(pcb->PCI);
aMandaCpu.SP = *(pcb->SP);
aMandaCpu.paginasDisponible = *(pcb->paginasDisponible);
aMandaCpu.tamanioIndiceCodigo = dictionary_size(pcb->indice_codigo);
aMandaCpu.tamanioStack = dictionary_size(pcb->indice_stack);
aMandaCpu.tamanioIndiceDeFunciones = list_size(pcb->indice_funciones);
int enviaPCB = 163;
enviarCPUConHeader(cpu,enviaPCB,sizeof(serializablePCB),&aMandaCpu,*(pcb->PID));
/*
* Orden:
* Indice de codigo
* Indice de funciones
* [int (tamanio nombre funcion)] [int posicion] [char* funcion]
* stack
* //Tamanio Args
* //Tamanio Vars
* //PidRetorno, -1 si es el main
* //direccion de memoria
* //Lista Args
* //Lista Vars
*
*/
//Empieza serializacion de listas y diccionarios
//serializo indice de codigo y lo mando
int tamanioIndiceCode = aMandaCpu.tamanioIndiceCodigo;
int i;
for(i=0;i<tamanioIndiceCode && tamanioIndiceCode !=0;i++){
direccionMemoria* aMandar = dictionary_get(pcb->indice_codigo,&i);
enviarCPU(cpu,sizeof(direccionMemoria),aMandar,*(pcb->PID));
}
//serializo indice de funciones y lo mando
int tamanioIndiceFunciones = aMandaCpu.tamanioIndiceDeFunciones;
for(i=0;i<tamanioIndiceFunciones && tamanioIndiceFunciones != 0;i++){
//SS sin serializar
//CS con serializado
funcion_sisop* funcionAMandarSS = list_get(pcb->indice_funciones,i);
funcionTemp func;
func.tamanioNombreFuncion = strlen(funcionAMandarSS->funcion)+1;//+1 para garegar el \0
func.posicionPID = *(funcionAMandarSS->posicion_codigo);
//Envio Tamanio y posicion
enviarCPU(cpu,sizeof(funcionTemp),&func,*(pcb->PID));
//Envio nombre funcion
enviarCPU(cpu,func.tamanioNombreFuncion,strcat(funcionAMandarSS->funcion,"\0"),*(pcb->PID));
}
//serializo stack y lo mando
//TESTEAR MUCHO YA Q ES UN KILOMBO
int tamanioStack = aMandaCpu.tamanioStack;
for(i=0;i<tamanioStack && tamanioStack!= 0;i++){
stack* stackAMandar = dictionary_get(pcb->indice_stack,&i);
//Puede ser null
int tamanioArgs;
if(stackAMandar->args!=NULL)
tamanioArgs = list_size(stackAMandar->args);
else
tamanioArgs = -1;
//Puede ser null
int tamanioVars;
if(stackAMandar->vars!=NULL)
tamanioVars = list_size(stackAMandar->vars);
else
tamanioVars = -1;
//Puede ser null
int PIDretorno;
if(stackAMandar->pos_ret!=NULL)
PIDretorno = *(stackAMandar->pos_ret);//;
else
PIDretorno = -1;
//Puede ser null
direccionMemoria direccionRetornoFuncion;
if(stackAMandar->memoriaRetorno!=NULL)
direccionRetornoFuncion = *(stackAMandar->memoriaRetorno);
else{
direccionRetornoFuncion.offset = -1;
direccionRetornoFuncion.pagina = -1;
direccionRetornoFuncion.tamanio = -1;
}
enviarCPU(cpu,sizeof(int),&tamanioArgs,*(pcb->PID));
enviarCPU(cpu,sizeof(int),&tamanioVars,*(pcb->PID));
enviarCPU(cpu,sizeof(int),&PIDretorno,*(pcb->PID));
enviarCPU(cpu,sizeof(direccionMemoria),&direccionRetornoFuncion,*(pcb->PID));
int j;
t_list* args = stackAMandar->args;
for(j=0;j<tamanioArgs;j++){
direccionMemoria* direccionMemoriaArg = list_get(args,j);
enviarCPU(cpu,sizeof(direccionMemoria),direccionMemoriaArg,*(pcb->PID));
}
t_list* vars = stackAMandar->vars;
for(j=0;j<tamanioVars;j++){
direccionStack* direccionStackVars = list_get(vars,j);
enviarCPU(cpu,sizeof(direccionStack),direccionStackVars,*(pcb->PID));
}
}
enviarCPU(cpu,sizeof(int),&quantum,*(pcb->PID));
enviarCPU(cpu,sizeof(int),&quantum_sleep,*(pcb->PID));
//!!!!!!!!!!!!!!!!!!!!!!!!!
//LIBERAR TODA MEMORIA PCB!
//!!!!!!!!!!!!!!!!!!!!!!!!!
return;
}
/*********************************************************************************************
F_SECUNDARIA: Creando un BSON del archivo, para insertalo en la DB TESTEADO =)
****************************/
bson_t * crearDocumentoParaLaDB(char * nombreDelArchivo, long tamanioDelArchivo, int dirPadreDelArchivo, t_dictionary * diccionarioDeBloques)
//Va eliminando el diccionario que ingresa por parametro :D
{
bson_t child; bson_t child2; bson_t child3; bson_t child4;
bson_oid_t oid;
int cantidadTotalDeBloques;
int identificadorDelBloque = 0;
t_dictionary* copiasDelBloqueX;
t_copiaX* copiaX;
char * iDelBloque;
//FIN DECLARACION DE VARIABLES
bson_t * documento = bson_new();
// ::: Estructura BASICA del documento :::
bson_oid_init (&oid, NULL);
BSON_APPEND_OID (documento, "_id", &oid);
BSON_APPEND_UTF8 (documento, "nombreDelArchivo", nombreDelArchivo);
BSON_APPEND_INT32 (documento, "tamanio", tamanioDelArchivo);
BSON_APPEND_INT32 (documento, "dirPadre", dirPadreDelArchivo);
BSON_APPEND_INT32 (documento, "estado", 1);
cantidadTotalDeBloques = dictionary_size(diccionarioDeBloques);
BSON_APPEND_INT32 (documento, "cantidadDeBloques", cantidadTotalDeBloques);
// ::: Estructura de BLOQUES del documento :::
//Guardando los N bloques con copias 3
bson_append_document_begin (documento, "Bloques", 7, &child);
while(identificadorDelBloque < cantidadTotalDeBloques)
{
iDelBloque = string_itoa(identificadorDelBloque);
bson_append_document_begin (&child, iDelBloque, 1, &child2);
copiasDelBloqueX = (t_dictionary*) dictionary_get( diccionarioDeBloques, iDelBloque );
//Guardando la cantidad de copias del bloque X
BSON_APPEND_INT32 (&child2, "cantidadDeCopias", 3);
//Guardando las 3 copias para el bloque X
bson_append_array_begin (&child2, "copias", 6, &child4);
copiaX = (t_copiaX*) dictionary_get( copiasDelBloqueX, "1" );
int Guachin= dictionary_size(copiasDelBloqueX);
bson_append_document_begin (&child4, "0", 1, &child3);
bson_append_int32(&child3,"IP", 2, (*copiaX).IP);
bson_append_int32(&child3, "puerto", 6, (*copiaX).puerto);
bson_append_int32(&child3, "numBloque", 9, (*copiaX).numBloque);
bson_append_document_end (&child4, &child3);
copiaX = (t_copiaX*) dictionary_get( copiasDelBloqueX, "2" );
bson_append_document_begin (&child4, "1", 1, &child3);
bson_append_int32(&child3,"IP", 2, (*copiaX).IP);
bson_append_int32(&child3, "puerto", 6, (*copiaX).puerto);
bson_append_int32(&child3, "numBloque", 9, (*copiaX).numBloque);
bson_append_document_end (&child4, &child3);
copiaX = (t_copiaX*) dictionary_get( copiasDelBloqueX, "3" );
bson_append_document_begin (&child4, "2", 1, &child3);
bson_append_int32(&child3,"IP", 2, (*copiaX).IP);
bson_append_int32(&child3, "puerto", 6, (*copiaX).puerto);
bson_append_int32(&child3, "numBloque", 9, (*copiaX).numBloque);
bson_append_document_end (&child4, &child3);
bson_append_array_end (&child2, &child4);
dictionary_clean(copiasDelBloqueX);
dictionary_destroy(copiasDelBloqueX);
//Anido las 3 copias al bloque X
bson_append_document_end (&child, &child2);
free(iDelBloque);
identificadorDelBloque++;
};
//::Estructura BASICA + estructura BLOQUES::
bson_append_document_end (documento, &child);
//Elimino el diccionarioDeBloques
dictionary_clean(diccionarioDeBloques);
dictionary_destroy(diccionarioDeBloques);
return documento;
}
