Стоимость общих операций для C#?

Это разумный вопрос, но почти все проблемы с производительностью, которые я видел, особенно в Java и C #, сводились к:

• слишком много уровней абстракции и
• полагаться на кодирование в стиле уведомлений на основе событий.

которые имеют мало или не имеют ничего общего с базовыми операциями.

Проблема с абстракцией в том, что это нормально, пока рабочая нагрузка не станет тяжелой. . Каждый уровень обычно приводит к небольшому снижению производительности, которое накапливается в совокупности. На этом этапе вам нужны обходные пути. (Я думаю, что StringBuilder является примером такого обходного пути.)

Проблема с кодированием в стиле уведомлений на основе событий (в отличие от более простых структур данных, согласованных с помощью периодического процесса) заключается в том, что то, что может показаться простыми действиями,

Я реализовал некоторые тесты из книги. Некоторые необработанные данные с моего компьютера:

Тестовый прогон №1:

TestIntegerAssignment 00: 00: 00.6680000
TestCallRoutineWithNoParameters 00: 00: 00.9780000
TestCallRoutineWithOneParameter 00: 00: 00.6580000
TestCallRoutineWithTwoParameters 00: 00: 00.9650000
TestIntegerAddition 00: 00: 00.6410000
TestIntegerSubtraction 00: 00: 00.9630000
TestIntegerMultiplication 00: 00: 00.6490000
TestIntegerDivision 00: 00: 00.9720000
TestFloatingPointDivision 00: 00: 00.6500000
TestFloatingPointSquareRoot 00: 00: 00.9790000
TestFloatingPointSine 00: 00: 00.6410000
TestFloatingPointLogarithm 00: 00: 41.1410000
TestFloatingPointExp 00: 00: 34.6310000

Тестовый прогон №2:

TestIntegerAssignment 00: 00: 00.6750000
TestCallRoutineWithNoParameters 00:00:00.9720000
TestCallRoutineWithOneParameter 00:00:00.6490000
TestCallRoutineWithTwoParameters 00:00:00.9750000
TestIntegerAddition 00:00:00.6730000
TestIntegerSubtraction 00:00:01.0300000
TestIntegerMultiplication 00:00:00.7000000
TestIntegerDivision 00:00:01.1120000
TestFloatingPointDivision 00:00:00.6630000
TestFloatingPointSquareRoot 00:00:00.9860000
TestFloatingPointSine 00:00:00.6530000
TestFloatingPointLogarithm 00:00:39.1150000
TestFloatingPointExp 00:00:33.8730000

Test Run #3:

TestIntegerAssignment 00:00:00.6590000
TestCallRoutineWithNoParameters 00:00:00.9700000
TestCallRoutineWithOneParameter 00:00:00.6680000
TestCallRoutineWithTwoParameters 00:00:00.9900000
TestIntegerAddition 00:00:00.6720000
TestIntegerSubtraction 00:00:00.9770000
TestIntegerMultiplication 00:00:00.6580000
TestIntegerDivision 00:00:00.9930000
TestFloatingPointDivision 00:00:00.6740000
TestFloatingPointSquareRoot 00:00:01.0120000
TestFloatingPointSine 00:00:00.6700000
TestFloatingPointLogarithm 00:00:39.1020000
TestFloatingPointExp 00: 00: 35.3560000

(1 миллиард тестов на тест, скомпилирован с помощью Optimize, AMD Athlon X2 3.0ghz, с использованием инфраструктуры микробенчмаркинга Джона Скита, доступной по адресу http://www.yoda.arachsys.com/csharp/ benchmark.html )

Источник:

class TestBenchmark  
{  
[Benchmark]  
public static void TestIntegerAssignment()
{
int i = 1;
int j = 2;

    for (int x = 0; x < 1000000000; x++)
    {
        i = j;
    }
}

[Benchmark]
public static void TestCallRoutineWithNoParameters()
{
    for (int x = 0; x < 1000000000; x++)
    {
        TestStaticRoutine();
    }
}

[Benchmark]
public static void TestCallRoutineWithOneParameter()
{
    for (int x = 0; x < 1000000000; x++)
    {
        TestStaticRoutine2(5);
    }
}

[Benchmark]
public static void TestCallRoutineWithTwoParameters()
{
    for (int x = 0; x < 1000000000; x++)
    {
        TestStaticRoutine3(5,7);
    }
}

[Benchmark]
public static void TestIntegerAddition()
{
    int i = 1;
    int j = 2;
    int k = 3;

    for (int x = 0; x < 1000000000; x++)
    {
        i = j + k;
    }
}

[Benchmark]
public static void TestIntegerSubtraction()
{
    int i = 1;
    int j = 6;
    int k = 3;

    for (int x = 0; x < 1000000000; x++)
    {
        i = j - k;
    }
}

[Benchmark]
public static void TestIntegerMultiplication()
{
    int i = 1;
    int j = 2;
    int k = 3;

    for (int x = 0; x < 1000000000; x++)
    {
        i = j * k;
    }
}


[Benchmark]
public static void TestIntegerDivision()
{
    int i = 1;
    int j = 6;
    int k = 3;

    for (int x = 0; x < 1000000000; x++)
    {
        i = j/k;
    }
}

[Benchmark]
public static void TestFloatingPointDivision()
{
    float i = 1;
    float j = 6;
    float k = 3;

    for (int x = 0; x < 1000000000; x++)
    {
        i = j / k;
    }
}

[Benchmark]
public static void TestFloatingPointSquareRoot()
{
    double x = 1;
    float y = 6;

    for (int x2 = 0; x2 < 1000000000; x2++)
    {
        x = Math.Sqrt(6);
    }
}

[Benchmark]
public static void TestFloatingPointSine()
{
    double x = 1;
    float y = 6;

    for (int x2 = 0; x2 < 1000000000; x2++)
    {
        x = Math.Sin(y);
    }
}

[Benchmark]
public static void TestFloatingPointLogarithm()
{
    double x = 1;
    float y = 6;

    for (int x2 = 0; x2 < 1000000000; x2++)
    {
        x = Math.Log(y);
    }
}

[Benchmark]
public static void TestFloatingPointExp()
{
    double x = 1;
    float y = 6;

    for (int x2 = 0; x2 < 1000000000; x2++)
    {
        x = Math.Exp(6);
    }
}

private static void TestStaticRoutine() {

}

private static void TestStaticRoutine2(int i)
{

}

private static void TestStaticRoutine3(int i, int j)
{

}

private static class TestStaticClass
{

}