it-swarm.dev

Mudah mengukur waktu yang telah berlalu

Saya mencoba menggunakan time () untuk mengukur berbagai titik program saya.

Yang tidak saya mengerti adalah mengapa nilai-nilai di sebelum dan sesudahnya sama? Saya mengerti ini bukan cara terbaik untuk profil program saya, saya hanya ingin melihat berapa lama waktu yang dibutuhkan.

printf("**MyProgram::before time= %ld\n", time(NULL));

doSomthing();
doSomthingLong();

printf("**MyProgram::after time= %ld\n", time(NULL));

Saya telah mencoba:

struct timeval diff, startTV, endTV;

gettimeofday(&startTV, NULL); 

doSomething();
doSomethingLong();

gettimeofday(&endTV, NULL); 

timersub(&endTV, &startTV, &diff);

printf("**time taken = %ld %ld\n", diff.tv_sec, diff.tv_usec);

Bagaimana cara saya membaca hasil **time taken = 0 26339? Apakah itu berarti 26.339 nanodetik = 26,3 msec?

Bagaimana dengan **time taken = 4 45025, apakah artinya 4 detik dan 25 msec?

258
hap497
#include <ctime>

void f() {
  using namespace std;
  clock_t begin = clock();

  code_to_time();

  clock_t end = clock();
  double elapsed_secs = double(end - begin) / CLOCKS_PER_SEC;
}

Fungsi time() hanya akurat dalam satu detik, tetapi ada CLOCKS_PER_SEC "jam" dalam sedetik. Ini adalah pengukuran yang mudah dan portabel, meskipun terlalu disederhanakan.

258
Roger Pate

Anda dapat mengabstraksi mekanisme pengukuran waktu dan membuat setiap runable callable diukur dengan kode tambahan minimal , hanya dengan dipanggil melalui struktur pengatur waktu. Plus, pada waktu kompilasi Anda dapat menentukan jenis waktu (milidetik, nanodetik, dll.).

Berkat ulasan oleh Loki Astari dan saran untuk menggunakan templat variadic.Ini mengapa panggilan fungsi yang diteruskan.

#include <iostream>
#include <chrono>

template<typename TimeT = std::chrono::milliseconds>
struct measure
{
    template<typename F, typename ...Args>
    static typename TimeT::rep execution(F&& func, Args&&... args)
    {
        auto start = std::chrono::steady_clock::now();
        std::forward<decltype(func)>(func)(std::forward<Args>(args)...);
        auto duration = std::chrono::duration_cast< TimeT> 
                            (std::chrono::steady_clock::now() - start);
        return duration.count();
    }
};

int main() {
    std::cout << measure<>::execution(functor(dummy)) << std::endl;
}

Demo

Menurut komentar oleh Howard Hinnant lebih baik tidak melarikan diri dari sistem chrono sampai kita harus melakukannya. Jadi kelas di atas dapat memberikan pengguna pilihan untuk memanggil count secara manual dengan memberikan metode statis tambahan (ditunjukkan dalam C++ 14)

template<typename F, typename ...Args>
static auto duration(F&& func, Args&&... args)
{
    auto start = std::chrono::steady_clock::now();
    std::forward<decltype(func)>(func)(std::forward<Args>(args)...);
    return std::chrono::duration_cast<TimeT>(std::chrono::steady_clock::now()-start);
} 

// call .count() manually later when needed (eg IO)
auto avg = (measure<>::duration(func) + measure<>::duration(func)) / 2.0;

dan paling bermanfaat untuk klien itu

"ingin memposting banyak proses durasi sebelum I/O (mis. rata-rata)"


Kode lengkap dapat ditemukan di sini . Upaya saya untuk membangun alat pembandingan berdasarkan chrono direkam di sini .


Jika C++ 17's std::invoke tersedia, permohonan callable di execution dapat dilakukan seperti ini:

