Code:
ivan@ivan-desktop:~/Desktop$ time ./cputest 
25 percent done:
50 percent done:
75 percent done:
100 percent done - Test completed!

real    0m16.900s
user    0m9.461s
sys    0m0.068s

Code:
ivan@ivan-desktop:~/Desktop$ time ./cputest 
25 percent done:
50 percent done:
75 percent done:
100 percent done - Test completed!

real    0m8.944s
user    0m8.545s
sys    0m0.008s

Code:
#include <stdio.h>



long i = 1 ;



int main ()

{

   printf ("Program Test-Brzne (verzija u C-u) (TM) :)))\n");    
   printf ("Startujte ga sa 'time ime_programa da bi merio brzinu.'\n");
   printf ("Merim skor za vas procesor...\n");
   printf (" \n");
     

    do {

    if (i==250000000) printf ("25 posto kompletirano...\n"); else

    if (i==500000000) printf("50 posto kompletirano...\n"); else

    if (i==750000000) printf("75 posto kompletirano...\n"); else

    if (i==1000000000) printf("100 posto - Test kompletiran!\n");

    i++; }

    

    while (i < 1000000001);

    return (1);

}

Code:

#include <stdio.h>

long i = 1 ;

int main ()
{
    do {
    if (i==250000000) printf ("25 percent done:\n"); else
    if (i==500000000) printf("50 percent done:\n"); else
    if (i==750000000) printf("75 percent done:\n"); else
    if (i==1000000000) printf("100 percent done - Test completed!\n");
    i++; }
    
    while (i < 1000000001);
    return (1);
}

Code:

if (i%250000000 == 0) printf ("%i percent done\n",(i/10000000));

Code:
$ cat test-01.c
#include <stdio.h>

int main ()
{
    long i;

    for (i = 1; i < 1000000001; ++i) {
        if (i==250000000) printf ("25 percent done:\n");
        else if (i==500000000) printf("50 percent done:\n");
        else if (i==750000000) printf("75 percent done:\n");
        else if (i==1000000000) printf("100 percent done - Test completed!\n");
    }

    return 0;
}
$ gcc test-01.c
$ time ./a.out
25 percent done:
50 percent done:
75 percent done:
100 percent done - Test completed!

real    0m3.577s
user    0m3.576s
sys     0m0.000s

Code:
$ cat test-01-omp.c
#include <stdio.h>

int main ()
{
    long i;

    #pragma omp parallel for
    for (i = 1; i < 1000000001; ++i) {
        if (i==250000000) printf ("25 percent done:\n");
        else if (i==500000000) printf("50 percent done:\n");
        else if (i==750000000) printf("75 percent done:\n");
        else if (i==1000000000) printf("100 percent done - Test completed!\n");
    }

    return 0;
}
$ gcc test-01.c -fopenmp
$ time ./a.out
75 percent done:
25 percent done:
100 percent done - Test completed!
50 percent done:

real    0m1.475s
user    0m2.924s
sys     0m0.000s

Code:

#include <stdlib.h>
#include <semaphore.h>
#include <pthread.h>
#include <stdio.h>

#define BLCK_SIZE 16777216

sem_t sema,sema1;

void* tf(void* p)
{
  int j = 80;
  while(j--)
  {
    int i = 0;
    for(;i<BLCK_SIZE;++i)
    {
      *((int*)p+i) = i;
    }
    if(j%20==0)
    {
      sem_post(&sema);
      sem_wait(&sema1);
    }
  }
  return 0;
}

int main ()
{
  sem_init(&sema,0,0);
  sem_init(&sema1,0,0);
  
  int* mem = calloc(4,BLCK_SIZE*sizeof(int));
  if(!mem)
  {
    printf("not enough memory\n");
    return 0;
  }
  pthread_t tid[4];

  pthread_create(tid+0,0,tf,mem+0*BLCK_SIZE);
  pthread_create(tid+1,0,tf,mem+1*BLCK_SIZE);
  pthread_create(tid+2,0,tf,mem+2*BLCK_SIZE);
  pthread_create(tid+3,0,tf,mem+3*BLCK_SIZE);

  sem_wait(&sema);
  sem_wait(&sema);
  sem_wait(&sema);
  sem_wait(&sema);
  printf ("25 percent done:\n");
  sem_post(&sema1);
  sem_post(&sema1);
  sem_post(&sema1);
  sem_post(&sema1);
  
  sem_wait(&sema);
  sem_wait(&sema);
  sem_wait(&sema);
  sem_wait(&sema);
  printf("50 percent done:\n");
  sem_post(&sema1);
  sem_post(&sema1);
  sem_post(&sema1);
  sem_post(&sema1);
  
  sem_wait(&sema);
  sem_wait(&sema);
  sem_wait(&sema);
  sem_wait(&sema);
  printf("75 percent done:\n");
  sem_post(&sema1);
  sem_post(&sema1);
  sem_post(&sema1);
  sem_post(&sema1);
  
  sem_wait(&sema);
  sem_wait(&sema);
  sem_wait(&sema);
  sem_wait(&sema);
  printf("100 percent done - Test completed!\n");
  sem_post(&sema1);
  sem_post(&sema1);
  sem_post(&sema1);
  sem_post(&sema1);
  
  pthread_join(tid[0],NULL);
  pthread_join(tid[1],NULL);
  pthread_join(tid[2],NULL);
  pthread_join(tid[3],NULL);

  free(mem);
  sem_destroy(&sema);
  sem_destroy(&sema1);

  return 0;
}

