sonolus.py 0.1.2__tar.gz → 0.1.4__tar.gz

sonolus_py-0.1.4/.github/workflows/publish.yaml

@@ -0,0 +1,52 @@
+name: Publish to PyPI
+
+on: push
+
+jobs:
+  build:
+    name: Build
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      - name: Install uv
+        uses: astral-sh/setup-uv@v3
+        with:
+          version: 0.5.2
+      - name: Install Python
+        run: |
+          uv python install
+      - name: Install project
+        run: |
+          uv sync --all-extras --dev
+      - name: Run tests
+        run: |
+          uv run pytest tests -n auto
+      - name: Build
+        run: |
+          uv build
+      - name: Store distribution packages
+        uses: actions/upload-artifact@v4
+        with:
+          name: python-package-distributions
+          path: dist/
+  publish:
+    name: Publish
+    if: startsWith(github.ref, 'refs/tags/')
+    needs:
+      - build
+    runs-on: ubuntu-latest
+    environment:
+      name: pypi
+      url: https://pypi.org/project/sonolus.py
+    permissions:
+      id-token: write
+    steps:
+      - name: Download distribution packages
+        uses: actions/download-artifact@v4
+        with:
+          name: python-package-distributions
+          path: dist/
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

{sonolus_py-0.1.2 → sonolus_py-0.1.4}/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2024 Kyle Chang
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+MIT License
+
+Copyright (c) 2024 Kyle Chang
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

{sonolus_py-0.1.2 → sonolus_py-0.1.4}/PKG-INFO

@@ -1,8 +1,7 @@
 Metadata-Version: 2.3
 Name: sonolus.py
-Version: 0.1.2
+Version: 0.1.4
 Summary: Sonolus engine development in Python
-License-File: LICENSE
 Requires-Python: >=3.13
 Description-Content-Type: text/markdown
 