invoke(forward<decltype(func)>(func), forward<Args>(args)...);

untuk menyediakan callable yang pointer ke fungsi anggota.

248
Nikos Athanasiou
//***C++11 Style:***
std::chrono::steady_clock::time_point begin = std::chrono::steady_clock::now();
std::chrono::steady_clock::time_point end= std::chrono::steady_clock::now();

std::cout << "Time difference = " << std::chrono::duration_cast<std::chrono::microseconds>(end - begin).count() <<std::endl;
std::cout << "Time difference = " << std::chrono::duration_cast<std::chrono::nanoseconds> (end - begin).count() <<std::endl;
232
user3762106

Seperti yang saya lihat dari pertanyaan Anda, sepertinya Anda ingin mengetahui waktu yang telah berlalu setelah eksekusi beberapa kode. Saya kira Anda akan merasa nyaman untuk melihat hasilnya dalam hitungan detik. Jika demikian, coba gunakan fungsi difftime() seperti yang ditunjukkan di bawah ini. Semoga ini bisa menyelesaikan masalah Anda.

#include <time.h>
#include <stdio.h>

time_t start,end;
time (&start);
.
.
.
<your code>
.
.
.
time (&end);
double dif = difftime (end,start);
printf ("Elasped time is %.2lf seconds.", dif );
56
AKN

Hanya Windows: (Tag Linux ditambahkan setelah saya memposting jawaban ini)

Anda dapat menggunakan GetTickCount () untuk mendapatkan jumlah milidetik yang berlalu sejak sistem dimulai.

long int before = GetTickCount();

// Perform time-consuming operation

long int after = GetTickCount();
30
RvdK

fungsi waktu (NULL) akan mengembalikan jumlah detik yang berlalu sejak 01/01/1970 pada pukul 00:00. Dan karena, fungsi itu dipanggil pada waktu yang berbeda di program Anda, itu akan selalu berbeda Waktu dalam C++

13
vodkhang

time(NULL) mengembalikan jumlah detik yang berlalu sejak 01/01/1970 pada 00:00 ( the Epoch ). Jadi perbedaan antara kedua nilai tersebut adalah jumlah detik yang Anda proses.

int t0 = time(NULL);
doSomthing();
doSomthingLong();
int t1 = time(NULL);

printf ("time = %d secs\n", t1 - t0);

Anda bisa mendapatkan hasil yang lebih baik dengan getttimeofday(), yang mengembalikan waktu saat ini dalam detik, seperti time() lakukan dan juga dalam mikrodetik.

12
philant
struct profiler
{
    std::string name;
    std::chrono::high_resolution_clock::time_point p;
    profiler(std::string const &n) :
        name(n), p(std::chrono::high_resolution_clock::now()) { }
    ~profiler()
    {
        using dura = std::chrono::duration<double>;
        auto d = std::chrono::high_resolution_clock::now() - p;
        std::cout << name << ": "
            << std::chrono::duration_cast<dura>(d).count()
            << std::endl;
    }
};

#define PROFILE_BLOCK(pbn) profiler _pfinstance(pbn)

Penggunaan di bawah ::

{
    PROFILE_BLOCK("Some time");
    // your code or function
}

Ini mirip dengan lingkup RAII

CATATAN ini bukan milik saya, tetapi saya pikir itu relevan di sini

11
user6266295
#include<time.h> // for clock
#include<math.h> // for fmod
#include<cstdlib> //for system
#include <stdio.h> //for delay

using namespace std;

