delay_schemeab.m

L. Dong and A. P. Petropulu, 揗ultichannel ALLIANCES: A Cross-layer Cooperative Scheme for Wireless

% Schemes A and B
% delay under Poisson Traffic

clear all
close all
G=4; %number of subchannels

M=2000; % total simulation slots 
J=32;   % number of users
simurange=20; % nuber of points of Traffic

BufSize = M; 
num_trial=2; % number of Monto-Carlo experiments
avg_delay1=zeros(1,simurange); % scheme B
avg_delay2=zeros(1,simurange);  % scheme A
avg_delay=zeros(1,simurange);   % lower bound (TDMA)
for ss=1:num_trial
    ss
    
    % generate the traffic
    [Traffic,WorkLoad] = gen_traffic(M, J, simurange);
    
    for ii = 1:simurange
        sm_traffic = G*Traffic(:,:,ii); % Generate new traffic
        Loads = zeros(1,J); 
        
        flag=zeros(1,J);
        time_table=zeros(J,(M+J)*G);
        time_table1=zeros(J,(M+J)*G);
        time_table2=zeros(J,(M+J)*G);
        
        % positions of packets in time axix
        pos_pack=zeros(J,(M+J)*G);
        for nn=1:J
            temp=find(Traffic(nn,:,ii)>=1);
            for mm=1:G
                pos_pack(nn,mm:G:G*(length(temp)-1)+mm)=temp;
            end
        end
        count_pack=0;
        flag_CTE=0;
        
        for t1 = 1:M
            newLoads = sm_traffic(:,t1)'; % new traffic
            Loads = Loads + newLoads; % new traffic added to buffer
            
            flag_CTE=max(0,flag_CTE-1);
            
            if  flag_CTE==0
                
                Trans=Loads>0;
                num_active=sum(Trans);
                active = find(Trans)';
                
                if   num_active>0 
                    
                    flag_CTE=num_active;
                    ret_array = zeros(1,J);
                    ret_array(active)=G;
                    Loads = Loads - ret_array;
                    count_pack=count_pack+num_active*G;
                    TDMA=randperm(num_active);
                    for kk=1:num_active
                        
                        for uu=1:G
                            flag(active(kk))=flag(active(kk))+1;
                            t_gen=pos_pack(active(kk),flag(active(kk)));
                            time_table(active(kk),flag(active(kk)))=1+ceil(uu*(num_active-1)/G)+t1-t_gen; % scheme B
                            time_table1(active(kk),flag(active(kk)))=num_active+t1-t_gen; % scheme A
                            time_table2(active(kk),flag(active(kk)))=TDMA(kk)+t1-t_gen; % lower bound
                        end
                    end
                end
                
            end
            
        end
        
        if count_pack>0
            avg_delay1(ii)=avg_delay1(ii)+sum(sum(time_table1))/count_pack;
            avg_delay2(ii)=avg_delay2(ii)+sum(sum(time_table2))/count_pack;
            avg_delay(ii)=avg_delay(ii)+sum(sum(time_table))/count_pack;
        end
        
        
    end
end
WorkLoad=[0:simurange-1]/simurange+0.01;
figure
hold on
plot(WorkLoad,avg_delay/num_trial,'k-','linewidth',2)
plot(WorkLoad,avg_delay1/num_trial,'k-.','linewidth',2)
plot(WorkLoad,avg_delay2/num_trial,'k--','linewidth',2)
legend('Scheme B','Scheme A','Lower Bound')