flummi 0.1.0__py3-none-any.whl

flummi/IR/AST.py

@@ -0,0 +1,111 @@
+from abc import ABC
+from dataclasses import dataclass
+
+from .common import (
+    Expression,
+    Label,
+    Located,
+    Type,
+    Variable,
+)
+from .common import (
+    Program as BaseProgram,
+)
+
+__all__ = (
+    "Assignment",
+    "Block",
+    "Break",
+    "Conditional",
+    "Continue",
+    "Declaration",
+    "Emit",
+    "Expression",
+    "Fork",
+    "Gather",
+    "Label",
+    "Loop",
+    "NoOp",
+    "Program",
+    "Statement",
+    "Stop",
+    "Sync",
+    "Type",
+    "Variable",
+)
+
+
+class Statement(Located, ABC): ...
+
+
+@dataclass
+class Declaration(Statement):
+    variable: Variable
+    type: Type
+
+
+@dataclass
+class Block(Statement):
+    statements: list[Statement]
+
+
+@dataclass
+class Assignment(Statement):
+    variable: Variable
+    expression: Expression
+
+
+@dataclass
+class Emit(Statement):
+    variable: Variable
+
+
+@dataclass
+class Stop(Statement): ...
+
+
+@dataclass
+class NoOp(Statement): ...
+
+
+@dataclass
+class Conditional(Statement):
+    condition: Variable
+    true_branch: Statement
+    false_branch: Statement
+
+
+@dataclass
+class Loop(Statement):
+    label: Label
+    body: Statement
+
+
+@dataclass
+class Continue(Statement):
+    label: Label
+
+
+@dataclass
+class Break(Statement):
+    label: Label
+
+
+@dataclass
+class Fork(Statement):
+    variables: list[Variable]
+    expression: Expression
+
+
+@dataclass
+class Gather(Statement):
+    aggregates: dict[Variable, Expression]
+    keys: list[Variable]
+
+
+@dataclass
+class Sync(Statement):
+    keys: list[Variable]
+
+
+Program = BaseProgram[Statement]

flummi/IR/CFP.py

@@ -0,0 +1,94 @@
+from abc import ABC
+from dataclasses import dataclass
+
+from ..library import graph
+from .common import Expression, Label, Located, Variable
+from .common import Program as BaseProgram
+
+__all__ = (
+    "Assignment",
+    "Emit",
+    "Expression",
+    "Fork",
+    "Gather",
+    "Jump",
+    "IsSynced",
+    "Label",
+    "Label",
+    "Merge",
+    "Plan",
+    "Primitive",
+    "Program",
+    "Start",
+    "Stop",
+    "Variable",
+    "Where",
+)
+
+
+@dataclass
+class Plan(Located):
+    entry_label: Label
+    primitives: dict[Label, Primitive]
+    successors_of: graph.Graph[Label]
+    virtual_successors_of: graph.Graph[Label]
+
+
+@dataclass
+class Primitive(Located, ABC): ...
+
+
+@dataclass
+class Start(Primitive): ...
+
+
+@dataclass
+class Stop(Primitive): ...
+
+
+@dataclass
+class Assignment(Primitive):
+    variable: Variable
+    expression: Expression
+
+
+@dataclass
+class Emit(Primitive):
+    variable: Variable
+
+
+@dataclass
+class Where(Primitive):
+    condition: Variable
+    inverted: bool
+
+
+@dataclass
+class Merge(Primitive): ...
+
+
+@dataclass
+class Jump(Primitive):
+    label: Label
+
+
+@dataclass
+class Fork(Primitive):
+    variables: list[Variable]
+    expression: Expression
+
+
+@dataclass
+class Gather(Primitive):
+    aggregates: dict[Variable, Expression]
+    keys: list[Variable]
+
+
+@dataclass
+class IsSynced(Primitive):
+    variable: Variable
+    label: Label
+    keys: list[Variable]
+
+
+Program = BaseProgram[Plan]

