C++ elapsed_time函数代码示例

    virtual void on_ctrl_change()
    {
        if(m_test.status())
        {
            on_draw();
            update_window();
            m_test.status(false);

            start_timer();
            int i;
            for(i = 0; i < 1000; i++)
            {
                draw_aliased();
            }
            double t1 = elapsed_time();

            start_timer();
            for(i = 0; i < 1000; i++)
            {
                draw_anti_aliased();
            }
            double t2 = elapsed_time();

            update_window();
            char buf[100];
            sprintf(buf, "Time Aliased=%.2fms Time Anti-Aliased=%.2fms", t1, t2);
            message(buf);
        }
    }

// encode function calls
void encode(const char* type, const char* infilename, const char* outfilename)
{
	infile = fopen(infilename, "r+b");
	outfile = fopen(outfilename, "w+b");

	printf("filename     %s\n", infilename);
	//printf("size         %d\n", get_file_size(infilename));
	printf("----\n");
	if ( strcmp(type, "HUFF") == 0 )
	{
		start_timer();
		huff(infile, outfile);
		printf("t-cmprss     %.2f\n", elapsed_time());
	}
	else if ( strcmp(type, "LZ1") == 0 )
	{
		start_timer();
		lz1(infile, outfile);
		printf("t-cmprss     %.2f\n", elapsed_time());
	}
	else if ( strcmp(type, "LZ2") == 0 )
	{
		start_timer();
		lz2(infile, outfile);
		printf("t-cmprss     %.2f\n", elapsed_time());
	}
	else
		printf("Error: unknown encode function call");
}

    virtual void on_ctrl_change()
    {
        if(m_benchmark.status())
        {
            int i;
            on_draw();
            update_window();

            scanline_rasterizer ras;

            pixfmt pixf(rbuf_window());
            base_renderer rb(pixf);
            solid_renderer solid(rb);
            draft_renderer draft(rb);

            char buf[256];
            if(m_draft.status())
            {
                start_timer();
                for(i = 0; i < 10; i++)
                {
                    draw_scene(ras, solid, draft);
                }
                sprintf(buf, "%3.3f milliseconds", elapsed_time());
            }
            else
            {
                double times[5];
                for(m_draw = 0; m_draw < 4; m_draw++)
                {
                    start_timer();
                    for(i = 0; i < 10; i++)
                    {
                        draw_scene(ras, solid, draft);
                    }
                    times[m_draw] = elapsed_time();
                }
                m_draw = 3;

                times[4]  = times[3];
                times[3] -= times[2];
                times[2] -= times[1];
                times[1] -= times[0];
            
                FILE* fd = fopen(full_file_name("benchmark"), "a");
                fprintf(fd, "%10.3f %10.3f %10.3f %10.3f %10.3f\n", 
                            times[0], times[1], times[2], times[3], times[4]);
                fclose(fd);
            

                sprintf(buf, "  pipeline  add_path         sort       render       total\n"
                             "%10.3f %10.3f %10.3f %10.3f %10.3f", 
                        times[0], times[1], times[2], times[3], times[4]);
            }
            message(buf);

            m_benchmark.status(false);
            force_redraw();
        }
    }

static void
random_bench (int very_strong)
{
  char buf[128];
  int i;

  printf ("%-10s", "random");

  if (!very_strong)
    {
      start_timer ();
      for (i=0; i < 100; i++)
        gcry_randomize (buf, sizeof buf, GCRY_STRONG_RANDOM);
      stop_timer ();
      printf (" %s", elapsed_time ());
    }

  start_timer ();
  for (i=0; i < 100; i++)
    gcry_randomize (buf, 8,
                    very_strong? GCRY_VERY_STRONG_RANDOM:GCRY_STRONG_RANDOM);
  stop_timer ();
  printf (" %s", elapsed_time ());

  putchar ('\n');
  if (verbose)
    gcry_control (GCRYCTL_DUMP_RANDOM_STATS);
}

