generator

type AcknowledgedCounterGenerator ¶

type AcknowledgedCounterGenerator struct {
	*CounterGenerator
	// contains filtered or unexported fields
}

A CounterGenerator that reports generated integers via LastInt() only after they have been acknowledged.

func NewAcknowledgedCounterGenerator(startCount int64) *AcknowledgedCounterGenerator

func (self *AcknowledgedCounterGenerator) Acknowledge(value int64)

func (self *AcknowledgedCounterGenerator) LastInt() int64

func (self *AcknowledgedCounterGenerator) LastString() string

type ConstantIntegerGenerator ¶

type ConstantIntegerGenerator struct {
	*IntegerGeneratorBase
	// contains filtered or unexported fields
}

ConstantIntegerGenerator is a trivial integer generator that always returns the same value.

func NewConstantIntegerGenerator(i int64) *ConstantIntegerGenerator

func (self *ConstantIntegerGenerator) Mean() float64

func (self *ConstantIntegerGenerator) NextInt() int64

func (self *ConstantIntegerGenerator) NextString() string

type CounterGenerator ¶

type CounterGenerator struct {
	*IntegerGeneratorBase
	// contains filtered or unexported fields
}

Generates a sequence of integers 0, 1, ...

func NewCounterGenerator(startCount int64) *CounterGenerator

func (self *CounterGenerator) Mean() float64

func (self *CounterGenerator) NextInt() int64

func (self *CounterGenerator) NextString() string

type DiscreteGenerator ¶

type DiscreteGenerator struct {
	// contains filtered or unexported fields
}

Generates a distribution by choosing from a discrete set of values.

func NewDiscreteGenerator() *DiscreteGenerator

func (self *DiscreteGenerator) AddValue(weight float64, value string)

func (self *DiscreteGenerator) LastString() string

func (self *DiscreteGenerator) NextString() string

type ExponentialGenerator ¶

type ExponentialGenerator struct {
	*IntegerGeneratorBase
	// contains filtered or unexported fields
}

A generator of an Exponential distribution. It produces a sequence of time intervals(integers) according to an exponential distribution. Smaller intervals are more frequent than larger ones, and there is no bound on the length of an interval. When you construct an instance of this class, you specify a parameter gamma, which corresponds to the rate at which events occur. Alternatively, 1/gamma is the average length of an interval.

func NewExponentialGenerator(percentile, theRange float64) *ExponentialGenerator

func NewExponentialGeneratorByMean(mean float64) *ExponentialGenerator

func (self *ExponentialGenerator) Mean() float64

func (self *ExponentialGenerator) NextInt() int64

func (self *ExponentialGenerator) NextString() string

type FileGenerator ¶

type FileGenerator struct {
	// contains filtered or unexported fields
}

A generator, whose sequence is the lines of a file.

func NewFileGenerator(filename string) (*FileGenerator, error)

func (self *FileGenerator) Close() error

func (self *FileGenerator) LastString() string

func (self *FileGenerator) NextString() string

func (self *FileGenerator) ReloadFile() error

type Generator ¶

type Generator interface {

	// NextString generates the next string in the distribution.
	NextString() string

	// LastString returns the previous string generated by the distribution;
	// e.g., returned from the last NextString() call.
	// Calling LastString() should not advance the distribution or
	// have any side effects. If NextString() has not yet been called,
	// LastString() should return something reasonable.
	LastString() string
}

Generator defines the interface that generates a sequence of string values, following some distribution (Uniform, Zipfian, Sequential, etc.)

type HistogramGenerator ¶

type HistogramGenerator struct {
	*IntegerGeneratorBase
	// contains filtered or unexported fields
}

Generate integers according to a histogram distribution. The histogram buckets are of width one, but the values are multiplied by a block size. Therefore, instead of drawing sizes uniformly at random within each bucket, we always draw the largest value in the current bucket, so the value drawn is always a multiple of blockSize. The minimum value this distribution returns is blockSize(not zero).

func NewHistogramGenerator(buckets []int64, blockSize int64) *HistogramGenerator

func NewHistogramGeneratorFromFile(file string) (*HistogramGenerator, error)

func (self *HistogramGenerator) Mean() float64

func (self *HistogramGenerator) NextInt() int64

func (self *HistogramGenerator) NextString() string

type HotspotIntegerGenerator ¶

type HotspotIntegerGenerator struct {
	*IntegerGeneratorBase
	// contains filtered or unexported fields
}

Generate integers resembling a hotspot distribution where x% of operations access y% of data items. The parameters specify the bounds for the numbers, the percentage of the interval which comprises the hot set and the percentage of operations that access the hot set. Numbers of the host set are always smaller than any number in the cold set. Elements from the hot set and the cold set are chosen using a uniform distribution.

func NewHotspotIntegerGenerator(
	lowerBound, upperBound int64,
	hotsetFraction, hotOpnFraction float64) *HotspotIntegerGenerator

func (self *HotspotIntegerGenerator) GetHotOpnFraction() float64

func (self *HotspotIntegerGenerator) GetHotsetFraction() float64

func (self *HotspotIntegerGenerator) GetLowerBound() int64

func (self *HotspotIntegerGenerator) GetUpperBound() int64

func (self *HotspotIntegerGenerator) Mean() float64

func (self *HotspotIntegerGenerator) NextInt() int64

func (self *HotspotIntegerGenerator) NextString() string

type IntegerGenerator ¶

