A single robot per task: the SR problem

This section reviews some definitions used to address the SR problem. As proved by Gerkey in [8], the ST-SR-IA algorithms can be described in terms of the well-known Optimal Assignment Problem (OAP). The OAP is defined as: given n agents (robots) and m tasks to carry out, each agent can only be assigned to one task and each task requires only one agent. For each couple (agent-task), a value is defined that forecasts the agents performance for that task, that is, this value models the agents utility regarding that task. The goal is to assign an agent to each task to maximize the total utility U. This goal function is given as: (1) where α_ij = 1 if the task i is assigned to agent j, and α_ij = 0 otherwise; U_ij is the utility gained by the system when agent j is assigned to task i; and w_j is the weight or importance of the task j. Thus, w_j represents the priority of the task. The Hungarian’s method allows to get the optimal solution for this kind of problems in a time O(nm²) through a dynamic programing centralized method [9]. We have to note that, if the utilities are interrelated, that is, if the agent’s utility for a task depends on the tasks previously assigned to that agent, then the assignment is a NP-hard problem of type ST-SR-TE.

Multiple robots per task: MR problem

In this section we introduce the definitions for MR problems, where the robots can form coalitions for carrying out a task. In this case, the definition for the Set Partitioning Problem (SPP) can be given in the following way according to [10]: given a finite set E, a family F of all feasible subsets of E and a utility function , the goal is to find a family X of F that has the maximum utility and which is a partition of E. The SPP problem is NP-hard, as it was proved in [11]. The Set Covering Problem (SCP) is similar to SPP but it is enough that X is a covering of E, being this a SCP NP-complete problem [12]. Both problems can be viewed as general cases of the multi-robot coalition formation problem, where E is the set of robots, F is the set of feasible robot coalitions formed (each one with a task assigned), and U is the utility function assigned to each coalition [13]. If time constraints are needed, the task deadlines should be considered just as one of the conditions to validate a family F of subsets of E. On the one hand, the SCP definition allows to allocate more than one task to the same robot and, therefore, it can address MT problems. On the other hand, the SPP definition is more restrictive because each robot can only belong to a single coalition at the same time and, therefore, these problems are ST. In [14], it is proved that, using the SPP and SCP definition, the multi-robot coalition formation problem is not only NP-hard but, in general, it cannot be approximated by a factor O(m^1−ε), for any ε > 0, where m is the number of tasks. This means that, unless P = NP, the solution obtained by means of an algorithm with a complexity bounded by a polynomial function will always be O(m^1−ε), for any ε > 0 worst than the optimal solution. As can be observed, the complexity of the coalition formation algorithms is very high. This fact justifies the great number of ad—hoc solutions that can be found in the literature.

In [15], a new coalition formation algorithm is proposed, based on the SCP and SPP definitions, where the maximum number of agents per coalition (k) is fixed beforehand. The algorithm complexity is O(n^km), where n is the number of agents and m the number of tasks. In [13], it is described a new algorithm with a complexity O(n^km) that extents to multi-robot systems the previous algorithms proposed only for multi-agents in [15]. In [14], Service and Adams improve the above cited algorithm given in [13], with a complexity. In any case, this solution is, in general, not optimal yet. Only, if the robots can be grouped in j homogeneous groups, in such a way that each robot only belongs to one of these groups, Service and Adams’ algorithm provides an optimal solution, with a complexity equal to O(n^2jm). In this algorithm, the task must be assigned to a certain number of robots to start its execution and only when this number is reached the task i is executed with a utility u_i. In nex sections, a new method, based on the SPP’s definition, will be explained where the number of robots k do not need to be known beforehand, the robots are not homogeneous and the utility u_i depends, among other factors, on the coalition size. Therefore, Service and Adams’ algorithm is not suitable for these kind of environments. It is also remarkable the Agarwal et al. contribution [16], where genetic algorithms optimize multiple objectives simultaneously for the coalition formation. These objectives can be the distance traveled by the robots, the number of finished tasks, or any other system parameter. Due to its complexity, the evolutive algorithms cannot deal with neither dynamic tasks nor tasks with time restrictions. Nevertheless, the Agarwal’s evolutive methods are very good candidates to improve someway the real time system’s performance.

