Подтвердить что ты не робот

Как измерить прошедшее время в С# и С++

У меня есть простой код С# и С++, который вычисляет сумму точечных продуктов.

Код С#:

using System;

namespace DotPerfTestCS
{
    class Program
    {
        struct Point3D
        {
            public double X, Y, Z;

            public Point3D(double x, double y, double z)
            {
                X = x;
                Y = y;
                Z = z;
            }
        }

        static void RunTest()
        {
            unchecked
            {
                const int numPoints = 100000;
                const int numIters = 100000000;

                Point3D[] pts = new Point3D[numPoints];
                for (int i = 0; i < numPoints; i++) pts[i] = new Point3D(i, i + 1, i + 2);

                var begin = DateTime.Now;
                double sum = 0.0;
                var u = new Point3D(1, 2, 3);
                for (int i = 0; i < numIters; i++)
                {
                    var v = pts[i % numPoints];
                    sum += u.X * v.X + u.Y * v.Y + u.Z * v.Z;
                }
                var end = DateTime.Now;
                Console.WriteLine("Sum: {0} Time elapsed: {1} ms", sum, (end - begin).TotalMilliseconds);
            }
        }

        static void Main(string[] args)
        {
            for (int i = 0; i < 5; i++) RunTest();
        }
    }
}

а С++ -

#include <iostream>
#include <vector>
#include <time.h>

using namespace std;

typedef struct point3d
{
    double x, y, z;

    point3d(double x, double y, double z)
    {
        this->x = x;
        this->y = y;
        this->z = z;
    }
} point3d_t;

double diffclock(clock_t clock1,clock_t clock2)
{
    double diffticks=clock1-clock2;
    double diffms=(diffticks*10)/CLOCKS_PER_SEC;
    return diffms;
}

void runTest()
{
    const int numPoints = 100000;
    const int numIters = 100000000;

    vector<point3d_t> pts;
    for (int i = 0; i < numPoints; i++) pts.push_back(point3d_t(i, i + 1, i + 2));

    auto begin = clock();
    double sum = 0.0, dum = 0.0;
    point3d_t u(1, 2, 3);
    for (int i = 0; i < numIters; i++) 
    {
        point3d_t v = pts[i % numPoints];
        sum += u.x * v.x + u.y * v.y + u.z * v.z;
    }
    auto end = clock();
    cout << "Sum: " << sum << " Time elapsed: " << double(diffclock(end,begin)) << " ms" << endl;

}

int main()
{
    for (int i = 0; i < 5; i++) runTest();
    return 0;
}

Версия С# (версия x86 с оптимизацией включена, x64 еще медленнее).

Sum: 30000500000000 Time elapsed: 551.0299 ms 
Sum: 30000500000000 Time elapsed: 551.0315 ms 
Sum: 30000500000000 Time elapsed: 552.0294 ms
Sum: 30000500000000 Time elapsed: 551.0316 ms 
Sum: 30000500000000 Time elapsed: 550.0315 ms

в то время как С++ (настройки по умолчанию для сборки VS2010 по умолчанию) дает

Sum: 3.00005e+013 Time elapsed: 4.27 ms
Sum: 3.00005e+013 Time elapsed: 4.27 ms
Sum: 3.00005e+013 Time elapsed: 4.25 ms
Sum: 3.00005e+013 Time elapsed: 4.25 ms
Sum: 3.00005e+013 Time elapsed: 4.25 ms

Теперь я ожидал бы, что код С# будет немного медленнее. Но в 130 раз медленнее мне кажется слишком много. Может кто-нибудь, пожалуйста, объясните мне, что здесь происходит?

ИЗМЕНИТЬ

Я не программист на С++, и я просто взял код разлома где-то из Интернета, не проверяя, правильно ли это.

Используя std:: difftime, результаты С++

Sum: 3.00005e+013 Time elapsed: 457 ms
Sum: 3.00005e+013 Time elapsed: 452 ms
Sum: 3.00005e+013 Time elapsed: 451 ms
Sum: 3.00005e+013 Time elapsed: 451 ms
Sum: 3.00005e+013 Time elapsed: 451 ms

который кажется правильным.

4b9b3361

ОТВЕТЫ

Ответ 1

Неверный код вашего разлома.

Если вы измените свой код на С++, чтобы использовать std::clock и std::difftime, он отображает фактическое время выполнения:

#include <iostream>
#include <vector>
#include <ctime>

using namespace std;

typedef struct point3d
{
    double x, y, z;

    point3d(double x, double y, double z)
    {
        this->x = x;
        this->y = y;
        this->z = z;
    }
} point3d_t;

void runTest()
{
    const int numPoints = 100000;
    const int numIters = 100000000;

    vector<point3d_t> pts;
    for (int i = 0; i < numPoints; i++) pts.push_back(point3d_t(i, i + 1, i + 2));

    auto begin = clock();
    double sum = 0.0, dum = 0.0;
    point3d_t u(1, 2, 3);
    for (int i = 0; i < numIters; i++) 
    {
        point3d_t v = pts[i % numPoints];
        sum += u.x * v.x + u.y * v.y + u.z * v.z;
    }
    auto end = clock();
    cout << "Sum: " << sum << " Time elapsed: " << double(std::difftime(end,begin)) << " ms" << endl;

}

int main()
{
    for (int i = 0; i < 5; i++) runTest();
    return 0;
}

Результаты:

Sum: 3.00005e+013 Time elapsed: 346 ms
Sum: 3.00005e+013 Time elapsed: 344 ms
Sum: 3.00005e+013 Time elapsed: 346 ms
Sum: 3.00005e+013 Time elapsed: 347 ms
Sum: 3.00005e+013 Time elapsed: 347 ms

Это приложение работает в режиме оптимизации по умолчанию, вне vs2010.

ИЗМЕНИТЬ

Как отмечали другие, в С++ использование clock() не является самым точным способом времени для функции (как в С#, Stopwatch лучше, чем DateTime).

Если вы используете окна, вы всегда можете использовать QueryPerformanceCounter для синхронизации с высоким разрешением.

Ответ 2

Я считаю, что вы обнаружите, что ваша реализация diffclock дает deciseconds, а не миллисекунды (предполагая, что CLOCKS_PER_SECOND точно названо). Исправляя это, реализация С# работает примерно на 30% медленнее, что кажется подходящим.

Ответ 3

Наиболее очевидной причиной может быть JIT, но как только это подтвердится, чтобы не быть причиной, у меня есть другое объяснение.

"Новая точка3D" встречается 100000 раз. Это 100000 распределений кучи, которые затем освобождаются позже. В версии С++ вектор также является основанной на куче, то есть когда он растет, существует realloc. Но когда вектор растет, он растет на много больше, чем один point3d_t каждый раз. Я ожидаю только 30 или около того вызовов realloc в версии С++.