flummi/IR/common.py

@@ -0,0 +1,43 @@
+from dataclasses import dataclass, field
+
+from ..library.errors import Location
+
+__all__ = (
+    "Expression",
+    "Identifier",
+    "Label",
+    "Located",
+    "Program",
+    "Type",
+    "Variable",
+)
+
+
+@dataclass(kw_only=True, match_args=False, slots=True)
+class Located:
+    location: Location = field(hash=False, compare=False, repr=False)
+
+
+@dataclass(unsafe_hash=True, order=True, slots=True)
+class Identifier(Located):
+    identifier: str
+
+
+Variable = Identifier
+Label = Identifier
+
+
+@dataclass(slots=True)
+class Expression(Located):
+    source: str
+    arguments: list[Variable]
+
+
+@dataclass(unsafe_hash=True, order=True, slots=True)
+class Type(Located):
+    source: str
+
+
+@dataclass(slots=True)
+class Program[B](Located):
+    body: B

flummi/IR/pretty/pretty.py

@@ -0,0 +1,28 @@
+from textwrap import dedent
+
+from .. import CFP
+from ...library import utils
+
+
+def pretty(primitive: CFP.Primitive) -> str:
+    match primitive:
+        case CFP.Emit(variable):
+            return f"EMIT {variable.identifier}"
+
+        case CFP.Assignment(variable, expression):
+            this = f"LET {variable.identifier} = "
+            this += utils.indent1(
+                dedent(
+                    expression.source.format(
+                        *(
+                            f"{{{argument.identifier}}}"
+                            for argument in expression.arguments
+                        )
+                    )
+                ),
+                " " * len(this),
+            )
+            return this
+
+        case _:
+            return type(primitive).__name__.upper()

flummi/IR/pretty/render.py

@@ -0,0 +1,68 @@
+from .. import CFP
+from .pretty import pretty
+
+
+__all__ = ("render",)
+
+
+PRORGAM_TEMPLATE = """\
+digraph "program" {{
+node [
+    shape = Mrecord,
+    nojustify = true,
+    fontname = "{font}",
+];
+graph [
+    fontname = "{font}",
+];
+edge [
+    fontname = "{font}",
+];
+{nodes}
+{edges}
+}}
+"""
+
+NODE_TEMPLATE = '"{label}" [label="{body}",{style}];'
+
+NODE_STYLES: dict[type[CFP.Primitive], str] = {
+    CFP.Assignment: "style = filled, fillcolor = royalblue, color = white, fontcolor = white",
+    CFP.Emit: "style = filled, fillcolor = navy, color = white, fontcolor = white",
+}
+
+
+def render[A](graph: CFP.Plan, *, font: str = "monospace") -> str:
+    nodes = (
+        NODE_TEMPLATE.format(
+            label=label.identifier,
+            body=(
+                f"{{{
+                    pretty(node)
+                    .replace('\n', '\\l')
+                    .replace('|', '\\|')
+                    .replace(' ', '\\ ')
+                    .replace('{', '\\{')
+                    .replace('}', '\\}')
+                    .replace('<', '\\<')
+                    .replace('>', '\\>')
+                    .replace('"', '\\"')
+                }\\l|{{{label.identifier}\\l|@{label.location.column}:{
+                    label.location.line
+                }}}}}"
+            ),
+            style=NODE_STYLES.get(type(node), ""),
+        )
+        for label, node in graph.primitives.items()
+    )
+
+    edges: list[str] = []
+
+    edges.extend(
+        f'"{source.identifier}":s -> "{target.identifier}":n;'
+        for source, targets in graph.successors_of.items()
+        for target in targets
+    )
+
+    return PRORGAM_TEMPLATE.format(
+        nodes="\n".join(nodes), edges="\n".join(edges), font=font
+    )

flummi/__init__.py

@@ -0,0 +1,3 @@
+from .compiler import compile
+
+__all__ = ("compile",)

flummi/cli.py

