A mapping of the Min-Sum decoder to reduction operations, and its implementation using CUDA kernels

Omer Shimon Sella; Thomas Heinis

REVIEW 3 major objections 5 minor 19 references

A mapping of the Min-Sum decoder to reduction operations, and its implementation using CUDA kernels

T0 review · 3 major / 5 minor · reviewed 2026-08-06 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

Pith's one-line read The paper claims that one Min-Sum decoding iteration reduces to a single fixed sequence of dense matrix operations, so a GPU decoder needs only the dimensions of the parity-check matrix, not its nonzero pattern.

desk verdict Clean map-reduce restatement of Min-Sum that self-destructs on Eq. (37) by swapping min0 and min1, then validates only with syndrome checks. read the letter →

arxiv 2507.10424 v1 pith:76TEJ6SB submitted 2025-07-14 cs.IT math.IT

Omer Shimon Sella , Thomas Heinis This is my paper · ORCID

classification cs.ITmath.IT MSC 94B3568W10

keywords LDPCcodesMin-SumdecoderGPUimplementationCUDAkernelsreductionoperationsparity-checkmatrixmap-reduceSIMT

verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

This paper tries to establish that the Min-Sum decoder for LDPC codes (sparse linear codes decoded by message passing) can be written as a fixed pipeline of matrix reductions, with no control flow that depends on where the ones in the parity-check matrix live. One iteration becomes: fan the current bit log-likelihoods out to every check-bit position, mask by the parity-check matrix $H$, reduce each row to the two smallest magnitudes and the sign product, assemble the check-to-bit message matrix, then reduce each column and add the received values. The only input that varies from code to code is $H$ itself; the kernels and their launch configuration depend solely on the dimensions $m$ and $n$. If the equivalence holds, the same CUDA implementation decodes any LDPC code of the same dimensions, which matters in the early design stage when several candidate codes are being compared before any code-specific optimization is worth doing.

What carries the argument

The load-bearing object is the masked dense message matrix $\lambda(i,j)=r(j)H(i,j)$ in the first iteration and $\lambda(i,j)=s(j)H(i,j)-\eta(i,j)$ afterward, together with the row reductions $\mathrm{min}_0$, $\mathrm{min}_0\mathrm{Location}$, $\mathrm{min}_1$, and the row sign product $\mathrm{sgn}(i)$ defined in Eqs. (33)-(36). The check-to-bit messages are assembled by Eq. (37), and Eq. (38) completes the iteration as the column-wise sum $s(j)=\sum_i \eta(i,j)+r(j)$. This map-reduce skeleton is what lets one kernel set be reused for any $H$ with the same shape.

What would settle it

Take a single check row with three connected bits and magnitudes $|\lambda|=(0.5, 2.0, 3.0)$, run one iteration of Algorithm 2, and compare the message produced by Eq. (37) for the bit with magnitude 0.5 against the message required by Eq. (9): if the printed update returns 0.5 instead of 2.0, the pipeline is not implementing the Min-Sum update at that position.

Watch

Extended reading notes

Core claim

The paper's central claim is that the sparse message-passing update of Algorithm 1 is exactly reproduced by a dense reduction pipeline, stated as Algorithm 2 with update equations (32)-(38). Observation 3.1 splits each check-node minimum into a row minimum $\mathrm{min}_0$, its location, and a second row minimum $\mathrm{min}_1$; Observation 3.2 turns the sign product into a single row sign product corrected by the outgoing bit's own sign. Setting $\eta(i,j)=0$ where $H(i,j)=0$ and taking $\mathrm{sign}(0)=1$ lets every extrinsic message be computed by reductions over full rows and columns. The resulting iteration is content-independent: only $m$ and $n$ enter the structure of the kernels, and $H$ enters only as data by which the message matrices are masked.

Load-bearing premise

The whole equivalence rests on the claim that masking $H$ into dense matrices with $\mathrm{sign}(0)=1$ reproduces the sparse check-node update exactly; a literal reading of Eq. (37) violates that at the argmin position, since it sends the row minimum to the bit that supplied it instead of the second minimum.

Editorial extensions

If this is right

A single compiled kernel set can decode every LDPC code with the same $m$ and $n$; only the matrix data in GPU memory changes between codes.
The decoder's runtime profile is dominated by a few reduction kernels, so further optimization can concentrate on row-wise minima, horizontal sign reduction, vertical summation, and masked fan-out.
Because every step is a map or reduction, the identical structure ports to any SIMT or bulk-synchronous GPU programming model, not only CUDA.
The experiments on a quasi-cyclic (8176, 1022) LDPC benchmark show the approach scaling across multiple GPUs and provide a direct throughput comparison against a CPU implementation.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

