import org.opendaylight.transportpce.common.fixedflex.GridUtils;
import org.opendaylight.transportpce.pce.constraints.PceConstraints;
import org.opendaylight.transportpce.pce.constraints.PceConstraints.ResourcePair;
-import org.opendaylight.transportpce.pce.model.SpectrumAssignment;
import org.opendaylight.transportpce.pce.networkanalyzer.PceNode;
import org.opendaylight.transportpce.pce.networkanalyzer.PceResult;
-import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev200529.OpenroadmLinkType;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.pce.rev220118.SpectrumAssignment;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.pce.rev220118.SpectrumAssignmentBuilder;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev211210.OpenroadmLinkType;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev181130.OpucnTribSlotDef;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.NodeId;
import org.opendaylight.yangtools.yang.common.Uint16;
import org.slf4j.Logger;
public static final Long CONST_OSNR = 1L;
public static final double SYS_MARGIN = 0;
+ @SuppressWarnings("fallthrough")
@SuppressFBWarnings(
value = "SF_SWITCH_FALLTHROUGH",
justification = "intentional fallthrough")
pceResult.setRC(ResponseCodes.RESPONSE_FAILED);
return pceResult;
}
- int tribSlotNb = 1;
int spectralWidthSlotNumber = GridConstant.SPECTRAL_WIDTH_SLOT_NUMBER_MAP
.getOrDefault(serviceType, GridConstant.NB_SLOTS_100G);
SpectrumAssignment spectrumAssignment = null;
//variable to deal with 1GE (Nb=1) and 10GE (Nb=10) cases
switch (serviceType) {
+ case StringConstants.SERVICE_TYPE_OTUC2:
+ case StringConstants.SERVICE_TYPE_OTUC3:
+ case StringConstants.SERVICE_TYPE_OTUC4:
case StringConstants.SERVICE_TYPE_400GE:
spectralWidthSlotNumber = GridConstant.SPECTRAL_WIDTH_SLOT_NUMBER_MAP
.getOrDefault(serviceType, GridConstant.NB_SLOTS_400G);
//fallthrough
- case StringConstants.SERVICE_TYPE_100GE:
+ case StringConstants.SERVICE_TYPE_100GE_T:
case StringConstants.SERVICE_TYPE_OTU4:
- spectrumAssignment = getSpectrumAssignment(path,
- allPceNodes, spectralWidthSlotNumber);
+ spectrumAssignment = getSpectrumAssignment(path, allPceNodes, spectralWidthSlotNumber);
pceResult.setServiceType(serviceType);
- if (spectrumAssignment.getBeginIndex() == 0 && spectrumAssignment.getStopIndex() == 0) {
+ if (spectrumAssignment.getBeginIndex().equals(Uint16.valueOf(0))
+ && spectrumAssignment.getStopIndex().equals(Uint16.valueOf(0))) {
pceResult.setRC(ResponseCodes.RESPONSE_FAILED);
pceResult.setLocalCause(PceResult.LocalCause.NO_PATH_EXISTS);
return pceResult;
}
- if (spectrumAssignment.isFlexGrid()) {
+ if (spectrumAssignment.getFlexGrid()) {
LOG.info("Spectrum assignment flexgrid mode");
pceResult.setResultWavelength(GridConstant.IRRELEVANT_WAVELENGTH_NUMBER);
} else {
LOG.info("Spectrum assignment fixedgrid mode");
pceResult.setResultWavelength(
- GridUtils.getWaveLengthIndexFromSpectrumAssigment(spectrumAssignment.getBeginIndex()));
+ GridUtils.getWaveLengthIndexFromSpectrumAssigment(spectrumAssignment.getBeginIndex()
+ .toJava()));
}
- pceResult.setMinFreq(GridUtils.getStartFrequencyFromIndex(spectrumAssignment.getBeginIndex()));
- pceResult.setMaxFreq(GridUtils.getStopFrequencyFromIndex(spectrumAssignment.getStopIndex()));
+ pceResult.setMinFreq(GridUtils.getStartFrequencyFromIndex(spectrumAssignment.getBeginIndex().toJava()));
+ pceResult.setMaxFreq(GridUtils.getStopFrequencyFromIndex(spectrumAssignment.getStopIndex().toJava()));
LOG.info("In PostAlgoPathValidator: spectrum assignment found {} {}", spectrumAssignment, path);
// Check the OSNR
pceResult.setRC(ResponseCodes.RESPONSE_OK);
pceResult.setLocalCause(PceResult.LocalCause.NONE);
break;
+ case StringConstants.SERVICE_TYPE_100GE_M:
case StringConstants.SERVICE_TYPE_10GE:
- tribSlotNb = 8;
- //fallthrough
case StringConstants.SERVICE_TYPE_1GE:
+ Map<String, Integer> tribSlotNbMap = Map.of(
+ StringConstants.SERVICE_TYPE_100GE_M, 20,
+ StringConstants.SERVICE_TYPE_10GE, 8,
+ StringConstants.SERVICE_TYPE_1GE, 1);
+ int tribSlotNb = tribSlotNbMap.get(serviceType);
pceResult.setRC(ResponseCodes.RESPONSE_FAILED);
pceResult.setServiceType(serviceType);
- Map<String, Uint16> tribPort = chooseTribPort(path, allPceNodes);
Map<String, List<Uint16>> tribSlot = chooseTribSlot(path, allPceNodes, tribSlotNb);
+ Map<String, Uint16> tribPort = chooseTribPort(path, allPceNodes, tribSlot, tribSlotNb);
+ List<OpucnTribSlotDef> resultTribPortTribSlot = getMinMaxTpTs(tribPort, tribSlot);
- if (tribPort != null && tribSlot != null) {
- pceResult.setResultTribPort(tribPort);
- pceResult.setResultTribSlot(tribSlot);
- pceResult.setResultTribSlotNb(tribSlotNb);
+ if (resultTribPortTribSlot.get(0) != null && resultTribPortTribSlot.get(1) != null) {
+ pceResult.setResultTribPortTribSlot(resultTribPortTribSlot);
pceResult.setRC(ResponseCodes.RESPONSE_OK);
LOG.info("In PostAlgoPathValidator: found TribPort {} - tribSlot {} - tribSlotNb {}",
tribPort, tribSlot, tribSlotNb);
}
break;
case StringConstants.SERVICE_TYPE_ODU4:
+ case StringConstants.SERVICE_TYPE_ODUC2:
+ case StringConstants.SERVICE_TYPE_ODUC3:
+ case StringConstants.SERVICE_TYPE_ODUC4:
+ case StringConstants.SERVICE_TYPE_100GE_S:
pceResult.setRC(ResponseCodes.RESPONSE_OK);
- LOG.info("In PostAlgoPathValidator: ODU4 path found {}", path);
+ pceResult.setServiceType(serviceType);
+ LOG.info("In PostAlgoPathValidator: ODU4/ODUCn path found {}", path);
break;
default:
pceResult.setRC(ResponseCodes.RESPONSE_FAILED);
double latency = 0;
for (PceGraphEdge edge : path.getEdgeList()) {
- try {
- latency += edge.link().getLatency();
- LOG.debug("- In checkLatency: latency of {} = {} units", edge.link().getLinkId().getValue(), latency);
- } catch (NullPointerException e) {
+ if (edge.link() == null || edge.link().getLatency() == null) {
LOG.warn("- In checkLatency: the link {} does not contain latency field",
edge.link().getLinkId().getValue());
+ return false;
}
+ latency += edge.link().getLatency();
+ LOG.debug("- In checkLatency: latency of {} = {} units", edge.link().getLinkId().getValue(), latency);
}
return (latency < maxLatency);
}
}
private Map<String, Uint16> chooseTribPort(GraphPath<String,
- PceGraphEdge> path, Map<NodeId, PceNode> allPceNodes) {
+ PceGraphEdge> path, Map<NodeId, PceNode> allPceNodes, Map<String, List<Uint16>> tribSlotMap, int nbSlot) {
LOG.info("In choosetribPort: edgeList = {} ", path.getEdgeList());
Map<String, Uint16> tribPortMap = new HashMap<>();
for (PceGraphEdge edge : path.getEdgeList()) {
NodeId linkSrcNode = edge.link().getSourceId();
- String linkSrcTp = edge.link().getSourceTP().toString();
+ String linkSrcTp = edge.link().getSourceTP().getValue();
NodeId linkDestNode = edge.link().getDestId();
- String linkDestTp = edge.link().getDestTP().toString();
+ String linkDestTp = edge.link().getDestTP().getValue();
PceNode pceOtnNodeSrc = allPceNodes.get(linkSrcNode);
PceNode pceOtnNodeDest = allPceNodes.get(linkDestNode);
List<Uint16> srcTpnPool = pceOtnNodeSrc.getAvailableTribPorts().get(linkSrcTp);
List<Uint16> destTpnPool = pceOtnNodeDest.getAvailableTribPorts().get(linkDestTp);
List<Uint16> commonEdgeTpnPool = new ArrayList<>();
- for (Uint16 integer : srcTpnPool) {
- if (destTpnPool.contains(integer)) {
- commonEdgeTpnPool.add(integer);
+ for (Uint16 srcTpn : srcTpnPool) {
+ if (destTpnPool.contains(srcTpn)) {
+ commonEdgeTpnPool.add(srcTpn);
}
}
Collections.sort(commonEdgeTpnPool);
if (!commonEdgeTpnPool.isEmpty()) {
- tribPortMap.put(edge.link().getLinkId().getValue(), commonEdgeTpnPool.get(0));
+ Integer startTribSlot = tribSlotMap.values().stream().findFirst().get().get(0).toJava();
+ Integer tribPort = (int) Math.ceil((double)startTribSlot / nbSlot);
+ for (Uint16 commonTribPort : commonEdgeTpnPool) {
+ if (tribPort.equals(commonTribPort.toJava())) {
+ tribPortMap.put(edge.link().getLinkId().getValue(), commonTribPort);
+ }
+ }
}
}
tribPortMap.forEach((k,v) -> LOG.info("TribPortMap : k = {}, v = {}", k, v));
for (PceGraphEdge edge : path.getEdgeList()) {
NodeId linkSrcNode = edge.link().getSourceId();
- String linkSrcTp = edge.link().getSourceTP().toString();
+ String linkSrcTp = edge.link().getSourceTP().getValue();
NodeId linkDestNode = edge.link().getDestId();
- String linkDestTp = edge.link().getDestTP().toString();
+ String linkDestTp = edge.link().getDestTP().getValue();
PceNode pceOtnNodeSrc = allPceNodes.get(linkSrcNode);
PceNode pceOtnNodeDest = allPceNodes.get(linkDestNode);
List<Uint16> srcTsPool = pceOtnNodeSrc.getAvailableTribSlots().get(linkSrcTp);
List<Uint16> destTsPool = pceOtnNodeDest.getAvailableTribSlots().get(linkDestTp);
- List<Uint16> commonEdgeTsPool = new ArrayList<>();
+ List<Uint16> commonEdgeTsPoolList = new ArrayList<>();
List<Uint16> tribSlotList = new ArrayList<>();
for (Uint16 integer : srcTsPool) {
if (destTsPool.contains(integer)) {
- commonEdgeTsPool.add(integer);
+ commonEdgeTsPoolList.add(integer);
}
}
- Collections.sort(commonEdgeTsPool);
- boolean discontinue = true;
- int index = 0;
- while (discontinue && (commonEdgeTsPool.size() - index >= nbSlot)) {
- discontinue = false;
- Integer val = commonEdgeTsPool.get(index).toJava();
- for (int i = 0; i < nbSlot; i++) {
- if (commonEdgeTsPool.get(index + i).equals(Uint16.valueOf(val + i))) {
- tribSlotList.add(commonEdgeTsPool.get(index + i));
- } else {
- discontinue = true;
- tribSlotList.clear();
- index += i;
- break;
+ Collections.sort(commonEdgeTsPoolList);
+ List<Uint16> commonGoodStartEdgeTsPoolList = new ArrayList<>();
+ for (Uint16 startEdgeTsPool : commonEdgeTsPoolList) {
+ if (Integer.valueOf(1).equals(startEdgeTsPool.toJava() % nbSlot)
+ || nbSlot == 1) {
+ commonGoodStartEdgeTsPoolList.add(startEdgeTsPool);
+ }
+ }
+ Collections.sort(commonGoodStartEdgeTsPoolList);
+ boolean goodTsList = false;
+ for (Uint16 goodStartTsPool : commonGoodStartEdgeTsPoolList) {
+ int goodStartIndex = commonEdgeTsPoolList.indexOf(Uint16.valueOf(goodStartTsPool.intValue()));
+ if (!goodTsList && commonEdgeTsPoolList.size() - goodStartIndex >= nbSlot) {
+ for (int i = 0; i < nbSlot; i++) {
+ if (!commonEdgeTsPoolList.get(goodStartIndex + i)
+ .equals(Uint16.valueOf(goodStartTsPool.toJava() + i))) {
+ goodTsList = false;
+ tribSlotList.clear();
+ break;
+ }
+ tribSlotList.add(commonEdgeTsPoolList.get(goodStartIndex + i));
+ goodTsList = true;
}
}
}
return tribSlotMap;
}
+ private List<OpucnTribSlotDef> getMinMaxTpTs(Map<String, Uint16> tribPort, Map<String, List<Uint16>> tribSlot) {
+ String tribport = tribPort.values().toArray()[0].toString();
+ @SuppressWarnings("unchecked")
+ List<Uint16> tsList = (List<Uint16>) tribSlot.values().toArray()[0];
+ OpucnTribSlotDef minOpucnTs = OpucnTribSlotDef
+ .getDefaultInstance(String.join(".", tribport, tsList.get(0).toString()));
+ OpucnTribSlotDef maxOpucnTs = OpucnTribSlotDef
+ .getDefaultInstance(String.join(".", tribport, tsList.get(tsList.size() - 1).toString()));
+ List<OpucnTribSlotDef> minmaxTpTsList = new ArrayList<>();
+ minmaxTpTsList.add(minOpucnTs);
+ minmaxTpTsList.add(maxOpucnTs);
+ return minmaxTpTsList;
+ }
+
// Check the path OSNR
private boolean checkOSNR(GraphPath<String, PceGraphEdge> path) {
double linkOsnrDb;
}
private double getOsnrDb(double osnrLu) {
- double osnrDb;
- osnrDb = 10 * Math.log10(osnrLu);
- return osnrDb;
+ return (10 * Math.log10(osnrLu));
}
private double getInverseOsnrLinkLu(double linkOsnrDb) {
// 1 over the link OSNR, in linear units
- double linkOsnrLu;
- linkOsnrLu = Math.pow(10, (linkOsnrDb / 10.0));
+ double linkOsnrLu = Math.pow(10, (linkOsnrDb / 10.0));
LOG.debug("In retrieveosnr: the inverse of link osnr is {} (Linear Unit)", linkOsnrLu);
return (CONST_OSNR / linkOsnrLu);
}
if (allPceNodes.containsKey(edge.link().getSourceId())) {
PceNode pceNode = allPceNodes.get(edge.link().getSourceId());
LOG.info("Processing PCE node {}", pceNode);
- if (StringConstants.OPENROADM_DEVICE_VERSION_1_2_1.equals(pceNode.getVersion())
- || pceNode.getSlotWidthGranularity().compareTo(GridConstant.SLOT_WIDTH_50) == 0) {
+ if (StringConstants.OPENROADM_DEVICE_VERSION_1_2_1.equals(pceNode.getVersion())) {
LOG.info("Node {}: version is {} and slot width granularity is {} -> fixed grid mode",
- pceNode.getNodeId(), pceNode.getVersion(), pceNode.getSlotWidthGranularity());
+ pceNode.getNodeId(), pceNode.getVersion(), pceNode.getSlotWidthGranularity());
+ isFlexGrid = false;
+ }
+ if ((pceNode.getSlotWidthGranularity().equals(GridConstant.SLOT_WIDTH_50))
+ && (pceNode.getCentralFreqGranularity().equals(GridConstant.SLOT_WIDTH_50))) {
+ LOG.info("Node {}: version is {} with slot width granularity {} and central "
+ + "frequency granularity is {} -> fixed grid mode",
+ pceNode.getNodeId(), pceNode.getVersion(), pceNode.getSlotWidthGranularity(),
+ pceNode.getCentralFreqGranularity());
isFlexGrid = false;
}
pceNodeFreqMap = pceNode.getBitSetData();
*/
private SpectrumAssignment computeBestSpectrumAssignment(BitSet spectrumOccupation, int spectralWidthSlotNumber,
boolean isFlexGrid) {
- SpectrumAssignment spectrumAssignment = new SpectrumAssignment(0, 0);
- spectrumAssignment.setFlexGrid(isFlexGrid);
+ SpectrumAssignmentBuilder spectrumAssignmentBldr = new SpectrumAssignmentBuilder()
+ .setBeginIndex(Uint16.valueOf(0))
+ .setStopIndex(Uint16.valueOf(0))
+ .setFlexGrid(isFlexGrid);
BitSet referenceBitSet = new BitSet(spectralWidthSlotNumber);
referenceBitSet.set(0, spectralWidthSlotNumber);
- int nbSteps = 1;
- if (isFlexGrid) {
- nbSteps = spectralWidthSlotNumber;
- }
+ int nbSteps = isFlexGrid ? spectralWidthSlotNumber : 1;
//higher is the frequency, smallest is the wavelength number
//in operational, the allocation is done through wavelength starting from the smallest
//so we have to loop from the last element of the spectrum occupation
for (int i = spectrumOccupation.size(); i >= spectralWidthSlotNumber; i -= nbSteps) {
if (spectrumOccupation.get(i - spectralWidthSlotNumber, i).equals(referenceBitSet)) {
- spectrumAssignment.setBeginIndex(i - spectralWidthSlotNumber);
- spectrumAssignment.setStopIndex(i - 1);
+ spectrumAssignmentBldr.setBeginIndex(Uint16.valueOf(i - spectralWidthSlotNumber));
+ spectrumAssignmentBldr.setStopIndex(Uint16.valueOf(i - 1));
break;
}
}
- return spectrumAssignment;
+ return spectrumAssignmentBldr.build();
}
-
}
Code Review / transportpce.git / blobdiff