The Software Project Scheduling (SPS) problem refers to the distribution of tasks during a software project lifetime. Software development involves managing human resources and the project budget in an optimal way for a successful project. Several different formulations and many optimization algorithms have been applied to solve this problem. We revise in this talk several aspects of this problem. First, we describe a formulation of the problem that takes into account the productivity of the employees in different tasks. Second, we present a robust variant of the problem considering the inaccuracies in task-cost estimations. Third, we discuss a methodology to interactively include the project manager in the optimization process by asking preferences in the objective values. We show the results of a set of experiments over synthetic data to proof the concepts presented in the talk.
We focus on the automatic enhancement of software to make it faster and also more efficient, in the sense that it makes a better use of the available resources. In this talk we present the Evo-LLVM framework, a tool that allows automatically improving a piece of code for a given architecture, according to several features. In particular, the framework is based on the modular LLVM Compiler Infrastructure, and makes use of evolutionary algorithms. It is designed to optimize, for a given input source code (written in C), the sequence of LLVM transformations that should be applied to the source code in order to improve its performance. This performance can be measured in different ways, and we here focus on energy efficiency and execution time. Therefore, we use Multi-Objective Evolutionary Algorithms (MOEAs) to optimize both performance metrics simultaneously. In this work, the NSGA-II algorithm is implemented within the Evo-LLVM yet the analysis of more advanced heuristics is in progress. We will present some preliminary results to experimentally validate the framework over a pedagogical code sample, revealing a drastic improvement of the energy consumed during the execution while maintaining (or even improving) the average execution time.