Beyond the paper: avoiding the host-device round trip for convergence checks would likely remove the majority of the API time that the profile attributes to device-to-host memory copies.
The same reduction skeleton should support normalized or offset Min-Sum variants by changing only the message-combination step, which would broaden the approach beyond unnormalized Min-Sum.
Because the formulation materializes dense $m \times n$ matrices, memory use grows with the product of the dimensions; a sparse-aware variant would be needed for very large codes, a trade-off the paper does not compare.
If the printed Eq. (37) is corrected to use $\mathrm{min}_1$ at the argmin position, the pipeline would implement exact Min-Sum; with the equation as printed it implements a close variant whose bit-error rate should be compared against the standard decoder.

Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Desk Editor's Note

read the letter

Colleague, here's the short version: the paper's central check-node update, Eq. (37), inverts the min-selection rule relative to its own (correct) derivation in Eq. (24). At the argmin position it uses min0 where it should use min1, and vice versa. So if you read the text literally, the algorithm is not Min-Sum. That is a load-bearing flaw, and it is not a minor typo because Algorithm 2 and the CUDA kernel produceNewMatrix2D explicitly implement Eq. (37).

What the paper does well: it gives a readable, self-contained account of how to express one Min-Sum iteration as masked fan-out, row-wise min/sign reductions, and a column-sum reduction. Observation 3.1 is old (they credit [17]), Observation 3.2 is elementary sign algebra, but the dense masked-matrix formulation is a clean way to think about batch decoding. The derivation up to Eq. (24) is correct, and the code is on GitHub, which is a real credit.

The soft spots: (1) the min/min1 swap is in the core formula, so the measured throughput and termination results are produced by a decoder that is not the Min-Sum decoder described in the paper. (2) The experiments never report bit error rate or frame error rate; syndrome-only termination is not evidence of error-correction quality. (3) There is no comparison against a serious edge-based GPU decoder like [17]; the CPU baseline is a Python/Numba loop, which is not a strong opponent. (4) There are minor typos: H(i,j)=1 should be H(i,j)=0 in the masking sentence, and Eq. (38) sums over the wrong index.

Proportion: the error is a single swap, and the conceptual restatement is sound, so the paper is not intellectually broken. But as written, the central claim is not demonstrated, and the evaluation does not establish that the decoder corrects errors.

Who is this for? Someone building a quick prototype to screen LDPC codes on a GPU, or a teaching resource for map-reduce views of message passing. Not for a new decoding result.

Recommendation: I would send it to a serious referee. The paper is a legitimate submission with a concrete implementation; a referee can catch the swap and the missing BER, and the authors can fix both. It should not be desk-rejected, but it needs revision before acceptance.

Referee Report

3 major / 5 minor

Summary. The paper proposes a reformulation of the min-sum LDPC decoder as a sequence of dense matrix map/reduce operations, with the parity matrix treated as an input rather than a fixed structure. The authors derive row-minimum, second-minimum, and sign-product reductions for the check-node update, then present CUDA kernels implementing one iteration as masked fan-out, horizontal reductions, and vertical summation. They benchmark the resulting decoder on a CCSDS quasi-cyclic code using one to four A100 GPUs and report throughput and termination behavior, while also profiling kernel and API time. The central claim is that the decoder implementation depends only on the dimensions of the parity matrix, not on its nonzero pattern.

Significance. If the reformulation were correct, the paper would offer a practically useful, content-independent GPU decoder for LDPC codes, applicable during code selection when per-code optimizations are not yet available. The derivation up to Eq. (24) is mostly straightforward algebra with no fitted constants; Observation 3.1 is attributed to prior work, and the use of sign(0)=1 to neutralize padded entries is a transparent convention. The authors also provide a code repository, which is a strength. However, the check-node update as written in Eq. (37) is not the min-sum update of Eq. (9), and the experiments as reported do not establish decoding correctness. The contribution is therefore not acceptable in its current form, but the main error is localized and appears fixable.

major comments (3)

