A Multi-Agent Negotiation Strategy for Reducing the Flowtime

Ellie Beauprez

, Anne-C

ecile Caron

, Maxime Morge

and Jean-Christophe Routier

Univ. Lille, CNRS, Centrale Lille, UMR 9189 CRIStAL, F-59000 Lille, France

Keywords:

Multi-Agent Systems, Distributed Problem Solving, Negotiation, Interaction Protocols.

Abstract:

In this paper, we study the problem of task reallocation for load-balancing in distributed data processing

models that tackle vast amount of data. In this context, we propose a novel strategy based on cooperative

agents used to optimize the rescheduling of tasks for multiple jobs submitted by users in order to be executed

as soon as possible. It allows an agent to determine locally the next task to process and the next task to delegate

according to its knowledge, its own belief base and its peer modelling. The novelty of our strategy lies in the

ability of agents to identify opportunities and bottleneck agents, and afterwards to reallocate some of the

tasks. Our contribution is that, thanks to concurrent bilateral negotiations, tasks are continuously reallocated

according to the local perception and the peer modelling of agents. In order to evaluate the responsiveness of

our approach, we implement a prototype testbed and our experimentation reveals that our strategy reaches a

ﬂowtime which is close to the one reached by the classical heuristic approach and signiﬁcantly reduces the

rescheduling time.

1 INTRODUCTION

Data science involves the processing of large volumes

of data which requires distributed ﬁle system and par-

allel programming. This emerging distributed com-

puting topic brings new challenges related to task al-

location and load-balancing. This paper is concerned

with a class of practical applications where (a) some

jobs, i.e. sets of tasks, are concurrently submitted by

users in order to be executed as soon as possible, and

(b) some of the resources, e.g. data, required to suc-

cessfully execute a task are distributed at different net-

work nodes.

In this class of applications, we consider here

MapReduce (Dean and Ghemawat, 2004) which is the

most prominent distributed data processing model for

tackling vast amount of data on commodity clusters

as with Hadoop (The Apache Software Foundation,

2020) or Spark (Zaharia et al., 2012). MapReduce

jobs are divided into a set of tasks that are distributed

on nodes ; the division labour should capitalize upon

the way resources are distributed in the system. In-

deed, as several resources are necessary to perform a

task, any initial allocation inevitably requires fetching

https://orcid.org/0000-0003-3865-5005

https://orcid.org/0000-0001-6672-5686

https://orcid.org/0000-0003-2139-7150

https://orcid.org/0000-0001-8032-6323

some of these resources from other nodes, thus incur-

ring an extra time cost for task execution.

In order to tackle the problem of load-balancing

and task reallocation in applications such as those that

motivate this work, multi-agent technologies have re-

ceived a lot of attention (Jiang, 2016). Most of

the existing works adopting the market-based ap-

proach (Walsh and Wellman, 1998; Shehory and

Kraus, 1998; An et al., 2010; Turner et al.,

2018) model the load-balancing problem as a non-

cooperative game. By contrast, in line with (Baert

et al., 2019), we assume that agents are cooperative,

viz.: they share the same objective and there is no

shared knowledge, including any knowledge about

the whole task allocation. Beyond (Baert et al., 2019),

we consider here several jobs which are divided into

a set of tasks that can be performed by any multi-task

agent. The agents aim at minimizing the mean ﬂow-

time of several concurrent jobs, i.e. the average com-

pletion time of these jobs. The main difﬁculty lies in

the fact that task reallocation does not only change the

workload of each agent but also their own scheduling.

For this purpose, we propose a negotiation strategy

which is composed of a consumption strategy and a

delegation strategy. While the consumption strategy

allows agents to decide the next tasks to execute, the

delegation strategy decides which deal is suggested

or accepted. The latter is based on peer modelling

Beauprez, E., Caron, A., Morge, M. and Routier, J.

A Multi-Agent Negotiation Strategy for Reducing the Flowtime.

DOI: 10.5220/0010226000580068

In Proceedings of the 13th International Conference on Agents and Artiﬁcial Intelligence (ICAART 2021) - Volume 1, pages 58-68

ISBN: 978-989-758-484-8

and determines the agent behaviour at each point of

choice for the negotiation protocol: (a) the offer strat-

egy selects a potential delegation, i.e. a task and a re-

ceiver; (b) the acceptability rule determines whether

the agent accepts or declines a delegation. Inspired

by our practical application, the experiments on our

testbed evaluate the responsiveness of our approach.

Speciﬁcally, our contributions are as follows:

• We formalize the multi-agent situated task allo-

cation problem with concurrent jobs where tasks

have different costs for different agents due to the

resource locality.

• We design a multi-agent strategy which allows the

agents to continuously identify opportunities and

bottleneck agents within a current unbalanced al-

location. Afterwards, concurrent and bilateral ne-

gotiations amongst agents are triggered to locally

delegate some of the tasks. Tasks reallocations oc-

cur continuoulsy according to the local perception

and the peer modelling of agents.

• We conduct extensive experiments which show

that our method reaches a ﬂowtime which is close

to the one reached by the classical heuristic ap-

proach and signiﬁcantly reduces the rescheduling

time.

The paper is structured as follows. After an overview

of the related work in Sec. 2, we formalize the multi-

agent situated task allocation problem with concur-

rent jobs in Sec. 3. Sec. 4 describes the operations of

consumption/delegation and the negotiation process.

Sec. 5 speciﬁes the consumption strategy, i.e. how

agents choose the scheduling order of their own bun-

dle. Sec. 6 details the delegation strategy, i.e. how

agents choose which task to negotiate with whom.

Our empirical evaluation is described in Sec. 7. Fi-

nally, Sec. 8 summarizes our contribution and outlines

our future work.

2 RELATED WORK

Classical scheduling problems are constrained opti-

mization problems that can be approximated by dif-

ferent heuristics such as hill climbing or simulated

annealing (See (Pinedo, 2008) for a survey). The lim-

