Unless we need to remove elements in the middle of a list, an array based variant is always faster.

There's no need for the current replica to further process the
request.

If a reply message completes a certificate while in the same
moment the lock acquire inside invoke times out then the following
retry instruction can reset the certificate even though the lock was
already released.

This ensures that the output of multiple threads won't be mixed up.

As both stdout and stderr point to the same file this can
cause garbling of log outputs between threads.

This simplifies handling of only part-time active clients

The first sequence number on the replicas is zero

Conflicting read request replies are not the leaders fault. So just
resend the request normally the first time.

A client could also reset it's certificate and retry the read
request for a newer sequence number.

This should lead to less mangled stack traces

The minimum is necessary for generating the keys not when
loading them

A replica directly replies with its current state to a weak
read requests. Therefore the client has to send the request
itself to all replicas.

This fixes hashed replies and weak read requests. In BFT
mode all replica should return a reply to the client. The only
question is whether a hashed reply is enough or not.

As the benchmark policy and the interval statistics start at
nearly exactly the same time this could cause the interval statistics
to report one interval too much or not.

This change slightly delays to policy start and suppresses printing
of the last incomplete interval. That way the first interval captures
slightly too little data (but that doesn't matter as it's normally cut
off anyways) and the last incomplete interval only captures data
for the fraction of a second.

This is useful for experiments where not all clients are active right from the start