Scheduling: ST-MR-TE Problems

The above definitions, based on SPP or SCP, do not take into account any temporal condition for the tasks, that is, they cannot deal with any scheduling consideration. On account of [17], the coalition formation problem can be defined in terms of the Job Shop Scheduling (JSS) problem as follows: given a set of m jobs J = {J₁, J₂, …, J_m} and a set of n machines, each job J_i has m_i associated operations O_i = {O_i1, O_i2, …, O_imi} each one of them with an execution time for each machine T_ij. The system’s goal is to decide (schedule) in which order the tasks must be carried out on the machines to minimize the execution time. Moreover, this formulation allows defining a precedence order among operations and, even more, set a maximum execution time bound for the tasks. Balas et al. in [18] propose a method that take into account all these constraints in a multi-agent scenario. It was demonstrated that, in general, the JSS problem is NP-hard. The JSS problem can be adapted to a multi-robot problem in such a way that the system should decide the execution order of the tasks assigned to each robot to minimize, among other factors, the total execution time, the traveled path or the robots’ energy consumption. Thus, these problems are classified as TE, following the Gerkey’s taxonomy. For example, Jones et al. in [19] use genetic algorithms to solve a variation of the JSS problem for multi-robot systems.

The Vehicle Routing Problem with Time Windows (VRPTW) can also be considered as a scheduling problem, where a set of vehicles must transport goods to several “clients”. Each vehicle has a load capacity and each client demands a quantity of goods that have to be delivered within a time window. The system goal is to find a route, as short as possible, that satisfies the clients constraints with the fewest number of vehicles [20]. As the JSS definition, the VRPTW problem is NP-hard too. A variation of the VRPTW is the Tasks with Overlapping Time Window Problem (TOTWP) where the time window can be overlapped. Nunes et al. in [21] try to solve the TOTWP but with non realistic environments and with a single robot per task (SR problem).

Finally, it should be noticed that MT problems, where a robot is able to execute several tasks at the same time, are not feasible in most of the multi-robot missions because, in general, the robots must be located in an specific place to carry out a task.

Centralized systems

In the centralised systems all the information about the robots or the environment characteristics is sent to a central agent that takes all the decisions. Typically, these systems use techniques such as, linear programming or heuristic searches on graphs to find the optimal solution or the closest to the optimal one. Koes et al. [22] utilize linear programming to address simultaneously task allocation, path planning and task scheduling. Yu and Cai, in [23], propose a centralized mechanism called Heterogeneous Interactive Cultural Hybrid Algorithm (HICHA) where, among other techniques, use genetic algorithms. Another centralized system has been introduced by Smith and Bullo in [24], where different task allocation methods are analyzed as a function of the arrival frequency of the tasks.

Swarm Intelligence

Swarm methods are inspired by insect colonies behavior, such as bees or ants, where a global action emerges from the interaction between very simple entities. These methods belong to a more general category of systems called self-organized systems which are defined by Cao et al. [25] as follows: “[…] systems of non-intelligent robots exhibiting collectively intelligent behavior”. That is, they consist on system without any central node, where the cooperative behavior emerges from the interaction of very simple behaviors running on each robot.

The main problem of swarm systems is its lack of global knowledge about the decision made by other robots. Due to this fact, the solutions provided by the swarm methods are far away from the optimal one, moreover, they can only address SR problems of limited complexity such as foraging or cleaning with homogeneous robots. This restriction is superseded in some already explained swarm systems by the authors [26, 27]. Due to its communication complexity, Low’s et al. algorithm [27] does not show some advantages of swarm methods. Furthermore, in Low’s system the robots must be homogeneous, and it cannot handle task time restrictions.

One important issue is how swarm system manage the physical interference effect between robots. This aspect, that will be addressed in Section Physical interference between robots, has already been broadly faced up in several papers, such as [28, 29]. Khaluf’s swarm methods [30] can manage deadlines but without taking into account the interference effect.

Auction methods

