Efficient threshold checks of absolute value in embedded C

Question

I thinking about a efficient way of implementing a threshold check (with optional hysteresis and delay).

Requirement/situation:

I want to check e.g. an non-negative value (e.g. absolute pressure) against an upper threshold and an lower threshold resulting in an over pressure error bit or an under pressure error bit respectively. There are going to be multiple set and reset thresholds. (I want to organize in an array)

Considering hysteresis, There shall be different set and reset vlaues: e.g. for the over pressure case a set threshold of pressure p_set (error bit gets set) and a reset threshold of p_reset <= p_set. Same applies for the unde pressure but here p_reset >= p_set, which causes the comparison operator to invert:

// Over pressure detection
if (pressure > overPressureSetThld){
  // Over pressure -> set error bit
else if (pressure < overPressureResetThld){
  // Reset over pressure error bit
}

// Under pressure detection
if (pressure < underPressureSetThld){              // Inverted comparison operator
  // Under pressure -> set error bit
else if (pressure > underPressureResetThld){       // Inverted comparison operator
  // Reset under pressure error bit

Alternatives:

Thinking about this, I see two alternatives:

1. Implement it straigt forward like above -> bigger code size/"duplicate" code (especially with a delay considered)

2. Compare relative values (substraction and abs, requires a reference pressure) -> reduced code size because only one if-elseif needed but higher runtime load e.g.:

   if (abs(pressure - REFRENCE_PRESSURE) > relSetThld){ // Threshold relative to reference and positive // Set over/under pressure error bit else if (abs(pressure - REFRENCE_PRESSURE) < relResetThld){ // Threshold relative to reference and positive // Reset over/under pressure error bit

Question:

I tend to use alternative 2 but I'm asking myself (and you) if there is an better way to do this. Suggestions welcome!

Best Christoph

Answer 1

The most efficient way to implement something like checking several levels, considering execution speed, is to form a "binary search"/BST out of the various levels. Which in practice means writing an if-else chain:

if(val < level_mid)
  if(val < level_low)
    // ...
  else
    // ...
else
  if(val < level_high)
    // ...
  else
    // ...

You can't really beat the above in terms of performance and branches. In terms of readability/maintenance, the optimal code would rather look like:

if(val < level_lowest)
  // ...
else if(val < level_low)
  // ...
else if(val < level_mid)
  // ...
else if(val < level_high)
  // ...

This code is fairly effective too, but much more readable/maintainable than the "binary search" alternative. As always, disassemble and see for yourself.

But then of course, manually optimizing code without a specific system in mind isn't very sensible. Suppose for example that you are using a 8 or 16 bit CPU. All that will matter in terms of performance in that case is the size of the integer types involved. Similarly, using floating point types on a MCU without FPU will lead to highly inefficient code.

If optimizing for code size, you should be looking at entirely different aspects than the amount of branches. Getting rid of bloated library calls being the #1 thing (I'm looking at you, stdio.h).

Doing something like taking absolute values just for the sake of reducing code size is nonsensical - it is not at all obvious that it will reduce code size. What it will certainly do however, is to increase complexity. Which in turn tends to lead to larger code and more bugs. Apply the KISS principle.