parallel-lab1/RandomVector.cpp at master · nrvru/parallel-lab1 · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
#include<string>
#include<random>
#include<omp.h>

#include"RandomVector.h"

RandomVector::RandomVector(int vector_size, int min_distribution_value, int max_distribution_value) {
this->min_distribution_value = min_distribution_value;
this->max_distribution_value = max_distribution_value;
this->vector = newint[vector_size];
this->vector_size = vector_size;
this->GenerateVector();
}

RandomVector::~RandomVector() {
delete [] vector;
}

voidRandomVector::GenerateVector() {
 std::minstd_rand generator;
 std::uniform_int_distribution<> distribution(min_distribution_value, max_distribution_value);

for(int i = 0; i < vector_size; i++) {
 vector[i] = distribution(generator);
 }
}

intRandomVector::MaxElement() {
int max = 0, i;

for(i = 0; i < vector_size; i++) {
if(vector[i] > max) {
 max = vector[i];
 }
 }
return max;
}

intRandomVector::MaxElement(int num_threads) {
int max = 0, i;
int vector_size = this->vector_size;
int* vector = this->vector;

 #pragma omp parallel num_threads(num_threads) shared(vector, vector_size, max) private(i)
 {
 #pragma omp for
for (i = 0; i < vector_size; i++) {
if (vector[i] > max) {
 max = vector[i];
 }
 }
 }
return max;
}

longlongRandomVector::ScalarProduct(RandomVector *multiplier) {
longlong product = 0;
int *multiplier_vector = multiplier->get_vector();

for(int i = 0; i < vector_size; i++){
 product += (longlong)vector[i] * multiplier_vector[i];
 }

return product;
}

longlongRandomVector::ScalarProductReduction(RandomVector *multiplier) {
longlong product = 0;
int *vector = this->vector;
int *multiplier_vector = multiplier->get_vector();
int vector_size = this->vector_size;

omp_set_num_threads(DEFAULT_NUM_THREADS);
 #pragma omp parallel for shared(vector, vector_size, multiplier_vector) reduction(+:product)
for (int i = 0; i < vector_size; i++) {
 product += (longlong) vector[i] * multiplier_vector[i];
 }

return product;
}

longlongRandomVector::ScalarProductCascade(RandomVector *multiplier, int elementsInSeriesPerThread) {
int *vector = this->vector;
int *multiplier_vector = multiplier->get_vector();
longlong *temp = newlonglong[this->vector_size];
int vector_size = this->vector_size;
int step;

omp_set_num_threads(DEFAULT_NUM_THREADS);
 #pragma omp parallel private(step) shared(vector_size)
 {
int i, j, count, num;
 num = omp_get_thread_num();
 count = omp_get_num_threads();

for(i = num * elementsInSeriesPerThread; i < vector_size; i += elementsInSeriesPerThread * count) {
 temp[i] = 0;
for (j = i; j < (i + elementsInSeriesPerThread) && j < vector_size; j++) {
 temp[i] += vector[j] * multiplier_vector[j];
 }
 }

for(step = elementsInSeriesPerThread; step < vector_size; step *= 2) {
 #pragma omp barrier
 #pragma omp for
for(i = step; i < vector_size; i += 2*step) {
 temp[i-step] += temp[i];
 }

 }
 }

return temp[0];
}

std::string RandomVector::ToString() {
 std::string str = "";
for (int i = 0; i < vector_size; i++) {
 str += std::to_string(vector[i]) + ", ";
if(i % 10 == 0 && i != 0){
 str += "\n";
 }
 }
return str;
}


int *RandomVector::get_vector() {
returnthis->vector;
}