Auction methods use communication protocols between robots to implement an explicit negotiation about which task must execute each robot or coalition of robots. These protocols are based on the Contract Net Protocol (CNP) proposed by Smith in 1980 [31]. Smith’s work defines a mechanism to assign tasks to communication nodes (machines) connected between them, that must solve some cooperative problem in a distributed way. When a node, called manager or auctioneer, finds or generates a new task, sends a message to announce it before starting the execution. The other nodes, called bidders, send to the auctioneer a value, called bid, that indicates how suitable are they for executing the new task. Once the manager node has received all the bids, it selects the best node (node with the highest bid) for the task. In multi-robot systems, the nodes are the robots and the manager is a central agent or another robot.

Most current auction methods only admit a robot per task, therefore, they are SR methods. In contrast, MR problems, which require coalition formation mechanisms, have hardly been addressed by auction approaches. Vig and Adam’s RACHNA method [32] allows MR problems but without deadlines. Paquet in [33] proposes a method where the working group size is unknown beforehand and considers task deadlines. This mechanism has only been tested on multi-agent systems, such as Robocup competition, but not on real or simulated physical robots. Furthermore, due to the high computational cost of its algorithms, the decision about how many agents are needed to finish a task cannot be made on-line. In [34], Tang and Parker introduce another auction approach, called ASyMTRe, that allows high tight tasks and coalition formation. More auction methods that admit coalition formation can be found in [35]. None of these methods consider the physical interference or the task deadlines.

Among the auction methods that allow time restrictions, one of the most remarkable work is that proposed by Jones [36]. This approach makes use of a learning algorithm to find the most suitable value for the bids in MR problems. Jones’ method uses a learning Support Vector Regression (SVR) model to obtain the bid value, but does not estimate the execution time. Lemaire’s auction method [37] allows soft deadlines but with a single robot per task. In [38], the proposed method can solve the VRPTW without overlapping windows. In [39], Campbell introduces a method that, that is partially inspired by auctions, where the robots can not decide to bid for a task despite it was the best option at that moment. The Campbell’s experimental results show a great improvement regarding the aforementioned methods.

Heretofore, all the methods cited does not try to forecast the expected execution time of the task. Sellner’s and Simmons’ SR method [40] predicts this time making use of kernels, but no physical interference is taken into account. In contrast, Sellner’s approach requires very heavy computational algorithms to carry out the tasks. As has been mentioned in previous sections, Nunes et al. [21] allow overlapped time windows with auctions to address SR problems. Finally, other auction-like mechanisms [41] also face up tasks with deadlines but with only one robot per task.

As has been exposed, the auction mechanisms allow the distribution of the decision process among the robots through communication protocols. Thus, the typical problems produced in centralized systems, such as single point of failure or overloading of the central agent, are avoided. Furthermore, these algorithms are, in general, much more simple than the centralized approaches. In contrast, to the aforesaid advantages, the solutions provided by the auction methods require more time and increase the energy consumption compared to the centralized systems. In addition, the auction methods are more complex than the swarm ones because they require communication protocols between robots. Despite of that, the auction systems outperform the swarm-based ones increasing the number of finished tasks and reducing the energy consumption, among other factors. Furthermore, due to the inter-robot communication protocols, the auction methods can deal with much more complex and tight tasks.

Physical interference between robots

The physical interference between robots is one of the most fundamental problems to address by the task allocation mechanisms. In [2] Rosenfeld et al. clearly state the huge impact of the physical interference on the multi-robot systems performance. There are a lot of methods that try to minimize the interference effect in multi-robot systems without deadline (see, for instance, [42]).

In [43], Dahl et al. propose a mechanism called Vacancy Chains to carry out foraging tasks for MR problems. The system assigns robots to a task (transport an object that can be divided in small parts) until it detects that the amount of transported object weight decreases. This reduction can only be due to the interference between robots. Dahl’s method neither deals with tasks with deadlines nor can estimate tasks execution time. Finally, Lerman’s et al. studies [1] and Nam and Shell [44] present methods to model the interference but none of them deal with time restrictions.

Other authors describe swarm-like strategies to deal with the physical interference in systems with a huge number of robots (see [6, 45, 46]). For example, Rubensteinin et al. in [45] use self-assembly with thousand of robots to build complex structures.

