mesh-rb 0.0.1 → 0.0.2

data/ext/mesh/mesh/src/mmap_heap.h

@@ -1,104 +0,0 @@
-// -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil -*-
-// Copyright 2019 The Heap-Layers and Mesh Authors. All rights reserved.
-// Use of this source code is governed by the Apache License,
-// Version 2.0, that can be found in the LICENSE file.
-
-#pragma once
-#ifndef MESH_MMAP_HEAP_H
-#define MESH_MMAP_HEAP_H
-
-#if defined(_WIN32)
-#error "TODO"
-#include <windows.h>
-#else
-// UNIX
-#include <fcntl.h>
-#include <stdlib.h>
-#include <sys/mman.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-#include <unistd.h>
-#include <map>
-#endif
-
-#include "internal.h"
-#include "one_way_mmap_heap.h"
-
-namespace mesh {
-
-// MmapHeap extends OneWayMmapHeap to track allocated address space
-// and will free memory with calls to munmap.
-class MmapHeap : public OneWayMmapHeap {
-private:
-  DISALLOW_COPY_AND_ASSIGN(MmapHeap);
-  typedef OneWayMmapHeap SuperHeap;
-
-public:
-  enum { Alignment = MmapWrapper::Alignment };
-
-  MmapHeap() : SuperHeap() {
-  }
-
-  inline void *malloc(size_t sz) {
-    auto ptr = map(sz, MAP_PRIVATE | MAP_ANONYMOUS, -1);
-
-    d_assert(_vmaMap.find(ptr) == _vmaMap.end());
-    _vmaMap[ptr] = sz;
-    d_assert(_vmaMap.find(ptr) != _vmaMap.end());
-    d_assert(_vmaMap[ptr] == sz);
-
-    return ptr;
-  }
-
-  inline size_t getSize(void *ptr) const {
-    auto entry = _vmaMap.find(ptr);
-    if (unlikely(entry == _vmaMap.end())) {
-      debug("mmap: invalid getSize: %p", ptr);
-      abort();
-      return 0;
-    }
-    return entry->second;
-  }
-
-  inline bool inBounds(void *ptr) const {
-    auto entry = _vmaMap.find(ptr);
-    if (unlikely(entry == _vmaMap.end())) {
-      return false;
-    }
-    // FIXME: this isn't right -- we want inclusion not exact match
-    return true;
-  }
-
-  inline void free(void *ptr) {
-    auto entry = _vmaMap.find(ptr);
-    if (unlikely(entry == _vmaMap.end())) {
-      debug("mmap: invalid free, possibly from memalign: %p", ptr);
-      // abort();
-      return;
-    }
-
-    auto sz = entry->second;
-
-    munmap(ptr, sz);
-    // madvise(ptr, sz, MADV_DONTNEED);
-    // mprotect(ptr, sz, PROT_NONE);
-
-    _vmaMap.erase(entry);
-    d_assert(_vmaMap.find(ptr) == _vmaMap.end());
-  }
-
-  // return the sum of the sizes of all large allocations
-  size_t arenaSize() const {
-    size_t sz = 0;
-    for (auto it = _vmaMap.begin(); it != _vmaMap.end(); it++) {
-      sz += it->second;
-    }
-    return sz;
-  }
-
-protected:
-  internal::unordered_map<void *, size_t> _vmaMap{};
-};
-}  // namespace mesh
-
-#endif  // MESH_MESH_MMAP_H

data/ext/mesh/mesh/src/one_way_mmap_heap.h