void t_move_missile::on_idle()
{
    t_uint32 new_time = get_time();

    // update animation (if any)
    if (elapsed_time( new_time, m_last_update_time ) >= m_delay )
    {
        int frame = m_missile.get_current_frame_num();

        frame++;
        if (frame >= m_missile.get_frame_count())
            frame = 0;
        m_battlefield.set_current_frame_num( m_missile, frame );
        m_last_update_time = new_time;
    }

    t_map_point_3d position;
    t_uint32       next_time = get_next_time() - get_delay();
    int			   skip_limit = 1;

    // move missile forward one space
    while (elapsed_time( new_time, next_time ) >= 0 && skip_limit-- > 0 )
    {
        next_time += get_delay();
        if (m_distance_left <= 0)
        {
            t_idle_ptr reference = this;

            suspend_idle_processing();
            m_battlefield.remove_object( &m_missile );
            animation_ended();
            m_end_handler( m_attacker, m_target_position );
            return;
        }

        t_map_point_3d delta;
        int            distance;

        // limit distance moved to distance left
        position = m_missile.get_position();
        distance = m_move_distance;
        if (distance > m_distance_left)
            distance = m_distance_left;
        m_distance_left -= distance;
        // add distance to accumulator
        m_sum += m_delta * distance;
        // find integer portion of moved distance
        delta = m_sum / m_distance;
        position += delta;
        m_sum -= delta * m_distance;
        // calculate parabolic arc
        if (m_is_parabolic)
        {
            position.height += m_vertical_velocity - k_gravity;
            m_vertical_velocity -= k_gravity << 1;
        }
    }
    set_next_time( next_time );
    m_battlefield.move_object( m_missile, position );
}

void process_whale(int is_male, int id) {
	int num_males, num_females;
	
	pthread_mutex_lock(&mutex);
	if (is_male) {
		male_queue[male_position++] = id;
		sem_post(&male_avail);
	}
	else {
		female_queue[female_position++] = id;
		sem_post(&female_avail);
	}

	sem_getvalue(&male_avail, &num_males);
	sem_getvalue(&female_avail, &num_females);

	pthread_mutex_unlock(&mutex);

	int this_sex = (is_male) ? num_males : num_females;
	int opposite_sex = (is_male) ? num_females : num_males;

	if (opposite_sex) {
		if (!mate_pending) {
			pthread_mutex_lock(&mutex);
			mate_pending++;
			LOCKED_PRINTF("(t=%f) %d: %s\n", elapsed_time(), male_queue[male_head], "Found Mate");
			LOCKED_PRINTF("(t=%f) %d: %s\n", elapsed_time(), female_queue[female_head], "Found Mate");
			pthread_mutex_unlock(&mutex);
		}

		if (this_sex > 1) { // matchmaker
			while (mate_pending) {
				pthread_mutex_lock(&mutex);
				LOCKED_PRINTF("(t=%f) %d: %s\n", elapsed_time(), id, "Became MatchMaker");

				sem_wait(&male_avail);
				sem_wait(&female_avail);

				LOCKED_PRINTF("(t=%f) %d: %s\n", elapsed_time(), male_queue[male_head], "Mated");
				LOCKED_PRINTF("(t=%f) %d: %s\n", elapsed_time(), female_queue[female_head], "Mated");
				
				mate_pending--;

				male_head++;
				female_head++;
				pthread_mutex_unlock(&mutex);
			}

			pthread_mutex_lock(&mutex);
			sem_getvalue(&male_avail, &num_males);
			sem_getvalue(&female_avail, &num_females);
			pthread_mutex_unlock(&mutex);
		}
	}
}

    void perform_rendering(Scanline &sl, Ras &ras, Ren &ren, Clp &clp)
    {
        if(m_operation.cur_item() > 0)
        {
            ras.reset();
            switch(m_operation.cur_item())
            {
                case 1: clp.operation(agg::clipper_or);           break;
                case 2: clp.operation(agg::clipper_and);          break;
                case 3: clp.operation(agg::clipper_xor);          break;
                case 4: clp.operation(agg::clipper_a_minus_b);    break;
                case 5: clp.operation(agg::clipper_b_minus_a);    break;
            }
            agg::conv_poly_counter<Clp> counter(clp);


            start_timer();
            counter.rewind(0);
            double t1 = elapsed_time();

            ras.reset();
            double x;
            double y;
            unsigned cmd;
            start_timer();
            while(!agg::is_stop(cmd = counter.vertex(&x, &y)))
            {
                ras.add_vertex(x, y, cmd);
            }

            ren.color(agg::rgba(0.5, 0.0, 0, 0.5));
            agg::render_scanlines(ras, sl, ren);
            double t2 = elapsed_time();

            char buf[100];
            sprintf_s(buf, "Contours: %d      Points: %d", counter.m_contours, counter.m_points);
            agg::gsv_text txt;
            agg::conv_stroke<agg::gsv_text> txt_stroke(txt);
            txt_stroke.width(1.5);
            txt_stroke.line_cap(agg::round_cap);
            txt.size(10.0);
            txt.start_point(250, 5);
            txt.text(buf);
            ras.add_path(txt_stroke);
            ren.color(agg::rgba(0.0, 0.0, 0.0));
            agg::render_scanlines(ras, sl, ren);

            sprintf_s(buf, "Clipper=%.3fms Render=%.3fms", t1, t2);
            txt.start_point(250, 20);
            txt.text(buf);
            ras.add_path(txt_stroke);
            ren.color(agg::rgba(0.0, 0.0, 0.0));
            agg::render_scanlines(ras, sl, ren);
        }
    }

