ninetoothed 0.7.0__py3-none-any.whl → 0.9.0__py3-none-any.whl

ninetoothed/__init__.py

@@ -1,5 +1,5 @@
-from ninetoothed.jit import jit
+from ninetoothed.jit import jit, make
 from ninetoothed.symbol import Symbol
 from ninetoothed.tensor import Tensor
 
-__all__ = ["Symbol", "Tensor", "jit"]
+__all__ = ["Symbol", "Tensor", "jit", "make"]

ninetoothed/jit.py

@@ -1,5 +1,6 @@
 import ast
 import collections
+import copy
 import functools
 import importlib.util
 import inspect
@@ -18,6 +19,15 @@ from ninetoothed.tensor import Tensor
 from ninetoothed.torchifier import Torchifier
 
 
+def make(arrangement, application, tensors):
+    params = inspect.signature(application).parameters
+    types = arrangement(*tensors)
+    annotations = {param: type for param, type in zip(params, types)}
+    application.__annotations__ = annotations
+
+    return jit(application)
+
+
 def jit(_func=None, *, _prettify=False):
     def wrapper(func):
         return JIT(func, _prettify=_prettify)()
@@ -29,23 +39,12 @@ def jit(_func=None, *, _prettify=False):
 
 
 class JIT:
-    handles = collections.defaultdict(dict)
-
     def __init__(self, func, _prettify=False):
         self.func = func
 
         self._prettify = _prettify
 
     def __call__(self):
-        source_file = inspect.getsourcefile(self.func)
-        source_line = inspect.getsourcelines(self.func)[1]
-
-        if (
-            source_file in type(self).handles
-            and source_line in type(self).handles[source_file]
-        ):
-            return type(self).handles[source_file][source_line]
-
         tree = self._get_tree()
 
         CodeGenerator(inspect.get_annotations(self.func)).visit(tree)
@@ -83,8 +82,6 @@ class JIT:
             source,
         )
 
-        type(self).handles[source_file][source_line] = handle
-
         return handle
 
     def _get_tree(self):
@@ -141,30 +138,12 @@ class CodeGenerator(ast.NodeTransformer):
     def visit_FunctionDef(self, node):
         self._func_def = node
 
-        self.generic_visit(node)
-
-        for arg in self._args:
-            if not isinstance(arg, Tensor) or arg.ndim == 0:
-                continue
-
-            offsets = arg.offsets()
+        self._invariants = {}
 
-            initializations = {
-                type(self)._name_for_offsets(arg, dim): offs
-                for dim, offs in enumerate(offsets)
-            } | {
-                type(self)._name_for_pointers(arg): arg.original.pointer_string()
-                + sum(
-                    type(self)._name_for_offsets(arg, dim)[
-                        type(self)._generate_slices(arg, dim)
-                    ]
-                    * stride
-                    for dim, stride in enumerate(arg.original.strides)
-                )
-            }
+        self.generic_visit(node)
 
-            for target, value in reversed(initializations.items()):
-                node.body.insert(0, ast.Assign(targets=[target.node], value=value.node))
+        for target, value in reversed(self._invariants.items()):
+            node.body.insert(0, ast.Assign(targets=[target.node], value=value.node))
 
         return node
 
@@ -192,24 +171,20 @@ class CodeGenerator(ast.NodeTransformer):
         ]
 
         autotune = self._generate_autotune(non_meta_names, meta_names)
-        self._func_def.decorator_list.insert(0, autotune)
+        self._func_def.decorator_list = [autotune, Symbol("triton.jit").node]
 
         self._launch = self._generate_launch(non_meta_names, meta_names)
 
         return node
 
     def visit_Subscript(self, node):
-        if (
-            isinstance(node.value, ast.Name)
-            and node.value.id in self._context
-            and isinstance(node.ctx, ast.Load)
-        ):
+        if self._in_context(node.value) and isinstance(node.ctx, ast.Load):
             value = self._context[node.value.id]
 
             if isinstance(value, Tensor):
