Homec4science
Diffusion EMPoWER (master) Browse

R1252/simulation-code/transfer_data.m
de096106547amaster

Last Change
Raw File

transfer_data.m
View Options

function [ queues, data_arrived, data_flows, used_times] = ...
transfer_data( queues, data_arrived, data_flows, routes, numInterfaces, size_slot_mp, times, interfaces_ind, neighborCapacityMat, links, contLinks_mat)
global epsilon;
global stop;
used_times = zeros(1,length(links));
queues_to_transmit = [];
for trans=1:numInterfaces
if ~isempty(queues{trans})
trans_queues = find(queues{trans}(:,3) > 0.1);
for j=1:length(trans_queues)
queue_trans = trans_queues(j);
flow = queues{trans}(queue_trans,1);
nPath = queues{trans}(queue_trans,2);
route = routes{1,flow}{nPath};
next_int = route(find(route == trans) + 1);
link = sub2ind(size(neighborCapacityMat), trans, next_int);
if ~any(links == link)
link = sub2ind(size(neighborCapacityMat), next_int, trans);
end
queues_to_transmit = [queues_to_transmit,[trans;queue_trans;find(links==link);1]];
end
end
end
transmit_time = 0;
while transmit_time <= (size_slot_mp - epsilon) && ~isempty(queues_to_transmit)
max_time = size_slot_mp/4;
ind_transmitting_queue = [];
while any(queues_to_transmit(4,:) == 1)
queues_can_transmit = find(queues_to_transmit(4,:) == 1);
ind_transmitting_queue = [ind_transmitting_queue, queues_can_transmit(ceil(rand*length(queues_can_transmit)))];
queues_to_transmit(4,ismember(queues_to_transmit(3,:), find(contLinks_mat(queues_to_transmit(3,ind_transmitting_queue(end)),:) == 1))) = 0;
max_time = min(max_time, queues{queues_to_transmit(1,ind_transmitting_queue(end))}(queues_to_transmit(2,ind_transmitting_queue(end)),3)...
/neighborCapacityMat(links(queues_to_transmit(3,ind_transmitting_queue(end)))));
end
used_time = min(max_time, (size_slot_mp - transmit_time));
queues_to_delete = zeros(1,size(queues_to_transmit,2));
for i=1:length(ind_transmitting_queue)
ind_queue = ind_transmitting_queue(i);
trans = queues_to_transmit(1,ind_queue);
queue_trans = queues_to_transmit(2,ind_queue);
flow = queues{trans}(queue_trans,1);
nPath = queues{trans}(queue_trans,2);
route = routes{1,flow}{nPath};
next_int = route(find(route == trans) + 1);
link = links(queues_to_transmit(3,ind_queue));
assert (sub2ind(size(neighborCapacityMat), next_int, trans) == link || sub2ind(size(neighborCapacityMat), trans, next_int) == link)
data_to_trans = neighborCapacityMat(link)*used_time;
queues{trans}(queue_trans,3) = queues{trans}(queue_trans,3) - data_to_trans;
if next_int == route(end)
data_arrived(times,flow) = data_arrived(times,flow) + data_to_trans/length(times);
data_flows(times, flow, nPath) = data_flows(times, flow, nPath) + data_to_trans/length(times);
else
next_next_int = route(find(route == trans) + 2);
if interfacesSameNode(next_int, next_next_int, interfaces_ind)
int_to_trans = next_next_int;
else
int_to_trans = next_int;
end
ind_new_queue = find(queues{int_to_trans}(:,1) == flow & queues{int_to_trans}(:,2) == nPath);
queues{int_to_trans}(ind_new_queue,3) = queues{int_to_trans}(ind_new_queue,3) + data_to_trans;
if ~any((queues_to_transmit(1,:) == int_to_trans) & (queues_to_transmit(2,:) == ind_new_queue))
new_link = sub2ind(size(neighborCapacityMat), int_to_trans, route(find(route == int_to_trans) + 1));
if ~any(links == new_link)
new_link = sub2ind(size(neighborCapacityMat), route(find(route == int_to_trans) + 1), int_to_trans);
end
end
end
used_times(queues_to_transmit(3,ind_queue)) = used_times(queues_to_transmit(3,ind_queue)) + used_time;
end
for i=1:length(ind_transmitting_queue)
ind_queue = ind_transmitting_queue(i);
trans = queues_to_transmit(1,ind_queue);
queue_trans = queues_to_transmit(2,ind_queue);
if queues{trans}(queue_trans,3) < 0.1
queues_to_delete(ind_queue) = 1;
end
end
queues_to_transmit(:,queues_to_delete == 1) = [];
queues_to_transmit(4,:) = 1;
transmit_time = transmit_time + used_time;
end
%
% time_to_transmit = zeros(1,numInterfaces);
% time_to_receive = zeros(1,numInterfaces);
% for i=1:numInterfaces
% if ~isempty(queues{i}) && any(queues{i}(:,3) > epsilon)
% time_to_transmit(i) = 0;
% else
% time_to_transmit(i) = size_slot_mp;
% end
% end
% wants_to_transmit=find(time_to_transmit < (size_slot_mp - epsilon));
% can_receive = find(time_to_receive < (size_slot_mp - epsilon));
%
% while ~isempty(wants_to_transmit)
% trans = wants_to_transmit(ceil(rand*length(wants_to_transmit)));
% non_empty_queues = find(queues{trans}(:,3) > epsilon & ismember(queues{trans}(:,4), can_receive));
% if ~isempty(non_empty_queues)
% queue_trans = non_empty_queues(ceil(rand*length(non_empty_queues)));
% flow = queues{trans}(queue_trans,1);
% nPath = queues{trans}(queue_trans,2);
% route = routes{1,flow}{nPath};
% next_int = route(find(route == trans) + 1);
% link = sub2ind(size(neighborCapacityMat), trans, next_int);
% if ~any(links == link)
% link = sub2ind(size(neighborCapacityMat), next_int, trans);
% end
% data_to_trans = min([(neighborCapacityMat(link)/3)*size_slot_mp,...
% (size_slot_mp-max(time_to_transmit(trans), time_to_receive(next_int)))*neighborCapacityMat(link), queues{trans}(queue_trans,3)]);
% used_time = data_to_trans/neighborCapacityMat(link);
% queues{trans}(queue_trans,3) = queues{trans}(queue_trans,3) - data_to_trans;
% if next_int == route(end)
% data_arrived(times,flow) = data_arrived(times,flow) + data_to_trans/length(times);
% data_flows(times, flow, nPath) = data_flows(times, flow, nPath) + data_to_trans/length(times);
% else
% next_next_int = route(find(route == trans) + 2);
% if interfacesSameNode(next_int, next_next_int, interfaces_ind)
% queues{next_next_int}(queues{next_next_int}(:,1) == flow & queues{next_next_int}(:,2) == nPath,3) = ...
% queues{next_next_int}(queues{next_next_int}(:,1) == flow & queues{next_next_int}(:,2) == nPath,3) + data_to_trans;
% else
% queues{next_int}(queues{next_int}(:,1) == flow & queues{next_int}(:,2) == nPath,3) = ...
% queues{next_int}(queues{next_int}(:,1) == flow & queues{next_int}(:,2) == nPath,3) + data_to_trans;
% end
% end
% non_empty_queues = find(queues{trans}(:,3) > epsilon, 1);
% if isempty(non_empty_queues)
% time_to_transmit(trans) = size_slot_mp;
% end
% neighbouring_nodes = whoCannotTransmit(trans, next_int, neighborCapacityMat > 0, contLinks_mat, links);
% time_to_transmit(neighbouring_nodes) = time_to_transmit(neighbouring_nodes) + used_time;
% time_to_receive(neighbouring_nodes) = time_to_receive(neighbouring_nodes) + used_time;
% wants_to_transmit=find(time_to_transmit < (size_slot_mp - epsilon));
% can_receive = find(time_to_receive < (size_slot_mp - epsilon));
% else
% time_to_transmit(trans) = time_to_transmit(trans) + size_slot_mp;
% wants_to_transmit=find(time_to_transmit < (size_slot_mp - epsilon));
% end
% end
end
c4science · Help