H2O: Various improvements based on the preview data (#2673)

* Update H2O to version 2.2.0

* Enable link-time optimization for mustache-c

* H2O: Another attempt at batch updates

This commit changes the database updates test implementation
to perform all updates in a single batch again, hopefully in
a faster way than before.

* H2O: Reduce the number of threads in the physical hardware environment

Many of the tests in the physical hardware environment do not saturate
a gigabit network connection, so there is no need to start the same
number of threads as logical processors. In this way thread contention
(mainly in kernel space) is reduced, hence performance is improved.

frameworks/C/h2o/CMakeLists.txt

@@ -16,7 +16,7 @@ include_directories(src ${H2O_INCLUDE} ${MUSTACHE_C_INCLUDE} ${YAJL_INCLUDE})
 file(GLOB SOURCES "src/*.c")
 add_executable(${PROJECT_NAME} ${SOURCES})
 target_link_libraries(${PROJECT_NAME} ${COMMON_OPTIONS})
-target_link_libraries(${PROJECT_NAME} ${H2O_LIB} ssl crypto pq ${MUSTACHE_C_LIB} ${YAJL_LIB})
+target_link_libraries(${PROJECT_NAME} ${H2O_LIB} ssl crypto pq z ${MUSTACHE_C_LIB} ${YAJL_LIB})
 install(TARGETS ${PROJECT_NAME} RUNTIME DESTINATION bin)
 file(GLOB TEMPLATES "template/*")
 install(FILES ${TEMPLATES} DESTINATION share/${PROJECT_NAME}/template)

frameworks/C/h2o/setup.sh

@@ -6,14 +6,17 @@ H2O_APP_HOME="${IROOT}/h2o_app"
 BUILD_DIR="${H2O_APP_HOME}_build"
 H2O_APP_PROFILE_PORT="54321"
 H2O_APP_PROFILE_URL="http://127.0.0.1:$H2O_APP_PROFILE_PORT"
+NUM_PROC=$(nproc)
 
 # A hacky way to detect whether we are running in the physical hardware or the cloud environment.
-if [[ $(nproc) -gt 16 ]]; then
+if [[ "$NUM_PROC" -gt 16 ]]; then
+	CLOUD_ENVIRONMENT=false
 	# In the physical hardware environment the application server has more CPU cores than the
 	# database server, so we need to reduce the maximum number of database connections per
 	# thread accordingly.
-	DB_CONN=2
+	DB_CONN=4
 else
+	CLOUD_ENVIRONMENT=true
 	DB_CONN=8
 fi
 
@@ -35,13 +38,13 @@ run_curl()
 
 run_h2o_app()
 {
-	"$1/h2o_app" -f "$2/template/fortunes.mustache" -m "$DB_CONN" "$3" "$4" \
+	taskset -c "$1" "$2/h2o_app" -f "$3/template/fortunes.mustache" -m "$DB_CONN" "$4" "$5" \
 		-d "host=TFB-database dbname=hello_world user=benchmarkdbuser password=benchmarkdbpass" &
 }
 
 generate_profile_data()
 {
-	run_h2o_app . "${TROOT}" -p$H2O_APP_PROFILE_PORT -t1
+	run_h2o_app 0 . "${TROOT}" -p$H2O_APP_PROFILE_PORT -t1
 	local -r H2O_APP_PROFILE_PID=$!
 	while ! curl ${H2O_APP_PROFILE_URL} > /dev/null 2>&1; do sleep 1; done
 	run_curl json
@@ -65,4 +68,11 @@ make -j "$(nproc)" install
 popd
 rm -rf "$BUILD_DIR"
 echo "Maximum database connections per thread: $DB_CONN"
-run_h2o_app "${H2O_APP_HOME}/bin" "${H2O_APP_HOME}/share/h2o_app"
+
+if "$CLOUD_ENVIRONMENT"; then
+	run_h2o_app "0-$((NUM_PROC - 1))" "${H2O_APP_HOME}/bin" "${H2O_APP_HOME}/share/h2o_app"
+else
+	for ((i = 0; i < 16; i++)); do
+		run_h2o_app "$i" "${H2O_APP_HOME}/bin" "${H2O_APP_HOME}/share/h2o_app" -t1
+	done
+fi

frameworks/C/h2o/src/database.c

@@ -66,9 +66,6 @@ static const struct {
 } prepared_statement[] = {
 	{FORTUNE_TABLE_NAME, "SELECT * FROM " FORTUNE_TABLE_NAME ";"},
 	{WORLD_TABLE_NAME, "SELECT * FROM " WORLD_TABLE_NAME " WHERE " ID_FIELD_NAME " = $1::integer;"},
-	{UPDATE_QUERY_NAME,
-	 "UPDATE " WORLD_TABLE_NAME " SET randomNumber = $2::integer "
-	 "WHERE " ID_FIELD_NAME " = $1::integer;"},
 };
 
 static int do_database_write(db_conn_t *db_conn)

frameworks/C/h2o/src/database.h

@@ -38,15 +38,19 @@
 #define IS_SINGLE_ROW 2
 #define MAX_ID 10000
 #define MESSAGE_FIELD_NAME "message"
-#define UPDATE_QUERY_NAME "Update"
 #define WORLD_TABLE_NAME "World"
 
-#define UPDATE_QUERY \
-	"EXECUTE \"" WORLD_TABLE_NAME "\"(%" PRIu32 ");" \
-	"EXECUTE \"" UPDATE_QUERY_NAME "\"(%" PRIu32 ", %" PRIu32 ");"
+#define UPDATE_QUERY_BEGIN \
+	"UPDATE " WORLD_TABLE_NAME " SET randomNumber = v.randomNumber " \
+	"FROM (VALUES(%" PRIu32 ", %" PRIu32 ")"
 
-#define MAX_UPDATE_QUERY_LEN \
-	(sizeof(UPDATE_QUERY) + 3 * (sizeof(MKSTR(MAX_ID)) - 1) - 3 * sizeof(PRIu32))
+#define UPDATE_QUERY_ELEM ", (%" PRIu32 ", %" PRIu32 ")"
+#define UPDATE_QUERY_END ") AS v (id, randomNumber) WHERE " WORLD_TABLE_NAME ".id = v.id;"
+
+#define MAX_UPDATE_QUERY_LEN(n) \
+	(sizeof(UPDATE_QUERY_BEGIN) + sizeof(UPDATE_QUERY_END) - sizeof(UPDATE_QUERY_ELEM) + \
+	 (n) * (sizeof(UPDATE_QUERY_ELEM) - 1 + \
+	        2 * (sizeof(MKSTR(MAX_ID)) - 1) - 2 * (sizeof(PRIu32) - 1) - 2))
 
 typedef enum {
 	SUCCESS,

frameworks/C/h2o/src/event_loop.c

@@ -263,7 +263,11 @@ void free_event_loop(event_loop_t *event_loop, h2o_multithread_receiver_t *h2o_r
 	h2o_multithread_unregister_receiver(event_loop->h2o_ctx.queue, h2o_receiver);
 	h2o_socket_close(event_loop->h2o_socket);
 	h2o_socket_close(event_loop->epoll_socket);
+
+	h2o_loop_t * const loop = event_loop->h2o_ctx.loop;
+
 	h2o_context_dispose(&event_loop->h2o_ctx);
+	h2o_evloop_destroy(loop);
 }
 
 void initialize_event_loop(bool is_main_thread,

frameworks/C/h2o/src/fortune.c

@@ -148,7 +148,12 @@ static void complete_fortunes(struct st_h2o_generator_t *self, h2o_req_t *req)
 	                                                         fortune_ctx->iovec_list);
 
 	fortune_ctx->iovec_list = iovec_list->l.next;
-	h2o_send(req, iovec_list->iov, iovec_list->iovcnt, !fortune_ctx->iovec_list);
+
+	const h2o_send_state_t state = fortune_ctx->iovec_list ?
+	                               H2O_SEND_STATE_IN_PROGRESS :
+	                               H2O_SEND_STATE_FINAL;
+
+	h2o_send(req, iovec_list->iov, iovec_list->iovcnt, state);
 }
 
 static list_t *get_sorted_sublist(list_t *head)
@@ -270,10 +275,12 @@ static result_return_t on_fortune_result(db_query_param_t *param, PGresult *resu
 			fortune_ctx->iovec_list = iovec_list->l.next;
 			set_default_response_param(HTML, fortune_ctx->content_length, fortune_ctx->req);
 			h2o_start_response(fortune_ctx->req, &fortune_ctx->generator);
-			h2o_send(fortune_ctx->req,
-			         iovec_list->iov,
-			         iovec_list->iovcnt,
-			         !fortune_ctx->iovec_list);
+
+			const h2o_send_state_t state = fortune_ctx->iovec_list ?
+			                               H2O_SEND_STATE_IN_PROGRESS :
+			                               H2O_SEND_STATE_FINAL;
+
+			h2o_send(fortune_ctx->req, iovec_list->iov, iovec_list->iovcnt, state);
 		}
 		else
 			send_error(INTERNAL_SERVER_ERROR, REQ_ERROR, fortune_ctx->req);

frameworks/C/h2o/src/main.c

@@ -131,7 +131,7 @@ static int initialize_global_data(const config_t *config, global_data_t *global_
 	h2o_access_log_filehandle_t *log_handle = NULL;
 
 	if (config->log) {
-		log_handle = h2o_access_log_open_handle(config->log, NULL);
+		log_handle = h2o_access_log_open_handle(config->log, NULL, H2O_LOGCONF_ESCAPE_APACHE);
 
 		if (!log_handle)
 			goto error;

frameworks/C/h2o/src/request_handler.c

@@ -205,6 +205,7 @@ void send_service_unavailable_error(const char *body, h2o_req_t *req)
 	h2o_add_header(&req->pool,
 	               &req->res.headers,
 	               H2O_TOKEN_RETRY_AFTER,
+	               NULL,
 	               H2O_STRLIT(MKSTR(H2O_DEFAULT_HTTP1_REQ_TIMEOUT_IN_SECS)));
 	h2o_send_error_503(req,
 	                   status_code_to_string(SERVICE_UNAVAILABLE),
@@ -223,18 +224,21 @@ void set_default_response_param(content_type_t content_type, size_t content_leng
 			h2o_add_header(&req->pool,
 			               &req->res.headers,
 			               H2O_TOKEN_CONTENT_TYPE,
+			               NULL,
 			               H2O_STRLIT("application/json"));
 			break;
 		case PLAIN:
 			h2o_add_header(&req->pool,
 			               &req->res.headers,
 			               H2O_TOKEN_CONTENT_TYPE,
+			               NULL,
 			               H2O_STRLIT("text/plain"));
 			break;
 		default:
 			h2o_add_header(&req->pool,
 			               &req->res.headers,
 			               H2O_TOKEN_CONTENT_TYPE,
+			               NULL,
 			               H2O_STRLIT("text/html; charset=utf-8"));
 	}
 }

frameworks/C/h2o/src/world.c

@@ -23,6 +23,7 @@
 #include <stddef.h>
 #include <stdint.h>
 #include <stdio.h>
+#include <stdlib.h>
 #include <arpa/inet.h>
 #include <postgresql/libpq-fe.h>
 #include <yajl/yajl_gen.h>
@@ -73,29 +74,14 @@ struct multiple_query_ctx_t {
 	size_t num_query;
 	size_t num_query_in_progress;
 	size_t num_result;
-	query_result_t res[];
-};
-
-typedef struct {
-	char *command;
-	update_ctx_t *ctx;
-	uint32_t random_number;
-	bool update;
-	db_query_param_t param;
-} update_param_t;
-
-struct update_ctx_t {
-	yajl_gen gen; // also an error flag
-	h2o_req_t *req;
-	update_param_t *update_param;
-	size_t num_query;
-	size_t num_query_in_progress;
-	size_t num_result;
+	bool do_update;
 	query_result_t res[];
 };
 
 static void cleanup_multiple_query(void *data);
-static void cleanup_update(void *data);
+static int compare_items(const void *x, const void *y);
+static int do_multiple_queries(bool do_update, h2o_req_t *req);
+static void do_updates(multiple_query_ctx_t *query_ctx);
 static size_t get_query_number(h2o_req_t *req);
 static void initialize_ids(size_t num_query, query_result_t *res, unsigned int *seed);
 static void on_multiple_query_error(db_query_param_t *param, const char *error_string);
@@ -104,9 +90,7 @@ static void on_multiple_query_timeout(db_query_param_t *param);
 static void on_single_query_error(db_query_param_t *param, const char *error_string);
 static result_return_t on_single_query_result(db_query_param_t *param, PGresult *result);
 static void on_single_query_timeout(db_query_param_t *param);
-static void on_update_error(db_query_param_t *param, const char *error_string);
 static result_return_t on_update_result(db_query_param_t *param, PGresult *result);
-static void on_update_timeout(db_query_param_t *param);
 static void process_result(PGresult *result, query_result_t *out);
 static int serialize_item(uint32_t id, uint32_t random_number, yajl_gen gen);
 static void serialize_items(const query_result_t *res,
@@ -122,12 +106,156 @@ static void cleanup_multiple_query(void *data)
 		yajl_gen_free(query_ctx->gen);
 }
 
-static void cleanup_update(void *data)
+static int compare_items(const void *x, const void *y)
+{
+	const query_result_t * const r1 = x;
+	const query_result_t * const r2 = y;
+
+	return r1->id < r2->id ? -1 : r1->id > r2->id;
+}
+
+static int do_multiple_queries(bool do_update, h2o_req_t *req)
+{
+	thread_context_t * const ctx = H2O_STRUCT_FROM_MEMBER(thread_context_t,
+	                                                      event_loop.h2o_ctx,
+	                                                      req->conn->ctx);
+
+	const size_t num_query = get_query_number(req);
+
+	// MAX_QUERIES is a relatively small number, so assume no overflow in the following
+	// arithmetic operations.
+	assert(num_query <= MAX_QUERIES);
+
+	size_t base_size = offsetof(multiple_query_ctx_t, res) + num_query * sizeof(query_result_t);
+
+	base_size = ((base_size + _Alignof(query_param_t) - 1) / _Alignof(query_param_t));
+	base_size = base_size * _Alignof(query_param_t);
+
+	const size_t num_query_in_progress = MIN(num_query, ctx->config->max_db_conn_num);
+	size_t sz = base_size + num_query_in_progress * sizeof(query_param_t);
+
+	if (do_update) {
+		const size_t reuse_size = (num_query_in_progress - 1) * sizeof(query_param_t);
+		const size_t update_query_len = MAX_UPDATE_QUERY_LEN(num_query);
+
+		if (update_query_len > reuse_size)
+			sz += update_query_len - reuse_size;
+	}
+
+	multiple_query_ctx_t * const query_ctx = h2o_mem_alloc_shared(&req->pool,
+	                                                              sz,
+	                                                              cleanup_multiple_query);
+
+	if (query_ctx) {
+		memset(query_ctx, 0, sz);
+		query_ctx->num_query = num_query;
+		query_ctx->num_query_in_progress = num_query_in_progress;
+		query_ctx->req = req;
+		query_ctx->do_update = do_update;
+		query_ctx->query_param = (query_param_t *) ((char *) query_ctx + base_size);
+		initialize_ids(num_query, query_ctx->res, &ctx->random_seed);
+
+		for (size_t i = 0; i < query_ctx->num_query_in_progress; i++) {
+			query_ctx->query_param[i].ctx = query_ctx;
+			// We need a copy of id because the original may be overwritten
+			// by a completed query.
+			query_ctx->query_param[i].id = htonl(query_ctx->res[i].id);
+			query_ctx->query_param[i].id_format = 1;
+			query_ctx->query_param[i].id_len = sizeof(query_ctx->query_param[i].id);
+			query_ctx->query_param[i].id_pointer = (const char *) &query_ctx->query_param[i].id;
+			query_ctx->query_param[i].param.command = WORLD_TABLE_NAME;
+			query_ctx->query_param[i].param.nParams = 1;
+			query_ctx->query_param[i].param.on_error = on_multiple_query_error;
+			query_ctx->query_param[i].param.on_result = on_multiple_query_result;
+			query_ctx->query_param[i].param.on_timeout = on_multiple_query_timeout;
+			query_ctx->query_param[i].param.paramFormats = &query_ctx->query_param[i].id_format;
+			query_ctx->query_param[i].param.paramLengths = &query_ctx->query_param[i].id_len;
+			query_ctx->query_param[i].param.paramValues = &query_ctx->query_param[i].id_pointer;
+			query_ctx->query_param[i].param.flags = IS_PREPARED;
+			query_ctx->query_param[i].param.resultFormat = 1;
+
+			if (execute_query(ctx, &query_ctx->query_param[i].param)) {
+				query_ctx->num_query_in_progress = i;
+				send_service_unavailable_error(DB_REQ_ERROR, req);
+				return 0;
+			}
+
+			h2o_mem_addref_shared(query_ctx);
+		}
+
+		// Create a JSON generator while the queries are processed.
+		query_ctx->gen = get_json_generator(&req->pool);
+
+		if (!query_ctx->gen)
+			send_error(INTERNAL_SERVER_ERROR, REQ_ERROR, req);
+	}
+	else
+		send_error(INTERNAL_SERVER_ERROR, REQ_ERROR, req);
+
+	return 0;
+}
+
+static void do_updates(multiple_query_ctx_t *query_ctx)
 {
-	const update_ctx_t * const update_ctx = data;
+	thread_context_t * const ctx = H2O_STRUCT_FROM_MEMBER(thread_context_t,
+	                                                      event_loop.h2o_ctx,
+	                                                      query_ctx->req->conn->ctx);
+	char *iter = (char *) (query_ctx->query_param + 1);
+	size_t sz = MAX_UPDATE_QUERY_LEN(query_ctx->num_result);
+
+	// Sort the results to avoid database deadlock.
+	qsort(query_ctx->res, query_ctx->num_result, sizeof(*query_ctx->res), compare_items);
+	query_ctx->query_param->param.command = iter;
+	query_ctx->query_param->param.nParams = 0;
+	query_ctx->query_param->param.on_result = on_update_result;
+	query_ctx->query_param->param.paramFormats = NULL;
+	query_ctx->query_param->param.paramLengths = NULL;
+	query_ctx->query_param->param.paramValues = NULL;
+	query_ctx->query_param->param.flags = 0;
+	query_ctx->res->random_number = get_random_number(MAX_ID, &ctx->random_seed) + 1;
+
+	int c = snprintf(iter,
+	                 sz,
+	                 UPDATE_QUERY_BEGIN,
+	                 query_ctx->res->id,
+	                 query_ctx->res->random_number);
+
+	if (c < 0 || (size_t) c >= sz)
+		goto error;
+
+	iter += c;
+	sz -= c;
+
+	for (size_t i = 1; i < query_ctx->num_result; i++) {
+		query_ctx->res[i].random_number = get_random_number(MAX_ID, &ctx->random_seed) + 1;
+		c = snprintf(iter,
+		             sz,
+		             UPDATE_QUERY_ELEM,
+		             query_ctx->res[i].id,
+		             query_ctx->res[i].random_number);
+
+		if (c < 0 || (size_t) c >= sz)
+			goto error;
+
+		iter += c;
+		sz -= c;
+	}
+
+	c = snprintf(iter, sz, UPDATE_QUERY_END);
+
+	if (c < 0 || (size_t) c >= sz)
+		goto error;
+
+	if (execute_query(ctx, &query_ctx->query_param->param))
+		send_service_unavailable_error(DB_REQ_ERROR, query_ctx->req);
+	else {
+		query_ctx->num_query_in_progress++;
+		h2o_mem_addref_shared(query_ctx);
+	}
 
-	if (update_ctx->gen)
-		yajl_gen_free(update_ctx->gen);
+	return;
+error:
+	send_error(INTERNAL_SERVER_ERROR, REQ_ERROR, query_ctx->req);
 }
 
 static size_t get_query_number(h2o_req_t *req)
@@ -216,8 +344,12 @@ static result_return_t on_multiple_query_result(db_query_param_t *param, PGresul
 			query_ctx->gen = NULL;
 			send_service_unavailable_error(DB_REQ_ERROR, query_ctx->req);
 		}
-		else if (query_ctx->num_result == query_ctx->num_query)
-			serialize_items(query_ctx->res, query_ctx->num_result, query_ctx->gen, query_ctx->req);
+		else if (query_ctx->num_result == query_ctx->num_query) {
+			if (query_ctx->do_update)
+				do_updates(query_ctx);
+			else
+				serialize_items(query_ctx->res, query_ctx->num_result, query_ctx->gen, query_ctx->req);
+		}
 
 		h2o_mem_release_shared(query_ctx);
 	}
@@ -300,107 +432,23 @@ static void on_single_query_timeout(db_query_param_t *param)
 	send_error(GATEWAY_TIMEOUT, DB_TIMEOUT_ERROR, query_ctx->req);
 }
 
-static void on_update_error(db_query_param_t *param, const char *error_string)
-{
-	const update_param_t * const query_param = H2O_STRUCT_FROM_MEMBER(update_param_t, param, param);
-	update_ctx_t * const update_ctx = query_param->ctx;
-
-	if (update_ctx->gen) {
-		yajl_gen_free(update_ctx->gen);
-		update_ctx->gen = NULL;
-		send_error(BAD_GATEWAY, error_string, update_ctx->req);
-	}
-
-	update_ctx->num_query_in_progress--;
-	h2o_mem_release_shared(update_ctx);
-}
-
 static result_return_t on_update_result(db_query_param_t *param, PGresult *result)
 {
-	update_param_t * const update_param = H2O_STRUCT_FROM_MEMBER(update_param_t, param, param);
-	update_ctx_t * const update_ctx = update_param->ctx;
-	result_return_t ret = DONE;
-
-	if (update_ctx->gen) {
-		if (update_param->update) {
-			if (PQresultStatus(result) == PGRES_COMMAND_OK) {
-				thread_context_t * const ctx =
-					H2O_STRUCT_FROM_MEMBER(thread_context_t,
-					                       event_loop.h2o_ctx,
-					                       update_ctx->req->conn->ctx);
-				const size_t num_query_remaining = update_ctx->num_query - update_ctx->num_result;
-
-				update_ctx->num_query_in_progress--;
-
-				if (update_ctx->num_query_in_progress < num_query_remaining) {
-					const size_t idx = update_ctx->num_result + update_ctx->num_query_in_progress;
-
-					update_param->random_number = get_random_number(MAX_ID, &ctx->random_seed) + 1;
-					update_param->update = false;
-					snprintf(update_param->command,
-					         MAX_UPDATE_QUERY_LEN,
-					         UPDATE_QUERY,
-					         update_ctx->res[idx].id,
-					         update_ctx->res[idx].id,
-					         update_param->random_number);
-
-					if (!execute_query(ctx, &update_param->param)) {
-						update_ctx->num_query_in_progress++;
-						PQclear(result);
-						return DONE;
-					}
-
-					yajl_gen_free(update_ctx->gen);
-					update_ctx->gen = NULL;
-					send_service_unavailable_error(DB_REQ_ERROR, update_ctx->req);
-				}
-				else if (update_ctx->num_result == update_ctx->num_query)
-					serialize_items(update_ctx->res,
-					                update_ctx->num_result,
-					                update_ctx->gen,
-					                update_ctx->req);
-
-				h2o_mem_release_shared(update_ctx);
-			}
-			else {
-				LIBRARY_ERROR("PQresultStatus", PQresultErrorMessage(result));
-				on_update_error(param, DB_ERROR);
-			}
-		}
-		else if (PQresultStatus(result) == PGRES_TUPLES_OK) {
-			process_result(result, update_ctx->res + update_ctx->num_result);
-			update_ctx->res[update_ctx->num_result].random_number = update_param->random_number;
-			update_ctx->num_result++;
-			update_param->update = true;
-			ret = SUCCESS;
-		}
-		else {
-			LIBRARY_ERROR("PQresultStatus", PQresultErrorMessage(result));
-			on_update_error(param, DB_ERROR);
-		}
+	query_param_t * const query_param = H2O_STRUCT_FROM_MEMBER(query_param_t, param, param);
+	multiple_query_ctx_t * const query_ctx = query_param->ctx;
+
+	if (PQresultStatus(result) == PGRES_COMMAND_OK) {
+		query_ctx->num_query_in_progress--;
+		serialize_items(query_ctx->res, query_ctx->num_result, query_ctx->gen, query_ctx->req);
+		h2o_mem_release_shared(query_ctx);
 	}
 	else {
-		update_ctx->num_query_in_progress--;
-		h2o_mem_release_shared(update_ctx);
+		LIBRARY_ERROR("PQresultStatus", PQresultErrorMessage(result));
+		on_multiple_query_error(param, DB_ERROR);
 	}
 
 	PQclear(result);
-	return ret;
-}
-
-static void on_update_timeout(db_query_param_t *param)
-{
-	const update_param_t * const query_param = H2O_STRUCT_FROM_MEMBER(update_param_t, param, param);
-	update_ctx_t * const update_ctx = query_param->ctx;
-
-	if (update_ctx->gen) {
-		yajl_gen_free(update_ctx->gen);
-		update_ctx->gen = NULL;
-		send_error(GATEWAY_TIMEOUT, DB_TIMEOUT_ERROR, update_ctx->req);
-	}
-
-	update_ctx->num_query_in_progress--;
-	h2o_mem_release_shared(update_ctx);
+	return DONE;
 }
 
 static void process_result(PGresult *result, query_result_t *out)
@@ -467,75 +515,7 @@ error_yajl:
 int multiple_queries(struct st_h2o_handler_t *self, h2o_req_t *req)
 {
 	IGNORE_FUNCTION_PARAMETER(self);
-
-	thread_context_t * const ctx = H2O_STRUCT_FROM_MEMBER(thread_context_t,
-	                                                      event_loop.h2o_ctx,
-	                                                      req->conn->ctx);
-
-	const size_t num_query = get_query_number(req);
-
-	// MAX_QUERIES is a relatively small number, so assume no overflow in the following
-	// arithmetic operations.
-	assert(num_query <= MAX_QUERIES);
-
-	size_t base_size = offsetof(multiple_query_ctx_t, res) + num_query * sizeof(query_result_t);
-
-	base_size = ((base_size + _Alignof(query_param_t) - 1) / _Alignof(query_param_t));
-	base_size = base_size * _Alignof(query_param_t);
-
-	const size_t num_query_in_progress = MIN(num_query, ctx->config->max_db_conn_num);
-	const size_t sz = base_size + num_query_in_progress * sizeof(query_param_t);
-
-	multiple_query_ctx_t * const query_ctx = h2o_mem_alloc_shared(&req->pool,
-	                                                              sz,
-	                                                              cleanup_multiple_query);
-
-	if (query_ctx) {
-		memset(query_ctx, 0, sz);
-		query_ctx->num_query = num_query;
-		query_ctx->num_query_in_progress = num_query_in_progress;
-		query_ctx->req = req;
-		query_ctx->query_param = (query_param_t *) ((char *) query_ctx + base_size);
-		initialize_ids(num_query, query_ctx->res, &ctx->random_seed);
-
-		for (size_t i = 0; i < query_ctx->num_query_in_progress; i++) {
-			query_ctx->query_param[i].ctx = query_ctx;
-			// We need a copy of id because the original may be overwritten
-			// by a completed query.
-			query_ctx->query_param[i].id = htonl(query_ctx->res[i].id);
-			query_ctx->query_param[i].id_format = 1;
-			query_ctx->query_param[i].id_len = sizeof(query_ctx->query_param[i].id);
-			query_ctx->query_param[i].id_pointer = (const char *) &query_ctx->query_param[i].id;
-			query_ctx->query_param[i].param.command = WORLD_TABLE_NAME;
-			query_ctx->query_param[i].param.nParams = 1;
-			query_ctx->query_param[i].param.on_error = on_multiple_query_error;
-			query_ctx->query_param[i].param.on_result = on_multiple_query_result;
-			query_ctx->query_param[i].param.on_timeout = on_multiple_query_timeout;
-			query_ctx->query_param[i].param.paramFormats = &query_ctx->query_param[i].id_format;
-			query_ctx->query_param[i].param.paramLengths = &query_ctx->query_param[i].id_len;
-			query_ctx->query_param[i].param.paramValues = &query_ctx->query_param[i].id_pointer;
-			query_ctx->query_param[i].param.flags = IS_PREPARED;
-			query_ctx->query_param[i].param.resultFormat = 1;
-
-			if (execute_query(ctx, &query_ctx->query_param[i].param)) {
-				query_ctx->num_query_in_progress = i;
-				send_service_unavailable_error(DB_REQ_ERROR, req);
-				return 0;
-			}
-
-			h2o_mem_addref_shared(query_ctx);
-		}
-
-		// Create a JSON generator while the queries are processed.
-		query_ctx->gen = get_json_generator(&req->pool);
-
-		if (!query_ctx->gen)
-			send_error(INTERNAL_SERVER_ERROR, REQ_ERROR, req);
-	}
-	else
-		send_error(INTERNAL_SERVER_ERROR, REQ_ERROR, req);
-
-	return 0;
+	return do_multiple_queries(false, req);
 }
 
 int single_query(struct st_h2o_handler_t *self, h2o_req_t *req)
@@ -577,72 +557,5 @@ int single_query(struct st_h2o_handler_t *self, h2o_req_t *req)
 int updates(struct st_h2o_handler_t *self, h2o_req_t *req)
 {
 	IGNORE_FUNCTION_PARAMETER(self);
-
-	thread_context_t * const ctx = H2O_STRUCT_FROM_MEMBER(thread_context_t,
-	                                                      event_loop.h2o_ctx,
-	                                                      req->conn->ctx);
-
-	const size_t num_query = get_query_number(req);
-
-	// MAX_QUERIES is a relatively small number, so assume no overflow in the following
-	// arithmetic operations.
-	assert(num_query <= MAX_QUERIES);
-
-	size_t base_size = offsetof(update_ctx_t, res) + num_query * sizeof(query_result_t);
-
-	base_size = ((base_size + _Alignof(update_param_t) - 1) / _Alignof(update_param_t));
-	base_size = base_size * _Alignof(update_param_t);
-
-	const size_t num_query_in_progress = MIN(num_query, ctx->config->max_db_conn_num);
-	const size_t struct_size = base_size + num_query_in_progress * sizeof(update_param_t);
-	const size_t sz = struct_size + num_query_in_progress * MAX_UPDATE_QUERY_LEN;
-	update_ctx_t * const update_ctx = h2o_mem_alloc_shared(&req->pool, sz, cleanup_update);
-
-	if (update_ctx) {
-		memset(update_ctx, 0, struct_size);
-		update_ctx->num_query = num_query;
-		update_ctx->num_query_in_progress = num_query_in_progress;
-		update_ctx->req = req;
-		update_ctx->update_param = (update_param_t *) ((char *) update_ctx + base_size);
-		initialize_ids(num_query, update_ctx->res, &ctx->random_seed);
-
-		char *command = (char *) update_ctx + struct_size;
-
-		for (size_t i = 0; i < update_ctx->num_query_in_progress; i++) {
-			update_ctx->update_param[i].command = command;
-			command += MAX_UPDATE_QUERY_LEN;
-			update_ctx->update_param[i].ctx = update_ctx;
-			update_ctx->update_param[i].param.command = update_ctx->update_param[i].command;
-			update_ctx->update_param[i].param.on_error = on_update_error;
-			update_ctx->update_param[i].param.on_result = on_update_result;
-			update_ctx->update_param[i].param.on_timeout = on_update_timeout;
-			update_ctx->update_param[i].param.resultFormat = 1;
-			update_ctx->update_param[i].random_number =
-				get_random_number(MAX_ID, &ctx->random_seed) + 1;
-			snprintf(update_ctx->update_param[i].command,
-			         MAX_UPDATE_QUERY_LEN,
-			         UPDATE_QUERY,
-			         update_ctx->res[i].id,
-			         update_ctx->res[i].id,
-			         update_ctx->update_param[i].random_number);
-
-			if (execute_query(ctx, &update_ctx->update_param[i].param)) {
-				update_ctx->num_query_in_progress = i;
-				send_service_unavailable_error(DB_REQ_ERROR, req);
-				return 0;
-			}
-
-			h2o_mem_addref_shared(update_ctx);
-		}
-
-		// Create a JSON generator while the queries are processed.
-		update_ctx->gen = get_json_generator(&req->pool);
-
-		if (!update_ctx->gen)
-			send_error(INTERNAL_SERVER_ERROR, REQ_ERROR, req);
-	}
-	else
-		send_error(INTERNAL_SERVER_ERROR, REQ_ERROR, req);
-
-	return 0;
+	return do_multiple_queries(true, req);
 }

toolset/setup/linux/systools/mustache-c.sh

@@ -8,7 +8,7 @@ BUILD_DIR="${MUSTACHE_C_HOME}_build"
 git clone 'https://github.com/x86-64/mustache-c.git' "$BUILD_DIR"
 pushd "$BUILD_DIR"
 git checkout 55dafd1e95adaca90ea50efb9a8573786514c85a
-CFLAGS="-march=native" ./configure --prefix="$MUSTACHE_C_HOME"
+CFLAGS="-O3 -flto -march=native" ./configure --prefix="$MUSTACHE_C_HOME"
 make -j "$(nproc)" install
 popd
 rm -rf "$BUILD_DIR"

toolset/setup/linux/webservers/h2o.sh

@@ -3,7 +3,7 @@
 fw_installed h2o && return 0
 
 H2O_HOME="${IROOT}/h2o"
-VERSION="2.1.0"
+VERSION="2.2.0"
 ARCHIVE="v${VERSION}.tar.gz"
 BUILD_DIR="h2o-${VERSION}"