Dear all,
I have a problem like this:
float input[100][16];
I want to group each 5 rows of the input so I will have 20 of 5 rows each with 16 dimensions.
For each group, I need to find max, min, and mean/median within each dimension separately, so I get 16 of max, min, and mean/median for each group. The next step is rather confusing so I ask this first pass first.
Is there any ways to do it using Brook+? I thought of using reduce kernel.
reduce void
sum(float i<>, reduce float o<>
{
o = o + i/(float)5;
}
for each 5 within a dimension in a group. But how? These each 5 separated by rows while reduce kernel operated in columns.
Is there anyway to do it by offset, for each 5 then reduce it to one? Yes I need to change the 2 dimensional array to 1 dimension but it is not hard.
Later will be compiled in the CPU for next operation.
As for max and min values haven't got any ideas yet. Anyone has a suggestion?
Thanks anyway.
I've tried the A4.1.3 and using the rest of min max reduction function there.
But it seems my program didn't execute well, the is access violation there, that I don't understand why.
From example the written:
#include "brookgenfiles/percobaan_pertama.h"
#include <iostream>
#include <iomanip>
#include <fstream>
using namespace std;
using namespace brook;
template <typename T>
T **AllocateDynamicArray2D( int nRows, int nCols)
{
T **dynamicArray;
dynamicArray = new T*[nRows];
for( int i = 0 ; i < nRows ; i++ )
dynamicArray = new T [nCols];
return dynamicArray;
}
template <typename T>
void FreeDynamicArray2D(T** dArray)
{
delete [] *dArray;
delete [] dArray;
}
template <typename T>
T *AllocateDynamicArray1D( int nDims)
{
T *dynamicArray;
dynamicArray = new T[nDims];
return dynamicArray;
}
template <typename T>
void FreeDynamicArray1D(T* dArray)
{
delete [] dArray;
}
int
main(int argc, char* argv[])
{
int jumlahData = 480;
int jumlahDiSatuGrup = 5;
int jumlahDimensi = 16;
int jumlahOutput = 6;
unsigned int streamSize[] = {jumlahDimensi, jumlahData};
unsigned int streamSizeReduce[] = {jumlahDimensi, jumlahData/jumlahDiSatuGrup};
unsigned int rank = 2;
//int baris = jumlahData * jumlahDimensi / jumlahDiSatuGrup;
//float ** arr0 = AllocateDynamicArray<float>(baris,jumlahDiSatuGrup);
float **arr0 = AllocateDynamicArray2D<float>(jumlahDimensi,jumlahData);
float **arr1 = AllocateDynamicArray2D<float>(jumlahDimensi,jumlahData/jumlahDiSatuGrup);
float **arr2 = AllocateDynamicArray2D<float>(jumlahDimensi,jumlahData/jumlahDiSatuGrup);
float **arr3 = AllocateDynamicArray2D<float>(jumlahDimensi,jumlahData/jumlahDiSatuGrup);
ifstream inFile;
inFile.open("train data.txt");
if (!inFile) {
cout << "Unable to open file";
exit(1); // terminate with error
}
//for( int i = 0; i < baris * jumlahDiSatuGrup; i++)
for( int i = 0; i < jumlahDimensi * jumlahData; i++)
{
float temp;
if( inFile >> temp)
arr0[i/jumlahData][i%jumlahData] = temp;
}
/*for( int i = 0; i < jumlahDimensi * jumlahData; i++)
{
printf("%f ", arr0[i/jumlahData][i%jumlahData]);
}*/
Stream<float> streami0(rank, streamSize);
Stream<float> streami1(rank, streamSizeReduce);
Stream<float> streami2(rank, streamSizeReduce);
Stream<float> streami3(rank, streamSizeReduce);
streamRead(streami0,arr0);
mean_of_five(streami0,streami1);
max_reduce(streami0,streami2);
min_reduce(streami0,streami3);
streami1.write(arr1);
streami2.write(arr2);
streami3.write(arr3);
inFile.close();
FreeDynamicArray2D<float>(arr0);
FreeDynamicArray2D<float>(arr1);
FreeDynamicArray2D<float>(arr2);
FreeDynamicArray2D<float>(arr3);
getchar();
return 0;
}
the brook+ code is like one below:
reduce void mean_of_five(float a<>, reduce float b<>
{
b += (float)0.2*a;
}
reduce void max_reduce(float a<>, reduce float b<>
{
if(a > b)
b = a;
}
reduce void min_reduce(float a<>, reduce float b<>
{
if(a < b)
b = a;
}
Why the access violation happens? The first subscript was fine if I look at the example.
Changing the last to:
mean_of_five((float)5.0,streami0,streami1);
max_reduce(streami0,streami2);
min_reduce(streami0,streami3);
streamWrite(streami1,arr1);
streamWrite(streami2,arr2);
streamWrite(streami3,arr3);
cout << (arr0[0]+arr0[1]+arr0[2]+arr0[3]+arr0[4])/5 <<endl;
cout << arr1[0] << endl;
cout << arr2[0] << endl;
cout << arr3[0] << endl;
with mean_of_five:
reduce void mean_of_five(float x,float a<>, reduce float b<>
{
b += a/x;
}
shows different result.
Anyone help
Thanks a lot. The array in stream kinda like transposing the CPU array, I just realized it 
So I will need to make kernel to average the summing:
kernel void average( float div, float a<>, out float b<> )
{
b = a / div;
}
then call it from main:
average( 5.0f, streami1, streamAverage);
At first I confuse to your explanation since in page A-10 Stream Computing User Guide there is a line in first paragraph:
..., or used as a subkernel by an enclosing kernel (which can itself be a reduction kernel).
Now I think that part of the book is not suitable in this situation, and for now I would not use that.
