[Issue]I think I might have encountered a bug. When I use the following configuration, the AMGX solver freezes. I'm not even sure if it has entered the solving state—it just stalls.

[Haiqing-Fang]

Describe the issue
When I run the following code with the given AMGX solver configuration, I notice that AMGX properly sets up matrix A and vector b, and correctly uploads the initial x vector; however, it stalls at the solve stage. Is it unable to proceed with the solution?
Code:
#include
#include
#include
#include
#include
#include
#include
#include
#include

#include <amgx_c.h>

#define CHECK_AMGX(call)
do {
AMGX_RC rc = (call);
if (rc != AMGX_RC_OK) {
std::cerr << "AMGX error at " << FILE
<< ":" << LINE
<< " - error code: " << rc
<< std::endl;
std::exit(1);
}
} while (0)

inline int idx(int i, int j, int nx) { return i + j * nx; }

void coo_to_csr(int n, int nnz,
const std::vector &coo_row,
const std::vector &coo_col,
const std::vector &coo_val,
std::vector &row_ptr,
std::vector &col_ind,
std::vector &values)
{
row_ptr.assign(n + 1, 0);
col_ind.resize(nnz);
values.resize(nnz);

for (int k = 0; k < nnz; ++k) {
    int r = coo_row[k];
    if (r < 0 || r >= n) {
        std::cerr << "coo_to_csr: row index out of range: " << r << std::endl;
        std::exit(1);
    }
    row_ptr[r + 1]++;
}

for (int i = 0; i < n; ++i) {
    row_ptr[i + 1] += row_ptr[i];
}


std::vector<int> offset = row_ptr;
for (int k = 0; k < nnz; ++k) {
    int r = coo_row[k];
    int dest = offset[r]++;
    col_ind[dest] = coo_col[k];
    values[dest]  = coo_val[k];
}

}

// A[p,p] = 1, rhs[p] = 0
void build_2d_poisson_coo_periodic(
int nx, int ny, double hx, double hy,
const std::function<double(int,int)> &f,
std::vector &coo_row,
std::vector &coo_col,
std::vector &coo_val,
std::vector &rhs)
{
const int N = nx * ny;
rhs.assign(N, 0.0);

coo_row.clear(); coo_col.clear(); coo_val.clear();
coo_row.reserve(static_cast<size_t>(N) * 5);
coo_col.reserve(static_cast<size_t>(N) * 5);
coo_val.reserve(static_cast<size_t>(N) * 5);

const double cx = 1.0 / (hx * hx);
const double cy = 1.0 / (hy * hy);

auto try_add = [&](int r, int c, double v) {
    coo_row.push_back(r);
    coo_col.push_back(c);
    coo_val.push_back(v);
};

for (int j = 0; j < ny; ++j) {
    for (int i = 0; i < nx; ++i) {
        int p = idx(i, j, nx);

        if (i == 0 && j == 0) {
            try_add(p, p, 1.0);
            rhs[p] = 0.0;
            continue;
        }

        int iL = (i - 1 + nx) % nx;
        int iR = (i + 1) % nx;
        int jD = (j - 1 + ny) % ny;
        int jU = (j + 1) % ny;

        int qL = idx(iL, j,  nx);
        int qR = idx(iR, j,  nx);
        int qD = idx(i,  jD, nx);
        int qU = idx(i,  jU, nx);

        double diag = 2.0 * (cx + cy);
        double b    = f(i, j);  // f(i,j) = 8π^2 sin(2πx) sin(2πy)

        try_add(p, p, diag);

        try_add(p, qL, -cx);
        try_add(p, qR, -cx);

        try_add(p, qD, -cy);
        try_add(p, qU, -cy);

        rhs[p] = b;
    }
}

}

std::vector analytical_solution(int nx, int ny, double hx, double hy)
{
const double PI = 3.14159265358979323846;
std::vector exact(nx * ny, 0.0);
for (int j = 0; j < ny; ++j) {
double y = j * hy;
for (int i = 0; i < nx; ++i) {
double x = i * hx;
exact[idx(i, j, nx)] = std::sin(2.0 * PI * x) * std::sin(2.0 * PI * y);
}
}
return exact;
}

struct ErrorStats {
double linf_abs;
double l2_abs;
double l2_rel;
};

