Java 进程分配的遗传算法

我有一个大学作业一直困扰着我。我必须实现一种将进程分配到处理器的遗传算法。更具体地说，问题如下：

“您有一个在并行处理器系统中计算的程序。该程序由N个进程组成，需要在N个处理器上分配这些进程（其中N远小于N）。整个过程中的进程通信可能非常耗时，因此最佳做法是将需要相互通信的进程分配给同一处理器

为了减少进程之间的通信时间，您可以将这些进程的一部分分配给同一个处理器，但这将否定并行处理的思想，即每个处理器都需要为整个进程做出贡献

考虑以下情况：假设Cij是进程i和进程j之间的通信总量。假设每个进程都需要相同的计算能力，以便通过将相同数量的进程分配给处理器来处理处理进程的限制。使用遗传算法分配N个进程从es到n个处理器。”

以上是对问题的粗略描述。现在我有一个让我困惑的问题

1）为了让遗传算法运行，什么是最佳可行的解决方案。我有他们背后的理论，我推断，为了检查每一代生产的人口，你需要一个最好的解决方案。

2）如何正确设计整个问题，以便由程序处理。

---

我计划用Java实现这一点，但是对于其他编程语言的任何其他建议都是受欢迎的。

这家伙遵守了。或者El Duderino如果你不喜欢简洁的话。 你要问的是一个由两部分组成的问题，但遗传算法部分可以很容易地在概念上加以说明。我发现给一个基本的开始是有帮助的，但是这个问题作为一个“整体”太复杂了，这里无法解决

正如您所注意到的，遗传算法（GA）可以用作优化器。为了将GA应用于流程执行计划，您需要能够对执行计划进行评分，然后克隆和变异最佳计划。遗传算法的工作原理是运行多个计划，克隆出最好的计划，然后对其中的一些计划进行略微的变异，以查看后代（克隆的）计划是改进了还是恶化了

在本例中，我创建了一个包含100个随机整数的数组。每个整数都是要运行的“进程”，整数的值是运行单个进程的“成本”

List<Integer> processes = new ArrayList<Integer>();

执行计划的总

成本

将通过取每轮的最高流程成本（最大整数）并将所有轮的成本相加来计算。因此，优化器的目标是将最初的100个整数（进程）分配到4个“处理器”上的25轮“处理”，从而使总成本尽可能低

// make 10 execution plans of 25 execution rounds running on 4 processors;        
List<ExecutionPlan> executionPlans = createAndIntializePlans(processes);
// Loop on generationCount
for ( int generation = 0; generation < GENERATIONCOUNT; ++generation) {
    computeCostOfPlans(executionPlans);
    // sort plans by cost
    Collections.sort(executionPlans);
    // print execution plan costs
    System.out.println(generation + " = " + executionPlans);
    // clone 5 better plans over 5 worse plans 
    // i.e., kill off the least fit and reproduce the best fit.
    cloneBetterPlansOverWorsePlans(executionPlans);
    // mutate 5 cloned plans
    mutateClones(executionPlans);
}

---

那家伙留下来了。或者El Duderino如果你不喜欢简洁的话。 你要问的是一个由两部分组成的问题，但遗传算法部分可以很容易地在概念上加以说明。我发现给一个基本的开始是有帮助的，但是这个问题作为一个“整体”太复杂了，这里无法解决

正如您所注意到的，遗传算法（GA）可以用作优化器。为了将GA应用于流程执行计划，您需要能够对执行计划进行评分，然后克隆和变异最佳计划。遗传算法的工作原理是运行多个计划，克隆出最好的计划，然后对其中的一些计划进行略微的变异，以查看后代（克隆的）计划是改进了还是恶化了

在本例中，我创建了一个包含100个随机整数的数组。每个整数都是要运行的“进程”，整数的值是运行单个进程的“成本”

List<Integer> processes = new ArrayList<Integer>();

执行计划的总

成本

将通过取每轮的最高流程成本（最大整数）并将所有轮的成本相加来计算。因此，优化器的目标是将最初的100个整数（进程）分配到4个“处理器”上的25轮“处理”，从而使总成本尽可能低

// make 10 execution plans of 25 execution rounds running on 4 processors;        
List<ExecutionPlan> executionPlans = createAndIntializePlans(processes);
// Loop on generationCount
for ( int generation = 0; generation < GENERATIONCOUNT; ++generation) {
    computeCostOfPlans(executionPlans);
    // sort plans by cost
    Collections.sort(executionPlans);
    // print execution plan costs
    System.out.println(generation + " = " + executionPlans);
    // clone 5 better plans over 5 worse plans 
    // i.e., kill off the least fit and reproduce the best fit.
    cloneBetterPlansOverWorsePlans(executionPlans);
    // mutate 5 cloned plans
    mutateClones(executionPlans);
}

---

首先我要说的是，这家伙真的很感谢你的回复。老实说，我并没有太大希望在这个话题上得到如此详细的回复。我有几个简单的问题：1）在你的例子中，每个过程所需的计算能力彼此不相等，而它们本应该是相同的。这种情况也适用吗？2） 你忽略了整个过程中的沟通概念。这是如何建模的？3） 您似乎没有使用GAs的全基因组概念来检查成员适合度。您的问题是关于

最佳可行解决方案的问题。这本质上是询问执行计划的复杂性。有关
最佳可行解决方案的讨论，请参见Hi中的三部分答案。1） 过程必须以某种方式不平等，否则就不会有任何问题需要解决。你可以把这些数字看作是沟通成本或任何你喜欢的东西。2） 建模很复杂，你必须弄清楚一些事情。您至少需要硬件功能和流程需求的结构。然后，您需要执行计划的结构（类）。3） 当然，每个
执行计划都有一个列表计划。那就是基因组。每个整数代表一条染色体。这些是
复制的
和
变异的
。我们去打保龄球吧，伙计。好吧，那家伙又住了。当我开始对此建模时，我采用了一种相当复杂的方法，将流程、处理器等作为由许多属性（PID、通信成本等）组成的对象