JASPL  0.2
Just Another Signal Processing Library
/home/bephillips2/Qt-Projects/JASPL/main.cpp
1 
2 //C System-Headers
3 #include <math.h>
4 #include <stdio.h>
5 //C++ System headers
6 #include <iostream>
7 #include <chrono>
8 #include <unistd.h>
9 //OpenCL Headers
10 //
11 //Boost Headers
12 //
13 //Qt Headers
14 //
15 //Project specific headers
16 #include "jFFT/test_jfft.h"
17 #include "jVector/jvector.h"
18 #include "jFFT/jfft.h"
19 #include "jFFT/perf_jfft.h"
20 #include "jPlot/jplot.h"
21 #include "jFilter/jlinearfilter.h"
22 #include "jTypeTraits/jtypetraits.h"
23 #include "jFilter/jfilter_unit_test.h"
24 #include "OpenCLBase/openclbase.h"
25 #include "TaskQueue/taskqueue.h"
26 #include "TaskItems/LinearConvolution/linearconvolution.h"
27 #include "jChart/jchart.h"
28 #include "TaskItems/FFT/fft.h"
29 #include "TaskItems/PowerSpectrum/powerspectrum.h"
30 #include "TaskItems/Arithmetic/ScalarAdd/scalaradd.h"
31 #include "TaskItems/Arithmetic/ScalarMultiply/scalarmultiply.h"
32 #include "Containers/test_ouroborus.h"
33 
34 #define TEST_POINTS pow( 2, 16 )
35 #define TEST_TYPE float
36 #define MAX_ITER 24
37 
38 void TimingTest() {
39  // QApplication a(argc, argv);
40 
41  uint N = (uint)TEST_POINTS;
42 
43  std::vector< TEST_TYPE > sin_vect;
44  sin_vect.reserve( N );
45 
46  for ( uint i = 0; i < N ; i++ ) {
47 
48  sin_vect.push_back( sinf( (N/8)*i *2*M_PI/N) + 2*sinf( (N/4)*i*2*M_PI/N) + 3*sinf( (3*N/8)*i*2*M_PI/N ) );
49  // uint M = 500;
50  // sin_vect.push_back( sinf( (M)*i *2*M_PI/N) + 2*sinf( (2*M)*i*2*M_PI/N) + 3*sinf( (3*M)*i*2*M_PI/N ) );
51  }
52 
53  // jaspl::plot( sin_vect );
54 
55  // auto start_opencl = std::chrono::high_resolution_clock::now();
56 
57  auto test_q = jaspl::ocl::TaskQueue< std::vector< TEST_TYPE > > ( 0, 0 );
58 
59  TEST_TYPE fact = static_cast< TEST_TYPE >( 1.0f / 100.0f );
60 
61  std::vector< TEST_TYPE > box_vec( 100, fact );
62  jaspl::ocl::LinearConvolution< std::vector< TEST_TYPE > > conv_task ( box_vec );
63  test_q.AddTaskItem( conv_task );
64 
65  auto fft_task = jaspl::ocl::PowerSpectrum< std::vector< TEST_TYPE > > ();
66  test_q.AddTaskItem( fft_task );
67 
68  auto mult_task = jaspl::ocl::ScalarMultiply< std::vector< TEST_TYPE > >( 2.0f );
69  test_q.AddTaskItem( mult_task );
70 
71  auto addition_task = jaspl::ocl::ScalarAdd< std::vector< TEST_TYPE > >( 5.0f );
72  test_q.AddTaskItem( addition_task );
73 
74  auto start_opencl = std::chrono::high_resolution_clock::now();
75 
76  test_q.Load( sin_vect );
77 
78  test_q.Execute();
79 
80  // test_q.PrintContents();
81 
82  std::vector< TEST_TYPE > processed = test_q.Recall();
83 
84  auto end_opencl = std::chrono::high_resolution_clock::now();
85  std::chrono::duration<double, std::milli> opencl_ms = end_opencl - start_opencl;
86  auto time_taken_opencl = opencl_ms.count();
87 
88  std::cout<<"OpenCL Took "<<time_taken_opencl<<" ms."<<std::endl;
89 
90  jaspl::plot( processed, "OpenCL" );
91 
92  // return a.exec();
93 
94  jaspl::JFFT< std::vector < TEST_TYPE > > fft_er( true );
95 
96  auto time_series = sin_vect;
97 
98  auto start_cpu = std::chrono::high_resolution_clock::now();
99 
100  fft_er.PowerSpectrum( time_series );
101 
102  uint spectrum_size = time_series.size();
103  uint n_half = (spectrum_size % 2 == 0) ? (spectrum_size / 2) : ((
104  spectrum_size - 1) / 2);
105 
106  time_series.erase(time_series.end() - n_half , time_series.end());
107 
108  auto end_cpu = std::chrono::high_resolution_clock::now();
109  std::chrono::duration<double, std::milli> cpu_ms = start_cpu - end_cpu;
110  auto time_taken_cpu = cpu_ms.count();
111 
112  std::cout << "CPU Took" << time_taken_cpu << " ms." << std::endl;
113 
114  // jaspl::plot( time_series, "CPU" );
115 }
116 
117 void fftTimingTest() {
118 
119  std::vector< double > opencl_timing_data;
120  std::vector< double > cpu_timing_data;
121 
122  auto test_q = jaspl::ocl::TaskQueue< std::vector< TEST_TYPE > > ( 0, 0 );
123 
124  auto fft = jaspl::ocl::FFT< std::vector< TEST_TYPE > >();
125  test_q.AddTaskItem( fft );
126 
127  for ( uint j = 2 ; j <= MAX_ITER ; j ++ ) {
128 
129  uint N = static_cast<uint>( pow( 2.0, j ) );
130 
131  std::cout << "Timing signal size of " << N << std::endl;
132 
133  std::vector< TEST_TYPE > sin_vect;
134  sin_vect.reserve( N );
135 
136  for ( uint i = 0; i < N ; i++ ) {
137  sin_vect.push_back( sinf( (N/8)*i *2*M_PI/N) + 2*sinf( (N/4)*i*2*M_PI/N) + 3*sinf( (3*N/8)*i*2*M_PI/N ) );
138  }
139 
140  auto start_opencl = std::chrono::high_resolution_clock::now();
141 
142  test_q.Load( sin_vect );
143 
144  test_q.Execute();
145 
146  std::vector< TEST_TYPE > processed = test_q.Recall();
147 
148  auto end_opencl = std::chrono::high_resolution_clock::now();
149  std::chrono::duration<double, std::milli> opencl_ms = end_opencl - start_opencl;
150  auto time_taken_opencl = opencl_ms.count();
151 
152  std::cout<<"OpenCL Took "<<time_taken_opencl<<" ms."<<std::endl;
153 
154  opencl_timing_data.push_back( time_taken_opencl );
155 
156  }
157 
158  for ( uint j = 2 ; j <= MAX_ITER ; j ++ ) {
159 
160  uint N = static_cast<uint>( pow( 2.0, j ) );
161 
162  std::cout << "Timing signal size of " << N << std::endl;
163 
164  std::vector< TEST_TYPE > sin_vect;
165  sin_vect.reserve( N );
166 
167  for ( uint i = 0; i < N ; i++ ) {
168  sin_vect.push_back( sinf( (N/8)*i *2*M_PI/N) + 2*sinf( (N/4)*i*2*M_PI/N) + 3*sinf( (3*N/8)*i*2*M_PI/N ) );
169  }
170 
171  auto start_cpu = std::chrono::high_resolution_clock::now();
172 
173  auto fft_er = std::unique_ptr< jaspl::JFFT< std::vector< TEST_TYPE > > >( new jaspl::JFFT< std::vector< TEST_TYPE > >( true ) );
174 
175  auto power_spec = fft_er->PowerSpectrum( sin_vect );
176 
177  uint spectrum_size = sin_vect.size();
178  uint n_half = (spectrum_size % 2 == 0) ? (spectrum_size / 2) : (( spectrum_size - 1) / 2);
179 
180  power_spec.erase( power_spec.end() - n_half , power_spec.end());
181 
182  auto end_cpu = std::chrono::high_resolution_clock::now();
183  std::chrono::duration<double, std::milli> cpu_ms = end_cpu - start_cpu;
184  auto time_taken_cpu = cpu_ms.count();
185 
186  std::cout << "CPU Took" << time_taken_cpu << " ms." << std::endl;
187 
188  cpu_timing_data.push_back( time_taken_cpu );
189  }
190 
191 // jaspl::plot_to_disk( cpu_timing_data,
192 // opencl_timing_data,
193 // "Intel(R) Core(TM) i7-4700HQ CPU @ 2.40GHz","GeForce GTX 860M",
194 // "Power Spectrum CPU vs. GPU" );
195 
196 }
197 
198 void convolutionTimingTest() {
199 
200  std::vector< double > opencl_timing_data;
201  std::vector< double > cpu_timing_data;
202 
203  auto test_q = jaspl::ocl::TaskQueue< std::vector< TEST_TYPE > > ( 0, 0 );
204 
205  TEST_TYPE fact = static_cast< TEST_TYPE >( 1.0f / 100.0f );
206 
207  std::vector< TEST_TYPE > box_vec( 100, fact );
208 
209  auto conv_task = jaspl::ocl::LinearConvolution< std::vector< TEST_TYPE > >( box_vec );
210  test_q.AddTaskItem( conv_task );
211 
212  for ( uint j = 2 ; j <= MAX_ITER ; j ++ ) {
213 
214  uint N = static_cast<uint>( pow( 2.0, j ) );
215 
216  std::cout << "Timing signal size of " << N << std::endl;
217 
218  std::vector< TEST_TYPE > sin_vect;
219  sin_vect.reserve( N );
220 
221  for ( uint i = 0; i < N ; i++ ) {
222  sin_vect.push_back( sinf( (N/8)*i *2*M_PI/N) + 2*sinf( (N/4)*i*2*M_PI/N) + 3*sinf( (3*N/8)*i*2*M_PI/N ) );
223  }
224 
225  auto start_opencl = std::chrono::high_resolution_clock::now();
226 
227  test_q.Load( sin_vect );
228 
229  test_q.Execute();
230 
231  std::vector< TEST_TYPE > processed = test_q.Recall();
232 
233  auto end_opencl = std::chrono::high_resolution_clock::now();
234  std::chrono::duration<double, std::milli> opencl_ms = end_opencl - start_opencl;
235  auto time_taken_opencl = opencl_ms.count();
236 
237  std::cout<<"OpenCL Took "<<time_taken_opencl<<" ms."<<std::endl;
238 
239  opencl_timing_data.push_back( time_taken_opencl );
240 
241  }
242 
243  for ( uint j = 2 ; j <= MAX_ITER ; j ++ ) {
244 
245  uint N = static_cast<uint>( pow( 2.0, j ) );
246 
247  std::cout << "Timing signal size of " << N << std::endl;
248 
249  std::vector< TEST_TYPE > sin_vect;
250  sin_vect.reserve( N );
251 
252  for ( uint i = 0; i < N ; i++ ) {
253  sin_vect.push_back( sinf( (N/8)*i *2*M_PI/N) + 2*sinf( (N/4)*i*2*M_PI/N) + 3*sinf( (3*N/8)*i*2*M_PI/N ) );
254  }
255 
256  auto start_cpu = std::chrono::high_resolution_clock::now();
257 
258  jaspl::JLinearConvolve( sin_vect, box_vec );
259 
260  auto end_cpu = std::chrono::high_resolution_clock::now();
261  std::chrono::duration<double, std::milli> cpu_ms = end_cpu - start_cpu;
262  auto time_taken_cpu = cpu_ms.count();
263 
264  std::cout << "CPU Took" << time_taken_cpu << " ms." << std::endl;
265 
266  cpu_timing_data.push_back( time_taken_cpu );
267  }
268 
269 // jaspl::plot_to_disk( cpu_timing_data,
270 // opencl_timing_data,
271 // "Intel(R) Core(TM) i7-4700HQ CPU @ 2.40GHz","GeForce GTX 860M",
272 // "Linear Convolution CPU vs. GPU" );
273 
274 }
275 
276 int main(int argc, char *argv[]) {
277 
278  (void)argc;
279  (void)argv;
280 
281 // jaspl::ocl::PrintOCLDebugInfo();
282 
283 // fftTimingTest();
284 // convolutionTimingTest();
285  jaspl::RunTestJFFT();
286 
287 }
Generated by   doxygen 1.8.11