int main(int argc, char *argv[]) { int retcode; use_timeout = (argc >= 2 && strcmp(argv[1], "-t") == 0); if (is_help_requested(argc, argv)) { usage(argv[0], ""); } timeout.tv_sec = (time_t) 200; timeout.tv_nsec = (long) 0; if (use_timeout && argc >= 3) { int t; sscanf(argv[2], "%d", &t); timeout.tv_sec = (time_t) t; } printf("timout(%ld sec %ld msec)\n", (long) timeout.tv_sec, (long) timeout.tv_nsec); pthread_t thread[N_THREADS]; int tidx[N_THREADS]; for (size_t i = 0; i < N_THREADS; i++) { tidx[i] = (int) i; retcode = pthread_create(thread + i, NULL, run, (void *) (tidx + i)); // equivalent: ((void *) tidx) + sizeof(int)*i handle_thread_error(retcode, "creating thread failed", PROCESS_EXIT); } printf("in parent: setting up\n"); pthread_mutex_init(&mutex, NULL); sleep(2); printf("in parent: getting mutex\n"); if (use_timeout) { while (TRUE) { retcode = pthread_mutex_timedlock(&mutex, &timeout); if (retcode == 0) { break; } else if (retcode == ETIMEDOUT) { printf("timed out in parent\n"); } else { handle_thread_error(retcode, "parent failed (timed)lock", PROCESS_EXIT); } } } else { retcode = pthread_mutex_lock(&mutex); handle_thread_error(retcode, "parent failed lock", PROCESS_EXIT); } printf("parent got mutex\n"); sleep(5); printf("parent releases mutex\n"); pthread_mutex_unlock(&mutex); printf("parent released mutex\n"); printf("parent waiting for child to terminate\n"); for (size_t i = 0; i < N_THREADS; i++) { retcode = pthread_join(thread[i], NULL); handle_thread_error(retcode, "join failed", PROCESS_EXIT); printf("joined thread %d\n", (int) i); } pthread_mutex_destroy(&mutex); printf("done\n"); exit(0); }
int main(int argc, char *argv[]) { int retcode; if (is_help_requested(argc, argv)) { usage(argv[0], ""); } int sock; /* Socket descriptor */ struct sockaddr_in server_address; /* Square server address */ unsigned short server_port; /* Square server port */ char *server_ip; /* Server IP address (dotted quad) */ char receive_buffer[RCVBUFSIZE]; /* Buffer for received string */ if (argc < 2 || argc > 3) { /* Test for correct number of arguments */ usage(argv[0], "wrong number of arguments"); } server_ip = argv[1]; /* First arg: server IP address (dotted quad) */ if (argc == 3) { server_port = atoi(argv[2]); /* Use given port, if any */ } else { server_port = 7000; /* 7000 is a free port */ } /* Create a reliable, stream socket using TCP */ sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP); handle_error(sock, "socket() failed", PROCESS_EXIT); /* Construct the server address structure */ memset(&server_address, 0, sizeof(server_address)); /* Zero out structure */ server_address.sin_family = AF_INET; /* Internet address family */ server_address.sin_addr.s_addr = inet_addr(server_ip); /* Server IP address */ server_address.sin_port = htons(server_port); /* Server port: htons host to network byte order */ /* Establish the connection to the square server */ retcode = connect(sock, (struct sockaddr *) &server_address, sizeof(server_address)); handle_error(retcode, "connect() failed", PROCESS_EXIT); const char *cmd_string = "GETX"; /* Send the string to the server */ write_4byte_string(sock, cmd_string); /* Receive the same string containing the square back from the server */ printf("Received: \n"); /* Setup to print the squared string */ while (TRUE) { size_t ulen = read_string_fragmentable(sock, receive_buffer, RCVBUFSIZE, consume); if (ulen == 0) { break; } } const char *done_string = "DONE"; write_4byte_string(sock, done_string); close(sock); printf("\nDONE\n"); exit(0); }
int main(int argc, char *argv[]) { int retcode; if (is_help_requested(argc, argv)) { usage(argv[0], ""); } int server_socket; /* Socket descriptor for server */ int client_socket; /* Socket descriptor for client */ struct sockaddr_in server_address; /* Local address */ struct sockaddr_in client_address; /* Client address */ unsigned short server_port; /* Server port */ unsigned int client_address_len; /* Length of client address data structure */ if (argc != 2) { /* Test for correct number of arguments */ usage(argv[0], "wrong number of arguments"); } server_port = atoi(argv[1]); /* First arg: local port */ /* Create socket for incoming connections */ server_socket = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP); handle_error(server_socket, "socket() failed", PROCESS_EXIT); /* Construct local address structure */ memset(&server_address, 0, sizeof(server_address)); /* Zero out structure */ server_address.sin_family = AF_INET; /* Internet address family */ server_address.sin_addr.s_addr = htonl(INADDR_ANY); /* Any incoming interface */ server_address.sin_port = htons(server_port); /* Local port */ /* Bind to the local address */ retcode = bind(server_socket, (struct sockaddr *) &server_address, sizeof(server_address)); handle_error(retcode, "bind() failed", PROCESS_EXIT); /* Mark the socket so it will listen for incoming connections */ retcode = listen(server_socket, MAXPENDING); handle_error(retcode, "listen() failed", PROCESS_EXIT); while (TRUE) { /* Run forever */ /* Set the size of the in-out parameter */ client_address_len = sizeof(client_address); /* Wait for a client to connect */ client_socket = accept(server_socket, (struct sockaddr *) &client_address, &client_address_len); handle_error(client_socket, "accept() failed", PROCESS_EXIT); printf("Handling client %s\n", inet_ntoa(client_address.sin_addr)); /* client_socket is connected to a client! */ pthread_t thread; int *client_socket_ptr = (int *) malloc(sizeof(int)); *client_socket_ptr = client_socket; pthread_create(&thread, NULL, handle_tcp_client, client_socket_ptr); pthread_detach(thread); } /* NOT REACHED: */ exit(0); }
int main(int argc, char *argv[]) { if (is_help_requested(argc, argv)) { usage(argv[0], ""); } atexit(exit_handler); printf("main stared\n"); pthread_exit(NULL); printf("after exit"); return 0; }
int main(int argc, char *argv[]) { if (is_help_requested(argc, argv)) { usage(argv[0], ""); } out = fopen("myfile", "w"); fwrite(TEXT, 1, strlen(TEXT), out); fwrite(TEXTO, 1, strlen(TEXTO), stdout); fwrite(TEXTE, 1, strlen(TEXTE), stderr); pthread_t thread1, thread2; pthread_create(&thread1, NULL, run, "thread1\n"); pthread_create(&thread2, NULL, run, "thread2\n"); run("main\n"); pthread_join(thread1, NULL); pthread_join(thread2, NULL); printf("joined all\n"); exit(0); }
int main(int argc, char *argv[]) { time_t t_start = time(NULL); if (is_help_requested(argc, argv)) { usage(argv[0], ""); } if (argc > 2) { usage(argv[0], "too many arguments"); } int retcode = 0; create_if_missing(REF_FILE, S_IRUSR | S_IWUSR); key_t shm_key = ftok(REF_FILE, 1); if (shm_key < 0) { handle_error(-1, "ftok failed", PROCESS_EXIT); } key_t sem_key = ftok(REF_FILE, 2); if (sem_key < 0) { handle_error(-1, "ftok failed", PROCESS_EXIT); } if (argc == 2 && strcmp(argv[1], "-s") == 0) { printf("setting up IPC\n"); int shm_id = create_shm(shm_key, "create", "shmget failed", IPC_CREAT); shmid_for_cleanup = shm_id; int semaphore_id = create_sem(sem_key, SEM_SIZE, "create", "semget (data) failed", IPC_CREAT); semid_for_cleanup = semaphore_id; show_sem_ctl(semaphore_id, 0, "semaphore before setup"); setup_sem(semaphore_id, "semaphore setup failed"); show_sem_ctl(semaphore_id, 0, "semaphore after setup"); printf("done\n"); exit(0); } int shm_id = create_shm(shm_key, "create", "shmget failed", 0); shmid_for_cleanup = shm_id; int semaphore_id = create_sem(sem_key, SEM_SIZE, "create", "semget failed", 0); semid_for_cleanup = semaphore_id; if (argc == 2 && strcmp(argv[1], "-c") == 0) { printf("cleaning up IPC\n"); cleanup(); exit(0); } char *name = ""; if (argc == 2) { name = argv[1]; } struct data *shm_data = (struct data *) shmat(shm_id, NULL, 0); time_t total_data_semops_wait = 0; char buffer[BUF_SIZE]; long *counter = shm_data->counter; while (TRUE) { ssize_t size_read = read(STDIN_FILENO, buffer, BUF_SIZE); if (size_read == 0) { /* end of file */ break; } handle_error(size_read, "error while reading stdin", PROCESS_EXIT); int i; for (i = 0; i < size_read; i++) { unsigned char c = buffer[i]; unsigned int ck = c % SEM_SIZE; struct sembuf semops_write; semops_write.sem_num = ck; semops_write.sem_op = -SEM_LIMIT; semops_write.sem_flg = SEM_UNDO; time_t t0 = time(NULL); // show_sem_ctl(semaphore_id, ck, "reserving write semaphore"); retcode = semop(semaphore_id, &semops_write, 1); handle_error(retcode, "error while getting write-semaphore", PROCESS_EXIT); // show_sem_ctl(semaphore_id, ck, "write semaphore reserved"); time_t dt = time(NULL) - t0; total_data_semops_wait += dt; counter[c]++; semops_write.sem_num = ck; semops_write.sem_op = SEM_LIMIT; semops_write.sem_flg = SEM_UNDO; // show_sem_ctl(semaphore_id, ck, "freeing write semaphore"); retcode = semop(semaphore_id, &semops_write, 1); handle_error(retcode, "error while releasing write-semaphore", PROCESS_EXIT); // show_sem_ctl(semaphore_id, ck, "write semaphore freed"); } } time_t total_duration = time(NULL) - t_start; unsigned int i; char output_buffer[16384]; char *output_ptr = output_buffer; int n; int m = 0; n = sprintf(output_ptr, "------------------------------------------------------------\n"); output_ptr += n; m += n; n = sprintf(output_ptr, "%s: pid=%ld\n", name, (long) getpid()); output_ptr += n; m += n; n = sprintf(output_ptr, "total wait for data: ~ %ld sec; total duration: ~ %ld\n", (long) total_data_semops_wait, (long) total_duration); output_ptr += n; m += n; n = sprintf(output_ptr, "------------------------------------------------------------\n"); output_ptr += n; m += n; for (i = 0; i < ALPHA_SIZE; i++) { struct sembuf semops_read; unsigned int ck = (i % SEM_SIZE); semops_read.sem_num = ck; semops_read.sem_op = -1; semops_read.sem_flg = SEM_UNDO; retcode = semop(semaphore_id, &semops_read, 1); handle_error(retcode, "error while getting read-semaphore", PROCESS_EXIT); long *counter = shm_data->counter; long val = counter[i]; semops_read.sem_op = 1; retcode = semop(semaphore_id, &semops_read, 1); handle_error(retcode, "error while releasing read-semaphore", PROCESS_EXIT); if (! (i & 007)) { n = sprintf(output_ptr, "\n"); output_ptr += n; m += n; } if ((i & 0177) < 32 || i == 127) { n = sprintf(output_ptr, "\\%03o: %10ld ", i, val); output_ptr += n; m += n; } else { n = sprintf(output_ptr, "%4c: %10ld ", (char) i, val); output_ptr += n; m += n; } } n = sprintf(output_ptr, "\n\n"); output_ptr += n; m += n; n = sprintf(output_ptr, "------------------------------------------------------------\n\n"); output_ptr += n; m += n; write(STDOUT_FILENO, output_buffer, (size_t) m); exit(0); }
int main(int argc, char *argv[]) { int retcode; if (is_help_requested(argc, argv)) { usage(argv[0], "Help:"); } char *server_ip = get_ip_with_default(argc, argv); unsigned short server_port = get_port_with_default(argc, argv); get_logging_properties(argc, argv); int sock; int interactive = TRUE; int firstRun = TRUE; char *cmd; int cmdLen; int i; for (i = 2; i < argc; i++) { if (strcmp(argv[i], "-c") == 0) { if (i + 2 <= argc ) { interactive = FALSE; i++; cmd = argv[i]; cmdLen = strlen(cmd); } else { usage(argv[0], "please provide a CMD if you're using -c"); } } else if (strcmp(argv[i], "-C") == 0) { if (i + 2 <= argc ) { if(interactive == TRUE) { usage(argv[0], "please provide a first line withe -c if you're using -C"); } i++; cmd = join_with_seperator(cmd, argv[i], "\n"); cmdLen = strlen(cmd); } else { usage(argv[0], "please provide a CMD if you're using -c"); } } } while (firstRun || interactive ) { char *send; if (interactive != TRUE){ send = join_with_seperator(cmd, "", "\n"); } else { char line[2048]; char c; char lastc = '\n'; int i = 0; printf("CMD="); fflush(stdout); while (EOF!= ( c = getc(stdin))) { if (lastc == '\n' && c == '\n') { break; } lastc = c; line[i] = c; i++; } line[i] = '\000'; int n = strlen(line); if (n == 0) { continue; } if (strcmp(line, "QUIT\n") == 0) { printf("terminated by user\n"); break; } send = line; } sock = create_client_socket(server_port, server_ip); log_debug("Sendling: '%s'\n", send); write_to_socket(sock, send); char *buffer_ptr[0]; // Receive command from server size_t received_msg_size = read_from_socket(sock, buffer_ptr); handle_error(received_msg_size, "recive failed", THREAD_EXIT); printf("Response=%s \n", *buffer_ptr); free(*buffer_ptr); close(sock); firstRun = FALSE; } exit(0); }
int main(int argc, char *argv[]) { int retcode; pthread_t *thread; char *argv0 = argv[0]; if (is_help_requested(argc, argv)) { usage(argv0, ""); } if (argc != 3 && argc != 5) { printf("found %d arguments\n", argc - 1); usage(argv0, "wrong number of arguments"); } int opt_idx = 1; int n_idx = 2; use_psort = FALSE; if (argc == 5) { if (strcmp(argv[1], "-p") != 0) { usage(argv0, "wrong first option"); } psort_internal_threads = atoi(argv[2]); opt_idx+=2; n_idx+=2; use_psort = TRUE; } /* TODO consider using getopt instead!! */ char *argv_opt = argv[opt_idx]; if (strlen(argv_opt) != 2 || argv_opt[0] != '-') { usage(argv0, "wrong option"); } char opt_char = argv_opt[1]; switch (opt_char) { case 'h' : selected_mt_sort_type = MT_HEAP_SORT; break; case 't' : selected_mt_sort_type = MT_TERNARY_HEAP_SORT; break; case 'f' : selected_mt_sort_type = MT_FLASH_SORT; break; case 'b' : selected_mt_sort_type = MT_FLASH_SORT_BIN; break; case 'q' : selected_mt_sort_type = MT_QUICK_SORT; break; case 'i' : selected_mt_sort_type = MT_INSERTION_SORT; break; case 'm' : selected_mt_sort_type = MT_MERGE_SORT; break; default: usage(argv0, "wrong option: only -q and -h supported"); break; } thread_count = atoi(argv[n_idx]); if (thread_count < 1 || thread_count > 1024) { printf("running with %d threads\n", thread_count); usage(argv[0], "wrong number of threads"); } struct string_array content = read_to_array(STDIN_FILENO); int len_per_thread = content.len / thread_count; thread = (pthread_t *) malloc(thread_count * sizeof(pthread_t)); segments = (struct thread_arg *) malloc(thread_count * sizeof(struct thread_arg)); retcode = pthread_barrier_init(&barrier, NULL, thread_count); handle_thread_error(retcode, "pthread_barrier_init", PROCESS_EXIT); retcode = pthread_mutex_init(&output_mutex, NULL); handle_thread_error(retcode, "pthread_mutex_init", PROCESS_EXIT); int rest_len = content.len; char **ptr = content.strings; for (int i = 0; i < thread_count; i++) { segments[i].thread_idx = i; segments[i].arr.strings = ptr; if (i == thread_count-1) { segments[i].arr.len = rest_len; } else { segments[i].arr.len = len_per_thread; } ptr += len_per_thread; rest_len -= len_per_thread; /* pthread_mutex_lock(&output_mutex); */ /* printf("main: starting thread %d\n", i); */ /* pthread_mutex_unlock(&output_mutex); */ retcode = pthread_create(&(thread[i]), NULL, thread_run, &(segments[i])); handle_thread_error(retcode, "pthread_create", PROCESS_EXIT); /* pthread_mutex_lock(&output_mutex); */ /* printf("main: started %d\n", i); */ /* pthread_mutex_unlock(&output_mutex); */ } for (int i = 0; i < thread_count; i++) { /* printf("main: joining thread %d\n", i); */ retcode = pthread_join(thread[i], NULL); handle_thread_error(retcode, "pthread_join", PROCESS_EXIT); /* printf("main: joined thread %d\n", i); */ } char_ptr *strings = segments[0].arr.strings; int len = segments[0].arr.len; for (int i = 0; i < len; i++) { /* printf("%5d \"%s\"\n", i, strings[i]); */ printf("%s\n", strings[i]); } pthread_barrier_destroy(&barrier); // printf("DONE\n"); exit(0); }