PerformanceTest.cs

Go to the documentation of this file.

using System;
using System.Threading;

namespace FFT.Test
{
   using FFT;


   ///
   /// Tests the performance.
   ///
   public class PerformaceTest 
   {
      ///
      /// The main entry point. 
      ///
      public static void Main(string[] args)
      {
         //Test.UnitTest.RunTests();

         PerformanceTests();
      }
      
      ///
      /// Runs performance tests. 
      ///
      protected static void PerformanceTests()
      {
         TestConvolutions(new IConvolution[] {
               new DirectConvolution(),
               new PolynomialConvolution(),
               new DFTConvolution(new RecursiveFFT())},
            new int[] { 
               100, 200, 300, 400, 500,
               600, 700, 800, 900,1000}
            );
         
         TestConvolutions(new IConvolution[] {
               new DirectConvolution(),
               new DFTConvolution(new RecursiveFFT())},
            new int[] { 
               1000, 2000, 3000, 4000, 5000,
               6000, 7000, 8000, 9000,10000}
            );

         TestConvolutions(new IConvolution[] {
               new DFTConvolution(new RecursiveFFT()),
               new DFTConvolution(new IterativeFFT())},
            new int[] { 
               1<<5,  1<<6,  1<<7,  1<<8,  1<<9, 
               1<<10, 1<<11, 1<<12, 1<<13, 1<<14,
               1<<15, 1<<16, 1<<17, 1<<18, 1<<19}           
            );

         TestConvolutions(new IConvolution[] {
               new DFTConvolution(new IterativeFFT()),
               new DFTConvolution(new ParallelFFT(2)),
               new DFTConvolution(new ParallelFFT(4))},
            new int[] { 
               1<<8,  1<<9,
               1<<10, 1<<11, 1<<12, 1<<13, 1<<14,
               1<<15, 1<<16, 1<<17, 1<<18, 1<<19}
            );
         
         TestConvolutions(new IConvolution[] {
               new DFTConvolution(new IterativeFFT()),
               new DFTConvolution(new ParallelFFT (2)),
               new DFTConvolution(new ParallelFFT(4))},
            new int[] { 
               1<<15, 1<<16, 1<<17, 1<<18, 1<<19, 1<<20, 1<<21}
            );
         
      } //PerformanceTests

      ///
      /// Measures the performace. 
      ///
      /// Equivalent to FFT::Test::TestConvolutions(conv,sizes,true).
      /// 
      public static void TestConvolutions(IConvolution[] conv, int[] sizes)
      {
         TestConvolutions(conv,sizes,true);
      }
      
      ///
      /// Measures the performance.
      ///
      /// \param conv convolution algorithms to test
      /// \param sizes the sizes of data to use
      /// \param precision whether the relative error should be printed. 
      ///
      public static void TestConvolutions(IConvolution[] conv, int[] sizes, bool precision)
      {
         System.Console.Write("|    Size |");
         for (int i = 0; i < conv.Length; i++) {
            if (precision) {
               System.Console.Write("{0,25}|",conv[i].ToString());
            } else {
               System.Console.Write("{0,11}|",conv[i].ToString());
            }
         }
         System.Console.Write('\n');
         
         System.Console.Write("+---------+");
         for (int i = 0; i < conv.Length; i++) {
            if (precision) {
               System.Console.Write("-------------------------+");
            } else {
               System.Console.Write("-----------+");
            }
         }
         System.Console.Write('\n');
         
         Complex[] a = null;
         Complex[] b = null;
         Complex[] c = null;
         
         foreach (int size in sizes) {
            System.Console.Write("| {0,7:d} |",size);
            GenerateData(size,ref a,ref b,ref c);
            for (int i = 0; i < conv.Length; i++) {
               TestConvolution(conv[i],a,b,c,precision);
            }
            System.Console.Write("\n");
         }
         
         System.Console.Write("\n");
      } // TestConvolutions
      
      ///
      /// The number of times each test is to be repeated.
      ///
      protected static int reps = 1;
      
      ///
      /// Measures the performance of a convolution. 
      ///
      /// \param conv convolution algorithm to test
      /// \param a the first input vector
      /// \param b the second input vector
      /// \param c the expected result
      /// \param precision whether the relative error should be printed
      ///
      protected static void TestConvolution(IConvolution conv, 
                                            Complex[] a, 
                                            Complex[] b,
                                            Complex[] c,
                                            bool precision)
      {
         
         TimeSpan[] duration = new TimeSpan[reps];
         double error = 0;
         for (int i = 0; i < reps; i++) {
            DateTime startTime = DateTime.Now;
            
            Complex[] res = conv.Convolution(a,b);
            
            DateTime stopTime = DateTime.Now;
            duration[i] = stopTime - startTime;
            error = Utils.dist(c,res);
         } 
         
         Array.Sort(duration);
         System.Console.Write(" {0:00}.{1:000} s. ",
                              duration[reps/2].TotalSeconds,
                              duration[reps/2].Milliseconds);
         
         if (precision) {
            System.Console.Write(" ({0,10:e3}) |",error);
         } else {
            System.Console.Write("|");
         }
         
         //forcing garbage collection 
         GC.Collect();
         GC.WaitForPendingFinalizers();
         
      } //TestConvolution
      
      ///
      /// Generates test data. 
      ///
      /// Assigns to <tt>a</tt> and <tt>b</tt> vectors of length <tt>n</tt>
      /// filled with <tt>1</tt>. <tt>c</tt> is filled with the exact values of 
      /// the convolution of <tt>a</tt> and <tt>b</tt>.
      ///
      /// \param n the desired size on the input vector
      /// \param a the first input vector to fill 
      /// \param b the second input vector to fill
      /// \param c the output vector with the convolution of <tt>a</tt> and <tt>b</tt>.
      ///
      protected static void GenerateData(int n,
                                         ref Complex[] a,
                                         ref Complex[] b,
                                         ref Complex[] c)
      {
         a = new Complex[n];
         b = new Complex[n];
         c = new Complex[2*n-1];
         
         for (int i = 0; i < n; i++) {
            a[i] = 1;
            b[i] = 1;
            c[i] = i+1;
            c[2*n-i-2] = i+1; 
         }
         
      }
      
   } //class Test
   
} //namespace FFT

---