1

[Ide gondoltam beküldeni, de csak Q3:

https: // www. springer. com/ journal/ 10703/ submission-guidelines
–Ez kafa, ebbe nem lehet belekötni.. szép az editoral board]
[Vagy legyen inkább ez a Q2: https: // www. springer. com/ journal/ 10601 ]

abstract

1 Introduction

[Ezt a végén megírjuk, a korábbi cikkek bevezetőit összefésülve + az új dolgokról]

Nowadays, the efficiency of energy usage is one of the trends and a hot topic in
scientific research. As a technical information society, energy consumption in wired and
wireless networks is a big challenge for many reasons. Extending the default network life
(e.g., Wireless Sensor Network (WSN)), optimising energy use, and reducing bills(e.g.,
Data Center Networks).
WSN is a set of sensor nodes spread across an environment, communicating with
each other to collect data about the target environment. The energy consumption is
associated with the sensor (actuator) device’s battery, which is tiny with low capac-
ity. Therefore the first aim of the current paper is to maximise the WSN’s lifetime
by generating optimal sleep/wake-up scheduling while respecting specific security and
dependability constraints.
On the other side, Data Center Network (DCN) is one of the world’s highest power
consumption costs. The global need for data storage and processing is snowballing as
our world is increasingly connected. By 2025, global demand will be an estimated 180
Zetta bytes, the equivalent of every single person alive today needing 48 laptops for
data storage [43]. In the meantime, with this enormous increase in the data centre size,
power demand will increase proportionally, inspiring researchers to innovate different
ideas to minimize the problem as much as possible.
The current DCNs consume significant amounts of power since the size of the traffic
demand does not proportion to power consumption. This makes the reduction of data
center energy consumption an essential battle in the world’s green transition.
This paper presents a comprehensive study of formal approaches that improve
power usage efficiency in the WSNs and DCNs with intensive experiments using the
leading solvers and the numerical results of many generated problems.
The rest part of the paper is organized as follows, ......

2 Literature

[Here we summarize our old versions models and some of resent studies in two parts:]
This section outlines the robustness and limitations of recent formal methods and
approaches that address the power consumption decrease challenge in WSNs And
DCNs.

2.1 Wireless sensor network

[TO DO: Mohammed: Could you try to write this section?]

2

Most of the related work used heuristic algorithms to maximize the lifetime of
the WSNs [45, 40, 13]. The results have shown a feasible solution for a few hundred
sensors to monitor tens of targets with a low coverage rate without considering the
dependability security constraints.

On the other hand, some researchers use Satisfiability Modulo Theories (SMT) tool
to solve constraints. Such a study in [27] proposes a satisfiability modulo theory-based
algorithm to solve the K-coverage problem, and the experiment shows improvement
in the performance of WSN in both terms of problem size and computing speed. The
Satisfiability Modulo Theories -based formalizations model is presented in [17]. Two-
direction problem is solved. K-coverage and reliable problems. The experiment was
carried out using Yices SMT Solver. Furthermore, it is worth pointing out that both
above studies introduce scheduling models to sleep and wake up the sensor nodes that
satisfy the security and coverage constraints without considering the maximization of
the lifetime of the WSNs.

While satisfiability modulo theories solving (SMT) aims at checking logical formulas
for satisfiability, optimization modulo theories (OMT) solving also incorporates exten-
sions with optimization capabilities (i.e., minimization and maximization problems).
In this context comes our last contribution in [28], OMT formalization is introduced
to maximize the lifetime of the WSNs for a single-hop wireless network that satisfies
the coverage and security constraints, the benchmarks were exported from a real-time
WSNs simulation. The experiment was implemented in three types of OMT solvers:
OptiMathSAT, Symba, and Z3. The results showed that OptiMathSAT outperforms
the other tools with consistent performance, and the benchmarks did not represent a big
challenge for OMT solvers. This encouraged us to contribute in [31], to study the effect
of the graph density and distribution on the lifetime of the WSNs. The results reported
the medium-graph density (i.e., the density of 40-50% ). It is the minimum density to
get an acceptable network lifetime. While the hight-graph density (i.e., the density of
80-90% ) formed enough challenge for OMT solvers to find the optimal solutions. We
followed-up In [33], the architecture of neO was introduced, and several experiments
were reported with fixed sensing ranges. The SAT solver MiniCARD, which natively
supports BCCs, is run beside the CNF-based SAT solvers MiniSat, Glucose, and Lin-
geling, in parallel with the SMT solvers Z3 and MathSAT. The result demonstrates
how different cardinality encodings, i.e., Sequential counters, Cardinality networks, etc,
influence the performance of SAT solvers on our WSN benchmarks. We concluded that
sequential counters outperform encoding on our benchmarks. Finally, in [30] we intro-
duced our OMT solver called Puli, which applied different search algorithms, binary
and linear regression. The experiment is reported by displaying the average runtime
followed by the number of solved instances in which the proposed solver outperforms
the other OMT solver in terms of the runtime and the number of benchmark instances
solved.

To the best of our knowledge, all the above papers test the WSNs with Fixed
Sensing Ranges. This paper will introduce a new novel model with Adjustable Sensing
Ranges and run it in neO – Portfolio Solver that we contribute in the current study as
an upgrade version of [33].
 3

2.2 Data center network

In the [22], the first formal model appears. The model is a standard multicommodity
flow (MCF) problem. The model aims to find a flow assignment that satisfies the
constraints to save power usage: (1) Multi-Commodity Network Flow, (2) deactivated
links have no traffic, and (3) correlates link and switch decision variable. The input
variables are the Traffic Matrix (MT), topology, and power mode of the switches, and
the output is the subset of the link and switches. However, the authors solve the model
using General Algebraic Modeling System (GAMS) and, MathProg. In contrast, the
proposed model tests using a wild range of operation research solvers.
The study in the [47] constructs a 0-1 Integer Linear Programming (ILP) formula.
The objective function minimizes the power consumption of integrated line cards and
chassis. The objective function is subject to link utility and packet delay constraints.
In the same context, another ILP model presents in [2]. The objective function aims
to manage the MAX/MIN limit of link utility to keep the network performance at an
acceptable level. However, the experimenting of both studies out of DCNs.
The scheduling Objective function proposed in [49], aims to allow a flow to monop-
olize all the links of the respective path and can be transmitted with the total capacity
of links. Such a method is not fit for time-sensitive traffic (i.e., streaming and real-time
traffics), and the flows with higher priorities can preemptively route along the paths
of other flows with lower priorities.
In our last contribution in cibernatica, we discuss an optimization method for
power consumption for DCN. an ILP problem is proposed, and the model minimizes
the number of used links based on interface switches ports under multi-constraints. We
considered the leading solvers (i.e., gurobi, scip, etc.). The paper shows the numerical
results of many generated traffic in DCN (i.e., small, mid, and long traffic patterns).
All the above studies succeed to a certain degree in improving the power usage of
the networks. However, some of the designs are too specific topologies. On the other
hand, some of them are independent of topology structures. All those facts encouraged
the authors to design new models to optimize the power usage in DCNs, explore a wide
range of state-of-the-art optimization tools, and compare their experimental results in
the current study. we follow-up In [33], the architecture of neO was introduced, and sev-
eral experiments were reported with fixed sensing ranges. Table 3 shows some of those
results, where the SAT solver MiniCARD, which natively supports BCCs, is run beside
the CNF-based SAT solvers MiniSat, Glucose, and Lingeling, in parallel with the SMT
solvers Z3 and MathSAT. The result demonstrates how different cardinality encodings,
i.e., Sequential counters, Cardinality networks, etc, influence the performance of SAT
solvers on our WSN benchmarks. we concluded that sequential counters outperform
encoding on our benchmarks. [TO DO: I have to proceed more with limitations and
new contribution]
Our contributions in the current paper are summarized as follows:

Preliminaries

A literal l is a Boolean variable x or its negation ¬x. A clause is a disjunction l1 ∨

· · · ∨ lk of literals. A Boolean formula is in Conjunctive Normal Form (CNF), if it is a
conjunction of clauses. We say that a Boolean formula, typically in CNF, is satisfiable
(SAT), if there exists a truth assignment to the Boolean variables of the formula such
4

that the formula evaluates to true. Otherwise, it is said to be unsatisfiable (UNSAT).

The Boolean Satisfiability (SAT) problem is the problem of determining if a Boolean
formula is satisfiable.
Satisfiability Modulo Theories (SMT) is the decision problem of checking the sat-
isfiability of a Boolean formula with respect to some background theory. Common
theories include the theory of integers, reals, fixed-size bit-vectors, etc. The logics that
one could use might differ from each other in the linearity or non-linearity of arithmetic
and the presence or absence of quantifiers. In this paper, we use the theory of integers
combined with linear arithmetic and without quantifiers – denoted as QF_LIA in the
SMT-LIB standard [8].
Optimization Modulo Theories (OMT) is an extension of SMT with objective func-
tions to maximize or minimize. An OMT problem, therefore, contains not only a for-
mula to satisfy, but also an expression max : obj or min : obj, where obj denotes the
objective function. There exist only a few SMT solvers that provide OMT solving.
A Boolean cardinality constraint (BCC) is defined as an expression
k
X
li ◦rel c (1)
i=1

where l1 , . . . , lk are literals, ◦rel ∈ {≤, ≥}, and c ∈ N is a constant where 0 ≤ c ≤ k.

A pseudo-Boolean constraint (PBC) can be considered to be a “weighted” BCC,
and can be defined as an expression
k
X
wi li ◦rel c (2)
i=1

where wi ∈ N, wi > 0.

Proposition 1 Any “AtLeast” PBC

k
X
wi li ≥ c
i=1

can always be translated to an “AtMost” PBC

k
X k
X
wi · ¬li ≤ wi − c
i=1 i=1

and vice versa.

Reifying a constraint C creates a new constraint

l⇔C

where l is a Boolean literal.

An indicator constraint means almost the same, except for that it applies implica-
tion instead of equivalence, in the form of

l⇒C

Note that a reified constraint can always be translated to a conjunction of two indicator
constraints, namely (l ⇒ C ) ∧ (¬l ⇒ ¬C ).
 5

Proposition 2 An indicator PBC

k
X
l ⇒ wi l i ≥ c
i=1

can always be translated to the PBC

k
X
wi li + c · ¬l ≥ c (3)
i=1

Note that this constraint encodes the implication in a proper way. IfPl evaluates to
k
false, then (3) gets immediately satisfied. If l evaluates to true, then i=1 wi li ≥ c
entails (3).

3 WSN Optimization

3.1 Motivating Example for WSN Optimization

Figure 1 shows a simple WSN with 5 sensor nodes (red dots). All of the sensor nodes
have the same sensing ranges, illustrated by blue circles. The task for the sensor nodes
is to constantly monitor the 2 target points (green and yellow dots).

Fig. 1: Simple WSN with 5 sensor nodes of uniform ranges and 2 target points.

Speaking of coverage,
6

– 1st and 2nd sensors cover only the green point,

– 3rd and 5th sensors cover both points,
– 4th sensor covers only the yellow point.
In this simple example, let us suppose that each sensor node can be active for at most 2
time intervals in total. Also, let us check 2-coverage, that is, let us insist on each target
point to be monitored by at least 2 sensor nodes at any time. The question is how
to generate a sleep/wake-up scheduling for this WSN in order to provide a maximal
lifetime.
The simplest solution would be to run the 3rd and 5th sensors together. However,
this solution would keep the WSN alive only for 2 time intervals, which is clearly not
the optimum. It is easy to see that those two sensors should also be run separately
from each other and together with the remaining three sensors in a kind of rotation.
For instance, the following scheduling provides a lifetime of 3 for the WSN:
1st time interval ⇒ run the 3rd and 5th sensors;
2nd time interval ⇒ run the 1st , 3rd , and 4th sensors;
3rd time interval ⇒ run the 2nd , 4th , and 5th sensors.
Notice that it is impossible to provide a longer lifetime for this WSN when checking
2-coverage, thus, the optimal lifetime equals to 3.

3.2 WSN Models and Constraints

The main objective is to prolong the lifetime of a WSN as much as possible, which
basically means to maximize the energy efficiency or, in other words, to minimize the
overall power consumption. The lifetime of a WSN is divided into a discrete number
of time intervals. Let T ∈ N denote the lifetime of the WSN and, thus, the objective
function is max : T . A sensor node can be either in an active or a sleep mode along
a time interval, and can switch mode only at the beginning of the subsequent time
interval.
Let n ≥ 1 denote the number of sensor nodes. In this paper, we are focusing on
point coverage, where the objective for the sensor nodes is to cover a set of m ≥ 1
target points. Although each sensor node and each point has a physical location, this
can be neglected in our model, since it is sufficient to know the physical distance, taken
pairwise, between each sensor node and target point, denoted by the constant Di,j for
the ith sensor node and the j th point.
In this paper, we are about to verify following constraints:
Coverage constraint [46, 14, 12]. Every point must be covered by at least K sensor
nodes at any time, where K ≥ 1 is a predefined constant.
Evasive constraint [9, 18, 29]. In a hostile environment or in critical systems, it is
important to protect the sensors from being active for too long. In such applications,
each sensor node must not stay active for more than E consecutive time intervals,
where E ≥ 1 is a predefined constant.
Moving target constraint [18, 29]. To improve resiliency and security, some critical
points may require not be covered by the same sensor for more than M consecutive
time intervals, where M ≥ 1 is a predefined constant and M < E.
In case of checking the moving target constraint, a set CR ⊆ [1, m] of critical points
are given in advance.
 7

3.2.1 WSNs with Fixed Sensing Ranges

Let the Boolean variables

xi,t , for all 1 ≤ i ≤ n, 1 ≤ t ≤ T,

denote if the ith sensor node is awake at the tth time interval. In this model, if a sensor
node is awake, then it operates with a fixed sensing range Ri , which has been predefined
for each sensor node separately. However, those sensing ranges can be heterogeneous
in this model. The greater the sensing range of a sensor node is, the shorter its lifetime
is, which can be calculated in advance. In a similar fashion, based on the fixed sensing
ranges, it can be checked in advance which sensor nodes can cover which target points.
Therefore, in this formal model, we do not need to deal with the constants Di,j and
Ri at all, but we can introduce the following constants in advance:

– sensor nodes’ lifetime: Li ∈ N for all 1 ≤ i ≤ n;

– target points’ sensors: the set Sj ⊆ [1, n] of sensor nodes which can cover the j th
target point, for all 1 ≤ j ≤ m. By definition,

Sj = {i | Di,j ≤ Ri , 1 ≤ i ≤ n}

The following constraints are defined on this WSN model:

Lifetime constraint. For each sensor node, the number of time intervals at which
the node is awake must not exceed the node’s lifetime Li .

T
X
∀i (1 ≤ i ≤ n). xi,t ≤ Li
t=1

Coverage constraint.

X
∀j, t (1 ≤ j ≤ m, 1 ≤ t ≤ T ). xi,t ≥ K
i∈Sj

Evasive constraint.

tX
+E
∀i, t (1 ≤ i ≤ n, 1 ≤ t ≤ T − E ). xi,t′ ≤ E
t′ = t

Moving target constraint.

tX
+M
∀j ∈ CR, ∀i ∈ Sj , ∀t (1 ≤ t ≤ T − M ). xi,t′ ≤ M
t′ =t

Note that the formalization of all the constraints utilizes BCCs.

8

3.2.2 WSNs with Adjustable Sensing Ranges

In this model, every sensor node can perform on L ∈ N different levels. Let the Boolean
variables
xli,t , for all 1 ≤ i ≤ n, 1 ≤ t ≤ T, 1 ≤ l ≤ L,

denote if the ith sensor node is performing on the lth level at the tth time interval. A
sensor node is considered to be in sleep mode at the time interval t if ¬x1i,t ∧ · · · ∧ ¬xL
i,t .
Otherwise, a sensor node can perform only on one level at the same time, which can
be represented by the following constraint:

L
X
∀i, t (1 ≤ i ≤ n, 1 ≤ t ≤ T ) : xli,t ≤ 1
l=1

This is a simple Boolean cardinality constraint, but, alternatively, it can also be ex-
pressed as a set of the binary clauses

∀ 1 ≤ i ≤ n, 1 ≤ t ≤ T, 1 ≤ l1 , l2 ≤ L, l1 ̸= l2 : ¬xli,t
1
∨ ¬xli,t
2

In actual sensor node hardware, there exist plenty of numerical features accompanied
with performance levels, see Section ??. In this WSN model, the following constants
have to be specified in advance:

– sensor nodes’ full power (in µA): Fi ∈ N for all 1 ≤ i ≤ n;

– sensor nodes’ power consumption on different performance levels (in µA): Pi,l ∈ N
for all 1 ≤ i ≤ n, 1 ≤ l ≤ L;
– sensor nodes’ sensing ranges on different performance levels (in m): Ri,l ∈ N for all
1 ≤ i ≤ n, 1 ≤ l ≤ L.
Let us now adopt the definitions for the lifetime, coverage, evasive and moving target
constraints to this WSN model, as follows:

Lifetime constraint. Taking the power consumption on different performance levels

into account, the overall power consumption of each sensor node must not exceed
the full power of that node.

T X
X L
∀i (1 ≤ i ≤ n). Pi,l · xli,t ≤ Fi
t=1 l=1

Coverage constraint. For the new definition of the coverage constraint, we need to
represent if the ith sensor node covers the j th target point at the tth time interval.
Let us introduce the Boolean variables ci,j,t and constrain them as follows:

L
X
∀i, j, t (1 ≤ i ≤ n, 1 ≤ j ≤ m, 1 ≤ t ≤ T ). Ri,l · xli,t ≥ ⌈Di,j ⌉ ⇔ ci,j,t
l=1

Then, the coverage constraint can be formalized as follows:

n
X
∀j, t (1 ≤ j ≤ m, 1 ≤ t ≤ T ). ci,j,t ≥ K
i=1
 9

Evasive constraint.

tX
+E X
L
∀i, t (1 ≤ i ≤ n, 1 ≤ t ≤ T − E ). xli,t′ ≤ E (4)
t′ =t l=1

Moving target constraint.

tX
+M
∀i, j, t (1 ≤ i ≤ n, j ∈ CR, 1 ≤ t ≤ T − M ). ci,j,t′ ≤ M
t′ =t

Note that the formalization of the lifetime and coverage constraints now utilizes
PBCs as well, including reified ones. BCCs are applied by the coverage, evasive, and
moving target constraints. The rest of the formalization can be expressed as a set of
Boolean clauses.

Remark 1 The evasive and moving target constraints in both WSN models are ex-
pressed as BCCs that make the sum of k + 1 Boolean variables less than or equal to
Pk+1 Wk+1
k. Such a BCC i=1 xi ≤ k can always be translated to a Boolean clause i=1 ¬xi .
This trick can also be applied to the evasive constraint (4), but first, it requires to
introduce of fresh Boolean variables by

L
_
∀i, t (1 ≤ i ≤ n, 1 ≤ t ≤ T ). xli,t ⇔ ai,t
l=1

and then to construct the clause

t_
+E
∀i, t (1 ≤ i ≤ n, 1 ≤ t ≤ T − E ). ¬ai,t′
t′ = t

3.3 Encoding of Constraints

[Some introduction...]

3.3.1 Encodings of Reified Pseudo-Boolean Constraints

While the WSN model in Section 3.2.1 can be encoded as a set of Boolean cardinality
constraints, the encoding of the WSN model in Section 3.2.2 requires to use various
kinds of constraints. There the most general kind of a constraint is a reified “AtLeast”
PBC
k
X
l ⇔ wi li ≥ c (5)
i=1

Such reified constraints are typically not supported by solvers, therefore one might
need to be encode them in different ways, depending on the target approach. Since
10

some solvers do support indicator constraints, it is worth to unfold (5) into a pair of
indicator constraints (assume c > 0):
k
X
l ⇒ wi l i ≥ c
i=1
k
X
¬l ⇒ wi l i ≤ c − 1
i=1

In case of PBC solvers that do not even support indicator constraints, the above con-
straints must be further translated to PBCs according to Propositions 1 and 2.

3.3.2 Encoding into Boolean Cardinality Constraints

Any PBC (2) can be further translated to a BCC

k
X
li + · · · + li ◦rel c,
| {z }
i=1 wi

which can then be solved by cardinality solvers with duplicated-literal handling, such
as MiniCARD [35].
Note that both Sections 3.2.1 and 3.2.2 apply Boolean clauses as well. A clause
l1 ∨ · · · ∨ lk can be interpreted as a BCC
k
X
li ≥ 1
i=1

3.3.3 Encoding into SAT

Recall that Sections 3.2.1 and 3.2.2 apply lots of BCCs, as well as the encoding of
PBCs in Section 3.3.2. Depending on what solving approach we want to apply to a
given set of BCCs, we might need to encode them. For instance, if we want to apply
SAT solvers, then those BCCs must typically be encoded by Boolean
Pk formulas in CNF.
Fortunately, there exist several techniques for encoding a BCC i=1 li ≥ c into CNF.

Sequential counters. The core

Pidea is to use a sequential counter circuits [44] in order to
i
computer partial sums si = j =1 lj , up to i = k. The value of each si is represented by
a unary number, encoded by the Boolean variables si,j . The following Boolean formula
encodes the BCC:

(l1 ⇔ s1,1 )
∧ ¬s1,j for j ∈ [2, c]
∧ (si,1 ⇔ li ∨ si−1,1 ) for i ∈ [2, k]


∧ si,j ⇔ (li ∧ si−1,j−1 ) ∨ si−1,j for i ∈ [2, k], j ∈ [2, c]

All the Boolean variables si,j are introduced as fresh variables and the formula above
can be converted into its CNF [44]. Evidently, the variable sk,c represents the Boolean
result of the BCC.
 11

Cardinality networks. They yield another, refined approach for encoding BCCs. A
cardinality network encoding [1] divides the BCC into multiple instances of the base
operations half sorting and simplified half merging, which basically work as building
blocks.

Modulo totalizer. This cardinality encoding [39] and its variant for k-cardinality [37]
improve the above-described approach based on cardinality network, especially in con-
nection with MaxSAT solving. The modulo totalizer approach of [39] addresses lim-
itations of the half sorting cardinality network approach from [1], by using totalizer
encodings from [5] in order to reduce the number of variables during CNF encodings.

Native support for BCCs. Another way of applying SAT solving to BCCs is to handle
BCCs natively inside CDCL SAT solvers, by using the same clause data structure and
the same techniques SAT solvers apply to clauses. The goal is to incur littlePoverhead as
k
opposed to CNF encoding. Recall that a clause l1 ∨· · ·∨lk is simply a BCC i=1 li ≥ 1,
thus a clause is a special case of a BCC. Consequently, the necessary modifications to
the clause data structure are minimal: the 2-watched-literal scheme has to be extended
to a (c + 1)-watched-literal scheme. Of course, some of the CDCL techniques, such as
constraint propagation and conflict analysis, has to be extended, but the magnitude
of those changes is quite minimal. The SAT solver MiniCARD [35] handles Boolean
cardinality constraints natively on the level of watched literals and conflict analysis 1 ,
instead of translating them into CNF.

3.3.4 Encoding into SMT

It is straightforward to directly encode BCCs into SMT over the logic QF_LIA, which
provides (1) the types Bool and Int; (2) the arithmetic operator +; (3) the relational
operators <= and >=. Summing over Booleans, however, is typically not supported by
SMT solvers, therefore one might need to implement a “boolToInt” function, such as
the following one in the SMT-LIB format:

Listing 1: boolToInt implementation in SMT-LIB.

( define - fun boolToInt (( b Bool )) Int ( ite b 1 0))

3.4 Implementation and Experiments

3.4.1 Benchmarks

In [29, 32, 30, 33], we made a lot of WSN benchmarks publicly available. Note that all
those benchmarks capture WSNs with fixed sensing ranges.
In the public repository of our open-source tool neO, which we will introduce in
detail in Section 3.5, a new set of benchmarks is available at https://github.com/
kovasz/neO/tree/master/benchmarks, capturing WSNs with fixed ranges as well as
with adjustable ranges. For neO, we introduced a JSON input format to read data
about sensor nodes and target points. The structure of this JSON format can be seen
in Listings 2 and 3.
1 Poster available at https://sun.iwu.edu/~mliffito/publications/sat12_liffiton_

minicard_poster.pdf
12

Listing 2: JSON format for WSNs of Listing 3: JSON format for WSNs
“Model 1”, i.e., with Fixed Ranges. of “Model 2”, i.e., with Adjustable
{ Ranges.
" version ": 1 , {
" sensors ": [ " version ": 2 ,
{ " sensors ": [
" x ": . . ., {
" y ": . . ., " x ": . . .,
" range ": . . . " y ": . . .,
} " power ": . . .
... }
], ...
" points ": [ ],
{ " levels ": [
" x ": . . ., {
" y ": . . ., " power ": . . .,
" critical ": true / false " range ": . . .
} }
... ...
] ],
} " points ": [
{
" x ": . . .,
" y ": . . .,
" critical ": true / false
}
...
]
}

The property version refers to the version number of the WSN model, which is 1 in
case of fixed sensing ranges and 2 in case of adjustable ones. The integer properties x
and y represent the physical position of a sensor node or a target point. The Boolean
property critical tells if a target point is marked as critical or it is not. The integer
property range represents the fixed sensing range (denoted by Ri ) of a node, or in
case of adjustable sensing ranges, the integer property power represents the initial full
power (denoted by Fi ) of a node. The possible performance levels are declared in the
array levels. Each level is defined by its power consumption power (denoted by Pi,l )
and sensing range range (denoted by Ri,l ).
For setting the property values in the benchmark instances, we choose an IEEE
802.15.4 compatible sensor node that is able to communicate wirelessly and has com-
mon parameters. Such sensor nodes are provided with an RF transceiver with an
estimated range of 100 − 120m. To accurately define the different ranges for differ-
ent performance levels, we choose a commonly used RF transceiver, the CC2420 2 .
While, depending on the operating system of the sensor node, 32 to 256 different per-
formance levels can be defined, the manufacturer of CC2420 published data about 8
performance levels, for which we calculated the estimated sensing ranges in [29]. In
Table 1, data about those performance levels are given, where the estimated sensing
ranges are rounded to the nearest integers.
In terms of WSN constraints, we will use the following abbreviations for the fol-
lowing 4 sets of constraints:
2 http://www.ti.com/lit/ds/symlink/cc2420.pdf
 13

PA_LEVEL Power (mW ) Consumption (mA) Estimated Range (m)

31 1.000 17.4 120
27 0.794 16.5 109
23 0.501 15.2 92
19 0.316 13.9 75
15 0.200 12.5 58
11 0.100 11.2 41
7 0.032 9.9 25
3 0.003 8.5 7

Table 1: Estimated ranges for the different performance levels of a sensor node equipped
with a CC2420 RF transceiver.

K2. Coverage constraint with K = 2.

K2E2. K2 + evasive constraint with E = 2.
K2M1. K2 + moving target constraint with M = 1.
K2E2M1. K2E2 + K2M1.

3.4.2 Experiments with OMT Solvers

In [29], we generated Optimization Module Theories (OMT) benchmarks for WSNs and
applied existing OMT solvers to solve the optimization problem for WSNs of “Model
1”. This required the same SMT encoding of the WSN constraints, but also adding an
objective function, which is, of course, the WSN’s lifetime to maximize. In those experi-
ments, we compared the performance of OptiMathSAT [42], Z3 [11], and Symba [34].
We concluded there that OptiMathSAT provided the most stable performance and
scaled the best. The follow-up paper [32] investigates further aspects of WSNs, in par-
ticular their density, that can make the OMT solving process more challenging. We
reported on further benchmarks and experiments with OptiMathSAT.

3.4.3 Puli – A Problem-Specific OMT solver

In [30], we introduced our OMT solver called Puli, which applied different search
algorithms, including linear regression-guided search, as follows:
Linear search. We set T to the lowest possible value 1 and then, after each satisfiable
instance, increment T by one. When we hit the first UNSAT instance, the optimum
T − 1 can returned.
Linear search boosted by linear regression. A speed-up is proposed for linear search by
applying regression analysis. To use this approach, we need to define

a so-called
resource function fres , in order to obtain data points T, fres (T ) for regression
analysis. For a WSN, the charge of the batteries of sensor nodes can be considered
to be such a resource, which is continuously decreasing until draining. This is
estimated by the following resource function:
n
X n X
X T
fres (T ) = Li − xi,t
i=1 i=1 t=1

The value of the resource function is obtained by summing the lifetime of all the
sensor nodes (which is the theoretical maximum of the network’s lifetime), and
14

then subtracting the sum of the time intervals that have been used up so far. This
is the only search strategy which needs to obtain the satisfying model from the
underlying solver in each iteration, which suffers from overhead. However, based
on our experiments, this pays off in comparison with simple linear search [30].
Binary search. We use a lower bound lb and an upper bound ub, and set the next value
of T to lb+2ub . In the WSN context, lb stores the highest lifetime of satisfiable (SAT)
instances so far and, similarly, ub the lowest lifetime of unsatisfiable (UNSAT)
instances so far. Since the sensor nodes together cannot be active for longer than
the sum of their individual lifetimes (Li ) and at least K sensor nodes must be
active in each time interval, we use the initial values
Pn
i=1 Li
lb = 1 and ub =
K
In those experiments, each benchmark included 20 instances. The time limit was
set to 1200 seconds. Table 2 shows some of the experimental results with OMT solvers
from [30]. In the table, each experiment is reported by displaying the average runtime
followed by the number of solved instances in parentheses, out of 20.

Puli Puli
with with OptiMathSAT Z3 Symba
lin−reg binary
K2 40.55 (20) 11.5 (20) 794.5 (14) 12.65 (20) 155.1 (20)
K2E2 141.15 (20) 35.8 (20) 619.5 (18) 589.55 (12) 820.2 (11)
K2M1 53.55 (20) 23.35 (20) 190.5 (19) 446.35 (17) 583.55 (17)
K2E2M1 93.4 (20) 42.3 (20) 192.8 (20) 774.7 (9) 1098.8 (4)

Table 2: OMT solvers’ results for “Model 1” WSNs of 80-90% density with 10 sensor
nodes and 4 target points. [30]

3.5 neO – Portfolio Solver for WSN Optimization

In our experiments with larger WSNs [29, 32, 30] we observed that the efficiency of
OMT solvers dramatically dropped. Additionally, we observed that the bottleneck for
underlying SMT solvers was typically to solve satisfiable instances. For SAT solvers,
we observed the opposite: the SAT-based approach is rather powerful on satisfiable
instances and poor on unsatisfiable ones. Therefore, it seems to be a decent idea to run
SAT solvers and SMT solvers in parallel, in a portfolio setting. Thus, in each iteration,
both the SAT and the SMT encodings of the current WSN verification problem can be
generated and fed into the underlying SAT and SMT solvers, respectively. Then, the
solvers are executed as parallel processes. Whenever any of those solvers obtains the
result, we terminate the other solvers.
This approach, including all the encodings described in the previous sections, are
implemented in Python as part of our network optimizing solver neO, which was in-
troduced in [33]. The source code of neO is publicly available at https://github.com/
kovasz/neO. neO is a portfolio solver, meaning that it executes different kinds of solvers
 15

(for instance, SAT and SMT solvers) in parallel. The parallel execution is implemented
by instantiating ProcessPool from the Python module pathos.multiprocessing [36],
which can run jobs with a non-blocking and unordered map.
The Python package PySAT [23] provides a unified API to several SAT solvers
such as MiniSat [20], Glucose [4] and Lingeling [10]. PySAT also supports a
lot of encodings for BCCs, including sequential counters [44], cardinality networks [1]
and modulo totalizer [39, 37]. Furthermore, PySAT offers API to the SAT solver
MiniCARD [35], which handles BCCs natively, instead of translating them into CNF.
In a similar manner, the Python package pySMT [21] provides a unified API to
several SMT solvers, such as MathSAT [15], Z3 [16], CVC4 [7] and Yices [19].
Recently we have extended neO with the support for WSNs with adjustable sens-
ing ranges. Therefore, the efficiency of PBC solving has become priority. Translating
PBCs into BCCs has a significant overhead in the number of literals and, thus, in the
performance of cardinality solvers. Furthermore, the resulting BCCs typically contain
duplicated literals, which make it impractical to translate them into CNF and then
to run CNF-based SAT solvers. Therefore, it is worth to experiment with solvers that
support PBCs by default, such as Integer Linear Programming (ILP) solvers. Note
that the WSN constraints in Section 3.2.2 are a special case of ILP constraints since
(1) all decision variables are Boolean, i.e., they may only take the values 0 and 1;
(2) some constraints are reified, therefore those constraints must be translated into
regular PBCs. Recently, we have extended neO with interfacing with Google’s Python
package OR-Tools 3 , which provides a unified API to several ILP solvers, among
other kinds of operational research tools.
Since translating reified PBCs into regular PBCs has also a certain overhead, we
wanted to experiment with solvers that supported indicator constraints. Recall that
a reified constraint is equivalent with a pair of indicator constraints. The constraint
programming solver CP-SAT provides a support for indicator constraints, and is part
of the package OR-Tools. The ILP solver Gurobi also supports indicator constraints.
Since OR-Tools treats Gurobi as a regular ILP solver, it does not give an interface
to Gurobi’s support for indicator constraints. This is why we introduced to neO
Gurobi’s dedicated Python package called gurobipy, which provides functionalities
in correspondence of indicator constraints.

3.5.1 Experiments with Fixed Sensing Ranges

In [33], the architecture of neO was introduced and several experiments were reported
on WSNs of “Model 1”, i.e., with fixed sensing ranges. Table 3 shows some of those
results, where the SAT solver MiniCARD, which natively supports BCCs, is run be-
sides the CNF-based SAT solvers MiniSat, Glucose, and Lingeling, in parallel with
the SMT solvers Z3 and MathSAT. The table demonstrates how different cardinal-
ity encodings, introduced in Section 3.3.3, influences the performance of SAT solvers
on our WSN benchmarks. From these results one can easily draw the conclusion that
sequential counters outperform cardinality networks and the modulo totalizer on our
benchmarks. However, the native support for BCCs inside MiniCARD outperforms
all the other encodings.
In this paper, we report on new experiments that we execute in addition to the
ones in [33]. We investigate how well ILP solvers, as part of neO, perform on WSN
3 OR-Tools webpage: https://developers.google.com/optimization
16

SAT Encoding SMT Runtime (#Solved)

MathSAT 1.9 (20)
MiniCARD
Z3 1.6 (20)
MathSAT 3.3 (20)
Seq-Counter
Z3 3.2 (20)
MiniSat MathSAT 852.8 (7)
Card-Network
Z3 282.3 (16)
MathSAT 1097.3 (2)
kM-Totalizer
Z3 322.2 (15)
MathSAT 9.4 (20)
Seq-Counter
Z3 9.3 (20)
Glucose MathSAT 843.1 (6)
Card-Network
Z3 315.4 (15)
MathSAT 891.3 (7)
kM-Totalizer
Z3 260.3 (16)
MathSAT 94.2 (20)
Seq-Counter
Z3 16.1 (20)
Lingeling MathSAT 1065.7 (4)
Card-Network
Z3 216.6 (17)
MathSAT 759.3 (11)
kM-Totalizer
Z3 134.0 (19)

Table 3: neO’s results for “Model 1” WSNs of 80-90% density with 10 sensor nodes
and 4 target points, for K2, only with binary search. [33]

benchmarks of “Model 1”, up to 200 sensor nodes and 60 target points. All the ex-
periments were run on the benchmarks that can be found in neO’s repository https:
//github.com/kovasz/neO. As before, each benchmark includes 20 instances. The time
limit was set to 1200 seconds.
First, let us execute neO on WSN benchmarks with 20 sensor nodes and 8 target
points. Now that ILP solvers also became accessible in neO, we run CBC, SCIP,
CP-SAT, and Gurobi on the corresponding benchmarks. Table 4 shows the results.
Since the experiments in [33] suggested that the parallel execution of MiniCARD + Z3
was the best choice in terms of SAT and SMT solvers, now we include the results by
the same “duo” setting, to provide reference values. Note that now ILP solvers are also
run in a “duo” setting with MiniCARD, which further boosts the solving. The duo of
MiniCARD + Gurobi provides the lowest average runtime.
Table 5 shows the results for 50 sensor nodes and 20 target points. The duo of
MiniCARD + Z3 is not able to solve all the instances under the time limit anymore.
Nevertheless, all the other settings included in the table can still successfully solve all
the instances, although the average runtime in most of the cases increases drastically,
as compared to Table 4. The duo of MiniCARD + Gurobi seems to scale the best so
far.
We can see a very similar tendency in Table 6, which shows the results for 100 sensor
nodes and 40 target points. The duo of MiniCARD + Z3 times out on almost all the
instances and, furthermore, the ILP solvers CBC and SCIP seem to work on the limit,
even in combination with MiniCARD. Interestingly, the duos of CP-SAT + CBC
and CP-SAT + SCIP provide quite decent results, which shows that CP-SAT is
 17

CBC SCIP CP-SAT Gurobi

K2 4.97 (20) 5.75 (20) 6.21 (20) 1.83 (20)
K2E2 7.57 (20) 9.01 (20) 10.06 (20) 2.46 (20)
K2M1 7.22 (20) 9.50 (20) 14.44 (20) 2.45 (20)
K2E2M1 9.81 (20) 12.73 (20) 17.72 (20) 3.00 (20)

MiniCARD MiniCARD MiniCARD MiniCARD MiniCARD

+ + + + +
Z3 CBC SCIP CP-SAT Gurobi
K2 7.00 (20) 2.60 (20) 3.32 (20) 3.49 (20) 1.48 (20)
K2E2 13.26 (20) 3.97 (20) 5.10 (20) 5.51 (20) 1.88 (20)
K2M1 12.44 (20) 3.76 (20) 5.23 (20) 5.19 (20) 1.86 (20)
K2E2M1 19.09 (20) 5.19 (20) 7.08 (20) 7.05 (20) 2.36 (20)

Table 4: Results with ILP solvers for “Model 1” WSNs with 20 sensor nodes and 8
target points.

CBC SCIP CP-SAT Gurobi

K2 107.75 (20) 137.00 (20) 122.16 (20) 17.04 (20)
K2E2 103.58 (20) 217.42 (20) 150.14 (20) 24.45 (20)
K2M1 109.28 (20) 263.79 (20) 222.90 (20) 25.64 (20)
K2E2M1 128.22 (20) 360.89 (20) 248.32 (20) 29.27 (20)

MiniCARD MiniCARD MiniCARD MiniCARD MiniCARD

+ + + + +
Z3 CBC SCIP CP-SAT Gurobi
K2 528.85 (13) 70.33 (20) 107.43 (20) 75.46 (20) 15.01 (20)
K2E2 577.99 (13) 66.08 (20) 161.48 (20) 92.28 (20) 21.75 (20)
K2M1 562.80 (13) 68.49 (20) 184.65 (20) 114.44 (20) 21.58 (20)
K2E2M1 726.80 (11) 78.57 (20) 281.12 (20) 129.01 (20) 25.44 (20)

CP-SAT CP-SAT
+ +
CBC SCIP
K2 99.47 (20) 91.94 (20)
K2E2 104.85 (20) 141.50 (20)
K2M1 109.56 (20) 168.55 (20)
K2E2M1 129.83 (20) 240.86 (19)

Table 5: Results with ILP solvers for “Model 1” WSNs with 50 sensor nodes and 20
target points.
18

able to boost the performance of CBC and SCIP. Anyhow, all of the aforementioned
settings are outperformed by the duo of MiniCARD+ Gurobi. Since CP-SAT seemed
to be a better substitute of MiniCARD, we also ran experiments with the duo of
CP-SAT + Gurobi, but it provided higher runtimes than the solo setting of Gurobi
did, therefore we do not include this duo in the table.

CBC SCIP CP-SAT Gurobi

K2 1151.82 (2) 1001.35 (12) 218.89 (20) 46.67 (20)
K2E2 844.19 (8) 1135.93 (6) 299.06 (20) 63.56 (20)
K2M1 818.66 (9) 1131.80 (6) 401.73 (20) 65.76 (20)
K2E2M1 1011.56 (5) 1162.14 (4) 468.37 (20) 77.27 (20)

MiniCARD MiniCARD MiniCARD MiniCARD MiniCARD

+ + + + +
Z3 CBC SCIP CP-SAT Gurobi
K2 1077.07 (3) 1200.00 (0) 1126.75 (2) 118.76 (20) 39.80 (20)
K2E2 1200.00 (0) 817.56 (8) 1168.33 (1) 170.37 (20) 53.56 (20)
K2M1 1200.00 (0) 789.14 (9) 1200.00 (0) 165.20 (20) 56.12 (20)
K2E2M1 1200.00 (0) 995.34 (5) 1200.00 (0) 204.32 (20) 68.54 (20)

CP-SAT CP-SAT
+ +
CBC SCIP
K2 192.35 (20) 182.42 (20)
K2E2 234.56 (20) 286.45 (20)
K2M1 235.02 (20) 369.92 (18)
K2E2M1 290.56 (20) 469.47 (17)

Table 6: Results with ILP solvers for “Model 1” WSNs with 100 sensor nodes and 40
target points.

The largest WSNs that we experimented with consist of 200 sensor nodes and 60
target points. The results of that experiment can be seen in Table 7. CBC and SCIP
are quite useless by themselves, but they can drastically boosted by the parallel use
of CP-SAT. The resulting duos of CP-SAT + CBC and CP-SAT + SCIP even
outperform the solo setting of CP-SAT, especially when the moving target constraint
is also checked. Anyhow, Gurobi outperforms all the other solvers, especially when
being executed in the duo setting MiniCARD + Gurobi.

3.5.2 Benchmarks with Adjustable Sensing Ranges

When switching to WSNs with adjustable sensing ranges, the solving gets more diffi-
cult, as it can be expected. We generated new benchmarks for this kind of WSNs and
made them publicly available in neO’s repository https://github.com/kovasz/neO.
As before, each benchmark includes 20 instances. The time limit was set to 1200 sec-
onds.
 19

CBC SCIP CP-SAT Gurobi

K2 1200 (0) 1199.89 (1) 222.13 (20) 54.67 (20)
K2E2 1200 (0) 1157.74 (1) 371.69 (20) 82.15 (20)
K2M1 1200 (0) 1150.82 (1) 849.17 (12) 76.98 (20)
K2E2M1 1200 (0) 1123.18 (2) 904.12 (13) 102.01 (20)

CP-SAT CP-SAT MiniCARD MiniCARD

+ + + +
CBC SCIP CP-SAT Gurobi
K2 209.32 (20) 204.54 (20) 178.40 (20) 52.52 (20)
K2E2 351.09 (20) 365.04 (20) 304.20 (20) 78.68 (20)
K2M1 319.47 (20) 348.53 (20) 277.63 (20) 73.82 (20)
K2E2M1 439.50 (20) 529.85 (18) 388.30 (20) 96.61 (20)

Table 7: Results with ILP solvers for “Model 1” WSNs with 200 sensor nodes and 60
target points.

We start our “Model 2” experiments with 10 sensor nodes and 4 target points.
The results are shown by Table 8. Even for those small WSN instances, CBC and
CP-SAT are useless. Note that CP-SAT natively supports indicator constraints, thus
it could be expected to perform much better. While SCIP shows a decent performance,
Gurobi clearly outperforms it. Note that in this experiment we run Gurobi in two
different ways: (1) via OR-Tools, which does not support indicator constraints; (2) via
gurobipy, which does support indicator constraints. As one can see, the latter setting
typically outperforms the previous one by one order of magnitude with respect to
average runtime.

Gurobi Gurobi
CBC SCIP CP-SAT via via
OR-Tools gurobipy
K2 1200 (0) 192.17 (18) 1200 (0) 42.42 (20) 3.03 (20)
K2E2 1200 (0) 266.35 (16) 1200 (0) 5.33 (20) 4.70 (20)
K2M1 1200 (0) 105.50 (19) 1200 (0) 73.10 (19) 4.14 (20)
K2E2M1 1200 (0) 275.61 (16) 1200 (0) 71.72 (19) 6.52 (20)

Table 8: Results for “Model 2” WSNs with 10 sensor nodes and 4 target points.

In order to draw an even more detailed picture, Figure 2 shows the distribution of
runtimes. Notice that the vertical axis is log-scaled.
Sadly, increasing the size of WSNs to 20 sensor nodes and 8 target points causes a
drastic decline in performance, as it is shown by Table 9 and Figure 3. For instance,
the average runtime of Gurobi increases by 2 orders of magnitude in certain cases.
Let us note that we tried to boost ILP solvers’ performance by running MiniCARD
or CP-SAT in parallel, similar to what we did in the “Model 1” experiments, but this
kind of boosting did not work on those “Model 2” benchmarks.
20

Gurobi Gurobi Gurobi Gurobi

via via via via
SCIP OR-Tools gurobipy SCIP OR-Tools gurobipy
103
Runtime (s)

102

101

(a) K2. (b) K2E2.

103
Runtime (s)

102

101

(c) K2M1. (d) K2E2M1.

Fig. 2: Distribution of runtimes for “Model 2” WSNs with 10 sensor nodes and 4 target
points.

Gurobi Gurobi
SCIP via via
OR-Tools gurobipy
K2 1048.27 (5) 948.04 (5) 570.16 (13)
K2E2 1097.10 (4) 556.74 (13) 458.35 (14)
K2M1 1068.29 (5) 915.03 (5) 561.15 (15)
K2E2M1 1097.46 (4) 521.25 (13) 500.85 (13)

Table 9: Results for “Model 2” WSNs with 20 sensor nodes and 8 target points.

Notice that the repository of neO provides even larger “Model 2” benchmark in-
stances, up to 100 sensor nodes and 40 target points. We ran experiments with some
of those, but we did not find any portfolio setting of the aforementioned solvers that
was able to solve them in a reasonable time, not even the duo setting of MiniCARD +
Gurobi could. So it seems there exists a lot of promising directions toward improving
the above results. For instance, you could try to apply other solvers, such as dedicated
pseudo-Boolean solvers, instead of ILP ones. Another possibility is to try to further
improve “Model 2” by encoding its constraints in different ways.
 21

Gurobi Gurobi Gurobi Gurobi

via via via via
SCIP OR-Tools gurobipy SCIP OR-Tools gurobipy
103
Runtime (s)

102

(a) K2. (b) K2E2.

103
Runtime (s)

102

(c) K2M1. (d) K2E2M1.

Fig. 3: Distribution of runtimes for “Model 2” WSNs with 20 sensor nodes and 8 target
points.

4 DCN Optimization

4.1 Motivating Example for DCN Optimization

Figure 4, shows a Fat-tree topology with k = 4, real-world DCN topology [41]. Assume
a scenario that all of the links have the same capacity of 1Gbps, with the following
status of sending and receiving of flows at different times: at time t =1, server (C)
sends traffic with a rate of 850M bps to the server (G), at time t = 2, server (D) sends
traffic with a rate of 50M bps to the server (H), at time t =3, server (M) sends traffic
with a rate of 5M bps to the server (J), and at time t =4, server (N) sends traffic with
a rate of 5M bps to the server (I)
Figure 5 shows two different solutions. The first solution is the output of the ILP
model presented in [38], which consolidates every two flows together to minimize the
number of links (i.e., routes) between the sender and the receiver. The minimum num-
ber of links is 16. The second solution is the output of the proposed model. Due to the
symmetry of the DCNs topologies, the two models’ solution output is the same number
of links, 16. Nevertheless, the proposed model uses less number of Switches, 9 instead
10, the output of the first solution. Besides, the proposed model is able to adjust the
speed of the links to the value relevant to link utilization. as a result, more power is
saved compared to the first one.
22

Fig. 4: Fat-tree DCN topology, where K = 4.

1st solution.

1 2
Pn Pn Pn Pn
f f f f
13 9 17 5

16 12 19 7

C G M J

D H N I

2nd solution.
Pn Pn
C 16 13 f 1 f 9 12 G

Pn Pn
D f f H

17 6

19 7

M J

N I

Fig. 5: Motivation example of power optimization models, legend refers to the adaptive
values of the links at different utilization values.

4.2 DCN Models and Constraints

[TO DO: Anett, Mohammed: Could you please reorganize the entire section in a way
that the 2 models are specified in a more organized and exact way?]
For the sake of simplicity, we added a table 10 to define all symbols that we use
in the DCN model. The DCN is modeled as an undirected graph G = (S, E), where
 23

Table 10: List of Parameters.

Symbols Definition
S Setof nodes, where S = {Si , . . . , Sm }
1, if switch, Si , is active
ℓi =
0, otherwise
E Setof the edges between switches
1, if edge, eij , is active
Lij =
0, otherwise
BWij Edge (i.e., link) capacity, wherein the current study, it is equal to 1 Gbps for all links
F
set of flows
f = f.Sr , f.Ds , λf A flow represented by source, destination, and bit rate, where f ∈ F
1, if flow f crosses through the eij
F R (f, i, j) =
0, otherwise
Uij utilization of the edge eij
T Input traffic matrix where Tij denotes input traffic of eij
k number of the pods (point of delivery) in the fat-tree topology
sr source switch
ds destination switch
LP(i,j) power
 consumption of the link
1, show if the linkeij is operating on level l
Llij =
0, otherwise
LP l power consumption of the link at a specific level
LS l speed of the link at a specific level

S = {s1 , s2 , . . . , sn } is a set of switches and E ⊆ {eij | si , sj ∈ S} is a set of links.

The traffic is represented as a set of flows F, where each flow f = (f.Sr , f.Ds , λf ) ∈ F
consists of a source f.Sr ∈ S, a destination f.Ds ∈ S and a bit rate λf ∈ N.
Based on recently reviewed studies, like [3], the power consumption of the data
center network count between edges and switches. Therefore, we can calculate the
Network Power Consumption (N P C ) in (6).
X X
N P C = Ps B s + Pl Le . (6)
∀s∈S ∀e∈E
Bs and Le denote the state of switches and links, respectively, where the value 1
represents the active state and 0 the passive state. The base power consumption of
switches and links are denoted by Ps and Pl .
We use constraints against the objective function, very similar to those in [38], just
we added new ones as follows: (1) Links and Traffics correlation constraint, to
keep the correlation between traffic volume and link. As a result, the link-utility is
increased. As shown in 7
Tij
⩽ Lij , ∀eij ∈ E, (7)
BWij
(2) Links and flows correlation constraint, to keep the link active if and only
if flow f passes through it. As shown in 8

F R (f, i, j ) ⩽ L(i, j ), ∀ f ∈ F, i, j ∈ S. (8)

(3) Utility constraint, to restrict the link-utility to be less than or equal to the
link’s bandwidth BWij , as shown in (10). First, let us computer the utilization of each
link as X

Uij = F R (f, i, j ) + F R (f, j, i) · λf , ∀eij ∈ E. (9)
f ∈F

Then, the corresponding constraint is shown in (10).

Uij ≤ BWij − Tij , ∀eij ∈ E, (10)

24

(4) Path conservation constraint, to establish path between the source, Sr , and
destination, Ds , for each flow. As shown in (11)
n
X n
X
F R (f, f.Sr , i) = 1, F R (f, i, f.Dr ) = 1, ∀f ∈ F, (11)
i=1 i=1

(5) Input/Output flows constraint, have to apply on the intermediate switches

to avoid packet loss after installing the path between the source, Sr , and destination,
Ds , for each flow. As shown in 12
n
X n
X
F R (f, i, j ) = F R (f, j, i) , ∀ f ∈ F, j ∈ S. (12)
i=1 i=1
i̸=f.Sr i̸=f.Ds

(6) Network loop avoidance constraint, to avoid the looping paths (i.e, routes).
As shown in 13

F R (f, i, j ) + F R (f, j, i) ⩽ 1, ∀ f ∈ F, i, j ∈ S. (13)

(7) Graph connection constraint, to optimize the number of switches that are
embraced in the installation paths, besides mitigation to stuck-in sub-graph problems
(i.e, disconnected graph) when the paths are installed on unshared switches between
different sources and destinations, as shown in the figure 5, we add this constraint to
keep the graph connected [48]. see 14

L(i, j ) ⩽ ℓi , L(i, j ) ⩽ ℓj , i, j ∈ S. (14)

[TO DO: Dr.Anett, please, could you check the above constraint carefully (we do
not have ℓj in the definition tabe )?]

4.2.1 Consolidation and balancing model

This section describes how a data center optimization model defines the minimum
number of links, given the traffic utilization (min L | λf ) with its drawback. The model
considers the following conditions: (1) the model defines a snapshot of the network
state in a specific unit of time. (2) the model treats a standard multi-commodity flow
problem [6], and it is worth stating that based on the fact that each flow consists of
several packets, we can do breaking up each flow into multiple packets. However, in
such cases, the transmission control protocol (TCP), and all other oriented-connection
protocols, their performance will degrade a lot due to unorder packets arriving through
different paths. As a result, we incorporate restrictions into our formulation based on
the entire flow although breaking up the flow into packets leads to more power saving.
The model in [38] employed the second parameter from (6), to minimize the number
of the links as shown in (15).
 
n X
X n
min  Lij  . ∀eij ∈ E (15)
i=1 j =1

The above function is subject to the first 6 constraints that define in the section
4.2. Although the model enhances the power consumption level in the DCN, however,
in some cases, the model is stuck with a disconnected graph problem, particularly when
 25

the independent paths are selected (i.e., unshared links between paths ). To mitigate
such an effect, we will modify the objective function to be a multi-objective function
by adding a new term to minimize the number of switches, as we will explain in a
moment. The new objective function as shown in (16).
 
Xn X
n m
X
min  Lij + ℓi  . ∀eij ∈ E, ∀Si ∈ S (16)
i=1 j =1 i=1

The above objective function works against the first 7 constraints that define in the
section 4.2.
On another side, based on the results obtained from the model in [38], there are
differences in link-utilization values (i.e,. between high and low) as shown in Figure 6 4 ,
although consolidating as much as possible of flows together, however, the utilization
value of the most links is not high (e.g., the utilization value between server 4 th and
server 18 th is only 53 kbps). So there is a good chance to adapt the link speed to be
more proportional to the value of the flows rate λf , especially since it is such OpenvFlow
Switch, PF5240, works with a range of speed rates with different power consumption
[25].

Fig. 6: The links utilization to accommodate 70 flows

4.2.2 Traffics consolidation with adjustable link Speed model

[TO DO: Dr.Racz and Mohammed: review and more explanation to model]
Let us dig deeper to see how to make link speed in line with its utility. The influence
of a number of line cards and active ports, utilization, and their configured capacity,
on the power consumption of DCN is presented in [25]. The study defines the power
consumption of the OpenvFlow switch model as follows:
4 benchmark available at https://github.com/kovasz/neO-DCN/blob/main/benchmarks/

electronics2021/xlsx/f-70.xlsx
26

Pswitch = Pbase + Pconfig + Pcontrol (17)

Where the Pbase is a base power of the OpenvFlow switch, Pconfig is the power
consumption of the number of active ports, and the configuration of the ports speed,
and Pcontrol is the power consumption to control traffic (i.e., the power consumption
due to installing the rules inside the OpenvFlow switches) [26].
As well as minimizing the number of links and switches, the current model aims
to control the speed of the link. Therefore, we focus only on Pconfig . Technically, each
link consists of two ports; a lower port speed equals the link speed. This study assumes
that each link has an equal port speed to simplify the computational model. Therefore,
we formulate the power consumption of the links in the DCN based SDN as follows:
X XX
LP = 2Pport LP l Llij , (18)
l i j

where LP is the power consumption of all the links, Pport is the power consumption of
the port at maximum speed. The Boolean variables Llij show if the link eij is operating
on level l.
To adjust the link speed configuration to the different levels, we select one of the
NEC ProgrammableFlow Networking Suite, PF5240 OpenvFlow switch with the fol-
lowing speed levels, idle, 10, 100, and 1000 Mbps. The measurement of the power
consumption is listed in Table 11 [25].

Table 11: PF5240 OpenvFlow Switch Power Specification

Properties Values
Base Power of the Switch (W) 118.3300
Port Configuration Power (W/port) 0.5295
1 for 1 Gbps
Port Configuration Power Factor 0.4455 for 100 Mbps
0.3761 for 10 Mbps

In this model, every switch can perform on one of the mentioned speed levels. To do
so, we add the Llij Boolean variables to the objective function to minimize the number
of links, switches, and adjust the links to a suitable power level, as shown in (19)
 
N X
X n X
n
min  (1 + LP l )Llij  , ∀eij ∈ E, (19)
l=1 i=1 j =1

where LP l is the links power consumption on different speed levels (1 ≤ l ≤ N ) for all
sets of edges eij . The above Objective Function works against all the constraints that
define in the section 4.2.
In order to force the Boolean variables Llij to be set according to the utilization of
the corresponding links, we add the set of the following new constraints:
Link speed adaptation constraint

Uij + Tij ≥ LS l ⇒ ¬Llij , ∀l = 1, . . . , N − 1, ∀eij ∈ E, (20)

 27

Note the “if-then” constraint (20) can be translated to the indicator constraint

Llij ⇒ Uij < LS l − Tij , ∀l = 1, . . . , N − 1, ∀eij ∈ E, (21)

PBC and ILP solvers that natively support indicator constraints can directly deal
with (21), since Uij is defined as a pseudo-Boolean expression in (9). For those without
such a support, we have to translate (21) to a PBC according to Proposition 2.

4.3 ILP Solving Tools

4.3.1 neO-DCN Portfolio Solver for DCN Optimization

[TO DO: Dr.Kovasznai and Mohammed: We have to describe the updated version of
neO-SDN ]

4.3.2 LinGo Solvers

LinGo is a robust language for addressing optimization models with a collection of

quick built-in solvers to solve and build Linear, Nonlinear, Quadratic, Stochastic, and
Integer optimization models. So we implemented our proposed models (i.e., with and
without adjustable link speed) in LinGo [24].
[TO DO: Dr.Racz is it OK? ]

4.4 Experiments and Discussion

In our experiments, to evaluate our model we used the fat-tree topology, which is
presented in sections 4.2.1 and 4.2.2. The bandwidth of each link is uniformly set to
1 Gbps. The ILP solvers mentioned in Section 4.1 were run on the same benchmark
instances which we used in cybernatica with a clock time limit of 1200 seconds. The
ILP solvers as part of neO-DCN ran on a 3.6 GHz 8-core CPU with 8 GB of memory
on Linux, while LINGO was run as a Windows desktop application, we measured two
metrics to evaluate our results: (1) runtime of the solvers; (2) the memory consumption
of solvers using the memory profiler mprof, except LINGO, we were not able to apply
it to LINGO.

4.4.1 Experiments with traffic consolidation

The inputs of the model are the topology (fat-tree made up of k = 4), where disabled
links status are set to zero,

the capacity of the link (1 Gbps), the current state of traffic,
flows f = f.Sr , f.Ds , λf determined by their source, destination, and speed rate, and
the optimizer gives the paths defined by the active links, Lij , for each flow, state of
the link utilization, speed rate for each link, and the set of the number switches. As
shown in the (22).

   
 (Lij )n×n , (Uij )n , (S)
 
input
← Opt. (BWij )n×n , F, Tij . (22)
F R(f, i, j ) | f ∈ F, eij ∈ E n×n
28

[TO DO: Dr.Racz, please, check the above equation ]

Table 12 Table 12 provides an overview of the evaluation results in terms of the
runtime..... [TO DO: Dr. Kovasznai, if you do not have time I can help you and describe
the result then you can moderate it.]

Flows Result Opt. Gurobi CP-SAT SCIP CBC

5 SAT 24 0.24 0.13 0.23 0.23
10 SAT 30 0.23 0.23 0.33 0.33
20 SAT 36 0.44 0.43 0.73 0.73
30 SAT 41 0.53 0.84 1.13 1.43
40 SAT 41 0.74 1.83 1.54 2.13
50 SAT 43 2.23 2.53 49.21 56.04
60 SAT 43 4.64 6.64 69.77 49.32
70 SAT 46 11.16 50.32 293.91 315.32
80 SAT 44 7.45 13.96 359.08 192.66
90 SAT 49 49.32 TO TO 1115.56
100 SAT 48 29.99 TO TO 1006.50
110 SAT 49 34.03 83.37 TO 657.95
120 UNSAT 1.84 1.33 1.63 11.95
130 SAT 63 846.24 TO TO TO
140 UNSAT 1.73 1.54 1.93 53.93
150 UNSAT 2.03 1.64 2.04 18.17
160 TO TO TO TO
170 SAT 46 164.73 TO TO TO
180 UNSAT 2.24 1.93 2.43 42.11
190 UNSAT 2.34 1.93 2.54 26.87
200 UNSAT 2.53 2.13 2.64 44.12

Table 12: Runtimes (s) of ILP solvers for DCN model with traffic consolidation.

4.4.2 Experiments with adjustable link speed

The inputs of the model are the same as in the consolidation model. However, the
output is a bit different, given the paths defined by the active links with the level of
power, Llij , for each Link, state of the link utilisation, speed rate for each link, and the
set of the number switches. As shown in the (23).

  !
Llij
 
, (Uij )n , (S) 
input

 n×n ← Opt. (BWij )n×n , F, Tij . (23)
F R(f, i, j ) | f ∈ F, eij ∈ E n×n

Table 13 provides an overview of the evaluation results in terms of the runtime.....

[TO DO: Dr. Kovasznai, if you do not have time I can help you and describe the
result then you can moderate it.]
 29

600
Gurobi
CP-SAT
500 SCIP
CBC
Memory consumption (MB)

400

300

200

100

0 20 40 60 80 100 120 140 160 180 200

Number of flows

Fig. 7: Memory consumption of ILP solvers for DCN model with traffic consolidation.

Gurobi Gurobi
Flows Result Opt. via via SCIP CBC
OR-Tools gurobipy
5 SAT 21.4 0.23 0.23 0.23 0.32
10 SAT 29.68 0.63 0.53 8.14 7.14
20 SAT 40.79 2.33 1.84 43.3 29.78
30 SAT 48.03 11.85 7.24 128.34 368.89
40 SAT 51.49 10.45 36.41 271.1 932.8
50 SAT 53.01 90.89 215.59 TO TO
60 SAT 55.23 169.83 388.64 TO TO
70 SAT 58.12 289.95 610.60 TO TO
80 SAT 58.89 453.38 602.62 TO TO
90 SAT 65.45 1095.54 TO TO TO
100 SAT 63.45 943.87 TO TO TO
110 SAT 64.89 973.07 TO TO TO
120 UNSAT 2.03 1.64 2.03 242.39
130 TO TO TO TO
140 UNSAT 2.13 1.84 2.33 200.99
150 UNSAT 2.14 2.03 2.43 290.73
160 TO TO TO TO
170 TO TO TO TO
180 UNSAT 2.73 2.33 3.03 517.91
190 UNSAT 2.94 2.43 3.13 630.66
200 UNSAT 2.93 2.53 3.23 924.51

Table 13: Runtimes (s) of ILP solvers for DCN model with adjustable link speed.
30

700
Gurobi via OR-Tools
Gurobi via gurobipy
600 SCIP
CBC
Memory consumption (MB)

500

400

300

200

100

0 20 40 60 80 100 120 140 160 180 200

Number of flows

Fig. 8: Memory consumption of ILP solvers for DCN model with adjustable link speed.

5 Conclusion

References

1. Asín, R., Nieuwenhuis, R., Oliveras, A., Rodríguez-Carbonell, E.: Cardinality networks: a
theoretical and empirical study. Constraints 16(2), 195–221 (2011)
2. Assefa, B.G., Ozkasap, O.: Framework for traffic proportional energy efficiency in software
defined networks. In: 2018 IEEE International Black Sea Conference on Communications
and Networking (BlackSeaCom), pp. 1–5. IEEE (2018)
3. Assefa, B.G., Özkasap, Ö.: A survey of energy efficiency in sdn: Software-based methods
and optimization models. Journal of Network and Computer Applications 137, 127–143
(2019). https://doi.org/10.1016/j.jnca.2019.04.001
4. Audemard, G., Simon, L.: Lazy clause exchange policy for parallel sat solvers. In: Proc. In-
ternational Conference on Theory and Applications of Satisfiability Testing (SAT), Lecture
Notes in Computer Science, vol. 8561, pp. 197–205. Springer (2014)
5. Bailleux, O., Boufkhad, Y.: Efficient CNF Encoding of Boolean Cardinality Constraints.
In: Proc. 9th International Conference on Principles and Practice of Constraint Program-
ming (CP), pp. 108–122 (2003)
6. Barnhart, C., Krishnan, N., Vance, P.H.: Multicommodity flow problemsMulticommod-
ity Flow Problems, pp. 1583–1591. Springer US, Boston, MA (2001). DOI 10.1007/
0-306-48332-7_316. URL https://doi.org/10.1007/0-306-48332-7_316
7. Barrett, C., Conway, C.L., Deters, M., Hadarean, L., Jovanovic, D., King, T., Reynolds,
A., Tinelli, C.: CVC4. In: Proc. Int. Conf. on Computer Aided Verification (CAV), Lecture
Notes in Computer Science, vol. 6806, pp. 171–177. Springer (2011)
8. Barrett, C., Fontaine, P., Tinelli, C.: The Satisfiability Modulo Theories Library (SMT-
LIB). www.SMT-LIB.org (2016)
9. Benenson, Z., Freiling, F.C., Cholewinski, P.M.: Advanced evasive data storage in sensor
networks. In: Proc. Int. Conf. on Mobile Data Management, MDM’07, pp. 146–151. IEEE
 31

Computer Society (2007). DOI 10.1109/MDM.2007.29. URL http://dx.doi.org/10.

1109/MDM.2007.29
10. Biere, A.: CaDiCaL, Lingeling, Plingeling, Treengeling, YalSAT Entering the SAT Com-
petition 2017. In: Proc. of SAT Competition 2017 – Solver and Benchmark Descriptions,
Department of Computer Science Series of Publications B, vol. B-2017-1, pp. 14–15. Uni-
versity of Helsinki (2017)
11. Bjørner, N., Phan, A.D., Fleckenstein, L.: µZ - an optimizing SMT solver. In: Proc. Int.
Conf. for Tools and Algorithms for the Construction and Analysis of Systems (TACAS),
LNCS, vol. 9206, pp. 194–199. Springer (2015)
12. Cardei, M.: Coverage problems in sensor networks. In: Handbook of Combinatorial Op-
timization, pp. 899–927. Springer (2013). DOI 10.1007/978-1-4419-7997-1_72. URL
http://dx.doi.org/10.1007/978-1-4419-7997-1_72
13. Cardei, M., Du, D.Z.: Improving wireless sensor network lifetime through power aware
organization. Wireless networks 11(3), 333–340 (2005)
14. Cardei, M., Du, D.Z.: Improving wireless sensor network lifetime through power aware
organization. Wireless Networks 11(3), 333–340 (2005). DOI 10.1007/s11276-005-6615-6.
URL http://dx.doi.org/10.1007/s11276-005-6615-6
15. Cimatti, A., Griggio, A., Schaafsma, B., Sebastiani, R.: The MathSAT5 SMT solver. In:
N. Piterman, S. Smolka (eds.) Proc. Int. Conference on Tools and Algorithms for the
Construction and Analysis of Systems (TACAS), Lecture Notes in Computer Science, vol.
7795, pp. 93–107. Springer (2013)
16. De Moura, L., Bjørner, N.: Z3: An efficient SMT solver. In: Proc. Int. Conf.
on Tools and Algorithms for the Construction and Analysis of Systems (TACAS),
TACAS’08/ETAPS’08, pp. 337–340. Springer-Verlag (2008)
17. Duan, Q., Al-Haj, S., Al-Shaer, E.: Provable configuration planning for wireless sensor
networks. In: 2012 8th international conference on network and service management (cnsm)
and 2012 workshop on systems virtualiztion management (svm), pp. 316–321. IEEE (2012)
18. Duan, Q., Al-Haj, S., Al-Shaer, E.: Provable configuration planning for wireless sensor
networks. In: Proc. 8th Int. Conf. on Network and Service Management (CNSM) and
Workshop on Systems Virtualization Management (SVM), pp. 316–321 (2012)
19. Dutertre, B.: Yices 2.2. In: A. Biere, R. Bloem (eds.) Proc. Int. Conf. on Computer-Aided
Verification (CAV), Lecture Notes in Computer Science, vol. 8559, pp. 737–744. Springer
(2014)
20. Eén, N., Sörensson, N.: An extensible SAT-solver. In: Proc. International Conference
on Theory and Applications of Satisfiability Testing (SAT), Lecture Notes in Computer
Science, vol. 2919, pp. 502–518. Springer (2004)
21. Gario, M., Micheli, A.: PySMT: a solver-agnostic library for fast prototyping of SMT-
based algorithms. In: International Workshop on Satisfiability Modulo Theories (SMT)
(2015)
22. Heller, B., Seetharaman, S., Mahadevan, P., Yiakoumis, Y., Sharma, P., Banerjee, S.,
McKeown, N.: Elastictree: Saving energy in data center networks. In: Nsdi, vol. 10, pp.
249–264 (2010)
23. Ignatiev, A., Morgado, A., Marques-Silva, J.: PySAT: A Python toolkit for prototyping
with SAT oracles. In: Proc. International Conference on Theory and Applications of
Satisfiability Testing (SAT), Lecture Notes in Computer Science, vol. 10929, pp. 428–437.
Springer (2018)
24. Inc, L.S.: LINGO the modeling language and optimizer. LINDO Systems Inc, 1415
North Dayton Street Chicago, Illinois 60642 Technical Support: (312)988-9421 E-mail:
tech@lindo.com,WWW: http://www.lindo.com (20203)
25. Kaup, F., Melnikowitsch, S., Hausheer, D.: Measuring and modeling the power consump-
tion of openflow switches. In: 10th International Conference on Network and Service
Management (CNSM) and Workshop, pp. 181–186. IEEE (2014)
26. Knuth, D.E.: OpenFlow Switch Specification. Open Networking Foundation (March 26,
2015)
27. Kong, W., Li, M., Han, L., Fukuda, A.: An smt-based accurate algorithm for the k-coverage
problem in sensor network. In: 8th International Conference on Mobile Ubiquitous Com-
puting, Systems, Services and Technologies, UBICOMM 2014 (2014)
28. Kovásznai, G., Biró, C., Erdélyi, B.: Generating optimal scheduling for wireless sensor
networks by using optimization modulo theories solvers. In: SMT, pp. 15–27 (2017)
29. Kovásznai, G., Biró, C., Erdélyi, B.: Generating optimal scheduling for wireless sen-
sor networks by using optimization modulo theories solvers. In: Proc. Int. Workshop
32

on Satisfiability Modulo Theories (SMT), CEUR, vol. 1889, pp. 15–27 (2017). URL
http://ceur-ws.org/Vol-1889/paper2.pdf
30. Kovásznai, G., Biró, C., Erdélyi, B.: Puli - A problem-specific OMT solver. In: Proc. 16th
International Workshop on Satisfiability Modulo Theories (SMT 2018), no. 371 in Easy-
Chair Preprint (2018)
31. Kovásznai, G., Erdélyi, B., Biró, C.: Investigations of graph properties in terms of wireless
sensor network optimization. In: 2018 IEEE International Conference on Future IoT
Technologies (Future IoT), pp. 1–8. IEEE (2018)
32. Kovásznai, G., Erdélyi, B., Biró, C.: Investigations of graph properties in terms of wireless
sensor network optimization. In: 2018 IEEE International Conference on Future IoT
Technologies (Future IoT), pp. 1–8. IEEE (2018)
33. Kovásznai, G., Gajdár, K., Kovács, L.: Portfolio sat and smt solving of cardinality con-
straints in sensor network optimization. In: 2019 21st International Symposium on Sym-
bolic and Numeric Algorithms for Scientific Computing (SYNASC), pp. 85–91 (2019).
DOI 10.1109/SYNASC49474.2019.00021
34. Li, Y., Albarghouthi, A., Kincaid, Z., Gurfinkel, A., Chechik, M.: Symbolic optimization
with SMT solvers. In: Proc. ACM SIGPLAN-SIGACT Symposium on Principles of Pro-
gramming Languages (POPL), pp. 607–618. ACM (2014). DOI 10.1145/2535838.2535857.
URL http://doi.acm.org/10.1145/2535838.2535857
35. Liffiton, M.H., Maglalang, J.C.: A cardinality solver: More expressive constraints for free
(poster presentation). In: Proc. International Conference on Theory and Applications of
Satisfiability Testing (SAT), Lecture Notes in Computer Science, vol. 7317, pp. 485–486.
Springer (2012). URL https://sun.iwu.edu/~mliffito/publications/sat12_liffiton_
minicard_poster.pdf
36. McKerns, M.M., Strand, L., Sullivan, T., Fang, A., Aivazis, M.A.: Building a framework
for predictive science. arXiv preprint arXiv:1202.1056 (2012)
37. Morgado, A., Ignatiev, A., Marques-Silva, J.: Mscg: Robust core-guided MaxSAT solving.
JSAT 9, 129–134 (2014)
38. Nsaif, M., Kovásznai, G., Rácz, A., Malik, A., de Fréin, R.: An adaptive routing frame-
work for efficient power consumption in software-defined datacenter networks. Electronics
10(23), 3027 (2021)
39. Ogawa, T., Liu, Y., Hasegawa, R., Koshimura, M., Fujita, H.: Modulo based CNF encoding
of cardinality constraints and its application to MaxSAT solvers. In: 25th International
Conference on Tools with Artificial Intelligence (ICTAI), pp. 9–17. IEEE (2013)
40. Pardalos, P.M., Du, D.Z., Graham, R.L.: Handbook of combinatorial optimization.
Springer (2013)
41. Pries, R., Jarschel, M., Schlosser, D., Klopf, M., Tran-Gia, P.: Power consumption analysis
of data center architectures. In: International conference on green communications and
networking, pp. 114–124. Springer (2012)
42. Sebastiani, R., Trentin, P.: OptiMathSAT: A tool for optimization modulo theories. In:
Proc. Int. Conf. on Computer-Aided Verification (CAV), LNCS, vol. 9206, pp. 447–454.
Springer (2015)
43. Shi, W., Pallis, G., Xu, Z.: Edge computing [scanning the issue]. Proceedings of the IEEE
107(8), 1474–1481 (2019)
44. Sinz, C.: Towards an optimal CNF encoding of boolean cardinality constraints. In:
Proc. Principles and Practice of Constraint Programming (CP), Lecture Notes in Com-
puter Science, vol. 3709, pp. 827–831. Springer (2005)
45. Tian, D., Georganas, N.D.: A coverage-preserving node scheduling scheme for large wireless
sensor networks. In: Proceedings of the 1st ACM international workshop on Wireless sensor
networks and applications, pp. 32–41 (2002)
46. Tian, D., Georganas, N.D.: A coverage-preserving node scheduling scheme for large wireless
sensor networks. In: Proc. Int. Workshop on Wireless Sensor Networks and Applications,
WSNA’02, pp. 32–41. ACM (2002)
47. Wang, R., Jiang, Z., Gao, S., Yang, W., Xia, Y., Zhu, M.: Energy-aware routing algorithms
in software-defined networks. In: Proceeding of IEEE International Symposium on a World
of Wireless, Mobile and Multimedia Networks 2014, pp. 1–6. IEEE (2014)
48. Wilson, R.J.: Introduction to Graph Theory, 4 edn., chap. 1. British Library, England
(1998)
49. Xu, G., Dai, B., Huang, B., Yang, J., Wen, S.: Bandwidth-aware energy efficient flow
scheduling with sdn in data center networks. Future Generation computer systems 68,
163–174 (2017)