Hacker News Reader

Comment by randlet | Hacker News Reader

Can someone explain what the purpose of the safe min macro is?

What is the advantage of this:

  #define min(a, b) ({ \
      __typeof__ (a) _a = (a); \
      __typeof__ (b) _b = (b); \
      _a < _b ? _a : _b; \
  })

over the naive

  #define min(a, b) (((a) < (b)) ? (a) : (b))

?

One of the two values (a or b) gets evaluated twice. Eg)

  min(a++, b++);

a or b would really be incremented twice.

Nice thanks. Makes perfect sense and I can see that making for a hair pulling debug session if you weren't aware of it.

It's the kind of thing that's made me very familiar with the -E option for GCC, which makes it spit out the preprocessed code...

It evaluates its arguments once. That means min(expensive_calculation(x), expensive_calculation(y)) works how it reads.

A compiler might be able to avoid this if it can prove expensive_calcluation is pure, but this is usually not done unless WPO is in play.

The linux kernel goes one step further and includes…

        (void) (&_a == &_b);      \

… which makes sure that the types are actually compatible, and not just having one converted to the other.

The purpose is to evaluate `a` and `b` only once; consider `min(i++, j)`.