int main()
{


   clock_t t1,t2;

   t1=clock(); // first time capture

   // Now your time spanning loop or code goes here
   // i am first trying to display time elapsed every time loop runs

   int ddays=0; // d prefix is just to say that this variable will be used for display
   int dhh=0;
   int dmm=0;
   int dss=0;

   int loopcount = 1000 ; // just for demo your loop will be different of course

   for(float count=1;count<loopcount;count++)
   {

     t2=clock(); // we get the time now

     float difference= (((float)t2)-((float)t1)); // gives the time elapsed since t1 in milliseconds

    // now get the time elapsed in seconds

    float seconds = difference/1000; // float value of seconds
    if (seconds<(60*60*24)) // a day is not over
    {
        dss = fmod(seconds,60); // the remainder is seconds to be displayed
        float minutes= seconds/60;  // the total minutes in float
        dmm= fmod(minutes,60);  // the remainder are minutes to be displayed
        float hours= minutes/60; // the total hours in float
        dhh= hours;  // the hours to be displayed
        ddays=0;
    }
    else // we have reached the counting of days
    {
        float days = seconds/(24*60*60);
        ddays = (int)(days);
        float minutes= seconds/60;  // the total minutes in float
        dmm= fmod(minutes,60);  // the rmainder are minutes to be displayed
        float hours= minutes/60; // the total hours in float
        dhh= fmod (hours,24);  // the hours to be displayed

    }

    cout<<"Count Is : "<<count<<"Time Elapsed : "<<ddays<<" Days "<<dhh<<" hrs "<<dmm<<" mins "<<dss<<" secs";


    // the actual working code here,I have just put a delay function
    delay(1000);
    system("cls");

 } // end for loop

}// end of main 
9
Eskay

Nilai yang dicetak oleh program kedua Anda adalah detik, dan mikrodetik.

0 26339 = 0.026'339 s =   26339 µs
4 45025 = 4.045'025 s = 4045025 µs
8
Didier Trosset
#include <ctime>
#include <cstdio>
#include <iostream>
#include <chrono>
#include <sys/time.h>
using namespace std;
using namespace std::chrono;

void f1()
{
  high_resolution_clock::time_point t1 = high_resolution_clock::now();
  high_resolution_clock::time_point t2 = high_resolution_clock::now();
  double dif = duration_cast<nanoseconds>( t2 - t1 ).count();
  printf ("Elasped time is %lf nanoseconds.\n", dif );
}

void f2()
{
  timespec ts1,ts2;
  clock_gettime(CLOCK_REALTIME, &ts1);
  clock_gettime(CLOCK_REALTIME, &ts2);
  double dif = double( ts2.tv_nsec - ts1.tv_nsec );
  printf ("Elasped time is %lf nanoseconds.\n", dif );
}

void f3()
{
  struct timeval t1,t0;
  gettimeofday(&t0, 0);
  gettimeofday(&t1, 0);
  double dif = double( (t1.tv_usec-t0.tv_usec)*1000);
  printf ("Elasped time is %lf nanoseconds.\n", dif );
}
void f4()
{
  high_resolution_clock::time_point t1 , t2;
  double diff = 0;
  t1 = high_resolution_clock::now() ;
  for(int i = 1; i <= 10 ; i++)
  {
    t2 = high_resolution_clock::now() ;
    diff+= duration_cast<nanoseconds>( t2 - t1 ).count();
    t1 = t2;
  }
  printf ("high_resolution_clock:: Elasped time is %lf nanoseconds.\n", diff/10 );
}

void f5()
{
  timespec ts1,ts2;
  double diff = 0;
  clock_gettime(CLOCK_REALTIME, &ts1);
  for(int i = 1; i <= 10 ; i++)
  {
    clock_gettime(CLOCK_REALTIME, &ts2);
    diff+= double( ts2.tv_nsec - ts1.tv_nsec );
    ts1 = ts2;
  }
  printf ("clock_gettime:: Elasped time is %lf nanoseconds.\n", diff/10 );
}

void f6()
{
  struct timeval t1,t2;
  double diff = 0;
  gettimeofday(&t1, 0);
  for(int i = 1; i <= 10 ; i++)
  {
    gettimeofday(&t2, 0);
    diff+= double( (t2.tv_usec-t1.tv_usec)*1000);
    t1 = t2;
  }
  printf ("gettimeofday:: Elasped time is %lf nanoseconds.\n", diff/10 );
}