type IntegerGenerator interface {
	Generator
	// NextInt returns the next value as an int. When overriding this method,
	// be sure to call setLastString() properly, or the LastString() call
	// won't work.
	NextInt() int64

	// LastInt returns the previous int generated by the distribution.
	// This call is unique to IntegerGenerator implementation struct, and
	// assumes all implementation of this interface always return ints for
	// NextInt (e.g. not arbitrary values).
	LastInt() int64

	// Mean returns the expected value(mean) of the values this generator will
	// return.
	Mean() float64
}

IntegerGenerator is a generator capable of generating integers and strings.

type IntegerGeneratorBase ¶

type IntegerGeneratorBase struct {
	// contains filtered or unexported fields
}

IntegerGeneratorBase is a parent class for all IntegerGenerator subclasses.

func NewIntegerGeneratorBase(last int64) *IntegerGeneratorBase

func (self *IntegerGeneratorBase) LastInt() int64

func (self *IntegerGeneratorBase) LastString() string

func (self *IntegerGeneratorBase) NextString(g IntegerGenerator) string

func (self *IntegerGeneratorBase) SetLastInt(value int64)

type Pair ¶

type Pair struct {
	Weight float64
	Value  string
}

type ScrambledZipfianGenerator ¶

type ScrambledZipfianGenerator struct {
	*IntegerGeneratorBase
	// contains filtered or unexported fields
}

A generator of a zipfian distribution. It produces a sequence of items, such that some items are more popular than others, according to a zipfian distribution. When you construct an instance of this class, you specify the number of items in the set to draw from, either by specifying an itemCount(so that the sequence is of items from 0 to itemCount-1) or by specifying a min and a max (so that the sequence is of items from min to max inclusive). After you construct the instance, you can change the number of items by calling NextInt(itemCount) or Next(itemCount). Unlike ZipfianGenerator, this class scatters the "popular" items across the item space. Use this, instead of ZipfianGenerator, if you don't want the head of the distribution(the popular items) clustered together.

func NewScrambledZipfianGenerator(min, max int64) *ScrambledZipfianGenerator

func NewScrambledZipfianGeneratorByItems(items int64) *ScrambledZipfianGenerator

func NewScrambledZipfianGeneratorConstant(min, max int64, constant float64) *ScrambledZipfianGenerator

func (self *ScrambledZipfianGenerator) Mean() float64

func (self *ScrambledZipfianGenerator) Next() int64

func (self *ScrambledZipfianGenerator) NextInt() int64

func (self *ScrambledZipfianGenerator) NextString() string

type SkewedLatestGenerator ¶

type SkewedLatestGenerator struct {
	*IntegerGeneratorBase
	// contains filtered or unexported fields
}

Generate a popularity distribution of items, skewed to favor recent items significantly more than older items.

func NewSkewedLatestGenerator(basis *CounterGenerator) *SkewedLatestGenerator

func (self *SkewedLatestGenerator) Mean() float64

func (self *SkewedLatestGenerator) NextInt() int64

func (self *SkewedLatestGenerator) NextString() string

type UniformGenerator ¶

type UniformGenerator struct {
	// contains filtered or unexported fields
}

An expression that generates a random integer in the specified range.

func NewUniformGenerator(values []string) *UniformGenerator

func (self *UniformGenerator) LastString() string

func (self *UniformGenerator) NextString() string

type UniformIntegerGenerator ¶

type UniformIntegerGenerator struct {
	*IntegerGeneratorBase
	// contains filtered or unexported fields
}

Generate integers randomly uniform from an interval.

func NewUniformIntegerGenerator(lowerBound, upperBound int64) *UniformIntegerGenerator

func (self *UniformIntegerGenerator) Mean() float64

func (self *UniformIntegerGenerator) NextInt() int64

func (self *UniformIntegerGenerator) NextString() string

type ZipfianGenerator ¶

type ZipfianGenerator struct {
	*IntegerGeneratorBase
	// contains filtered or unexported fields
}

A generator of a zipfian distribution. It produces a sequence of items, such that some items are more popular than others, according to a zipfian distribution. When you construct an instance of this class, you specify the number of items in the set to draw from, either by specifying an itemcount (so that the sequence is of items from 0 to itemcount-1) or by specifying a min and a max (so that the sequence is of items from min to max inclusive). After you construct the instance, you can change the number of items by calling NextInt() or nextLong().

Note that the popular items will be clustered together, e.g. item 0 is the most popular, item 1 the second most popular, and so on (or min is the most popular, min+1 the next most popular, etc.) If you don't want this clustering, and instead want the popular items scattered throughout the item space, then use ScrambledZipfianGenerator instead.

Be aware: initializing this generator may take a long time if there are lots of items to choose from (e.g. over a minute for 100 million objects). This is because certain mathematical values need to be computed to properly generate a zipfian skew, and one of those values (zeta) is a sum sequence from 1 to n, where n is the itemCount. Note that if you increase the number of items in the set, we can compute a new zeta incrementally, so it should be fast unless you have added millions of items. However, if you decrease the number of items, we recompute zeta from scratch, so this can take a long time.

The algorithm used here is from "Quickly Generating Billion-Record Synthetic Databases", Jim Gray et al, SIGMOD 1994.

func NewZipfianGenerator(
	min, max int64, zipfianConstant, zetan float64) *ZipfianGenerator

func NewZipfianGeneratorByInterval(min, max int64) *ZipfianGenerator

func (self *ZipfianGenerator) Mean() float64

func (self *ZipfianGenerator) Next(itemCount int64) int64

func (self *ZipfianGenerator) NextInt() int64

func (self *ZipfianGenerator) NextLong() int64

func (self *ZipfianGenerator) NextString() string