refreshLocalVars.m

function nvars = refreshLocalVars(self)
% NVARS = REFRESHLOCALVARS()
 
R = self.getNumberOfClasses;
nvars = zeros(self.getNumberOfNodes, 2*R+1);
nodeparam = cell(self.getNumberOfNodes, 1);
rtnodes = self.sn.rtnodes;
% Draft SPN code:
% isp = [];
% ist = [];
% nodeToPlace = zeros(1, self.getNumberOfNodes);
% nodeToTransition = zeros(1, self.getNumberOfNodes);
% for ind=1:self.getNumberOfNodes
%     node = self.getNodeByIndex(ind);
%     switch class(node)
%     case 'Place'
%         isp = [isp, ind];
%         nodeToPlace(ind) = length(isp);
%     case 'Transition'
%         ist = [ist, ind];
%         nodeToTransition(ind) = length(ist);
%     end
% end
sn = self.sn;
 
for ind=1:self.getNumberOfNodes
    node = self.getNodeByIndex(ind);
    switch class(node)
        case 'Cache'
            nodeparam{ind} = struct();
            nodeparam{ind}.nitems = 0;
            nodeparam{ind}.accost = node.accessProb;
            for r=1:self.getNumberOfClasses
                if length(node.popularity) >= r && isa(node.popularity{r}, 'Distribution') && ~node.popularity{r}.isDisabled
                    nodeparam{ind}.nitems = max(nodeparam{ind}.nitems,node.popularity{r}.support(2));
                end
            end
            % nvars holds the cache state width: cache contents plus, when a retrieval
            % system is configured, a per-item occupancy bitmap (one column per item);
            % otherwise only the cache contents are stored.
            if node.retrievalSystemCapacity > 0
                retrievalBitmapWidth = nodeparam{ind}.nitems;
            else
                retrievalBitmapWidth = 0;
            end
            nvars(ind,2*R+1) = node.totalCacheCapacity + retrievalBitmapWidth;
            nodeparam{ind}.itemcap = node.itemLevelCap;
            nodeparam{ind}.totalCacheCapacity = node.totalCacheCapacity;
            nodeparam{ind}.retrievalSystemCapacity = node.retrievalSystemCapacity;
            nodeparam{ind}.pread = cell(1,self.getNumberOfClasses);
            for r=1:self.getNumberOfClasses
                if length(node.popularity) < r || ~isa(node.popularity{r}, 'Distribution') || node.popularity{r}.isDisabled
                    nodeparam{ind}.pread{r} = NaN;
                else
                    nodeparam{ind}.pread{r} = node.popularity{r}.evalPMF(1:nodeparam{ind}.nitems);
                end
            end
            nodeparam{ind}.replacestrat = node.replacestrategy;
            if isprop(node,'admissionProb') && ~isempty(node.admissionProb)
                nodeparam{ind}.qlru = node.admissionProb;
            else
                nodeparam{ind}.qlru = 1.0;
            end
            % CLIMB is solved as an equivalent FIFO cache with unit-capacity
            % lists: CLIMB on one list of capacity C equals FIFO on C lists of
            % capacity 1 with chain promotion (identity, exact). Rewrite the
            % analyzer inputs here so no bespoke CLIMB discipline is needed.
            if node.replacestrategy == ReplacementStrategy.CLIMB
                Cclimb = sum(nodeparam{ind}.itemcap);
                nodeparam{ind}.itemcap = ones(1, Cclimb);
                nodeparam{ind}.replacestrat = ReplacementStrategy.FIFO;
                chainAc = diag(ones(1,Cclimb),1); chainAc(Cclimb+1,Cclimb+1) = 1;
                Kclimb = self.getNumberOfClasses;
                acClimb = cell(Kclimb, nodeparam{ind}.nitems);
                for vClimb = 1:Kclimb
                    for kClimb = 1:nodeparam{ind}.nitems
                        acClimb{vClimb,kClimb} = chainAc;
                    end
                end
                nodeparam{ind}.accost = acClimb;
            end
            nodeparam{ind}.hitclass = zeros(1,self.getNumberOfClasses);
            nodeparam{ind}.hitclass(1:length(node.server.hitClass)) = round(node.server.hitClass);
            nodeparam{ind}.missclass = zeros(1,self.getNumberOfClasses);
            nodeparam{ind}.missclass(1:length(node.server.missClass)) = round(node.server.missClass);
 
            % retrieval-system class matrix: pad to current class count and -1 outside known entries
            K = self.getNumberOfClasses;
            if isprop(node.server, 'retrievalClasses') && ~isempty(node.server.retrievalClasses)
                rc = -ones(nodeparam{ind}.nitems, K);
                rc(1:size(node.server.retrievalClasses,1), 1:min(size(node.server.retrievalClasses,2),K)) = ...
                    node.server.retrievalClasses(1:size(node.server.retrievalClasses,1), 1:min(size(node.server.retrievalClasses,2),K));
                nodeparam{ind}.retrievalClasses = rc;
            else
                nodeparam{ind}.retrievalClasses = -ones(max(nodeparam{ind}.nitems,1), K);
            end
            nodeparam{ind}.retrievalClassIndices = node.retrievalClassIndices;
            nodeparam{ind}.retrievalSystemQueueIndices = containers.Map('KeyType','int32','ValueType','any');
            keysList = keys(node.retrievalSystemQueueIndices);
            for kk = 1:numel(keysList)
                nodeparam{ind}.retrievalSystemQueueIndices(keysList{kk}) = node.retrievalSystemQueueIndices(keysList{kk});
            end
 
            % Store actual hit/miss/latency from solver results (if available)
            if isprop(node.server, 'actualHitProb') && ~isempty(node.server.actualHitProb)
                nodeparam{ind}.actualhitprob = full(node.server.actualHitProb);
                nodeparam{ind}.actualmissprob = full(node.server.actualMissProb);
            end
            if isprop(node.server, 'actualDelayedHitProb') && ~isempty(node.server.actualDelayedHitProb)
                nodeparam{ind}.actualdelayedhitprob = full(node.server.actualDelayedHitProb);
            end
            if isprop(node.server, 'actualResidT') && ~isempty(node.server.actualResidT)
                nodeparam{ind}.actualresidt = full(node.server.actualResidT);
            end
        case 'Fork'
            nodeparam{ind}.fanOut = node.output.tasksPerLink;
        case 'Join'
            nodeparam{ind}.joinStrategy = node.input.joinStrategy;
            nodeparam{ind}.fanIn = cell(1,self.getNumberOfClasses);
            for r=1:self.getNumberOfClasses
                nodeparam{ind}.fanIn{r} = node.input.joinRequired{r};
            end
        case 'Logger'
            nodeparam{ind}.fileName = node.fileName;
            nodeparam{ind}.filePath = node.filePath;
            nodeparam{ind}.startTime = node.getStartTime;
            nodeparam{ind}.loggerName = node.getLoggerName;
            nodeparam{ind}.timestamp = node.getTimestamp;
            nodeparam{ind}.jobID = node.getJobID;
            nodeparam{ind}.jobClass = node.getJobClass;
            nodeparam{ind}.timeSameClass = node.getTimeSameClass;
            nodeparam{ind}.timeAnyClass = node.getTimeAnyClass;            
        case {'Source'}
            for r=1:self.getNumberOfClasses
                if ~iscell(node.arrivalProcess) || length(node.arrivalProcess) < r || isempty(node.arrivalProcess{r})
                    continue;
                end
                switch class(node.arrivalProcess{r})
                    case {'MAP','MMPP2'} % Markov-modulated: track restart phase (see State.afterEvent ismkvmodclass)
                        nvars(ind,r) = nvars(ind,r) + 1;
                    case {'Replayer', 'Trace'}
                        if isempty(nodeparam{ind})
                            nodeparam{ind} = cell(1,self.getNumberOfClasses);
                        end
                        if isempty(nodeparam{ind}{r})
                            nodeparam{ind}{r} = struct();
                        end
                        nodeparam{ind}{r}.(node.arrivalProcess{r}.params{1}.paramName) = node.arrivalProcess{r}.params{1}.paramValue;
                end
            end
        case {'Queue','QueueingStation','Delay','DelayStation','Transition'}
            for r=1:self.getNumberOfClasses
                switch class(node.server.serviceProcess{r}{3})
                    case {'MAP','MMPP2'} % Markov-modulated: track restart phase (see State.afterEvent ismkvmodclass)
                        nvars(ind,r) = nvars(ind,r) + 1;
                    case {'Replayer', 'Trace'}
                        if isempty(nodeparam{ind})
                            nodeparam{ind} = cell(1,self.getNumberOfClasses);
                        end
                        if isempty(nodeparam{ind}{r})
                            nodeparam{ind}{r} = struct();
                        end
                        nodeparam{ind}{r}.(node.server.serviceProcess{r}{3}.params{1}.paramName) = node.server.serviceProcess{r}{3}.params{1}.paramValue;
                end
                if ~isa(node,'Delay') && ~isa(node,'Transition') && ~isempty(node.setupTime) && ~isempty(node.setupTime{r})
                    if isempty(nodeparam{ind})
                        nodeparam{ind} = cell(1,self.getNumberOfClasses);
                    end
                    if isempty(nodeparam{ind}{r})
                        nodeparam{ind}{r} = struct();
                    end
                    nodeparam{ind}{r}.setupTime = node.setupTime{r}.getProcess();
                    nodeparam{ind}{r}.delayoffTime = node.delayoffTime{r}.getProcess();
                end
                if (isa(node,'Queue') || isa(node,'QueueingStation'))
                    if isempty(nodeparam{ind}) && (~isempty(node.pollingType) || ~isempty(node.switchoverTime))
                        nodeparam{ind} = cell(1,self.getNumberOfClasses);
                        for s=1:self.getNumberOfClasses
                            nodeparam{ind}{s} = struct();
                        end
                    end
                    if ~isempty(node.pollingType) && ~isempty(node.pollingType{r})
                        nodeparam{ind}{r}.pollingType = node.pollingType{r};
                        nodeparam{ind}{r}.pollingPar = node.pollingPar;
                    end
                    if ~isempty(node.switchoverTime) && ~isempty(node.switchoverTime{r})
                        if min(size(node.switchoverTime))==1
                            nodeparam{ind}{r}.switchoverTime = node.switchoverTime{r}.getProcess();
                            nodeparam{ind}{r}.switchoverProcId = ProcessType.toId(ProcessType.fromText(class(node.switchoverTime{r})));
                        else
                            for t=1:length(node.switchoverTime)
                                % A from-to switchover matrix can have empty
                                % cells (e.g. the diagonal, or pairs never set);
                                % treat those as a zero-time (Immediate) switch
                                % rather than dereferencing an empty entry.
                                so_rt = node.switchoverTime{r,t};
                                if isempty(so_rt)
                                    so_rt = Immediate();
                                end
                                nodeparam{ind}{r}.switchoverTime{t} = so_rt.getProcess();
                                nodeparam{ind}{r}.switchoverProcId(t) = ProcessType.toId(ProcessType.fromText(class(so_rt)));
                            end
                        end
                    end
                end
            end
            % Pass-and-swap (PAS) queues carry a node-level class
            % compatibility/swap graph rather than per-class parameters.
            if (isa(node,'Queue') || isa(node,'QueueingStation')) && ...
                    (SchedStrategy.toId(node.schedStrategy) == SchedStrategy.PAS || ...
                     SchedStrategy.toId(node.schedStrategy) == SchedStrategy.OI)
                if isempty(nodeparam{ind})
                    nodeparam{ind} = struct();
                end
                if SchedStrategy.toId(node.schedStrategy) == SchedStrategy.OI
                    % Order-independent queue: swap graph is always zero (empty),
                    % so class order is preserved on completion (plain OI).
                    nodeparam{ind}.swapGraph = zeros(R,R);
                elseif isempty(node.swapGraph)
                    % PAS default: complete compatibility graph (any class may
                    % swap with any other; no self-loops) when none was set.
                    nodeparam{ind}.swapGraph = ones(R,R) - eye(R);
                else
                    nodeparam{ind}.swapGraph = node.swapGraph;
                end
                % Total service rate function mu(c) of the ordered state vector c.
                nodeparam{ind}.svcRateFun = node.svcRateFun;
            end
    end
 
    for r=1:R
        switch sn.routing(ind,r)
            case RoutingStrategy.KCHOICES
                nodeparam{ind}{r}.k = node.output.outputStrategy{r}{3}{1};
                nodeparam{ind}{r}.withMemory = node.output.outputStrategy{r}{3}{2};
                if nodeparam{ind}{r}.withMemory
                    % Reserve a state slot per class to record the last
                    % selected destination so sub_kchoices can replicate the
                    % "Power-of-K with memory" semantics (Mitzenmacher 2002).
                    nvars(ind, R+r) = nvars(ind, R+r) + 1;
                end
            case RoutingStrategy.WRROBIN
                nvars(ind,R+r) = nvars(ind,R+r) + 1;
                % save indexes of outgoing links
                if isempty(nodeparam) || isempty(nodeparam{ind}) % reinstantiate if not a cache
                    nodeparam{ind}{r} = struct();
                end
                nodeparam{ind}{r}.weights = zeros(1,self.sn.nnodes);
                nodeparam{ind}{r}.outlinks = find(self.sn.connmatrix(ind,:));
                for c=1:size(node.output.outputStrategy{1, r}{3},2)
                    destination = node.output.outputStrategy{1, r}{3}{c}{1};
                    weight = node.output.outputStrategy{1, r}{3}{c}{2};
                    nodeparam{ind}{r}.weights(destination.index) = weight;
                end
                % Build the WRR cycle by replicating each outlink by its weight.
                % afterEventRouter walks this list one position per DEP. With
                % unit weights this collapses to ordinary RR.
                cycle = [];
                for ol = nodeparam{ind}{r}.outlinks
                    w = nodeparam{ind}{r}.weights(ol);
                    if w > 0
                        cycle = [cycle, repmat(ol, 1, max(1, round(w)))]; %#ok<AGROW>
                    else
                        cycle = [cycle, ol]; %#ok<AGROW>
                    end
                end
                nodeparam{ind}{r}.weighted_outlinks = cycle;
            case RoutingStrategy.RROBIN
                nvars(ind,R+r) = nvars(ind,R+r) + 1;
                % save indexes of outgoing links
                if isempty(nodeparam) || isempty(nodeparam{ind}) % reinstantiate if not a cache
                    nodeparam{ind}{r} = struct();
                end
                nodeparam{ind}{r}.outlinks = find(self.sn.connmatrix(ind,:));
        end
    end
