LQN2QN.m

function model = LQN2QN(lqn)
% LQN2QN Convert a LayeredNetwork (LQN) to a Network (QN)
%
% model = LQN2QN(lqn) converts a LayeredNetwork model to an equivalent
% ordinary queueing network that approximates LQN blocking semantics.
%
% The conversion models synchronous call blocking by aggregating service
% times: when a task makes a synchCall, its effective service time includes
% both its own processing and all downstream processing (since it blocks
% until the reply is received).
%
% This approach:
% - Correctly models THROUGHPUT (validated against LQNS)
% - Queue lengths are APPROXIMATED (blocking aggregated into entry task)
%
% For accurate queue length distribution across tiers, explicit blocking
% with Reply signals would be required (future enhancement).
%
% Example:
%   lqn = LayeredNetwork('MyLQN');
%   % ... define LQN model ...
%   model = LQN2QN(lqn);
%   SolverDES(model).getAvgTable()
%
% Copyright (c) 2012-2026, Imperial College London
% All rights reserved.
 
%% Get LQN structure
lsn = lqn.getStruct();
 
%% Create QN model
model = Network([lqn.getName(), '-QN']);
 
%% Identify reference tasks
refTaskIndices = find(lsn.isref);
nRefTasks = length(refTaskIndices);
 
if nRefTasks == 0
    line_error(mfilename, 'LQN must have at least one reference task.');
end
 
%% Build call graph and compute effective service times
effectiveService = zeros(1, lsn.ntasks + lsn.tshift);
 
% First pass: get own service times
for t = 1:lsn.ntasks
    tidx = lsn.tshift + t;
    effectiveService(tidx) = getTaskServiceDemand(lsn, tidx);
end
 
% Build downstream map
downstreamTasks = cell(1, lsn.ntasks + lsn.tshift);
for t = 1:lsn.ntasks
    tidx = lsn.tshift + t;
    downstreamTasks{tidx} = [];
 
    entries = lsn.entriesof{tidx};
    for eidx = entries
        acts = lsn.actsof{eidx};
        for aidx = acts
            if lsn.type(aidx) ~= LayeredNetworkElement.ACTIVITY
                continue;
            end
            if aidx > length(lsn.callsof) || isempty(lsn.callsof{aidx})
                continue;
            end
            calls = lsn.callsof{aidx};
            for cidx = calls
                if full(lsn.calltype(cidx)) == CallType.SYNC
                    targetEidx = lsn.callpair(cidx, 2);
                    targetTidx = lsn.parent(targetEidx);
                    downstreamTasks{tidx} = [downstreamTasks{tidx}, targetTidx];
                end
            end
        end
    end
end
 
% Compute effective service times (includes all downstream blocking time)
computed = false(1, lsn.ntasks + lsn.tshift);
for iter = 1:lsn.ntasks
    changed = false;
    for t = 1:lsn.ntasks
        tidx = lsn.tshift + t;
        if computed(tidx)
            continue;
        end
 
        downstream = downstreamTasks{tidx};
        if isempty(downstream)
            computed(tidx) = true;
            changed = true;
        else
            allDownstreamComputed = true;
            for dt = downstream
                if ~computed(dt)
                    allDownstreamComputed = false;
                    break;
                end
            end
 
            if allDownstreamComputed
                for dt = downstream
                    effectiveService(tidx) = effectiveService(tidx) + effectiveService(dt);
                end
                computed(tidx) = true;
                changed = true;
            end
        end
    end
    if ~changed
        break;
    end
end
 
%% Create nodes
procNodes = cell(lsn.nhosts, 1);
thinkNodes = cell(lsn.ntasks, 1);
 
% Find entry tasks for reference tasks
entryTaskForRef = zeros(1, nRefTasks);
for rt = 1:nRefTasks
    tidx = refTaskIndices(rt);
    downstream = downstreamTasks{tidx};
    if ~isempty(downstream)
        entryTaskForRef(rt) = downstream(1);
    end
end
 
