void run( int tile, float * A, float * B, float * C, int N ) { struct timeval tv_start, tv_stop; gettimeofday(&tv_start, NULL); #define CALL( fun ) fun( A, B, C, N ); switch ( tile ) { case 0: CALL(MulMatrixCPU); break; case 8: CALL(GPUMatrixMul_T8); break; case 16: CALL(GPUMatrixMul_T16); break; } #undef CALL gettimeofday(&tv_stop, NULL); if ( tile ) { printf("GPU(T=%d) time: %f\n", tile, timevaldiff(tv_start,tv_stop)); } else // CPU { printf("CPU time: %f\n", timevaldiff(tv_start,tv_stop)); } }
int main() { pthread_t blinker; struct sigaction new_action; int device, i; struct timeval start, end; device = open(DEVICE, O_RDWR); if (device < 0) { fprintf(stderr, "could not open " DEVICE "\n"); } gettimeofday(&start, NULL); for (i = 0; i < NUMBER; i++) { turn_on(device); turn_off(device); } gettimeofday(&end, NULL); printf("%lf usec\n", timevaldiff(&start, &end) / NUMBER); close(device); return 0; }
bool compare_times(struct timeval *first, struct timeval *second) { long msec; msec = timevaldiff(first, second); if (msec <= TIME_THRESHOLD) return true; return false; }
static void process_rs(struct Interface *iface, unsigned char *msg, int len, struct sockaddr_in6 *addr) { double delay; double next; struct timeval tv; uint8_t *opt_str; /* validation */ len -= sizeof(struct nd_router_solicit); opt_str = (uint8_t *) (msg + sizeof(struct nd_router_solicit)); while (len > 0) { int optlen; if (len < 2) { flog(LOG_WARNING, "trailing garbage in RS"); return; } optlen = (opt_str[1] << 3); if (optlen == 0) { flog(LOG_WARNING, "zero length option in RS"); return; } else if (optlen > len) { flog(LOG_WARNING, "option length greater than total length in RS"); return; } if (*opt_str == ND_OPT_SOURCE_LINKADDR && IN6_IS_ADDR_UNSPECIFIED(&addr->sin6_addr)) { flog(LOG_WARNING, "received icmpv6 RS packet with unspecified source address and there is a lladdr option"); return; } len -= optlen; opt_str += optlen; } gettimeofday(&tv, NULL); delay = MAX_RA_DELAY_TIME * rand() / (RAND_MAX + 1.0); if (iface->UnicastOnly) { send_ra_forall(iface, &addr->sin6_addr); } else if (timevaldiff(&tv, &iface->last_multicast) / 1000.0 < iface->MinDelayBetweenRAs) { /* last RA was sent only a few moments ago, don't send another immediately. */ next = iface->MinDelayBetweenRAs - (tv.tv_sec + tv.tv_usec / 1000000.0) + (iface->last_multicast.tv_sec + iface->last_multicast.tv_usec / 1000000.0) + delay / 1000.0; iface->next_multicast = next_timeval(next); } else { /* no RA sent in a while, send a multicast reply */ send_ra_forall(iface, NULL); next = rand_between(iface->MinRtrAdvInterval, iface->MaxRtrAdvInterval); iface->next_multicast = next_timeval(next); } }
int main() { struct timeval start, finish; long msec; gettimeofday(&start, NULL); sleep(1); gettimeofday(&finish, NULL); msec = timevaldiff(&start, &finish); printf("Elapsed time for sleep(1) is: %d milliseconds.\n", msec); return 0; }
int main() { struct timeval s,f; //1 std::tr1::unordered_map< int, int> m; gettimeofday( &s, NULL ); int n = 1000000,tot; for(int i=0;i<n;i++){ m[i]=i*10; } gettimeofday( &f, NULL ); std::cerr << "unom-create:"<<timevaldiff( &s, &f) << std::endl; // 1-1 gettimeofday( &s, NULL ); tot=0; for(int i=0;i<n;i++){ tot += m[i]; } gettimeofday( &f, NULL ); std::cerr << "unom-read:"<<timevaldiff( &s, &f) << std::endl; // 1-2 gettimeofday( &s, NULL ); for(int i=0;i<n;i++){ m.erase(i); } gettimeofday( &f, NULL ); std::cerr << "unom-erase:"<<timevaldiff( &s, &f) << " sz:" << m.size() << std::endl; //2 gettimeofday( &s, NULL ); std::map<int,int>mm; for(int i=0;i<n;i++){ mm[i]=i*10; } gettimeofday( &f, NULL ); std::cerr << "stdm-create:"<<timevaldiff( &s, &f) << std::endl; //2-1 gettimeofday( &s, NULL ); tot=0; for(int i=0;i<n;i++){ tot += mm[i]; } gettimeofday( &f, NULL ); std::cerr << "stdm-read:"<<timevaldiff( &s, &f) << std::endl; // 1-2 gettimeofday( &s, NULL ); for(int i=0;i<n;i++){ mm.erase(i); } gettimeofday( &f, NULL ); std::cerr << "stdm-erase:"<<timevaldiff( &s, &f) << " sz:" << mm.size() << std::endl; }
static void network_udp_start(void) { bzero(&receive_addr, sizeof(struct sockaddr_in)); receive_addr.sin_family = AF_INET; receive_addr.sin_addr.s_addr = INADDR_ANY; receive_addr.sin_port = htons(3338); bzero(&broadcast_addr, sizeof(struct sockaddr_in)); broadcast_addr.sin_family = AF_INET; broadcast_addr.sin_addr.s_addr = INADDR_BROADCAST; broadcast_addr.sin_port = htons(sendPort); if (-1 == (server_sock = socket(AF_INET, SOCK_DGRAM, 0))) { printf("E > socket error\n\r"); return; } int broadcast = 1; if (setsockopt(server_sock, SOL_SOCKET, SO_BROADCAST, &broadcast, sizeof(broadcast)) < 0) { printf("E > socket options error\n\r"); return; } struct timeval tv; tv.tv_sec = 3; tv.tv_usec = 0; if (setsockopt(server_sock, SOL_SOCKET, SO_RCVTIMEO,&tv,sizeof(tv)) < 0) { printf("E > socket options error\n\r"); return; } if (-1 == bind(server_sock, (struct sockaddr *)(&receive_addr), sizeof(struct sockaddr))) { printf("E > bind fail\n\r"); return; } const int recv_len = 256; char *recv_buf = (char *)malloc(recv_len); char recv_addr_b[sizeof(struct sockaddr_in)]; socklen_t addr_len = sizeof(struct sockaddr_in); struct timeval system_time, compare_time; const char packet_type_detect[] = "SimpleUDP_detect\nOWN\n"; // We have been started right now: Send broacast message that we are on network_data_received(0, (char*)packet_type_detect, sizeof(packet_type_detect)-1); if (DEBUG) printf("D > Wait on port: %d\n\r", ntohs(receive_addr.sin_port)); int recbytes; const int flags = 0; for (;;) { gettimeofday(&system_time, 0); errno = 0; while ((recbytes = recvfrom(server_sock, recv_buf, recv_len, flags, (struct sockaddr *)recv_addr_b, &addr_len)) > 0) { recv_buf[recbytes] = 0; const int t = sizeof(struct sockaddr_in); if (addr_len != t) { printf("E > read peer address failed! %d %d\n\r", (int)addr_len, t); continue; } struct sockaddr_in copy; memcpy(©, &recv_addr_b, sizeof(struct sockaddr_in)); network_data_received(©, recv_buf, recbytes); } if (errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK) { gettimeofday(&compare_time, 0); if (timevaldiff(&system_time, &compare_time) > 5000) { if (DEBUG) printf("D > Resume from suspend\n\r"); // We have been suspended (system time differs more than 5 seconds): Send broacast message that we are on again network_data_received(0, (char*)packet_type_detect, sizeof(packet_type_detect)-1); } continue; } if (recbytes < 0) { perror("E > read data fail: "); break; } } free(recv_buf); close(server_sock); server_sock = -1; }
// TODO wirite shot boundary info to files // 1. deal m_curr_frame_ts // 2. timediff of two video file is large int video_split_processor::video_split(FILE *fp, off_t pos, video_file_info *p_info, \ live_timeval &task_begin_time, live_timeval &task_end_time) { off_t len = p_info->width * p_info->height * 2; size_t mapped_size = 0; unsigned char *mapped_buffer = map_file(fp, len * (int)p_info->frame_count, \ mapped_size); int fts = 1000 / p_info->frame_rate; write_yuv_file(mapped_buffer, mapped_size, p_info); if (timevaldiff(m_prev_end_time, p_info->begin_time) < fts) { unsigned char frame_buf[len]; memset(frame_buf, 0, len); int y_size = p_info->width * p_info->height; unsigned char *ybuffer = (unsigned char*)malloc(y_size); memset(ybuffer, 0, y_size); for (int i = 0; i < p_info->frame_count; ++i) { memcpy(frame_buf, mapped_buffer + i * len, len); //posix_memalign((void **)ybuffer, 32, y_size); get_Y(p_info->color_type, frame_buf, ybuffer, y_size); // first time detect invoke restart after init if (!mb_initialized) { // 1. init video_split_processor // 2. create a new yuv file memcpy(&m_shot_begin_time, &p_info->begin_time, sizeof(live_timeval)); mp_sd = new shot_detector((uint32_t)p_info->width, \ (uint32_t)p_info->height, 4, 4, m_cfg); memset(m_tmp_video, 0, FILE_NAME_LEN); // shot info file char shot_file[FILE_NAME_LEN]; memset(shot_file, 0, FILE_NAME_LEN); sprintf(shot_file, "%s/%lld%03lld.%lld%03lld.xml", m_shot_path, \ task_begin_time.tv_sec, task_begin_time.tv_usec /1000, task_end_time.tv_sec, task_end_time.tv_usec / 1000); m_fshot = fopen(shot_file, "w"); if (!m_fshot) { // open failed cout << " open " << shot_file << "failed" << endl; return -1; } string s = "</shots>\n"; cout << "write:"<< shot_file << endl; size_t l= fwrite(s.c_str(), s.size(), 1, m_fshot); cout << "tettttttt " << l << endl; mp_sd->restart(ybuffer, fts); //size_t s = fwrite(frame_buf, len, 1, m_fp); m_curr_frame_ts = fts; memcpy(&m_shot_begin_time, &p_info->begin_time, sizeof(live_timeval)); mb_initialized = true; #if DEBUG #endif } else { // TODO // 1. detect shot // 2. write frame to yuv file // 3. frame offset m_curr_frame_ts += fts; m_curr_shot = mp_sd->detect(ybuffer, m_curr_frame_ts); //fwrite(frame_buf, len, 1, m_fp); if (m_curr_shot.start > 0 and m_curr_shot.end > 0) { write_shot_info(); cout << "shot info: " << m_curr_shot.start << ", " << m_curr_shot.end << ", " << m_curr_shot.start_frame_type << "," << m_curr_shot.end_frame_type << endl; memcpy(&m_shot_end_time, &p_info->begin_time, sizeof(live_timeval)); // current shot end time timeval tv; unsigned int t_seconds = (p_info->begin_time.tv_usec + i * fts*1000) / 1000000; tv.tv_usec = (p_info->begin_time.tv_usec + i * fts*1000) % 1000000; tv.tv_sec = p_info->begin_time.tv_sec + t_seconds; m_shot_end_time.tv_sec = tv.tv_sec; m_shot_end_time.tv_usec = tv.tv_usec; // next shot begin time tv.tv_usec = (tv.tv_usec + fts * 1000) % 1000000; t_seconds = (tv.tv_usec + fts * 1000) / 1000000; tv.tv_sec = tv.tv_sec + t_seconds; m_shot_begin_time.tv_sec = tv.tv_sec; m_shot_begin_time.tv_usec = tv.tv_usec; memset(m_tmp_video, 0, FILE_NAME_LEN); sprintf(m_tmp_video, "%s/tmp_%lld_%03lld.yuv", m_video_path, \ p_info->begin_time.tv_sec, p_info->begin_time.tv_usec / 1000 ); //m_fp = fopen(m_tmp_video, "w"); } } } free(ybuffer); } else { // lost frames } memcpy(&m_prev_end_time, &(p_info->end_time), sizeof(live_timeval)); // if the last video_file to deal memcpy(&m_shot_end_time, &(p_info->end_time), sizeof(live_timeval)); return 0; }
int main(int argc, char **argv) { char *outfilename = (char*)calloc(MAXNAMESIZE, sizeof(char)); char *infilename = (char*)calloc(MAXNAMESIZE, sizeof(char)); long kmin, kmax, n, chunksize, clustersize; int dim; int threads=1; /*Last input should be number of threads*/ timer start, end; fprintf(stderr,"Streamcluster Kernel\n"); fflush(NULL); if (argc<10) { fprintf(stderr,"usage: %s k1 k2 d n chunksize clustersize infile outfile threads\n", argv[0]); fprintf(stderr," k1: Min. number of centers allowed\n"); fprintf(stderr," k2: Max. number of centers allowed\n"); fprintf(stderr," d: Dimension of each data point\n"); fprintf(stderr," n: Number of data points\n"); fprintf(stderr," chunksize: Number of data points to handle per step\n"); fprintf(stderr," clustersize: Maximum number of intermediate centers\n"); fprintf(stderr," infile: Input file (if n<=0)\n"); fprintf(stderr," outfile: Output file\n"); fprintf(stderr," threads: Number of threads\n"); fprintf(stderr,"\n"); fprintf(stderr, "if n > 0, points will be randomly generated instead of reading from infile.\n"); exit(1); } kmin = atoi(argv[1]); kmax = atoi(argv[2]); dim = atoi(argv[3]); n = atoi(argv[4]); chunksize = atoi(argv[5]); clustersize = atoi(argv[6]); strcpy(infilename, argv[7]); strcpy(outfilename, argv[8]); threads=atoi(argv[9]); srand48(SEED); SimStream stream; if(n > 0) { stream.n = n; } else { fprintf(stderr, "Currently no input files supported!\n"); exit(EXIT_FAILURE); } TIME(start); /**************************************SET THREADS NUMBER**************************************************/ omp_set_num_threads(threads); streamCluster(&stream, kmin, kmax, dim, chunksize, clustersize, outfilename ); TIME(end); double ctime_msec = (double)timevaldiff(&start, &end); printf("Compute time: %ds (%d msec)\n", (int)(ctime_msec/1000), (int)ctime_msec); free(outfilename); free(infilename); return 0; }
SANE_Byte *collectData( char *uuid, SANE_Handle *openDeviceHandle, size_t totbytes, int bpl, char *header ) { SANE_Status status; SANE_Int received_length_from_sane = 0; SANE_Byte *raw_image; SANE_Byte *raw_image_current_pos; int progress = 0; int feedback = 5; int bufferSize = 32768; size_t readSoFar = 0; size_t headerLength = strlen(header); size_t stillToRead = totbytes; struct timeval start, end; // Initialise the blank image; raw_image = calloc( totbytes + headerLength + 1, sizeof(unsigned char) ); if( raw_image == NULL ) { o_log(ERROR, "Out of memory, when assiging the new image storage."); return NULL; } strcpy((char *)raw_image, header); raw_image_current_pos = raw_image + headerLength; //status = sane_set_io_mode (openDeviceHandle, SANE_TRUE); //o_log(DEBUGM, "setting non-blocking mode was %s", sane_strstatus( status ) ); o_log(DEBUGM, "scan_read - start"); gettimeofday(&start, NULL); do { // Set status as 'scanning' if ( 0 > feedback ) { updateScanProgress(uuid, SCAN_SCANNING, progress); feedback = 5; } feedback--; // // Read buffer from sane (the scanner) //status = sane_read (openDeviceHandle, raw_image_current_pos, stillToRead, &received_length_from_sane); status = sane_read (openDeviceHandle, raw_image_current_pos, bufferSize, &received_length_from_sane); o_log(DEBUGM, "At %d%, requested %d bytes, got %d, with status %d)", progress, stillToRead, received_length_from_sane, status); // // Write the read 'buffer' onto 'raw_image' if( received_length_from_sane > 0 ) { readSoFar += received_length_from_sane; stillToRead -= received_length_from_sane; raw_image_current_pos += received_length_from_sane; if ( received_length_from_sane == bufferSize ) { bufferSize += 32768; } if ( bufferSize > stillToRead ) { bufferSize = stillToRead; } // Update the progress info progress = (int)((readSoFar*100) / totbytes); if(progress > 100) progress = 100; if ( stillToRead == 0 ) { o_log(ERROR, "No more bytes to read" ); break; } } // get some data from sane if (status != SANE_STATUS_GOOD) { if (status == SANE_STATUS_EOF) { o_log(ERROR, "sane told us were at the end" ); break; } else { o_log(ERROR, "something wrong while scanning: %s", sane_strstatus(status) ); break; } } } while (1); gettimeofday(&end, NULL); o_log(DEBUGM, "scan_read - end." ); o_log( INFORMATION, "Read %d of an expected %d bytes, in %lu ms", readSoFar, totbytes, timevaldiff(&start, &end) ); return raw_image; }