end
 
% True BAS: a station using Blocking-After-Service holds a completed job at its server
% (blocked) until the downstream has room. Reserve one local state variable (nvars col
% 2*R+1, otherwise used only by Cache) as the per-station blocked marker; it is
% enumerated {0,1} in State.fromMarginal and driven by afterEventStation
% (DEP-to-full-dest -> blocked; a blocked front job departs at rate 1e7 once the
% destination has room). A station is either POLLING or BAS-FCFS, never both, so this
% shares nvars col 2*R+1 with the polling controller below without collision.
%
% A station needs the marker when it can BE BLOCKED, and blocking is caused by the
% DESTINATION being full, not by this station's own capacity. Testing this station's
% own capacity (as this did) silently downgraded the canonical BAS shape -- upstream
% unbounded, downstream finite -- to repetitive service, and made a NON-binding
% capacity on the upstream change the answer by 29%. So the test is reachability: is
% there a directly reachable destination station with a finite capacity, for which BAS
% is declared HERE, on the station that does the blocking? (That is the convention of
% examples/basic/closedQN/cqn_bas_blocking.m.) The marker column is shared with the
% polling controller and the cache width, so State.fromMarginal disambiguates it by
% re-testing this station's own BAS rule; declaration and enumeration must therefore
% agree on that same test, which is why a destination-declared BAS (the JMT
% convention, testsAdvFeatures/des/test_des_bas_closed.m) is NOT honoured here -- see
% BUG-83. Mirrors Network.declaresBlockedMarker in the JAR.
% sn.isbasblocking(ind) records the true-BAS blocking relation EXPLICITLY, instead
% of overloading it onto the shared marker column nvars(:,2*R+1) (which also holds
% the polling controller and the cache width). Enumeration (State.fromMarginal) and
% the become-blocked edge (solver_ctmc) gate on this field rather than re-testing the
% station's own drop rule, so declaration and enumeration agree for BOTH the upstream
% and the destination declaration forms. Node-indexed (nnodes,1), default 0.
isbasblocking = zeros(self.getNumberOfNodes, 1);
for ind=1:self.getNumberOfNodes
    node = self.getNodeByIndex(ind);
    if isa(node,'Station') && ~isa(node,'Source') && ~isa(node,'Cache')
        if declaresBlockedMarker(self, ind, R)
            % Option B (BUG-83): the marker column is shared with the polling
            % controller, and a station cannot carry both. A polling station that is
            % also a BAS blocking station is rejected cleanly here, before the state
            % space is built, rather than corrupting the shared column and failing
            % later in State validation.
            if self.sn.sched(self.sn.nodeToStation(ind)) == SchedStrategy.POLLING
                line_error(mfilename, sprintf(['True BAS blocking is not supported at a polling station (%s): the ', ...
                    'polling controller and the BAS blocked marker share one local-state column. Use a non-polling ', ...
                    'scheduling strategy at the blocking station, or remove the BAS drop rule.'], self.sn.nodenames{ind}));
            end
            nvars(ind, 2*R+1) = 1;
            isbasblocking(ind) = 1;
        end
    end
