Использование статистических характеристик программного кода в задачах дедупликации и оценки качества

NovaInfo 9
Опубликовано
Раздел: Технические науки
Просмотров за месяц: 0
CC BY-NC

Аннотация

Предлагается новый подход к решению задачи определения релевантности дублирующихся фрагментов, использующий статистические характеристики кода. Данный подход позволяет повысить качество процедуры поиска клонов без снижения производительности. The new approach to solving the problem of determining the relevance of duplicate fragments, using the statistical characteristics of source code. This approach allows improving the quality of software clones detection without performance degradation.

Ключевые слова

ДУБЛИРУЮЩИЙСЯ КОД, DUPLICATED CODE, SOFTWARE CLONES, СХОЖИЙ КОД, ПРОГРАММНЫЕ КЛОНЫ, МЕТРИКИ КОДА, SIMILAR CODE, SOFTWARE METRICS

Текст научной работы

Введение

Дублирование исходного кода — это одна из причин, которые значительно усложняют поддержку и развитие крупных программных продуктов. Со временем дублирующийся код появляется практически в любой системе независимо от того, насколько хорошо и качественно она была спроектирована и реализована изначально.

Присутствие дубликатов в коде приводит к необоснованному увеличению его объёма, что в свою очередь вынуждает программистов контролировать и отлаживать больше кода, чем нужно. Кроме того, возрастает время на накладные расходы (компиляция проекта, работа с репозиторием и т.п.). Также повышается вероятность внесения несогласованных изменений, когда обнаруженная ошибка исправляется только в части продублированных фрагментов, а не везде. Следствием этого становятся увеличивающиеся затраты на поддержку и развитие программного продукта, и в целом, как правило, снижение качества продукта.

Количество дубликатов в больших проектах варьируется в пределах от 5% до 50% от общего объёма кода [1, 2]. Существование дубликатов объясняется сложившейся практикой программирования, когда разработчики, чтобы быстро добавить некоторую функциональность, предпочитают скопировать часть кода (copy/paste), а не видоизменить и повторно использовать первоначальный код.

В связи с этим возникает задача своевременного обнаружения дублирующегося кода и его последующего удаления.

Основной целью дедупликации исходного кода является повышение качества этого кода и, как следствие, повышение качества программного продукта в целом за счёт снижения трудозатрат на внесение изменений, снижения риска возникновения связанных ошибок, повышения сопровождаемости.

В данной статье предлагается алгоритм определения минимального размера дублирующегося фрагмента кода с использованием статистических характеристик кода, призванный в дальнейшем существенно повысить эффективность поиска программных клонов.

Теоретический анализ

Дубликаты (clones, клоны, клон-фрагменты) — это фрагменты кода, которые полностью идентичны (match) другим фрагментам кода или в определенной степени похожи на них, то есть совпадают за исключением некоторых формальных параметров, например, имён функций, методов или переменных. Фрагменты кода состоят из единиц кода.

Единица кода E представляет собой минимальный блок кода, который можно рассматривать, как единое целое, и к которому применима операция сравнения.

В качестве подобного блока допустимо использовать отдельную строку кода в исходном файле. Это объясняется с одной стороны тем, что все основные операции во время кодирования, включая копирование и вставку, выполняются над одной или несколькими строками, а с другой стороны позволяет упростить предварительную обработку кода. Однако использование строк негативно сказывается на качестве обнаруживаемых клонов, а также существенно затрудняет определение синтаксических характеристик кода.

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

Введение единиц кода позволяет абстрагироваться от конкретных особенностей работы с исходным кодом (на уровне строк или на уровне токенов). Все рассматриваемые далее алгоритмы оперируют именно единицами кода.

Фрагмент кода F можно представить в виде последовательности единиц кода:

F=\left\{E_{1}, E_{2}, …,E_{K} \right\},

где E_{i} \, (i=1,…,K) — i-ая единица кода.

Размер фрагмента кода есть количество единиц кода, составляющих этот фрагмент:

\left|F\right|=\left|\left\{E_{1}, E_{2}, …,E_{K} \right\}\right|=K.

Синтаксическая единица SU — это логически завершенный фрагмент кода — метод класса или функция (то есть, по сути, базовая конструкция языка программирования).

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

Основным, на данный момент, критерием релевантности является размер фрагмента кода. Извлечение слишком маленьких фрагментов не представляет смысла, так как потребует существенных трудозатрат и вряд ли положительно отразится на читаемости и наглядности кода. Такие фрагменты считаются иррелевантными.

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

