Private static extern bool QueryPerformanceCounter(ref

long lpPerformanceCount );

 

[ System. Runtime. InteropServices. DllImport ( "KERNEL32" )]

private static extern bool

QueryPerformanceFrequency (ref long lpFrequency );

 

long totalCount = 0;

long startCount = 0;

long stopCount = 0;

long freq = 0;

 

public void Start ()

{

startCount = 0;

QueryPerformanceCounter (ref startCount );

}

 

public void Stop ()

{

stopCount = 0;

QueryPerformanceCounter (ref stopCount );

totalCount += stopCount - startCount;

}

 

public void Reset ()

{

totalCount = 0;

}

 

public float TotalSeconds

{

get

{

freq = 0;

QueryPerformanceFrequency (ref freq );

return(( float ) totalCount / ( float ) freq );

}

}

 

public double MFlops ( double total_flops )

{

return ( total_flops / ( 1e6 * TotalSeconds ));

}

 

public override string ToString ()

{

return String. Format ( "{0:F3} seconds", TotalSeconds );

}

}

}

 

using System;

using PerfCounter;

 

namespace BenchArrays

{

/// <summary>

/// Тестирование последовательного и диагонального доступа

/// к неровным и прямоугольным массивам

/// </summary>

class TestArrays

{

 

[ STAThread ]

static void Main ( string [] args )

{

int loopCounter = 1000;

int dim = 1000;

double temp;

 

// Объявляем неровный двухмерный массив

double [][] arrJagged = new double [ dim ][];

 

// Объявляем прямоугольный двухмерный массив

double [,] arrRect = new double [ dim, dim ];

 

/* Создаем экземпляры массивов и инициализируем их */

for ( int i = 0; i <;arrJagged. Length; i ++)

{

arrJagged [ i ] = new double [ dim ];

for ( int j = 0; j <;arrJagged [ i ]. Length; j ++)

{

arrJagged [ i ][ j ] = arrRect [ i, j ] = i * j;

}

}

 

Counter counter = new Counter ();

 

// ЦИКЛ 1.

// Измеряем время последовательного доступа

// к прямоугольному массиву.

counter. Reset ();

counter. Start ();

Console. WriteLine ( "Starting loop 1..." );

for( int i = 0; i <;loopCounter; i ++)

{

for( int j = 0; j <;dim; j ++)

{

for( int k = 0; k <;dim; k ++)

{

temp = arrRect [ j, k ];

}

}

}

counter. Stop ();

Console. WriteLine ( "Time for rect sequential access:

{ 0 } ", counter);

Console. WriteLine ();

 

// ЦИКЛ 2.

// Измеряем время диагонального доступа

// к прямоугольному массиву.

Console. WriteLine ( "Starting loop 2..." );

counter. Reset ();

counter. Start ();

for( int i = 0; i <;loopCounter; i ++)

{

for( int j = 0; j <;dim; j ++)

{

for( int k = 0; k <;dim; k ++)

{

temp = arrRect [ k, k ];

}

}

}

counter. Stop ();

Console. WriteLine ( "Time for rect diagonal access:

{ 0 } ", counter);

Console. WriteLine ();

 

// ЦИКЛ 3.

// Измеряем время последовательного доступа

// к неровному массиву.

counter. Reset ();

counter. Start ();

Console. WriteLine ( "Starting loop 3..." );

for( int i = 0; i <;loopCounter; i ++)

{

for( int j = 0; j <;arrJagged. Length; j ++)

{

for( int k = 0; k <;arrJagged [ j ]. Length; k ++)

{

temp = arrJagged [ j ][ k ];

}

}

}

counter. Stop ();

Console. WriteLine ( "Time for jagged sequential

access: { 0 } ", counter);

Console. WriteLine ();

 

// ЦИКЛ 4.

// Измеряем время диагонального доступа

// к неровному массиву.

counter. Reset ();

counter. Start ();

Console. WriteLine ( "Starting loop 4..." );

for( int i = 0; i <;loopCounter; i ++)

{

for( int j = 0; j <;arrJagged. Length; j ++)

{

for( int k = 0; k <;arrJagged [ j ]. Length; k ++)

{

temp = arrJagged [ k ][ k ];

}

}

}

counter. Stop ();

Console. WriteLine ( "Time for jagged diagonal access:

{ 0 } ", counter);

Console. WriteLine ( "End Of Benchmark." );

Console. ReadLine ();

}

}

}

 

На рис. 2 показаны результаты, полученные при выполнении тестов из листинга 6. Как видите, последовательная выборка из довольно больших массивов для обоих типов массивов дает сравнимые результаты, тогда как диагональная выборка из неровного массива выполняется примерно в восемь раз медленнее, чем из прямоугольного.

Рис. 2. Последовательная и диагональная выборка

 

Хотя прямоугольные массивы обычно превосходят неровные в отношении структуризации и производительности, возможны случаи, где неровные массивы оптимальны. Если вашему приложению не нужны сортируемые, переупорядочиваемые, разделенные (partitioned), разреженные или большие массивы, то неровные массивы вполне подойдут. Однако заметьте: это утверждение верно для большинства приложений, но неприменимо для библиотечного кода. Контекст, в котором кто-то другой будет использовать ваш библиотечный код, зачастую неизвестен, и это может стать причиной плохой производительности систем.

 

Например, пожелав написать универсальную библиотеку Matrix с применением неровных массивов, вы обнаружите, что она ужасно работает в ряде приложений, имеющих дело с графикой, анализом изображений, анализом конечных элементов, механикой, «просеиванием» данных, подбором данных и нейронными сетями. Это вызвано тем, что в них часто встречаются большие разреженные матрицы, где большинство элементов равно нулю или не используется, и поэтому соответствующие массивы нужно считывать в произвольном порядке.

 

В таких ситуациях переходите на прямоугольные массивы, и общая производительность значительно возрастет. Для примера в коде листинга 7 и 8 тестируется производительность двух разных реализаций приложения, которое перемножает пару больших матриц. Каждое из этих приложений использует класс счетчика производительности, показанный в листинге 6. Для представления матриц в коде листинга 7 используются двухмерные неровные массивы, а в листинге 8 — прямоугольные. Каждое приложение выводит время своей работы и число MFLOPS. Этот простой тест призван показать, что код, использующий прямоугольные массивы, примерно в восемь—девять раз быстрее эквивалентного кода с неровными массивами.