scalasca_lab_codes_fin.tgz

./PaxHeaders.235860/ScalascaExerciseCodes0000644000000000000000000000005014276224567015160 xustar0020 atime=1660599778
20 ctime=1660496247
ScalascaExerciseCodes/0000700001313400131340000000000014276224567015515 5ustar00jheinjhein00000000000000ScalascaExerciseCodes/PaxHeaders.235860/Exercise_40000644000000000000000000000005014275221144017000 xustar0020 atime=1660599785
20 ctime=1660232292
ScalascaExerciseCodes/Exercise_4/0000700001313400131340000000000014275221144017472 5ustar00jheinjhein00000000000000ScalascaExerciseCodes/Exercise_4/PaxHeaders.235860/vectorNormAtomicSub_method.f900000644000000000000000000000005014111367402024677 xustar0020 atime=1660597309
20 ctime=1660232292
ScalascaExerciseCodes/Exercise_4/vectorNormAtomicSub_method.f900000600001313400131340000000461714111367402025326 0ustar00jheinjhein00000000000000Program vectornormsub

  use omp_lib
  implicit none

  integer, parameter :: vleng=20000000

  double precision, dimension(:), allocatable :: vect
  double precision :: norm
  
  ! OpenMP related and measurement
  integer :: myNum, numThreads
  double precision :: start_time, init_time, norm_time
  integer, parameter :: loop_count = 2
  integer :: loops
  
  ! indices
  integer i
  print *,"Calculating vector norm for length", vleng
  print *,"Running each test", loop_count, " times"

  allocate(vect(vleng))

  numThreads = 1
  !$omp parallel default(none), shared(numThreads)
  !$omp master
  !$ numthreads = omp_get_num_threads()
  !$omp end master
  !$omp end parallel

  init_time = 0.0D0
  norm_time = 0.0D0

  Do loops = 1, loop_count

     !$ start_time = omp_get_wtime()

     !$omp parallel default(none) shared(vect)
     call vectorinit(vect, vleng)
     !$omp end parallel

     !$ init_time = init_time + omp_get_wtime() - start_time

     !$ start_time = omp_get_wtime()
     norm = vectornorm(vect, vleng)
     !$ norm_time = norm_time + omp_get_wtime() - start_time

  enddo

  deallocate(vect)

  print *,"Using", numthreads, " threads"
  print *,"Norm:", norm
  print *,"Walltime: Initialisation: ", init_time/loop_count
  print *,"Walltime: Normcalculation:", norm_time/loop_count

contains

  Subroutine vectorinit(vdata, leng)
    integer, intent(in) :: leng
    double precision, dimension(leng), intent(out) :: vdata

    integer i
    !$omp master
    Do i = 1, leng
       vdata(i) = i
    enddo
    !$omp end master
       
  End Subroutine vectorinit

!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

  double precision function vectornorm(vdata, leng)
    integer, intent(in) :: leng
    double precision, dimension(leng), intent(out) :: vdata

    double precision :: norm, lnorm
    integer i
    
    norm = 0.0D0
    !$omp parallel default(none) shared(vdata, norm, leng) private(lnorm)
    lnorm = 0.0D0
    !$omp do
    Do i = 1, leng
       lnorm = lnorm + dprod(vdata(i))
    enddo
    !$omp end do
    
    !$omp atomic update
    norm = norm + lnorm

    !$omp end parallel

    norm = dsqrt(norm)

    vectornorm = norm

  end function vectornorm

!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

  double precision function dprod(input)
    double precision, intent(in) :: input
    dprod = input * input
  end function dprod

End Program vectornormsub

ScalascaExerciseCodes/Exercise_4/PaxHeaders.235860/vectorNormAtomicSub_method.c0000644000000000000000000000005014111367347024533 xustar0020 atime=1660597035
20 ctime=1660232292
ScalascaExerciseCodes/Exercise_4/vectorNormAtomicSub_method.c0000600001313400131340000000377614111367347025167 0ustar00jheinjhein00000000000000#include <stdio.h>
#include <stdlib.h>
#include <omp.h>
#include <math.h>

void   vectorinit(double *vdata, int leng);
double vectornorm(double *vdata, int leng);
double dprod(double input);

