# A Model-Driven Approach for Solving the Software Component Allocation Problem
## 6 Results and Discussion
Then, we used _PyAllocator_ to solve the single-objective optimization problem. In the script, we defined the weights of the three resources by setting the elements of the trade-off vector \(w_{j}\). There are no architectural constraints in the allocation problems. To apply our framework, we created a model transformation program to transform SCALL models into models conforming to the CAP meta-model. We used this transformation program to transform the models, which correspond to _Systems 0_ and 9. Figure 8: Multi-objective optimization results for _Systems 1_ and 9. (a) Pareto fronts for System 1; (b) Pareto fronts for System 9. Figure 10 shows optimal cost results obtained in 10 different runs. In the figure, the ranges for the approximated optimal costs (as found by SCALL) are represented as gray rectangles delimited by the minimum and maximum values in the different runs for each system. In addition, the figure shows the optimal cost for each system obtained using our framework as a solid black line. With regards to the execution times, for _System 9_, the 95% confidence interval for the execution times was 0.19447 \(\pm\) 0.0022941 (the unit is in seconds) in the case of using the _PyAllocator_ script and 0.16861 \(\pm\) 0.0041780 in the case of using our framework. Furthermore, we apply our proposed approach in order to extend and improve the previous works relying only on single-objective optimization in cases of conflicting goals. However, in such cases, conflicting aspects are present, such as infrastructure cost and energy consumption which should be kept as small as possible, while the performance has to be maximized, on the other side. Therefore, the adoption of multi-objective approach has the potential for improvement of the allocation outcome in these scenarios when there  
Figure 10: Optimal cost results for _Systems 0_ and 9. Figure 9: The _SCALL_ meta-model. are several equivalent solutions with respect to cost minimization, but exhibit different performance or vice versa. First, we considered the SMADA-Fog framework [40] which aims to find optimal container allocations to heterogeneous devices in the context of Fog Computing scenarios. In the original paper, the allocation problem is treated as a single-objective optimization problem aiming to minimize energy consumption or maximize execution speed under the constraints related to memory capacity, computing architecture (ARM/x86), and execution environment (Fog or Cloud). After the execution of the same experiments from [40], it was noticed that our approach was at least an order of magnitude faster regarding the execution time when it comes to the single-objective optimization case. Moreover, it was noticed that the speedup was more significant for larger models, reaching up to 2 orders of magnitude. On the other side, additional benefits were achieved using the proposed approach, as it enables multi-objective optimization of both energy consumption (minimization) and execution speed (maximization) at the same time. This way, it was possible to select more energy-efficient deployments for the same execution speed, while minimizing overall infrastructure maintenance costs. However, in the case of multi-objective optimization, the execution times were two orders of magnitude larger, reaching up to around 2.8 s in our experiments. On the other side, similar findings are observed when it comes to the usage of our framework in the telecommunications domain for the optimal base station allocation at given smart city locations in the context of next-generation software-defined mobile networks [41]. The goal of the objective function is to minimize the deployment costs, while taking into account constraints related to fading-affected network performance and service demand.