Parallel Random Number Generator Research Articles

Multi-channel broadband optical chaos generation assisted by phase modulation and CFBG feedback

In this paper, we propose a novel and simple multi-channel broadband optical chaos generation scheme based on phase modulation and chirped fiber Bragg grating (CFBG). Firstly, phase modulation is introduced to generate more new frequency components to broaden the spectrum of the phase chaos. Meanwhile, the accumulated dispersion from CFBG distorts the intensity chaos, converts phase chaos to intensity chaos, and weakens the laser relaxation oscillation. This process would lead to energy redistribution in the power spectrum, effectively increasing the chaotic bandwidth. Then, the wavelength detuning between CFBG and the semiconductor laser is introduced to enhance the chaotic bandwidth further. The experiment results show that the 10 dB bandwidths of the five channels are up to 31.0 GHz, 34.3 GHz, 36.3 GHz, 40 GHz, and 40 GHz, respectively. Note that the maximum bandwidth of the PD in our experiment is limited to 40 GHz. In addition, the multi-channel chaotic signals obtained from the experiment system are used to generate multi-channel physical random numbers. After the post-processing operations, the total rate of five parallel high-speed physical random number generation channels is 4.64 Tbit/s (160 GSa/s × 5bit × 1 channel + 160 GSa/s × 6bit × 4 channels). As far as we know, this is the highest record of using external cavity feedback semiconductor lasers to generate random numbers, which has great potential to meet the security requirements of next-generation Tbit/s optical communication systems.

A Low Latency and Compact GCD Design Using an Intelligent Seed-Selection Scheme of LL-PRNG

Stochastic computing has shown great promise for a variety of applications, including image processing circuits, due to its design simplicity and low power consumption. This work proposes a hardware efficient and low latency implementation of Greatest Common Divisor (GCD) circuit. It uses a Low Latency Parallel Random Number Generator (LL-PRNG) architecture with an intelligently chosen seed value that eliminates the use of correlators and decorrelators in the circuit, reducing the hardware overhead to a great extent. The proposed approach is compared with the conventional LFSR based design showing reasonable accuracy while the latency in computation greatly reduced. The circuit is evaluated for blind image deconvolution employing GCD and has shown encouraging results.

On multiplexing in physical random number generation, and conserved total entropy content

In the current article, we use a random supercontinuum based on a random Raman distributed feedback laser to investigate the generation of random numbers by spectrally demultiplexing the broad supercontinuum spectrum in parallel channels. By tuning the spectral separation between two independent channels, we test the most typically used statistical tests’ abilities to identify the required minimum spectral separation between channels, especially after the use of post-processing steps. Out of all the tests that were investigated, the cross-correlation across channels using the raw data appears to be the most robust. We also demonstrate that the use of post-processing steps, either least significant bits extraction or exclusive-OR operations, hinders the ability of these tests to detect the existing correlations. As such, performing these tests on post-processed data, often reported in literature, is insufficient to properly establish the independence of two parallel channels. We therefore present a methodology, which may be used to confirm the true randomness of parallel random number generation schemes. Finally, we demonstrate that, while tuning a single channel’s bandwidth can modify its potential randomness output, it also affects the number of available channels, such that the total random number generation bitrate is conserved.

Tbps parallel random number generation based on a single quarter-wavelength-shifted DFB laser

We propose and experimentally demonstrate a parallel physical random number generator (Ph-RNG) based on a single quarter-wavelength-shifted distributed feedback laser (QWS-DFB LD). Though simply connecting the two output ports of the QWS-DFB LD to form a cross-coupled perturbation, we simultaneously produce two paths of complex optical chaotic signals with a bandwidth above 10 GHz. Furthermore, a dual-channel Ph-RNG with a bit rate of order terabit per second (Tbps) is implemented by combining a multi-bit extraction method. Final results show that our generated physical random numbers can successfully pass standard benchmark tests for randomness.

Scrambling additive lagged-Fibonacci generators

