# A Social Multi-Agent Cooperation System Based on Planning and Distributed Task Allocation
## 6 Evaluation
For our approach, we denote by numberMsg messages such the number when we use only two kinds of agents, which are initiator and participant agents. For the second approach [7], we denote by numberMsgMd messages such the number when we use manager, mediator and participant agents in coordination. If we apply our approach, in this case, the initiator agent has to inform all the planning agents (i.e., N) to apply any distributed task before waiting for their responses and, after that, decide to accept or to refuse the offer; then, numberMsg = 2 * N.  
If we apply the second approach [37], in this case, the manager agent has to inform all its neighboring agents (i.e., N) to apply any distributed task. The worst case is needing the help of another agent (mediator), which also in turn needs another mediator, and so forth. If we consider that each mediator agent sends the request to its neighboring agents, P represents the number of mediator agents existing in the distributed system (where P << N). Then, numberMsgMd = (2 * N) * P.  
If we apply the GDAP, the manager agent has to request only its neighbors (in the best case). In the worst case, there is a failure in task allocation and the same process has to be repeated several times by another managers. The worst case is to have the number of manager agents existing in the distributed system being equal to all the agents. Then, numberMsgMd = (2 * N) * N.  
The algorithms have been evaluated according to the _number of exchanged messages_ as a criterion in this experiment. All the results are obtained by applying the logarithm function. From Figure 6, it is clear that whenever the number of neighboring agents is reduced, the three approaches have approximatively the same performance. Whenever the number of neighboring agents is elevated, it is evident that our approach is the best as it reduces the communication cost. In conclusion, our proposed solution is very efficient (especially when the neighboring agent number \begin{table}
\begin{tabular}{c c} \hline \hline
**Setting** & **Quantity** \\ \hline Number of agents & 10 \\ Average number of neighbors & [1..10] \\ Tasks & 5 \\ Available resources & 6 \\ \hline \hline \end{tabular}
\end{table} 
Table 2: The details of the settings. is high) as it requests little message exchange. The approach in [37] suffers from a very high message exchange rate in the case of the neighboring agent number being important. The second criterion is the execution time. The unit of execution time is the millisecond. For simplicity, we suppose that once a task has been allocated to an agent, the agent would successfully finish this task without failure. We would like to test, in this experiment, the impact of different average numbers of neighbors on the execution time applied for these three approaches. We notice in Figure 7 that our approach tracks the lowest execution time amongst the other ones. The third criterion is the utility ratio, which is defined as the sum of completed tasks divided by the total number of tasks. \[\text{Utility Ratio}=\frac{\sum successful-completed-task}{Total-of-Tasks}\]  
We would like to test, in this experiment, the influence of different average numbers of neighbors on the three algorithms. We notice in Figure 8 that the utility ratio of our algorithm in different networks is more reliable than that of the GDAP algorithm. We notice also that the GDAP solution utility is the worst in the majority of cases. Whenever the number of neighboring agents is reduced, our solution performs moderately in terms of utility. This is can be explained by the following:  
* Not all the planning agents having the requested resources are registered in the directory facilitator (some of them are selfish and do not like sharing their resources). * Even when the initiator agent searches the neighboring agent providing the requested resources (the number is reduced), some of the planning agents refuse to participate in the distributed task allocation for the simple reason that the resource can be used by itself later.