Дублирование программного кода имеет несколько форм.

  1. Текстовое дублирование. Этот вид наиболее простой и легко находимый. Он проявляется, когда в программе есть секции кода, которые идентичны или очень похожи;
  2. Функциональное дублирование. Это особый вид текстового дублирования, когда в исходном коде есть различные функции или методы, предназначенные для одного и того же. Его можно часто встретить в проектах, которые разделены между группами разработчиков, недостаточно хорошо взаимодействующих друг с другом;
  3. Временное дублирование. Оно более трудное, менее ясное, и не так легко обнаруживаемое. Временное дублирование наблюдается, когда при выполнении программы одна и та же работа делается повторно — в то время, когда так не должно быть. Оно может стать серьезной проблемой при масштабировании системы, существенно снижая производительность.

В дальнейшем будет рассматриваться только текстовое и, отчасти, функциональное дублирование. Для устранения временного дублирования лучше всего подходят системы профилирования кода (profilers).

Все клоны можно разделить на несколько групп в зависимости от степени схожести и сложности обнаружения (табл.1).

Таблица 1. Классификация дублирующихся блоков кода

Название типа

Описание

Вид схожести

Тип 1

Абсолютно идентичный фрагмент кода, не содержащий никаких различий

Синтаксическая

Тип 2

Идентичный фрагмент кода, но отформатированный, содержащий комментарии, или изменённые имена переменных

Синтаксическая

Тип 3

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

Синтаксическая (частично семантическая)

Тип 4

Функционально идентичный фрагмент кода, вероятно созданный автором, не подозревающим о существовании оригинального кода

Семантическая

Большинство из существующих подходов для выявления клонов фокусируются главным образом на синтаксической схожести фрагментов кода, поскольку определение семантической схожести очень сложно и малоэффективно в плане производительности. Согласно [3] все методы могут быть разделены на 4 класса:

  1. Методы, основанные на строках (string-based, line-based), разбивают программный код по строкам исходного файла. Таким образом, каждый фрагмент кода представляется в виде последовательности строк. Два фрагмента считаются похожими, если составляющие их строки схожи между собой;
  2. Методы, основанные на токенах (token-based), трансформируют исходный код в последовательность токенов. Затем эта последовательность анализируется на вхождение дублирующихся подпоследовательностей, что может служить признаком программных клонов. В сравнении с подходами, основанными на строках, методы, базирующиеся на токенах, более устойчивы к таким изменениям кода, как форматирование, добавление пробелов и комментариев;
  3. Методы, основанные на деревьях (tree-based), представляют программный код в виде абстрактного синтаксического дерева (АСД). Точные или близкие совпадения поддеревьев могут быть найдены путём их сравнения с АСД. В качестве альтернативного подхода может применяться метод отпечатков (fingerprints) для поддеревьев. Поддеревья с похожими отпечатками являются признаком дублирования кода;
  4. Методы, основанные на семантическом анализе (semantics-based), используют граф зависимостей (program dependence graphs) и расщепление (slicing) программы для поиска изоморфных подграфов (т.е. имеющих идентичную форму) с целью идентификации клонов.

Как показано в [4] процесс поиска клонов всегда включает два основных этапа: трансформацию кода и дальнейшее сравнение этого кода.

На этапе трансформации необходимо решить как минимум две проблемы: характер преобразования кода и минимальный размер фрагмента, которым в дальнейшем будет оперировать алгоритм сравнения.

Характер преобразования кода определяет глубину и объём изменений. Минимальное преобразование кода требует удаления всей незначащей информации: комментариев, пустых строк и лишних пробелов.

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

Для определения схожести единиц кода введём функцию SE, множество допустимых значений которой лежит на отрезке [0, 1], т.е.

S_{E} (E_{1}, E_{2}) \, \in \, [0,\, 1],\, \forall \, E_{1}, E_{2}

где E1 и E2 — единицы кода.

Функция SE обладает следующими свойствами:

1. S_{E} (E_{1}, E_{2}) \, =1, тогда и только тогда, когда E_{1} =E_{2}, то есть когда единицы кода полностью идентичны;

2. S_{E} (E_{1}, E_{2}) \, =0, если E_{1} \ne E_{2} (единицы кода абсолютно не совпадают);

3. S_{E} (E_{1}, E_{2}) \, \in \, (0,\, 1), если E_{1} \approx E_{2} (единицы кода частично совпадают).

Конкретная реализация функции SE может основываться, например, на редакционном расстоянии или локальном выравнивании.

В общем случае для поддержки независимости от конкретного языка программирования алгоритм сравнения двух единиц кода должен использовать анализ строк (string matching) и возвращать логическое значение «истина», если единицы кода совпадают, или «ложь» в противном случае.

Под алгоритмом сравнения мы будем понимать некоторую функцию AE такую, что A_{E} (E_{1}, E_{2}) \, =true для любой пары схожих единиц кода E1 и E2. Используя (3), расширим определение функции AE, введя пороговое значение схожести единиц кода σ:

A_{E} (E_{1}, E_{2}, \sigma) \, =true,\, \forall \, E_{1}, E_{2}, таких что S_{E} (E_{1}, E_{2}) \, \ge \, \sigma

Очевидно, что допустимые значения σ также лежат на отрезке [0, 1]. Изменяя значение σ, можно управлять количеством обнаруживаемых схожих единиц кода, и тем самым влиять на количество получаемых клон-фрагментов.

Для удобства восприятия значение σ может задаваться в процентах.

Фрагменты кода, также как и единицы кода, обладают схожестью. Для определения схожести фрагментов кода по аналогии с (3) введём функцию SF:

S_{F} (F_{1}, F_{2}) \, \in \, [0,\, 1],\, \forall \, F_{1}, F_{2},

где F1 и F2 — фрагменты кода.

Функция SF обладает всеми свойствами рассмотренной ранее функции SE.

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

Наиболее подходящим видится использование метода локального выравнивания для нахождения подстрок высокого сходства. Такой подход позволит определять клон-фрагменты, в которых производилось добавление или удаление единиц кода, либо изменялся порядок следования единиц кода.

Методика

Задача: для заданного фрагмента дублирующегося кода F размера K=\left|F\right| определить его релевантность.

Решение: введём функцию R(F), которая возвращает логическое значение «истина», если фрагмент кода является релевантным, и значение «ложь» в противном случае.

Математическим отображением критерия релевантности служит пороговое значение размера фрагмента кода Kmin такое, что все фрагменты F, размер которых \left|F\right|<K_{\min }, считаются иррелевантными.

R(F)=false, \forall \, F, таких что \left|F\right|<K_{\min }

Таким образом, определение Kmin является ключевой задачей, для выявления релевантности фрагментов дублирующегося кода.

В общем случае значение Kmin является индивидуальным для каждого программного продукта и может быть определено с использованием двух различных подходов: эмпирического и аналитического.

Эмпирический подход основывается на многократном повторении процедуры поиска клонов и ручном подборе Kmin. Его основные недостатки: субъективность, низкая точность, требует серии испытаний.

Аналитический подход основывается на использовании предварительной обработки исходного кода и аппарата математической статистики. Он позволяет получать более точный результат за меньшее время, но требует реализации дополнительного программного модуля для вычисления характеристик кода, что в свою очередь потребует реализации синтаксического анализатора для каждого поддерживаемого языка программирования.

Для аналитического определения Kmin сформулируем несколько предпосылок.

Во-первых, целью поиска дублирующихся фрагментов кода является их дальнейшее устранение путём рефакторинга кода.

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

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

Для этого рассмотрим подробнее статистические характеристики исходного кода.

Пусть исходный код содержит N синтаксических единиц SUi, где i=1,…,N.

K_{i} =\left|SU_{i} \right| — размер i-той синтаксической единицы (в единицах кода).

Размер синтаксической единицы является дискретной случайной величиной. Тогда среднее значение размера синтаксической единицы равно:

m_{K} =\frac{1}{N} \sum _{i=1}^{N}K_{i}.

Дисперсию можно определить как

D_{K} =\frac{1}{N} \sum _{i=1}^{N}\left(K_{i} -m_{K} \right)^{2}.

А среднее квадратическое (стандартное) отклонение будет равно

\sigma _{K} =\sqrt{D_{K} } .

Задача: для заданного исходного кода определить пороговое значение размера фрагмента кода Kmin.

Решение:

1. Значение Kmin должно быть меньше или равно среднему размеру фрагмента кода mK. Такое ограничение позволяет отбросить значительную часть иррелевантных фрагментов с очень маленьким размером.

K_{\min } \le m_{K} .

2. Значение Kmin должно быть строго меньше среднего размера фрагмента кода mK. Дело в том, что дублироваться могут не отдельные синтаксические единицы, а их части, и согласно исследованиям [5, 6] количество таких дубликатов велико.

K_{\min } <m_{K} .

3. Для ответа на вопрос, насколько меньше, целесообразно учитывать среднее квадратическое отклонение, вычисляемое по (9).

K_{\min } <m_{K} -\sigma _{K} .

Тогда значение Kmin можно найти как:

K_{\min } =\gamma \left(m_{K} -\sigma _{K} \right),

где \gamma \in \left(0,\, 1\right) — пороговый коэффициент, зависящий от характеристик кода.

