Stresstest server: starting requests at given subsecond timestamps - c

Question

I have to stresstest a server via a list of 100k Post-Requests per day. Each request must start at a given fixed timestamp. Smallest time-difference between two requests is around 100ms.
Example:
12:08:38.971 url1
12:08:39.429 url2
12:08:40.186 url3
12:08:40.444 url4
...
I'll use perl or c to implement the stresstest. Requests are executed with curl, threading is used, because responses are typically longer than 100ms.
My problem is to fill some kind of queue which starts the requests at the given fixed times from the list.
My first idea is to use a while loop (example for single request) and permanently check the timestamps:
#include <stdio.h>
#include <sys/time.h>
struct timeval time;
int t_sec=1496064929;
int t_usec=100;
int request_started=0;
int main(){
while(1){
gettimeofday(&time, NULL);
if(time.tv_sec == t_sec && time.tv_usec > t_usec && request_started == 0){
printf("Request start at %d %d\n", time.tv_sec, time.tv_usec);
request_started=1;
}
}
}
But this code is far from ideal...
Is there some kind of scheduler library which can handle requests in subsecond-area? Or maybe, there are ready to use benchmark-tools which can produce such requests from the given list (I already checked apache benchmark, httperf and siege without luck)?
Thanks in advance!

Answer 1

You can code your stress client by setting appropriate adding a delay before sending each request.
Please note the calculations done for sending requests emulating a stress test are subjective to network delay,system resources(cpu,memory) available,priority of client and server program when they are running.
You have 100k to be sent over 24 hour(assuming you mean 24 hours for a day), so basically you need to keep delay of 1158 msec between two consecutive requests being sent.
You need to calculate time taken for each request in the loop by subtracting timestamp before sending the request from the timestamp taken after receiving response
Lets say it took x msec for a reqeust to get processed,if x is less than 1158msec, sleep for (1158 - x) msec before sending next request,otherwise just send the next request with any delay.
When you run it with multiple processes or threads, you need to factor that in your calculation as each thread/process is supposed to send 100k/n number of requests in 24 hours where n is number of threads or processes.