Implementation of parallel class using CUDA C++? - parallel-processing

Question

I've been trying to parallelize my class and class constructor by using CUDA.
You can find the both serial version and parallelized version of my class. It compiles correctly and I wonder if there are any improvements in my parallelized code.
Serial Code Ray.h:
#pragma once
#include <iostream>
#include <fstream>
#include <string>
#include <sstream>
#include <math.h>
#include <vector>
#include <algorithm>
#include <complex>
#include "arithmatic_operations.h"
#include <cuda_runtime.h>
#include <device_launch_parameters.h>
class Ray
{
public:
std::vector<std::vector<double>>Point = { { 0,0,0 } ,{ 0,0,0 } ,{ 0,0,0 } };
std::vector<std::vector<double>>Direction = { { 0,0,0 } ,{ 0,0,0 } ,{ 0,0,0 } };
double no_bounces = -1;
double length = -1;
std::vector<double>E_thei = { 0,0,0 };
std::vector<double>E_phii = { 0,0,0 };
std::complex<double> Er_the_the = 0;
std::complex<double> Er_phi_the = 0;
std::complex<double> Er_the_phi = 0;
std::complex<double> Er_phi_phi = 0;
double Ai = 0;
Ray(std::vector<double>OO, std::vector<std::vector<double>>DD, double delta)
{
//Point.push_back({ 0,0,0 });
this->Point[no_bounces + 1][0] = OO[0];
this->Point[no_bounces + 1][1] = OO[1];
this->Point[no_bounces + 1][2] = OO[2];
std::vector<double>first_row_DD = { 0,0,0 };
first_row_DD[0] = DD[0][0];
first_row_DD[1] = DD[0][1];
first_row_DD[2] = DD[0][2];
//Direction.push_back({ 0,0,0 });
this->Direction[no_bounces + 1][0] = DD[0][0] / norm(first_row_DD);
this->Direction[no_bounces + 1][1] = DD[0][1] / norm(first_row_DD);
this->Direction[no_bounces + 1][2] = DD[0][2] / norm(first_row_DD);
this->E_thei[0] = DD[1][0];
this->E_thei[1] = DD[1][1];
this->E_thei[2] = DD[1][2];
this->E_phii[0] = DD[2][0];
this->E_phii[1] = DD[2][1];
this->E_phii[2] = DD[2][2];
this->Ai = pow(delta, 2);
}
};
and below there is the code I parallelized:
Ray.cuh:
#include <iostream>
#include <array>
#include <fstream>
#include <string>
#include <sstream>
#include <cstddef>
#include <utility>
#include <cuda.h>
#include <cuda_runtime.h>
#include <device_launch_parameters.h>
#include <thrust/device_vector.h>
#include <thrust/host_vector.h>
#include <thrust/transform.h>
#include <thrust/functional.h>
#include <thrust/fill.h>
#include <thrust/copy.h>
#include <thrust/iterator/transform_iterator.h>
#include <thrust/iterator/zip_iterator.h>
#include <thrust/zip_function.h>
#include <thrust/execution_policy.h>
__device__ double square(double& x) { return x * x; }
struct myPow
{
__device__
double operator()(double& x) const { return square(x); }
};
struct CalculateNormValues
{
__device__
double operator()(const thrust::tuple<double, double, double>& t) const
{
double x = thrust::get<0>(t);
double y = thrust::get<1>(t);
double z = thrust::get<2>(t);
return (double)sqrt(x * x + y * y + z * z);
}
};
struct Normalize
{
__device__
thrust::tuple<double, double, double> operator()(const thrust::tuple<double, double, double, double>& t) const
{
double x = thrust::get<0>(t);
double y = thrust::get<1>(t);
double z = thrust::get<2>(t);
double norm = thrust::get<3>(t);
return thrust::make_tuple(x / norm, y / norm, z / norm);
}
};
class Ray {
static constexpr int n_dims = 3;
static constexpr int cn_dims = 2;
using Container = thrust::device_vector<double>;
using Vectors = std::array<Container, n_dims>;
using Matrices = std::array<Container, n_dims* n_dims>;
using Complexes = std::array<Container, cn_dims>;
public:
std::ptrdiff_t n_rays{};
Vectors E_thei;
Vectors E_phii;
Matrices Point;
Matrices Direction;
Complexes Er_the_the;
Complexes Er_phi_the;
Complexes Er_the_phi;
Complexes Er_phi_phi;
Container Ai;
Container no_bounces;
Container length;
Container normValues;
Ray(thrust::device_vector<double>& OO_0,
thrust::device_vector<double>& OO_1,
thrust::device_vector<double>& OO_2,
thrust::device_vector<double>& DD_00,
thrust::device_vector<double>& DD_01,
thrust::device_vector<double>& DD_02,
thrust::device_vector<double>& DD_10,
thrust::device_vector<double>& DD_11,
thrust::device_vector<double>& DD_12,
thrust::device_vector<double>& DD_20,
thrust::device_vector<double>& DD_21,
thrust::device_vector<double>& DD_22,
thrust::device_vector<double>& delta) :
n_rays{ static_cast<std::ptrdiff_t>(OO_0.size()) },
Direction{ std::move(DD_00), //Normalize direction components later
std::move(DD_01),
std::move(DD_02) },
Point{ std::move(OO_0),
std::move(OO_1),
std::move(OO_2) },
E_thei{ std::move(DD_10),
std::move(DD_11),
std::move(DD_12) },
E_phii{ std::move(DD_20),
std::move(DD_21),
std::move(DD_22) },
Ai{ std::move(delta) } //Multiply Ai values later
{
thrust::transform(Ai.begin(), Ai.end(), Ai.begin(), myPow()); //Multiplies Ai values
//Calculate normalized values
normValues.resize(3);
thrust::transform(
thrust::make_zip_iterator(thrust::make_tuple(Direction[0].begin(), Direction[1].begin(), Direction[2].begin())),
thrust::make_zip_iterator(thrust::make_tuple(Direction[0].end(), Direction[1].end(), Direction[2].end())),
normValues.begin(),
CalculateNormValues{});
//Normalize Direction
thrust::transform(
thrust::make_zip_iterator(
thrust::make_tuple(Direction[0].begin(), Direction[1].begin(), Direction[2].begin(), normValues.begin())),
thrust::make_zip_iterator(
thrust::make_tuple(Direction[0].end(), Direction[1].end(), Direction[2].end(), normValues.end())),
thrust::make_zip_iterator(
thrust::make_tuple(Direction[0].begin(), Direction[1].begin(), Direction[2].begin())),
Normalize{});
}
};
The program compiles but I'd like to ask some questions.
When I use thrust::transform I know that the thrust library does the memory allocation and copying on the device for me. I wonder after the operation is done, does it copy back to the host? After
thrust::transform(Ai.begin(), Ai.end(), Ai.begin(), myPow());
if I write a line like this Ai[0]=5. Is this line executed on CPU or GPU?
My second question is I wonder if I can write a device function in my parallelized class by using __global__ and cuda threads. If the answer is yes, for example after moving device_vectors OO_1 and OO_2 to the member Point, If I want to do math on these device vectors in __global__ function since device_vectors are host only I need to copy them to C arrays and allocate memory on device and do the math right?