/** @internal
 * @brief Calculates the RTT of the host with SSH channel operations, and
 * returns the average of the calculated RTT.
 * @param[in] session active SSH session to test.
 * @param[out] average average RTT in milliseconds.
 * @returns 0 on success, -1 if there is an error.
 */
int benchmarks_ssh_latency(ssh_session session, float *average){
  float times[3];
  struct timestamp_struct ts;
  int i;
  ssh_channel channel;
  channel=ssh_channel_new(session);
  if(channel==NULL)
    goto error;
  if(ssh_channel_open_session(channel)==SSH_ERROR)
    goto error;

  for(i=0;i<3;++i){
    timestamp_init(&ts);
    if(ssh_channel_request_env(channel,"TEST","test")==SSH_ERROR &&
        ssh_get_error_code(session)==SSH_FATAL)
      goto error;
    times[i]=elapsed_time(&ts);
  }
  ssh_channel_close(channel);
  ssh_channel_free(channel);
  channel=NULL;
  printf("Times : %f ms ; %f ms ; %f ms\n", times[0], times[1], times[2]);
  *average=(times[0]+times[1]+times[2])/3;
  return 0;
error:
  fprintf(stderr,"Error calculating SSH latency : %s\n",ssh_get_error(session));
  if(channel)
    ssh_channel_free(channel);
  return -1;
}

initialize::~initialize() {
  if (!quiet) master_printf("\nElapsed run time = %g s\n", elapsed_time());
#ifdef HAVE_MPI
  end_divide_parallel();
  MPI_Finalize();
#endif
}

    void perform_rendering(VertexSource& vs)
    {
        pixfmt_type pixf(rbuf_window());

        typedef agg::pixfmt_amask_adaptor<pixfmt_type, alpha_mask_type> pixfmt_amask_type;
        typedef agg::renderer_base<pixfmt_amask_type>                   amask_ren_type;


        pixfmt_amask_type pixfa(pixf, m_alpha_mask);
        amask_ren_type rbase(pixfa);
        agg::renderer_scanline_aa_solid<amask_ren_type> ren(rbase);

        ren.color(agg::rgba(0.5, 0.0, 0, 0.5));

        start_timer();
        m_ras.reset();
        m_ras.add_path(vs);
        agg::render_scanlines(m_ras, m_sl, ren);
        double t1 = elapsed_time();


        char buf[100];
        sprintf(buf, "Render with AlphaMask: %.3fms", t1);
        draw_text(250, 5, buf);
    }

    template<class VertexSource> void generate_alpha_mask(VertexSource& vs)
    {
        unsigned cx = (unsigned)width();
        unsigned cy = (unsigned)height();

        delete [] m_alpha_buf;
        m_alpha_buf = new unsigned char[cx * cy];
        m_alpha_mask_rbuf.attach(m_alpha_buf, cx, cy, cx);

        typedef agg::renderer_base<agg::pixfmt_gray8> ren_base;
        typedef agg::renderer_scanline_aa_solid<ren_base> renderer;

        agg::pixfmt_gray8 pixf(m_alpha_mask_rbuf);
        ren_base rb(pixf);
        renderer ren(rb);

        start_timer();
        if(m_operation.cur_item() == 0)
        {
            rb.clear(agg::gray8(0));
            ren.color(agg::gray8(255));
        }
        else 
        {
            rb.clear(agg::gray8(255));
            ren.color(agg::gray8(0));
        }
        m_ras.add_path(vs);
        agg::render_scanlines(m_ras, m_sl, ren);
        double t1 = elapsed_time();

        char buf[100];
        sprintf(buf, "Generate AlphaMask: %.3fms", t1);
        draw_text(250, 20, buf);
    }