Code:


gcc -Wall -lpthread -O2 ime.c -o ime

Code:

((int*)p)[i]

Code:


#include <stdlib.h>
#include <semaphore.h>
#include <pthread.h>
#include <stdio.h>

#define BLCK_SIZE 16777216

sem_t sema,sema1;

void* tf(void* p)
{
  int j = 80;
  while(j--)
  {
    int i = 0;
    for(;i<BLCK_SIZE;++i)
    {
      *((int*)p+i) = i;
    }
    if(j%20==0)
    {
      sem_post(&sema);
      sem_wait(&sema1);
    }
  }
  return 0;
}

int main ()
{
  sem_init(&sema,0,0);
  sem_init(&sema1,0,0);
  
  int* mem = calloc(4,BLCK_SIZE*sizeof(int));
  int d = 0.000015259 * BLCK_SIZE;
  if(!mem)
  {
    printf("not enough memory\n");
    return 0;
  }
  else printf("program allocated %d MB of RAM\n", d);

  pthread_t tid[4];

  pthread_create(tid+0,0,tf,mem+0*BLCK_SIZE);
  pthread_create(tid+1,0,tf,mem+1*BLCK_SIZE);
  pthread_create(tid+2,0,tf,mem+2*BLCK_SIZE);
  pthread_create(tid+3,0,tf,mem+3*BLCK_SIZE);

  sem_wait(&sema);
  sem_wait(&sema);
  sem_wait(&sema);
  sem_wait(&sema);
  printf ("25 percent done:\n");
  sem_post(&sema1);
  sem_post(&sema1);
  sem_post(&sema1);
  sem_post(&sema1);
  
  sem_wait(&sema);
  sem_wait(&sema);
  sem_wait(&sema);
  sem_wait(&sema);
  printf("50 percent done:\n");
  sem_post(&sema1);
  sem_post(&sema1);
  sem_post(&sema1);
  sem_post(&sema1);
  
  sem_wait(&sema);
  sem_wait(&sema);
  sem_wait(&sema);
  sem_wait(&sema);
  printf("75 percent done:\n");
  sem_post(&sema1);
  sem_post(&sema1);
  sem_post(&sema1);
  sem_post(&sema1);
  
  sem_wait(&sema);
  sem_wait(&sema);
  sem_wait(&sema);
  sem_wait(&sema);
  printf("100 percent done - Test completed!\n");
  sem_post(&sema1);
  sem_post(&sema1);
  sem_post(&sema1);
  sem_post(&sema1);
  
  pthread_join(tid[0],NULL);
  pthread_join(tid[1],NULL);
  pthread_join(tid[2],NULL);
  pthread_join(tid[3],NULL);

  free(mem);
  sem_destroy(&sema);
  sem_destroy(&sema1);

  return 0;
}

Code:

#include <stdlib.h>
#include <semaphore.h>
#include <pthread.h>
#include <stdio.h>

sem_t sema,sema1;

int memparse ();
int memload ();

int memparse()
{
  int d;
  int i;
  i = memload ();
  d = i * 65536;
  return d;
}

int memload()
{
  int memory;
  scanf("%d", &memory);
  return memory;
}

void* tf(void* p)
{
  int j = 80;
//  KAKO DA UCITAM BLCK_SIZE IZ MAIN FUNKCIJE???
  while(j--)
  {
    int i = 0;
    for(;i<BLCK_SIZE;++i)
    {
      *((int*)p+i) = i;
    }
    if(j%20==0)
    {
      sem_post(&sema);
      sem_wait(&sema1);
    }
  }
  return 0;
}

