Python-VirtualMachine/memory.py at main · Aurimukstis1/Python-VirtualMachine · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
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
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
import struct

class MemoryManagementUnit:
    FRAME_SIZE = 0x1000  # 4 KiB

    def __init__(self, memory_amount:int = 256*FRAME_SIZE):
        self.num_frames = memory_amount // self.FRAME_SIZE
        self.frames = [bytearray(self.FRAME_SIZE) for _ in range(self.num_frames)]
        self.free_frames = set(range(self.num_frames))

        print(f"{memory_amount} bytes of memory")
        print(f"{self.num_frames} frames of {self.FRAME_SIZE} bytes")

    # -------------------------
    #* Physical memory access
    # -------------------------

    def read_physical(self, frame, offset):
        return self.frames[frame][offset]

    def write_physical(self, frame, offset, value):
        self.frames[frame][offset] = value

    # -------------------------
    #* Frame allocation
    # -------------------------

    def allocate_frame(self):
        if not self.free_frames:
            raise Exception("MMU out of free physical memory!")
        return self.free_frames.pop()

    def free_frame(self, frame):
        self.free_frames.add(frame)

    # -------------------------
    #* Virtual memory functions
    # -------------------------

    def translate(self, process, virtual_address):
        page = virtual_address // self.FRAME_SIZE
        offset = virtual_address % self.FRAME_SIZE

        if page not in process.page_table:
            self.handle_page_fault(process, page)

        frame = process.page_table[page]
        return frame, offset

    def handle_page_fault(self, process, page):
        frame = self.allocate_frame()
        self.frames[frame][:] = bytes(self.FRAME_SIZE)
        process.page_table[page] = frame

    def read(self, process, virtual_address):
        frame, offset = self.translate(process, virtual_address)
        return self.read_physical(frame, offset)

    def write(self, process, virtual_address, value):
        frame, offset = self.translate(process, virtual_address)
        self.write_physical(frame, offset, value)

    def write_int(self, process, addr, value, size, signed):
        data = value.to_bytes(size, "little", signed=signed)
        for i, b in enumerate(data):
            self.write(process, addr + i, b)

    def read_int(self, process, addr, size, signed):
        data = bytes(self.read(process, addr + i) for i in range(size))
        return int.from_bytes(data, "little", signed=signed)

    """
    # 1 byte
    read_uint8 / write_uint8
    read_int8  / write_int8
    """

    def write_uint8(self, process, addr, value):
        self.write_int(process, addr, value, 1, signed=False)

    def read_uint8(self, process, addr):
        return self.read_int(process, addr, 1, signed=False)

    def write_int8(self, process, addr, value):
        self.write_int(process, addr, value, 1, signed=True)

    def read_int8(self, process, addr):
        return self.read_int(process, addr, 1, signed=True)

    """
    # 2 bytes
    read_uint16 / write_uint16
    read_int16  / write_int16
    """

    def write_uint16(self, process, addr, value):
        self.write_int(process, addr, value, 2, signed=False)

    def read_uint16(self, process, addr):
        return self.read_int(process, addr, 2, signed=False)

    def write_int16(self, process, addr, value):
        self.write_int(process, addr, value, 2, signed=True)

    def read_int16(self, process, addr):
        return self.read_int(process, addr, 2, signed=True)

    """
    # 4 bytes
    read_uint32 / write_uint32
    read_int32  / write_int32
    """

    def write_uint32(self, process, addr, value):
        self.write_int(process, addr, value, 4, signed=False)

    def read_uint32(self, process, addr):
        return self.read_int(process, addr, 4, signed=False)

    def write_int32(self, process, addr, value):
        self.write_int(process, addr, value, 4, signed=True)

    def read_int32(self, process, addr):
        return self.read_int(process, addr, 4, signed=True)

    """
    # 8 bytes
    read_uint64 / write_uint64
    read_int64  / write_int64
    """

    def write_uint64(self, process, addr, value):
        self.write_int(process, addr, value, 8, signed=False)

    def read_uint64(self, process, addr):
        return self.read_int(process, addr, 8, signed=False)

    def write_int64(self, process, addr, value):
        self.write_int(process, addr, value, 8, signed=True)

    def read_int64(self, process, addr):
        return self.read_int(process, addr, 8, signed=True)

    """
    FLOATS
    # 4 bytes
    read_float32 / write_float32
    """

    def write_float32(self, process, addr, value):
        data = struct.pack("<f", value)
        for i, b in enumerate(data):
            self.write(process, addr + i, b)

    def read_float32(self, process, addr):
        data = bytes(self.read(process, addr + i) for i in range(4))
        return struct.unpack("<f", data)[0]

    """
    # 8 bytes
    read_float64 / write_float64
    """

    def write_float64(self, process, addr, value):
        data = struct.pack("<d", value)
        for i, b in enumerate(data):
            self.write(process, addr + i, b)

    def read_float64(self, process, addr):
        data = bytes(self.read(process, addr + i) for i in range(8))
        return struct.unpack("<d", data)[0]