ErrorStats compute_errors(const std::vector &u_num,
const std::vector &u_ex,
double hx, double hy)
{
double linf = 0.0;
double l2 = 0.0;
double l2_ex = 0.0;
const int N = static_cast(u_num.size());
for (int k = 0; k < N; ++k) {
double d = std::abs(u_num[k] - u_ex[k]);
linf = std::max(linf, d);
l2 += d * d;
l2_ex += u_ex[k] * u_ex[k];
}

l2 = std::sqrt(l2 * hx * hy);
l2_ex = std::sqrt(l2_ex * hx * hy);

ErrorStats s;
s.linf_abs = linf;
s.l2_abs   = l2;
s.l2_rel   = (l2_ex > 0.0) ? (l2 / l2_ex) : 0.0;
return s;

}

int main()
{

const int nx = 3201;      
const int ny = 3201;    
const double Lx = 1.0, Ly = 1.0;
const double hx = Lx / (nx - 1);   
const double hy = Ly / (ny - 1);
const int N = nx * ny;



const double PI = 3.14159265358979323846;


auto f = [&](int i, int j) {
    double x = i * hx;
    double y = j * hy;
    return 8.0 * PI * PI *
           std::sin(2.0 * PI * x) *
           std::sin(2.0 * PI * y);
};



std::vector<int> coo_row, coo_col;
std::vector<double> coo_val, rhs;
build_2d_poisson_coo_periodic(nx, ny, hx, hy,
                              f,
                              coo_row, coo_col, coo_val, rhs);

const int nnz = static_cast<int>(coo_row.size());



std::vector<int> row_ptr, col_ind;
std::vector<double> values;

coo_to_csr(N, nnz, coo_row, coo_col, coo_val, row_ptr, col_ind, values);



CHECK_AMGX(AMGX_initialize());
// CHECK_AMGX(AMGX_initialize_plugins());

AMGX_config_handle cfg;

// Reading from JSON configuration file (filename: cheaper_Solver.json)
CHECK_AMGX(AMGX_config_create_from_file(
&cfg,
"./cheaper_Solver.json"));

AMGX_resources_handle rsrc;
CHECK_AMGX(AMGX_resources_create_simple(&rsrc, cfg));

AMGX_matrix_handle A;
AMGX_vector_handle b, x;
AMGX_solver_handle solver;

CHECK_AMGX(AMGX_matrix_create(&A, rsrc, AMGX_mode_dDDI));
CHECK_AMGX(AMGX_vector_create(&b, rsrc, AMGX_mode_dDDI));
CHECK_AMGX(AMGX_vector_create(&x, rsrc, AMGX_mode_dDDI));
CHECK_AMGX(AMGX_solver_create(&solver, rsrc, AMGX_mode_dDDI, cfg));

std::cout << "Uploading matrix to AMGX...\n";
CHECK_AMGX(AMGX_matrix_upload_all(
A, N, nnz,
1, 1,
row_ptr.data(),
col_ind.data(),
values.data(),
nullptr
));

std::cout << "Uploading RHS and initial value...\n";
CHECK_AMGX(AMGX_vector_upload(b, N, 1, rhs.data()));
std::vector h_x0(N, 0.0);
CHECK_AMGX(AMGX_vector_upload(x, N, 1, h_x0.data()));

const double ABS_TOL      = 1e-7;   
const int    MAX_OUTER_IT = 20;      

std::cout << "Setup and solve...\n";
CHECK_AMGX(AMGX_solver_setup(solver, A));

double abs_residual = 1e30;   
int    outer_iter   = 0;

while (abs_residual > ABS_TOL && outer_iter < MAX_OUTER_IT)
{

std::cout << "\n=== AMGX Outer Iteration " << outer_iter << " ===\n";
CHECK_AMGX(AMGX_solver_solve(solver, b, x));

    AMGX_SOLVE_STATUS status;
    CHECK_AMGX(AMGX_solver_get_status(solver, &status));


    int iters = 0;
    CHECK_AMGX(AMGX_solver_get_iterations_number(solver, &iters));

    abs_residual = 0.0;
    CHECK_AMGX(AMGX_solver_get_iteration_residual(
        solver,
        iters,   
        0,       // block_idx
        &abs_residual));

    std::cout << "  inner iters = " << iters
              << ", |r|_L2 = " << std::scientific << abs_residual << "\n";

    ++outer_iter;
}

if (abs_residual > ABS_TOL) {
std::cerr << "Warning: After " << outer_iter
<< " outer iterations, the absolute residual is still " << std::scientific << abs_residual
<< " > tol = " << ABS_TOL << "\n";
}

std::vector<double> u(N);
CHECK_AMGX(AMGX_vector_download(x, u.data()));


auto exact = analytical_solution(nx, ny, hx, hy);
auto err   = compute_errors(u, exact, hx, hy);




CHECK_AMGX(AMGX_solver_destroy(solver));
CHECK_AMGX(AMGX_vector_destroy(x));
CHECK_AMGX(AMGX_vector_destroy(b));
CHECK_AMGX(AMGX_matrix_destroy(A));
CHECK_AMGX(AMGX_resources_destroy(rsrc));
CHECK_AMGX(AMGX_config_destroy(cfg));
CHECK_AMGX(AMGX_finalize());


return 0;

}
std::cout << "\nProgram execution completed!\n";

