New example: Cloud Balancing

Author: CameleoGrey

examples/object_oriented/cloud_balancing/__init__.py

@@ -0,0 +1,24 @@
+
+
+
+class CotComputer():
+
+    def __init__(self, computer_id, cpu_power, memory_size, network_bandwidth, cost):
+
+        self.computer_id = computer_id
+        self.cpu_power = cpu_power
+        self.memory_size = memory_size
+        self.network_bandwidth = network_bandwidth
+        self.cost = cost
+    
+    def build_from_domain_computer(domain_computer):
+
+        cot_computer = CotComputer(
+            domain_computer.computer_id,
+            domain_computer.cpu_power,
+            domain_computer.memory_size,
+            domain_computer.network_bandwidth,
+            domain_computer.cost,
+        )
+
+        return cot_computer

examples/object_oriented/cloud_balancing/cotwin/CotComputer.py

@@ -0,0 +1,12 @@
+
+
+
+class CotProcess():
+
+    def __init__(self, process_id, cpu_power_req, memory_size_req, network_bandwidth_req, computer_id):
+
+        self.process_id = process_id
+        self.cpu_power_req = cpu_power_req
+        self.memory_size_req = memory_size_req
+        self.network_bandwidth_req = network_bandwidth_req
+        self.computer_id = computer_id

examples/object_oriented/cloud_balancing/cotwin/CotProcess.py

@@ -0,0 +1,11 @@
+
+
+
+from greyjack.cotwin.CotwinBase import CotwinBase
+
+class CotScheduleCB( CotwinBase ):
+
+    def __init__(self):
+        super().__init__()
+
+        pass

examples/object_oriented/cloud_balancing/cotwin/CotScheduleCB.py

@@ -0,0 +1,12 @@
+
+
+
+class Computer():
+
+    def __init__(self, computer_id, cpu_power, memory_size, network_bandwidth, cost):
+
+        self.computer_id = computer_id
+        self.cpu_power = cpu_power
+        self.memory_size = memory_size
+        self.network_bandwidth = network_bandwidth
+        self.cost = cost

examples/object_oriented/cloud_balancing/cotwin/__init__.py

@@ -0,0 +1,12 @@
+
+
+
+class Process():
+
+    def __init__(self, process_id, cpu_power_req, memory_size_req, network_bandwidth_req, computer_id):
+
+        self.process_id = process_id
+        self.cpu_power_req = cpu_power_req
+        self.memory_size_req = memory_size_req
+        self.network_bandwidth_req = network_bandwidth_req
+        self.computer_id = computer_id

examples/object_oriented/cloud_balancing/domain/Computer.py

@@ -0,0 +1,62 @@
+
+
+
+class ScheduleCB():
+
+    def __init__(self, computers, processes):
+        
+        self.computers = computers
+        self.processes = processes
+    
+
+    def print_metrics(self):
+
+        used_resources_map = {}
+        for process in self.processes:
+            process_id  = process.process_id
+            cpu_power_req  = process.cpu_power_req
+            memory_size_req  = process.memory_size_req
+            network_bandwidth_req  = process.network_bandwidth_req
+            computer_id  = process.computer_id
+
+            if computer_id not in used_resources_map:
+                used_resources_map[computer_id] = {
+                    "processes": [],
+                    "cpu": 0,
+                    "memory": 0,
+                    "network": 0
+                }
+            
+            used_resources_map[computer_id]["processes"].append(process_id)
+            used_resources_map[computer_id]["cpu"] += cpu_power_req
+            used_resources_map[computer_id]["memory"] += memory_size_req
+            used_resources_map[computer_id]["network"] += network_bandwidth_req
+        
+        total_violations = 0
+        computer_ids = list(sorted(list(used_resources_map.keys())))
+        for computer_id in computer_ids:
+            computer_info = self.computers[computer_id]
+
+            if used_resources_map[computer_id]["cpu"] > computer_info.cpu_power:
+                total_violations += 1
+            if used_resources_map[computer_id]["memory"] > computer_info.memory_size:
+                total_violations += 1
+            if used_resources_map[computer_id]["network"] > computer_info.network_bandwidth:
+                total_violations += 1
+
+            print("Computer {} utilization: ".format(computer_id))
+            print("    CPU: {} / {} | RAM: {} / {} | NTWRK: {} / {}".format(
+                used_resources_map[computer_id]["cpu"], computer_info.cpu_power,
+                used_resources_map[computer_id]["memory"], computer_info.memory_size,
+                used_resources_map[computer_id]["network"], computer_info.network_bandwidth,
+            ))
+            print("    PIDs: {}".format(", ".join(str(pid) for pid in used_resources_map[computer_id]["processes"])))
+            print()
+            print()
+
+        print("Total violations: {}".format(total_violations))
+        print("Computers used: {}".format(len(computer_ids)))
+        print()
+            
+
+

