VortexRNG - Home

Introducing the VortexRNG Server^TM

Welcome to the home of VortexRNG. Please pardon our lack of buzzword salads and glitzy photos, we're on a strict diet of meaningful and useful information. If you are new to the world of random numbers, click here to download our whitepaper "Random Number Generation for Computer Simulations" to learn why high-quality random numbers are critical for realistic simulation results. Click here to download the VortexRNG Server brochure.

The VortexRNG Server is an innovative software package for researchers and scientists who require a large volume of high quality, deterministic random numbers in their simulation work. The VortexRNG Server off-loads random number generation from the system running simulations for faster simulations and shorter time to results (more on this below). The VortexRNG Server turns a 64-bit X86 based Linux computer into a high-performance, high quality random number generator, providing a dedicated virtual RNG each for a large number of users. Raw generation rates over 25 million random numbers per second per core have been achieved with mid-level performance Intel Xeon processors.

The VortexRNG Server utilizes multiple CPU cores as RNG nodes as shown in the block diagram below. As well as being highly scalable (it can run on computers from laptop to supercomputer), the VortexRNG Server is also highly configurable. RNG Nodes can be reserved for high priority requests or grouped to act as a single RNG for parallel generation, dramatically increasing the generation rates for a single client. When run on a dedicated system, non-RNG functions can be assigned to dedicated cores to help maximize throughput. When run on a multi-purpose system where resources must be shared, the number of cores used for RNG nodes may be restricted and the non-RNG functions run on the Control Node to free up resources for other applications.

Two RNG algorithms are supported by the VortexRNG Server, the commonly used Mersenne Twister (32 and 64 bit versions) and the proprietary VortexRNG algorithm. The Mersenne Twister algorithm is widely used in simulations and incorporating it in the VortexRNG Server provides a well-known and proven RNG along with compatibility with previous simulation work and when working with others who don’t use the VortexRNG Server. Other RNG algorithms are supported through "shared libraries" libraries. This means that essentially any RNG algorithm the user has source code for can be used with VortexRNG Server (see the disclaimer on RNG compatibility at the bottom of this page). The RNG algorithm and post-processing requirements are configured for each virtual RNG to match each user's specific requirements.

The unique architecture of the VortexRNG algorithm makes the data flow through the algorithm similar to a swirling vortex. Synthesized entropy data is passed into the algorithm at a relatively slow rate where it is expanded into a larger set of entropy data. Multiple expanded entropy data values are combined to feed into the DRNG. The DRNG is repeatedly cycled to produce the random number output sequence. Each stage of the data flow is cycled faster and more times than the previous stage, resulting in dozens of random numbers being produced for each set of input entropy data values. The amount of state data makes the probability of generating a repeating pattern on the order of one in 10³⁰⁰ numbers (for reference the age of the universe is generally accepted to be on the order of 10¹⁸ seconds). This provides effectively true random number generation comparable to a hardware true RNG but with deterministic operation and orders of magnitude faster generation rates. The VortexRNG algorithm was designed with acceleration in mind so it runs very efficiently on NVIDIA GPUs where raw generation rates over 1 billion random numbers per second have been achieved using commodity graphics-card oriented GPUs.

Regardless of which RNG algorithm is used, the main benefit to the user comes from off-loading the number generation. Instead of generating random numbers and post-processing them one at a time in a serial manner inside the simulation code, the number generation and post-processing is done in parallel with the simulation code. The more random numbers used in the inner-loop of the simulation code (and the more post-processing they receive) the greater this benefit becomes. The VortexRNG Server also implements pre-generation so idle time on the RNG nodes is used to generate and buffer numbers before they are requested. Depending on the rate at which the client system requests numbers, this can reduce and even eliminate the time required to generate the numbers when they are requested, the pre-generated numbers only have to be transferred over the network to the requesting system. All of this is done such that when operating in detemerministic mode the same sequence of numbers is always generated for a given seed value.

The VortexRNG Server is very cost effective to deploy. The server software can be installed and configured in well under an hour. The provided client source code can be integrated into the application software in a matter of minutes. The VortexRNG Server software performs well on older hardware, in many cases acceptable performance can be achieved without investing in the latest generation server hardware. The VortexRNG Server is offered in a number of versions in configurations suitable for individual and small departmental use to large datacenter and supercomputer applications. For the non-GPU versions, at the maximum number of streams the cost is well under $50 per stream (a stream is essentially a virtual RNG as mentioned earlier, a stream may represent a user but a user can use multiple streams). Several of these configurations are priced below common discretionary spending limits for a university professor or mid-level manager in a corporate environment. The capabilities of the various versions are outlined below, please contact us for pricing information and acquisition models.

VortexRNG Server Features

