Skip to content

vHost

The vHost class is the implementation of simulated Host.

Bases: vHardwareEntity

Source code in PyCloudSim\entity\v_host.py 
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
class vHost(vHardwareEntity):
    def __init__(
        self,
        ipc: int | Callable[..., Any],
        frequency: int | Callable[..., Any],
        num_cores: int | Callable[..., Any],
        cpu_tdps: int | float | Callable[..., Any],
        cpu_mode: int,
        ram: int | Callable[..., Any],
        rom: int | Callable[..., Any],
        architecture: str = Constants.X86,
        label: str | None = None,
        create_at: int
        | float
        | Callable[..., int]
        | Callable[..., float]
        | None = None,
        terminate_at: int
        | float
        | Callable[..., int]
        | Callable[..., float]
        | None = None,
        precursor: Entity | List[Entity] | None = None,
    ) -> None:
        """Create a simulated host.

        Args:
            ipc (int | Callable[..., Any]): the instructions per cycle (IPC) of the CPU.
            frequency (int | Callable[..., Any]): the frequency of the CPU.
            num_cores (int | Callable[..., Any]): the number of cores of the CPU.
            cpu_tdps (int | float | Callable[..., Any]): the thermal design power (TDP) of the CPU.
            ram (int | Callable[..., Any]): the RAM capacity of the host, in GiB.
            rom (int | Callable[..., Any]): the ROm capacity of the host, in GiB.
            label (str | None, optional): the short name of the host. Defaults to None.
            create_at (int | float | Callable[..., Any] | None, optional): when this host should be created. Defaults to None.
            terminate_at (int | float | Callable[..., Any] | None, optional): when this host should be terminated. Defaults to None.
            precursor (Entity | List[Entity] | None, optional): the precursors that must be terminated before this host is created. Defaults to None.
        """
        super().__init__(
            ipc,
            frequency,
            num_cores,
            cpu_tdps,
            cpu_mode,
            ram,
            rom,
            architecture,
            label,
            create_at,
            terminate_at,
            precursor,
        )

        if callable(ram):
            self._ram_reservoir = Resource(
                capacity=GiB(round(ram())).bytes, label=f"{self} RAM Reservoir"
            )
        else:
            self._ram_reservoir = Resource(
                capacity=GiB(ram).bytes, label=f"{self} RAM Reservoir"
            )

        if callable(rom):
            self._rom_reservoir = Resource(
                capacity=GiB(round(rom())).bytes, label=f"{self} ROM Reservoir"
            )
        else:
            self._rom_reservoir = Resource(
                capacity=GiB(rom).bytes, label=f"{self} ROM Reservoir"
            )

        self._container_queue: List[vContainer] = EntityList(
            label=f"{self} Container Queue"
        )
        self._volume_queue: List[vVolume] = EntityList(label=f"{self} Volume Queue")

    def on_power_off(self) -> None:
        for container in self.container_queue:
            container.terminate(at=simulation.now)

    def allocate_container(self, container: vContainer) -> None:
        """Allocate a container to the host. This will start the creation of the container."""
        self._container_queue.append(container)
        container.get(self.cpu_reservoir, container.cpu)
        container.get(self.ram_reservoir, container.ram)
        container.get(self.rom_reservoir, container.image_size)
        container._host = self
        container.state.append(Constants.SCHEDULED)
        container.initiate(simulation.now)
        logger.info(
            f"{simulation.now}:\t{container} is allocated to {self}, available CPU {self.cpu_reservoir.utilization():.2f}% | RAM {self.ram_reservoir.utilization():.2f}% | ROM {self.rom_reservoir.utilization():.2f}%."
        )

    def allocate_volume(self, volume: vVolume) -> None:
        self._volume_queue.append(volume)
        volume.get(self.rom_reservoir, volume.size)
        volume._host = self
        volume.state.append(Constants.SCHEDULED)
        logger.info(
            f"{simulation.now}:\t{volume} is allocated to {self}, available ROM {self.rom_reservoir.utilization():.2f}%."
        )

    @property
    def cpu_reservoir(self):
        """Return the CPU reservoir, used in container allocation."""
        return self.cpu.computational_power_reservoir

    @property
    def ram_reservoir(self):
        """Return the RAM reservoir, used in container allocation."""
        return self._ram_reservoir

    @property
    def rom_reservoir(self):
        """Return the ROM reservoir, used in container allocation."""
        return self._rom_reservoir

    @property
    def container_queue(self):
        """Return the container queue, all the containers allocated on the host."""
        return self._container_queue

    @property
    def volume_queue(self):
        """Return the volume queue, all the volumes allocated on the host."""
        return self._volume_queue

    @property
    def ip_address(self):
        """Return the IP address of the host."""
        return [port.ip_address for port in self.NIC.ports]

container_queue property

Return the container queue, all the containers allocated on the host.

cpu_reservoir property

Return the CPU reservoir, used in container allocation.

ip_address property

