Разрабатываемая система в конечном варианте будет представлять собой Web - приложение. Таким образом, для обеспечения надежной работы системы необходимо обеспечить надежную работу программной части. При этом надежность системы будет рассчитываться по формуле (1):
Р сист = Р апп.ч Р прог.ч , (1)
где Р сист - надежность всей системы;
Р апп.ч - надежность аппаратной части;
Р прог.ч - надежность программной части.
Расчет надежности программной части
Надежность программной части будет рассчитываться по формуле (2):
Р прог.ч = Р сервер Р клиент P ПО , (2)
где Р сервер - надежность программного обеспечения сервера;
Р клиент - надежность программного обеспечения клиента;
Р ПО - надежность разработанного программного обеспечения.
Расчет надежности программного обеспечения сервера
Надежность программного обеспечения сервера рассчитывается по формуле(3):
Р сервер = Р СУБД Р ОС , (3)
где РСУБД - надежность системы управления базой данных;
Р ОС - надежность операционной системы, установленной на сервере.
В качестве операционной системы, установленной на сервере, используется Red Hat Enterprise Linux 5, компания производитель установила вероятность безотказной работы равной:
Р ОС = 0,99.
В качестве сервера базы данных используется СУБД Cache, компания производитель Intersystems установила вероятность безотказной работы равной:
Р СУБД = 0,98.
Таким образом, вероятность безотказной работы ПО сервера составляет:
Р сервер =0,99 0,98= 0,98
Расчет надежности программного обеспечения клиента
Надежность программного обеспечения клиента рассчитывается по формуле (4):
Р клиент = Р ОС Р ВБ , (4)
где Р ОС - надежность операционной системы, установленной на клиенте;
Р ВБ - надежность веб-браузера, используемого клиентом.
В качестве операционной системы, установленной на клиенте, используется Windows 7 Home Premium, компания производитель Microsoft Corporation установила вероятность безотказной работы равной:
Р ОС = 0,98.
Для пакета Internet Explorer 10, компания производитель установила вероятность безотказной работы равной:
Р ВБ = 0,9.
Вероятность безотказной работы программного обеспечения клиента составляет:
Р клиент = 0,98 0,9 = 0,88
Расчет надежности программного обеспечения
Надежность программного обеспечения целиком определяется ошибками разработки. Для среды, в которой по мере обнаружения ошибки исправляются и не вносятся в результаты новые ошибки, надежность программного обеспечения со временем увеличивается.
Используя модель Миллса, рассчитаем надежность программного обеспечения разработанной системы. В программу было искусственно занесено S = 25 ошибок и при Т = 100 запусков обнаружено V = 24 искусственных и n = 4 собственных ошибок. Предполагается, что все ошибки, как искусственные, так и собственные, имеют равную вероятность быть обнаруженными. Тогда первоначальное количество ошибок можно определить из соотношения (5):
Вероятность, с которой можно высказать такое предположение в случае, когда не обнаружены все искусственно рассеянные ошибки, рассчитывается по формуле (6):
где К? n - число собственных ошибок; числитель и знаменатель формулы являются биноминальными коэффициентами вида (7):
Получаем вероятность того, что в системе было 5 собственных ошибок С = 0,75.
Вероятность неверного исхода определяется по формуле 8.
Вероятность безотказной работы (ВБР) определяется формулой (9):
График зависимости безотказной работы программного обеспечения системы от времени (в часах) представлен на рисунке 23.
Рисунок 23 - Зависимость вероятности безотказной работы программного обеспечения от времени (в часах)
Надежность программной части. По формуле (5.2) определим вероятность безотказной работы всей программной части системы и построим график зависимости. График зависимости вероятности безотказной работы программной части системы от времени (в часах) представлен на рисунке 24.
Рисунок 24 - Зависимость вероятности безотказной работы программной части системы от времени (в часах)
По рисунку видно, что ошибки разработки программного обеспечения уменьшают надежность всей системы. По мере выявления и устранения ошибок разработки, их влияние на надежность системы уменьшается.
Одной из важнейших характеристик качества программного средства является надежность.
Надежность - свойство программного средства сохранять работоспособность в течение определенного периода времени, в определенных условиях эксплуатации с учетом последствий для пользователя каждого отказа.
Работоспособным называется такое состояние программного средства, при котором оно способно выполнять заданные функции с параметрами, установленными требованиями технического задания. С переходом в неработоспособное состояние связано событие отказа.
Причиной отказа программного средства является невозможность его полной проверки в процессе тестирования и испытаний. При эксплуатации программного средства в реальных условиях может возникнуть такая комбинация входных данных, которая вызовет отказ, следовательно, работоспособность программного средства зависит от входных данных, и чем меньше эта зависимость, тем выше уровень надежности.
Для оценки надежности используются три группы показателей: качественные, порядковые и количественные.
К основным количественным показателям надежности программного средства относятся:
Вероятность безотказной работы P(t3) - это вероятность того, что в пределах заданной наработки отказ системы не возникает. Наработка - продолжительность или объем работ:
P(t3) = P(t≥t3),
где t - случайное время работы ПС до отказа, t3 - заданная наработка.
Вероятность отказа - вероятность того, что в пределах заданной наработки отказ системы возникает. Этот показатель, обратный предыдущему:
Q(t3) = 1 - P(t3).
Интенсивность отказов системы λ(t) - это условная плотность вероятности возникновения отказа программного средства в определенный момент времени при условии, что до этого времени отказ не возник:
λ(t) = f (t) / P(t),
где f(t) - плотность вероятности отказа в момент времени t:
Существует следующая связь между λ(t) и P(t):
В частном случае λ = const.
Р(t) = exp(- λ(t)d t.).
Р(t) = exp(-λ(t)).
Если в процессе тестирования фиксируется число отказов за определенный интервал времени, то λ(t) - число отказов в единицу времени.
Средняя наработка до отказа Тi - математическое ожидание времени работы программного средства до очередного отказа
где t - время работы программного средства от (К-1) до К отказа.
Ti = (t1+t2+...+tn)/n,
где ti - время работы программного средства между отказами, n - количество отказов.
Среднее время восстановления Тв - математическое ожидание времени восстановления tвi - времени, затраченного на восстановление и локализацию отказа - tо.л.i, времени устранения отказа - tу.о.i, времени пропускной проверки работоспособности - tп.п.i:
tвi = tо.л.i + tу.о.i + tп.п.i.
Для этого показателя термин «время» означает время, затраченное программистом на перечисленные виды работ.
Коэффициент готовности К2 - вероятность того, что программное средство ожидается в работоспособном состоянии в произвольный момент времени его использования по назначению:
К2 = Ti / (Ti +Tв).
Причиной отказа программного средства являются ошибки , которые могут быть вызваны: внутренним свойством программного средства, реакцией программного средства на изменение внешней среды функционирования. Это значит, что при самом тщательном тестировании, если предположить, что удалось избавиться от всех внутренних ошибок, нельзя с полной уверенность утверждать, что в процессе эксплуатации программного средства не возникнет отказ.
Основным средством определения количественных показателей надежности являются модели надежности , под которыми понимают математическую модель, построенную для оценки зависимости надежности от заранее известных или оцененных в ходе создания программного средства параметров. В связи с этим определение надежности показателей принято рассматривать в единстве трех процессов - предсказание, измерение, оценивание.
Предсказание - это определение количественных показателей надежности исходя из характеристик будущего программного средства.
Измерение - это определение количественных показателей надежности, основанное на анализе данных об интервалах между отказами, полученных при выполнении программ в условиях тестовых испытаний.
Оценивание - это определение количественных показателей надежности, основанное на данных об интервалах между отказами, полученными при испытании программного средства в реальных условиях функционирования.
Все модели надежности можно классифицировать по тому, какой из перечисленных процессов они поддерживают (предсказывающие, прогнозные, оценивающие, измеряющие). Нужно отметить, что модели надежности, которые в качестве исходной информации используют данные об интервалах между отказами, можно отнести и к измеряющим, и к оценивающим в равной степени. Некоторые модели, основанные на информации, полученной в ходе тестирования программного средства, дают возможность делать прогнозы поведения программного средства в процессе эксплуатации.
Рассмотрим аналитические и эмпирические модели надежности.
Аналитические модели дают возможность рассчитать количественные показатели надежности, основываясь на данных о поведении программы в процессе тестирования (измеряющие и оценивающие модели).
Эмпирические модели базируются на анализе структурных особенностей программ. Они рассматривают зависимость показателей надежности от числа межмодульных связей, количества циклов в модулях, отношения количества прямолинейных участков к количеству точек ветвления и тому подобное. Нужно отметить, что часто эмпирические модели не дают конечных результатов показателей надежности.
Аналитическое моделирование надежности программного средства включает четыре шага:
Определение предложений, связанных с процедурой тестирования программного средства;
Разработка или выбор аналитической модели, базирующейся на предположениях о процедуре тестирования;
Выбор параметров моделей с использование полученных данных;
Применение модели - расчет количественных показателей надежности по модели.
Аналитические модели представлены двумя группами : динамические и статические модели. В динамических моделях надежности программного средства поведение программы (появление отказов) рассматривается во времени. В статических моделях появление отказов не связывают со временем, а учитывают только зависимость количества ошибок от числа тестовых прогонов (по области ошибок) или зависимость количества ошибок от характеристики входных данных (по области данных). Для использования динамических моделей необходимо иметь данные о появлении отказов во времени. Статические модели принципиально отличаются от динамических тем, что в них не учитывается время появления ошибок в процессе тестирования и не используется никаких предположений о поведении функции риска λ(t). Эти модели строятся на твердом статистическом фундаменте.
Модель Коркорэна
Применение модели предполагает знание следующих ее показателей:
Модель содержит изменяющуюся вероятность отказов для различных источников ошибок и соответственно разную вероятность их исправления;
В модели используются такие параметры, как результат только N испытаний, в которых наблюдается Ni ошибок i-го типа;
Выявление в ходе N испытаний ошибки i-го типа появляется с вероятностью аi.
Показатель уровня надежности R вычисляют по следующей формуле:
где N0 - число безотказных (или безуспешных) испытаний, выполненных в серии из N испытаний,
k - известное число типов ошибок,
Yi - вероятность появления ошибок,
при Ni > 0, Yi = ai,
при Ni = 0, Yi = 0.
Модель Шумана
Модель Шумана относится к динамическим моделям дискретного времени, данные для которой собираются в процессе тестирования программного обеспечения в течение фиксированных или случайных интервалов времени. Модель Шумана предполагает, что тестирование проводится в несколько этапов. Каждый этап представляет собой выполнение программы на полном комплексе разработанных тестовых данных. Выявленные ошибки регистрируются, но не исправляются. В конце этапа рассчитываются количественные показатели надежности, исправляются найденные ошибки, корректируются тестовые наборы и проводится следующий этап тестирования. В модели Шумана предполагается, что число ошибок в программе постоянно и в процессе корректировки новые ошибки не вносятся. Скорость обнаружения ошибок пропорциональна числу оставшихся ошибок.
Предполагается, что до начала тестирования имеется Et ошибок. В течение времени тестирования τ обнаруживается εc ошибок в расчете на одну команду в машинном языке.
Таким образом, удельное число ошибок на одну машинную команду, оставшихся в системе после τ времени тестирования, равно:
εr (τ) = Et / It * εc (τ),
где It - общее число машинных команд, которое предполагается постоянным в рамках этапа тестирования.
Предполагается, что значение функции частоты отказов Z(t) пропорционально числу ошибок, оставшихся в программе после израсходованного на тестирование времени τ:
Z (t) = C * εr (τ) ,
где С - некоторая постоянная
t - время работы программы без отказов.
Тогда, если время работы программы без отказа t отсчитывается от точки t = 0, а τ остается фиксированным, функция надежности, или вероятность безотказной работы на интервале от 0 до t, равна:
R (t, τ) = exp {-C * * t} (1.9)
tср = 1 / {C * }.
Нам необходимо найти начальное значение ошибок Et и коэффициент пропорциональности - С. В процессе тестирования собирается информация о времени и количестве ошибок на каждом прогоне, т.е. общее время тестирования τ складывается из времени каждого прогона
τ = τ1 + τ2 + τ3 + … + τn.
Предполагая, что интенсивность появления ошибок постоянна и равна λ, можно вычислить ее как число ошибок в единицу времени, где Ai - количество ошибок на i - ом прогоне:
Имея данные для двух различных моментов тестирования τa и τb, которые выбираются произвольно с учетом требования, чтобы εc(τb) > εc(τa), можно сопоставить уравнения, приведенные выше при τa и τb:
Неизвестный параметр С получается путем подстановки Et в выражение (1.13).Вычисляя соотношения (1.13). Вычисляя соотношения (1.13) и (1.14) получим:
программы по формуле (1.9).
Проведем расчеты применительно к учебной программе.
Например, в программе имеется It = 4381 оператор.
В процессе последовательных тестовых прогонов были получены следующие данные:
Выберем две точки, исходя из требования, чтобы число ошибок, найденных на интервале А - В, и было больше, чем на интервале 0 - А. За точку А возьмем 2 прогон, а за точку В – 8 прогон. Тогда ошибки, найденные на этапах тестирования на интервалах 0 -А и А - В, будут равны соответственно:
εс(τА) = 3 ⁄ 4381= 0.0007
εс(τВ) = 7 ⁄ 4381= 0.0015.
Время тестирования на интервалах равно:
Рассчитаем интенсивности появления ошибок на двух интервалах:
λА = 3 ⁄ 13 = 0.23
λВ = 7 ⁄ 12 = 0.58.
Тогда число имеющихся до начала тестирования ошибок равно:
Рассчитаем вероятность безотказной работы в течение времени t при τ =
Возьмем t=60 мин.
Таким образом, надежность безотказной работы достаточно велика и вероятность сбоев и возникновения ошибок небольшая.
Модель La Padula
Смотри методическое руководство по дипломному проектированию (Л.Е. Куницына), страницы 27-29.
Введение
Описание предметной области
1 Модель Шумана
2 Модель Миллса
3 Модель Джелинского-Моранды
4 Модель Липова
5 Постановка задачи
Технология разработки приложения
1 Алгоритм решения
2. Макет приложения
2.1 Макет приложения. Модель Шумана (tabPage1)
2.2 Макет приложения. Модель Джелинского-Моранды(tabPage3)
2.3 Макет приложения. Модель Миллса(tabPage5)
2.4 Макет приложения. Модель Липова(tabPage4)
3 Описание программы
3.5 Сохранение результатов
Руководство пользователя
Заключение
Реферат
Программа для расчета надежности программного обеспечения
Ключевые слова:
надежность, модели, эффективность, программное обеспечение, шуман, миллс, моранда, липов.
Цель работы:
Проектирование и разработка программы для определения надежности тестируемого ПО различными моделями с использование языка C# и VisualStudio 2013.
Объект исследования:
модели надежности программного обеспечения
Предмет исследования:
Программа на языке C#
Введение
Такой фактор как "надежность программного обеспечения" всегда играл, играет и будет играть ключевую роль в разработке любого программного продукта. Что же такое "надежность ПО?" Ответ очень прост - это свойство системы выполнять заданные функции, сохраняя во времени значения установленных эксплуатационных показателей в заданных пределах, соответствующих заданным режимам и условиям исполнения. Каждый разработчик стремится сделать свою программу максимально надежной, эффективной и безотказной. К сожалению, полностью исключить факт сбоя или ошибки в настоящий момент не представляется возможным, хотя каждый день в этом направлении ведется работа. Но, представляется возможным рассчитать вероятность возникновения ошибок в программе вследствие тестирования ее на различных математических моделях надежности. Для того чтобы знать, на сколько надежна программа, ее необходимо протестировать и не раз. В соответствии с поставленной целью были сформулированы следующие задачи: ) Провести предметный анализ в области ) Разработать необходимую программу ) Выполнить программную реализацию ) Провести тестирование приложения ) Определить эффективность разработанной программы ) Записать и проанализировать результаты Объектом исследования является метод расчета стоимости разработки ПО. Предметом исследования является программа на платформе VisualStudio на языке C#. В международном стандарте ISO 9126:1991 надежность выделена как одна из основных характеристик качества программного обеспечения ПО. Стандартный словарь терминов программного обеспечения как способность системы или компонента выполнять требуемые функции в заданных условиях на протяжении указанного периода времени. Сама проблема надежности программного обеспечения имеет, по крайней мере, два аспекта: обеспечение и оценка (измерение) надежности. Практически вся имеющаяся литература посвящена первому аспекту, а вопрос оценки надежности компьютерных программ недостаточно проработан. Вместе с тем очевидно, что надежность программы гораздо важнее таких традиционных ее характеристик, как время исполнения или требуемый объем оперативной памяти, однако никакой общепринятой количественной меры надежности программ до сих пор не существует. Модели надежности программных средств подразделяются на аналитические и эмпирические. Аналитические модели дают возможность рассчитать количественные показатели надежности, основываясь на данных о поведении программы в процессе тестирования. Эмпирические модели базируются на анализе структурных особенностей программ. Аналитические модели представлены двумя группами: динамические и статические. В динамических моделях поведение ПО (появление отказов) рассматривается во времени. Если фиксируются интервалы каждого отказа, то получается непрерывная картина появления отказов во времени. Может фиксироваться только число отказов за произвольный интервал времени. В этом случае поведение ПО может быть представлено только в дискретных точках.
1. Описание предметной области
.1 Модель Шумана
Модель Шумана строится на основе нескольких критериев: ¾общее число команд в программе на машинном языке постоянно;
¾в начале компоновочных испытаний число ошибок равно некоторой постоянной величине, и по мере исправления ошибок их становится меньше. В ходе испытаний программы новые ошибки не вносятся;
¾ошибки изначально различимы, по суммарному числу исправленных ошибок можно судить об оставшихся;
¾интенсивность отказов программы пропорциональна числу остаточных ошибок.
Предполагается, что до начала тестирования (т.е. в момент t=0) имеется M ошибок. В течение времени тестирования τ обнаруживается ε1(t) ошибок в расчете на одну команду в машинном языке.
Тогда удельное число ошибок на одну машинную команду, оставшихся в системе после времени тестирования τ, равно:
где I - общее число машинных команд, которое предполагается постоянным в рамках этапа тестирования. Предполагается, что значение функции количества ошибок Z(t) пропорционально числу ошибок, оставшихся в программе после израсходованного на тестирование времени τ.
Z (t) = C * ε2 (τ),
где С - некоторая постоянная, t - время работы программы без отказов. Тогда, если время работы программы без отказа t отсчитывается от точки t = 0, а τ остается фиксированным, функция надежности, или вероятность безотказной работы на интервале от 0 до t, равна
Нам необходимо найти начальное значение ошибок M и коэффициент пропорциональности С. Эти неизвестные оцениваются путем пропуска функционального теста в двух точках переменной оси отладки ta и tв, выбранных так, что ε1(ta)<ε1(td).
В процессе тестирования собирается информация о времени и количестве ошибок на каждом прогоне, т.е. общее время тестирования τ складывается из времени каждого прогона:
τ = τ1 + τ2 + τ3 + … + τn.
Предполагая, что интенсивность появления ошибок постоянна и равна λ, можно вычислить ее как число ошибок в единицу времени,
Тогда
Имея данные для двух различных моментов тестирования ta и tв, можно сопоставить уравнения (3) при τa и τb:
Из соотношений (6) и (7) найдем неизвестный параметр С и М:
Пример 1
.
Программа содержит 2 000 командных строк, из них, до начала эксплуатации (после периода отладки), 15 командных строк содержат ошибки. После 20 дней работы обнаружена 1 ошибка. Найти среднее время безошибочной работы программы и интенсивность отказов программы при коэффициенте пропорциональности, равном 0,7. I=2000=15=20=1=0,7
E1(t)=0,00052(t)=0,007(t)=0,906649ср=204,0816
λ=0,0049 - интенсивность отказов
Пример 2.
На условиях примера 1 определить вероятность безошибочной работы программы в течение 90 суток. I= 2000= 15= 90= 1= 0,7(t)= 0,643393 Пример 3
.
Определить первоначальное количество возможных ошибок в программе, содержащей 2 000 командных строк, если в течение первых 60 суток эксплуатации было обнаружено 2 ошибки, а за последующие 40 суток была обнаружена одна ошибка. Определить T0
- среднее время безошибочной работы, соответствующее первому и второму периоду эксплуатации программы и коэффициент пропорциональности.
I= 20001= 60 суток2= 100 суток1= 2 ошибок2= 3 ошибок0= 30,333333
λ1= 0,033333
λ2= 0,03= 6,6666671(t1)= 0,0012(t2)= 0,0015= 12
Л2/Л1= 0,9
1.2 Модель Миллса
алгоритм тестирование шуман миллс Использование этой модели предполагает необходимость перед началом тестирования искусственно "засорять" программу, т.е. вносить в нее некоторое количество известных ошибок. Ошибки вносятся случайным образом и фиксируются в протоколе искусственных ошибок. Специалист, проводящий тестирование, не знает ни количества, ни характера внесенных ошибок до момента оценки показателей надежности по модели Миллса. Предполагается, что все ошибки (как естественные, так и искусственно внесенные) имеют равную вероятность быть найденными в процессе тестирования. Тестируя программу в течение некоторого времени, собирают статистику об ошибках. В момент оценки надежности по протоколу искусственных ошибок все ошибки делятся на собственные и искусственные. Соотношение, называемое формулой Миллса,
Дает возможность оценить первоначальное число ошибок в программе N. Здесь S - количество искусственно внесенных ошибок; n - число найденных собственных ошибок; V - число обнаруженных к моменту оценки искусственных ошибок.
1.3 Модель Джелинского-Моранды
Основное положение, на котором базируется модель, заключается в том, что в процессе тестирования ПО значение интервалов времени тестирования между обнаружением двух ошибок имеет экспоненциальное распределение с интенсивностью отказов, пропорциональной числу еще не выявленных ошибок. Каждая обнаруженная ошибка устраняется, число оставшихся ошибок уменьшается на единицу. Функция плотности распределения времени обнаружения i-й ошибки, отсчитываемого от момента выявления (i - 1)-й ошибки, имеет вид
Где - интенсивность отказов, которая пропорциональна числу еще не выявленных ошибок в программе: Где N - число ошибок, первоначально присутствующих в программе; С - коэффициент пропорциональности. Наиболее вероятные значения величин N и С определяются на основе данных, полученных при тестировании. Для этого фиксируют время выполнения программы до очередного отказа t1,t2,t3,…,tk. Значения N и С можно получить, решив систему уравнений
Чтобы получить числовые значения λ, нужно подставить вместо N и С их возможные значения N и C . Рассчитав К значений по формуле (5) и подставив их в выражение (4), можно определить вероятность безотказной работы на различных временных интервалах.
1.4 Модель Липова
Липов модифицировал модель Миллса, рассмотрев вероятность обнаружения ошибки при использовании различного числа тестов. Если сделать то же предположение, что и в модели Миллса, т.е что собственные и искусственные ошибки имеют равную вероятность быть найденными, то вероятность обнаружения n собственных и V внесенных ошибок
Где m - количество используемых тестов, q - вероятность обнаружения ошибки в каждом из m тестов, рассчитанная по формуле
S - общее количество искусственно внесенных ошибок; N - количество собственных ошибок, имеющихся в ПО до начала тестирования.
.5 Постановка задачи
Название приложения: Программа расчета надежности программного обеспечения. Назначение разработки: Исходя из введенных пользователем данных, рассчитать основные показатели надежности программного продукта. Входные данные вводятся в специальные поля. После обработки данных, программа выводить результаты в соответствующих полях вывода. Для корректной работы программы все поля должны быть заполнены. По умолчанию в некоторых моделях установлены постоянные значения коэффициентов пропорциональности. Для реализации данной программы мы используем язык программирования C#, на платформе Visual Studio. Системные требования к ПК: ) Операционная система Windows 7 или выше. ) Свободное место на жестком диске: 5МБ и более. ) Наличие Net Framework 4.0 или выше. ) Оперативная память: 128МБ и выше. ) Клавиатура и мышь.
2. Технология разработки приложения
.1 Алгоритм решения
В самом начале выполнения программы появляется форма, где пользователю предлагается заполнить соответствующие поля необходимыми для расчета данными. В начале выполнения программы производится проверка полноты и корректности введенных данных. Если пользовательские данные не прошли проверку - выводится соответствующее уведомление. После успешно пройденной проверки на корректность и полноту, программа начинает производить вычисления. Программа считывает данные, заполненные в специальных полях и производит расчет по формулам. После этого результаты выводятся в специально отведенные окна, а выполнение программы прекращается. .2.1 Макет приложения. Модель Шумана (tabPage1)
menuStrip1 - выводит список меню содержащий пункты "Сохранить результаты" и "Выход" tabPage1 - вкладка элемента tabControl1, содержащая в себе элементы: label49 - 54, label63 - 67, label 61, label59, label48, label62, label58, textBox14 - 19, groupBox4 label52 - принимает текстовое значение "Командных строк в программе" label51 - принимает текстовое значение "Строк содержащих ошибку" label50 - принимает текстовое значение "Дней работы" label49 - принимает текстовое значение "Ошибок за время работы" label58 - принимает текстовое значение "Исходные данные" label54 - принимает текстовое значение "Конечный результат" label61 - принимает сокращенное значение "КСП" label60 - принимает сокращенное значение "ССО" label59 - принимает сокращенное значение "ДР" label48 - принимает сокращенное значение "ОВР" label62 - принимает сокращенное значение "КП" textBox17 - получает значение введенных пользовательских данных в графу "Командных строк в программе" textBox15 - получает значение введенных пользовательских данных в графу "Строк содержащих ошибок" textBox16 - получает значение введенных пользовательских данных в графу "Дней работы" textBox14 - получает значение введенных пользовательских данных в графу "Ошибок за время работы" textBox18 - получает значение введенных пользовательских данных в графу "Коэффициент пропорциональности", по умолчанию установлено значение "1". textBox19 - служит для вывода результатов вычислений, произведенных по формуле Шумана. button5 - принимает текстовое значение "Очистить", а также отчищает все поля в данном блоке
2.2.2 Макет приложения. Модель Джелинского-Моранды(tabPage3)
tabPage3 - содержит все группы объектов, таких как label41-42, label45-46, label73-69, label19-14, textBox4, button3, textBox13-10, groupBox3. label41 - принимает текстовое значение "Число ошибок, первоначально находящихся в программе. label42 - принимает текстовое значение "Коэффициент пропорциональности" label45 - принимает текстовое значение "Количество ошибок спустя время" label46 - принимает текстовое значение "время обнаружения i ошибки" label73 - принимает текстовое значение "Результат" label69 - принимает текстовое значение "Исходные данные" label72 - принимает сокращенное значение "ЧОПНВП" label71 - принимает сокращенное значение "КП" label70 - принимает сокращенное значение "КОСВ" label15 - принимает сокращенное значение "ВОО" label14 - принимает текстовое значение "Конечный результат" Элементы label19 - label16 принимают одинаковые начальные текстовые значения "null" textBox10 - получает значение введенных пользовательских данных в графу "Число ошибок, первоначально находящихся в программе" textBox12 - получает значение введенных пользовательских данных в графу "Коэффициент пропорциональности" textBox11 - получает значение введенных пользовательских данных в графу "Количество ошибок спустя время" textBox13 - получает значение введенных пользовательских данных в графу "Время обнаружения ошибки" textBox4 - служит для вывода результатов вычислений, произведенных по формуле Джелинского-Моранды. button3 - принимает текстовое значение "Очистить", а также отчищает все поля в данном блоке
2.2.3 Макет приложения. Модель Миллса(tabPage5)
tabPage5 - содержит группы объектов, label9-1, textBox3-1, groupBox1, button1, label13, label44. label2 - принимает текстовое значение "Количество искусственно внесенных ошибок" label3 - принимает текстовое значение "Число собственных найденных ошибок" label4 - принимает текстовое значение "Число обнаруженных к моменту оценки искусственных ошибок" label5 - принимает текстовое значение "Результат" label9 - принимает текстовое значение "Исходные данные" label13 - принимает текстовое значение "Конечный результат" label6 - принимает сокращенное значение "КИВО" label7 - принимает сокращенное значение "ЧОНО" label8 - принимает сокращенное значение "ЧОКМОИО" label10 - первоначально получает пустое значение, а после получает значения графы "Количество искусственно внесенных ошибок" label11 - первоначально получает пустое значение, а после получает значения графы "Число собственных найденных ошибок" label12 - первоначально получает пустое значение, а после получает значения графы "Число обнаруженных к моменту оценки искусственных ошибок" label44 - получает и выводит результат вычислений по формуле Миллса button1 - принимает текстовое значение "Очистить", а также отчищает все поля в данном блоке. textBox1 - -получает значение введенных пользовательских данных в графу "Количество искусственно внесенных ошибок" textBox2 - получает значение введенных пользовательских данных в графу "Число собственных найденных ошибок" textBox3 - получает значение введенных пользовательских данных в графу "Число обнаруженных к моменту оценки искусственных ошибок"
2.2.4 Макет приложения. Модель Липова(tabPage4)
tabPage4 - содержит группы объектов, label78-74, label84-97, label82, groupBox5, button4. label74 - принимает текстовое значение "Количество используемых тестов" label76 - принимает текстовое значение "Общее количество искусственно внесенных ошибок label77 - принимает текстовое значение "Количество собственных ошибок, до начала тестирования label78 - принимает текстовое значение "Количество внесенных ошибок к концу тестирования label86 - принимает текстовое значение "Результат" label82 - принимает текстовое значение "Исходные данные" label90 - принимает текстовое значение "Конечный результат" label91 - принимает текстовое значение "Вероятность обнаружения ошибки при использовании различного числа m тестов" label92 - получает и выводит результат вычислений по формуле Липова, начальное значение "null" label85 - принимает сокращенное значение "КИТ" label84 - принимает сокращенное значение "ОКИВО" label87 - принимает сокращенное значение "КСОДНТ" label88 - принимает сокращенное значение "КВОКТ" label89 - принимает сокращенное значение "КСОКТ" textBox20 - получает значение введенных пользовательских данных в графу "Количество используемых тестов" textBox22 - получает значение введенных пользовательских данных в графу "Общее количество искусственных внесенных ошибок" textBox23 - получает значение введенных пользовательских данных в графу "Количество собственных ошибок до начала тестирования" textBox24 - получает значение введенных пользовательских данных в графу "Количество внесенных ошибок к концу тестирования" textBox21 - получает значение введенных пользовательских данных в графу "Количество собственных ошибок к концу тестирования" button4 - принимает текстовое значение "Очистить", а также отчищает все поля в данном блоке.
2.3 Описание программы
.3.1 tabPage1
Иерархия классов using System.Collections.Generic;System.ComponentModel;System.Data;System.Drawing;System.Linq;System.Text;System.Windows.Forms;System.IO; Используемые элементы:;;;;;; Обработчики событийvoid button5_Click(object sender, EventArgs e) В данной вкладке одна функция Функция Suman производит расчет по формуле Шумана и передает результат в соответствующий объект вывода, как изображено на рисунке 1.1 {(textBox20.Text == "") }(textBox22.Text == "") }(textBox23.Text == "") }(textBox21.Text == "") }(textBox24.Text == "") MessageBox.Show("Введите числовое значение!"); MessageBox.Show("Введите числовое значение!"); MessageBox.Show("Введите числовое значение!"); MessageBox.Show("Введите числовое значение!"); Результат работы вы можете видеть на рисунке 1.2
Рисунок 1.2 Расчет по модели Шумана
2.3.2 tabPage3
Иерархия классовSystem;System.Collections.Generic;System.ComponentModel;System.Data;System.Drawing;System.Linq;System.Text;System.Windows.Forms; using System.IO; Используемые элементы: Обработчики событийvoid button3_Click(object sender, EventArgs e) В данной вкладке тоже одна функция Функция Moranda производит расчет по формуле Джелинского-Моранды и выводит результат public void Moranda(EventArgs e_Moranda) {(textBox11.Text == "") {.Show("Введите количество ошибок спустя время!", "Модель Джелинского-Моранды"); }(textBox13.Text == "") {.Show("Введите время обнаружения i-ошибки!", "Модель Джелинского-Моранды"); }(textBox12.Text == "") {.Show("Введите коэффициент пропорциональности!", "Модель Джелинского-Моранды"); }(textBox10.Text == "") {.Show("Введите число ошибок первоначально находящихся в программе!", "Модель Джелинского-Моранды"); }t10;(!int.TryParse(textBox10.Text, out t10)) MessageBox.Show("Введите числовое значение!"); int t12;(!int.TryParse(textBox12.Text, out t12)) MessageBox.Show("Введите числовое значение!"); int t13;(!int.TryParse(textBox13.Text, out t13)) MessageBox.Show("Введите числовое значение!"); int t11;(!int.TryParse(textBox11.Text, out t11)) MessageBox.Show("Введите числовое значение!"); {.Show("Ошибка:" + ex.Message); }lambda, C, N, i, P,t;= Double.Parse(textBox10.Text);= Double.Parse(textBox12.Text);= Double.Parse(textBox11.Text);= Double.Parse(textBox13.Text);= C * (N - i + 1);= lambda * Math.Exp(lambda * (-1) * t); textBox4.Text = " Функция плотности распределения времени обнаружения i-й ошибки, отсчитываемого от момента выявления:" + P. ToString(); label16.Text = N. ToString();.Text = C. ToString();.Text = i.ToString();.Text = t.ToString(); Результат работы виден на рисунке 1.3
Рисунок 1.3 Результат выполнения расчетов по модели Джелинского-Моранды
2.3.3 tabPage5
Используемые элементы:;;;;;; Обработчики событийvoid button1_Click(object sender, EventArgs e) В данной вкладке одна функция Функция Mills производит расчет по формуле Миллса и выводит результат public void Mills(EventArgs e_Mills) {(textBox1.Text == "") {.Show("Введите количество искусственно внесенных ошибок!", "Модель Миллса"); }(textBox2.Text == "") {.Show("Введите число собственных найденных ошибок!", "Модель Миллса"); }(textBox13.Text == "") {.Show("Введите число обнаруженных к моменту оценки искусственных ошибок!", "Модель Миллса"); }t1;(!int.TryParse(textBox1.Text, out t1)) MessageBox.Show("Введите числовое значение!"); int t2;(!int.TryParse(textBox2.Text, out t2)) MessageBox.Show("Введите числовое значение!"); int t3;(!int.TryParse(textBox3.Text, out t3)) MessageBox.Show("Введите числовое значение!"); {.Show("Ошибка:" + ex.Message); }S, n, V, N;= Double.Parse(textBox1.Text);= Double.Parse(textBox2.Text);= Double.Parse(textBox3.Text); N = (S * n) / V;.Text = "Первоначальное число ошибок в программе равно:" + N. ToString(); label10.Text = S. ToString();.Text = n.ToString(); label12.Text = V. ToString(); Результат выполнения вычислений по формуле Миллса хорошо видны на рисунке 1.4
2.3.4 tabPage4
Иерархия классовSystem;System.Collections.Generic;System.ComponentModel;System.Data;System.Drawing;System.Linq;System.Text;System.Windows.Forms;System.IO; Используемые элементы:;;;;;; Обработчики событийvoid button4_Click(object sender, EventArgs e) В данной вкладке одна функция Функция Lipov производит вычисления по формуле Липова и выводит результат public void Lipov(EventArgs e_Lipov) {(textBox20.Text == "") {.Show("Введите количество используемых тестов!", "Модель Липова"); }(textBox22.Text == "") {.Show("Введите общее количество искусственно внесенных ошибок!", "Модель Липова"); }(textBox23.Text == "") {.Show("Введите количество собственных ошибок до начала тестирования!", "Модель Липова"); {.Show("Введите количество собственных ошибок к концу тестирования!", "Модель Липова"); }(textBox24.Text == "") {.Show("Введите количество внесенных ошибок к концу тестирования!", "Модель Липова"); // Проверка на введенные значенияt20; if (!int.TryParse(textBox20.Text, out t20)) MessageBox.Show("Введите числовое значение!"); int t21;(!int.TryParse(textBox21.Text, out t21)) MessageBox.Show("Введите числовое значение!"); int t22;(!int.TryParse(textBox22.Text, out t22)) MessageBox.Show("Введите числовое значение!"); int t24;(!int.TryParse(textBox24.Text, out t24)) MessageBox.Show("Введите числовое значение!"); int t23;(!int.TryParse(textBox23.Text, out t23)) MessageBox.Show("Введите числовое значение!"); {.Show("Ошибка:" + ex.Message); }m, q, S, N, n, V;= Double.Parse(textBox20.Text);= Double.Parse(textBox22.Text);= Double.Parse(textBox23.Text);= Double.Parse(textBox21.Text);= Double.Parse(textBox24.Text);= (n + V) / n;Q = (m / (n + V)) * Math.Pow(n + V, q) * Math.Pow(m - n - V, 1 - q) * ((N / n) * (S / V) / ((N + S) / (n + V)));.Text = Q. ToString();.Text = m.ToString();.Text = S. ToString();.Text = N. ToString();.Text = V. ToString();.Text = n.ToString(); {.Show("Введены значения, при которых результат отрицателен!", "Модель Липова"); 2.3.5 Сохранение результатов
Для сохранения результатов изпользуется обработчик событий ToolStripMenu. После произведения вычислений по предложенным выше моделям, пользователь может сохранить свои результаты. Рисунок 1.6 Выбор пути для сохранения
А после подтверждения сохранения, уведомление об успешной операции:
Рисунок 1.7. Уведомление об успешном сохранении.
3. Руководство пользователя
Для корректной работы программы необходимо заполнить все предложенные в программе модели. Некоторые из параметров статичны и их изменение может привести к некорректной работе программы. При сохранении программа автоматически присваивает имя файлу в формате "Результаты №" + рандомное число от 0 до 9999. Вы также можете задать свое имя сохранения. При вводе некорректных параметров для расчета вы можете получить отрицательные результаты. Для расчета и получения результатов нажмите кнопку "Рассчитать".
Заключение
Язык программирования C# на основе Visual Studio способен реализовать все необходимые средства для расчета надежности программ. Во время выполнения поставленной задачи были улучшены навыки программирования, работы с математическими формулами. Разработанная программа наглядно демонстрирует реализацию 4 моделей для определения надежности программного обеспечения. Основное преимущество программа - производство вычислений по 4 моделям одновременно.
В составе современных технических систем всё больший удельный вес занимают средства вычислительной техники. Стоимость основной ячейки интегральных микросхем – логического вентиля – с развитием электроники непрерывно снижается. Напротив, программное обеспечение, удельная стоимость которого у первых ЭВМ была очень малой, в настоящее время составляет более 90 % стоимости компьютеров. Этот рост стоимости объясняется несколькими причинами:
1) Технология создания программного обеспечения серьезно отстаёт от технологии производства элементной базы;
2) по своей природе программное обеспечение сложнее оборудования (объём программ для современных систем оценивается в 10 6 – 10 8 и более команд или информационных слов);
3) требования к программному обеспечению в течение его жизненного цикла, который увеличился до 15 – 20 лет, существенно изменяются;
4) в отличие от комплекса технических средств для программного обеспечения (ПО) очень трудно рассчитать на этапе проектирования достижимое быстродействие, кроме того, в оборудование непрерывно вносятся изменения.
Отсюда следует, что в процессе создания и эксплуатации ПО непрерывно изменяется, а самим программам свойственны ошибки. В самом общем виде под ошибкой понимают любое не выполнение программой функций, которые заданы техническим заданием. Проявление ошибки является отказом, а надёжность вычислительной техники состоит из двух составляющих: надёжности технических средств и надёжности программного обеспечения.
Приближенно можно полагать, что отношение числа ошибок в программе к общему числу команд в ней лежит в диапазоне от 0,25 до 10 на 1000 команд. Это означает, что в ПО объёмом в 0,5 млн. команд может быть 125 – 5000 ошибок; причем, такая оценка является оптимистической. Выявление ошибок и их исправление является процессом многоэтапным (в соответствии с этапами «жизни» ПО), трудоёмким и дорогостоящим. По мере перехода к более поздним этапам разработки ПО цена ошибки возрастает, тенденцию этого роста иллюстрирует таблица:
Таблица 2.1 - Примерная «цена» программной ошибки на разных этапах жизни программного обеспечения
Цена ошибки, которую не удалось обнаружить на этих этапах, может быть совершенно непредсказуемой и огромной. Свидетельством этого являются аварии, происходящие с космическими аппаратами, многие из которых были потеряны из-за ошибок именно в программном обеспечении.
2.3.1 Основные определения теории надёжности программного обеспечения
Основными терминами, которые используются в теории надёжности программного обеспечения, являются следующие: программная ошибка; число оставшихся в программе ошибок, которые будут переданы далее пользователю; интенсивность обнаружения ошибок (функция риска); «прогон» программы; отказ программы; вероятность безотказной работы программного обеспечения.
Основная трудность определения термина «программная ошибка» состоит в том, что ошибка в программе – это по своей сути функция самой программы и того, чего ожидает от неё пользователь. Перечислим основные проявления, которые можно идентифицировать как ошибку:
Появление при программировании ошибочного операнда или операции;
Несоответствие выполняемых ПО функций требованиям спецификаций, либо ошибка в спецификации, которая приводит к ошибке при выполнении операции ПО;
Ошибки вычислительного характера (например, переполнение);
Исправление ПО, улучшающее его взаимодействие с пользователем.
К программным ошибкам не относят исправления, создающие или уничтожающие временные программные «заглушки» на отсутствующую или не корректную программу, а так же перетрансляцию программы, вызванную накопившимися исправлениями. Количество оставшихся в ПО или переданных ошибок – это потенциальное число ошибок в ПО, которое может быть обнаружено в нём на последующих этапах его жизненного цикла после исправлений, внесённых на данном этапе. Это количество ошибок будем обозначать символом В .
Введём интенсивность обнаружения ошибок или функцию риска r(t), которая определяется отношением числа обнаруженных ошибок к промежутку времени, за который эти ошибки были обнаружены. Для интенсивности обнаружения ошибок справедливы все формулы, которые известны из теории надёжности. В отличие от интенсивности отказов функция риска убывает по мере обнаружения и исправления ошибок. Если предположить, что остаётся постоянной между моментами обнаружения и исправления ошибок, уменьшаясь скачкообразно на постоянную величину в момент обнаружения ошибок, то для простоты целесообразно полагать её пропорциональной количеству оставшихся ошибок
, (2.80)
где - число обнаруженных ошибок на данном этапе.
Дифференцируя уравнение (2.80) по времени получим
где - есть функция риска . Если решить дифференциальное уравнение 
, с начальными условиями то
(2.81)
Обозначим 
Тогда уравнение (2.81) можно переписать в виде
Функцию риска зададим дискретно, придав интервалу времени заданное значение (день, неделя, месяц). Логарифмируя уравнение (2.82) для выбранных значений времени , получим систему уравнений вида
(2.83)
Расчёт экспоненциальной регрессии даёт следующие выражения для её коэффициентов
(2.84)
(2.85)
Программа для расчёта экспоненциальной регрессии приведена ниже в 2.3.3.
Будем под удельной интенсивностью обнаружения ошибок в ПО понимать следующую функцию времени:
(2.87)
где - число ошибок в ПО, которые исправлены к моменту времени t ; - число команд в программе. Приближенно можно полагать, что
здесь - разрядность команды; - объем программы по Холстеду, что будет; В – число оставшихся ошибок в ПО к моменту t = 0; К – коэффициент пропорциональности. Величины В и К являются неизвестными.
Рассмотрим два периода отладки программы Т 1 и Т 2 такие, что Т 1 < Т 2 . Пусть n 1 и n 2 соответственно количество ошибок в ПО, обнаруженных в каждом из периодов. Тогда для среднего времени безошибочной (безотказной) работы в каждом из периодов можно записать следующие выражения:
(2.89)
(2.90)
Разделив первое равенство на второе, после преобразований можно получить:
(2.91)
Подставив полученное значение B в формулу для среднего времени безотказной работы в первом периоде отладки программы, можем определить коэффициент пропорциональности
. (2.92)
Определив В и К , можно для любого момента времени вычислить значение удельной интенсивности обнаружения ошибок в ПО и вероятность безотказной работы, полагая, что время исправной работы подчинено экспоненциальному закону распределения.
Прогоном программы называют совокупность действий, включающую в себя:
Ввод возможной комбинации Е i входных данных;
Выполнение расчёта по программе, которая заканчивается получением результата F(E i) или отказом.
Для определенного набора входных данных отклонение результата от заданного значения F`(E i), полученное в результате выполнения программы, находится в допустимых пределах
(2.93)
а для всех остальных E i , образующих подмножество , выполнение программы не обеспечивает приемлемого результата, т.е.
> (2.94)
События, описываемые неравенством (2.94), называются отказами программы.
Методика статистической оценки вероятности отказа ПО за n независимых прогонов программы является традиционной и формально включает в себя оценку
(2.95)
где если выполняется неравенство (2.93); если выполняется неравенство (2.94).
Обозначим через допустимую относительную погрешность оценки вероятности отказа. Тогда необходимое число независимых прогонов программы n должно быть пропорционально величине где - заданное значение вероятности отказа. Так, при и значении число независимых прогонов должно быть не меньше
Такое количество прогонов трудно реализовать на практике и обычно обращаются к другим методам оценки вероятности отказа ПО. Зная вероятность отказа, нетрудно вычислить вероятность безотказной работы ПО.
Для проверки надёжности ПО используются методы проверки статистических гипотез и, в частности, последовательный анализ Вальда. Сопоставим дихотомической переменной значение 1
, если выполняется (2.94), и значение 0, если выполняется (2.93). Тогда результат прогонов образует выборку случайных величин 
Обозначим вероятность того, что , т.е. программа отказывает, как Р; а вероятность Р 0 того. что принимает значение 0, а программа исправна. Тогда выбор значения
Р 0 =0,99 означает, что в серии из 100 прогонов вероятно в среднем появление одного отказа.
Применение последовательного анализа позволяет существенно ограничить число испытаний на надёжность ПО и не налагает жёстких требований на закон распределения случайной величины . Практическое применение последовательного анализа будет продемонстрировано ниже.
Большое значение для получения приближенных оценок показателей надёжности ПО имеют так называемые метрики Холстеда. Эти же метрики позволяют численно оценить и другие характеристики ПО: длину программы, её объём, уровень программы, её интеллектуальное содержание, длительность разработки и т.п. Метрики прошли серьезную практическую апробацию и показали приемлемую для практических расчётов точность. Рассмотрим сущность метода Холстеда.
Для любой программы можно определить:
Число различных операций , например, 
и др.;
Общее число всех операндов (переменных и констант);
Общее число всех операций
Общее число всех операндов
Тогда словарь программы есть , а длина реализации составляет Длина программы в этом случае равна
а объём программы (2.97)
потенциальный объём программы
где минимальное число различных операндов (точнее, число независимых входных и выходных величин).
Потенциальный объём - минимально возможный объём определённого алгоритма. Уровень программы L определяется через отношение потенциального объёма к объёму программы
Работа по программированию Е оценивается как суммарное число элементарных мысленных отличий между элементами, необходимых для генерации программы:
Уровень языка позволяет оценивать преимущество языка более высокого уровня по сравнению со своим предшественником и определяется выражением
что позволяет иначе выразить характеристики Е и V :
В таблице 2.2 приведены численные значения для языков различного уровня.
Таблица 2.2 – Численные значения уровня языка
Трудоемкость разработки программного обеспечения определяется по формуле
чел. - часов; (2.104)
где - параметр Страуда, т.е. время, которое необходимо человеческому мозгу для определения существенного отличия между двумя элементами, оценивается значением 5-20 существенных различий в секунду.
Замечено, что при разработке сложных программ трудоёмкость их создания и количество выявленных при отладке ошибок существенно возрастают. При этом число переданных ошибок пропорционально объёму программы.
Коэффициент пропорциональности С определяют, исходя из следующих соображений. В соответствии с эмпирическим законом Д. Миллера «7 2» для определим, что , а для английского языка с учётом (2.100) получим
что позволяет оценить коэффициент С
как 
однако для языков более низкого уровня правильнее оценивать С , используя выражение более общего вида
что, в частности, для Ассемблера даёт значение 
Таким образом,
(2.108)
или в более общей форме
Значения величин и могут быть определены из результатов анализа ПО или косвенно путем решения уравнений Холстеда, если известны значения и :
(2.110)
2.3.2 Методика оценки числа оставшихся ошибок в программе
Оценка потенциального числа ошибок в ПО перед началом разработки программы может быть проведена путём расчёта количества независимых входных и выходных величин , потенциального объёма программы и возможного числа ошибок в ней. Приведём примеры анализа входных и выходных данных.
Пример 1. Рассматривается система контроля посадки самолётов в условиях ограниченной видимости. В состав системы входят курсовой радиомаяк, глиссадный радиомаяк, ответчик радиодальномера. Входными величинами системы являются: три пространственные координаты (азимут, угол места, дальность), всего количество координат равно Три информационных эталонных канала, т.е. - четыре координаты самолёта (высота, путевая скорость, крен, тангаж).
Всего есть сорок входных величин. Выходных величин для каждого информационного канала будет четыре (три пространственные координаты плюс время), т.е. всего 12 независимых величин.
Решение.
потенциальный объём программы равен
а количество потенциальных ошибок в ПО равно
Пример 2. Определить характеристики программного обеспечения для боевой космической станции (БКС) системы противоракетной обороны (ПРО) типа стратегической оборонной инициативы президента США Рейгана. БКС должна быть рассчитана на перехват около 1000 целей с расстояния примерно 400 км.
Решение. Для перехвата необходимо рассчитать местоположение целей, их скорость, расстояние до них и условные параметры прицеливания. Упростим задачу и попытаемся получить оценку снизу. Поэтому не будем рассматривать задачи распознавания целей и согласования полученных данных с моделью боевой ситуации. Будем рассматривать предельно простой случай полной децентрализации, когда процессор управляющего компьютера непосредственно подключён к датчикам БКС и обрабатывает данные о координатах наблюдаемых объектов с целью вычислить их положение на момент перехвата. Полагаем, что на одном экране БКС появляется одновременно не более 20 целей, а 30 последовательных измерений положения объекта и его скорости статистически достаточно для получения необходимой точности и выбора наилучшего момента поражения одной цели.
Пусть для определения природы объекта необходимо измерить пять величин и на экране измеряются две координаты для каждого из 20 объектов. Таким образом, количество входных величин оказывается равным
Выходные величины программы – это угловые координаты целей и расстояние до них. Для 20 целей количество выходных величин составляет
Итак, 
что даёт для потенциального объёма программы значение равное
Расчёты показывают, что для создания такого объёмного ПО требуется около 10 12 чел. - часов. Потенциальное количество ошибок в этом гигантском по объёму ПО для языков различного уровня равно:
На устранение такого огромного количества ошибок может потребоваться значительно больше времени, чем на создание самого программного обеспечения. Поэтому разработка ПО такого большого объёма сомнительна.
Выполним расчёт потенциального количества ошибок в ПО перед началом комплексной отладки. Уточнение значения числа ошибок можно было бы провести путём прямого подсчёта значений и . Однако для программ, написанных на языке низкого уровня это сделать затруднительно. Возможен иной подход, который рассмотрим для ПО при условиях примера 1. Особенностью этого ПО является то, что оно написано на Ассемблере.
Значение складывается из числа команд , используемой системы команд и из числа отдельных подпрограмм . В ПО примера использовалось 45 различных операторов, число подпрограмм составило 157. Таким образом,
Количество операндов равно сумме (различные переменные и массивы данных, используемых в ПО); плюс количество локальных меток и констант . Для облегчения подсчёта используют имеющееся распределение памяти оперативного запоминающее устройства (ОЗУ), при этом подходе исключается повторяемость соответствующих операндов. Число локальных меток подсчитывают по тексту программы на Ассемблере слева от мнемонической записи команды. Таким способом гарантируется не повторяемость меток, а общепринятая табуляция облегчает подсчёт. Сложнее сосчитать число различных констант, которые оформляются в массивы числовых данных и используются при адресации в Ассемблере. Поэтому по тексту программы считают лишь число констант, заведомо помещающихся в одном байте. Как правило, они выделяются в тексте и вероятность их совпадения очень мала. К значению этой величины прибавляют 256 – число возможных байтовых констант. Для рассматриваемого ПО указанные величины имеют следующие значения:
82 + 334 + 280 + 256 = 952.
Полученные значения и можно сопоставить с расчётными значениями, которые определены из решения уравнений Холстеда для 
В результате решения 
Эти значения можно полагать приемлемыми (отличие от реального ПО составляет 11,0 % и 10,5 %).
Рассчитаем длину программы
и определим объём программы
Уточнённая оценка переданного количества ошибок в ПО равна:
Оценка отличается от полученной ранее = 168 лишь на 12 % и по своему смыслу является более близкой к реальности.
2.3.3 Методика расчёта интенсивности обнаружения ошибок в зависимости от времени эксплуатации программы
В процессе комплексной отладки ПО видоизменяется с целью осуществления недостающих функций и внесения исправлений для обнаруженных ошибок в уже реализованной программе. Такие изменения обычно заносятся в специальный журнал учёта исправлений с указанием даты и семантики исправления. В качестве примера рассмотрим ПО из примера 1. Исходными данными являются результаты комплексной отладки этого ПО примерно за двухлетний период. Количество обнаруженных ошибок фиксировалось помесячно, поэтому интенсивность обнаружения ошибок имеет размер «количество ошибок/месяц». Значения интенсивности обнаружения ошибок за 20 месяцев приведены ниже в таблице. Таблица 2.3 - Значения интенсивности обнаружения ошибок
| Δt i | ||||||||||
| r(t i) | ||||||||||
| Δt i | ||||||||||
| r(t i) |
Используя экспоненциальную аппроксимацию что даёт значение количества оставшихся ошибок Это значение хорошо согласуется с ранее определенными значениями и .
Экспоненциальная аппроксимация интенсивности обнаружения ошибок может быть использована для прогностического расчёта количества оставшихся ошибок, если определить интенсивность определения ошибок на какое-то время вперед, например, на квартал.
Таблица 2.4 - Интенсивность обнаружения ошибок на квартал вперед
| Δt i | |||
| r(t i) |
2.3.4 Статистическая оценка вероятности безотказной работы
программного обеспечения
Рассмотрим метод последовательного анализа для оценки вероятности безотказной работы программы. В нём вводится допущение о том, что если вероятность успешного прогона Р находится в достаточно малой окрестности точки Р 0 , то риск принятия неправильного решения допустимо мал. Под неправильным решением понимают решение отвергнуть надёжную программу или пропустить не надёжную программу. Для формализации этого допущения задают такие P` и P`` (P`
Что принятие не надёжной программы рассматривается как ошибочное решение только при , а отказ от надёжной программы является ошибочным в случае, когда . После задания значений вероятностей P` и P`` допустимый риск принятия неправильных решений таков, что вероятность ошибки первого рода, т.е. отказа от надёжной программы, не должна превышать α = Вер , а вероятность ошибки второго рода, т.е. принятия не надёжной программы не должна превышать β = Вер . Значения величин α и β при этом назначаются, исходя из разумного компромисса, до начала испытаний, так как с их уменьшением растёт объём испытаний.
Сущность последовательного анализа гипотезы Н 0 (Р = Р 0) состоит в проверке двух конкурирующих гипотез Н`(P = P`) и H``(P = P``). Здесь под вероятностью безотказной работы ПО P(m) понимают вероятность получения выборки в которой для элементов P`
Тогда
Если верна гипотеза H`, то
Аналогично, если верна гипотеза H``, то
Составим отношение «правдоподобия»:
(2.114)
Последовательный анализ проводится до тех пор, пока не будет выполняться следующие неравенства:
(2.115)
Если на этапе m
то ПО не надёжно; а если 
то ПО можно принять как надёжное.
Теория надежности аппаратуры частично применима к проблеме надежности программного обеспечения, учитывая следующие различия между надежностью аппаратуры и программного обеспечения:
Элементы программного обеспечения не стареют из-за износа или усталости;
В аппаратуре использование стандартных элементов распространено намного шире, чем в системе программного обеспечения;
Количество документации по программному обеспечению гораздо больше по сравнению с количеством документации для аппаратных средств;
Ввести изменения в программы просто, но трудно сделать это корректно.
Надежность программного обеспечения - свойство программы выполнять заданные функции, сохранять свои характеристики в установленных пределах при определенных условиях эксплуатации. Надежность программного обеспечения определяется его безотказностью и восстанавливаемостью.
Безотказность программного обеспечения или программы - свойство программы сохранять работоспособность при использовании в процессе обработки информации.
Безотказность программного обеспечения можно также характеризовать средним временем между возникновениями отказов в процессе функционирования программы. При этом предполагается, что аппаратура информационной системы находится полностью в работоспособном состоянии.
Важной характеристикой надежности программного обеспечения является его восстанавливаемость, которая определяется затратами времени и труда на устранение отказа из-за проявившейся ошибки в программе и его последствий. Восстановление после отказа в программе может заключаться в корректировке и восстановлении текста программы, исправлении данных, внесения изменений в организацию вычислительного процесса.
Принципиальное отличие программного обеспечения от аппаратуры состоит в том, что программное обеспечение не изнашивается и его выход из строя из-за поломки невозможен. Поэтому характеристики функционирования программного обеспечения зависят только от его качества.
В значительной степени на функционирование программного обеспечения влияют входные данные. Так проявление ошибок программного обеспечения связано с тем, что в некоторые моменты времени на обработку поступают ранее не встречавшиеся совокупности данных, которые программа не в состоянии корректно обработать.
Увеличение надежности программы является следствием того, что в процессе эксплуатации обнаруживаются и устраняются скрытые ошибки.
Основными причинами, непосредственно вызывающими нарушения нормального функционирования программы являются:
Ошибки, скрытые в самой программе;
Искажения входной информации, подлежащей обработке;
Неверные действия пользователя;
Неисправности аппаратуры, на которой реализуется вычислительный процесс.
В процессе отладки сложных программных средств невозможно обнаружить и ликвидировать все ошибки. В результате в программах остается некоторое количество скрытых ошибок. Они могут вызвать неверное функционирование программ при определенных сочетаниях входных данных. Наличие скрытых ошибок программного обеспечения является главным фактором нарушения нормальных условий его функционирования.
Искажение информации, подлежащей обработке, вызывает нарушение функционирования программного обеспечения, когда входные данные не попадают в область допустимых значений переменных программы. В этом случае между исходной информацией и характеристиками программы возникает несоответствие.
Причинами искажения вводимой информации могут быть следующие: сбои и отказы в аппаратуре ввода данных, шумы и сбои в каналах связи при передаче сообщений по линиям связи, сбои и отказы в аппаратуре передачи или приема информации, ошибки пользователей при подготовке исходной информации и т.д.
Неверные действия пользователя, приводящие к отказу в процессе функционирования программного обеспечения, связаны, прежде всего, с неправильной интерпретацией сообщений, с неправильными действиями пользователей в процессе работы с системой и т.д.
Отказы программного обеспечения, обусловленные ошибками пользователя, называют ошибками использования. Часто эти ошибки являются следствием некачественной программной документации (неверное описание возможностей программы, режимов работы, форматов входной и выходной информации, диагностических сообщений и т.д.).
Появление отказа или сбоя в работе аппаратуры приводит к нарушению нормального хода вычислительного процесса и во многих случаях - к искажению данных и текстов программ в основной и внешней памяти.
Всесторонний анализ ошибок, встречающихся в программах, возможен только при наличии точных данных об отказах программ, причинах отказов, о самих программах и условиях их разработки (квалификации программиста, сроков разработки и др.).
Эти данные являются основой для построения аналитических моделей надежности программ с целью ее оценки и прогнозирования, а также для нахождения путей ее обеспечения и повышения. Модели надежности программ строятся на предположении, что проявление ошибки является случайным событием и поэтому имеет вероятностный характер.
Для построения моделей используются следующие характеристики надежности программ:
Функция надежности P(t), определяемая как вероятность того, что ошибка программы не проявится на интервале от 0 до t, т.е. время ее безотказной работы будет больше t;
Функция ненадежности Q(t) - вероятность того, что в течение времени t произойдет отказ программы в результате проявления ошибки в программе;
Интенсивность отказов - условная плотность вероятности времени до возникновения отказа программы при условии, что до момента t отказа не было;
Средняя наработка до отказа - математическое ожидание временного интервала между последовательными отказами.
Наибольшее распространение получили модели, основанные на экспоненциальном характере изменения числа ошибок в зависимости от времени тестирования и функционирования программы.
Экспоненциальная модель надежности основана на предположении об экспоненциальном характере изменения во времени числа ошибок в программе.
В этой модели прогнозируется надежность программы на основе данных, полученных во время тестирования. В модели вводится суммарное время функционирования, которое отсчитывается от момента начала тестирования программы (с устранением обнаруженных ошибок) до контрольного момента, когда производится оценка надежности. Тестирование информационной подсистемы проводится в течение одного месяца (= 168 ч.).
Предполагается, что все ошибки в программе независимы и проявляются в случайные моменты времени с постоянной средней интенсивностью в течение всего времени выполнения программы. Это означает, что число ошибок, имеющихся в программе в данный момент, имеет пуассоновское распределение, а временной интервал между двумя программами распределен по экспоненциальному закону, параметр которого изменяется после исправления ошибки.
Если M - число ошибок, имеющихся в программе перед фазой тестирования (M = 10); m() - конечное число исправленных ошибок, а m 0 () - число оставшихся ошибок, тогда
m 0 () = M - m() (4.4)
При принятых предположениях интенсивность отказов пропорциональна m 0 (), т.е.
где C - коэффициент пропорциональности, учитывающий реальное быстродействие системы и число команд в программе.
Перед началом работы системы (t = 0) ни одна ошибка исправлена не была (= 0), поэтому
Будем характеризовать надежность программы после тестирования в течение времени средним временем наработки на отказ:
Следовательно,
Введем - исходное значение среднего времени наработки на отказ перед тестированием (= 1000 ч.). Тогда
В результате имеем
Очевидно, что среднее время наработки на отказ увеличивается по мере выявления и исправления ошибок.
Расчет надежности разработанной информационной системы показал, что надежность программного обеспечения в несколько раз ниже надежности аппаратуры. Это можно объяснить двумя основными причинами:
В информационной системе используется испытанная аппаратура, прошедшая долговременное тестирование;
На тестирование информационной системы отведено недостаточное время для получения достоверных данных.
Следовательно, увеличение времени тестирования позволит более точно определить основные показатели надежности разработанной системы и увеличить ее надежность.