itations of these approaches for task reallocation in

distributed systems are due to the following aspects:

• Decentralization: global control causes a perfor-

mance bottleneck as it must collect status infor-

mation of the entire system in real time. By

contrast, agents can take local decisions over an

existing allocation in order to improve the load-

balancing.

• Adaptation: classical scheduling problems are

static. The inaccurate estimation of tasks exe-

cution time and the disruptive phenomena (task

consumption, job release, etc.), may require ma-

jor modiﬁcations in the existing allocation to stay

optimal. Agents can act in dynamic environments

that evolve over time.

These are the reasons why multi-agent scheduling has

received signiﬁcant attention for load-balancing prob-

lems in distributed systems (See (Jiang, 2016) for a re-

cent survey). Banerjee and Hecker propose in (Baner-

jee and Hecker, 2017) a general distributed resource

allocation protocol for load-balancing coarse-grained

jobs on a massively distributed system. They empha-

size that the local interactions between agents lead

to some complex high-level emergent properties. By

contrast, Selvitopi et al. investigate in (Selvitopi et al.,

2019) the simultaneous scheduling of ﬁne-grained

tasks in order to improve the data locality and balance

the workloads. Their approach is based on graph and

hypergraph models which make use of application-

speciﬁc knowledge. Our study aims at bridging this

granularity gap by the reassignment of independent

tasks within multiple jobs in an application-agnostic

way.

Schaerf et al. investigate in (Schaerf et al., 1995)

the adaptive behaviour of agents for efﬁcient load-

balancing using multi-agent reinforcement learning.

Turner et al. combine in (Turner et al., 2018)

supervised classiﬁcation learning with an internal

decision-making process for task assignments. Con-

versely, we do not assume any prior model of the

data/environment since it is not relevant considering

the class of practical applications we are concerned

with.

In (Jiang and Li, 2011), the authors distinguish

two kinds of vicinity: the locality of the resources

which are needed to perform the tasks, and the neigh-

bourhood of the agents. On this latter point, we as-

sume a fully connected social network with uniform

communication costs. In (Zaharia et al., 2010), the

authors are concerned with data locality. In the con-

text of the scheduling problem of MapReduce jobs

composed of multiple tasks, they try to place com-

putations near their input data in order to maximize

the system throughput. In this paper, we abstract

away from the practical applications, but we address a

similar challenging problem by considering task con-

sumption, job release and slowing down nodes as un-

expected events in a dynamic environment.

On one hand, most of the existing works adopting

the market-based approach model the load-balancing

problem as a non-cooperative game. For instance, An

et al. propose in (An et al., 2010) a distributed ne-

A Multi-Agent Negotiation Strategy for Reducing the Flowtime

gotiation mechanism where selﬁsh agents negotiate

over resources both a contract price and a decommit-

ment penalty. On the other hand, most of the solving

algorithms for the distributed constraint optimization

problems (See (Fioretto et al., 2018) for a recent sur-

vey) try to optimize a single-objective function which

is assumed to be utilitarian (a sum of costs to be min-

imized). More recently, (Baert et al., 2019) targets

an egalitarian objective which is the minimization of

the maximum completion time of the tasks to per-

form (i.e. the makespan). In this paper, we consider

the problem of coordinating agent decisions to ﬁnd

a globally optimal solution for multi-objective func-

tions. The agents try to minimize the mean ﬂowtime

of several concurrent jobs, i.e. the mean of the maxi-

mum completion times of the tasks in these jobs.

3 SITUATED TASKS

We formalize here the multi-agent situated task allo-

cation problem with concurrent jobs.

A job is a set of independent, non divisible and

non preemptive tasks without precedence order. The

execution of each task requires resources which are

distributed at different nodes. We consider that the

resources are transferable and non consumable.

Deﬁnition 1 (Distributed system). A system is a triple

D = hN, E,Ri where:

• N = {ν

,. ..,ν

} is a set of m nodes;

• E is an acquaintance relation, i.e. a binary and

symmetric relation over N;

• R = {ρ

,. ..,ρ

} is a set of k resources having a

size (e.g. |ρ

|). The locations of the resources,

which are possibly replicated, are determined by

the function:

l : R → 2

(1)

For simplicity, we assume that there is exactly one

agent per node (the set of agents is N) and all the re-

sources are accessible by any agent.

The execution of a job (without deadline) con-

sists of the performance of a set of independent tasks

which require resources to produce an outcome.

Deﬁnition 2 (Job/Task). Let D be a distributed sys-

tem and Outcome be the space of outcomes. We con-

sider the set of ` jobs J = {J

,. ..,J

}. Each job

is a set of k

tasks J

= {τ

,. ..,τ

} associated

to the release date t

where each task τ is a func-

tion which links a set of resources to an outcome:

τ : 2

7→ Outcome.

T =

1≤i≤`

denotes the set of the n tasks of J

and R

⊆ R is the set of the resources required for the

task τ. For the sake of brevity, we denote job(τ) the

job containing the task τ. We assume that the num-

ber of jobs is negligible with respect to the number of

tasks, |J| << |T|.

The task cost estimates its runtime on a node.

Deﬁnition 3 (Task cost). Let D be a distributed sys-

tem and T be a set of tasks. the cost function is s.t.:

c : T × N 7→ R

∗

(2)

The cost of the task τ

for the node ν

is a strict posi-

