Пример #1
0
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");
}
Пример #2
0
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;   
}
Пример #3
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;
}
Пример #4
0
lista* domanda(lista *p)
{
    int n;

    do
    {
        printf("Inserisci : ");
        scanf("%d",&n);

        if(n > 0)
            p = crea(p,n);
    }while(n > 0);

    return p;
}
Пример #5
0
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);
	}
}
Пример #7
0
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();
}