--- .../testing/selftests/xcall_prefetch/Makefile | 37 ++++ .../selftests/xcall_prefetch/echo_client.c | 119 +++++++++++++ .../xcall_prefetch/echo_client_multi | Bin 0 -> 21896 bytes .../selftests/xcall_prefetch/echo_server.c | 110 ++++++++++++ .../selftests/xcall_prefetch/echo_test.c | 52 ++++++ .../xcall_prefetch/mulit_close_test.c | 48 +++++ .../xcall_prefetch/multi_write_test.c | 77 ++++++++ .../xcall_prefetch/signal_recovery_test.c | 164 ++++++++++++++++++ .../xcall_prefetch/thundering_herd_test.c | 119 +++++++++++++ .../testing/selftests/xcall_prefetch/utils.h | 54 ++++++ .../xcall_prefetch/xcall_prefetch_test.sh | 39 +++++ 11 files changed, 819 insertions(+) create mode 100644 tools/testing/selftests/xcall_prefetch/Makefile create mode 100644 tools/testing/selftests/xcall_prefetch/echo_client.c create mode 100755 tools/testing/selftests/xcall_prefetch/echo_client_multi create mode 100644 tools/testing/selftests/xcall_prefetch/echo_server.c create mode 100644 tools/testing/selftests/xcall_prefetch/echo_test.c create mode 100644 tools/testing/selftests/xcall_prefetch/mulit_close_test.c create mode 100644 tools/testing/selftests/xcall_prefetch/multi_write_test.c create mode 100644 tools/testing/selftests/xcall_prefetch/signal_recovery_test.c create mode 100644 tools/testing/selftests/xcall_prefetch/thundering_herd_test.c create mode 100644 tools/testing/selftests/xcall_prefetch/utils.h create mode 100755 tools/testing/selftests/xcall_prefetch/xcall_prefetch_test.sh diff --git a/tools/testing/selftests/xcall_prefetch/Makefile b/tools/testing/selftests/xcall_prefetch/Makefile new file mode 100644 index 000000000000..5bd509df66e0 --- /dev/null +++ b/tools/testing/selftests/xcall_prefetch/Makefile @@ -0,0 +1,37 @@ +CFLAGS += -Wall -Wextra -g +TEST_GEN_FILES := echo_server echo_client echo_test multi_write_test thundering_herd_test mulit_close_test signal_recovery_test + +# enable debug +# echo_client: CFLAGS += -DDEBUG=1 +# echo_server: CFLAGS += -DDEBUG=1 +# multi_write_test: CFLAGS += -DDEBUG=1 +# thundering_herd_test: CFLAGS += -DDEBUG=1 +# mulit_close_test: CFLAGS += -DDEBUG=1 +# signal_recovery_test: CFLAGS += -DDEBUG=1 + +all: $(TEST_GEN_FILES) + +echo_server: echo_server.c + $(CC) $(CFLAGS) $< -o $@ + +echo_client: echo_client.c + $(CC) $(CFLAGS) $< -o $@ + +echo_test: echo_test.c + $(CC) $(CFLAGS) $< -o $@ + +multi_write_test: multi_write_test.c + $(CC) $(CFLAGS) $< -o $@ + +thundering_herd_test: thundering_herd_test.c + $(CC) $(CFLAGS) $< -o $@ + +mulit_close_test: mulit_close_test.c + $(CC) $(CFLAGS) $< -o $@ + +signal_recovery_test: signal_recovery_test.c + $(CC) $(CFLAGS) $< -o $@ + +.PHONY: all + +include ../lib.mk diff --git a/tools/testing/selftests/xcall_prefetch/echo_client.c b/tools/testing/selftests/xcall_prefetch/echo_client.c new file mode 100644 index 000000000000..2e3c41b2b14e --- /dev/null +++ b/tools/testing/selftests/xcall_prefetch/echo_client.c @@ -0,0 +1,119 @@ +#define _GNU_SOURCE +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <sys/socket.h> +#include <netinet/in.h> +#include <unistd.h> +#include <sys/epoll.h> +#include <arpa/inet.h> +#include <pthread.h> +#include <errno.h> + +#include "./utils.h" + +#define DEBUG + +void *client(void *arg) +{ + int thread_id = *(int *)arg; + int sock = 0; + struct sockaddr_in serv_addr; + struct epoll_event ev, events[MAX_EVENTS]; + const char* test_messages[MAX_MSGS]; + + if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0) { + handle_error("client:%d create socket failed\n", thread_id); + } + serv_addr.sin_family = AF_INET; + serv_addr.sin_port = htons(PORT); + + if (inet_pton(AF_INET, "127.0.0.1", &serv_addr.sin_addr) <= 0) { + close(sock); + handle_error("client:%d invalid address\n", thread_id); + } + if (connect(sock, (struct sockaddr *)&serv_addr, sizeof(serv_addr))) { + close(sock); + handle_error("client:%d connection failed\n", thread_id); + } + + debug_printf("Thread %d connected\n", thread_id); + + int epoll_fd = epoll_create1(0); + if (epoll_fd == -1) { + handle_error("client:%d epoll_create1 failed\n", thread_id); + } + + ev.events = EPOLLIN; + ev.data.fd = sock; + if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, sock, &ev) == -1) { + handle_error("client:%d epoll_ctl add sock failed\n", thread_id); + } + + test_messages[0] = "hello world."; + test_messages[1] = generate_number_string(100); + test_messages[2] = generate_number_string(1024); + test_messages[3] = generate_number_string(4096); + + + for (int i = 0; i < MAX_MSGS; i++) { + const char* msg = test_messages[i]; + ssize_t msg_len = strlen(msg); + if (send(sock, msg, msg_len, 0) != msg_len) { + handle_error("client:%d send failed\n", thread_id); + } + + debug_printf("Client:%d send %s\n", thread_id, msg); + + int nfds = epoll_wait(epoll_fd, events, MAX_EVENTS, -1); + if (nfds == -1) { + handle_error("client:%d epoll_wait failed\n", thread_id); + } + + for (int n = 0; n < nfds; ++n) { + if (events[n].data.fd == sock) { + char buffer[BUFFER_SIZE] = {0}; + ssize_t read_bytes = read(sock, buffer, BUFFER_SIZE); + + if (read_bytes <= 0) { + close(sock); + if (read_bytes == 0) { + handle_error("client:%d server disconnected\n", thread_id); + } else { + handle_error("client:%d read failed\n", thread_id); + } + } else { + debug_printf("Client:%d received %s\n", thread_id, buffer); + if (strncmp(msg, buffer, msg_len) != 0) { + handle_error("client:%d error: response does not match sent message\n", thread_id); + } + } + } + } + } + + close(sock); + pthread_exit(NULL); +} + +int main() +{ + pthread_t threads[NUM_THREADS]; + int ret; + + for (int i = 0; i < NUM_THREADS; i++) { + ret = pthread_create(&threads[i], NULL, client, &i); + if (ret != 0) { + perror("pthread_create failed"); + continue; + } + } + + for (int i = 0; i < NUM_THREADS; i++) { + if (threads[i] != 0) { + pthread_join(threads[i], NULL); + } + } + + return 0; +} \ No newline at end of file diff --git a/tools/testing/selftests/xcall_prefetch/echo_client_multi b/tools/testing/selftests/xcall_prefetch/echo_client_multi new file mode 100755 index 0000000000000000000000000000000000000000..36aa08d6e12f6e8ec73b2a7f8eb567225eb0b2f8 GIT binary patch literal 21896 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 awoFy7Ql!(JO@(L8TPHL=YcsHk?7sjWb7VRI literal 0 HcmV?d00001 diff --git a/tools/testing/selftests/xcall_prefetch/echo_server.c b/tools/testing/selftests/xcall_prefetch/echo_server.c new file mode 100644 index 000000000000..49c1ea035788 --- /dev/null +++ b/tools/testing/selftests/xcall_prefetch/echo_server.c @@ -0,0 +1,110 @@ +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <unistd.h> +#include <sys/socket.h> +#include <netinet/in.h> +#include <sys/epoll.h> +#include <errno.h> +#include <fcntl.h> + +#include "./utils.h" + +static int client_id_counter = 0; +char buffers[NUM_THREADS][BUFFER_SIZE]; + +int main() { + int server_fd, epoll_fd; + struct sockaddr_in address; + struct epoll_event ev, events[MAX_EVENTS]; + struct client_info *clients[MAX_EVENTS] = {0}; + + if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == 0) { + handle_error("socket failed\n"); + } + + address.sin_family = AF_INET; + address.sin_addr.s_addr = INADDR_ANY; + address.sin_port = htons(PORT); + + if (bind(server_fd, (struct sockaddr *)&address, sizeof(address)) < 0) { + handle_error("bind failed\n"); + } + + if (listen(server_fd, 100) < 0) { + handle_error("listen failed\n"); + } + + debug_printf("Server listening on port %d...\n", PORT); + + epoll_fd = epoll_create1(0); + if (epoll_fd == -1) { + handle_error("epoll_create1\n"); + } + + ev.events = EPOLLIN; + ev.data.fd = server_fd; + if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, server_fd, &ev) == -1) { + handle_error("epoll_ctl: server_fd\n"); + } + + while (1) { + int nfds = epoll_wait(epoll_fd, events, MAX_EVENTS, -1); + if (nfds == -1) { + handle_error("epoll_wait failed\n"); + } + + for (int n = 0; n < nfds; ++n) { + if (events[n].data.fd == server_fd) { + int client_fd; + socklen_t addr_len = sizeof(address); + if ((client_fd = accept(server_fd, (struct sockaddr *)&address, &addr_len)) < 0) { + debug_printf("accept failed\n"); + goto fail; + } + + struct client_info *info = malloc(sizeof(struct client_info)); + info->fd = client_fd; + info->id = client_id_counter++; + info->addr = address; + + clients[client_fd] = info; + debug_printf("new connection accepted client:%d\n", info->id); + + int flags = fcntl(client_fd, F_GETFL, 0); + fcntl(client_fd, F_SETFL, flags | O_NONBLOCK); + + ev.events = EPOLLIN | EPOLLET; + ev.data.fd = client_fd; + if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, client_fd, &ev) == -1) { + debug_printf("epoll_ctl: client_fd\n"); + goto fail; + } + } else { + int client_fd = events[n].data.fd; + // char buffer[BUFFER_SIZE] = {0}; + struct client_info *info = clients[client_fd]; + char *buffer = buffers[info->id]; + memset(buffers[info->id], 0, BUFFER_SIZE); + ssize_t read_bytes = read(client_fd, buffer, BUFFER_SIZE); + + if (read_bytes <= 0) { + if (read_bytes == 0) { + debug_printf("client:%d disconnected\n", info->id); + continue; + } else { + debug_printf("read failed\n"); + } + goto fail; + } else { + debug_printf("Server received client:%d %s\n", info->id, buffer); + write(client_fd, buffer, read_bytes); + } + } + } + } + +fail: + close(server_fd); + return -1; +} \ No newline at end of file diff --git a/tools/testing/selftests/xcall_prefetch/echo_test.c b/tools/testing/selftests/xcall_prefetch/echo_test.c new file mode 100644 index 000000000000..fc7180869f3c --- /dev/null +++ b/tools/testing/selftests/xcall_prefetch/echo_test.c @@ -0,0 +1,52 @@ +#include <stdio.h> +#include <stdlib.h> +#include <unistd.h> +#include <sys/wait.h> + +#include "./utils.h" + +int main() { + pid_t server_pid, client_pid; + int server_status, client_status; + + server_pid = fork(); + if (server_pid == 0) { + execl("./echo_server", "./echo_server", NULL); + printf("execl echo_server failed\n"); + exit(EXIT_FAILURE); + } else if (server_pid < 0) { + printf("fork echo_server failed\n"); + exit(EXIT_FAILURE); + } + + sleep(1); + + client_pid = fork(); + if (client_pid == 0) { + execl("./echo_client", "./echo_client", NULL); + printf("execl client failed\n"); + exit(EXIT_FAILURE); + } else if (client_pid < 0) { + printf("fork echo_client failed\n"); + exit(EXIT_FAILURE); + } + + waitpid(client_pid, &client_status, 0); + + kill(server_pid, SIGTERM); + waitpid(server_pid, &server_status, 0); + + if (WIFEXITED(client_status)) { + int exit_code = WEXITSTATUS(client_status); + if (exit_code == 0) { + printf("echo test %sok%s.\n", ANSI_COLOR_GREEN, ANSI_COLOR_RESET); + exit(EXIT_SUCCESS); + } else { + printf("echo test %sfailed%s.\n", ANSI_COLOR_RED, ANSI_COLOR_RESET); + exit(EXIT_FAILURE); + } + } else { + printf("echo test %sfailed%s.\n", ANSI_COLOR_RED, ANSI_COLOR_RESET); + exit(EXIT_FAILURE); + } +} \ No newline at end of file diff --git a/tools/testing/selftests/xcall_prefetch/mulit_close_test.c b/tools/testing/selftests/xcall_prefetch/mulit_close_test.c new file mode 100644 index 000000000000..fae0407e8473 --- /dev/null +++ b/tools/testing/selftests/xcall_prefetch/mulit_close_test.c @@ -0,0 +1,48 @@ +#include <stdio.h> +#include <stdlib.h> +#include <unistd.h> +#include <sys/epoll.h> +#include <sys/socket.h> + +#include "./utils.h" + +int main() { + int epoll_fd; + struct epoll_event ev, events[1]; + int ret = -1; + + int fds[2]; + socketpair(AF_UNIX, SOCK_STREAM, 0, fds); + + epoll_fd = epoll_create1(0); + ev.events = EPOLLIN | EPOLLHUP; + ev.data.fd = fds[0]; + epoll_ctl(epoll_fd, EPOLL_CTL_ADD, fds[0], &ev); + + if (fork() == 0) { + close(fds[1]); + exit(0); + } + + close(fds[1]); + + int nfds = epoll_wait(epoll_fd, events, 1, 1000); + + if (nfds == 1) { + if (events[0].events & EPOLLHUP) { + ret = 0; + } + } + + close(fds[0]); + close(epoll_fd); + if (!ret) { + debug_printf("epoll_wait detected EPOLLHUP!\n"); + printf("multi close test %sok%s.\n", ANSI_COLOR_GREEN, ANSI_COLOR_RESET); + return 0; + } + + printf("multi close test %sfailed%s.\n", ANSI_COLOR_RED, ANSI_COLOR_RESET); + + return -1; +} \ No newline at end of file diff --git a/tools/testing/selftests/xcall_prefetch/multi_write_test.c b/tools/testing/selftests/xcall_prefetch/multi_write_test.c new file mode 100644 index 000000000000..0af07b742e73 --- /dev/null +++ b/tools/testing/selftests/xcall_prefetch/multi_write_test.c @@ -0,0 +1,77 @@ +#include <stdio.h> +#include <stdlib.h> +#include <unistd.h> +#include <sys/epoll.h> +#include <sys/wait.h> + +#include "./utils.h" + +#define NUM_CHILDREN 3 + +int main() { + int epoll_fd, pipe_fd[2]; + struct epoll_event ev, events[MAX_EVENTS]; + char buffer[BUFFER_SIZE]; + + if (pipe(pipe_fd) == -1) { + handle_error("pipe failed\n"); + } + + epoll_fd = epoll_create1(0); + if (epoll_fd == -1) { + handle_error("epoll_create1 failed\n"); + } + + ev.events = EPOLLIN; + ev.data.fd = pipe_fd[0]; + if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, pipe_fd[0], &ev) == -1) { + handle_error("epoll_ctl failed\n"); + } + + for (int i = 0; i < NUM_CHILDREN; i++) { + sleep(1); + pid_t pid = fork(); + if (pid == 0) { + close(pipe_fd[0]); + char msg[10]; + sprintf(msg, "%d %d\n", 2*i, 2*i+1); + write(pipe_fd[1], msg, strlen(msg)); + exit(0); + } else if (pid < 0) { + handle_error("fork failed\n"); + } + } + + sleep(1); + + int nfds = epoll_wait(epoll_fd, events, MAX_EVENTS, -1); + if (nfds == -1) { + handle_error("epoll_wait failed\n"); + } + + debug_printf("epoll_wait returned %d events\n", nfds); + + for (int i = 0; i < nfds; i++) { + if (events[i].data.fd == pipe_fd[0]) { + ssize_t n = read(pipe_fd[0], buffer, BUFFER_SIZE); + if (n > 0) { + debug_printf("Received: %.*s", (int)n, buffer); + } + char *expected_msg = "0 1\n2 3\n4 5\n"; + if (strncmp(expected_msg, buffer, strlen(expected_msg)) != 0) { + printf("multi write test %sfailed%s.\n", ANSI_COLOR_RED, ANSI_COLOR_RESET); + handle_error("expected msg: %s, buffer: %s", expected_msg, buffer); + } + } + } + + for (int i = 0; i < NUM_CHILDREN; i++) { + wait(NULL); + } + + close(pipe_fd[0]); + close(pipe_fd[1]); + close(epoll_fd); + printf("multi write test %sok%s.\n", ANSI_COLOR_GREEN, ANSI_COLOR_RESET); + return 0; +} \ No newline at end of file diff --git a/tools/testing/selftests/xcall_prefetch/signal_recovery_test.c b/tools/testing/selftests/xcall_prefetch/signal_recovery_test.c new file mode 100644 index 000000000000..9645f8ffec1b --- /dev/null +++ b/tools/testing/selftests/xcall_prefetch/signal_recovery_test.c @@ -0,0 +1,164 @@ +#include <stdio.h> +#include <stdlib.h> +#include <unistd.h> +#include <signal.h> +#include <sys/epoll.h> +#include <sys/socket.h> +#include <netinet/in.h> +#include <errno.h> +#include <string.h> +#include <pthread.h> + +#include "./utils.h" + + +int epoll_fd; +int server_fd; +volatile sig_atomic_t signal_received = 0; + +void signal_handler() { + signal_received = 1; +} + +void* worker_thread() { + struct epoll_event events[MAX_EVENTS]; + + while (!signal_received) { + int nfds = epoll_wait(epoll_fd, events, MAX_EVENTS, -1); + if (nfds == -1) { + if (errno == EINTR) { + debug_printf("epoll_wait interrupted by signal! re-waiting...\n"); + continue; + } else { + handle_error("epoll_wait failed\n"); + } + } + + for (int i = 0; i < nfds; i++) { + if (events[i].data.fd == server_fd) { + struct sockaddr_in address; + socklen_t addr_len = sizeof(address); + int client_fd = accept(server_fd, (struct sockaddr*)&address, &addr_len); + if (client_fd < 0) { + handle_error("accept failed\n"); + } + + struct epoll_event ev; + ev.events = EPOLLIN | EPOLLET; + ev.data.fd = client_fd; + if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, client_fd, &ev) < 0) { + close(client_fd); + handle_error("epoll_ctl failed\n"); + } + } else { + char buffer[1024]; + ssize_t n = read(events[i].data.fd, buffer, sizeof(buffer)); + if (n <= 0) { + if (n < 0) { + handle_error("read failed\n"); + } + epoll_ctl(epoll_fd, EPOLL_CTL_DEL, events[i].data.fd, NULL); + close(events[i].data.fd); + debug_printf("closing fd %d\n", events[i].data.fd); + } else { + buffer[n] = '\0'; + debug_printf("receive: %s\n", buffer); + } + } + } + } + + return NULL; +} + +void* client_thread() { + sleep(1); + + int client_fd = socket(AF_INET, SOCK_STREAM, 0); + struct sockaddr_in server_addr = { + .sin_family = AF_INET, + .sin_port = htons(8082), + .sin_addr.s_addr = htonl(INADDR_LOOPBACK), + }; + + if (connect(client_fd, (struct sockaddr*)&server_addr, sizeof(server_addr)) < 0) { + debug_printf("connect failed\n"); + goto fail; + } + + const char *msg = "hello world."; + write(client_fd, msg, strlen(msg)); + close(client_fd); + + sleep(1); + + debug_printf("Sending SIGUSR1 to interrupt epoll_wait...\n"); + kill(getpid(), SIGUSR1); + + sleep(1); + debug_printf("Testing if epoll_wait can still work after signal...\n"); + + client_fd = socket(AF_INET, SOCK_STREAM, 0); + if (connect(client_fd, (struct sockaddr*)&server_addr, sizeof(server_addr)) < 0) { + debug_printf("connect failed\n"); + goto fail; + } + + const char *msg2 = "hello world again."; + if (write(client_fd, msg2, strlen(msg2)) < 0) { + goto fail; + } + + close(client_fd); + return NULL; + +fail: + close(client_fd); + pthread_exit((void *)42); +} + +int main() { + pthread_t worker, client; + + signal(SIGUSR1, signal_handler); + + server_fd = socket(AF_INET, SOCK_STREAM, 0); + struct sockaddr_in addr = { + .sin_family = AF_INET, + .sin_port = htons(8082), + .sin_addr.s_addr = INADDR_ANY, + }; + bind(server_fd, (struct sockaddr*)&addr, sizeof(addr)); + listen(server_fd, SOMAXCONN); + + epoll_fd = epoll_create1(0); + if (epoll_fd < 0) { + handle_error("epoll_create1 failed\n"); + } + + struct epoll_event ev; + ev.events = EPOLLIN | EPOLLET; + ev.data.fd = server_fd; + if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, server_fd, &ev) < 0) { + handle_error("epoll_ctl failed\n"); + } + + pthread_create(&worker, NULL, worker_thread, NULL); + pthread_create(&client, NULL, client_thread, NULL); + + void *retval; + pthread_join(worker, NULL); + pthread_join(client, &retval); + + close(server_fd); + close(epoll_fd); + + if (retval != NULL) { + printf("signal recovery test %sfailed%s.\n", ANSI_COLOR_RED, ANSI_COLOR_RESET); + return -1; + } + + printf("signal recovery test %sok%s.\n", ANSI_COLOR_GREEN, ANSI_COLOR_RESET); + + return 0; +} \ No newline at end of file diff --git a/tools/testing/selftests/xcall_prefetch/thundering_herd_test.c b/tools/testing/selftests/xcall_prefetch/thundering_herd_test.c new file mode 100644 index 000000000000..bf98fcf94b6a --- /dev/null +++ b/tools/testing/selftests/xcall_prefetch/thundering_herd_test.c @@ -0,0 +1,119 @@ +#include <stdio.h> +#include <stdlib.h> +#include <unistd.h> +#include <sys/epoll.h> +#include <sys/socket.h> +#include <netinet/in.h> +#include <sys/wait.h> +#include <string.h> +#include <sys/ipc.h> +#include <sys/shm.h> +#include <fcntl.h> +#include <errno.h> + +#include "./utils.h" + +#define TIMEOUT_MS 1000 + +int create_client_connection() { + struct sockaddr_in addr = { + .sin_family = AF_INET, + .sin_port = htons(8081), + .sin_addr.s_addr = htonl(INADDR_LOOPBACK), + }; + + int fd = socket(AF_INET, SOCK_STREAM, 0); + connect(fd, (struct sockaddr *)&addr, sizeof(addr)); + return fd; +} + +void set_nonblocking(int fd) { + int flags = fcntl(fd, F_GETFL, 0); + fcntl(fd, F_SETFL, flags | O_NONBLOCK); +} + +int main() { + int listen_fd, epoll_fd; + struct sockaddr_in addr = { + .sin_family = AF_INET, + .sin_port = htons(8081), + .sin_addr.s_addr = INADDR_ANY, + }; + + int shm_id = shmget(IPC_PRIVATE, sizeof(int), IPC_CREAT | 0666); + int tmp_cnt; + int *accept_count = (int *)shmat(shm_id, NULL, 0); + *accept_count = 0; + + listen_fd = socket(AF_INET, SOCK_STREAM, 0); + set_nonblocking(listen_fd); + int reuse = 1; + setsockopt(listen_fd, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse)); + bind(listen_fd, (struct sockaddr *)&addr, sizeof(addr)); + listen(listen_fd, SOMAXCONN); + + for (int i = 0; i < NUM_THREADS; i++) { + if (fork() == 0) { + usleep(1000 * i); + epoll_fd = epoll_create1(0); + struct epoll_event ev = { + .events = EPOLLIN | EPOLLET, + .data.fd = listen_fd, + }; + epoll_ctl(epoll_fd, EPOLL_CTL_ADD, listen_fd, &ev); + + debug_printf("Worker %d waiting...\n", getpid()); + + struct epoll_event events[MAX_EVENTS]; + int nfds = epoll_wait(epoll_fd, events, MAX_EVENTS, TIMEOUT_MS); + + if (nfds == -1) { + handle_error("epoll_wait failed\n"); + } + + debug_printf("Worker %d: epoll_wait returned %d events\n", getpid(), nfds); + + int client_fd = accept(listen_fd, NULL, NULL); + if (client_fd >= 0) { + debug_printf("Worker %d accepted a connection!\n", getpid()); + __sync_fetch_and_add(accept_count, 1); + close(client_fd); + } else if (errno != EAGAIN && errno != EWOULDBLOCK) { + debug_printf("accept failed\n"); + } + + close(epoll_fd); + exit(0); + } + } + + sleep(1); + + debug_printf("Parent creating client connection...\n"); + int client_fd = create_client_connection(); + sleep(1); + close(client_fd); + + int waited = 0; + for (int i = 0; i < NUM_THREADS; i++) { + if (wait(NULL) < 0 && errno == ECHILD) { + break; + } + waited++; + } + + tmp_cnt = *accept_count; + debug_printf("Total successful accepts: %d\n", tmp_cnt); + + shmdt(accept_count); + shmctl(shm_id, IPC_RMID, NULL); + close(listen_fd); + + if (tmp_cnt == 1) { + printf("thundering herd test %sok%s.\n", ANSI_COLOR_GREEN, ANSI_COLOR_RESET); + return 0; + } else { + printf("thundering herd test %sfailed%s.\n", ANSI_COLOR_RED, ANSI_COLOR_RESET); + return -1; + } +} \ No newline at end of file diff --git a/tools/testing/selftests/xcall_prefetch/utils.h b/tools/testing/selftests/xcall_prefetch/utils.h new file mode 100644 index 000000000000..58959c564119 --- /dev/null +++ b/tools/testing/selftests/xcall_prefetch/utils.h @@ -0,0 +1,54 @@ +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <netinet/in.h> + +#define ANSI_COLOR_GREEN "\x1b[32m" +#define ANSI_COLOR_RED "\x1b[31m" +#define ANSI_COLOR_RESET "\x1b[0m" + +#define PORT 8080 +#define BUFFER_SIZE 4097 +#define MAX_EVENTS 100 +#define MAX_MSGS 4 +#define NUM_THREADS 4 + +#ifdef DEBUG +#define debug_printf(fmt, ...) (printf(fmt, ##__VA_ARGS__)) +#else +#define debug_printf(fmt, ...) (void)fmt +#endif + +struct client_info { + int fd; + int id; + struct sockaddr_in addr; +}; + +void handle_error(const char *format, ...) +{ + printf("%s", format); + exit(EXIT_FAILURE); +} + +char* generate_number_string(int length) +{ + if (length <= 0) { + printf("\nnumber string length invalid\n"); + return NULL; + } + + char* result = (char*)malloc((length + 1) * sizeof(char)); + if (result == NULL) { + printf("\nnumber string malloc failed\n"); + return NULL; + } + + for (int i = 0; i < length; i++) { + result[i] = '0' + (i % 10); + } + + result[length] = '\0'; + + return result; +} \ No newline at end of file diff --git a/tools/testing/selftests/xcall_prefetch/xcall_prefetch_test.sh b/tools/testing/selftests/xcall_prefetch/xcall_prefetch_test.sh new file mode 100755 index 000000000000..e9a990dac69a --- /dev/null +++ b/tools/testing/selftests/xcall_prefetch/xcall_prefetch_test.sh @@ -0,0 +1,39 @@ +#!/bin/bash + +RED="\033[31m" +GREEN="\033[32m" +RESET="\033[0m" + +make clean +make + +if [ -e "/proc/$$/xcall" ]; then + echo 22 > "/proc/$$/xcall" + echo @22 > "/proc/$$/xcall" + echo "enable xcall epoll prefetch, pid is $$." +else + echo "Warnning: not enable xcall." +fi + +./echo_test +sleep 1 + +./multi_write_test +sleep 1 + +./thundering_herd_test +sleep 1 + +./mulit_close_test +sleep 1 + +./signal_recovery_test +sleep 1 + +if [ $? -eq 0 ]; then + echo -e "${GREEN}tests passed successfully.${RESET}" + exit 0 +else + echo -e "${RED}tests failed.${RESET}" + exit 1 +fi \ No newline at end of file -- 2.34.1