Generic problem

The MRTA-ST-MR with deadlines problem (from now on simply MRTA problem) can be seen as a particular case of the SPP. From now on, will denote the set of positive integer numbers. Moreover, in the following, R will denote the set of robots with R = {r₁, …, r_Nr} and T will denote the set of tasks to carry out with T = {t₁, …, t_Nt}, where . Furthermore, we will assume that both sets, R and T, are kept constant over the time. Next, denote by G the the subset of 2^R formed by all working groups or coalitions of robots allowed over R, where 2^R stands for the power set of R. The criteria to decide if a working group is allowed depends on specific task characteristics.

Now, taking into account the preceding notation, we introduce the main notions in order to formalize the MRTA problem with deadlines. To this end, let us denote by the non negative real numbers.

Definition 1 Let t_j ∈ T and with 1 ≤ j ≤ N_t. The sets of coalitions assigned to t_j over the time, Sg_tj, is defined by where each pair stands for the coalition of robots g_k allocated at task t_j at time τ_k for all k = 1, …, n(t_j) and, in addition, satisfies that τ_k < τ_m whenever k < m for all k, m = 1…n(t_j).

It must be pointed out that each coalition g_k allocated at a task t_j is kept constant from time instant τ_k until τ_k+1 for all k = 1, …, n(t_j), where τ_n(tj)+1 denotes the finishing time for that task provided that the set of coalitions Sg_tj is able to carry out the task.

Notice that if the allocation is non preemptive, that is, a robot cannot leave its current working group after allocating it in a task, then the cardinality of the set of coalitions must be lower or equal to 1, i.e., ∣Sg_tj∣ ≤ 1 for all j = 1…N_t and, thus, for all j = 1, …, N_t.

Definition 2 Let j ∈ {1, …, N_t}. Then the execution time of the task t_j ∈ T is defined as the function such that

Note that β_j(Sg_tj)) provides the time needed by the set of coalitions to finish the task t_j whenever the aforementioned set is able to carry out t_j.

As has been pointed out in Section Previous work on coalition formation, giving the exact value of β function for a certain coalition is often impossible or quite difficult because of, among other factors, the interference effect. Therefore, in most cases, the function β must be predicted through different methods.

Definition 3 Let j ∈ {1, …, N_t}. Then the utility of a task t_j is defined as a function such that U_j(∞) = 0.

Note that the utility function of a task will depend on task’s characteristics such as its deadline which will be denoted by DL_j. Fig 1(a) shows an example of an utility function U_j called hard-deadline utility function, where U_j(τ) is constant and equal to U_maxj if τ < DL_j and abruptly drops to zero if τ ≥ DL_j (the task cannot be executed on time). Another kind of utility function are so-called soft-deadline utility functions. An example of these type of functions can be seen in Fig 1(b), where the value of U_j(τ) progressively falls to zero from τ = DL_j.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Fig 1. Utility function (U_j) examples.

(a) Hard-deadline utility function, (b) Soft-deadline utility function, where τ stands for the time needed by the coalition to finish the task.

https://doi.org/10.1371/journal.pone.0170659.g001

In the light of Definition 3 it is clear that the value U_j(β_j(Sg_tj)) yields the utility after assigning a coalition set Sg_j to a task t_j ∈ T. Depending on the characteristics of the composition function U_j ∘ β_j, as for instance linearity or continuity, the allocation problem must be addressed by a different kind of strategy, as will be seen later.

As we have noticed before, whenever the allocation is not preemptive. Hence in this case the global utility associated to the MRTA problem matches up with the function given as follows: (2)

It is clear that an element can be identified with a function such that where TA_j(t_j) = Sg_tj for all j = 1, …N_t.

Under the preceding assumptions, the goal of the MRTA problem is to maximize the global utility function, that is, to find a function TA* which maximizes the function U. Thus, the aforesaid goal matches up with obtaining the solution to the following optimization problem: (3)

Observe that we need to consider the restriction of Problem 3, since the MRTA problem is an SPP problem.

To validate the model explained above we propose a simple but generic example of a foraging-like task. To this end, we assume, in addition to the non preemptive allocation assumption, an IA strategy and that the coalitions for the tasks are formed simultaneously, i.e., τ₁ is the same for all t_j with j =, …, N_t.

