ResourceCache.java

Go to the documentation of this file.

/* Copyright 2017 Telstra Open Source
 *
 *   Licensed under the Apache License, Version 2.0 (the "License");
 *   you may not use this file except in compliance with the License.
 *   You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *   Unless required by applicable law or agreed to in writing, software
 *   distributed under the License is distributed on an "AS IS" BASIS,
 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *   See the License for the specific language governing permissions and
 *   limitations under the License.
 */

package org.openkilda.pce.cache;

import org.openkilda.messaging.model.Flow;
import org.openkilda.messaging.model.ImmutablePair;
import org.openkilda.messaging.model.SwitchId;
import org.openkilda.messaging.payload.ResourcePool;

import com.google.common.base.MoreObjects;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.Collections;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.stream.Collectors;

public class ResourceCache extends Cache {
    public static final long FLOW_COOKIE_VALUE_MASK = 0x00000000FFFFFFFFL;

    public static final long FORWARD_FLOW_COOKIE_MASK = 0x4000000000000000L;

    public static final long REVERSE_FLOW_COOKIE_MASK = 0x2000000000000000L;

    static final int MIN_VLAN_ID = 2;

    static final int MAX_VLAN_ID = 4094;

    static final int MIN_METER_ID = 11;

    static final int MAX_METER_ID = 2500;

    static final int MAX_COOKIE = 128 * 1024;

    static final int MIN_COOKIE = 1;

    private static final Logger logger = LoggerFactory.getLogger(ResourceCache.class);

    private final Map<SwitchId, ResourcePool> meterPool = new ConcurrentHashMap<>();

    private final ResourcePool cookiePool = new ResourcePool(MIN_COOKIE, MAX_COOKIE);

    private final ResourcePool vlanPool = new ResourcePool(MIN_VLAN_ID, MAX_VLAN_ID);

    public ResourceCache() {
    }

    public void clear() {
        cookiePool.dumpPool().forEach(cookiePool::deallocate);
        vlanPool.dumpPool().forEach(vlanPool::deallocate);
        meterPool.clear();
    }

    public Integer allocateCookie() {
        return cookiePool.allocate();
    }

    public Integer allocateCookie(Integer cookie) {
        if (cookie == 0) {
            return cookiePool.allocate();
        } else {
            cookiePool.allocate(cookie);
            return cookie;
        }
    }

    public Integer deallocateCookie(Integer cookie) {
        return cookiePool.deallocate(cookie);
    }

    public Integer allocateVlanId() {
        return vlanPool.allocate();
    }

    public Integer allocateVlanId(Integer vlanId) {
        if (vlanId == 0) {
            return vlanPool.allocate();
        } else {
            vlanPool.allocate(vlanId);
            return vlanId;
        }
    }

    public Integer deallocateVlanId(Integer vlanId) {
        return vlanPool.deallocate(vlanId);
    }

    public synchronized Integer allocateMeterId(SwitchId switchId) {
        return meterPool.computeIfAbsent(switchId, k -> new ResourcePool(MIN_METER_ID, MAX_METER_ID)).allocate();
    }

    public synchronized Integer allocateMeterId(SwitchId switchId, Integer meterId) {
        if (meterId == 0) {
            return meterPool.computeIfAbsent(switchId, k -> new ResourcePool(MIN_METER_ID, MAX_METER_ID))
                    .allocate();
        } else {
            meterPool.computeIfAbsent(switchId, k -> new ResourcePool(MIN_METER_ID, MAX_METER_ID))
                    .allocate(meterId);
            return meterId;
        }
    }

    public synchronized Integer deallocateMeterId(SwitchId switchId, Integer meterId) {
        ResourcePool switchMeterPool = meterPool.get(switchId);
        return switchMeterPool != null ? switchMeterPool.deallocate(meterId) : null;
    }

    public synchronized Set<Integer> deallocateMeterId(SwitchId switchId) {
        ResourcePool switchMeterPool = meterPool.remove(switchId);
        return switchMeterPool != null ? switchMeterPool.dumpPool() : null;
    }

    public Set<Integer> getAllCookies() {
        return cookiePool.dumpPool();
    }

    public Set<Integer> getAllVlanIds() {
        return vlanPool.dumpPool();
    }

    public Set<Integer> getAllMeterIds(SwitchId switchId) {
        return meterPool.containsKey(switchId) ? meterPool.get(switchId).dumpPool() : Collections.emptySet();
    }

    public Map<SwitchId, Set<Integer>> getAllMeterIds() {
        return meterPool.entrySet().stream()
                        .collect(Collectors.toMap(
                                Entry::getKey,
                                e -> e.getValue().dumpPool())
                        );
    }


    public void allocateFlow(ImmutablePair<Flow, Flow> flow) {

        if (flow.left != null) {
            allocateCookie((int) (FLOW_COOKIE_VALUE_MASK & flow.left.getCookie()));
            if (!flow.left.isOneSwitchFlow()) {
                // Don't allocate if one switch .. it is zero
                // .. and allocateVlanId *will* allocate if it is zero, which consumes a very
                // .. limited resource unnecessarily
                allocateVlanId(flow.left.getTransitVlan());
            }
            allocateMeterId(flow.left.getSourceSwitch(), flow.left.getMeterId());
        }

        if (flow.right != null) {
            if (!flow.right.isOneSwitchFlow()) {
                // Don't allocate if one switch .. it is zero
                // .. and allocateVlanId *will* allocate if it is zero, which consumes a very
                // .. limited resource unnecessarily
                allocateVlanId(flow.right.getTransitVlan());
            }
            allocateMeterId(flow.right.getSourceSwitch(), flow.right.getMeterId());
        }
    }

    public void deallocateFlow(ImmutablePair<Flow, Flow> flow) {
        deallocateCookie((int) (FLOW_COOKIE_VALUE_MASK & flow.left.getCookie()));

        deallocateVlanId(flow.left.getTransitVlan());
        deallocateMeterId(flow.left.getSourceSwitch(), flow.left.getMeterId());

        if (flow.right != null) {
            deallocateVlanId(flow.right.getTransitVlan());
            deallocateMeterId(flow.right.getSourceSwitch(), flow.right.getMeterId());
        }
    }

    @Override
    public String toString() {
        return MoreObjects.toStringHelper(this)
                .add("meters", meterPool)
                .add("cookies", cookiePool)
                .add("vlans", vlanPool)
                .toString();
    }
}