Deriving cuda-class from c++ class, in large framework - c++

Question

I have a quite large c++/mpi project in which I want to integrate some cuda-functionality.
I created a sample project (not runnable yet) to illustrate the problem. The comments in between the sources describe the problem.
I have a main.cc:
/*main.cc*/
#include <iostream>
#include "derivedclass.h"
#include "someotherclass.h"
using namespace std;
int main(){
int intstate = 4;
DerivedClass<int> myDerivedClass;
myDerivedClass.setState(intstate);
myDerivedClass.compute();
int result = myDerived.getResult();
SomeOtherClass mySomeOtherClass(result);
mySomeOtherClass.print();
}
which includes some c++ class(es):
/*someotherclass.h*/
#ifndef INTEGRATOR_H_GUARD
#define INTEGRATOR_H_GUARD
class SomeOtherClass{
private:
int someVariable;
public:
SomeotherClass(int someVariable);
void print();
};
#endif
/*someotherclass.cc*/
#include "someotherclass.h"
SomeOtherClass::SomeOtherClass(int someVariable){
this->someVariable = someVariable;
}
SomeOtherClass::print(){
cout << this->someVariable << endl;
}
These c++ parts a quite large and I don't won't to change them.
There is some baseclass:
/*baseclass.h*/
#ifndef BASECLASS_H_GUARD
#define BASECLASS_H_GUARD
class BaseClass{
protected:
int someVariable;
public:
BaseClass(int someVariable);
void compute();
int getResult();
};
#endif
/*baseclass.cc*/
BaseClass::BaseClass(int someVariable){
this->someVariable = someVariable;
}
void BaseClass::compute(){
/* do something*/
}
int BaseClass::getResult(){
return this->someVariable;
}
This base class provides a lot of functionality (too much but not my project so I can't change that).
Some methods are to be parallelized by me. So for me it seems to be the cleanest way to derive the BaseClass with a Class using Cuda:
/*derivedclass.h*/
#ifndef DERIVEDCLASS_H_GUARD
#define DERIVEDCLASS_H_GUARD
#include "baseclass.h"
class DerivedClass: public BaseClass{
public:
DerivedClass(int someVariable);
void compute();
};
#endif
/*derivedclass.cu*/
#include "derivedclass.h"
DerivedClass::DerivedClass(int someVariable):
BaseClass(someVariable);
{
}
void DerivedClass::compute(){
/* do some cuda stuff*/
}
So I have the following questions:
Is it possible to derive a cuda-class from a c++-class
When I try to compile the main.cc class with g++ and the .cu classes with nvcc I get an error when using cuda stuff in the .cu class for example cudamalloc:
./Folder/class.cu:line: Fehler: expected initializer before »cudaMalloc«
When I try to compile the main class with nvcc I get problems with MPI-functionality.
So is it possible to use a cuda-class from a main.cc compiled with g++/mpicc (which seems to be the right way round for me)?
I hope I described my problem understandable and appreciate any help.

Answer 1

From what I can tell from your code, your derived class is just a C++ class that launches CUDA kernels. So it's not really a "CUDA class". So the answer to your question 1. is "yes", you can do that. You just have to put any member functions that launch kernels in .cu files with the kernels they launch.
The error "expected initializer before 'cudaMalloc'" is a weird syntax error. It doesn't really seem to have anything to do with your derived class stuff. I suspect you just have a C++ syntax error.