[§III, Eq. (37) and Algorithm 2] Equation (37) swaps the roles of min0 and min1 relative to Eq. (24). In Eq. (24), the message magnitude is min1 at the location j = min0Location(i) and min0 everywhere else, which correctly removes the bit's own contribution. Equation (37) instead selects min0 at min0Location and min1 elsewhere, so the message to the least-reliable bit includes that bit's own magnitude, and all other messages use the second minimum. Because Algorithm 2 states that eta is computed according to Eq. (37) and the produceNewMatrix2D kernel is described as implementing that equation, the decoder that was implemented and benchmarked is not the min-sum decoder of Eq. (9). The text must be corrected to match Eq. (24), the kernel must be changed accordingly, and all experimental results must be regenerated.
[§VI, Figures 5-9] No bit-error rate or frame-error rate is reported for the CUDA decoder. The only termination criterion shown is the syndrome check H·b = 0, and the transmitted word is the all-zero codeword, so convergence to any nonzero codeword would satisfy the syndrome check and be counted as a successful decode. Throughput and iteration counts are not meaningful without a correctness metric such as BER or FER. The authors should report decoding error rates for the corrected decoder at each SNR point.
[§IV, Listing 1] The kernel listing supplies the arguments smallest_device, secondSmallest_device, and locationOfMinimum_device to produceNewMatrix2D but does not show the body of that kernel. Given the error in Eq. (37), the reader cannot confirm from the paper how the two minima are combined. The corrected kernel body, or at least the exact selection expression it implements, should be shown or described precisely so that the implementation can be checked against the corrected equation.

minor comments (5)

[§III, Eqs. (33)-(35) and (38)] The reduction bounds are inconsistent with the matrix dimensions: Eqs. (33)-(35) use 0 ≤ j < m, but the columns of the m×n matrix are indexed by n, and Eq. (38) sums over a range written as 0 ≤ j < n although the sum is over the row index i. These bounds should be corrected.
[§II, Algorithm 1 and §IV, Algorithm 2] Algorithm 1 says 'For every bj ∈ C calculate' where the bit nodes are the set B, and Algorithm 2 says 'Set λ(i,j) = r(i) · H(i,j) = 1,' which should read 'r(j) · H(i,j)' and the trailing '= 1' is confusing. These are notation errors but should be fixed for clarity.
[§III, text after Eq. (24)] The sentence 'We have already set η(i, j) = 0 whenever H(i, j) = 1' states the opposite of the masking condition; it should say 'whenever H(i, j) = 0'. The subsequent derivation of the sign product relies on the zero-padded entries, so this typo is misleading.
[§III, Eq. (30)] The product index in 'Y_i sign(λ_k − ηprevious_i,k) · sign(λ_j − ηprevious_i,j)' appears to be written as 'Y_i', but the product is over the row entries k (or equivalently over all columns), not over the row index i. This typo obscures the reduction operation being defined.
[§VI, Figures 5-9] The CPU and GPU experiments use different sample sizes (56 vs. 60 per SNR point) and different termination-check periods (presumably every iteration on the CPU versus every 6 iterations on the GPU). The text explains these choices, but the figures and captions should state them consistently so that the CPU/GPU comparison is not misread as a controlled benchmark.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: the Min-Sum map-reduce derivation is an algebraic restatement of an externally sourced algorithm; no fitted parameter or self-cited theorem is load-bearing.

full rationale

The derivation chain starts from Algorithm 1, which the paper explicitly attributes to external references: 'The implementation of a message-passing decoder developed in this work uses the min-sum decoding algorithm described in (for example) [12] and [10]' (Section V). The map-reduce formulation in Section III is a substitution exercise: Eq. (24) combines Observation 3.1 and 3.2 into the check-node update, and Observation 3.1 is attributed to prior work: 'Observation 3.1 can be found in [17].' The masking identities, Eqs. (22)-(23), are algebraic identities that pad sparse sums with zeros, and Eqs. (32)-(38) are direct restatements of Algorithm 1 with reduction operations. There are no fitted constants, no parameters estimated from data, and no quantity is defined in terms of the very quantity it is claimed to predict. The only self-reference is [13], the authors' own code repository, and it is used to point to the implementation rather than to justify a mathematical premise. A cited result counts as independent support when it is external or machine-checked; here [17] is prior published literature and [12]/[10] are standard references. The skeptical note that Eq. (37) uses min0 at the argmin position where Eq. (24) calls for min1 identifies a correctness/implementation defect, not a circularity: a wrong update rule is still not a rule that assumes its own conclusion. Therefore no circular step is exhibited, and the paper should be scored at the non-circular end of the scale.

