static enum hrtimer_restart _DISP_CmdModeTimer_handler(struct hrtimer *timer)
{
	EXT_DISP_LOG("fake timer, wake up\n");
	dpmgr_signal_event(pgc->dpmgr_handle, DISP_PATH_EVENT_IF_VSYNC);		
#if 0
	if((get_current_time_us() - pgc->last_vsync_tick) > 16666)
	{
		dpmgr_signal_event(pgc->dpmgr_handle, DISP_PATH_EVENT_IF_VSYNC);		
		pgc->last_vsync_tick = get_current_time_us();
	}
#endif
	return HRTIMER_RESTART;
}
Пример #2
0
void dprec_logger_done(unsigned int type_logsrc,  unsigned int val1, unsigned int val2)
{
	unsigned long flags = 0;

	dprec_to_mmp(type_logsrc, MMProfileFlagEnd, val1, val2);

	DPREC_LOGGER_ENUM source = type_logsrc &0xffffff;
	spin_lock_irqsave(&gdprec_logger_spinlock, flags);
	dprec_logger* l = &logger[source];
	unsigned long long time = get_current_time_us();
	
	if(l->ts_start == 0)
	{	
		goto done;
	}
	
	l->period_frame = time- l->ts_trigger;

	if(l->period_frame > l->period_max_frame)
		l->period_max_frame = l->period_frame;
		
	if(l->period_frame < l->period_min_frame)
		l->period_min_frame = l->period_frame;

	l->period_total += l->period_frame;
	l->count ++;	

	if(source == DPREC_LOGGER_RDMA0_TRANSFER)
	{
		//DISPMSG("done, count=%llu,period=%llu.%02lums,max=%llu.%02lums\n", l->count, SPLIT_NS(l->period_frame), SPLIT_NS(l->period_max_frame));
	}
	
done:	
	spin_unlock_irqrestore(&gdprec_logger_spinlock, flags);
}
Пример #3
0
void DBG_OnHDMIDone(void)
{
    long int time;

    if (!dbg_opt.en_fps_log && !dbg_opt.en_touch_latency_log) return;

    // deal with touch latency log

    time = get_current_time_us();
    hdmi_fps.current_hdmi_time_us = (time - hdmi_fps.trigger_hdmi_time_us);


    if (!dbg_opt.en_fps_log) return;

    // deal with fps log
        
    hdmi_fps.total_hdmi_time_us += hdmi_fps.current_hdmi_time_us;
    ++ hdmi_fps.trigger_hdmi_count;

    if (hdmi_fps.trigger_hdmi_count >= dbg_opt.log_fps_wnd_size) {

        long int f = hdmi_fps.trigger_hdmi_count * 100 * 1000 * 1000 
                     / (time - hdmi_fps.hdmi_start_time_us);

        long int update = hdmi_fps.total_hdmi_time_us * 100 
                          / (1000 * hdmi_fps.trigger_hdmi_count);

        DISP_LOG_PRINT(ANDROID_LOG_INFO, "DBG", "[HDMI] FPS: %ld.%02ld, Avg. update time: %ld.%02ld ms\n",
               f / 100, f % 100,
               update / 100, update % 100);
        
        reset_hdmi_fps_logger();
    }
}
Пример #4
0
static void _WaitForEngineNotBusy(void)
{
    int timeOut;
#if ENABLE_DSI_INTERRUPT
    long int time;
    static const long WAIT_TIMEOUT = 2 * HZ;    // 2 sec
#endif

	if (DSI_REG->DSI_MODE_CTRL.MODE)
		return ;

	timeOut = 20;

#if ENABLE_DSI_INTERRUPT
	time = get_current_time_us();

    if (in_interrupt())
    {
        // perform busy waiting if in interrupt context
		while(_IsEngineBusy()) {
			msleep(1);
			if (--timeOut < 0)	{
						
				DISP_LOG_PRINT(ANDROID_LOG_ERROR, "DSI", " Wait for DSI engine not busy timeout!!!(Wait %d us)\n", get_current_time_us() - time);
				DSI_DumpRegisters();
				DSI_Reset();
				
				break;
			}
		}
    }
    else
    {
        while (_IsEngineBusy())
        {
            long ret = wait_event_interruptible_timeout(_dsi_wait_queue, 
                                                        !_IsEngineBusy(),
                                                        WAIT_TIMEOUT);
            if (0 == ret) {
                DISP_LOG_PRINT(ANDROID_LOG_WARN, "DSI", " Wait for DSI engine not busy timeout!!!\n");
            }
        }
    }
#else

    while(_IsEngineBusy()) {
		msleep(1);
		if (--timeOut < 0)	{
					
			DISP_LOG_PRINT(ANDROID_LOG_ERROR, "DSI", " Wait for DSI engine not busy timeout!!!\n");
			DSI_DumpRegisters();
			DSI_Reset();
			
			break;
		}
	}

#endif    
}
Пример #5
0
void DBG_OnTriggerHDMI(void)
{
    if (!dbg_opt.en_fps_log && !dbg_opt.en_touch_latency_log) return;
    
    hdmi_fps.trigger_hdmi_time_us = get_current_time_us();
    if (hdmi_fps.trigger_hdmi_count == 0) {
        hdmi_fps.hdmi_start_time_us = hdmi_fps.trigger_hdmi_time_us;
    }
}
Пример #6
0
void DBG_OnTriggerLcd(void)
{
    if (!dbg_opt.en_fps_log && !dbg_opt.en_touch_latency_log) return;
    
    fps.trigger_lcd_time_us = get_current_time_us();
    if (fps.trigger_lcd_count == 0) {
        fps.start_time_us = fps.trigger_lcd_time_us;
    }
}
Пример #7
0
void dprec_logger_reset_all(void)
{
	int i = 0;
	for(i = 0;i<sizeof(logger)/sizeof(logger[0]);i++)
	{
		dprec_logger_reset(i);
	}
	ts_dprec_reset = get_current_time_us();
}
Пример #8
0
void DBG_OnLcdDone(void)
{
    long int time;

    if (!dbg_opt.en_fps_log && !dbg_opt.en_touch_latency_log) return;

    // deal with touch latency log

    time = get_current_time_us();
    fps.current_lcd_time_us = (time - fps.trigger_lcd_time_us);

#if 0   // FIXME
    if (dbg_opt.en_touch_latency_log && tpd_start_profiling) {

        DISP_LOG_PRINT(ANDROID_LOG_INFO, "DBG", "Touch Latency: %ld ms\n", 
               (time - tpd_last_down_time) / 1000);

        DISP_LOG_PRINT(ANDROID_LOG_INFO, "DBG", "LCD update time %ld ms (TE delay %ld ms + LCD %ld ms)\n",
               fps.current_lcd_time_us / 1000,
               fps.current_te_delay_time_us / 1000,
               (fps.current_lcd_time_us - fps.current_te_delay_time_us) / 1000);
        
        tpd_start_profiling = 0;
    }
#endif

    if (!dbg_opt.en_fps_log) return;

    // deal with fps log
        
    fps.total_lcd_time_us += fps.current_lcd_time_us;
    ++ fps.trigger_lcd_count;

    if (fps.trigger_lcd_count >= dbg_opt.log_fps_wnd_size) {

        long int f = fps.trigger_lcd_count * 100 * 1000 * 1000 
                     / (time - fps.start_time_us);

        long int update = fps.total_lcd_time_us * 100 
                          / (1000 * fps.trigger_lcd_count);

        long int te = fps.total_te_delay_time_us * 100 
                      / (1000 * fps.trigger_lcd_count);

        long int lcd = (fps.total_lcd_time_us - fps.total_te_delay_time_us) * 100
                       / (1000 * fps.trigger_lcd_count);

        DISP_LOG_PRINT(ANDROID_LOG_INFO, "DBG", "MTKFB FPS: %ld.%02ld, Avg. update time: %ld.%02ld ms "
               "(TE delay %ld.%02ld ms, LCD %ld.%02ld ms)\n",
               f / 100, f % 100,
               update / 100, update % 100,
               te / 100, te % 100,
               lcd / 100, lcd % 100);
		reset_fps_logger();
	}
}
Пример #9
0
void DBG_OnTeDelayDone(void)
{
    long int time;
    
    if (!dbg_opt.en_fps_log && !dbg_opt.en_touch_latency_log) return;

    time = get_current_time_us();
    fps.current_te_delay_time_us = (time - fps.trigger_lcd_time_us);
    fps.total_te_delay_time_us += fps.current_te_delay_time_us;
}
Пример #10
0
void dprec_done(dprec_logger_event *event, unsigned int val1, unsigned int val2)
{
	if(event)
	{
		if(event->level & DPREC_LOGGER_LEVEL_MMP)
		{
			MMProfileLogEx(event->mmp, MMProfileFlagEnd, val1, val2);
		}
		if(event->level & DPREC_LOGGER_LEVEL_LOGGER)
		{
			unsigned long flags = 0;

			spin_lock_irqsave(&gdprec_logger_spinlock, flags);
			dprec_logger *l = &(event->logger);
			unsigned long long time = get_current_time_us();

			if(l->ts_start != 0)
			{	
				l->period_frame = time- l->ts_trigger;

				if(l->period_frame > l->period_max_frame)
				l->period_max_frame = l->period_frame;

				if(l->period_frame < l->period_min_frame)
				l->period_min_frame = l->period_frame;

				l->ts_trigger = 0;
				l->period_total += l->period_frame;
				l->count ++;	
			}

			spin_unlock_irqrestore(&gdprec_logger_spinlock, flags);
		}
		if(event->level & DPREC_LOGGER_LEVEL_MOBILE_LOG)
		{
			//xlog_printk(ANDROID_LOG_DEBUG,"DPREC"LOG_TAG, "DISP/"LOG_TAG,"done,0x%08x,0x%08x\n",event->name, val1, val2);
		}
		if(event->level & DPREC_LOGGER_LEVEL_UART_LOG)
		{
			printk("DISP/%s done,0x%08x,0x%08x\n",event->name, val1, val2);
		}		
#ifdef CONFIG_TRACING
		if(event->level & DPREC_LOGGER_LEVEL_SYSTRACE && _control.systrace)
		{
			mmp_kernel_trace_end();
			//trace_printk("E|%s\n", event->name);
		}
#endif
	}
}
Пример #11
0
void dprec_start(dprec_logger_event *event, unsigned int val1, unsigned int val2)
{
	if(event)
	{
		if(event->level & DPREC_LOGGER_LEVEL_MMP)
		{
			MMProfileLogEx(event->mmp, MMProfileFlagStart, val1, val2);
		}
		if(event->level & DPREC_LOGGER_LEVEL_LOGGER)
		{
			unsigned long flags = 0;	
			
			spin_lock_irqsave(&gdprec_logger_spinlock, flags);
			dprec_logger *l = &(event->logger);
			unsigned long long time = get_current_time_us();
			if(l->count == 0)
			{
				l->ts_start = time;
				l->period_min_frame = 0xffffffffffffffff;
			}
			
			l->ts_trigger = time;	
			
			spin_unlock_irqrestore(&gdprec_logger_spinlock, flags);
		}
		if(event->level & DPREC_LOGGER_LEVEL_MOBILE_LOG)
		{
			//xlog_printk(ANDROID_LOG_DEBUG, "DPREC/"LOG_TAG, "DISP/%s start,0x%08x,0x%08x\n",event->name, val1, val2);
		}
		if(event->level & DPREC_LOGGER_LEVEL_UART_LOG)
		{
			printk("DISP/%s start,0x%08x,0x%08x\n",event->name, val1, val2);
		}
		
#ifdef CONFIG_TRACING
		if(event->level & DPREC_LOGGER_LEVEL_SYSTRACE && _control.systrace)
		{
			char name[256];
			scnprintf(name, sizeof(name)/sizeof(name[0]), "K_%s_0x%x_0x%x", event->name, val1, val2);

			mmp_kernel_trace_begin(name);
			//trace_printk("B|%d|%s\n", current->pid, event->name);
		}
#endif		
	}
}
int ext_disp_wait_for_vsync(void *config)
{
	disp_session_vsync_config *c = (disp_session_vsync_config *)config;
	int ret = 0;
	ret = dpmgr_wait_event(pgc->dpmgr_handle, DISP_PATH_EVENT_IF_VSYNC);	
    ///dprec_logger_trigger(DPREC_LOGGER_VSYNC);
	if(ret == -2)
	{
		EXT_DISP_LOG("vsync for ext display path not enabled yet\n");
		return -1;
	}
	//EXT_DISP_LOG("vsync signaled\n");
	c->vsync_ts = get_current_time_us();
	c->vsync_cnt ++;
	
	return ret;
}
Пример #13
0
void dprec_logger_trigger(unsigned int type_logsrc,  unsigned int val1, unsigned int val2)
{
	unsigned long flags = 0;	

    dprec_to_mmp(type_logsrc, MMProfileFlagPulse, val1, val2);
    
	DPREC_LOGGER_ENUM source = type_logsrc &0xffffff;
	spin_lock_irqsave(&gdprec_logger_spinlock, flags);
	dprec_logger* l = &logger[source];
	unsigned long long time = get_current_time_us();
	if(l->count == 0)
	{
		l->ts_start = time;
		l->ts_trigger = time;
		l->period_min_frame = 0xffffffffffffffff;
	}
	else
	{
		l->period_frame = time- l->ts_trigger;

		if(l->period_frame > l->period_max_frame)
			l->period_max_frame = l->period_frame;
			
		if(l->period_frame < l->period_min_frame)
			l->period_min_frame = l->period_frame;

		l->ts_trigger = time;
		
		if(l->count == 0)
		{
			l->ts_start = l->ts_trigger;
		}
	}	
	l->count ++;
	
	if(source == DPREC_LOGGER_DSI_EXT_TE)
	{
		//DISPMSG("count=%d, time=%llu, period=%llu, max=%llu,min=%llu,start=%llu,trigger=%llu\n", l->count, time, l->period_frame, l->period_max_frame, l->period_min_frame, l->ts_start, l->ts_trigger);
		//DISPMSG("count=%d,period=%lld.%02lums,max=%lld.%02lums\n", l->count, SPLIT_NS(l->period_frame), SPLIT_NS(l->period_max_frame));
	}
	
	spin_unlock_irqrestore(&gdprec_logger_spinlock, flags);
}
Пример #14
0
void dprec_logger_start(unsigned int type_logsrc,  unsigned int val1, unsigned int val2)
{
	unsigned long flags = 0;    
	dprec_to_mmp(type_logsrc, MMProfileFlagStart, val1, val2);
	
	DPREC_LOGGER_ENUM source = type_logsrc &0xffffff;
	spin_lock_irqsave(&gdprec_logger_spinlock, flags);
	dprec_logger* l = &logger[source];
	unsigned long long time = get_current_time_us();
	if(l->count == 0)
	{
		l->ts_start = time;
		l->period_min_frame = 0xffffffffffffffff;
	}
	
	l->ts_trigger = time;	
	if(source == DPREC_LOGGER_RDMA0_TRANSFER)
	{
		//DISPMSG("start, count=%llu,trigger=%llu.%02lums\n", l->count, SPLIT_NS(l->ts_trigger));
	}
	spin_unlock_irqrestore(&gdprec_logger_spinlock, flags);
}
Пример #15
0
unsigned long long dprec_logger_get_current_hold_period(unsigned int type_logsrc)
{
	unsigned long long period = 0;
	unsigned long flags = 0;    
	
	unsigned long long time = get_current_time_us();	
	
	DPREC_LOGGER_ENUM source = type_logsrc &0xffffff;
	spin_lock_irqsave(&gdprec_logger_spinlock, flags);
	dprec_logger* l = &logger[source];
	if(l->ts_trigger)
	{
		period = (time - l->ts_trigger);
	}
	else
	{
		period = 0;
	}
	spin_unlock_irqrestore(&gdprec_logger_spinlock, flags);

	return period;
}
Пример #16
0
int fec_encode_manager_t::append(char *s,int len/*,int &is_first_packet*/)
{
	if(counter==0)
	{
		itimerspec its;
		memset(&its.it_interval,0,sizeof(its.it_interval));
		first_packet_time=get_current_time_us();
		my_time_t tmp_time=fec_timeout+first_packet_time;
		its.it_value.tv_sec=tmp_time/1000000llu;
		its.it_value.tv_nsec=(tmp_time%1000000llu)*1000llu;
		timerfd_settime(timer_fd,TFD_TIMER_ABSTIME,&its,0);
	}
	if(fec_mode==0)//for type 0 use blob
	{
		assert(blob_encode.input(s,len)==0);
	}
	else if(fec_mode==1)//for tpe 1 use  input_buf and counter
	{
		mylog(log_trace,"counter=%d\n",counter);
		assert(len<=65535&&len>=0);
		//assert(len<=fec_mtu);//relax this limitation
		char * p=input_buf[counter]+sizeof(u32_t)+4*sizeof(char);//copy directly to final position,avoid unnecessary copy.
		//remember to change this,if protocol is modified

		write_u16(p,(u16_t)((u32_t)len));  //TODO  omit this u16 for data packet while sending
		p+=sizeof(u16_t);
		memcpy(p,s,len);
		input_len[counter]=len+sizeof(u16_t);
	}
	else
	{
		assert(0==1);
	}
	counter++;
	return 0;
}
Пример #17
0
void hdmi_update_impl(void)
{
    HDMI_LOG("hdmi_update_impl\n");
	int t = 0;
    //int ret = 0;
    //MdpkBitbltConfig pmdp;
    //int lcm_physical_rotation = 0;
    int pixelSize =  p->hdmi_width * p->hdmi_height;
    int dataSize = pixelSize * hdmi_bpp;

    RET_VOID_IF_NOLOG(p->output_mode == HDMI_OUTPUT_MODE_DPI_BYPASS);

    if(pixelSize == 0)
    {
        HDMI_LOG("ignored[resolution is null]\n");
        return;
    }

    //HDMI_FUNC();
    if(down_interruptible(&hdmi_update_mutex))
    {
        HDMI_LOG("[HDMI] can't get semaphore in\n");
        return;
    }

    if (IS_HDMI_NOT_ON())
    {
        goto done;
    }
    if(IS_HDMI_IN_VIDEO_MODE())
    {
        goto done;
    }

    DBG_OnTriggerHDMI();
    //LCD_WaitForNotBusy();

    if(temp_va != 0 && hdmi_va != 0)
    {
        DdpkBitbltConfig pddp;
        int dstOffset;
        memset((void*)&pddp, 0, sizeof(DdpkBitbltConfig));

        pddp.srcX = pddp.srcY = 0;
        pddp.srcW = p->lcm_width;
        pddp.srcH   = p->lcm_height;
        pddp.srcWStride = p->lcm_width;
        pddp.srcHStride = p->lcm_height;
        pddp.srcAddr[0] = temp_va;
        pddp.srcFormat = eRGB888_K;
        pddp.srcBufferSize[0] = p->lcm_width*p->lcm_height*3;
        pddp.srcPlaneNum = 1;

        pddp.dstX = 0;
        pddp.dstY = 0;
        pddp.dstFormat = eARGB8888_K;
        pddp.pitch = p->hdmi_width;
        pddp.dstWStride = p->hdmi_width;
        pddp.dstHStride = p->hdmi_height;
        pddp.dstPlaneNum = 1;

        pddp.orientation = 0;

        switch(pddp.orientation)
        {
            case 90:
            case 270:
#if 1
            {
                pddp.dstW = ALIGN_TO(p->lcm_height * p->hdmi_height / p->lcm_width * 95 / 100, 4);
                pddp.dstH = ALIGN_TO(p->hdmi_height * 95 /100, 4);
                break;
            }
#endif // fall through now
            case 0:
            case 180:
            {
                pddp.dstW = ALIGN_TO(p->hdmi_width * 95 / 100, 4);
                pddp.dstH = ALIGN_TO(p->hdmi_height * 95 /100, 4);
                break;
            }
            default:
                HDMI_LOG("Unknown orientation %d\n", pddp.orientation);
                return;
        }
        dstOffset = (p->hdmi_height - pddp.dstH ) / 2 * p->hdmi_width * hdmi_bpp +
                    (p->hdmi_width - pddp.dstW) / 2 * hdmi_bpp;

        pddp.dstAddr[0] = hdmi_va;// + hdmi_buffer_write_id * p->hdmi_width * p->hdmi_height * hdmi_bpp + dstOffset;
        pddp.dstBufferSize[0] = p->hdmi_width*p->hdmi_height*hdmi_bpp;
		t = get_current_time_us();
        DDPK_Bitblt_Config(DDPK_CH_HDMI_0, &pddp);
        DDPK_Bitblt(DDPK_CH_HDMI_0);
    }

    //HDMI_LOG("dstw=%d, dsth=%d, ori=%d\n", p.dstW, p.dstH, p.orientation);

    DBG_OnHDMIDone();
    HDMI_LOG("cost %d us\n", get_current_time_us() - t);

    //hdmi_buffer_read_id = hdmi_buffer_write_id;

    //hdmi_buffer_write_id = (hdmi_buffer_write_id+1) % hdmi_params->intermediat_buffer_num;
    
    done:
    up(&hdmi_update_mutex);

    return;
}
Пример #18
0
// learn_workloads(SharedVariable* v):
// This function is called at the start part of the program before actual scheduling
// - Parameters
// sv: The variable which is shared for every function over all threads
void learn_workloads(SharedVariable* sv) {
  // TODO: Fill the body
  // This function is executed before the scheduling simulation.
  // You need to calculate the execution time of each thread here.

  long long beginTime;
  long long endTime;

  // Thread functions for workloads: 
  // thread_button, thread_twocolor, thread_temp, thread_track,
  // thread_shock, thread_rgbcolor, thread_aled, thread_buzzer

  beginTime = get_current_time_us();
  thread_button(&sv);
  endTime = get_current_time_us();

  sv->exec_times[0] = endTime - beginTime;

  beginTime = get_current_time_us();
  thread_twocolor(&sv);
  endTime = get_current_time_us();

  sv->exec_times[1] = endTime - beginTime;

  beginTime = get_current_time_us();
  thread_temp(&sv);
  endTime = get_current_time_us();

  sv->exec_times[2] = endTime - beginTime;

  beginTime = get_current_time_us();
  thread_track(&sv);
  endTime = get_current_time_us();

  sv->exec_times[3] = endTime - beginTime;

  beginTime = get_current_time_us();
  thread_shock(&sv);
  endTime = get_current_time_us();

  sv->exec_times[4] = endTime - beginTime;

  beginTime = get_current_time_us();
  thread_rgbcolor(&sv);
  endTime = get_current_time_us();

  sv->exec_times[5] = endTime - beginTime;

  beginTime = get_current_time_us();
  thread_aled(&sv);
  endTime = get_current_time_us();

  sv->exec_times[6] = endTime - beginTime;

  beginTime = get_current_time_us();
  thread_buzzer(&sv);
  endTime = get_current_time_us();

  sv->exec_times[7] = endTime - beginTime;

  //initiate idle time
  sv->totalIdleTime = 0;
  int i,j;
  //long long temp;

  for(i = 0; i < 8; ++i)
  {
    /**if(i%2 == 0) 
    {
      sv->freq[i] = 0;
    } 
    else
    {
      sv->freq[i] = 1;
    }**/
 
    sv->deadlines[i] = LLONG_MAX;
    sv->prev_alive[i] = 0; 
    
  }
  //basic way of setting a few tasks to high frequency
  long long max = sv->exec_times[7];
  sv->freq[7] = 1;
  for(i = 6; i >= 0; --i)
  {
    if(sv->exec_times[i] > max)
    {
      max = sv->exec_times[i];
      sv->freq[i] = 1;
    }
    else
    {
      sv->freq[i] = 0;
    }
    printDBG("exec %d = %lld\n", i, sv->exec_times[i]);
    printDBG("freq  = %d\n", sv->freq[i]);
  }
     


 /** for(i = 0; i < 8; ++i)
  {
    for(j = i + 1; j < 8; ++j)
    {
      if(sv->exec_time[i] > sv->exec_time[j])
      {
        temp = sv->exec_time[i];
        sv->exec_time[i] = sv->exec_time[j];
        sv->exec_time[j] = temp;
      }
    }
  }**/


  
  // Tip 1. You can call each workload function here like:
  // thread_button();

  // Tip 2. You can get the current time here like:
  // long long curTime = get_current_time_us();
}
Пример #19
0
int dprec_logger_get_result_string_all(char *stringbuf, int strlen)
{
	int n = 0;
	int i = 0;
	n += scnprintf(stringbuf+n, strlen - n, "|**** Display Driver Statistic Information Dump ****\n");
	n += scnprintf(stringbuf+n, strlen - n, "|Timestamp Begin=%llu.%03lds, End=%llu.%03lds\n", SPLIT_MS(ts_dprec_reset), SPLIT_MS(get_current_time_us()));
	n += scnprintf(stringbuf+n, strlen - n, "|------------------------+---------+------------+------------+------------+------------|\n");	
	n += scnprintf(stringbuf+n, strlen - n, "|Event                   | count   | fps        |average(ms) | max(ms)    | min(ms)    |\n");	
	n += scnprintf(stringbuf+n, strlen - n, "|------------------------+---------+------------+------------+------------+------------|\n");	
	for(i = 0;i<sizeof(logger)/sizeof(logger[0]);i++)
	{
		n += dprec_logger_get_result_string(i, stringbuf + n, strlen-n); 
	}	
	n += scnprintf(stringbuf+n, strlen - n, "|------------------------+---------+------------+------------+------------+------------|\n");	
	n += scnprintf(stringbuf+n, strlen - n, "dprec error log buffer\n");	

	return n;
}