Forum |  HardWare.fr | News | Articles | PC | S'identifier | S'inscrire | Shop Recherche
1015 connectés 

  FORUM HardWare.fr
  Programmation
  C++

  [Résolu] OpenCL, gcc et g++

 


 Mot :   Pseudo :  
 
Bas de page
Auteur Sujet :

[Résolu] OpenCL, gcc et g++

n°2225338
vckbm
tu destroye tout le monde
Posté le 17-04-2014 à 08:34:59  profilanswer
 

Salut,  
 
je suis sous ubuntu 12.04, gcc 4.6.3 et g++ 4.6.3
j'ai téléchargé la SDK d'AMD: AMD-APP-SDK-v2.9-lnx64
 
lorsque je compile un example simple (en bas) avec gcc j'ai les erreurs suivantes:
 

Code :
  1. >gcc -std=c++0x -o truc truc.cpp -lOpenCL


Code :
  1. truc.cpp:(.text+0x5b): undefined reference to `std::cout'
  2. truc.cpp:(.text+0x60): undefined reference to `std::basic_ostream<char, std::char_traits<char> >& std::operator<< <std::char_traits<char> >(std::basic_ostream<char, std::char_traits<char> >&, char const*)'
  3. truc.cpp:(.text+0xbb): undefined reference to `std::cout'
  4. truc.cpp:(.text+0xc0): undefined reference to `std::basic_ostream<char, std::char_traits<char> >& std::operator<< <std::char_traits<char> >(std::basic_ostream<char, std::char_traits<char> >&, char const*)'
  5. truc.cpp:(.text+0xd2): undefined reference to `std::basic_ostream<char, std::char_traits<char> >& std::operator<< <char, std::char_traits<char>, std::allocator<char> >(std::basic_ostream<char, std::char_traits<char> >&, std::basic_string<char, std::char_traits<char>, std::allocator<char> > const& )'
  6. truc.cpp:(.text+0xdf): undefined reference to `std::basic_ostream<char, std::char_traits<char> >& std::operator<< <std::char_traits<char> >(std::basic_ostream<char, std::char_traits<char> >&, char const*)'
  7. truc.cpp:(.text+0xee): undefined reference to `std::basic_string<char, std::char_traits<char>, std::allocator<char> >::~basic_string()'
  8. truc.cpp:(.text+0x13b): undefined reference to `std::cout'
  9. truc.cpp:(.text+0x140): undefined reference to `std::basic_ostream<char, std::char_traits<char> >& std::operator<< <std::char_traits<char> >(std::basic_ostream<char, std::char_traits<char> >&, char const*)'
  10. truc.cpp:(.text+0x19b): undefined reference to `std::cout'
  11. truc.cpp:(.text+0x1a0): undefined reference to `std::basic_ostream<char, std::char_traits<char> >& std::operator<< <std::char_traits<char> >(std::basic_ostream<char, std::char_traits<char> >&, char const*)'
  12. truc.cpp:(.text+0x1b2): undefined reference to `std::basic_ostream<char, std::char_traits<char> >& std::operator<< <char, std::char_traits<char>, std::allocator<char> >(std::basic_ostream<char, std::char_traits<char> >&, std::basic_string<char, std::char_traits<char>, std::allocator<char> > const& )'
  13. truc.cpp:(.text+0x1bf): undefined reference to `std::basic_ostream<char, std::char_traits<char> >& std::operator<< <std::char_traits<char> >(std::basic_ostream<char, std::char_traits<char> >&, char const*)'
  14. truc.cpp:(.text+0x1ce): undefined reference to `std::basic_string<char, std::char_traits<char>, std::allocator<char> >::~basic_string()'
  15. truc.cpp:(.text+0x2b9): undefined reference to `std::allocator<char>::allocator()'
  16. truc.cpp:(.text+0x2d1): undefined reference to `std::basic_string<char, std::char_traits<char>, std::allocator<char> >::basic_string(char const*, std::allocator<char> const& )'


visiblement il ne prends pas en compte les bibliotheques standards du C++
 
par contre si je compile avec g++ ça marche:
 

Code :
  1. >g++ -std=c++0x -o truc truc.cpp -lOpenCL


pourquoi ne reconnait il pas le C++ avec gcc???

EDIT:
il suffit d'ajouter -lstdc++ avec gcc

 

Code :
  1. gcc -std=c++0x -o truc truc.cpp -lOpenCL -lstdc++


et la ca marche
 
merci
 
PS: l'exemple
 