Assumptions & free parameters 1 free parameters · 4 assumptions · 0 invented entities

No fitted scientific constants. Hand-tuned kernel launch configurations affect throughput but not correctness. Three axioms and one explicit convention (sign(0)=1) are introduced to enable dense reductions. No new physical or algorithmic entities are postulated.

free parameters (1)

Kernel launch parameters BPG (blocks per grid) and TPB (threads per block) = not reported
Hand-tuned per kernel; the paper notes fine-tuning improves performance, and throughput figures depend on these values.

assumptions (4)

standard math Min-Sum decoding as described by Moon [12] is a correct approximation of belief propagation for LDPC codes.
Used as the starting algorithm in Section II-B, Eq. (9).
ad hoc to paper sign(0)=1 makes zero-padded non-neighbor entries neutral in sign products.
Introduced in Section III before Eq. (25) to allow dense reductions; it is a convention, not forced by coding theory.
domain assumption Zero-padded entries are neutral in min and sum reductions, so dense m by n matrices exactly reproduce the sparse graph behavior.
Underlies Eqs. (22) and (24)-(30); requires H masking and no contribution from entries where H(i,j)=0.
domain assumption The all-zero codeword test with syndrome check H times b equals zero is sufficient to validate decoding.
Experimental section uses only syndrome termination; no BER or FER is reported.

how reviews work

0 comments

Cite this review

Pith. "Pith review of A mapping of the Min-Sum decoder to reduction operations, and its implementation using CUDA kernels." pith.science (2026). https://pith.science/paper/76TEJ6SB

@misc{pith2026250710424,
  author       = {Pith},
  title        = {Pith review of: A mapping of the Min-Sum decoder to reduction operations, and its implementation using CUDA kernels},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/76TEJ6SB}},
  note         = {Machine review of arXiv:2507.10424}
}

read the original abstract

Decoders for Low Density Parity Check (LDPC) codes are usually tailored to an application and optimized once the specific content and structure of the parity matrix are known. In this work we consider the parity matrix as an argument of the Min-Sum decoder, and provide a GPU implementation that is independent of the content of the parity matrix, and relies only on its dimensions.

Figures

Figures reproduced from arXiv: 2507.10424 by the authors.

**Figure 2.** Tanner graph example. and yields 1I2 = (1, 0, 1, 0, 1, 1, 0, 1, 1, 0) • Check 3 is defined by I3 = {3, 4, 5, 7, 9, 10} and yields 1I3 = (1, 1, 1, 0, 0, 1, 1, 0, 0, 1) • Check 4 is defined by I4 = {2, 4, 5, 6, 8, 10} and yields 1I4 = (0, 1, 0, 1, 1, 1, 0, 1, 0, 1) • Check 5 is defined by I5 = {1, 2, 4, 7, 8, 9} and yields 1I5 = (1, 1, 0, 1, 0, 0, 1, 1, 1, 0) A binary vector v ∈ {0, 1} 10 satisfies all these SPCs conc… view at source ↗

**Figure 3.** The sets Ni are defined for every check node and so correspond to the locations of non-zero elements in the rows of the parity matrix. denote by Mj the set of check nodes that are connected to bit node j, i.e.: Mj = {ci : H(i, j) = 1} (5) [PITH_FULL_IMAGE:figures/full_fig_p002_3.png] view at source ↗

Figures from the paper (6 more)

**Figure 4.** Figure 4: shows how to find the set M7 using the parity matrix. An observed vector r of real values serves as initial values for (a) We use the same binary matrix as in [PITH_FULL_IMAGE:figures/full_fig_p003_4.png]

**Figure 7.** Figure 7: GPU formulated Min-Sum decoder. For each fixed [PITH_FULL_IMAGE:figures/full_fig_p007_7.png]

**Figure 5.** Figure 5: Scaling results of our implementation of a Min-Sum [PITH_FULL_IMAGE:figures/full_fig_p007_5.png]

**Figure 8.** Figure 8: Throughput as a function of SNR when the parity [PITH_FULL_IMAGE:figures/full_fig_p007_8.png]

**Figure 6.** Figure 6: Scaling results of our implementation of a Min-Sum [PITH_FULL_IMAGE:figures/full_fig_p007_6.png]

