Continuous reasoning for adaptive  container image distribution in the cloud-edge continuum]Continuous reasoning for adaptive container image distribution in the cloud-edge continuum

1]Damiano Azzolini
All Authors contributed equally to this study.
[1]
Department of Environmental and Prevention Sciences,
University of Ferrara,

2]Stefano Forti
All Authors contributed equally to this study.
[2]
Department of Computer Science,
University of Pisa,

3]Antonio Ielo
All Authors contributed equally to this study.
[3]
Deparment of Mathematics and Computer Science,
University of Calabria,

Cloud-edge computing requires applications to operate across diverse infrastructures, often triggered by cyber-physical events. Containers offer a lightweight deployment option but pulling images from central repositories can cause delays. This article presents a novel declarative approach and open-source prototype for replicating container images across the cloud-edge continuum. Considering resource availability, network QoS, and storage costs, we leverage logic programming to (i) determine optimal initial placements via Answer Set Programming (ASP) and (ii) adapt placements using Prolog-based continuous reasoning. We evaluate our solution through simulations, showcasing how combining ASP and Prolog continuous reasoning can balance cost optimisation and prompt decision-making in placement adaptation at increasing infrastructure sizes.

§ INTRODUCTION

Cloud-edge computing paradigms (e.g., fog [1] and edge [2] computing) have been getting increasing attention both from academia and industry as a solution to deal with the considerable amounts of data coming from the Internet of Things (IoT) [3].

All such paradigms aim at placing (part of the) computation suitably closer to where IoT data are produced to aggregate and filter them along a pervasive continuum of heterogeneous infrastructure resources at the interplay between IoT devices and cloud datacentres.

Such an approach requires to deploy application components (e.g., microservices and serverless functions) in a context- and QoS-aware manner in order to improve their response times, data-locality, energy demand, security, and trust [4]. Indeed, cloud-edge computing is particularly well-suited for latency-sensitive and bandwidth-hungry IoT applications that require prompt reactions to sensed cyber-physical events, e.g., virtual reality, remote surgery, and online gaming [5].

Much research (e.g., surveyed in [6]) has focussed on the decision-making process related to placing application components onto cloud-edge resources according to a large variety of constraints (e.g., hardware, IoT, and QoS) and optimisation targets (e.g., operational cost, resource usage, and battery lifetime), also in response to cyber-physical stimuli. Many proposals foresee deploying application components through containers, being a lightweight and scalable virtualisation technology that runs both on powerful cloud servers and resource-constrained edge devices [7, 8].

To run a container, one must first pull its image from the repository stored in an image registry, i.e., a server that acts as a distribution hub for container images, allowing users to push and pull images to and from the repository.

However, as highlighted in [9, 10], very few works considered the problems related to distributing container image repositories over cloud-edge registries to further improve application performance by reducing application start-up times.

On one hand, downloading images from a central cloud repository is not always viable in short times, especially for devices closer to the edge of the Internet that might incur intermittent connectivity or scarce bandwidth availability. On the other hand, some edge application components require fast start-ups, being deployed to the task in response to cyber-physical events that trigger them, or to specific end-users mobility patterns. This is especially true in Function-as-a-Service edge settings, where short-running containerised stateless functions run only when needed [11].

Hereinafter, we precisely consider the possibility of distributing container images across cloud-edge registry nodes to speed up on-demand image downloads to any other node and, therefore, containers' start-up times.  In the above settings, deciding onto which infrastructure nodes to place different container images is an interesting and challenging problem [9, 10]. Image placement should guarantee that images can be downloaded from any infrastructure node within a specific time frame.

In doing so, it should replicate images onto a subset of infrastructure nodes in a QoS-aware and context-aware manner, without exceeding the capacity of each node and containing operational costs related to leasing the needed storage resources. Indeed, if relying on a central cloud repository might suffer from too high transfer times, replicating all images on all available nodes might be economically unsustainable or unfeasible due to edge resource constraints.

The above scenario is characterised by large-scale deployments, high network churn, and frequent image repository updates. Decision-making should scale to quickly distribute tens of images over hundreds of cloud-edge registry nodes, encompassing their high heterogeneity. Edge nodes can temporarily join and leave the network either due to failures (e.g., power disruption, node crash, reboot) or to network QoS degradation (e.g., network congestion, increased jitter due to node mobility) [12].

Image repositories are continuously updated by developers as soon as new features are released or newly discovered bugs are fixed. As for 2018, operating system (OS) images such as Ubuntu and Alpine received monthly updates, while non-OS images such as Nginx and MongoDB received up to ten updates per month [13].

Hence, decision-making should run continuously to adapt image placements in response to changes in the infrastructure (e.g., node/link crashes, link QoS degradation) or in the image repository to be distributed (e.g., image addition/removal, increase of storage requirements), that may negatively affect image transfer times.
Hence, adaptation should also migrate as few images as possible to avoid unnecessary data transfers. To the best of our knowledge,
no prior work exists tackling these adaptation aspects.

