Question

write a small C program including the following C functions/subroutines. Your main routine should use these functions to generate a small-ish array of random values and show that the standard deviation lowers as the array is smoothed.
• void random_array(double* array, int size, double scale); – load an array with random double values scaled by scale (random number generators generate double values between 0 and 1). Note: array should point to memory already allocated. • double sum(double* array, int size); – return the sum of all elements in the array • double stdev(double* array, int size); – calculate the standard deviation of the elements in array • void smooth(double* array, int size, double w); – replace all internal values (not the first or last) with a weighted sum of itself and average of the neighboring elements newvali = oldvali ∗w + (oldvali−1 + oldvali+1)(1−w)/2

Main task is use OpenMP to parallelize code from above instructions that generated a random array and repeatedly smoothed the array to lower the standard deviation.

parallelize each for loop individually, meaning that the code between the functions you wrote is serialized. This should not affect performance in any notable way. (In other words, most of the work here is simply using #pragma omp parallel for Make sure to use default(none) on your parallel sections to ensure that you are not inadvertently sharing data (or assuming that some variable is unique to each thread, for that matter).
Prioritize the use of reductions over critical sections.

use a smoothing algorihtm that smooths into a second array, as this is much easier to parallelize safely than an in-place smoothing. (You can do it with an OpenMP for loop, instead of having to partition it yourself). Also note that some versions of the rand() function are forced to be serial by the operating system. Perhaps you can find a safely parallelizable alternate function?)

Answer 1

Program Files

pxmain.c

// pxmain.c
#include <stdio.h>
#include <stdlib.h>
#include <omp.h>
#include "pxarray.h"
int main()
{
// constants
long ARRAYLENGTH;
int NUMSMOOTH;
double SMOOTHWEIGHT, ARRAYSCALE;

//read input for the above
printf("Enter the length of your array: \n");
scanf("%li", &ARRAYLENGTH);
printf("Enter the max possible value of an element in your array:\n");
scanf("%lf", &ARRAYSCALE);
printf("Enter the weight of your smoothing algorithm [e.g. 0.25]:\n");
scanf("%lf", &SMOOTHWEIGHT);
printf("Enter the number of times you would like to smooth your array:\n");
scanf("%i", &NUMSMOOTH);
printf("\n");

// create an array d[] and initialize it
// demonstration of random_array()
double *d;
d = (double *)malloc(sizeof(double)*ARRAYLENGTH);
random_array(d,ARRAYLENGTH,ARRAYSCALE);

// // // //
// uncomment the below to print the array
// ...leaving it out for large sizes
// // // //

//printf("Hello! Here's your array: \n");
//printarray(d,ARRAYLENGTH);

// demonstration of sum()
printf("The sum of your array is: ");
double start_a = omp_get_wtime();
printf("%f", sum(d,ARRAYLENGTH));
double end_a = omp_get_wtime();
printf("\n");

// demonstration of stdev()
printf("The standard deviation of your array is:");
double start_b = omp_get_wtime();
printf("%f", stdev(d,ARRAYLENGTH));
double end_b = omp_get_wtime();
printf("\n");

// demonstration of smooth()
printf("If we smooth out your array, weighted at ");
printf("%f", SMOOTHWEIGHT);
printf(", we get: \n");

double start_c = omp_get_wtime();
for (int i = 0; i < NUMSMOOTH; i++) {
printf("*** Iteration %d *** \n", i + 1);
smooth(d,ARRAYLENGTH,SMOOTHWEIGHT);
//printarray(d,ARRAYLENGTH);
printf("The stdev of your array after smoothing is: ");
printf("%f \n", stdev(d,ARRAYLENGTH));
}
double end_c = omp_get_wtime();

printf("The runtime of this algorithm was %lf seconds in total.\n",(end_a - start_a) + (end_b - start_b) + (end_c - start_c));
printf("The summation took %lf seconds. \n", end_a - start_a);
printf("The standard deviation took %lf seconds. \n", end_b - start_b);
printf("The smoothing took %lf seconds (totaled over %d iterations). \n", end_c - start_c, NUMSMOOTH);

printf("\n");

return 0;
}

pxarray.h

// pxarray.h
#ifndef PXARRAY_H
#define PXARRAY_H
void printarray(double* array, int size);
void random_array(double* array, int size, double scale);
double sum(double* array, int size);
double stdev(double* array, int size);
void smooth(double* array, int size, double w);
#endif

pxarray.c

// pxarray.c
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <omp.h>
#include "pxarray.h"

// printarray()
// print out the elements of an array
void printarray(double* array, int size) {
#pragma omp for
for (int i = 0; i < size; i++) {
printf("%f \n", array[i]);
}
}

// random_array()
// throws random numbers into the provided array, weighted by scale
void random_array(double* array, int size, double scale) {
//#pragma omp parallel default(none) shared(array, size, scale)
{
//srand(time(0)) ^ omp_get_thread_num();
//srand(time(omp_get_thread_num()));
//#pragma omp for
for (int i = 0; i < size; i++) {
array[i] = rand() * scale / RAND_MAX;
}
}
}

// sum()
// return the sum of all elements in the array
double sum(double* array, int size) {
double sum = 0.0;

#pragma omp parallel for reduction(+:sum) schedule(guided)
for (int i = 0; i < size; i++) {
sum += array[i];
}

return sum;
}

// stdev()
// calculate the standard deviation of the elements in array
double stdev(double* array, int size) {
double stdv = 0.0;
double mean = sum(array, size)/size;

#pragma omp parallel for reduction(+:stdv) schedule(guided)
for (int i = 0; i < size; i++) {
stdv += pow(array[i] - mean, 2);
}

return sqrt(stdv/size);
}

// smooth()
// replace all internal values (not the first or last) with a weighted sum of
// itself and average of the neighboring elements
// newvali = oldvali ∗ w + (oldvali−1 + oldvali+1)(1 − w)/2
void smooth(double* array, int size, double w) {
double temp[size];

//init the "inner" array
temp[0] = array[0];
temp[size - 1] = array[size - 1];

//...and then smooth the array as described above
for (int i = 1; i < size - 1; i++) {
temp[i] = array[i] * w + (array[i - 1] + array[i + 1]) * (1 - w)/2;
}

//finally, replace the elements of array with that of temp
#pragma omp parallel for
for (int i = 0; i < size; i++) {
array[i] = temp[i];
}
}

Hope this helps!

Please let me know if any changes needed.

Thank you!