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
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
|
#include "cuda_runtime.h"
#include "device_launch_parameters.h"
#include <time.h>
#include <stdio.h>
#include <omp.h>
#define NUMOFTRACES (70000)
#define NUMOFDATAPOINTS (256*6*14)
#define arraySize ((long long)NUMOFTRACES*NUMOFDATAPOINTS)
#define Anzahl_block (256)
// GPU BERECHNUNGSFUNKTION
__global__ void Berechnung_Mittelwert_Varianz(float *Mittelwert, float *Varianz, const float *Vektor, unsigned int numtraces, unsigned int numdatapoints)
{
float Sum_varianz=0;
float Sum_mittelwert=0;
int mydatapoint=blockDim.x * blockIdx.x + threadIdx.x;
for(int i=0; i<numtraces; i++)
{
float temp =Vektor[(size_t) i*numdatapoints + mydatapoint];
//Bestimme den Mittelwert der Datenpunkte an der Stelle [i]
Sum_mittelwert += temp;
//Bestimme den Mittelwert der QUADRATE der Datenpunkte an der Stelle [i]
Sum_varianz += temp*temp;
}
Sum_mittelwert /= numtraces;
Sum_varianz /= numtraces;
Varianz[mydatapoint]= Sum_varianz-Sum_mittelwert*Sum_mittelwert ;
Mittelwert[mydatapoint]=Sum_mittelwert;
}
// CPU BERECHNUNGSFUNKTION
void Berechnung_Mittelwert_Varianz1(float *Mittelwert, float *Varianz, const float *Vektor, unsigned int numtraces, unsigned int numdatapoints)
{
#pragma omp parallel for
for(int j=0;j<NUMOFDATAPOINTS;j++)
{
float Sum_varianz=0;
float Sum_mittelwert=0;
for(int i=0; i<numtraces; i++)
{
float temp =Vektor[i*numdatapoints+j];
//Bestimme den Mittelwert der Datenpunkte an der Stelle [i]
Sum_mittelwert += temp;
//Bestimme den Mittelwert der QUADRATE der Datenpunkte an der Stelle [i]
Sum_varianz += temp*temp;
}
Sum_mittelwert /= numtraces;
Sum_varianz /= numtraces;
Varianz[j]= Sum_varianz-Sum_mittelwert*Sum_mittelwert ;
Mittelwert[j]=Sum_mittelwert;
}
}
int main()
{
unsigned int numtraces = NUMOFTRACES ;
unsigned int numdatapoints = NUMOFDATAPOINTS;
// Zeit parameter
double start, end, start1, end1;
//CPU (host)
float *Vektor = (float*) malloc( arraySize*sizeof(float) );
float *Varianz = (float*) malloc( NUMOFDATAPOINTS*sizeof(float) );
float *Mittelwert = (float*) malloc( NUMOFDATAPOINTS*sizeof(float) );
//Initialization von Vektor
for (int i=0;i<NUMOFTRACES;i++)
{
for (int j=0;j<NUMOFDATAPOINTS;j++)
Vektor[i*NUMOFDATAPOINTS+j] = j-3+(i%7);
}
//GPU
float *dev_Vektor = 0;
float *dev_Varianz = 0;
float *dev_Mittelwert = 0;
// Allocate GPU buffers for two vectors (one input, one output) .
cudaMalloc((void**)&dev_Mittelwert, numdatapoints * sizeof(float));
cudaMalloc((void**)&dev_Varianz, numdatapoints * sizeof(float));
cudaMalloc((void**)&dev_Vektor, (size_t) numtraces *numdatapoints* sizeof(float));
// START Die Zeit messen für die GPU
start = clock();
cudaMemcpy(dev_Vektor, Vektor, (size_t) numtraces*numdatapoints * sizeof(float), cudaMemcpyHostToDevice);
// Launch a kernel on the GPU with one thread for each element.
Berechnung_Mittelwert_Varianz<<<numdatapoints/Anzahl_block, 256>>>(dev_Mittelwert, dev_Varianz, dev_Vektor, numtraces, numdatapoints);
// Copy output vector from GPU buffer to host memory.
cudaMemcpy(Mittelwert, dev_Mittelwert, numdatapoints * sizeof(float), cudaMemcpyDeviceToHost);
cudaMemcpy(Varianz, dev_Varianz, numdatapoints * sizeof(float), cudaMemcpyDeviceToHost);
// cudaDeviceSynchronize waits for the kernel to finish, and returns
// any errors encountered during the launch.
cudaDeviceSynchronize();
// END Die Zeit messen für die GPU
end = clock();
// Ausgabe des Mittelwert und des Varianz
for (int j=0;j<15;j++)
{
printf("Mittelwert[%d] == [%f] ===> Varianz[%d] == [%f]\n",j, Mittelwert[j],j, Varianz[j]);
}
// START Die Zeit messen für die CPU
start1 = clock();
//CPU BERECHNUNGSFUNKTION
Berechnung_Mittelwert_Varianz1(Mittelwert, Varianz, Vektor, numtraces, numdatapoints);
// END Die Zeit messen für die CPU
end1 = clock();
// Ausgabe des Mittelwert und des Varianz
for (int j=0;j<15;j++)
{
printf("Mittelwert[%d] == [%f] ===> Varianz[%d] == [%f]\n",j, Mittelwert[j],j, Varianz[j]);
}
fprintf(stderr, "Time GPU in Sekunde : %f\n", (double)(end-start) / (double) CLOCKS_PER_SEC);
fprintf(stderr, "Time CPU in Sekunde : %f\n", (double)(end1-start1) / (double) CLOCKS_PER_SEC);
cudaFree(dev_Mittelwert);
cudaFree(dev_Varianz);
cudaFree(dev_Vektor);
} |
Calcul de la moyenne d un Tableau
Répondre avec citation
)
Partager