Case studies

Case 3 (Hard-deadline utility function).

If the utility functions U_j, for all j = 1, …, N_t, are two-step hard deadline discontinuous function (see Fig 1(a)) then we show that the problem can be addressed as an integer linear programming problem. To this end, let us recall that according to [47] a renowned classical optimization problem consists in minimizing a function f defined by (16) where each α_ij is given as in Eq (9) and H is the heaviside function defined by (17)

Following [47], the preceding optimization problem can be converted into an integer program problem adding for each task t_j a new binary auxiliary variables η_j ∈ {0, 1} and the constraint , where M is a value greater than all the values for the argument of H. Thus the optimization problem of minimizing the function f can be reformulated as the next optimization problem where the variable are now η_j and α_ij: (18)

In the light of the exposed considerations, it is clear that the multi-robot task allocation problem under consideration can be seen as an optimization problem which fits the characteristics of the Problem (18). Indeed, the fact that any η_j takes the value 0 can be interpreted as the coalition of robots allocated in task t_j can carry out the task before its deadline (of course η_j = 1 can be interpreted dually). Moreover, each utility function U_j can be expressed in terms of the H functions as follows: (19) where τ is the amount of time required to finish the task t_j. This expression can be rewritten to add robots’ capabilities, task’s characteristics and interference, as follows: (20)

After taking into account the information provided by the utility functions U_j and the interference effect, Problem (18) becomes the following optimization problem: (21) where for all j = 1, …, N_t. Consequently, when the utility functions meet the characteristics of the Case 3, the optimization problem matches up with a binary linear programming problem.

Table 1 summarizes the aforementioned cases, assuming that the interference function I_g is linear. In spite of most MRTA cases can be addressed as linear (binary-integer) optimization problems they still require too much time to be solved in dynamic environments, especially when there are a large number of tasks or robots. As pointed in section about previous work, many approaches have tried to give a good enough solution with a reasonable amount of time: swarm intelligence, auction approaches, and so on, but only few of them take into account task with deadlines. Inspired by the preceding fact and by the exposed example, a new auction-like algorithm to address MRTA-IA problems is introduced in the next section.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Table 1. Summary of the complexity regarding the utility function, where BINLP is binary integer nonlinear programming problem; BILP denotes integer linear programing problem problem; LP is linear programing problem.

https://doi.org/10.1371/journal.pone.0170659.t001

Simple Double Round Auction (SDRA)

The SDRA algorithm splits the classical auction process into two steps: auction for a task and auction for a robot. In each task there is a robot, called the task leader, that will manage an auction process. Thus, several auction processes can be executed in parallel; one for each task. Each task must have a single leader which is the robot that handles the coalition or work group, that is, it will be the auctioneer. In the initial stage, each robot is looking for a task. When a robot finds a new task, it tries to lead it. As there can only be one leader per task, the candidate will execute the leadership request process to ensure at most one leader per group.

If a robot is promoted to the leadership of the task t_j, it creates a coalition of robots, if necessary. In that case, the leader must decide the optimum group size and which robots are part of it. To take this decision, the leader uses the first step of the SDRA, called auction for a task. In this process the leader is the auctioneer and the other robots bid using their work capacities, C_ij. After a given time, the leader selects the robots with the highest work capacity using a greedy algorithm until it detects that, even if the next best robot is added to the group, the task utility function U_j is not improved. Following the new formulation, if U_j ∘ β_j function meets the constraints of the Case 2 detailed in Section Case studies, the task leader selects the best robots until this condition is verified: (22) where g_B stands for the group of best robots already selected and where r_nmax is the next best robot. If U_j is a hard-deadline function (see Case 3), the task leader stops selecting new robots when it detects that the group is able to reach the task deadline, that is until β_j(g_B) ≤ DL_j.

Furthermore, the leader does not include any selected robot in its group until it receives the confirmation from these candidates. This confirmation is generated during the auction for a robot round. In this round, to get the selected robots, the leader bids for them sending the expected utility of the task. Therefore, now the leader becomes the bidder and the selected robots are the auctioneers. When a robot receives a bid from a leader, it waits a certain time for more bids from other leaders. After this time, the robot selects the coalitions with the greatest bid and it becomes a member sending a confirmation message to the corresponding leader.