AMGX solver configuration
{
"config_version": 2,
"solver": "PCG",
"preconditioner": {
"solver": "AMG",
"algorithm": "AGGREGATION",
"cycle": "F",
"max_levels": 30,
"presweeps": 2,
"postsweeps": 2,
"coarsest_sweeps": 4,
"max_iters": 1,
"smoother": "JACOBI_L1",
"selector": "SIZE_2",
"strength_threshold": 0.25,
"interpolator": "D2",
"max_row_sum": 0.9,
"coarse_solver": "JACOBI_L1"
},

"convergence": "ABSOLUTE",
"max_iters": 1000,        
"tolerance": 1e-7,
"norm": "L2",
"print_solve_stats": 0,
"obtain_timings": 1,
"monitor_residual": 1,
"store_res_history": 1,
"print_grid_stats": 0,
"matrix_coloring_scheme": "MIN_MAX",
"dense_lu_num_rows": 128,
"reorder_cols_by_color": 1,
"print_config": 1

}

RUN log

AMGX version 2.5.0
Built on Nov 9 2025, 19:52:31
Compiled with CUDA Runtime 11.5, using CUDA driver 11.0
Device 0: A100-SXM-80GB
AMG Configuration:

Default values:

        GS_L1_variant = 0
        affinity_iterations = 4
        affinity_vectors = 4
        aggregate_size = 2
        aggregation_edge_weight_component = 0
        aggregation_passes = 3
        aggressive_interpolator = MULTIPASS
        aggressive_levels = 0
        aggressive_selector = DEFAULT
        algorithm = CLASSICAL
        alt_rel_tolerance = 1e-12
        amg_consolidation_flag = 0
        amg_host_levels_rows = -1
        block_convert = 0
        block_format = ROW_MAJOR
        boundary_coloring = SYNC_COLORS
        cf_smoothing_mode = 0
        cheby_max_lambda = 1
        cheby_min_lambda = 0.125
        chebyshev_lambda_estimate_mode = 0
        chebyshev_polynomial_order = 5
        coarseAgenerator = LOW_DEG
        coarseAgenerator_coarse = LOW_DEG
        coarse_smoother = BLOCK_JACOBI
        coarse_solver = DENSE_LU_SOLVER
        coarsen_threshold = 1
        coarsest_sweeps = 2
        coloring_custom_arg = 
        coloring_level = 1
        coloring_try_remove_last_colors = 0
        communicator = MPI
        complex_conversion = 0
        convergence = ABSOLUTE
        convergence_analysis = 0
        cycle = V
        cycle_iters = 2
        dense_lu_max_rows = 0
        dense_lu_num_rows = 128
        determinism_flag = 0
        device_alloc_scaling_factor = 10
        device_alloc_scaling_threshold = 16384
        device_consolidation_pool_size = 268435456
        device_mem_pool_max_alloc_size = 20971520
        device_mem_pool_size = 268435456
        device_mem_pool_size_limit = 0
        energymin_interpolator = EM
        energymin_selector = CR
        error_scaling = 0
        exact_coarse_solve = 0
        exception_handling = 0
        filter_weights = 0
        filter_weights_alpha = 0.5
        fine_level_consolidation = 0
        fine_levels = -1
        fine_smoother = BLOCK_JACOBI
        finest_sweeps = -1
        full_ghost_level = 0
        geometric_dim = 2
        ghost_offdiag_limit = 0
        gmres_krylov_dim = 0
        gmres_n_restart = 20
        halo_coloring = LAST
        handshaking_phases = 1
        high_priority_stream = 0
        ilu_sparsity_level = 0
        initial_color = 0
        insert_diag_while_reordering = 0
        intensive_smoothing = 0
        interp_max_elements = -1
        interp_truncation_factor = 1.1
        interpolator = D1
        jacobi_iters = 5
        kaczmarz_coloring_needed = 1
        kpz_mu = 4
        kpz_order = 3
        late_rejection = 0
        matrix_coloring_scheme = MIN_MAX
        matrix_consolidation_lower_threshold = 0
        matrix_consolidation_upper_threshold = 1000
        matrix_halo_exchange = 0
        matrix_writer = matrixmarket
        max_coarse_iters = 100
        max_iters = 100
        max_levels = 100
        max_matching_iterations = 15
        max_num_hash = 7
        max_row_sum = 1.1
        max_unassigned_percentage = 0.05
        max_uncolored_percentage = 0.15
        merge_singletons = 1
        min_coarse_rows = 2
        min_fine_rows = 1
        min_rows_latency_hiding = -1
        modified_handshake = 0
        monitor_residual = 0
        norm = L2
        notay_weights = 0
        num_colors = 10
        num_streams = 0
        obtain_timings = 0
        postsweeps = 1
        preconditioner = AMG
        presweeps = 1
        print_aggregation_info = 0
        print_coloring_info = 0
        print_config = 0
        print_grid_stats = 0
        print_solve_stats = 0
        print_vis_data = 0
        rel_div_tolerance = -1
        relaxation_factor = 0.9
        reorder_cols_by_color = 0
        reuse_scale = 0
        rhs_from_a = 0
        scaling = NONE
        scaling_smoother_steps = 2
        selector = PMIS
        separation_exterior = OWNED
        separation_interior = INTERIOR
        serial_matching = 0
        serialize_threads = 0
        smoother = BLOCK_JACOBI
        solver = AMG
        solver_verbose = 0
        spmm_gmem_size = 1024
        spmm_max_attempts = 6
        spmm_no_sort = 1
        spmm_verbose = 0
        store_res_history = 0
        strength = AHAT
        strength_threshold = 0.25
        structure_reuse_levels = 0
        subspace_dim_s = 8
        symmetric_GS = 0
        tolerance = 1e-12
        use_bsrxmv = 0
        use_cuda_ipc_consolidation = 0
        use_cusparse_kernels = 0
        use_opt_kernels = 0
        use_scalar_norm = 0
        use_sum_stopping_criteria = 0
        verbosity_level = 3
        weakness_bound = 2147483647
        weight_formula = 0