/***
 * Print out an optional message followed by the current timer timing.
 */
void Timer::check(const char* msg)
{
  // Print an optional message, something like "Checking timer t";
  if (msg) VERBOSE(0, msg << " : ");

  VERBOSE(0, "[" << (running ? elapsed_time() : 0) << "] seconds\n");
}

static void
do_powm ( const char *n_str, const char *e_str, const char *m_str)
{
  gcry_mpi_t e, n, msg, cip;
  gcry_error_t err;
  int i;

  err = gcry_mpi_scan (&n, GCRYMPI_FMT_HEX, n_str, 0, 0);
  if (err) BUG ();
  err = gcry_mpi_scan (&e, GCRYMPI_FMT_HEX, e_str, 0, 0);
  if (err) BUG ();
  err = gcry_mpi_scan (&msg, GCRYMPI_FMT_HEX, m_str, 0, 0);
  if (err) BUG ();

  cip = gcry_mpi_new (0);

  start_timer ();
  for (i=0; i < 1000; i++)
    gcry_mpi_powm (cip, msg, e, n);
  stop_timer ();
  printf (" %s", elapsed_time ()); fflush (stdout);
/*    { */
/*      char *buf; */

/*      if (gcry_mpi_aprint (GCRYMPI_FMT_HEX, (void**)&buf, NULL, cip)) */
/*        BUG (); */
/*      printf ("result: %s\n", buf); */
/*      gcry_free (buf); */
/*    } */
  gcry_mpi_release (cip);
  gcry_mpi_release (msg);
  gcry_mpi_release (n);
  gcry_mpi_release (e);
}

void obj::scene::initialize() {
    glClearColor(.1, .16, .19, 0);
    glClearDepth(1.0);

    GLfloat light_position[] = { 1.0, 1.0, 1.0, 0.0 };
    GLfloat light_specular[] = { 1.0, 1.0, 1.0, 1.0 };
    GLfloat light_diffuse[]  = { 1.0, 1.0, 1.0, 1.0 };
    glShadeModel(GL_SMOOTH);

    glLightfv(GL_LIGHT0, GL_POSITION, light_position);
    glLightfv(GL_LIGHT0, GL_SPECULAR, light_specular);
    glLightfv(GL_LIGHT0, GL_DIFFUSE, light_diffuse);

    glEnable(GL_DEPTH_TEST);
    glEnable(GL_LIGHTING);
    glEnable(GL_LIGHT0);
    glEnable(GL_COLOR_MATERIAL);

    glLineWidth(3);
    glPointSize(20);

    glScalef(2, 2, 5);

    glutSetCursor(GLUT_CURSOR_CROSSHAIR);

    current_time = timebase = elapsed_time();

    camera = new obj::camera(90);

    reset_camera();
}

void benchmark(Graf& cos, int poczatek, int koniec, std::ostream& out) {

	std::chrono::time_point<std::chrono::system_clock> start, end;
	std::chrono::duration<double> elapsed_time(0);

	start = std::chrono::system_clock::now();
	auto list = depth_first(cos, poczatek, koniec);
	end = std::chrono::system_clock::now();
	elapsed_time = end-start;
	out << "DEPTH-FIRST time: " << elapsed_time.count()  << "s. ";
	for( auto t : list ) std::cerr << t << " -> "; std::cerr << "\n";


	start = std::chrono::system_clock::now();
	list = breadth_first(cos, poczatek, koniec);
	end = std::chrono::system_clock::now();
	elapsed_time = end-start;
	out << "BREADTH-FIRST time: " << elapsed_time.count()  << "s. ";
	for( auto t : list ) std::cerr << t << " -> "; std::cerr << "\n";

	start = std::chrono::system_clock::now();
	list = a_star(cos, poczatek, koniec );
	end = std::chrono::system_clock::now();
	elapsed_time = end-start;
	out << "A* time: " << elapsed_time.count()  << "s. ";
	for( auto t : list ) std::cerr << t << " -> "; std::cerr << "\n";

}