void *thread_work(void *ptr){ //printf("entered worker thread \n"); mapreduce_t* mr = (mapreduce_t*)ptr; int counter = num_process; int i; char s[size_buf][BUFFER_SIZE + 1]; for(i=0;i<size_buf;i++) s[i][0]='\0'; while (counter) { struct epoll_event ev; epoll_wait(epoll_fd,&ev,1,-1); // printf("read data from pipe%d\n",ev.data.fd); int ret=read_from_fd(ev.data.fd, s[ev.data.fd-1], mr); if(ret==0){ --counter; // printf("read failed counter =%d\n",counter+1); //if finished read one pipe epoll_ctl(epoll_fd,EPOLL_CTL_DEL,ev.data.fd,NULL); } } /* close unused pipes */ /* add your code here */ /*for(i=0;i<num_process;i++) //close all read side of pipe close(fd[i][0]); */ //printf("exit"); return NULL; }
static int calc_chunk_metrics( f_c * ebuf, f_c * rbuf, f_c * tbuf ) { char buf[CHUNKBYTES]; double *chunk_window; int chunkcount = 0; f_c *in, *out; f_p p; in = fftw_malloc( sizeof( f_c ) * CHUNKSAMPS ); assert( in != NULL ); out = fftw_malloc( sizeof( f_c ) * CHUNKSAMPS ); assert( out != NULL ); p = fftw_plan_dft_1d( CHUNKSAMPS, in, out, FFTW_FORWARD, FFTW_ESTIMATE ); chunk_window = setup_window( CHUNKSAMPS ); while ( CHUNKBYTES == read_from_fd( 0, buf, CHUNKBYTES ) ) { /* Forget about the last fraction of a second of audio data. */ /* Process exactly one second of audio data per iteration. */ double be[NUM_BANDS]; /* band energies */ audio_to_fftw( buf, in ); window( in, chunk_window, CHUNKSAMPS ); fftw_execute( p ); /* post: in[] -> FFT -> out[] is done */ calc_band_energies( out, be ); /* post: be[] is valid */ chunk_metrics( be, ebuf, rbuf, tbuf, chunkcount ); chunkcount++; /* post: ebuf[], rbuf[], and tbuf[] have chunkcount valid elements */ } /* post: we got to the end of the input data */ fftw_free( in ); fftw_free( out ); fftw_destroy_plan( p ); free( chunk_window ); return chunkcount; }
void * worker(void * mr0){ char ** buffers= malloc(sizeof(char *) * numValues); mapreduce_t * mr= (mapreduce_t *)mr0; int i= 0; for( ; i < numValues; i++){ buffers[i]= malloc(BUFFER_SIZE+1); buffers[i][0]= '\0'; } int n= numValues; while(n){ i=0; struct epoll_event ev; epoll_wait(mr->epoll_fd, &ev, 1, -1); int index= getIndex(mr, ev.data.fd); if(index == -1) printf("error at getting index\n"); int bytes= read_from_fd(ev.data.fd, buffers[index], mr); if(bytes == 0){ n--; epoll_ctl(mr->epoll_fd,EPOLL_CTL_DEL,ev.data.fd,NULL); } else if(bytes == -1){ printf("error\n"); } } for(i=0; i < numValues; i++) free(buffers[i]); free(buffers); return NULL; }
static void input_from_file(const char *fname, size_t offset, size_t fp_len, int action, int options) { size_t len, buf_len; int fd = open(fname, O_RDONLY, 0); if (fd == -1) DIE("cannot open '%s'", fname); if (action == BMZ_A_LIST) { do_list(fd); } else { void *data = read_from_fd(fd, &len, &buf_len); do_block(data, len, buf_len, offset, fp_len, action, options); } /* close and free etc. are omitted intentionally */ }
void * worker_function (void * in){ mapreduce_t * mr = (mapreduce_t *) in; fd_set master_fdset, active_fdset; FD_ZERO(&master_fdset); FD_ZERO(&active_fdset); int i, j; int alive_num = mr -> size; char ** buffer_arr = malloc(sizeof(char *) * mr->size); mr -> buffers = buffer_arr; for (i = 0; i < (mr-> size); i++){ FD_SET(mr->pipes[i][0], &master_fdset); buffer_arr[i] = malloc(BUFFER_SIZE + 1); buffer_arr[i][0] = '\0'; } while(alive_num> 0){ active_fdset = master_fdset; select(FD_SETSIZE, &active_fdset, NULL, NULL, NULL); for (j = 0; j < mr -> size; j++){ if (FD_ISSET(mr->pipes[j][0], &active_fdset)){ if (!read_from_fd(mr->pipes[j][0], buffer_arr[j], mr)){ close(mr->pipes[j][0]); FD_CLR(mr->pipes[j][0], &master_fdset); alive_num --; } } } } //for (i = 0; i < mr -> size; i++){ // free(buffer_arr[i]); // free(mr -> pipes[i]); //} //free(buffer_arr); //free(mr -> pipes); mr -> done = 1; return 0; }
void define_test(void(*callback)(ZRuntimeContext *), struct zco_context_t *ctx, const char *title) { trace("======================\n"); trace("%s:\n", title); /* redirect stdout to a pipe */ int the_pipe[2]; pipe(the_pipe); int original_stdout = write_stdout_to_pipe(the_pipe[1]); /* run test in native mode */ ZRuntimeContext *runtime_context = z_runtime_context_new(ctx, NULL); z_runtime_context_set_target(runtime_context, 0); callback(runtime_context); /* restore stdout as we don't need any more data that is sent to it */ restore_stdout(original_stdout); /* read data that is sent to the pipe and close the pipe */ ZString *out = read_from_fd(ctx, NULL, the_pipe[0]); close(the_pipe[0]); z_object_unref(Z_OBJECT(runtime_context)); /* run test in JS mode and verify its output */ runtime_context = z_runtime_context_new(ctx, NULL); z_runtime_context_set_target(runtime_context, 1); callback(runtime_context); verify_output(runtime_context, out); z_object_unref(Z_OBJECT(runtime_context)); /* print out the expected string */ char *print_out = z_string_get_cstring(out, Z_STRING_ENCODING_UTF8); fputs(print_out, stdout); free(print_out); z_object_unref(Z_OBJECT(out)); trace("\n"); }
void verify_output(ZRuntimeContext *runtime_context, ZString *expected_value) { pid_t pid; /* create a full-duplex pipe */ int pipe_to_child[2]; int pipe_to_parent[2]; pipe(pipe_to_child); pipe(pipe_to_parent); switch (pid = fork()) { case -1: perror("fork"); abort(); break; case 0: /* child */ close(pipe_to_child[1]); close(pipe_to_parent[0]); dup2(pipe_to_child[0], 0); dup2(pipe_to_parent[1], 1); execlp("node", "node", NULL); break; } close(pipe_to_child[0]); close(pipe_to_parent[1]); if (is_verbose) { /* print out the script if we are in verbose mode */ z_runtime_context_run(runtime_context); } /* backup the original stdout and redirect stdout to 'pipe_to_child' */ int original_stdout = write_stdout_to_pipe(pipe_to_child[1]); /* push the script to stdout, which is the pipe to the child */ z_runtime_context_run(runtime_context); z_runtime_context_clear(runtime_context); /* restore the original stdout */ restore_stdout(original_stdout); /* wait for child to exit */ siginfo_t info; memset (&info, 0, sizeof(info)); waitid (P_PID, pid, &info, WEXITED | WUNTRACED | WNOHANG | WNOWAIT); /* read all data from pipe_to_parent[0] and store it in a string */ ZString *out = read_from_fd(CTX_FROM_OBJECT(runtime_context), ALLOCATOR_FROM_OBJECT(runtime_context), pipe_to_parent[0]); close(pipe_to_parent[0]); /* compare the output matches the expected value */ if (z_string_compare(out, NULL, expected_value, NULL, 0, -1)) { char *s; s = z_string_get_cstring(expected_value, Z_STRING_ENCODING_UTF8); printf("Expected value: \n'%s'\n", s); free(s); s = z_string_get_cstring(out, Z_STRING_ENCODING_UTF8); printf("\nActual value: \n'%s'\n", s); free(s); abort(); } z_object_unref(Z_OBJECT(out)); }
int trace_main(char *hostIp, int portNum, char *imsi, int outflag, char *path) { int fd_stdin, peersock, maxfd, status, readsize; int selStatus; fd_set fdset_Read; FILE *fp = NULL; char buff[128]; struct timeval timeout; fd_stdin = fileno(stdin); peersock = connect_to_peer(hostIp, portNum); if(peersock < 0) return 1; if(outflag){ fp = open_trace_file(path, imsi); if(!fp) exit(1); } timeout.tv_sec = 0; timeout.tv_usec = 100; while(1){ FD_ZERO(&fdset_Read); FD_SET(fd_stdin, &fdset_Read); FD_SET(peersock, &fdset_Read); maxfd = (fd_stdin >= peersock)?fd_stdin:peersock; maxfd += 1; selStatus = select(maxfd, &fdset_Read, NULL, NULL, &timeout); if(selStatus < 0){ fprintf(stderr, "[ERROR] select - %s\n", strerror(errno)); }else if(selStatus > 0){ if(FD_ISSET(fd_stdin, &fdset_Read)){ memset(buff, 0x00, sizeof(buff)); read_from_fd(fd_stdin, buff, 1); if(buff[0] == 'q' || buff[0] == 'Q'){ close(peersock); fclose(fp); return 1; } } if(FD_ISSET(peersock, &fdset_Read)){ status = read_trace(peersock, fp, imsi); if(status < 0){ // try to reconnect to peer. peersock = connect_to_peer(hostIp, portNum); if(peersock < 0) return 1; } } } #ifdef DEBUG_1 else{ printf("."); } #endif } return 0; }
int read_trace(int sock, FILE *fp, char *imsi) { char buff[1024], *start = NULL, tmpB[128]; int readsize, traceFlag, sizeToRead, matchFlag; int readBytes, restBytes; readsize = sizeof(SockLibHeadType); if(read_from_fd(sock, buff, readsize) < 0) return -1; parse_sock_header((SockLibHeadType *)buff, &sizeToRead, &traceFlag); if(readsize == 0) return 0; if(!traceFlag){ while(read_from_fd(sock, buff, sizeof(buff)) > 0); return 0; } readsize = (sizeToRead > (sizeof(buff)-1))?(sizeof(buff)-1):sizeToRead; readBytes = 0; memset(buff, 0x00, sizeof(buff)); if((readBytes = read_from_fd(sock, buff, readsize)) < 0) return -1; if(!readBytes) return 0; if(if_imsi_match(buff, imsi, &start)){ restBytes = sizeToRead - readBytes; sprintf(tmpB, "\n\n[ ************************ TRACE RECEIVERD TIME : " "%s ************************ ]\n", current_time()); if(fp){ if(fputs(tmpB, fp) == EOF){ fprintf(stderr, "[ERROR] fputs error - %s\n", strerror(errno)); fclose(fp); exit(0); } if(!fwrite(start, 1, strlen(start), fp)){ fprintf(stderr, "[ERROR] fwrite error - %s\n", strerror(errno)); fclose(fp); exit(0); } } // print trace out to STDOUT puts(tmpB); fwrite(start, 1, strlen(start), stdout); while(restBytes > 0){ readsize = (restBytes > sizeof(buff))?sizeof(buff):restBytes; if((readBytes = read_from_fd(sock, buff, readsize)) < 0) return -1; if(fp){ if(!fwrite(buff, 1, readBytes, fp)){ fprintf(stderr, "[ERROR] fwrite error - %s\n", strerror(errno)); fclose(fp); exit(0); } } fwrite(buff, 1, readBytes, stdout); restBytes -= readBytes; } puts("\n\n"); if(fp){ fputs("\n", fp); fflush(fp); } fflush(stdout); }else{ while(read_from_fd(sock, buff, sizeof(buff)) > 0); #ifdef DEBUG_1 puts(buff); #endif return 0; } return 1; }