Abstract Random numbers are used in a variety of applications including simulation, sampling, and cryptography. Fortunately, there exist many well-established methods of random number generation. An example of a well-known pseudorandom number generator is the lagged-Fibonacci generator (LFG). Marsaglia showed that the lagged-Fibonacci generator using addition failed some of his DIEHARD statistical tests, while it passed all when longer lags were used. This paper presents a scrambler that takes bits from a pseudorandom number generator and outputs (hopefully) improved pseudorandom numbers. The scrambler is based on a modified Feistel function, a method used in the generation of cryptographic random numbers, and multiplication by a chosen multiplier. We show that this scrambler improves the quality of pseudorandom numbers by applying it to the additive LFG with small lags. The scrambler performs well based on its performance with the TestU01 suite of randomness tests. The TestU01 suite of randomness tests is more comprehensive than the DIEHARD tests. In fact, the specific suite of tests we used from TestU01 includes the DIEHARD tests The scrambling of the LFG is so successful that scrambled LFGs with small lags perform as well as unscrambled LFGs with long lags. This comes at the cost of a doubling of execution time, and provides users with generators with small memory footprints that can provide parallel generators like the LFGs in the SPRNG parallel random number generation package.

A Unifying Framework for Parallel and Distributed Processing in R using Futures

A future is a programming construct designed for concurrent and asynchronous evaluation of code, making it particularly useful for parallel processing. The future package implements the Future API for programming with futures in R. This minimal API provides sufficient constructs for implementing parallel versions of well-established, high-level map-reduce APIs. The future ecosystem supports exception handling, output and condition relaying, parallel random number generation, and automatic identification of globals lowering the threshold to parallelize code. The Future API bridges parallel frontends with parallel backends following the philosophy that end-users are the ones who choose the parallel backend while the developer focuses on what to parallelize. A variety of backends exist and third-party contributions meeting the specifications, which ensure that the same code works on all backends, are automatically supported. The future framework solves several problems not addressed by other parallel frameworks in R.

Bayesian Neural Networks for Identification and Classification of Radio Frequency Transmitters Using Power Amplifiers’ Nonlinearity Signatures

The edge devices in an emerging Internet-of-Things (IoT) environment require comprehensive security measures that are within the power budget for ubiquitous computing. In this paper, a transmitter identification scheme consisting of a lightweight Bayesian neural network (BNN)-based classifier using raw time-domain data is presented. Evaluation is performed with data obtained in schematic-level simulation of high-efficiency CMOS power amplifier designs using a 65 nm process design kit (PDK). The Bayesian neural networks achieve 89.5% accuracy on the task of classifying six transmitters. Moreover, the BNN classifier is implemented on field-programmable gate array (FPGA) with parallel pseudo-Gaussian random number generators to achieve a throughput of more than 340,000 classifications per second, with average energy consumption for each classification task of 0.548 μJ. This low-power system enables comprehensive security for energy-constrained IoT devices and sensors.

Phased-array assisted time-delay signature suppression in the optical chaos generated by an external-cavity semiconductor laser

An external-cavity semiconductor laser (ECSL) outputs high-dimensional chaos, which has potential for various applications, but the unwanted time-delay signature (TDS) might compromise the performance. In this work, a highly integrated and extensible framework of phased-array semiconductor lasers, operating in a steady state when isolated, is employed to postprocess the original chaos generated by an ECSL. Our results demonstrate that such a compact active device enables TDS suppression over wide parameter space. Better performance can be achieved in the proposed scheme compared with the conventional, discrete semiconductor laser subjected to optical chaotic injection. The influence of the injection parameters and the laser separation is studied, which further confirms the feasibility of the proposed scheme for TDS suppression. The phased array can be readily extended to include a large number of elements, and thus the current scheme allows for the generation of multiple independent chaotic signals with no discernible TDS in parallel. This means that the current study may pave the way for parallel random number generation based on optical chaos.

Parallel quantum random number generation based on spontaneous emission of alkaline earth

We propose a parallel quantum random number generator based on spontaneous emission of strontium atoms. By directly detecting the spontaneously emitted photons in different directions, two strings of true random bits with no apparent correlation at rates up to 5.12 Mb s−1 are simultaneously extracted. Via post-processing, both output sequences pass the NIST tests. Taking advantage of the random directions of the emitted photons, the presented scheme has great scalability to be extended to arbitrary multiple channels without limitations of devices’ demultiplexing configurations.

Heterogeneous Hardware Parallelism Review of the IN2P3 2016 Computing School

Parallel and hybrid Monte Carlo computation.The Monte Carlo method is the main workhorse for computation of particle physics observables. This paper provides an overview of various HPC technologies that can be used today: multicore (OpenMP, HPX), manycore (OpenCL). The rewrite of a twenty years old Fortran 77 Monte Carlo will illustrate the various programming paradigms in use beyond language implementation. The problem of parallel random number generator will be addressed. We will give a short report of the one week school dedicated to these recent approaches, that took place in École Polytechnique in May 2016.