Offloads random number generation from primary compute resources so simulations run faster.
Multi-threaded architecture takes advantage of multi-core processors and multiple processors in a server.
A C source code driver is provided for client use and easy implementation on a variety of host microprocessors. Only slight modifications are required to work with Fortran applications. The server side software will work with any client side operating system, programming language or processor architecture.
Interacts with client through “streams”, each stream is a virtual, independent DRNG.
Supports buffered pre-generation to minimize latency when the client requests a block of numbers.
Multiple options for increasing number generation rates (without compromising the quality of generated numbers) such as grouping streams for parallel generation.
Supports multiple priority levels on a per-stream basis so lower priority development work doesn’t impact generation rates for high priority “production” simulation runs.
Supports multiple NICs and any TCP/IP based network including IPoIB. Other high performance interfaces and protocols such as RDMA will be supported in future releases.
Post processing options for floating point results, range fitting and specific distribution matching.
Expected to run on any Linux distribution (tested on Ubuntu and CentOS, others to follow).
Secure operation ensured by users only being able to interact with streams they create.
Developed with system security in mind. Only well-known and proven Linux libraries have been used and no open-source or free-ware software is used. Users don't require special privelege levels and the server administrator only needs directory level access permissions, not superuser priveleges. Neither the server nor provided client functions have access to the application data or user identify information.
Multiple product offerings suitable for running on a wide range of hardware from a desktop computer for individual or small departmental use to datacenter servers with hundreds of cores.

RNG Features

Easy selection option to use the Mersenne Twister RNG or the VortexRNG RNG.
Supports the Mersenne Twister RNG (32 and 64-bit versions) for compatibility with previous simulation work and with others not using the VortexRNG Server. GPU acceleration is not available for the Mersenne Twister.
The VortexRNG DRNG is a very fast and strong proprietary DRNG based on multiple enhanced linear-feedback shift registers. Generation rates in excess of 25 million numbers per-second per-core can be achieved with commodity-level 64-bit X86 processors.
Performance and the quality of numbers generated are comparable to commonly used DRNGs for simulations such as Mersenne Twister, the GSL Tausworthe RNG and others.
Comparable results on common tests of randomness as for commonly used DRNGs and even hardware true RNGs. This includes NIST-22 and FIPS 140 tests for cryptographically secure applications.
Very large amount of state data minimizes concern for repeating number sequences for even the longest simulation runs. The probability of a repeating pattern is less than 1 in 10³⁰⁰ numbers and the algorithm was designed to prevent repeating patterns.
Easy client selection for deterministic or random mode with similar performance and number quality.
Seeding algorithm generates quality seeds from the user supplied seed values. This means there are no "bad seeds" and high quality number generation occurs with the very first numbers generated after seeding.

GPU Acceleration

The VortexRNG DRNG can take advantage of an NVIDIA GPU for significantly higher performance (over one billion numbers per second with a consumer oriented graphics GPU).
Core section of the DRNG algorithm runs on parallel GPU threads and optionally on parallel CUDA blocks to achieve even higher generation rates.
Supports NVIDIA architectures starting with Pascal (compute capabilities 6.0 or higher). Even the older architectures provide a significant performance boost compared to running on a X86 processor.
Configurable use of GPU resources allows for optimizing for maximum performance or for multiple users to efficiently share an expensive resource.

VortexRNG Server Versions

Version *	Max RNG Nodes	Max Virtual RNGs	RNG Memory	Max Network Interfaces	Max CUDA Threads **
F1	8	118	8 GB	2	1,000
F2-A	16	256	8 GB	2	3,000
F2-B	32	512	16 GB	4	3,000
F3-A	60	960	16 GB	4	6,000
F3-B	96	1,536	32 GB	8	6,000
F4-A	192	3,072	32 GB	8	12,000
F4-B	256	4,096	64 GB	8	12,000
F5	unlimited	16/core	16MB/core	8	unlimited

* VRNG Server version F0 using up 4 RNG nodes is available for a single user with modest performance requirements.
** GPU acceleration is an extra cost option.

*************** Disclaimer on RNG Compatibility ***************

The VortexRNG Server uses the standard 32 and 64-bit Mersenne Twister implementations (currently Matsumoto and Nishimura's 2002 mt19937ar.c improved version of their original algorithm from 1997). There are also a number of variants that produce different number sequences than what the standard implementation generates so it's necessary to know which version is in use. Even when using the mt19937.c version compatibility can be difficult to achieve when doing post-processing such as range fitting and fitting to a specific distribution. There are no standards for this post-processing so different implementations exist. Even when using the same code, floating point results may be different when running the code on different processor types (such as an X86 micro and a Power micro). Programmatic differences can be accomodated by only replacing the MT algorithm code with the VortexRNG Server and using the same post processing functions, however this reduces the performance benefit of off-loading number generation since the post-processing will no longer be a parallel operation. The more common versions of this post-processing code (such as in the C++ library) will be implemented in future versions of the VortexRNG Server and the use of shared libraries will allow any RNG and/or post-processing code to be used if the user has access to the source code. This will ensure compatibility without sacrificing performance. If RNG compatibility is critical for your use please contact us to discuss.