@@ -1,77 +0,0 @@
-// -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil -*-
-// Copyright 2019 The Heap-Layers and Mesh Authors. All rights reserved.
-// Use of this source code is governed by the Apache License,
-// Version 2.0, that can be found in the LICENSE file.
-
-#pragma once
-#ifndef MESH_ONE_WAY_MMAP_HEAP_H
-#define MESH_ONE_WAY_MMAP_HEAP_H
-
-#if defined(_WIN32)
-#error "TODO"
-#include <windows.h>
-#else
-// UNIX
-#include <fcntl.h>
-#include <stdlib.h>
-#include <sys/mman.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-#include <unistd.h>
-#endif
-
-#include "common.h"
-
-#ifndef HL_MMAP_PROTECTION_MASK
-#error "define HL_MMAP_PROTECTION_MASK before including mmapheap.h"
-#endif
-
-#if !defined(MAP_ANONYMOUS) && defined(MAP_ANON)
-#define MAP_ANONYMOUS MAP_ANON
-#endif
-
-namespace mesh {
-
-// OneWayMmapHeap allocates address space through calls to mmap and
-// will never unmap address space.
-class OneWayMmapHeap {
-private:
-  DISALLOW_COPY_AND_ASSIGN(OneWayMmapHeap);
-
-public:
-  enum { Alignment = MmapWrapper::Alignment };
-
-  OneWayMmapHeap() {
-  }
-
-  inline void *map(size_t sz, int flags, int fd = -1) {
-    if (sz == 0)
-      return nullptr;
-
-    // Round up to the size of a page.
-    sz = (sz + kPageSize - 1) & (size_t) ~(kPageSize - 1);
-
-    void *ptr = mmap(nullptr, sz, HL_MMAP_PROTECTION_MASK, flags, fd, 0);
-    if (ptr == MAP_FAILED)
-      abort();
-
-    d_assert(reinterpret_cast<size_t>(ptr) % Alignment == 0);
-
-    return ptr;
-  }
-
-  inline void *malloc(size_t sz) {
-    return map(sz, MAP_PRIVATE | MAP_ANONYMOUS | MAP_NORESERVE, -1);
-  }
-
-  inline size_t getSize(void *ATTRIBUTE_UNUSED ptr) const {
-    return 0;
-  }
-
-  inline void free(void *ATTRIBUTE_UNUSED ptr) {
-  }
-};
-
-}  // namespace mesh
-
-#endif  // MESH_ONE_WAY_MMAP_HEAP_H

data/ext/mesh/mesh/src/partitioned_heap.h

@@ -1,111 +0,0 @@
-// -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil -*-
-// Copyright 2019 The Mesh Authors. All rights reserved.
-// Use of this source code is governed by the Apache License,
-// Version 2.0, that can be found in the LICENSE file.
-
-#pragma once
-#ifndef MESH_PARTITIONED_HEAP_H
-#define MESH_PARTITIONED_HEAP_H
-
-// we can only include "common.h", as the partitioned heap is used as
-// the allocator-internal heap in "internal.h"
-#include "common.h"
-
-#include "cheap_heap.h"
-#include "one_way_mmap_heap.h"
-
-namespace mesh {
-
-static constexpr int kPartitionedHeapNBins = 16;
-static constexpr int kPartitionedHeapArenaSize = 512 * 1024 * 1024;  // 512 MB
-static constexpr int kPartitionedHeapSizePer = kPartitionedHeapArenaSize / kPartitionedHeapNBins;
-
-// Fast allocation for multiple size classes
-class PartitionedHeap : public OneWayMmapHeap {
-private:
-  DISALLOW_COPY_AND_ASSIGN(PartitionedHeap);
-  typedef OneWayMmapHeap SuperHeap;
-
-public:
-  PartitionedHeap() : SuperHeap() {
-    _smallArena = reinterpret_cast<char *>(SuperHeap::malloc(kPartitionedHeapArenaSize));
-    hard_assert(_smallArena != nullptr);
-    _smallArenaEnd = _smallArena + kPartitionedHeapArenaSize;
-
-    auto freelist = reinterpret_cast<char *>(SuperHeap::malloc(kPartitionedHeapArenaSize));
-    hard_assert(freelist != nullptr);
-
-    for (size_t i = 0; i < kPartitionedHeapNBins; ++i) {
-      auto arenaStart = _smallArena + i * kPartitionedHeapSizePer;
-      auto freelistStart = freelist + i * kPartitionedHeapSizePer;
-
-      const auto allocSize = powerOfTwo::ByteSizeForClass(i);
-      const auto maxCount = kPartitionedHeapSizePer / allocSize;
-
-      // mesh::debug("internal heap of allocSize %zu\n", allocSize);
-
-      _smallHeaps[i].init(allocSize, maxCount, arenaStart, reinterpret_cast<void **>(freelistStart));
-    }
-
-    // TODO: calc freelist + arena offsets
-  }
-
-  inline void *malloc(size_t sz) {
-    const auto sizeClass = powerOfTwo::ClassForByteSize(sz);
-
-    if (unlikely(sizeClass >= kPartitionedHeapNBins)) {
-      auto res = _bigHeap.malloc(sz);
-      // debug("internalHeap::malloc(%zu): %p (big)\n", sz, res);
-      return res;
-    }
-
-    auto res = _smallHeaps[sizeClass].alloc();
-    // debug("internalHeap::malloc(%zu): %p\n", sz, res);
-    return res;
-  }
-
-  inline void free(void *ptr) {
-    // debug("internalHeap::free(): %p\n", ptr);
-    if (unlikely(!contains(ptr))) {
-      _bigHeap.free(ptr);
-      return;
-    }
-
-    const auto sizeClass = getSizeClass(ptr);
-    d_assert(sizeClass >= 0);
-    d_assert(sizeClass < kPartitionedHeapNBins);
-
-    return _smallHeaps[sizeClass].free(ptr);
-  }
-
-  inline size_t getSize(void *ptr) {
-    if (unlikely(!contains(ptr))) {
-      return _bigHeap.getSize(ptr);
-    }
-
-    return powerOfTwo::ByteSizeForClass(getSizeClass(ptr));
-  }
-
-  // must be protected with a contains()
-  inline int getSizeClass(void *ptr) const {
-    const char *ptrval = reinterpret_cast<char *>(ptr);
-    const auto sizeClass = (ptrval - _smallArena) / kPartitionedHeapSizePer;
-    d_assert(sizeClass >= 0);
-    d_assert(sizeClass < kPartitionedHeapNBins);
-    return sizeClass;
-  }
-
-  inline bool contains(void *ptr) const {
-    const auto ptrval = reinterpret_cast<char *>(ptr);
-    return ptrval >= _smallArena && ptrval < _smallArenaEnd;
-  }
-
-private:
-  char *_smallArena{nullptr};
-  char *_smallArenaEnd{nullptr};
-  DynCheapHeap _smallHeaps[kPartitionedHeapNBins]{};
-  HL::MmapHeap _bigHeap{};
-};
-}  // namespace mesh
-
-#endif  // MESH_PARTITIONED_HEAP_H

