From 50eeba56a4e3ed0072c036c34585fdc2d34076a4 Mon Sep 17 00:00:00 2001 From: ubuntu201711081 <201711081@jbnu.ac.kr> Date: Mon, 7 Dec 2020 09:17:01 +0000 Subject: [PATCH] refactor client.c --- client.c | 211 +++++++++++++++++++++++++++++++++++-------------------- 1 file changed, 135 insertions(+), 76 deletions(-) diff --git a/client.c b/client.c index 53c0f0f..bafea34 100644 --- a/client.c +++ b/client.c @@ -187,7 +187,9 @@ int SendOpAndReceiveFile(const char * filename, struct sockaddr const * addr){ close(sock); return ret; } - +//==== +//bench +//==== struct benchmark_data{ bool benchmode; struct timespec begin; @@ -207,22 +209,75 @@ void init_bench_data(){ clock_getres(bench.clock_id,&bench.resolution); } } - -static size_t thread_number_option = 1; - +//==== +//simple queue +//==== typedef enum{ From_CharArray, From_FileStream } queueing_method_t; +typedef struct SimpleCharQueue{ + queueing_method_t method; + const char ** filename_begin; + const char ** filename_end; + FILE * fs; +} simple_queue_t; +// +// q have lifetime of arg b or arg e. +// do not deallocate before queue closed. +static bool init_queue_from_chararray(simple_queue_t * restrict q,const char ** b, const char ** e){ + q->method = From_CharArray; + q->filename_begin = b; + q->filename_end = e; + return true; +} +// +// q have lifetime of arg f. +// do not close file f before queue closed. +static bool init_queue_from_file(simple_queue_t * restrict q, FILE * f){ + q->method = From_CharArray; + q->fs = f; + return true; +} + +static const char * dequeue_from_simplecharqueue(simple_queue_t * restrict q,char * restrict buf, size_t size){ + const char * filename; + if (q->method == From_CharArray){ + if (__glibc_unlikely(q->filename_begin == q->filename_end)) { + return NULL; + } + filename = *(q->filename_begin++); + } + else{ + //unsafe. + int t = fscanf(q->fs,"%s",buf); + if (__glibc_unlikely(t != 1)) { + return NULL; + } + filename = buf; + } + return filename; +} +//==== +//thread +//==== struct SimpleThreadGlobal{ size_t thread_arr_size; pthread_t * thread_arr; pthread_mutex_t queueing_mutex; - queueing_method_t method; - const char ** filename_begin; - const char ** filename_end; + simple_queue_t queue; } global_state; +//if initialization is success, return true +bool init_global_state(struct SimpleThreadGlobal * t, size_t size){ + pthread_mutex_init(&t->queueing_mutex,NULL); + t->thread_arr_size = size; + t->thread_arr = (pthread_t *)malloc(sizeof(*global_state.thread_arr) * global_state.thread_arr_size); + if (t->thread_arr == NULL){ + return false; + } + return true; +} typedef struct SimpleThreadReturn{ int retval; @@ -249,7 +304,6 @@ void destroy_thread_arg(worker_arg_t * arg){ free(arg); } - void * WorkerProc(void * args){ worker_arg_t * arg = (worker_arg_t *)(args); worker_return_t * ret = create_worker_return(); @@ -258,123 +312,128 @@ void * WorkerProc(void * args){ for(;;) { pthread_mutex_lock(&global_state.queueing_mutex); - if (global_state.method == From_CharArray){ - if (__glibc_unlikely(global_state.filename_begin == global_state.filename_end)) { - pthread_mutex_unlock(&global_state.queueing_mutex); - break; - } - filename = *(global_state.filename_begin++); - } - else{ - //unsafe. - int t = fscanf(stdin,"%s",filename_buf); - if (__glibc_unlikely(t != 1)) { - pthread_mutex_unlock(&global_state.queueing_mutex); - break; - } - filename = filename_buf; - } + filename = dequeue_from_simplecharqueue(&global_state.queue,filename_buf,FILENAME_BUF_SIZE); pthread_mutex_unlock(&global_state.queueing_mutex); - + if(filename == NULL) break; ret->retval += SendOpAndReceiveFile(filename,&arg->addr); ret->op_count++; } destroy_thread_arg(arg); return ret; } - -static bool stdinisatty; - -int main(int argc, const char *argv[]){ - struct sockaddr_in addr; - const char * filename; +//==== +// cmd parse +//==== +static struct { const char * server_name; - in_port_t server_port = 0; - int arg_filename_start = 3; - int err; - int retval = 0; + in_port_t server_port; + bool stdinisatty; + int thread_number_option; +} cmd_args = { + .server_name = "", + .server_port = 0 +}; - init_bench_data(); - stdinisatty = isatty(STDIN_FILENO); +static const char * show_help_message(FILE * file,const char * argv0){ + static const char * msg = + "USAUE: %s SERVERNAME PORT [Option]... [FILENAME]...\n" + "Options and arguments: \n" + "-b or --benchmark\t:benchmark mode\n" + "-nv or --no-verbose\t:no progress bar\n" + "-h\t:print help message.\n"; + fprintf(file,msg,argv0); + return msg; +} - if (argc < (stdinisatty ? 4 : 3)){ - fprintf(stderr,"USAUE: %s SERVERNAME PORT [Option]... [FILENAME]...\n",argv[0]); +static int parse_arg(int argc,const char *argv[]){ + int cur; + cmd_args.stdinisatty = isatty(STDIN_FILENO); + if (argc < (cmd_args.stdinisatty ? 4 : 3)){ + show_help_message(stderr,argv[0]); return 1; } - server_name = argv[1]; - server_port = atoi(argv[2]); - while(arg_filename_start < argc){ - if (strcmp("-b",argv[arg_filename_start])==0 - ||strcmp("--benchmark",argv[arg_filename_start])==0){ - arg_filename_start++; + cmd_args.server_name = argv[1]; + cmd_args.server_port = atoi(argv[2]); + if (cmd_args.server_port == 0){ + fprintf(stderr,"port invalid\n"); + return -1; + } + cmd_args.thread_number_option = 1; + for(cur = 3;cur < argc; cur++){ + if (strcmp("-b",argv[cur])==0||strcmp("--benchmark",argv[cur])==0){ bench.benchmode = true; } - else if(strcmp("-nv",argv[arg_filename_start]) == 0||strcmp("--no-verbose",argv[arg_filename_start])==0){ - arg_filename_start++; + else if(strcmp("-nv",argv[cur]) == 0||strcmp("--no-verbose",argv[cur])==0){ DisplayProgress = false; } - else if(strcmp("-t",argv[arg_filename_start]) == 0 || strcmp("--thread",argv[arg_filename_start]) == 0){ - arg_filename_start++; - if (arg_filename_start >= argc){ + else if(strcmp("-t",argv[cur]) == 0 || strcmp("--thread",argv[cur]) == 0){ + cur++; + if (cur >= argc){ fprintf(stderr,"need number"); return -2; } - thread_number_option = atoi(argv[arg_filename_start++]); - if(thread_number_option == 0){ + cmd_args.thread_number_option = atoi(argv[cur]); + if(cmd_args.thread_number_option == 0){ fprintf(stderr,"not number or zero"); return -2; } } + else if(strcmp("-h",argv[cur]) == 0 || strcmp("--help",argv[cur]) == 0){ + show_help_message(stdout,argv[0]); + return 0; + } else break; } - if (server_port == 0){ - fprintf(stderr,"port invalid\n"); - return 1; + if (cmd_args.stdinisatty){ + init_queue_from_chararray(&global_state.queue, &argv[cur],&argv[argc]); } + else{ + init_queue_from_file(&global_state.queue,stdin); + } + + return 0; +} - err = getsockaddrbyname(AF_INET,SOCK_STREAM,0,server_name,(struct sockaddr *)&addr); +int main(int argc, const char *argv[]){ + struct sockaddr_in addr; + const char * filename; + int err; + int retval = 0; + + init_bench_data(); + if(parse_arg(argc,argv) < 0) return EXIT_FAILURE; + + err = getsockaddrbyname(AF_INET,SOCK_STREAM,0,cmd_args.server_name,(struct sockaddr *)&addr); if (err != 0){ int check; fprintf(stderr,"netdb fail: %s\n",gai_strerror(err)); //assume that sernmae is *.*.*.* and try to parse addr - check = inet_pton(AF_INET,server_name,&addr.sin_addr); + check = inet_pton(AF_INET,cmd_args.server_name,&addr.sin_addr); assert(check != -1); if (check == 0){ fprintf(stderr,"parsing fail : invaild format\n"); - return 1; + return -1; } } addr.sin_family = AF_INET; - addr.sin_port = htons(server_port); + addr.sin_port = htons(cmd_args.server_port); if (bench.benchmode){ clock_gettime(bench.clock_id,&bench.begin); } - if(thread_number_option == 1){ + if(cmd_args.thread_number_option == 1){ char filename_buf[FILENAME_BUF_SIZE]; for (;;){ - if (stdinisatty){ - if (arg_filename_start >= argc) break; - filename = argv[arg_filename_start++]; - } - else{ - //unsafe. - int t = fscanf(stdin,"%s",filename_buf); - if (t != 1) break; - filename = filename_buf; - } + filename = dequeue_from_simplecharqueue(&global_state.queue,filename_buf,FILENAME_BUF_SIZE); + if (filename == NULL) break; + retval += SendOpAndReceiveFile(filename,(struct sockaddr *)&addr); bench.op_count++; } } else{ int i = 0; - global_state.method = stdinisatty ? From_CharArray : From_FileStream; - global_state.filename_begin = &argv[arg_filename_start]; - global_state.filename_end = &argv[argc]; - pthread_mutex_init(&global_state.queueing_mutex,NULL); - global_state.thread_arr_size = thread_number_option; - global_state.thread_arr = (pthread_t *)malloc(sizeof(*global_state.thread_arr) * global_state.thread_arr_size); + init_global_state(&global_state,cmd_args.thread_number_option); for (i = 0; i < global_state.thread_arr_size; i++){ worker_arg_t * arg = create_thread_arg((struct sockaddr *)&addr); pthread_create(&global_state.thread_arr[i],NULL,WorkerProc,arg);