examples/object_oriented/cloud_balancing/domain/Process.py

@@ -0,0 +1,148 @@
+
+from greyjack.persistence.CotwinBuilderBase import CotwinBuilderBase
+from greyjack.variables.GJInteger import GJInteger
+from examples.object_oriented.cloud_balancing.cotwin.CotScheduleCB import CotScheduleCB
+from examples.object_oriented.cloud_balancing.cotwin.CotProcess import CotProcess
+from examples.object_oriented.cloud_balancing.cotwin.CotComputer import CotComputer
+from examples.object_oriented.cloud_balancing.score.PlainScoreCalculatorCB import PlainScoreCalculatorCB
+from examples.object_oriented.cloud_balancing.score.IncrementalScoreCalculatorCB import IncrementalScoreCalculatorCB
+import numpy as np
+from numba import jit
+
+class CotwinBuilder(CotwinBuilderBase):
+
+    def __init__(self, use_incremental_score_calculator, use_greed_init):
+
+        self.use_incremental_score_calculator = use_incremental_score_calculator
+        self.use_greed_init = use_greed_init
+
+        pass
+
+    def build_cotwin(self, domain_model, is_already_initialized):
+
+        cotwin_model = CotScheduleCB()
+
+        cotwin_model.add_planning_entities_list(self._build_planning_processes(domain_model), "processes")
+        cotwin_model.add_problem_facts_list(self._build_problem_fact_computers(domain_model), "computers")
+
+        if self.use_incremental_score_calculator:
+            score_calculator = IncrementalScoreCalculatorCB()
+
+            #to avoid joining, fast get common info only
+            score_calculator.utility_objects["processes_info"] = self._build_processes_common_info(domain_model)
+            score_calculator.utility_objects["computers_info"] = self._build_computers_common_info(domain_model)
+            score_calculator.utility_objects["computers_costs"] = self._build_computers_costs(domain_model)
+        else:
+            score_calculator = PlainScoreCalculatorCB()
+
+        cotwin_model.set_score_calculator( score_calculator )
+
+        return cotwin_model
+    
+    def _build_planning_processes(self, domain_model):
+
+        cot_processes = []
+        n_computers = len(domain_model.computers)
+
+        if self.use_greed_init:
+            initial_computer_ids = self._build_greed_initial_computer_ids(domain_model)
+        else:
+            initial_computer_ids = n_computers * [None]
+
+
+        for i, process in enumerate(domain_model.processes):
+            cot_process = CotProcess(
+                process.process_id,
+                process.cpu_power_req,
+                process.memory_size_req,
+                process.network_bandwidth_req,
+                GJInteger(0, n_computers-1, False, initial_computer_ids[i])
+            )
+            cot_processes.append(cot_process)
+
+        return cot_processes
+    
+    def _build_greed_initial_computer_ids(self, domain_model):
+
+        processes_info = self._build_processes_common_info(domain_model)
+        computers_info = self._build_computers_common_info(domain_model)
+        n_processes = len(processes_info)
+        m_computers = len(computers_info)
+
+        initial_computer_ids = self._build_initial_ids(n_processes, m_computers, processes_info, computers_info)
+        initial_computer_ids = [int(initial_computer_ids[i]) if initial_computer_ids[i] >= 0 else None for i in range(len(initial_computer_ids))]
+
+        
+        return initial_computer_ids
+    
+    @staticmethod
+    @jit(nopython=True, cache=True)
+    def _build_initial_ids(n_processes, m_computers, processes_info, computers_info):
+        initial_computer_ids = np.zeros(n_processes, np.int64) - 1
+        current_consumed_resources = np.zeros(3, np.int64)
+        assigned_processes_index = [np.zeros(n_processes, np.int64) - 1 for i in range(m_computers)]
+        assigned_processes_counts = np.zeros(m_computers, np.int64)
+        for process_id in range(n_processes):
+            
+            acceptable_computer_id = None
+            for computer_id in range(m_computers):
+                current_consumed_resources = np.zeros(3, np.int64)
+                for i in range(assigned_processes_counts[computer_id]):
+                    current_consumed_resources += processes_info[assigned_processes_index[computer_id][i]]
+
+                current_consumed_resources += processes_info[process_id]
+                resource_deltas = current_consumed_resources - computers_info[computer_id]
+                resource_deltas = np.where(resource_deltas > 0, resource_deltas, 0)
+                resources_unacceptance = np.sum(resource_deltas)
+                if resources_unacceptance == 0:
+                    acceptable_computer_id = computer_id
+                    assigned_processes_index[computer_id][assigned_processes_counts[computer_id]] = process_id
+                    assigned_processes_counts[computer_id] += 1
+                    break
+
+            if acceptable_computer_id is not None:
+                initial_computer_ids[process_id] = acceptable_computer_id
+
+        return initial_computer_ids
+            
+
+    def _build_problem_fact_computers(self, domain_model):
+
+        cot_computers = [CotComputer.build_from_domain_computer(computer) for computer in domain_model.computers]
+
+        return cot_computers
+    
+    def _build_processes_common_info(self, domain_model):
+
+        n_processes = len(domain_model.processes)
+        m_info_fields = 3
+        processes_common_info = np.zeros((n_processes, m_info_fields), dtype=np.int64)
+        for i in range(n_processes):
+            processes_common_info[i][0] = domain_model.processes[i].cpu_power_req
+            processes_common_info[i][1] = domain_model.processes[i].memory_size_req
+            processes_common_info[i][2] = domain_model.processes[i].network_bandwidth_req
+        
+        return processes_common_info
+    
+
+    def _build_computers_common_info(self, domain_model):
+
+        n_computers = len(domain_model.computers)
+        m_info_fields = 3
+        computers_common_info = np.zeros((n_computers, m_info_fields), dtype=np.int64)
+        for i in range(n_computers):
+            computers_common_info[i][0] = domain_model.computers[i].cpu_power
+            computers_common_info[i][1] = domain_model.computers[i].memory_size
+            computers_common_info[i][2] = domain_model.computers[i].network_bandwidth
+        
+        return computers_common_info
+    
+    def _build_computers_costs(self, domain_model):
+        
+        # to avoid unnecessary slicing while constraints computation
+        n_computers = len(domain_model.computers)
+        computers_costs = np.zeros((n_computers), dtype=np.int64)
+        for i in range(n_computers):
+            computers_costs[i] = domain_model.computers[i].cost
+        
+        return computers_costs

