• Main Page
  • Namespaces
  • Data Structures
  • Files
  • File List
  • Globals

/data/development/ViennaCL/ViennaCL-1.1.2/viennacl/linalg/kernels/compressed_matrix_kernels.h

Go to the documentation of this file.
00001 #ifndef _VIENNACL_COMPRESSED_MATRIX_KERNELS_HPP_
00002 #define _VIENNACL_COMPRESSED_MATRIX_KERNELS_HPP_
00003 #include "viennacl/tools/tools.hpp"
00004 #include "viennacl/ocl/kernel.hpp"
00005 #include "viennacl/ocl/platform.hpp"
00006 #include "viennacl/ocl/utils.hpp"
00007 #include "viennacl/linalg/kernels/compressed_matrix_source.h"
00008 
00009 //Automatically generated file from aux-directory, do not edit manually!
00010 namespace viennacl
00011 {
00012  namespace linalg
00013  {
00014   namespace kernels
00015   {
00016    template<class TYPE, unsigned int alignment>
00017    struct compressed_matrix;
00018 
00019 
00021    template <>
00022    struct compressed_matrix<float, 4>
00023    {
00024     static std::string program_name()
00025     {
00026       return "f_compressed_matrix_4";
00027     }
00028     static void init()
00029     {
00030       viennacl::ocl::DOUBLE_PRECISION_CHECKER<float>::apply();
00031       static std::map<cl_context, bool> init_done;
00032       viennacl::ocl::context & context_ = viennacl::ocl::current_context();
00033       if (!init_done[context_.handle()])
00034       {
00035         std::string source;
00036         source.append(compressed_matrix_align4_vec_mul);
00037         source.append(compressed_matrix_align1_row_scaling_2);
00038         source.append(compressed_matrix_align1_jacobi_precond);
00039         source.append(compressed_matrix_align1_row_scaling_1);
00040         source.append(compressed_matrix_align1_lu_forward);
00041         source.append(compressed_matrix_align1_bicgstab_kernel2);
00042         source.append(compressed_matrix_align1_lu_backward);
00043         source.append(compressed_matrix_align1_bicgstab_kernel1);
00044         std::string prog_name = program_name();
00045         #ifdef VIENNACL_BUILD_INFO
00046         std::cout << "Creating program " << prog_name << std::endl;
00047         #endif
00048         context_.add_program(source, prog_name);
00049         viennacl::ocl::program & prog_ = context_.get_program(prog_name);
00050         prog_.add_kernel("vec_mul");
00051         prog_.add_kernel("row_scaling_2");
00052         prog_.add_kernel("jacobi_precond");
00053         prog_.add_kernel("row_scaling_1");
00054         prog_.add_kernel("lu_forward");
00055         prog_.add_kernel("bicgstab_kernel2");
00056         prog_.add_kernel("lu_backward");
00057         prog_.add_kernel("bicgstab_kernel1");
00058         init_done[context_.handle()] = true;
00059        } //if
00060      } //init
00061     }; // struct
00062 
00063    template <>
00064    struct compressed_matrix<float, 1>
00065    {
00066     static std::string program_name()
00067     {
00068       return "f_compressed_matrix_1";
00069     }
00070     static void init()
00071     {
00072       viennacl::ocl::DOUBLE_PRECISION_CHECKER<float>::apply();
00073       static std::map<cl_context, bool> init_done;
00074       viennacl::ocl::context & context_ = viennacl::ocl::current_context();
00075       if (!init_done[context_.handle()])
00076       {
00077         std::string source;
00078         source.append(compressed_matrix_align1_vec_mul);
00079         source.append(compressed_matrix_align1_row_scaling_2);
00080         source.append(compressed_matrix_align1_jacobi_precond);
00081         source.append(compressed_matrix_align1_row_scaling_1);
00082         source.append(compressed_matrix_align1_lu_forward);
00083         source.append(compressed_matrix_align1_bicgstab_kernel2);
00084         source.append(compressed_matrix_align1_lu_backward);
00085         source.append(compressed_matrix_align1_bicgstab_kernel1);
00086         std::string prog_name = program_name();
00087         #ifdef VIENNACL_BUILD_INFO
00088         std::cout << "Creating program " << prog_name << std::endl;
00089         #endif
00090         context_.add_program(source, prog_name);
00091         viennacl::ocl::program & prog_ = context_.get_program(prog_name);
00092         prog_.add_kernel("vec_mul");
00093         prog_.add_kernel("row_scaling_2");
00094         prog_.add_kernel("jacobi_precond");
00095         prog_.add_kernel("row_scaling_1");
00096         prog_.add_kernel("lu_forward");
00097         prog_.add_kernel("bicgstab_kernel2");
00098         prog_.add_kernel("lu_backward");
00099         prog_.add_kernel("bicgstab_kernel1");
00100         init_done[context_.handle()] = true;
00101        } //if
00102      } //init
00103     }; // struct
00104 
00105    template <>
00106    struct compressed_matrix<float, 8>
00107    {
00108     static std::string program_name()
00109     {
00110       return "f_compressed_matrix_8";
00111     }
00112     static void init()
00113     {
00114       viennacl::ocl::DOUBLE_PRECISION_CHECKER<float>::apply();
00115       static std::map<cl_context, bool> init_done;
00116       viennacl::ocl::context & context_ = viennacl::ocl::current_context();
00117       if (!init_done[context_.handle()])
00118       {
00119         std::string source;
00120         source.append(compressed_matrix_align8_vec_mul);
00121         source.append(compressed_matrix_align1_row_scaling_2);
00122         source.append(compressed_matrix_align1_jacobi_precond);
00123         source.append(compressed_matrix_align1_row_scaling_1);
00124         source.append(compressed_matrix_align1_lu_forward);
00125         source.append(compressed_matrix_align1_bicgstab_kernel2);
00126         source.append(compressed_matrix_align1_lu_backward);
00127         source.append(compressed_matrix_align1_bicgstab_kernel1);
00128         std::string prog_name = program_name();
00129         #ifdef VIENNACL_BUILD_INFO
00130         std::cout << "Creating program " << prog_name << std::endl;
00131         #endif
00132         context_.add_program(source, prog_name);
00133         viennacl::ocl::program & prog_ = context_.get_program(prog_name);
00134         prog_.add_kernel("vec_mul");
00135         prog_.add_kernel("row_scaling_2");
00136         prog_.add_kernel("jacobi_precond");
00137         prog_.add_kernel("row_scaling_1");
00138         prog_.add_kernel("lu_forward");
00139         prog_.add_kernel("bicgstab_kernel2");
00140         prog_.add_kernel("lu_backward");
00141         prog_.add_kernel("bicgstab_kernel1");
00142         init_done[context_.handle()] = true;
00143        } //if
00144      } //init
00145     }; // struct
00146 
00147 
00148 
00150    template <>
00151    struct compressed_matrix<double, 4>
00152    {
00153     static std::string program_name()
00154     {
00155       return "d_compressed_matrix_4";
00156     }
00157     static void init()
00158     {
00159       viennacl::ocl::DOUBLE_PRECISION_CHECKER<double>::apply();
00160       static std::map<cl_context, bool> init_done;
00161       viennacl::ocl::context & context_ = viennacl::ocl::current_context();
00162       if (!init_done[context_.handle()])
00163       {
00164         std::string source;
00165         std::string fp64_ext = viennacl::ocl::current_device().double_support_extension();
00166         source.append(viennacl::tools::make_double_kernel(compressed_matrix_align4_vec_mul, fp64_ext));
00167         source.append(viennacl::tools::make_double_kernel(compressed_matrix_align1_row_scaling_2, fp64_ext));
00168         source.append(viennacl::tools::make_double_kernel(compressed_matrix_align1_jacobi_precond, fp64_ext));
00169         source.append(viennacl::tools::make_double_kernel(compressed_matrix_align1_row_scaling_1, fp64_ext));
00170         source.append(viennacl::tools::make_double_kernel(compressed_matrix_align1_lu_forward, fp64_ext));
00171         source.append(viennacl::tools::make_double_kernel(compressed_matrix_align1_bicgstab_kernel2, fp64_ext));
00172         source.append(viennacl::tools::make_double_kernel(compressed_matrix_align1_lu_backward, fp64_ext));
00173         source.append(viennacl::tools::make_double_kernel(compressed_matrix_align1_bicgstab_kernel1, fp64_ext));
00174         std::string prog_name = program_name();
00175         #ifdef VIENNACL_BUILD_INFO
00176         std::cout << "Creating program " << prog_name << std::endl;
00177         #endif
00178         context_.add_program(source, prog_name);
00179         viennacl::ocl::program & prog_ = context_.get_program(prog_name);
00180         prog_.add_kernel("vec_mul");
00181         prog_.add_kernel("row_scaling_2");
00182         prog_.add_kernel("jacobi_precond");
00183         prog_.add_kernel("row_scaling_1");
00184         prog_.add_kernel("lu_forward");
00185         prog_.add_kernel("bicgstab_kernel2");
00186         prog_.add_kernel("lu_backward");
00187         prog_.add_kernel("bicgstab_kernel1");
00188         init_done[context_.handle()] = true;
00189        } //if
00190      } //init
00191     }; // struct
00192 
00193    template <>
00194    struct compressed_matrix<double, 1>
00195    {
00196     static std::string program_name()
00197     {
00198       return "d_compressed_matrix_1";
00199     }
00200     static void init()
00201     {
00202       viennacl::ocl::DOUBLE_PRECISION_CHECKER<double>::apply();
00203       static std::map<cl_context, bool> init_done;
00204       viennacl::ocl::context & context_ = viennacl::ocl::current_context();
00205       if (!init_done[context_.handle()])
00206       {
00207         std::string source;
00208         std::string fp64_ext = viennacl::ocl::current_device().double_support_extension();
00209         source.append(viennacl::tools::make_double_kernel(compressed_matrix_align1_vec_mul, fp64_ext));
00210         source.append(viennacl::tools::make_double_kernel(compressed_matrix_align1_row_scaling_2, fp64_ext));
00211         source.append(viennacl::tools::make_double_kernel(compressed_matrix_align1_jacobi_precond, fp64_ext));
00212         source.append(viennacl::tools::make_double_kernel(compressed_matrix_align1_row_scaling_1, fp64_ext));
00213         source.append(viennacl::tools::make_double_kernel(compressed_matrix_align1_lu_forward, fp64_ext));
00214         source.append(viennacl::tools::make_double_kernel(compressed_matrix_align1_bicgstab_kernel2, fp64_ext));
00215         source.append(viennacl::tools::make_double_kernel(compressed_matrix_align1_lu_backward, fp64_ext));
00216         source.append(viennacl::tools::make_double_kernel(compressed_matrix_align1_bicgstab_kernel1, fp64_ext));
00217         std::string prog_name = program_name();
00218         #ifdef VIENNACL_BUILD_INFO
00219         std::cout << "Creating program " << prog_name << std::endl;
00220         #endif
00221         context_.add_program(source, prog_name);
00222         viennacl::ocl::program & prog_ = context_.get_program(prog_name);
00223         prog_.add_kernel("vec_mul");
00224         prog_.add_kernel("row_scaling_2");
00225         prog_.add_kernel("jacobi_precond");
00226         prog_.add_kernel("row_scaling_1");
00227         prog_.add_kernel("lu_forward");
00228         prog_.add_kernel("bicgstab_kernel2");
00229         prog_.add_kernel("lu_backward");
00230         prog_.add_kernel("bicgstab_kernel1");
00231         init_done[context_.handle()] = true;
00232        } //if
00233      } //init
00234     }; // struct
00235 
00236    template <>
00237    struct compressed_matrix<double, 8>
00238    {
00239     static std::string program_name()
00240     {
00241       return "d_compressed_matrix_8";
00242     }
00243     static void init()
00244     {
00245       viennacl::ocl::DOUBLE_PRECISION_CHECKER<double>::apply();
00246       static std::map<cl_context, bool> init_done;
00247       viennacl::ocl::context & context_ = viennacl::ocl::current_context();
00248       if (!init_done[context_.handle()])
00249       {
00250         std::string source;
00251         std::string fp64_ext = viennacl::ocl::current_device().double_support_extension();
00252         source.append(viennacl::tools::make_double_kernel(compressed_matrix_align8_vec_mul, fp64_ext));
00253         source.append(viennacl::tools::make_double_kernel(compressed_matrix_align1_row_scaling_2, fp64_ext));
00254         source.append(viennacl::tools::make_double_kernel(compressed_matrix_align1_jacobi_precond, fp64_ext));
00255         source.append(viennacl::tools::make_double_kernel(compressed_matrix_align1_row_scaling_1, fp64_ext));
00256         source.append(viennacl::tools::make_double_kernel(compressed_matrix_align1_lu_forward, fp64_ext));
00257         source.append(viennacl::tools::make_double_kernel(compressed_matrix_align1_bicgstab_kernel2, fp64_ext));
00258         source.append(viennacl::tools::make_double_kernel(compressed_matrix_align1_lu_backward, fp64_ext));
00259         source.append(viennacl::tools::make_double_kernel(compressed_matrix_align1_bicgstab_kernel1, fp64_ext));
00260         std::string prog_name = program_name();
00261         #ifdef VIENNACL_BUILD_INFO
00262         std::cout << "Creating program " << prog_name << std::endl;
00263         #endif
00264         context_.add_program(source, prog_name);
00265         viennacl::ocl::program & prog_ = context_.get_program(prog_name);
00266         prog_.add_kernel("vec_mul");
00267         prog_.add_kernel("row_scaling_2");
00268         prog_.add_kernel("jacobi_precond");
00269         prog_.add_kernel("row_scaling_1");
00270         prog_.add_kernel("lu_forward");
00271         prog_.add_kernel("bicgstab_kernel2");
00272         prog_.add_kernel("lu_backward");
00273         prog_.add_kernel("bicgstab_kernel1");
00274         init_done[context_.handle()] = true;
00275        } //if
00276      } //init
00277     }; // struct
00278 
00279 
00280   }  //namespace kernels
00281  }  //namespace linalg
00282 }  //namespace viennacl
00283 #endif

Generated on Sat May 21 2011 20:36:50 for ViennaCL - The Vienna Computing Library by  doxygen 1.7.1