সি ++ এর মধ্যে সময়ের পার্থক্য কীভাবে গণনা করা যায়

Question 1

সি ++ এর সাথে সময়ের পার্থক্য গণনা করার সর্বোত্তম উপায় কী? আমি একটি প্রোগ্রামের সম্পাদনের গতির সময় নির্ধারণ করছি, তাই আমি মিলিসেকেন্ডে আগ্রহী। আরও ভাল, সেকেন্ড.মিলিসেকেন্ড ..

গৃহীত উত্তরটি কাজ করে তবে মন্তব্যে উল্লিখিত সিটিটাইম বা টাইম হ'ল অন্তর্ভুক্ত করা দরকার।

Question 2

std::clock()ফাংশন দেখুন ।

const clock_t begin_time = clock();
// do something
std::cout << float( clock () - begin_time ) /  CLOCKS_PER_SEC;

যদি আপনি নিজের জন্য (ব্যবহারকারীর জন্য নয়) এক্সিকিউশন সময় গণনা করতে চান, তবে এটি ক্লক টিকগুলিতে (সেকেন্ড নয়) করা ভাল।

সম্পাদনা:
দায়ী হেডার ফাইল - <ctime>বা<time.h>

Question 3

আপনি যদি সি ++ 11 ব্যবহার করেন তবে এখানে একটি সাধারণ মোড়ক দেওয়া আছে (এই টুকরোটি দেখুন ):

#include <iostream>
#include <chrono>

class Timer
{
public:
    Timer() : beg_(clock_::now()) {}
    void reset() { beg_ = clock_::now(); }
    double elapsed() const { 
        return std::chrono::duration_cast<second_>
            (clock_::now() - beg_).count(); }

private:
    typedef std::chrono::high_resolution_clock clock_;
    typedef std::chrono::duration<double, std::ratio<1> > second_;
    std::chrono::time_point<clock_> beg_;
};

অথবা সি ++ 03 এর জন্য * নিক্সে:

#include <iostream>
#include <ctime>

class Timer
{
public:
    Timer() { clock_gettime(CLOCK_REALTIME, &beg_); }

    double elapsed() {
        clock_gettime(CLOCK_REALTIME, &end_);
        return end_.tv_sec - beg_.tv_sec +
            (end_.tv_nsec - beg_.tv_nsec) / 1000000000.;
    }

    void reset() { clock_gettime(CLOCK_REALTIME, &beg_); }

private:
    timespec beg_, end_;
};

ব্যবহারের উদাহরণ:

int main()
{
    Timer tmr;
    double t = tmr.elapsed();
    std::cout << t << std::endl;

    tmr.reset();
    t = tmr.elapsed();
    std::cout << t << std::endl;
    return 0;
}

Question 4

আমি বুস্টের ব্যবহারটি বিশেষত বুস্ট :: পিক্সিক_টাইম :: পিটাইম এবং বুস্ট :: পিক্সিক_টাইম :: সময়_দূত্রে ( http://www.boost.org/doc/libs/1_38_0/doc/html/date_time/posix_time এ গুরুত্ব সহকারে বিবেচনা করব) .html )।

এটি ক্রস প্ল্যাটফর্ম, সহজেই ব্যবহারযোগ্য এবং আমার অভিজ্ঞতায় একটি অপারেটিং সিস্টেমের সর্বোচ্চ স্তরের সময় রেজোলিউশন সরবরাহ করে। সম্ভবত খুব গুরুত্বপূর্ণ; এটি কিছু খুব সুন্দর আইও অপারেটর সরবরাহ করে।

প্রোগ্রামের প্রয়োগের পার্থক্য গণনা করতে এটি ব্যবহার করতে (মাইক্রোসেকেন্ডগুলিতে; সম্ভবত ওভারকিল), এটি দেখতে কিছুটা [ব্রাউজার লিখিত, পরীক্ষিত নয়]:

ptime time_start(microsec_clock::local_time());
//... execution goes here ...
ptime time_end(microsec_clock::local_time());
time_duration duration(time_end - time_start);
cout << duration << '\n';

Question 5

আমি এই উত্তরটি স্পষ্ট করে যোগ করেছি যে গ্রহণযোগ্য উত্তর সিপিইউ সময় দেখায় যা আপনি চান সময় হতে পারে না। কারণ রেফারেন্স অনুযায়ী , সিপিইউ সময় এবং প্রাচীর ঘড়ির সময় আছে । ওয়াল ক্লক টাইম এমন সময় যা অন্যান্য প্রক্রিয়া দ্বারা ভাগ করা সিপিইউর মতো অন্য কোনও শর্ত নির্বিশেষে আসল সময় কেটে যায় shows উদাহরণস্বরূপ, আমি একটি নির্দিষ্ট কাজটি করার জন্য একাধিক প্রসেসর ব্যবহার করেছি এবং সিপিইউর সময়টি 18 এর বেশি ছিল যেখানে প্রকৃত প্রাচীরের ঘড়ির সময়টিতে এটি আসলে 2 সেকেন্ড নিয়েছিল ।

আপনার আসল সময়টি পেতে,

#include <chrono>

auto t_start = std::chrono::high_resolution_clock::now();
// the work...
auto t_end = std::chrono::high_resolution_clock::now();

double elapsed_time_ms = std::chrono::duration<double, std::milli>(t_end-t_start).count();

Question 6

1.46.0 অনুমোদন এবং আপ অন্তর্ভুক্ত Chrono গ্রন্থাগার:

থ্রেড_ক্লক ক্লাসটি আসল থ্রেড ওয়াল-ক্লক, অর্থাৎ কলিং থ্রেডের আসল সিপিইউ-টাইম ক্লকটিতে অ্যাক্সেস সরবরাহ করে। থ্রেড আপেক্ষিক বর্তমান সময় থ্রেড_ক্লোক :: এখন () কল করে পাওয়া যাবে

#include <boost/chrono/thread_clock.hpp>
{
...
    using namespace boost::chrono;
    thread_clock::time_point start = thread_clock::now();
    ...
    thread_clock::time_point stop = thread_clock::now();  
    std::cout << "duration: " << duration_cast<milliseconds>(stop - start).count() << " ms\n";

Question 7

উইন্ডোজে: গেটটিকাউন্ট ব্যবহার করুন

//GetTickCount defintition
#include <windows.h>
int main()
{

    DWORD dw1 = GetTickCount();

    //Do something 

    DWORD dw2 = GetTickCount();

    cout<<"Time difference is "<<(dw2-dw1)<<" milliSeconds"<<endl;

}

Question 8

আপনি ক্লক_জেটটাইমও ব্যবহার করতে পারেন । এই পদ্ধতিটি পরিমাপ করতে ব্যবহার করা যেতে পারে:

সিস্টেমের প্রশস্ত রিয়েল-টাইম ঘড়ি
সিস্টেম প্রশস্ত একঘেয়ে ঘড়ি
প্রসেস সিপিইউ সময়
প্রতি প্রক্রিয়া থ্রেড সিপিইউ সময়

কোডটি নিম্নরূপ:

#include < time.h >
#include <iostream>
int main(){
  timespec ts_beg, ts_end;
  clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &ts_beg);
  clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &ts_end);
  std::cout << (ts_end.tv_sec - ts_beg.tv_sec) + (ts_end.tv_nsec - ts_beg.tv_nsec) / 1e9 << " sec";
}

