I'm on the load-based handover patches: it is adding a second handover decision
algorithm. What keeps slightly itching me about it is that it is not really
cleanly separate from the first (current) handover algorithm.

- For example, in the VTY, we have the 'handover algorithm (1|2)' command, and
  the 'handover *' namespace is shared between ho 1 and ho 2. So when I look at
  the VTY commands under 'handover', a considerable number of those apply only
  to handover algorithm 2, while some, like rxlev averaging window settings and
  similar, apply to both.  (I marked the ho2 ones in the VTY docs, but still)

- The patches also add penalty timers and ho failure counters in generic
  places. In ho algorithm 2, these penalty timers and failure counts are heeded
  and cause ho / assignment to be omitted if appropriate. Not so in ho1.

The point being, if we add a third, fourth, fifth HO algo at some point, this
would probably become a tad intransparent.

I wonder now whether I should spend time on jolly's patches to more cleanly
separate the two algorithms. For example, in the structs and code, more clearly
set and apply the penalty timers and failure counts *only* if ho algo 2 is
actually used, probably even moving all of it out to context structs only known
within the ho2 code.  (Otherwise, some code adds penalty timers which might
never be looked at or cleaned up until the conn is discarded..)

On the other hand, some shared concepts make sense to be re-used. If HO algo 3
(hypothetically) wants penalty timers as well, will separating merely amount to
code dup?

Do we want separate sets of parameters for ho1 and ho2? For example, for the
rxlev window averaging, is it better to have one setting used for both ho1 and
ho2, or do I expect each algo to remember its own rxlev averaging settings?

The current patch state kind of throws both in one pot; I tried to put some
struct members in a { }ho2 sub-struct, but it's a bit half-hearted. I'm
deciding back and forth.

Truly modularizing all of it would make for more code, like opaque struct
pointers to store context, specific to each ho algorithm, at e.g. subscr_conn;
and function callbacks to take actions in certain triggers (like setting a
penalty timer for ho failure); fully separate VTY namespaces for each algo. In
other words, a proper API, sort of like the auth algo code does. It is easier
to just patch it all in there and re-use existing members, but will that bite
us in the future...

Any thoughts?


Attachment: signature.asc
Description: PGP signature

Reply via email to