tive real number denoted c(τ

,ν

The difﬁculty lies in the speciﬁcation of this func-

tion in order to have a good estimation of the runtime.

As the fetching time of resources is supposed to be

signiﬁcant, the cost function must verify that the task

τ is cheaper for ν

than for ν

(c(τ, ν

) ≤ c(τ,ν

)) if

the required resources are ”more local” to ν

than to

. We postpone the full speciﬁcation of the task cost

function to the experimental setup (Sec. 7).

A multi-agent situated task allocation problem

with concurrent jobs consists of assigning several jobs

to some nodes according to the underlying task costs.

Deﬁnition 4 (MASTA+). A multi-agent situated

task allocation problem is a quadruple MASTA+ =

hD,T,J,ci where:

• D = hN,E,Ri is a distributed system with m

nodes;

• T = {τ

,. .. ,τ

} is a set of n tasks;

• J = {J

,. .. ,J

} is a set of ` jobs, i.e. a partition

of tasks s.t.

(T =

[

1≤i≤`

) ∧ (J

∩ J

0 with 1 ≤ i 6= j ≤ `)

(3)

• c : T × N 7→ R

∗

is the task cost function.

A task allocation is a distribution of sorted bundles at

different nodes.

Deﬁnition 5 (Allocation). Let MASTA+ be a task

allocation problem. An allocation is a vector of

m sorted task bundles.

A = ((B

,≺

),. .. ,(B

,≺

))

where each bundle (B

,≺

) is the set of tasks (B

⊆ T)

assigned to the node ν

associated with a scheduling

order, i.e. a strict and total order (≺

⊆ T × T) s.t.

≺

means that if τ

,τ

∈ B

then τ

is performed

before τ

by ν

. The allocation

A is s.t.:

∀τ ∈ T, ∃ν

∈ N, τ ∈ B

(4)

∀ν

∈ N, ∀ν

∈ N \ {ν

}, B

∩ B

0 (5)

All the tasks are assigned (Eq. 4) and each task is as-

signed to a single node (Eq. 5). For brevity, we de-

note:

•

= (B

,≺

), the sorted bundle of ν

;

ICAART 2021 - 13th International Conference on Agents and Artiﬁcial Intelligence

• min

≺

, the next task to perform by ν

• jobs(B

), the set of jobs assigned to ν

, i.e. the

jobs having at least one task in B

;

• ν(τ,

A), the node responsible for τ in

The sum of the task costs in a bundle estimates its

runtime. Formally, The workload of ν

for

A is:

(

A) =

∑

τ∈B

c(τ

) (6)

In order to evaluate a task allocation, we consider the

ﬂowtime, which measures the time between the re-

lease date of the jobs and their completion dates, and

the makespan which is the completion time of all the

jobs.

Deﬁnition 6 (Flowtime/Makespan). Let MASTA+ be

a task allocation problem and

A be an allocation. We

deﬁne:

• the delay of τ for ν

t(τ, ν

) =

∑

∈B

|τ

≺

c(τ

,ν

) (7)

• the completion time of τ ∈ T for

(

A) = t(τ,ν(τ,

A)) + c(τ, ν(τ,

A)) (8)

• the completion time of J ∈ J for

(

A) = max

τ∈J

(

A)} (9)

• the completion date of J ∈ J for

(

A) = t

+ C

(

A) (10)

• the mean ﬂowtime of J for

A) =

∑

J∈J

(

A) (11)

• the makespan of J for

max

(

A) = max

J∈J

(

A) (12)

• the local availability ratio of

A) =

∑

τ∈T

∑

ρ∈R

, ν(τ,

A)∈l(ρ)

|ρ|

∑

ρ∈R

|ρ|

(13)

The delay of a task for a node estimates the

runtimes (costs) of the previous tasks in the bundle

(Eq. 7) since we assume the nodes are never inactive.

The completion time of a task is the sum of the de-

lay before the task is started plus its runtime (Eq. 8).

Contrary to the cost of the task, its delay and its com-

pletion time depend on the scheduling order over the

bundle. According to Eq. 9, a job is ﬁnished for all

the agents when they have performed all the tasks in

this job. The completion date of a job is the ﬁnishing

date (Eq. 10). The mean ﬂowtime is the mean com-

pletion time of the jobs (Eq. 11). Since the makespan

measures the maximum completion time of the jobs

(Eq. 12), it is the maximum workload of the nodes:

max

(

A) = max

∈N

(

A)} (14)

Contrary to the makespan, the ﬂowtime depends on

the scheduling order. The local availability ratio mea-

sures the proportion of locally processed resources

(Eq. 13).

Example 1 (MASTA+). We consider D = hN, E,Ri

where:

• 3 nodes N = {ν

,ν

} are fully connected E =

{(ν

,ν

),(ν

,ν

),(ν

,ν

)};

• 9 resources R = {ρ

,ρ

}

are replicated over 2 nodes (Fig. 1a). For in-

stance, ρ

, with |ρ

| = 6, is over ν

and ν

but

not over ν

We also consider MASTA+ = hD, T, J,ci with:

• 9 tasks T = {τ

,τ

}. Each

one requires the corresponding resource, e.g. ρ

is required for τ

;

• 3 jobs J = {J

}, s.t. J

= {τ

,τ

}, J

{τ

,τ

} and J

= {τ

,τ

• the cost function which is represented in Tab. 1.

We assume that the cost of a task is proportional

to the resource size and two times more important

if the resource is remote.

The allocation represented in Fig. 1b is s.t.

(τ

,τ

= (τ

,τ

) and

= (τ

,τ

). The

makespan and the mean ﬂowtime are C

max

(

A) = 10

and C(

A) = 8.33, respectively.

In summary, we consider heterogeneous nodes be-

cause the cost of tasks depend on the processing nodes

due to the locality of the underlying resources. Our

objective is to minimize the mean ﬂowtime of the con-

current jobs containing several tasks:

|Σ

J∈J

max

τ∈J

(

4 CONSUMPTION AND

DELEGATION PROCESS

We describe here the operations of consump-

tion/delegation and we sketch the negotiation proto-

col.

The addition/removal of the task τ in the bundle

modiﬁes not only the set of tasks but also the schedul-

ing order over the bundle. Formally,

A Multi-Agent Negotiation Strategy for Reducing the Flowtime

0.0

0.5

1.0

1.5

2.0

2.5

3.0

3.5

4.0

4.5

5.0

5.5

6.0

Resource size

Jobs

Nodes

(a) Resource distribution

ν1 ν2 ν3

Nodes

Workload

Jobs

(b) Allocation

Figure 1: The resource distribution and the allocation sorted by the LCJF strategy.

Table 1: The cost of the tasks for the nodes

c(τ, ν

) 3 5 0.5 3 2 6 4 2 1

c(τ, ν

) 3 5 0.5 3 1 12 4 1 2

c(τ, ν

) 6 10 1 6 1 6 8 1 1

• if τ /∈ B

then

−−−→

⊕ τ denotes the bundle which

contains the set of tasks B

∪ {τ} sorted with ≺

;

• if τ ∈ B

then

−−−→

 τ denotes the bundle which

contains B

\ {τ} sorted with ≺

These operations imply a rescheduling of the bundle.

As we will see in Sec. 5, the consumption strategy

specify the scheduling order.

A task consumption is a disruptive event which

modiﬁes not only the allocation of tasks but also the

underlying problem.

Deﬁnition 7 (Consumption). Let MASTA+ =

hD,T,J,ci be a task allocation problem and

A be

an allocation. The consumption of τ by ν

with a

non-empty bundle (B

0) leads to the allocation

= γ(ν

A) for the problem MASTA

= hD,T

,ci

where:

= T \ {min

≺

} (15)











J \ {job(min

≺

)}

if job(min

≺

) = {min

≺

}

J else

(16)

In the latter case:

(

\ {min

≺

} if job(min

≺

) = J

else

(17)

and

(

−−−−−−−−→

 min

≺

if j = i

else

(18)

The task is removed from the set of tasks (Eq. 15)

and from the corresponding job (Eq. 17). The

latter is removed if it only contains τ (Eq. 16).

The task is removed from the allocation (Eq. 18).

Obviously, a task consumption can increase nei-

ther the makespan nor the ﬂowtime but it de-

creases the local makespan (w

(γ(ν

A)) < w

(

A))

and the local ﬂowtime (Σ

J∈jobs(B

)

(γ(ν

)) <

J∈jobs(B

)

(

)). The sequence of consumptions,

which consists of an iteration of MASTA+ problems,

removes one by one all the tasks from the initial allo-

cation to the empty one.

A task delegation is a disruptive event which

changes the current allocation, i.e. a reallocation.

Deﬁnition 8 (Delegation). Let MASTA+ =

hD,T,J,ci be a task allocation problem and

A = (

,. .. ,

) be an allocation. If the task τ is as-

signed to the donor ν

(τ ∈ B

), then the delegation to

the recipient ν

leads to the allocation δ(τ,ν

,ν

with the m bundles δ(τ,ν

,ν

) such as:

δ(τ, ν

,ν

) =











−−−→

 τ if k = i

−−−→

⊕ τ if k = j

else

(19)

A task delegation must reduce the local makespan and

the local ﬂowtime.

Deﬁnition 9 (Socially rational delegation). Let

MASTA+ = hD, T, J,ci be a task allocation problem,

A be an allocation and δ(τ,ν

,ν

A) the allocation af-

ter the delegation of τ by ν

to ν

. This delegation is

socially rational:

ICAART 2021 - 13th International Conference on Agents and Artiﬁcial Intelligence

• with respect to the makespan if and only if the lo-

cal makespan decreases

(

A) + c(τ, ν

) < w

(

A) (20)

• with respect to the ﬂowtime if and only if the local

ﬂowtime decreases

J∈jobs(B

∪B

)

max(C

(

−−−→

 τ),C

(

−−−→

⊕ τ)) <

J∈jobs(B

∪B

)

max(C

(

),C

(

))

(21)

An allocation is stable if none of the agents have so-

cially rational delegations. In a stable allocation with

respect to the makespan, agents cannot locally im-

prove the makespan.

Property 1 (Termination). Let MASTA+ =

hD,T,J,ci be a task allocation problem and

be a non-stable allocation with respect to the

makespan. There is always a ﬁnite path of socially

rational delegations with respect to this criterion,

which leads to a stable allocation with respect to

makespan.

The property derives from Theo. 7 in (Endriss et al.,

2006). By contrast, a sequence of socially rational

delegations with respect to the ﬂowtime does not nec-

essarily lead to a stable allocation for this criterion.

Agents operate in multiple bilateral single-round

negotiations for task delegations. Each negotiation,

which is based on the alternating offers protocol (Ru-

binstein, 1982), includes three decision steps: (a) the

offer strategy of the proposer (Sec. 6) which selects

a potential delegation, i.e. a task in its bundle and

a recipient, (b) the acceptability rule (Sec. 6) allows

the responder to determine whether it rejects or ac-

cepts such a delegation, and (c) in the latter case, the

delegation is conﬁrmed or withdrawn by the proposer

depending on the interleaved consumptions.

5 CONSUMPTION STRATEGY

We describe here the consumption strategy adopted

by an agent to select the next task to perform, i.e.

a scheduling order over its bundle based on its local

knowledge.

We consider a task allocation problem

MASTA+ = hD,T,J,ci and an allocation

Each agent ν

∈ N which knows the problem and has

a local perception of the allocation, i.e. its bundle

can deduce the following metrics:

• its workload (Eq. 6);

• the delay of the tasks in its bundle (Eq. 7);

• the completion time of these tasks (Eq. 8);

• the completion time of the jobs for the node,

(

) =

(

max

τ∈J∩B

(

)} if J ∈ jobs(B

)

0 else

(22)

• the job costs for the node,

c(J

) = Σ

τ∈J∩B

c(τ

) (23)

It is worth noticing that the mean completion time of

the jobs for an agent depends on the scheduling order

over its bundle.

A consumption strategy is deﬁned by a schedul-

ing order, i.e. a strict total order over the bundle.

Since we aim at minimizing the completion time of

jobs rather than tasks we focus on job-oriented con-

sumption strategies. Such a strategy is a lexicographic

order which consists of sorting ﬁrst jobs, and then the

tasks inside the same job.

Deﬁnition 10 (Job-oriented strategy). Let

and

two strict total order relations over T and J, respec-

tively. A job sorting strategy based on (

) sorts

the bundle B

according to the strict total order rela-

tion ≺

deﬁned by:

∀τ

,τ

∈ B

≺

⇔

job(τ

)

job(τ

) ∨ (job(τ

) = job(τ

) ∧ τ

j i

)

(24)

1 i

means that the tasks in J

are prior to the

tasks in J

. The tasks in the same job are consecutive

in the bundle.

The job-oriented consumption strategy we con-

sider in this paper aims at minimizing the completion

times of jobs by sorting them according to their costs.

Deﬁnition 11 (LCJF). Let

a strict total order on

T. A job sorting strategy based on (

) is said

”Locally Cheapest Job First” (LCJF) if and only if

the relation

over the jobs satisﬁes :

∀J

∈ J, J

j i

⇔

c(J

,ν

) < c(J

,ν

) ∨ (c(J

,ν

) = c(J

,ν

) ∧ J

< J

)

(25)

where < denotes the order over the jobs induced by

the natural order over their identiﬁers.

This strategy executes the tasks in the cheapest

jobs before the tasks in the expensive ones.

The relation over the jobs

is based on the

knowledge of the agent about the MASTA+ problem

and its own bundle. This scheduling order is strict and

total since < discriminates the ties. Since we assume

a strict total order over the tasks

(e.g. arbitrary the

A Multi-Agent Negotiation Strategy for Reducing the Flowtime

natural order over the task identiﬁers), ≺

is also strict

and total.

A LCJF strategy allows ν

to locally minimize the

completion time of jobs. None permutation of jobs in

the bundle can strictly decrease the local ﬂowtime.

Lemma 1 (LCJF). Let ≺

be a LCJF strategy based

on (

∀σ ∈ S(jobs(B

)),

J∈jobs(B

)

(

) ≤ Σ

J∈jobs(B

)

(σ(

))

(26)

where S(jobs(B

)) denotes the set of all the permuta-

tions of the jobs assigned to ν

The lemma derives from Theo. 3.1.1 in Chap. 3

of (Pinedo, 2008).

Example 2 (LCJF). Let us consider Ex. 1. If the

bundles are B

= {τ

,τ

}, B

= {τ

,τ

} and,

= {τ

,τ

}, the allocation sorted with the LCJF

strategy (Fig. 1b) is s.t.:

•

= (τ

,τ

) since (c(J

,ν

) = c(τ

,ν

)) <

(c(J

,ν

) = c(τ

,ν

)) < (c(J

,ν

) = c(τ

,ν

));

•

= (τ

,τ

) since (c(J

,ν

) = c(τ

,ν

)) =

(c(J

,ν

) = c(τ

,ν

)) < (c(J

,ν

) = c(τ

,ν

))

and J

< J

;

•

= (τ

,τ

) since (c(J

,ν

) = c(τ

,ν

)) =

(c(J

,ν

) = c(τ

,ν

)) < (c(J

,ν

) = c(τ

,ν

))

and J

< J

6 DELEGATION STRATEGY

We describe here the different parts of the delega-

tion strategy (peer modelling, acceptability rule, offer

strategy) and we sketch the agent behaviour.

The peer modelling is built upon the information

exchanged by the agents through messages. In par-

ticular, the agent ν

informs its peers about the job

costs for it (c(J

), ∀J ∈ J) before the negotiation

process and after each delegation in which it is in-

volved. Since the number of jobs is much smaller

than the number of tasks, the size of theses messages

(O(|J|)) is negligible wrt the task bundle descriptions

(O(|T|)). The peer modelling of the target ν

by the

subject ν

is based on:

• the belief base of the subject, eventually partial or

obsolete, which contains the belief about the job

costs for ν

(J, ν

) ∀J ∈ J) and the belief about

the workload of ν

(

A) = Σ

J∈J

(J, ν

));

• the consumption strategy of the target assumed by

the subject which boils down to the relation over

the jobs adopted by the target, denoted

For readability, we denote c

(J, ν

) = c(J, ν

) and

(

A) = w

(

A). From its beliefs about the target and

the assumed consumption strategy, the subject can de-

duce the completion time of the job J for the target,

eventually after the addition/removal of τ : C

(

−−−→

⊕ τ) and C

(

−−−→

 τ). Then, the subject can de-

duce the completion time of a job for the allocation:

(

A) = max

∈N

(

) where C

(

) = C

(

) (27)

The subject considers the target as a bottleneck for the

job J (ν

= nodeMax

(

A,J)) if the completion time of

this job for the target is the completion time for the

allocation, i.e. C

(

A) = C

(

The acceptability rule is a local decision by the

recipient of a delegation, which is based on its knowl-

edge and its peer modelling, to determine whether a

delegation is accepted or declined depending on its

perception of the social rationality of the delegation.

Deﬁnition 12 (Acceptability criterion). Let

δ(τ, ν

,ν

A) be the delegation of τ from ν

A. This delegation is acceptable by the recipient

• with respect to the makespan if and only if the re-

cipient believes that the delegation decreases the

local makespan,

(

A) + c(τ, ν

) < w

(

A) (28)

• with respect to the ﬂowtime if and only if the re-

cipient believes that the delegation decreases the

local ﬂowtime,

J∈J

max(C

(

−−−→

 τ),C

(

−−−→

⊕ τ)) <

J∈J

max(C

(

),C

(

))

(29)

While the ﬁrst criterion is built upon the belief

about the workload of the donor (Eq. 28), the second

one is built upon the knowledge about the comple-

tion times of the jobs for the recipient before/after the

delegation and its belief about the completion times

of the jobs for the donor before/after the delegation

(Eq. 29).

In order to reduce the ﬂowtime, the acceptability

rule consists in checking not only the acceptability

criterion wrt the ﬂowtime but also the acceptability

criterion wrt the makespan which guarantees the con-

vergence of the negotiation process (Prop. 1).

The offer Strategy of a possible donor ν

, which

is based on its knowledge and its peer modelling, se-

lects a potential delegation: a recipient, a task and so

a job. The strategy is divided in 4 steps:

1. Job Selection. According to the principle of sub-

sidiarity, the goal of the donor is to reduce the

ICAART 2021 - 13th International Conference on Agents and Artiﬁcial Intelligence

completion time of the jobs it is responsible for.

In order to reduce not only the completion time

of one job for the donor but also the completion

time of the next jobs in

, our heuristic selects

the prior job for which the donor is a bottleneck,

∀J

⊆ J, J

∗

= σ

) =

min

{J ∈ jobs(B

) ∩ J

| ν

= nodeMax

(

A,J)}

(30)

2. Recipient Selection. The jobs assigned to the re-

cipient which are impacted by the delegation are

those after J

∗

according to

. Not to increase

the completion times of these jobs, our heuristic

selects the recipient for whom the sum of the dif-

ferences between the completion time for the al-

location and the completion time for this agent is

the greatest one,

∀N

⊆ N, ν

∗

= σ

∗

) =

min

{argmax

∈N

∑

∗

(

A) − C

(

))}

(31)

where < denotes the order over the nodes induced

by the natural order over their identiﬁers.

3. Task Selection. In order to reduce the completion

times, the donor selects a distant task whose dele-

gation reduces its cost since it is locally executed.

For this purpose, our heuristic selects the task in

the job J

∗

or in the prior jobs in

with the highest

payoff. In case of tie, the prior task is chosen,

∀T

⊆ T, τ

∗

= σ

,ν

∗

) =

min

{ argmax

τ∈T

∩B

∩{J|J=J

∗

∨(J

∗

)}

c(τ, ν

) − c(τ, ν

∗

)}

(32)

4. Validation. By symmetry with the acceptability

criterion (Def. 12), the trigger criterion is a lo-

cal decision by the donor to determine whether

a delegation is perceived as socially rational. In

order to warranty the convergence of the negoti-

ation process, the trigger rule is a conjunction of

the trigger criterion wrt the makespan and the trig-

ger criterion wrt the ﬂowtime. If the trigger rule

is not satisﬁed, then another task (T

= T

\ {τ

∗

}

in step 3) or another recipient (N

= N

\ {ν

∗

} in

step 2), eventually another job (J

= J

\ {J

∗

} in

step 1) is chosen. In case of failure, no delegation

is proposed and the agent enters in pause until its

belief base is updated and a new opportunity (i.e.

a potential delegation) is found.

In our approach, the task reallocation is the outcome

of negotiations between agents adopting the same be-

haviour: they alternatively play the roles of proposer,

responder and contractor. The agents execute this be-

haviour according to their knowledge and beliefs. The

agent behavior is speciﬁed in (Beauprez and Morge,

2020) by a deterministic ﬁnite state automaton

. In

order to avoid deadlock, the proposals are associated

with deadlines.

It is worth noticing the reception of the message

from the peers updates the belief base of the agent

and none proposal is sent when the agents believes

that the allocation is stable.

Example 3 (Delegation strategy). Let us consider the

MASTA+ instance and the allocation

A of Ex. 1. We

assume that the agents have up-to-date beliefs and

that they know that all of them adopt the LCJF strat-

egy. Contrary to ν

and ν

, the agent ν

can make a

proposal since it selects:

1. the job for which it is a limiting factor (Eq. 30),

∗

= J

;

2. the less bottleneck agent for the impacted jobs

(Eq. 31) which are the jobs J

for ν

and the jobs

and J

for ν

∑

∗

(

A) − C

(

)) = 0 (33)

∑

∗

(

A) − C

(

)) = 8 (34)

Therefore, ν

∗

= ν

;

3. the prior task with the highest payoff (Eq. 32) in

or in the prior jobs, i.e. J

and J

(c(τ

,ν

) − c(τ

,ν

)) = 6 − 12 = −6

(c(τ

,ν

) − c(τ

,ν

)) = 1 − 2 = −1

(c(τ

,ν

) − c(τ

,ν

)) = 1 − 0.5 = 0.5

(35)

Therefore, τ

∗

= τ

;

4. the delegation is triggerable since the trigger cri-

terion wrt the ﬂowtime is satisﬁed,

J∈J

max(C

(

−−−−→

 τ

),C

(

−−−−→

⊕ τ

)) = 16.5 <

J∈J

max(C

),C

)) = 17.0

(36)

and the trigger criterion wrt the makespan is sat-

isﬁed,

(

A) + c(τ, ν

) = 7.5 < w

(

A) = 8.0 (37)

The donor ν

delegates the task τ

to the agent ν

reach

= δ(τ

,ν

A) s.t.

= {τ

,τ

{τ

,τ

} and

= {τ

,τ

}. The allocation is

stable.

https://gitlab.univ-lille.fr/maxime.morge/smastaplus/-/

tree/master/doc/speciﬁcation

A Multi-Agent Negotiation Strategy for Reducing the Flowtime

7 EMPIRICAL EVALUATION

We consider as a practical application the distributed

deployment of the MapReduce design pattern in or-

der to process large datasets on a cluster, as with

Hadoop (The Apache Software Foundation, 2020) or

Spark (Zaharia et al., 2012). We focus here on the

reduce stage of MapReduce jobs. This can be formal-

ized by a MASTA+ problem where several jobs are

concurrently submitted and the cost function is s.t.:

(τ, ν

) =

∑

∈R

(ρ

,ν

)

with c

(ρ

,ν

) =

(

|ρ

| if ν

∈ l(ρ

)

κ × |ρ

| else

(38)

where we empirically calibrate κ = 2 as a realistic

value.

To our best knowledge, no alive project of agent

platforms provides a logic-based agent programming

language, allowing a direct implementation of con-

cepts such as beliefs and goals, that supports the de-

velopment of cognitive agents for large-scale, dis-

tributed applications and services. That is the rea-

son why our testbed (Beauprez and Morge, 2020)

is implemented with the general purpose program-

ming language Scala and Akka (Lightbend, 2020) for

highly concurrent, distributed, and resilient message-

driven applications. We assume that: (a) the mes-

sage transmission delay is arbitrary but not negligi-

ble, (b) the message order per sender-receiver pair is

preserved, and (c) the delivery of messages is guar-

anteed. Experiments have been conducted on a blade

with 20 CPUs and 512Go RAM.

We consider three metrics: (1) the mean ﬂowtime

(Eq. 11), (2) the local availability ratio (Eq. 13), and

(3) the scheduling time. We aim at (i) comparing the

allocation reached by our negociation process with

the classical approach, and (ii) evaluating the accel-

eration thanks to the decentralization.

The outcome reached by the general-purpose

solver IBM® ILOG® CPLEX® tackling the under-

lying non-linear discrete mathematical optimization

problem is poor. This is the reason why our base-

line is a hill climbing algorithm. The latter and our

method both start with the same randomly generated

initial allocation sorted according to the LCJF strat-

egy. At each step, the hill climbing algorithm itera-

tively selects among all the possible delegations, the

one which minimizes the ﬂowtime after the applica-

tion of the LCJF strategy.

The MASTA+ problem instances we consider are

such that m ∈ [2; 12] nodes/agents, ` ∈ [2;5] jobs and

n = 3 × ` × m tasks. We consider one resource per

task. Each resource ρ

is replicated 3 times and

|ρ

| ∈ [0; 100]. We generate 10 MASTA+ problem in-

stances, and for each we randomly generate 10 initial

allocations.

The hypothesis we want to test are: (1) the ﬂow-

time reached from our strategy is close to the one

reached by the classical approach and (2) the decen-

tralization signiﬁcantly reduces the scheduling time.

Figures 2a and 2b present the medians of the ﬂow-

time and the scheduling time exhibited by the meth-

ods depending on the number of nodes and the num-

ber of jobs. Figures 2c, 2d and 3 focus on the medians

and the standard deviations of all the metrics depend-

ing on the number of nodes with ` = 4 jobs. It is worth

noticing that the hill climbing algorithm has been

used with small MASTA+ instances due to its pro-

hibitive scheduling time. At each step, the hill climb-

ing algorithm considers all the possible delegations,

thus it reaches an allocation with a better ﬂowtime

than our strategy. Since the overhead of our strategy

is 25%, our delegation strategy seems to be efﬁcient

even if the acceptability criterion wrt the makespan,

which is required to guarantee the convergence, may

lead to discard some delegations which may reduce

the ﬂowtime (Sec. 4). This is due to the fact that

the delegation strategy selects the distant tasks whose

delegations reduce their cost in order to improve lo-

cal availability ratio which is slightly better than the

one reached by the hill climbing algorithm. More-

over, since the latter evaluates at each step all the pos-

sible delegations, its scheduling time is much higher

than the one of our negociation strategy. For instance,

it is six times higher for 9 agents and 4 jobs.

It is worth noticing that the gap between the

scheduling times of the two methods increases expo-

nentially with the number of agents, while the gap

between the ﬂowtimes is roughly constant. We can

expect a higher scheduling time if we adopt a local

search method such as the simulated annealing with-

out any warranty about the optimality of the outcome.

As a result, even if the number of agents is small,

the gain realized on the ﬂowtime by the hill climb-

ing algorithm will be penalized and cancelled by the

overhead of its scheduling time. This overhead pe-

nalized the time-extented assignment in a distributed

system which should be adaptive to disruptive phe-

nomena (task consumption, job release, slowing down

nodes).

Finally, we observe that, when it is decentralized

on several cores, the acceleration of our algorithm in-

creases with the number of agents and jobs. For in-

stance, with a similar ﬂowtime neglecting the observ-

able nondeterminism of their executions, the decen-

tralized version runs 3 times faster than the central-

ized one for 12 agents and 4 jobs.

ICAART 2021 - 13th International Conference on Agents and Artiﬁcial Intelligence

Centralized

Decentralized

Hillclimbing

Numberofnodes

2.5

3.5

4.5

Numberofjobs

200

300

400

500

600

700

800

900

1000

Meanowtime

(a) Flowtime

Centralized

Decentralized

Hillclimbing

Numberofnodes

2.5

3.5

4.5

Numberofjobs

100

200

300

400

500

600

700

Schedulingtime(s)

(b) Scheduling time

300

400

500

600

700

800

900

1000

1100

3 4 5 6 7 8 9 10 11 12

Meanowtime

Numberofnodes

Centralized

Decentralized

HillClimbing

100

200

300

400

500

600

700

800

900

3 4 5 6 7 8 9 10 11 12

Schedulingtime(s)

Numberofnodes

Centralized

Decentralized

HillClimbing

(d) Scheduling time

Figure 2: The mean ﬂowtime and the scheduling time for our (centralized and decentralized) negociation strategy and the hill

climbing algorithm.

100

3 4 5 6 7 8 9

Localavailabilityratio(%)

Numberofnodes

Initial

Centralized

Decentralized

HillClimbing

Figure 3: The local availability ratio for our (centralized and

decentralized) negociation strategy, the hill climbing algo-

rithm and the initial allocation.

8 CONCLUSION

In this paper, we have proposed a multi-agent system

for task reallocation among distributed nodes based

on the location of the required resources in order to

minimize the mean ﬂowtime of concurrent jobs. Our

prototype has been empirically evaluated. Our experi-

ments show that the ﬂowtime reached by our strategy

is close to the one reached by the classical heuristic

approach and it signiﬁcantly reduces the rescheduling

time. This is due to the fact that our negotiation pro-

cess continuously adapts the allocation in order to im-

prove the load-balancing by reducing the completion

times of the jobs for the bottleneck agents. On one

hand, the consumption strategy performs the tasks of

the cheapest jobs before the most expensive ones. On

the other hand, the delegation strategy selects a job

which can reduce the completion times of the donor

by choosing a receiver which is not a bottleneck for

the impacted jobs and by choosing a task whose del-

egation reduces its cost since it is locally executed. A

sensitivity analysis to study the inﬂuence of the repli-

cation factor has been beyond the scope of this work,

but it is certainly worth of further investigation. Obvi-

ously, our approach is scalable since it tackles a large

number of tasks due to the local decisions of agents

about the next task to delegate/execute. Moreover, the

overhead of the negotiation is negligible with respect

to the beneﬁt of the load-balancing since no negotia-

tion is triggered when the agents believe that the allo-

cation is stable.

A comparative study of our strategy with different

distributed resolution methods algorithms is beyond

the scope of this paper, but it is certainly worth of fur-

ther investigation. Some of our experiments suggest

that we need to extend our negotiation framework to

consider (a) task swaps to improve the mean ﬂow-

time of stable allocations, and (b) a less restrictive

A Multi-Agent Negotiation Strategy for Reducing the Flowtime

acceptability rule which currently discards some task

delegations which may reduce the ﬂowtime. Gener-

ally, future work must extend the task reallocation

toward an iterated, dynamic and on-going process,

which takes place concurrently with the task execu-

tion, allowing the distributed system to be adaptive to

disruptive phenomena (task consumption, job release,

slowing down nodes).

ACKNOWLEDGMENTS

We thank the anonymous reviewers for their stimulat-

ing comments which help us to improve the paper.

REFERENCES

An, B., Lesser, V., Irwin, D., and Zink, M. (2010). Au-

tomated negotiation with decommitment for dynamic

resource allocation in cloud computing. In Proc. of

9th International Conference on Autonomous Agents

and Multiagent Systems (AAMAS), pages 981–988.

Baert, Q., Caron, A.-C., Morge, M., Routier, J.-C., and

Stathis, K. (2019). A Location-Aware Strategy for

Agents Negotiating Load-balancing. In Proc. of 2019

IEEE 31st International Conference on Tools with Ar-

tiﬁcial Intelligence (ICTAI), Portland, Oregon, United

States.

Banerjee, S. and Hecker, J. P. (2017). A Multi-agent

System Approach to Load-Balancing and Resource

Allocation for Distributed Computing. In Proc. of

the 1st Complex Systems Digital Campus World E-

Conference 2015, pages 41–54. Springer International

Publishing.

Beauprez, E. and Morge, M. (2020). Scala implemen-

tation of the Extended Multi-agents Situated Task

Allocation. https://gitlab.univ-lille.fr/maxime.morge/

smastaplus.

Dean, J. and Ghemawat, S. (2004). MapReduce: Simpli-

ﬁed Data Processing on Large Clusters. In Proc. of

the 9th Symposium on Operating Systems Design and

Implementation, pages 137–150.

Endriss, U., Maudet, N., Sadri, F., and Toni, F. (2006). Ne-

gotiating Socially Optimal Allocations of Resources.

Journal of Artiﬁcial Intelligence Research, 25:315 –

348.

Fioretto, F., Pontelli, E., and Yeoh, W. (2018). Distributed

constraint optimization problems and applications: A

survey. Journal of Artiﬁcial Intelligence Research,

61:623–698.

Jiang, Y. (2016). A survey of task allocation and load bal-

ancing in distributed systems. IEEE Transactions on

Parallel and Distributed Systems, 27(2):585–599.

Jiang, Y. and Li, Z. (2011). Locality-sensitive task alloca-

tion and load balancing in networked multiagent sys-

tems: Talent versus centrality. Journal of Parallel and

Distributed Computing, 71(6):822–836.

Lightbend (2020). Akka is the implementation of the actor

model on the JVM. http://akka.io.

Pinedo, M. L. (2008). Scheduling. Theory, Algorithms, and

Systems. Third Edition. Springer.

Rubinstein, A. (1982). Perfect equilibrium in a bargaining

model. Econometrica, 50(1):97–102.

Schaerf, A., Shoham, Y., and Tennenholtz, M. (1995).

Adaptive load balancing: A study in multi-agent

learning. Journal of Artiﬁcial Intelligence Research,

2:475–500.

Selvitopi, O., Demirci, G. V., Turk, A., and Aykanat, C.

(2019). Locality-aware and load-balanced static task

scheduling for MapReduce. Future Generation Com-

puter Systems, 90:49–61.

Shehory, O. and Kraus, S. (1998). Methods for task allo-

cation via agent coalition formation. Artiﬁcial Intelli-

gence, 101(1-2):165–200.

The Apache Software Foundation (2020). Apache Hadoop.

https://hadoop.apache.org.

Turner, J., Meng, Q., Schaefer, G., and Soltoggio, A.

(2018). Distributed Strategy Adaptation with a Pre-

diction Function in Multi-Agent Task Allocation.

In Proc. of 17th International Conference on Au-

tonomous Agents and Multiagent Systems (AAMAS),

pages 739–747.

Walsh, W. E. and Wellman, M. P. (1998). A market proto-

col for decentralized task allocation. In Proc. of the

3rd International Conference on Multiagent Systems

(ICMAS), pages 325–332.

Zaharia, M., Borthakur, D., Sarma, J., Elmeleegy, K.,

Shenker, S., and Stoica, I. (2010). Delay scheduling:

A simple technique for achieving locality and fairness

in cluster scheduling. In Proc. of the EuroSys 2010

Conference, pages 265–278.

Zaharia, M., Chowdhury, M., Das, T., Dave, A., Ma, J., Mc-

Cauly, M., Franklin, M. J., Shenker, S., and Stoica, I.

(2012). Resilient distributed datasets: A fault-tolerant

abstraction for in-memory cluster computing. In Proc.

of the 9th USENIX Symposium on Networked Systems

Design and Implementation (NSDI); San Jose, CA,

USA, pages 15–28.

ICAART 2021 - 13th International Conference on Agents and Artiﬁcial Intelligence