Code :
  1. #include <iostream>
  2. #include <CL/cl.hpp>
  3. using namespace std;
  4. int main(){
  5.   //get all platforms (drivers)                                                                                                                                                                                                                                                                                                                                                   
  6.   std::vector<cl::Platform> all_platforms;
  7.   cl::Platform::get(&all_platforms);
  8.   if(all_platforms.size()==0){
  9.     std::cout<<" No platforms found. Check OpenCL installation!n";
  10.     exit(1);
  11.   }
  12.   cl::Platform default_platform=all_platforms[0];
  13.   std::cout << "Using platform: "<<default_platform.getInfo<CL_PLATFORM_NAME>()<<"n";
  14.   //get default device of the default platform                                                                                                                                                                                                                                                                                                                                     
  15.   std::vector<cl::Device> all_devices;
  16.   default_platform.getDevices(CL_DEVICE_TYPE_ALL, &all_devices);
  17.   if(all_devices.size()==0){
  18.     std::cout<<" No devices found. Check OpenCL installation!n";
  19.     exit(1);
  20.   }
  21.   cl::Device default_device=all_devices[0];
  22.   std::cout<< "Using device: "<<default_device.getInfo<CL_DEVICE_NAME>()<<"n";
  23.   cl::Context context({default_device});
  24.   cl::Program::Sources sources;
  25.   // kernel calculates for each element C=A+B                                                                                                                                                                                                                                                                                                                                     
  26.   std::string kernel_code=
  27.     " void kernel simple_add(global const int* A, global const int* B, global int* C){ "
  28.     " C[get_global_id(0)]=A[get_global_id(0)]+B[get_global_id(0)]; "
  29.     " } ";
  30.   sources.push_back({kernel_code.c_str(),kernel_code.length()});
  31.   cl::Program program(context,sources);
  32.   if(program.build({default_device})!=CL_SUCCESS){
  33.     std::cout<<" Error building: "<<program.getBuildInfo<CL_PROGRAM_BUILD_LOG>(default_device)<<"n";
  34.     exit(1);
  35.   }
  36.   // create buffers on the device                                                                                                                                                                                                                                                                                                                                                 
  37.   cl::Buffer buffer_A(context,CL_MEM_READ_WRITE,sizeof(int)*10);
  38.   cl::Buffer buffer_B(context,CL_MEM_READ_WRITE,sizeof(int)*10);
  39.   cl::Buffer buffer_C(context,CL_MEM_READ_WRITE,sizeof(int)*10);
  40.   int A[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
  41.   int B[] = {0, 1, 2, 0, 1, 2, 0, 1, 2, 0};
  42.   //create queue to which we will push commands for the device.                                                                                                                                                                                                                                                                                                                   
  43.   cl::CommandQueue queue(context,default_device);
  44.   //write arrays A and B to the device                                                                                                                                                                                                                                                                                                                                             
  45.   queue.enqueueWriteBuffer(buffer_A,CL_TRUE,0,sizeof(int)*10,A);
  46.   queue.enqueueWriteBuffer(buffer_B,CL_TRUE,0,sizeof(int)*10,B);
  47.   //run the kernel                                                                                                                                                                                                                                                                                                                                                                 
  48.   cl::KernelFunctor simple_add(cl::Kernel(program,"simple_add";),queue,cl::NullRange,cl::NDRange(10),cl::NullRange);
  49.   simple_add(buffer_A,buffer_B,buffer_C);
  50.   //alternative way to run the kernel                                                                                                                                                                                                                                                                                                                                             
  51.   /*cl::Kernel kernel_add=cl::Kernel(program,"simple_add";);                                                                                                                                                                                                                                                                                                                       
  52.     kernel_add.setArg(0,buffer_A);                                                                                                                                                                                                                                                                                                                                                 
  53.     kernel_add.setArg(1,buffer_B);                                                                                                                                                                                                                                                                                                                                                 
  54.     kernel_add.setArg(2,buffer_C);                                                                                                                                                                                                                                                                                                                                                 
  55.     queue.enqueueNDRangeKernel(kernel_add,cl::NullRange,cl::NDRange(10),cl::NullRange);                                                                                                                                                                                                                                                                                           
  56.     queue.finish();*/
  57.   int C[10];
  58.   //read result C from the device to array C                                                                                                                                                                                                                                                                                                                                       
  59.   queue.enqueueReadBuffer(buffer_C,CL_TRUE,0,sizeof(int)*10,C);
  60.   std::cout<<" result: n";
  61.   for(int i=0;i<10;i++){
  62.     std::cout<<C[i]<<" ";
  63.   }
  64.   return 0;
  65. }


Message édité par vckbm le 17-04-2014 à 08:47:02

---------------
A Vendre
mood
Publicité
Posté le 17-04-2014 à 08:34:59  profilanswer
 


Aller à :
Ajouter une réponse
  FORUM HardWare.fr
  Programmation
  C++

  [Résolu] OpenCL, gcc et g++

 

Sujets relatifs
Optimiser une boucle en OpenCLOpenCL et C++ (héritage)
[C\C++] Développement sur GPU : NVIDIA Cuda 
Plus de sujets relatifs à : [Résolu] OpenCL, gcc et g++


Copyright © 1997-2022 Hardware.fr SARL (Signaler un contenu illicite / Données personnelles) / Groupe LDLC / Shop HFR