int main ()
{
  sem_init(&sema,0,0);
  sem_init(&sema1,0,0);
  int BLCK_SIZE;
  printf("Unesite vrednost memorije za alokaciju u MB:");
  BLCK_SIZE = memparse ();
  int* mem = calloc(4,BLCK_SIZE*sizeof(int));
  if(!mem)
  {
    printf("not enough memory\n");
    return 0;
  }
  pthread_t tid[4];

  pthread_create(tid+0,0,tf,mem+0*BLCK_SIZE);
  pthread_create(tid+1,0,tf,mem+0*BLCK_SIZE);
  pthread_create(tid+2,0,tf,mem+0*BLCK_SIZE);
  pthread_create(tid+3,0,tf,mem+0*BLCK_SIZE);

  sem_wait(&sema);
  sem_wait(&sema);
  sem_wait(&sema);
  sem_wait(&sema);
  printf ("25 percent done:\n");
  sem_post(&sema1);
  sem_post(&sema1);
  sem_post(&sema1);
  sem_post(&sema1);
  
  sem_wait(&sema);
  sem_wait(&sema);
  sem_wait(&sema);
  sem_wait(&sema);
  printf("50 percent done:\n");
  sem_post(&sema1);
  sem_post(&sema1);
  sem_post(&sema1);
  sem_post(&sema1);
  
  sem_wait(&sema);
  sem_wait(&sema);
  sem_wait(&sema);
  sem_wait(&sema);
  printf("75 percent done:\n");
  sem_post(&sema1);
  sem_post(&sema1);
  sem_post(&sema1);
  sem_post(&sema1);
  
  sem_wait(&sema);
  sem_wait(&sema);
  sem_wait(&sema);
  sem_wait(&sema);
  printf("100 percent done - Test completed!\n");
  sem_post(&sema1);
  sem_post(&sema1);
  sem_post(&sema1);
  sem_post(&sema1);
  
  pthread_join(tid[0],NULL);
  pthread_join(tid[1],NULL);
  pthread_join(tid[2],NULL);
  pthread_join(tid[3],NULL);

  free(mem);
  sem_destroy(&sema);
  sem_destroy(&sema1);

  return 0;
}

Code:

#include <stdlib.h>
#include <semaphore.h>
#include <pthread.h>
#include <stdio.h>

sem_t sema,sema1;
int BLCK_SIZE;

int memparse ();
int memload ();

int memparse()
{
  int d;
  int i;
  i = memload ();
  d = i * 65536;
  return d;
}

int memload()
{
  int memory;
  scanf("%d", &memory);
  return memory;
}

void* tf(void* p)
{
  int j = 80;
  while(j--)
  {
    int i = 0;
    for(;i<BLCK_SIZE;++i)
    {
      *((int*)p+i) = i;
    }
    if(j%20==0)
    {
      sem_post(&sema);
      sem_wait(&sema1);
    }
  }
  return 0;
}

int main ()
{
  sem_init(&sema,0,0);
  sem_init(&sema1,0,0);
  int mb;
  printf("Unesite vrednost memorije za alokaciju u MB:");
  BLCK_SIZE = memparse ();
  mb = 0.000015259 * BLCK_SIZE;
  int* mem = calloc(4,BLCK_SIZE*sizeof(int));
  if(!mem)
  {
    printf("not enough memory\n");
    return 0;
  }
  else printf("program allocated %d MB of RAM\n", mb);

  pthread_t tid[4];

  pthread_create(tid+0,0,tf,mem+0*BLCK_SIZE);
  pthread_create(tid+1,0,tf,mem+0*BLCK_SIZE);
  pthread_create(tid+2,0,tf,mem+0*BLCK_SIZE);
  pthread_create(tid+3,0,tf,mem+0*BLCK_SIZE);

  sem_wait(&sema);
  sem_wait(&sema);
  sem_wait(&sema);
  sem_wait(&sema);
  printf ("25 percent done:\n");
  sem_post(&sema1);
  sem_post(&sema1);
  sem_post(&sema1);
  sem_post(&sema1);
  
  sem_wait(&sema);
  sem_wait(&sema);
  sem_wait(&sema);
  sem_wait(&sema);
  printf("50 percent done:\n");
  sem_post(&sema1);
  sem_post(&sema1);
  sem_post(&sema1);
  sem_post(&sema1);
  
  sem_wait(&sema);
  sem_wait(&sema);
  sem_wait(&sema);
  sem_wait(&sema);
  printf("75 percent done:\n");
  sem_post(&sema1);
  sem_post(&sema1);
  sem_post(&sema1);
  sem_post(&sema1);
  
  sem_wait(&sema);
  sem_wait(&sema);
  sem_wait(&sema);
  sem_wait(&sema);
  printf("100 percent done - Test completed!\n");
  sem_post(&sema1);
  sem_post(&sema1);
  sem_post(&sema1);
  sem_post(&sema1);
  
  pthread_join(tid[0],NULL);
  pthread_join(tid[1],NULL);
  pthread_join(tid[2],NULL);
  pthread_join(tid[3],NULL);

  free(mem);
  sem_destroy(&sema);
  sem_destroy(&sema1);

  return 0;
}