\gamma =\left\{\begin{array}{c} {I_{C} \left(1-\frac{m_{\min } }{m_{K} } \right),\, 5A;8\, m_{\min } <m_{K} } \\ {I_{C}, \, 5A;8\, m_{\min } =m_{K} } \end{array}\right.,

где mmin– минимальный размер синтаксической единицы; mK — средний размер синтаксической единицы по (7); IC =0,9999 — коэффициент, который позволяет значению Kmin, найденному по (11), удовлетворять неравенству (10).

Чем больше размер синтаксической единицы кода, тем сложнее становятся её модификация, тестирование и отладка. Таким образом, при разработке программного обеспечения целесообразно стремиться к тому, чтобы размеры синтаксических единиц находились в определенных рамках. Тогда максимальный размер единицы кода будет приближаться к среднему значению:

m_{max} \to m_{K} .

Под метрикой объемной структурированности кода будем понимать величину:

M_{struct} =\frac{m_{max} -m_{K} }{m_{K} },

где mmax — максимальный размер синтаксической единицы; mK — средний размер синтаксической единицы по (7).

Из (13) следует, что чем лучше структурирован исходный код, и чем меньше разброс между средним и максимальным размерами синтаксических единиц, тем меньше будет значение метрики:

\mathop{\lim M_{struct} }\limits_{m_{max } \to m_{K} } =0.

Экспериментальная часть

Нахождение и выделение синтаксических единиц в программном коде требует реализации синтаксического анализатора (парсера) для каждого поддерживаемого языка программирования. Для решения этой задачи был выбран генератор компиляторов Сосо/R.

Coco/R воспринимает атрибутную LL(1) грамматику языка в расширенной форме Бэкуса-Наура (EBNF) и строит для нее нисходящий рекурсивный синтаксический и лексический анализатор. По функциональности Coco/R покрывает использование пары утилит flex/yacc.

Для определения синтаксических характеристик программного кода и вычисления порогового размера клон-фрагмента написана грамматика, поддерживающая язык программирования C#. Также разработана библиотека классов, использующая сгенерированные лексический и синтаксический анализаторы.

Для апробации разработанной библиотеки были выбраны четыре программных продукта с открытым исходным кодом. В табл. 2 приведены результаты анализа синтаксических характеристик этих продуктов.

Таблица 2. Метрики объемной структурированности для open-source продуктов

Программный продукт

Количество строк

mminmmaxmKKminMstruct

db4o

366834

3

3658

30

27

120

MediaPortal

387978

4

7714

29

25

265

Nlog

75462

4

691

41

37

15

SharpDevelop

1133693

3

4058

30

26

134

Во всех рассмотренных программных продуктах присутствуют синтаксические единицы с пустым телом (m_{\min } \div 3…4). Это иррелевантные фрагменты кода, и на этапе сбора статистических характеристик такие фрагменты целесообразно пропустить. Также нельзя провести однозначную зависимость между метрикой объёмной структурированности и размером исходного кода (см. MediaPortal и SharpDevelop), однако чаще всего программы небольшого размера лучше структурированы, чем крупные продукты (см. Nlog).

Результаты

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

Читайте также

Список литературы

  1. Вахрушев, И. Н. Проблема дублирования исходного кода в программных продуктах / И. Н. Вахрушев // Вузовская наука – региону: Материалы восьмой всероссийской научно-технической конференции. – Вологда: ВоГТУ, 2010
  2. Вахрушев, И. Н. Применение методов поиска дублирующегося кода в процессе разработки программного обеспечения / И. Н. Вахрушев // Автоматизация и энергосбережение машиностроительного и металлургического производств, технология и надёжность машин, приборов и оборудования: Материалы шестой международной научно-технической конференции. Т. 1. – Вологда: ВоГТУ, 2010. – с. 73-76
  3. DECKARD: Scalable and Accurate Tree-Based Detection of Code Clones / L. Jiang, G. Misherghi, Z. Su, S. Glondu // Proceedings of the 29th international conference on Software Engineering. – USA, Washington DC:IEEE Computer Society. – 2007. – p. 96-105
  4. Ducasse, S. A language independent approach for detecting duplicate code / S. Ducasse, M. Reiger, S. Demeyer. // In ICSM’99: Proceedings of the International Conference on Software Maintenance. – UK, Oxford, England. – 1999. – p. 109-118
  5. Kamiya, T. CCFinder: A Multilinguistic Token-Based Code Clone Detection System for Large Scale Source Code / Toshihiro Kamiya, Shinji Kusumoto, Katsuro Inoue // IEEE Transactions on Software Engineering. – 2002. – №28. – p. 654-670
  6. Baxter, I. Clone detection using abstract syntax trees / I. Baxter, A. Yahin, L. Moura. // In ICSM’98: Proceedings of the International Conference on Software Maintenance. – USA, Bethesda, Maryland. – 1998. – p. 368-377

Цитировать

Вахрушев, И.Н. Использование статистических характеристик программного кода в задачах дедупликации и оценки качества / И.Н. Вахрушев. — Текст : электронный // NovaInfo, 2012. — № 9. — URL: https://novainfo.ru/article/1492 (дата обращения: 24.01.2022).

Поделиться