{sonolus_py-0.1.2 → sonolus_py-0.1.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sonolus.py"
-version = "0.1.2"
+version = "0.1.4"
 description = "Sonolus engine development in Python"
 readme = "README.md"
 requires-python = ">=3.13"

{sonolus_py-0.1.2 → sonolus_py-0.1.4}/scripts/generate.py

@@ -1,91 +1,91 @@
-import json
-from pathlib import Path
-from typing import TextIO
-
-functions_file = "Functions.json"
-block_files = {
-    "Tutorial": "Engine/Tutorial/Blocks.json",
-    "Play": "Level/Play/Blocks.json",
-    "Preview": "Level/Preview/Blocks.json",
-    "Watch": "Level/Watch/Blocks.json",
-}
-base_dir = Path(__file__).parent
-out_dir = base_dir / "out"
-runtimes_dir = base_dir / "runtimes"
-
-
-def functions():
-    with (
-        (runtimes_dir / functions_file).open("r", encoding="utf-8") as f,
-        (out_dir / "ops.py").open("w", encoding="utf-8") as out,
-    ):
-        data = json.load(f)
-        out.write(
-            "from enum import Enum\n"
-            "\n"
-            "\n"
-            "class Op(str, Enum):\n"
-            "    def __new__(cls, name: str, side_effects: bool, pure: bool, control_flow: bool):\n"
-            "        obj = str.__new__(cls, name)\n"
-            "        obj._value_ = name\n"
-            "        obj.side_effects = side_effects\n"
-            "        obj.pure = pure\n"
-            "        obj.control_flow = control_flow\n"
-            "        return obj\n"
-            "\n"
-        )
-        for function in data:
-            name = function["name"]
-            side_effects = function["sideEffects"]
-            pure = function["pure"]
-            control_flow = function["controlFlow"]
-            out.write(f'    {name} = ("{name}", {side_effects}, {pure}, {control_flow})\n')
-
-
-def block(name: str, f: TextIO, out: TextIO):
-    data = json.load(f)
-    out.write(f"class {name}Block(_Block, Enum):\n")
-    for block in data:
-        name = block["name"]
-        id_ = block["id"]
-        readable = block["readable"]
-        writable = block["writable"]
-        out.write(
-            f'    {name} = ({id_}, {{{
-            ", ".join(f'"{e}"' for e in readable)
-            }}}, {{{
-            ", ".join(f'"{e}"' for e in writable)
-            }}})\n'
-        )
-
-
-def blocks():
-    with (out_dir / "blocks.py").open("w", encoding="utf-8") as out:
-        out.write(
-            "from enum import Enum\n"
-            "\n"
-            "\n"
-            "class _Block(int):\n"
-            "    def __new__(cls, id_: int, readable: set[str], writable: set[str]):\n"
-            "        obj = int.__new__(cls, id_)\n"
-            "        obj.readable = readable\n"
-            "        obj.writable = writable\n"
-            "        return obj\n"
-        )
-        for name, file in block_files.items():
-            out.write("\n\n")
-            with (
-                (runtimes_dir / file).open("r", encoding="utf-8") as f,
-            ):
-                block(name, f, out)
-        out.write(f"\n" f"\n" f"type Block = {" | ".join(f'{name}Block' for name in block_files)}\n")
-
-
-def main():
-    out_dir.mkdir(exist_ok=True)
-    functions()
-    blocks()
-
-
-if __name__ == "__main__":
-    main()
+import json
+from pathlib import Path
+from typing import TextIO
+
+functions_file = "Functions.json"
+block_files = {
+    "Tutorial": "Engine/Tutorial/Blocks.json",
+    "Play": "Level/Play/Blocks.json",
+    "Preview": "Level/Preview/Blocks.json",
+    "Watch": "Level/Watch/Blocks.json",
+}
+base_dir = Path(__file__).parent
+out_dir = base_dir / "out"
+runtimes_dir = base_dir / "runtimes"
+
+
+def functions():
+    with (
+        (runtimes_dir / functions_file).open("r", encoding="utf-8") as f,
+        (out_dir / "ops.py").open("w", encoding="utf-8") as out,
+    ):
+        data = json.load(f)
+        out.write(
+            "from enum import Enum\n"
+            "\n"
+            "\n"
+            "class Op(str, Enum):\n"
+            "    def __new__(cls, name: str, side_effects: bool, pure: bool, control_flow: bool):\n"
+            "        obj = str.__new__(cls, name)\n"
+            "        obj._value_ = name\n"
+            "        obj.side_effects = side_effects\n"
+            "        obj.pure = pure\n"
+            "        obj.control_flow = control_flow\n"
+            "        return obj\n"
+            "\n"
+        )
+        for function in data:
+            name = function["name"]
+            side_effects = function["sideEffects"]
+            pure = function["pure"]
+            control_flow = function["controlFlow"]
+            out.write(f'    {name} = ("{name}", {side_effects}, {pure}, {control_flow})\n')
+
+
+def block(name: str, f: TextIO, out: TextIO):
+    data = json.load(f)
+    out.write(f"class {name}Block(_Block, Enum):\n")
+    for block in data:
+        name = block["name"]
+        id_ = block["id"]
+        readable = block["readable"]
+        writable = block["writable"]
+        out.write(
+            f'    {name} = ({id_}, {{{
+            ", ".join(f'"{e}"' for e in readable)
+            }}}, {{{
+            ", ".join(f'"{e}"' for e in writable)
+            }}})\n'
+        )
+
+
+def blocks():
+    with (out_dir / "blocks.py").open("w", encoding="utf-8") as out:
+        out.write(
+            "from enum import Enum\n"
+            "\n"
+            "\n"
+            "class _Block(int):\n"
+            "    def __new__(cls, id_: int, readable: set[str], writable: set[str]):\n"
+            "        obj = int.__new__(cls, id_)\n"
+            "        obj.readable = readable\n"
+            "        obj.writable = writable\n"
+            "        return obj\n"
+        )
+        for name, file in block_files.items():
+            out.write("\n\n")
+            with (
+                (runtimes_dir / file).open("r", encoding="utf-8") as f,
+            ):
+                block(name, f, out)
+        out.write(f"\n" f"\n" f"type Block = {" | ".join(f'{name}Block' for name in block_files)}\n")
+
+
+def main():
+    out_dir.mkdir(exist_ok=True)
+    functions()
+    blocks()
+
+
+if __name__ == "__main__":
+    main()

sonolus_py-0.1.4/sonolus/backend/allocate.py

