/* 获取当前所有温度传感器最高的温度 */ static INT8 local_max_temperature_get() { UINT8 sensor_id, max = 0, i; INT16 temperature; /* 获取温度 */ temperature = ds_get_id_temperaturex16_unblock(&sensor_id); if(temperature > -1000 && sensor_id < TEMPERATURE_SENSOR_NUM){ /* 成功获取温度 */ temperature_info[0].temperature[sensor_id] = temperature / 16; temperature_info[0].lastTime[sensor_id] = timebase_get(); }else{ /* 有错误发生 */ } for(i=0; i<1; i++){ UINT32 diff = time_diff_ms(temperature_info[0].lastTime[i]); if(diff > 60000){ /* 60秒没有成功获取温度 */ temperature_info[0].temperature[i] = 120; } if(diff > 10000){ /* 十秒没有成功获取温度,温度+10度 */ temperature_info[0].lastTime[i] = local_ms_get(); temperature_info[0].temperature[i] += 10; if(temperature_info[0].temperature[i] > 120) temperature_info[0].temperature[i] = 120; } if(max < temperature_info[0].temperature[i]) max = temperature_info[0].temperature[i]; } return max; }
int main() { UINT32 val; char c, forceClearCfg = 0; /* enable watchdog */ wdt_enable(WDTO_8S); #ifdef INCLUDE_KTANK_UART /* init UART */ init_uart(9600); printk("\n\n\n!!!!!!!!!!ktank start!!!!!!!!!!!!!!\n\n\n"); #endif /* init PWM, local time */ pwm_init(); /* enable i2c bus, rtc need it */ I2C_init(); /* init timer */ timer_init(); val = timebase_get(); #ifdef INCLUDE_KTANK_UART do{ if(uart_poll_c((UINT8*)&c) > 0 && c == 'c'){ forceClearCfg++; } }while(time_diff_ms(val) < 2000); #endif if(forceClearCfg > 10){ DBG_PRINT("slave force clear cfg..\n"); EEPROM_put(EEPROM_OFS_RFAVAIL, 0xff); } local_device_info_load(); local_device_info_show(); if(RF_CFG_AVAL()){ rf_init(NULL, SLAVE_MODE_NORMAL); rf_config(EEPROM_get(EEPROM_OFS_HOSTID), EEPROM_get(EEPROM_OFS_DEVID)); DBG_PRINT("slave start hostid 0x%x devid 0x%x\n", EEPROM_get(EEPROM_OFS_HOSTID), EEPROM_get(EEPROM_OFS_DEVID)); nrf_enter_rx_mode(); }else{ #if 0 rf_init(NULL, SLAVE_MODE_WAIT_SYNC); DBG_PRINT("no cfg, force device id 1, host id 0xef\n"); rf_config(0xef, 1); nrf_enter_rx_mode(); #else rf_init(NULL, SLAVE_MODE_WAIT_DISCOVER); rf_config(0xc0, 0x80); DBG_PRINT("slave start without rf cfg\n"); #endif } sei(); while(1){ wdt_reset(); rf_process(); local_device_update(); } }
void report(char *name, struct timespec a, struct timespec b) { uint64_t bytes = FLAGS_num * (KEY_SIZE + VAL_SIZE); long long cost_ms = time_diff_ms(a, b) + 1; printf("%s:%" PRIu64 ", cost:%d(ms), %.f ops/sec, %6.1f MB/sec\n", name, FLAGS_num, (int)cost_ms, (double)(FLAGS_num / cost_ms) * 1000, (double)((double)(bytes / cost_ms / 1048576.0) * 1000)); }
int flush_node_callback(void *tree, struct node *n) { int r; struct timespec t1, t2; struct tree *t = (struct tree*)tree; gettime(&t1); r = serialize_node_to_disk(t->fd, t->block, n, t->hdr); gettime(&t2); t->status->tree_node_flush_costs += time_diff_ms(t1, t2); t->status->tree_node_flush_nums++; if (r != NESS_OK) __PANIC("flush node to disk error, errno [%d]", r); return r; }
int fetch_node_callback(void *tree, NID nid, struct node **n) { int r; struct timespec t1, t2; struct tree *t = (struct tree*)tree; gettime(&t1); r = deserialize_node_from_disk(t->fd, t->block, t->hdr, nid, n); gettime(&t2); atomic64_add(&t->status->tree_node_fetch_costs, (uint64_t)time_diff_ms(t1, t2)); atomic64_increment(&t->status->tree_node_fetch_nums); if (r != NESS_OK) __PANIC("fetch node from disk error, errno [%d]", r); return r; }
int main(int argc, char *argv[]) { int loop; struct nessdb *db; char basedir[] = "./dbbench/"; struct timespec start; struct timespec end; struct random *rnd; if (argc != 2) { printf("./db-bench [count]\n"); return 0; } loop = atoi(argv[1]); rnd = rnd_new(); db = db_open(basedir); gettime(&start); do_bench(db, rnd, loop); gettime(&end); uint64_t bytes = loop * (KEY_SIZE + VAL_SIZE); long long cost_ms = time_diff_ms(start, end) + 1; printf("--------loop:%d, cost:%d(ms), %.f ops/sec, %6.1f MB/sec\n", loop, (int)cost_ms, (double)(loop/cost_ms)*1000, (double)((bytes/cost_ms/1048576.0) * 1000)); db_close(db); rnd_free(rnd); return 1; }
int workqueue_show_status(struct workqueue_ctx* ctx, FILE *fp) { int i; long long time_ms; struct TIME_STRUCT_TYPE now_time; GET_TIME(now_time); LOCK_MUTEX(&ctx->mutex); fprintf(fp, "Number of worker threads=%d \n", ctx->num_worker_threads); fprintf(fp, "Total jobs added=%d queue_size=%d waiting_jobs=%d \n", ctx->job_count, ctx->queue_size, ctx->waiting_jobs); fprintf(fp, "\n"); fprintf(fp, "%3s | %8s | %4s | %6s ms\n", "Qi", "JobID", "Pri", "Time" ); fprintf(fp, "---------------------------------\n"); for (i = 0; i < ctx->queue_size; i++) { if (!ctx->queue[i]) continue; /* unused location */ if (TIME_SEC(ctx->queue[i]->start_time) || TIME_MSEC(ctx->queue[i]->start_time)) { // has been scheduled for a time in the future. time_ms = time_diff_ms(&ctx->queue[i]->start_time, &now_time); } else { // will run ASAP time_ms = 0; } fprintf(fp,"%3d | %8d | %4d | %6lld ms\n", i, ctx->queue[i]->job_id, ctx->queue[i]->priority, time_ms); } UNLOCK_MUTEX(&ctx->mutex); fflush(fp); return 0; }
void create_everything(struct main_context *ctx) { struct callmaster_config mc; struct control_tcp *ct; struct control_udp *cu; struct control_ng *cn; struct cli *cl; int kfd = -1; struct timeval tmp_tv; struct timeval redis_start, redis_stop; double redis_diff = 0; if (table < 0) goto no_kernel; if (kernel_create_table(table)) { fprintf(stderr, "FAILED TO CREATE KERNEL TABLE %i, KERNEL FORWARDING DISABLED\n", table); ilog(LOG_CRIT, "FAILED TO CREATE KERNEL TABLE %i, KERNEL FORWARDING DISABLED\n", table); if (no_fallback) exit(-1); goto no_kernel; } kfd = kernel_open_table(table); if (kfd == -1) { fprintf(stderr, "FAILED TO OPEN KERNEL TABLE %i, KERNEL FORWARDING DISABLED\n", table); ilog(LOG_CRIT, "FAILED TO OPEN KERNEL TABLE %i, KERNEL FORWARDING DISABLED\n", table); if (no_fallback) exit(-1); goto no_kernel; } no_kernel: ctx->p = poller_new(); if (!ctx->p) die("poller creation failed"); ctx->m = callmaster_new(ctx->p); if (!ctx->m) die("callmaster creation failed"); dtls_timer(ctx->p); ZERO(mc); mc.kernelfd = kfd; mc.kernelid = table; mc.interfaces = &interfaces; mc.port_min = port_min; mc.port_max = port_max; mc.max_sessions = max_sessions; mc.timeout = timeout; mc.silent_timeout = silent_timeout; mc.delete_delay = delete_delay; mc.default_tos = tos; mc.b2b_url = b2b_url; mc.fmt = xmlrpc_fmt; mc.graphite_port = graphite_port; mc.graphite_ip = graphite_ip; mc.graphite_interval = graphite_interval; ct = NULL; if (listenport) { ct = control_tcp_new(ctx->p, listenp, listenport, ctx->m); if (!ct) die("Failed to open TCP control connection port"); } cu = NULL; if (udp_listenport) { callmaster_exclude_port(ctx->m, udp_listenport); cu = control_udp_new(ctx->p, udp_listenp, udp_listenport, ctx->m); if (!cu) die("Failed to open UDP control connection port"); } cn = NULL; if (ng_listenport) { callmaster_exclude_port(ctx->m, ng_listenport); cn = control_ng_new(ctx->p, ng_listenp, ng_listenport, ctx->m); if (!cn) die("Failed to open UDP control connection port"); } cl = NULL; if (cli_listenport) { callmaster_exclude_port(ctx->m, cli_listenport); cl = cli_new(ctx->p, cli_listenp, cli_listenport, ctx->m); if (!cl) die("Failed to open UDP CLI connection port"); } if (redis_ip) { mc.redis = redis_new(redis_ip, redis_port, redis_db, MASTER_REDIS_ROLE); if (!mc.redis) die("Cannot start up without Redis database"); } if (redis_read_ip) { mc.redis_read = redis_new(redis_read_ip, redis_read_port, redis_read_db, ANY_REDIS_ROLE); if (!mc.redis_read) die("Cannot start up without Redis read database"); } if (redis_write_ip) { mc.redis_write = redis_new(redis_write_ip, redis_write_port, redis_write_db, ANY_REDIS_ROLE); if (!mc.redis_write) die("Cannot start up without Redis write database"); } ctx->m->conf = mc; callmaster_config_init(ctx->m); if (!foreground) daemonize(); wpidfile(); // start redis restore timer gettimeofday(&redis_start, NULL); if (mc.redis_read) { if (redis_restore(ctx->m, mc.redis_read, ANY_REDIS_ROLE)) die("Refusing to continue without working Redis read database"); } else if (mc.redis) { if (redis_restore(ctx->m, mc.redis, MASTER_REDIS_ROLE)) die("Refusing to continue without working Redis database"); } // stop redis restore timer gettimeofday(&redis_stop, NULL); // print redis restore duration redis_diff += time_diff_ms(redis_start, redis_stop); ilog(LOG_INFO, "Redis restore time = %.0lf ms", redis_diff); gettimeofday(&ctx->m->latest_graphite_interval_start, NULL); timeval_from_ms(&tmp_tv, graphite_interval*1000000); set_graphite_interval_tv(&tmp_tv); }
//------------------------------------------------------------------------------ int main(int argc, char** argv) { if(argc < 9) { std::cerr << "usage: " << argv[0] << " <platform name> <device type = default | cpu | gpu " "| acc | all> <device num> <OpenCL source file path>" " <kernel name> <size> <local size> <vec element width>" << std::endl; exit(EXIT_FAILURE); } const int SIZE = atoi(argv[argc - 3]); // number of elements const int CL_ELEMENT_SIZE = atoi(argv[argc - 1]); // number of per-element // components const int CPU_BLOCK_SIZE = 16384; //use block dot product if SIZE divisible //by this value const size_t BYTE_SIZE = SIZE * sizeof(real_t); const int BLOCK_SIZE = atoi(argv[argc - 2]); //local cache for reduction //equal to local workgroup size const int REDUCED_SIZE = SIZE / BLOCK_SIZE; const int REDUCED_BYTE_SIZE = REDUCED_SIZE * sizeof(real_t); //setup text header that will be prefixed to opencl code std::ostringstream clheaderStream; clheaderStream << "#define BLOCK_SIZE " << BLOCK_SIZE << '\n'; clheaderStream << "#define VEC_WIDTH " << CL_ELEMENT_SIZE << '\n'; #ifdef USE_DOUBLE clheaderStream << "#define DOUBLE\n"; const double EPS = 0.000000001; #else const float EPS = 0.00001; #endif const bool PROFILE_ENABLE_OPTION = true; CLEnv clenv = create_clenv(argv[1], argv[2], atoi(argv[3]), PROFILE_ENABLE_OPTION, argv[4], argv[5], clheaderStream.str()); cl_int status; //create input and output matrices std::vector<real_t> V1 = create_vector(SIZE); std::vector<real_t> V2 = create_vector(SIZE); real_t hostDot = std::numeric_limits< real_t >::quiet_NaN(); real_t deviceDot = std::numeric_limits< real_t >::quiet_NaN(); //ALLOCATE DATA AND COPY TO DEVICE //allocate output buffer on OpenCL device //the partialReduction array contains a sequence of dot products //computed on sub-arrays of size BLOCK_SIZE cl_mem partialReduction = clCreateBuffer(clenv.context, CL_MEM_WRITE_ONLY, REDUCED_BYTE_SIZE, 0, &status); check_cl_error(status, "clCreateBuffer"); //allocate input buffers on OpenCL devices and copy data cl_mem devV1 = clCreateBuffer(clenv.context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR, BYTE_SIZE, &V1[0], //<-- copy data from V1 &status); check_cl_error(status, "clCreateBuffer"); cl_mem devV2 = clCreateBuffer(clenv.context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR, BYTE_SIZE, &V2[0], //<-- copy data from V2 &status); check_cl_error(status, "clCreateBuffer"); //set kernel parameters status = clSetKernelArg(clenv.kernel, //kernel 0, //parameter id sizeof(cl_mem), //size of parameter &devV1); //pointer to parameter check_cl_error(status, "clSetKernelArg(V1)"); status = clSetKernelArg(clenv.kernel, //kernel 1, //parameter id sizeof(cl_mem), //size of parameter &devV2); //pointer to parameter check_cl_error(status, "clSetKernelArg(V2)"); status = clSetKernelArg(clenv.kernel, //kernel 2, //parameter id sizeof(cl_mem), //size of parameter &partialReduction); //pointer to parameter check_cl_error(status, "clSetKernelArg(devOut)"); //setup kernel launch configuration //total number of threads == number of array elements const size_t globalWorkSize[1] = {SIZE / CL_ELEMENT_SIZE}; //number of per-workgroup local threads const size_t localWorkSize[1] = {BLOCK_SIZE}; //LAUNCH KERNEL // make sure all work on the OpenCL device is finished status = clFinish(clenv.commandQueue); check_cl_error(status, "clFinish"); cl_event profilingEvent; timespec kernelStart = {0, 0}; timespec kernelEnd = {0, 0}; clock_gettime(CLOCK_MONOTONIC, &kernelStart); //launch kernel status = clEnqueueNDRangeKernel(clenv.commandQueue, //queue clenv.kernel, //kernel 1, //number of dimensions for work-items 0, //global work offset globalWorkSize, //total number of threads localWorkSize, //threads per workgroup 0, //number of events that need to //complete before kernel executed 0, //list of events that need to complete //before kernel executed &profilingEvent); //event object associated // with this particular // kernel execution // instance check_cl_error(status, "clEnqueueNDRangeKernel"); status = clFinish(clenv.commandQueue); //ensure kernel execution is //terminated; used for timing purposes only; there is no need to enforce //termination when issuing a subsequent blocking data transfer operation check_cl_error(status, "clFinish"); status = clWaitForEvents(1, &profilingEvent); clock_gettime(CLOCK_MONOTONIC, &kernelEnd); check_cl_error(status, "clWaitForEvents"); //get_cl_time(profilingEvent); //gives similar results to the following const double kernelElapsedTime_ms = time_diff_ms(kernelStart, kernelEnd); //READ DATA FROM DEVICE //read back and print results std::vector< real_t > partialDot(REDUCED_SIZE); status = clEnqueueReadBuffer(clenv.commandQueue, partialReduction, CL_TRUE, //blocking read 0, //offset REDUCED_BYTE_SIZE, //byte size of data &partialDot[0], //destination buffer in host //memory 0, //number of events that need to //complete before transfer executed 0, //list of events that need to complete //before transfer executed &profilingEvent); //event identifying this //specific operation check_cl_error(status, "clEnqueueReadBuffer"); const double dataTransferTime_ms = get_cl_time(profilingEvent); timespec accStart = {0, 0}; timespec accEnd = {0, 0}; //FINAL REDUCTION ON HOST clock_gettime(CLOCK_MONOTONIC, &accStart); deviceDot = std::accumulate(partialDot.begin(), partialDot.end(), real_t(0)); clock_gettime(CLOCK_MONOTONIC, &accEnd); const double accTime_ms = time_diff_ms(accStart, accEnd); //COMPUTE DOT PRODUCT ON HOST timespec hostStart = {0, 0}; timespec hostEnd = {0, 0}; clock_gettime(CLOCK_MONOTONIC, &hostStart); if(true || SIZE % CPU_BLOCK_SIZE != 0) hostDot = host_dot_product(V1, V2); else hostDot = host_dot_block(&V1[0], &V2[0], SIZE, CPU_BLOCK_SIZE); clock_gettime(CLOCK_MONOTONIC, &hostEnd); const double host_time = time_diff_ms(hostStart, hostEnd); //PRINT RESULTS std::cout << deviceDot << ' ' << hostDot << std::endl; if(check_result(hostDot, deviceDot, EPS)) { std::cout << "PASSED" << std::endl; std::cout << "kernel: " << kernelElapsedTime_ms << "ms\n" << "host reduction: " << accTime_ms << "ms\n" << "total: " << (kernelElapsedTime_ms + accTime_ms) << "ms" << std::endl; std::cout << "transfer: " << dataTransferTime_ms << "ms\n" << std::endl; if(true || SIZE % CPU_BLOCK_SIZE != 0) { std::cout << "host: " << host_time << "ms" << std::endl; } else { std::cout << "host (16k blocks): " << host_time << "ms" << std::endl; } } else { std::cout << "FAILED" << std::endl; } check_cl_error(clReleaseMemObject(devV1), "clReleaseMemObject"); check_cl_error(clReleaseMemObject(devV2), "clReleaseMemObject"); check_cl_error(clReleaseMemObject(partialReduction), "clReleaseMemObject"); release_clenv(clenv); return 0; }
// dequeue the next job that needes to run in this thread static struct workqueue_job* _workqueue_get_job(struct workqueue_thread *thread, struct TIME_STRUCT_TYPE *wait_time, long long *wait_ms) { int i; struct workqueue_job *job = NULL; struct workqueue_ctx *ctx = thread->ctx; struct TIME_STRUCT_TYPE now; if (!thread->keep_running) return NULL; /* init default wait time*/ GET_TIME(now); *wait_time = now; TIME_SECP(wait_time) += 9999; // if no work wait for 9999 sec *wait_ms = 5000; assert(ctx); DEBUG_MSG("thread %d locking ctx\n",thread->thread_num); LOCK_MUTEX(&ctx->mutex); DEBUG_MSG("thread %d got lock\n",thread->thread_num); assert(ctx->queue); /* for each queued job item while keep_running serach for a job and break out if we find one */ for(i = 0; thread->keep_running && i < ctx->queue_size; i++) { /* if queue pointer not null there is a job in this slot */ if (ctx->queue[i]) { DEBUG_MSG("job %d set wait=%u.%03lu start_time=%u.%03lu now=%u.%03lu\n", ctx->queue[i]->job_id, (unsigned int) TIME_SECP(wait_time), TIME_MSECP(wait_time), (unsigned int) TIME_SEC(ctx->queue[i]->start_time), TIME_MSEC(ctx->queue[i]->start_time), (unsigned int) TIME_SEC(now), TIME_MSEC(now)); /* check scheduled time */ if (_time_gt(&now, &ctx->queue[i]->start_time)) { /* job found that must start now */ job = ctx->queue[i]; ctx->queue[i] = NULL; DEBUG_MSG("found job %d\n", job->job_id); ctx->waiting_jobs--; break; /* found job ready to run */ } else if (_time_gt(wait_time, &ctx->queue[i]->start_time)) { /* next job in the queue is not scheduled to be run yet */ /* calculate time thread should sleep for */ *wait_time = ctx->queue[i]->start_time; *wait_ms = time_diff_ms(&ctx->queue[i]->start_time, &now); DEBUG_MSG("waiting %lld ms\n", *wait_ms); DEBUG_MSG("set wait to %u.%03lu for job %d\n", (unsigned int) TIME_SECP(wait_time), TIME_MSECP(wait_time), ctx->queue[i]->job_id); } else { DEBUG_MSG("no other job\n", NULL); } } } DEBUG_MSG("thread %d unlocking ctx job=%p wait=%u.%03lu\n", thread->thread_num, job, (unsigned int) TIME_SECP(wait_time), TIME_MSECP(wait_time)); UNLOCK_MUTEX(&ctx->mutex); return job; }
//Read a max amount of characters into a buffer. int uart_read(uart_s* uart, uint8_t* buff, int lenmax, int maxms){ if (uart == NULL){ return ERROR_NO_UART; } if (!uart->opened){ return 0; } uart_printf(CLR_CANCEL,2,"uart_read\n"); int n = 0; int rlen = 0; int number_of_bytes_read=0; struct timeval timeout, holdthis; // initialise the timeout structure timeout.tv_sec = 0; timeout.tv_usec = 1000UL*(uint32_t)maxms; //Wait 200ms //timeout.tv_usec = 5000; struct timeval start, now; holdthis=timeout; int read_size = lenmax; //Wait for characters to be sent. //fsync(uart->fd); if (uart->fd == -1){ return -1; } //Set for reading. fd_set readfds; FD_ZERO(&readfds); FD_SET(uart->fd, &readfds); uint32_t diffms; gettimeofday (&start, NULL); while(rlen < lenmax){ n = select(uart->fd + 1, &readfds, NULL, NULL, &timeout); uart_printf(CLR_CANCEL,1,"Selecting to %i, lenmax %i, rlen %i, rsz: %i\n",maxms,lenmax,rlen,read_size); if(n>0){ number_of_bytes_read = read(uart->fd,&buff[rlen],read_size); //This starts writing at bufferout[0]. //scc_printf(SRC_TCPSERV|LEVEL_WARNING,0,"\x1b[37m%d bytes selected in %dusec, appended at: %d, last was '%02X',\r\n" , number_of_bytes_read, holdthis.tv_usec-timeout.tv_usec, rlen, buffer_out[rlen+number_of_bytes_read-1]); rlen += number_of_bytes_read; read_size -= number_of_bytes_read; uart_printf(CLR_CANCEL,1,"n>0: Read %i/%i\n",rlen,lenmax); //Set the new timeout, or return: gettimeofday (&now, NULL); diffms = time_diff_ms(&start,&now); //printf("Diff: %lu n==%i\n",diffms,n); if (diffms > maxms){ //uart_close(uart); return rlen; } timeout.tv_sec = 0; timeout.tv_usec = 1000L*(int32_t)(maxms-diffms); uart_printf(CLR_CANCEL,1,"remaining : %lu\n",timeout.tv_usec); timeout=holdthis; }else if(n == 0){ //Not all characters received. //Set the new timeout, or return: gettimeofday (&now, NULL); diffms = time_diff_ms(&start,&now); uart_printf(CLR_CANCEL,1,"Diff: %lu. n==0\n",diffms); //uart_close(uart); return rlen; }else{ //Port may be occupied. //Set the new timeout, or return: gettimeofday (&now, NULL); diffms = time_diff_ms(&start,&now); uart_printf(CLR_CANCEL,1,"Diff: %lu n== -1\n",diffms); //uart_close(uart); return 0; } } uart_printf(CLR_CANCEL,1,"Done.\n"); //uart_close(uart); return rlen; }
int CTask::report() { TestCase *pCase = m_casesList; m_uiSuccCases = m_uiTotalCases - m_uiFailCases; m_ulTimeTaskDone = time_diff_ms(m_stTimeStartTask,m_stTimeEndTask); int sec = m_ulTimeTaskDone/1000; int msec = m_ulTimeTaskDone%1000; if(0 == sec) { //g_log.info("[==========]%u tese cases ran.(%lu ms total)\n", m_uiTotalWorkItem, m_ulTimeTaskDone); printf_green("[==========]%u tese cases ran.(%lu ms total)\n", m_uiTotalCases, m_ulTimeTaskDone); } else { //g_log.info("[==========]%u tese cases ran.(%d.%d s total)\n", m_uiTotalWorkItem, sec, msec); printf_green("[==========]%u tese cases ran.(%d.%d s total)\n", m_uiTotalCases, sec, msec); } //g_log.info("[==PASSED==]%u tese cases!\n",m_succWorkItem); printf_green("[==PASSED==]%u tese cases!\n",m_uiSuccCases); if(m_uiFailCases > 0) { //g_log.info("[==FAILED==]%u tese cases,listed below:\n",m_failWorkItem); printf_red("[==FAILED==]%u tese cases,listed below:\n",m_uiFailCases); pCase = m_casesList; while(pCase != NULL) { if(WORKITEM_DONE_FAIL == pCase->status) { //g_log.info("[==FAILED==]%s\n",pItem->fileName); printf_red("[==FAILED==]%s(Reason: %s)\n",pCase->fileName,pCase->errReason); } pCase = pCase->next; } } printf_yellow("[==STATIC==]transactionName\t\ttotal \tlost \tsuccess \tavgTime(usec)\tminTime(usec)\tmaxTime(usec)\tmaxIdx\n"); printf_yellow("[==STATIC==]QuoteInterval \t\t%-19lld\t%-19lld\t%-19lld\t%-10d\t%-10d\t%-10d\t%-19lld\n", m_stQuoteIntervalStatic.quoteNum, m_stQuoteIntervalStatic.quoteNum - m_stQuoteIntervalStatic.quoteNum, m_stQuoteIntervalStatic.quoteNum, m_stQuoteIntervalStatic.avgQuoteInterval, m_stQuoteIntervalStatic.minQuoteInterval, m_stQuoteIntervalStatic.maxQuoteInterval, m_stQuoteIntervalStatic.maxIdx); printf_yellow("[==STATIC==]tradeProcTime \t\t%-19lld\t%-19lld\t%-19lld\t%-10d\t%-10d\t%-10d\t%-19lld\n", m_stQuoteIntervalStatic.quoteNum, m_stQuoteIntervalStatic.quoteNum - m_stTradeProcTimeStatic.tradeNum, m_stTradeProcTimeStatic.tradeNum, m_stTradeProcTimeStatic.avgTimeTradeProcess, m_stTradeProcTimeStatic.mixTimeTradeProcess, m_stTradeProcTimeStatic.maxTimeTradeProcess, m_stTradeProcTimeStatic.maxIdx); PrintResultToXML(); return ATF_SUCC; }
int CTask::run() { unsigned long timeDiff = 0; TestCase *pCase = NULL; unsigned int uiCaseDone = 0; CCasesParser cases; //load test cases if(ATF_SUCC != cases.GetCasesList(m_arrTestcasesPath,m_casesList,&m_uiTotalCases)) { g_log.error("Failed to get cases list !\n"); return ATF_FAIL; } if(READABLE == m_exchgConf.isValid) m_pExchgSvr = new ExchgServer(m_exchgConf); if(READABLE == m_quoteConf.isValid) m_pQuoteSvr = new QuoteServer(m_quoteConf); pCase = m_casesList; while(NULL != pCase) { //g_log.info("[RUN ] %s :\n",pItem->fileName); printf_green("[RUN ] %s :\n",pCase->fileName); pCase->startTime = time_get_now(); if(0 == uiCaseDone) m_stTimeStartTask = pCase->startTime; pCase->status = WORKITEM_DOING; //m_pExchgSvr->SetTradeMode(pCase->exchgOrder.tradeMode); //start exchange simulator if(READABLE == m_exchgConf.isValid) m_pExchgSvr->StartNewOrder(&pCase->exchgOrder); //start quote data server if(READABLE == m_quoteConf.isValid) m_pQuoteSvr->StartNewOrder(&pCase->quoteOrder); if(READABLE == m_quoteConf.isValid) { if(READABLE == m_exchgConf.isValid) { if(LIMITED == pCase->exchgOrder.tradeMode) { while(1) { sleep(1); if(NO_TASK == m_pQuoteSvr->m_status && NO_TASK == m_pExchgSvr->m_status) { g_log.debug("%s done.\n",pCase->fileName); break; } } } /*else { while(!m_pQuoteSvr->GetQuoteSendFlag()) { sleep(1); } sleep(1); m_pExchgSvr->Finish(); }*/ } else { while(1) { sleep(1); if(NO_TASK == m_pQuoteSvr->m_status) { g_log.debug("%s done.\n",pCase->fileName); break; } } } } else { if(READABLE == m_exchgConf.isValid) { if(LIMITED == pCase->exchgOrder.tradeMode) { while(1) { sleep(1); if(NO_TASK == m_pExchgSvr->m_status) { g_log.debug("%s done.\n",pCase->fileName); break; } } } } } pCase->endTime = time_get_now(); if(uiCaseDone == m_uiTotalCases - 1) m_stTimeEndTask = pCase->endTime; timeDiff = time_diff_ms(pCase->startTime,pCase->endTime); GetCaseResult(pCase); if(WORKITEM_DONE_SUCC == pCase->status) { //g_log.info("[==SUCCESS==]%s(%lu ms)\n\n",pItem->fileName,timeDiff); printf_green("[==SUCCESS==]%s(%lu ms)\n\n",pCase->fileName,timeDiff); } else if(WORKITEM_DONE_FAIL == pCase->status) { //g_log.info("[==FAILED==]%s(%lu ms)\n\n",pItem->fileName,timeDiff); printf_red("[==FAILED==]%s(%lu ms)\n\n",pCase->fileName,timeDiff); } pCase = pCase->next; uiCaseDone++; } finishTransact(); //get static info from ATF agent GotStaticInfo(); report(); printf("All test cases done.\n"); return ATF_SUCC; }
void _flush_buffer_to_child(struct tree *t, struct node *child, struct nmb *buf) { struct mb_iter iter; mb_iter_init(&iter, buf->pma); while (mb_iter_next(&iter)) { /* TODO(BohuTANG): check msn */ struct nmb_values nvalues; nmb_get_values(&iter, &nvalues); struct bt_cmd cmd = { .msn = nvalues.msn, .type = nvalues.type, .key = &nvalues.key, .val = &nvalues.val, .xidpair = nvalues.xidpair }; node_put_cmd(t, child, &cmd); } } void _flush_some_child(struct tree *t, struct node *parent); /* * PROCESS: * - check child reactivity * - if FISSIBLE: split child * - if FLUSHBLE: flush buffer from child * ENTER: * - parent is already locked * - child is already locked * EXIT: * - parent is unlocked * - no nodes are locked */ void _child_maybe_reactivity(struct tree *t, struct node *parent, struct node *child) { enum reactivity re = get_reactivity(t, child); switch (re) { case STABLE: cache_unpin(t->cf, child->cpair, make_cpair_attr(child)); cache_unpin(t->cf, parent->cpair, make_cpair_attr(parent)); break; case FISSIBLE: node_split_child(t, parent, child); cache_unpin(t->cf, child->cpair, make_cpair_attr(child)); cache_unpin(t->cf, parent->cpair, make_cpair_attr(parent)); break; case FLUSHBLE: cache_unpin(t->cf, parent->cpair, make_cpair_attr(parent)); _flush_some_child(t, child); break; } } /* * PROCESS: * - pick a heaviest child of parent * - flush from parent to child * - maybe split/flush child recursively * ENTER: * - parent is already locked * EXIT: * - parent is unlocked * - no nodes are locked */ void _flush_some_child(struct tree *t, struct node *parent) { int childnum; enum reactivity re; struct node *child; struct partition *part; struct nmb *buffer; struct timespec t1, t2; childnum = node_find_heaviest_idx(parent); nassert(childnum < parent->n_children); part = &parent->parts[childnum]; buffer = part->ptr.u.nonleaf->buffer; if (cache_get_and_pin(t->cf, part->child_nid, (void**)&child, L_WRITE) != NESS_OK) { __ERROR("cache get node error, nid [%" PRIu64 "]", part->child_nid); return; } ngettime(&t1); re = get_reactivity(t, child); if (re == STABLE) { node_set_dirty(parent); part->ptr.u.nonleaf->buffer = nmb_new(t->e); _flush_buffer_to_child(t, child, buffer); nmb_free(buffer); } ngettime(&t2); status_add(&t->e->status->tree_flush_child_costs, time_diff_ms(t1, t2)); status_increment(&t->e->status->tree_flush_child_nums); _child_maybe_reactivity(t, parent, child); }
static bool rmi_filter_tap_down_proc(struct rmi_filter * tap_filter, struct rmi_input_abs_pos *abs_pos) { struct rmi_touchpad * tp = tap_filter->rmi_input->context; struct rmi_touchpad_finger * finger = &tp->fingers[abs_pos->n_finger]; struct rmi_input_abs_pos last_pkt; memset(&last_pkt, 0, sizeof(struct rmi_input_abs_pos)); last_pkt.n_finger = abs_pos->n_finger; last_pkt.tool_type = abs_pos->tool_type; rmi_touchpad_queue_peek(&finger->finger_fifo, &last_pkt, 0); if ( finger->tap_status == 0 && abs_pos->z != 0 ) { finger->finger_down_pkt = *abs_pos; finger->tap_status = 1; pr_debug("aaa 5 finger status 1- x:%d y:%d z:%d wx:%d wy:%d\n", abs_pos->x, abs_pos->y, abs_pos->z, abs_pos->w_x,abs_pos->w_y); return false; } if ( finger->tap_status == 1 && abs_pos->z != 0 ) { //tracking pre-palm if ( abs_pos->w_max >= tp->highw_threshold ) { pr_debug("aaa 5 palm pkt- x:%d y:%d z:%d wx:%d wy:%d\n", abs_pos->x, abs_pos->y, abs_pos->z, abs_pos->w_x,abs_pos->w_y); finger->last_palm_time_stamp = abs_pos->time_stamp; return false; //*abs_pos = last_pkt; //return true; } //tap --make sure time interval and distance in range if ( time_diff_ms (abs_pos->time_stamp, finger->finger_down_pkt.time_stamp) < MAX_TAP_TIME_IN_MS && abs(abs_pos->x - finger->finger_down_pkt.x) < MAX_TAP_DISTANCE && abs(abs_pos->y - finger->finger_down_pkt.y) < MAX_TAP_DISTANCE ) { pr_debug("aaa 5 tap pkt- x:%d y:%d z:%d wx:%d wy:%d\n", abs_pos->x, abs_pos->y, abs_pos->z, abs_pos->w_x,abs_pos->w_y); return false; //*abs_pos = last_pkt; //return true; } // if detect palm, ignore a few packet after palm if ( time_diff_ms(abs_pos->time_stamp, finger->last_palm_time_stamp) < MAX_TAP_TIME_IN_MS ) { pr_debug("aaa 5 ignore pkt - x:%d y:%d z:%d wx:%d wy:%d\n", abs_pos->x, abs_pos->y, abs_pos->z, abs_pos->w_x,abs_pos->w_y); return false; //*abs_pos = last_pkt; //return true; } // normal finger move packet finger->tap_status = 2; pr_debug("aaa 5 normal status 2- x:%d y:%d z:%d wx:%d wy:%d, time: %u\n", abs_pos->x, abs_pos->y, abs_pos->z, abs_pos->w_x,abs_pos->w_y, time_diff_ms (abs_pos->time_stamp, finger->finger_down_pkt.time_stamp)); return true; } //finger up, this will generate tap if ( finger->tap_status == 1 && abs_pos->z == 0 && time_diff_ms(abs_pos->time_stamp, finger->finger_down_pkt.time_stamp) < MAX_TAP_TIME_IN_MS) { _rmi_input_report_abs(tap_filter->rmi_input, &finger->finger_down_pkt); finger->tap_status = 3; pr_debug("aaa 5 tap first pkt- x:%d y:%d z:%d wx:%d wy:%d\n", finger->finger_down_pkt.x, finger->finger_down_pkt.y, finger->finger_down_pkt.z, finger->finger_down_pkt.w_x,finger->finger_down_pkt.w_y); return false; } else if (finger->tap_status == 3 && abs_pos->z ==0) { finger->tap_status = 0; pr_debug("aaa 5 tap up pkt\n"); return true; } else if (abs_pos->z == 0) { finger->tap_status = 0; } return true; }
static int connect_with_timeout(struct lttcomm_sock *sock) { unsigned long timeout = lttcomm_get_network_timeout(); int ret, flags, connect_ret; struct timespec orig_time, cur_time; ret = fcntl(sock->fd, F_GETFL, 0); if (ret == -1) { PERROR("fcntl"); return -1; } flags = ret; /* Set socket to nonblock */ ret = fcntl(sock->fd, F_SETFL, flags | O_NONBLOCK); if (ret == -1) { PERROR("fcntl"); return -1; } ret = clock_gettime(CLOCK_MONOTONIC, &orig_time); if (ret == -1) { PERROR("clock_gettime"); return -1; } connect_ret = connect(sock->fd, (struct sockaddr *) &sock->sockaddr.addr.sin, sizeof(sock->sockaddr.addr.sin)); if (connect_ret == -1 && errno != EAGAIN && errno != EWOULDBLOCK && errno != EINPROGRESS) { goto error; } else if (!connect_ret) { /* Connect succeeded */ goto success; } /* * Perform poll loop following EINPROGRESS recommendation from * connect(2) man page. */ do { struct pollfd fds; fds.fd = sock->fd; fds.events = POLLOUT; fds.revents = 0; ret = poll(&fds, 1, RECONNECT_DELAY); if (ret < 0) { goto error; } else if (ret > 0) { int optval; socklen_t optval_len = sizeof(optval); if (!(fds.revents & POLLOUT)) { /* Either hup or error */ errno = EPIPE; goto error; } /* got something */ ret = getsockopt(sock->fd, SOL_SOCKET, SO_ERROR, &optval, &optval_len); if (ret) { goto error; } if (!optval) { connect_ret = 0; goto success; } else { goto error; } } /* ret == 0: timeout */ ret = clock_gettime(CLOCK_MONOTONIC, &cur_time); if (ret == -1) { PERROR("clock_gettime"); connect_ret = ret; goto error; } } while (time_diff_ms(&cur_time, &orig_time) < timeout); /* Timeout */ errno = ETIMEDOUT; connect_ret = -1; success: /* Restore initial flags */ ret = fcntl(sock->fd, F_SETFL, flags); if (ret == -1) { PERROR("fcntl"); /* Continue anyway */ } error: return connect_ret; }
/********************************************************************* * * MAIN process * ********************************************************************/ int main(int argc, char* argv[]) { pid_t pid; int num_counters=0; int last_counter; int i, k; PIN_STATE_t pin_value; PIN_STATE_t active_value=LOW; struct timespec pulse_start_time, pulse_end_time; unsigned char pulse_started; /* Parse input parameters */ if ((argc==1) || ((argc==2) && !strcmp(argv[1], "-h"))) { printf("Usage:\n"); printf(" pulsecountd <pin1> <div1> [<statefile1>] [<pin2> <div2> [<statefile2>] ... [<pinN> <divN> [<statefileN>]]]\n"); printf(" pinX: kernel Id of GPIO pin to count pulses on (use 0 for dummy pin)\n"); printf(" divX: divisor for pulse count values\n"); printf(" statefileX: file containing the counter selection\n"); printf(" (optional, used for dual virtual counters)\n\n"); printf(" Note: max number of counters is %d\n", MAX_COUNTERS); return 1; } memset(counter_param, 0, sizeof(counter_param)); for (i=1, k=0; i<(argc); i++, k++) { /* Get pin Id and divisor for each counter */ counter_param[k].pin = atoi(argv[i++]); counter_param[k].divisor = atof(argv[i]); /* is this the last parameter? */ if (i<(argc-1)) { /* is next parameter a string (filename)? */ if ((*argv[i+1] < '0') || (*argv[i+1] > '9')) { /* next parameter is the optional statefile name, save it */ strcpy(counter_param[k].statefile, argv[++i]); } } if (counter_param[k].pin) num_counters++; #if 0 printf("counter_param[%d].pin=%d\n", k, counter_param[k].pin); printf("counter_param[%d].divisor=%f\n", k, counter_param[k].divisor); printf("counter_param[%d].statefile=%s\n\n", k, counter_param[k].statefile); #endif } last_counter = k; openlog("pulsecountd", LOG_PID|LOG_CONS, LOG_USER); syslog(LOG_DAEMON | LOG_NOTICE, "Starting Pulse counter daemon (version %s)", VERSION); syslog(LOG_DAEMON | LOG_NOTICE, "Using %s logic", (active_value==HIGH)?"ACTIVE_HIGH":"ACTIVE_LOW" ); /* Install signal handler for SIGTERM and SIGINT ("CTRL C") * to be used to cleanly terminate parent annd child processes */ signal(SIGTERM, doExit); signal(SIGINT, doExit); /* Save the parent pid (used in signal handler) */ parentpid = getpid(); /* Init counter struct */ memset((void*)&counter, 0, sizeof(counter)); syslog(LOG_DAEMON | LOG_NOTICE, "Creating %d counter processes", num_counters); /* Create a child process for each counter */ for (i=0; i<last_counter; i++) { /* Check for dummy pin */ if (counter_param[i].pin == 0) continue; /* Create child */ pid=fork(); if (pid == -1) { syslog(LOG_DAEMON | LOG_ERR, "Error creating child process for counter %d", i+1); return 2; } if (pid != 0) { /***** We are in the parent process *****/ /* Save child pid */ counter_param[i].child_pid=pid; } else { /***** We are in the child process *****/ syslog(LOG_DAEMON | LOG_NOTICE, "Started child process counting pulses on GPIO pin with Kernel Id %d", counter_param[i].pin); /* Init */ if (setup(counter_param[i], &counter) != 0) { /* Setup failed, wait to be terminated */ while (1) usleep(100000); } /* Wait for possibly ongoing pulse to end */ while (digitalRead(counter.value_fd) == active_value) usleep(100000); pulse_started = 0; /***** Main child loop *****/ while (1) { if (waitForEdge(&pin_value, counter.value_fd) == 0) { if (pin_value == active_value) { /* Pulse started */ if (pulse_started == 0) { clock_gettime(CLOCK_REALTIME, &pulse_start_time); pulse_started = 1; } else { #if DEBUG syslog(LOG_DAEMON | LOG_DEBUG, "Warning: detected starting pulse out of sequence on pin %d", counter_param[i].pin); #endif } } else { char str[20]; /* Pulse ended */ if (pulse_started == 1) { clock_gettime(CLOCK_REALTIME, &pulse_end_time); #if DEBUG syslog(LOG_DAEMON | LOG_DEBUG, "Detected pulse with length %lu ms on pin %d", time_diff_ms(pulse_end_time, pulse_start_time), counter_param[i].pin); #endif pulse_started = 0; } else { #if DEBUG syslog(LOG_DAEMON | LOG_DEBUG, "Warning: detected ending pulse out of sequence on pin %d", counter_param[i].pin); #endif continue; } /* TODO: check pulse lenght and filter glitches */ /* Check statefile for which virtual counter to increment */ switch (stateRead(counter.state_fd)) { case 1: /* Increment counter 1, apply divisor and save value */ counter.pulse_count1++; sprintf(str, "%010lu\n", (unsigned long)(counter.pulse_count1/counter.divisor)); pwrite(counter.export1_fd, str, strlen(str), 0); break; case 2: /* Increment counter 2, apply divisor and save value */ counter.pulse_count2++; sprintf(str, "%010lu\n", (unsigned long)(counter.pulse_count2/counter.divisor)); pwrite(counter.export2_fd, str, strlen(str), 0); break; default: /* unknown state, do nothing */ ; //printf("unknown value %d in statefile\n", stateRead(counter.state_fd)); } } } else { /* waitForEdge failed, wait to be terminated */ while (1) usleep(100000); } } } } /* Create child process for TCP server */ modbus_server_pid=fork(); if (modbus_server_pid == -1) { syslog(LOG_DAEMON | LOG_ERR, "Error creating child process for Modbus server"); return 3; } if (modbus_server_pid == 0) { /***** We are in the child process *****/ modbus_server_pid = getpid(); /* Start Modbus TCP server loop */ modbustcp_server(MODBUS_SLAVE_ADDRESS, // Modbus slave address read_register_handler, // Read register handler NULL // Write register handler ); } else { /***** We are in the parent process *****/ /* Wait for termination signal */ while (cont) sleep(1); } /* Wait for all counter child processes to terminate */ for (i=0; i<last_counter; i++) { /* Check for dummy pin */ if (counter_param[i].pin == 0) continue; kill(counter_param[i].child_pid, SIGTERM); if (waitpid(counter_param[i].child_pid, NULL, 0) == counter_param[i].child_pid) { syslog(LOG_DAEMON | LOG_NOTICE, "Child process %d successfully terminated", counter_param[i].child_pid); } else { syslog(LOG_DAEMON | LOG_ERR, "Error terminating child process %d", counter_param[i].child_pid); } } /* Terminate Modbus server */ kill(modbus_server_pid, SIGTERM); if (waitpid(modbus_server_pid, NULL, 0) == modbus_server_pid) { syslog(LOG_DAEMON | LOG_NOTICE, "Modbus server process %d successfully terminated", modbus_server_pid); } else { syslog(LOG_DAEMON | LOG_ERR, "Error terminating Modbus server process %d", modbus_server_pid); } syslog(LOG_DAEMON | LOG_NOTICE, "Exiting Pulse counter daemon"); closelog(); return 0; }