fix:hip code could not run in DCU

Author: kunkunblueberry

source/module_hsolver/kernels/rocm/dngvd_op.hip.cu

@@ -57,7 +57,25 @@ namespace hsolver {
         hipErrcheck(hipMemcpy(_vcc, vcc.data(), sizeof(double) * vcc.size(), hipMemcpyHostToDevice));
 
         // Copy eigenvalues back to device
+<<<<<<< HEAD
         hipErrcheck(hipMemcpy(_eigenvalue, eigenvalue.data(), sizeof(doubl int* fail_info)
+=======
+        hipErrcheck(hipMemcpy(_eigenvalue, eigenvalue.data(), sizeof(double) * eigenvalue.size(), hipMemcpyHostToDevice));
+    }
+#endif // __LCAO
+
+    // GPU implementation of generalized eigenvalue solver for single precision complex
+    template <>
+    void dngvd_op<std::complex<float>, base_device::DEVICE_GPU>::operator()(
+        const base_device::DEVICE_GPU* ctx,
+        const int nstart,
+        const int ldh,
+        const std::complex<float>* _hcc,
+        const std::complex<float>* _scc,
+        float* _eigenvalue,
+        std::complex<float>* _vcc,
+        int* fail_info)
+>>>>>>> 8c430373269e0a744ed2fda32b97d3b3df6a0188
     {
         // Allocate host memory for complex matrices
         std::vector<std::complex<float>> hcc(ldh * nstart, {0, 0});
@@ -66,7 +84,25 @@ namespace hsolver {
         std::vector<float> eigenvalue(nstart, 0);
 
         // Copy complex Hamiltonian matrix from device to host
+<<<<<<< HEAD
         hipErrcheck(hipMemcpy(hcc.data(), _hcc, sizeof(std::complex<float>) * hcc.size(), hipMemcpyDevice     eigenvalue.data(),
+=======
+        hipErrcheck(hipMemcpy(hcc.data(), _hcc, sizeof(std::complex<float>) * hcc.size(), hipMemcpyDeviceToHost));
+        
+        // Copy complex overlap matrix from device to host
+        hipErrcheck(hipMemcpy(scc.data(), _scc, sizeof(std::complex<float>) * scc.size(), hipMemcpyDeviceToHost));
+        
+        base_device::DEVICE_CPU* cpu_ctx = {};
+        
+        // Call CPU solver for complex single precision
+        dngvd_op<std::complex<float>, base_device::DEVICE_CPU>()(
+            cpu_ctx,
+            nstart,
+            ldh,
+            hcc.data(),
+            scc.data(),
+            eigenvalue.data(),
+>>>>>>> 8c430373269e0a744ed2fda32b97d3b3df6a0188
             vcc.data(),
             fail_info);
 
@@ -77,7 +113,24 @@ namespace hsolver {
         hipErrcheck(hipMemcpy(_eigenvalue, eigenvalue.data(), sizeof(float) * eigenvalue.size(), hipMemcpyHostToDevice));
     }
 
+<<<<<<< HEAD
     // GPU implementation of generalized eigenvalue solver for double precision compt, {0, 0});
+=======
+    // GPU implementation of generalized eigenvalue solver for double precision complex
+    template <>
+    void dngvd_op<std::complex<double>, base_device::DEVICE_GPU>::operator()(
+        const base_device::DEVICE_GPU* ctx,
+        const int nstart,
+        const int ldh,
+        const std::complex<double>* _hcc,
+        const std::complex<double>* _scc,
+        double* _eigenvalue,
+        std::complex<double>* _vcc,
+        int* fail_info)
+    {
+        // Allocate host memory for double complex matrices
+        std::vector<std::complex<double>> hcc(ldh * nstart, {0, 0});
+>>>>>>> 8c430373269e0a744ed2fda32b97d3b3df6a0188
         std::vector<std::complex<double>> scc(ldh * nstart, {0, 0});
         std::vector<std::complex<double>> vcc(ldh * nstart, {0, 0});
         std::vector<double> eigenvalue(nstart, 0);
@@ -86,7 +139,11 @@ namespace hsolver {
         hipErrcheck(hipMemcpy(hcc.data(), _hcc, sizeof(std::complex<double>) * hcc.size(), hipMemcpyDeviceToHost));
         
         // Copy double complex overlap matrix from device to host
+<<<<<<< HEAD
         hipErrcheck(hipMemcpy(scc.data(), _scc,  eigenvectors back to device
+=======
+        hipErrcheck(hipMemcpy( eigenvectors back to device
+>>>>>>> 8c430373269e0a744ed2fda32b97d3b3df6a0188
         hipErrcheck(hipMemcpy(_vcc, vcc.data(), sizeof(std::complex<double>) * vcc.size(), hipMemcpyHostToDevice));
         
         // Copy eigenvalues back to device
@@ -97,7 +154,11 @@ namespace hsolver {
     // GPU implementation of standard eigenvalue solver for double precision
     template <>
     void dnevx_op<double, base_device::DEVICE_GPU>::operator()(
+<<<<<<< HEAD
         const base_device:: _hcc, sizeof(double) * hcc.size(), hipMemcpyDeviceToHost));
+=======
+        c _hcc, sizeof(double) * hcc.size(), hipMemcpyDeviceToHost));
+>>>>>>> 8c430373269e0a744ed2fda32b97d3b3df6a0188
         
         base_device::DEVICE_CPU* cpu_ctx = {};
         
@@ -108,7 +169,11 @@ namespace hsolver {
         hipErrcheck(hipMemcpy(_vcc, vcc.data(), sizeof(double) * vcc.size(), hipMemcpyHostToDevice));
         
         // Copy eigenvalues back to device
+<<<<<<< HEAD
         hipErrcheck(hipMemcpy(envalue,
+=======
+        hipEenvalue,
+>>>>>>> 8c430373269e0a744ed2fda32b97d3b3df6a0188
         std::complex<float>* _vcc)
     {
         // Allocate host memory for complex matrices
@@ -119,9 +184,13 @@ namespace hsolver {
         // Copy complex Hamiltonian matrix from device to host
         hipErrcheck(hipMemcpy(hcc.data(), _hcc, sizeof(std::complex<float>) * hcc.size(), hipMemcpyDeviceToHost));
         
+<<<<<<< HEAD
         base_device::DEVICE_CPU* cpu_ctx = {};
         
      // Copy eigenvalues back to device
+=======
+        base_device::DEVICE_CPU* cpu_ctx = // Copy eigenvalues back to device
+>>>>>>> 8c430373269e0a744ed2fda32b97d3b3df6a0188
         hipErrcheck(hipMemcpy(_eigenvalue, eigenvalue.data(), sizeof(float) * eigenvalue.size(), hipMemcpyHostToDevice));
     }
 
@@ -133,8 +202,12 @@ namespace hsolver {
         const int ldh,
         const std::complex<double>* _hcc,
         const int m,
+<<<<<<< HEAD
         double* _eigenvalue,
         std::cot));
+=======
+        double* _eigenvalut));
+>>>>>>> 8c430373269e0a744ed2fda32b97d3b3df6a0188
         
         base_device::DEVICE_CPU* cpu_ctx = {};
         
@@ -150,8 +223,12 @@ namespace hsolver {
         
         // Copy double complex eigenvectors back to device
         hipErrcheck(hipMemcpy(_vcc, vcc.data(), sizeof(std::complex<double>) * vcc.size(), hipMemcpyHostToDevice));
+<<<<<<< HEAD
         
         //lex<float>* hcc,
+=======
+ lex<float>* hcc,
+>>>>>>> 8c430373269e0a744ed2fda32b97d3b3df6a0188
         std::complex<float>* scc,
         const int m,
         float* eigenvalue,
@@ -169,7 +246,11 @@ namespace hsolver {
         std::complex<double>* hcc,
         std::complex<double>* scc,
         const int m,
+<<<<<<< HEAD
         double* eigenvle* vcc,
+=======
+    le* vcc,
+>>>>>>> 8c430373269e0a744ed2fda32b97d3b3df6a0188
         int* fail_info)
     {
     }