Code:

#include <stdlib.h>
#include <semaphore.h>
#include <pthread.h>
#include <stdio.h>
#include <time.h>

time_t timer1,timer2;
struct tm *tarray1,*tarray2;
sem_t sema,sema1;
int BLCK_SIZE;

int memparse ();
int memload ();

int memparse()
{
  int d;
  int i;
  i = memload ();
  d = i * 65536;
  return d;
}

int memload()
{
  int memory;
  scanf("%d", &memory);
  return memory;
}

void* tf(void* p)
{
  int j = 80;
  while(j--)
  {
    int i = 0;
    for(;i<BLCK_SIZE;++i)
    {
      *((int*)p+i) = i;
    }
    if(j%20==0)
    {
      sem_post(&sema);
      sem_wait(&sema1);
    }
  }
  return 0;
}

int main ()
{
  int min1, sec1, min2, sec2;
  timer1 = time(NULL);
  tarray1 = localtime(&timer1);
  min1 = tarray1->tm_min;
  sec1 = tarray1->tm_sec;  
  sem_init(&sema,0,0);
  sem_init(&sema1,0,0);
  int mb;
  printf("Enter the amount of memory to be allocated in MB:");
  BLCK_SIZE = memparse ();
  mb = 0.000015259 * BLCK_SIZE;
  int* mem = calloc(4,BLCK_SIZE*sizeof(int));
  if(!mem)
  {
    printf("not enough memory\n");
    return 0;
  }
  else printf("program allocated %d MB of RAM\n", mb);

  pthread_t tid[4];

  pthread_create(tid+0,0,tf,mem+0*BLCK_SIZE);
  pthread_create(tid+1,0,tf,mem+0*BLCK_SIZE);
  pthread_create(tid+2,0,tf,mem+0*BLCK_SIZE);
  pthread_create(tid+3,0,tf,mem+0*BLCK_SIZE);

  sem_wait(&sema);
  sem_wait(&sema);
  sem_wait(&sema);
  sem_wait(&sema);
  printf ("25 percent done:\n");
  sem_post(&sema1);
  sem_post(&sema1);
  sem_post(&sema1);
  sem_post(&sema1);
  
  sem_wait(&sema);
  sem_wait(&sema);
  sem_wait(&sema);
  sem_wait(&sema);
  printf("50 percent done:\n");
  sem_post(&sema1);
  sem_post(&sema1);
  sem_post(&sema1);
  sem_post(&sema1);
  
  sem_wait(&sema);
  sem_wait(&sema);
  sem_wait(&sema);
  sem_wait(&sema);
  printf("75 percent done:\n");
  sem_post(&sema1);
  sem_post(&sema1);
  sem_post(&sema1);
  sem_post(&sema1);
  
  sem_wait(&sema);
  sem_wait(&sema);
  sem_wait(&sema);
  sem_wait(&sema);
  printf("100 percent done - Test completed!\n");
  sem_post(&sema1);
  sem_post(&sema1);
  sem_post(&sema1);
  sem_post(&sema1);
  
  pthread_join(tid[0],NULL);
  pthread_join(tid[1],NULL);
  pthread_join(tid[2],NULL);
  pthread_join(tid[3],NULL);

  free(mem);
  sem_destroy(&sema);
  sem_destroy(&sema1);
  timer2 = time(NULL);
  tarray2 = localtime(&timer2);
  min2 = tarray2->tm_min;
  sec2 = tarray2->tm_sec;
  printf ("Time of execution is %d min : %d sec\n", min2-min1,sec2-sec1);
  return 0;
}

Code:

#include <stdlib.h>
#include <semaphore.h>
#include <pthread.h>
#include <stdio.h>
#include <time.h>

time_t timer1,timer2;
struct tm *tarray1,*tarray2;
sem_t sema,sema1;
int BLCK_SIZE;

int memparse ();
int memload ();

int memparse()
{
  int d;
  int i;
  i = memload ();
  d = i * 65536;
  return d;
}

int memload()
{
  int memory;
  scanf("%d", &memory);
  return memory;
}

void* tf(void* p)
{
  int j = 80;
  while(j--)
  {
    int i = 0;
    for(;i<BLCK_SIZE;++i)
    {
      *((int*)p+i) = i;
    }
    if(j%20==0)
    {
      sem_post(&sema);
      sem_wait(&sema1);
    }
  }
  return 0;
}

