Reduce Memory Footprint Using Shared Lookup Tables

sharedLUTGroups = findSharedInputLUTGroups("IPMSMTorqueWithVariant")

groupToOptimize = sharedLUTGroups.Blocks{1}

problem = FunctionApproximation.Problem(groupToOptimize)

problem.Options.BreakpointSpecification = "EvenSpacing";
problem.Options.Interpolation = "Linear";
problem.Options.WordLengths = 32;

problem.Options.AbsTol = 1e-2;
problem.Options.RelTol = 5e-3;

doOptimization = false;
if doOptimization
    solution = solve(problem);
    save("solution.mat","solution")
else
    load("solution.mat","solution")
end

solution.displayFeasibleSolutions

fprintf("Original: %d bits | Optimized: %d bits | Reduction: %.2f%%\n", ...
    sharedLUTGroups.TotalBits(1), totalMemoryUsage(solution, "bits"), solution.PercentReduction);

populateOptimizedVariant(solution);

simIn = Simulink.SimulationInput("IPMSMTorqueWithVariant");
simOrig = sim(simIn.setVariable("useOptimized", 0));
simOpt = sim(simIn.setVariable("useOptimized", 1));

plotCurrentReferenceComparison(simOrig, simOpt)

plotTorqueComparison(simOrig, simOpt)

function groupTable = findSharedInputLUTGroups(model)
% Measure the memory of every lookup table in the model. Searching inside
% library links reaches the tables nested in the PMSM controller libraries.
memoryCalculator = FunctionApproximation.LUTMemoryUsageCalculator;
memoryCalculator.FindOptions.SearchInsideLibraryLinks = true;
memoryTable = lutmemoryusage(memoryCalculator, model);
lutPaths = string(memoryTable.BlockPath);

% For each lookup table, record the source port that drives each of its
% inputs. Two tables share inputs when these source ports match. Unused
% input slots stay at -1 so tables with different input counts never match.
inputPortsPerLUT = arrayfun(@(p) get_param(p,"PortHandles").Inport, lutPaths, "UniformOutput", false);
sourcePortMatrix = -ones(numel(lutPaths), max(cellfun(@numel, inputPortsPerLUT)));
for k = 1:numel(lutPaths)
    for j = 1:numel(inputPortsPerLUT{k})
        % Trace the input line back to the port that drives it.
        sourcePortMatrix(k,j) = get_param(get_param(inputPortsPerLUT{k}(j), "Line"), "SrcPortHandle");
    end
end

% Group tables whose source-port rows are identical. Count the tables and
% total the memory per group. lutmemoryusage reports bytes, so scale by 8.
[~, ~, groupIndex] = unique(sourcePortMatrix, "rows");
lutsPerGroup = accumarray(groupIndex, 1);
totalBitsPerGroup = accumarray(groupIndex, memoryTable.MemoryUsage) * 8;
blockGroups = splitapply(@(p) {p}, lutPaths, groupIndex);

% Keep only groups of two or more tables and rank them by memory so the
% heaviest candidate is the first row.
keepGroup = lutsPerGroup >= 2;
groupTable = table(lutsPerGroup(keepGroup), totalBitsPerGroup(keepGroup), blockGroups(keepGroup), ...
    VariableNames=["NumLUTs","TotalBits","Blocks"]);
groupTable = sortrows(groupTable, "TotalBits", "descend");
end

function populateOptimizedVariant(solution)
optimizedPath = 'IPMSMTorqueWithVariant/Control/FOC/Outer loop control/PMSM Current Reference Generator/CurrentRefVariant/Optimized';

% Generate the approximation as a subsystem in a throwaway model, and close
% that model automatically when this function returns.
[approximationModel, approximationBlock] = solution.approximate(false, false);
cleanupApproximationModel = onCleanup(@() close_system(approximationModel.Name, 0));

% Copy the generated subsystem into the Optimized variant.
add_block(approximationBlock.getFullName, [optimizedPath '/Approximation']);

% Wire the three inputs and two outputs. The Optimized inputs In1-In3 do not
% map one-to-one onto the approximation inputs, so set each connection
% explicitly (In2->1, In1->2, In3->3).
wires = ["In2/1", "Approximation/1"
         "In1/1", "Approximation/2"
         "In3/1", "Approximation/3"
         "Approximation/1", "Out1/1"
         "Approximation/2", "Out2/1"];
for k = 1:size(wires, 1)
    add_line(optimizedPath, wires(k,1), wires(k,2), "autorouting","on");
end

% Arrange the subsystem so the added blocks and lines are readable.
Simulink.BlockDiagram.arrangeSystem(optimizedPath);
end

function plotCurrentReferenceComparison(simOrig, simOpt)
% Extract the d- and q-axis current references from each run as timeseries.
idRefOrig = getElement(simOrig.logsout_IPMSMTorque, "idRef").Values;
idRefOpt = getElement(simOpt.logsout_IPMSMTorque, "idRef").Values;
iqRefOrig = getElement(simOrig.logsout_IPMSMTorque, "iqRef").Values;
iqRefOpt = getElement(simOpt.logsout_IPMSMTorque, "iqRef").Values;

% Report the largest deviation the approximation introduces on each reference.
fprintf("idRef: max |err| = %.4g A\n", max(abs(idRefOpt.Data - idRefOrig.Data)))
fprintf("iqRef: max |err| = %.4g A\n", max(abs(iqRefOpt.Data - iqRefOrig.Data)))

figure
tiledlayout(2, 1)

% Top axes: d-axis current reference.
nexttile
plot(idRefOrig.Time, idRefOrig.Data, "b")
hold on
plot(idRefOpt.Time, idRefOpt.Data, "r--")
hold off
legend("Original LUTs", "Shared-prelookup")
grid on
ylabel("idRef (A)")
title("d-axis current reference: original vs optimized")

% Bottom axes: q-axis current reference.
nexttile
plot(iqRefOrig.Time, iqRefOrig.Data, "b")
hold on
plot(iqRefOpt.Time, iqRefOpt.Data, "r--")
hold off
legend("Original LUTs", "Shared-prelookup")
grid on
xlabel("Time (s)")
ylabel("iqRef (A)")
title("q-axis current reference: original vs optimized")
end

function plotTorqueComparison(simOrig, simOpt)
% Extract the measured electrical torque from each run as a timeseries.
torqueOrig = getElement(simOrig.logsout_IPMSMTorque, "torque_meas").Values;
torqueOpt = getElement(simOpt.logsout_IPMSMTorque, "torque_meas").Values;

% Report the largest deviation the approximation introduces at the terminals.
fprintf("torque_meas: max |err| = %.4g Nm\n", max(abs(torqueOpt.Data - torqueOrig.Data)))

figure
plot(torqueOrig.Time, torqueOrig.Data, "b")
hold on
plot(torqueOpt.Time, torqueOpt.Data, "r--")
hold off
legend("Original LUTs", "Shared-prelookup")
grid on
xlabel("Time (s)")
ylabel("Measured electrical torque (Nm)")
title("Measured torque: original vs optimized")
end