Grid Computing Assignment 1 Discrete Fourier Transform ...

Grid Computing
Assignment 1
Discrete Fourier Transform implementation using Vishwa
Problem statement
Shamju Joseph K
I. M.Tech
CS05M038
Finding the frequency spectrum of a given signal using the Discrete Fourier Transform (DFT)
algorithm.
Algorithm
The DFT is given by the equation :
X[k] = 1/N x[n] ( cos 2 kn/N – j sin 2 kn/N), n= 0 : N­1, k = 0 : N­1
where x[n] is the input data, X[k] is the spectrum output, N is the total number of samples.
Parallelization
As the equation shows, this is a very computation intensive operation for large values of N and
is the case with most of the real world applications. The DFT equation is parallelized by dividing the
outer loop (loop of k) into m subtasks and these subtasks are executed on different nodes. The input
data signal is available in one single file. Every task is provided with parameters like total number of
tasks, current task number, number of samples and each task processes a section of the equation based
on the parameters. These parameters are provided in a separate file for each task. So that the data file
need not be partitioned separately.
The sequential DFT code is given below:
int DFT(int samples,double *x1,double *y1)
{
long i,k;
double arg;
double cosarg,sinarg;
double *x2=NULL,*y2=NULL;
x2 = (double*) malloc(samples*sizeof(double));
y2 = (double*) malloc(samples*sizeof(double));
if (x2 == NULL || y2 == NULL)
return(FALSE);

}
for (i=0;i

sinarg = sin(k * arg);
x2[i2] += (x1[k] * cosarg ­ y1[k] * sinarg);
y2[i2] += (x1[k] * sinarg + y1[k] * cosarg);
}
}
// Copy the data back
for( i = 0; i < blockSize; i++ )
{
x1[i] = x2[i];
y1[i] = y2[i];
}
free(x2);
free(y2);
return(1);
}
where blockSize and offset fields are decided by Total Tasks and Current Task No
parameters and is given by:
blockSize = samples / TotalTasks;
offset = CurrentTask * blockSize;
Execution Procedure
The following shows various files required for parallelization of DFT computation of a 1024
sample data file using 4 grid nodes
1. data.txt : Input data file
2. param0.data : Parameter file for task 0
3. param1.data : Parameter file for task 1
4. param2.data : Parameter file for task 2
5. param3.data : Parameter file for task 3
6. metafile.txt : Configuration file which specifies the arguments to each subtask.
Content of the file ‘param0.dat’
4 (No of Tasks)
0 (current task no)
1024 (total samples)
Content of the file ‘param1.dat’
4 (No of Tasks)
1 (current task no)
1024 (total samples)

Content of the file ‘param2.dat’
4 (No of Tasks)
2 (current task no)
1024 (total samples)
Content of the file ‘param3.dat’
4 (No of Tasks)
3 (current task no)
1024 (total samples)
Content of the file ‘metafile.txt’
4 (No of Tasks)
2 (No of arguments to each task)
param0.dat data.dat (arguments to task 0 )
param1.dat data.dat (arguments to task 1 )
param2.dat data.dat (arguments to task 2 )
param3.dat data.dat (arguments to task 3 )
1. Run ‘purezonalserver’ on one of the nodes.
2. Next set up the grid by running ‘purefaultgridnode’
on the four nodes which want to participate in the grid.
3. Submit the grid task by running ‘user’ .
The parameters for the program ‘user’ :
• Meta file name : metafile.txt
• Source file for tasks : dft_task.c
• No of splits : 4
• Output file : result.dat
• Source file for aggregation : dft_agg.c
4. The result will be available in the file ‘result.dat’ after the computation.
Vishwa starts the grid computation by running the ‘dft_task’ at each node with the files
‘paramx.dat’ (x corresponds to task number) and ‘data.dat’ as arguments, which are provided in the file
‘metafile.txt’. Each subtask reads ‘paramx.dat’ file to get number of tasks, current task no and number
of samples, then computes a portion of the equation using these values and writes the result into a file.
Once all the subtasks finish execution, ‘dft_agg’ is executed which will aggregate the result into the
‘result.dat’file.
Sample Plots

Observations
1. There can be a provision for the user to list the various grid nodes participating in the
computation with status like busy, idle etc.
2. The total number of tasks and current task number are to be given to the subtasks by vishwa to
allow writing parallel code. Splitting the data manually is tedious and time consuming. Once these two
parameters are available, the sub task can read a selected region of the input data for processing.
3. It is observed that, when given number of splits more than one, most of the time the sub tasks are
executed on the same grid node and when executed on different nodes, the result is not properly
combined.
4. Finding the time requirement for the computation including task distribution and result
aggregation is difficult.
5. A provision can be given for submitting multiple source files including cpp files.
6. The 'user' program could read the parameters (metafile, sub task file, result file etc) from a file to
avoid entering these parameters every time for different runs.
7. Displaying the entire result file onto the screen can be avoided.
References
1. Digital Signal Processing, Alan V. Oppenheim and Ronald W. Schafer
2. http://dos.iitm.ac.in