int main ()
{
  int min1,min2,sec1,sec2,minf,secf;
  timer1 = time(NULL);
  tarray1 = localtime(&timer1);
  min1 = tarray1->tm_min;
  sec1 = tarray1->tm_sec;  
  sem_init(&sema,0,0);
  sem_init(&sema1,0,0);
  int mb;
  printf("Enter the amount of memory to allocate in MB:");
  BLCK_SIZE = memparse ();
  mb = 0.000015259 * BLCK_SIZE;
  int* mem = calloc(4,BLCK_SIZE*sizeof(int));
  if(!mem)
  {
    printf("not enough memory\n");
    return 0;
  }
  else printf("program allocated %d MB of RAM\n", mb);

  pthread_t tid[4];

  pthread_create(tid+0,0,tf,mem+0*BLCK_SIZE);
  pthread_create(tid+1,0,tf,mem+1*BLCK_SIZE);
  pthread_create(tid+2,0,tf,mem+2*BLCK_SIZE);
  pthread_create(tid+3,0,tf,mem+3*BLCK_SIZE);

  sem_wait(&sema);
  sem_wait(&sema);
  sem_wait(&sema);
  sem_wait(&sema);
  printf ("25 percent done:\n");
  sem_post(&sema1);
  sem_post(&sema1);
  sem_post(&sema1);
  sem_post(&sema1);
  
  sem_wait(&sema);
  sem_wait(&sema);
  sem_wait(&sema);
  sem_wait(&sema);
  printf("50 percent done:\n");
  sem_post(&sema1);
  sem_post(&sema1);
  sem_post(&sema1);
  sem_post(&sema1);
  
  sem_wait(&sema);
  sem_wait(&sema);
  sem_wait(&sema);
  sem_wait(&sema);
  printf("75 percent done:\n");
  sem_post(&sema1);
  sem_post(&sema1);
  sem_post(&sema1);
  sem_post(&sema1);
  
  sem_wait(&sema);
  sem_wait(&sema);
  sem_wait(&sema);
  sem_wait(&sema);
  printf("100 percent done - Test completed!\n");
  sem_post(&sema1);
  sem_post(&sema1);
  sem_post(&sema1);
  sem_post(&sema1);
  
  pthread_join(tid[0],NULL);
  pthread_join(tid[1],NULL);
  pthread_join(tid[2],NULL);
  pthread_join(tid[3],NULL);

  timer2 = time(NULL);
  tarray2 = localtime(&timer2);
  min2 = tarray2->tm_min;
  sec2 = tarray2->tm_sec;
  if (min2 < min1) 
{
  minf = min2 + 60 - min1;
}
  else 
  minf = min2 - min1;
  
  if (sec2 < sec1) 
{
  secf = sec2 + 60 - sec1;
  minf -= 1;
}  
  else
  secf = sec2 - sec1;
  printf ("Time of execution is %d min : %d sec\n",minf,secf);
  free(mem);
  sem_destroy(&sema);
  sem_destroy(&sema1);
  return 0;
}

Code:

#include <stdlib.h>
#include <semaphore.h>
#include <pthread.h>
#include <stdio.h>
#include <time.h>

time_t timer1,timer2;
struct tm *tarray1,*tarray2;
sem_t sema,sema1;
int BLCK_SIZE;

int memparse ();
int memload ();

int memparse()
{
  int d;
  int i;
  i = memload ();
  d = i * 65536;
  return d;
}

int memload()
{
  int memory;
  scanf("%d", &memory);
  return memory;
}

void* tf(void* p)
{
  int j = 80;
  while(j--)
  {
    int i = 0;
    for(;i<BLCK_SIZE;++i)
    {
      *((int*)p+i) = i;
    }
    if(j%20==0)
    {
      sem_post(&sema);
      sem_wait(&sema1);
    }
  }
  return 0;
}

