IAlephCuda.h

// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
//-----------------------------------------------------------------------------
// Copyright 2000-2026 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
// See the top-level COPYRIGHT file for details.
// SPDX-License-Identifier: Apache-2.0
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* IAlephCnc.h                                                 (C) 2000-2012 */
/*                                                                           */
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
#ifndef _ALEPH_INTERFACE_CNC_H_
#define _ALEPH_INTERFACE_CNC_H_
 
#include "arcane/aleph/cuda/AlephCuda.h"
 
#include <cuda.h>
#include <cublas.h>
#include <cuda_runtime.h>
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane
{
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
/******************************************************************************
 * AlephVectorCnc
 *****************************************************************************/
class AlephVectorCnc : public IAlephVector
{
 public:
 
  AlephVectorCnc(ITraceMng* tm,
                 AlephKernel* kernel,
                 Integer index)
  : IAlephVector(tm, kernel, index)
  , m_cnc_vector(0)
  {
    debug() << "\t\t[AlephVectorCnc::AlephVectorCnc] new AlephVectorCnc";
  }
 
  /******************************************************************************
   *****************************************************************************/
  void AlephVectorCreate(void)
  {
    debug() << "\t\t[AlephVectorCnc::AlephVectorCreate] CNC VectorCreate 0-" << m_kernel->topology()->nb_row_size() - 1;
    m_cnc_vector.allocate(m_kernel->topology()->nb_row_size());
    debug() << "\t\t[AlephVectorCnc::AlephVectorCreate] done";
  }
 
  /******************************************************************************
   *****************************************************************************/
  void AlephVectorSet(const double* bfr_val, const int* bfr_idx, Integer size)
  {
    debug() << "\t\t[AlephVectorCnc::AlephVectorSet]";
    for (Integer i = 0; i < size; ++i) {
      m_cnc_vector[bfr_idx[i]] = bfr_val[i];
    }
  }
 
  /******************************************************************************
   *****************************************************************************/
  int AlephVectorAssemble(void)
  {
    return 0;
  }
 
  /******************************************************************************
   *****************************************************************************/
  void AlephVectorGet(double* bfr_val, const int* bfr_idx, Integer size)
  {
    debug() << "\t\t[AlephVectorCnc::AlephVectorGet]";
    for (Integer i = 0; i < size; ++i) {
      bfr_val[i] = m_cnc_vector[bfr_idx[i]];
    }
  }
 
  /******************************************************************************
   *****************************************************************************/
  void writeToFile(const String filename)
  {
    debug() << "\t\t[AlephVectorCnc::writeToFile]";
    m_cnc_vector.print();
  }
 
 public:
 
  CNC_Vector<double> m_cnc_vector;
};
 
/******************************************************************************
 AlephMatrixCnc
 *****************************************************************************/
class AlephMatrixCnc : public IAlephMatrix
{
 public:
 
  /******************************************************************************
   AlephMatrixCnc
  *****************************************************************************/
  AlephMatrixCnc(ITraceMng* tm,
                 AlephKernel* kernel,
                 Integer index)
  : IAlephMatrix(tm, kernel, index)
  , m_cnc_matrix(0)
  , m_cuda()
  , m_smcrs()
  , has_been_allocated_on_gpu(false)
  {
    debug() << "\t\t[AlephMatrixCnc::AlephMatrixCnc] new SolverMatrixCnc";
  }
 
  /******************************************************************************
   * ~AlephMatrixCnc
   *****************************************************************************/
  ~AlephMatrixCnc()
  {
    debug() << "\t\t[AlephMatrixCnc::~AlephMatrixCnc] DELETE SolverMatrixCnc";
    m_smcrs.gpu_deallocate();
  }
 
  /******************************************************************************
   *****************************************************************************/
  void AlephMatrixCreate(void)
  {
    debug() << "\t\t[AlephMatrixCnc::AlephMatrixCreate] CNC MatrixCreate";
    m_cnc_matrix.allocate(m_kernel->topology()->nb_row_size(),
                          m_kernel->topology()->nb_row_size(),
                          CNC_Matrix::ROWS,
                          false); // symmetric ?
    m_cuda.cnc_cuda_set_dim_vec_from_n(m_kernel->topology()->nb_row_size());
  }
 
  /******************************************************************************
   *****************************************************************************/
  void AlephMatrixSetFilled(bool) {}
 
  /******************************************************************************
   *****************************************************************************/
  int AlephMatrixAssemble(void)
  {
    debug() << "\t\t[AlephMatrixCnc::AlephMatrixConfigure] AlephMatrixConfigure";
    m_cuda.convert_matrix(m_cnc_matrix, m_smcrs, false);
    if (has_been_allocated_on_gpu == false) {
      m_smcrs.gpu_allocate();
      has_been_allocated_on_gpu = true;
    }
    return 0;
  }
 
  /******************************************************************************
   *****************************************************************************/
  void AlephMatrixFill(int nrows, int* rows, int* cols, double* values)
  {
    debug() << "\t\t[AlephMatrixCnc::AlephMatrixFill]";
    for (int i = 0, iMax = m_kernel->topology()->gathered_nb_setValued(m_kernel->rank()); i < iMax; ++i) {
      m_cnc_matrix.add(rows[i],
                       cols[i],
                       values[i]);
    }
    debug() << "\t\t[AlephMatrixCnc::AlephMatrixFill] done";
  }
 
  /******************************************************************************
   * LinftyNormVectorProductAndSub
   *****************************************************************************/
  Real LinftyNormVectorProductAndSub(AlephVector* x,
                                     AlephVector* b)
  {
    throw FatalErrorException("LinftyNormVectorProductAndSub", "error");
  }
 
  /******************************************************************************
   *****************************************************************************/
  int AlephMatrixSolve(AlephVector* x,
                       AlephVector* b,
                       AlephVector* t,
                       Integer& nb_iteration,
                       Real* residual_norm,
                       AlephParams* solver_param)
  {
    const String func_name("SolverMatrixCnc::solve");
 
    debug() << "\t\t[AlephMatrixCnc::AlephMatrixSolve] Getting X & B";
    CNC_Vector<double>* X = &(dynamic_cast<AlephVectorCnc*>(x->implementation()))->m_cnc_vector;
    CNC_Vector<double>* B = &(dynamic_cast<AlephVectorCnc*>(b->implementation()))->m_cnc_vector;
 
    debug() << "\t\t[AlephMatrixCnc::AlephMatrixSolve] Flushing X";
    X->set_all(0.0f);
 
    // solving the algebraic system
    unsigned int cnc_nb_iter_max = solver_param->maxIter();
    double cnc_epsilon = solver_param->epsilon();
 
    debug() << "\t\t[AlephMatrixCnc::AlephMatrixSolve] Launching CNC_Solver";
    m_cuda.solve(m_smcrs, *B, *X, cnc_nb_iter_max, cnc_epsilon, nb_iteration, residual_norm);
 
    /*  debug()<<"\t\t[AlephMatrixCnc::AlephMatrixSolve] HARD-CODING arguments";
      nb_iteration  = cnc_nb_iter_max-1;
      residual_norm[0] = cnc_epsilon;
    */
 
    if (nb_iteration == solver_param->maxIter() && solver_param->stopErrorStrategy()) {
      info() << "\n============================================================";
      info() << "\nThis error is returned after " << nb_iteration << "\n";
      info() << "\nThe maximum number of solver iterations has been reached.";
      info() << "\nIt is possible to ask the code not to consider this error.";
      info() << "\nSee the dataset documentation regarding the solver service.";
      info() << "\n======================================================";
      throw Exception("AlephMatrixCnc::Solve", "The maximum number of solver iterations has been reached");
    }
    return 0;
  }
 
  /******************************************************************************
   *****************************************************************************/
  void writeToFile(const String filename)
  {
    //CNC_MatrixPrint(m_cnc_matrix, filename.localstr());
  }
 
 public:
 
  CNC_Matrix m_cnc_matrix;
  Cuda m_cuda;
  CNC_MatrixCRS<double> m_smcrs;
  bool has_been_allocated_on_gpu;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // namespace Arcane
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#endif