-                return type(self)._generate_load(
+                return self._generate_load(
                     value,
-                    intermediate_indices=node.slice.elts
+                    indices=node.slice.elts
                     if isinstance(node.slice, ast.Tuple)
                     else (node.slice,),
                 )
@@ -219,7 +194,7 @@ class CodeGenerator(ast.NodeTransformer):
         return node
 
     def visit_Attribute(self, node):
-        if isinstance(node.value, ast.Name) and node.value.id in self._context:
+        if self._in_context(node.value):
             value = self._context[node.value.id]
 
             if isinstance(value, Tensor):
@@ -234,8 +209,8 @@ class CodeGenerator(ast.NodeTransformer):
     def visit_Name(self, node):
         self.generic_visit(node)
 
-        if node.id in self._context and isinstance(node.ctx, ast.Load):
-            return type(self)._generate_load(self._context[node.id])
+        if self._in_context(node) and isinstance(node.ctx, ast.Load):
+            return self._generate_load(self._context[node.id])
 
         return node
 
@@ -243,16 +218,15 @@ class CodeGenerator(ast.NodeTransformer):
         if len(node.targets) == 1:
             target = node.targets[0]
 
-            if isinstance(target, ast.Name) and target.id in self._context:
+            if self._in_context(target):
                 self.generic_visit(node)
 
                 return ast.Expr(
-                    type(self)._generate_store(self._context[target.id], node.value)
+                    self._generate_store(self._context[target.id], node.value)
                 )
             elif (
                 isinstance(target, ast.Subscript)
-                and isinstance(target.value, ast.Name)
-                and target.value.id in self._context
+                and self._in_context(target.value)
                 and isinstance(target.ctx, ast.Store)
             ):
                 value = self._context[target.value.id]
@@ -261,10 +235,10 @@ class CodeGenerator(ast.NodeTransformer):
                     self.generic_visit(node)
 
                     return ast.Expr(
-                        type(self)._generate_store(
+                        self._generate_store(
                             value,
                             node.value,
-                            intermediate_indices=target.slice.elts
+                            indices=target.slice.elts
                             if isinstance(target.slice, ast.Tuple)
                             else (target.slice,),
                         )
@@ -274,6 +248,11 @@ class CodeGenerator(ast.NodeTransformer):
 
         return node
 
+    _NAME_FOR_PID = Symbol("ninetoothed_pid")
+
+    def _in_context(self, node):
+        return isinstance(node, ast.Name) and node.id in self._context
+
     def _generate_autotune(self, params, meta):
         device = triton.runtime.driver.active.get_current_device()
         properties = triton.runtime.driver.active.utils.get_device_properties(device)
@@ -354,10 +333,11 @@ class CodeGenerator(ast.NodeTransformer):
             name=f"launch_{self._func_def.name}",
             args=ast.arguments(
                 posonlyargs=[],
-                args=[ast.arg(arg=arg.original.name) for arg in self._args]
+                args=[ast.arg(arg=arg.source.name) for arg in self._args]
                 + [
                     ast.arg(arg=param)
                     for param in non_next_power_of_2_constexpr_params_without_prefixes
+                    if not Tensor.size_pattern().fullmatch(param)
                 ],
                 kwonlyargs=[],
                 defaults=[],
@@ -427,51 +407,105 @@ class CodeGenerator(ast.NodeTransformer):
 
         return ast.parse(f"lambda meta: ({num_elements},)", mode="eval").body
 
-    @staticmethod
-    def _generate_load(tensor, intermediate_indices=()):
+    def _generate_load(self, tensor, indices=()):
         if tensor.ndim == 0:
-            return Symbol(tensor.original.name).node
+            return Symbol(tensor.source.name).node
 
-        pointers, mask = CodeGenerator._generate_pointers_and_mask(
-            tensor, intermediate_indices
-        )
-        other = CodeGenerator._generate_other(tensor)
+        pointers, mask = self._generate_pointers_and_mask(tensor, indices)
+        other = type(self)._generate_other(tensor)
 
         return call("load", pointers, mask=mask, other=other).node
 
-    @staticmethod
-    def _generate_store(tensor, value, intermediate_indices=()):
-        pointers, mask = CodeGenerator._generate_pointers_and_mask(
-            tensor, intermediate_indices
-        )
+    def _generate_store(self, tensor, value, indices=()):
+        pointers, mask = self._generate_pointers_and_mask(tensor, indices)
 
         return call("store", pointers, value, mask=mask).node
 
-    @staticmethod
-    def _generate_pointers_and_mask(tensor, intermediate_indices):
-        intermediate_offsets = CodeGenerator._generate_intermediate_offsets(
-            tensor, intermediate_indices
-        )
-        offsets = [
-            CodeGenerator._name_for_offsets(tensor, dim) + intermediate_offsets[dim]
-            for dim in range(tensor.original.ndim)
-        ]
-        pointers = CodeGenerator._name_for_pointers(tensor) + sum(
-            map(lambda x, y: x * y, intermediate_offsets, tensor.original.strides)
+    def _generate_pointers_and_mask(self, tensor, indices):
+        invariant_target_dims = type(self)._find_invariant_target_dims(tensor)
+
+        indices = self._complete_indices(tensor, indices)
+        offsets = type(self)._generate_offsets(tensor, indices)
+
+        for source_dim in range(tensor.source.ndim):
+            for target_dim in range(tensor.target.ndim):
+                if target_dim not in invariant_target_dims:
+                    continue
+
+                name = type(self)._name_for_offsets(tensor, source_dim, target_dim)
+                self._invariants[name] = offsets[source_dim][target_dim]
+                offsets[source_dim][target_dim] = name
+
+        name_for_pointers = type(self)._name_for_pointers(tensor)
+        self._invariants[name_for_pointers] = Symbol(tensor.source.pointer_string())
+
+        for source_dim in range(tensor.source.ndim):
+            for target_dim in range(tensor.target.ndim):
+                if target_dim not in invariant_target_dims:
+                    continue
+
+                self._invariants[name_for_pointers] += (
+                    offsets[source_dim][target_dim][
+                        type(self)._generate_slices(tensor, target_dim)
+                    ]
+                    * tensor.source.strides[source_dim]
+                )
+
+        pointers = name_for_pointers + sum(
+            offsets[source_dim][target_dim][
+                type(self)._generate_slices(tensor, target_dim)
+            ]
+            * tensor.source.strides[source_dim]
+            for source_dim in range(tensor.source.ndim)
+            for target_dim in range(tensor.target.ndim)
+            if target_dim not in invariant_target_dims
+            and offsets[source_dim][target_dim] != 0
         )
         mask = functools.reduce(
             lambda x, y: x & y,
             (
-                offs[CodeGenerator._generate_slices(tensor, dim)] < size
-                for dim, (offs, size) in enumerate(zip(offsets, tensor.original.shape))
+                offsets[source_dim][target_dim][
+                    type(self)._generate_slices(tensor, target_dim)
+                ]
+                < tensor.source.shape[source_dim]
+                for source_dim in range(tensor.source.ndim)
+                for target_dim in range(tensor.target.ndim)
+                if offsets[source_dim][target_dim] != 0
             ),
         )
 
         return pointers, mask
 
+    def _complete_indices(self, tensor, indices):
+        indices = list(self._generate_pid_indices(tensor) + tuple(indices))
+
+        for size in tensor.inmost().shape:
+            if Symbol.is_name(size):
+                name = size.node.id
+                if not naming.is_meta(name):
+                    size = naming.make_next_power_of_2(name)
+
+            indices.append(call("arange", 0, size))
+
+        return tuple(indices)
+
+    def _generate_pid_indices(self, tensor):
+        self._invariants[type(self)._NAME_FOR_PID] = call("program_id", 0)
+
+        indices = list(
+            type(self)._unravel_index(type(self)._NAME_FOR_PID, tensor.shape)
+        )
+
+        for dim, index in enumerate(indices):
+            name = type(self)._name_for_index(tensor, dim)
+            self._invariants[name] = index
+            indices[dim] = name
+
+        return tuple(indices)
+
     @staticmethod
     def _generate_other(tensor):
-        other = tensor.original.other
+        other = tensor.source.other
 
         if isinstance(other, float) and not math.isfinite(other):
             return f"float('{other}')"
@@ -483,23 +517,86 @@ class CodeGenerator(ast.NodeTransformer):
         return tuple(slice(None) if i == dim else None for i in range(tensor.ndim))
 
     @staticmethod
-    def _generate_intermediate_offsets(tensor, intermediate_indices):
-        return tuple(
-            offs
-            for offs in tensor.offsets(
-                [0 for _ in range(tensor.ndim)]
-                + list(intermediate_indices)
-                + [0 for _ in range(tensor.inmost().ndim)]
-            )
+    def _generate_offsets(tensor, indices):
+        offsets = collections.defaultdict(
+            lambda: collections.defaultdict(lambda: Symbol(0))
         )
 
+        curr = tensor
+        start = 0
+
+        while isinstance(curr, type(tensor)):
+            stop = start + curr.ndim
+            curr_indices = indices[start:stop]
+
+            for index, stride, source_dim, target_dim in zip(
+                curr_indices, curr.strides, curr.source_dims, curr.target_dims
+            ):
+                offsets[source_dim][target_dim] += index * stride
+
+            start = stop
+            curr = curr.dtype
+
+        for source_dim in tuple(offsets):
+            for target_dim in tuple(offsets[source_dim]):
+                if not isinstance(source_dim, tuple):
+                    continue
+
+                unraveled = CodeGenerator._unravel_index(
+                    offsets[source_dim][target_dim],
+                    tuple(tensor.source.shape[dim] for dim in source_dim),
+                )
+
+                for offs, dim in zip(unraveled, source_dim):
+                    offsets[dim][target_dim] = offs
+
+        for source_dim in range(tensor.source.ndim):
+            for target_dim in range(tensor.target.ndim):
+                offsets[source_dim][target_dim] = copy.deepcopy(
+                    offsets[source_dim][target_dim]
+                )
+                offsets[source_dim][target_dim].find_and_replace(
+                    Symbol(tensor.source.strides[source_dim]), Symbol(1)
+                )
+
+        return offsets
+
+    @staticmethod
+    def _find_invariant_target_dims(tensor):
+        invariant_target_dims = set()
+
+        curr = tensor.dtype
+
+        while isinstance(curr.dtype, Tensor):
+            for target_dim in range(curr.target.ndim):
+                if target_dim not in curr.target_dims:
+                    invariant_target_dims.add(target_dim)
+
+            curr = curr.dtype
+
+        return invariant_target_dims
+
     @staticmethod
     def _name_for_pointers(tensor):
-        return Symbol(f"{tensor.original.name}_pointers")
+        return Symbol(f"{tensor.source.name}_pointers")
+
+    @staticmethod
+    def _name_for_offsets(tensor, source_dim, target_dim):
+        return Symbol(f"{tensor.source.name}_offsets_{source_dim}_{target_dim}")
 
     @staticmethod
-    def _name_for_offsets(tensor, dim):
-        return Symbol(f"{tensor.original.name}_offsets_{dim}")
+    def _name_for_index(tensor, dim):
+        return Symbol(f"{tensor.source.name}_index_{dim}")
+
+    @staticmethod
+    def _unravel_index(index, shape):
+        indices = []
+
+        for stride in Tensor(shape=shape).strides:
+            indices.append(index // stride)
+            index %= stride
+
+        return tuple(indices)
 
 
 class Tritonizer(ast.NodeTransformer):

ninetoothed/naming.py

@@ -1,6 +1,10 @@
 import re
 
 
+def auto_generate(name):
+    return f"ninetoothed_{name}"
+
+
 def make_constexpr(name):
     return _add_prefix(name, _CONSTEXPR)
 

ninetoothed/tensor.py

@@ -1,4 +1,5 @@
 import itertools
+import math
 import re
 
 import ninetoothed.naming as naming
@@ -16,18 +17,25 @@ class Tensor:
         dtype=None,
         strides=None,
         other=None,
+        constexpr_shape=None,
         name=None,
-        original=None,
+        source=None,
+        source_dims=None,
+        target=None,
+        target_dims=None,
     ):
         self.dtype = dtype
 
         if name is not None:
             self.name = name
         else:
-            self.name = f"_ninetoothed_tensor_{type(self).num_instances}"
+            self.name = naming.auto_generate(f"tensor_{type(self).num_instances}")
 
         if ndim is not None:
-            self.shape = (Symbol(self.size_string(i)) for i in range(ndim))
+            self.shape = (
+                Symbol(self.size_string(i), constexpr=constexpr_shape)
+                for i in range(ndim)
+            )
             self.strides = (Symbol(self.stride_string(i)) for i in range(ndim))
         else:
             self.shape = shape
@@ -39,10 +47,25 @@ class Tensor:
 
         self.other = other
 
-        if original is not None:
-            self.original = original
+        if source is not None:
+            self.source = source
+        else:
+            self.source = self
+
+        if source_dims is not None:
+            self.source_dims = source_dims
+        else:
+            self.source_dims = (dim for dim in range(self.source.ndim))
+
+        if target is not None:
+            self.target = target
+        else:
+            self.target = self
+
+        if target_dims is not None:
+            self.target_dims = target_dims
         else:
-            self.original = self
+            self.target_dims = (dim for dim in range(self.target.ndim))
 
         type(self).num_instances += 1
 
@@ -87,10 +110,16 @@ class Tensor:
                 shape=inner_shape,
                 dtype=self.dtype,
                 strides=inner_strides,
-                original=self.original,
+                source=self.source,
+                source_dims=self.source_dims,
+                target=self.target,
+                target_dims=self.target_dims,
             ),
             strides=outer_strides,
-            original=self.original,
+            source=self.source,
+            source_dims=self.source_dims,
+            target=self.target,
+            target_dims=self.target_dims,
         )
 
     def expand(self, shape):
@@ -105,7 +134,10 @@ class Tensor:
                 stride if new_size == -1 else 0
                 for new_size, stride in zip(shape, self.strides)
             ],
-            original=self.original,
+            source=self.source,
+            source_dims=self.source_dims,
+            target=self.target,
+            target_dims=self.target_dims,
         )
 
     def squeeze(self, dim):
@@ -114,81 +146,109 @@ class Tensor:
             shape=[size for i, size in enumerate(self.shape) if dim != i],
             dtype=self.dtype,
             strides=[stride for i, stride in enumerate(self.strides) if dim != i],
-            original=self.original,
+            source=self.source,
+            source_dims=[
+                source_dim for i, source_dim in enumerate(self.source_dims) if dim != i
+            ],
+            target=self.target,
+            target_dims=[
+                target_dim for i, target_dim in enumerate(self.target_dims) if dim != i
+            ],
         )
 
-    def names(self):
-        if self.ndim == 0:
-            return {self.original.name}
-
-        return (
-            {self.original.pointer_string()}
-            | {
-                name
-                for value in itertools.chain(self.shape, self.strides)
-                if isinstance(value, Symbol)
-                for name in value.names()
-            }
-            | (self.dtype.names() if isinstance(self.dtype, type(self)) else set())
-            | (self.original.names() if self.original is not self else set())
-        )
+    def permute(self, dims):
+        # TODO: Add error handling.
+        new_shape = [None for _ in range(self.ndim)]
+        new_strides = [None for _ in range(self.ndim)]
+        new_source_dims = [None for _ in range(self.ndim)]
 
-    def offsets(self, indices=None):
-        if indices is None:
-            indices = self.indices()
+        for original_dim, permuted_dim in enumerate(dims):
+            new_shape[original_dim] = self.shape[permuted_dim]
+            new_strides[original_dim] = self.strides[permuted_dim]
+            new_source_dims[original_dim] = self.source_dims[permuted_dim]
 
-        offsets = [[] for _ in range(self.original.ndim)]
+        return type(self)(
+            shape=new_shape,
+            dtype=self.dtype,
+            strides=new_strides,
+            source=self.source,
+            source_dims=new_source_dims,
+            target=self.target,
+            target_dims=self.target_dims,
+        )
 
-        curr = self
-        start = 0
+    def flatten(self, start_dim=None, end_dim=None):
+        # TODO: Add error handling.
+        if start_dim is None:
+            start_dim = 0
+        if end_dim is None:
+            end_dim = self.ndim
 
-        while isinstance(curr, type(self)):
-            stop = start + curr.ndim
-            curr_indices = indices[start:stop]
+        leading_sizes = self.shape[:start_dim]
+        flattening_sizes = self.shape[start_dim:end_dim]
+        trailing_sizes = self.shape[end_dim:]
 
-            for index, stride in zip(curr_indices, curr.strides):
-                for dim in self._dims_of(stride):
-                    offsets[dim].append(index * stride)
+        new_shape = leading_sizes + (math.prod(flattening_sizes),) + trailing_sizes
 
-            start = stop
-            curr = curr.dtype
+        leading_strides = self.strides[:start_dim]
+        flattening_strides = self.strides[start_dim:end_dim]
+        trailing_strides = self.strides[end_dim:]
 
-        for dim in range(self.original.ndim):
-            offsets[dim] = sum(offsets[dim])
-            offsets[dim].find_and_replace(Symbol(self.original.strides[dim]), Symbol(1))
+        new_strides = leading_strides + (flattening_strides[-1],) + trailing_strides
 
-        return offsets
+        leading_source_dims = self.source_dims[:start_dim]
+        flattening_source_dims = self.source_dims[start_dim:end_dim]
+        trailing_source_dims = self.source_dims[end_dim:]
 
-    def indices(self, index=None):
-        if index is None:
-            index = call("program_id", 0)
+        new_source_dims = (
+            leading_source_dims + (flattening_source_dims,) + trailing_source_dims
+        )
 
-        indices = []
+        return type(self)(
+            shape=new_shape,
+            dtype=self.dtype,
+            strides=new_strides,
+            source=self.source,
+            source_dims=new_source_dims,
+            target=self.target,
+            target_dims=self.target_dims,
+        )
 
-        for stride in type(self)(shape=self.shape, original=self.original).strides:
-            indices.append(index // stride)
-            index %= stride
+    def ravel(self):
+        # TODO: Add error handling.
+        new_shape = []
+        new_strides = []
 
-        curr = self.dtype
+        curr = self
 
-        while isinstance(curr.dtype, type(self)):
-            for _ in range(curr.ndim):
-                indices.append(0)
+        while isinstance(curr, type(self)):
+            new_shape.extend(curr.shape)
+            new_strides.extend(curr.strides)
 
             curr = curr.dtype
 
-        if isinstance(curr, type(self)):
-            for dim in range(curr.ndim):
-                size = curr.shape[dim]
-
-                if Symbol.is_name(size):
-                    name = size.node.id
-                    if not naming.is_meta(name):
-                        size = naming.make_next_power_of_2(name)
+        return type(self)(
+            shape=new_shape,
+            strides=new_strides,
+            other=self.source.other,
+            name=self.source.name,
+        )
 
-                indices.append(call("arange", 0, size))
+    def names(self):
+        if self.ndim == 0:
+            return {self.source.name}
 
-        return tuple(indices)
+        return (
+            {self.source.pointer_string()}
+            | {
+                name
+                for value in itertools.chain(self.shape, self.strides)
+                if isinstance(value, Symbol)
+                for name in value.names()
+            }
+            | (self.dtype.names() if isinstance(self.dtype, type(self)) else set())
+            | (self.source.names() if self.source is not self else set())
+        )
 
     def inmost(self):
         if not isinstance(self.dtype, type(self)):
@@ -237,6 +297,22 @@ class Tensor:
     def ndim(self):
         return len(self.shape)
 
+    @property
+    def source_dims(self):
+        return self._source_dims
+
+    @source_dims.setter
+    def source_dims(self, value):
+        self._source_dims = tuple(value)
+
+    @property
+    def target_dims(self):
+        return self._target_dims
+
+    @target_dims.setter
+    def target_dims(self, value):
+        self._target_dims = tuple(value)
+
     @staticmethod
     def pointer_pattern():
         return re.compile(rf"({_identifier_pattern_raw_string()})_(pointer)")
@@ -249,16 +325,6 @@ class Tensor:
     def stride_pattern():
         return re.compile(rf"({_identifier_pattern_raw_string()})_(stride)_(.+)")
 
-    def _dims_of(self, stride):
-        dims = set()
-        names = stride.names() if isinstance(stride, Symbol) else {stride}
-
-        for dim, original_stride in enumerate(self.original.strides):
-            if str(original_stride) in names:
-                dims.add(dim)
-
-        return dims
-
     @staticmethod
     def _calculate_default_strides(shape):
         strides = [1]

ninetoothed/torchifier.py

@@ -1,5 +1,6 @@
 import ast
 
+import ninetoothed.naming as naming
 from ninetoothed.tensor import Tensor
 
 
@@ -9,6 +10,9 @@ class Torchifier(ast.NodeTransformer):
 
         source = node.id
 
+        if naming.is_constexpr(source):
+            return node
+
         def repl(match):
             return f"{match.group(1)}"
 

{ninetoothed-0.7.0.dist-info → ninetoothed-0.9.0.dist-info}/METADATA

@@ -1,10 +1,11 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: ninetoothed
-Version: 0.7.0
+Version: 0.9.0
 Summary: A domain-specific language based on Triton but providing higher-level abstraction.
 Project-URL: Homepage, https://github.com/InfiniTensor/ninetoothed
 Project-URL: Issues, https://github.com/InfiniTensor/ninetoothed/issues
 Author-email: Jiacheng Huang <huangjiacheng0709@outlook.com>
+License-File: LICENSE
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3

ninetoothed-0.9.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+ninetoothed/__init__.py,sha256=dX34sk5GA3OgWf1Jc4gJMW3UwcGcJsuG3hs3rkiqq6g,161
+ninetoothed/jit.py,sha256=B3q32ksKTRr7I4jLcoDXjwEx7A_Awz9DXGEmIkrtoBc,23393
+ninetoothed/language.py,sha256=YwjlBENmmKPTnhaQ2uYbj5MwzrCAT7MLJ6VkQ6NeXJE,504
+ninetoothed/naming.py,sha256=Fl0x4eDRStTpkXjJg6179ErEnY7bR5Qi0AT6RX9C3fU,951
+ninetoothed/symbol.py,sha256=rZ5nXtn-U1Nw0BBRJ-kfrwmX_zCbAi76un-Z2QFaoZc,4773
+ninetoothed/tensor.py,sha256=OU6lVjzKU614mk3EN1AAgTDradbvJkyl22AXwdhxcfs,9577
+ninetoothed/torchifier.py,sha256=aDijK5UOwK2oLXDHgDo8M959rJclEI0lcfaPr7GQTXY,1012
+ninetoothed-0.9.0.dist-info/METADATA,sha256=LKtSbgc_mWKJ4L_8BYiRKWjoV-JKjr4hefhrkdPmrHs,7054
+ninetoothed-0.9.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+ninetoothed-0.9.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+ninetoothed-0.9.0.dist-info/RECORD,,

{ninetoothed-0.7.0.dist-info → ninetoothed-0.9.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.26.3
+Generator: hatchling 1.27.0
 Root-Is-Purelib: true
 Tag: py3-none-any

ninetoothed-0.7.0.dist-info/RECORD

@@ -1,11 +0,0 @@
-ninetoothed/__init__.py,sha256=T5UJXlC-wbo8JKPbLUNT65Kccp12xP52WFV5FsugETI,147
-ninetoothed/jit.py,sha256=y0y3gfcBNeRLhozIzLuDHLLzBAGrL8tLk8Rcvhw_uec,20068
-ninetoothed/language.py,sha256=YwjlBENmmKPTnhaQ2uYbj5MwzrCAT7MLJ6VkQ6NeXJE,504
-ninetoothed/naming.py,sha256=3FBnC-S3dAZRcBcob9SrcVpVEYE5IXRacwkCiA3vIGU,891
-ninetoothed/symbol.py,sha256=rZ5nXtn-U1Nw0BBRJ-kfrwmX_zCbAi76un-Z2QFaoZc,4773
-ninetoothed/tensor.py,sha256=KL6Iw2nwaRnZsNTxOeghDeXUQUgphnVh_1fsmAObOtI,7391
-ninetoothed/torchifier.py,sha256=8M2PDwyFIfVypX6Z-Vt_bGbsCPqxqKnftL0rXeh9bOM,911
-ninetoothed-0.7.0.dist-info/METADATA,sha256=gRLAzPSdxWYff8SqPuwJ3ji3Z_kPq_vtEupnSe7dIQ0,7032
-ninetoothed-0.7.0.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
-ninetoothed-0.7.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-ninetoothed-0.7.0.dist-info/RECORD,,