int main()
{
  //  f1();
  //  f2();
  //  f3();
  f6();
  f4();
  f5();
  return 0;
}
7
Akanksha Gupta

C++ std :: chrono memiliki keuntungan yang jelas sebagai cross-platform. Namun, itu juga memperkenalkan overhead yang signifikan dibandingkan dengan POSIX clock_gettime (). Pada kotak Linux saya semua rasa std::chrono::xxx_clock::now() memiliki kinerja yang hampir sama:

std::chrono::system_clock::now()
std::chrono::steady_clock::now()
std::chrono::high_resolution_clock::now()

Meskipun POSIX clock_gettime(CLOCK_MONOTONIC, &time) harus sama dengan steady_clock::now() tetapi lebih dari x3 kali lebih cepat!

Inilah tes saya, untuk kelengkapan.

#include <stdio.h>
#include <chrono>
#include <ctime>

void print_timediff(const char* prefix, const struct timespec& start, const 
struct timespec& end)
{
    double milliseconds = end.tv_nsec >= start.tv_nsec
                        ? (end.tv_nsec - start.tv_nsec) / 1e6 + (end.tv_sec - start.tv_sec) * 1e3
                        : (start.tv_nsec - end.tv_nsec) / 1e6 + (end.tv_sec - start.tv_sec - 1) * 1e3;
    printf("%s: %lf milliseconds\n", prefix, milliseconds);
}

int main()
{
    int i, n = 1000000;
    struct timespec start, end;

    // Test stopwatch
    clock_gettime(CLOCK_MONOTONIC, &start);
    for (i = 0; i < n; ++i) {
        struct timespec dummy;
        clock_gettime(CLOCK_MONOTONIC, &dummy);
    }
    clock_gettime(CLOCK_MONOTONIC, &end);
    print_timediff("clock_gettime", start, end);

    // Test chrono system_clock
    clock_gettime(CLOCK_MONOTONIC, &start);
    for (i = 0; i < n; ++i)
        auto dummy = std::chrono::system_clock::now();
    clock_gettime(CLOCK_MONOTONIC, &end);
    print_timediff("chrono::system_clock::now", start, end);

    // Test chrono steady_clock
    clock_gettime(CLOCK_MONOTONIC, &start);
    for (i = 0; i < n; ++i)
        auto dummy = std::chrono::steady_clock::now();
    clock_gettime(CLOCK_MONOTONIC, &end);
    print_timediff("chrono::steady_clock::now", start, end);

    // Test chrono high_resolution_clock
    clock_gettime(CLOCK_MONOTONIC, &start);
    for (i = 0; i < n; ++i)
        auto dummy = std::chrono::high_resolution_clock::now();
    clock_gettime(CLOCK_MONOTONIC, &end);
    print_timediff("chrono::high_resolution_clock::now", start, end);

    return 0;
}

Dan ini adalah output yang saya dapatkan ketika dikompilasi dengan gcc7.2 -O3:

clock_gettime: 24.484926 milliseconds
chrono::system_clock::now: 85.142108 milliseconds
chrono::steady_clock::now: 87.295347 milliseconds
chrono::high_resolution_clock::now: 84.437838 milliseconds
4
Alexey Polonsky

Panggilan fungsi time(NULL) akan mengembalikan jumlah detik yang berlalu sejak epoc: 1 Januari 1970. Mungkin yang ingin Anda lakukan adalah mengambil perbedaan antara dua cap waktu:

size_t start = time(NULL);
doSomthing();
doSomthingLong();

printf ("**MyProgram::time elapsed= %lds\n", time(NULL) - start);
3
wilhelmtell

