saberbud/ceres-solver
1
0
Fork 0
mirror of https://github.com/ceres-solver/ceres-solver.git synced 2026-08-29 08:34:37 +08:00
Code Issues Packages Projects Releases Wiki Activity

Block-sparse to CRS conversion using block-structure

Browse Source 
Instead of pre-computing pemutation from block-sparse to CRS order,
index of value in CRS matrix is computed in the process of updating
values using block-sparse structure.

When it is possible to update values via a simple host-to-device copy,
block-sparse structure on GPU is discarded after computing CRS
structure.

Computing index is significantly slower than using pre-computed
permutation, but is still hidden by host-to-device transfer.

On problems from BAL dataset this results into reduction of extra
gpu memory consumption from 33% (permutation stored as 32-bit indices)
to ~10% for storing block-sparse structure.

Benchmark results:

======================= CUDA Device Properties ======================
Cuda version         : 11.8
Device ID            : 0
Device name          : NVIDIA GeForce RTX 2080 Ti
Total GPU memory     :  11012 MiB
GPU memory available :  10852 MiB
Compute capability   : 7.5
Warp size            : 32
Max threads per block: 1024
Max threads per dim  : 1024 1024 64
Max grid size        : 2147483647 65535 65535
Multiprocessor count : 68
====================================================================
Running ./bin/evaluation_benchmark
Run on (112 X 3200 MHz CPU s)
CPU Caches:
  L1 Data 32 KiB (x56)
  L1 Instruction 32 KiB (x56)
  L2 Unified 1024 KiB (x56)
  L3 Unified 39424 KiB (x2)
Load Average: 24.58, 11.75, 8.52

-----------------------------------------------------------------------
Benchmark                                                          Time
-----------------------------------------------------------------------
Using on-the-fly computation of CRS index corresponding to block-sparse
index:

JacobianToCRS<g/final/problem-4585-1324582-pre.txt>             1607 ms
JacobianToCRSView<g/final/problem-4585-1324582-pre.txt>          564 ms
JacobianToCRSMatrix<g/final/problem-4585-1324582-pre.txt>       2226 ms
JacobianToCRSViewUpdate<g/final/problem-4585-1324582-pre.txt>    228 ms
JacobianToCRSMatrixUpdate<g/final/problem-4585-1324582-pre.txt>  400 ms

Using precomputed permutation:
JacobianToCRS</final/problem-4585-1324582-pre.txt>              1656 ms
JacobianToCRSView</final/problem-4585-1324582-pre.txt>           553 ms
JacobianToCRSMatrix</final/problem-4585-1324582-pre.txt>        2255 ms
JacobianToCRSViewUpdate</final/problem-4585-1324582-pre.txt>     228 ms
JacobianToCRSMatrixUpdate</final/problem-4585-1324582-pre.txt>   406 ms

Performance of JacobianToCRSViewUpdate is still limited by
host-to-device transfer, and JacobianToCRSView is faster than computing
CRS structure on CPU.

Change-Id: Ifb6910fb01ae6071400d36c277846fadc5857964
This commit is contained in:
Dmitriy Korchemkin
2023-05-17 14:43:33 +03:00
parent 0f9de3daf4
commit bdee4d6172
23 changed files with 828 additions and 479 deletions
Download Patch File Download Diff File Expand all files Collapse all files
internal/ceres/cuda_block_structure.cc
+29 -19
View File
@@ -46,7 +46,7 @@ inline int Dimension(const std::vector<Block>& blocks) {
CudaBlockSparseStructure::CudaBlockSparseStructure(
const CompressedRowBlockStructure& block_structure, ContextImpl* context)
: row_block_offsets_(context),
: first_cell_in_row_block_(context),
cells_(context),
row_blocks_(context),
col_blocks_(context) {
@@ -56,44 +56,56 @@ CudaBlockSparseStructure::CudaBlockSparseStructure(
const auto& col_blocks = block_structure.cols;
// Row block offset is an index of the first cell corresponding to row block
std::vector<int> row_block_offsets;
std::vector<int> first_cell_in_row_block;
// Flat array of all cells from all row-blocks
std::vector<Cell> cells;
int f_values_offset = 0;
is_crs_compatible_ = true;
num_row_blocks_ = block_structure.rows.size();
num_col_blocks_ = col_blocks.size();
row_blocks.reserve(num_row_blocks_);
row_block_offsets.reserve(num_row_blocks_ + 1);
first_cell_in_row_block.reserve(num_row_blocks_ + 1);
num_nonzeros_ = 0;
num_cells_ = 0;
sequential_layout_ = true;
for (const auto& r : block_structure.rows) {
const int row_block_size = r.block.size;
if (r.cells.size() > 1 && row_block_size > 1) {
is_crs_compatible_ = false;
}
row_blocks.emplace_back(r.block);
row_block_offsets.push_back(num_cells_);
first_cell_in_row_block.push_back(cells.size());
for (const auto& c : r.cells) {
cells.emplace_back(c);
const int col_block_size = col_blocks[c.block_id].size;
num_nonzeros_ += col_block_size * row_block_size;
++num_cells_;
const int cell_size = col_block_size * row_block_size;
cells.push_back(c);
sequential_layout_ &= c.position == num_nonzeros_;
num_nonzeros_ += cell_size;
}
}
row_block_offsets.push_back(num_cells_);
first_cell_in_row_block.push_back(cells.size());
num_cells_ = cells.size();
num_rows_ = Dimension(row_blocks);
num_cols_ = Dimension(col_blocks);
is_crs_compatible_ &= sequential_layout_;
if (VLOG_IS_ON(3)) {
const size_t row_block_offsets_size =
row_block_offsets.size() * sizeof(int);
const size_t first_cell_in_row_block_size =
first_cell_in_row_block.size() * sizeof(int);
const size_t cells_size = cells.size() * sizeof(Cell);
const size_t row_blocks_size = row_blocks.size() * sizeof(Block);
const size_t col_blocks_size = col_blocks.size() * sizeof(Block);
const size_t total_size =
row_block_offsets_size + cells_size + col_blocks_size + row_blocks_size;
const size_t total_size = first_cell_in_row_block_size + cells_size +
col_blocks_size + row_blocks_size;
const double ratio =
(100. * total_size) / (num_nonzeros_ * (sizeof(int) + sizeof(double)) +
num_rows_ * sizeof(int));
VLOG(3) << "\nCudaBlockSparseStructure:\n"
"\tRow block offsets: "
<< row_block_offsets_size
<< first_cell_in_row_block_size
<< " bytes\n"
"\tColumn blocks: "
<< col_blocks_size
@@ -102,13 +114,11 @@ CudaBlockSparseStructure::CudaBlockSparseStructure(
<< row_blocks_size
<< " bytes\n"
"\tCells: "
<< cells_size
<< " bytes\n"
"\tTotal: "
<< total_size << " bytes of GPU memory";
<< cells_size << " bytes\n\tTotal: " << total_size
<< " bytes of GPU memory (" << ratio << "% of CRS matrix size)";
}
row_block_offsets_.CopyFromCpuVector(row_block_offsets);
first_cell_in_row_block_.CopyFromCpuVector(first_cell_in_row_block);
cells_.CopyFromCpuVector(cells);
row_blocks_.CopyFromCpuVector(row_blocks);
col_blocks_.CopyFromCpuVector(col_blocks);