The interference factor I_gj, required to calculate the expected execution time, (see Eqs (4) and (5)), was estimated using a Support Vector Regression method (SVR). In the experimental results section, we will explain in a more detailed way how the interference parameters have been estimated.

Multiple Objectives Double Round Auction (MDRA)

When applying the SDRA method, the auction for a robot round only used the utility sent by the leader and did not take into account the individual capacity of the robots. The new method, called Multiple Objectives Double Round Auction (MDRA), uses both the individual and the leader’s utility during the auction for a robot round in order to improve the system performance. The other two steps of the auction process: leader’s selection and auction for a task, are not modified with respect to SDRA.

In the MDRA method, as in SDRA, the robots selected by the leaders receive the expected utility of the tasks, denoted by B = {(t₁, b₁), …, (t_n, b_n)}, where represents the utility of the group that attempts to execute the task t_i ∈ T. Let (t_best, b_best) be the tuple in B with highest utility; and denote by B_bests = {(t_i, b_i) ∈ B: b_i ≥ λ_B ⋅ b_best} where λ_B ∈ [0, 1]. The robot will select the task from B_bests for which it has the highest capacity. Algorithm 1 specifies the steps executed by a non-leader robot to implement the auction for a robot stage, where TIME_BID_ACCEPTED stands for the amount of time that the robot waits for leaders bids (AWARD messages). After this time, the robot selects the coalition with the greatest bid and it becomes a member sending a confirmation message (ROBOT_ALIVE) to the corresponding leader. If the leader doesn’t receive any answer from a robot or receives a reject message (REFUSE), it removes that robot from its list of selected robots. On the other hand, a robot is definitely added to the group, when the leader receives a confirmation message from it. The λ_B value is inspired by the selection factor used in [13], but it is now applied in an auction process with tasks’ deadlines.

Algorithmn 1 Auction for a robot round executed in each no leader robot

Require: λ_B ∈ [0, 1]

Require: time current time

1: if AWARD message, (t₀, b₀), from a leader then

2:  B ← (t₀, b₀)

3:  time_init ← time

4:  while time − time_init ≤ TIME_BID_ACCEPTED do

5:   if AWARD message, (t_j, b_j), from a leader then

6:    B ← B ⋃ (t_j, b_j)

7:    j ← j + 1

8:   end if

9:  end while

10:  (t_best, b_best) tuple in B with the maximum bit value

11:  B_bests = {(t_i, b_i) ∈ B: b_i ≥ λ_B ⋅ b_best}

12:  t_sel ← task from B_bests with the highest robot’s capacity

13:  Send a ROBOT_ALIVE message to the leader of t_sel

14:  for all t_j in B and t_i ≠ t_sel do

15:   Send REFUSE message to the leader of t_j

16:  end for

17: end if

Experiments with physical robots: Interference function

First, we describe how the parameters of the interference function (Eq 14) have been estimated. In a previous work [49], the first two authors exposed how, for foraging-like tasks (see Section Example: Foraging with tasks’ deadline), the interference can be modelled as a set of polynomial functions that only depends on the number of robots and on the distance between the delivery point and the object. To get the parameters of the polynomial functions the following experiment in the realistic simulator RoboCoT was carried out: several robots must transport a unique object, formed by transportable bits, and the total weight transported by the robots after 40,000 time units is calculated. Seven different distances between object and delivery point were tested and the parameters of I were fitted for each one of them (see Table 2). Fig 2 shows an snapshot of one of these executions, where the little square represents the object, the big circle the delivery point and the little circles are the robots. These results were also validated with other well-known simulator called Player/Stage [50]. Although all the interference values in this paper relate to physical simulations, the algorithms were also implemented on four real Pioneer-3DX. Videos with some executions can be watched in [51] and a more detailed description of these experiments can be found in [49].

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Fig 2. Execution example of a RoboCoT experiment to calculate the parameters of the interference function I.

