958 lines
55 KiB
TeX
958 lines
55 KiB
TeX
\documentclass[a4paper,fontsize=14bp]{article}
|
||
|
||
\input{../common-preamble}
|
||
\input{../fancy-listings-preamble}
|
||
\input{../bmstu-preamble}
|
||
\numerationTop
|
||
\begin{document}
|
||
\setlength{\columnsep}{22pt}
|
||
\thispagestyle{empty}
|
||
\makeBMSTUHeader
|
||
|
||
\makeReportTitle{лабораторной}{2}{Разработка программного обеспечения. \\Отладка и профилирование кода}{Программное обеспечение встроенных систем}{}{доцент кафедры ИУ-3 \\ Федоров С.В.}
|
||
\newpage
|
||
\pagestyle{fancy}
|
||
%\blankpage
|
||
\tableofcontents
|
||
\newpage
|
||
\section*{Цель работы}
|
||
\addcontentsline{toc}{section}{Цель работы}
|
||
В лабораторной работе необходимо осуществить отладку программы, её профилирование, выполнить требования по быстродействию и объему для отдельных функций ПО. Изучить влияние ручных оптимизаций циклов на быстродействие программы. Изучить оптимизации компилятора на уровне формируемого ассемблерного кода.
|
||
|
||
\section*{Задания}
|
||
\addcontentsline{toc}{section}{Задания}
|
||
\begin{itemize}
|
||
\item Общее задание части I
|
||
\begin{enumerate}
|
||
\item Исходный код программы обработки прерывания от кнопок с замером времени выполнения обработчика прерывания.
|
||
\item Результаты измерения времени выполнения первого и последующих вызовов обработчика прерывания для разных уровней оптимизации.
|
||
\item Прокомментированный ассемблерный код обработчика прерывания для оптимизации Level3 и для отключенной оптимизации.
|
||
\item Сравнение результатов и выводы.
|
||
\end{enumerate}
|
||
\item Индивидуальное задание части I
|
||
\begin{enumerate}
|
||
\item Текст индивидуального задания.
|
||
\item Исходный код программы, в которой реализована инициализация и обработка массива данных с помощью двух разработанных по заданию функций: одна без развертывания цикла, а другая с развертыванием цикла.
|
||
\item Результаты измерения времени выполнения разработанных функций для оптимизации Level3 и для отключенной оптимизации.
|
||
\item Результаты измерения количества тактов, затрачиваемых на одну итерацию неразвернутого цикла при включенной оптимизации Level3 при разных объемах массивов данных.
|
||
\item Прокомментированный ассемблерный код разработанных функций для оптимизации Level3 и для отключенной оптимизации.
|
||
\item Сравнение результатов и выводы.
|
||
\end{enumerate}
|
||
\item Общее задание части II
|
||
\end{itemize}
|
||
|
||
\section*{Общее задание части I.}
|
||
\addcontentsline{toc}{section}{Общее задание части I.}
|
||
Для подсчёта времени был модифицирован код из первой лабораторной работы (добавлен таймер и вывод информации с него). Код представлен в листинге \hrf{lst:btnISR} внесённые изменения отмечены \lh{red}{красным}, функции, директивы и комментарии, оставшиеся без изменений опущены:
|
||
|
||
\begin{lstlisting}[language=C, style=CCodeStyle, caption=Performance counter в обработчике прерываний, label={lst:btnISR}]
|
||
// includes
|
||
// defines
|
||
|
||
volatile int edge_capture;
|
||
void handle_button_interrupts(void* context, alt_u32 id) {
|
||
<@\lh{red}{PERF\_BEGIN (PERFORMANCE\_COUNTER\_0\_BASE, 1);}@>
|
||
|
||
volatile int* edge_capture_ptr = (volatile int*) context;
|
||
*edge_capture_ptr = IORD_ALTERA_AVALON_PIO_EDGE_CAP(BUTTONS_BASE);
|
||
IOWR_ALTERA_AVALON_PIO_EDGE_CAP(BUTTONS_BASE, 0x0);
|
||
IORD_ALTERA_AVALON_PIO_EDGE_CAP(BUTTONS_BASE);
|
||
|
||
<@\lh{red}{PERF\_END (PERFORMANCE\_COUNTER\_0\_BASE, 1);}@>
|
||
}
|
||
|
||
void init_button_pio() {
|
||
// edge capture ptr, PIO_IRQ_MASK, PIO_EDGE_CAP, alt_ic_isr_register
|
||
}
|
||
|
||
int main(void) {
|
||
int led = 0x01;
|
||
printf("Simple\n");
|
||
|
||
IOWR_ALTERA_AVALON_PIO_DATA(GREEN_LED_BASE,led);
|
||
// Performance counter reset and initialize
|
||
<@\lh{red}{PERF\_RESET (PERFORMANCE\_COUNTER\_0\_BASE);}@>
|
||
<@\lh{red}{PERF\_START\_MEASURING (PERFORMANCE\_COUNTER\_0\_BASE);}@>
|
||
|
||
init_button_pio();
|
||
edge_capture = 0;
|
||
|
||
// local counter to control performance
|
||
<@\lh{red}{int cntCounts = 0;}@>
|
||
while (1) {
|
||
if (edge_capture != 0) {
|
||
<@\lh{red}{cntCounts++;}@>
|
||
switch(edge_capture) {
|
||
case KEY_3:
|
||
led = 0xFF; // all bits 1
|
||
break;
|
||
case KEY_2:
|
||
led &= led >> 1;
|
||
break;
|
||
case KEY_1:
|
||
led &= led << 1;
|
||
break;
|
||
case KEY_0:
|
||
led = 0x00; // all bits 0
|
||
break;
|
||
}
|
||
IOWR_ALTERA_AVALON_PIO_DATA(GREEN_LED_BASE,led);
|
||
edge_capture = 0;
|
||
|
||
// recompile this condition to check one or ten interrupts
|
||
// if (cntCounts == 1) {
|
||
<@\lh{red}{if (cntCounts == 10) \{}@>
|
||
<@\lh{red}{PERF\_STOP\_MEASURING (PERFORMANCE\_COUNTER\_0\_BASE);}@>
|
||
<@\lh{red}{perf\_print\_formatted\_report (}@>
|
||
<@\lh{red}{PERFORMANCE\_COUNTER\_0\_BASE,}@>
|
||
<@\lh{red}{ALT\_CPU\_FREQ, 1,}@>
|
||
<@\lh{red}{"Btn irq time",}@>
|
||
<@\lh{red}{"Time of ten interrupts");}@>
|
||
<@\lh{red}{PERF\_END (PERFORMANCE\_COUNTER\_0\_BASE, 0);}@>
|
||
<@\lh{red}{\}}@>
|
||
}
|
||
}
|
||
}
|
||
\end{lstlisting}
|
||
|
||
Для помещения функции обработчика прерываний в тесно связанную память был добавлен прототип функции с указанием атрибута, уточняющего секцию памяти, в которой функция должна располагаться.
|
||
|
||
\begin{lstlisting}[language=C,style=CCodeStyle]
|
||
void handle_button_interrupts(void* context, alt_u32 id) __attribute__ ((section("irq")));
|
||
\end{lstlisting}
|
||
|
||
В результате выполнения данного кода были получены результаты, представленные в таблице \hrf{table:isrtime}. Скриншоты с этими же результатами представлены в приложении \hrf{appendix:isrtime}. После нескольких запусков с разными вариантами настроек можно однозначно сказать, что при расположении обработчика прерываний в тесносвязанной памяти очевидно ускорение работы функции даже без оптимизаций компилятора. Из результатов видно, что размещённый в тесносвязанной памяти код выполняется так, будто находится в кэше. При размещении в обычной памяти, первый вызов выполняется дольше, поскольку обработчик перемещается в кэш (далее он оттуда не вытесняется, поскольку в целом программа очень простая). Время работы при разных типах оптимизации не меняется так как обработчик очень простой.
|
||
|
||
\begin{table}[H]
|
||
\centering
|
||
\begin{tabular}{||l|l|c|c||}
|
||
\hline
|
||
Использование TCM & Оптимизация & Количество прерываний & Время (тактов) \\ [0.5ex]
|
||
\hline\hline
|
||
нет & нет & 1 & 62 \\
|
||
нет & нет & 10 & 314 \\
|
||
нет & -О2 & 1 & 43 \\
|
||
нет & -О2 & 10 & 223 \\
|
||
нет & размер & 1 & 43 \\
|
||
нет & размер & 10 & 223 \\
|
||
да & нет & 1 & 28 \\
|
||
да & нет & 10 & 280 \\
|
||
да & -О3 & 1 & 20 \\
|
||
да & -О3 & 10 & 200 \\
|
||
да & размер & 1 & 20 \\
|
||
да & размер & 10 & 200 \\ [1ex]
|
||
\hline
|
||
\end{tabular}
|
||
\caption{Зависимость времени исполнения функции от количества прерываний}
|
||
\label{table:isrtime}
|
||
\end{table}
|
||
|
||
Оптимизации процессора значительно повлияли на транслируемый код, скопмилировав в результате ассемблерный код, представленный в листингах \hrf{lst:noopt} и \hrf{lst:optlv2}. В неоптимизированном коде видно гораздо больше обращений к памяти (мнемоники \code{stw}, \code{ldw}), в то время, как оптимизированный код сразу работает только с периферийным модулем (мнемоники \code{stwio}, \code{ldwio}). Также неоптимизированная версия программы сразу выделяет место для своей работы на стеке (\code{sp,sp,-16}), сохраняет принятые в функцию параметры, несмотря на то, что один из них не используется вовсе, а второй используется только один раз (\code{r4}, \code{r5} записываются в -8 и -12 сдвиги от указателя на фрейм, соответственно, а читается только \code{r4}: \code{ldw r2,-8(fp)}) и активнее работает с локальными регистрами, сохраняя в них промежуточные значения, прочитанные из периферийных модулей. В то время, как оптимизированная функция работает с единственным, возвращающим, регистром \code{r2}.
|
||
|
||
\begin{lstlisting}[style=ASMStyle, caption=Код без оптимизаций, label={lst:noopt}]
|
||
00000284 <handle_button_interrupts>:
|
||
284: defffc04 addi sp,sp,-16
|
||
288: df000315 stw fp,12(sp)
|
||
28c: df000304 addi fp,sp,12
|
||
290: e13ffe15 stw r4,-8(fp)
|
||
294: e17ffd15 stw r5,-12(fp)
|
||
298: 0007883a mov r3,zero
|
||
29c: 00820034 movhi r2,2048
|
||
2a0: 10c40535 stwio r3,4116(r2)
|
||
2a4: e0bffe17 ldw r2,-8(fp)
|
||
2a8: e0bfff15 stw r2,-4(fp)
|
||
2ac: 00820034 movhi r2,2048
|
||
2b0: 10c42337 ldwio r3,4236(r2)
|
||
2b4: e0bfff17 ldw r2,-4(fp)
|
||
2b8: 10c00015 stw r3,0(r2)
|
||
2bc: 0007883a mov r3,zero
|
||
2c0: 00820034 movhi r2,2048
|
||
2c4: 10c42335 stwio r3,4236(r2)
|
||
2c8: 00820034 movhi r2,2048
|
||
2cc: 10842337 ldwio r2,4236(r2)
|
||
2d0: 0007883a mov r3,zero
|
||
2d4: 00820034 movhi r2,2048
|
||
2d8: 10c40435 stwio r3,4112(r2)
|
||
2dc: 0001883a nop
|
||
2e0: e037883a mov sp,fp
|
||
2e4: df000017 ldw fp,0(sp)
|
||
2e8: dec00104 addi sp,sp,4
|
||
2ec: f800283a ret
|
||
\end{lstlisting}
|
||
|
||
\begin{lstlisting}[style=ASMStyle, caption=Код с оптимизацией -О2, label={lst:optlv2}]
|
||
00000284 <handle_button_interrupts>:
|
||
284: 00820034 movhi r2,2048
|
||
288: 10040535 stwio zero,4116(r2)
|
||
28c: 10842337 ldwio r2,4236(r2)
|
||
290: 20800015 stw r2,0(r4)
|
||
294: 00820034 movhi r2,2048
|
||
298: 10042335 stwio zero,4236(r2)
|
||
29c: 10842337 ldwio r2,4236(r2)
|
||
2a0: 00820034 movhi r2,2048
|
||
2a4: 10040435 stwio zero,4112(r2)
|
||
2a8: f800283a ret
|
||
\end{lstlisting}
|
||
|
||
\section*{Индивидуальное задание части I.}
|
||
\addcontentsline{toc}{section}{Индивидуальное задание части I.}
|
||
\subsection*{Развёрнутый цикл и оптимизации}
|
||
Индивидуальным заданием в первой части работы был расчёт контрольной суммы UDP для блока данных. Код программы, реализующей вызов функции расчёта контрольной суммы и подсчёт времени выполнения посредством Performance Counter представлен в листинге \hrf{lst:udpCode}. На строках \hrf{line:nounroll} и \hrf{line:unroll} представлены циклы, выполняющие одну и ту же задачу, но без применения развёртывания цикла (loop unrolling) и с применением, соответственно. Также важно, что цикл без развёртывания является циклом <<добора>>, то есть когда развёрнутый цикл (строка \hrf{line:unroll}) завершает свою работу в массиве данных могут остаться некратные данные, которые досчитываются циклом со строки \hrf{line:nounroll}.
|
||
\begin{lstlisting}[language=C, style=CCodeStyle, caption=Функция расчёта контрольной суммы UDP, label={lst:udpCode}]
|
||
#include <stdio.h>
|
||
#include <unistd.h>
|
||
#include "altera_avalon_pio_regs.h"
|
||
#include "altera_avalon_performance_counter.h"
|
||
#include "sys/alt_irq.h"
|
||
#include "system.h"
|
||
|
||
#define CACHE_CHECK 2048
|
||
|
||
unsigned short checkSum(unsigned short* addr, int size) __attribute__ ((section("irq")));
|
||
unsigned short checkSum(unsigned short* addr, int size) {
|
||
register unsigned short checksum = 0;
|
||
register int sum = 0;
|
||
|
||
// unrolled cycle
|
||
while (size > 8) { <@\label{line:unroll}@>
|
||
sum += *addr++;
|
||
sum += *addr++;
|
||
sum += *addr++;
|
||
sum += *addr++;
|
||
size -= 8;
|
||
}
|
||
|
||
// simple cycle (and)
|
||
while (size > 1) { <@\label{line:nounroll}@>
|
||
sum += *addr++;
|
||
size -= 2;
|
||
}
|
||
|
||
if (size > 0) {
|
||
sum += *(unsigned char *) addr;
|
||
}
|
||
|
||
while (sum >> 16) {
|
||
sum = (sum & 0xffff) + (sum >> 16);
|
||
}
|
||
checksum = ~sum;
|
||
return checksum;
|
||
}
|
||
|
||
int main(void) {
|
||
printf("udp tcm 3 opt unroll cycle\n");
|
||
PERF_RESET(PERFORMANCE_COUNTER_0_BASE);
|
||
|
||
const int SIZE = CACHE_CHECK;
|
||
unsigned short udpCheckSum = 0;
|
||
short datagram[SIZE];
|
||
const void *buf;
|
||
|
||
// filling datagram
|
||
short c1 = 0xf001;
|
||
short c2 = 0x0e11;
|
||
short c3 = 0xaad0;
|
||
short c4 = 0xa00c;
|
||
int i = 0;
|
||
do {
|
||
datagram[i + 0] = c1;
|
||
datagram[i + 1] = c2;
|
||
datagram[i + 2] = c3;
|
||
datagram[i + 3] = c4;
|
||
i += 4;
|
||
} while (i < SIZE);
|
||
buf = (const void*) datagram;
|
||
|
||
PERF_START_MEASURING(PERFORMANCE_COUNTER_0_BASE);
|
||
i = 100;
|
||
while (0 < --i) {
|
||
PERF_BEGIN (PERFORMANCE_COUNTER_0_BASE, 1);
|
||
udpCheckSum = checkSum(buf, (SIZE + 1) * 2);
|
||
PERF_END (PERFORMANCE_COUNTER_0_BASE, 1);
|
||
}
|
||
|
||
perf_print_formatted_report (
|
||
PERFORMANCE_COUNTER_0_BASE,
|
||
ALT_CPU_FREQ, 1,
|
||
"UDP 2048",
|
||
"Time");
|
||
PERF_STOP_MEASURING (PERFORMANCE_COUNTER_0_BASE);
|
||
printf("checksum = 0x%x\n", udpCheckSum);
|
||
return 0;
|
||
}
|
||
\end{lstlisting}
|
||
|
||
Результаты замеров времени выполнения этих двух вариантов функции приведены в таблице \hrf{table:udpchecksum}. Все измерения проводились на 99ти повторениях, снимки экрана представлены в приложении \hrf{appendix:checksumTime}.
|
||
|
||
\begin{table}[H]
|
||
\centering
|
||
\begin{tabular}{||r|c|c||}
|
||
\hline
|
||
Оптимизация & Цикл развёрнут & Время(тактов) \\ [0.5ex]
|
||
\hline\hline
|
||
нет & нет & 24322152 \\
|
||
нет & да & 14470051 \\
|
||
-О3 & нет & 6835626 \\
|
||
-О3 & да & 4174875 \\
|
||
\hline
|
||
\end{tabular}
|
||
\caption{Применение развёртывания цикла при выполнении вычислений}
|
||
\label{table:udpchecksum}
|
||
\end{table}
|
||
|
||
Для массивов длиной 8192 элементов типа \code{unsigned short}, циклически заполненных значениями \code{0xf001}, \code{0x0e11}, \code{0xaad0}, \code{0xa00c} получилось значение \code{0xbec8}, что является корректным значением контрольной суммы.
|
||
|
||
\subsection*{Оптимизация и заполнение памяти}
|
||
В процессе выполнения программы были произведены измерения количества тактов, затрачиваемых на одну итерацию неразвернутого цикла при включенной оптимизации -O3 при разных объемах массивов данных. Результаты измерений приведены в таблице \hrf{table:memory}. Подсчёт результатов был произведён без изменения положения Performace Counter (для всей функции целиком) согласно средней асимтотической сложности алгоритма получения контрольной суммы O(n), где n - это размер входящего массива данных. Для системы было выделено 16384 байта, соответственно, для заполнения её согласно задания необходимо создать массивы на 16384 ($200\%$), 8192 ($100\%$), 4096 ($50\%$), 2048 ($25\%$) элементов типа \code{unsigned short} (шестнадцатиразрядные беззнаковые целые числа). Снимки экрана с результатами работы Performance counter представлены в приложении \hrf{appendix:udpMemory}.
|
||
|
||
\begin{table}[H]
|
||
\centering
|
||
\begin{tabular}{||r|c|c|c||}
|
||
\hline
|
||
Цикл развёрнут & \thead{Расчётное\\заполнение памяти\\(процентов)} & \thead{Время\\функции\\(секунд)} & \thead{Расчётное время\\одной итерации\\(мксек)} \\ [0.5ex]
|
||
\hline\hline
|
||
нет & 25 & 0.03427 & 0.169024 \\
|
||
нет & 50 & 0.06843 & 0.168753 \\
|
||
нет & 100 & 0.13671 & 0.168568 \\
|
||
нет & 200 & 0.27328 & 0.168482 \\
|
||
да & 25 & 0.02097 & 0.413707 \\
|
||
да & 50 & 0.04181 & 0.412425 \\
|
||
да & 100 & 0.08350 & 0.411833 \\
|
||
да & 200 & 0.16676 & 0.411241 \\
|
||
\hline
|
||
\end{tabular}
|
||
\caption{Скорость исполнения одной итерации относительно заполнения памяти}
|
||
\label{table:memory}
|
||
\end{table}
|
||
|
||
В таблице видно, что каждая итерация развёрнутого цикла выполняется дольше, но не в четыре раза, поэтому за счёт уменьшения количества итераций в четыре раза получается довольно значительный прирост в скорости исполнения программы. Такой прирост обусловлен снижением накладных расходов на каждую итерацию цикла. В листингах \hrf{lst:nooptsim} и \hrf{lst:nooptunf} представлен ассемблерный код функции подсчёта контрольной суммы без применения развёртывания основного цикла и с применением, соответственно, а в листингах \hrf{lst:optsim} и \hrf{lst:optunf} такой же код, но с оптимизацией компилятора -О3.
|
||
|
||
В листинге \hrf{lst:nooptsim} на строках с \hrf{line:simbody} по \hrf{line:simcond} виден цикл, обрабатывающий значения из массива. Аналогичный цикл виден как <<цикл добора>> в листинге \hrf{lst:nooptunf} на строках с \hrf{line:unfsimbody} по \hrf{line:unfsimcond}. Адреса начала и конца тел циклов выделены \lh{blue}{синим}.
|
||
|
||
В листинге с развёртыванием цикла на каждой итерации осуществляется четыре идентичных действия по чтению значения из исходного массива (\hrf{line:unfit1b}, \hrf{line:unfit2b}, \hrf{line:unfit3b}, \hrf{line:unfit4b}), выделены \lh{dkgreen}{зелёным}; прибавления этого значения в регистр суммы и инкремент указателя на массив (\hrf{line:unfit1e}, \hrf{line:unfit2e}, \hrf{line:unfit3e}, \hrf{line:unfit4e}), выделены \lh{red}{красным}. Далее в обеих функциях следует условие добора нечётности исходного массива и цикл преобразования суммы к 16-разрядному значению.
|
||
|
||
\begin{lstlisting}[style=ASMStyle, caption=Код без развёртывания, label={lst:nooptsim}]
|
||
// <@\lh{dkgreen}{выделить для стека функции 16 байт}@>
|
||
10000000: defffc04 addi sp,sp,-16
|
||
// <@\lh{dkgreen}{сохранить в указатель на фрейм 12й байт (первый элемент) стека}@>
|
||
10000004: df000315 stw fp,12(sp)
|
||
// <@\lh{dkgreen}{что в sp(8)?}@>
|
||
10000008: dc000215 stw r16,8(sp)
|
||
// <@\lh{dkgreen}{fp = sp+12}@>
|
||
1000000c: df000304 addi fp,sp,12
|
||
// <@\lh{dkgreen}{указатель на переданный массив в }@>fp-8
|
||
10000010: e13ffe15 stw r4,-8(fp)
|
||
// <@\lh{dkgreen}{переданная длина массива в }@>fp-12
|
||
10000014: e17ffd15 stw r5,-12(fp)
|
||
// <@\lh{dkgreen}{сумма = 0}@>
|
||
10000018: 0021883a mov r16,zero
|
||
// <@\lh{dkgreen}{переходим по адресу }@>0x44
|
||
<@\lh{blue}{1000001c: 00000906 br}@> 10000044<checkSum+0x44> <@\label{line:simbody}@>
|
||
// <@\lh{dkgreen}{r2 = массив}@>
|
||
10000020: e0bffe17 ldw r2,-8(fp)
|
||
// <@\lh{dkgreen}{r3 = массив + 2 байта}@>
|
||
10000024: 10c00084 addi r3,r2,2
|
||
// <@\lh{dkgreen}{сохраняем новый адрес в }@>r3
|
||
10000028: e0fffe15 stw r3,-8(fp)
|
||
// <@\lh{dkgreen}{загружаем полуслово по старому указателю на массив}@>
|
||
1000002c: 1080000b ldhu r2,0(r2)
|
||
// <@\lh{dkgreen}{маск\'{и}руем младшие 16 битов}@>
|
||
10000030: 10bfffcc andi r2,r2,65535
|
||
// <@\lh{dkgreen}{сумма += r2}@>
|
||
10000034: 80a1883a add r16,r16,r2
|
||
// <@\lh{dkgreen}{кладём в r2 (оставшуюся) длину массива}@>
|
||
10000038: e0bffd17 ldw r2,-12(fp)
|
||
// <@\lh{dkgreen}{длина -= 2}@>
|
||
1000003c: 10bfff84 addi r2,r2,-2
|
||
// <@\lh{dkgreen}{сохраняем оставшуюся длину обратно в }@>fp-12
|
||
10000040: e0bffd15 stw r2,-12(fp)
|
||
// <@\lh{dkgreen}{загружаем из fp-12 (длина массива) в }@>r2
|
||
<@\lh{blue}{10000044: e0bffd17 ldw}@> r2,-12(fp) <@\label{line:simcond}@>
|
||
// <@\lh{dkgreen}{r2 = длина > 2}@>
|
||
10000048: 10800088 cmpgei r2,r2,2
|
||
// <@\lh{dkgreen}{((длина > 2) != false)? переходим 0x20}@>
|
||
1000004c: 103ff41e bne r2,zero,10000020<checkSum+0x20>
|
||
// <@\lh{dkgreen}{((длина > 2) == false) ? r2 = длина}@>
|
||
10000050: e0bffd17 ldw r2,-12(fp)
|
||
// <@\lh{dkgreen}{r2 >= 0 ? переходим 0x78}@>
|
||
10000054: 0080080e bge zero,r2,10000078<checkSum+0x78>
|
||
// <@\lh{dkgreen}{r2 < 0 ? r2 = массив}@>
|
||
10000058: e0bffe17 ldw r2,-8(fp)
|
||
// <@\lh{dkgreen}{r2 = значение массива}@>
|
||
1000005c: 1080000b ldhu r2,0(r2)
|
||
// <@\lh{dkgreen}{r2 = r2 \& 0xffff}@>
|
||
10000060: 10bfffcc andi r2,r2,65535
|
||
// <@\lh{dkgreen}{сумма += r2}@>
|
||
10000064: 80a1883a add r16,r16,r2
|
||
// <@\lh{dkgreen}{переходим 0x78}@>
|
||
10000068: 00000306 br 10000078<checkSum+0x78>
|
||
// <@\lh{dkgreen}{r3 = сумма \& 0xffff}@>
|
||
1000006c: 80ffffcc andi r3,r16,65535
|
||
// <@\lh{dkgreen}{r2 = сумма >> 16}@>
|
||
10000070: 8005d43a srai r2,r16,16
|
||
// <@\lh{dkgreen}{сумма = r2 + r3}@>
|
||
10000074: 18a1883a add r16,r3,r2
|
||
// <@\lh{dkgreen}{сумма >> 16}@>
|
||
10000078: 8005d43a srai r2,r16,16
|
||
// <@\lh{dkgreen}{r2 != 0 ? переходим 0x6c}@>
|
||
1000007c: 103ffb1e bne r2,zero,1000006c<checkSum+0x6c>
|
||
// <@\lh{dkgreen}{r2 == 0 ? r2 = сумма}@>
|
||
10000080: 8005883a mov r2,r16
|
||
// <@\lh{dkgreen}{r2 = \textasciitilde(r2|0)}@>
|
||
10000084: 0084303a nor r2,zero,r2
|
||
// <@\lh{dkgreen}{сумма = r2}@>
|
||
10000088: 1021883a mov r16,r2
|
||
// <@\lh{dkgreen}{r2 = сумма}@>
|
||
1000008c: 8005883a mov r2,r16
|
||
// <@\lh{dkgreen}{завершаем выполнение функции, перемещаем обратно указатели}@>
|
||
10000090: e6ffff04 addi sp,fp,-4
|
||
10000094: df000117 ldw fp,4(sp)
|
||
10000098: dc000017 ldw r16,0(sp)
|
||
1000009c: dec00204 addi sp,sp,8
|
||
// return
|
||
100000a0: f800283a ret
|
||
\end{lstlisting}
|
||
|
||
\begin{lstlisting}[style=ASMStyle, caption=Код с развёртыванием, label={lst:nooptunf}]
|
||
// <@\lh{dkgreen}{инициализация}@>
|
||
10000000: defffc04 addi sp,sp,-16
|
||
10000004: df000315 stw fp,12(sp)
|
||
10000008: dc000215 stw r16,8(sp)
|
||
1000000c: df000304 addi fp,sp,12
|
||
// <@\lh{dkgreen}{адрес массива}@>
|
||
10000010: e13ffe15 stw r4,-8(fp)
|
||
// <@\lh{dkgreen}{длина массива}@>
|
||
10000014: e17ffd15 stw r5,-12(fp)
|
||
// <@\lh{dkgreen}{сумма = 0}@>
|
||
10000018: 0021883a mov r16,zero
|
||
// <@\lh{dkgreen}{переход 0x8c}@>
|
||
1000001c: 00001b06 br 1000008c<checkSum+0x8c>
|
||
<@\lh{dkgreen}{10000020: e0bffe17 ldw}@> r2,-8(fp) <@\label{line:unfit1b}@>
|
||
10000024: 10c00084 addi r3,r2,2
|
||
10000028: e0fffe15 stw r3,-8(fp)
|
||
1000002c: 1080000b ldhu r2,0(r2)
|
||
10000030: 10bfffcc andi r2,r2,65535
|
||
<@\lh{red}{10000034: 80a1883a add}@> r16,r16,r2 <@\label{line:unfit1e}@>
|
||
<@\lh{dkgreen}{10000038: e0bffe17 ldw}@> r2,-8(fp) <@\label{line:unfit2b}@>
|
||
1000003c: 10c00084 addi r3,r2,2
|
||
10000040: e0fffe15 stw r3,-8(fp)
|
||
10000044: 1080000b ldhu r2,0(r2)
|
||
10000048: 10bfffcc andi r2,r2,65535
|
||
<@\lh{red}{1000004c: 80a1883a add}@> r16,r16,r2 <@\label{line:unfit2e}@>
|
||
<@\lh{dkgreen}{10000050: e0bffe17 ldw}@> r2,-8(fp)<@\label{line:unfit3b}@>
|
||
10000054: 10c00084 addi r3,r2,2
|
||
10000058: e0fffe15 stw r3,-8(fp)
|
||
1000005c: 1080000b ldhu r2,0(r2)
|
||
10000060: 10bfffcc andi r2,r2,65535
|
||
<@\lh{red}{10000064: 80a1883a add}@> r16,r16,r2<@\label{line:unfit3e}@>
|
||
<@\lh{dkgreen}{10000068: e0bffe17 ldw}@> r2,-8(fp)<@\label{line:unfit4b}@>
|
||
1000006c: 10c00084 addi r3,r2,2
|
||
10000070: e0fffe15 stw r3,-8(fp)
|
||
10000074: 1080000b ldhu r2,0(r2)
|
||
10000078: 10bfffcc andi r2,r2,65535
|
||
<@\lh{red}{1000007c: 80a1883a add}@> r16,r16,r2<@\label{line:unfit4e}@>
|
||
10000080: e0bffd17 ldw r2,-12(fp)
|
||
10000084: 10bffe04 addi r2,r2,-8
|
||
10000088: e0bffd15 stw r2,-12(fp)
|
||
1000008c: e0bffd17 ldw r2,-12(fp)
|
||
10000090: 10800248 cmpgei r2,r2,9
|
||
10000094: 103fe21e bne r2,zero,10000020 <checkSum+0x20>
|
||
<@\lh{blue}{10000098: 00000906 br}@> 100000c0 <checkSum+0xc0> <@\label{line:unfsimbody}@>
|
||
1000009c: e0bffe17 ldw r2,-8(fp)
|
||
100000a0: 10c00084 addi r3,r2,2
|
||
100000a4: e0fffe15 stw r3,-8(fp)
|
||
100000a8: 1080000b ldhu r2,0(r2)
|
||
100000ac: 10bfffcc andi r2,r2,65535
|
||
100000b0: 80a1883a add r16,r16,r2
|
||
100000b4: e0bffd17 ldw r2,-12(fp)
|
||
100000b8: 10bfff84 addi r2,r2,-2
|
||
100000bc: e0bffd15 stw r2,-12(fp)
|
||
<@\lh{blue}{100000c0: e0bffd17 ldw}@> r2,-12(fp) <@\label{line:unfsimcond}@>
|
||
100000c4: 10800088 cmpgei r2,r2,2
|
||
100000c8: 103ff41e bne r2,zero,1000009c <checkSum+0x9c>
|
||
100000cc: e0bffd17 ldw r2,-12(fp)
|
||
100000d0: 0080080e bge zero,r2,100000f4 <checkSum+0xf4>
|
||
100000d4: e0bffe17 ldw r2,-8(fp)
|
||
100000d8: 1080000b ldhu r2,0(r2)
|
||
100000dc: 10bfffcc andi r2,r2,65535
|
||
100000e0: 80a1883a add r16,r16,r2
|
||
100000e4: 00000306 br 100000f4 <checkSum+0xf4>
|
||
100000e8: 80ffffcc andi r3,r16,65535
|
||
100000ec: 8005d43a srai r2,r16,16
|
||
100000f0: 18a1883a add r16,r3,r2
|
||
100000f4: 8005d43a srai r2,r16,16
|
||
100000f8: 103ffb1e bne r2,zero,100000e8 <checkSum+0xe8>
|
||
100000fc: 8005883a mov r2,r16
|
||
10000100: 0084303a nor r2,zero,r2
|
||
10000104: 1021883a mov r16,r2
|
||
10000108: 8005883a mov r2,r16
|
||
1000010c: e6ffff04 addi sp,fp,-4
|
||
10000110: df000117 ldw fp,4(sp)
|
||
10000114: dc000017 ldw r16,0(sp)
|
||
10000118: dec00204 addi sp,sp,8
|
||
1000011c: f800283a ret
|
||
\end{lstlisting}
|
||
|
||
В оптимизированной версии кода в листингах \hrf{lst:optsim} и \hrf{lst:optunf} также есть общая часть - условие добора нечётности массива и цикл преобразования к 16-разрядному значению, начало и конец выделены \lh{red}{красным}.
|
||
|
||
\begin{lstlisting}[style=ASMStyle, caption=Код -О3 без развёртывания, label={lst:optsim}]
|
||
// unsigned short checkSum(unsigned short* addr, int size) {
|
||
// register unsigned short checksum = 0;
|
||
// register int sum = 0;
|
||
// <@\lh{dkgreen}{параметры функции передаются в регистрах r4 (addr) и r5 (size)}@>
|
||
// <@\lh{dkgreen}{r2 = длина < 2}@>
|
||
10000000: 28800090 cmplti r2,r5,2
|
||
// <@\lh{dkgreen}{((длина < 2) != false) ? переходим 0x78}@>
|
||
10000004: 10001c1e bne r2,zero,10000078 <checkSum+0x78>
|
||
// <@\lh{dkgreen}{попадаем сюда, если (длина < 2) == false}@>
|
||
// <@\lh{dkgreen}{idky записываем во временный регистр r6 значение -2}@>
|
||
10000008: 01bfff84 movi r6,-2
|
||
// <@\lh{dkgreen}{временный регистр r7 = длина массива - 2}@>
|
||
1000000c: 29ffff84 addi r7,r5,-2
|
||
// <@\lh{dkgreen}{r2 = r7 \& r6, то есть (длина - 2) \& (-2)}@>
|
||
// <@\lh{dkgreen}{предполагаю, что это как-то гарантирует чётность длины}@>
|
||
10000010: 3984703a and r2,r7,r6
|
||
// <@\lh{dkgreen}{r6 = r4 (указатель на массив) + 2}@>
|
||
10000014: 21800084 addi r6,r4,2
|
||
// <@\lh{dkgreen}{r6 = r2 (результат операции с 0х0с) + r6 (указатель на массив +2)}@>
|
||
// <@\lh{dkgreen}{предполагаю, что это адрес последнего элемента массива}@>
|
||
// <@\lh{dkgreen}{для сравнения в цикле 0х024 - 0х030}@>
|
||
10000018: 118d883a add r6,r2,r6
|
||
// <@\lh{dkgreen}{r3 = r4 (указатель на массив)}@>
|
||
1000001c: 2007883a mov r3,r4
|
||
// <@\lh{dkgreen}{r2 = 0}@>
|
||
10000020: 0005883a mov r2,zero
|
||
// <@\lh{dkgreen}{здесь начался цикл аккумулирования значений из массива}@>
|
||
// <@\lh{dkgreen}{цикл перевёрнут, то есть реализован как do {} while();}@>
|
||
// while (size > 1) {
|
||
// sum += *addr++;
|
||
// size -= 2;
|
||
// }
|
||
// <@\lh{dkgreen}{в r5 записался 0-й байт массива беззнаково}@>
|
||
<@\lh{blue}{10000024: 1940000b ldhu}@> r5,0(r3)
|
||
// <@\lh{dkgreen}{сместили временный указатель на начало массива}@>
|
||
10000028: 18c00084 addi r3,r3,2
|
||
// <@\lh{dkgreen}{аккумулируем сумму}@>
|
||
1000002c: 1145883a add r2,r2,r5
|
||
// <@\lh{dkgreen}{проверяем выход за пределы (r6 != r3)}@>
|
||
<@\lh{blue}{10000030: 30fffc1e bne}@> r6,r3,10000024 <checkSum+0x24>
|
||
// <@\lh{dkgreen}{когда закончили с основным суммирующим циклом}@>
|
||
// <@\lh{dkgreen}{во временный регистр r3 записали (((длину массива) - 2) / 2)??!!}@>
|
||
// <@\lh{dkgreen}{(r6 == r3) ? r3 = r7 >> 1 (логическое)}@>
|
||
10000034: 3806d07a srli r3,r7,1
|
||
// <@\lh{dkgreen}{странная манипуляция длиной массива и адресом, видимо,}@>
|
||
// <@\lh{dkgreen}{это связано с тем, что стек растёт отрицательно, поэтому}@>
|
||
// <@\lh{dkgreen}{адреса последних элементов имеют отрицательное смещение}@>
|
||
// <@\lh{dkgreen}{новый размер массива получаем из половины старого * -2}@>
|
||
// <@\lh{dkgreen}{r5 = r3 * (-2)}@>
|
||
10000038: 197fffa4 muli r5,r3,-2
|
||
// <@\lh{dkgreen}{r3 += 1 (прибавили к размеру (половины массива) единицу)}@>
|
||
1000003c: 18c00044 addi r3,r3,1
|
||
// <@\lh{dkgreen}{судя по всему, получаем реальный размер оставшегося массива}@>
|
||
// <@\lh{dkgreen}{r3 += r3}@>
|
||
10000040: 18c7883a add r3,r3,r3
|
||
// <@\lh{dkgreen}{прибавляем к начальному адресу массива расчётный размер}@>
|
||
// <@\lh{dkgreen}{r7 = r5 + r7 (длина - 2)}@>
|
||
10000044: 29cf883a add r7,r5,r7
|
||
// <@\lh{dkgreen}{сравниваем получившийся результат с единицей}@>
|
||
// <@\lh{dkgreen}{то есть, проверяем, дошли ли мы до конца массива)}@>
|
||
// <@\lh{dkgreen}{r7 = r7 != 1}@>
|
||
10000048: 39c00058 cmpnei r7,r7,1
|
||
// <@\lh{dkgreen}{r4 += r3}@>
|
||
1000004c: 20c9883a add r4,r4,r3
|
||
// <@\lh{dkgreen}{((r7 != 1) != false) ? переходим 0x68}@>
|
||
10000050: 3800051e bne r7,zero,10000068 <checkSum+0x68>
|
||
// <@\lh{dkgreen}{((r7 != 1) == false) ? производим финальные действия:}@>
|
||
// <@\lh{dkgreen}{приводим полученную сумму к размеру и битовую инверсию}@>
|
||
// sum += *(unsigned char *) addr;
|
||
// <@\lh{dkgreen}{в r3 записываем нулевой элемент массива r4 (полуслово, младшие 8 бит)}@>
|
||
<@\lh{red}{10000054: 20c0000b ldhu}@> r3,0(r4)
|
||
// <@\lh{dkgreen}{r2 += r3 (нулевой элемент r4)}@>
|
||
10000058: 10c5883a add r2,r2,r3
|
||
// <@\lh{dkgreen}{переходим 0x68}@>
|
||
1000005c: 00000206 br 10000068 <checkSum+0x68>
|
||
// while (sum >> 16) {
|
||
// sum = (sum \& 0xffff) + (sum >> 16);
|
||
// }
|
||
// <@\lh{dkgreen}{маск\'{и}руем младшие 16 битов}@>
|
||
10000060: 10bfffcc andi r2,r2,65535
|
||
// <@\lh{dkgreen}{r2 += r3}@>
|
||
10000064: 10c5883a add r2,r2,r3
|
||
// <@\lh{dkgreen}{r3 = r2 >> 16 (арифметическое)}@>
|
||
10000068: 1007d43a srai r3,r2,16
|
||
// <@\lh{dkgreen}{(r3 != 0) ? переходим 0x60}@>
|
||
<@\lh{red}{1000006c: 183ffc1e bne}@> r3,zero,10000060 <checkSum+0x60>
|
||
// <@\lh{dkgreen}{(r3 == 0) ? r2 = \textasciitilde(r2|0)}@>
|
||
// checksum = ~sum;
|
||
10000070: 0084303a nor r2,zero,r2
|
||
// <@\lh{dkgreen}{Выйти из функции}@>
|
||
10000074: f800283a ret
|
||
// <@\lh{dkgreen}{r5 = длина == 1}@>
|
||
10000078: 29400060 cmpeqi r5,r5,1
|
||
// <@\lh{dkgreen}{((длина == 1) == false) ? переходим 0x88}@>
|
||
1000007c: 28000226 beq r5,zero,10000088 <checkSum+0x88>
|
||
// <@\lh{dkgreen}{в противном случае, то есть, когда}@>
|
||
// <@\lh{dkgreen}{((длина == 1) != false) ? r2 = 0}@>
|
||
10000080: 0005883a mov r2,zero
|
||
// <@\lh{dkgreen}{переходим 0x54}@>
|
||
10000084: 003ff306 br 10000054 <checkSum+0x54>
|
||
// <@\lh{dkgreen}{вернуть из функции -1}@>
|
||
10000088: 00bfffc4 movi r2,-1
|
||
// <@\lh{dkgreen}{Выйти из функции}@>
|
||
1000008c: f800283a ret
|
||
\end{lstlisting}
|
||
|
||
\begin{lstlisting}[style=ASMStyle, caption=Код -О3 с развёртыванием, label={lst:optunf}]
|
||
// <@\lh{dkgreen}{r4 = \&addr, r5 = size}@>
|
||
// unsigned short checkSum(unsigned short* addr, int size) {
|
||
register unsigned short checksum = 0;
|
||
register int sum = 0;
|
||
// <@\lh{dkgreen}{Первый, развёрнутый цикл работает по условию size > 8,}@>
|
||
// <@\lh{dkgreen}{следовательно, первая проверка - не нужно ли его пропустить}@>
|
||
// <@\lh{dkgreen}{r2 = длина < 9}@>
|
||
10000000: 28800250 cmplti r2,r5,9
|
||
// <@\lh{dkgreen}{если массив не требует обработки развёрнутым циклом}@>
|
||
// <@\lh{dkgreen}{((длина < 9) != false) ? переходим 0xe0}@>
|
||
10000004: 1000361e bne r2,zero,100000e0 <checkSum+0xe0>
|
||
// <@\lh{dkgreen}{вычисляем, где закончится массив}@>
|
||
// <@\lh{dkgreen}{((длина < 9) == false) ? r9 = r5 (длина) - 9}@>
|
||
10000008: 2a7ffdc4 addi r9,r5,-9
|
||
// <@\lh{dkgreen}{r9 = r9 (длина - 9) >> 3 (логическое)}@>
|
||
1000000c: 4812d0fa srli r9,r9,3
|
||
// <@\lh{dkgreen}{инициализируем переменную куда будем накапливать результат}@>
|
||
// <@\lh{dkgreen}{r2 = 0}@>
|
||
10000010: 0005883a mov r2,zero
|
||
// <@\lh{dkgreen}{r8 = r9 (изменённая на 0х0с длина массива) + 1}@>
|
||
10000014: 4a000044 addi r8,r9,1
|
||
// <@\lh{dkgreen}{r8 = r8 * 8 (логическим сдвигом)}@>
|
||
10000018: 401090fa slli r8,r8,3
|
||
// <@\lh{dkgreen}{иными словами считаем, где мы окажемся, когда закончим}@>
|
||
// <@\lh{dkgreen}{выполнение нижеследующего цикла}@>
|
||
// <@\lh{dkgreen}{r8 = r4 (указатель на массив) + r8}@>
|
||
1000001c: 2211883a add r8,r4,r8
|
||
// while (size > 8) { <@\label{line:unroll}@>
|
||
// sum += *addr++;
|
||
// sum += *addr++;
|
||
// sum += *addr++;
|
||
// sum += *addr++;
|
||
// size -= 8;
|
||
// }
|
||
// <@\lh{dkgreen}{далее начинается развёрнутый явно в коде цикл, в котором}@>
|
||
// <@\lh{dkgreen}{происходит последовательное чтение данных из массива}@>
|
||
// <@\lh{dkgreen}{со сдвигом относительно адреса на +0, +2, +4, +6 байт,}@>
|
||
// <@\lh{dkgreen}{аккумулируя прочитанные значения (в результате) в регистр r2}@>
|
||
<@\lh{dkgreen}{10000020: 21c0000b ldhu}@> r7,0(r4)
|
||
10000024: 2180008b ldhu r6,2(r4)
|
||
10000028: 20c0010b ldhu r3,4(r4)
|
||
1000002c: 3885883a add r2,r7,r2
|
||
10000030: 308d883a add r6,r6,r2
|
||
10000034: 2080018b ldhu r2,6(r4)
|
||
10000038: 1987883a add r3,r3,r6
|
||
1000003c: 21000204 addi r4,r4,8
|
||
10000040: 10c5883a add r2,r2,r3
|
||
// <@\lh{dkgreen}{не дошли до конца массива? зацикливаемся, переходим 0x20}@>
|
||
<@\lh{dkgreen}{10000044: 413ff61e bne}@> r8,r4,10000020 <checkSum+0x20>
|
||
// <@\lh{dkgreen}{r9 = изменённая на 0х0с длина массива * -8}@>
|
||
10000048: 4a7ffe24 muli r9,r9,-8
|
||
// <@\lh{dkgreen}{r5 = реальная переданная длина массива - 8}@>
|
||
1000004c: 297ffe04 addi r5,r5,-8
|
||
// <@\lh{dkgreen}{r5 = r9 + r5}@>
|
||
10000050: 494b883a add r5,r9,r5
|
||
// <@\lh{dkgreen}{на адрес 0х54 мы попадаем, когда размер исходного массива}@>
|
||
// <@\lh{dkgreen}{меньше 9 то есть или сразу при вызове функции, или}@>
|
||
// <@\lh{dkgreen}{после прохода по явно развёрнутому циклу}@>
|
||
// <@\lh{dkgreen}{во временный регистр r3 записываем результат сравнения}@>
|
||
// <@\lh{dkgreen}{r3 = переданный размер массива < 2}@>
|
||
10000054: 28c00090 cmplti r3,r5,2
|
||
// <@\lh{dkgreen}{((r3 < 2) != false) ? переходим 0xb4}@>
|
||
// <@\lh{dkgreen}{то есть если размер массива < 2, то переходим}@>
|
||
// <@\lh{dkgreen}{к завершению функции, значит код далее (не совершая переход)}@>
|
||
// <@\lh{dkgreen}{это код цикла добора. Последовательно забирая элементы}@>
|
||
// <@\lh{dkgreen}{массива мы сравниваем получившийся адрес с}@>
|
||
// <@\lh{dkgreen}{исходным +0, +2, +4, и выходим по адресу 0х9с, из чего}@>
|
||
// <@\lh{dkgreen}{делаем вывод, что произошло развёртывание компилятором}@>
|
||
10000058: 1800161e bne r3,zero,100000b4 <checkSum+0xb4>
|
||
// <@\lh{dkgreen}{((r3 < 2) == false) ? r7 = array[0]}@>
|
||
<@\lh{blue}{1000005c: 21c0000b ldhu}@> r7,0(r4) <@\label{line:unfoptldw0}@>
|
||
//<@\lh{dkgreen}{r6 = размера массива - 2}@>
|
||
10000060: 29bfff84 addi r6,r5,-2
|
||
// <@\lh{dkgreen}{r3 = r6 < 2}@>
|
||
10000064: 30c00090 cmplti r3,r6,2
|
||
// <@\lh{dkgreen}{накапливаем полученную сумму}@>
|
||
// <@\lh{dkgreen}{r2 (сумма) += r7}@>
|
||
10000068: 11c5883a add r2,r2,r7
|
||
// <@\lh{dkgreen}{((r6 < 2) != false) ? переходим 0x9c}@>
|
||
1000006c: 18000b1e bne r3,zero,1000009c <checkSum+0x9c>
|
||
// <@\lh{dkgreen}{((r6 < 2) == false) ? r7 = array[1]}@>
|
||
<@\lh{blue}{10000070: 21c0008b ldhu}@> r7,2(r4) <@\label{line:unfoptldw2}@>
|
||
// <@\lh{dkgreen}{уменьшаем размер массива на 4}@>
|
||
// <@\lh{dkgreen}{r5 -= 4}@>
|
||
10000074: 297fff04 addi r5,r5,-4
|
||
// <@\lh{dkgreen}{временный регистр r3 = r5 (изменённый размер) < 2}@>
|
||
10000078: 28c00090 cmplti r3,r5,2
|
||
// <@\lh{dkgreen}{накапливаем прочитанный результат}@>
|
||
1000007c: 11c5883a add r2,r2,r7
|
||
// <@\lh{dkgreen}{((изменённый размер < 2) != false) ? переходим 0x9c}@>
|
||
10000080: 1800061e bne r3,zero,1000009c <checkSum+0x9c>
|
||
// <@\lh{dkgreen}{((изменённый размер < 2) == false) ? r3 = array[2]}@>
|
||
<@\lh{blue}{10000084: 20c0010b ldhu}@> r3,4(r4) <@\label{line:unfoptldw4}@>
|
||
// <@\lh{dkgreen}{r5 = изменённый на 0х74 размер массива != 4}@>
|
||
10000088: 29400118 cmpnei r5,r5,4
|
||
// <@\lh{dkgreen}{накапливаем прочитанный результат}@>
|
||
1000008c: 10c5883a add r2,r2,r3
|
||
// <@\lh{dkgreen}{((r5 != 4) != false) ? переходим 0x9c}@>
|
||
10000090: 2800021e bne r5,zero,1000009c <checkSum+0x9c>
|
||
// <@\lh{dkgreen}{((r5 != 4) == false) ? r3 = array[3]}@>
|
||
<@\lh{blue}{10000094: 20c0018b ldhu}@> r3,6(r4) <@\label{line:unfoptldw6}@>
|
||
10000098: 10c5883a add r2,r2,r3
|
||
// <@\lh{dkgreen}{аналогичные простому варианту функции манипуляции}@>
|
||
// <@\lh{dkgreen}{с проверкой адреса массива, длины массива с учётом}@>
|
||
// <@\lh{dkgreen}{роста стека функции в отрицательные адреса}@>
|
||
// <@\lh{dkgreen}{когда закончили с основным суммирующим циклом}@>
|
||
// <@\lh{dkgreen}{временный регистр r3 = (((длина массива) - 2) / 2)??!!}@>
|
||
// <@\lh{dkgreen}{r3 = r6 >> 1 (логическое)}@>
|
||
1000009c: 3006d07a srli r3,r6,1
|
||
// <@\lh{dkgreen}{странная манипуляция длиной массива и адресом, видимо,}@>
|
||
// <@\lh{dkgreen}{это связано с тем, что стек растёт отрицательно, поэтому}@>
|
||
// <@\lh{dkgreen}{адреса последних элементов имеют отрицательное смещение}@>
|
||
// <@\lh{dkgreen}{новый размер массива получаем из половины старого * -2}@>
|
||
// <@\lh{dkgreen}{r5 (длина) = r3 * (-2)}@>
|
||
100000a0: 197fffa4 muli r5,r3,-2
|
||
// <@\lh{dkgreen}{r3 += 1 (прибавили к размеру (половины массива) единицу)}@>
|
||
100000a4: 18c00044 addi r3,r3,1
|
||
// <@\lh{dkgreen}{судя по всему, получаем реальный размер оставшегося массива}@>
|
||
// <@\lh{dkgreen}{r3 += r3}@>
|
||
100000a8: 18c7883a add r3,r3,r3
|
||
// <@\lh{dkgreen}{к исходному адресу массива прибавляем его расчётный размер}@>
|
||
// <@\lh{dkgreen}{r4 += r3}@>
|
||
100000ac: 20c9883a add r4,r4,r3
|
||
// <@\lh{dkgreen}{r5 += r6}@>
|
||
100000b0: 298b883a add r5,r5,r6
|
||
// <@\lh{dkgreen}{r5 = r5 != 1}@>
|
||
100000b4: 29400058 cmpnei r5,r5,1
|
||
// <@\lh{dkgreen}{((r5 != 1) != false) ? переходим 0xd0}@>
|
||
100000b8: 2800051e bne r5,zero,100000d0 <checkSum+0xd0>
|
||
// <@\lh{dkgreen}{((r5 != 1) == false) ? производим финальные действия:}@>
|
||
// <@\lh{dkgreen}{приводим полученную сумму к размеру и битовую инверсию}@>
|
||
// sum += *(unsigned char *) addr;
|
||
// <@\lh{dkgreen}{в r3 записываем нулевой элемент массива r4 (полуслово, младшие 8 бит)}@>
|
||
<@\lh{red}{100000bc: 20c0000b ldhu}@> r3,0(r4)
|
||
// <@\lh{dkgreen}{накапливаем загруженный результат}@>
|
||
// <@\lh{dkgreen}{r2 += r3}@>
|
||
100000c0: 10c5883a add r2,r2,r3
|
||
// <@\lh{dkgreen}{переходим на 0х68}@>
|
||
100000c4: 00000206 br 100000d0 <checkSum+0xd0>
|
||
// while (sum >> 16) {
|
||
// sum = (sum & 0xffff) + (sum >> 16);
|
||
// }
|
||
// <@\lh{dkgreen}{маскируем младшие 16 битов}@>
|
||
100000c8: 10bfffcc andi r2,r2,65535
|
||
// <@\lh{dkgreen}{r2 += r3}@>
|
||
100000cc: 10c5883a add r2,r2,r3
|
||
// <@\lh{dkgreen}{r3 = r2 >> 16 (арифметическое)}@>
|
||
100000d0: 1007d43a srai r3,r2,16
|
||
// <@\lh{dkgreen}{((r2 >> 16) != false) ? переходим 0xc8}@>
|
||
<@\lh{red}{100000d4: 183ffc1e bne}@> r3,zero,100000c8 <checkSum+0xc8>
|
||
// <@\lh{dkgreen}{((r2 >> 16) == false) ? r2 = \textasciitilde(0 | r2)}@>
|
||
100000d8: 0084303a nor r2,zero,r2
|
||
// <@\lh{dkgreen}{выход из функции}@>
|
||
100000dc: f800283a ret
|
||
// <@\lh{dkgreen}{обнуляем регистр r2}@>
|
||
100000e0: 0005883a mov r2,zero
|
||
// <@\lh{dkgreen}{переходим на 0х54}@>
|
||
100000e4: 003fdb06 br 10000054 <checkSum+0x54>
|
||
\end{lstlisting}
|
||
|
||
В листинге \hrf{lst:optunf} развёрнутый цикл, описанный явно выделен \lh{dkgreen}{зелёным}. В развёрнутом цикле видно обращение по адресу массива со смещением 0, 2, 4 и 6 байт, соответственно. Основной цикл (для задания с явным развёртыванием цикла - это <<цикл добора>>) выделен в листингах \lh{blue}{синим}, причём в листинге \hrf{lst:optunf} очевидна развёртывающая оптимизация компилятора на строках \hrf{line:unfoptldw0}, \hrf{line:unfoptldw2}, \hrf{line:unfoptldw4}, \hrf{line:unfoptldw6} (выделены \lh{blue}{синим}) следует загрузка значений из массива с последующим сдвигом указателя на исходный массив и суммированием прочитанных значений с промежуточным значением суммы (регистр \code{r2}), дополнительные комментарии представлены в листинге.
|
||
|
||
Дополнительно были отслежены изменения вспомогательных регистров (для мгновенного расчёта адреса чтения из массива по окончании работы развёрнутого цикла)
|
||
\begin{lstlisting}[language=C,style=CCodeStyle]
|
||
r4=array& 1000
|
||
r5=size 100
|
||
|
||
00 r2=r5<9 false
|
||
04 r2==0
|
||
08 r9=20-9 91
|
||
0c r9>>=3 11
|
||
10 r2=0 0
|
||
14 r8=r9+1 12
|
||
18 r8<<=3 96
|
||
1c r8+=r4 1096
|
||
20 c=================
|
||
24 c
|
||
28 l
|
||
2c e
|
||
30
|
||
34 u
|
||
38 n
|
||
3c f
|
||
40 l
|
||
44 d=================
|
||
48 r9*=-8 -88
|
||
4c r5-=8 92
|
||
50 r5+=r9 4
|
||
\end{lstlisting}
|
||
|
||
|
||
\section*{Часть II.}
|
||
\addcontentsline{toc}{section}{Часть II.}
|
||
\subsection*{Задание}
|
||
Во второй части работы требовалось изучить отчёт профилировщика, сохранить иерархию вызовов функции main и начало таблицы <<плоского>> профиля. На примере реализованной функции обработки данных в части I определить с помощью Performance Counter, какой оверхед (накладные расходы) в циклах вносит вызов функции \code{mcount} в выполнение функции. Изучите ассемблерный код и найдите в нем вызов функции \code{mcount}. Результаты сохраните в отчет.
|
||
|
||
\subsection*{Проделанная работа}
|
||
Согласно показаний Performance Counter (рис. \hrf{pic:pcpt2}) функция подсчёта контрольной суммы без подключенного профайлера выполнялась в среднем 843.434 микросекунд, а с вызовом \code{mcount} 863.816, то есть на $\approx$20 мкс больше.
|
||
\begin{figure}[H]
|
||
\centering
|
||
\includegraphics[width=9cm]{01-ess-lab-02-counter.png}
|
||
\caption{Показания Performance Counter для вызовов функции со включенным профилировщиком}
|
||
\label{pic:pcpt2}
|
||
\end{figure}
|
||
|
||
В листинге \hrf{lst:gprofrpt} приведены первые строки плоского профиля выполнения программы, демонстрирующие, что программа находилась 93\% времени в функции \code{main}, то есть, выполняла работу основного цикла (прямые вызовы функции подсчёта контрольной суммы).
|
||
|
||
\begin{lstlisting}[frame=single, basicstyle={\tiny\ttfamily}, caption=Начало отчёта плоского профиля, label={lst:gprofrpt}, numbers=left, numberstyle=\tiny\color{gray}]
|
||
Flat profile:
|
||
|
||
Each sample counts as 0.001 seconds.
|
||
% cumulative self self total
|
||
time seconds seconds calls s/call s/call name
|
||
93.26 13.78 13.78 1 13.78 14.14 main
|
||
6.47 14.74 0.96 4 0.24 0.24 altera_avalon_jtag_uart_close
|
||
0.21 14.77 0.03 1 0.03 0.03 _exit
|
||
0.01 14.77 0.00 14 0.00 0.00 __sfvwrite_r
|
||
0.01 14.77 0.00 5 0.00 0.00 altera_avalon_jtag_uart_write
|
||
0.01 14.77 0.00 28 0.00 0.00 __muldf3
|
||
0.01 14.77 0.00 3 0.00 0.00 _fflush_r
|
||
\end{lstlisting}
|
||
|
||
В листинге \hrf{lst:gprofassemble} отмечен \lh{red}{красным} вызов функции \code{mcount}. Интересно, что адрес функции (\code{0000ddfc <\_mcount>:}) считается налету с применением временного регистра.
|
||
|
||
\begin{lstlisting}[frame=single, basicstyle={\tiny\ttfamily}, caption=Начало отчёта плоского профиля, label={lst:gprofassemble}, numbers=left, numberstyle=\tiny\color{gray}]
|
||
10000000 <checkSum>:
|
||
10000000: f811883a mov r8,ra
|
||
//<@\lh{black}{уходим считать адрес вызова}@>
|
||
<@\lh{red}{10000004: 00000f40 call}@> 100000f4 <checkSum+0xf4>
|
||
10000008: 403f883a mov ra,r8
|
||
1000000c: 28800250 cmplti r2,r5,9
|
||
|
||
// ...
|
||
// ...
|
||
// ...
|
||
|
||
100000ec: 0005883a mov r2,zero
|
||
100000f0: 003fdb06 br 10000060 <checkSum+0x60>
|
||
// <@\lh{black}{записали 1 в старший разряд временного регистра (at = 65536)}@>
|
||
100000f4: 00400074 movhi at,1
|
||
// 65536 - 8708 = 0xDDFC
|
||
100000f8: 08777f04 addi at,at,-8708
|
||
// <@\lh{black}{перемещаемся по адресу 0xddfc}@>
|
||
<@\lh{red}{100000fc: 0800683a jmp at}@>
|
||
|
||
// ...
|
||
// ...
|
||
// ...
|
||
|
||
ddf8: f800283a ret
|
||
|
||
<@\lh{red}{0000ddfc <\_mcount>:}@>
|
||
* of values for bits 4:2 won't be even (aligning on cache line boundaries
|
||
* will skew it). Higher bits should be fairly random.
|
||
|
||
\end{lstlisting}
|
||
|
||
|
||
\newpage
|
||
\appendix
|
||
\section*{Приложения}
|
||
\addcontentsline{toc}{section}{Приложения}
|
||
\renewcommand{\thesubsection}{\Alph{subsection}}
|
||
|
||
\subsection{Снимки экрана с отчётом Performance Counter}
|
||
\label{appendix:isrtime}
|
||
\begin{figure}[H]
|
||
\centering
|
||
\begin{multicols}{2}
|
||
\includegraphics[width=8cm]{01-ess-lab-02-notcmnoopt.png}
|
||
|
||
\includegraphics[width=8cm]{01-ess-lab-02-notcmnoopt10.png}
|
||
|
||
\includegraphics[width=8cm]{01-ess-lab-02-notcm2opt.png}
|
||
|
||
\includegraphics[width=8cm]{01-ess-lab-02-notcm2opt10.png}
|
||
|
||
\includegraphics[width=8cm]{01-ess-lab-02-notcmszopt.png}
|
||
|
||
\includegraphics[width=8cm]{01-ess-lab-02-notcmszopt10.png}
|
||
|
||
\columnbreak
|
||
|
||
\includegraphics[width=8cm]{01-ess-lab-02-tcmnoopt.png}
|
||
|
||
\includegraphics[width=8cm]{01-ess-lab-02-tcmnoopt10.png}
|
||
|
||
\includegraphics[width=8cm]{01-ess-lab-02-tcm3opt.png}
|
||
|
||
\includegraphics[width=8cm]{01-ess-lab-02-tcm3opt10.png}
|
||
|
||
\includegraphics[width=8cm]{01-ess-lab-02-tcmszopt.png}
|
||
|
||
\includegraphics[width=8cm]{01-ess-lab-02-tcmszopt10.png}
|
||
\end{multicols}
|
||
\caption{Оригинальные терминальные сообщения Performance Counter}
|
||
\end{figure}
|
||
|
||
\subsection{Показания Performance Counter для подсчёта контрольной суммы}
|
||
\label{appendix:checksumTime}
|
||
\begin{figure}[H]
|
||
\centering
|
||
\begin{multicols}{2}
|
||
\includegraphics[width=8cm]{01-ess-lab-02-100udpnosim.png}
|
||
|
||
\includegraphics[width=8cm]{01-ess-lab-02-100udpnounf.png}
|
||
|
||
\columnbreak
|
||
|
||
\includegraphics[width=8cm]{01-ess-lab-02-100udpo3sim.png}
|
||
|
||
\includegraphics[width=8cm]{01-ess-lab-02-100udpo3unf.png}
|
||
\end{multicols}
|
||
\caption{Performance Counter для вызова функции checkSum}
|
||
\end{figure}
|
||
|
||
\subsection{Показания Performance Counter для подсчёта контрольной суммы массивов разного объёма}
|
||
\label{appendix:udpMemory}
|
||
\begin{figure}[H]
|
||
\centering
|
||
\begin{multicols}{2}
|
||
\includegraphics[width=8cm]{01-ess-lab-02-025udpo3sim.png}
|
||
|
||
\includegraphics[width=8cm]{01-ess-lab-02-050udpo3sim.png}
|
||
|
||
\includegraphics[width=8cm]{01-ess-lab-02-100udpo3sim.png}
|
||
|
||
\includegraphics[width=8cm]{01-ess-lab-02-200udpo3sim.png}
|
||
|
||
\columnbreak
|
||
|
||
\includegraphics[width=8cm]{01-ess-lab-02-025udpo3unf.png}
|
||
|
||
\includegraphics[width=8cm]{01-ess-lab-02-050udpo3unf.png}
|
||
|
||
\includegraphics[width=8cm]{01-ess-lab-02-100udpo3unf.png}
|
||
|
||
\includegraphics[width=8cm]{01-ess-lab-02-200udpo3unf.png}
|
||
\end{multicols}
|
||
\caption{Performance Counter для подсчёта контрольной суммыразного объёма данных}
|
||
\end{figure}
|
||
|
||
\begin{lstlisting}[language=C,style=CCodeStyle,caption=Функция расчёта времени выполнения одной итерации цикла]
|
||
double count(int datagram_size, double total_time_spent, int actions_in_iteration) {
|
||
return (total_time_spent
|
||
/ 99.0 // function calls
|
||
/ ((datagram_size * 2) // typecast elements
|
||
/ actions_in_iteration)) // 1 for simple 4 for unfolded
|
||
* 1000000; // seconds to microseconds
|
||
}
|
||
\end{lstlisting}
|
||
|
||
\end{document} |