WIP: Consistent hashing for balancer

[TheRandomCharacter]

Integrates consistent hashing library into yanet.
Adds option to create "chash" type balancer services.

[ol-imorozko]

I'll add comments that I've left at Levon's pr, since you will be merging his commit now:

We will have code duplication here with the following lines:

auto it = reals_enabled.find(key);
if (it != reals_enabled.end())
{
	if (it->second.has_value())
	{
		effective_weight = it->second.value();
	}
}

Mayve we can add a private method in balancer_t, smth like

 template <typename Map>
    std::optional<typename Map::mapped_type::value_type> get_effective_weight(const Map& map, const balancer::real_key_global_t& key) const {
        auto it = map.find(key);
        if (it != map.end() && it->second.has_value()) {
            return it->second.value();
        }
        return std::nullopt;
    }

And then use it, for example, with compound initialization:

if (auto found_weight = get_effective_weight(reals_wlc_weight, key); found_weight) {
    effective_weight = *found_weight;
}

[ol-imorozko]

auto found_weight = get_effective_weight(reals_enabled, key);
uint32_t effective_weight = found_weight ? *found_weight : weight;

[ol-imorozko]

that's obscure. I suggest:

    auto scaled_connections = static_cast<double>(connections * weight_sum);
    auto scaled_weight = static_cast<double>(connection_sum * weight);
    double connection_ratio = scaled_connections / scaled_weight;

    double wlc_ratio = std::max(min_ratio, wlc_power * (1.0 - connection_ratio));

    auto new_weight = static_cast<uint32_t>(std::round(weight * wlc_ratio));

[ol-imorozko]

IMHO this makes code unnecessary complex. Maybe with more complex logic it will be fine, but here I feel like just doing

//...
	if (start == do_not_exceed)
	
		YANET_LOG_ERROR("Balancer service exceeded ring chunk bounds\n");
		YADECAP_MEMORY_BARRIER_COMPILE
		return start;
	}
//...
	YADECAP_MEMORY_BARRIER_COMPILE;
	return start;
}

is sufficient enough

[TheRandomCharacter]

We need to YADECAP_MEMORY_BARRIER_COMPILE at each function exit path. Using it at each existing function exit doesn't convey this intent to future function changes.

How about using a DEFERED_MEMORY_BARRIER_COMPILE macro?

[ol-imorozko]

Yeah, maybe your solution makes more sense that I've thought initially.
smth like this will suffice?

struct MemoryBarrierGuard {
    ~MemoryBarrierGuard() {
        YADECAP_MEMORY_BARRIER_COMPILE;
    }
};

And do that at the start of every method:

Result cControlPlane::init(bool use_kernel_interface)
{
    MemoryBarrierGuard guard;
    //...

[ol-imorozko]

LGTM apart from those three unresolved conversations:
https://github.com/yanet-platform/yanet/pull/258/files#r1867724542
https://github.com/yanet-platform/yanet/pull/258/files#r1867703973
#258 (comment)