RequestGenerator.cpp

Go to the documentation of this file.

 
#include "RequestGenerator.h"
 
#include <algorithm>
#include <cmath>
 
namespace {
constexpr std::size_t kSampleCount = 10;
}
 
RequestGenerator::RequestGenerator(const GeneratorSettings& settings, std::uint32_t seed)
    : settings_(settings),
      seed_(seed),
      engine_(seed),
      taskCycles_(settings.minTaskCycles, settings.maxTaskCycles),
      octet_(0, 255),
      firstOctet_(1, 223),
      hostOctet_(1, 254),
      streaming_(settings.streamingShare) {}
 
double RequestGenerator::rateAt(unsigned long cycle) const {
    if (settings_.wavePeriod == 0 || settings_.waveAmplitude == 0.0) {
        return settings_.arrivalRate;
    }
    const double pi = std::acos(-1.0);
    const double phase = 2.0 * pi * static_cast<double>(cycle % settings_.wavePeriod) / settings_.wavePeriod;
    return std::max(0.0, settings_.arrivalRate * (1.0 + settings_.waveAmplitude * std::sin(phase)));
}
 
std::string RequestGenerator::randomIp() {
    unsigned int first = firstOctet_(engine_);
    while (first == 127) {  // skip the loopback network
        first = firstOctet_(engine_);
    }
    return std::to_string(first) + "." + std::to_string(octet_(engine_)) + "." +
           std::to_string(octet_(engine_)) + "." + std::to_string(hostOctet_(engine_));
}
 
Request RequestGenerator::makeRequest(unsigned long cycle) {
    Request request;
    request.id = nextId_++;
    request.sourceIp = randomIp();
    request.destinationIp = randomIp();
    request.taskCycles = taskCycles_(engine_);
    request.arrivalCycle = cycle;
    request.jobType = streaming_(engine_) ? JobType::Streaming : JobType::Processing;
    record(request);
    return request;
}
 
std::vector<Request> RequestGenerator::makeInitialBatch(std::size_t count, unsigned long cycle) {
    std::vector<Request> batch;
    batch.reserve(count);
    for (std::size_t i = 0; i < count; ++i) {
        batch.push_back(makeRequest(cycle));
    }
    stats_.initial += count;
    return batch;
}
 
std::vector<Request> RequestGenerator::arrivalsFor(unsigned long cycle) {
    const double rate = rateAt(cycle);
    unsigned int count = 0;
    if (rate > 0.0) {  // a Poisson mean must be positive
        arrivals_.param(std::poisson_distribution<unsigned int>::param_type(rate));
        count = arrivals_(engine_);
    }
    stats_.arrivalHistogram[std::min<std::size_t>(count, GeneratorStats::kArrivalBins - 1)]++;
    stats_.maxArrivalsInCycle = std::max<unsigned long>(stats_.maxArrivalsInCycle, count);
    std::vector<Request> batch;
    batch.reserve(count);
    for (unsigned int i = 0; i < count; ++i) {
        batch.push_back(makeRequest(cycle));
    }
    return batch;
}
 
void RequestGenerator::record(const Request& request) {
    if (stats_.total == 0) {
        stats_.minTaskSeen = request.taskCycles;
        stats_.maxTaskSeen = request.taskCycles;
    }
    ++stats_.total;
    if (request.jobType == JobType::Streaming) {
        ++stats_.streaming;
    } else {
        ++stats_.processing;
    }
    stats_.minTaskSeen = std::min(stats_.minTaskSeen, request.taskCycles);
    stats_.maxTaskSeen = std::max(stats_.maxTaskSeen, request.taskCycles);
    stats_.taskCycleSum += request.taskCycles;
 
    const unsigned long span = settings_.maxTaskCycles - settings_.minTaskCycles + 1UL;
    const unsigned long offset = request.taskCycles - settings_.minTaskCycles;
    stats_.taskHistogram[offset * GeneratorStats::kTaskBins / span]++;
 
    if (samples_.size() < kSampleCount) {
        samples_.push_back(request);
    }
}
 
const GeneratorSettings& RequestGenerator::settings() const {
    return settings_;
}
 
const GeneratorStats& RequestGenerator::stats() const {
    return stats_;
}
 
std::uint32_t RequestGenerator::seed() const {
    return seed_;
}
 
const std::vector<Request>& RequestGenerator::samples() const {
    return samples_;
}