int main()
{

  const int vleng=20000000;

  printf("Calculating vector norm for length: %i\n", vleng);

  double *vect; 
  int start, fin, i;
  int  myNum;
  double norm, lNorm;


  const int loop_count = 2;
  printf("Running each test %i times\n", loop_count);


  double start_time, init_time, norm_time;
  int numThreads;

  vect = malloc(vleng * sizeof(double));

#pragma omp parallel default(none) shared(numThreads)
  {
    #pragma omp master
    {
     #ifdef _OPENMP
      numThreads = omp_get_num_threads();
     #else
      numThreads = 1;
     #endif
    }
  }


  init_time = 0.0;
  norm_time = 0.0;

  for (int loops=0; loops < loop_count; loops++)
    {

#ifdef _OPENMP
  start_time = omp_get_wtime();
#endif

#pragma omp parallel default(none) shared(vect )	
      {
	vectorinit( vect, vleng);
      }
      
#ifdef _OPENMP
      init_time += omp_get_wtime() - start_time;
#endif
      

#ifdef _OPENMP
      start_time = omp_get_wtime();
#endif

      norm = vectornorm(vect, vleng);

#ifdef _OPENMP
      norm_time += omp_get_wtime() - start_time;
#endif

    } 

  free(vect);

  printf("Using %i threads\n", numThreads);
  printf("Norm: %f\n",norm);
  printf("Walltime:  Initialisation: %f sec  Norm calculation: %f sec\n", init_time/loop_count, norm_time/loop_count);



  return 0;
}
					  
					  
void vectorinit(double *vdata, int leng)
  
{
#pragma omp master
  for ( int i = 0; i < leng; i++)
    {
      vdata[i] = i;
    }
  return;
}



double vectornorm(double *vdata, int leng)
{
  double norm = 0.0;

#pragma omp parallel default(none) shared(vdata, norm, leng)
  {
    double lnorm =0.0;
#pragma omp for
    for (int i = 0; i<leng; i++)
      {
	lnorm += dprod(vdata[i]);
      }
#pragma omp atomic
    norm += lnorm;
  }

  norm = sqrt(norm);

  return norm;
  
}

double dprod(double input)
{
  return input*input;
}
ScalascaExerciseCodes/PaxHeaders.235860/Exercise_20000644000000000000000000000005014276531625017007 xustar0020 atime=1660599785
20 ctime=1660597141
ScalascaExerciseCodes/Exercise_2/0000700001313400131340000000000014276531625017501 5ustar00jheinjhein00000000000000ScalascaExerciseCodes/Exercise_2/PaxHeaders.235860/vectorNormAtomicSub.f900000644000000000000000000000005014276457161023353 xustar0020 atime=1660597035
20 ctime=1660575345
ScalascaExerciseCodes/Exercise_2/vectorNormAtomicSub.f900000600001313400131340000000420214276457161023770 0ustar00jheinjhein00000000000000Program vectornormsub

  use omp_lib
  implicit none

  integer, parameter :: vleng=2000000000

  double precision, dimension(:), allocatable :: vect
  double precision :: norm
  
  ! OpenMP related and measurement
  integer :: myNum, numThreads
  double precision :: start_time, init_time, norm_time
  integer, parameter :: loop_count = 20
  integer :: loops
  
  ! indices
  integer i
  print *,"Calculating vector norm for length", vleng
  print *,"Running each test", loop_count, " times"

  allocate(vect(vleng))

  numThreads = 1
  !$omp parallel default(none), shared(numThreads)
  !$omp master
  !$ numthreads = omp_get_num_threads()
  !$omp end master
  !$omp end parallel

  init_time = 0.0D0
  norm_time = 0.0D0

  Do loops = 1, loop_count

     !$ start_time = omp_get_wtime()

     !$omp parallel default(none) shared(vect)
     call vectorinit(vect, vleng)
     !$omp end parallel

     !$ init_time = init_time + omp_get_wtime() - start_time

     !$ start_time = omp_get_wtime()
     norm = vectornorm(vect, vleng)
     !$ norm_time = norm_time + omp_get_wtime() - start_time

  enddo

  deallocate(vect)

  print *,"Using", numthreads, " threads"
  print *,"Norm:", norm
  print *,"Walltime: Initialisation: ", init_time/loop_count
  print *,"Walltime: Normcalculation:", norm_time/loop_count

