void runserver(int numthreads, unsigned short serverport) { ////////////////////////////////////////////////// // create your pool of threads here ////////////////////////////////////////////////// int main_socket = prepare_server_socket(serverport); if (main_socket < 0) { exit(-1); } signal(SIGINT, signal_handler); struct sockaddr_in client_address; socklen_t addr_len; fprintf(stderr, "Server listening on port %d. Going into request loop.\n", serverport); while (still_running) { struct pollfd pfd = {main_socket, POLLIN}; int prv = poll(&pfd, 1, 10000); if (prv == 0) { continue; } else if (prv < 0) { PRINT_ERROR("poll"); still_running = FALSE; continue; } addr_len = sizeof(client_address); memset(&client_address, 0, addr_len); int new_sock = accept(main_socket, (struct sockaddr *)&client_address, &addr_len); if (new_sock > 0) { fprintf(stderr, "Got connection from %s:%d\n", inet_ntoa(client_address.sin_addr), ntohs(client_address.sin_port)); //////////////////////////////////////////////////////// /* You got a new connection. Hand the connection off * to one of the threads in the pool to process the * request. * * Don't forget to close the socket (in the worker thread) * when you're done. */ //////////////////////////////////////////////////////// } } fprintf(stderr, "Server shutting down.\n"); close(main_socket); }
void runserver(int numthreads, unsigned short serverport) { /////////////////////////////////////////////////////////////// int i=0; for(;i<numthreads;i++){ pthread_t thread; pthread_create(&thread,NULL, &worker_start, NULL); } printf("made %d threads\n", numthreads); ////////////////////////////////////////////////////////////// int main_socket = prepare_server_socket(serverport); if (main_socket < 0) { exit(-1); } signal(SIGINT, signal_handler); struct sockaddr_in client_address; socklen_t addr_len; fprintf(stderr, "Server listening on port %d. Going into request loop.\n", serverport); while (still_running) { struct pollfd pfd = {main_socket, POLLIN}; int prv = poll(&pfd, 1, 10000); if (prv == 0) { continue; } else if (prv < 0) { PRINT_ERROR("poll"); still_running = FALSE; continue; } addr_len = sizeof(client_address); memset(&client_address, 0, addr_len); int new_sock = accept(main_socket, (struct sockaddr *)&client_address, &addr_len); if (new_sock > 0) { time_t now = time(NULL); char* ip = inet_ntoa(client_address.sin_addr); int port = ntohs(client_address.sin_port); fprintf(stderr, "Got connection from %s:%d at %s\n", ip, port, ctime(&now)); ///////////////////////////////////////////////////////////////////// queue_add_head(new_sock, ip, port); printf("added to queue\n"); pthread_cond_signal(&cond); ///////////////////////////////////////////////////////////////////// } } pthread_cond_broadcast(&cond); fprintf(stderr, "Server shutting down.\n"); close(main_socket); }
/* Worker thread that waits for JVM migration */ static void JNICALL worker2(jvmtiEnv* jvmti, JNIEnv* jni, void *p) { char buffer[256]; struct sockaddr_in cli_addr; socklen_t clilen = sizeof(cli_addr); pid_t pid = getpid(); int sockfd = prepare_server_socket(); if(sockfd < 0) { fprintf(log, "ERROR: unable to create proxy server... exiting.\n"); fflush(log); return; } while(true) { coord_sock = accept(sockfd, (struct sockaddr *) &cli_addr, &clilen); if (coord_sock < 0) { fprintf(log, "ERROR: connection accept failed.\n"); return; } // Write PID if (write(coord_sock, &pid, sizeof(pid_t)) < 0) { fprintf(log, "ERROR: unable to send pid (%u)\n", pid); } // Read Command if(read(coord_sock, buffer, 256) < 0) { fprintf(log, "ERROR: failed to read from socket.\n"); } else if(!strncmp(buffer, PREPARE_MIGRATION, sizeof(PREPARE_MIGRATION))) { fprintf(log, "Prepare Migration\n"); agent_sock = prepare_client_socket(PROXY_SOCK_PORT); // closed at finish prepare_marking = 1; jvmti->PrepareMigration(0); fprintf(log, "Going to sleep\n"); sem_wait(&semph); fprintf(log, "Comming from sleep\n"); prepare_migration = 1; jvmti->PrepareMigration(min_migration_bandwidth); } else { fprintf(log, "ERROR: received unknown message. Ignoring...\n"); } fflush(log); } }
void runserver(int numthreads, unsigned short serverport) { //setting up args// pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; pthread_cond_t worker = PTHREAD_COND_INITIALIZER; pthread_cond_t producer = PTHREAD_COND_INITIALIZER; int nextin = 0; int nextout = 0; int requests = 0; int sockets[numthreads];//stores the socket numbers, how the threads will know what socket to send a file to struct sockaddr_in addrs[numthreads]; //socket addresses, this with the sockets array will tell the workers where to send info threadargs temparg;//dummy arg temparg.mutex = &mutex; temparg.worker = &worker; temparg.producer = &producer; //nextin, nextout, and requests will all be pointers to an in b/c they will be shared amongst all threads to help w/ concurrency temparg.nextin = &nextin; temparg.nextout = &nextout; temparg.requests = &requests; temparg.numthreads = numthreads; struct sockaddr_in holdaddr; int i = 0; for(;i<numthreads;i++){//initialze lists sockets[i] = 0; addrs[i] = holdaddr; } temparg.socketnumber = &sockets;//use a pointer to these lists to enable sharing temparg.saddr = &addrs; //whew.. all done w/ that, now lets make some threads pthread_t workers[numthreads]; i = 0; for(; i<numthreads;i++){ pthread_create(&workers[i], NULL, dowork, (void*)&temparg);//make the lists } // create your pool of threads here ////////////////////////////////////////////////// int main_socket = prepare_server_socket(serverport); //set up constant part of threadarguments// if (main_socket < 0) { exit(-1); } signal(SIGINT, signal_handler); struct sockaddr_in client_address; socklen_t addr_len; fprintf(stderr, "Server listening on port %d. Going into request loop.\n", serverport); while (still_running) { struct pollfd pfd = {main_socket, POLLIN}; int prv = poll(&pfd, 1, 10000); if (prv == 0) { continue; } else if (prv < 0) { PRINT_ERROR("poll"); still_running = FALSE; continue; } addr_len = sizeof(client_address); memset(&client_address, 0, addr_len); int new_sock = accept(main_socket, (struct sockaddr *)&client_address, &addr_len); if (new_sock > 0) { fprintf(stderr, "Got connection from %s:%d\n", inet_ntoa(client_address.sin_addr), ntohs(client_address.sin_port)); //////////////////////////////////////////////////////// pthread_mutex_lock(&mutex); while (requests == numthreads){//dont give us too much work pthread_cond_wait(&producer, &mutex); } sockets[nextin] = new_sock;//update the socket info addrs[nextin] = client_address;//and the address nextin = (nextin +1) % numthreads;//overwrite last used bin requests++;//one more task pthread_cond_signal(&worker); pthread_mutex_unlock(&mutex); //////////////////////////////////////////////////////// } } //closeing threads -- eventually will be refactored into a function for(;i<requests;i++){ pthread_cond_signal(&worker);//clear out the rest of the requests } sockets[nextout] = -9999;//alert threads that we're closing i = 0; requests = numthreads+1; for(; i <numthreads;i++){//all threads should have exited pthread_cond_signal(&worker); } i = 0; for(; i <numthreads;i++){//pick up the scraps pthread_join(workers[i], NULL); } fprintf(stderr, "Server shutting down.\n"); pthread_mutex_destroy(&mutex); pthread_cond_destroy(&worker); pthread_cond_destroy(&producer); close(main_socket); }
void runserver(int numthreads, unsigned short serverport) { ////////////////////////////////////////////////// // create your pool of threads here //pthread_t p1; // pthread_t threadarray [numthreads]; int x = 0; for(; x < numthreads; x++) { pthread_create(&(threadarray[x]),NULL, worker_function, NULL); } ////////////////////////////////////////////////// int main_socket = prepare_server_socket(serverport); if (main_socket < 0) { exit(-1); } signal(SIGINT, signal_handler); struct sockaddr_in client_address; socklen_t addr_len; fprintf(stderr, "Server listening on port %d. Going into request loop.\n", serverport); while (still_running) { //printf("%s", "loop"); //fflush(stdout); struct pollfd pfd = {main_socket, POLLIN}; int prv = poll(&pfd, 1, 10000); if (prv == 0) { continue; } else if (prv < 0) { PRINT_ERROR("poll"); still_running = FALSE; continue; } addr_len = sizeof(client_address); memset(&client_address, 0, addr_len); int new_sock = accept(main_socket, (struct sockaddr *)&client_address, &addr_len); if (new_sock > 0) { time_t now = time(NULL); fprintf(stderr, "Got connection from %s:%d at %s\n", inet_ntoa(client_address.sin_addr), ntohs(client_address.sin_port), ctime(&now)); //////////////////////////////////////////////////////// /* You got a new connection. Hand the connection off * to one of the threads in the pool to process the * request. * * Don't forget to close the socket (in the worker thread) * when you're done. */ //////////////////////////////////////////////////////// struct work_queue_item * newnode = (struct work_queue_item *) malloc(sizeof(struct work_queue_item)); newnode->sock = new_sock; pthread_mutex_lock(&work_mutex); if (head != NULL) { head->previous = newnode; } else { tail = newnode; } newnode->next = head; head = newnode; newnode->previous = NULL; newnode->port = ntohs(client_address.sin_port); newnode->ip =inet_ntoa(client_address.sin_addr); queue_count++; pthread_cond_signal(&work_cond); pthread_mutex_unlock(&work_mutex); senddata(new_sock, HTTP_200, strlen(HTTP_200)); } } while(queue_count > 0); //spin wait for threads to finish queue_count = -1; //when signal all threads should break and be free! pthread_cond_broadcast(&work_cond); x = 0; for(; x < numthreads; x++) { pthread_join(threadarray[x], NULL); } fprintf(stderr, "Server shutting down.\n"); close(main_socket); }
void runserver(int numthreads, unsigned short serverport) { ////////////////////////////////////////////////// // create your pool of threads here ////////////////////////////////////////////////// //Initialize socket queue socket_pool_t *mysockets = malloc(sizeof(socket_pool_t)); socket_pool_init(mysockets); struct thread_args *myargs = malloc(sizeof(struct thread_args)); myargs->sockets = mysockets; //myargs->weblog = fopen(NULL,"weblog.txt"); pthread_t threadpool[numthreads]; int i=0; //for loop to initialize threads in threadpool for (; i<numthreads; i++){ if (0 > pthread_create(&threadpool[i], NULL, (void *)consumer, myargs)){ fprintf(stderr, "Error creating thread: %s\n", strerror(errno)); } } int main_socket = prepare_server_socket(serverport); if (main_socket < 0) { exit(-1); } signal(SIGINT, signal_handler); struct sockaddr_in client_address; socklen_t addr_len; fprintf(stderr, "Server listening on port %d. Going into request loop.\n", serverport); while (still_running) { struct pollfd pfd = {main_socket, POLLIN}; int prv = poll(&pfd, 1, 10000); if (prv == 0) { continue; } else if (prv < 0) { PRINT_ERROR("poll"); still_running = FALSE; continue; } addr_len = sizeof(client_address); memset(&client_address, 0, addr_len); int new_sock = accept(main_socket, (struct sockaddr *)&client_address, &addr_len); if (new_sock > 0) { fprintf(stderr, "Got connection from %s:%d\n", inet_ntoa(client_address.sin_addr), ntohs(client_address.sin_port)); //////////////////////////////////////////////////////// /* You got a new connection. Hand the connection off * to one of the threads in the pool to process the * request. * * Don't forget to close the socket (in the worker thread) * when you're done. */ //////////////////////////////////////////////////////// pthread_mutex_lock(&mysockets->socket_pool_lock); add_socket(mysockets, new_sock); pthread_mutex_unlock(&mysockets->socket_pool_lock); get_new_socket(mysockets); close(new_sock); } } fprintf(stderr, "Server shutting down.\n"); close(main_socket); }
void runserver(int num_threads, unsigned short serverport) { struct node **sock_list[2]; //to contain pointers to head and tail for passing to threads struct node *head = NULL; struct node *tail = NULL; sock_list[0] = &head; sock_list[1] = &tail; //to pass to new threads pthread_t threads[num_threads]; int i = 0; // start up the threads; they'll start trying to consume immeidately for (i = 0; i < num_threads; i++) { if (0 > pthread_create(&threads[i], NULL, worker, (void*)&sock_list)) { fprintf(stderr, "Error creating thread: %s\n", strerror(errno)); } } int main_socket = prepare_server_socket(serverport); if (main_socket < 0){ exit(-1); } signal(SIGINT, signal_handler); struct sockaddr_in client_address; socklen_t addr_len; fprintf(stderr, "Server listening on port %d. Going into request loop.\n", serverport); //thread pool set up and a-okay by now while (still_running) { struct pollfd pfd = {main_socket, POLLIN}; int prv = poll(&pfd, 1, 10000); if (prv == 0) { continue; } else if (prv < 0) { PRINT_ERROR("poll"); still_running = FALSE; continue; } addr_len = sizeof(client_address); memset(&client_address, 0, addr_len); int new_sock = accept(main_socket, (struct sockaddr *)&client_address, &addr_len); if (new_sock > 0) { fprintf(stderr, "Got connection from %s:%d\n", inet_ntoa(client_address.sin_addr), ntohs(client_address.sin_port)); produce_cnct(new_sock, client_address, &head, &tail); //inserting socket at end of linked list. Only executed on main thread } } fprintf(stderr, "Server shutting down.\n"); // threads are done doing work // wait for workers to complete pthread_cond_broadcast(&consumer); //wakes up all the consumers, which will then escape and stop running for (i = 0; i < num_threads; i++) { pthread_join(threads[i], NULL); } printf("threads woken up"); close(main_socket); }
void runserver(int numthreads, unsigned short serverport) { ////////////////////////////////////////////////// linkedlist* socks = malloc(sizeof(linkedlist)); socks-> head = malloc(sizeof(struct node)); (socks->head)->socket = -1; socks->tail = socks->head; socks->listlock = malloc(sizeof(pthread_mutex_t)); pthread_mutex_init(socks->listlock, NULL); socks->listempty = malloc(sizeof(pthread_cond_t)); pthread_cond_init(socks->listempty,NULL); // create your pool of threads here if(numthreads<1){ numthreads = 1; } pthread_t** threads = malloc(sizeof(pthread_t*)*numthreads); int i = 0; for(; i < numthreads; i++){ threads[i] = malloc(sizeof(pthread_t)); pthread_create(threads[i], NULL, sock_consume, (void*)socks); } ////////////////////////////////////////////////// int main_socket = prepare_server_socket(serverport); if (main_socket < 0) { exit(-1); } signal(SIGINT, signal_handler); struct sockaddr_in client_address; socklen_t addr_len; fprintf(stderr, "Server listening on port %d. Going into request loop.\n", serverport); while (still_running) { struct pollfd pfd = {main_socket, POLLIN}; int prv = poll(&pfd, 1, 10000); if (prv == 0) { continue; } else if (prv < 0) { PRINT_ERROR("poll"); still_running = FALSE; continue; } addr_len = sizeof(client_address); memset(&client_address, 0, addr_len); int new_sock = accept(main_socket, (struct sockaddr *)&client_address, &addr_len); if (new_sock > 0) { fprintf(stderr, "Got connection from %s:%d\n", inet_ntoa(client_address.sin_addr), ntohs(client_address.sin_port)); //////////////////////////////////////////////////////// /* You got a new connection. Hand the connection off * to one of the threads in the pool to process the * request. * * Don't forget to close the socket (in the worker thread) * when you're done. */ //////////////////////////////////////////////////////// pthread_mutex_lock(socks-> listlock); list_insert(new_sock, &socks->tail); (socks->tail)-> ip = strdup(inet_ntoa(client_address.sin_addr)); //malloc! The free is taken care of in list_remove. (socks->tail)-> port = ntohs(client_address.sin_port); pthread_cond_broadcast(socks->listempty); pthread_mutex_unlock(socks->listlock); } } i = 0; for(; i < numthreads; i++){ pthread_join(*(threads[i]), NULL); free(threads[i]); } free(threads); free(socks->listlock); free(socks->listempty); free(socks); fprintf(stderr, "Server shutting down.\n"); close(main_socket); }