NVIDIA GPU 상에서의 난수 생성을 위한 CUDA 병렬프로그램

In this paper, we implemented a parallel random number generation program on GPU's, which are known for high performance computing, using LCG (Linear Congruential Generator). Random numbers are important in all fields requiring the use of randomness, and LCG is one of the most widely used methods for the generation of pseudo-random numbers. We explained the parallel program using the NVIDIA CUDA model and MPI(Message Passing Interface) and showed uniform distribution and performance results. We also used a Monte Carlo algorithm to calculate pi() comparing the parallel random number generator with cuRAND, which is a CUDA library function, and showed that our program is much more efficient. Finally we compared performance results using multi-GPU's with those of ideal speedups.

A GPU enhanced approach to identify atomic vacancies in solid materials

Identification of vacancies in atomic structures plays a crucial role in the characterization of a material, from structural to dynamical properties. In this work we introduce a computationally improved vacancy recognition technique, based in a previous developed search algorithm. The procedure is highly parallel, based in the use of Graphics Processing Unit (GPU), taking advantage of parallel random number generation as well as the use of a large amount of simultaneous threads as available in GPU architecture. This increases the spatial resolution in the sample and the speed during the process of identification of atomic vacancies. The results show an improvement of efficiency up to two orders of magnitude compared to a single CPU. Along with the above a reduction of required parameters with respect to the original algorithm is presented. We show that only the lattice constant and a tunable overlap parameter are enough as input parameters, and that they are also highly related. A study of those parameters is presented, suggesting how the parameter choice must be addressed.

On parallel random number generation for accelerating simulations of communication systems

Abstract. Powerful compute clusters and multi-core systems have become widely available in research and industry nowadays. This boost in utilizable computational power tempts people to run compute-intensive tasks on those clusters, either for speed or accuracy reasons. Especially Monte Carlo simulations with their inherent parallelism promise very high speedups. Nevertheless, the quality of Monte Carlo simulations strongly depends on the quality of the employed random numbers. In this work we present a comprehensive analysis of state-of-the-art pseudo random number generators like the MT19937 or the WELL generator used for parallel stream generation in different settings. These random number generators can be realized in hardware as well as in software and help to accelerate the analysis (or simulation) of communications systems. We show that it is possible to generate high-quality parallel random number streams with both generators, as long as some configuration constraints are met. We furthermore depict that distributed simulations with those generator types are viable even to very high degrees of parallelism.

Using RngStreams for parallel random number generation in C++ and R

The RngStreams software package provides one viable solution to the problem of creating independent random number streams for simulations in parallel processing environments. Techniques are presented for effectively using RngStreams with C++ programs that are parallelized via OpenMP or MPI. Ways to access the backbone generator from RngStreams in R through the parallel and rstream packages are also described. The ideas in the paper are illustrated with both a simple running example and a Monte Carlo integration application.

PRAND: GPU accelerated parallel random number generation library: Using most reliable algorithms and applying parallelism of modern GPUs and CPUs