int main ()
{
  int min1,min2,sec1,sec2,minf,secf;
  timer1 = time(NULL);
  tarray1 = localtime(&timer1);
  min1 = tarray1->tm_min;
  sec1 = tarray1->tm_sec;  
  sem_init(&sema,0,0);
  sem_init(&sema1,0,0);
  int mb;
  printf ("\n"); 
  printf("Unesite koliko memorije alocirate za test (64 do 512 MB):");
  BLCK_SIZE = memparse ();
  mb = 0.000015259 * BLCK_SIZE;
  int* mem = calloc(4,BLCK_SIZE*sizeof(int));

  if (mb < 64) 
{
printf("\n"); 
printf("Postavljena vrednost nije dozvoljena.\n"); 
printf("\n");
return 0;
}

if (mb > 512)
{
printf("\n");
printf("Postavljena vrednost nije dozvoljena.\n"); 
printf("\n");
return 0;
}

  
  if(!mem)
  {
    printf("Nema dovoljno memorije.\n");
    return 0;
  }
  else printf("Program je alocirao %d MB RAM-a.\n", mb);

  pthread_t tid[4];

  pthread_create(tid+0,0,tf,mem+0*BLCK_SIZE);
  pthread_create(tid+1,0,tf,mem+1*BLCK_SIZE);
  pthread_create(tid+2,0,tf,mem+2*BLCK_SIZE);
  pthread_create(tid+3,0,tf,mem+3*BLCK_SIZE);

  sem_wait(&sema);
  sem_wait(&sema);
  sem_wait(&sema);
  sem_wait(&sema);
  printf ("25 procenata komletirano... \n");
  sem_post(&sema1);
  sem_post(&sema1);
  sem_post(&sema1);
  sem_post(&sema1);
  
  sem_wait(&sema);
  sem_wait(&sema);
  sem_wait(&sema);
  sem_wait(&sema);
  printf ("50 procenata komletirano... \n");
  sem_post(&sema1);
  sem_post(&sema1);
  sem_post(&sema1);
  sem_post(&sema1);
  
  sem_wait(&sema);
  sem_wait(&sema);
  sem_wait(&sema);
  sem_wait(&sema);
  printf ("75 procenata komletirano... \n");
  sem_post(&sema1);
  sem_post(&sema1);
  sem_post(&sema1);
  sem_post(&sema1);
  
  sem_wait(&sema);
  sem_wait(&sema);
  sem_wait(&sema);
  sem_wait(&sema);
  printf ("100 procenata komletirano! \n");
  sem_post(&sema1);
  sem_post(&sema1);
  sem_post(&sema1);
  sem_post(&sema1);
  
  pthread_join(tid[0],NULL);
  pthread_join(tid[1],NULL);
  pthread_join(tid[2],NULL);
  pthread_join(tid[3],NULL);

  timer2 = time(NULL);
  tarray2 = localtime(&timer2);
  min2 = tarray2->tm_min;
  sec2 = tarray2->tm_sec;
  if (min2 < min1) 
{
  minf = min2 + 60 - min1;
}
  else 
  minf = min2 - min1;
  
  if (sec2 < sec1) 
{
  secf = sec2 + 60 - sec1;
  minf -= 1;
}  
  else
  secf = sec2 - sec1;
  printf ("\n");
  printf ("Vreme izvrsavanja je %d minuta i %d sekundi.\n",minf,secf);
  printf ("\n");
  free(mem);
  sem_destroy(&sema);
  sem_destroy(&sema1);
  return 0;
}

Code:

150 linija koda

Code:

