How to use coder.unroll in a while loop

Question

Life is Wonderful 2022-8-16

0
链接

此问题的直接链接

https://ww2.mathworks.cn/matlabcentral/answers/1780035-how-to-use-coder-unroll-in-a-while-loop

评论： Life is Wonderful 2022-8-16

Hi

I'm looking for a sample code of how to use "coder. unroll" in a while loop. I intend to perform a division operation and want to unroll the loop if I achieve the required accuracy level.

For example,

format long g
a = (4);
b = (6);
T = numerictype('Signed', true,...
    'WordLength', 64,...
    'FractionLength', 60);
quotient = divide(T,a,b)
quotient = 
         0.666666666666667

and I want to stop the division process when a certain fractional bit accuracy, say 0.6667, is reached.

0 个评论
显示 -2更早的评论隐藏 -2更早的评论

请先登录，再进行评论。

请先登录，再回答此问题。

Answer 1

Walter Roberson 2022-8-16

1
链接

此回答的直接链接

https://ww2.mathworks.cn/matlabcentral/answers/1780035-how-to-use-coder-unroll-in-a-while-loop#answer_1027180

coder.unroll() by itself cannot do that. coder,unroll() always unrolls the number of times given in the for loop. The loop limits do not need to be constant inside the function being unrolled, but if not then during the code generation phase, the limit must be given as a numeric constant. If you had two different limits that you wanted to unroll to, then you would have to generate code twice, once for each limit.

6 个评论
显示 4更早的评论隐藏 4更早的评论

Walter Roberson 2022-8-16

在 MATLAB Online 中打开

The limit for unrolling cannot be dynamic. Multiple copies of the code are generated and the loop is completely replaced.

MATLAB does not generate code along the lines of

K = 1; Z(K) = sin(X(K));
K = 2; Z(K) = sin(X(K));
K = 3; Z(K) = sin(X(K));
if n > 3
    for K = 4 : n
       Z(K) = sin(X(K));
    end
end

That is, you are not providing some kind of promise of a minimum number of loops and unrolling to that count. coder.unroll always fully unrolls according to the constant count passed during code compilation phase.

coder.unroll is unable to handle the situation you are describing. It always does the full number of loops.

If you knew the maximum number of iterations then you could potentially hand-unroll, something along the lines of

remainder = a;
precision = inf;
divisor = 0;
while true
    [divisor, remainder, precision] = divide_one_step(divisor, remainder, b);
    if precision <= target; break; end
    
    [divisor, remainder, precision] = divide_one_step(divisor, remainder, b);
    if precision <= target; break; end
    
    %more stuff
end

and keep repeating those two lines right there the maximum number of iterations that will ever be needed.

Will this give any improvement compared to a for loop that is not unrolled? Probably not. Unrolling has efficiency gains when there are no conditional branches in the code, which allows for more possibilities about keeping values in registers, or consolidating operations (e.g., instead of adding one to a value 8 times, add 8 to it once at the end.)