Merge branch 'export-D57463419' of github.com:kirklandsign/executorch into export-D57463419

kirklandsign · kirklandsign · commit b162d1971d92 · 2024-06-21T10:50:13.000-07:00
diff --git a/backends/arm/tosa_utils.py b/backends/arm/tosa_utils.py
@@ -33,7 +33,7 @@ def dbg_node(node):
     logger.info("  node.meta = ")
     for k, v in node.meta.items():
         logger.info(f"    '{k}' = {v}")
-        if type([]) == type(v):
+        if isinstance(v, list):
             for i in v:
                 logger.info(f"      {i} ")
 
diff --git a/backends/qualcomm/passes/convert_to_linear.py b/backends/qualcomm/passes/convert_to_linear.py
@@ -192,7 +192,11 @@ def _convert(self, graph_module: torch.fx.GraphModule):
         for _, src_partitions in partitions.items():
             for src_partition in src_partitions:
                 op_cnt = Counter(
-                    [n.target for n in src_partition.nodes if type(n.target) == edge_op]
+                    [
+                        n.target
+                        for n in src_partition.nodes
+                        if isinstance(n.target, edge_op)
+                    ]
                 )
                 if self.linear in op_cnt:
                     continue
diff --git a/backends/qualcomm/passes/fold_qdq.py b/backends/qualcomm/passes/fold_qdq.py
@@ -45,7 +45,7 @@ def _fold(self, graph_module: torch.fx.GraphModule) -> torch.fx.GraphModule:
 
             # collecting quant nodes to be removed
             for i in range(1, len(n.args)):
-                if type(n.args[i]) == torch.fx.node.Node:
+                if isinstance(n.args[i], torch.fx.node.Node):
                     to_be_removed.append(n.args[i])
                     # could be a commonly shared attribute between q & dq
                     if n.args[i].target == exir_ops.edge.aten._to_copy.default:
diff --git a/backends/qualcomm/passes/insert_io_qdq.py b/backends/qualcomm/passes/insert_io_qdq.py
@@ -47,7 +47,9 @@ def _ceate_args(self, target: torch.fx.node.Target, quant_attrs: Dict):
             if name == "out_dtype":
                 continue
             value = quant_attrs[name]
-            if type(arg_schema.type) == torch.tensor and type(value) in [int, float]:
+            if isinstance(arg_schema.type, torch.tensor) and (
+                isinstance(value, int) or isinstance(value, float)
+            ):
                 value = torch.tensor(value)
             ret.append(value)
         return ret