combuster@vostro:~/test$ i586-mingw32msvc-gcc -x c test.c
/tmp/ccGW9wEm.o:test.c:(.text+0x92): undefined reference to `_sem_post'
/tmp/ccGW9wEm.o:test.c:(.text+0xa2): undefined reference to `_sem_wait'
/tmp/ccGW9wEm.o:test.c:(.text+0x118): undefined reference to `_sem_init'
/tmp/ccGW9wEm.o:test.c:(.text+0x12c): undefined reference to `_sem_init'
/tmp/ccGW9wEm.o:test.c:(.text+0x1d5): undefined reference to `_pthread_create'
/tmp/ccGW9wEm.o:test.c:(.text+0x1f9): undefined reference to `_pthread_create'
/tmp/ccGW9wEm.o:test.c:(.text+0x21d): undefined reference to `_pthread_create'
/tmp/ccGW9wEm.o:test.c:(.text+0x248): undefined reference to `_pthread_create'
/tmp/ccGW9wEm.o:test.c:(.text+0x258): undefined reference to `_sem_wait'
/tmp/ccGW9wEm.o:test.c:(.text+0x268): undefined reference to `_sem_wait'
/tmp/ccGW9wEm.o:test.c:(.text+0x278): undefined reference to `_sem_wait'
/tmp/ccGW9wEm.o:test.c:(.text+0x288): undefined reference to `_sem_wait'
/tmp/ccGW9wEm.o:test.c:(.text+0x2a8): undefined reference to `_sem_post'
/tmp/ccGW9wEm.o:test.c:(.text+0x2b8): undefined reference to `_sem_post'
/tmp/ccGW9wEm.o:test.c:(.text+0x2c8): undefined reference to `_sem_post'
/tmp/ccGW9wEm.o:test.c:(.text+0x2d8): undefined reference to `_sem_post'
/tmp/ccGW9wEm.o:test.c:(.text+0x2e8): undefined reference to `_sem_wait'
/tmp/ccGW9wEm.o:test.c:(.text+0x2f8): undefined reference to `_sem_wait'
/tmp/ccGW9wEm.o:test.c:(.text+0x308): undefined reference to `_sem_wait'
/tmp/ccGW9wEm.o:test.c:(.text+0x318): undefined reference to `_sem_wait'
/tmp/ccGW9wEm.o:test.c:(.text+0x338): undefined reference to `_sem_post'
/tmp/ccGW9wEm.o:test.c:(.text+0x348): undefined reference to `_sem_post'
/tmp/ccGW9wEm.o:test.c:(.text+0x358): undefined reference to `_sem_post'
/tmp/ccGW9wEm.o:test.c:(.text+0x368): undefined reference to `_sem_post'
/tmp/ccGW9wEm.o:test.c:(.text+0x378): undefined reference to `_sem_wait'
/tmp/ccGW9wEm.o:test.c:(.text+0x388): undefined reference to `_sem_wait'
/tmp/ccGW9wEm.o:test.c:(.text+0x398): undefined reference to `_sem_wait'
/tmp/ccGW9wEm.o:test.c:(.text+0x3a8): undefined reference to `_sem_wait'
/tmp/ccGW9wEm.o:test.c:(.text+0x3c8): undefined reference to `_sem_post'
/tmp/ccGW9wEm.o:test.c:(.text+0x3d8): undefined reference to `_sem_post'
/tmp/ccGW9wEm.o:test.c:(.text+0x3e8): undefined reference to `_sem_post'
/tmp/ccGW9wEm.o:test.c:(.text+0x3f8): undefined reference to `_sem_post'
/tmp/ccGW9wEm.o:test.c:(.text+0x408): undefined reference to `_sem_wait'
/tmp/ccGW9wEm.o:test.c:(.text+0x418): undefined reference to `_sem_wait'
/tmp/ccGW9wEm.o:test.c:(.text+0x428): undefined reference to `_sem_wait'
/tmp/ccGW9wEm.o:test.c:(.text+0x438): undefined reference to `_sem_wait'
/tmp/ccGW9wEm.o:test.c:(.text+0x458): undefined reference to `_sem_post'
/tmp/ccGW9wEm.o:test.c:(.text+0x468): undefined reference to `_sem_post'
/tmp/ccGW9wEm.o:test.c:(.text+0x478): undefined reference to `_sem_post'
/tmp/ccGW9wEm.o:test.c:(.text+0x488): undefined reference to `_sem_post'
/tmp/ccGW9wEm.o:test.c:(.text+0x499): undefined reference to `_pthread_join'
/tmp/ccGW9wEm.o:test.c:(.text+0x4aa): undefined reference to `_pthread_join'
/tmp/ccGW9wEm.o:test.c:(.text+0x4bb): undefined reference to `_pthread_join'
/tmp/ccGW9wEm.o:test.c:(.text+0x4cc): undefined reference to `_pthread_join'
/tmp/ccGW9wEm.o:test.c:(.text+0x589): undefined reference to `_sem_destroy'
/tmp/ccGW9wEm.o:test.c:(.text+0x599): undefined reference to `_sem_destroy'
collect2: ld returned 1 exit status

Code:

srdjan@Zverko:~$ ./ProcTest64-v1.0.0 
Test Brzine Procesora - 64-bit - Verzija 1.0.0  - [ES]

Unesite koliko memorije alocirate za test (64 do 512 MB):32

Postavljena vrednost nije dozvoljena. Minimum je 64.

srdjan@Zverko:~$ ./ProcTest64-v1.0.0 
Test Brzine Procesora - 64-bit - Verzija 1.0.0  - [ES]

Unesite koliko memorije alocirate za test (64 do 512 MB):513

Postavljena vrednost nije dozvoljena. Maksimum je 512.

srdjan@Zverko:~$ ./ProcTest64-v1.0.0 
Test Brzine Procesora - 64-bit - Verzija 1.0.0  - [ES]

Unesite koliko memorije alocirate za test (64 do 512 MB):128
Program je alocirao 128 MB RAM-a.
25 procenata komletirano... 
50 procenata komletirano... 
75 procenata komletirano... 
100 procenata komletirano! 

Vreme izvrsavanja je 0 minuta i 11 sekundi.

srdjan@Zverko:~$ 

Code:
double a[VSIZE], b[VSIZE];
double sum;

// Uspostavljanje a, b...

// Štoperica počinje ovde.
sum = 0.0;
for(i = 0; i < VSIZE; ++i) {
    sum += a[i] * b[i];
}
// Štoperica staje ovde.

Code:
$ gcc test-02.c -O3 -fopenmp
$ OMP_NUM_THREADS=1 ./a.out > t1.dat
$ OMP_NUM_THREADS=2 ./a.out > t2.dat
$ OMP_NUM_THREADS=4 ./a.out > t4.dat
$ ./test-02-plot.py t1.dat t2.dat t4.dat
t1~t2~t4.png
$

Code:

#include <stdlib.h>
#include <semaphore.h>
#include <pthread.h>
#include <stdio.h>

#define BLCK_SIZE 16777216

sem_t sema,sema1;
typedef struct Data{ int blck_size,cpu; } Data_t;