The library PRAND for pseudorandom number generation for modern CPUs and GPUs is presented. It contains both single-threaded and multi-threaded realizations of a number of modern and most reliable generators recently proposed and studied in Barash (2011), Matsumoto and Tishimura (1998), L’Ecuyer (1999,1999), Barash and Shchur (2006) and the efficient SIMD realizations proposed in Barash and Shchur (2011). One of the useful features for using PRAND in parallel simulations is the ability to initialize up to 1019 independent streams. Using massive parallelism of modern GPUs and SIMD parallelism of modern CPUs substantially improves performance of the generators. Program summaryProgram title: PRANDCatalogue identifier: AESB_v1_0Program summary URL:http://cpc.cs.qub.ac.uk/summaries/AESB_v1_0.htmlProgram obtainable from: CPC Program Library, Queen’s University, Belfast, N. IrelandLicensing provisions: Standard CPC licence, http://cpc.cs.qub.ac.uk/licence/licence.htmlNo. of lines in distributed program, including test data, etc.: 45979No. of bytes in distributed program, including test data, etc.: 23953564Distribution format: tar.gzProgramming language: Cuda C, Fortran.Computer: PC, workstation, laptop, or server with NVIDIA GPU (tested on Tesla X2070, Fermi C2050, GeForce GT540M) and with Intel or AMD processor.Operating system: Linux with CUDA version 5.0 or later. Should also run on MacOs, Windows, or UNIX.RAM: 4 MbytesClassification: 4.13.Nature of problem:Any calculation requiring uniform pseudorandom number generator, in particular, Monte Carlo calculations. Any calculation or simulation requiring uncorrelated parallel streams of uniform pseudorandom numbers.Solution method:The library contains realization of a number of modern and reliable generators: MT19937, MRG32K3A and LFSR113. Also new realizations of the method based on parallel evolution of an ensemble of transformations of two-dimensional torus are included in the library: GM19, GM29, GM31, GM61, GM55, GQ58.1, GQ58.3 and GQ58.4. The library contains: single-threaded and multi-threaded realizations for GPU, single-threaded realizations for CPU, realizations for CPU based on SSE command set. Also, the library contains the abilities to jump ahead inside RNG sequence and to initialize independent random number streams with block splitting method for each of the RNGs.Restrictions:Nvidia Cuda Toolkit version 5.0 or later should be installed. To use GPU realizations, Nvidia GPU supporting CUDA and the corresponding Nvidia driver should be installed. For SSE realizations of the generators, Intel or AMD CPU supporting SSE2 command set is required. In order to use the SSE realization of LFSR113, CPU must support SSE4 command set.Additional comments:A version of this program, which only contains the realizations for CPUs, is held in the Library as Catalog Id., AEIT_v2_0 (RNGSSELIB). It does not require a GPU device or CUDA compiler.Running time:The tests and the examples included in the package take less or about one minute to run. Running time is analyzed in detail in Section 8 of the paper.

Analysis of Elementary Cellular Automata Boundary Conditions

We present the findings of analysis of elementary cellular automata (ECA) boundary conditions. Fixed and variable boundaries are attempted. The outputs of linear feedback shift registers (LFSRs) act as continuous inputs to the two boundaries of a one-dimensional (1-D) Elementary Cellular Automata (ECA) are analyzed and compared. The results show superior randomness features and the output string has passed the Diehard statistical battery of tests. The design has strong correlation immunity and it is inherently amenable for VLSI implementation. Therefore it can be considered to be a good and viable candidate for parallel pseudo random number generation.

GPU-Accelerated Computation for Electromagnetic Scattering of a Double-Layer Vegetation Model

In this paper we develop a graphics processing unit (GPU)-based massively parallel approach for efficient computation of electromagnetic scattering via a proposed double-layer vegetation model composed of vegetation and ground layers. The proposed vector radiative transfer (VRT) model for vegetation scattering considers different sizes and orientations of the leaves. It uses the Monte Carlo method to calculate the backward scattering coefficients of rough ground and vegetation where the leaves are approximated as a large number of randomly oriented flat ellipsoids and the ground is treated as a Gaussian random rough surface. In the original CPU-based sequential code, the Monte Carlo simulation to calculate the electromagnetic scattering of vegetation takes up 97.2% of the total execution time. In this paper we take advantage of the massively parallel compute capability of NVIDIA Fermi GTX480 with the Compute Unified Device Architecture (CUDA) to compute the multiple scattering of all the leaf groups simultaneously. Our parallel design includes the registers for faster memory access, the shared memory for parallel reduction, the pipelined multiple-stream asynchronous transfer, the parallel random number generator and the CPU-GPU heterogeneous computation. By using these techniques, we achieved speedup of 213-fold on the NVIDIA GTX 480 GPU and 291-fold on the NVIDIA GTX 590 GPU as compared with its single-core CPU counterpart.

A PARALLEL MONTE CARLO CODE FOR SIMULATING COLLISIONAL N -BODY SYSTEMS