Dari apa yang dilihat, tv_sec menyimpan detik berlalu sementara tv_usec menyimpan mikrodetik berlalu secara terpisah. Dan mereka bukan konversi satu sama lain. Oleh karena itu, mereka harus diubah ke unit yang tepat dan ditambahkan untuk mendapatkan total waktu yang telah berlalu.

struct timeval startTV, endTV;

gettimeofday(&startTV, NULL); 

doSomething();
doSomethingLong();

gettimeofday(&endTV, NULL); 

printf("**time taken in microseconds = %ld\n",
    (endTV.tv_sec * 1e6 + endTV.tv_usec - (startTV.tv_sec * 1e6 + startTV.tv_usec))
    );
2
Safar Ligal

Secara internal fungsi akan mengakses jam sistem, itulah sebabnya ia mengembalikan nilai yang berbeda setiap kali Anda menyebutnya. Secara umum dengan bahasa non-fungsional, ada banyak efek samping dan status tersembunyi dalam fungsi yang tidak dapat Anda lihat hanya dengan melihat nama fungsi dan argumen.

2
Mike Weller

Di linux, clock_gettime () adalah salah satu pilihan yang baik. Anda harus menautkan perpustakaan waktu nyata (-lrt).

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <time.h>

#define BILLION  1000000000L;

int main( int argc, char **argv )
  {
    struct timespec start, stop;
    double accum;

    if( clock_gettime( CLOCK_REALTIME, &start) == -1 ) {
      perror( "clock gettime" );
      exit( EXIT_FAILURE );
    }

    system( argv[1] );

    if( clock_gettime( CLOCK_REALTIME, &stop) == -1 ) {
      perror( "clock gettime" );
      exit( EXIT_FAILURE );
    }

    accum = ( stop.tv_sec - start.tv_sec )
          + ( stop.tv_nsec - start.tv_nsec )
            / BILLION;
    printf( "%lf\n", accum );
    return( EXIT_SUCCESS );
  }
2
cloudrain21

Seperti yang telah dicatat orang lain, fungsi time () di pustaka standar C tidak memiliki resolusi yang lebih baik dari satu detik. Satu-satunya fungsi C yang sepenuhnya portabel yang dapat memberikan resolusi yang lebih baik tampaknya adalah clock (), tetapi yang mengukur waktu prosesor daripada waktu jam dinding. Jika seseorang puas membatasi diri pada platform POSIX (mis. Linux), maka fungsi clock_gettime () adalah pilihan yang baik.

Sejak C++ 11, ada jauh lebih baik fasilitas timing tersedia yang menawarkan resolusi yang lebih baik dalam bentuk yang harus sangat portabel di berbagai kompiler dan sistem operasi. Demikian pula, pustaka boost :: datetime menyediakan kelas timing resolusi tinggi yang bagus yang sangat portabel.

Salah satu tantangan dalam menggunakan salah satu dari fasilitas ini adalah penundaan waktu yang diperkenalkan dengan menanyakan jam sistem. Dari bereksperimen dengan clock_gettime (), boost :: datetime dan std :: chrono, keterlambatan ini dapat dengan mudah menjadi masalah mikrodetik. Jadi, ketika mengukur durasi dari bagian mana pun dari kode Anda, Anda perlu mengizinkan ada kesalahan pengukuran sekitar ukuran ini, atau mencoba untuk memperbaiki kesalahan nol dalam beberapa cara. Idealnya, Anda mungkin ingin mengumpulkan beberapa pengukuran waktu yang diambil oleh fungsi Anda, dan menghitung rata-rata, atau waktu maksimum/minimum yang diambil di banyak berjalan.

Untuk membantu semua masalah portabilitas dan pengumpulan statistik ini, saya telah mengembangkan pustaka cxx-rtimers yang tersedia di Github yang mencoba menyediakan API sederhana untuk blok waktu kode C++, menghitung nol kesalahan, dan melaporkan statistik dari beberapa timer yang tertanam dalam kode Anda. Jika Anda memiliki kompiler C++ 11, Anda cukup #include <rtimers/cxx11.hpp>, dan gunakan sesuatu seperti:

