std::function<int64_t(int64_t base, int64_t offset)> getTimestamp_)

: getTimestamp(getTimestamp_),

getRealtimeBase(getRealtimeBase_)

{

getRealtimeBase(realTimeBase, initialTimeOffset);

{

int position = lastInsertedState.load(std::memory_order_relaxed);

// Process the commands in the order we have just computed.

while (position < DataProcessingStates::STATES_BUFFER_SIZE) {

DataProcessingStates::CommandHeader header;

// Avoid alignment issues.

memcpy(&header, &store[position], sizeof(DataProcessingStates::CommandHeader));

int id = header.id;

int64_t timestamp = header.timestamp;

int size = header.size;

assert(id < updateInfos.size());

auto& update = updateInfos[id];

// We need to update only once per invoked callback,

// because the metrics are stored in reverse insertion order.

if (generation > update.generation) {

// If we have enough capacity, we reuse the buffer.

// If the size is the same, we mark it as updated only if different.

if (statesViews[id].size == size) {

int diff = memcmp(statesBuffer.data() + statesViews[id].first, &store[position + sizeof(DataProcessingStates::CommandHeader)], size);

if (diff) {

memcpy(statesBuffer.data() + statesViews[id].first, &store[position + sizeof(DataProcessingStates::CommandHeader)], size);

updated[id] = true;

update.timestamp = timestamp;

update.generation = generation;

pushedMetricsLapse++;

}

} else if (statesViews[id].capacity >= size) {

memcpy(statesBuffer.data() + statesViews[id].first, &store[position + sizeof(DataProcessingStates::CommandHeader)], size);

statesViews[id].size = size;

updated[id] = true;

update.timestamp = timestamp;

update.generation = generation;

pushedMetricsLapse++;

} else if (statesViews[id].capacity < size) {

// Otherwise we need to reallocate.

int newCapacity = std::max(size, 64);

int first = statesBuffer.size();

statesBuffer.resize(statesBuffer.size() + newCapacity);

assert(first < statesBuffer.size());

memcpy(statesBuffer.data() + first, &store[position + sizeof(DataProcessingStates::CommandHeader)], size);

statesViews[id].first = first;

statesViews[id].size = size;

statesViews[id].capacity = newCapacity;

updated[id] = true;

update.timestamp = timestamp;

update.generation = generation;

pushedMetricsLapse++;

}

}

position += sizeof(DataProcessingStates::CommandHeader) + header.size;

}

assert(position == DataProcessingStates::STATES_BUFFER_SIZE);

// We reset the queue. Once again, the queue is filled in reverse order.

nextState.store(STATES_BUFFER_SIZE, std::memory_order_relaxed);

lastInsertedState.store(STATES_BUFFER_SIZE, std::memory_order_relaxed);

generation++;

{

LOGP(debug, "Updating state {} with {}", cmd.id, std::string_view(cmd.data, cmd.size));

if (stateSpecs[cmd.id].name.empty()) {

throw runtime_error_f("StateID %d was not registered", (int)cmd.id);

}

if (cmd.id >= stateNames.size()) {

throw runtime_error_f("StateID %d is out of range", (int)cmd.id);

}

if (cmd.id >= updateInfos.size()) {

throw runtime_error_f("MetricID %d is out of range", (int)cmd.id);

}

// Do not update currently disabled states

if (enabled[cmd.id] == false) {

return;

}

pendingStates++;

// Add a static mutex to protect the queue

// Get the next available operation in an atomic way.

int size = sizeof(CommandHeader) + cmd.size;

if (size > 16384) {

throw runtime_error_f("State size is %d for state %s. States larger than 16384 bytes not supported for now.",

size, stateSpecs[cmd.id].name.c_str());

}

int idx = nextState.fetch_sub(size, std::memory_order_relaxed);

if (idx - size < 0) {

// We abort this command

pendingStates--;

while (pendingStates.load(std::memory_order_relaxed) > 0) {

// We need to wait for all the pending commands to be processed.

// This is needed because we are going to flush the queue.

// We cannot flush the queue while there are pending commands

// as we might end up with a command being processed twice.

std::this_thread::sleep_for(std::chrono::milliseconds(1));

}

processCommandQueue();

lastInsertedState.store(STATES_BUFFER_SIZE, std::memory_order_relaxed);

nextState.store(STATES_BUFFER_SIZE, std::memory_order_relaxed);

pendingStates++;

idx = nextState.fetch_sub(size, std::memory_order_relaxed);

} else if (idx < 0) {

while (idx < 0) {

// We need to wait for the flushing of the queue

std::this_thread::sleep_for(std::chrono::milliseconds(1));

idx = nextState.load(std::memory_order_relaxed);

}

return updateState(cmd);

}

// Save the state in the queue

assert(idx >= 0);

assert(cmd.id < statesViews.size());

int64_t timestamp = getTimestamp(realTimeBase, initialTimeOffset);

// We also write starting from idx - size, because we know this is

// reserved for us.

idx -= size;

CommandHeader header{(short)cmd.id, cmd.size, timestamp};

assert(idx >= 0);

assert(idx + sizeof(CommandHeader) + cmd.size <= store.size());

memcpy(&store.data()[idx], &header, sizeof(CommandHeader));

memcpy(&store.data()[idx + sizeof(CommandHeader)], cmd.data, cmd.size);

lastInsertedState = idx;

pendingStates--;

// Keep track of the number of commands we have received.

updatedMetricsLapse++;

{

publishingInvokedTotal++;

bool publish = false;

auto currentTimestamp = getTimestamp(realTimeBase, initialTimeOffset);

for (auto mi : registeredStates) {

auto& update = updateInfos[mi];

auto& spec = stateSpecs[mi];

auto& view = statesViews[mi];

if (updated[mi] == false && (currentTimestamp - update.timestamp) > spec.maxRefreshLatency) {

updated[mi] = true;

update.timestamp = currentTimestamp;

}

if (updated[mi] == false) {

continue;

}

int64_t delayPublished = (currentTimestamp - update.lastPublished);

assert(delayPublished >= 0);

if (delayPublished < spec.minPublishInterval) {

continue;

}

publish = true;

assert(view.first + view.size <= statesBuffer.size());

assert(view.first <= statesBuffer.size());

auto msg = std::string_view(statesBuffer.data() + view.first, view.size);

callback(spec.name.data(), update.timestamp, msg);

publishedMetricsLapse++;

update.lastPublished = currentTimestamp;

updated[mi] = false;

}

if (publish) {

publishingDoneTotal++;

}

static int64_t startTime = uv_hrtime();

int64_t now = uv_hrtime();

double averageInvocations = (publishingInvokedTotal * 1000000000) / (now - startTime);

double averagePublishing = (publishedMetricsLapse * 1000000000) / (now - startTime);

LOGP(debug, "Publishing invoked {} times / s, {} metrics published / s", (int)averageInvocations, (int)averagePublishing);

{

// Everytime we publish, we repack the states buffer so that we can minimize the

// amount of memory me use.

std::array<int, MAX_STATES> order;

std::iota(order.begin(), order.end(), 0);

std::stable_sort(order.begin(), order.begin() + statesViews.size(), [&](int a, int b) {

return statesViews[a].first < statesViews[b].first;

});

int position = 0;

for (size_t i = 0; i < order.size(); ++i) {

auto& view = statesViews[order[i]];

// If we have no size, we do not need to move anything.

if (view.size == 0) {

continue;

}

// If we are already in the correct place, do nothing.

if (view.first == position) {

continue;

}

memcpy(statesBuffer.data() + position, statesBuffer.data() + view.first, view.size);

view.first = position;

view.capacity = view.size;

position += view.size;

}

{

if (stateSpecs[spec.stateId].name.size() != 0 && spec.name != stateSpecs[spec.stateId].name) {

auto currentName = stateSpecs[spec.stateId].name;

throw runtime_error_f("Metric %d already registered with name %s", spec.stateId, currentName.data(), spec.name.data());

}

auto currentMetric = std::find_if(stateSpecs.begin(), stateSpecs.end(), [&spec](StateSpec const& s) { return s.name == spec.name && s.stateId != spec.stateId; });

if (currentMetric != stateSpecs.end()) {

throw runtime_error_f("Metric %s already registered with id %d. Cannot reregister with %d.", spec.name.data(), currentMetric->stateId, spec.stateId);

}

stateSpecs[spec.stateId] = spec;

stateNames[spec.stateId] = spec.name;

int64_t currentTime = getTimestamp(realTimeBase, initialTimeOffset);

updateInfos[spec.stateId] = UpdateInfo{currentTime, currentTime};

updated[spec.stateId] = spec.sendInitialValue;

enabled[spec.stateId] = spec.defaultEnabled;

registeredStates.push_back(spec.stateId);