%*******************************************************************
% Simulation for Adaptive Voters Explanied In the "Adaptive Fault Masking With
% Incoherence Scoring".
% It runs 5MR test scenario for Falut Masking Algorithms supporting
% 16 bit Full Adder modules.
%
% Programmer: B. Baykant ALAGZ
% Ver.1.0 date: 07.2008
%******************************************************************
clear
% Simulation presetings.
NumberOfBitAtInputs=16; % Numbers of bits in each input
TestNumber=10000; % Number of input processed by system.
TestGrupNumber=6; % Number of test sessions in the test scenario
% Adaptive voter with inchorence scoring regulation parameter
Alfa=0.1;
Beta=0.3;
BetaDynamic=0.3;
AlfaDynamic=0.1;
%Fault status of 5 modules (n1,n2,n3,n4,n5) to 5MR test scenario
n1=1; % 1: Faulty modules 0: Fault free modules
n2=0; % 1: Faulty modules 0: Fault free modules
n3=0; % 1: Faulty modules 0: Fault free modules
n4=0; % 1: Faulty modules 0: Fault free modules
n5=0; % 1: Faulty modules 0: Fault free modules
% Inchorence History Rs declerations for 5 modules
Rs=[0 0 0 0 0];
Rsb=[0 0 0 0 0];
RsbDynamic=[0 0 0 0 0];
% Adaptive Majority Voter declerations for 5 modules
H=[0 0 0 0 0];
% Consensus thresholds for majority voters.
aIc=3;
aMaj=3;
% Reseting statistical variables
IncorrectAdaptIncScore=zeros(TestGrupNumber,1);
IncorrectAdaptMaj=zeros(TestGrupNumber,1);
IncorrectConMaj=zeros(TestGrupNumber,1);
IncorrectModule1=zeros(TestGrupNumber,1);
IncorrectModule2=zeros(TestGrupNumber,1);
IncorrectModule3=zeros(TestGrupNumber,1);
IncorrectModule4=zeros(TestGrupNumber,1);
IncorrectModule5=zeros(TestGrupNumber,1);
IncorrectAdaptIncScoreBitByBit=zeros(TestGrupNumber,1);
IncorrectConMajBitByBit=zeros(TestGrupNumber,1);
IncorrectAdaptIncScoreBitByBitDynamic=zeros(TestGrupNumber,1);
for j=1:TestGrupNumber
% Test test sessions in the test senario 5MR
if j==1
n1=0;%0: Fault fress modules
n2=0;%0: Fault fress modules
n3=0;%0: Fault fress modules
n4=0;%0: Fault fress modules
n5=0;%0: Fault fress modules
% (NNNNN)
elseif j==2
n1=1;%1: Faulty modules
n2=0;%0: Fault fress modules
n3=0;%0: Fault fress modules
n4=0;%0: Fault fress modules
n5=0;%0: Fault fress modules
% (FNNNN)
elseif j==3
n1=1;%1: Faulty modules
n2=1;%1: Faulty modules
n3=0;%0: Fault fress modules
n4=0;%0: Fault fress modules
n5=0;%0: Fault fress modules
% (FFNNN)
elseif j==4
n1=1;%1: Faulty modules
n2=1;%1: Faulty modules
n3=1;%1: Faulty modules
n4=0;%0: Fault fress modules
n5=0;%0: Fault fress modules
% (FFFNN)
elseif j==5
n1=1;%1: Faulty modules
n2=1;%1: Faulty modules
n3=1;%1: Faulty modules
n4=1;%1: Faulty modules
n5=0;%0: Fault fress modules
% (FFFFN)
elseif j==6
n1=1;%1: Faulty modules
n2=1;%1: Faulty modules
n3=1;%1: Faulty modules
n4=1;%1: Faulty modules
n5=1;%1: Faulty modules
% (FFFFF)
end
fprintf('Test Seassion: %d \n',j);
% TestNumber inputs applied to system to calculate correct results
for i=1:TestNumber
%Random input generation process
a(i)=round(65536*rand);
b(i)=round(65536*rand);
for k=1:NumberOfBitAtInputs
Ab(k)=bitget(a(i),k);
Bb(k)=bitget(b(i),k);
end
% Random input vectors are applied to healty full adder
[Sc Cc]=fullAdder16(Ab,Bb,0,0);
% Random input vectors are applied to tested modules
[S1 C1]=fullAdder16F1(Ab,Bb,0,n1);
[S2 C2]=fullAdder16F2(Ab,Bb,0,n2);
[S3 C3]=fullAdder16F3(Ab,Bb,0,n3);
[S4 C4]=fullAdder16F4(Ab,Bb,0,n4);
[S5 C5]=fullAdder16F5(Ab,Bb,0,n5);
% Adaptive voters:
% Adaptive Voter with incoherence scoring using Majority Grouping Vm technique (Word Votering)described in Reference [12] and
% in the paper (page:4 Title:Majority Voter Using Distance Metric)
[AdapVoterIncScoOutput,ConMajVoterOutput,Is,Rs]=AdaptiveVoterIncScoNBit(S1,S2,S3,S4,S5,Rs,Beta,Alfa,aIc);
% Adaptive Majority Voter with incoherence scoring using bit by bit
% voting desribed in Figure 6 in the paper.
[AdapVoterIncScoOutputBitByBit,ConMajVoterOutputBitByBit,Isb,Rsb]=AdaptiveVoterIncScoNBitMajBit(S1,S2,S3,S4,S5,Rsb,Beta,Alfa);
% Adaptive Majority Voter in described in Reference [12]
[AdapVoterMajOutput,H,NoResult(i)]=AdaptiveVoterOlderNBit(S1,S2,S3,S4,S5,H,aMaj);
% Dynamic Adaptive Majority Voter with incoherence scoring using bit by bit
% voting desribed in Figure 6 in the paper.
[AdapVoterIncScoOutputBitByBitDynamic,ConMajVoterOutputBitByBit,Isb,RsbDynamic]=AdaptiveVoterIncScoNBitMajBit(S1,S2,S3,S4,S5,RsbDynamic,BetaDynamic,AlfaDynamic);
%Dynamic regulation parameter setting
% Vth threshold for diagnostic.
Vth=0.0010;
% When AllFaultyIndicator variable is true, it indicates
% that all redundant modules diagnosed as faulty.
AllFaultyIndicator=(RsbDynamic(1)>Vth)&(RsbDynamic(2)>Vth)&(RsbDynamic(3)>Vth)&(RsbDynamic(4)>Vth)&(RsbDynamic(5)>Vth);
if AllFaultyIndicator==0
BetaDynamic=0.3;
AlfaDynamic=0.1;
else
BetaDynamic=0.8;
AlfaDynamic=0.1;
end
BHist(i)=BetaDynamic;
AHist(i)=AlfaDynamic;
% Calculating and storing incorrect results for modules and voters
IncorrectAdaptIncScore(j)=IncorrectAdaptIncScore(j)+sign(HammingDist(AdapVoterIncScoOutput,Sc));
IncorrectAdaptMaj(j)=IncorrectAdaptMaj(j)+sign(HammingDist(AdapVoterMajOutput,Sc));
IncorrectConMaj(j)=IncorrectConMaj(j)+sign(HammingDist(ConMajVoterOutput,Sc));
IncorrectAdaptIncScoreBitByBit(j)=IncorrectAdaptIncScoreBitByBit(j)+sign(HammingDist(AdapVoterIncScoOutputBitByBit,Sc));
IncorrectConMajBitByBit(j)=IncorrectConMajBitByBit(j)+sign(HammingDist(ConMajVoterOutputBitByBit,Sc));
IncorrectAdaptIncScoreBitByBitDynamic(j)=IncorrectAdaptIncScoreBitByBitDynamic(j)+sign(HammingDist(AdapVoterIncScoOutputBitByBitDynamic,Sc));
IncorrectModule1(j)=IncorrectModule1(j)+sign(HammingDist(S1,Sc));
IncorrectModule2(j)=IncorrectModule2(j)+sign(HammingDist(S2,Sc));
IncorrectModule3(j)=IncorrectModule3(j)+sign(HammingDist(S3,Sc));
IncorrectModule4(j)=IncorrectModule4(j)+sign(HammingDist(S4,Sc));
IncorrectModule5(j)=IncorrectModule5(j)+sign(HammingDist(S5,Sc));
%Incorrectfark=Incorrectfark+sign(HammingDist(ConMajVoterOutput,AdaptiveVoterOutputOld));
end
% Calculating availabilities for modules and voters
AvailabilityAdaptIncScore(j)=(TestNumber-IncorrectAdaptIncScore(j))/TestNumber;
AvailabilityAdaptMaj(j)=(TestNumber-IncorrectAdaptMaj(j))/TestNumber;
AvailabilityConMaj(j)=(TestNumber-IncorrectConMaj(j))/TestNumber;
AvailabilityAdaptIncScoreBitByBit(j)=(TestNumber-IncorrectAdaptIncScoreBitByBit(j))/TestNumber;
AvailabilityConMajBitByBit(j)=(TestNumber-IncorrectConMajBitByBit(j))/TestNumber;
AvailabilityAdaptIncScoreBitByBitDynamic(j)=(TestNumber-IncorrectAdaptIncScoreBitByBitDynamic(j))/TestNumber;
AvailabilityModule1(j)=(TestNumber-IncorrectModule1(j))/TestNumber;
AvailabilityModule2(j)=(TestNumber-IncorrectModule2(j))/TestNumber;
AvailabilityModule3(j)=(TestNumber-IncorrectModule3(j))/TestNumber;
AvailabilityModule4(j)=(TestNumber-IncorrectModule4(j))/TestNumber;
AvailabilityModule5(j)=(TestNumber-IncorrectModule5(j))/TestNumber;
end
% Reporting when the simulation completed.
disp('--------AVERAGE AVAILABILITY---------')
fprintf('Average availability of the Incoherence Scoring with Word Voting: %f\n',mean(AvailabilityAdaptIncScore));
fprintf('Average availability of the Adaptive Majority Word Voter: %f\n',mean(AvailabilityAdaptMaj));
fprintf('Average availability of the Conventional Word Voter: %f\n',mean(AvailabilityConMaj));
fprintf('Average availability of the Incoherence Scoring with Bit By Bit Voter: %f\n',mean(AvailabilityAdaptIncScoreBitByBit));
fprintf('Average availability of the Conventional Bit By Bit Voter: %f\n',mean(AvailabilityConMajBitByBit));
fprintf('Average availability of the Dynamic Incoherence Scoring with Bit By Bit Voter: %f\n',mean(AvailabilityAdaptIncScoreBitByBitDynamic));
fprintf('Average availability of the Redundant Module 1: %f\n',mean(AvailabilityModule1));
fprintf('Average availability of the Redundant Module 2: %f\n',mean(AvailabilityModule2));
fprintf('Average availability of the Redundant Module 3: %f\n',mean(AvailabilityModule3));
fprintf('Average availability of the Redundant Module 4: %f\n',mean(AvailabilityModule4));
fprintf('Average availability of the Redundant Module 5: %f\n',mean(AvailabilityModule5));
disp('--------AVERAGE ERROR NUMBERS---------')
fprintf('Incorrect Output of the Incoherence Scoring with Word Voting: %f\n',mean(IncorrectAdaptIncScore));
fprintf('Incorrect Output of the Adaptive Majority Word Voter: %f\n',mean(IncorrectAdaptMaj));
fprintf('Incorrect Output of the Conventional Word Voter: %f\n',mean(IncorrectConMaj));
fprintf('Incorrect Output of the Incoherence Scoring with Bit By Bit Voter: %f\n',mean(IncorrectAdaptIncScoreBitByBit));
fprintf('Incorrect Output of the Conventional Bit By Bit Voter: %f\n',mean(IncorrectConMajBitByBit));
fprintf('Incorrect Output of the Dynamic Incoherence Scoring with Bit By Bit Voter: %f\n',mean(IncorrectAdaptIncScoreBitByBitDynamic));
fprintf('Incorrect Output of the Redundant Module 1: %f\n',mean(IncorrectModule1));
fprintf('Incorrect Output of the Redundant Module 2: %f\n',mean(IncorrectModule2));
fprintf('Incorrect Output of the Redundant Module 3: %f\n',mean(IncorrectModule3));
fprintf('Incorrect Output of the Redundant Module 4: %f\n',mean(IncorrectModule4));
fprintf('Incorrect Output of the Redundant Module 5: %f\n',mean(IncorrectModule5));
fprintf('AVAILABILITY REPORT FOR TEST SESSIONS \n');
for j=1:TestGrupNumber
fprintf('TEST SESSIONS: %d \n',j);
fprintf('------------------------------ \n');
fprintf('Availability of the Incoherence Scoring with Word Voting: : %d \n',AvailabilityAdaptIncScore(j));
fprintf('Availability of the Adaptive Majority Word Voter: %d \n',AvailabilityAdaptMaj(j));
fprintf('Availability of the Conventional Word Voter: %d \n',AvailabilityConMaj(j));
fprintf('Availability of the Incoherence Scoring with Bit By Bit Voter: %d \n',AvailabilityAdaptIncScoreBitByBit(j));
fprintf('Availability of the Conventional Bit By Bit Voter:: %d \n',AvailabilityConMajBitByBit(j));
fprintf('Availability of the Dynamic Incoherence Scoring with Bit By Bit Voter: %d \n',AvailabilityAdaptIncScoreBitByBitDynamic(j));
fprintf('Availability of the Redundant Module 1: %f\n',AvailabilityModule1(j));
fprintf('Availability of the Redundant Module 2: %f\n',AvailabilityModule2(j));
fprintf('Availability of the Redundant Module 3: %f\n',AvailabilityModule3(j));
fprintf('Availability of the Redundant Module 4: %f\n',AvailabilityModule4(j));
fprintf('Availability of the Redundant Module 5: %f\n',AvailabilityModule5(j));
fprintf('********************************************************************* \n');
end