contains

  Subroutine vectorinit(vdata, leng)
    integer, intent(in) :: leng
    double precision, dimension(leng), intent(out) :: vdata

    integer i
    !$omp master
    Do i = 1, leng
       vdata(i) = i
    enddo
    !$omp end master
       
  End Subroutine vectorinit


  double precision function vectornorm(vdata, leng)
    integer, intent(in) :: leng
    double precision, dimension(leng), intent(out) :: vdata

    double precision :: norm, lnorm
    integer i
    
    norm = 0.0D0
    !$omp parallel default(none) shared(vdata, norm, leng) private(lnorm)
    lnorm = 0.0D0
    !$omp do
    Do i = 1, leng
       lnorm = lnorm + vdata(i)*vdata(i)
    enddo
    !$omp end do
    
    !$omp atomic update
    norm = norm + lnorm

    !$omp end parallel

    norm = dsqrt(norm)

    vectornorm = norm

  End Function vectornorm

End Program vectornormsub

ScalascaExerciseCodes/Exercise_2/PaxHeaders.235860/vectorNormAtomicSub.c0000644000000000000000000000005014276457172023201 xustar0020 atime=1660597035
20 ctime=1660575354
ScalascaExerciseCodes/Exercise_2/vectorNormAtomicSub.c0000600001313400131340000000366314276457172023630 0ustar00jheinjhein00000000000000#include <stdio.h>
#include <stdlib.h>
#include <omp.h>
#include <math.h>

void   vectorinit(double *vdata, int leng);
double vectornorm(double *vdata, int leng);

int main()
{

  const int vleng=2000000000;

  printf("Calculating vector norm for length: %i\n", vleng);

  double *vect; 
  int start, fin, i;
  int  myNum;
  double norm, lNorm;


  const int loop_count = 20;
  printf("Running each test %i times\n", loop_count);


  double start_time, init_time, norm_time;
  int numThreads;

  vect = malloc(vleng * sizeof(double));

#pragma omp parallel default(none) shared(numThreads)
  {
    #pragma omp master
    {
     #ifdef _OPENMP
      numThreads = omp_get_num_threads();
     #else
      numThreads = 1;
     #endif
    }
  }


  init_time = 0.0;
  norm_time = 0.0;

  for (int loops=0; loops < loop_count; loops++)
    {

#ifdef _OPENMP
  start_time = omp_get_wtime();
#endif

#pragma omp parallel default(none) shared(vect )	
      {
	vectorinit( vect, vleng);
      }
      
#ifdef _OPENMP
      init_time += omp_get_wtime() - start_time;
#endif
      

#ifdef _OPENMP
      start_time = omp_get_wtime();
#endif

      norm = vectornorm(vect, vleng);

#ifdef _OPENMP
      norm_time += omp_get_wtime() - start_time;
#endif

    } 

  free(vect);

  printf("Using %i threads\n", numThreads);
  printf("Norm: %f\n",norm);
  printf("Walltime:  Initialisation: %f sec  Norm calculation: %f sec\n", init_time/loop_count, norm_time/loop_count);



  return 0;
}
					  
					  
void vectorinit(double *vdata, int leng)
  
{
#pragma omp master
  for ( int i = 0; i < leng; i++)
    {
      vdata[i] = i;
    }
  return;
}