void expensiveFunction() {
    static rtimers::cxx11::DefaultTimer timer("expensiveFunc");
    auto scopedStartStop = timer.scopedStart();
    // Do something costly...
}

Saat keluar dari program, Anda akan mendapatkan ringkasan statistik waktu yang ditulis ke std :: cerr seperti:

Timer(expensiveFunc): <t> = 6.65289us, std = 3.91685us, 3.842us <= t <= 63.257us (n=731)

yang menunjukkan waktu rata-rata, standar-deviasinya, batas atas dan bawah, dan berapa kali fungsi ini dipanggil.

Jika Anda ingin menggunakan fungsi waktu khusus Linux, Anda bisa #include <rtimers/posix.hpp>, atau jika Anda memiliki pustaka Boost tetapi kompiler C++ yang lebih lama, Anda bisa #include <rtimers/boost.hpp>. Ada juga versi kelas pengatur waktu ini yang dapat mengumpulkan informasi waktu statistik dari berbagai utas. Ada juga metode yang memungkinkan Anda untuk memperkirakan kesalahan nol yang terkait dengan dua kueri langsung berturut-turut dari jam sistem.

2
rwp

Saya perlu mengukur waktu eksekusi fungsi individu dalam perpustakaan. Saya tidak ingin harus membungkus setiap panggilan dari setiap fungsi dengan fungsi pengukuran waktu karena itu jelek dan memperdalam tumpukan panggilan. Saya juga tidak ingin meletakkan kode penghitung waktu di bagian atas dan bawah dari setiap fungsi karena membuat berantakan ketika fungsi tersebut dapat keluar lebih awal atau melempar pengecualian misalnya. Jadi apa yang akhirnya saya lakukan adalah membuat pengatur waktu yang menggunakan masa hidupnya sendiri untuk mengukur waktu.

Dengan cara ini saya dapat mengukur waktu dinding blok kode yang diambil dengan hanya instantiate salah satu objek ini pada awal blok kode yang bersangkutan (fungsi atau ruang lingkup benar-benar) dan kemudian memungkinkan instance destructor untuk mengukur waktu yang berlalu sejak konstruksi ketika instance keluar dari ruang lingkup. Anda dapat menemukan contoh lengkap di sini tetapi structnya sangat sederhana:

template <typename clock_t = std::chrono::steady_clock>
struct scoped_timer {
  using duration_t = typename clock_t::duration;
  const std::function<void(const duration_t&)> callback;
  const std::chrono::time_point<clock_t> start;

  scoped_timer(const std::function<void(const duration_t&)>& finished_callback) :
      callback(finished_callback), start(clock_t::now()) { }
  scoped_timer(std::function<void(const duration_t&)>&& finished_callback) :
      callback(finished_callback), start(clock_t::now()) { }
  ~scoped_timer() { callback(clock_t::now() - start); }
};

Struct akan memanggil Anda kembali pada functor yang disediakan ketika keluar dari ruang lingkup sehingga Anda dapat melakukan sesuatu dengan informasi waktu (cetak atau simpan atau apa pun). Jika Anda perlu melakukan sesuatu yang lebih kompleks, Anda bahkan dapat menggunakan std::bind dengan std::placeholders untuk fungsi panggil balik dengan lebih banyak argumen.

Berikut adalah contoh cepat menggunakannya:

void test(bool should_throw) {
  scoped_timer<> t([](const scoped_timer<>::duration_t& elapsed) {
    auto e = std::chrono::duration_cast<std::chrono::duration<double, std::milli>>(elapsed).count();
    std::cout << "took " << e << "ms" << std::endl;
  });

  std::this_thread::sleep_for(std::chrono::seconds(1));

  if (should_throw)
    throw nullptr;

  std::this_thread::sleep_for(std::chrono::seconds(1));
}