end
 
% Polling stations carry a controller (server position, switchover phase, visit
% budget) in the trailing local-variable block. Its width depends on the
% discipline and on which switchovers are non-immediate, so it is sized here,
% after nodeparam has been fully populated above. State.pollingInfo derives the
% width from the same nodeparam fields and is the single definition of the
% block layout; it needs sn.nodeparam/sn.sched, hence the temporary write-back.
if ~isempty(self.sn)
    self.sn.nvars = nvars;
    self.sn.nodeparam = nodeparam;
    for ind=1:self.getNumberOfNodes
        if self.sn.isstation(ind) && self.sn.sched(self.sn.nodeToStation(ind)) == SchedStrategy.POLLING
            pinfo = State.pollingInfo(self.sn, ind);
            nvars(ind, 2*R+1) = pinfo.width;
            % memoize: State.pollingInfo is read once per state per
            % synchronization while the generator is built
            nodeparam{ind}{1}.pollinfo = pinfo;
            self.sn.nodeparam = nodeparam;
        end
    end
    self.sn.nvars = nvars;
    self.sn.isbasblocking = isbasblocking;
end
end
 
function tf = declaresBlockedMarker(self, ind, R)
% TF = DECLARESBLOCKEDMARKER(SELF, IND, R)
%
% True when station IND is the BLOCKING (upstream) side of a true-BAS relation:
% it has a directly reachable destination station with a finite capacity, and
% BAS is declared EITHER on this station (upstream form, cqn_bas_blocking.m) OR
% on that destination (destination form, the JMT/LDES convention used by
% test_des_bas_closed.m; canonical since BUG-83). Both forms resolve to the same
% blocking station -- the held job sits here and the become-blocked edge starts
% here -- so the marker always lives on the upstream station. Whether the caller
% keys enumeration on the station's own drop rule (which fails for the
% destination form) or on the dedicated sn.isbasblocking field is what BUG-83
% fixes. Mirrors Network.declaresBlockedMarker in the JAR.
tf = false;
node = self.getNodeByIndex(ind);
dests = downstreamStations(self, ind);
for r = 1:R
    hereBAS = length(node.dropRule) >= r && node.dropRule(r) == DropStrategy.BAS;
    for d = 1:length(dests)
        dnode = self.getNodeByIndex(dests(d));
        if ~isa(dnode,'Station') || isa(dnode,'Source')
            continue
        end
        dcap = dnode.cap;
        if isempty(dcap) || ~isfinite(dcap) || dcap <= 0
            continue % the destination must be able to fill
        end
        thereBAS = length(dnode.dropRule) >= r && dnode.dropRule(r) == DropStrategy.BAS;
        if hereBAS || thereBAS
            tf = true; % BAS declared upstream or on the reachable full destination
            return
        end
    end
end
end
 
function out = downstreamStations(self, ind)
% OUT = DOWNSTREAMSTATIONS(SELF, IND)
%
% Node indices of the stations directly downstream of IND, walking through
% intermediate stateless nodes (Router, ClassSwitch, ...) but stopping at the first
% station on each path, since a blocked job is held for its immediate destination.
out = [];
conn = self.sn.connmatrix;
if isempty(conn)
    return
end
n = self.getNumberOfNodes;
seen = false(1,n);
queue = ind;
seen(ind) = true;
while ~isempty(queue)
    cur = queue(1); queue(1) = [];
    for j = 1:min(n, size(conn,2))
        if conn(cur,j) ~= 1 || seen(j)
            continue
        end
        seen(j) = true;
        if isa(self.getNodeByIndex(j),'Station')
            out(end+1) = j; %#ok<AGROW>
        else
            queue(end+1) = j; %#ok<AGROW>
        end
    end
end
end