diff --git a/backends/qualcomm/passes/utils.py b/backends/qualcomm/passes/utils.py
@@ -32,7 +32,7 @@ def get_quant_attrs(
         attr_n = quant_node.args[i]
 
         value = attr_n
-        if type(attr_n) == torch.fx.node.Node:
+        if isinstance(attr_n, torch.fx.node.Node):
             # could be a commonly shared attribute between q & dq
             if attr_n.target == exir_ops.edge.aten._to_copy.default:
                 value = get_parameter(attr_n.args[0], edge_program)
diff --git a/backends/qualcomm/quantizer/quantizer.py b/backends/qualcomm/quantizer/quantizer.py
@@ -295,7 +295,7 @@ def _get_quant_config(self, op: str | OpOverload) -> Optional[QuantizationConfig
             1. is one of use_per_channel_weight_quant_ops
             2. int8 / int16 config
         """
-        if type(op) == str:
+        if isinstance(op, str):
             return
 
         if op in self.use_per_channel_weight_quant_ops:
diff --git a/backends/transforms/i64_to_i32.py b/backends/transforms/i64_to_i32.py
@@ -14,6 +14,14 @@
 
 class I64toI32(ExportPass):
 
+    def __init__(self, _skip_dim_order=False):
+        super(I64toI32, self).__init__()
+        self.copy_op = (
+            exir_ops.edge.aten._to_copy.default
+            if _skip_dim_order
+            else exir_ops.edge.dim_order_ops._to_dim_order_copy.default
+        )
+
     def _is_i64_tensor(self, node_val):
         return isinstance(node_val, FakeTensor) and node_val.dtype == torch.int64
 
@@ -34,7 +42,7 @@ def _apply_to_i32(self, graph: torch.fx.Graph):
                         args = (node,)
                         node_i32 = graph.create_node(
                             "call_function",
-                            exir_ops.edge.dim_order_ops._to_dim_order_copy.default,
+                            self.copy_op,
                             args,
                             {"dtype": torch.int32},
                         )
@@ -62,7 +70,7 @@ def _apply_to_i32(self, graph: torch.fx.Graph):
                             args = (node.args[0][i],)
                             node_i64 = graph.create_node(
                                 "call_function",
-                                exir_ops.edge.dim_order_ops._to_dim_order_copy.default,
+                                self.copy_op,
                                 args,
                                 {"dtype": torch.int64},
                             )
diff --git a/backends/vulkan/runtime/graph/ops/glsl/view.glsl b/backends/vulkan/runtime/graph/ops/glsl/view.glsl
@@ -16,16 +16,11 @@ layout(std430) buffer;
 
 #include "indexing_utils.h"
 
-layout(set = 0, binding = 0, ${IMAGE_FORMAT[DTYPE]}) uniform PRECISION restrict writeonly ${IMAGE_T[NDIM][DTYPE]} image_out;
-layout(set = 0, binding = 1) uniform PRECISION sampler3D image_in;
+${layout_declare_tensor(0, "w", "t_out", DTYPE, STORAGE)}
+${layout_declare_tensor(1, "r", "t_in", DTYPE, STORAGE)}
 
-layout(set = 0, binding = 2) uniform PRECISION restrict OutSizes {
-  ivec4 out_sizes;
-};
-
-layout(set = 0, binding = 3) uniform PRECISION restrict InSizes {
-  ivec4 in_sizes;
-};
+${layout_declare_ubo(2, "ivec4", "out_sizes")}
+${layout_declare_ubo(3, "ivec4", "in_sizes")}
 
 layout(local_size_x_id = 0, local_size_y_id = 1, local_size_z_id = 2) in;
 
@@ -52,10 +47,10 @@ void main() {
     if (out_tensor_idx[out_packed_dim]++ < out_sizes[out_packed_dim]) {
       ivec4 user_coor = from_nchw_buffer_i(buf_indices[i], in_sizes);
       ivec4 in_pos_elem = to_texture_elem_pos(user_coor, in_sizes, in_packed_dim);
-      VEC4_T intex = texelFetch(image_in, in_pos_elem.xyz, 0);
+      VEC4_T intex = texelFetch(t_in, in_pos_elem.xyz, 0);
       value[i] = intex[in_pos_elem.w];
     }
   }
 
-  imageStore(image_out, out_pos, value);
+  imageStore(t_out, out_pos, value);
 }
diff --git a/backends/vulkan/runtime/graph/ops/glsl/view.yaml b/backends/vulkan/runtime/graph/ops/glsl/view.yaml
@@ -2,9 +2,11 @@ view:
   parameter_names_with_default_values:
     DTYPE: float
     NDIM: 3
+    STORAGE: texture3d
   generate_variant_forall:
     DTYPE:
       - VALUE: half
       - VALUE: float
+      - VALUE: int
   shader_variants:
     - NAME: view
diff --git a/backends/vulkan/test/test_vulkan_delegate.py b/backends/vulkan/test/test_vulkan_delegate.py
@@ -1083,6 +1083,22 @@ def forward(self, x):
             memory_layouts=[vk_graph_schema.VkMemoryLayout.TENSOR_CHANNELS_PACKED],
         )
 
+    def test_vulkan_backend_view_int(self):
+        class ViewModule(torch.nn.Module):
+            def __init__(self):
+                super().__init__()
+
+            def forward(self, x):
+                return x.view([-1, x.size(-1)])
+
+        sample_inputs = (torch.randint(size=(3, 6, 2, 7), high=100, dtype=torch.int32),)
+
+        self.lower_module_and_test_output(
+            ViewModule(),
+            sample_inputs,
+            memory_layouts=[vk_graph_schema.VkMemoryLayout.TENSOR_CHANNELS_PACKED],
+        )
+
     def test_vulkan_backend_unsqueeze(self):
         class UnsqueezeModule(torch.nn.Module):
             def __init__(self):
diff --git a/examples/qualcomm/scripts/dummy_llama2.py b/examples/qualcomm/scripts/dummy_llama2.py
@@ -27,7 +27,7 @@ def create_device_inputs(example_inputs, use_kv_cache):
     input_list = ""
     if use_kv_cache:
         for i, d in enumerate(inputs[0]):
-            if type(d) == list:
+            if isinstance(d, list):
                 d = torch.stack(d)
             d.numpy().tofile(f"{args.artifact}/input_0_0.raw")
             input_list = f"input_0_{i}.raw "
diff --git a/exir/emit/_emitter.py b/exir/emit/_emitter.py
@@ -285,18 +285,17 @@ def _emit_list(self, val: List[_Argument], val_type: _SchemaType) -> EValue:
 
         NOTE: When symbool and symfloat are supported bool and float lists will be stored boxed.
         """
-        elem_type = type(val_type)
 
-        if elem_type == torch.BoolType:
+        if isinstance(val_type, torch.BoolType):
             return EValue(BoolList(typing.cast(List[bool], val)))
 
-        if elem_type == torch.IntType:
+        if isinstance(val_type, torch.IntType):
             return self._emit_int_list(val)
 
-        if elem_type == torch.FloatType:
+        if isinstance(val_type, torch.FloatType):
             return EValue(DoubleList(typing.cast(List[float], val)))
 
-        if elem_type == torch.TensorType:
+        if isinstance(val_type, torch.TensorType):
             values = []
             for v in val:
                 assert isinstance(v, _AbstractValue)
@@ -308,10 +307,10 @@ def _emit_list(self, val: List[_Argument], val_type: _SchemaType) -> EValue:
                 values.append(v.id)
             return EValue(TensorList(values))
 
-        if elem_type == torch.OptionalType:
+        if isinstance(val_type, torch.OptionalType):
             # refine further
-            actual_type = typing.cast(torch.OptionalType, val_type).getElementType()
-            if type(actual_type) == torch.TensorType:
+            actual_type = val_type.getElementType()
+            if isinstance(actual_type, torch.TensorType):
                 vals = []
                 for v in val:
                     if v is None:
@@ -437,9 +436,9 @@ def _constant_to_evalue(  # noqa: C901
                 val_type = torch.ListType(
                     self._get_list_tuple_jit_type(val)  # pyre-ignore
                 )
-            if type(val_type) == torch.OptionalType:
+            if isinstance(val_type, torch.OptionalType):
                 val_type = val_type.getElementType()
-            assert type(val_type) == torch.ListType
+            assert isinstance(val_type, torch.ListType)
             return self._emit_list(
                 typing.cast(List[_Argument], val),
                 typing.cast(_SchemaType, val_type.getElementType()),
diff --git a/exir/passes/remove_mixed_type_operators.py b/exir/passes/remove_mixed_type_operators.py
@@ -61,7 +61,7 @@ def call_operator(self, op, args, kwargs, meta: NodeMetadata):  # noqa: C901
         )[1]
 
         def try_coerce(value: PyTree, arg: torch.Argument) -> PyTree:
-            if type(arg.type) != torch.TensorType:
+            if not isinstance(arg.type, torch.TensorType):
                 return value
 
             if isinstance(value, ProxyValue):
diff --git a/exir/passes/scalar_to_tensor_pass.py b/exir/passes/scalar_to_tensor_pass.py
@@ -24,7 +24,7 @@ def try_coerce(value, arg):
                 return (
                     torch.tensor(value)
                     if isinstance(value, (float, int, bool))
-                    and type(arg.type) == torch.TensorType
+                    and isinstance(arg.type, torch.TensorType)
                     else value
                 )
 
diff --git a/exir/tracer.py b/exir/tracer.py
@@ -345,7 +345,7 @@ def __torch_dispatch__(  # noqa: C901
 
         # Kind of a hacky way to test if an op is in-place or not
         if func.__name__[-1] == "_" and func.__name__[0] != "_":
-            if type(args[0]) == PythonTensor:
+            if isinstance(args[0], PythonTensor):
                 args[0].proxy = proxy_out
 
         if not torch.fx.traceback.has_preserved_node_meta():
@@ -361,13 +361,13 @@ def wrap_with_proxy(e: LeafValue, proxy: torch.fx.Proxy) -> LeafValue:
             if e is None:
                 e = torch.empty(())
 
-            if type(e) == torch.Tensor:
+            if isinstance(e, torch.Tensor):
                 return PythonTensor(e, proxy)
 
             # Inplace and out-variant ops may return one of their arguments, which is already
             # a PythonTensor. In this case, we need to update the PythonTensor's associated
             # proxy to the newly created proxy.
-            if type(e) == PythonTensor:
+            if isinstance(e, PythonTensor):
                 e.update_proxy(proxy)
                 return e
 
diff --git a/requirements-lintrunner.txt b/requirements-lintrunner.txt
@@ -3,18 +3,18 @@ lintrunner==0.11.0
 lintrunner-adapters==0.11.0
 
 # Flake 8 and its dependencies
-flake8==6.0.0
+flake8==6.1.0
 flake8-breakpoint==1.1.0
-flake8-bugbear==23.6.5
-flake8-comprehensions==3.12.0
+flake8-bugbear==23.9.16
+flake8-comprehensions==3.14.0
 flake8-pyi==23.5.0
 mccabe==0.7.0
-pycodestyle==2.10.0
+pycodestyle==2.11.1
 torchfix==0.5.0
 
 # UFMT
-black==24.2.0
-ufmt==2.5.1
+black==24.4.2
+ufmt==2.6.0
 usort==1.0.5
 
 # Other linters
diff --git a/sdk/bundled_program/test/test_config.py b/sdk/bundled_program/test/test_config.py
@@ -31,10 +31,8 @@ def assertIOListEqual(
     ) -> None:
         self.assertEqual(len(tl1), len(tl2))
         for t1, t2 in zip(tl1, tl2):
-            if type(t1) == torch.Tensor:
-                assert type(t1) == type(t2)
-                # pyre-fixme[6]: For 2nd argument expected `Tensor` but got
-                #  `Union[bool, float, int, Tensor]`.
+            if isinstance(t1, torch.Tensor):
+                assert isinstance(t2, torch.Tensor)
                 self.assertTensorEqual(t1, t2)
             else:
                 self.assertTrue(t1 == t2)