https://doi.org/10.1371/journal.pone.0170659.g002

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Table 2. Parameter a_j of the linear interference function.

https://doi.org/10.1371/journal.pone.0170659.t002

From the results of the aforesaid simulations, it can be seen that the maximum utility of the group (the maximum of Eq (5)) is reached when the number of robots is equal to or lower than 30. Thanks to the condition given by Eq (22), the maximum number of robots in a coalition created by the auction algorithms is 30. Although in the original paper [49] the polynomials have a degree equals to two, if n_g < 30 the I_g can be fitted by a linear polynomial function with a very low error, meeting all the conditions of the cases exposed in section about the formalization (Cases 2 and 3). The parameter b_j of Eq (14) was set to 0 because it is assumed that a coalition with a single robot does not have physical interference. Table 2 shows the interference linear function parameter a_j that minimizes the square error for each distance tested.

Experiments with soft-deadline utility functions

The first set of experiments assume that each U_j ∘ β_j is linear and it meets the condition of Case 2. Therefore the problem to solve is Problem (15). The characteristics of the experiments are the following: The number of robots (N_r) varies from 2 to 30 times the number of objects (N_t). There are 5 different types of objects and each robot has a different load capacity depending on the object type. In order to apply the parameters of Table 2, the distances always fall into the bounds described in above section. In addition, robots’ work capacity C_ij depends on the type of task and on its velocity, as is pointed out by the authors in [3]. The main goal of these experiments is to test the new MDRA algorithm with a very large number of robots. It is worth to point out that when N_t = 15 there are up to 450 robots, and if N_t = 30 then this number is increased up to 900 robots. Each experiment has been performed 500 times using a uniform random distribution to generate the position of the objects, their weights, the load capacity of the robots and their velocities. S1 Table shows the parameters of the uniform random variables for each one of these characteristics. In order to keep the robots as simple as possible, the robots use their load capacities for selecting the best task in the Greedy strategy.

Fig 3 (N_t = 15) and Fig 4 (N_t = 30) show the utility per robot obtained by different strategies (SDRA, MDRA and greedy) divided by the utility per robot obtained with the optimal method (see S2 and S3 Tables). For all these results, utility per robot stands for the mean of the total obtained utility divided by the number of robots. Thus, higher values stand for results closer to the optimal. The X-axis shows the ratio between the number of robots and the total number of tasks and the bars stand for the standard deviation (σ²). As can be seen, the total utility obtained with MDRA utilities is close to the optimal and the better results (higher values) are obtained when the number of robots per task is 8. With more than 8 robots per task, the results stay constant or show a slight decrease. For some cases, MDRA utility reaches more than the 75% of the optimal utility and from around 14 robots per task this value keeps almost constant. If, instead of the mean, it is calculated the median, the MDRA utility reaches more than an 80% of the optimal (see S3 Table). The Greedy strategy provides the worst results, always lower than a 55% of the optimal utility. In most cases, the new MDRA algorithm gives the best results when λ_B = 0.8 and outperforms the SDRA. It should be recalled that the tested environments are very heterogeneous and, therefore, this issue increases the σ² values of the experimental results.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Fig 3. Ratio between utility obtained with MDRA and the utility of the optimal strategy with N_t = 15.

The bars stand for the standard deviation (σ²).

https://doi.org/10.1371/journal.pone.0170659.g003

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Fig 4. Ratio between utility obtained with MDRA and the utility of the optimal strategy with N_t = 30.

The bars stand for the standard deviation (σ²).

https://doi.org/10.1371/journal.pone.0170659.g004

Fig 5 shows the ratio between utility per robot using greedy algorithm and MDRA with λ_B = 0.8, similar results are obtained for other values of λ_B. The experiments demonstrate that the higher number of robots the lower greedy performance with respect to MDRA and hence, the new auction algorithm improves the results compared to a fully distributed approach. The standard deviation of these experiments can be obtained from the information of the Figs 3 and 4.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Fig 5. Ratio between greedy utility and MDRA (λ_B = 0.8).

https://doi.org/10.1371/journal.pone.0170659.g005