In this article, we propose a novel declarative methodology – and its open-source prototype[Freely available at <https://github.com/teto1992/declace>.]  – to solve the problem of adaptively distributing base container images along a cloud-edge infrastructure in a QoS-, context- and cost-aware manner.

Our prototype extensively relies on logic programming. It combines a cost-optimal image placement strategy, written in Answer Set Programming (ASP), to determine initial image placements and a heuristic iterative deepening placement strategy, written in Prolog, to adapt such initial placements via continuous reasoning[Originally proposed at Meta, continuous reasoning speeds up static analyses over Facebook's shared codebase by only focussing on incrementally analysing the latest changes [14]. More recently, Forti et al. [5] and Herrera et al. [15] extended the benefits of continuous reasoning to cloud-edge application management, adapting application deployments by possibly migrating only services in need for attention due to infrastructure or application changes.] when needed. Thanks to the declarative nature of logic programming,  is more concise ( $\simeq100$ lines of code), readable, and extensible compared to imperative solutions.

While initial placements tolerate the longer decision-making times of our ASP approach in favour of minimising operational placement costs (i.e., it solves the problem by finding the global minimum), runtime adaptation calls for prompt decision-making to minimise disruption of the image distribution service, even at the price of sub-optimal placements.

By employing heuristic continuous reasoning to solve the container image placement problem at runtime, this work enables the

adaptation of distributed image repositories to changing cloud-edge environments and image requirements.

As we will show through our experiments, continuous reasoning reduces the size of the problem instances to be solved at runtime and contains the number of images to be migrated when adapting to changing conditions. This permits handling various infrastructure sizes and speeds up decision-making.

The rest of this article is organised as follows. After formally defining the decision and optimisation problems of interest for this work (Section <ref>), we detail the Prolog and ASP solutions to such problems and how they are combined into the  prototype tool (Section <ref>). We then describe the results of the experimental assessment of  through simulation over lifelike data (Section <ref>). Finally, after discussing some closely related work (Section <ref>), we conclude by pointing to directions for future work (Section <ref>).

§ CONSIDERED PROBLEM

In this section, we illustrate a formal model of the considered cloud-edge settings and formally define the problems we will tackle, while proving their NP-hard nature.

§.§ Formal Model

First, we model base container images[We here focus on base images as they are needed to define and build any other container image.
] as follows.

A container image is a triple $\langle i, s, m \rangle$ where $i$ denotes the unique image identifier, $s$ the size of the image in Megabytes (MB), and $m$ the maximum amount of time in seconds tolerated to download such image onto a target node.

The latest version[Image sizes are taken from Docker by pulling the images with latest tag as of June 2024.] of the alpine, ubuntu and nginx images are modeled by the following triples:

$$\langle \cd{alpine}, 8\ \textrm{\em MB}, 30\ \textrm{\em s} \rangle, \langle \cd{ubuntu}, 69\ \textrm{\em MB}, 60\ \textrm{\em s} \rangle, \langle \cd{nginx}, 192\ \textrm{\em MB}, 120\ \textrm{\em s} \rangle$$

enforcing that alpine can be downloaded from any network node within 30 seconds, ubuntu within 60 seconds, and nginx within 120 seconds.$\qed$

We model registry nodes, their available storage and storage cost, and the Quality of Service of end-to-end links between them in terms of latency and bandwidth. We assume that the considered nodes host a container image registry, i.e., they can be used to distributed container image repositories across the cloud-edge network.

A registry node is a triple $\langle n, h, c \rangle$ where $n$ denotes the unique node identifier (e.g., its IP address), $h$ the available amount of storage it features expressed in MB, and $c$ the monthly cost per used unit of storage (MB) at such node.

A link is a 4-tuple $\langle n, n', \ell, b \rangle$ where $\ell$ and $b$ denote the end-to-end latency in milliseconds and bandwidth in Mbps, respectively, between the nodes identified by $n$ and $n'$.

Consider the cloud-edge infrastructure of Figure <ref>, composed of one cloud and five edge nodes. As an example, the cloud node can be modelled via the tuple

$$\langle \cd{cloud}, 2048\ \textrm{\em MB},  0.9\ \text{\euro/MB} \rangle$$

For the sake of readability, Figure <ref> only shows direct (wired or wireless) links between nodes. We assume that all other end-to-end links are computed by selecting shortest paths based on latency, and that the end-to-end bandwidth corresponds to the minimum bandwidth[It is worth noting that, even though we assume symmetric links in this example, our solution also works with asymmetric bandwidth and latency combinations between pairs of nodes.] along the path. Then, the links between cloud and edge1 and between cloud and edge5 can be modelled as follows

$$\langle \cd{cloud}, \cd{edge1}, 20\ \textrm{\em ms},  50\ \textrm{\em Mbps} \rangle, \langle \cd{cloud}, \cd{edge5}, 55\ \textrm{\em ms},  5\ \textrm{\em Mbps} \rangle$$

with traffic from cloud to edge5 routed through edge2. $\qed$

It is now possible to formally define image placements. Note that one image can be stored onto multiple nodes, i.e., we foresee the possibility to replicate an image onto multiple infrastructure nodes.

Let $I$ be a set of container images and $N$ be a set of available infrastructure nodes. An image placement is a mapping $p: I' \rightarrow \mathcal{P}(N)$ that maps each image of $I' \subseteq I$ to a subset[$\mathcal{P}(N)$ denotes the power set of $N$, i.e., the set of all possible subsets of $N$.] of infrastructure nodes $\overline{N}\subseteq N$. If $I'=I$, then the placement is total, it is partial otherwise.

Considering the images of Example <ref> as $I$ and the infrastructure of Example <ref> as $N$ and $L$, a possible partial placement $p'$ is defined by:

$$p'(\cd{alpine}) = \{\cd{cloud, edge2}\} \ \ \ \ p'(\cd{ubuntu}) = \{\cd{edge5}\} $$

as a placement is not defined for image nginx.

Thus, a total placement $p$ is defined by:

$$p(\cd{alpine}) = \{\cd{edge2}\} \ \ p(\cd{ubuntu}) = \{\cd{edge2, edge5}\} \ \ p(\cd{nginx}) = \{\cd{edge2, edge3, edge5}\} $$

since it maps all images onto a target node.$\qed$

Assuming a cap on the number of replicas for all images, we now define the eligibility criteria for image placement. An eligible image placement must (1) not exceed the cap on the number of replicas for any placed image, (2) enable all infrastructure nodes to download any image within its associated maximum time frame (including transmission and propagation times) or to have it already stored, and (3) not exceed storage capacity at any infrastructure node. These conditions correspond to the three conditions in the following definition of eligible placement.

Let $I$ be a set of container images, $N$ be a set of available infrastructure nodes, $p: I' \rightarrow \mathcal{P}(N)$ be an image placement over $I'\subseteq I$, $R \in \mathbb{N}$ be a maximum image replica factor, and $L$ be the set of links between nodes in $N$. The image placement $p$ is an eligible placement over $I'$ if and only if:

\begin{equation}\label{eq:maxreplicas}
\forall i \in I'. \quad |p(i)| \leq R
\end{equation}

\begin{align}\label{eq:transfertimes}
\forall \langle n, &\_, \_ \rangle  \in  N.\  \forall  \langle  i, s, m \rangle  \in  I'.\ \exists \ \langle n',\_,\_\rangle \in p(i)\ : \nonumber \\
& n=n'\ \lor\ ( \langle n', n, \ell, b \rangle \in L\ \wedge\ 8\times s/b + \ell/1000 \leqslant m )
\end{align}

\begin{align}\label{eq:hardwarelimit}
\forall \langle n, h, \_ \rangle \in N.\ I'_n = \{\  \langle i, s, \_ \rangle \in I'\ |\ p(i) &= n\ \} \Rightarrow \sum_{\langle \_, s,\_\rangle \in I'_n}s \leqslant h
\end{align}

Note that Definition <ref> is incremental and enables reasoning on partial eligible image placements while extending them to total eligible placements. Such an aspect is crucial for continuous reasoning and will be key to the Prolog code presented next.
The $8$ constant factor in Equation <ref> is needed to convert $b$'s Mbps to MB/ms and correctly sum them with the milliseconds of $\ell$, converted to seconds by dividing by 1000.

Eligible placements can then be associated with their monthly cost as follows.

Let $I$ be a set of container images, $N$ be a set of available infrastructure nodes, and $p: I \rightarrow \mathcal{P}(N)$ be an eligible image placement. The cost of $p$ is defined as:

$$cost(p) = \sum_{\langle \_, s, \_ \rangle \in I}\ \sum_{\langle \_, \_, c\rangle \in p(i)} s \times c$$

Lastly, we provide a notion of optimality of an eligible placement based on its associated cost.

An eligible image placement $p: I \rightarrow \mathcal{P}(N)$ is cost-optimal if no other eligible image placement $p': I \rightarrow \mathcal{P}(N)$ exists such that $p \neq p' \ \land\ cost(p') < cost(p)$.

Retaking Example <ref> and setting $R=3$, the first partial placement $p'$ is not eligible as, for instance, it is not possible to transfer image ubuntu from node edge5 to node cloud within 60 seconds (as it requires over 110 seconds). Readers can instead verify that the total placement $p$ of Example <ref> is eligible as it meets all conditions (1), (2), and (3) of Definition <ref>. Besides, as we will programmatically check in Section <ref>, placement $p$, with a cost of 308, is also cost-optimal in the described scenario. $\qed$

§.§ Problem Statements and Complexity

In this section we formally define the problems we address in this paper.

The first (decision) problem we consider in this article is precisely how to determine eligible image placements in Cloud-Edge landscapes. We define it as follows.

[Image Placement, IPP]

An instance of the image placement problem is a 4-tuple $\langle N, L, I, R \rangle$ where
$N$ is a set of available infrastructure nodes,
$L$ is the set of end-to-end links between such nodes,
$I$ is a set of container images, and
$R$ is a maximum replica factor. Determine (if it exists) a total eligible placement $p: I \rightarrow \mathcal{P}(N)$
as per Definition <ref>.

We prove that Problem <ref> is NP-hard by sketching a polynomial time reduction of the NP-hard [16] problem of bin-packing (BPP) to IPP. Bin packing can be stated as follows.

Let $O$ be a finite set of items each of size $s(o) \in \mathbb{N}$. Determine if there exists a partition of items in $O$ over $K\in \mathbb{N}$ bins without exceeding their capacity $B\in \mathbb{N}$.

IPP $\in$ NP-hard.

Given an instance $\langle O, K, B \rangle$ of BPP it is possible to reduce it to an instance $\langle N, L, I, R \rangle$ of IPP as follows:

* populate $N$ with $K$ nodes of the form $\langle k, B, 0 \rangle$ with $k = 1,2,\dots,K$, size $B$, and null cost,

* populate $L$ with a complete set of end-to-end links between pairs of nodes $i,j \in N$ of the form $\langle i, j, 0, \infty \rangle$, so that nodes reach each other with null latency and infinite bandwidth,

* populate $I$ with a container image $\langle o, s(o), \infty \rangle \in I$ for each object $o \in O$, where the size of the object becomes the size of the image and the maximum tolerated transfer time is infinite, and

* set the maximum replica factor $R$ to $1$, i.e. placing each image to a single node only.

Determining a solution to the above instance of IPP would partition images in $I$ (i.e., item in $O$) over $K$ nodes (i.e., bins) without exceeding their capacity $B$. Thus, it would solve the original instance of BPP.

The above steps reduce an instance of BPP to an instance of IPP, incurring a polynomial time complexity of $O(K^2)$, due to step 2, which requires creating a link for each pair of nodes in $N$.

This proves that IPP is at least as difficult as BPP, which is known to be NP-hard. Hence, IPP is also NP-hard.

Such a result means that no poly-time algorithm is currently known to solve IPP (unless $P=NP$ is proven). However, checking whether a placement $p$ is eligible, according to Definition <ref>, can be performed naively in $O(|I|N^{2})$. This consideration along with the previous lemma proves that IPP $\in$ NP-complete.

The second problem we will be studying is to continuously adapt a previously eligible total placement whenever changes in the underlying network topology or image requirements occur that affect its eligibility.

[Continuous Image Placement, CIPP]

Let $\langle N,L,I,R\rangle$ and $\langle N',L',I',R' \rangle$ be two image placement problem instances and $p: I \rightarrow \mathcal{P}(N)$ be a total eligible placement for the first problem instance. Let $I_{OK}$ be a maximal proper subset of $I'$ such that $p$ is eligible over $I_{OK}$, and $I_{KO} = I' \setminus I_{OK}$. Determine an eligible total placement $p': I' \rightarrow \mathcal{P}(N')$ (if any) such that $p'(i) = p(i), \forall i \in I_{OK}$.

Said otherwise, given infrastructure or image requirements changes that make a previously total eligible placement $p$ only partially eligible, we aim at extending $p$ over $I_{OK}$ into a total eligible placement $p'$ over $I$, by (possibly) only modifying the placement of images in $I_{KO}$.

Last, following Definition <ref>, we can easily define the optimisation problem corresponding to Problem <ref>.

[Optimal Image Placement, OIPP]

Let $\langle N,L,I,R\rangle$ be a placement problem instance, determine whether it exists an eligible cost-optimal image placement $p: I \rightarrow \mathcal{P}(N)$
as per Definition <ref> and Definition <ref>.

As solving CIPP and OIPP implies solving IPP, Problems <ref>  and <ref> are also NP-hard.

In this section, we briefly overview some background on Prolog and ASP, needed to understand the content of the next sections.

Prolog is a programming language based on first-order logic [17]. A Prolog program is a set of rules (also called clauses) of the form:

h :- b1, ..., bn.

stating that h (an atom) holds when the conjunction of literals (i.e., atoms or negated atoms) b1 $, \dots,$ bn (n$\geq$0) are all true (i.e., their logical AND holds).
The atom h is called head while the conjunction of the literals bi is called body of the clause.

Rules with empty bodies are called facts (omitting the neck operator, $\impl$). Rules with the same functor (i.e., name and arity) identify a predicate.

Prolog variables begin with upper-case letters (except for the anonymous variable, which is represented with an underscore, $\_)$, lists are denoted by square brackets and negation by $\backslash +$.

We use the standard notation pred/K (called functor) to compactly represent a set of atoms or clauses with the atom pred as the head and K arguments.

Answer Set Programming Answer Set Programming (ASP) is a declarative knowledge representation formalism rooted in the stable model semantics of logic programs <cit.>. Despite not being Turing complete, unlike Prolog, ASP has shown to be particularly effective in modelling and solving combinatorial and optimisation problems in a variety of domains. We briefly introduce the typical workflow in ASP applications, recap minimal notions about its syntax and semantics, and provide an example. Interested readers can refer to [20] for a comprehensive introduction to the ASP language.

ASP requires that a problem instance is encoded into a logic program in such a way that its answer sets (e.g., its solutions, models according to the stable model semantics <cit.>) can be mapped back into solutions of the original program - usually by projecting onto particular predicates. The most common ASP system architecture is based on the grounding & solving approach - where the logic program is first transformed into a propositional one (e.g., one that does not contain variables) which is then passed to a solver component which searches its answer sets.

Despite sharing syntactical similarities with Prolog, such as normal rules, atoms, and literals, the semantics of answer set programs is radically different as it relies on the concept of stable models <cit.>.

Modern answer set solvers such as clingo <cit.>, introduce many syntactic shortcuts, which ease the modeling task, such as choice rules, weak constraints, and aggregates. Interested readers can refer to [20] for a complete reference on the modeling capabilities of the language, and to <cit.> for an up-to-date reference on the language standard.

§ METHODOLOGY

In this section we propose declarative solutions to all the problems introduced in Section <ref>. In particular, we will detail a knowledge representation for our problems, two Prolog iterative deepening solutions to solve IPP and CIPP, respectively, and an ASP encoding to efficiently solve OIPP. Summing up, we show how to combine Prolog continuous reasoning with the ASP encoding to implement adaptive QoS-, context- and cost-aware container image distribution in cloud-edge landscapes. We assume readers to be familiar with basics of logic programming. For a complete treatment of the Prolog and ASP, we refer them to [17] and [18].

§.§ Knowledge Representation

We encode a problem instance as a set of facts over the predicates node/3, image/3, and link/4, which can be mapped one to one to Definitions <ref>, <ref>, and <ref> of Section <ref>, respectively.

In particular, container images are denoted by facts like image(ImgId, Size, Max),

where ImgId is a unique image identifier, Size is the image size expressed in MB, and Max is the maximum tolerated download latency for the image at hand expressed in ms.

Similarly, infrastructure nodes are declared as facts of the form node(NodeId, Storage, Cost)

where NodeId is a unique node identifier, Storage the available node storage capacity expressed in MB, and Cost the unit storage cost per MB.

Links between nodes are declared as facts of the form link(NodeId1, NodeId2, Latency, Bandwidth)

where NodeId1 and NodeId2 are the considered link endpoints, and Latency and Bandwidth the average end-to-end latency in ms and bandwidth in Mbps featured by such a link.

Finally, the maximum image replica factor is denoted by maxReplicas(R)

where R is an integer.

A portion of the problem instance described in Examples <ref>– <ref> and sketched in Figure <ref> is encoded as follows:

image(alpine,8,30).          image(ubuntu,69,60).       image(nginx,192,120).

node(cloud,1024000,0.7).     node(edge1,64000,0.7).     node(edge2,32000,0.4).
node(edge3,8000,0.5).        node(edge4,4000,0.7).      node(edge5,2000,0.4).

link(edge0,edge1,20,50).     link(edge1,edge0,20,50).    link(edge0,edge2,25,70).
link(edge2,edge0,25,70).     link(edge1,edge2,5,100).    link(edge2,edge1,5,100).
link(edge1,edge3,15,10).     link(edge3,edge1,15,10).    link(edge1,edge4,10,30).
link(edge4,edge1,10,30).     link(edge2,edge5,30,5).     link(edge5,edge2,30,5).

For the sake of readability, we only reported the direct links sketched in Figure <ref>.

§.§ Solving IPP with Prolog

Let us now discuss the Prolog encoding to solve the IPP (Problem <ref>) task.

Placement Strategy Given a (non-empty) list [I|Is] of images to be placed, a list of candidate placement Nodes, a maximum replica factor R, and a partial eligible PPlacement, predicate imagePlacement/5 (lines 1–4) determines a total eligible Placement by relying on subsequent evaluations of predicate replicaPlacement/5 (line 2). While recurring on the image list, replicaPlacement/5 extends the previous partial placement PPlacement into a new eligible partial placement TmpPPlacement which also includes image I at hand (line 3). Recursion ends when the list of images to be placed has been fully consumed, viz., it is empty (line 4).

imagePlacement([I|Is], Nodes, PPlacement, Placement, R) :-
replicaPlacement(I, Nodes, PPlacement, TmpPPlacement, R),
imagePlacement(Is, Nodes, TmpPPlacement, Placement, R).
imagePlacement([], _, Placement, Placement, _).

In turn, given an image I, list of Nodes, a maximum replica factor R and a partial eligible placement PPlacement, predicate replicaPlacement/5 (lines 5–13) extends PPlacement into a new partial eligible NewPPlacement by adding at most R replicas of image I. Until the maximum replica factor has not been exceeded (line 6, viz., Equation <ref> of Definition <ref>) and the transfer time condition for image I in PPlacement does not hold (line 7, viz., Equation <ref> of Definition <ref>), replicaPlacement/5 selects a candidate deployment node N (line 8) onto which I has not been placed yet (line 9). It then checks whether node N can support all images that it hosts as per PPlacement and the new replica of image I (line 10, viz., Equation <ref> of Definition <ref>). If this holds, the association at(I,N) is added to PPlacement in the recursive call (line 11). The recursion ends when the transfer times condition holds for image I by returning the newly constructed eligible partial Placement (line 13).

[firstnumber=5, breaklines]
replicaPlacement(I, Nodes, PPlacement, NewPPlacement, R) :-
R > 0, NewR is R - 1,
transferTimesOk(I, Nodes, PPlacement),
image(I, Size, _), member(N, Nodes),
member(at(I,N), PPlacement),
storageOk(PPlacement, N, Size),
replicaPlacement(I, Nodes, [at(I, N)|PPlacement], NewPPlacement, NewR).
replicaPlacement(I, Nodes, Placement, Placement, _) :-
transferTimesOk(I, Nodes, Placement).

Predicates transferTimesOk/3 and storageOk/3 are in charge of checking conditions imposed by Equation <ref> and Equation <ref> of Definition <ref>, respectively.

Given an image I, a list of nodes [N|Ns], transferTimesOk/3 (lines 14–20) recursively checks that for each node in the list there exists a node M (possibly M=N) from which it is possible to download I within a transfer time of at most MaxT (lines 17–18), as specified in the correspondingimage/3 fact (line 16). Predicate transferTime/4 (line 19–24) simply computes the transfer time T of an Image from a source node Src to a destination node Dst following Equation <ref> of Definition <ref>. We use here the cut operator ! (line 16). Such an operator prevents unwanted backtracking, thus avoiding determining unneeded solutions. Indeed, as per Equation <ref> of Definition <ref>, the availability of one image source is sufficient for each destination node.

[firstnumber=14, breaklines, commandchars=
transferTimesOk(I, [N|Ns], P) :-
dif(P,[]), member(at(I,M),P), image(I,_,MaxT),
transferTime(I,M,N,T), T < MaxT, !,
transferTimesOk(I, Ns, P).
transferTimesOk(_, [], _).

transferTime(Image, Src, Dst, T) :-
dif(Src, Dst), node(Src, _, _), node(Dst, _, _),
image(Image, Size, _),
link(Src, Dst, Latency, Bandwidth),
T is Size * 8 / Bandwidth + Latency / 1000.
transferTime(_, N, N, 0).

Given a partial eligible Placement, a node N and the Size of a new image to be placed on N, predicate storageOk/3 checks whether node N can also host the new image without exceeding its capacity. It first retrieves the node Storage capacity (line 26) and sums up resources allocated at N by the partial placement through predicate usedHW/3 (line 27, 29–30). Finally, it checks Equation <ref> of Definition <ref> for the partial Placement extended with the new image replica (line 28).

[firstnumber=25, breaklines]
storageOk(Placement, N, Size) :-
node(N, Storage, _),
usedHw(Placement, N, UsedHw),
Storage - UsedHw >= Size.

usedHw(P, N, TotUsed) :-
findall(S, (member(at(I,N), P), image(I,S,_)), Used), sum_list(Used, TotUsed).

The above 30 lines of code, mimicking the incremental nature of Definition <ref>, already solve the image placement problem (viz., Problem <ref>) stated in Section <ref> by determining a total eligible placement of a set of images onto a target infrastructure.

Querying the imagePlacement/5 predicate over the input of Example <ref> returns as a first result the eligible image placement P
?- imagePlacement([alpine,ubuntu,nginx], [cloud,edge1,edge2,edge3,edge4,edge5], [], P, 3).
P = [at(nginx, edge5), at(nginx, edge3), at(nginx, cloud), at(ubuntu, edge5), at(ubuntu, edge1), at(ubuntu, cloud), at(alpine, cloud)].

which, going back to the model of Section <ref>, corresponds to the complete eligible placement $p$ defined as follows

$$p(\cd{alpine:latest}) = \{\cd{cloud}\} $$

$$p(\cd{ubuntu:latest}) = \{\cd{cloud, edge1, edge5}\}\ \ \ p(\cd{nginx:latest}) = \{\cd{cloud, edge3, edge5}\} $$

Iterative Deepening To limit the amount of memory used by Prolog's backtracking and make our program more efficient, imagePlacement/5 is wrapped in the id/6 predicate (lines 31–36) that performs iterative deepening [19]. At each step, if the replica factor R has not reached the maximum replica factor RMax (line 32), id/6 exploits imagePlacement/5 to determine a total eligible Placement with at most R replicas of each image (line 33). If such a placement is not found, the value of R is incremented (line 35) and id/6 is called recursively (line 36).

[firstnumber=31, breaklines, commandchars=
{} ]
id(Images, Nodes, PP, Placement, R, RMax) :-
R =< RMax,
imagePlacement(Images, Nodes, PP, Placement, R), !.
id(Images, Nodes, PP, Placement, RMax) :-
R =< RMax, NewR is R+1,
id(Images, Nodes, PP, Placement, NewR, RMax).

The placement/6 (lines 37–41) predicate relies on id/6 (setting the replica factor from 1 to RMax) to determine a total eligible Placement, possibly starting from a partial eligible placement PPlacement. It then computes its Cost by relying on predicate[The Prolog built-in predicate findall(X, Goal, Result) collects in the list Result all the items X satisfying the given Goal. The Prolog built-in predicate sumlist(List, Sum) computes the Sum of all elements in the given List.] cost/2 (lines 39, 42–43) and its storage Allocation via predicate allocatedStorage/2 (lines 40, 44–45). Storage allocation is simply represented as a list of pairs (N,Storage) that keeps track of the Storage used by each image at each node N. Finally, predicate storePlacement/3 (lines 41, 46–49) stores the found Placement, its storage Allocation, and its Cost in the knowledge base as a fact of the form

placedImages(Placement, Allocation, Cost).

that will later be used by our continuous reasoning approach. If a placedImages/3 fact already exists, it is retracted (line 47), and then the new one is asserted (line 48).

[firstnumber=37, breaklines]
placement(Images, Nodes, MaxR, PPlacement, Placement, Cost) :-
id(Images, Nodes, PPlacement, Placement, 1, MaxR),
cost(Placement, Cost),
storePlacement(Placement, Allocation, Cost).

cost(Placement, Cost) :-
findall(CS, (member(at(I,N),Placement), image(I,S,_), node(N,_,C), CS is C*S), CSs), sum_list(CSs, Cost).

allocatedStorage(P, Alloc) :-
findall((N,S), (member(at(I,N), P), image(I,S,_)), Alloc).

storePlacement(Placement, Alloc, Cost) :-
( placedImages/3 -> retract(placedImages/3) ; true),
assert(placedImages(Placement, Alloc, Cost)).

Querying id/6 over the knowledge base of Example <ref> returns the same placement P of Example <ref>, along with its associated cost of €437.

?- placement([alpine,ubuntu,nginx], [cloud,edge1,edge2,edge3,edge4,edge5], 3, [], P, 1, Cost).
P = [at(nginx, edge5), at(nginx, edge3), at(nginx, cloud), at(ubuntu, edge5), at(ubuntu, edge1), at(ubuntu, cloud), at(alpine, cloud)].
Cost = 437.0

As a side effect, it also asserts a fact placedImages(P,Alloc,Cost) within the knowledge base. Such fact can be retrieved as follows

? - placedImages(P, Alloc, Cost).
P = [at(nginx, edge5), at(nginx, edge3), at(nginx, cloud), at(ubuntu, edge5), at(ubuntu, edge1), at(ubuntu, cloud), at(alpine, cloud)],
Alloc = [(edge5, 192), (edge3, 192), (cloud, 192), (edge5, 69), (edge1, 69), (cloud, 69), (cloud, 8)],
Cost = 437.0.

Such asserted facts will be used in the next section for adapting image placements in response to infrastructure changes through continuous reasoning. $\qed$

§.§ Solving CIPP with Prolog

Based on the above, we now describe a solution to CIPP (Problem <ref>).

Predicate cr/7 (lines 49–58) inputs a list [I|Is] of images to be placed, a list of target Nodes, and the current image placement P with its associated allocation Alloc. By recurring on the list of images to be placed, it determines a portion NewPOk of P, which constitutes a partial eligible placement of [I|Is] over Nodes, and collects in the KO list all images that need to be migrated.

The first clause of  cr/7 retrieves the placement of image I from the current placement P and appends it to the partial eligible placement POk being build by creating TmpPOk (lines 50). Then, cr/7 checks[Note that cr/7 exploits an extended version of predicate storageOk/3, which checks all placement nodes and inputs the current allocation Alloc. This is needed to account for changes in the size of an image by unloading the previous allocation and summing up possibly updated image requirements. Interested readers can find the code of storageOk/4 in the  repository. ] whether for TmpPOk Equation <ref>, Equation <ref> and Equation <ref> still hold (lines 51–53). In such a case, TmpPOk is passed to the recursive call, moving to the next image.

Whenever such conditions do not hold true[Pursuing efficiency, instead of negating transferTimesOk/3 and storageOk/4 in the second clause of cr/7, we use the cut operator (line 53) to prevent backtracking, thus avoiding that an image already included in POk (i.e., matching the first clause of cr/7) is then also included in KO (by a later match with the third clause of cr/7).], the second clause of  cr/7 adds image I to the list of KO images (line 55) and recurs to the next image without extending the partial eligible placement being build (line 56). It is worth noting that this case also handles new images to be placed, which can be continuously added to the image repository, by including them in the KO list. The recursion ends when the list of images to be checked is empty (line 57).

[firstnumber=49, breaklines]
cr([I|Is], Nodes, MaxR, P, POk, NewPOk, Alloc, KO) :-
findall(at(I,N), member(at(I,N), P), INs), append(INs, POk, TmpPOk),
length(INs, IReplicas), IReplicas =< MaxR,
transferTimesOk(I, Nodes, TmpPOk),
image(I, Size, _), storageOk(I, Size, TmpPOk, Alloc), !,
cr(Is, Nodes, MaxR, P, TmpPOk, NewPOk, Alloc, KO).
cr([I|Is], Nodes, MaxR, P, POk, NewPOk, Alloc, [I|KO]) :-
cr(Is, Nodes, MaxR, P, POk, NewPOk, Alloc, KO).
cr([], _, _, _, POk, POk, _, []).

Predicate crPlacement/5 retrieves the current Placement and its allocation Alloc (line 60) and exploits cr/7 to identify a partial eligible PPlacement and the list of KOImages within Placement (line 60). Finally, it relies on placement/6 to determine a complete eligible NewPlacement that extends the identified partial one (line 61). If no previous placement exists or it is not possible to fix the current one via continuous reasoning, predicate crPlacement/5 attempts to determine a complete eligible InitPlacement from scratch (line 62–63).

[firstnumber=58, breaklines]
crPlacement(Images, Nodes, MaxR, NewPlacement, Cost) :-
placedImages(Placement, Alloc, _),
cr(Images, Nodes, MaxR, Placement, [], OkPlacement, Alloc, KOImages), dif(KOImages, Images),
placement(KOImages, Nodes, MaxR, OkPlacement, NewPlacement, Cost).
crPlacement(Images, Nodes, MaxR, InitPlacement, Cost) :-
placement(Images, Nodes, MaxR, [], InitPlacement, Cost).

Lastly, predicate declace/2 (lines 64–68) can be called periodically over a changing knowledge base to continuously determine needed updates of the image Placement and its associated Cost. It simply retrieves input data for crPlacement/5 via predicates imagesToPlace/1, networkNodes/1 and via the fact maxReplicas/1 (lines 65–67), and last it calls crPlacement/5 stopping at the first result through once/1 (line 68).

Note that predicates imagesToPlace/1 and networkNodes/1 (lines 65 and 66, respectively) sort their output to drive backtracking via a combination of a fail-first and a fail-last heuristics [19]. Particularly, Images are sorted (and will be explored) by size in descending order so as to try to place larger images first, in that they might be supported by fewer candidate nodes (fail-first).
Nodes are instead sorted by increasing cost and decreasing average outgoing bandwidth and hardware capabilities, thus pursuing the two-fold objective of containing deployment costs and avoiding filling up less capable nodes too early in the search (fail-last).

declace(Placement, Cost) :-
crPlacement(Images, Nodes, Max, Placement, Cost), !.

The above 68 lines of code, which already constitute the core of , heuristically solve the continuous image placement problem (viz., Problem <ref>) stated in Section <ref> by determining a total eligible placement of a set of images onto a target infrastructure, starting from a previous partial eligible placement.

Note that the proposed solution adapts the current placement in response to changes in the image repository to be distributed (i.e., image addition/removal and storage requirements changes), in the target infrastructure (i.e., node/link crash, link QoS degradation), and in the maximum replica factor.

Querying predicate declace/2 over the knowledge base of Example <ref> gives the following result

?- declace(P, Cost).
P = [at(alpine, edge2), at(ubuntu, edge5), at(ubuntu, edge2), at(nginx, edge3), at(nginx, edge5), at(nginx, edge2)],
B = 308.0.

which corresponds to the eligible placement of Example <ref>, costs €308, and replicates alpine onto one node, ubuntu onto two nodes, and nginx onto three nodes.

Assume that node edge3 fails. Querying again predicate declace/2 over the updated knowledge base adapts the previous placement as follows

?- declace(PNew, Cost).
PNew = [at(nginx, edge5), at(nginx, edge2), at(alpine, edge2), at(ubuntu, edge5), at(ubuntu, edge2)],
Cost = 212.0.

which simply removes the nginx image deployed at edge3.

Similarly, adding a new image to place image(redis,149,60) to the repository and querying declace/2 returns the following placement

?- declace(PNew, Cost).
PNew = [at(redis, n5), at(redis, n2), at(alpine, n2), at(ubuntu, n5), at(ubuntu, n2), at(nginx, n5), at(nginx, n2)],
Cost = 331.2.

without affecting the previously determined one but only adding the placement for the redis image, highlighted in green. $\qed$

The described Prolog implementation can be easily extended with a predicate to solve OIPP. However, proving a placement P optimal would require exploring the whole search space, incurring in exp-time complexity. This approach becomes practically unfeasible even over small problem instances and it is the reason why, in the next section, we present an ASP encoding for solving OIPP. As aforementioned, ASP is particularly well-suited to efficiently solve optimisation problems [18].

§.§ Solving OIPP with ASP

We now introduce an ASP encoding (according to the GrinGo language [20]) to solve the OIPP problem (Problem <ref>).

We follow the Guess, Check & Optimise paradigm, thus defining programs that (i) generate the search space of possible image placements, (ii) prune invalid ones, and (iii) minimise an objective function to rank valid solutions.

1  placement(I, N): node(N, _, _) R :- image(I, _, _), maxReplicas(R).

transfer_time(Img, Src, Src, 0) :-
placement(Img, Src).
transfer_time(Img, Src, Dst, @compute_transfer_time(S,B,L)) :-
placement(Img, Src),
image(Img, S, _),
link(Src, Dst, L, B).

transfer_ok(Img, Dst) :-
transfer_time(Img, X, Dst, T),
image(Img, _, MaxTransferTime),
T <= MaxTransferTime.

:- image(Img,_,_), node(Dst, _, _), not transfer_ok(Img, Dst).

:- TS = #sumSize, Img : image(Img, Size, _),
placement(Img, N), node(N, Cap, _), TS > Cap.

:  placement(Img, X), node(X, _, Cost),
image(Img, Size, _). [Cost * Size, Img, X]

ASP encoding of OIPP.

The ASP input follows the format introduced in Section <ref>. Figure <ref> lists the complete ASP encoding.
The first requirement is for each image to be deployed on at least one (and at most R) nodes as per Equation <ref> of Definition <ref>. This is succintly encoded at line 75, where the placement(I,N) atom models that each image I is placed onto a non-empty set of at most R nodes N.

The rules at lines 76–81 account for the computation of transfer times, where transfer_time(I, Src, Dst, T) models that it is possible to transfer image I from node Src to node Dst in T time units. The first rule (line 76–77) states that if the image Img is placed on node Src its transfer time towards Src itself is null.
The second rule computes transfer times in the general case as in the Prolog code (lines 19–24) and relies on the compute_transfer_time, which executes a Python function to compute transfer times of images between pairs of nodes – since ASP does not natively support floating point operations.

Last, the rule transfer_ok(Img,Dst) models that the image Img can be pulled from node Dst within its maximum transfer time.

We now define constraints to prune invalid image placements generated by the above choice rule.

First, each image's transfer time must meet the specified maximum latency requirements as per Equation <ref> of Definition <ref>. Thus, our ASP enconding discards placements that do no allow a node to pull an image within its maximum transfer time (line 86).

Furthermore, the images placed on the same node should not exceed its capacity as per Equation <ref> of Definition <ref>. This is achieved by discarding solutions that do not meet this constraint (line 87–88).
Here, TS is the sum (computed with the aggregate #sum) of the sizes Size over all the pairs (Size, Img) for an image Img with size Size (line 87) placed on the node N with maximum capacity Cap (line 88). The above lines determine all solutions to IPP.

Finally, we aim at finding a cost-optimal image placement, i.e., one that minimise storage costs as per Definition <ref>. We can do so by adding the weak constraint at line 89–90.

Weak constraints enable defining a preference criterion over a logic program's answer sets, akin to an objective function in an optimisation problem. The weak constraint in our program expresses the following: when there is a placement of an image Img of size Size on a node X that has monthly a cost per MB of Cost, such placement contributes to the cost of the answer set as the additive term Cost * Size once for each distinct pair of the tuple (Img,X).

Optimal answer sets are those with minimal costs.

§.§ Functioning of

We assume that  periodically checks the state of the image placement exploiting  Prolog continuous reasoning in combination with ASP-based optimisation. Figure <ref> sketches the overall functioning of .
ASP is used to solve OIPP when (i) an initial image placement needs to be determined, or (ii) the heuristic continuous reasoning, invoked via declace/2, fails to fix the current placement after an infrastructure or repository change. Informally, the ASP encoding acts as a backup for the second clause of crPlacement/5 of Section <ref>.

Such behaviour, which we will thoroughly assess in the next section, suitably alternates ASP optimisation and continuous reasoning adaptation steps, balancing between prompt adaptation and cost optimisation of found placements. On one hand, it ensures optimal initial placements and optimal re-placements when the current status cannot be recovered. On the other hand, it features faster decision-making in the adaptation phase at runtime, by focussing only on those images that need to be migrated to reduce service disruption and avoid unnecessary image transfers.

Indeed, ASP solves OIPP exactly with the disadvantage of possibly incurring longer execution times over small problem instances than our Prolog heuristic, which solves problem instances reduced via continuous reasoning, taming their NP-hard complexity.

At the time of initial placement, we may want to find an optimal solution, since images are yet to be deployed and we could wait some more time in favour of cost minimisation. Once deployed, instead, the goal is to react as fast as possible to network failures or changes in the image requirements.
Hence, quickly determining a (sub-optimal) eligible placement and reducing the number of images to be migrated through continuous reasoning may be preferred to finding a cost-optimal solution.

Analogously, ASP is used when continuous reasoning fails to adapt the current placement. This situation reflects some critical network scenarios that might require some more attention for determining a new placement, thus tolerating longer execution times.

§ EXPERIMENTAL ASSESSMENT

Experimental image set.

Id     Image name     Size [MB]     $T_{max}$     Id     Image name     Size [MB]     $T_{max}$
1      busybox        4        15        7      httpd          195      60
2      memcached      126      30        8      postgres       438      120
3      nginx          192      60        9      ubuntu         69       15
4      mariadb        387      120       10     redis          149      30
5      alpine         8        15        11     rabbitmq       201      60
6      traefik        148      30        12     mysql          621      120

In this section, we report and discuss the results of our experiments[All experiments run on a machine featuring Ubuntu 20.04.5 LTS equipped with 64GB of RAM and a 2.3GHz Intel Xeon Gold 5218 16-core processor.]  with the prototypes illustrated in Section <ref>. In the following, we will assess, compare and contrast via simulation the performance of both the individual components of and of their combination as per the workflow depicted in Figure <ref>.

§.§ Assessment of ASP and Iterative Deepening

In this first experiment, we compare the performance of our iterative deepening solution and ASP solutions to IPP and OIPP, respectively. Particularly, we consider the execution times of both solutions and the cost of their output placements.

Setup We consider the set of images of Table <ref>, and we group them into three subsets, each containing four images: $I_1=\{\cd{busybox}, $ $ \cd{memcached},$ $ \cd{nginx}, $ $ \cd{mariadb}\}$,  $ I_2=\{\cd{alpine}, \cd{traefik},$ $ \cd{httpd},$ $\cd{postgres}\}$, and $I_3=\{\cd{ubuntu},$ $ \cd{redis},$ $\cd{rabbitmq},$ $ \cd{mysql}\}$. Note that the three subsets are homogeneous in that they contain one small image (with maximum transfer time $T_{max}=15$ seconds), two medium images ($T_{max}=30$ and $T_{max}=60$ seconds, respectively), and one large image ($T_{max}=120$ seconds).

We then generate random infrastructures at varying number of nodes $n$. Each infrastructure is generated according to a Barabasi-Albert topology [21], with preferential attachment parameter $m=3$ by relying on the Python's NetworkX library [22]. The Barabasi-Albert
yields graphs with inhomogeneous degree distributions that are often observed in real-life networks [21], characterised by hubs with a high degree (e.g. Cloud nodes), while most of the nodes have a lower degree (e.g. edge noes), such as computer networks and the Internet [23].
As the first nodes in the network are likely to be connected to many other nodes in Barabasi-Albert topologies, we generate infrastructures with three extra nodes and we then remove the first three nodes from the obtained graph to avoid that they can host all image replicas.

On top of the generated network topology, each node gets assigned its storage according to a uniform discrete distribution: 10% of the nodes get 2000 MB, 50% of the nodes get 4000 MB and, 40% of the nodes get either 8000 MB or 16000 MB.

Links in the generated network are assigned a latency in between 1 and 10 ms, and a bandwidth in between 25 and 1000 Mbps. Last, end-to-end links are computed by determining shortest paths between nodes based on latency through Dijkstra algorithm, and constraining them to the minimum bandwidth value along the path.

This first experiment consists of trying to place from scratch the set of images $I_1$, $I_1 \cup I_2$ and $I_1 \cup I_2 \cup I_3$ onto 1000 randomly generated infrastructures per each infrastructure size $n \in \{ 25, 50, 75,$ $ 100, 125, 150\}$. We set the maximum amount of replicas $R=15$. For all runs, we measure execution times (with a timeout of $45$ seconds) and output placement costs.

Results Figure <ref>, <ref>, and <ref> show the average execution times and placement costs obtained over 1000 random instances when placing $I_1$ (4 images), $I_1 \cup I_2$ (8 images) and $I_1 \cup I_2 \cup I_3$ (12 images) onto varying infrastructure sizes. We only consider instances for which both ASP and iterative deepening can succeed, i.e., we do not account for problem instances that are labelled as unsatisfiable by our ASP solution.

Figure <ref> shows that iterative deepening is faster than ASP in placing 4 images for infrastructure of at least 75 nodes. Particularly, it is at least 1–2 seconds faster than ASP for infrastructure sizes above 100 nodes; this corresponds to iterative deepening being between 2% (25 nodes) and 43% (150 nodes) faster than ASP in determining eligible placements. For what concerns cost, instead, iterative deepening determines solutions that are on average more expensive by a factor between 4% (25 nodes) and 18% (150 nodes) than the optimal solution identified by ASP (Figure <ref>). In our experiments, this constitutes a difference of at most 45 euro per month for 150 nodes.

Similarly, Figure <ref> shows that iterative deepening is faster than ASP in placing 8 images, already for infrastructures larger than 50 nodes. This corresponds to execution times that are between 11% (50 nodes) and 58% (150 nodes) faster, in favour of iterative deepening. Again, such a performance increase is paid at the price of solutions that are sub-optimal by a percentage between 7% (25 nodes) and 21% (150 nodes) (Figure <ref>). This turns out in execution times of at most 3 seconds for iterative deepening and of almost 8 seconds for ASP on average, with a cost difference of at most 115 euro per month on average.

Then, Figure <ref> shows that iterative deepening is always faster than ASP in placing 12 images. In this latter case, which represents more complex problem instances, iterative deepening is between 20% (25 nodes) and 81% (150 nodes) faster than ASP in determining solutions that are between 5% (25 nodes) and 15% (150 nodes) far from optimal (Figure <ref>). This corresponds to at most 5-second execution times for iterative deepening, with a cost increase of at most 150 euro per month on average, compared to ASP execution times that reach 22 seconds on average.

Note that, while ASP always determines eligible placements – if any exists – the heuristic approach incurs in some instances that cannot be solved within the timeout. Such number increases along with the size of the considered problem instances (from $0.1\%$ – 8 images, 50 nodes – up to $11.8\%$ of the instances – 12 images, 150 nodes).

execution times

ASP versus iterative deepening at varying number of nodes (4 images).

execution times

ASP versus iterative deepening at varying number of nodes (8 images).

execution times

ASP versus iterative deepening at varying number of nodes (12 images).

Discussion These results confirm the analyses of Section <ref>:

* iterative deepening is in general faster than ASP (by a factor between 2% and 81%) in solving the considered container image placement problem both at varying infrastructure sizes and number of images to be placed,

* ASP always finds exact solutions to OIPP, while heuristic iterative deepening determines solutions that are between 4% and 18% far from optimal, and shows an increasing failure rate while handling larger problem instances,

* iterative deepening stays closer to the optimal when placing fewer images irrespectively of the size of the target infrastructure, as per Figures <ref> and <ref>.

Finally, the above experimental results allow us to estimate reasonable timeout thresholds for both our ASP encoding (which did not exceed 25 seconds on average) and heuristic iterative deepening solution (which did not exceed 6 seconds on average).

§.§ Assessment of adaptive behaviour

In this second experiment, we will assess the performance of in continuously adapting the placement of container images over cloud-edge resources, i.e., in solving CIPP over lifelike scenarios at an increasing number of nodes and images to place. As before, we focus on execution times and placement costs achieved by against an ASP-computed baseline.

Setup We consider again the set of images reported in <ref>, and group them as before into the same subsets of images to place, viz. $I_1$, $I_1 \cup I_2$ and $I_1 \cup I_2 \cup I_3$.

For each amount of images to place, we generate a random Barabasi-Albert infrastructure again setting parameter $m=3$. Each node is initially assigned 4000 MB of storage, while end-to-end links are generated with the same QoS profiles and routing procedure as in the previous experiment.

Differently from the previous experiment, since we are interested in evaluating our methods in an dynamic scenario, we do not generate multiple random infrastructures but simulate life-like network events by modifying an initial random infrastructure and set of images for $1000$ epochs. At each epoch, the following changes in the infrastructure can happen:

* node failure: each node in the network can fail (and be removed from the infrastructure for one[To avoid complete network degradation and considerable reduction of the network size, failed nodes are started anew in the subsequent simulation step. Since node failures affect network for a single simulation step, this implicitly models re-connection of nodes in the infrastructure.] epoch.) with a probability of $5\%$,

* link QoS and node storage variations: with a probability of $0.5$ each node storage, and each link latency and bandwidth profile[To simulate network changes in a lifelike manner, latency increases are accompanied by bandwidth decreases (QoS degradation) and, vice versa, latency decreases are accompanied by bandwidth increases (QoS improvement).] change by a uniformly sampled factor of $\pm 15\%$, and

* image requirements variations: with a probability of $0.1$, each image storage requirement change by a uniformly sampled factor of $\pm 5\%$.

Link and node attributes are directly affected (depending on the type of change), while node-to-node metrics are re-computed as we sketched in the previous experiment and are indirectly affected by the simulated network changes. Thus, each simulation step yields a network infrastructure and image requirements that slightly differ from the previous configuration.

On each step of the simulation, we run (according to the workflow in Figure <ref>) and the vanilla version of our ASP enconding to collect their respective execution times. Continuous reasoning Prolog steps are executed with 6-second timeouts, while ASP-based reasoning steps are executed with a timeout of 25 seconds (both in and in the vanilla version), as per our previous experiment.

Results <ref>, <ref>, and <ref> show the results of the three simulations we run, aggregating average execution times and placement costs at varying infrastructure sizes and for 4, 8 and 12 images, respectively.

As per <ref>, and ASP show similar performances both in terms of execution times and obtained placement costs, with slightly worse on both metrics. Note that, despite this, the optimal ASP solution guarantees a cost-optimal placement but does not consider the implicit cost paid to discard (a possibly large part of) the current image placement (intuitively, the “cost of moving images around”). On the other hand, continuous reasoning attempts to contain this cost by identifying and migrating only those images that do not currently satisfy their transfer time and storage requirements, in view of evolving infrastructure conditions.

On the other hand, <ref> already shows the benefits of continuous reasoning in reducing decision-making times for infrastructures of at least 50 nodes. Indeed, as per <ref>, shows an average consistent reduction in the range of 1.4–1.9 seconds, corresponding to a reduction in the execution times that ranges from  11% (150 nodes) to 21% (75 nodes). For what concerns cost, <ref> shows a slight increase in the range between 3% (150 nodes) and 19.8% (75 nodes).

Finally, <ref> shows how more complex settings can benefit from continuous reasoning on any of the considered infrastructure sizes. Particularly, as per <ref>, improves on execution times by a factor between 19.2% (150 nodes) and 85% (25 nodes). On the other hand, cost increases by a factor between 3.9% (150 nodes) and 23.9% (25 nodes).

Discussion Summing up, we obtained the following experimental evidence:

* execution times lower than ASP: as for problem instances with at least 8 images and 75 nodes, always performs better than ASP by reducing execution times of a portion between $11\%$ and $85\%$ and is inversely proportional to the size of the target infrastructure (i.e., the larger the infrastructure, the lower the gain in terms of execution times),

* limited cost increase: as for problem instances with at least 8 images and 50 nodes, the advantages in terms of execution times brought by correspond to a cost increase between 3% and 24%, also inversely proportional to the size of the target infrastructure,

* avoidance of unnecessary migrations: since continuous reasoning focuses on computing feasible placements by migrating only images that violate constraints in Definition <ref>, which turns out in a considerable reduction in terms of execution times when the current network conditions still support the previously enacted placement.

Overall, the above results show that interleaving ASP with continuous reasoning based on iterative deepening achieves a positive trade-off between execution times and the cost of the found solution placement.

execution times

versus ASP at varying number of nodes (4 images).

execution times

versus ASP at varying number of nodes (8 images).

execution times

versus ASP at varying number of nodes (12 images).

§ RELATED WORK

Despite being interesting and challenging, the problem of distributing container images in Cloud-Edge landscapes has only been investigated in a few recent works, viz., [24, 9, 25, 10, 26], none of which considers runtime image placement adaptation.

Indeed, most efforts have been devoted to the (online or offline) problem of placing multiservice applications onto specific target nodes in a context- and QoS-aware manner as surveyed, for instance, in [6]. Among these, Forti et al. [12] and Herrera et al. [15]   proposed to exploit  continuous reasoning to speed up decision-making at runtime, when selecting suitable placements for multiservice applications.

Focussing on Docker image distribution in cloud datacentres, Kangjin et al. [27] proposed a peer-to-peer extension of the Docker Image Registry system.

Similarly, yet targeting cloud-edge computing settings, the authors of [24] and [25] devise fully decentralised container registries based on local agents compliant with the Docker registry API. Also Zhang et al. [26] propose a container image distribution architecture based on peer-to-peer pre-caching of images onto alive edge nodes. Although missing QoS-, cost- and context-aware strategies to decide on container image placement, the above works show that distributing images around the network can lead to substantially lower container pull times, improved image availability, and reduced network traffic. They might constitute the enabling technology for  to distribute images.

Darrous et al. [9] first investigated the problem of QoS-aware image placement in cloud-edge settings by proposing two placement strategies based on k-center optimisation. While their problem model is similar to ours, they do not consider storage costs and only focus on reducing container retrieval times. They employ a Python-based solver for k-center problems and propose sorting images to be placed by decreasing size as we do. They assess their proposal against a best-fit and a random strategy over networks up to 50 nodes.

Finally, Theodoropoulos et al. [10] formulate the image placement problem as a minimum vertex cover problem and solve it through a reinforcement learning approach. They assess their proposal against a greedy strategy.

Execution times of the proposed reinforcement strategies are two orders of magnitude slower than those of the greedy strategy but obtain on average a better vertex cover.

Differently from , both [9] and [10] focus on initial image placement and do not consider the possibility of adapting such placement in response to runtime infrastructural or image repository changes, which might turn useful in ever-changing cloud-edge landscapes, working in continuity with CI/CD release pipelines.

To the best of our knowledge, our work is the first employing continuous reasoning for adaptively solving the cloud-edge image placement problem at runtime while reducing execution times, by focussing only on those images that need to be re-allocated. Thanks to its declarative nature, our approach features better readability, maintainability and extensibility than procedural solutions like [9], and better

interpretability and incrementality of the obtained solutions, which can be difficult to obtain when relying on learning approaches, like [10].

§ CONCLUDING REMARKS

In this article, we have formally modelled the (optimal and continuous versions of the) problem of adaptive placement of container images in cloud-edge setting and proved its decisional version is NP-hard. Then, we have proposed a declarative pipeline to solve such a problem in a QoS- , context- and cost-aware manner. We have implemented our methodology through logic programming in the open-source prototype , which combines ASP to determine cost-optimal initial placements and Prolog for adapting image placements at runtime via continuous reasoning. We have thoroughly assessed our prototype by simulating its functioning over lifelike data.

The incremental approach of continuous reasoning reduces the size of the problem instances to be solved and the number of image migrations. This makes runtime decision-making faster, also avoiding unneeded data transfers. The synergistic use of Prolog and ASP balances initial cost optimisation with prompt runtime adaptation. The usage of logic programming to define our methodology makes it more concise ($\simeq$ 100 lines of code), readable and extensible than imperative solutions.

Future work on this line may include:

* the extension of  to account for image layers, dependencies between non-base images, and associated transfer delays, and with with probabilistic reasoning [28] to assess candidate placements against the uncertainty of infrastructure variations, so to improve the resilience of found placements against such variations (as in [29]),

* the combination of our methodology with deep learning solutions for container image placement (like [10]) to extend them with interpretability, explainability and incrementality features and to equip  with prediction features, eventually improving decisions in the spirit on neuro-symbolic artificial intelligence <cit.>, and

* further experimental assessment over real data about the dynamics of cloud-edge networks (currently unavailable) and the integration of with a distributed container repository to be assessed in testbed settings with real images to manage.

#1ISBN #1#1#1#1#1#1#1#1#1#1#1#1#1#1#1#1#1#1#1#1#1<https://doi.org/#1>et al.#1#1#1#1#1#1#1#1#1#1#1#1#1#1#1#1#1#1#1#1#1#1#1#1#1#1#1#1#1#1#1#1<><#>1#1#1#1#1#1#1#1#1#1#1#1#1#1PreBibitemsHook

[1]

Naha, R.K., :
Fog computing: Survey of trends, architectures, requirements, and research directions.
IEEE Access

[2]

Khan, W.Z., :
Edge computing: A survey.
Future Gener. Comput. Syst.

[3]

Tortonesi, M., :
Taming the iot data deluge: An innovative information-centric service model for fog computing applications.
Future Gener. Comput. Syst.

[4]

Aït-Salaht, F.,
Desprez, F.,
Lebre, A.:
An overview of service placement problem in fog and edge computing.
ACM Comput. Surv.

[5]

Forti, S., :
Declarative continuous reasoning in the cloud-iot continuum.
J. Log. Comput.

[6]

Mahmud, M.R., :
Application management in fog computing environments: A taxonomy, review and future directions.
ACM Comput. Surv.

[7]

Shakarami, A., :
Resource provisioning in edge/fog computing: A comprehensive and systematic review.
J. Syst. Archit.

[8]

Soldani, J., :
The pains and gains of microservices: A systematic grey literature review.
J. Syst. Softw.

[9]

Darrous, J., :
On the importance of container image placement for service provisioning in the edge.
In: IEEE ICCCN,
pp. 1–9

[10]

Theodoropoulos, T., :
GNOSIS: proactive image placement using graph neural networks & deep reinforcement learning.
In: IEEE CLOUD,
pp. 120–128

[11]

Aslanpour, M.S., :
Serverless edge computing: Vision and challenges.
In: ACM ACSW,
pp. 10–11010

[12]

Forti, S., :
Lightweight self-organising distributed monitoring of fog infrastructures.
Future Gener. Comput. Syst.

[13]

Springer, A.:
How often are Docker images updated - Revisited.
Last accessed: August 27, 2024

[14]

Distefano, D., :
Scaling static analyses at facebook.
Commun. ACM

[15]

Herrera, J.L., :
Continuous qos-aware adaptation of cloud-iot application placements.

[16]

Garey, M.R.,
Johnson, D.S.:
Computers and Intractability: A Guide to the Theory of NP-Completeness

[17]

Sterling, L.,
Shapiro, E.:
The Art of Prolog: Advanced Programming Techniques.
Logic programming.
MIT Press,

[18]

Lifschitz, V.:
Answer Set Programming.

[19]

Russell, S.,
Norvig, P.:
Artificial Intelligence: A Modern Approach (4th Edition).

[20]

Potassco User Guide

[21]

Barabási, A.-L.,
Albert, R.:
Emergence of scaling in random networks.

[22]

Hagberg, A.A., :
Exploring network structure, dynamics, and function using NetworkX.
In: Varoquaux, G.,
Vaught, T.,
Millman, J. (eds.)
Proceedings of the 7th Python in Science Conference,
pp. 11–15

[23]

Barabási, A.-L.,
Albert, R.,
Jeong, H.:
Scale-free characteristics of random networks: the topology of the world-wide web.
Physica A: Statistical Mechanics and its Applications

[24]

Becker, S., :
EdgePier: P2P-based container image distribution in edge computing environments.
In: IEEE IPCCC,
pp. 1–8

[25]

Gazzetti, M., et al.:
Scalable linux container provisioning in fog and edge computing platforms

[26]

Zhang, J., :
A container deployment optimization method for edge computing.
In: Journal of Physics: Conference Series,
vol. 1927,
p. 012017
IOP Publishing

[27]

Wang, K., et al.:
FID: A faster image distribution system for docker platform,

[28]

Azzolini, D.,
Riguzzi, F.,
Lamma, E.:
A semantics for hybrid probabilistic logic programs with function symbols.
Artificial Intelligence

[29]

Forti, S., :
Probabilistic QoS-aware Placement of VNF Chains at the Edge.
Theory Pract. Log. Program.


${\cal N}=1$ supersymmetric QCD with $1\leq N_{F}<N_{c}$ light quarks flavors
:
the phase transition at large $N_{c}$

Victor L. Chernyak ${}^{\,a,\,b}$

(e-mail<EMAIL_ADDRESS>
${}^{a}\,$ Novosibirsk State University,

630090 Novosibirsk, Pirogova str.2, Russia

${}^{b}\,$ Budker Institute of Nuclear Physics SB RAS,

630090 Novosibirsk, Lavrent’ev ave.11, Russia

Abstract

It is argued that in ${\cal N}=1$ $SU(N_{c})$ supersymmetric QCD (SQCD) with
$1\leq N_{F}<N_{c}$ flavors of light quarks there is the phase transition at
large $N_{c}\sim N^{0}_{c}\gg 1$ between the region $N_{c}\ll N^{0}_{c}$ where
quarks are higgsed to the region $N_{c}\gg N^{0}_{c}$ where they are confined.

Besides, it is shown in Appendix that at $N_{F}=N_{c}-1,\,N_{c}\ll N^{0}_{c}$
there is the phase transition at $m_{Q}\sim\Lambda_{Q}$ between the region
$m_{Q}\gg\Lambda_{Q}$ where quarks are confined and the region
$m_{Q}\ll\Lambda_{Q}$ where they are higgsed.

##  1 The Higgs phase

The purpose of this paper is to argue that, in the standard ${\cal N}=1$
supersymmetric QCD (SQCD) with $SU(N_{c})$ colors and $1\leq N_{F}<N_{c}$
flavors of light quarks with $m_{Q}\ll\Lambda_{Q}$, there is a phase
transition at $N_{c}\sim N^{0}_{c}\gg 1$ from the region $N_{c}\ll N^{0}_{c}$
in which all light quarks are higgsed to the region $N_{c}\gg N^{0}_{c}$ where
they are not higgsed but confined.

For this, let us recall first in short some properties of the standard ${\cal
N}=1$ SQCD with $SU(N_{c})$ colors and $1\leq N_{F}<3N_{c}$ flavors of light
quarks, see e.g. section 2 in [1]. It is convenient to start e.g. with
$3N_{c}/2<N_{F}<3N_{c}$, $m_{Q}\rightarrow 0$ and the scale $\mu=\Lambda_{Q}$.
The Lagrangian looks as 111 The gluon exponents are implied in Kahler terms.

$\displaystyle K={\rm
Tr}\,\Bigl{(}Q^{\dagger}Q+(Q\rightarrow{\overline{Q}})\Bigr{)}\,,\quad{\cal
W}=-\frac{2\pi}{\alpha(\mu=\Lambda_{Q})}S+m_{Q}{\rm Tr}\,({\overline{Q}}Q)\,.$
(1.1)

Here : $m_{Q}=m_{Q}(\mu=\Lambda_{Q})$ is the mass parameter,
$S_{N_{c}}=\sum_{A,\beta}W^{A}_{\beta}W^{A,\,\beta}/32\pi^{2}$, where
$W^{A}_{\beta}$ is the gauge field strength, $A=1...N_{c}^{2}-1,\,\beta=1,2$,
$a(\mu)=N_{c}g^{2}(\mu)/8\pi^{2}=N_{c}\alpha(\mu)/2\pi$ is the gauge coupling
with its scale factor $\Lambda_{Q}$. Let us evolve now to the UV Pauli-Villars
(PV) scale $\mu_{PV}$ to define the parent UV theory. The only change in
comparison with (1.1) will be the appearance of the corresponding logarithmic
renormalization factor $z(\Lambda_{Q},\mu_{PV})\gg 1$ in the Kahler term for
massless quarks and replacement of $\alpha(\mu=\Lambda_{Q})$ by
$\alpha(\mu=\mu_{PV})\ll\alpha(\mu=\Lambda_{Q})$, while the scale factor
$\Lambda_{Q}$ of the gauge coupling remains the same. Now, we continue the
parameter $m_{Q}$ from zero to some nonzero value, e.g.
$0<m_{Q}\ll\Lambda_{Q}$. And this will be a definition of our parent UV
theory.

The Konishi anomaly [2] for this theory looks as

$\displaystyle m_{Q}(\mu)\langle M^{i}_{j}(\mu)\rangle=\delta^{i}_{j}\langle
S\rangle\,,\quad i,j=1...N_{F}\,,\quad
M^{i}_{j}(\mu)=\sum_{a=1}^{N_{c}}\Bigl{(}{\overline{Q}}^{a}_{j}Q^{i}_{a}(\mu)\Bigr{)}\,,$
(1.2) $\quad m_{Q}(\mu)=z^{-1}_{Q}(\Lambda_{Q},\mu)m_{Q}\,,\quad m_{Q}\equiv
m_{Q}(\mu=\Lambda_{Q})\,,\quad
M^{i}_{j}(\mu)=z_{Q}(\Lambda_{Q},\mu)M^{i}_{j}\,,\quad M^{i}_{j}\equiv
M^{i}_{j}(\mu=\Lambda_{Q})\,.$

Evolving now to lower energies, the regime is conformal at $\mu<\Lambda_{Q}$
and the pole mass of quarks looks as 222 Here and below we use the
perturbative NSVZ $\beta$-function [3]. In (1.3) and below $A\sim B$ means
equality up to a constant factor independent of $m_{Q}$ and $N_{c}$.

$\displaystyle m^{\rm pole}_{Q}=\frac{m_{Q}}{z_{Q}(\Lambda_{Q},m^{\rm
pole}_{Q})}\sim\Lambda_{Q}\Bigl{(}\frac{m_{Q}}{\Lambda_{Q}}\Bigr{)}^{\frac{N_{F}}{3N_{c}}}\ll\Lambda_{Q}\,,\quad
z_{Q}(\Lambda_{Q},\mu\ll\Lambda_{Q})\sim\Bigl{(}\frac{\mu}{\Lambda_{Q}}\Bigr{)}^{\frac{3N_{c}-N_{F}}{N_{F}}}\ll
1\,.$ (1.3)

Integrating then all quarks as heavy, 333 As well known, the global flavor
symmetry $SU(N_{F})$ is not broken spontaneously in ${\cal N}=1$ $SU(N_{c})$
SQCD for equal mass quarks, see (1.2). Therefore, due to the rang restriction
at $N_{F}>N_{c}$, the quarks are not higgsed but decouple as heavy.  there
remains $SU(N_{c})$ SYM with the scale factor $\Lambda_{SYM}$ (1.4) of its
coupling. Integrating then all gluons via the Veneziano-Yankielowicz (VY)
procedure [4], one obtains the gluino condensate see (1.2)

$\displaystyle\Lambda_{SYM}=\Bigl{(}\Lambda_{Q}^{3N_{c}-N_{F}}m^{N_{F}}_{Q}\Bigr{)}_{,}^{\frac{1}{3N_{c}}}\quad\langle
S\rangle=\Lambda_{SYM}^{3}=\Bigl{(}\Lambda_{Q}^{3N_{c}-N_{F}}m^{N_{F}}_{Q}\Bigr{)}^{\frac{1}{N_{c}}}=m_{Q}\langle
M\rangle,\quad\langle
M\rangle=\Lambda_{Q}^{2}\Bigl{(}\frac{m_{Q}}{\Lambda_{Q}}\Bigr{)}_{.}^{\frac{N_{F}-N_{c}}{N_{c}}}\,$
(1.4)

Another way, we can take the IR-free ${\cal N}=1$ SQCD with $N_{F}>3N_{c}$ and
to start from $\mu=\Lambda_{Q}$ with $m_{Q}\ll\Lambda_{Q}$. All quarks
decouple as heavy at $\mu=m^{\rm pole}_{Q}=m_{Q}/z_{Q}(\Lambda_{Q},m^{\rm
pole}_{Q})\ll\Lambda_{Q}$ in the weak coupling regime, where
$z_{Q}(\Lambda_{Q},m^{\rm pole}_{Q})\ll 1$ is the logarithmic renormalization
factor. There remains ${\cal N}=1\,\,SU(N_{c})$ SYM with the scale factor
$\Lambda_{SYM}$ of its coupling. From matching the coupling $a_{+}(m^{\rm
pole}_{Q})$ with $a_{SYM}(m^{\rm pole}_{Q})$ one obtains the same
$\Lambda_{SYM}$ (1.4).

Now (1.4) can be continued to other values of $N_{F}$, in particular $1\leq
N_{F}<N_{c}$ considered in this paper.

In this range of $N_{F}$, the standard weak coupling Higgs phase at $N_{c}\ll
N^{0}_{c}$ (2.1) for light quarks with $0<m_{Q}\ll\Lambda_{Q}$ looks as
follows, see e.g. section 2 in [1]. All light quarks are higgsed at the high
scale $\mu\sim\mu^{\rm pole}_{\rm gl}\gg\Lambda_{Q}$ in the weak coupling
regime 444 We ignore from now for simplicity all logarithmic factors and trace
only the power dependence on $m_{Q}/\Lambda_{Q}$ and on $N_{c}$.

$\displaystyle\Bigl{(}\frac{\mu^{\rm pole}_{\rm
gl}}{\Lambda_{Q}}\Bigr{)}^{2}\sim g^{2}(\mu=\mu^{\rm pole}_{\rm
gl})\,z_{Q}(\Lambda_{Q},\mu=\mu^{\rm pole}_{\rm
gl})\,\frac{\langle{\overline{Q}}\rangle\,\langle
Q\rangle}{\Lambda_{Q}^{2}}\sim\frac{1}{N_{c}}\frac{\langle
S\rangle}{m_{Q}\Lambda_{Q}^{2}}\sim\frac{1}{N_{c}}\Bigl{(}\frac{\Lambda_{Q}}{m_{Q}}\Bigr{)}^{\frac{N_{c}-N_{F}}{N_{c}}}\gg
1\,,$ (1.5) $\quad g^{2}(\mu=\mu^{\rm pole}_{\rm
gl})\approx\frac{8\pi^{2}}{(3N_{c}-N_{F})\ln\Bigl{(}\mu^{\rm pole}_{\rm
gl}/\Lambda_{Q}\Bigr{)}}\sim\frac{1}{N_{c}}\,,\quad
z_{Q}(\Lambda_{Q},\mu=\mu^{\rm pole}_{\rm gl})\sim\Bigl{(}\ln\frac{\mu^{\rm
pole}_{\rm gl}}{\Lambda_{Q}}\Bigr{)}^{\frac{N_{c}}{3N_{c}-N_{F}}}\sim 1\,.$

For $N_{F}\leq N_{c}-2$, the color gauge group $SU(N_{c})$ is broken as
$SU(N_{c})\rightarrow SU(N_{c}-N_{F})$. $N_{F}(2N_{c}-N_{F})$ gluons and the
same number of their ${\cal N}=1$ scalar superpartners acquire masses
$\mu^{\rm pole}_{\rm gl}\gg\Lambda_{Q}$ and decouple at $\mu<\mu^{\rm
pole}_{\rm gl}$. There remain at lower energies $SU(N_{c}-N_{F})$ SYM and
$N^{2}_{F}$ light pion fields $M^{i}_{j},\,i,j=1...N_{F}$. After integrating
out all heavy particles with masses $\sim\mu^{\rm pole}_{\rm gl}$, the scale
factor of $SU(N_{c}-N_{F})$ SYM looks as, see section 2 in [1] and (1.2) 555
The whole $SU(N_{c})$ group is higgsed at $N_{F}=N_{c}-1$ and the
nonperturbative term in the superpotential (1.7) is then due to the instanton
contribution [5]. For $N_{F}\leq N_{c}-2$ the instanton contribution to
superpotential from the broken part of $SU(N_{c})$ is zero due to extra gluino
zero modes. The nonperturbative term in the superpotential (1.7) originates
from nonperturbative effects in the ${\cal N}=1\,\,SU(N_{c}-N_{F})$ SYM, see
section 2 in [1] and [4].

$\displaystyle\Lambda^{3}_{SYM}=\Bigl{(}\frac{\Lambda_{Q}^{3N_{c}-N_{F}}}{\det
M}\Bigr{)}^{\frac{1}{N_{c}-N_{F}}},\quad
M^{i}_{j}=\sum_{a=1}^{N_{c}}\Bigl{(}{\overline{Q}}^{a}_{j}Q^{i}_{a}\Bigr{)}(\mu=\Lambda_{Q})\,,\quad\langle
M^{i}_{j}\rangle=\delta^{i}_{j}\langle M(\mu=\Lambda_{Q})\rangle\,.$ (1.6)

Lowering energy to $\mu\sim\Lambda_{SYM}$ and integrating all
$SU(N_{c}-N_{F})$ gluons via the VY procedure [4], the Lagrangian of
$N^{2}_{F}$ light pions $M^{i}_{j}$ looks as

$\displaystyle K_{M}\sim\sqrt{{\rm Tr}\,(M^{\dagger}M)}\,,\quad{\cal
W}_{M}=m_{Q}{\rm
Tr}\,M+(N_{c}-N_{F})\Bigl{(}\frac{\Lambda_{Q}^{3N_{c}-N_{F}}}{\det
M}\Bigr{)}^{\frac{1}{N_{c}-N_{F}}}.$ (1.7)

From this, $\langle M\rangle$ and the pion masses are

$\displaystyle\langle
M\rangle=\Lambda_{Q}^{2}\Bigl{(}\frac{\Lambda_{Q}}{m_{Q}}\Bigr{)}^{\frac{N_{c}-N_{F}}{N_{c}}}\,,\quad\mu^{\rm
pole}(M)\sim m_{Q}\ll\Lambda_{SYM}\ll\Lambda_{Q}\,.$ (1.8)

On the whole, the mass spectrum at $N_{c}\ll N^{0}_{c}$ looks as follows. All
quarks are higgsed and there are: $N_{F}(2N_{c}-N_{F})\,\,\,{\cal N}=1$
multiplets of massive gluons with large masses $\mu^{\rm pole}_{\rm
gl}\gg\Lambda_{Q}$ (1.5); a large number of gluonia with the mass scale
$\sim\Lambda_{SYM}\ll\Lambda_{Q}$ (1.6),(1.4); $N^{2}_{F}$ light pions with
masses $\sim m_{Q}\ll\Lambda_{SYM}$ (1.8).

##  2 The heavy quark (HQ) phase

As it is seen from (1.5), the value $\mu^{\rm pole}_{\rm gl}$ decreases with
increasing $N_{c}$ at $\mu\gtrsim\Lambda_{Q}$. And at sufficiently large
number of colors,

$\displaystyle N_{c}\gg
N^{0}_{c}\,,\quad\frac{N^{0}_{c}}{N^{0}_{c}-N_{F}}\ln(N^{0}_{c})\sim\ln(\frac{\Lambda_{Q}}{m_{Q}})\gg
1\,.$ (2.1)

it becomes much smaller than $\Lambda_{Q}$. This means that quarks are not
higgsed in the weak coupling regime at $\mu\gg\Lambda_{Q}$. And now, at
$N_{c}\gg N^{0}_{c}$ (2.1), all quarks and gluons remain effectively massless
in some interval of scales $\mu_{H}<\mu<\Lambda_{Q}$. Recall also that
considered ${\cal N}=1$ SQCD is outside the conformal window at
$N_{F}<3N_{c}/2$ [6]. Therefore, to see whether quarks are really able to give
by higgsing such a mass to gluons which will stop the massless RG-evolution,
we have to consider the region $\mu\ll\Lambda_{Q}$ where the theory entered
into a perturbative strong coupling regime with
$a(\mu\ll\Lambda_{Q})=N_{c}\alpha(\mu)/2\pi\gg 1$.

Let us recall a similar situation at $N_{c}<N_{F}<3N_{c}/2$ considered in
section 7 of [1] (only pages 18 - 21, including the footnote 18). As pointed
out therein, when decreasing scale $\mu$ crosses $\mu\sim\Lambda_{Q}$ from
above, the increasing perturbative coupling $a(\mu)$ crosses unity from below.
But for (effectively) massless quarks and gluons the perturbatively exact NSVZ
$\beta$-function [3]

$\displaystyle\frac{da(\mu)}{d\ln\mu}=\beta(a)=-\,\frac{a^{2}}{1-a}\,\frac{(3N_{c}-N_{F})-N_{F}\gamma_{Q}(a)}{N_{c}}\,,\quad
a(\mu)=N_{c}g^{2}(\mu)/8\pi^{2}=N_{c}\alpha(\mu)/2\pi\,.$ (2.2)

can’t change its sign by itself (and can’t become frozen outside the conformal
window) and behaves smoothly. I.e., when increased $a(\mu)$ crosses unity from
below and denominator in (2.2) crosses zero, the increased quark anomalous
dimension $\gamma_{Q}(\mu)$ crosses $(3N_{c}-N_{F})/N_{F}$ from below, so that
the $\beta$-function behaves smoothly and remains negative at
$\mu<\Lambda_{Q}$. The coupling $a(\mu\ll\Lambda_{Q})$ continues to increase
with decreasing $\mu$

$\displaystyle\frac{da(\mu)}{d\ln\mu}=\beta(a)\rightarrow\,-\,\nu\,a\,<\,0,\quad\nu=\Bigl{[}\frac{N_{F}}{N_{c}}(1+\gamma^{\rm
str}_{Q})-3\Bigr{]}={\rm const}>0\,,\quad
a(\mu\ll\Lambda_{Q})\sim\Bigl{(}\frac{\Lambda_{Q}}{\mu}\Bigr{)}^{\nu\,>\,0}\gg
1\,.$ (2.3)

In section 7 of [1] (see also [7],[8]) the values $\gamma^{\rm
str}_{Q}=(2N_{c}-N_{F})/(N_{F}-N_{c})>1,\,\,\nu=(3N_{c}-2N_{F})/(N_{F}-N_{c})>0$
at $\mu\ll\Lambda_{Q}$ and $N_{c}<N_{F}<3N_{c}/2$ have been found from
matching of definite two point correlators in the direct $SU(N_{c})$ theory
and in $SU(N_{F}-N_{c})$ Seiberg’s dual [6]. In our case here with $1\leq
N_{F}<N_{c}$ the dual theory does not exist. So that, unfortunately, we can’t
find the concrete value $\gamma^{\rm str}_{Q}$. But, as will be shown below,
for our purposes it will be sufficient to have the only condition $\nu>0$ in
(2.3).

Let us look now whether a potentially possible higgsing of quarks at $N_{c}\gg
N^{0}_{c}$ (2.1) can give gluons such a mass which will stop the massless RG-
evolution. At $N_{c}\gg N^{0}_{c}\gg 1$ such running gluon mass at
$\mu\ll\Lambda_{Q}$ would look as, see (1.5),(2.3),(2.6),(2.7)

$\displaystyle\frac{\mu^{2}_{\rm
gl}(\mu\ll\Lambda_{Q},N_{c})}{\mu^{2}}\sim\frac{a(\mu\ll\Lambda_{Q})}{N_{c}}\,z_{Q}(\Lambda_{Q},\mu\ll\Lambda_{Q})\,\frac{\langle{\overline{Q}}\rangle\langle
Q\rangle}{\mu^{2}}\sim\Bigl{(}\frac{\mu}{\Lambda_{Q}}\ll
1\Bigr{)}^{\Delta>\,0}\Bigl{[}\frac{1}{N_{c}}\Bigl{(}\frac{\Lambda_{Q}}{m_{Q}}\Bigr{)}^{\frac{N_{c}-N_{F}}{N_{c}}}\ll
1\Bigr{]}\ll 1,\,\,$ (2.4) $\Delta=\frac{N_{c}-N_{F}}{N_{c}}(1+\gamma^{\rm
str}_{Q})>0\,,\quad
z_{Q}(\Lambda_{Q},\mu\ll\Lambda_{Q})\sim\Bigl{(}\frac{\mu}{\Lambda_{Q}}\Bigr{)}^{\gamma^{\rm
str}_{Q}\,>\,2}\ll 1\,,\quad{\rm at}\quad m^{\rm
pole}_{Q}<\mu\ll\Lambda_{Q}\,,$ $\displaystyle\frac{\mu^{2}_{\rm
gl}(\mu<m^{\rm pole}_{Q},N_{c})}{\mu^{2}}\sim\frac{a^{(str)}_{SYM}(\mu<m^{\rm
pole}_{Q})}{N_{c}}\,z_{Q}(\Lambda_{Q},m^{\rm
pole}_{Q})\,\frac{\langle{\overline{Q}}\rangle\langle
Q\rangle}{\mu^{2}}\sim\frac{1}{N_{c}}\frac{\mu}{m^{\rm pole}_{Q}}\ll
1,\quad{\rm at}\,\,\Lambda_{SYM}<\mu<m^{\rm pole}_{Q}.\,$ (2.5)

It is seen from (1.5),(2.4),(2.5) that at $N_{c}\gg N^{0}_{c}$ (2.1) the
potentially possible gluon mass becomes too small. I.e., at $N_{c}\gg
N^{0}_{c}$ potentially higgsed quarks become unable to give such masses to
gluons which will stop the massless RG-evolution (and there is no pole in the
gluon propagator). Although the mean value $\langle
M\rangle=\sum_{a=1}^{N_{c}}\langle{\overline{Q}}^{a}_{1}Q^{1}_{a}\rangle(\mu=\Lambda_{Q})=\langle
S\rangle/m_{Q}\gg\Lambda_{Q}^{2}$ (1.4) remains numerically the same, it
becomes non-factorizable at $N_{c}\gg N^{0}_{c}$ because gluons become
(effectively) massless. The order parameter
$\rho=\langle{\overline{Q}}\rangle=\langle Q\rangle$ drops then to zero due to
freely fluctuating quark phases from interaction with (effectively) massless
gluons. And this shows that the assumption about higgsed quarks becomes not
self-consistent at $N_{c}\gg N^{0}_{c}$.

And the meaning and properties of the operator $M$ are very different for
higgsed at $N_{c}\ll N^{0}_{c}$ or non-higgsed at $N_{c}\gg N^{0}_{c}$ quarks.
While $M=[\,\langle{\overline{Q}}\rangle\langle Q\rangle\neq 0\,]+\delta M$ is
the one-particle operator $\delta M$ of the light pion for higgsed quarks, see
(1.7), for non-higgsed quarks with $\rho=\langle{\overline{Q}}\rangle=\langle
Q\rangle=0$ it is the two-particle quark operator, its mean value $\langle
M\rangle$ becomes non-factorizable and originates from the one-loop Konishi
anomaly, see (1.4).

Therefore, let us look in this case of non-higgsed quarks on the increasing
with decreasing $\mu<\Lambda_{Q}$ running quark mass $m_{Q}(\mu<\Lambda_{Q})$
and on possible value of the quark pole mass. It looks as, see (2.3)

$m_{Q}(\mu\ll\Lambda_{Q})=\frac{m_{Q}}{z_{Q}(\Lambda_{Q},\mu\ll\Lambda_{Q})}\,,\quad
z_{Q}(\Lambda_{Q},\mu\ll\Lambda_{Q})\sim\Bigl{(}\frac{\mu}{\Lambda_{Q}}\Bigr{)}^{\gamma^{\rm
str}_{Q}\,>\,2}\ll 1\,,$

$\displaystyle m^{\rm pole}_{Q}=\frac{m_{Q}}{z_{Q}(\Lambda_{Q},m^{\rm
pole}_{Q})}\quad\rightarrow\quad m^{\rm
pole}_{Q}\sim\Lambda_{Q}\Bigl{(}\frac{m_{Q}}{\Lambda_{Q}}\Bigr{)}^{\frac{1}{1+\gamma^{\rm
str}_{Q}}\,>\,0}\ll\Lambda_{Q}\,.$ (2.6)

As a result, the quarks are not higgsed and decouple as heavy at $\mu<m^{\rm
pole}_{Q}$. There remains at lower energies the ${\cal N}=1\,\,SU(N_{c})$ SYM
in the strong coupling branch. From the NSVZ $\beta$-function [3]

$\frac{da^{(str)}_{SYM}(\mu\gg\Lambda_{SYM})}{d\ln\mu}=-\frac{3\,\Bigl{(}a^{(str)}_{SYM}(\mu\gg\Lambda_{SYM})\Bigr{)}^{2}}{1-a^{(str)}_{SYM}(\mu\gg\Lambda_{SYM})}\rightarrow
3\,a^{(str)}_{SYM}(\mu)\,,$ $\displaystyle
a^{(str)}_{SYM}(\mu\gg\Lambda_{SYM})\sim\Bigl{(}\frac{\mu}{\Lambda_{SYM}}\Bigr{)}^{3}\gg
1\,,\quad a^{(str)}_{SYM}(\mu\sim\Lambda_{SYM})={\cal O}(1)\,.$ (2.7)

At $\mu<\Lambda_{SYM}$ the whole RG evolution becomes frozen due to
nonperturbative effects $\sim\Lambda_{SYM}$ in the pure ${\cal N}=1$ SYM. The
scale factor of $\Lambda_{SYM}$ of the gauge coupling is determined from
matching, see (2.3),(2.6),(2.7)

$\displaystyle a_{+}(\mu=m^{\rm pole}_{Q})=\Bigl{(}\frac{\Lambda_{Q}}{m^{\rm
pole}_{Q}}\Bigr{)}^{\nu}=a^{(str)}_{SYM}(\mu=m^{\rm
pole}_{Q})=\Bigl{(}\frac{m^{\rm
pole}_{Q})}{\Lambda_{SYM}}\Bigr{)}^{3}\,\rightarrow\,\Lambda_{SYM}=\Bigl{(}\Lambda_{Q}^{3N_{c}-N_{F}}m^{N_{F}}_{Q}\Bigr{)}^{1/3N_{c}}\,,$
(2.8)

as it should be, see (1.4).

Besides, as a check of self-consistency, see (2.3),(2.6),(2.8)

$\displaystyle\Bigl{(}\frac{\Lambda_{SYM}}{m^{\rm
pole}_{Q}}\Bigr{)}^{3}\sim\Bigl{(}\frac{m_{Q}}{\Lambda_{Q}}\Bigr{)}^{\omega\,>\,0}\ll
1\,,\quad\omega=\frac{\nu>0}{(1+\gamma^{\rm str}_{Q})}>0\,.$ (2.9)

as it should be.

On the whole, the mass spectrum at $N_{c}\gg N^{0}_{c}$ (2.1) looks as
follows. a) The quarks are not higgsed (i.e. $\rho=0$ and their color charges
are not screened due to $\rho=\langle
Q\rangle=\langle{\overline{Q}}\rangle\neq 0$) but decouple as heavy at
$\mu<m^{\rm pole}_{Q}$ and are weakly confined. There is a large number of
quarkonia with the mass scale ${\cal O}(m^{\rm pole}_{Q})\ll\Lambda_{Q}$, see
(2.6),(2.8),(2.9), with different spins and other quantum numbers. The
confinement originates from the ${\cal N}=1\,\,SU(N_{c})$ SYM and so the
string tension is $\sigma^{1/2}_{SYM}\sim\Lambda_{SYM}\ll m^{\rm
pole}_{Q}\ll\Lambda_{Q}$. 666 There is no confinement in Yukava-like theories
without gauge interactions. Confinement originates only from (S)YM sector. The
${\cal N}=1$ SYM is the theory with only one dimensional parameter
$\Lambda_{SYM}$. Therefore, it can’t give a string tension
$\sigma^{1/2}\sim\Lambda_{Q}$, but only
$\sigma^{1/2}\sim\Lambda_{SYM}\ll\Lambda_{Q}$.  b) There is a large number of
gluonia with the mass scale $\sim\Lambda_{SYM}$ (2.8). There are no massless
particles in the spectrum. This is all. It is seen that the mass spectra at
$N_{c}\ll N^{0}_{c}$ or $N_{c}\gg N^{0}_{c}$ (2.1) are qualitatively
different.

Now, about a qualitative difference between the smooth crossover and not
smooth phase transition. The order parameter for quark higgsing can be taken
as the mean vacuum value $\rho=\langle Q\rangle=\langle{\overline{Q}}\rangle$.
As pointed out below (2.5), $\rho=0$ at $N_{c}\gg N^{0}_{c}$ due to freely
fluctuating quark phases from interaction with (effectively) massless gluons.
This shows that quarks become unhiggsed at $N_{c}\gg N^{0}_{c}$. While
$\rho\neq 0$ and large at $N_{c}\ll N^{0}_{c}$ because the corresponding
gluons are heavy. There is the phase transition at $N_{c}\sim N^{0}_{c}$.

The additional arguments for a phase transition between regions $N_{c}\ll
N^{0}_{c}$ and $N_{c}\gg N^{0}_{c}$ (as opposite to a smooth crossover) look
as follows. At $N_{c}\gg N^{0}_{c}$ the RG evolution in (2.4) is valid in the
range $m^{\rm pole}_{Q}<\mu<\Lambda_{Q}$ where all quarks and gluons are
(effectively) massless. And the RG evolution in (2.5) (after quarks decoupled
as heavy) is valid in the range $\Lambda_{SYM}<\mu<m^{\rm pole}_{Q}$ where all
gluons still remain (effectively) massless. At $\mu\sim\Lambda_{SYM}$ the
nonperturbative effects from ${\cal N}=1\,\,SU(N_{c})$ SYM come into a game
and stop the whole RG evolution. For the case of decoupled as heavy non-
higgsed quarks with $\rho=0$ (as described above), the common opinion
(supported by lattice calculations) is that the confinement of quarks
originates from higgsing of magnetically charged solitons in ${\cal
N}=1\,\,SU(N_{c})$ SYM. The scale of their condensate is $\sim\Lambda_{SYM}$.

Let us suppose now that, for a smooth analytical crossover instead of phase
transition, the quarks would remain higgsed at $N_{c}\gg N^{0}_{c}$, with
$\rho=\langle Q\rangle=\langle{\overline{Q}}\rangle\neq 0$ (i.e. ignoring
given above arguments for $\rho=0$). As can be seen from
(2.4),(2.5),(1.2),(1.4), the additional effects from still higgsed quarks at
$\mu\sim\Lambda_{SYM}$, where the RG evolution finally stops, will be then
small numerically in comparison with $\Lambda_{SYM}$ :
$\mu^{2}_{0}=z_{Q}(\Lambda_{Q},m^{\rm
pole}_{Q})\langle{\overline{Q}}\rangle\langle Q\rangle\ll\Lambda_{SYM}^{2}$,
and even $N_{c}\mu^{2}_{\rm
gl}(\mu\sim\Lambda_{SYM})/\Lambda_{SYM}^{2}\sim\Lambda_{SYM}/m^{\rm
pole}_{Q}\ll 1$. I.e., down to $\mu\sim\Lambda_{SYM}$, the effects from
supposedly higgsed quarks remain dynamically irrelevant and all $SU(N_{c})$
gluons remain effectively massless. And so, the RG-evolution will still stop
only at $\mu\sim\Lambda_{SYM}$ due to larger nonperturbative effects
$\sim\Lambda_{SYM}$ in ${\cal N}=1\,\,SU(N_{c})$ SYM.

Then, for heavy but still higgsed quarks, the regime would be self-
contradictory. Independently from nonzero numerical values, there would be
then in the whole ${\cal N}=1\,\,SU(N_{c})$ SYM simultaneously higgsed quarks
and higgsed magnetically charged solitons. But these magnetically charged
solitons and quarks are mutually nonlocal and can’t be higgsed simultaneously.

On the whole, we conclude that the order parameter of quark higgsing,
$\rho=\langle Q\rangle=\langle{\overline{Q}}\rangle$, is nonzero and large at
$N_{c}\ll N^{0}_{c}$ and becomes not simply small but zero at $N_{c}\gg
N^{0}_{c}$. And therefore, there is not a smooth crossover but the phase
transition at $N_{c}\sim N^{0}_{c}$ between the phases with higgsed or
confined quarks.

Another types of phase transitions in considered here theories and in ${\cal
N}=2$ SQCD are described in Appendix and in sections 6.1, 6.2, 7, 8 of [9].

##  Appendix A The phase transition between the regions
$m_{Q}\gg\Lambda_{Q}$ and $m_{Q}\ll\Lambda_{Q}$ at $N_{F}=N_{c}-1,\,\,N_{c}\ll
N^{0}_{c}$

.

I. Heavy quarks with $m_{Q}\gg\Lambda_{Q}$.

Heavy quarks have large masses and small
$\langle{\overline{Q}}Q\rangle\sim\Lambda_{Q}^{2}(\Lambda_{Q}/m_{Q})^{(N_{c}-N_{F}=1)/N_{c}}\ll\Lambda_{Q}^{2}\ll\Lambda_{SYM}^{2}\ll
m^{2}_{Q}$. For this reason they are not higgsed (i.e.
$\rho=\langle{\overline{Q}}\rangle=\langle Q\rangle=0$ due to freely
fluctuating quark phases from interaction with (effectively) massless gluons
at $\mu\sim m_{Q}$) but confined and decouple as heavy at $\mu\sim m_{Q}$. 777
The nonzero gluon masses originate only in SYM due to nonperturbative effects.
Therefore, their scale is $\sim\Lambda_{SYM}\ll m_{Q}$.

The whole local $SU(N_{c})$ and global $SU(N_{F})$ are not broken. There is in
the spectrum a large number of heavy flavored quarkonia with masses ${\cal
O}(m_{Q})\gg\Lambda_{Q}$ and different quantum numbers. For instance, the
quark-antiquark bound states with different spins and other quantum numbers
are in the adjoint or singlet representations of unbroken global $SU(N_{F})$.
It is important that, due to a confinement, there are no particles in the
spectrum in the $SU(N_{F})$ (anti)fundamental representation of dimensionality
$N_{F}$. Besides, there are in the spectrum many $SU(N_{F})$ singlet gluonia
with masses ${\cal
O}(\Lambda_{SYM}),\,\,\Lambda_{SYM}=\Lambda_{Q}(m_{Q}/\Lambda_{Q})^{N_{F}/3N_{c}},\,\Lambda_{Q}\ll\Lambda_{SYM}\ll
m_{Q}$. This is all.

II. Light quarks with $m_{Q}\ll\Lambda_{Q}$.

All light quarks with their $4N_{F}N_{c}$ real degrees of freedom have small
masses $m_{Q}\ll\Lambda_{Q}$ and large condensates
$\langle{\overline{Q}}Q\rangle=\langle{\overline{Q}}\rangle\langle
Q\rangle\sim\Lambda_{Q}^{2}(\Lambda_{Q}/m_{Q})^{1/N_{c}}\gg\Lambda_{Q}^{2}\gg
m^{2}_{Q}$. They are higgsed in this case in the weak coupling region and the
whole color group $SU(N_{c})$ is broken: $\langle
Q^{i}_{a}\rangle=\delta^{i}_{a}\,\omega,\,\,\langle{\overline{Q}}^{a}_{i}\rangle=\delta^{a}_{i}\,\omega,\,\,\omega=\Lambda_{Q}(\Lambda_{Q}/m_{Q})^{1/2N_{c}}\gg\Lambda_{Q}\gg
m_{Q}$. The unbroken global symmetry looks now as: $SU(N_{F})_{F+C}$, i.e. the
color-flavor locking. All $N_{c}^{2}-1=N_{F}^{2}+2N_{F}$ heavy gluons (which
”ate” $N_{F}^{2}+2N_{F}$ massless real degrees of freedom from quarks) and the
same number of their scalar superpartners acquired large masses (1.5). They
form 2 adjoint representations of $SU(N_{F})$ plus two $SU(N_{F})$ singlets.
Plus, and this is most important, else $2N_{F}$ heavy gluons
$(A_{\mu})^{i}_{a=N_{c}},\,(A_{\mu})^{a=N_{c}}_{i},\,i=1...N_{F}$ and $2N_{F}$
their scalar superpartners. These $4N_{f}$ form two fundamental and two
antifundamental representations of $SU(N_{F})$ with dimensionality $N_{F}$
each. And finally, there are $N^{2}_{F}$ light complex pions
$M^{i}_{j},\,i,j=1...N_{F}$ with masses $\sim m_{Q}$ (1.8) which form the
adjoint and singlet representations of $SU(N_{F})$. Therefore, there are only
fixed numbers of particles with fixed quantum numbers in the spectrum.

From comparison of mass spectra properties in regions $m_{q}\gg\Lambda_{Q}$
and $m_{Q}\ll\Lambda_{Q}$ it is seen that, although the unbroken global
symmetry $SU(N_{F})$ is the same, but realized are its different
representations. In the case of heavy confined quarks there are no particles
in the spectrum in the (anti)fundamental representation of $SU(N_{F})$, while
in the case of light higgsed quarks such representations are present. We can,
for instance, to start from the case of heavy quarks with
$m_{Q}\gg\Lambda_{Q}$ and to diminish continuously $m_{Q}$ until
$m_{Q}\ll\Lambda_{Q}$. And when crossing the region $m_{Q}\sim\Lambda_{Q}$,
the behavior under global $SU(N_{F})$ transformations changes discontinuously
(because the dimensions of representations can not change continuously). This
jump is impossible in the case of crossover (which is smooth), this means the
phase transition.

At the same time, for instance, the bilinear mean vacuum value
$\langle{\overline{Q}}Q\rangle$ is a holomorphic function of $m_{Q}$ and
behaves smoothly, but this does not mean that there can not be the phase
transition. The qualitative difference is that
$\langle{\overline{Q}}Q\rangle=\langle{\overline{Q}}\rangle\langle
Q\rangle\neq 0$, i.e. factorizes for light higgsed quarks with
$m_{Q}\ll\Lambda_{Q}$ (i.e. the order parameter
$\rho=\langle{\overline{Q}}\rangle=\langle Q\rangle\neq 0$). While for heavy
non-higgsed but weakly confined quarks with $m_{Q}\gg\Lambda_{SYM}$ (the
string tension originates from unbroken $SU(N_{c})$ and is
$\sigma^{1/2}\sim\Lambda_{SYM}\ll m_{Q}$) this bilinear mean value $\langle
M\rangle$ becomes non-factorizable (it originates then from the one-loop
Konishi anomaly, see (1.4)) and $\rho=\langle{\overline{Q}}\rangle=\langle
Q\rangle=0$, see the text under (2.5).

## References

  * [1] V.L. Chernyak, JETP 110, 383 (2010) (sections 2 and 7 only), arXiv:0712.3167 [hep-th]
  * [2] K. Konishi, Phys. Lett. B135, 439 (1984)
  * [3] V. Novikov, M. Shifman, A. Vainshtein, V. Zakharov, Nucl. Phys. B229, 381 (1983)
M. Shifman, A. Vainshtein, Nucl. Phys. B277, 456 (1986)

  * [4] G. Veneziano, S. Yankielowicz, Phys. Lett. B113, 321 (1982)
  * [5] I. Affleck, M. Dine, N. Seiberg, Nucl.Phys. B241, 493 (1984)
  * [6] N. Seiberg, Nucl. Phys. B435, 129 (1995), hep-th/9411149
  * [7] V.L. Chernyak, JETP 114, 61 (2012), arXiv:0811.4283 [hep-th]
  * [8] V.L. Chernyak, Physics of Atomic Nuclei, 83, 794 (2020), arXiv:2003.10160 [hep-th]
  * [9] V.L. Chernyak, Softly broken ${\cal N}=2$ SQCD: mass spectra in vacua with unbroken
$Z_{2N_{c}-N_{F}}$ symmetry, arXiv:1711.01169 [hep-th]