Return the IP address of the host.

ram_reservoir property

Return the RAM reservoir, used in container allocation.

rom_reservoir property

Return the ROM reservoir, used in container allocation.

volume_queue property

Return the volume queue, all the volumes allocated on the host.

__init__(ipc, frequency, num_cores, cpu_tdps, cpu_mode, ram, rom, architecture=Constants.X86, label=None, create_at=None, terminate_at=None, precursor=None)

Create a simulated host.

Parameters:

Name Type Description Default
ipc int | Callable[..., Any]

the instructions per cycle (IPC) of the CPU.

 required
frequency int | Callable[..., Any]

the frequency of the CPU.

 required
num_cores int | Callable[..., Any]

the number of cores of the CPU.

 required
cpu_tdps int | float | Callable[..., Any]

the thermal design power (TDP) of the CPU.

 required
ram int | Callable[..., Any]

the RAM capacity of the host, in GiB.

 required
rom int | Callable[..., Any]

the ROm capacity of the host, in GiB.

 required
label str | None

the short name of the host. Defaults to None.

 None
create_at int | float | Callable[..., Any] | None

when this host should be created. Defaults to None.

 None
terminate_at int | float | Callable[..., Any] | None

when this host should be terminated. Defaults to None.

 None
precursor Entity | List[Entity] | None

the precursors that must be terminated before this host is created. Defaults to None.

 None
Source code in PyCloudSim\entity\v_host.py 
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
def __init__(
    self,
    ipc: int | Callable[..., Any],
    frequency: int | Callable[..., Any],
    num_cores: int | Callable[..., Any],
    cpu_tdps: int | float | Callable[..., Any],
    cpu_mode: int,
    ram: int | Callable[..., Any],
    rom: int | Callable[..., Any],
    architecture: str = Constants.X86,
    label: str | None = None,
    create_at: int
    | float
    | Callable[..., int]
    | Callable[..., float]
    | None = None,
    terminate_at: int
    | float
    | Callable[..., int]
    | Callable[..., float]
    | None = None,
    precursor: Entity | List[Entity] | None = None,
) -> None:
    """Create a simulated host.

    Args:
        ipc (int | Callable[..., Any]): the instructions per cycle (IPC) of the CPU.
        frequency (int | Callable[..., Any]): the frequency of the CPU.
        num_cores (int | Callable[..., Any]): the number of cores of the CPU.
        cpu_tdps (int | float | Callable[..., Any]): the thermal design power (TDP) of the CPU.
        ram (int | Callable[..., Any]): the RAM capacity of the host, in GiB.
        rom (int | Callable[..., Any]): the ROm capacity of the host, in GiB.
        label (str | None, optional): the short name of the host. Defaults to None.
        create_at (int | float | Callable[..., Any] | None, optional): when this host should be created. Defaults to None.
        terminate_at (int | float | Callable[..., Any] | None, optional): when this host should be terminated. Defaults to None.
        precursor (Entity | List[Entity] | None, optional): the precursors that must be terminated before this host is created. Defaults to None.
    """
    super().__init__(
        ipc,
        frequency,
        num_cores,
        cpu_tdps,
        cpu_mode,
        ram,
        rom,
        architecture,
        label,
        create_at,
        terminate_at,
        precursor,
    )

    if callable(ram):
        self._ram_reservoir = Resource(
            capacity=GiB(round(ram())).bytes, label=f"{self} RAM Reservoir"
        )
    else:
        self._ram_reservoir = Resource(
            capacity=GiB(ram).bytes, label=f"{self} RAM Reservoir"
        )

    if callable(rom):
        self._rom_reservoir = Resource(
            capacity=GiB(round(rom())).bytes, label=f"{self} ROM Reservoir"
        )
    else:
        self._rom_reservoir = Resource(
            capacity=GiB(rom).bytes, label=f"{self} ROM Reservoir"
        )

    self._container_queue: List[vContainer] = EntityList(
        label=f"{self} Container Queue"
    )
    self._volume_queue: List[vVolume] = EntityList(label=f"{self} Volume Queue")

allocate_container(container)

Allocate a container to the host. This will start the creation of the container.

Source code in PyCloudSim\entity\v_host.py 
104
105
106
107
108
109
110
111
112
113
114
115
def allocate_container(self, container: vContainer) -> None:
    """Allocate a container to the host. This will start the creation of the container."""
    self._container_queue.append(container)
    container.get(self.cpu_reservoir, container.cpu)
    container.get(self.ram_reservoir, container.ram)
    container.get(self.rom_reservoir, container.image_size)
    container._host = self
    container.state.append(Constants.SCHEDULED)
    container.initiate(simulation.now)
    logger.info(
        f"{simulation.now}:\t{container} is allocated to {self}, available CPU {self.cpu_reservoir.utilization():.2f}% | RAM {self.ram_reservoir.utilization():.2f}% | ROM {self.rom_reservoir.utilization():.2f}%."
    )