User-defined parameters:
Current_scope:parameter_name(new_scope) = parameter_value

        default:convergence = ABSOLUTE
        default:dense_lu_num_rows = 128
        default:matrix_coloring_scheme = MIN_MAX
        default:max_iters = 1000
        default:monitor_residual = 1
        default:norm = L2
        default:obtain_timings = 1
        default:preconditioner(default_sub_preconditioner) = AMG
        default:print_config = 1
        default:print_grid_stats = 0
        default:print_solve_stats = 0
        default:reorder_cols_by_color = 1
        default:solver = PCG
        default:store_res_history = 1
        default:tolerance = 1e-07
        default_sub_preconditioner:algorithm = AGGREGATION
        default_sub_preconditioner:coarse_solver = JACOBI_L1
        default_sub_preconditioner:coarsest_sweeps = 4
        default_sub_preconditioner:cycle = F
        default_sub_preconditioner:interpolator = D2
        default_sub_preconditioner:max_iters = 1
        default_sub_preconditioner:max_levels = 30
        default_sub_preconditioner:max_row_sum = 0.9
        default_sub_preconditioner:postsweeps = 2
        default_sub_preconditioner:presweeps = 2
        default_sub_preconditioner:selector = SIZE_2
        default_sub_preconditioner:smoother = JACOBI_L1
        default_sub_preconditioner:strength_threshold = 0.25

Uploading matrix to AMGX...
Uploading RHS and initial value...
Setup and solve...

=== AMGX Outer Iteration 0 ===