SHARE
TWEET

ORIANA

a guest Jun 15th, 2019 60 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #include <stdio.h>
  2. #include<pthread.h>
  3. #include <time.h>
  4. #include <unistd.h>
  5. #include<stdlib.h>
  6. #include <sys/time.h>
  7. /* Time in seconds from some point in the past */
  8.  
  9. /*****************************************************************/
  10.  
  11.  
  12.  
  13. double dwalltime()
  14. {
  15.     double sec;
  16.     struct timeval tv;
  17.  
  18.     gettimeofday(&tv,NULL);
  19.     sec = tv.tv_sec + tv.tv_usec/1000000.0;
  20.     return sec;
  21. }
  22.  
  23. //FIN de calcular tiempo
  24.  
  25.  
  26. int N = 4;
  27. /*Variables pertenecientes a los hilos*/
  28. int P=0;
  29. pthread_mutex_t s=PTHREAD_MUTEX_INITIALIZER;
  30. /*Variables a reemplazar por argumentos*/
  31. int Min=999;
  32. int Max=-1;
  33. int check = 1;
  34.  
  35. /*matriz A por fila y por columnas*/
  36. int *Af,*Ac,*L,*U,*A,*At,*AU,*AL,*AA ,*AAt,*RESULT;
  37. double timetick;
  38.  
  39.  
  40.  
  41.  
  42.  
  43.  
  44.  
  45.  
  46.  
  47.  
  48. //funcion para poder visualizar matriz
  49. void vermatriz(int* m,int modo){
  50. /*LE DA EL FORMATO A LA COLUMNA*/
  51.         printf(" \t Columna |\t");
  52.         for(int k=0;k<N;k++){
  53.             printf(" %d \t",k);
  54.         }
  55.         printf("\n");
  56.         printf("\t -------------------------------------------");
  57.         printf("\n");  
  58.  
  59.         printf("\t");
  60.         for(int i=0;i<N;i++){
  61.             printf(" Fila %d  |\t",i);
  62.                for(int j=0;j<N;j++){
  63.                     if(modo = 0){
  64.                         printf(" %d \t",m[i*N+j] );//recorre por fila
  65.                     }
  66.                     else{
  67.                         printf(" %d \t",m[i+j*N] );//recorre por columna
  68.                         }
  69.                 }
  70.                 printf("\n \t");
  71.            }
  72.                
  73. }
  74.  
  75.  
  76. //funcion que hace la tarea de forma secuencial
  77. void resultadoSecuencial(){
  78.  
  79.         /*OPERACION  L*A  */
  80.  
  81.  
  82.     for(int i=0;i<N;i++){
  83.            for(int j=0;j<N;j++){
  84.                  for(int k=0;k<N;k++) {
  85.                    AL[j*N+i] = ( A[i*N+k] * L[k+j*N] ) + AL[j*N+i];
  86.  
  87.  
  88.     //SE MUEVE POR  COLUMNA         FILA        COLUMNA
  89.                  }
  90.                }
  91.             }
  92.  
  93.  
  94.         /*OPERACION  A*At  */
  95.  
  96.  
  97.         for(int i=0;i<N;i++){
  98.               for(int j=0;j<N;j++){
  99.                 for(int k=0;k<N;k++) {
  100.                   AAt[i*N+j]+= A[i*N+k] * At[i*N+k];
  101.     //SE MUEVE POR  FILA        FILA        COLUMNA
  102.                 }
  103.               }
  104.             }
  105.  
  106.  
  107.         /*OPERACION  U*A  */
  108.  
  109.  
  110.  
  111.         for(int i=0;i<N;i++){
  112.               for(int j=0;j<N;j++){
  113.                 for(int k=0;k<N;k++) {
  114.                   AU[i*N+j]+= U[i*N+k] * Ac[k+j*N];
  115.     //SE MUEVE POR  FILA        FILA        COLUMNA
  116.                 }
  117.               }
  118.             }
  119.  
  120.  
  121. // vamos a hacer esteeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee!!!!!!!!!!!
  122.  
  123.         /*OPERACION DE MAXIMO Y MINIMO  forma secuencial*/
  124.  
  125. /*
  126.         for(int i=0;i<N;i++){
  127.                 for(int j=0;j<N;j++){
  128.                         if(AU[i*N+j]>max){
  129.                                 max=AU[i*N+j];
  130.                         }
  131.                         else{
  132.                             if(AU[i*N+j]<min)
  133.                               {
  134.                                 min=AU[i*N+j];
  135.                               }
  136.                         }
  137.                 }
  138.             }
  139.             */
  140.  
  141.  
  142. }
  143.  
  144. /*Paralelizamos!!!!!!!!!!!!!!!!!!!!!!!!!!!!! :D:D:D:D::D:D */
  145.  
  146. /*Funcion para */
  147. void * Funcion_maxmin(void * arg){
  148.  
  149.  
  150.     int tid = *(int*) arg;
  151.     int ini= tid*(P);
  152.     int fin= (tid+1)*(P);
  153.     int min=999;  int max=-1;  // es mejor calcular los minimos y maximos de manera local
  154.     // y al final pasarselos a una variable global minimo y maximo. Esto es debido a la rapidez
  155.     printf(" \n ");
  156.     printf(" \n ");
  157.     printf(" ESTOY EN LA FUNCION DE H %d",tid);
  158.     printf(" \n ");
  159.     printf(" \n ");
  160.     printf(" INI %d FIN  %d",ini,fin);
  161.     printf(" \n ");
  162.     printf(" \n ");
  163.  
  164.     for(int i=ini;i<fin;i++){
  165.             printf(" \n ");
  166.             printf(" \n ");
  167.             printf(" FILA %d ",i);
  168.             printf(" \n ");
  169.             printf(" \n ");
  170.            for(int j=ini;j<fin;j++){
  171.             printf(" \n ");
  172.             printf(" \n ");
  173.             printf(" COLUMNA %d ",j);
  174.             printf(" \n ");
  175.             printf(" \n ");
  176.                 if(AU[i*fin+j]<min){
  177.                    
  178.                         min=AU[i*N+j];  
  179.                    
  180.                 }
  181.                 if(AU[i*fin+j]>max){
  182.                    
  183.                         max=AU[i*N+j];
  184.                
  185.                 }
  186.             }
  187.     }
  188.     // se lo pasamos a la variable global
  189.    
  190.         pthread_mutex_lock(&s);
  191.             if(min<Min){
  192.                 Min=min;
  193.             }
  194.         pthread_mutex_unlock(&s);
  195.            
  196.            
  197.     pthread_mutex_lock(&s);
  198.             if(max>Max){
  199.                 Max=max;
  200.             }
  201.            
  202.     pthread_mutex_unlock(&s);
  203.     pthread_exit(NULL); //finalizacion del hilo
  204.    
  205. }
  206.  
  207.  
  208.  
  209.  
  210. int main(int argc,char*argv[]){
  211.     int H=2; // es un valor por defecto en el caso de que no se
  212.     // introduzca ningun valor por consola.
  213.  
  214.  //Controla los argumentos al programa
  215.     if ((argc != 3) || ((N = atoi(argv[1])) <= 0) || ((H = atoi(argv[2])) <= 0) )
  216.     {
  217.         printf("\nUsar: %s n\n  h: cant hilos  \n", argv[0]);
  218.         exit(1);
  219.     }
  220.  
  221.  
  222.     /*Declarar e inicializaciones*/
  223.     N=atoi(argv[1]); // Inicializa valor de mi arreglo de N elementos
  224.     H=atoi(argv[2]); //incializar valor de hilos
  225.  
  226.  
  227.     //calculamos la proporcion
  228.     P=N/H;
  229.  
  230.     // ejemplo  a = (double *) malloc(n*n*sizeof(double));
  231.         /*matriz A por fila y por columnas*/
  232.         Af = (int*)malloc(N*N*sizeof(int));
  233.         Ac = (int*)malloc(N*N*sizeof(int));
  234.         /*Matrices triangular superior e inferiror*/
  235.         L = (int*)malloc(N*N*sizeof(int));
  236.         U = (int*)malloc(N*N*sizeof(int));
  237.         /*Matriz A original*/
  238.         A = (int*)malloc(N*N*sizeof(int));
  239.         /*almacena la matriz transpuesta de A, el producto de tri sup por A y tri inf por A*/
  240.         At = (int*)malloc(N*N*sizeof(int));
  241.         AU = (int*)malloc(N*N*sizeof(int));
  242.         AL = (int*)malloc(N*N*sizeof(int));
  243.         AA = (int*)malloc(N*N*sizeof(int));
  244.         AAt = (int*)malloc(N*N*sizeof(int));
  245.         /*almacena en la variable resultado */
  246.         RESULT = (int*)malloc(N*N*sizeof(int));
  247.  
  248.  
  249.  
  250.  
  251.     /*---- iniialisa por filas---*/
  252.  
  253.     /*---- iniialisa por columnas---*/
  254.  //iniializa los valores de la matriz A cuadrada
  255.     for(int i=0;i<N;i++){
  256.        for(int j=0;j<N;j++){
  257.             A[i*N+j]= 1;
  258.             Ac[i+j*N]=1;
  259.             Af[i*N+j]=1;
  260.             AU[i*N+j]=0;
  261.             AL[i*N+j]=0;
  262.             AAt[j*N+i]=0;
  263.         }
  264.     }
  265.  
  266. //iniializa la matriz L
  267.     for(int i=0;i<N;i++){
  268.        for(int j=0;j<N;j++){
  269.             if (i>=j)
  270.             {
  271.                 L[i+j*N]= 1;
  272.             }
  273.             else
  274.             {
  275.                 L[i+j*N]= 0;   // ori estuvo aca era 0
  276.             }
  277.  
  278.        }
  279.       }
  280.  
  281. //iniializa la matriz U
  282.       for(int i=0;i<N;i++){
  283.        for(int j=0;j<N;j++){
  284.             if (i>=j)
  285.             {
  286.                 U[i*N+j]= 1;
  287.             }
  288.             else
  289.             {
  290.                 U[i*N+j]= 0;
  291.             }
  292.  
  293.        }
  294.       }
  295. //--------------------------------
  296. // trabajamos con los hilos
  297.    
  298.  
  299.     //Reservo memoria para el vector de hilos
  300.     pthread_t* tid = (pthread_t*)(malloc(sizeof(pthread_t)*H)); // por esto me daba error!
  301.     int* threads_ids =  (int*)(malloc(sizeof(int)*H));
  302.     pthread_mutex_init(&s,NULL); // inicializacion s
  303.  
  304.  //Realiza el tiempo inicial para la busqueda y calclulo
  305.  
  306. timetick = dwalltime();
  307. for (int t = 0; t < H; t++)
  308. {
  309.     threads_ids[t]=t;
  310.     pthread_create(&tid[t],NULL,Funcion_maxmin,(void *)&threads_ids[t]);
  311.    
  312. }
  313. for (int t = 0; t < H; t++)
  314. {
  315.     pthread_join(tid[t],NULL);
  316.  
  317. }
  318. //Destruccion de s
  319.     pthread_mutex_destroy(&s);
  320. //-----------------------------------
  321.  
  322.  
  323. //calculo la matriz transpuesta de A
  324.     for(int i=0;i<N;i++){
  325.        for(int j=0;j<N;j++){
  326.             At[j*N+i]=A[i*N+j];
  327.         }
  328.     }
  329.  
  330.  
  331. //Realiza el tiempo iniial para la busqueda y calclulo
  332. timetick = dwalltime();
  333.     // algoritmo secuencial
  334.     resultadoSecuencial();
  335.  
  336. printf("Tiempo en segundos %f\n", dwalltime() - timetick);
  337.  
  338. /*NOTA fila = 0 ; columna = 1; */
  339.     /*printf(" \n ");
  340.     printf(" \n ");
  341.     printf(" La matriz U es: ");
  342.     printf(" \n ");
  343.     printf(" \n ");
  344.     vermatriz(U,0);
  345.     printf(" \n ");
  346.     printf(" \n ");
  347. */
  348.     printf(" \n ");
  349.     printf(" \n ");
  350.     printf(" La matriz U es: ");
  351.     printf(" \n ");
  352.     printf(" \n ");
  353.     vermatriz(U,0);
  354.     printf(" \n ");
  355.     printf(" \n ");
  356.  
  357.     printf(" \n ");
  358.     printf(" \n ");
  359.     printf(" La matriz A es: ");
  360.     printf(" \n ");
  361.     printf(" \n ");
  362.     vermatriz(A,0);
  363.     printf(" \n ");
  364.     printf(" \n ");
  365.  
  366.     printf(" \n ");
  367.     printf(" \n ");
  368.     printf(" La matriz AU es: ");
  369.     printf(" \n ");
  370.     printf(" \n ");
  371.     vermatriz(AU,0);
  372.     printf(" \n ");
  373.     printf(" \n ");
  374.  
  375.  
  376. int i, j;
  377. //Verifica el resultado
  378.   for(i=0;i<N;i++){
  379.    for(j=0;j<N;j++){
  380.     check=check&&( AU[i*N+j]<=N);
  381.     printf("Multiplicacion (%d, %d) = %d da %d \n",  i , j, AU[i*N+j], check);
  382.  
  383.  
  384.  
  385.    }
  386.   }  
  387.  
  388.   if(check){
  389.    printf("Multiplicacion de matrices resultado correcto\n");
  390.   }else{
  391.    printf("Multiplicacion de matrices resultado erroneo\n");
  392.   }
  393.   printf("resultado max es: %d \n",Max );
  394.   printf("resultado min es: %d \n",Min );
  395.  
  396. /*matriz A por fila y por columnas*/
  397. free(Af);
  398. free(Ac);
  399.  
  400. /*Matrices triangular superior e inferiror*/
  401. free(L);
  402. free(U);
  403.  
  404. /*Matriz A original*/
  405. free(A);
  406.  
  407. /*almacena la matriz transpuesta de A, el producto de tri sup por A y tri inf por A*/
  408. free(At);
  409. free(AU);
  410. free(AL);
  411. free(AA);
  412. free(AAt);
  413.  
  414. /*almacena en la variable resultado */
  415. free(RESULT);
  416.  
  417.  
  418. return(0);
  419. }
  420.  
  421.  
  422. //NOTA AVERIGUAR POR QUE SE DESBORDA
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top