veb: remove 2 clones of response bodies; reduce the GC load for the most common case (fix #25423) (#26236)

Author: fleximus

vlib/veb/context.v

@@ -100,11 +100,14 @@ pub fn (mut ctx Context) send_response_to_client(mimetype string, response strin
 	// ctx.done is only set in this function, so in order to sent a response over the connection
 	// this value has to be set to true. Assuming the user doesn't use `ctx.conn` directly.
 	ctx.done = true
-	ctx.res.body = response.clone()
 	$if veb_livereload ? {
 		if mimetype == 'text/html' {
 			ctx.res.body = response.replace('</html>', '<script src="/veb_livereload/${veb_livereload_server_start}/script.js"></script>\n</html>')
+		} else {
+			ctx.res.body = response.clone()
 		}
+	} $else {
+		ctx.res.body = response.clone()
 	}
 	// set Content-Type and Content-Length headers
 	mut custom_mimetype := if ctx.content_type.len == 0 { mimetype } else { ctx.content_type }
@@ -127,10 +130,8 @@ pub fn (mut ctx Context) send_response_to_client(mimetype string, response strin
 		ctx.res.set_status(.ok)
 	}
 	if ctx.takeover {
-		println('calling fast send resp')
 		fast_send_resp(mut ctx.conn, ctx.res) or {}
 	}
-	ctx.res.body = ctx.res.body.clone() // !!!! TODO memory bug
 	// result is send in `veb.v`, `handle_route`
 	return Result{}
 }

vlib/veb/tests/memory_leak_test.v

@@ -0,0 +1,68 @@
+// vtest build: !docker-ubuntu-musl
+import os
+import time
+import net.http
+
+const sport = 13085
+const localserver = '127.0.0.1:${sport}'
+const exit_after_time = 30000
+const vexe = os.getenv('VEXE')
+const vroot = os.dir(vexe)
+const serverexe = os.join_path(os.cache_dir(), 'veb_memory_test_server.exe')
+
+fn testsuite_begin() {
+	os.chdir(vroot) or {}
+	if os.exists(serverexe) {
+		os.rm(serverexe) or {}
+	}
+}
+
+fn testsuite_end() {
+	if os.exists(serverexe) {
+		os.rm(serverexe) or {}
+	}
+}
+
+fn test_server_compiles() {
+	did_compile := os.system('${os.quoted_path(vexe)} -o ${os.quoted_path(serverexe)} vlib/veb/tests/memory_leak_test_server.v')
+	assert did_compile == 0
+	assert os.exists(serverexe)
+}
+
+fn test_server_runs_in_background() {
+	spawn os.system('${os.quoted_path(serverexe)} ${sport} ${exit_after_time}')
+	time.sleep(500 * time.millisecond)
+}
+
+fn test_large_responses_work_correctly() {
+	// Make requests with large response bodies and verify they work
+	request_count := 20
+	mut successful := 0
+	for _ in 0 .. request_count {
+		resp := http.get('http://${localserver}/large') or { continue }
+		if resp.status_code == 200 && resp.body.len > 50000 {
+			successful += 1
+		}
+	}
+	// Ensure most requests succeeded (allows for some network variability)
+	assert successful >= request_count - 2, 'Only ${successful}/${request_count} requests succeeded'
+}
+
+fn test_heap_usage_endpoint_works() {
+	resp := http.get('http://${localserver}/heap') or {
+		assert false, 'Failed to get heap usage: ${err}'
+		return
+	}
+	heap := resp.body.i64()
+	// Just verify we get a reasonable value (more than 1MB, less than 1GB)
+	assert heap > 1024 * 1024, 'Heap usage ${heap} seems too low'
+	assert heap < 1024 * 1024 * 1024, 'Heap usage ${heap} seems too high'
+}
+
+fn test_gc_collect_endpoint_works() {
+	resp := http.get('http://${localserver}/gc') or {
+		assert false, 'Failed to trigger GC: ${err}'
+		return
+	}
+	assert resp.status_code == 200
+}

vlib/veb/tests/memory_leak_test_server.v

@@ -0,0 +1,57 @@
+module main
+
+import os
+import veb
+import time
+
+struct Context {
+	veb.Context
+}
+
+struct App {}
+
+fn exit_after_timeout(timeout_in_ms int) {
+	time.sleep(timeout_in_ms * time.millisecond)
+	exit(0)
+}
+
+fn main() {
+	if os.args.len != 3 {
+		panic('Usage: memory_leak_test_server.exe PORT TIMEOUT_IN_MILLISECONDS')
+	}
+	http_port := os.args[1].int()
+	assert http_port > 0
+	timeout := os.args[2].int()
+	assert timeout > 0
+	spawn exit_after_timeout(timeout)
+
+	mut app := &App{}
+	veb.run_at[App, Context](mut app,
+		host:               'localhost'
+		port:               http_port
+		family:             .ip
+		timeout_in_seconds: 10
+	)!
+}
+
+pub fn (mut app App) index(mut ctx Context) veb.Result {
+	return ctx.text('OK')
+}
+
+@['/heap']
+pub fn (mut app App) heap(mut ctx Context) veb.Result {
+	usage := gc_heap_usage()
+	return ctx.text('${usage.heap_size}')
+}
+
+@['/gc']
+pub fn (mut app App) gc_collect(mut ctx Context) veb.Result {
+	gc_collect()
+	return ctx.text('GC collected')
+}
+
+@['/large']
+pub fn (mut app App) large(mut ctx Context) veb.Result {
+	data := 'X'.repeat(100 * 1024)
+	return ctx.text(data)
+}

vlib/veb/veb_picoev.v

@@ -322,11 +322,6 @@ $if !new_veb ? {
 				pv.delete(fd)
 				return
 			}
-			// TODO: At this point the Context can safely be freed when this function returns.
-			// The user will have to clone the context if the context object should be kept.
-			// defer {
-			// 	completed_context.free()
-			// }
 			match completed_context.return_type {
 				.normal {
 					// small optimization: if the response is small write it immediately