data/ext/mesh/mesh/src/plasma/mesh.h

@@ -1,33 +0,0 @@
-// -*- mode: c; c-basic-offset: 2; indent-tabs-mode: nil -*-
-// Copyright 2019 The Mesh Authors. All rights reserved.
-// Use of this source code is governed by the Apache License,
-// Version 2.0, that can be found in the LICENSE file.
-
-#pragma once
-#ifndef PLASMA__MESH_H
-#define PLASMA__MESH_H
-
-#include <stddef.h>
-
-#define MESH_VERSION_MAJOR 1
-#define MESH_VERSION_MINOR 0
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-// Same API as je_mallctl, allows a program to query stats and set
-// allocator-related options.
-int mesh_mallctl(const char *name, void *oldp, size_t *oldlenp, void *newp, size_t newlen);
-
-// 0 if not in bounds, 1 if is.
-int mesh_in_bounds(void *ptr);
-
-// returns the usable size of an allocation
-size_t mesh_usable_size(void *ptr);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* PLASMA__MESH_H */

data/ext/mesh/mesh/src/real.cc

@@ -1,52 +0,0 @@
-// -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil -*-
-// Copyright 2019 The Mesh Authors. All rights reserved.
-// Use of this source code is governed by the Apache License,
-// Version 2.0, that can be found in the LICENSE file.
-
-#include <dlfcn.h>
-
-#include "real.h"
-
-#include "common.h"
-
-#define DEFINE_REAL(name) decltype(::name) *name
-#define INIT_REAL(name, handle)                                         \
-  do {                                                                  \
-    name = reinterpret_cast<decltype(::name) *>(dlsym(handle, #name));  \
-    hard_assert_msg(name != nullptr, "mesh::real: expected %s", #name); \
-  } while (false)
-
-namespace mesh {
-namespace real {
-#ifdef __linux__
-DEFINE_REAL(epoll_pwait);
-DEFINE_REAL(epoll_wait);
-#endif
-
-DEFINE_REAL(pthread_create);
-DEFINE_REAL(pthread_exit);
-
-DEFINE_REAL(sigaction);
-DEFINE_REAL(sigprocmask);
-
-void init() {
-  static mutex initLock;
-  static bool initialized;
-
-  lock_guard<mutex> lock(initLock);
-  if (initialized)
-    return;
-  initialized = true;
-#ifdef __linux__
-  INIT_REAL(epoll_pwait, RTLD_NEXT);
-  INIT_REAL(epoll_wait, RTLD_NEXT);
-#endif
-
-  INIT_REAL(pthread_create, RTLD_NEXT);
-  INIT_REAL(pthread_exit, RTLD_NEXT);
-
-  INIT_REAL(sigaction, RTLD_NEXT);
-  INIT_REAL(sigprocmask, RTLD_NEXT);
-}
-}  // namespace real
-}  // namespace mesh

data/ext/mesh/mesh/src/real.h

@@ -1,36 +0,0 @@
-// -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil -*-
-// Copyright 2019 The Mesh Authors. All rights reserved.
-// Use of this source code is governed by the Apache License,
-// Version 2.0, that can be found in the LICENSE file.
-
-#include <pthread.h>
-#include <signal.h>
-
-#ifdef __linux__
-#include <sys/epoll.h>
-#endif
-
-#pragma once
-#ifndef MESH_REAL_H
-#define MESH_REAL_H
-
-#define DECLARE_REAL(name) extern decltype(::name) *name
-
-namespace mesh {
-namespace real {
-void init();
-
-#ifdef __linux__
-DECLARE_REAL(epoll_pwait);
-DECLARE_REAL(epoll_wait);
-#endif
-
-DECLARE_REAL(pthread_create);
-DECLARE_REAL(pthread_exit);
-
-DECLARE_REAL(sigaction);
-DECLARE_REAL(sigprocmask);
-}  // namespace real
-}  // namespace mesh
-
-#endif  // MESH_REAL_H

data/ext/mesh/mesh/src/rng/mwc.h

@@ -1,296 +0,0 @@
-// -*- C++ -*-
-
-#ifndef MESH_MWC_H
-#define MESH_MWC_H
-
-#include "../common.h"
-//#include <assert.h>
-//#define d_assert assert
-
-#include "mwc64.h"
-// #include "sx.hh"
-
-/**
- * @class MWC
- * @brief A super-fast multiply-with-carry pseudo-random number generator.
- * @author Emery Berger <http://www.cs.umass.edu/~emery>
- * @note   Copyright (C) 2005-2011 by Emery Berger, University of Massachusetts Amherst.
- */
-
-class RealMWC {
-public:
-  explicit RealMWC(unsigned int seed1, unsigned int seed2) : z(seed1), w(seed2) {
-    d_assert(seed1 != 0);
-    d_assert(seed2 != 0);
-    // debug("MWC seed1: %u seed2: %u\n", seed1, seed2);
-  }
-
-  inline unsigned int next(void) {
-    d_assert(w != 0);
-    d_assert(z != 0);
-    // These magic numbers are derived from a note by George Marsaglia.
-    unsigned int znew = 36969 * (z & 65535) + (z >> 16);
-    unsigned int wnew = 18000 * (w & 65535) + (w >> 16);
-    unsigned int x = (znew << 16) + wnew;
-    // debug("MWC: %8x\n", x);
-    d_assert(wnew != 0);
-    d_assert(znew != 0);
-    w = wnew;
-    z = znew;
-    return x;
-  }
-
-private:
-  unsigned int z;
-  unsigned int w;
-};
-
-class MWC : public MWC64 {
-public:
-  MWC(uint64_t s1, uint64_t s2) : MWC64::MWC64(s1, s2) {
-  }
-  // returns a number between min and max (inclusive)
-  inline unsigned int ATTRIBUTE_ALWAYS_INLINE inRange(size_t min, size_t max) {
-    size_t range = 1 + max - min;
-
-    //    return min + next() % range;
-    // adapted from https://lemire.me/blog/2016/06/27/a-fast-alternative-to-the-modulo-reduction/
-    return min + (((uint64_t)(uint32_t)next() * (uint64_t)range) >> 32);
-  }
-};
-
-#endif
-
-#if 0
-
-#include <stdio.h>
-#define znew (z = 36969 * (z & 65535) + (z >> 16))
-#define wnew (w = 18000 * (w & 65535) + (w >> 16))
-#define MWC ((znew << 16) + wnew)
-#define SHR3 (jsr ^= (jsr << 17), jsr ^= (jsr >> 13), jsr ^= (jsr << 5))
-#define CONG (jcong = 69069 * jcong + 1234567)
-#define FIB ((b = a + b), (a = b - a))
-#define KISS ((MWC ^ CONG) + SHR3)
-#define LFIB4 (c++, t[c] = t[c] + t[UC(c + 58)] + t[UC(c + 119)] + t[UC(c + 178)])
-#define SWB (c++, bro = (x < y), t[c] = (x = t[UC(c + 34)]) - (y = t[UC(c + 19)] + bro))
-#define UNI (KISS * 2.328306e-10)
-#define VNI ((int)KISS) * 4.656613e-10
-#define UC (unsigned char)/*a cast operation*/
-typedef unsigned int UL;
-
-/*  Global static variables: */
-static UL z = 362436069, w = 521288629, jsr = 123456789, jcong = 380116160;
-static UL a = 224466889, b = 7584631, t[256];
-/* Use random seeds to reset z,w,jsr,jcong,a,b, and the table t[256]*/
-
-static UL x = 0, y = 0, bro;
-static unsigned char c = 0;
-
-/* Example procedure to set the table, using KISS: */
-void settable(UL i1, UL i2, UL i3, UL i4, UL i5, UL i6) {
-  int i;
-  z = i1;
-  w = i2, jsr = i3;
-  jcong = i4;
-  a = i5;
-  b = i6;
-  for (i = 0; i < 256; i = i + 1)
-    t[i] = KISS;
-}
-
-/* This is a test main program.  It should compile and print 7  0's. */
-int main(void) {
-  int i;
-  UL k;
-  settable(12345, 65435, 34221, 12345, 9983651, 95746118);
-
-  for (i = 1; i < 1000001; i++) {
-    k = LFIB4;
-  }
-  printf("%u\n", k - 1064612766U);
-  for (i = 1; i < 1000001; i++) {
-    k = SWB;
-  }
-  printf("%u\n", k - 627749721U);
-  for (i = 1; i < 1000001; i++) {
-    k = KISS;
-  }
-  printf("%u\n", k - 1372460312U);
-  for (i = 1; i < 1000001; i++) {
-    k = CONG;
-  }
-  printf("%u\n", k - 1529210297U);
-  for (i = 1; i < 1000001; i++) {
-    k = SHR3;
-  }
-  printf("%u\n", k - 2642725982U);
-  for (i = 1; i < 1000001; i++) {
-    k = MWC;
-  }
-  printf("%u\n", k - 904977562U);
-  for (i = 1; i < 1000001; i++) {
-    k = FIB;
-  }
-  printf("%u\n", k - 3519793928U);
-}
-
-/*-----------------------------------------------------
-   Write your own calling program and try one or more of
-   the above, singly or in combination, when you run a
-   simulation. You may want to change the simple 1-letter
-   names, to avoid conflict with your own choices.        */
-
-/* All that follows is comment, mostly from the initial
-   post. You may want to remove it */
-
-/* Any one of KISS, MWC, FIB, LFIB4, SWB, SHR3, or CONG
-   can be used in an expression to provide a random 32-bit
-   integer.
-
-
-   The KISS generator, (Keep It Simple Stupid), is
-   designed to combine the two multiply-with-carry
-   generators in MWC with the 3-shift register SHR3 and
-   the congruential generator CONG, using addition and
-   exclusive-or. Period about 2^123.
-   It is one of my favorite generators.
-
-
-   The  MWC generator concatenates two 16-bit multiply-
-   with-carry generators, x(n)=36969x(n-1)+carry,
-   y(n)=18000y(n-1)+carry  mod 2^16, has period about
-   2^60 and seems to pass all tests of randomness. A
-   favorite stand-alone generator---faster than KISS,
-   which contains it.
-
-
-   FIB is the classical Fibonacci sequence
-   x(n)=x(n-1)+x(n-2),but taken modulo 2^32.
-   Its period is 3*2^31 if one of its two seeds is odd
-   and not 1 mod 8. It has little worth as a RNG by
-   itself, but provides a simple and fast component for
-   use in combination generators.
-
-
-   SHR3 is a 3-shift-register generator with period
-   2^32-1. It uses y(n)=y(n-1)(I+L^17)(I+R^13)(I+L^5),
-   with the y's viewed as binary vectors, L the 32x32
-   binary matrix that shifts a vector left 1, and R its
-   transpose.  SHR3 seems to pass all except those
-   related to the binary rank test, since 32 successive
-   values, as binary vectors, must be linearly
-   independent, while 32 successive truly random 32-bit
-   integers, viewed as binary vectors, will be linearly
-   independent only about 29% of the time.
-
-
-   CONG is a congruential generator with the widely used 69069
-   multiplier: x(n)=69069x(n-1)+1234567.  It has period
-   2^32. The leading half of its 32 bits seem to pass
-   tests, but bits in the last half are too regular.
-
-
-   LFIB4 is an extension of what I have previously
-   defined as a lagged Fibonacci generator:
-   x(n)=x(n-r) op x(n-s), with the x's in a finite
-   set over which there is a binary operation op, such
-   as +,- on integers mod 2^32, * on odd such integers,
-   exclusive-or(xor) on binary vectors. Except for
-   those using multiplication, lagged Fibonacci
-   generators fail various tests of randomness, unless
-   the lags are very long. (See SWB below).
-   To see if more than two lags would serve to overcome
-   the problems of 2-lag generators using +,- or xor, I
-   have developed the 4-lag generator LFIB4 using
-   addition: x(n)=x(n-256)+x(n-179)+x(n-119)+x(n-55)
-   mod 2^32. Its period is 2^31*(2^256-1), about 2^287,
-   and it seems to pass all tests---in particular,
-   those of the kind for which 2-lag generators using
-   +,-,xor seem to fail.  For even more confidence in
-   its suitability,  LFIB4 can be combined with KISS,
-   with a resulting period of about 2^410: just use
-   (KISS+LFIB4) in any C expression.
-
-
-   SWB is a subtract-with-borrow generator that I
-   developed to give a simple method for producing
-   extremely long periods:
-      x(n)=x(n-222)-x(n-237)- borrow mod 2^32.
-   The 'borrow' is 0, or set to 1 if computing x(n-1)
-   caused overflow in 32-bit integer arithmetic. This
-   generator has a very long period, 2^7098(2^480-1),
-   about 2^7578.   It seems to pass all tests of
-   randomness, except for the Birthday Spacings test,
-   which it fails badly, as do all lagged Fibonacci
-   generators using +,- or xor. I would suggest
-   combining SWB with KISS, MWC, SHR3, or CONG.
-   KISS+SWB has period >2^7700 and is highly
-   recommended.
-   Subtract-with-borrow has the same local behaviour
-   as lagged Fibonacci using +,-,xor---the borrow
-   merely provides a much longer period.
-   SWB fails the birthday spacings test, as do all
-   lagged Fibonacci and other generators that merely
-   combine two previous values by means of =,- or xor.
-   Those failures are for a particular case: m=512
-   birthdays in a year of n=2^24 days. There are
-   choices of m and n for which lags >1000 will also
-   fail the test.  A reasonable precaution is to always
-   combine a 2-lag Fibonacci or SWB generator with
-   another kind of generator, unless the generator uses
-   *, for which a very satisfactory sequence of odd
-   32-bit integers results.
-
-
-   The classical Fibonacci sequence mod 2^32 from FIB
-   fails several tests.  It is not suitable for use by
-   itself, but is quite suitable for combining with
-   other generators.
-
-
-   The last half of the bits of CONG are too regular,
-   and it fails tests for which those bits play a
-   significant role. CONG+FIB will also have too much
-   regularity in trailing bits, as each does. But keep
-   in mind that it is a rare application for which
-   the trailing bits play a significant role.  CONG
-   is one of the most widely used generators of the
-   last 30 years, as it was the system generator for
-   VAX and was incorporated in several popular
-   software packages, all seemingly without complaint.
-
-
-   Finally, because many simulations call for uniform
-   random variables in 0<x<1 or -1<x<1, I use #define
-   statements that permit inclusion of such variates
-   directly in expressions:  using UNI will provide a
-   uniform random real (float) in (0,1), while VNI will
-   provide one in (-1,1).
-
-
-   All of these: MWC, SHR3, CONG, KISS, LFIB4, SWB, FIB
-   UNI and VNI, permit direct insertion of the desired
-   random quantity into an expression, avoiding the
-   time and space costs of a function call. I call
-   these in-line-define functions.  To use them, static
-   variables z,w,jsr,jcong,a and b should be assigned
-   seed values other than their initial values.  If
-   LFIB4 or SWB are used, the static table t[256] must
-   be initialized.
-
-
-   A note on timing:  It is difficult to provide exact
-   time costs for inclusion of one of these in-line-
-   define functions in an expression.  Times may differ
-   widely for different compilers, as the C operations
-   may be deeply nested and tricky. I suggest these
-   rough comparisons, based on averaging ten runs of a
-   routine that is essentially a long loop:
-   for(i=1;i<10000000;i++) L=KISS; then with KISS
-   replaced with SHR3, CONG,... or KISS+SWB, etc. The
-   times on my home PC, a Pentium 300MHz, in nanoseconds:
-   FIB 49;LFIB4 77;SWB 80;CONG 80;SHR3 84;MWC 93;KISS 157;
-   VNI 417;UNI 450;
- */
-
-#endif