**Figure 9.** Figure 9: Scaling results of our implementation of a GPU [PITH_FULL_IMAGE:figures/full_fig_p008_9.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

19 extracted references · 18 canonical work pages

[17]

Low-density parity-check (ldpc) codes constructed from protographs

Jeremy Thorpe. Low-density parity-check (ldpc) codes constructed from protographs. 42(154):42–154. URL: https://ipnpr.jpl.nasa.gov/progress_ report/42-154/154C.pdf

work page
[1]

Project silica: towards sustainable cloud archival storage in glass

Patrick Anderson, Erika Blancada Aranas, Youssef Assaf, Raphael Behrendt, Richard Black, Marco Caballero, Pashmina Cameron, Burcu Canakci, Thales De Carvalho, Andromachi Chatzieleftheriou, et al. Project silica: towards sustainable cloud archival storage in glass. In Proceedings of the 29th Symposium on Operating Systems Principles , pages 166–181, 2023

work page 2023
[2]

5g nr ldpc decoding performance comparison be- tween gpu & fpga platforms

Alex Aronov, Leonid Kazakevich, Jane Mack, Fred Schreider, and Scott Newton. 5g nr ldpc decoding performance comparison be- tween gpu & fpga platforms. In 2019 IEEE Long Island Sys- tems, Applications and Technology Conference (LISAT) , pages 1–

work page 2019
[3]

Low density parity check codes for use in near-earth and deep space applications

CCSDS. Low density parity check codes for use in near-earth and deep space applications. online, 2007. Research and Development for Space Data System Standards. URL: https://public.ccsds.org/Pubs/131x1o2e2s. pdf

work page 2007
[4]

Second generation framing structure, channel coding and modulation systems for broadcast- ing, interactive services, news gathering and other broadband satel- lite applications

Digital Video Broadcasting (DVB). Second generation framing structure, channel coding and modulation systems for broadcast- ing, interactive services, news gathering and other broadband satel- lite applications. ETSI EN , 302:2005–01, 2003. ETSI EN 302 307. URL: https://www.etsi.org/deliver/etsi_en/302300_302399/ 30230701/01.04.01_60/en_30230701v010401p.pdf

work page 2005
[5]

Optimizing parallel reduction in cuda

Mark Harris et al. Optimizing parallel reduction in cuda. 2(4):70. URL: http://vuduc.org/teaching/cse6230-hpcta-fa12/slides/ cse6230-fa12--05b-reduction-notes.pdf

work page
[6]

URL: https://ieeexplore.ieee.org/stamp/stamp.jsp?arnumber= 8816821, doi:10.1109/LISAT.2019.8816821

IEEE. URL: https://ieeexplore.ieee.org/stamp/stamp.jsp?arnumber= 8816821, doi:10.1109/LISAT.2019.8816821

work page arXiv 2019
[7]

The openairinterface 5g new radio implementation: Current status and roadmap

Florian Kaltenberger, Guy de Souza, Raymond Knopp, and Hongzhi Wang. The openairinterface 5g new radio implementation: Current status and roadmap. In WSA 2019; 23rd International ITG Workshop on Smart Antennas , pages 1–5. VDE. URL: https://5genesis.eu/wp-content/uploads/ 2019/04/The-OpenAirInterface-5G-New-Radio-Implementation_ Current-status-and-roadmap.pdf

work page 2019

Show all 19 references

[8]

Programming massively parallel processors: a hands-on approach

David B Kirk and W Hwu Wen-Mei. Programming massively parallel processors: a hands-on approach . Morgan kaufmann
[9]

High throughput gpu ldpc encoder and decoder for dvb-s2

David Kun. High throughput gpu ldpc encoder and decoder for dvb-s2. In 2018 IEEE Aerospace Conference , pages 1–9. IEEE. URL: https://ieeexplore.ieee.org/stamp/stamp.jsp?arnumber= 8396831, doi:10.1109/AERO.2018.8396831

2018
[10]

Numba: A llvm- based python jit compiler

Siu Kwan Lam, Antoine Pitrou, and Stanley Seibert. Numba: A llvm- based python jit compiler. In Proceedings of the Second Workshop on the LLVM Compiler Infrastructure in HPC , pages 1–6
[11]

LDPC code designs, constructions, and unification

Juane Li, Shu Lin, Khaled Abdel-Ghaffar, Daniel J Costello Jr, and William E Ryan. LDPC code designs, constructions, and unification . Cambridge University Press
[12]

An introduction to factor graphs

H-A Loeliger. An introduction to factor graphs. 21(1):28–41. URL: https://ieeexplore.ieee.org/stamp/stamp.jsp?arnumber=1267047, doi:10.1109/MSP.2004.1267047

2004 arXiv
[13]

Error correction coding: mathematical methods and algorithms

Todd K Moon. Error correction coding: mathematical methods and algorithms. John Wiley & Sons
[14]

Omer S. Sella. Cuda implementation of the min-sum decoder, code repository, 2024. URL: https://github.com/Omer-Sella/cudaLDPC

2024
[15]

A recursive approach to low complexity codes

R Tanner. A recursive approach to low complexity codes. 27(5):533–
[16]

Ldpc decoder architecture for high-data rate personal-area networks

Matthew Weiner, Borivoje Nikoli ´c, and Zhengya Zhang. Ldpc decoder architecture for high-data rate personal-area networks. In 2011 IEEE International Symposium of Circuits and Systems (ISCAS) , pages 1784–

2011
[19]

4.7-gb/s ldpc decoder on gpu

Jinyang Yuan and Jin Sha. 4.7-gb/s ldpc decoder on gpu. 22(3):478–481. doi:10.1109/LCOMM.2017.2778727

2017
[547]

doi:10.1109/TIT.1981.1056404

1981

Pith tools

Reviewed August 6, 2026 · model on record in the stance chip above.

[1] [17]

Low-density parity-check (ldpc) codes constructed from protographs

Jeremy Thorpe. Low-density parity-check (ldpc) codes constructed from protographs. 42(154):42–154. URL: https://ipnpr.jpl.nasa.gov/progress_ report/42-154/154C.pdf

work page

[2] [1]

Project silica: towards sustainable cloud archival storage in glass

Patrick Anderson, Erika Blancada Aranas, Youssef Assaf, Raphael Behrendt, Richard Black, Marco Caballero, Pashmina Cameron, Burcu Canakci, Thales De Carvalho, Andromachi Chatzieleftheriou, et al. Project silica: towards sustainable cloud archival storage in glass. In Proceedings of the 29th Symposium on Operating Systems Principles , pages 166–181, 2023

work page 2023

[3] [2]

5g nr ldpc decoding performance comparison be- tween gpu & fpga platforms

Alex Aronov, Leonid Kazakevich, Jane Mack, Fred Schreider, and Scott Newton. 5g nr ldpc decoding performance comparison be- tween gpu & fpga platforms. In 2019 IEEE Long Island Sys- tems, Applications and Technology Conference (LISAT) , pages 1–

work page 2019

[4] [3]

Low density parity check codes for use in near-earth and deep space applications

CCSDS. Low density parity check codes for use in near-earth and deep space applications. online, 2007. Research and Development for Space Data System Standards. URL: https://public.ccsds.org/Pubs/131x1o2e2s. pdf

work page 2007

[5] [4]

Second generation framing structure, channel coding and modulation systems for broadcast- ing, interactive services, news gathering and other broadband satel- lite applications

Digital Video Broadcasting (DVB). Second generation framing structure, channel coding and modulation systems for broadcast- ing, interactive services, news gathering and other broadband satel- lite applications. ETSI EN , 302:2005–01, 2003. ETSI EN 302 307. URL: https://www.etsi.org/deliver/etsi_en/302300_302399/ 30230701/01.04.01_60/en_30230701v010401p.pdf

work page 2005

[6] [5]

Optimizing parallel reduction in cuda

Mark Harris et al. Optimizing parallel reduction in cuda. 2(4):70. URL: http://vuduc.org/teaching/cse6230-hpcta-fa12/slides/ cse6230-fa12--05b-reduction-notes.pdf

work page

[7] [6]

URL: https://ieeexplore.ieee.org/stamp/stamp.jsp?arnumber= 8816821, doi:10.1109/LISAT.2019.8816821

IEEE. URL: https://ieeexplore.ieee.org/stamp/stamp.jsp?arnumber= 8816821, doi:10.1109/LISAT.2019.8816821

work page arXiv 2019

[8] [7]

The openairinterface 5g new radio implementation: Current status and roadmap

Florian Kaltenberger, Guy de Souza, Raymond Knopp, and Hongzhi Wang. The openairinterface 5g new radio implementation: Current status and roadmap. In WSA 2019; 23rd International ITG Workshop on Smart Antennas , pages 1–5. VDE. URL: https://5genesis.eu/wp-content/uploads/ 2019/04/The-OpenAirInterface-5G-New-Radio-Implementation_ Current-status-and-roadmap.pdf

work page 2019