Jika Anda ingin lebih berhati-hati, Anda juga dapat menggunakan new dan delete untuk secara eksplisit memulai dan menghentikan timer tanpa mengandalkan pelingkupan untuk melakukannya untuk Anda.

1
Kevin Kreiser

Saya biasanya menggunakan yang berikut ini:

#include <chrono>
#include <type_traits>

using perf_clock = std::conditional<
    std::chrono::high_resolution_clock::is_steady,
    std::chrono::high_resolution_clock,
    std::chrono::steady_clock
>::type;

using floating_seconds = std::chrono::duration<double>;

template<class F, class... Args>
floating_seconds run_test(Func&& func, Args&&... args)
{
   const auto t0 = perf_clock::now();
   std::forward<Func>(func)(std::forward<Args>(args)...);
   return floating_seconds(perf_clock::now() - t0);
} 

Itu sama dengan @ nikos-athanasiou yang diusulkan kecuali bahwa saya menghindari penggunaan jam yang tidak stabil dan menggunakan jumlah detik mengambang sebagai durasi.

1
oliora

Mereka sama karena fungsi doSomething Anda terjadi lebih cepat daripada rincian waktu. Mencoba:

printf ("**MyProgram::before time= %ld\n", time(NULL));

for(i = 0; i < 1000; ++i) {
    doSomthing();
    doSomthingLong();
}

printf ("**MyProgram::after time= %ld\n", time(NULL));
1
kibibu

Alasan kedua nilai tersebut sama adalah karena prosedur panjang Anda tidak memakan waktu yang lama - kurang dari satu detik. Anda dapat mencoba hanya menambahkan loop panjang (untuk (int i = 0; i <100000000; i ++);) di akhir fungsi untuk memastikan ini masalahnya, maka kita dapat pergi dari sana ...

Jika hal di atas ternyata benar, Anda perlu menemukan fungsi sistem yang berbeda (saya mengerti Anda bekerja di linux, jadi saya tidak dapat membantu Anda dengan nama fungsi) untuk mengukur waktu lebih akurat. Saya yakin ada fungsi simular untuk GetTickCount () di linux, Anda hanya perlu menemukannya.

1
David Božjak

Sebagai jawaban untuk OP tiga pertanyaan spesifik.

"Yang tidak saya mengerti adalah mengapa nilai-nilai di sebelum dan sesudah sama? "

pertanyaan pertama dan kode sampel menunjukkan bahwa time() memiliki resolusi 1 detik, jadi jawabannya adalah kedua fungsi tersebut dieksekusi dalam waktu kurang dari 1 detik. Tapi sesekali itu akan (tampaknya tidak masuk akal) menginformasikan 1 detik jika dua tanda timer mengangkangi batas satu detik.

Contoh selanjutnya menggunakan gettimeofday() yang mengisi struct ini

struct timeval {
    time_t      tv_sec;     /* seconds */
    suseconds_t tv_usec;    /* microseconds */
};

dan pertanyaan kedua menanyakan: "Bagaimana cara saya membaca hasil **time taken = 0 26339? Apakah itu berarti 26.339 nanodetik = 26,3 msec?"

Jawaban kedua saya adalah waktu yang diperlukan adalah 0 detik dan 26339 mikrodetik, yaitu 0,026339 detik, yang menghasilkan contoh pertama yang dijalankan dalam waktu kurang dari 1 detik.

The pertanyaan ketiga bertanya: "Bagaimana dengan **time taken = 4 45025, apakah itu berarti 4 detik dan 25 msec?"

Jawaban ketiga saya adalah waktu yang diambil adalah 4 detik dan 45025 mikrodetik, yaitu 4,045025 detik, yang menunjukkan bahwa OP telah mengubah tugas yang dilakukan oleh dua fungsi yang sebelumnya diatur waktunya.

0
Weather Vane