As can be seen in Fig 6 (see also S4 Table), the optimal algorithm needs much more execution time to give a solution than MDRA with λ_B = 0.8 or greedy algorithm and it clearly grows with the number of robots. Moreover, the MDRA algorithm increases very slowly its execution time with respect to the number of robots. Therefore, it can be concluded that the results provided by the new MDRA method are pretty close to the optimal results with much less execution time and it outperforms the SDRA approach.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Fig 6. Execution time for soft deadline experiments and N_t = 30.

The bars stand for the standard deviation (σ²).

https://doi.org/10.1371/journal.pone.0170659.g006

Experiments with hard-deadline utility functions

This section describes the experiments carried out with hard-deadline utility functions and lineal interference, that is, Case 3 described in Section Case studies. Therefore, the problem to solve is the same as Problem (21). In order solve it numerically, we must find coalitions with a performance (amount of work carried out per time unit) greater or equal than the performance needed to finish the task before the deadline, instead of the execution time. Notice that both problems are equivalent and, therefore, the resulting solutions are exactly the same. Moreover the new problem has the same form as the Problem 21 but with , for all j = 1, …, N_t. The new m value is simpler than the original one and avoids division by zero problems.

As for soft-deadline experiments, each experiment has been performed 500 times using a uniform random distribution to generate the position of each object, its weight and deadline, the load capacity of the robots and their velocities. As the scalability of the system has already been demonstrated in the previous section, all the simulations have been performed with 4 tasks (N_t = 4) and the robots always use their expected capacities for selecting the best robot (Greedy) and for bidding (SDRA or MDRA).

Fig 7 (see also S5 Table) shows the utility per robot for different strategies (SDRA, MDRA and greedy) divided by the utility per robot obtained with the optimal method, where the bars stand for the standard deviation σ². As can be seen, the higher number of robots the higher value of this ratio for MDRA, which means that the MDRA results are getting closer to the optimal. Despite of the utility per robot provided by MDRA decreases compared to the soft-deadline case, it reaches values near the 70% of the optimal (ratio = 0.7). This must be considered a very good result, specially tanking into account that the complexity of the problem is dramatically increased, which implies that the MATLAB solver takes order of minutes to give a results while MDRA keeps bounded on the order of seconds. In all the cases, the MDRA outperforms the SDRA when λ_B = 0.8, as happened for soft-deadline utility function experiments. So the optimal value of λ_B seems to be very stable for any environment or utility function. Furthermore, the greedy algorithm keeps very far from the optimal and even from the auction approaches. Finally, the standard deviation decreases regarding the number of robots. The overlap in the standard deviation bars is due to the great heterogeneity of the carried out experiments. In order to cover a broad spectrum of situations, the standard deviations of the uniform random variables used to generate each experiment are very high, as can be seen in S1 Table. If we focus on a specific set of experiments, the aforementioned overlap is reduced. For example, Fig 8 (see also S6 Table) shows the ratio between auction or greedy utility and optimal utility with hard-deadline over the 50 experiments with the highest tasks’ deadline values. For the sake of simplicity this figure only shows the MDRA results with λ_B = 0.8. As can be seen, the overlap between the standard deviation of SDRA and MDRA is reduced regarding Fig 7. In order to address these problems, future work will analyze the impact of the environment configuration on the system performance.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Fig 7. Ratio between auction or greedy utility and optimal utility with hard-deadline.

The bars stand for the standard deviation (σ²).

https://doi.org/10.1371/journal.pone.0170659.g007

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Fig 8. Ratio between auction or greedy utility and optimal utility with hard-deadline using the 50 experiments with the highest tasks’ deadline values.

The bars stand for the standard deviation (σ²).

https://doi.org/10.1371/journal.pone.0170659.g008

As in previous section, Fig 9 shows the ratio between utility per robot using greedy algorithm and MDRA with λ_B = 0.8, similar results are obtained for other values of λ_B. The results demonstrate how the performance of the greedy algorithm decreases regarding the number of robots. The standard deviation of these experiments can be obtained from the information of Fig 7.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Fig 9. Ratio between greedy utility and MDRA (λ_B = 0.8) for hard-deadline tasks.

https://doi.org/10.1371/journal.pone.0170659.g009