android / platform / external / chromium_org / v8 / ac35710 / . / src / utils / random-number-generator.h

// Copyright 2013 the V8 project authors. All rights reserved. | |

// Use of this source code is governed by a BSD-style license that can be | |

// found in the LICENSE file. | |

#ifndef V8_UTILS_RANDOM_NUMBER_GENERATOR_H_ | |

#define V8_UTILS_RANDOM_NUMBER_GENERATOR_H_ | |

#include "src/base/macros.h" | |

namespace v8 { | |

namespace internal { | |

// ----------------------------------------------------------------------------- | |

// RandomNumberGenerator | |

// | |

// This class is used to generate a stream of pseudorandom numbers. The class | |

// uses a 48-bit seed, which is modified using a linear congruential formula. | |

// (See Donald Knuth, The Art of Computer Programming, Volume 3, Section 3.2.1.) | |

// If two instances of RandomNumberGenerator are created with the same seed, and | |

// the same sequence of method calls is made for each, they will generate and | |

// return identical sequences of numbers. | |

// This class uses (probably) weak entropy by default, but it's sufficient, | |

// because it is the responsibility of the embedder to install an entropy source | |

// using v8::V8::SetEntropySource(), which provides reasonable entropy, see: | |

// https://code.google.com/p/v8/issues/detail?id=2905 | |

// This class is neither reentrant nor threadsafe. | |

class RandomNumberGenerator V8_FINAL { | |

public: | |

// EntropySource is used as a callback function when V8 needs a source of | |

// entropy. | |

typedef bool (*EntropySource)(unsigned char* buffer, size_t buflen); | |

static void SetEntropySource(EntropySource entropy_source); | |

RandomNumberGenerator(); | |

explicit RandomNumberGenerator(int64_t seed) { SetSeed(seed); } | |

// Returns the next pseudorandom, uniformly distributed int value from this | |

// random number generator's sequence. The general contract of |NextInt()| is | |

// that one int value is pseudorandomly generated and returned. | |

// All 2^32 possible integer values are produced with (approximately) equal | |

// probability. | |

V8_INLINE int NextInt() V8_WARN_UNUSED_RESULT { | |

return Next(32); | |

} | |

// Returns a pseudorandom, uniformly distributed int value between 0 | |

// (inclusive) and the specified max value (exclusive), drawn from this random | |

// number generator's sequence. The general contract of |NextInt(int)| is that | |

// one int value in the specified range is pseudorandomly generated and | |

// returned. All max possible int values are produced with (approximately) | |

// equal probability. | |

int NextInt(int max) V8_WARN_UNUSED_RESULT; | |

// Returns the next pseudorandom, uniformly distributed boolean value from | |

// this random number generator's sequence. The general contract of | |

// |NextBoolean()| is that one boolean value is pseudorandomly generated and | |

// returned. The values true and false are produced with (approximately) equal | |

// probability. | |

V8_INLINE bool NextBool() V8_WARN_UNUSED_RESULT { | |

return Next(1) != 0; | |

} | |

// Returns the next pseudorandom, uniformly distributed double value between | |

// 0.0 and 1.0 from this random number generator's sequence. | |

// The general contract of |NextDouble()| is that one double value, chosen | |

// (approximately) uniformly from the range 0.0 (inclusive) to 1.0 | |

// (exclusive), is pseudorandomly generated and returned. | |

double NextDouble() V8_WARN_UNUSED_RESULT; | |

// Fills the elements of a specified array of bytes with random numbers. | |

void NextBytes(void* buffer, size_t buflen); | |

private: | |

static const int64_t kMultiplier = V8_2PART_UINT64_C(0x5, deece66d); | |

static const int64_t kAddend = 0xb; | |

static const int64_t kMask = V8_2PART_UINT64_C(0xffff, ffffffff); | |

int Next(int bits) V8_WARN_UNUSED_RESULT; | |

void SetSeed(int64_t seed); | |

int64_t seed_; | |

}; | |

} } // namespace v8::internal | |

#endif // V8_UTILS_RANDOM_NUMBER_GENERATOR_H_ |