@@ -0,0 +1,91 @@
+import subprocess
+import sys
+from pathlib import Path
+from typing import Annotated
+
+import typer
+
+from .compiler.allocation import allocate
+from .compiler.analysis import analyze
+from .compiler.generation import generate
+from .compiler.lowering import lower
+from .compiler.parsing import parse
+from .compiler.solving import solve
+from .IR.CFP import Plan
+from .IR.pretty.render import render
+from .library.errors import PrettyError
+
+__all__ = ("cli",)
+
+cli = typer.Typer()
+
+
+@cli.command("compile")
+def compile(
+    input: Annotated[
+        Path,
+        typer.Argument(
+            dir_okay=False,
+            file_okay=True,
+            readable=True,
+            exists=True,
+            help="The file to compile.",
+        ),
+    ],
+    output: Annotated[
+        Path | None,
+        typer.Argument(
+            dir_okay=False,
+            file_okay=True,
+            writable=True,
+            help="The path to write the compiled query to.",
+        ),
+    ] = None,
+    graph: Annotated[
+        Path | None,
+        typer.Option(
+            dir_okay=False,
+            file_okay=True,
+            writable=True,
+            help="File to render CFP to.",
+        ),
+    ] = None,
+    dot: Annotated[
+        str, typer.Option(help="GraphVis dot-command to use for rendering.")
+    ] = "dot",
+):
+    with open(input, "r") as f:
+        source = f.read()
+
+    try:
+        program = parse(source)
+
+        analysis = analyze(program)
+
+        lowered_program = lower(program)
+
+        if graph is not None:
+            render_to_file(lowered_program.body, graph, dot)
+
+        dataflow = solve(lowered_program, analysis)
+
+        allocation = allocate(lowered_program, analysis, dataflow)
+
+        sql = generate(lowered_program, analysis, dataflow, allocation)
+
+    except PrettyError as e:
+        print(e.format(source), file=sys.stderr)
+        sys.exit(1)
+
+    if output:
+        with open(output, "w+") as f:
+            _ = f.write(sql)
+    else:
+        print(sql)
+
+
+def render_to_file(graph: Plan, path: Path, command: str = "dot"):
+    _ = subprocess.run(
+        args=[command, "-T", path.suffix[1:] or "png", "-o", path.absolute()],
+        input=render(graph).encode(),
+    )

flummi/compiler/__init__.py

@@ -0,0 +1,26 @@
+from ..library.sql import SQL
+
+from .parsing import parse
+from .analysis import analyze
+from .lowering import lower
+from .solving import solve
+from .allocation import allocate
+from .generation import generate
+
+__all__ = ("compile",)
+
+
+def compile(source: str) -> SQL:
+    program = parse(source)
+
+    analysis = analyze(program)
+
+    lowered_program = lower(program)
+
+    dataflow = solve(lowered_program, analysis)
+
+    allocation = allocate(lowered_program, analysis, dataflow)
+
+    sql = generate(lowered_program, analysis, dataflow, allocation)
+
+    return sql

flummi/compiler/allocation.py