@@ -0,0 +1,125 @@
+from sonolus.backend.flow import BasicBlock, traverse_cfg_preorder
+from sonolus.backend.ir import IRConst, IRGet, IRInstr, IRPureInstr, IRSet
+from sonolus.backend.liveness import LivenessAnalysis, get_live
+from sonolus.backend.passes import CompilerPass
+from sonolus.backend.place import BlockPlace, TempBlock
+
+TEMP_SIZE = 4096
+
+
+class AllocateBasic(CompilerPass):
+    """Allocate temporary memory for temporary variables without considering lifetimes."""
+
+    def run(self, entry: BasicBlock):
+        offsets = {}
+        index = 0
+
+        def process(stmt):
+            nonlocal index
+            match stmt:
+                case int():
+                    return stmt
+                case IRConst():
+                    return stmt
+                case IRPureInstr(op=op, args=args):
+                    return IRPureInstr(
+                        op=op,
+                        args=[process(arg) for arg in args],
+                    )
+                case IRInstr(op=op, args=args):
+                    return IRInstr(
+                        op=op,
+                        args=[process(arg) for arg in args],
+                    )
+                case IRGet(place=place):
+                    return IRGet(place=process(place))
+                case IRSet(place=place, value=value):
+                    return IRSet(place=process(place), value=process(value))
+                case BlockPlace() as place:
+                    if isinstance(place.block, TempBlock):
+                        if place.block not in offsets:
+                            offsets[place.block] = index
+                            index += place.block.size
+                            if index >= TEMP_SIZE:
+                                raise ValueError("Temporary memory limit exceeded")
+                        return BlockPlace(10000, process(place.index), place.offset + offsets[place.block])
+                    return BlockPlace(
+                        process(place.block) if isinstance(place.block, BlockPlace) else place.block,
+                        process(place.index),
+                        process(place.offset),
+                    )
+                case _:
+                    raise TypeError(f"Unsupported statement: {stmt}")
+
+        for block in traverse_cfg_preorder(entry):
+            block.statements = [process(statement) for statement in block.statements]
+            block.test = process(block.test)
+
+        return entry
+
+
+class Allocate(CompilerPass):
+    def requires(self) -> set[CompilerPass]:
+        return {LivenessAnalysis()}
+
+    def run(self, entry: BasicBlock):
+        mapping = self.get_mapping(entry)
+        for block in traverse_cfg_preorder(entry):
+            block.statements = [self.update_stmt(statement, mapping) for statement in block.statements]
+            block.test = self.update_stmt(block.test, mapping)
+        return entry
+
+    def update_stmt(self, stmt, mapping: dict[TempBlock, int]):
+        match stmt:
+            case int() | float() | IRConst():
+                return stmt
+            case IRInstr(op=op, args=args):
+                return IRInstr(op=op, args=[self.update_stmt(arg, mapping) for arg in args])
+            case IRPureInstr(op=op, args=args):
+                return IRPureInstr(op=op, args=[self.update_stmt(arg, mapping) for arg in args])
+            case IRGet(place=place):
+                return IRGet(place=self.update_stmt(place, mapping))
+            case IRSet(place=place, value=value):
+                return IRSet(place=self.update_stmt(place, mapping), value=self.update_stmt(value, mapping))
+            case BlockPlace(block=block, index=index, offset=offset):
+                if isinstance(block, TempBlock):
+                    if block.size == 0:
+                        offset = -1
+                    else:
+                        offset = mapping[block] + offset
+                    return BlockPlace(block=10000, index=self.update_stmt(index, mapping), offset=offset)
+                return BlockPlace(
+                    block=self.update_stmt(block, mapping),
+                    index=self.update_stmt(index, mapping),
+                    offset=self.update_stmt(offset, mapping),
+                )
+            case _:
+                raise TypeError(f"Unsupported statement: {stmt}")
+
+    def get_mapping(self, entry: BasicBlock) -> dict[TempBlock, int]:
+        interference = self.get_interference(entry)
+        offsets: dict[TempBlock, int] = {}
+
+        for block, others in sorted(interference.items(), key=lambda x: -x[0].size):
+            size = block.size
+            offset = 0
+            for other in sorted(others, key=lambda x: offsets.get(x, 0) + x.size):
+                if other not in offsets:
+                    continue
+                other_offset = offsets[other]
+                if offset + size > other_offset or other_offset + other.size > offset:
+                    offset = other_offset + other.size
+            if offset + size > TEMP_SIZE:
+                raise ValueError("Temporary memory limit exceeded")
+            offsets[block] = offset
+
+        return offsets
+
+    def get_interference(self, entry: BasicBlock) -> dict[TempBlock, set[TempBlock]]:
+        result = {}
+        for block in traverse_cfg_preorder(entry):
+            for stmt in [*block.statements, block.test]:
+                live = {p for p in get_live(stmt) if isinstance(p, TempBlock) and p.size > 0}
+                for place in live:
+                    result.setdefault(place, set()).update(live - {place})
+        return result