From 76da364d75ab5830d69dfba16a049d2c89934230 Mon Sep 17 00:00:00 2001
From: Frederic Lecaille <flecaille@haproxy.com>
Date: Tue, 25 Aug 2026 15:55:36 +0200
Subject: [PATCH] MINOR: haload: add -T to add a think time after each response

Add -T <time>, like h1load's option of the same name: after a
response, wait <time> ms (with a bit of random jitter) before sending
the next request, instead of sending it right away. This simulates a
real user pausing between actions.

-T is positional, like -post or -head: it applies to the URLs that
follow it on the command line, not to all of them.

If -R is also set, the wait used is the larger of the two: the rate
limit and the think time never fight each other, whichever asks for
more waiting wins.

-ee takes over as soon as an error is detected: -T is ignored while it
is still probing, and applies again once probing is done and the
normal load resumes.
---
 doc/haload.txt           |  1 +
 include/haproxy/haload.h |  2 ++
 src/haload.c             | 41 +++++++++++++++++++++++++++++-----------
 src/haload_init.c        |  6 ++++++
 4 files changed, 39 insertions(+), 11 deletions(-)

diff --git a/doc/haload.txt b/doc/haload.txt
index d217c8890..edaed1fef 100644
--- a/doc/haload.txt
+++ b/doc/haload.txt
@@ -81,6 +81,7 @@ HALoad displays its usage when run without argument or wrong arguments:
             -C               dump the configuration and exit
             -H "foo:bar"     add this header name and value
             -R <rate>        limit to this many request attempts per second (0)
+            -T <time>        think time in ms after a response (0) (*)
             -v               shows version
             --defaults <str> add a string to default section
             --global <str>   add a string to global section
diff --git a/include/haproxy/haload.h b/include/haproxy/haload.h
index b66c0e4f6..271cee939 100644
--- a/include/haproxy/haload.h
+++ b/include/haproxy/haload.h
@@ -34,6 +34,7 @@ struct hld_url_cfg {
 	int ssl;
 	int is_quic;
 	int h2c;
+	int thnk_time;
 	enum hld_http_ver http_ver;
 	char *addr;
 	char *raw_addr; // used only to set the host header value
@@ -83,6 +84,7 @@ extern int arg_rcon;
 extern int arg_slow;
 extern int arg_serr;
 extern int arg_usr;
+extern int arg_thnk;
 extern int arg_thrd;
 extern int arg_wait;
 
diff --git a/src/haload.c b/src/haload.c
index e2cd6a71d..f303790fe 100644
--- a/src/haload.c
+++ b/src/haload.c
@@ -107,6 +107,7 @@ int arg_rcon = -1;     // max requests per conn
 int arg_reqs = -1;     // max total requests
 int arg_serr;          // 1 = stop on first error (-e), 2 = probe and ramp (-ee)
 int arg_slow;          // slow start: delay in milliseconds
+int arg_thnk;          // think time after a reponse (ms)
 int arg_thrd;          // number of threads
 int arg_usr = 1;       // number of users
 int arg_wait = 10000;  // I/O time out (ms)
@@ -1432,8 +1433,11 @@ static inline uint32_t hld_thr_rate_max(struct hld_thr_info *ti, int rate)
 	return hld_thr_rate_share(rate);
 }
 
-/* Schedule <usr> user, depending on <rate> conn/req rate value */
-static inline void hld_usr_schedule(struct hld_usr *usr, int rate)
+/* Schedule <usr> user, depending on <rate> conn/req rate value and on
+ * <think>, an already-computed think time in ms (0 if none). The wait
+ * used is the larger of the two, same as h1load's -T.
+ */
+static inline void hld_usr_schedule(struct hld_usr *usr, int rate, uint32_t think)
 {
 	uint32_t max, wait;
 	struct hld_thr_info *ti = &thrs_info[tid];
@@ -1441,17 +1445,19 @@ static inline void hld_usr_schedule(struct hld_usr *usr, int rate)
 	hld_thr_sync_ramp_gen(ti);
 	max = hld_thr_rate_max(ti, rate);
 
-	if (!max) {
+	if (!max)
 		/* this thread has no budget right now (its exact share of
 		 * <rate> is 0, or it's still ramping up under -s): nothing
 		 * to send from here, just check back shortly.
 		 */
-		task_schedule(usr->task, tick_add(now_ms, MS_TO_TICKS(1000)));
-		return;
-	}
+		wait = 1000;
+	else
+		wait = hld_next_event_delay(&ti->req_rate, max,
+		                            ti->curusrs - ti->cur_req, date);
+
+	if (think > wait)
+		wait = think;
 
-	wait = hld_next_event_delay(&ti->req_rate, max,
-	                            ti->curusrs - ti->cur_req, date);
 	task_schedule(usr->task, tick_add(now_ms, MS_TO_TICKS(wait)));
 }
 