@@ -0,0 +1,155 @@
+from collections import defaultdict
+from dataclasses import dataclass, field
+
+from ..IR.CFP import (
+    Label,
+    Program,
+    Start,
+    Variable,
+)
+from ..IR.common import Type
+from ..library import utils
+from .analysis import AnalysisResult
+from .names import PROGRAM_VARIABLE, SystemVariable
+from .solving import DataflowResult
+
+__all__ = ("allocate",)
+
+
+type Column = str
+type Schema = dict[Column, Type]
+
+type PerLabel[T] = dict[Label, T]
+
+
+@dataclass(slots=True)
+class Allocation:
+    _variable_allocation: dict[Variable, Column]
+    _column_allocation: dict[Column, Variable] = field(init=False)
+
+    def __post_init__(self):
+        self._column_allocation = {
+            column: variable
+            for variable, column in self._variable_allocation.items()
+        }
+
+    def column_for(self, variable: Variable) -> Column | None:
+        return self._variable_allocation.get(variable)
+
+    def variable_at(self, column: Column) -> Variable | None:
+        return self._column_allocation.get(column)
+
+
+@dataclass(frozen=True, slots=True)
+class AllocationResult:
+    schema: Schema
+    at: PerLabel[Allocation]
+
+
+def allocate(
+    program: Program,
+    analysis: AnalysisResult,
+    data_flow: DataflowResult,
+    naive: bool = True,
+) -> AllocationResult:
+    labels_to_allocate: list[Label] = [
+        label
+        for label, primitive in program.body.primitives.items()
+        if isinstance(primitive, Start)
+    ]
+
+    SYSTEM_SCHEMA = {
+        variable.identifier: analysis.symbol_table[variable]
+        for variable in analysis.system_variables.values()
+        if variable.identifier != SystemVariable.CONTROL
+    }
+
+    if naive:
+        schema = SYSTEM_SCHEMA
+        allocations = {}
+        for label in labels_to_allocate:
+            schema |= {
+                input.identifier: analysis.symbol_table[input]
+                for input in data_flow.inputs_of[label]
+            }
+            allocations[label] = Allocation(
+                {
+                    analysis.system_variables[
+                        SystemVariable.LABEL
+                    ]: SystemVariable.LABEL,
+                }
+                | {
+                    input: input.identifier
+                    for input in data_flow.inputs_of[label]
+                }
+            )
+
+        return AllocationResult(schema, allocations)
+
+    # First, collect all "type siblings", i.e., groupings of like typed
+    # variables, at each label we wish to perform column allocation for.
+    # Since we are only looking at nodes containing start primitives, we
+    # compute these type siblings over the inputs of the nodes. In addition
+    # to the sets of type siblings themselves, we also collect the maximum
+    # cardinality of them by type.
+
+    type_siblings_at: PerLabel[dict[Type, list[Variable]]] = defaultdict(
+        lambda: defaultdict(list)
+    )
+    max_type_counts: dict[Type, int] = defaultdict(int)
+
+    for label in labels_to_allocate:
+        for type, variables in utils.groupby(
+            iter(
+                data_flow.inputs_of[label]
+                - set(analysis.system_variables.values())
+            ),
+            lambda variable: analysis.symbol_table[variable],
+        ):
+            variables = list(variables)
+            type_siblings_at[label][type] = variables
+            count = len(variables)
+            if count > max_type_counts[type]:
+                max_type_counts[type] = count
+
+    # Second, we compute the schema of the working table in two parts. The
+    # first part simply contains the system columns, e.g. the column for
+    # goto targets, the one for program results etc. The second part,
+    # contains the program columns, i.e., this set contains just enough
+    # columns of each type, such that all sets of type siblings computed
+    # above are covered.
+
+    schema: Schema = dict(SYSTEM_SCHEMA)
+    offset: int = 0
+    offset_of: dict[Type, int] = {}
+    for type, count in max_type_counts.items():
+        offset_of[type] = offset
+        schema.update(
+            {
+                PROGRAM_VARIABLE.format(idx=offset + i): type
+                for i in range(count)
+            }
+        )
+        offset += count
+
+    # Lastly, we compute the allocations for each label based on the schema
+    # we determined above. (The reverse mappings are generated automatically
+    # elsewhere, thus we can focus on simply computing on direction here.)
+
+    allocations: dict[Label, Allocation] = {
+        label: Allocation(
+            {
+                analysis.system_variables[
+                    SystemVariable.LABEL
+                ]: SystemVariable.LABEL,
+            }
+            | {
+                variable: PROGRAM_VARIABLE.format(idx=offset_of[type] + i)
+                for type, variables in type_siblings_at.get(label, {}).items()
+                for i, variable in enumerate(variables)
+            }
+        )
+        for label in labels_to_allocate
+    }
+
+    return AllocationResult(schema, allocations)