We present a new parallel code for computing the dynamical evolution of collisional N-body systems with up to N~10^7 particles. Our code is based on the the Henon Monte Carlo method for solving the Fokker-Planck equation, and makes assumptions of spherical symmetry and dynamical equilibrium. The principal algorithmic developments involve optimizing data structures, and the introduction of a parallel random number generation scheme, as well as a parallel sorting algorithm, required to find nearest neighbors for interactions and to compute the gravitational potential. The new algorithms we introduce along with our choice of decomposition scheme minimize communication costs and ensure optimal distribution of data and workload among the processing units. The implementation uses the Message Passing Interface (MPI) library for communication, which makes it portable to many different supercomputing architectures. We validate the code by calculating the evolution of clusters with initial Plummer distribution functions up to core collapse with the number of stars, N, spanning three orders of magnitude, from 10^5 to 10^7. We find that our results are in good agreement with self-similar core-collapse solutions, and the core collapse times generally agree with expectations from the literature. Also, we observe good total energy conservation, within less than 0.04% throughout all simulations. We analyze the performance of the code, and demonstrate near-linear scaling of the runtime with the number of processors up to 64 processors for N=10^5, 128 for N=10^6 and 256 for N=10^7. The runtime reaches a saturation with the addition of more processors beyond these limits which is a characteristic of the parallel sorting algorithm. The resulting maximum speedups we achieve are approximately 60x, 100x, and 220x, respectively.

Random number generation system improving simulations of stochastic models of neural cells

The purpose of this work is to speed up simulations of neural tissues based on the stochastic version of the Hodgkin–Huxley model. Authors achieve that by introducing the system providing random values with desired distribution in simulation process. System consists of two parts. The first one is a high entropy fast parallel random number generator consisting of a hardware true random number generator and graphics processing unit implementation of pseudorandom generation algorithm. The second part of the system is Gaussian distribution approximation algorithm based on a set of generators of uniform distribution. Authors present hardware implementation details of the system, test results of the mentioned parts separately and of the whole system in neural cell simulation task.

GASPRNG: GPU accelerated scalable parallel random number generator library

Graphics processors represent a promising technology for accelerating computational science applications. Many computational science applications require fast and scalable random number generation with good statistical properties, so they use the Scalable Parallel Random Number Generators library (SPRNG). We present the GPU Accelerated SPRNG library (GASPRNG) to accelerate SPRNG in GPU-based high performance computing systems. GASPRNG includes code for a host CPU and CUDA code for execution on NVIDIA graphics processing units (GPUs) along with a programming interface to support various usage models for pseudorandom numbers and computational science applications executing on the CPU, GPU, or both. This paper describes the implementation approach used to produce high performance and also describes how to use the programming interface. The programming interface allows a user to be able to use GASPRNG the same way as SPRNG on traditional serial or parallel computers as well as to develop tightly coupled programs executing primarily on the GPU. We also describe how to install GASPRNG and use it. To help illustrate linking with GASPRNG, various demonstration codes are included for the different usage models. GASPRNG on a single GPU shows up to 280x speedup over SPRNG on a single CPU core and is able to scale for larger systems in the same manner as SPRNG. Because GASPRNG generates identical streams of pseudorandom numbers as SPRNG, users can be confident about the quality of GASPRNG for scalable computational science applications. Program summaryProgram title: GASPRNGCatalogue identifier: AEOI_v1_0Program summary URL:http://cpc.cs.qub.ac.uk/summaries/AEOI_v1_0.htmlProgram obtainable from: CPC Program Library, Queen’s University, Belfast, N. IrelandLicensing provisions: UTK license.No. of lines in distributed program, including test data, etc.: 167900No. of bytes in distributed program, including test data, etc.: 1422058Distribution format: tar.gzProgramming language: C and CUDA.Computer: Any PC or workstation with NVIDIA GPU (Tested on Fermi GTX480, Tesla C1060, Tesla M2070).Operating system: Linux with CUDA version 4.0 or later. Should also run on MacOS, Windows, or UNIX.Has the code been vectorized or parallelized?: Yes. Parallelized using MPI directives.RAM: 512 MB∼ 732 MB (main memory on host CPU, depending on the data type of random numbers.) / 512 MB (GPU global memory)Classification: 4.13, 6.5.Nature of problem:Many computational science applications are able to consume large numbers of random numbers. For example, Monte Carlo simulations are able to consume limitless random numbers for the computation as long as resources for the computing are supported. Moreover, parallel computational science applications require independent streams of random numbers to attain statistically significant results. The SPRNG library provides this capability, but at a significant computational cost. The GASPRNG library presented here accelerates the generators of independent streams of random numbers using graphical processing units (GPUs).Solution method:Multiple copies of random number generators in GPUs allow a computational science application to consume large numbers of random numbers from independent, parallel streams. GASPRNG is a random number generators library to allow a computational science application to employ multiple copies of random number generators to boost performance. Users can interface GASPRNG with software code executing on microprocessors and/or GPUs.Running time:The tests provided take a few minutes to run.