examples/object_oriented/cloud_balancing/domain/ScheduleCB.py

@@ -0,0 +1,69 @@
+
+import json
+from greyjack.persistence.DomainBuilderBase import DomainBuilderBase
+from examples.object_oriented.cloud_balancing.domain.Process import Process
+from examples.object_oriented.cloud_balancing.domain.Computer import Computer
+from examples.object_oriented.cloud_balancing.domain.ScheduleCB import ScheduleCB
+
+class DomainBuilder(DomainBuilderBase):
+
+    def __init__(self, file_path):
+        
+        super().__init__()
+        self.file_path = file_path
+
+        pass
+
+    def build_domain_from_scratch(self):
+
+        with open(self.file_path, "r") as json_file:
+            readed_json = json.load(json_file)
+
+        computers = []
+        for cumputer_dict in readed_json["computerList"]:
+            current_computer = Computer(
+                cumputer_dict["id"],
+                cumputer_dict["cpuPower"],
+                cumputer_dict["memory"],
+                cumputer_dict["networkBandwidth"],
+                cumputer_dict["cost"],
+            )
+            computers.append(current_computer)
+        
+
+        processes = []
+        for process_dict in readed_json["processList"]:
+            current_process = Process(
+                process_dict["id"],
+                process_dict["requiredCpuPower"],
+                process_dict["requiredMemory"],
+                process_dict["requiredNetworkBandwidth"],
+                process_dict["computer"],
+            )
+            processes.append(current_process)
+        
+        domain_model = ScheduleCB(computers, processes)
+        
+        return domain_model
+
+    def build_from_solution(self, solution, initial_domain=None):
+
+        n_processes = len(solution.variable_values_dict.values())
+        process_assigned_computer_id_map = [-1 for i in range(n_processes)]
+        for assign_name in solution.variable_values_dict.keys():
+            computer_id = solution.variable_values_dict[assign_name]
+            process_id = int(assign_name.split("-->")[0].split(" ")[-1])
+            process_assigned_computer_id_map[process_id] = computer_id
+
+        if initial_domain is None:
+            domain_model = self.build_domain_from_scratch()
+        else:
+            domain_model = initial_domain
+
+        for i in range(n_processes):
+            domain_model.processes[i].computer_id = process_assigned_computer_id_map[i]
+
+        return domain_model
+    
+    def build_from_domain(self, domain):
+        return super().build_from_domain(domain)