`

Question 9

আপনি যদি ইউনিক্সে থাকেন timeতবে এক্সিকিউশনের সময় পেতে আপনি এটি ব্যবহার করতে পারেন :

$ g++ myprog.cpp -o myprog
$ time ./myprog

Question 10

কেবলমাত্র একটি পার্শ্ব নোট: আপনি যদি উইন্ডোয় চলমান থাকেন এবং আপনার যদি সত্যই নির্ভুলতার প্রয়োজন হয় তবে আপনি কোয়েরি পারফরম্যান্স কাউন্টার ব্যবহার করতে পারেন । এটি আপনাকে (সম্ভাব্য) ন্যানো সেকেন্ডে সময় দেয় ।

Question 11

আমার জন্য, সবচেয়ে সহজ উপায় হ'ল:

#include <boost/timer.hpp>

boost::timer t;
double duration;

t.restart();
/* DO SOMETHING HERE... */
duration = t.elapsed();

t.restart();
/* DO OTHER STUFF HERE... */
duration = t.elapsed();

এই কোডের টুকরোটি ব্যবহার করে আপনাকে ক্লাসিকটি করতে হবে না end - start।

আপনার পছন্দসই পদ্ধতির উপভোগ করুন।

Question 12

শুরুতে মিলিসেকেন্ডে সিস্টেমের সময়টি পান, এবং আবার শেষে, এবং বিয়োগ করুন।

পসিক্সে ১৯ 1970০ সাল থেকে মিলিসেকেন্ডের সংখ্যা পেতে আপনি লিখতে পারেন:

struct timeval tv;

gettimeofday(&tv, NULL);
return ((((unsigned long long)tv.tv_sec) * 1000) +
        (((unsigned long long)tv.tv_usec) / 1000));

উইন্ডোজে 1601 সাল থেকে মিলিসেকেন্ডের সংখ্যা পেতে আপনি লিখতে পারেন:

SYSTEMTIME systime;
FILETIME filetime;

GetSystemTime(&systime);
if (!SystemTimeToFileTime(&systime, &filetime))
    return 0;

unsigned long long ns_since_1601;
ULARGE_INTEGER* ptr = (ULARGE_INTEGER*)&ns_since_1601;

// copy the result into the ULARGE_INTEGER; this is actually
// copying the result into the ns_since_1601 unsigned long long.
ptr->u.LowPart = filetime.dwLowDateTime;
ptr->u.HighPart = filetime.dwHighDateTime;

// Compute the number of milliseconds since 1601; we have to
// divide by 10,000, since the current value is the number of 100ns
// intervals since 1601, not ms.
return (ns_since_1601 / 10000);

আপনি যদি উইন্ডোজ উত্তরটি স্বাভাবিক করার জন্য যত্নশীল হন যাতে এটি 1970 সাল থেকে মিলিসেকেন্ডের সংখ্যাটিও ফিরিয়ে দেয় তবে আপনাকে নিজের উত্তরটি 11644473600000 মিলিসেকেন্ড দ্বারা সামঞ্জস্য করতে হবে। তবে এটি প্রয়োজনীয় নয় যদি আপনার যত্ন নেওয়া সমস্ত সময় অতিবাহিত হয়।

Question 13

আপনি যদি ব্যবহার করছেন:

tstart = clock();

// ...do something...

tend = clock();

তারপরে আপনার সেকেন্ডে সময় পেতে নিম্নলিখিতগুলির প্রয়োজন হবে:

time = (tend - tstart) / (double) CLOCKS_PER_SEC;

Question 14

এটি ইন্টেল ম্যাক 10.7 এর জন্য দুর্দান্ত কাজ করছে বলে মনে হচ্ছে:

#include <time.h>

time_t start = time(NULL);


    //Do your work


time_t end = time(NULL);
std::cout<<"Execution Time: "<< (double)(end-start)<<" Seconds"<<std::endl;