void* tf(void* p)
{
  Data_t* dt = (Data_t*)p;
  int *mem=NULL;
  cpu_set_t set;
  CPU_ZERO(&set);
  CPU_SET(dt->cpu,&set);
  if(sched_setaffinity(0,sizeof(cpu_set_t),&set)<0)
    printf("set affinity failed cpu %d\n",dt->cpu);

  printf("set affinity cpu %d\n",dt->cpu);

  mem = malloc(dt->blck_size*sizeof(int));
  if(!mem)return 0;

  int j = 80;
  while(j--)
  {
    int i = 0;
    unsigned long long sum=0;
    for(;i<dt->blck_size;++i)
    {
      *(mem+i) = i;
    }
    for(i=0;i<dt->blck_size;++i)
    {
      sum += mem[i];
    }
    if(j%20==0)
    {
      printf("thread %lu, sum %llu\n",(unsigned long)pthread_self(),sum);
      sem_post(&sema);
      sem_wait(&sema1);
    }
  }
  free(mem);
  return 0;
}

static void waitT(int count)
{
  while(count--)
  {
    sem_wait(&sema);
  }
}

static void postT(int count)
{
  while(count--)
  {
    sem_post(&sema1);
  }
}

int main (int argc,char* argv[])
{
  int single=0;
  
  int numcpus=0,i;
  pthread_t* tid=NULL;
  cpu_set_t set;

  if(argc>1)single=1;

  sem_init(&sema,0,0);
  sem_init(&sema1,0,0);

  CPU_ZERO(&set);
  CPU_SET(0,&set);
  
  while(sched_setaffinity(0,sizeof(cpu_set_t),&set)==0)
  {
    ++numcpus;
    CPU_ZERO(&set);
    CPU_SET(numcpus,&set);
  }
  printf("numcpus %d\n",numcpus);  
  tid = calloc(numcpus,sizeof(pthread_t));
  Data_t dt[numcpus];
  if(single)numcpus=1;
  for(i=0;i<numcpus;++i)
  {
      dt[i].blck_size = BLCK_SIZE*4/numcpus;
      dt[i].cpu = i;
      pthread_create(tid+i,NULL,tf,dt+i);
  }
  
  waitT(numcpus);
  printf ("25 percent done:\n");
  postT(numcpus);  

  waitT(numcpus);
  printf("50 percent done:\n");
  postT(numcpus);  

  waitT(numcpus);
  printf("75 percent done:\n");
  postT(numcpus);  

  waitT(numcpus);
  printf("100 percent done - Test completed!\n");
  postT(numcpus);  

  for(i=0;i<numcpus;++i)
    pthread_join(tid[i],NULL);

  free(tid);
  sem_destroy(&sema);
  sem_destroy(&sema1);

  return 0;
}

Code:

combuster@vostro:~$ time ./a.out
# Selected loop: 0
#       VSIZE [*]  SPEED [MFLOPS]      SUMSUM [*]
              100              21            16.7
              200              56            33.3
              500             103            83.3
             1000             173           166.7
             2000             390           333.3
             5000             597           833.3
            10000             795          1666.7
            20000             974          3333.3
            50000            1105          8333.3
           100000             939         16666.7
           200000             566         33333.3
           500000             540         83333.3
          1000000             571        166666.7
          2000000             584        333333.3
          5000000             614        833333.3
         10000000             580       1666666.7

real    0m32.034s
user    0m32.382s
sys    0m6.400s

Code:

combuster@vostro:~$ time ./test1
numcpus 2
set affinity cpu 0
set affinity cpu 1
thread 1111632208, sum 562949936644096
thread 1103239504, sum 562949936644096
25 percent done:
thread 1103239504, sum 562949936644096
thread 1111632208, sum 562949936644096
50 percent done:
thread 1103239504, sum 562949936644096
thread 1111632208, sum 562949936644096
75 percent done:
thread 1111632208, sum 562949936644096
thread 1103239504, sum 562949936644096
100 percent done - Test completed!

real    0m16.518s
user    0m30.890s
sys    0m0.392s

Code:

    unsigned int ticks_lo, ticks_hi;

    __asm__ volatile
        ("\n  rdtsc"
        : "=a" (ticks_lo), "=d" (ticks_hi));

//
//  ovde ide deo koda koji se zeli meriti
//

    __asm__ volatile
        ("\n  rdtsc"
        "\n  sub  %2, %%eax"
        "\n  sbb  %3, %%edx"
        : "=&a" (ticks_lo), "=&d" (ticks_hi)
        : "g" (ticks_lo), "g" (ticks_hi));

    printf("Broj clock-ova: %lld\n", (long long)ticks_lo + 4294967296 * (long long)ticks_hi);