I have been working on the mathematical model for a long time and now I have some problems. In this model we have nodes and edges and the flows that pass through these nodes according to the topology. We also have network functions that we use to create two length chains.
First, I don't know how to define two dependent indices that use the same range. for example: cons1 , sum (j in 1..2: j+1 in 1..1 && nj[j] in Nodes && nj[j+1] in 0..9). Is it correct or not?
Second How to define IL decision variable.
I just got this error:"Cannot use type range for int" in cons19 and cons20. I will write the explanation of the two constraints 19 and 20, but I don't know how to change the code.
Constraints (19) and (20) are flow conservation constraints for the (destination node). Constraint (19) makes sure that one of the incoming links of the destination node is assigned to route from the node hosting the last NF of the service chain (nJ ) to the destination node (df ) that is also represented as the J + 1 service. In addition, Constraint (20) assigns one of the outgoing links of the node serving the last service to the (J + 1)th service order. I put my whole code for you.
Dear Mr Fleischer, I have asked you several times questions and I am very grateful for your kindness, but if you can, please help me this time as well. Thanks in advance.
using CPLEX;
int Numnodes=10;
range Nodes = 0..Numnodes;
//...................................................
//total links number=> int L=13;
tuple edge{
key int fromnode;
key int tonode;
}
{edge} Edges with fromnode,tonode in Nodes =
{<0,1>,<1,3>,<2,3>,<3,4>,<3,5>,<3,6>,<4,5>,<4,6>,<4,8>,<5,6>,<6,7>,<6,9>,<9,10>};
{edge} Lin with fromnode,tonode in Nodes =
{<0,1>,<1,3>,<2,3>,<3,4>,<3,5>,<3,6>,<4,5>,<4,6>,<4,8>,<5,6>,<6,7>,<6,9>,<9,10>};
{edge} Lout with fromnode,tonode in Nodes =
{<0,1>,<1,3>,<2,3>,<3,4>,<3,5>,<3,6>,<4,5>,<4,6>,<4,8>,<5,6>,<6,7>,<6,9>,<9,10>};
tuple cflow{
key int node1;
key int node2;
}
{cflow} Flows with node1,node2 in Nodes= {<0,1>, <0,3>, <0,4>, <0,5>, <0,6>, <0,7>, <0,8>,
<0,9>, <0,10>, <1,3>, <1,4>, <1,5>, <1,6>, <1,7>, <1,8>, <1,9>, <1,10>, <2,3>, <2,4>, <2,5>,
<2,6>, <2,7>, <2,8>, <2,9>, <2,10>,<3,4>, <3,5>, <3,6>, <3,7>, <3,8>, <3,9>, <3,10>, <4,5>,
<4,6>, <4,7>, <4,8>, <4,9>, <4,10>, <5,6>, <5,7>, <5,9>, <5,10>,<6,7>, <6,9>, <6,10>,
<9,10>};
tuple arraytoset
{
cflow ed;
int rank;
}
{arraytoset} srout = union(ed in Flows) {<ed,i> | i in 1..card(Routes[ed])};
//....................................................................................
//number flows
range F = 1..50;
//length chains
int J[f in Flows] = 2;
int nj[1..2];
//.......................................................................................
//VNFs
{string} V = {"Proxy", "Firewall", "IDS", "DPI", "NAT"};
//An NF instance v hosted on node n is characterized by its service rate of requests.
float u[V][Nodes]=...;
//transmission rate.
float C[l in Edges]=...;
//Delays
float Dvn[V][Nodes]=...; //denote t
//landa
float landa[f in Flows]=(0.5+rand(2))/2;
//..............................................................
//MAIN DECISION VARIABLES
dvar int I[V][Nodes][Flows][1..2] in 0..1;
//denotes that an NF instance v hosted at node n is used by the j-th service on the service
chain of flow f.
dvar int IL[l in Edges][Flows][1..2][Nodes][1..1][0..9] in 0..1;
//denotes that link l is used by flow f to route from the j-th to (j + 1)-th NF service,
hosted at node nj and nj+1.
dvar int Y[V][Nodes];
//represents the number of NF type v instances that are hosted at node n.
//Decision variables related with non linear equations
dvar int z[l1 in Lout][Flows][1..2][Nodes][1..1][0..9][V] in 0..1;
//Related with floor function
dexpr float x[f in Flows] = sum(v in V, n in Nodes, j in 1..2) I[v][n][f][j] / J[f];
dvar int s[f in Flows];
dvar float floorequ[i in Flows] in 0..0.99999;
//Total delays
dexpr float DT = sum(l in Edges, f in Flows, j in 1..2: j+1 in 1..1 && nj[j] in Nodes &&
nj[j+1] in 0..9) IL[l][f][j][nj[j]][j+1][nj[j+1]] * Dlink[l];
dexpr float DP = sum(v in V, n in Nodes, f in Flows, j in 1..2) I[v][n][f][j] * Dvn[v][n];
//MAIN objective functions
dexpr float objmodel1 = sum(n in Nodes, v in V) (Y[v][n] * Cpuvnf[v] / Cpunode[n]);//to minimize the use of cores
dexpr float objmodel2 = sum(l in Edges, f in Flows, j in 1..2: j+1 in 1..1 && nj[j] in Nodes
&& nj[j+1] in 0..9) ((IL[l][f][j][nj[j]][j+1][nj[j+1]] * landa[f]) / C[l]); //to minimize the utilization of link capacities.
dexpr float objmodel3 = sum(f in Flows) s[f];
maximize staticLex(objmodel3, -objmodel1, -objmodel2);
subject to{
//constrains with j,j+1,nj[j],nj[j+1] are wrong, I don't know how to define these.
forall (<o,d> in Edges)
cons1: sum(f in Flows, j in 1..2: j+1 in 1..1 && nj[j] in Nodes && nj[j+1] in 0..9) (IL[<o,d>]
[f][j][nj[j]][j+1][nj[j+1]] * landa[f]) <= C[<o,d>];
forall (n in Nodes)
cons2: sum(v in V) Y[v][n] * Cpuvnf[v] <= Cpunode[n];
forall (v in V, n in Nodes)
cons3: sum(f in Flows, j in 1..2) I[v][n][f][j] * landa[f] <= u[v][n];
forall (n in Nodes, v in V, f in Flows, j in 1..2)
cons4: Y[v][n] >= I[v][n][f][j];
forall (f in Flows, j in 1..2)
cons5: sum(n in Nodes, v in V) I[v][n][f][j] == 1;
forall (i in Flows)
cons6a: x[i]==s[i]+floorequ[i];
forall (f in Flows)
cons7: DT + DP <= Dflow[f];
//convert non_linear_equation_11 to new linear constraints == constraints 8, 9, 10
forall (f in Flows, j in 1..2: j+1 in 1..1 && nj[j] in Nodes && nj[j+1] in 0..9, v in V)
cons8: sum(<o1,d1> in Lout) z[<o1,d1>][f][j][nj[j]][j+1][nj[j+1]][v] == 1;
forall (<o1,d1> in Lout, f in Flows, j in 1..2: j+1 in 1..1 && nj[j] in Nodes && nj[j+1]
in 0..9, v in V) {
cons9: 3 * z[<o1,d1>][f][j][nj[j]][j+1][nj[j+1]][v] <= (IL[<o1,d1>][f][j][nj[j]][j+1]
[nj[j+1]] + I[v][nj[j]][f][j] + I[v][nj[j+1]][f][j+1]);
cons10: z[<o1,d1>][f][j][nj[j]][j+1][nj[j+1]][v] >= (IL[<o1,d1>][f][j][nj[j]][j+1]
[nj[j+1]] + I[v][nj[j]][f][j] + I[v][nj[j+1]][f][j+1]) - 2; }
//convert non_linear_equation_12 to new linear constraints == constraints 11, 12, 13
forall (f in Flows, j in 1..2: j+1 in 1..1 && nj[j] in Nodes && nj[j+1] in 0..9, v in V)
cons11: sum(<o2,d2> in Lin) z[<o2,d2>][f][j][nj[j]][j+1][nj[j+1]][v] == 1;
forall (<o2,d2> in Lin, f in Flows, j in 1..2: j+1 in 1..1 && nj[j] in Nodes && nj[j+1] in
0..9, v in V) {
cons12: 3 * z[<o2,d2>][f][j][nj[j+1]][j+1][nj[j+1]][v] <= (IL[<o2,d2>][f][j][nj[j]][j+1]
[nj[j+1]] + I[v][nj[j]][f][j] + I[v][nj[j+1]][f][j+1]);
cons13: z[<o2,d2>][f][j][nj[j]][j+1][nj[j+1]][v] >= (IL[<o2,d2>][f][j][nj[j]][j+1]
[nj[j+1]] + I[v][nj[j]][f][j] + I[v][nj[j+1]][f][j+1]) - 2; }
//constraints 14, 15
forall(f in Flows, j in 1..2: j+1 in 1..1 && nj[j] in Nodes && nj[j+1] in 0..9, v in V){
cons14: sum(<o1,d1> in Lout) IL[<o1,d1>][f][j][nj[j]][j+1][nj[j+1]] <= 1;
cons15: sum(<o2,d2> in Lin) IL[<o2,d2>][f][j][nj[j]][j+1][nj[j+1]] <= 1; }
//constraints 16
forall (f in Flows, j in 1..2: j+1 in 1..1 && nj[j] in Nodes && nj[j+1] in 0..9)
cons16: (sum(<o2,d2> in Lin) IL[<o2,d2>][f][j][nj[j]][j+1][nj[j+1]]) - (sum(<o1,d1>
in Lout) IL[<o1,d1>][f][j][nj[j]][j+1][nj[j+1]]) == 0;
//constraints 17, 18
forall (f in Flows, j in 1..2: j+1 in 1..1 && nj[j] in Nodes && nj[j+1] in 0..9, v in
V) {
cons17: sum(<o2,d2> in Lin) IL[<o2,d2>][f][0][0][1][1] == I[v][1][f][1];
cons18: sum(<o1,d1> in Lout) IL[<o1,d1>][f][0][0][1][1] == I[v][1][f][1]; }
//constraints 19, 20
forall (f in Flows, j in 1..2: j+1 in 1..1 && nj[j] in Nodes && nj[j+1] in 0..9, v in
V) {
cons19: sum(<o2,d2> in Lin) IL[<o2,d2>][f][1..2][9][1..1][10] == I[v][9][f][1..2];
cons20: sum(<o1,d1> in Lout) IL[<o1,d1>][f][1..2][9][1..1][10] == I[v][9][f][1..2];}}
assert forall(f in Flows) s[f]==floor(x[f]);
execute DISPLAY_After_SOLVE {
writeln("objmodel1==", objmodel1, "objmodel2==", objmodel2, "objmodel3==", objmodel3);
}
data file:
Cpunode=[1, 1, 1, 5, 4, 4, 5, 1, 10, 1, 1]; //number of core for each
node
Cpuvnf=[1, 1, 1, 1, 1]; //number of core that each vnf wants
C=[1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000,
1000, 1000]; //1ms
u=[[10,10,10,10,10,10,10,10,10,10,10]
[10,10,10,10,10,10,10,10,10,10,10]
[10,10,10,10,10,10,10,10,10,10,10]
[10,10,10,10,10,10,10,10,10,10,10]
[10,10,10,10,10,10,10,10,10,10,10]]; //10Mbps
Dvn=[[0.003, 0.003, 0.003, 0.003, 0.003, 0.003, 0.003, 0.003, 0.003,
0.003, 0.003]
[0.003, 0.003, 0.003, 0.003, 0.003, 0.003, 0.003, 0.003, 0.003,
0.003, 0.003]
[0.003, 0.003, 0.003, 0.003, 0.003, 0.003, 0.003, 0.003, 0.003,
0.003, 0.003]
[0.003, 0.003, 0.003, 0.003, 0.003, 0.003, 0.003, 0.003, 0.003,
0.003, 0.003]
[0.003, 0.003, 0.003, 0.003, 0.003, 0.003, 0.003, 0.003, 0.003,
0.003, 0.003] ]; //3ms
Dlink=[0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01,
0.01, 0.01, 0.01]; //10ms
Dflow=[0.04, 0.04, 0.04, 0.04, 0.04, 0.04, 0.04, 0.04, 0.04, 0.04,
0.04, 0.04, 0.04, 0.04, 0.04, 0.04, 0.04, 0.04, 0.04, 0.04,
0.04, 0.04, 0.04, 0.04, 0.04, 0.04, 0.04, 0.04, 0.04, 0.04,
0.04, 0.04, 0.04, 0.04, 0.04, 0.04, 0.04, 0.04, 0.04, 0.04,
0.04, 0.04, 0.04, 0.04, 0.04, 0.04]; //40ms
If r is a range , v[r] is not a value!
So in your model you should change
cons19: sum(<o2,d2> in Lin) IL[<o2,d2>][f][1..2][9][1..1][10] == I[v][9][f][1..2];
cons20: sum(<o1,d1> in Lout) IL[<o1,d1>][f][1..2][9][1..1][10] == I[v][9][f][1..2];
into
cons19: sum(<o2,d2> in Lin) IL[<o2,d2>][f][1][9][1][10] == I[v][9][f][1];
cons20: sum(<o1,d1> in Lout) IL[<o1,d1>][f][1][9][1][10] == I[v][9][f][1];
At least this will solve the error and you will be able to go further
My code is represented in Dart, but this is more general to the Binary Tree data structure and Register-based VM implementation. I have commented the code for you to understand if you do not know Dart as well.
So, here are my nodes:
enum NodeType {
numberNode,
addNode,
subtractNode,
multiplyNode,
divideNode,
plusNode,
minusNode,
}
NumberNode has a number value in it.
AddNode, SubtractNode, MultiplyNode, DivideNode, they are really just Binary Op Nodes .
PlusNode, MinusNode, are Unary Operator nodes.
The tree is generated based off Order of Operations. Unary Operation first, then multiplication and division, and then addition and subtraction. E.g. "1 + 2 * -3" becomes "(1 + (2 * (-3)))"
Here is my code to trying to walk over the AST:
/// Converts tree to Register-based VM code
List<Opcode> convertNodeToCode(Node node) {
List<Opcode> result = [const Opcode(OpcodeKind.loadn, 2, -1)];
bool counterHasBeenZero = false;
bool binOpDebounce = false;
int counter = 0;
List<Opcode> convert(Node node) {
switch (node.nodeType) {
case NodeType.numberNode:
counter = counter == 0 ? 1 : 0;
if (counter == 0 && !counterHasBeenZero) {
counterHasBeenZero = true;
} else {
counter = 1;
}
return [Opcode(OpcodeKind.loadn, counter, (node as NumberNode).value)];
case NodeType.addNode:
var aNode = node as AddNode;
return convert(aNode.nodeA) +
convert(aNode.nodeB) +
[
const Opcode(
OpcodeKind.addn,
0,
1,
)
];
case NodeType.subtractNode:
var sNode = node as SubtractNode;
var result = convert(sNode.nodeA) +
convert(sNode.nodeB) +
(binOpDebounce
? [
const Opcode(
OpcodeKind.subn,
0,
0,
1,
)
]
: [
const Opcode(
OpcodeKind.subn,
0,
1,
)
]);
if (!binOpDebounce) binOpDebounce = true;
return result;
case NodeType.multiplyNode:
var mNode = node as MultiplyNode;
var result = convert(mNode.nodeA) +
convert(mNode.nodeB) +
(binOpDebounce
? [
const Opcode(
OpcodeKind.muln,
0,
0,
1,
)
]
: [
const Opcode(
OpcodeKind.muln,
0,
1,
)
]);
if (!binOpDebounce) binOpDebounce = true;
return result;
case NodeType.divideNode:
var dNode = node as DivideNode;
var result = convert(dNode.nodeA) +
convert(dNode.nodeB) +
(binOpDebounce
? [
const Opcode(
OpcodeKind.divn,
0,
0,
1,
)
]
: [
const Opcode(
OpcodeKind.divn,
0,
1,
)
]);
if (!binOpDebounce) binOpDebounce = true;
return result;
case NodeType.plusNode:
return convert((node as PlusNode).node);
case NodeType.minusNode:
return convert((node as MinusNode).node) +
[Opcode(OpcodeKind.muln, 1, 2)];
default:
throw Exception('Non-existent node type');
}
}
return result + convert(node) + [const Opcode(OpcodeKind.exit)];
}
I tried a method to just use 2-3 registers and using a counter to track where I loaded the number in the register, but the code gets ugly real quick and when I'm trying to do Order of Operations, it gets really hard to track where the numbers are with the counter. Basically, how I tried to make this code work is just store the number in register 1 or 0 and load the number if needed to and add the registers together to equal to register 0. Example, 1 + 2 + 3 + 4 becomes [r2 = -1.0, r1 = 1.0, r0 = 2.0, r0 = r1 + r0, r1 = 3.0, r0 = r1 + r0, r1 = 4.0, r0 = r1 + r0, exit]. When I tried this with multiplication though, this became very hard as it incorrectly multiplied the wrong number which is possibly because of the order of operations.
I tried to see if this way could be done as well:
// (1 + (2 * ((-2) + 3) * 5))
const code = [
// (-2)
Opcode(OpcodeKind.loadn, 1, -2), // r1 = -2;
// (2 + 3)
Opcode(OpcodeKind.loadn, 1, 2), // r1 = 2;
Opcode(OpcodeKind.loadn, 2, 3), // r2 = 3;
Opcode(OpcodeKind.addn, 2, 1, 2), // r2 = r1 + r2;
// (2 * (result) * 5)
Opcode(OpcodeKind.loadn, 1, 2), // r1 = 2;
Opcode(OpcodeKind.loadn, 3, 5), // r3 = 5;
Opcode(OpcodeKind.muln, 2, 1, 2), // r2 = r1 * r2;
Opcode(OpcodeKind.muln, 2, 2, 3), // r2 = r2 * r3;
// (1 + (result))
Opcode(OpcodeKind.loadn, 1, 1), // r1 = 1;
Opcode(OpcodeKind.addn, 1, 1, 2), // r1 = r1 + r2;
Opcode(OpcodeKind.exit), // exit halt
];
I knew this method would not work because if I'm going to iterate through the nodes I need to know the position of the numbers and registers beforehand, so I'd have to use another method or way to find the number/register.
You don't need to read all of above; those were just my attempts to try to produce register-based virtual machine code.
I want to see how you guys would do it or how you would make it.