void enqueue(pnodo *H,pnodo *T, void *c)
{
pnodo p = crea(c);
if (p!=NULL)
{
if ((*T)!=NULL) (*T)->next=p;
else ((*H)=p);
*T=p;
}
else printf("OverFlow\n");
}
int main(){
Elem e1[10]={65,66,67,68,69,70};
Elem e2[10]={69,70,71,72,73,74,75,76};
Conjunto c1=crea(e1,6);
Conjunto c2=crea(e2,8);
imprime(union1(c1,c2));
puts("");
printf("%d",cardinalidad(union1(c1,c2)));
puts("");
imprime(interseccion(c1,c2));
puts("");
printf("%d\n",cardinalidad(interseccion(c1,c2)));
imprime(diferencia(c1,c2));
return 0;
}
lista* crea(lista* p,int n)
{
if(p == NULL)
{
p = (lista*)malloc(sizeof(lista));
p->dato = n;
p->next = NULL;
}
else
p->next = crea(p->next,n);
return p;
}
lista* domanda(lista *p)
{
int n;
do
{
printf("Inserisci : ");
scanf("%d",&n);
if(n > 0)
p = crea(p,n);
}while(n > 0);
return p;
}
int Q3DGraph::load() {
func3d.vars.modifica("x", 0);
func3d.vars.modifica("y", 0);
func3d.Calcula();
if(func3d.err.isEmpty()) {
QTime t;
t.restart();
mem();
tefunc=true;
crea();
this->repaint();
sendStatus(i18n("Done: %1ms").arg(t.elapsed()));
return 0;
} else {
sendStatus(i18n("<b>Error:</b> %1").arg(func3d.err));
tefunc=false;
this->repaint();
return -1;
}
}
/**
* Aca se atiende todos lo que llega desde la CPU.
* Interfaz expuesta a la CPU.
*/
void _atender_socket_cpu(conexion_cpu_t* conexion_cpu)
{
if(conexion_cpu == NULL)
return;
char* mensaje;
uint32_t len;
int32_t resultado = recibir(conexion_cpu->socket, &mensaje, &len);
tcb_t* tcbKM = get_tcb_km();
if(resultado == 0)
{
flag_t cod_op = codigo_operacion(mensaje);
printf("-- Recibimos request de CPU %d\n", conexion_cpu->id);
printf("");
bloquear_exit();
printf("- Codigo de operacion %d\n", cod_op);
printf("");
switch (cod_op) {
case MANDA_TCB:
printf("Pedido de TCB de CPU %d\n", conexion_cpu->id);
printf("");
pedir_tcb(conexion_cpu->id);
break;
case TOMA_RESULTADO:
;
pedido_con_resultado_t* pedido_resultado = deserializar_pedido_con_resultado_t(mensaje);
if(!proceso_muriendo(pedido_resultado->tcb->pid))
{ // Recibimos el TCB y esta todos OK
printf("Recibimos TCB con resultado %d\n", pedido_resultado->resultado);
printf("");
recibir_tcb(pedido_resultado->resultado, pedido_resultado->tcb);
}
else if(pedido_resultado->tcb->km)
{ // Recibimos el TCB de un proceso muriendo, siendo este el TCB KM (hay que replanificar KM?)
//eliminar_conclusion_tcb();
replanificar_tcb_km();
}
else
{// Recibimos el TCB de un proceso muriendo
// Creo que en este caso no hay que hacer nada
}
_enviar_completadook(conexion_cpu->socket);
free(pedido_resultado->tcb);
free(pedido_resultado);
planificar();
break;
case INTERRUPCION:
;
pedido_interrupcion_t* pedido_interrupcion = deserializar_pedido_interrupcion_t(mensaje);
logear_instruccion_protegida("INTERRUPCION", pedido_interrupcion->tcb);
if(!proceso_muriendo(pedido_interrupcion->tcb->pid))
interrupcion(pedido_interrupcion->tcb, pedido_interrupcion->direccion_de_memoria);
_enviar_completadook(conexion_cpu->socket);
free(pedido_interrupcion->tcb);
free(pedido_interrupcion);
break;
case ENTRADA_ESTANDAR:
logear_instruccion_protegida("ENTRADA ESTANDAR", get_tcb_km());
pedido_entrada_estandar_t* pedido_entrada = deserializar_pedido_entrada_estandar_t(mensaje);
if(!proceso_muriendo(tcbKM->pid))
{
if(enviar_entrada_estandar(pedido_entrada) == 0)
{
}
else
{
//_informar_fallo_syscall(conexion_cpu->socket);
}
}
free(pedido_entrada);
break;
case SALIDA_ESTANDAR:
logear_instruccion_protegida("SALIDA ESTANDAR", get_tcb_km());
pedido_salida_estandar_t* pedido_salida = deserializar_pedido_salida_estandar_t(mensaje);
if(!proceso_muriendo(tcbKM->pid))
{
if(salida_estandar(pedido_salida) == 0)
_enviar_completadook(conexion_cpu->socket);
else
{
_informar_fallo_syscall(conexion_cpu->socket);
}
}
else
{
_enviar_completadook(conexion_cpu->socket);
}
free(pedido_salida->cadena_de_texto);
free(pedido_salida);
break;
case JOIN:
logear_instruccion_protegida("JOIN", get_tcb_km());
pedido_join_t* pedido_join = deserializar_pedido_join_t(mensaje);
if(!proceso_muriendo(tcbKM->pid))
join(pedido_join->tid_llamador, pedido_join->tid_esperador);
_enviar_completadook(conexion_cpu->socket);
free(pedido_join);
break;
case BLOQUEAR:
logear_instruccion_protegida("BLOQUEAR", get_tcb_km());
pedido_bloquear_t* pedido_bloqueo = deserializar_pedido_bloquear_t(mensaje);
// No usamos el TCB porque el que se esta bloqueando
// es el que esta esperando la conclusion del KM
if(!proceso_muriendo(tcbKM->pid))
bloquear(pedido_bloqueo->identificador_de_recurso);
_enviar_completadook(conexion_cpu->socket);
free(pedido_bloqueo->tcb);
free(pedido_bloqueo);
break;
case DESPERTAR:
logear_instruccion_protegida("DESPERTAR", get_tcb_km());
pedido_despertar_t* pedido_despertar = deserializar_pedido_despertar_t(mensaje);
if(!proceso_muriendo(tcbKM->pid))
despertar(pedido_despertar->identificador_de_recurso);
_enviar_completadook(conexion_cpu->socket);
free(pedido_despertar);
break;
case CREAR_HILO:
logear_instruccion_protegida("CREAR HILO", get_tcb_km());
pedido_crear_hilo_t* pedido_crea = deserializar_pedido_crear_hilo_t(mensaje);
crea(pedido_crea->tcb, conexion_cpu->id);
break;
case DESCONEXION_CPU:
loggear_desconexion_cpu(conexion_cpu->id);
quitar_cpu_de_lista_espera_tcb(conexion_cpu->id);
FD_CLR(conexion_cpu->socket->fd, &READFDS_CPUS);
if(esta_ejecutando(conexion_cpu->id))
{
tcb_t* t = get_tcb_ejecutando_en_cpu(conexion_cpu->id);
mover_tcbs_a_exit(t->pid, true);
}
remover_y_eliminar_conexion_cpu(conexion_cpu->id);
break;
case CREA_UN_SEGMENTO:
;
pedido_de_crear_segmento_t* pedido_crear_segmento = deserializar_pedido_de_crear_segmento_t(mensaje);
crear_segmento_cpu(pedido_crear_segmento->pid, pedido_crear_segmento->tamano,&(conexion_cpu->id));
break;
case DESTRUI_SEGMENTO:
;
pedido_de_destruir_segmento_t* pedido_destruir_segmento = deserializar_pedido_de_destruir_segmento_t(mensaje);
destruir_segmento_cpu(pedido_destruir_segmento->pid,pedido_destruir_segmento->direccion_virtual, &(conexion_cpu->id));
break;
default:
break;
}
desbloquear_exit();
printf("-- Terminamos request de CPU %d\n", conexion_cpu->id);
printf("");
free(mensaje);
}
}
void Q3DGraph::paintGL() {
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
if(keyspressed & KEYDOWN) graus[0]+=3.f;
if(keyspressed & KEYUP) graus[0]-=3.f;
if(keyspressed & KEYAVPAG) graus[1]+=3.f;
if(keyspressed & KEYREPAG) graus[1]-=3.f;
if(keyspressed & KEYLEFT) graus[2]+=3.f;
if(keyspressed & KEYRIGHT) graus[2]-=3.f;
if(keyspressed & KEYW) z/=1.1f;
if(keyspressed & KEYS) z= z!=0. ? z*1.1f : .1f;
if(keyspressed & KEYQ) { zoom/=2.0f; crea(); }
if(keyspressed & KEYE) { zoom*=2.0f; crea(); }
graus[0] = graus[0]>=360.f ? graus[0]-360.f : graus[0];
graus[1] = graus[1]>=360.f ? graus[1]-360.f : graus[1];
graus[2] = graus[2]>=360.f ? graus[2]-360.f : graus[2];
glTranslatef(0.0f, 0.0f, z);
glRotatef(graus[0], 1.0, 0.0, 0.0);
glRotatef(graus[1], 0.0, 1.0, 0.0);
glRotatef(graus[2], 0.0, 0.0, 2.0);
double mida=default_size*zoom, step=default_step*zoom;
dibuixa_eixos();
int i,j;
if(method == G_POINTS || method == G_LINES) {
if(method == G_POINTS){
glBegin(GL_POINTS);
} else if(method == G_LINES){
glBegin(GL_LINES);
}
for(i=0; tefunc && i<(2*mida/step)-1; i++) {
for(j=0; tefunc && j<2*mida/step-1; j++) {
if(method == G_POINTS){
glColor3d( i*step/mida, j*step/mida, punts[i][j]/5);
glVertex3d( i*step-mida, j*step - mida, punts[i][j]);
} else {
if(method == G_LINES)
glColor3d( i*step/mida, j*step/mida, punts[i][j]/5);
else
glColor3d( 0.0,0.0,0.0);
glVertex3d( i*step-mida, j*step - mida, punts[i][j]);
glVertex3d( (i?i-1:i)*step-mida, j*step - mida, punts[i?i-1:i][j]);
glVertex3d( i*step-mida, j*step - mida, punts[i][j]);
glVertex3d( i*step-mida, (j?j-1:j)*step - mida, punts[i][j?j-1:j]);
}
}
}
glEnd();
} else if(method == G_SOLID){
if(trans){
glEnable(GL_BLEND);
glDisable(GL_DEPTH_TEST);
glBlendFunc(GL_SRC_ALPHA,GL_ONE);
}else{
glDisable(GL_BLEND);
glEnable(GL_DEPTH_TEST);
}
double trans=0.8;
glEnable(GL_TEXTURE_2D);
glBegin(GL_QUADS);
for(i=0; tefunc && i<(2*mida/step)-2; i++) {
for(j=0; tefunc && j<2*mida/step-2; j++) {
if(abs(punts[i][j]-punts[i][j+1])>700000. || abs(punts[i][j]-punts[i+1][j])>700000.){
// qDebug("assimptota %f %f", punts[i][j], punts[i][j+1]);
} else {
if(punts[i][j]>300.)
qDebug("%f %f %f %f", punts[i][j], punts[i+1][j], punts[i][j+1], punts[i+1][j+1]);
glTexCoord2f(0.0f, 1.0f);
glColor4d( i*step/mida/2, (j+1)*step/mida/2, punts[i][j+1]/5, trans);
glVertex3d( i*step-mida, (j+1)*step - mida, punts[i][j+1]);
glTexCoord2f(0.0f, 0.0f);
glColor4d( i*step/mida/2, j*step/mida/2, punts[i][j]/5, trans);
glVertex3d( i*step-mida, j*step - mida, punts[i][j]);
glTexCoord2f(1.0f, 0.0f);
glColor4d((i+1)*step/mida/2, j*step/mida/2, punts[i+1][j]/5, trans);
glVertex3d( (i+1)*step-mida, j*step - mida, punts[i+1][j]);
glTexCoord2f(1.0f, 1.0f);
glColor4d((i+1)*step/mida/2, (j+1)*step/mida/2, punts[i+1][j+1]/5,trans);
glVertex3d( (i+1)*step-mida, (j+1)*step - mida, punts[i+1][j+1]);
}
}
}
glEnd();
glDisable(GL_TEXTURE_2D);
}
glFlush();
}