% Create processor nodes for entry tasks
for rt = 1:nRefTasks
    entryTidx = entryTaskForRef(rt);
    if entryTidx <= 0
        continue;
    end
 
    procIdx = lsn.parent(entryTidx);
    if isempty(procIdx) || procIdx <= 0 || procIdx > lsn.nhosts || ~isempty(procNodes{procIdx})
        continue;
    end
 
    procName = lsn.names{procIdx};
    nServers = lsn.mult(procIdx);
    sched = lsn.sched(procIdx);
 
    if isinf(nServers) || sched == SchedStrategy.INF
        procNodes{procIdx} = Delay(model, procName);
    else
        procNodes{procIdx} = Queue(model, procName, sched);
        procNodes{procIdx}.setNumberOfServers(nServers);
    end
end
 
% Create think nodes
for rt = 1:nRefTasks
    tidx = refTaskIndices(rt);
    taskName = lsn.names{tidx};
    t = tidx - lsn.tshift;
    thinkNodes{t} = Delay(model, [taskName, '_Think']);
end
 
%% Create job classes and set service times
jobClasses = cell(nRefTasks, 1);
 
for rt = 1:nRefTasks
    tidx = refTaskIndices(rt);
    taskName = lsn.names{tidx};
    t = tidx - lsn.tshift;
    thinkNode = thinkNodes{t};
    N = lsn.mult(tidx);
 
    jobClass = ClosedClass(model, [taskName, '_Job'], N, thinkNode);
    jobClasses{rt} = jobClass;
 
    % Think time
    thinkDist = lsn.think{tidx};
    if isa(thinkDist, 'Immediate') || thinkDist.getMean() < GlobalConstants.FineTol
        thinkDist = Exp(1e8);
    end
    thinkNode.setService(jobClass, thinkDist);
 
    % Effective service at entry task's processor
    entryTidx = entryTaskForRef(rt);
    if entryTidx > 0
        entryProcIdx = lsn.parent(entryTidx);
        if ~isempty(entryProcIdx) && entryProcIdx > 0 && entryProcIdx <= lsn.nhosts && ~isempty(procNodes{entryProcIdx})
            procNode = procNodes{entryProcIdx};
            effService = effectiveService(entryTidx);
 
            if effService > GlobalConstants.FineTol
                procNode.setService(jobClass, Exp(1/effService));
            else
                procNode.setService(jobClass, Immediate());
            end
        end
    end
end
 
%% Build routing matrix
P = model.initRoutingMatrix();
 
for rt = 1:nRefTasks
    tidx = refTaskIndices(rt);
    t = tidx - lsn.tshift;
    thinkNode = thinkNodes{t};
    jobClass = jobClasses{rt};
 
    entryTidx = entryTaskForRef(rt);
    if entryTidx <= 0
        P{jobClass, jobClass}(thinkNode, thinkNode) = 1.0;
        continue;
    end
 
    entryProcIdx = lsn.parent(entryTidx);
    if isempty(entryProcIdx) || entryProcIdx <= 0 || entryProcIdx > lsn.nhosts || isempty(procNodes{entryProcIdx})
        P{jobClass, jobClass}(thinkNode, thinkNode) = 1.0;
        continue;
    end
 
    procNode = procNodes{entryProcIdx};
    P{jobClass, jobClass}(thinkNode, procNode) = 1.0;
    P{jobClass, jobClass}(procNode, thinkNode) = 1.0;
end
 
model.link(P);
 
end
 
%% Helper: Get service demand for a task
function demand = getTaskServiceDemand(lsn, tidx)
    demand = 0;
 
    entries = lsn.entriesof{tidx};
    for eidx = entries
        acts = lsn.actsof{eidx};
        for aidx = acts
            if lsn.type(aidx) == LayeredNetworkElement.ACTIVITY
                hostDem = lsn.hostdem{aidx};
                if isa(hostDem, 'Distribution')
                    demand = demand + hostDem.getMean();
                end
            end
        end
    end
end