Профилирование программыTest_cyc.C

TBS (Time Based Sampling)

Address Line Clockticks Source

1 #define Size 1000000

2 " int i, tmp, dim[Size];"

3

4 void main()

01:0010 5 {

01:0028 6 1 for(i=0;i<Size/10;i++){ tmp=dim[0]; dim[0]=dim[i]; dim[i]=tmp; };

01:0080 7 2 for(i=0;i<Size/5;i++){ tmp=dim[0]; dim[0]=dim[i]; dim[i]=tmp; };

01:00D8 8 4 for(i=0;i<Size/2;i++){ tmp=dim[0]; dim[0]=dim[i]; dim[i]=tmp; };

01:0130 9 8 for(i=0;i<Size;i++) { tmp=dim[0]; dim[0]=dim[i]; dim[i]=tmp; };

01:0188 10 for(i=0;i<Size/10;i++)

01:01AD 11 1 { tmp=dim[0]; dim[0]=dim[i]; dim[i]=tmp; };

01:01E0 12 for(i=0;i<Size/5;i++)

01:0205 13 1 { tmp=dim[0]; dim[0]=dim[i]; dim[i]=tmp; };

01:0238 14 1 for(i=0;i<Size/2;i++)

01:025D 15 3 { tmp=dim[0]; dim[0]=dim[i]; dim[i]=tmp; };

01:0290 16 2 for(i=0;i<Size;i++)

01:02B5 17 5 { tmp=dim[0]; dim[0]=dim[i]; dim[i]=tmp; };

01:02E8 18 1 for(i=0;i<Size/10;i++)

01:030D 19 { tmp=dim[0];

01:0319 20 dim[0]=dim[i];

01:032B 21 dim[i]=tmp;

01:033E 22 };

01:0340 23 for(i=0;i<Size/5;i++)

01:0365 24 { tmp=dim[0];

01:0371 25 1 dim[0]=dim[i];

01:0383 26 dim[i]=tmp;

01:0396 27 };

01:0398 28 2 for(i=0;i<Size/2;i++)

01:03BD 29 1 { tmp=dim[0];

01:03C9 30 dim[0]=dim[i];

01:03DB 31 dim[i]=tmp;

01:03EE 32 1 };

01:03F0 33 for(i=0;i<Size;i++)

01:0415 34 1 { tmp=dim[0];

01:0421 35 3 dim[0]=dim[i];

01:0433 36 2 dim[i]=tmp;

01:0446 37 2 };

01:0448 38 }

Вывод: Наблюдается прямо пропорциональная зависимость между временем выполнения цикла и числом повторений цикла. Порядок и способ записи операторов не влияет на скорость выполнения программы. Время работы не зависит от способа записи цикла.

Профилирование программыTest_sub.C

TBS (Time Based Sampling)

Address Line Clockticks Source

2

3

4 void TestLoop(int nTimes)

01:0020 5 {

6 static int TestDim[Size];

7 int tmp;

8 int iLoop;

9

01:0038 10 while (nTimes > 0)

11 {

01:003E 12 nTimes --;

13

01:0047 14 iLoop = Size;

01:004E 15 1 while (iLoop > 0)

16 {

01:0054 17 iLoop -- ;

01:005D 18 2 tmp = TestDim[0];

01:0066 19 3 TestDim[0] = TestDim[nTimes];

01:0076 20 2 TestDim[nTimes] = tmp;

01:0083 21 }

01:0085 22 }

01:0087 23 } /* TestLoop */

24

25

26 void main()

01:00B0 27 {

01:00C8 28 TestLoop(Size / 10); // 100 * 1000 ?®?a®a?­?©

01:00D2 29 TestLoop(Size / 5); // 200 * 1000 ?®?a®a?­?©

01:00DF 30 TestLoop(Size / 2); // 500 * 1000 ?®?a®a?­?©

01:00EC 31 TestLoop(Size / 1); // 1000* 1000 ?®?a®a?­?©

01:00F9 32 }

EBS (Event Based Sampling)

Address Line Clockticks Source

2

3

4 void TestLoop(int nTimes)

01:0020 5 {

6 static int TestDim[Size];

7 int tmp;

8 int iLoop;

9

01:0038 10 201 while (nTimes > 0)

11 {

01:003E 12 32 nTimes --;

13

01:0047 14 4 iLoop = Size;

01:004E 15 4749 while (iLoop > 0)

16 {

01:0054 17 2235 iLoop -- ;

01:005D 18 2513 tmp = TestDim[0];

01:0066 19 2400 TestDim[0] = TestDim[nTimes];

01:0076 20 2674 TestDim[nTimes] = tmp;

01:0083 21 4510 }

01:0085 22 1 }

01:0087 23 2 } /* TestLoop */

24

25

26 void main()

01:00B0 27 1 {

01:00C8 28 TestLoop(Size / 10); // 100 * 1000 повторений

01:00D2 29 TestLoop(Size / 5); // 200 * 1000 повторений

01:00DF 30 TestLoop(Size / 2); // 500 * 1000 повторений

01:00EC 31 TestLoop(Size / 1); // 1000* 1000 повторений

01:00F9 32 }

Вывод: Цель данной программы – выявить зависимость скорости выполнения процедуры от числа итераций внутри процедуры. При профилировании было выявлено, что наибольшее время было затрачено на выполнения цикла while, что вполне понятно, т.к. этот цикл несет основную вычислительную нагрузку. Время выполнения процедур оценить не удалось.

Интересным является момент со строками 18-20. В данном случае скорость записи из массива в массив (при использовании одного и того же массива) меньше, хоть и незначительно, чем скорость записи из переменной в массив и из массива в переменную.