double vectornorm(double *vdata, int leng)
{
  double norm = 0.0;

#pragma omp parallel default(none) shared(vdata, norm, leng)
  {
    double lnorm =0.0;
#pragma omp for
    for (int i = 0; i<leng; i++)
      {
	lnorm += vdata[i] * vdata[i];
      }
#pragma omp atomic
    norm += lnorm;
  }

  norm = sqrt(norm);

  return norm;
  
}
ScalascaExerciseCodes/PaxHeaders.235860/Exercise_30000644000000000000000000000005014276532042017002 xustar0020 atime=1660599785
20 ctime=1660597282
ScalascaExerciseCodes/Exercise_3/0000700001313400131340000000000014276532042017474 5ustar00jheinjhein00000000000000ScalascaExerciseCodes/PaxHeaders.235860/Exercise_10000644000000000000000000000005014276531573017010 xustar0020 atime=1660599785
20 ctime=1660597115
ScalascaExerciseCodes/Exercise_1/0000700001313400131340000000000014276531573017502 5ustar00jheinjhein00000000000000ScalascaExerciseCodes/Exercise_1/PaxHeaders.235860/gauss2d_omp_atomic.f900000644000000000000000000000005014111444263023147 xustar0020 atime=1660597035
20 ctime=1660232292
ScalascaExerciseCodes/Exercise_1/gauss2d_omp_atomic.f900000600001313400131340000000333514111444263023572 0ustar00jheinjhein00000000000000Program gauss2d

  !$ use omp_lib
  
  implicit none

  ! parameters N and h
  integer, parameter :: nsize    = 240000
  double precision, parameter :: stepsize = 0.00005D0

  
  double precision :: xpos, ypos
  double precision :: integral
  double precision :: local_int
  integer :: numthreads

  logical :: parallel_omp

  ! summation indices
  integer :: i, j

  ! timing
  double precision :: start_time, stop_time
  
  ! logical variable to check OpenMP compilation
  parallel_omp = .false.
  !$ parallel_omp = .true.

  ! query the number of threads
  if ( parallel_omp ) then
     !$OMP parallel default(none) shared(numthreads)
     !$ if (omp_get_thread_num() .eq. 0) then
     !$    numThreads = omp_get_num_threads()     
     !$ endif
     !$OMP end parallel
  else
     numThreads = 1
  endif

  integral = 0.0D0
  
  ! start the timer
  !$ start_time = omp_get_wtime()

  ! parallel evalutation of the double sum, parallelise outer loop
  !$OMP parallel default(none) shared(integral) &
  !$OMP    private(xpos, ypos, local_int, i, j)
  local_int = 0.0D0
  !$OMP do schedule(static)
  do i = 0, nsize-1
     xpos = i * stepsize
     do j = i+1, nsize-1
        ypos = j * stepsize
        local_int = local_int + &
             stepsize*stepsize*exp(-xpos*xpos - ypos*ypos)
     enddo  ! j-loop
  enddo     !i-loop
  
  !$OMP atomic update
  integral = integral + local_int
  !$OMP end parallel

  integral = 8.0D0 * integral

  !$ stop_time = omp_get_wtime()

  print *, "Approximate integral:", integral, " for n:", nsize, " and stepsize:", stepsize 

  if(parallel_omp) then
     print *, "Time taken:", stop_time - start_time, "s on", numthreads
  else
     print *,"No timing for serial code implemented"
  endif
  
End program gauss2d
ScalascaExerciseCodes/Exercise_1/PaxHeaders.235860/gauss2d_omp_atomic.c0000644000000000000000000000005014111444310022764 xustar0020 atime=1660597035
20 ctime=1660232292
ScalascaExerciseCodes/Exercise_1/gauss2d_omp_atomic.c0000600001313400131340000000272114111444310023405 0ustar00jheinjhein00000000000000#include <stdio.h>
#include <omp.h>
#include <math.h>

// parameters N and h
#define NSIZE 240000
#define STEPSIZE 0.00005

int main()
{

  double xpos, ypos;
  double integral=0.0;
  double local_int;
  int numThreads;

  // Query the number of threads
#ifdef _OPENMP
#pragma omp parallel default(none) shared(numThreads)
  {
    if (omp_get_thread_num() == 0 )
    {
      numThreads = omp_get_num_threads();
    }
  }
#else
  numThreads = 1;
#endif


  // start the time
#ifdef _OPENMP
  double starttime = omp_get_wtime();
#endif

  // parallel evaluation of the double sum, parallelise outer loop
#pragma omp parallel default(none)              \
  private(xpos, ypos, local_int) shared(integral) 
  {
    local_int = 0.0;
#pragma omp for schedule(static) 
    for ( int i = 0; i < NSIZE; i++)
      {

	xpos = (double) i * STEPSIZE;
	for (int j = i+1; j < NSIZE; j++ )
	  {
	    ypos = (double) j * STEPSIZE;
	    double xvecSquare = xpos*xpos + ypos*ypos;
	    local_int += exp(-xvecSquare) * STEPSIZE * STEPSIZE;
	  }  // j-loop
      }  // i-loop
    
#pragma omp atomic update
    integral += local_int;
    
  }  // parallel region
  
  integral *= 8.0;

#ifdef _OPENMP
  double finaltime = omp_get_wtime() - starttime;
#endif
  printf("Approximate integral: %f for n: %i and stepsize: %f \n",
	 integral, NSIZE, STEPSIZE);
#ifdef _OPENMP
  printf("Time taken: %f s on %i threads\n", finaltime, numThreads);
#else
  printf("No timing for serial code\n");
#endif

  return 0;

}