CODEWITHSUNDEEP
phpalgorithmfactoryinternal-load-balancer
Markomafs
Markomafs

Reputation: 546

Weighted Load Balancing Algorithm into PHP Application

I want to resolve weighted an Adapter from an factory which could be configured by user (enable/disable and weight %).

Example:

I can grant that all items will never sum more than one hundred (100%), but sometimes any adapter could be deactivated.

I have the following parameters: 

public function handleAdapter()
{
    $isWActive = (boolean)$this->_config[self::W];
    $isXActive = (boolean)$this->_config[self::X];
    $isYActive = (boolean)$this->_config[self::Y];
    $isZActive = (boolean)$this->_config[self::Z];
    $WPercentage = (int)$this->_config[self::LOAD_BALANCE_W];
    $XPercentage = (int)$this->_config[self::LOAD_BALANCE_X];
    $YPercentage = (int)$this->_config[self::LOAD_BALANCE_Y];
    $ZPercentage = (int)$this->_config[self::LOAD_BALANCE_Z];
    .
    .
    .
    return (self::W | self::X | self::Y | self::Z); 
}

How can i balance weighted between this adapters dynamically?

Edit

created a gist to a executable code: https://gist.github.com/markomafs/5d892d06d6670909f9b4

Upvotes: 1

Views: 602

Answers (3)

Brain Foo Long
Brain Foo Long

Reputation: 2087

Another try, this should work for your case - But it only work if you have an adapter as a single char string, this is not visible by your question.

public function handleAdapter()
{
    # a map with all adapters
    $map = array(
        self::W => self::LOAD_BALANCE_W,
        self::X => self::LOAD_BALANCE_X,
        self::Y => self::LOAD_BALANCE_Y,
        self::Z => self::LOAD_BALANCE_Z
    );
    # generate a string map with one char per percentage point
    $stringMap = "";
    foreach($map as $key => $value){
        # skip if disabled
        if(!$this->_config[$key]) continue;
        # repeat the key for each percentage point
        $stringMap .= str_repeat($key, (int)$this->_config[$value]);
    }
    # return a random string char from the map
    return $stringMap[rand(0, strlen($stringMap) - 1)];
}

Upvotes: 1

Brain Foo Long
Brain Foo Long

Reputation: 2087

Edit: I've misunderstood the question, the answer is wrong.

I understand your question so that you always want to return the adapter with the lowest load to force traffic to this adapter.

public function handleAdapter()
{
    $isWActive = (boolean)$this->_config[self::W];
    $isXActive = (boolean)$this->_config[self::X];
    $isYActive = (boolean)$this->_config[self::Y];
    $isZActive = (boolean)$this->_config[self::Z];
    $WPercentage = (int)$this->_config[self::LOAD_BALANCE_W];
    $XPercentage = (int)$this->_config[self::LOAD_BALANCE_X];
    $YPercentage = (int)$this->_config[self::LOAD_BALANCE_Y];
    $ZPercentage = (int)$this->_config[self::LOAD_BALANCE_Z];

    $map = array();
    if($isWActive) $map[self::W] = $WPercentage;
    if($isXActive) $map[self::X] = $XPercentage;
    if($isYActive) $map[self::Y] = $YPercentage;
    if($isZActive) $map[self::Z] = $ZPercentage;

    asort($map);
    return key($map);    
}

Edit: Fixed wrong sort(), you need asort() to maintain the index.

Upvotes: 0

Diana Arnos
Diana Arnos

Reputation: 21

This may not be the best approach, but you can try something like this:

public function handleAdapter()
{
    //an array to return the balanced entries
    $balancedEntries[] = false;

    //verifies which of the options are active
    $isWActive = (boolean)$this->_config[self::W];
    $isXActive = (boolean)$this->_config[self::X];
    $isYActive = (boolean)$this->_config[self::Y];
    $isZActive = (boolean)$this->_config[self::Z];

    //get configured percentage of each
    $WPercentage = (int)$this->_config[self::LOAD_BALANCE_W];
    $XPercentage = (int)$this->_config[self::LOAD_BALANCE_X];
    $YPercentage = (int)$this->_config[self::LOAD_BALANCE_Y];
    $ZPercentage = (int)$this->_config[self::LOAD_BALANCE_Z];

    //here you fill the array according to the proportion defined by the percentages
    if ($isWActive) {
            for ($i = 0; $i < $WPercentage; $i++) {
                $balancedEntries[] = self::W;
            }
        }

        if ($isXActive) {
            for ($i = 0; $i < $XPercentage; $i++) {
                $balancedEntries[] = self::X;
            }
        }

        if ($isYActive) {
            for ($i = 0; $i < $YPercentage; $i++) {
                $balancedEntries[] = self::Y;
            }
        }

        if ($isZActive) {
            for ($i = 0; $i < $ZPercentage; $i++) {
                $balancedEntries[] = self::Z;
            }
        }

        return $balancedEntries;
}

And then, in case you want a proportion of 1 to 100 (as in percentages):

$balancedResult = $balancedEntries[array_rand($balancedEntries, 1)];

Since array_rand will return 1 key from the original array, you use it to get it's value.

Upvotes: 2

Related Questions