@@ -1645,7 +1651,7 @@ struct task *hld_strm_task(struct task *t, void *context, unsigned int state)
 	/* Note that the user task will release all the expired streams
 	 * attached to it.
 	 */
-	if (!HA_ATOMIC_LOAD(&arg_rate)) {
+	if (!HA_ATOMIC_LOAD(&arg_rate) && !url->cfg->thnk_time) {
 		task_wakeup(usr->task, TASK_WOKEN_IO);
 		if (LIST_ISEMPTY(&usr->strms))
 			usr->task->expire = TICK_ETERNITY;
@@ -1659,7 +1665,20 @@ struct task *hld_strm_task(struct task *t, void *context, unsigned int state)
 		}
 	}
 	else {
-		hld_usr_schedule(usr, HA_ATOMIC_LOAD(&arg_rate));
+		int rate = HA_ATOMIC_LOAD(&arg_rate);
+		uint32_t think = 0;
+
+		/* -ee takes over as soon as an error is detected: ignore -T
+		 * while it is still probing. -R and -T only apply again once
+		 * probing is done and the normal load resumes.
+		 */
+		if (!HA_ATOMIC_LOAD(&err_ramp_active) && url->cfg->thnk_time)
+			think = url->cfg->thnk_time * (4096 - 128 + statistical_prng_range(256)) / 4096;
+
+		if (rate)
+			hld_usr_schedule(usr, rate, think);
+		else
+			task_schedule(usr->task, tick_add(now_ms, MS_TO_TICKS(think)));
 	}
 
 	goto leave;
@@ -1693,7 +1712,7 @@ struct task *hld_strm_task(struct task *t, void *context, unsigned int state)
 		if (!HA_ATOMIC_LOAD(&arg_rate))
 			task_wakeup(usr->task, TASK_WOKEN_IO);
 		else
-			hld_usr_schedule(usr, HA_ATOMIC_LOAD(&arg_rate));
+			hld_usr_schedule(usr, HA_ATOMIC_LOAD(&arg_rate), 0);
 
 		if (arg_serr == 1) {
 			usr->flags |= HLD_USR_FL_STOP;
diff --git a/src/haload_init.c b/src/haload_init.c
index 4182dc667..5ec9837d4 100644
--- a/src/haload_init.c
+++ b/src/haload_init.c
@@ -47,6 +47,7 @@ static void  hld_usage(char *name, int argc)
 		"        -F               merge send() with connect's ACK\n"
 		"        -H \"foo:bar\"   add this header name and value\n"
 		"        -R <rate>        limit to this many request attempts per second (0)\n"
+		"        -T <time>        think time in ms after a response (0) (*)\n"
 		"        -v               shows version\n"
 		"        --defaults <str> add a string to default section\n"
 		"        --global <str>   add a string to global section\n"
@@ -304,6 +305,7 @@ static struct hld_url_cfg *hld_alloc_url(char *url, int is_quic,
 	hld_url_cfg->ssl = ssl;
 	hld_url_cfg->is_quic = is_quic;
 	hld_url_cfg->h2c = h2c_param;
+	hld_url_cfg->thnk_time = arg_thnk;
 	hld_url_cfg->http_ver = http_ver;
 	hld_url_cfg->addr = addr;
 	hld_url_cfg->raw_addr = raw_addr;
@@ -670,6 +672,10 @@ void haproxy_init_args(int argc, char **argv)
 				opt++;
 				hld_parse_long(&arg_rate, opt, &argc, &argv);
 			}
+			else if (*opt == 'T') {
+				opt++;
+				hld_parse_long(&arg_thnk, opt, &argc, &argv);
+			}
 			else if (*opt == 'v') {
 				/* empty option */
 				if (*(opt + 1))
-- 
2.47.3