-
-
Save mariecwhite/fb37546dbea53cf8e62d6eedbf252576 to your computer and use it in GitHub Desktop.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| #executable_target_embedded_elf_x86_64_ = #hal.executable.target<"llvm-cpu", "embedded-elf-x86_64", {cpu = "generic", cpu_features = "", data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", native_vector_size = 16 : index, target_triple = "x86_64-unknown-unknown-eabi-elf", ukernels = false}> | |
| #map = affine_map<(d0, d1) -> (d0, d1)> | |
| #map1 = affine_map<(d0, d1, d2) -> (d0, d1, d2)> | |
| #map2 = affine_map<(d0, d1, d2) -> (d2)> | |
| #map3 = affine_map<(d0, d1, d2) -> (d0, d1)> | |
| #map4 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2)> | |
| #map5 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> | |
| #map6 = affine_map<(d0, d1, d2) -> (d0, d1, 0)> | |
| #map7 = affine_map<(d0, d1, d2) -> (d1)> | |
| #map8 = affine_map<(d0, d1, d2, d3) -> (d0, d2, d3)> | |
| #map9 = affine_map<(d0, d1, d2, d3) -> (d1, d2, d3)> | |
| #map10 = affine_map<(d0, d1, d2, d3) -> (d0, d3)> | |
| #map11 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d3)> | |
| #map12 = affine_map<(d0, d1, d2, d3) -> ()> | |
| #map13 = affine_map<(d0, d1, d2, d3) -> (d0, d2, d1, d3)> | |
| #map14 = affine_map<(d0, d1, d2, d3) -> (d0, d3, d1, d2)> | |
| #map15 = affine_map<(d0, d1, d2, d3) -> (d0, 0, d2, d3)> | |
| #map16 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d3, d2)> | |
| #map17 = affine_map<(d0, d1, d2, d3) -> (d0, d2, d3, d1)> | |
| #map18 = affine_map<(d0) -> (d0)> | |
| #map19 = affine_map<(d0, d1) -> (d1)> | |
| #map20 = affine_map<(d0, d1, d2) -> (0, 0, d2)> | |
| #map21 = affine_map<(d0, d1) -> (d1, d0)> | |
| #map22 = affine_map<() -> ()> | |
| #device_target_llvm_cpu = #hal.device.target<"llvm-cpu", {executable_targets = [#executable_target_embedded_elf_x86_64_]}> | |
| module @jit_forward attributes {hal.device.targets = [#device_target_llvm_cpu], iree.fixedpoint.iteration = 0 : index} { | |
| util.global private @hoisted_110 : tensor<768x50257xf32> | |
| util.global private @hoisted_109 : tensor<64x512x768xf32> | |
| util.global private @hoisted_108 : tensor<64x512x768xf32> | |
| util.global private @hoisted_107 : tensor<3072x768xf32> | |
| util.global private @hoisted_106 : tensor<768x3072xf32> | |
| util.global private @hoisted_105 : tensor<64x512x768xf32> | |
| util.global private @hoisted_104 : tensor<64x512x768xf32> | |
| util.global private @hoisted_103 : tensor<768x768xf32> | |
| util.global private @hoisted_102 : tensor<768x2304xf32> | |
| util.global private @hoisted_101 : tensor<64x512x768xf32> | |
| util.global private @hoisted_100 : tensor<64x512x768xf32> | |
| util.global private @hoisted_99 : tensor<3072x768xf32> | |
| util.global private @hoisted_98 : tensor<768x3072xf32> | |
| util.global private @hoisted_97 : tensor<64x512x768xf32> | |
| util.global private @hoisted_96 : tensor<64x512x768xf32> | |
| util.global private @hoisted_95 : tensor<768x768xf32> | |
| util.global private @hoisted_94 : tensor<768x2304xf32> | |
| util.global private @hoisted_93 : tensor<64x512x768xf32> | |
| util.global private @hoisted_92 : tensor<64x512x768xf32> | |
| util.global private @hoisted_91 : tensor<3072x768xf32> | |
| util.global private @hoisted_90 : tensor<768x3072xf32> | |
| util.global private @hoisted_89 : tensor<64x512x768xf32> | |
| util.global private @hoisted_88 : tensor<64x512x768xf32> | |
| util.global private @hoisted_87 : tensor<768x768xf32> | |
| util.global private @hoisted_86 : tensor<768x2304xf32> | |
| util.global private @hoisted_85 : tensor<64x512x768xf32> | |
| util.global private @hoisted_84 : tensor<64x512x768xf32> | |
| util.global private @hoisted_83 : tensor<3072x768xf32> | |
| util.global private @hoisted_82 : tensor<768x3072xf32> | |
| util.global private @hoisted_81 : tensor<64x512x768xf32> | |
| util.global private @hoisted_80 : tensor<64x512x768xf32> | |
| util.global private @hoisted_79 : tensor<768x768xf32> | |
| util.global private @hoisted_78 : tensor<768x2304xf32> | |
| util.global private @hoisted_77 : tensor<64x512x768xf32> | |
| util.global private @hoisted_76 : tensor<64x512x768xf32> | |
| util.global private @hoisted_75 : tensor<3072x768xf32> | |
| util.global private @hoisted_74 : tensor<768x3072xf32> | |
| util.global private @hoisted_73 : tensor<64x512x768xf32> | |
| util.global private @hoisted_72 : tensor<64x512x768xf32> | |
| util.global private @hoisted_71 : tensor<768x768xf32> | |
| util.global private @hoisted_70 : tensor<768x2304xf32> | |
| util.global private @hoisted_69 : tensor<64x512x768xf32> | |
| util.global private @hoisted_68 : tensor<64x512x768xf32> | |
| util.global private @hoisted_67 : tensor<3072x768xf32> | |
| util.global private @hoisted_66 : tensor<768x3072xf32> | |
| util.global private @hoisted_65 : tensor<64x512x768xf32> | |
| util.global private @hoisted_64 : tensor<64x512x768xf32> | |
| util.global private @hoisted_63 : tensor<768x768xf32> | |
| util.global private @hoisted_62 : tensor<768x2304xf32> | |
| util.global private @hoisted_61 : tensor<64x512x768xf32> | |
| util.global private @hoisted_60 : tensor<64x512x768xf32> | |
| util.global private @hoisted_59 : tensor<3072x768xf32> | |
| util.global private @hoisted_58 : tensor<768x3072xf32> | |
| util.global private @hoisted_57 : tensor<64x512x768xf32> | |
| util.global private @hoisted_56 : tensor<64x512x768xf32> | |
| util.global private @hoisted_55 : tensor<768x768xf32> | |
| util.global private @hoisted_54 : tensor<768x2304xf32> | |
| util.global private @hoisted_53 : tensor<64x512x768xf32> | |
| util.global private @hoisted_52 : tensor<64x512x768xf32> | |
| util.global private @hoisted_51 : tensor<3072x768xf32> | |
| util.global private @hoisted_50 : tensor<768x3072xf32> | |
| util.global private @hoisted_49 : tensor<64x512x768xf32> | |
| util.global private @hoisted_48 : tensor<64x512x768xf32> | |
| util.global private @hoisted_47 : tensor<768x768xf32> | |
| util.global private @hoisted_46 : tensor<768x2304xf32> | |
| util.global private @hoisted_45 : tensor<64x512x768xf32> | |
| util.global private @hoisted_44 : tensor<64x512x768xf32> | |
| util.global private @hoisted_43 : tensor<3072x768xf32> | |
| util.global private @hoisted_42 : tensor<768x3072xf32> | |
| util.global private @hoisted_41 : tensor<64x512x768xf32> | |
| util.global private @hoisted_40 : tensor<64x512x768xf32> | |
| util.global private @hoisted_39 : tensor<768x768xf32> | |
| util.global private @hoisted_38 : tensor<768x2304xf32> | |
| util.global private @hoisted_37 : tensor<64x512x768xf32> | |
| util.global private @hoisted_36 : tensor<64x512x768xf32> | |
| util.global private @hoisted_35 : tensor<3072x768xf32> | |
| util.global private @hoisted_34 : tensor<768x3072xf32> | |
| util.global private @hoisted_33 : tensor<64x512x768xf32> | |
| util.global private @hoisted_32 : tensor<64x512x768xf32> | |
| util.global private @hoisted_31 : tensor<768x768xf32> | |
| util.global private @hoisted_30 : tensor<768x2304xf32> | |
| util.global private @hoisted_29 : tensor<64x512x768xf32> | |
| util.global private @hoisted_28 : tensor<64x512x768xf32> | |
| util.global private @hoisted_27 : tensor<3072x768xf32> | |
| util.global private @hoisted_26 : tensor<768x3072xf32> | |
| util.global private @hoisted_25 : tensor<64x512x768xf32> | |
| util.global private @hoisted_24 : tensor<64x512x768xf32> | |
| util.global private @hoisted_23 : tensor<768x768xf32> | |
| util.global private @hoisted_22 : tensor<768x2304xf32> | |
| util.global private @hoisted_21 : tensor<64x512x768xf32> | |
| util.global private @hoisted_20 : tensor<64x512x768xf32> | |
| util.global private @hoisted_19 : tensor<3072x768xf32> | |
| util.global private @hoisted_18 : tensor<768x3072xf32> | |
| util.global private @hoisted_17 : tensor<64x512x768xf32> | |
| util.global private @hoisted_16 : tensor<64x512x768xf32> | |
| util.global private @hoisted_15 : tensor<768x768xf32> | |
| util.global private @hoisted_14 : tensor<f32> | |
| util.global private @hoisted_13 : tensor<768x2304xf32> | |
| util.global private @hoisted_12 : tensor<1024xi32> | |
| util.global private @hoisted_11 : tensor<64x512x768xf32> | |
| util.global private @hoisted_10 : tensor<64x512x768xf32> | |
| util.global private @hoisted_9 : tensor<64x512x768xf32> | |
| util.global private @hoisted_8 : tensor<64x512x1x768xf32> | |
| util.global private @hoisted_7 : tensor<1xi32> | |
| util.global private @hoisted_6 : tensor<1x1xi32> | |
| util.global private @hoisted_5 : tensor<64x512x1xi32> | |
| util.global private @hoisted_4 : tensor<64x512xi32> | |
| util.global private @hoisted_3 : tensor<1xi32> | |
| util.global private @hoisted_2 : tensor<1x1xi32> | |
| util.global private @hoisted_1 : tensor<1x1xi32> | |
| util.global private @hoisted_0 : tensor<512xi32> | |
| util.global private @hoisted : tensor<512xi32> | |
| func.func @main(%arg0: !hal.buffer_view, %arg1: !hal.buffer_view) -> !hal.buffer_view attributes {iree.abi.stub} { | |
| %cst = arith.constant dense<...> : tensor<768xf32> | |
| %cst_0 = arith.constant dense<...> : tensor<3072xf32> | |
| %cst_1 = arith.constant dense<...> : tensor<768xf32> | |
| %cst_2 = arith.constant dense<...> : tensor<2304xf32> | |
| %cst_3 = arith.constant dense<...> : tensor<768xf32> | |
| %cst_4 = arith.constant dense<...> : tensor<3072xf32> | |
| %cst_5 = arith.constant dense<...> : tensor<768xf32> | |
| %cst_6 = arith.constant dense<...> : tensor<2304xf32> | |
| %cst_7 = arith.constant dense<...> : tensor<768xf32> | |
| %cst_8 = arith.constant dense<...> : tensor<3072xf32> | |
| %cst_9 = arith.constant dense<...> : tensor<768xf32> | |
| %cst_10 = arith.constant dense<...> : tensor<2304xf32> | |
| %cst_11 = arith.constant dense<...> : tensor<768xf32> | |
| %cst_12 = arith.constant dense<...> : tensor<3072xf32> | |
| %cst_13 = arith.constant dense<...> : tensor<768xf32> | |
| %cst_14 = arith.constant dense<...> : tensor<2304xf32> | |
| %cst_15 = arith.constant dense<...> : tensor<768xf32> | |
| %cst_16 = arith.constant dense<...> : tensor<3072xf32> | |
| %cst_17 = arith.constant dense<...> : tensor<768xf32> | |
| %cst_18 = arith.constant dense<...> : tensor<2304xf32> | |
| %cst_19 = arith.constant dense<...> : tensor<768xf32> | |
| %cst_20 = arith.constant dense<...> : tensor<3072xf32> | |
| %cst_21 = arith.constant dense<...> : tensor<768xf32> | |
| %cst_22 = arith.constant dense<...> : tensor<2304xf32> | |
| %cst_23 = arith.constant dense<...> : tensor<768xf32> | |
| %cst_24 = arith.constant dense<...> : tensor<3072xf32> | |
| %cst_25 = arith.constant dense<...> : tensor<768xf32> | |
| %cst_26 = arith.constant dense<...> : tensor<2304xf32> | |
| %cst_27 = arith.constant dense<...> : tensor<768xf32> | |
| %cst_28 = arith.constant dense<...> : tensor<3072xf32> | |
| %cst_29 = arith.constant dense<...> : tensor<768xf32> | |
| %cst_30 = arith.constant dense<...> : tensor<2304xf32> | |
| %cst_31 = arith.constant dense<...> : tensor<768xf32> | |
| %cst_32 = arith.constant dense<...> : tensor<3072xf32> | |
| %cst_33 = arith.constant dense<...> : tensor<768xf32> | |
| %cst_34 = arith.constant dense<...> : tensor<2304xf32> | |
| %cst_35 = arith.constant dense<...> : tensor<768xf32> | |
| %cst_36 = arith.constant dense<...> : tensor<3072xf32> | |
| %cst_37 = arith.constant dense<...> : tensor<768xf32> | |
| %cst_38 = arith.constant dense<...> : tensor<2304xf32> | |
| %cst_39 = arith.constant dense<...> : tensor<768xf32> | |
| %cst_40 = arith.constant dense<...> : tensor<3072xf32> | |
| %cst_41 = arith.constant dense<...> : tensor<768xf32> | |
| %cst_42 = arith.constant dense<...> : tensor<2304xf32> | |
| %cst_43 = arith.constant dense<...> : tensor<768xf32> | |
| %cst_44 = arith.constant dense<...> : tensor<3072xf32> | |
| %cst_45 = arith.constant dense<...> : tensor<768xf32> | |
| %cst_46 = arith.constant dense<...> : tensor<2304xf32> | |
| %cst_47 = arith.constant dense<...> : tensor<50257x768xf32> | |
| %cst_48 = arith.constant dense<5.000000e-01> : tensor<64x512x3072xf32> | |
| %cst_49 = arith.constant dense<1.000000e+00> : tensor<64x512x3072xf32> | |
| %cst_50 = arith.constant dense<0.797884583> : tensor<64x512x3072xf32> | |
| %cst_51 = arith.constant dense<4.471500e-02> : tensor<64x512x3072xf32> | |
| %cst_52 = arith.constant dense<-3.40282347E+38> : tensor<64x1x512x512xf32> | |
| %cst_53 = arith.constant dense<0.000000e+00> : tensor<64x1x512x512xf32> | |
| %cst_54 = arith.constant dense<0> : tensor<64x1x512x512xi32> | |
| %cst_55 = arith.constant dense<9.99999974E-6> : tensor<64x512x1xf32> | |
| %cst_56 = arith.constant dense<0.000000e+00> : tensor<64x512xf32> | |
| %cst_57 = arith.constant dense<7.680000e+02> : tensor<64x512xf32> | |
| %cst_58 = arith.constant dense<0> : tensor<64x512xi32> | |
| %cst_59 = arith.constant dense<50257> : tensor<64x512xi32> | |
| %cst_60 = arith.constant dense<0> : tensor<64x512x1xi32> | |
| %cst_61 = arith.constant dense<0x7FC00000> : tensor<64x512x768xf32> | |
| %true = arith.constant true | |
| %cst_62 = arith.constant 0.000000e+00 : f32 | |
| %cst_63 = arith.constant 0xFF800000 : f32 | |
| %0 = hal.tensor.import %arg0 "input 0" : !hal.buffer_view -> tensor<64x512xi32> | |
| %1 = hal.tensor.import %arg1 "input 1" : !hal.buffer_view -> tensor<64x512xi32> | |
| %hoisted = util.global.load @hoisted : tensor<512xi32> | |
| %hoisted_0 = util.global.load @hoisted_0 : tensor<512xi32> | |
| %2 = tensor.empty() : tensor<64x512xi32> | |
| %3 = tensor.empty() : tensor<64x512xi1> | |
| %4 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%0, %cst_58 : tensor<64x512xi32>, tensor<64x512xi32>) outs(%3 : tensor<64x512xi1>) { | |
| ^bb0(%in: i32, %in_333: i32, %out: i1): | |
| %937 = arith.cmpi slt, %in, %in_333 : i32 | |
| linalg.yield %937 : i1 | |
| } -> tensor<64x512xi1> | |
| %5 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%0, %cst_59 : tensor<64x512xi32>, tensor<64x512xi32>) outs(%2 : tensor<64x512xi32>) { | |
| ^bb0(%in: i32, %in_333: i32, %out: i32): | |
| %937 = arith.addi %in, %in_333 : i32 | |
| linalg.yield %937 : i32 | |
| } -> tensor<64x512xi32> | |
| %6 = linalg.generic {indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%4, %5, %0 : tensor<64x512xi1>, tensor<64x512xi32>, tensor<64x512xi32>) outs(%2 : tensor<64x512xi32>) { | |
| ^bb0(%in: i1, %in_333: i32, %in_334: i32, %out: i32): | |
| %937 = arith.select %in, %in_333, %in_334 : i32 | |
| linalg.yield %937 : i32 | |
| } -> tensor<64x512xi32> | |
| %expanded = tensor.expand_shape %6 [[0], [1, 2]] : tensor<64x512xi32> into tensor<64x512x1xi32> | |
| %hoisted_1 = util.global.load @hoisted_1 : tensor<1x1xi32> | |
| %hoisted_2 = util.global.load @hoisted_2 : tensor<1x1xi32> | |
| %hoisted_3 = util.global.load @hoisted_3 : tensor<1xi32> | |
| %7 = tensor.empty() : tensor<64x512x1xi1> | |
| %8 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded, %cst_60 : tensor<64x512x1xi32>, tensor<64x512x1xi32>) outs(%7 : tensor<64x512x1xi1>) { | |
| ^bb0(%in: i32, %in_333: i32, %out: i1): | |
| %937 = arith.cmpi sge, %in, %in_333 : i32 | |
| linalg.yield %937 : i1 | |
| } -> tensor<64x512x1xi1> | |
| %9 = tensor.empty() : tensor<64x512x1xi32> | |
| %10 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%hoisted_3 : tensor<1xi32>) outs(%9 : tensor<64x512x1xi32>) { | |
| ^bb0(%in: i32, %out: i32): | |
| linalg.yield %in : i32 | |
| } -> tensor<64x512x1xi32> | |
| %11 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded, %10 : tensor<64x512x1xi32>, tensor<64x512x1xi32>) outs(%7 : tensor<64x512x1xi1>) { | |
| ^bb0(%in: i32, %in_333: i32, %out: i1): | |
| %937 = arith.cmpi sle, %in, %in_333 : i32 | |
| linalg.yield %937 : i1 | |
| } -> tensor<64x512x1xi1> | |
| %12 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%8, %11 : tensor<64x512x1xi1>, tensor<64x512x1xi1>) outs(%7 : tensor<64x512x1xi1>) { | |
| ^bb0(%in: i1, %in_333: i1, %out: i1): | |
| %937 = arith.andi %in, %in_333 : i1 | |
| linalg.yield %937 : i1 | |
| } -> tensor<64x512x1xi1> | |
| %13 = linalg.fill ins(%true : i1) outs(%3 : tensor<64x512xi1>) -> tensor<64x512xi1> | |
| %14 = linalg.generic {indexing_maps = [#map1, #map3], iterator_types = ["parallel", "parallel", "reduction"]} ins(%12 : tensor<64x512x1xi1>) outs(%13 : tensor<64x512xi1>) { | |
| ^bb0(%in: i1, %out: i1): | |
| %937 = arith.andi %out, %in : i1 | |
| linalg.yield %937 : i1 | |
| } -> tensor<64x512xi1> | |
| %15 = tensor.empty() : tensor<64x512x1x768xf32> | |
| %16 = linalg.generic {indexing_maps = [#map4, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded : tensor<64x512x1xi32>) outs(%15 : tensor<64x512x1x768xf32>) { | |
| ^bb0(%in: i32, %out: f32): | |
| %937 = arith.index_cast %in : i32 to index | |
| %938 = linalg.index 3 : index | |
| %extracted = tensor.extract %cst_47[%937, %938] : tensor<50257x768xf32> | |
| linalg.yield %extracted : f32 | |
| } -> tensor<64x512x1x768xf32> | |
| %collapsed = tensor.collapse_shape %16 [[0], [1], [2, 3]] : tensor<64x512x1x768xf32> into tensor<64x512x768xf32> | |
| %17 = tensor.empty() : tensor<64x512x768xi1> | |
| %18 = linalg.generic {indexing_maps = [#map3, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%14 : tensor<64x512xi1>) outs(%17 : tensor<64x512x768xi1>) { | |
| ^bb0(%in: i1, %out: i1): | |
| linalg.yield %in : i1 | |
| } -> tensor<64x512x768xi1> | |
| %19 = tensor.empty() : tensor<64x512x768xf32> | |
| %20 = linalg.generic {indexing_maps = [#map1, #map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%18, %collapsed, %cst_61 : tensor<64x512x768xi1>, tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: i1, %in_333: f32, %in_334: f32, %out: f32): | |
| %937 = arith.select %in, %in_333, %in_334 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %hoisted_4 = util.global.load @hoisted_4 : tensor<64x512xi32> | |
| %hoisted_5 = util.global.load @hoisted_5 : tensor<64x512x1xi32> | |
| %hoisted_6 = util.global.load @hoisted_6 : tensor<1x1xi32> | |
| %hoisted_7 = util.global.load @hoisted_7 : tensor<1xi32> | |
| %hoisted_8 = util.global.load @hoisted_8 : tensor<64x512x1x768xf32> | |
| %hoisted_9 = util.global.load @hoisted_9 : tensor<64x512x768xf32> | |
| %21 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%20, %hoisted_9 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %22 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%21 : tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.mulf %in, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %23 = tensor.empty() : tensor<64x512xf32> | |
| %24 = linalg.fill ins(%cst_62 : f32) outs(%23 : tensor<64x512xf32>) -> tensor<64x512xf32> | |
| %25 = linalg.generic {indexing_maps = [#map1, #map3], iterator_types = ["parallel", "parallel", "reduction"]} ins(%22 : tensor<64x512x768xf32>) outs(%24 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.addf %out, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %26 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%25, %cst_57 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.divf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %27 = linalg.generic {indexing_maps = [#map1, #map3], iterator_types = ["parallel", "parallel", "reduction"]} ins(%21 : tensor<64x512x768xf32>) outs(%24 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.addf %out, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %28 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%27, %cst_57 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.divf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %29 = linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel"]} ins(%28 : tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.mulf %in, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %30 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%26, %29 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.subf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %31 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%30, %cst_56 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.maxf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %expanded_64 = tensor.expand_shape %31 [[0], [1, 2]] : tensor<64x512xf32> into tensor<64x512x1xf32> | |
| %32 = linalg.generic {indexing_maps = [#map3, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%28 : tensor<64x512xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| %33 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%21, %32 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.subf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %34 = tensor.empty() : tensor<64x512x1xf32> | |
| %35 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_64, %cst_55 : tensor<64x512x1xf32>, tensor<64x512x1xf32>) outs(%34 : tensor<64x512x1xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x1xf32> | |
| %36 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%35 : tensor<64x512x1xf32>) outs(%34 : tensor<64x512x1xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = math.rsqrt %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x1xf32> | |
| %37 = linalg.generic {indexing_maps = [#map6, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%36 : tensor<64x512x1xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| %hoisted_10 = util.global.load @hoisted_10 : tensor<64x512x768xf32> | |
| %38 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%37, %hoisted_10 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %39 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%33, %38 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %hoisted_11 = util.global.load @hoisted_11 : tensor<64x512x768xf32> | |
| %40 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%39, %hoisted_11 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %hoisted_12 = util.global.load @hoisted_12 : tensor<1024xi32> | |
| %41 = tensor.empty() : tensor<1x1024x1024xi32> | |
| %42 = linalg.generic {indexing_maps = [#map7, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%hoisted_12 : tensor<1024xi32>) outs(%41 : tensor<1x1024x1024xi32>) { | |
| ^bb0(%in: i32, %out: i32): | |
| linalg.yield %in : i32 | |
| } -> tensor<1x1024x1024xi32> | |
| %43 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%hoisted_12 : tensor<1024xi32>) outs(%41 : tensor<1x1024x1024xi32>) { | |
| ^bb0(%in: i32, %out: i32): | |
| linalg.yield %in : i32 | |
| } -> tensor<1x1024x1024xi32> | |
| %44 = tensor.empty() : tensor<1x1024x1024xi1> | |
| %45 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%42, %43 : tensor<1x1024x1024xi32>, tensor<1x1024x1024xi32>) outs(%44 : tensor<1x1024x1024xi1>) { | |
| ^bb0(%in: i32, %in_333: i32, %out: i1): | |
| %937 = arith.cmpi sge, %in, %in_333 : i32 | |
| linalg.yield %937 : i1 | |
| } -> tensor<1x1024x1024xi1> | |
| %46 = tensor.empty() : tensor<1x1x1024x1024xi1> | |
| %47 = linalg.generic {indexing_maps = [#map8, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%45 : tensor<1x1024x1024xi1>) outs(%46 : tensor<1x1x1024x1024xi1>) { | |
| ^bb0(%in: i1, %out: i1): | |
| linalg.yield %in : i1 | |
| } -> tensor<1x1x1024x1024xi1> | |
| %hoisted_13 = util.global.load @hoisted_13 : tensor<768x2304xf32> | |
| %collapsed_65 = tensor.collapse_shape %40 [[0, 1], [2]] : tensor<64x512x768xf32> into tensor<32768x768xf32> | |
| %48 = tensor.empty() : tensor<32768x2304xf32> | |
| %49 = linalg.fill ins(%cst_62 : f32) outs(%48 : tensor<32768x2304xf32>) -> tensor<32768x2304xf32> | |
| %50 = linalg.matmul ins(%collapsed_65, %hoisted_13 : tensor<32768x768xf32>, tensor<768x2304xf32>) outs(%49 : tensor<32768x2304xf32>) -> tensor<32768x2304xf32> | |
| %expanded_66 = tensor.expand_shape %50 [[0, 1], [2]] : tensor<32768x2304xf32> into tensor<64x512x2304xf32> | |
| %51 = tensor.empty() : tensor<64x512x2304xf32> | |
| %52 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%cst_46 : tensor<2304xf32>) outs(%51 : tensor<64x512x2304xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x2304xf32> | |
| %53 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_66, %52 : tensor<64x512x2304xf32>, tensor<64x512x2304xf32>) outs(%51 : tensor<64x512x2304xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x2304xf32> | |
| %extracted_slice = tensor.extract_slice %53[0, 0, 0] [64, 512, 768] [1, 1, 1] : tensor<64x512x2304xf32> to tensor<64x512x768xf32> | |
| %extracted_slice_67 = tensor.extract_slice %53[0, 0, 768] [64, 512, 768] [1, 1, 1] : tensor<64x512x2304xf32> to tensor<64x512x768xf32> | |
| %extracted_slice_68 = tensor.extract_slice %53[0, 0, 1536] [64, 512, 768] [1, 1, 1] : tensor<64x512x2304xf32> to tensor<64x512x768xf32> | |
| %expanded_69 = tensor.expand_shape %extracted_slice [[0], [1], [2, 3]] : tensor<64x512x768xf32> into tensor<64x512x12x64xf32> | |
| %expanded_70 = tensor.expand_shape %extracted_slice_67 [[0], [1], [2, 3]] : tensor<64x512x768xf32> into tensor<64x512x12x64xf32> | |
| %expanded_71 = tensor.expand_shape %extracted_slice_68 [[0], [1], [2, 3]] : tensor<64x512x768xf32> into tensor<64x512x12x64xf32> | |
| %extracted_slice_72 = tensor.extract_slice %47[0, 0, 0, 0] [1, 1, 512, 512] [1, 1, 1, 1] : tensor<1x1x1024x1024xi1> to tensor<1x1x512x512xi1> | |
| %collapsed_73 = tensor.collapse_shape %extracted_slice_72 [[0], [1, 2], [3]] : tensor<1x1x512x512xi1> into tensor<1x512x512xi1> | |
| %54 = tensor.empty() : tensor<64x1x512x512xi1> | |
| %55 = linalg.generic {indexing_maps = [#map9, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%collapsed_73 : tensor<1x512x512xi1>) outs(%54 : tensor<64x1x512x512xi1>) { | |
| ^bb0(%in: i1, %out: i1): | |
| linalg.yield %in : i1 | |
| } -> tensor<64x1x512x512xi1> | |
| %56 = tensor.empty() : tensor<64x1x1x512xi32> | |
| %57 = linalg.generic {indexing_maps = [#map10, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1 : tensor<64x512xi32>) outs(%56 : tensor<64x1x1x512xi32>) { | |
| ^bb0(%in: i32, %out: i32): | |
| linalg.yield %in : i32 | |
| } -> tensor<64x1x1x512xi32> | |
| %collapsed_74 = tensor.collapse_shape %57 [[0], [1], [2, 3]] : tensor<64x1x1x512xi32> into tensor<64x1x512xi32> | |
| %58 = tensor.empty() : tensor<64x1x512x512xi32> | |
| %59 = linalg.generic {indexing_maps = [#map11, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%collapsed_74 : tensor<64x1x512xi32>) outs(%58 : tensor<64x1x512x512xi32>) { | |
| ^bb0(%in: i32, %out: i32): | |
| linalg.yield %in : i32 | |
| } -> tensor<64x1x512x512xi32> | |
| %60 = linalg.generic {indexing_maps = [#map5, #map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%59, %cst_54 : tensor<64x1x512x512xi32>, tensor<64x1x512x512xi32>) outs(%54 : tensor<64x1x512x512xi1>) { | |
| ^bb0(%in: i32, %in_333: i32, %out: i1): | |
| %937 = arith.cmpi ne, %in, %in_333 : i32 | |
| linalg.yield %937 : i1 | |
| } -> tensor<64x1x512x512xi1> | |
| %61 = linalg.generic {indexing_maps = [#map5, #map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%60, %55 : tensor<64x1x512x512xi1>, tensor<64x1x512x512xi1>) outs(%54 : tensor<64x1x512x512xi1>) { | |
| ^bb0(%in: i1, %in_333: i1, %out: i1): | |
| %937 = arith.andi %in, %in_333 : i1 | |
| linalg.yield %937 : i1 | |
| } -> tensor<64x1x512x512xi1> | |
| %62 = tensor.empty() : tensor<64x1x512x512xf32> | |
| %63 = linalg.generic {indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%61 : tensor<64x1x512x512xi1>) outs(%62 : tensor<64x1x512x512xf32>) { | |
| ^bb0(%in: i1, %out: f32): | |
| %937 = arith.uitofp %in : i1 to f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x1x512x512xf32> | |
| %64 = linalg.generic {indexing_maps = [#map5, #map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%63, %cst_53 : tensor<64x1x512x512xf32>, tensor<64x1x512x512xf32>) outs(%54 : tensor<64x1x512x512xi1>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: i1): | |
| %937 = arith.cmpf ogt, %in, %in_333 : f32 | |
| linalg.yield %937 : i1 | |
| } -> tensor<64x1x512x512xi1> | |
| %65 = linalg.generic {indexing_maps = [#map5, #map5, #map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%64, %cst_53, %cst_52 : tensor<64x1x512x512xi1>, tensor<64x1x512x512xf32>, tensor<64x1x512x512xf32>) outs(%62 : tensor<64x1x512x512xf32>) { | |
| ^bb0(%in: i1, %in_333: f32, %in_334: f32, %out: f32): | |
| %937 = arith.select %in, %in_333, %in_334 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x1x512x512xf32> | |
| %hoisted_14 = util.global.load @hoisted_14 : tensor<f32> | |
| %66 = tensor.empty() : tensor<64x512x12x64xf32> | |
| %67 = linalg.generic {indexing_maps = [#map12, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%hoisted_14 : tensor<f32>) outs(%66 : tensor<64x512x12x64xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x12x64xf32> | |
| %68 = linalg.generic {indexing_maps = [#map5, #map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_69, %67 : tensor<64x512x12x64xf32>, tensor<64x512x12x64xf32>) outs(%66 : tensor<64x512x12x64xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.divf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x12x64xf32> | |
| %69 = tensor.empty() : tensor<64x12x512x64xf32> | |
| %70 = linalg.generic {indexing_maps = [#map13, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%68 : tensor<64x512x12x64xf32>) outs(%69 : tensor<64x12x512x64xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x12x512x64xf32> | |
| %71 = tensor.empty() : tensor<64x12x64x512xf32> | |
| %72 = linalg.generic {indexing_maps = [#map14, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_70 : tensor<64x512x12x64xf32>) outs(%71 : tensor<64x12x64x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x12x64x512xf32> | |
| %collapsed_75 = tensor.collapse_shape %70 [[0, 1], [2], [3]] : tensor<64x12x512x64xf32> into tensor<768x512x64xf32> | |
| %collapsed_76 = tensor.collapse_shape %72 [[0, 1], [2], [3]] : tensor<64x12x64x512xf32> into tensor<768x64x512xf32> | |
| %73 = tensor.empty() : tensor<768x512x512xf32> | |
| %74 = linalg.fill ins(%cst_62 : f32) outs(%73 : tensor<768x512x512xf32>) -> tensor<768x512x512xf32> | |
| %75 = linalg.batch_matmul ins(%collapsed_75, %collapsed_76 : tensor<768x512x64xf32>, tensor<768x64x512xf32>) outs(%74 : tensor<768x512x512xf32>) -> tensor<768x512x512xf32> | |
| %expanded_77 = tensor.expand_shape %75 [[0, 1], [2], [3]] : tensor<768x512x512xf32> into tensor<64x12x512x512xf32> | |
| %76 = tensor.empty() : tensor<64x12x512x512xf32> | |
| %77 = linalg.generic {indexing_maps = [#map15, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%65 : tensor<64x1x512x512xf32>) outs(%76 : tensor<64x12x512x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x12x512x512xf32> | |
| %78 = linalg.generic {indexing_maps = [#map5, #map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_77, %77 : tensor<64x12x512x512xf32>, tensor<64x12x512x512xf32>) outs(%76 : tensor<64x12x512x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x12x512x512xf32> | |
| %79 = tensor.empty() : tensor<64x12x512xf32> | |
| %80 = linalg.fill ins(%cst_63 : f32) outs(%79 : tensor<64x12x512xf32>) -> tensor<64x12x512xf32> | |
| %81 = linalg.generic {indexing_maps = [#map5, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%78 : tensor<64x12x512x512xf32>) outs(%80 : tensor<64x12x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.maxf %out, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x12x512xf32> | |
| %82 = linalg.generic {indexing_maps = [#map4, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%81 : tensor<64x12x512xf32>) outs(%76 : tensor<64x12x512x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x12x512x512xf32> | |
| %83 = linalg.generic {indexing_maps = [#map5, #map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%78, %82 : tensor<64x12x512x512xf32>, tensor<64x12x512x512xf32>) outs(%76 : tensor<64x12x512x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.subf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x12x512x512xf32> | |
| %84 = linalg.generic {indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%83 : tensor<64x12x512x512xf32>) outs(%76 : tensor<64x12x512x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = math.exp %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x12x512x512xf32> | |
| %85 = linalg.fill ins(%cst_62 : f32) outs(%79 : tensor<64x12x512xf32>) -> tensor<64x12x512xf32> | |
| %86 = linalg.generic {indexing_maps = [#map5, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%84 : tensor<64x12x512x512xf32>) outs(%85 : tensor<64x12x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.addf %out, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x12x512xf32> | |
| %87 = linalg.generic {indexing_maps = [#map4, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%86 : tensor<64x12x512xf32>) outs(%76 : tensor<64x12x512x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x12x512x512xf32> | |
| %88 = linalg.generic {indexing_maps = [#map5, #map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%84, %87 : tensor<64x12x512x512xf32>, tensor<64x12x512x512xf32>) outs(%76 : tensor<64x12x512x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.divf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x12x512x512xf32> | |
| %89 = linalg.generic {indexing_maps = [#map14, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_71 : tensor<64x512x12x64xf32>) outs(%71 : tensor<64x12x64x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x12x64x512xf32> | |
| %90 = linalg.generic {indexing_maps = [#map16, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%88 : tensor<64x12x512x512xf32>) outs(%76 : tensor<64x12x512x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x12x512x512xf32> | |
| %collapsed_78 = tensor.collapse_shape %89 [[0, 1], [2], [3]] : tensor<64x12x64x512xf32> into tensor<768x64x512xf32> | |
| %collapsed_79 = tensor.collapse_shape %90 [[0, 1], [2], [3]] : tensor<64x12x512x512xf32> into tensor<768x512x512xf32> | |
| %91 = tensor.empty() : tensor<768x64x512xf32> | |
| %92 = linalg.fill ins(%cst_62 : f32) outs(%91 : tensor<768x64x512xf32>) -> tensor<768x64x512xf32> | |
| %93 = linalg.batch_matmul ins(%collapsed_78, %collapsed_79 : tensor<768x64x512xf32>, tensor<768x512x512xf32>) outs(%92 : tensor<768x64x512xf32>) -> tensor<768x64x512xf32> | |
| %expanded_80 = tensor.expand_shape %93 [[0, 1], [2], [3]] : tensor<768x64x512xf32> into tensor<64x12x64x512xf32> | |
| %94 = linalg.generic {indexing_maps = [#map17, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_80 : tensor<64x12x64x512xf32>) outs(%66 : tensor<64x512x12x64xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x12x64xf32> | |
| %hoisted_15 = util.global.load @hoisted_15 : tensor<768x768xf32> | |
| %collapsed_81 = tensor.collapse_shape %94 [[0, 1], [2, 3]] : tensor<64x512x12x64xf32> into tensor<32768x768xf32> | |
| %95 = tensor.empty() : tensor<32768x768xf32> | |
| %96 = linalg.fill ins(%cst_62 : f32) outs(%95 : tensor<32768x768xf32>) -> tensor<32768x768xf32> | |
| %97 = linalg.matmul ins(%collapsed_81, %hoisted_15 : tensor<32768x768xf32>, tensor<768x768xf32>) outs(%96 : tensor<32768x768xf32>) -> tensor<32768x768xf32> | |
| %expanded_82 = tensor.expand_shape %97 [[0, 1], [2]] : tensor<32768x768xf32> into tensor<64x512x768xf32> | |
| %98 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%cst_45 : tensor<768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| %99 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_82, %98 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %100 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%99, %21 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %101 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%100 : tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.mulf %in, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %102 = linalg.generic {indexing_maps = [#map1, #map3], iterator_types = ["parallel", "parallel", "reduction"]} ins(%101 : tensor<64x512x768xf32>) outs(%24 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.addf %out, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %103 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%102, %cst_57 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.divf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %104 = linalg.generic {indexing_maps = [#map1, #map3], iterator_types = ["parallel", "parallel", "reduction"]} ins(%100 : tensor<64x512x768xf32>) outs(%24 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.addf %out, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %105 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%104, %cst_57 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.divf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %106 = linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel"]} ins(%105 : tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.mulf %in, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %107 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%103, %106 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.subf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %108 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%107, %cst_56 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.maxf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %expanded_83 = tensor.expand_shape %108 [[0], [1, 2]] : tensor<64x512xf32> into tensor<64x512x1xf32> | |
| %109 = linalg.generic {indexing_maps = [#map3, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%105 : tensor<64x512xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| %110 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%100, %109 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.subf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %111 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_83, %cst_55 : tensor<64x512x1xf32>, tensor<64x512x1xf32>) outs(%34 : tensor<64x512x1xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x1xf32> | |
| %112 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%111 : tensor<64x512x1xf32>) outs(%34 : tensor<64x512x1xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = math.rsqrt %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x1xf32> | |
| %113 = linalg.generic {indexing_maps = [#map6, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%112 : tensor<64x512x1xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| %hoisted_16 = util.global.load @hoisted_16 : tensor<64x512x768xf32> | |
| %114 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%113, %hoisted_16 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %115 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%110, %114 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %hoisted_17 = util.global.load @hoisted_17 : tensor<64x512x768xf32> | |
| %116 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%115, %hoisted_17 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %hoisted_18 = util.global.load @hoisted_18 : tensor<768x3072xf32> | |
| %collapsed_84 = tensor.collapse_shape %116 [[0, 1], [2]] : tensor<64x512x768xf32> into tensor<32768x768xf32> | |
| %117 = tensor.empty() : tensor<32768x3072xf32> | |
| %118 = linalg.fill ins(%cst_62 : f32) outs(%117 : tensor<32768x3072xf32>) -> tensor<32768x3072xf32> | |
| %119 = linalg.matmul ins(%collapsed_84, %hoisted_18 : tensor<32768x768xf32>, tensor<768x3072xf32>) outs(%118 : tensor<32768x3072xf32>) -> tensor<32768x3072xf32> | |
| %expanded_85 = tensor.expand_shape %119 [[0, 1], [2]] : tensor<32768x3072xf32> into tensor<64x512x3072xf32> | |
| %120 = tensor.empty() : tensor<64x512x3072xf32> | |
| %121 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%cst_44 : tensor<3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %122 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_85, %121 : tensor<64x512x3072xf32>, tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %123 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%122 : tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.mulf %in, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %124 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%122, %123 : tensor<64x512x3072xf32>, tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %125 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%124, %cst_51 : tensor<64x512x3072xf32>, tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %126 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%122, %125 : tensor<64x512x3072xf32>, tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %127 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%126, %cst_50 : tensor<64x512x3072xf32>, tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %128 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%127 : tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = math.tanh %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %129 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%128, %cst_49 : tensor<64x512x3072xf32>, tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %130 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%129, %cst_48 : tensor<64x512x3072xf32>, tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %131 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%122, %130 : tensor<64x512x3072xf32>, tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %hoisted_19 = util.global.load @hoisted_19 : tensor<3072x768xf32> | |
| %collapsed_86 = tensor.collapse_shape %131 [[0, 1], [2]] : tensor<64x512x3072xf32> into tensor<32768x3072xf32> | |
| %132 = linalg.matmul ins(%collapsed_86, %hoisted_19 : tensor<32768x3072xf32>, tensor<3072x768xf32>) outs(%96 : tensor<32768x768xf32>) -> tensor<32768x768xf32> | |
| %expanded_87 = tensor.expand_shape %132 [[0, 1], [2]] : tensor<32768x768xf32> into tensor<64x512x768xf32> | |
| %133 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%cst_43 : tensor<768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| %134 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_87, %133 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %135 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%100, %134 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %136 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%135 : tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.mulf %in, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %137 = linalg.generic {indexing_maps = [#map1, #map3], iterator_types = ["parallel", "parallel", "reduction"]} ins(%136 : tensor<64x512x768xf32>) outs(%24 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.addf %out, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %138 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%137, %cst_57 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.divf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %139 = linalg.generic {indexing_maps = [#map1, #map3], iterator_types = ["parallel", "parallel", "reduction"]} ins(%135 : tensor<64x512x768xf32>) outs(%24 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.addf %out, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %140 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%139, %cst_57 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.divf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %141 = linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel"]} ins(%140 : tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.mulf %in, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %142 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%138, %141 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.subf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %143 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%142, %cst_56 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.maxf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %expanded_88 = tensor.expand_shape %143 [[0], [1, 2]] : tensor<64x512xf32> into tensor<64x512x1xf32> | |
| %144 = linalg.generic {indexing_maps = [#map3, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%140 : tensor<64x512xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| %145 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%135, %144 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.subf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %146 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_88, %cst_55 : tensor<64x512x1xf32>, tensor<64x512x1xf32>) outs(%34 : tensor<64x512x1xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x1xf32> | |
| %147 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%146 : tensor<64x512x1xf32>) outs(%34 : tensor<64x512x1xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = math.rsqrt %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x1xf32> | |
| %148 = linalg.generic {indexing_maps = [#map6, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%147 : tensor<64x512x1xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| %hoisted_20 = util.global.load @hoisted_20 : tensor<64x512x768xf32> | |
| %149 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%148, %hoisted_20 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %150 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%145, %149 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %hoisted_21 = util.global.load @hoisted_21 : tensor<64x512x768xf32> | |
| %151 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%150, %hoisted_21 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %hoisted_22 = util.global.load @hoisted_22 : tensor<768x2304xf32> | |
| %collapsed_89 = tensor.collapse_shape %151 [[0, 1], [2]] : tensor<64x512x768xf32> into tensor<32768x768xf32> | |
| %152 = linalg.matmul ins(%collapsed_89, %hoisted_22 : tensor<32768x768xf32>, tensor<768x2304xf32>) outs(%49 : tensor<32768x2304xf32>) -> tensor<32768x2304xf32> | |
| %expanded_90 = tensor.expand_shape %152 [[0, 1], [2]] : tensor<32768x2304xf32> into tensor<64x512x2304xf32> | |
| %153 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%cst_42 : tensor<2304xf32>) outs(%51 : tensor<64x512x2304xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x2304xf32> | |
| %154 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_90, %153 : tensor<64x512x2304xf32>, tensor<64x512x2304xf32>) outs(%51 : tensor<64x512x2304xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x2304xf32> | |
| %extracted_slice_91 = tensor.extract_slice %154[0, 0, 0] [64, 512, 768] [1, 1, 1] : tensor<64x512x2304xf32> to tensor<64x512x768xf32> | |
| %extracted_slice_92 = tensor.extract_slice %154[0, 0, 768] [64, 512, 768] [1, 1, 1] : tensor<64x512x2304xf32> to tensor<64x512x768xf32> | |
| %extracted_slice_93 = tensor.extract_slice %154[0, 0, 1536] [64, 512, 768] [1, 1, 1] : tensor<64x512x2304xf32> to tensor<64x512x768xf32> | |
| %expanded_94 = tensor.expand_shape %extracted_slice_91 [[0], [1], [2, 3]] : tensor<64x512x768xf32> into tensor<64x512x12x64xf32> | |
| %expanded_95 = tensor.expand_shape %extracted_slice_92 [[0], [1], [2, 3]] : tensor<64x512x768xf32> into tensor<64x512x12x64xf32> | |
| %expanded_96 = tensor.expand_shape %extracted_slice_93 [[0], [1], [2, 3]] : tensor<64x512x768xf32> into tensor<64x512x12x64xf32> | |
| %155 = linalg.generic {indexing_maps = [#map5, #map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_94, %67 : tensor<64x512x12x64xf32>, tensor<64x512x12x64xf32>) outs(%66 : tensor<64x512x12x64xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.divf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x12x64xf32> | |
| %156 = linalg.generic {indexing_maps = [#map13, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%155 : tensor<64x512x12x64xf32>) outs(%69 : tensor<64x12x512x64xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x12x512x64xf32> | |
| %157 = linalg.generic {indexing_maps = [#map14, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_95 : tensor<64x512x12x64xf32>) outs(%71 : tensor<64x12x64x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x12x64x512xf32> | |
| %collapsed_97 = tensor.collapse_shape %156 [[0, 1], [2], [3]] : tensor<64x12x512x64xf32> into tensor<768x512x64xf32> | |
| %collapsed_98 = tensor.collapse_shape %157 [[0, 1], [2], [3]] : tensor<64x12x64x512xf32> into tensor<768x64x512xf32> | |
| %158 = linalg.batch_matmul ins(%collapsed_97, %collapsed_98 : tensor<768x512x64xf32>, tensor<768x64x512xf32>) outs(%74 : tensor<768x512x512xf32>) -> tensor<768x512x512xf32> | |
| %expanded_99 = tensor.expand_shape %158 [[0, 1], [2], [3]] : tensor<768x512x512xf32> into tensor<64x12x512x512xf32> | |
| %159 = linalg.generic {indexing_maps = [#map5, #map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_99, %77 : tensor<64x12x512x512xf32>, tensor<64x12x512x512xf32>) outs(%76 : tensor<64x12x512x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x12x512x512xf32> | |
| %160 = linalg.generic {indexing_maps = [#map5, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%159 : tensor<64x12x512x512xf32>) outs(%80 : tensor<64x12x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.maxf %out, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x12x512xf32> | |
| %161 = linalg.generic {indexing_maps = [#map4, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%160 : tensor<64x12x512xf32>) outs(%76 : tensor<64x12x512x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x12x512x512xf32> | |
| %162 = linalg.generic {indexing_maps = [#map5, #map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%159, %161 : tensor<64x12x512x512xf32>, tensor<64x12x512x512xf32>) outs(%76 : tensor<64x12x512x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.subf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x12x512x512xf32> | |
| %163 = linalg.generic {indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%162 : tensor<64x12x512x512xf32>) outs(%76 : tensor<64x12x512x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = math.exp %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x12x512x512xf32> | |
| %164 = linalg.generic {indexing_maps = [#map5, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%163 : tensor<64x12x512x512xf32>) outs(%85 : tensor<64x12x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.addf %out, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x12x512xf32> | |
| %165 = linalg.generic {indexing_maps = [#map4, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%164 : tensor<64x12x512xf32>) outs(%76 : tensor<64x12x512x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x12x512x512xf32> | |
| %166 = linalg.generic {indexing_maps = [#map5, #map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%163, %165 : tensor<64x12x512x512xf32>, tensor<64x12x512x512xf32>) outs(%76 : tensor<64x12x512x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.divf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x12x512x512xf32> | |
| %167 = linalg.generic {indexing_maps = [#map14, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_96 : tensor<64x512x12x64xf32>) outs(%71 : tensor<64x12x64x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x12x64x512xf32> | |
| %168 = linalg.generic {indexing_maps = [#map16, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%166 : tensor<64x12x512x512xf32>) outs(%76 : tensor<64x12x512x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x12x512x512xf32> | |
| %collapsed_100 = tensor.collapse_shape %167 [[0, 1], [2], [3]] : tensor<64x12x64x512xf32> into tensor<768x64x512xf32> | |
| %collapsed_101 = tensor.collapse_shape %168 [[0, 1], [2], [3]] : tensor<64x12x512x512xf32> into tensor<768x512x512xf32> | |
| %169 = linalg.batch_matmul ins(%collapsed_100, %collapsed_101 : tensor<768x64x512xf32>, tensor<768x512x512xf32>) outs(%92 : tensor<768x64x512xf32>) -> tensor<768x64x512xf32> | |
| %expanded_102 = tensor.expand_shape %169 [[0, 1], [2], [3]] : tensor<768x64x512xf32> into tensor<64x12x64x512xf32> | |
| %170 = linalg.generic {indexing_maps = [#map17, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_102 : tensor<64x12x64x512xf32>) outs(%66 : tensor<64x512x12x64xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x12x64xf32> | |
| %hoisted_23 = util.global.load @hoisted_23 : tensor<768x768xf32> | |
| %collapsed_103 = tensor.collapse_shape %170 [[0, 1], [2, 3]] : tensor<64x512x12x64xf32> into tensor<32768x768xf32> | |
| %171 = linalg.matmul ins(%collapsed_103, %hoisted_23 : tensor<32768x768xf32>, tensor<768x768xf32>) outs(%96 : tensor<32768x768xf32>) -> tensor<32768x768xf32> | |
| %expanded_104 = tensor.expand_shape %171 [[0, 1], [2]] : tensor<32768x768xf32> into tensor<64x512x768xf32> | |
| %172 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%cst_41 : tensor<768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| %173 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_104, %172 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %174 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%173, %135 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %175 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%174 : tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.mulf %in, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %176 = linalg.generic {indexing_maps = [#map1, #map3], iterator_types = ["parallel", "parallel", "reduction"]} ins(%175 : tensor<64x512x768xf32>) outs(%24 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.addf %out, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %177 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%176, %cst_57 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.divf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %178 = linalg.generic {indexing_maps = [#map1, #map3], iterator_types = ["parallel", "parallel", "reduction"]} ins(%174 : tensor<64x512x768xf32>) outs(%24 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.addf %out, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %179 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%178, %cst_57 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.divf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %180 = linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel"]} ins(%179 : tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.mulf %in, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %181 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%177, %180 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.subf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %182 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%181, %cst_56 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.maxf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %expanded_105 = tensor.expand_shape %182 [[0], [1, 2]] : tensor<64x512xf32> into tensor<64x512x1xf32> | |
| %183 = linalg.generic {indexing_maps = [#map3, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%179 : tensor<64x512xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| %184 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%174, %183 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.subf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %185 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_105, %cst_55 : tensor<64x512x1xf32>, tensor<64x512x1xf32>) outs(%34 : tensor<64x512x1xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x1xf32> | |
| %186 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%185 : tensor<64x512x1xf32>) outs(%34 : tensor<64x512x1xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = math.rsqrt %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x1xf32> | |
| %187 = linalg.generic {indexing_maps = [#map6, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%186 : tensor<64x512x1xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| %hoisted_24 = util.global.load @hoisted_24 : tensor<64x512x768xf32> | |
| %188 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%187, %hoisted_24 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %189 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%184, %188 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %hoisted_25 = util.global.load @hoisted_25 : tensor<64x512x768xf32> | |
| %190 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%189, %hoisted_25 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %hoisted_26 = util.global.load @hoisted_26 : tensor<768x3072xf32> | |
| %collapsed_106 = tensor.collapse_shape %190 [[0, 1], [2]] : tensor<64x512x768xf32> into tensor<32768x768xf32> | |
| %191 = linalg.matmul ins(%collapsed_106, %hoisted_26 : tensor<32768x768xf32>, tensor<768x3072xf32>) outs(%118 : tensor<32768x3072xf32>) -> tensor<32768x3072xf32> | |
| %expanded_107 = tensor.expand_shape %191 [[0, 1], [2]] : tensor<32768x3072xf32> into tensor<64x512x3072xf32> | |
| %192 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%cst_40 : tensor<3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %193 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_107, %192 : tensor<64x512x3072xf32>, tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %194 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%193 : tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.mulf %in, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %195 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%193, %194 : tensor<64x512x3072xf32>, tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %196 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%195, %cst_51 : tensor<64x512x3072xf32>, tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %197 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%193, %196 : tensor<64x512x3072xf32>, tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %198 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%197, %cst_50 : tensor<64x512x3072xf32>, tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %199 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%198 : tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = math.tanh %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %200 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%199, %cst_49 : tensor<64x512x3072xf32>, tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %201 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%200, %cst_48 : tensor<64x512x3072xf32>, tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %202 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%193, %201 : tensor<64x512x3072xf32>, tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %hoisted_27 = util.global.load @hoisted_27 : tensor<3072x768xf32> | |
| %collapsed_108 = tensor.collapse_shape %202 [[0, 1], [2]] : tensor<64x512x3072xf32> into tensor<32768x3072xf32> | |
| %203 = linalg.matmul ins(%collapsed_108, %hoisted_27 : tensor<32768x3072xf32>, tensor<3072x768xf32>) outs(%96 : tensor<32768x768xf32>) -> tensor<32768x768xf32> | |
| %expanded_109 = tensor.expand_shape %203 [[0, 1], [2]] : tensor<32768x768xf32> into tensor<64x512x768xf32> | |
| %204 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%cst_39 : tensor<768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| %205 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_109, %204 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %206 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%174, %205 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %207 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%206 : tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.mulf %in, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %208 = linalg.generic {indexing_maps = [#map1, #map3], iterator_types = ["parallel", "parallel", "reduction"]} ins(%207 : tensor<64x512x768xf32>) outs(%24 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.addf %out, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %209 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%208, %cst_57 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.divf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %210 = linalg.generic {indexing_maps = [#map1, #map3], iterator_types = ["parallel", "parallel", "reduction"]} ins(%206 : tensor<64x512x768xf32>) outs(%24 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.addf %out, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %211 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%210, %cst_57 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.divf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %212 = linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel"]} ins(%211 : tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.mulf %in, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %213 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%209, %212 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.subf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %214 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%213, %cst_56 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.maxf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %expanded_110 = tensor.expand_shape %214 [[0], [1, 2]] : tensor<64x512xf32> into tensor<64x512x1xf32> | |
| %215 = linalg.generic {indexing_maps = [#map3, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%211 : tensor<64x512xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| %216 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%206, %215 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.subf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %217 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_110, %cst_55 : tensor<64x512x1xf32>, tensor<64x512x1xf32>) outs(%34 : tensor<64x512x1xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x1xf32> | |
| %218 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%217 : tensor<64x512x1xf32>) outs(%34 : tensor<64x512x1xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = math.rsqrt %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x1xf32> | |
| %219 = linalg.generic {indexing_maps = [#map6, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%218 : tensor<64x512x1xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| %hoisted_28 = util.global.load @hoisted_28 : tensor<64x512x768xf32> | |
| %220 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%219, %hoisted_28 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %221 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%216, %220 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %hoisted_29 = util.global.load @hoisted_29 : tensor<64x512x768xf32> | |
| %222 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%221, %hoisted_29 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %hoisted_30 = util.global.load @hoisted_30 : tensor<768x2304xf32> | |
| %collapsed_111 = tensor.collapse_shape %222 [[0, 1], [2]] : tensor<64x512x768xf32> into tensor<32768x768xf32> | |
| %223 = linalg.matmul ins(%collapsed_111, %hoisted_30 : tensor<32768x768xf32>, tensor<768x2304xf32>) outs(%49 : tensor<32768x2304xf32>) -> tensor<32768x2304xf32> | |
| %expanded_112 = tensor.expand_shape %223 [[0, 1], [2]] : tensor<32768x2304xf32> into tensor<64x512x2304xf32> | |
| %224 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%cst_38 : tensor<2304xf32>) outs(%51 : tensor<64x512x2304xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x2304xf32> | |
| %225 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_112, %224 : tensor<64x512x2304xf32>, tensor<64x512x2304xf32>) outs(%51 : tensor<64x512x2304xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x2304xf32> | |
| %extracted_slice_113 = tensor.extract_slice %225[0, 0, 0] [64, 512, 768] [1, 1, 1] : tensor<64x512x2304xf32> to tensor<64x512x768xf32> | |
| %extracted_slice_114 = tensor.extract_slice %225[0, 0, 768] [64, 512, 768] [1, 1, 1] : tensor<64x512x2304xf32> to tensor<64x512x768xf32> | |
| %extracted_slice_115 = tensor.extract_slice %225[0, 0, 1536] [64, 512, 768] [1, 1, 1] : tensor<64x512x2304xf32> to tensor<64x512x768xf32> | |
| %expanded_116 = tensor.expand_shape %extracted_slice_113 [[0], [1], [2, 3]] : tensor<64x512x768xf32> into tensor<64x512x12x64xf32> | |
| %expanded_117 = tensor.expand_shape %extracted_slice_114 [[0], [1], [2, 3]] : tensor<64x512x768xf32> into tensor<64x512x12x64xf32> | |
| %expanded_118 = tensor.expand_shape %extracted_slice_115 [[0], [1], [2, 3]] : tensor<64x512x768xf32> into tensor<64x512x12x64xf32> | |
| %226 = linalg.generic {indexing_maps = [#map5, #map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_116, %67 : tensor<64x512x12x64xf32>, tensor<64x512x12x64xf32>) outs(%66 : tensor<64x512x12x64xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.divf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x12x64xf32> | |
| %227 = linalg.generic {indexing_maps = [#map13, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%226 : tensor<64x512x12x64xf32>) outs(%69 : tensor<64x12x512x64xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x12x512x64xf32> | |
| %228 = linalg.generic {indexing_maps = [#map14, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_117 : tensor<64x512x12x64xf32>) outs(%71 : tensor<64x12x64x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x12x64x512xf32> | |
| %collapsed_119 = tensor.collapse_shape %227 [[0, 1], [2], [3]] : tensor<64x12x512x64xf32> into tensor<768x512x64xf32> | |
| %collapsed_120 = tensor.collapse_shape %228 [[0, 1], [2], [3]] : tensor<64x12x64x512xf32> into tensor<768x64x512xf32> | |
| %229 = linalg.batch_matmul ins(%collapsed_119, %collapsed_120 : tensor<768x512x64xf32>, tensor<768x64x512xf32>) outs(%74 : tensor<768x512x512xf32>) -> tensor<768x512x512xf32> | |
| %expanded_121 = tensor.expand_shape %229 [[0, 1], [2], [3]] : tensor<768x512x512xf32> into tensor<64x12x512x512xf32> | |
| %230 = linalg.generic {indexing_maps = [#map5, #map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_121, %77 : tensor<64x12x512x512xf32>, tensor<64x12x512x512xf32>) outs(%76 : tensor<64x12x512x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x12x512x512xf32> | |
| %231 = linalg.generic {indexing_maps = [#map5, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%230 : tensor<64x12x512x512xf32>) outs(%80 : tensor<64x12x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.maxf %out, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x12x512xf32> | |
| %232 = linalg.generic {indexing_maps = [#map4, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%231 : tensor<64x12x512xf32>) outs(%76 : tensor<64x12x512x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x12x512x512xf32> | |
| %233 = linalg.generic {indexing_maps = [#map5, #map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%230, %232 : tensor<64x12x512x512xf32>, tensor<64x12x512x512xf32>) outs(%76 : tensor<64x12x512x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.subf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x12x512x512xf32> | |
| %234 = linalg.generic {indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%233 : tensor<64x12x512x512xf32>) outs(%76 : tensor<64x12x512x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = math.exp %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x12x512x512xf32> | |
| %235 = linalg.generic {indexing_maps = [#map5, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%234 : tensor<64x12x512x512xf32>) outs(%85 : tensor<64x12x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.addf %out, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x12x512xf32> | |
| %236 = linalg.generic {indexing_maps = [#map4, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%235 : tensor<64x12x512xf32>) outs(%76 : tensor<64x12x512x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x12x512x512xf32> | |
| %237 = linalg.generic {indexing_maps = [#map5, #map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%234, %236 : tensor<64x12x512x512xf32>, tensor<64x12x512x512xf32>) outs(%76 : tensor<64x12x512x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.divf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x12x512x512xf32> | |
| %238 = linalg.generic {indexing_maps = [#map14, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_118 : tensor<64x512x12x64xf32>) outs(%71 : tensor<64x12x64x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x12x64x512xf32> | |
| %239 = linalg.generic {indexing_maps = [#map16, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%237 : tensor<64x12x512x512xf32>) outs(%76 : tensor<64x12x512x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x12x512x512xf32> | |
| %collapsed_122 = tensor.collapse_shape %238 [[0, 1], [2], [3]] : tensor<64x12x64x512xf32> into tensor<768x64x512xf32> | |
| %collapsed_123 = tensor.collapse_shape %239 [[0, 1], [2], [3]] : tensor<64x12x512x512xf32> into tensor<768x512x512xf32> | |
| %240 = linalg.batch_matmul ins(%collapsed_122, %collapsed_123 : tensor<768x64x512xf32>, tensor<768x512x512xf32>) outs(%92 : tensor<768x64x512xf32>) -> tensor<768x64x512xf32> | |
| %expanded_124 = tensor.expand_shape %240 [[0, 1], [2], [3]] : tensor<768x64x512xf32> into tensor<64x12x64x512xf32> | |
| %241 = linalg.generic {indexing_maps = [#map17, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_124 : tensor<64x12x64x512xf32>) outs(%66 : tensor<64x512x12x64xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x12x64xf32> | |
| %hoisted_31 = util.global.load @hoisted_31 : tensor<768x768xf32> | |
| %collapsed_125 = tensor.collapse_shape %241 [[0, 1], [2, 3]] : tensor<64x512x12x64xf32> into tensor<32768x768xf32> | |
| %242 = linalg.matmul ins(%collapsed_125, %hoisted_31 : tensor<32768x768xf32>, tensor<768x768xf32>) outs(%96 : tensor<32768x768xf32>) -> tensor<32768x768xf32> | |
| %expanded_126 = tensor.expand_shape %242 [[0, 1], [2]] : tensor<32768x768xf32> into tensor<64x512x768xf32> | |
| %243 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%cst_37 : tensor<768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| %244 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_126, %243 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %245 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%244, %206 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %246 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%245 : tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.mulf %in, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %247 = linalg.generic {indexing_maps = [#map1, #map3], iterator_types = ["parallel", "parallel", "reduction"]} ins(%246 : tensor<64x512x768xf32>) outs(%24 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.addf %out, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %248 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%247, %cst_57 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.divf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %249 = linalg.generic {indexing_maps = [#map1, #map3], iterator_types = ["parallel", "parallel", "reduction"]} ins(%245 : tensor<64x512x768xf32>) outs(%24 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.addf %out, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %250 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%249, %cst_57 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.divf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %251 = linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel"]} ins(%250 : tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.mulf %in, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %252 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%248, %251 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.subf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %253 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%252, %cst_56 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.maxf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %expanded_127 = tensor.expand_shape %253 [[0], [1, 2]] : tensor<64x512xf32> into tensor<64x512x1xf32> | |
| %254 = linalg.generic {indexing_maps = [#map3, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%250 : tensor<64x512xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| %255 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%245, %254 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.subf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %256 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_127, %cst_55 : tensor<64x512x1xf32>, tensor<64x512x1xf32>) outs(%34 : tensor<64x512x1xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x1xf32> | |
| %257 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%256 : tensor<64x512x1xf32>) outs(%34 : tensor<64x512x1xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = math.rsqrt %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x1xf32> | |
| %258 = linalg.generic {indexing_maps = [#map6, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%257 : tensor<64x512x1xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| %hoisted_32 = util.global.load @hoisted_32 : tensor<64x512x768xf32> | |
| %259 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%258, %hoisted_32 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %260 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%255, %259 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %hoisted_33 = util.global.load @hoisted_33 : tensor<64x512x768xf32> | |
| %261 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%260, %hoisted_33 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %hoisted_34 = util.global.load @hoisted_34 : tensor<768x3072xf32> | |
| %collapsed_128 = tensor.collapse_shape %261 [[0, 1], [2]] : tensor<64x512x768xf32> into tensor<32768x768xf32> | |
| %262 = linalg.matmul ins(%collapsed_128, %hoisted_34 : tensor<32768x768xf32>, tensor<768x3072xf32>) outs(%118 : tensor<32768x3072xf32>) -> tensor<32768x3072xf32> | |
| %expanded_129 = tensor.expand_shape %262 [[0, 1], [2]] : tensor<32768x3072xf32> into tensor<64x512x3072xf32> | |
| %263 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%cst_36 : tensor<3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %264 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_129, %263 : tensor<64x512x3072xf32>, tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %265 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%264 : tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.mulf %in, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %266 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%264, %265 : tensor<64x512x3072xf32>, tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %267 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%266, %cst_51 : tensor<64x512x3072xf32>, tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %268 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%264, %267 : tensor<64x512x3072xf32>, tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %269 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%268, %cst_50 : tensor<64x512x3072xf32>, tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %270 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%269 : tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = math.tanh %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %271 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%270, %cst_49 : tensor<64x512x3072xf32>, tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %272 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%271, %cst_48 : tensor<64x512x3072xf32>, tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %273 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%264, %272 : tensor<64x512x3072xf32>, tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %hoisted_35 = util.global.load @hoisted_35 : tensor<3072x768xf32> | |
| %collapsed_130 = tensor.collapse_shape %273 [[0, 1], [2]] : tensor<64x512x3072xf32> into tensor<32768x3072xf32> | |
| %274 = linalg.matmul ins(%collapsed_130, %hoisted_35 : tensor<32768x3072xf32>, tensor<3072x768xf32>) outs(%96 : tensor<32768x768xf32>) -> tensor<32768x768xf32> | |
| %expanded_131 = tensor.expand_shape %274 [[0, 1], [2]] : tensor<32768x768xf32> into tensor<64x512x768xf32> | |
| %275 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%cst_35 : tensor<768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| %276 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_131, %275 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %277 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%245, %276 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %278 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%277 : tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.mulf %in, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %279 = linalg.generic {indexing_maps = [#map1, #map3], iterator_types = ["parallel", "parallel", "reduction"]} ins(%278 : tensor<64x512x768xf32>) outs(%24 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.addf %out, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %280 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%279, %cst_57 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.divf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %281 = linalg.generic {indexing_maps = [#map1, #map3], iterator_types = ["parallel", "parallel", "reduction"]} ins(%277 : tensor<64x512x768xf32>) outs(%24 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.addf %out, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %282 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%281, %cst_57 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.divf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %283 = linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel"]} ins(%282 : tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.mulf %in, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %284 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%280, %283 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.subf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %285 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%284, %cst_56 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.maxf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %expanded_132 = tensor.expand_shape %285 [[0], [1, 2]] : tensor<64x512xf32> into tensor<64x512x1xf32> | |
| %286 = linalg.generic {indexing_maps = [#map3, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%282 : tensor<64x512xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| %287 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%277, %286 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.subf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %288 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_132, %cst_55 : tensor<64x512x1xf32>, tensor<64x512x1xf32>) outs(%34 : tensor<64x512x1xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x1xf32> | |
| %289 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%288 : tensor<64x512x1xf32>) outs(%34 : tensor<64x512x1xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = math.rsqrt %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x1xf32> | |
| %290 = linalg.generic {indexing_maps = [#map6, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%289 : tensor<64x512x1xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| %hoisted_36 = util.global.load @hoisted_36 : tensor<64x512x768xf32> | |
| %291 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%290, %hoisted_36 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %292 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%287, %291 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %hoisted_37 = util.global.load @hoisted_37 : tensor<64x512x768xf32> | |
| %293 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%292, %hoisted_37 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %hoisted_38 = util.global.load @hoisted_38 : tensor<768x2304xf32> | |
| %collapsed_133 = tensor.collapse_shape %293 [[0, 1], [2]] : tensor<64x512x768xf32> into tensor<32768x768xf32> | |
| %294 = linalg.matmul ins(%collapsed_133, %hoisted_38 : tensor<32768x768xf32>, tensor<768x2304xf32>) outs(%49 : tensor<32768x2304xf32>) -> tensor<32768x2304xf32> | |
| %expanded_134 = tensor.expand_shape %294 [[0, 1], [2]] : tensor<32768x2304xf32> into tensor<64x512x2304xf32> | |
| %295 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%cst_34 : tensor<2304xf32>) outs(%51 : tensor<64x512x2304xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x2304xf32> | |
| %296 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_134, %295 : tensor<64x512x2304xf32>, tensor<64x512x2304xf32>) outs(%51 : tensor<64x512x2304xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x2304xf32> | |
| %extracted_slice_135 = tensor.extract_slice %296[0, 0, 0] [64, 512, 768] [1, 1, 1] : tensor<64x512x2304xf32> to tensor<64x512x768xf32> | |
| %extracted_slice_136 = tensor.extract_slice %296[0, 0, 768] [64, 512, 768] [1, 1, 1] : tensor<64x512x2304xf32> to tensor<64x512x768xf32> | |
| %extracted_slice_137 = tensor.extract_slice %296[0, 0, 1536] [64, 512, 768] [1, 1, 1] : tensor<64x512x2304xf32> to tensor<64x512x768xf32> | |
| %expanded_138 = tensor.expand_shape %extracted_slice_135 [[0], [1], [2, 3]] : tensor<64x512x768xf32> into tensor<64x512x12x64xf32> | |
| %expanded_139 = tensor.expand_shape %extracted_slice_136 [[0], [1], [2, 3]] : tensor<64x512x768xf32> into tensor<64x512x12x64xf32> | |
| %expanded_140 = tensor.expand_shape %extracted_slice_137 [[0], [1], [2, 3]] : tensor<64x512x768xf32> into tensor<64x512x12x64xf32> | |
| %297 = linalg.generic {indexing_maps = [#map5, #map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_138, %67 : tensor<64x512x12x64xf32>, tensor<64x512x12x64xf32>) outs(%66 : tensor<64x512x12x64xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.divf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x12x64xf32> | |
| %298 = linalg.generic {indexing_maps = [#map13, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%297 : tensor<64x512x12x64xf32>) outs(%69 : tensor<64x12x512x64xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x12x512x64xf32> | |
| %299 = linalg.generic {indexing_maps = [#map14, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_139 : tensor<64x512x12x64xf32>) outs(%71 : tensor<64x12x64x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x12x64x512xf32> | |
| %collapsed_141 = tensor.collapse_shape %298 [[0, 1], [2], [3]] : tensor<64x12x512x64xf32> into tensor<768x512x64xf32> | |
| %collapsed_142 = tensor.collapse_shape %299 [[0, 1], [2], [3]] : tensor<64x12x64x512xf32> into tensor<768x64x512xf32> | |
| %300 = linalg.batch_matmul ins(%collapsed_141, %collapsed_142 : tensor<768x512x64xf32>, tensor<768x64x512xf32>) outs(%74 : tensor<768x512x512xf32>) -> tensor<768x512x512xf32> | |
| %expanded_143 = tensor.expand_shape %300 [[0, 1], [2], [3]] : tensor<768x512x512xf32> into tensor<64x12x512x512xf32> | |
| %301 = linalg.generic {indexing_maps = [#map5, #map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_143, %77 : tensor<64x12x512x512xf32>, tensor<64x12x512x512xf32>) outs(%76 : tensor<64x12x512x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x12x512x512xf32> | |
| %302 = linalg.generic {indexing_maps = [#map5, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%301 : tensor<64x12x512x512xf32>) outs(%80 : tensor<64x12x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.maxf %out, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x12x512xf32> | |
| %303 = linalg.generic {indexing_maps = [#map4, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%302 : tensor<64x12x512xf32>) outs(%76 : tensor<64x12x512x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x12x512x512xf32> | |
| %304 = linalg.generic {indexing_maps = [#map5, #map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%301, %303 : tensor<64x12x512x512xf32>, tensor<64x12x512x512xf32>) outs(%76 : tensor<64x12x512x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.subf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x12x512x512xf32> | |
| %305 = linalg.generic {indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%304 : tensor<64x12x512x512xf32>) outs(%76 : tensor<64x12x512x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = math.exp %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x12x512x512xf32> | |
| %306 = linalg.generic {indexing_maps = [#map5, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%305 : tensor<64x12x512x512xf32>) outs(%85 : tensor<64x12x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.addf %out, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x12x512xf32> | |
| %307 = linalg.generic {indexing_maps = [#map4, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%306 : tensor<64x12x512xf32>) outs(%76 : tensor<64x12x512x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x12x512x512xf32> | |
| %308 = linalg.generic {indexing_maps = [#map5, #map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%305, %307 : tensor<64x12x512x512xf32>, tensor<64x12x512x512xf32>) outs(%76 : tensor<64x12x512x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.divf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x12x512x512xf32> | |
| %309 = linalg.generic {indexing_maps = [#map14, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_140 : tensor<64x512x12x64xf32>) outs(%71 : tensor<64x12x64x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x12x64x512xf32> | |
| %310 = linalg.generic {indexing_maps = [#map16, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%308 : tensor<64x12x512x512xf32>) outs(%76 : tensor<64x12x512x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x12x512x512xf32> | |
| %collapsed_144 = tensor.collapse_shape %309 [[0, 1], [2], [3]] : tensor<64x12x64x512xf32> into tensor<768x64x512xf32> | |
| %collapsed_145 = tensor.collapse_shape %310 [[0, 1], [2], [3]] : tensor<64x12x512x512xf32> into tensor<768x512x512xf32> | |
| %311 = linalg.batch_matmul ins(%collapsed_144, %collapsed_145 : tensor<768x64x512xf32>, tensor<768x512x512xf32>) outs(%92 : tensor<768x64x512xf32>) -> tensor<768x64x512xf32> | |
| %expanded_146 = tensor.expand_shape %311 [[0, 1], [2], [3]] : tensor<768x64x512xf32> into tensor<64x12x64x512xf32> | |
| %312 = linalg.generic {indexing_maps = [#map17, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_146 : tensor<64x12x64x512xf32>) outs(%66 : tensor<64x512x12x64xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x12x64xf32> | |
| %hoisted_39 = util.global.load @hoisted_39 : tensor<768x768xf32> | |
| %collapsed_147 = tensor.collapse_shape %312 [[0, 1], [2, 3]] : tensor<64x512x12x64xf32> into tensor<32768x768xf32> | |
| %313 = linalg.matmul ins(%collapsed_147, %hoisted_39 : tensor<32768x768xf32>, tensor<768x768xf32>) outs(%96 : tensor<32768x768xf32>) -> tensor<32768x768xf32> | |
| %expanded_148 = tensor.expand_shape %313 [[0, 1], [2]] : tensor<32768x768xf32> into tensor<64x512x768xf32> | |
| %314 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%cst_33 : tensor<768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| %315 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_148, %314 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %316 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%315, %277 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %317 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%316 : tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.mulf %in, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %318 = linalg.generic {indexing_maps = [#map1, #map3], iterator_types = ["parallel", "parallel", "reduction"]} ins(%317 : tensor<64x512x768xf32>) outs(%24 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.addf %out, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %319 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%318, %cst_57 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.divf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %320 = linalg.generic {indexing_maps = [#map1, #map3], iterator_types = ["parallel", "parallel", "reduction"]} ins(%316 : tensor<64x512x768xf32>) outs(%24 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.addf %out, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %321 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%320, %cst_57 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.divf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %322 = linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel"]} ins(%321 : tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.mulf %in, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %323 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%319, %322 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.subf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %324 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%323, %cst_56 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.maxf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %expanded_149 = tensor.expand_shape %324 [[0], [1, 2]] : tensor<64x512xf32> into tensor<64x512x1xf32> | |
| %325 = linalg.generic {indexing_maps = [#map3, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%321 : tensor<64x512xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| %326 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%316, %325 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.subf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %327 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_149, %cst_55 : tensor<64x512x1xf32>, tensor<64x512x1xf32>) outs(%34 : tensor<64x512x1xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x1xf32> | |
| %328 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%327 : tensor<64x512x1xf32>) outs(%34 : tensor<64x512x1xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = math.rsqrt %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x1xf32> | |
| %329 = linalg.generic {indexing_maps = [#map6, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%328 : tensor<64x512x1xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| %hoisted_40 = util.global.load @hoisted_40 : tensor<64x512x768xf32> | |
| %330 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%329, %hoisted_40 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %331 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%326, %330 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %hoisted_41 = util.global.load @hoisted_41 : tensor<64x512x768xf32> | |
| %332 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%331, %hoisted_41 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %hoisted_42 = util.global.load @hoisted_42 : tensor<768x3072xf32> | |
| %collapsed_150 = tensor.collapse_shape %332 [[0, 1], [2]] : tensor<64x512x768xf32> into tensor<32768x768xf32> | |
| %333 = linalg.matmul ins(%collapsed_150, %hoisted_42 : tensor<32768x768xf32>, tensor<768x3072xf32>) outs(%118 : tensor<32768x3072xf32>) -> tensor<32768x3072xf32> | |
| %expanded_151 = tensor.expand_shape %333 [[0, 1], [2]] : tensor<32768x3072xf32> into tensor<64x512x3072xf32> | |
| %334 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%cst_32 : tensor<3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %335 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_151, %334 : tensor<64x512x3072xf32>, tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %336 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%335 : tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.mulf %in, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %337 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%335, %336 : tensor<64x512x3072xf32>, tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %338 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%337, %cst_51 : tensor<64x512x3072xf32>, tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %339 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%335, %338 : tensor<64x512x3072xf32>, tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %340 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%339, %cst_50 : tensor<64x512x3072xf32>, tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %341 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%340 : tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = math.tanh %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %342 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%341, %cst_49 : tensor<64x512x3072xf32>, tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %343 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%342, %cst_48 : tensor<64x512x3072xf32>, tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %344 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%335, %343 : tensor<64x512x3072xf32>, tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %hoisted_43 = util.global.load @hoisted_43 : tensor<3072x768xf32> | |
| %collapsed_152 = tensor.collapse_shape %344 [[0, 1], [2]] : tensor<64x512x3072xf32> into tensor<32768x3072xf32> | |
| %345 = linalg.matmul ins(%collapsed_152, %hoisted_43 : tensor<32768x3072xf32>, tensor<3072x768xf32>) outs(%96 : tensor<32768x768xf32>) -> tensor<32768x768xf32> | |
| %expanded_153 = tensor.expand_shape %345 [[0, 1], [2]] : tensor<32768x768xf32> into tensor<64x512x768xf32> | |
| %346 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%cst_31 : tensor<768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| %347 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_153, %346 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %348 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%316, %347 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %349 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%348 : tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.mulf %in, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %350 = linalg.generic {indexing_maps = [#map1, #map3], iterator_types = ["parallel", "parallel", "reduction"]} ins(%349 : tensor<64x512x768xf32>) outs(%24 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.addf %out, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %351 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%350, %cst_57 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.divf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %352 = linalg.generic {indexing_maps = [#map1, #map3], iterator_types = ["parallel", "parallel", "reduction"]} ins(%348 : tensor<64x512x768xf32>) outs(%24 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.addf %out, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %353 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%352, %cst_57 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.divf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %354 = linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel"]} ins(%353 : tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.mulf %in, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %355 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%351, %354 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.subf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %356 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%355, %cst_56 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.maxf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %expanded_154 = tensor.expand_shape %356 [[0], [1, 2]] : tensor<64x512xf32> into tensor<64x512x1xf32> | |
| %357 = linalg.generic {indexing_maps = [#map3, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%353 : tensor<64x512xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| %358 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%348, %357 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.subf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %359 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_154, %cst_55 : tensor<64x512x1xf32>, tensor<64x512x1xf32>) outs(%34 : tensor<64x512x1xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x1xf32> | |
| %360 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%359 : tensor<64x512x1xf32>) outs(%34 : tensor<64x512x1xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = math.rsqrt %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x1xf32> | |
| %361 = linalg.generic {indexing_maps = [#map6, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%360 : tensor<64x512x1xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| %hoisted_44 = util.global.load @hoisted_44 : tensor<64x512x768xf32> | |
| %362 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%361, %hoisted_44 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %363 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%358, %362 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %hoisted_45 = util.global.load @hoisted_45 : tensor<64x512x768xf32> | |
| %364 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%363, %hoisted_45 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %hoisted_46 = util.global.load @hoisted_46 : tensor<768x2304xf32> | |
| %collapsed_155 = tensor.collapse_shape %364 [[0, 1], [2]] : tensor<64x512x768xf32> into tensor<32768x768xf32> | |
| %365 = linalg.matmul ins(%collapsed_155, %hoisted_46 : tensor<32768x768xf32>, tensor<768x2304xf32>) outs(%49 : tensor<32768x2304xf32>) -> tensor<32768x2304xf32> | |
| %expanded_156 = tensor.expand_shape %365 [[0, 1], [2]] : tensor<32768x2304xf32> into tensor<64x512x2304xf32> | |
| %366 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%cst_30 : tensor<2304xf32>) outs(%51 : tensor<64x512x2304xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x2304xf32> | |
| %367 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_156, %366 : tensor<64x512x2304xf32>, tensor<64x512x2304xf32>) outs(%51 : tensor<64x512x2304xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x2304xf32> | |
| %extracted_slice_157 = tensor.extract_slice %367[0, 0, 0] [64, 512, 768] [1, 1, 1] : tensor<64x512x2304xf32> to tensor<64x512x768xf32> | |
| %extracted_slice_158 = tensor.extract_slice %367[0, 0, 768] [64, 512, 768] [1, 1, 1] : tensor<64x512x2304xf32> to tensor<64x512x768xf32> | |
| %extracted_slice_159 = tensor.extract_slice %367[0, 0, 1536] [64, 512, 768] [1, 1, 1] : tensor<64x512x2304xf32> to tensor<64x512x768xf32> | |
| %expanded_160 = tensor.expand_shape %extracted_slice_157 [[0], [1], [2, 3]] : tensor<64x512x768xf32> into tensor<64x512x12x64xf32> | |
| %expanded_161 = tensor.expand_shape %extracted_slice_158 [[0], [1], [2, 3]] : tensor<64x512x768xf32> into tensor<64x512x12x64xf32> | |
| %expanded_162 = tensor.expand_shape %extracted_slice_159 [[0], [1], [2, 3]] : tensor<64x512x768xf32> into tensor<64x512x12x64xf32> | |
| %368 = linalg.generic {indexing_maps = [#map5, #map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_160, %67 : tensor<64x512x12x64xf32>, tensor<64x512x12x64xf32>) outs(%66 : tensor<64x512x12x64xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.divf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x12x64xf32> | |
| %369 = linalg.generic {indexing_maps = [#map13, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%368 : tensor<64x512x12x64xf32>) outs(%69 : tensor<64x12x512x64xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x12x512x64xf32> | |
| %370 = linalg.generic {indexing_maps = [#map14, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_161 : tensor<64x512x12x64xf32>) outs(%71 : tensor<64x12x64x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x12x64x512xf32> | |
| %collapsed_163 = tensor.collapse_shape %369 [[0, 1], [2], [3]] : tensor<64x12x512x64xf32> into tensor<768x512x64xf32> | |
| %collapsed_164 = tensor.collapse_shape %370 [[0, 1], [2], [3]] : tensor<64x12x64x512xf32> into tensor<768x64x512xf32> | |
| %371 = linalg.batch_matmul ins(%collapsed_163, %collapsed_164 : tensor<768x512x64xf32>, tensor<768x64x512xf32>) outs(%74 : tensor<768x512x512xf32>) -> tensor<768x512x512xf32> | |
| %expanded_165 = tensor.expand_shape %371 [[0, 1], [2], [3]] : tensor<768x512x512xf32> into tensor<64x12x512x512xf32> | |
| %372 = linalg.generic {indexing_maps = [#map5, #map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_165, %77 : tensor<64x12x512x512xf32>, tensor<64x12x512x512xf32>) outs(%76 : tensor<64x12x512x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x12x512x512xf32> | |
| %373 = linalg.generic {indexing_maps = [#map5, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%372 : tensor<64x12x512x512xf32>) outs(%80 : tensor<64x12x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.maxf %out, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x12x512xf32> | |
| %374 = linalg.generic {indexing_maps = [#map4, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%373 : tensor<64x12x512xf32>) outs(%76 : tensor<64x12x512x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x12x512x512xf32> | |
| %375 = linalg.generic {indexing_maps = [#map5, #map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%372, %374 : tensor<64x12x512x512xf32>, tensor<64x12x512x512xf32>) outs(%76 : tensor<64x12x512x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.subf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x12x512x512xf32> | |
| %376 = linalg.generic {indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%375 : tensor<64x12x512x512xf32>) outs(%76 : tensor<64x12x512x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = math.exp %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x12x512x512xf32> | |
| %377 = linalg.generic {indexing_maps = [#map5, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%376 : tensor<64x12x512x512xf32>) outs(%85 : tensor<64x12x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.addf %out, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x12x512xf32> | |
| %378 = linalg.generic {indexing_maps = [#map4, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%377 : tensor<64x12x512xf32>) outs(%76 : tensor<64x12x512x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x12x512x512xf32> | |
| %379 = linalg.generic {indexing_maps = [#map5, #map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%376, %378 : tensor<64x12x512x512xf32>, tensor<64x12x512x512xf32>) outs(%76 : tensor<64x12x512x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.divf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x12x512x512xf32> | |
| %380 = linalg.generic {indexing_maps = [#map14, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_162 : tensor<64x512x12x64xf32>) outs(%71 : tensor<64x12x64x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x12x64x512xf32> | |
| %381 = linalg.generic {indexing_maps = [#map16, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%379 : tensor<64x12x512x512xf32>) outs(%76 : tensor<64x12x512x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x12x512x512xf32> | |
| %collapsed_166 = tensor.collapse_shape %380 [[0, 1], [2], [3]] : tensor<64x12x64x512xf32> into tensor<768x64x512xf32> | |
| %collapsed_167 = tensor.collapse_shape %381 [[0, 1], [2], [3]] : tensor<64x12x512x512xf32> into tensor<768x512x512xf32> | |
| %382 = linalg.batch_matmul ins(%collapsed_166, %collapsed_167 : tensor<768x64x512xf32>, tensor<768x512x512xf32>) outs(%92 : tensor<768x64x512xf32>) -> tensor<768x64x512xf32> | |
| %expanded_168 = tensor.expand_shape %382 [[0, 1], [2], [3]] : tensor<768x64x512xf32> into tensor<64x12x64x512xf32> | |
| %383 = linalg.generic {indexing_maps = [#map17, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_168 : tensor<64x12x64x512xf32>) outs(%66 : tensor<64x512x12x64xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x12x64xf32> | |
| %hoisted_47 = util.global.load @hoisted_47 : tensor<768x768xf32> | |
| %collapsed_169 = tensor.collapse_shape %383 [[0, 1], [2, 3]] : tensor<64x512x12x64xf32> into tensor<32768x768xf32> | |
| %384 = linalg.matmul ins(%collapsed_169, %hoisted_47 : tensor<32768x768xf32>, tensor<768x768xf32>) outs(%96 : tensor<32768x768xf32>) -> tensor<32768x768xf32> | |
| %expanded_170 = tensor.expand_shape %384 [[0, 1], [2]] : tensor<32768x768xf32> into tensor<64x512x768xf32> | |
| %385 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%cst_29 : tensor<768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| %386 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_170, %385 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %387 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%386, %348 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %388 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%387 : tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.mulf %in, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %389 = linalg.generic {indexing_maps = [#map1, #map3], iterator_types = ["parallel", "parallel", "reduction"]} ins(%388 : tensor<64x512x768xf32>) outs(%24 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.addf %out, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %390 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%389, %cst_57 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.divf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %391 = linalg.generic {indexing_maps = [#map1, #map3], iterator_types = ["parallel", "parallel", "reduction"]} ins(%387 : tensor<64x512x768xf32>) outs(%24 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.addf %out, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %392 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%391, %cst_57 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.divf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %393 = linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel"]} ins(%392 : tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.mulf %in, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %394 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%390, %393 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.subf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %395 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%394, %cst_56 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.maxf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %expanded_171 = tensor.expand_shape %395 [[0], [1, 2]] : tensor<64x512xf32> into tensor<64x512x1xf32> | |
| %396 = linalg.generic {indexing_maps = [#map3, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%392 : tensor<64x512xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| %397 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%387, %396 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.subf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %398 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_171, %cst_55 : tensor<64x512x1xf32>, tensor<64x512x1xf32>) outs(%34 : tensor<64x512x1xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x1xf32> | |
| %399 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%398 : tensor<64x512x1xf32>) outs(%34 : tensor<64x512x1xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = math.rsqrt %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x1xf32> | |
| %400 = linalg.generic {indexing_maps = [#map6, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%399 : tensor<64x512x1xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| %hoisted_48 = util.global.load @hoisted_48 : tensor<64x512x768xf32> | |
| %401 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%400, %hoisted_48 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %402 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%397, %401 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %hoisted_49 = util.global.load @hoisted_49 : tensor<64x512x768xf32> | |
| %403 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%402, %hoisted_49 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %hoisted_50 = util.global.load @hoisted_50 : tensor<768x3072xf32> | |
| %collapsed_172 = tensor.collapse_shape %403 [[0, 1], [2]] : tensor<64x512x768xf32> into tensor<32768x768xf32> | |
| %404 = linalg.matmul ins(%collapsed_172, %hoisted_50 : tensor<32768x768xf32>, tensor<768x3072xf32>) outs(%118 : tensor<32768x3072xf32>) -> tensor<32768x3072xf32> | |
| %expanded_173 = tensor.expand_shape %404 [[0, 1], [2]] : tensor<32768x3072xf32> into tensor<64x512x3072xf32> | |
| %405 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%cst_28 : tensor<3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %406 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_173, %405 : tensor<64x512x3072xf32>, tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %407 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%406 : tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.mulf %in, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %408 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%406, %407 : tensor<64x512x3072xf32>, tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %409 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%408, %cst_51 : tensor<64x512x3072xf32>, tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %410 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%406, %409 : tensor<64x512x3072xf32>, tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %411 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%410, %cst_50 : tensor<64x512x3072xf32>, tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %412 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%411 : tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = math.tanh %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %413 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%412, %cst_49 : tensor<64x512x3072xf32>, tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %414 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%413, %cst_48 : tensor<64x512x3072xf32>, tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %415 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%406, %414 : tensor<64x512x3072xf32>, tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %hoisted_51 = util.global.load @hoisted_51 : tensor<3072x768xf32> | |
| %collapsed_174 = tensor.collapse_shape %415 [[0, 1], [2]] : tensor<64x512x3072xf32> into tensor<32768x3072xf32> | |
| %416 = linalg.matmul ins(%collapsed_174, %hoisted_51 : tensor<32768x3072xf32>, tensor<3072x768xf32>) outs(%96 : tensor<32768x768xf32>) -> tensor<32768x768xf32> | |
| %expanded_175 = tensor.expand_shape %416 [[0, 1], [2]] : tensor<32768x768xf32> into tensor<64x512x768xf32> | |
| %417 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%cst_27 : tensor<768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| %418 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_175, %417 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %419 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%387, %418 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %420 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%419 : tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.mulf %in, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %421 = linalg.generic {indexing_maps = [#map1, #map3], iterator_types = ["parallel", "parallel", "reduction"]} ins(%420 : tensor<64x512x768xf32>) outs(%24 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.addf %out, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %422 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%421, %cst_57 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.divf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %423 = linalg.generic {indexing_maps = [#map1, #map3], iterator_types = ["parallel", "parallel", "reduction"]} ins(%419 : tensor<64x512x768xf32>) outs(%24 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.addf %out, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %424 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%423, %cst_57 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.divf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %425 = linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel"]} ins(%424 : tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.mulf %in, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %426 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%422, %425 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.subf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %427 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%426, %cst_56 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.maxf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %expanded_176 = tensor.expand_shape %427 [[0], [1, 2]] : tensor<64x512xf32> into tensor<64x512x1xf32> | |
| %428 = linalg.generic {indexing_maps = [#map3, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%424 : tensor<64x512xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| %429 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%419, %428 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.subf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %430 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_176, %cst_55 : tensor<64x512x1xf32>, tensor<64x512x1xf32>) outs(%34 : tensor<64x512x1xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x1xf32> | |
| %431 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%430 : tensor<64x512x1xf32>) outs(%34 : tensor<64x512x1xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = math.rsqrt %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x1xf32> | |
| %432 = linalg.generic {indexing_maps = [#map6, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%431 : tensor<64x512x1xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| %hoisted_52 = util.global.load @hoisted_52 : tensor<64x512x768xf32> | |
| %433 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%432, %hoisted_52 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %434 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%429, %433 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %hoisted_53 = util.global.load @hoisted_53 : tensor<64x512x768xf32> | |
| %435 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%434, %hoisted_53 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %hoisted_54 = util.global.load @hoisted_54 : tensor<768x2304xf32> | |
| %collapsed_177 = tensor.collapse_shape %435 [[0, 1], [2]] : tensor<64x512x768xf32> into tensor<32768x768xf32> | |
| %436 = linalg.matmul ins(%collapsed_177, %hoisted_54 : tensor<32768x768xf32>, tensor<768x2304xf32>) outs(%49 : tensor<32768x2304xf32>) -> tensor<32768x2304xf32> | |
| %expanded_178 = tensor.expand_shape %436 [[0, 1], [2]] : tensor<32768x2304xf32> into tensor<64x512x2304xf32> | |
| %437 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%cst_26 : tensor<2304xf32>) outs(%51 : tensor<64x512x2304xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x2304xf32> | |
| %438 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_178, %437 : tensor<64x512x2304xf32>, tensor<64x512x2304xf32>) outs(%51 : tensor<64x512x2304xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x2304xf32> | |
| %extracted_slice_179 = tensor.extract_slice %438[0, 0, 0] [64, 512, 768] [1, 1, 1] : tensor<64x512x2304xf32> to tensor<64x512x768xf32> | |
| %extracted_slice_180 = tensor.extract_slice %438[0, 0, 768] [64, 512, 768] [1, 1, 1] : tensor<64x512x2304xf32> to tensor<64x512x768xf32> | |
| %extracted_slice_181 = tensor.extract_slice %438[0, 0, 1536] [64, 512, 768] [1, 1, 1] : tensor<64x512x2304xf32> to tensor<64x512x768xf32> | |
| %expanded_182 = tensor.expand_shape %extracted_slice_179 [[0], [1], [2, 3]] : tensor<64x512x768xf32> into tensor<64x512x12x64xf32> | |
| %expanded_183 = tensor.expand_shape %extracted_slice_180 [[0], [1], [2, 3]] : tensor<64x512x768xf32> into tensor<64x512x12x64xf32> | |
| %expanded_184 = tensor.expand_shape %extracted_slice_181 [[0], [1], [2, 3]] : tensor<64x512x768xf32> into tensor<64x512x12x64xf32> | |
| %439 = linalg.generic {indexing_maps = [#map5, #map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_182, %67 : tensor<64x512x12x64xf32>, tensor<64x512x12x64xf32>) outs(%66 : tensor<64x512x12x64xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.divf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x12x64xf32> | |
| %440 = linalg.generic {indexing_maps = [#map13, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%439 : tensor<64x512x12x64xf32>) outs(%69 : tensor<64x12x512x64xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x12x512x64xf32> | |
| %441 = linalg.generic {indexing_maps = [#map14, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_183 : tensor<64x512x12x64xf32>) outs(%71 : tensor<64x12x64x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x12x64x512xf32> | |
| %collapsed_185 = tensor.collapse_shape %440 [[0, 1], [2], [3]] : tensor<64x12x512x64xf32> into tensor<768x512x64xf32> | |
| %collapsed_186 = tensor.collapse_shape %441 [[0, 1], [2], [3]] : tensor<64x12x64x512xf32> into tensor<768x64x512xf32> | |
| %442 = linalg.batch_matmul ins(%collapsed_185, %collapsed_186 : tensor<768x512x64xf32>, tensor<768x64x512xf32>) outs(%74 : tensor<768x512x512xf32>) -> tensor<768x512x512xf32> | |
| %expanded_187 = tensor.expand_shape %442 [[0, 1], [2], [3]] : tensor<768x512x512xf32> into tensor<64x12x512x512xf32> | |
| %443 = linalg.generic {indexing_maps = [#map5, #map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_187, %77 : tensor<64x12x512x512xf32>, tensor<64x12x512x512xf32>) outs(%76 : tensor<64x12x512x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x12x512x512xf32> | |
| %444 = linalg.generic {indexing_maps = [#map5, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%443 : tensor<64x12x512x512xf32>) outs(%80 : tensor<64x12x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.maxf %out, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x12x512xf32> | |
| %445 = linalg.generic {indexing_maps = [#map4, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%444 : tensor<64x12x512xf32>) outs(%76 : tensor<64x12x512x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x12x512x512xf32> | |
| %446 = linalg.generic {indexing_maps = [#map5, #map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%443, %445 : tensor<64x12x512x512xf32>, tensor<64x12x512x512xf32>) outs(%76 : tensor<64x12x512x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.subf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x12x512x512xf32> | |
| %447 = linalg.generic {indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%446 : tensor<64x12x512x512xf32>) outs(%76 : tensor<64x12x512x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = math.exp %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x12x512x512xf32> | |
| %448 = linalg.generic {indexing_maps = [#map5, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%447 : tensor<64x12x512x512xf32>) outs(%85 : tensor<64x12x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.addf %out, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x12x512xf32> | |
| %449 = linalg.generic {indexing_maps = [#map4, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%448 : tensor<64x12x512xf32>) outs(%76 : tensor<64x12x512x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x12x512x512xf32> | |
| %450 = linalg.generic {indexing_maps = [#map5, #map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%447, %449 : tensor<64x12x512x512xf32>, tensor<64x12x512x512xf32>) outs(%76 : tensor<64x12x512x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.divf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x12x512x512xf32> | |
| %451 = linalg.generic {indexing_maps = [#map14, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_184 : tensor<64x512x12x64xf32>) outs(%71 : tensor<64x12x64x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x12x64x512xf32> | |
| %452 = linalg.generic {indexing_maps = [#map16, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%450 : tensor<64x12x512x512xf32>) outs(%76 : tensor<64x12x512x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x12x512x512xf32> | |
| %collapsed_188 = tensor.collapse_shape %451 [[0, 1], [2], [3]] : tensor<64x12x64x512xf32> into tensor<768x64x512xf32> | |
| %collapsed_189 = tensor.collapse_shape %452 [[0, 1], [2], [3]] : tensor<64x12x512x512xf32> into tensor<768x512x512xf32> | |
| %453 = linalg.batch_matmul ins(%collapsed_188, %collapsed_189 : tensor<768x64x512xf32>, tensor<768x512x512xf32>) outs(%92 : tensor<768x64x512xf32>) -> tensor<768x64x512xf32> | |
| %expanded_190 = tensor.expand_shape %453 [[0, 1], [2], [3]] : tensor<768x64x512xf32> into tensor<64x12x64x512xf32> | |
| %454 = linalg.generic {indexing_maps = [#map17, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_190 : tensor<64x12x64x512xf32>) outs(%66 : tensor<64x512x12x64xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x12x64xf32> | |
| %hoisted_55 = util.global.load @hoisted_55 : tensor<768x768xf32> | |
| %collapsed_191 = tensor.collapse_shape %454 [[0, 1], [2, 3]] : tensor<64x512x12x64xf32> into tensor<32768x768xf32> | |
| %455 = linalg.matmul ins(%collapsed_191, %hoisted_55 : tensor<32768x768xf32>, tensor<768x768xf32>) outs(%96 : tensor<32768x768xf32>) -> tensor<32768x768xf32> | |
| %expanded_192 = tensor.expand_shape %455 [[0, 1], [2]] : tensor<32768x768xf32> into tensor<64x512x768xf32> | |
| %456 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%cst_25 : tensor<768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| %457 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_192, %456 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %458 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%457, %419 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %459 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%458 : tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.mulf %in, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %460 = linalg.generic {indexing_maps = [#map1, #map3], iterator_types = ["parallel", "parallel", "reduction"]} ins(%459 : tensor<64x512x768xf32>) outs(%24 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.addf %out, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %461 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%460, %cst_57 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.divf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %462 = linalg.generic {indexing_maps = [#map1, #map3], iterator_types = ["parallel", "parallel", "reduction"]} ins(%458 : tensor<64x512x768xf32>) outs(%24 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.addf %out, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %463 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%462, %cst_57 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.divf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %464 = linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel"]} ins(%463 : tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.mulf %in, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %465 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%461, %464 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.subf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %466 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%465, %cst_56 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.maxf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %expanded_193 = tensor.expand_shape %466 [[0], [1, 2]] : tensor<64x512xf32> into tensor<64x512x1xf32> | |
| %467 = linalg.generic {indexing_maps = [#map3, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%463 : tensor<64x512xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| %468 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%458, %467 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.subf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %469 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_193, %cst_55 : tensor<64x512x1xf32>, tensor<64x512x1xf32>) outs(%34 : tensor<64x512x1xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x1xf32> | |
| %470 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%469 : tensor<64x512x1xf32>) outs(%34 : tensor<64x512x1xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = math.rsqrt %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x1xf32> | |
| %471 = linalg.generic {indexing_maps = [#map6, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%470 : tensor<64x512x1xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| %hoisted_56 = util.global.load @hoisted_56 : tensor<64x512x768xf32> | |
| %472 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%471, %hoisted_56 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %473 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%468, %472 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %hoisted_57 = util.global.load @hoisted_57 : tensor<64x512x768xf32> | |
| %474 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%473, %hoisted_57 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %hoisted_58 = util.global.load @hoisted_58 : tensor<768x3072xf32> | |
| %collapsed_194 = tensor.collapse_shape %474 [[0, 1], [2]] : tensor<64x512x768xf32> into tensor<32768x768xf32> | |
| %475 = linalg.matmul ins(%collapsed_194, %hoisted_58 : tensor<32768x768xf32>, tensor<768x3072xf32>) outs(%118 : tensor<32768x3072xf32>) -> tensor<32768x3072xf32> | |
| %expanded_195 = tensor.expand_shape %475 [[0, 1], [2]] : tensor<32768x3072xf32> into tensor<64x512x3072xf32> | |
| %476 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%cst_24 : tensor<3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %477 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_195, %476 : tensor<64x512x3072xf32>, tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %478 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%477 : tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.mulf %in, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %479 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%477, %478 : tensor<64x512x3072xf32>, tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %480 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%479, %cst_51 : tensor<64x512x3072xf32>, tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %481 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%477, %480 : tensor<64x512x3072xf32>, tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %482 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%481, %cst_50 : tensor<64x512x3072xf32>, tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %483 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%482 : tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = math.tanh %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %484 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%483, %cst_49 : tensor<64x512x3072xf32>, tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %485 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%484, %cst_48 : tensor<64x512x3072xf32>, tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %486 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%477, %485 : tensor<64x512x3072xf32>, tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %hoisted_59 = util.global.load @hoisted_59 : tensor<3072x768xf32> | |
| %collapsed_196 = tensor.collapse_shape %486 [[0, 1], [2]] : tensor<64x512x3072xf32> into tensor<32768x3072xf32> | |
| %487 = linalg.matmul ins(%collapsed_196, %hoisted_59 : tensor<32768x3072xf32>, tensor<3072x768xf32>) outs(%96 : tensor<32768x768xf32>) -> tensor<32768x768xf32> | |
| %expanded_197 = tensor.expand_shape %487 [[0, 1], [2]] : tensor<32768x768xf32> into tensor<64x512x768xf32> | |
| %488 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%cst_23 : tensor<768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| %489 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_197, %488 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %490 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%458, %489 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %491 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%490 : tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.mulf %in, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %492 = linalg.generic {indexing_maps = [#map1, #map3], iterator_types = ["parallel", "parallel", "reduction"]} ins(%491 : tensor<64x512x768xf32>) outs(%24 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.addf %out, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %493 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%492, %cst_57 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.divf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %494 = linalg.generic {indexing_maps = [#map1, #map3], iterator_types = ["parallel", "parallel", "reduction"]} ins(%490 : tensor<64x512x768xf32>) outs(%24 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.addf %out, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %495 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%494, %cst_57 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.divf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %496 = linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel"]} ins(%495 : tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.mulf %in, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %497 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%493, %496 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.subf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %498 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%497, %cst_56 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.maxf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %expanded_198 = tensor.expand_shape %498 [[0], [1, 2]] : tensor<64x512xf32> into tensor<64x512x1xf32> | |
| %499 = linalg.generic {indexing_maps = [#map3, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%495 : tensor<64x512xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| %500 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%490, %499 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.subf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %501 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_198, %cst_55 : tensor<64x512x1xf32>, tensor<64x512x1xf32>) outs(%34 : tensor<64x512x1xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x1xf32> | |
| %502 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%501 : tensor<64x512x1xf32>) outs(%34 : tensor<64x512x1xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = math.rsqrt %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x1xf32> | |
| %503 = linalg.generic {indexing_maps = [#map6, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%502 : tensor<64x512x1xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| %hoisted_60 = util.global.load @hoisted_60 : tensor<64x512x768xf32> | |
| %504 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%503, %hoisted_60 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %505 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%500, %504 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %hoisted_61 = util.global.load @hoisted_61 : tensor<64x512x768xf32> | |
| %506 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%505, %hoisted_61 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %hoisted_62 = util.global.load @hoisted_62 : tensor<768x2304xf32> | |
| %collapsed_199 = tensor.collapse_shape %506 [[0, 1], [2]] : tensor<64x512x768xf32> into tensor<32768x768xf32> | |
| %507 = linalg.matmul ins(%collapsed_199, %hoisted_62 : tensor<32768x768xf32>, tensor<768x2304xf32>) outs(%49 : tensor<32768x2304xf32>) -> tensor<32768x2304xf32> | |
| %expanded_200 = tensor.expand_shape %507 [[0, 1], [2]] : tensor<32768x2304xf32> into tensor<64x512x2304xf32> | |
| %508 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%cst_22 : tensor<2304xf32>) outs(%51 : tensor<64x512x2304xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x2304xf32> | |
| %509 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_200, %508 : tensor<64x512x2304xf32>, tensor<64x512x2304xf32>) outs(%51 : tensor<64x512x2304xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x2304xf32> | |
| %extracted_slice_201 = tensor.extract_slice %509[0, 0, 0] [64, 512, 768] [1, 1, 1] : tensor<64x512x2304xf32> to tensor<64x512x768xf32> | |
| %extracted_slice_202 = tensor.extract_slice %509[0, 0, 768] [64, 512, 768] [1, 1, 1] : tensor<64x512x2304xf32> to tensor<64x512x768xf32> | |
| %extracted_slice_203 = tensor.extract_slice %509[0, 0, 1536] [64, 512, 768] [1, 1, 1] : tensor<64x512x2304xf32> to tensor<64x512x768xf32> | |
| %expanded_204 = tensor.expand_shape %extracted_slice_201 [[0], [1], [2, 3]] : tensor<64x512x768xf32> into tensor<64x512x12x64xf32> | |
| %expanded_205 = tensor.expand_shape %extracted_slice_202 [[0], [1], [2, 3]] : tensor<64x512x768xf32> into tensor<64x512x12x64xf32> | |
| %expanded_206 = tensor.expand_shape %extracted_slice_203 [[0], [1], [2, 3]] : tensor<64x512x768xf32> into tensor<64x512x12x64xf32> | |
| %510 = linalg.generic {indexing_maps = [#map5, #map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_204, %67 : tensor<64x512x12x64xf32>, tensor<64x512x12x64xf32>) outs(%66 : tensor<64x512x12x64xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.divf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x12x64xf32> | |
| %511 = linalg.generic {indexing_maps = [#map13, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%510 : tensor<64x512x12x64xf32>) outs(%69 : tensor<64x12x512x64xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x12x512x64xf32> | |
| %512 = linalg.generic {indexing_maps = [#map14, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_205 : tensor<64x512x12x64xf32>) outs(%71 : tensor<64x12x64x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x12x64x512xf32> | |
| %collapsed_207 = tensor.collapse_shape %511 [[0, 1], [2], [3]] : tensor<64x12x512x64xf32> into tensor<768x512x64xf32> | |
| %collapsed_208 = tensor.collapse_shape %512 [[0, 1], [2], [3]] : tensor<64x12x64x512xf32> into tensor<768x64x512xf32> | |
| %513 = linalg.batch_matmul ins(%collapsed_207, %collapsed_208 : tensor<768x512x64xf32>, tensor<768x64x512xf32>) outs(%74 : tensor<768x512x512xf32>) -> tensor<768x512x512xf32> | |
| %expanded_209 = tensor.expand_shape %513 [[0, 1], [2], [3]] : tensor<768x512x512xf32> into tensor<64x12x512x512xf32> | |
| %514 = linalg.generic {indexing_maps = [#map5, #map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_209, %77 : tensor<64x12x512x512xf32>, tensor<64x12x512x512xf32>) outs(%76 : tensor<64x12x512x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x12x512x512xf32> | |
| %515 = linalg.generic {indexing_maps = [#map5, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%514 : tensor<64x12x512x512xf32>) outs(%80 : tensor<64x12x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.maxf %out, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x12x512xf32> | |
| %516 = linalg.generic {indexing_maps = [#map4, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%515 : tensor<64x12x512xf32>) outs(%76 : tensor<64x12x512x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x12x512x512xf32> | |
| %517 = linalg.generic {indexing_maps = [#map5, #map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%514, %516 : tensor<64x12x512x512xf32>, tensor<64x12x512x512xf32>) outs(%76 : tensor<64x12x512x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.subf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x12x512x512xf32> | |
| %518 = linalg.generic {indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%517 : tensor<64x12x512x512xf32>) outs(%76 : tensor<64x12x512x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = math.exp %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x12x512x512xf32> | |
| %519 = linalg.generic {indexing_maps = [#map5, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%518 : tensor<64x12x512x512xf32>) outs(%85 : tensor<64x12x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.addf %out, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x12x512xf32> | |
| %520 = linalg.generic {indexing_maps = [#map4, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%519 : tensor<64x12x512xf32>) outs(%76 : tensor<64x12x512x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x12x512x512xf32> | |
| %521 = linalg.generic {indexing_maps = [#map5, #map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%518, %520 : tensor<64x12x512x512xf32>, tensor<64x12x512x512xf32>) outs(%76 : tensor<64x12x512x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.divf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x12x512x512xf32> | |
| %522 = linalg.generic {indexing_maps = [#map14, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_206 : tensor<64x512x12x64xf32>) outs(%71 : tensor<64x12x64x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x12x64x512xf32> | |
| %523 = linalg.generic {indexing_maps = [#map16, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%521 : tensor<64x12x512x512xf32>) outs(%76 : tensor<64x12x512x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x12x512x512xf32> | |
| %collapsed_210 = tensor.collapse_shape %522 [[0, 1], [2], [3]] : tensor<64x12x64x512xf32> into tensor<768x64x512xf32> | |
| %collapsed_211 = tensor.collapse_shape %523 [[0, 1], [2], [3]] : tensor<64x12x512x512xf32> into tensor<768x512x512xf32> | |
| %524 = linalg.batch_matmul ins(%collapsed_210, %collapsed_211 : tensor<768x64x512xf32>, tensor<768x512x512xf32>) outs(%92 : tensor<768x64x512xf32>) -> tensor<768x64x512xf32> | |
| %expanded_212 = tensor.expand_shape %524 [[0, 1], [2], [3]] : tensor<768x64x512xf32> into tensor<64x12x64x512xf32> | |
| %525 = linalg.generic {indexing_maps = [#map17, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_212 : tensor<64x12x64x512xf32>) outs(%66 : tensor<64x512x12x64xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x12x64xf32> | |
| %hoisted_63 = util.global.load @hoisted_63 : tensor<768x768xf32> | |
| %collapsed_213 = tensor.collapse_shape %525 [[0, 1], [2, 3]] : tensor<64x512x12x64xf32> into tensor<32768x768xf32> | |
| %526 = linalg.matmul ins(%collapsed_213, %hoisted_63 : tensor<32768x768xf32>, tensor<768x768xf32>) outs(%96 : tensor<32768x768xf32>) -> tensor<32768x768xf32> | |
| %expanded_214 = tensor.expand_shape %526 [[0, 1], [2]] : tensor<32768x768xf32> into tensor<64x512x768xf32> | |
| %527 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%cst_21 : tensor<768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| %528 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_214, %527 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %529 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%528, %490 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %530 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%529 : tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.mulf %in, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %531 = linalg.generic {indexing_maps = [#map1, #map3], iterator_types = ["parallel", "parallel", "reduction"]} ins(%530 : tensor<64x512x768xf32>) outs(%24 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.addf %out, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %532 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%531, %cst_57 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.divf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %533 = linalg.generic {indexing_maps = [#map1, #map3], iterator_types = ["parallel", "parallel", "reduction"]} ins(%529 : tensor<64x512x768xf32>) outs(%24 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.addf %out, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %534 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%533, %cst_57 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.divf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %535 = linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel"]} ins(%534 : tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.mulf %in, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %536 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%532, %535 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.subf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %537 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%536, %cst_56 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.maxf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %expanded_215 = tensor.expand_shape %537 [[0], [1, 2]] : tensor<64x512xf32> into tensor<64x512x1xf32> | |
| %538 = linalg.generic {indexing_maps = [#map3, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%534 : tensor<64x512xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| %539 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%529, %538 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.subf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %540 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_215, %cst_55 : tensor<64x512x1xf32>, tensor<64x512x1xf32>) outs(%34 : tensor<64x512x1xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x1xf32> | |
| %541 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%540 : tensor<64x512x1xf32>) outs(%34 : tensor<64x512x1xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = math.rsqrt %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x1xf32> | |
| %542 = linalg.generic {indexing_maps = [#map6, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%541 : tensor<64x512x1xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| %hoisted_64 = util.global.load @hoisted_64 : tensor<64x512x768xf32> | |
| %543 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%542, %hoisted_64 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %544 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%539, %543 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %hoisted_65 = util.global.load @hoisted_65 : tensor<64x512x768xf32> | |
| %545 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%544, %hoisted_65 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %hoisted_66 = util.global.load @hoisted_66 : tensor<768x3072xf32> | |
| %collapsed_216 = tensor.collapse_shape %545 [[0, 1], [2]] : tensor<64x512x768xf32> into tensor<32768x768xf32> | |
| %546 = linalg.matmul ins(%collapsed_216, %hoisted_66 : tensor<32768x768xf32>, tensor<768x3072xf32>) outs(%118 : tensor<32768x3072xf32>) -> tensor<32768x3072xf32> | |
| %expanded_217 = tensor.expand_shape %546 [[0, 1], [2]] : tensor<32768x3072xf32> into tensor<64x512x3072xf32> | |
| %547 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%cst_20 : tensor<3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %548 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_217, %547 : tensor<64x512x3072xf32>, tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %549 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%548 : tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.mulf %in, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %550 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%548, %549 : tensor<64x512x3072xf32>, tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %551 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%550, %cst_51 : tensor<64x512x3072xf32>, tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %552 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%548, %551 : tensor<64x512x3072xf32>, tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %553 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%552, %cst_50 : tensor<64x512x3072xf32>, tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %554 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%553 : tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = math.tanh %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %555 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%554, %cst_49 : tensor<64x512x3072xf32>, tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %556 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%555, %cst_48 : tensor<64x512x3072xf32>, tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %557 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%548, %556 : tensor<64x512x3072xf32>, tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %hoisted_67 = util.global.load @hoisted_67 : tensor<3072x768xf32> | |
| %collapsed_218 = tensor.collapse_shape %557 [[0, 1], [2]] : tensor<64x512x3072xf32> into tensor<32768x3072xf32> | |
| %558 = linalg.matmul ins(%collapsed_218, %hoisted_67 : tensor<32768x3072xf32>, tensor<3072x768xf32>) outs(%96 : tensor<32768x768xf32>) -> tensor<32768x768xf32> | |
| %expanded_219 = tensor.expand_shape %558 [[0, 1], [2]] : tensor<32768x768xf32> into tensor<64x512x768xf32> | |
| %559 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%cst_19 : tensor<768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| %560 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_219, %559 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %561 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%529, %560 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %562 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%561 : tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.mulf %in, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %563 = linalg.generic {indexing_maps = [#map1, #map3], iterator_types = ["parallel", "parallel", "reduction"]} ins(%562 : tensor<64x512x768xf32>) outs(%24 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.addf %out, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %564 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%563, %cst_57 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.divf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %565 = linalg.generic {indexing_maps = [#map1, #map3], iterator_types = ["parallel", "parallel", "reduction"]} ins(%561 : tensor<64x512x768xf32>) outs(%24 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.addf %out, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %566 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%565, %cst_57 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.divf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %567 = linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel"]} ins(%566 : tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.mulf %in, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %568 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%564, %567 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.subf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %569 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%568, %cst_56 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.maxf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %expanded_220 = tensor.expand_shape %569 [[0], [1, 2]] : tensor<64x512xf32> into tensor<64x512x1xf32> | |
| %570 = linalg.generic {indexing_maps = [#map3, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%566 : tensor<64x512xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| %571 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%561, %570 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.subf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %572 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_220, %cst_55 : tensor<64x512x1xf32>, tensor<64x512x1xf32>) outs(%34 : tensor<64x512x1xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x1xf32> | |
| %573 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%572 : tensor<64x512x1xf32>) outs(%34 : tensor<64x512x1xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = math.rsqrt %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x1xf32> | |
| %574 = linalg.generic {indexing_maps = [#map6, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%573 : tensor<64x512x1xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| %hoisted_68 = util.global.load @hoisted_68 : tensor<64x512x768xf32> | |
| %575 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%574, %hoisted_68 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %576 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%571, %575 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %hoisted_69 = util.global.load @hoisted_69 : tensor<64x512x768xf32> | |
| %577 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%576, %hoisted_69 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %hoisted_70 = util.global.load @hoisted_70 : tensor<768x2304xf32> | |
| %collapsed_221 = tensor.collapse_shape %577 [[0, 1], [2]] : tensor<64x512x768xf32> into tensor<32768x768xf32> | |
| %578 = linalg.matmul ins(%collapsed_221, %hoisted_70 : tensor<32768x768xf32>, tensor<768x2304xf32>) outs(%49 : tensor<32768x2304xf32>) -> tensor<32768x2304xf32> | |
| %expanded_222 = tensor.expand_shape %578 [[0, 1], [2]] : tensor<32768x2304xf32> into tensor<64x512x2304xf32> | |
| %579 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%cst_18 : tensor<2304xf32>) outs(%51 : tensor<64x512x2304xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x2304xf32> | |
| %580 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_222, %579 : tensor<64x512x2304xf32>, tensor<64x512x2304xf32>) outs(%51 : tensor<64x512x2304xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x2304xf32> | |
| %extracted_slice_223 = tensor.extract_slice %580[0, 0, 0] [64, 512, 768] [1, 1, 1] : tensor<64x512x2304xf32> to tensor<64x512x768xf32> | |
| %extracted_slice_224 = tensor.extract_slice %580[0, 0, 768] [64, 512, 768] [1, 1, 1] : tensor<64x512x2304xf32> to tensor<64x512x768xf32> | |
| %extracted_slice_225 = tensor.extract_slice %580[0, 0, 1536] [64, 512, 768] [1, 1, 1] : tensor<64x512x2304xf32> to tensor<64x512x768xf32> | |
| %expanded_226 = tensor.expand_shape %extracted_slice_223 [[0], [1], [2, 3]] : tensor<64x512x768xf32> into tensor<64x512x12x64xf32> | |
| %expanded_227 = tensor.expand_shape %extracted_slice_224 [[0], [1], [2, 3]] : tensor<64x512x768xf32> into tensor<64x512x12x64xf32> | |
| %expanded_228 = tensor.expand_shape %extracted_slice_225 [[0], [1], [2, 3]] : tensor<64x512x768xf32> into tensor<64x512x12x64xf32> | |
| %581 = linalg.generic {indexing_maps = [#map5, #map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_226, %67 : tensor<64x512x12x64xf32>, tensor<64x512x12x64xf32>) outs(%66 : tensor<64x512x12x64xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.divf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x12x64xf32> | |
| %582 = linalg.generic {indexing_maps = [#map13, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%581 : tensor<64x512x12x64xf32>) outs(%69 : tensor<64x12x512x64xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x12x512x64xf32> | |
| %583 = linalg.generic {indexing_maps = [#map14, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_227 : tensor<64x512x12x64xf32>) outs(%71 : tensor<64x12x64x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x12x64x512xf32> | |
| %collapsed_229 = tensor.collapse_shape %582 [[0, 1], [2], [3]] : tensor<64x12x512x64xf32> into tensor<768x512x64xf32> | |
| %collapsed_230 = tensor.collapse_shape %583 [[0, 1], [2], [3]] : tensor<64x12x64x512xf32> into tensor<768x64x512xf32> | |
| %584 = linalg.batch_matmul ins(%collapsed_229, %collapsed_230 : tensor<768x512x64xf32>, tensor<768x64x512xf32>) outs(%74 : tensor<768x512x512xf32>) -> tensor<768x512x512xf32> | |
| %expanded_231 = tensor.expand_shape %584 [[0, 1], [2], [3]] : tensor<768x512x512xf32> into tensor<64x12x512x512xf32> | |
| %585 = linalg.generic {indexing_maps = [#map5, #map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_231, %77 : tensor<64x12x512x512xf32>, tensor<64x12x512x512xf32>) outs(%76 : tensor<64x12x512x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x12x512x512xf32> | |
| %586 = linalg.generic {indexing_maps = [#map5, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%585 : tensor<64x12x512x512xf32>) outs(%80 : tensor<64x12x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.maxf %out, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x12x512xf32> | |
| %587 = linalg.generic {indexing_maps = [#map4, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%586 : tensor<64x12x512xf32>) outs(%76 : tensor<64x12x512x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x12x512x512xf32> | |
| %588 = linalg.generic {indexing_maps = [#map5, #map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%585, %587 : tensor<64x12x512x512xf32>, tensor<64x12x512x512xf32>) outs(%76 : tensor<64x12x512x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.subf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x12x512x512xf32> | |
| %589 = linalg.generic {indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%588 : tensor<64x12x512x512xf32>) outs(%76 : tensor<64x12x512x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = math.exp %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x12x512x512xf32> | |
| %590 = linalg.generic {indexing_maps = [#map5, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%589 : tensor<64x12x512x512xf32>) outs(%85 : tensor<64x12x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.addf %out, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x12x512xf32> | |
| %591 = linalg.generic {indexing_maps = [#map4, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%590 : tensor<64x12x512xf32>) outs(%76 : tensor<64x12x512x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x12x512x512xf32> | |
| %592 = linalg.generic {indexing_maps = [#map5, #map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%589, %591 : tensor<64x12x512x512xf32>, tensor<64x12x512x512xf32>) outs(%76 : tensor<64x12x512x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.divf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x12x512x512xf32> | |
| %593 = linalg.generic {indexing_maps = [#map14, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_228 : tensor<64x512x12x64xf32>) outs(%71 : tensor<64x12x64x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x12x64x512xf32> | |
| %594 = linalg.generic {indexing_maps = [#map16, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%592 : tensor<64x12x512x512xf32>) outs(%76 : tensor<64x12x512x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x12x512x512xf32> | |
| %collapsed_232 = tensor.collapse_shape %593 [[0, 1], [2], [3]] : tensor<64x12x64x512xf32> into tensor<768x64x512xf32> | |
| %collapsed_233 = tensor.collapse_shape %594 [[0, 1], [2], [3]] : tensor<64x12x512x512xf32> into tensor<768x512x512xf32> | |
| %595 = linalg.batch_matmul ins(%collapsed_232, %collapsed_233 : tensor<768x64x512xf32>, tensor<768x512x512xf32>) outs(%92 : tensor<768x64x512xf32>) -> tensor<768x64x512xf32> | |
| %expanded_234 = tensor.expand_shape %595 [[0, 1], [2], [3]] : tensor<768x64x512xf32> into tensor<64x12x64x512xf32> | |
| %596 = linalg.generic {indexing_maps = [#map17, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_234 : tensor<64x12x64x512xf32>) outs(%66 : tensor<64x512x12x64xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x12x64xf32> | |
| %hoisted_71 = util.global.load @hoisted_71 : tensor<768x768xf32> | |
| %collapsed_235 = tensor.collapse_shape %596 [[0, 1], [2, 3]] : tensor<64x512x12x64xf32> into tensor<32768x768xf32> | |
| %597 = linalg.matmul ins(%collapsed_235, %hoisted_71 : tensor<32768x768xf32>, tensor<768x768xf32>) outs(%96 : tensor<32768x768xf32>) -> tensor<32768x768xf32> | |
| %expanded_236 = tensor.expand_shape %597 [[0, 1], [2]] : tensor<32768x768xf32> into tensor<64x512x768xf32> | |
| %598 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%cst_17 : tensor<768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| %599 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_236, %598 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %600 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%599, %561 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %601 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%600 : tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.mulf %in, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %602 = linalg.generic {indexing_maps = [#map1, #map3], iterator_types = ["parallel", "parallel", "reduction"]} ins(%601 : tensor<64x512x768xf32>) outs(%24 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.addf %out, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %603 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%602, %cst_57 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.divf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %604 = linalg.generic {indexing_maps = [#map1, #map3], iterator_types = ["parallel", "parallel", "reduction"]} ins(%600 : tensor<64x512x768xf32>) outs(%24 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.addf %out, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %605 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%604, %cst_57 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.divf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %606 = linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel"]} ins(%605 : tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.mulf %in, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %607 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%603, %606 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.subf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %608 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%607, %cst_56 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.maxf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %expanded_237 = tensor.expand_shape %608 [[0], [1, 2]] : tensor<64x512xf32> into tensor<64x512x1xf32> | |
| %609 = linalg.generic {indexing_maps = [#map3, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%605 : tensor<64x512xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| %610 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%600, %609 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.subf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %611 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_237, %cst_55 : tensor<64x512x1xf32>, tensor<64x512x1xf32>) outs(%34 : tensor<64x512x1xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x1xf32> | |
| %612 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%611 : tensor<64x512x1xf32>) outs(%34 : tensor<64x512x1xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = math.rsqrt %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x1xf32> | |
| %613 = linalg.generic {indexing_maps = [#map6, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%612 : tensor<64x512x1xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| %hoisted_72 = util.global.load @hoisted_72 : tensor<64x512x768xf32> | |
| %614 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%613, %hoisted_72 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %615 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%610, %614 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %hoisted_73 = util.global.load @hoisted_73 : tensor<64x512x768xf32> | |
| %616 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%615, %hoisted_73 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %hoisted_74 = util.global.load @hoisted_74 : tensor<768x3072xf32> | |
| %collapsed_238 = tensor.collapse_shape %616 [[0, 1], [2]] : tensor<64x512x768xf32> into tensor<32768x768xf32> | |
| %617 = linalg.matmul ins(%collapsed_238, %hoisted_74 : tensor<32768x768xf32>, tensor<768x3072xf32>) outs(%118 : tensor<32768x3072xf32>) -> tensor<32768x3072xf32> | |
| %expanded_239 = tensor.expand_shape %617 [[0, 1], [2]] : tensor<32768x3072xf32> into tensor<64x512x3072xf32> | |
| %618 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%cst_16 : tensor<3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %619 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_239, %618 : tensor<64x512x3072xf32>, tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %620 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%619 : tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.mulf %in, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %621 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%619, %620 : tensor<64x512x3072xf32>, tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %622 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%621, %cst_51 : tensor<64x512x3072xf32>, tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %623 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%619, %622 : tensor<64x512x3072xf32>, tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %624 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%623, %cst_50 : tensor<64x512x3072xf32>, tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %625 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%624 : tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = math.tanh %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %626 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%625, %cst_49 : tensor<64x512x3072xf32>, tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %627 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%626, %cst_48 : tensor<64x512x3072xf32>, tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %628 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%619, %627 : tensor<64x512x3072xf32>, tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %hoisted_75 = util.global.load @hoisted_75 : tensor<3072x768xf32> | |
| %collapsed_240 = tensor.collapse_shape %628 [[0, 1], [2]] : tensor<64x512x3072xf32> into tensor<32768x3072xf32> | |
| %629 = linalg.matmul ins(%collapsed_240, %hoisted_75 : tensor<32768x3072xf32>, tensor<3072x768xf32>) outs(%96 : tensor<32768x768xf32>) -> tensor<32768x768xf32> | |
| %expanded_241 = tensor.expand_shape %629 [[0, 1], [2]] : tensor<32768x768xf32> into tensor<64x512x768xf32> | |
| %630 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%cst_15 : tensor<768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| %631 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_241, %630 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %632 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%600, %631 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %633 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%632 : tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.mulf %in, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %634 = linalg.generic {indexing_maps = [#map1, #map3], iterator_types = ["parallel", "parallel", "reduction"]} ins(%633 : tensor<64x512x768xf32>) outs(%24 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.addf %out, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %635 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%634, %cst_57 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.divf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %636 = linalg.generic {indexing_maps = [#map1, #map3], iterator_types = ["parallel", "parallel", "reduction"]} ins(%632 : tensor<64x512x768xf32>) outs(%24 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.addf %out, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %637 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%636, %cst_57 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.divf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %638 = linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel"]} ins(%637 : tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.mulf %in, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %639 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%635, %638 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.subf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %640 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%639, %cst_56 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.maxf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %expanded_242 = tensor.expand_shape %640 [[0], [1, 2]] : tensor<64x512xf32> into tensor<64x512x1xf32> | |
| %641 = linalg.generic {indexing_maps = [#map3, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%637 : tensor<64x512xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| %642 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%632, %641 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.subf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %643 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_242, %cst_55 : tensor<64x512x1xf32>, tensor<64x512x1xf32>) outs(%34 : tensor<64x512x1xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x1xf32> | |
| %644 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%643 : tensor<64x512x1xf32>) outs(%34 : tensor<64x512x1xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = math.rsqrt %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x1xf32> | |
| %645 = linalg.generic {indexing_maps = [#map6, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%644 : tensor<64x512x1xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| %hoisted_76 = util.global.load @hoisted_76 : tensor<64x512x768xf32> | |
| %646 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%645, %hoisted_76 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %647 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%642, %646 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %hoisted_77 = util.global.load @hoisted_77 : tensor<64x512x768xf32> | |
| %648 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%647, %hoisted_77 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %hoisted_78 = util.global.load @hoisted_78 : tensor<768x2304xf32> | |
| %collapsed_243 = tensor.collapse_shape %648 [[0, 1], [2]] : tensor<64x512x768xf32> into tensor<32768x768xf32> | |
| %649 = linalg.matmul ins(%collapsed_243, %hoisted_78 : tensor<32768x768xf32>, tensor<768x2304xf32>) outs(%49 : tensor<32768x2304xf32>) -> tensor<32768x2304xf32> | |
| %expanded_244 = tensor.expand_shape %649 [[0, 1], [2]] : tensor<32768x2304xf32> into tensor<64x512x2304xf32> | |
| %650 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%cst_14 : tensor<2304xf32>) outs(%51 : tensor<64x512x2304xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x2304xf32> | |
| %651 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_244, %650 : tensor<64x512x2304xf32>, tensor<64x512x2304xf32>) outs(%51 : tensor<64x512x2304xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x2304xf32> | |
| %extracted_slice_245 = tensor.extract_slice %651[0, 0, 0] [64, 512, 768] [1, 1, 1] : tensor<64x512x2304xf32> to tensor<64x512x768xf32> | |
| %extracted_slice_246 = tensor.extract_slice %651[0, 0, 768] [64, 512, 768] [1, 1, 1] : tensor<64x512x2304xf32> to tensor<64x512x768xf32> | |
| %extracted_slice_247 = tensor.extract_slice %651[0, 0, 1536] [64, 512, 768] [1, 1, 1] : tensor<64x512x2304xf32> to tensor<64x512x768xf32> | |
| %expanded_248 = tensor.expand_shape %extracted_slice_245 [[0], [1], [2, 3]] : tensor<64x512x768xf32> into tensor<64x512x12x64xf32> | |
| %expanded_249 = tensor.expand_shape %extracted_slice_246 [[0], [1], [2, 3]] : tensor<64x512x768xf32> into tensor<64x512x12x64xf32> | |
| %expanded_250 = tensor.expand_shape %extracted_slice_247 [[0], [1], [2, 3]] : tensor<64x512x768xf32> into tensor<64x512x12x64xf32> | |
| %652 = linalg.generic {indexing_maps = [#map5, #map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_248, %67 : tensor<64x512x12x64xf32>, tensor<64x512x12x64xf32>) outs(%66 : tensor<64x512x12x64xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.divf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x12x64xf32> | |
| %653 = linalg.generic {indexing_maps = [#map13, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%652 : tensor<64x512x12x64xf32>) outs(%69 : tensor<64x12x512x64xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x12x512x64xf32> | |
| %654 = linalg.generic {indexing_maps = [#map14, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_249 : tensor<64x512x12x64xf32>) outs(%71 : tensor<64x12x64x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x12x64x512xf32> | |
| %collapsed_251 = tensor.collapse_shape %653 [[0, 1], [2], [3]] : tensor<64x12x512x64xf32> into tensor<768x512x64xf32> | |
| %collapsed_252 = tensor.collapse_shape %654 [[0, 1], [2], [3]] : tensor<64x12x64x512xf32> into tensor<768x64x512xf32> | |
| %655 = linalg.batch_matmul ins(%collapsed_251, %collapsed_252 : tensor<768x512x64xf32>, tensor<768x64x512xf32>) outs(%74 : tensor<768x512x512xf32>) -> tensor<768x512x512xf32> | |
| %expanded_253 = tensor.expand_shape %655 [[0, 1], [2], [3]] : tensor<768x512x512xf32> into tensor<64x12x512x512xf32> | |
| %656 = linalg.generic {indexing_maps = [#map5, #map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_253, %77 : tensor<64x12x512x512xf32>, tensor<64x12x512x512xf32>) outs(%76 : tensor<64x12x512x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x12x512x512xf32> | |
| %657 = linalg.generic {indexing_maps = [#map5, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%656 : tensor<64x12x512x512xf32>) outs(%80 : tensor<64x12x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.maxf %out, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x12x512xf32> | |
| %658 = linalg.generic {indexing_maps = [#map4, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%657 : tensor<64x12x512xf32>) outs(%76 : tensor<64x12x512x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x12x512x512xf32> | |
| %659 = linalg.generic {indexing_maps = [#map5, #map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%656, %658 : tensor<64x12x512x512xf32>, tensor<64x12x512x512xf32>) outs(%76 : tensor<64x12x512x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.subf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x12x512x512xf32> | |
| %660 = linalg.generic {indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%659 : tensor<64x12x512x512xf32>) outs(%76 : tensor<64x12x512x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = math.exp %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x12x512x512xf32> | |
| %661 = linalg.generic {indexing_maps = [#map5, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%660 : tensor<64x12x512x512xf32>) outs(%85 : tensor<64x12x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.addf %out, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x12x512xf32> | |
| %662 = linalg.generic {indexing_maps = [#map4, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%661 : tensor<64x12x512xf32>) outs(%76 : tensor<64x12x512x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x12x512x512xf32> | |
| %663 = linalg.generic {indexing_maps = [#map5, #map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%660, %662 : tensor<64x12x512x512xf32>, tensor<64x12x512x512xf32>) outs(%76 : tensor<64x12x512x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.divf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x12x512x512xf32> | |
| %664 = linalg.generic {indexing_maps = [#map14, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_250 : tensor<64x512x12x64xf32>) outs(%71 : tensor<64x12x64x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x12x64x512xf32> | |
| %665 = linalg.generic {indexing_maps = [#map16, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%663 : tensor<64x12x512x512xf32>) outs(%76 : tensor<64x12x512x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x12x512x512xf32> | |
| %collapsed_254 = tensor.collapse_shape %664 [[0, 1], [2], [3]] : tensor<64x12x64x512xf32> into tensor<768x64x512xf32> | |
| %collapsed_255 = tensor.collapse_shape %665 [[0, 1], [2], [3]] : tensor<64x12x512x512xf32> into tensor<768x512x512xf32> | |
| %666 = linalg.batch_matmul ins(%collapsed_254, %collapsed_255 : tensor<768x64x512xf32>, tensor<768x512x512xf32>) outs(%92 : tensor<768x64x512xf32>) -> tensor<768x64x512xf32> | |
| %expanded_256 = tensor.expand_shape %666 [[0, 1], [2], [3]] : tensor<768x64x512xf32> into tensor<64x12x64x512xf32> | |
| %667 = linalg.generic {indexing_maps = [#map17, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_256 : tensor<64x12x64x512xf32>) outs(%66 : tensor<64x512x12x64xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x12x64xf32> | |
| %hoisted_79 = util.global.load @hoisted_79 : tensor<768x768xf32> | |
| %collapsed_257 = tensor.collapse_shape %667 [[0, 1], [2, 3]] : tensor<64x512x12x64xf32> into tensor<32768x768xf32> | |
| %668 = linalg.matmul ins(%collapsed_257, %hoisted_79 : tensor<32768x768xf32>, tensor<768x768xf32>) outs(%96 : tensor<32768x768xf32>) -> tensor<32768x768xf32> | |
| %expanded_258 = tensor.expand_shape %668 [[0, 1], [2]] : tensor<32768x768xf32> into tensor<64x512x768xf32> | |
| %669 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%cst_13 : tensor<768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| %670 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_258, %669 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %671 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%670, %632 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %672 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%671 : tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.mulf %in, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %673 = linalg.generic {indexing_maps = [#map1, #map3], iterator_types = ["parallel", "parallel", "reduction"]} ins(%672 : tensor<64x512x768xf32>) outs(%24 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.addf %out, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %674 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%673, %cst_57 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.divf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %675 = linalg.generic {indexing_maps = [#map1, #map3], iterator_types = ["parallel", "parallel", "reduction"]} ins(%671 : tensor<64x512x768xf32>) outs(%24 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.addf %out, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %676 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%675, %cst_57 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.divf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %677 = linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel"]} ins(%676 : tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.mulf %in, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %678 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%674, %677 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.subf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %679 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%678, %cst_56 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.maxf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %expanded_259 = tensor.expand_shape %679 [[0], [1, 2]] : tensor<64x512xf32> into tensor<64x512x1xf32> | |
| %680 = linalg.generic {indexing_maps = [#map3, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%676 : tensor<64x512xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| %681 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%671, %680 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.subf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %682 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_259, %cst_55 : tensor<64x512x1xf32>, tensor<64x512x1xf32>) outs(%34 : tensor<64x512x1xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x1xf32> | |
| %683 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%682 : tensor<64x512x1xf32>) outs(%34 : tensor<64x512x1xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = math.rsqrt %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x1xf32> | |
| %684 = linalg.generic {indexing_maps = [#map6, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%683 : tensor<64x512x1xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| %hoisted_80 = util.global.load @hoisted_80 : tensor<64x512x768xf32> | |
| %685 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%684, %hoisted_80 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %686 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%681, %685 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %hoisted_81 = util.global.load @hoisted_81 : tensor<64x512x768xf32> | |
| %687 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%686, %hoisted_81 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %hoisted_82 = util.global.load @hoisted_82 : tensor<768x3072xf32> | |
| %collapsed_260 = tensor.collapse_shape %687 [[0, 1], [2]] : tensor<64x512x768xf32> into tensor<32768x768xf32> | |
| %688 = linalg.matmul ins(%collapsed_260, %hoisted_82 : tensor<32768x768xf32>, tensor<768x3072xf32>) outs(%118 : tensor<32768x3072xf32>) -> tensor<32768x3072xf32> | |
| %expanded_261 = tensor.expand_shape %688 [[0, 1], [2]] : tensor<32768x3072xf32> into tensor<64x512x3072xf32> | |
| %689 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%cst_12 : tensor<3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %690 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_261, %689 : tensor<64x512x3072xf32>, tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %691 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%690 : tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.mulf %in, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %692 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%690, %691 : tensor<64x512x3072xf32>, tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %693 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%692, %cst_51 : tensor<64x512x3072xf32>, tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %694 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%690, %693 : tensor<64x512x3072xf32>, tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %695 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%694, %cst_50 : tensor<64x512x3072xf32>, tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %696 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%695 : tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = math.tanh %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %697 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%696, %cst_49 : tensor<64x512x3072xf32>, tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %698 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%697, %cst_48 : tensor<64x512x3072xf32>, tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %699 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%690, %698 : tensor<64x512x3072xf32>, tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %hoisted_83 = util.global.load @hoisted_83 : tensor<3072x768xf32> | |
| %collapsed_262 = tensor.collapse_shape %699 [[0, 1], [2]] : tensor<64x512x3072xf32> into tensor<32768x3072xf32> | |
| %700 = linalg.matmul ins(%collapsed_262, %hoisted_83 : tensor<32768x3072xf32>, tensor<3072x768xf32>) outs(%96 : tensor<32768x768xf32>) -> tensor<32768x768xf32> | |
| %expanded_263 = tensor.expand_shape %700 [[0, 1], [2]] : tensor<32768x768xf32> into tensor<64x512x768xf32> | |
| %701 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%cst_11 : tensor<768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| %702 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_263, %701 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %703 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%671, %702 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %704 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%703 : tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.mulf %in, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %705 = linalg.generic {indexing_maps = [#map1, #map3], iterator_types = ["parallel", "parallel", "reduction"]} ins(%704 : tensor<64x512x768xf32>) outs(%24 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.addf %out, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %706 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%705, %cst_57 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.divf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %707 = linalg.generic {indexing_maps = [#map1, #map3], iterator_types = ["parallel", "parallel", "reduction"]} ins(%703 : tensor<64x512x768xf32>) outs(%24 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.addf %out, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %708 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%707, %cst_57 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.divf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %709 = linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel"]} ins(%708 : tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.mulf %in, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %710 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%706, %709 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.subf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %711 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%710, %cst_56 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.maxf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %expanded_264 = tensor.expand_shape %711 [[0], [1, 2]] : tensor<64x512xf32> into tensor<64x512x1xf32> | |
| %712 = linalg.generic {indexing_maps = [#map3, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%708 : tensor<64x512xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| %713 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%703, %712 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.subf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %714 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_264, %cst_55 : tensor<64x512x1xf32>, tensor<64x512x1xf32>) outs(%34 : tensor<64x512x1xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x1xf32> | |
| %715 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%714 : tensor<64x512x1xf32>) outs(%34 : tensor<64x512x1xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = math.rsqrt %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x1xf32> | |
| %716 = linalg.generic {indexing_maps = [#map6, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%715 : tensor<64x512x1xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| %hoisted_84 = util.global.load @hoisted_84 : tensor<64x512x768xf32> | |
| %717 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%716, %hoisted_84 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %718 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%713, %717 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %hoisted_85 = util.global.load @hoisted_85 : tensor<64x512x768xf32> | |
| %719 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%718, %hoisted_85 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %hoisted_86 = util.global.load @hoisted_86 : tensor<768x2304xf32> | |
| %collapsed_265 = tensor.collapse_shape %719 [[0, 1], [2]] : tensor<64x512x768xf32> into tensor<32768x768xf32> | |
| %720 = linalg.matmul ins(%collapsed_265, %hoisted_86 : tensor<32768x768xf32>, tensor<768x2304xf32>) outs(%49 : tensor<32768x2304xf32>) -> tensor<32768x2304xf32> | |
| %expanded_266 = tensor.expand_shape %720 [[0, 1], [2]] : tensor<32768x2304xf32> into tensor<64x512x2304xf32> | |
| %721 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%cst_10 : tensor<2304xf32>) outs(%51 : tensor<64x512x2304xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x2304xf32> | |
| %722 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_266, %721 : tensor<64x512x2304xf32>, tensor<64x512x2304xf32>) outs(%51 : tensor<64x512x2304xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x2304xf32> | |
| %extracted_slice_267 = tensor.extract_slice %722[0, 0, 0] [64, 512, 768] [1, 1, 1] : tensor<64x512x2304xf32> to tensor<64x512x768xf32> | |
| %extracted_slice_268 = tensor.extract_slice %722[0, 0, 768] [64, 512, 768] [1, 1, 1] : tensor<64x512x2304xf32> to tensor<64x512x768xf32> | |
| %extracted_slice_269 = tensor.extract_slice %722[0, 0, 1536] [64, 512, 768] [1, 1, 1] : tensor<64x512x2304xf32> to tensor<64x512x768xf32> | |
| %expanded_270 = tensor.expand_shape %extracted_slice_267 [[0], [1], [2, 3]] : tensor<64x512x768xf32> into tensor<64x512x12x64xf32> | |
| %expanded_271 = tensor.expand_shape %extracted_slice_268 [[0], [1], [2, 3]] : tensor<64x512x768xf32> into tensor<64x512x12x64xf32> | |
| %expanded_272 = tensor.expand_shape %extracted_slice_269 [[0], [1], [2, 3]] : tensor<64x512x768xf32> into tensor<64x512x12x64xf32> | |
| %723 = linalg.generic {indexing_maps = [#map5, #map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_270, %67 : tensor<64x512x12x64xf32>, tensor<64x512x12x64xf32>) outs(%66 : tensor<64x512x12x64xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.divf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x12x64xf32> | |
| %724 = linalg.generic {indexing_maps = [#map13, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%723 : tensor<64x512x12x64xf32>) outs(%69 : tensor<64x12x512x64xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x12x512x64xf32> | |
| %725 = linalg.generic {indexing_maps = [#map14, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_271 : tensor<64x512x12x64xf32>) outs(%71 : tensor<64x12x64x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x12x64x512xf32> | |
| %collapsed_273 = tensor.collapse_shape %724 [[0, 1], [2], [3]] : tensor<64x12x512x64xf32> into tensor<768x512x64xf32> | |
| %collapsed_274 = tensor.collapse_shape %725 [[0, 1], [2], [3]] : tensor<64x12x64x512xf32> into tensor<768x64x512xf32> | |
| %726 = linalg.batch_matmul ins(%collapsed_273, %collapsed_274 : tensor<768x512x64xf32>, tensor<768x64x512xf32>) outs(%74 : tensor<768x512x512xf32>) -> tensor<768x512x512xf32> | |
| %expanded_275 = tensor.expand_shape %726 [[0, 1], [2], [3]] : tensor<768x512x512xf32> into tensor<64x12x512x512xf32> | |
| %727 = linalg.generic {indexing_maps = [#map5, #map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_275, %77 : tensor<64x12x512x512xf32>, tensor<64x12x512x512xf32>) outs(%76 : tensor<64x12x512x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x12x512x512xf32> | |
| %728 = linalg.generic {indexing_maps = [#map5, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%727 : tensor<64x12x512x512xf32>) outs(%80 : tensor<64x12x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.maxf %out, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x12x512xf32> | |
| %729 = linalg.generic {indexing_maps = [#map4, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%728 : tensor<64x12x512xf32>) outs(%76 : tensor<64x12x512x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x12x512x512xf32> | |
| %730 = linalg.generic {indexing_maps = [#map5, #map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%727, %729 : tensor<64x12x512x512xf32>, tensor<64x12x512x512xf32>) outs(%76 : tensor<64x12x512x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.subf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x12x512x512xf32> | |
| %731 = linalg.generic {indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%730 : tensor<64x12x512x512xf32>) outs(%76 : tensor<64x12x512x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = math.exp %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x12x512x512xf32> | |
| %732 = linalg.generic {indexing_maps = [#map5, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%731 : tensor<64x12x512x512xf32>) outs(%85 : tensor<64x12x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.addf %out, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x12x512xf32> | |
| %733 = linalg.generic {indexing_maps = [#map4, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%732 : tensor<64x12x512xf32>) outs(%76 : tensor<64x12x512x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x12x512x512xf32> | |
| %734 = linalg.generic {indexing_maps = [#map5, #map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%731, %733 : tensor<64x12x512x512xf32>, tensor<64x12x512x512xf32>) outs(%76 : tensor<64x12x512x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.divf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x12x512x512xf32> | |
| %735 = linalg.generic {indexing_maps = [#map14, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_272 : tensor<64x512x12x64xf32>) outs(%71 : tensor<64x12x64x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x12x64x512xf32> | |
| %736 = linalg.generic {indexing_maps = [#map16, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%734 : tensor<64x12x512x512xf32>) outs(%76 : tensor<64x12x512x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x12x512x512xf32> | |
| %collapsed_276 = tensor.collapse_shape %735 [[0, 1], [2], [3]] : tensor<64x12x64x512xf32> into tensor<768x64x512xf32> | |
| %collapsed_277 = tensor.collapse_shape %736 [[0, 1], [2], [3]] : tensor<64x12x512x512xf32> into tensor<768x512x512xf32> | |
| %737 = linalg.batch_matmul ins(%collapsed_276, %collapsed_277 : tensor<768x64x512xf32>, tensor<768x512x512xf32>) outs(%92 : tensor<768x64x512xf32>) -> tensor<768x64x512xf32> | |
| %expanded_278 = tensor.expand_shape %737 [[0, 1], [2], [3]] : tensor<768x64x512xf32> into tensor<64x12x64x512xf32> | |
| %738 = linalg.generic {indexing_maps = [#map17, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_278 : tensor<64x12x64x512xf32>) outs(%66 : tensor<64x512x12x64xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x12x64xf32> | |
| %hoisted_87 = util.global.load @hoisted_87 : tensor<768x768xf32> | |
| %collapsed_279 = tensor.collapse_shape %738 [[0, 1], [2, 3]] : tensor<64x512x12x64xf32> into tensor<32768x768xf32> | |
| %739 = linalg.matmul ins(%collapsed_279, %hoisted_87 : tensor<32768x768xf32>, tensor<768x768xf32>) outs(%96 : tensor<32768x768xf32>) -> tensor<32768x768xf32> | |
| %expanded_280 = tensor.expand_shape %739 [[0, 1], [2]] : tensor<32768x768xf32> into tensor<64x512x768xf32> | |
| %740 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%cst_9 : tensor<768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| %741 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_280, %740 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %742 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%741, %703 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %743 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%742 : tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.mulf %in, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %744 = linalg.generic {indexing_maps = [#map1, #map3], iterator_types = ["parallel", "parallel", "reduction"]} ins(%743 : tensor<64x512x768xf32>) outs(%24 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.addf %out, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %745 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%744, %cst_57 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.divf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %746 = linalg.generic {indexing_maps = [#map1, #map3], iterator_types = ["parallel", "parallel", "reduction"]} ins(%742 : tensor<64x512x768xf32>) outs(%24 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.addf %out, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %747 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%746, %cst_57 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.divf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %748 = linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel"]} ins(%747 : tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.mulf %in, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %749 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%745, %748 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.subf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %750 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%749, %cst_56 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.maxf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %expanded_281 = tensor.expand_shape %750 [[0], [1, 2]] : tensor<64x512xf32> into tensor<64x512x1xf32> | |
| %751 = linalg.generic {indexing_maps = [#map3, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%747 : tensor<64x512xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| %752 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%742, %751 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.subf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %753 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_281, %cst_55 : tensor<64x512x1xf32>, tensor<64x512x1xf32>) outs(%34 : tensor<64x512x1xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x1xf32> | |
| %754 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%753 : tensor<64x512x1xf32>) outs(%34 : tensor<64x512x1xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = math.rsqrt %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x1xf32> | |
| %755 = linalg.generic {indexing_maps = [#map6, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%754 : tensor<64x512x1xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| %hoisted_88 = util.global.load @hoisted_88 : tensor<64x512x768xf32> | |
| %756 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%755, %hoisted_88 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %757 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%752, %756 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %hoisted_89 = util.global.load @hoisted_89 : tensor<64x512x768xf32> | |
| %758 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%757, %hoisted_89 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %hoisted_90 = util.global.load @hoisted_90 : tensor<768x3072xf32> | |
| %collapsed_282 = tensor.collapse_shape %758 [[0, 1], [2]] : tensor<64x512x768xf32> into tensor<32768x768xf32> | |
| %759 = linalg.matmul ins(%collapsed_282, %hoisted_90 : tensor<32768x768xf32>, tensor<768x3072xf32>) outs(%118 : tensor<32768x3072xf32>) -> tensor<32768x3072xf32> | |
| %expanded_283 = tensor.expand_shape %759 [[0, 1], [2]] : tensor<32768x3072xf32> into tensor<64x512x3072xf32> | |
| %760 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%cst_8 : tensor<3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %761 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_283, %760 : tensor<64x512x3072xf32>, tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %762 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%761 : tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.mulf %in, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %763 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%761, %762 : tensor<64x512x3072xf32>, tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %764 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%763, %cst_51 : tensor<64x512x3072xf32>, tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %765 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%761, %764 : tensor<64x512x3072xf32>, tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %766 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%765, %cst_50 : tensor<64x512x3072xf32>, tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %767 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%766 : tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = math.tanh %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %768 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%767, %cst_49 : tensor<64x512x3072xf32>, tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %769 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%768, %cst_48 : tensor<64x512x3072xf32>, tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %770 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%761, %769 : tensor<64x512x3072xf32>, tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %hoisted_91 = util.global.load @hoisted_91 : tensor<3072x768xf32> | |
| %collapsed_284 = tensor.collapse_shape %770 [[0, 1], [2]] : tensor<64x512x3072xf32> into tensor<32768x3072xf32> | |
| %771 = linalg.matmul ins(%collapsed_284, %hoisted_91 : tensor<32768x3072xf32>, tensor<3072x768xf32>) outs(%96 : tensor<32768x768xf32>) -> tensor<32768x768xf32> | |
| %expanded_285 = tensor.expand_shape %771 [[0, 1], [2]] : tensor<32768x768xf32> into tensor<64x512x768xf32> | |
| %772 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%cst_7 : tensor<768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| %773 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_285, %772 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %774 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%742, %773 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %775 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%774 : tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.mulf %in, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %776 = linalg.generic {indexing_maps = [#map1, #map3], iterator_types = ["parallel", "parallel", "reduction"]} ins(%775 : tensor<64x512x768xf32>) outs(%24 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.addf %out, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %777 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%776, %cst_57 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.divf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %778 = linalg.generic {indexing_maps = [#map1, #map3], iterator_types = ["parallel", "parallel", "reduction"]} ins(%774 : tensor<64x512x768xf32>) outs(%24 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.addf %out, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %779 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%778, %cst_57 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.divf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %780 = linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel"]} ins(%779 : tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.mulf %in, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %781 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%777, %780 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.subf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %782 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%781, %cst_56 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.maxf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %expanded_286 = tensor.expand_shape %782 [[0], [1, 2]] : tensor<64x512xf32> into tensor<64x512x1xf32> | |
| %783 = linalg.generic {indexing_maps = [#map3, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%779 : tensor<64x512xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| %784 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%774, %783 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.subf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %785 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_286, %cst_55 : tensor<64x512x1xf32>, tensor<64x512x1xf32>) outs(%34 : tensor<64x512x1xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x1xf32> | |
| %786 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%785 : tensor<64x512x1xf32>) outs(%34 : tensor<64x512x1xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = math.rsqrt %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x1xf32> | |
| %787 = linalg.generic {indexing_maps = [#map6, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%786 : tensor<64x512x1xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| %hoisted_92 = util.global.load @hoisted_92 : tensor<64x512x768xf32> | |
| %788 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%787, %hoisted_92 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %789 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%784, %788 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %hoisted_93 = util.global.load @hoisted_93 : tensor<64x512x768xf32> | |
| %790 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%789, %hoisted_93 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %hoisted_94 = util.global.load @hoisted_94 : tensor<768x2304xf32> | |
| %collapsed_287 = tensor.collapse_shape %790 [[0, 1], [2]] : tensor<64x512x768xf32> into tensor<32768x768xf32> | |
| %791 = linalg.matmul ins(%collapsed_287, %hoisted_94 : tensor<32768x768xf32>, tensor<768x2304xf32>) outs(%49 : tensor<32768x2304xf32>) -> tensor<32768x2304xf32> | |
| %expanded_288 = tensor.expand_shape %791 [[0, 1], [2]] : tensor<32768x2304xf32> into tensor<64x512x2304xf32> | |
| %792 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%cst_6 : tensor<2304xf32>) outs(%51 : tensor<64x512x2304xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x2304xf32> | |
| %793 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_288, %792 : tensor<64x512x2304xf32>, tensor<64x512x2304xf32>) outs(%51 : tensor<64x512x2304xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x2304xf32> | |
| %extracted_slice_289 = tensor.extract_slice %793[0, 0, 0] [64, 512, 768] [1, 1, 1] : tensor<64x512x2304xf32> to tensor<64x512x768xf32> | |
| %extracted_slice_290 = tensor.extract_slice %793[0, 0, 768] [64, 512, 768] [1, 1, 1] : tensor<64x512x2304xf32> to tensor<64x512x768xf32> | |
| %extracted_slice_291 = tensor.extract_slice %793[0, 0, 1536] [64, 512, 768] [1, 1, 1] : tensor<64x512x2304xf32> to tensor<64x512x768xf32> | |
| %expanded_292 = tensor.expand_shape %extracted_slice_289 [[0], [1], [2, 3]] : tensor<64x512x768xf32> into tensor<64x512x12x64xf32> | |
| %expanded_293 = tensor.expand_shape %extracted_slice_290 [[0], [1], [2, 3]] : tensor<64x512x768xf32> into tensor<64x512x12x64xf32> | |
| %expanded_294 = tensor.expand_shape %extracted_slice_291 [[0], [1], [2, 3]] : tensor<64x512x768xf32> into tensor<64x512x12x64xf32> | |
| %794 = linalg.generic {indexing_maps = [#map5, #map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_292, %67 : tensor<64x512x12x64xf32>, tensor<64x512x12x64xf32>) outs(%66 : tensor<64x512x12x64xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.divf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x12x64xf32> | |
| %795 = linalg.generic {indexing_maps = [#map13, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%794 : tensor<64x512x12x64xf32>) outs(%69 : tensor<64x12x512x64xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x12x512x64xf32> | |
| %796 = linalg.generic {indexing_maps = [#map14, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_293 : tensor<64x512x12x64xf32>) outs(%71 : tensor<64x12x64x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x12x64x512xf32> | |
| %collapsed_295 = tensor.collapse_shape %795 [[0, 1], [2], [3]] : tensor<64x12x512x64xf32> into tensor<768x512x64xf32> | |
| %collapsed_296 = tensor.collapse_shape %796 [[0, 1], [2], [3]] : tensor<64x12x64x512xf32> into tensor<768x64x512xf32> | |
| %797 = linalg.batch_matmul ins(%collapsed_295, %collapsed_296 : tensor<768x512x64xf32>, tensor<768x64x512xf32>) outs(%74 : tensor<768x512x512xf32>) -> tensor<768x512x512xf32> | |
| %expanded_297 = tensor.expand_shape %797 [[0, 1], [2], [3]] : tensor<768x512x512xf32> into tensor<64x12x512x512xf32> | |
| %798 = linalg.generic {indexing_maps = [#map5, #map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_297, %77 : tensor<64x12x512x512xf32>, tensor<64x12x512x512xf32>) outs(%76 : tensor<64x12x512x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x12x512x512xf32> | |
| %799 = linalg.generic {indexing_maps = [#map5, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%798 : tensor<64x12x512x512xf32>) outs(%80 : tensor<64x12x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.maxf %out, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x12x512xf32> | |
| %800 = linalg.generic {indexing_maps = [#map4, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%799 : tensor<64x12x512xf32>) outs(%76 : tensor<64x12x512x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x12x512x512xf32> | |
| %801 = linalg.generic {indexing_maps = [#map5, #map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%798, %800 : tensor<64x12x512x512xf32>, tensor<64x12x512x512xf32>) outs(%76 : tensor<64x12x512x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.subf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x12x512x512xf32> | |
| %802 = linalg.generic {indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%801 : tensor<64x12x512x512xf32>) outs(%76 : tensor<64x12x512x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = math.exp %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x12x512x512xf32> | |
| %803 = linalg.generic {indexing_maps = [#map5, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%802 : tensor<64x12x512x512xf32>) outs(%85 : tensor<64x12x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.addf %out, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x12x512xf32> | |
| %804 = linalg.generic {indexing_maps = [#map4, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%803 : tensor<64x12x512xf32>) outs(%76 : tensor<64x12x512x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x12x512x512xf32> | |
| %805 = linalg.generic {indexing_maps = [#map5, #map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%802, %804 : tensor<64x12x512x512xf32>, tensor<64x12x512x512xf32>) outs(%76 : tensor<64x12x512x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.divf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x12x512x512xf32> | |
| %806 = linalg.generic {indexing_maps = [#map14, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_294 : tensor<64x512x12x64xf32>) outs(%71 : tensor<64x12x64x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x12x64x512xf32> | |
| %807 = linalg.generic {indexing_maps = [#map16, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%805 : tensor<64x12x512x512xf32>) outs(%76 : tensor<64x12x512x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x12x512x512xf32> | |
| %collapsed_298 = tensor.collapse_shape %806 [[0, 1], [2], [3]] : tensor<64x12x64x512xf32> into tensor<768x64x512xf32> | |
| %collapsed_299 = tensor.collapse_shape %807 [[0, 1], [2], [3]] : tensor<64x12x512x512xf32> into tensor<768x512x512xf32> | |
| %808 = linalg.batch_matmul ins(%collapsed_298, %collapsed_299 : tensor<768x64x512xf32>, tensor<768x512x512xf32>) outs(%92 : tensor<768x64x512xf32>) -> tensor<768x64x512xf32> | |
| %expanded_300 = tensor.expand_shape %808 [[0, 1], [2], [3]] : tensor<768x64x512xf32> into tensor<64x12x64x512xf32> | |
| %809 = linalg.generic {indexing_maps = [#map17, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_300 : tensor<64x12x64x512xf32>) outs(%66 : tensor<64x512x12x64xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x12x64xf32> | |
| %hoisted_95 = util.global.load @hoisted_95 : tensor<768x768xf32> | |
| %collapsed_301 = tensor.collapse_shape %809 [[0, 1], [2, 3]] : tensor<64x512x12x64xf32> into tensor<32768x768xf32> | |
| %810 = linalg.matmul ins(%collapsed_301, %hoisted_95 : tensor<32768x768xf32>, tensor<768x768xf32>) outs(%96 : tensor<32768x768xf32>) -> tensor<32768x768xf32> | |
| %expanded_302 = tensor.expand_shape %810 [[0, 1], [2]] : tensor<32768x768xf32> into tensor<64x512x768xf32> | |
| %811 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%cst_5 : tensor<768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| %812 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_302, %811 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %813 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%812, %774 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %814 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%813 : tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.mulf %in, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %815 = linalg.generic {indexing_maps = [#map1, #map3], iterator_types = ["parallel", "parallel", "reduction"]} ins(%814 : tensor<64x512x768xf32>) outs(%24 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.addf %out, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %816 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%815, %cst_57 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.divf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %817 = linalg.generic {indexing_maps = [#map1, #map3], iterator_types = ["parallel", "parallel", "reduction"]} ins(%813 : tensor<64x512x768xf32>) outs(%24 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.addf %out, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %818 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%817, %cst_57 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.divf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %819 = linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel"]} ins(%818 : tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.mulf %in, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %820 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%816, %819 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.subf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %821 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%820, %cst_56 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.maxf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %expanded_303 = tensor.expand_shape %821 [[0], [1, 2]] : tensor<64x512xf32> into tensor<64x512x1xf32> | |
| %822 = linalg.generic {indexing_maps = [#map3, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%818 : tensor<64x512xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| %823 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%813, %822 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.subf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %824 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_303, %cst_55 : tensor<64x512x1xf32>, tensor<64x512x1xf32>) outs(%34 : tensor<64x512x1xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x1xf32> | |
| %825 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%824 : tensor<64x512x1xf32>) outs(%34 : tensor<64x512x1xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = math.rsqrt %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x1xf32> | |
| %826 = linalg.generic {indexing_maps = [#map6, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%825 : tensor<64x512x1xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| %hoisted_96 = util.global.load @hoisted_96 : tensor<64x512x768xf32> | |
| %827 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%826, %hoisted_96 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %828 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%823, %827 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %hoisted_97 = util.global.load @hoisted_97 : tensor<64x512x768xf32> | |
| %829 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%828, %hoisted_97 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %hoisted_98 = util.global.load @hoisted_98 : tensor<768x3072xf32> | |
| %collapsed_304 = tensor.collapse_shape %829 [[0, 1], [2]] : tensor<64x512x768xf32> into tensor<32768x768xf32> | |
| %830 = linalg.matmul ins(%collapsed_304, %hoisted_98 : tensor<32768x768xf32>, tensor<768x3072xf32>) outs(%118 : tensor<32768x3072xf32>) -> tensor<32768x3072xf32> | |
| %expanded_305 = tensor.expand_shape %830 [[0, 1], [2]] : tensor<32768x3072xf32> into tensor<64x512x3072xf32> | |
| %831 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%cst_4 : tensor<3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %832 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_305, %831 : tensor<64x512x3072xf32>, tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %833 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%832 : tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.mulf %in, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %834 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%832, %833 : tensor<64x512x3072xf32>, tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %835 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%834, %cst_51 : tensor<64x512x3072xf32>, tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %836 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%832, %835 : tensor<64x512x3072xf32>, tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %837 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%836, %cst_50 : tensor<64x512x3072xf32>, tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %838 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%837 : tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = math.tanh %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %839 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%838, %cst_49 : tensor<64x512x3072xf32>, tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %840 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%839, %cst_48 : tensor<64x512x3072xf32>, tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %841 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%832, %840 : tensor<64x512x3072xf32>, tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %hoisted_99 = util.global.load @hoisted_99 : tensor<3072x768xf32> | |
| %collapsed_306 = tensor.collapse_shape %841 [[0, 1], [2]] : tensor<64x512x3072xf32> into tensor<32768x3072xf32> | |
| %842 = linalg.matmul ins(%collapsed_306, %hoisted_99 : tensor<32768x3072xf32>, tensor<3072x768xf32>) outs(%96 : tensor<32768x768xf32>) -> tensor<32768x768xf32> | |
| %expanded_307 = tensor.expand_shape %842 [[0, 1], [2]] : tensor<32768x768xf32> into tensor<64x512x768xf32> | |
| %843 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%cst_3 : tensor<768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| %844 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_307, %843 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %845 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%813, %844 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %846 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%845 : tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.mulf %in, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %847 = linalg.generic {indexing_maps = [#map1, #map3], iterator_types = ["parallel", "parallel", "reduction"]} ins(%846 : tensor<64x512x768xf32>) outs(%24 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.addf %out, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %848 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%847, %cst_57 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.divf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %849 = linalg.generic {indexing_maps = [#map1, #map3], iterator_types = ["parallel", "parallel", "reduction"]} ins(%845 : tensor<64x512x768xf32>) outs(%24 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.addf %out, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %850 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%849, %cst_57 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.divf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %851 = linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel"]} ins(%850 : tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.mulf %in, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %852 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%848, %851 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.subf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %853 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%852, %cst_56 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.maxf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %expanded_308 = tensor.expand_shape %853 [[0], [1, 2]] : tensor<64x512xf32> into tensor<64x512x1xf32> | |
| %854 = linalg.generic {indexing_maps = [#map3, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%850 : tensor<64x512xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| %855 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%845, %854 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.subf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %856 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_308, %cst_55 : tensor<64x512x1xf32>, tensor<64x512x1xf32>) outs(%34 : tensor<64x512x1xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x1xf32> | |
| %857 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%856 : tensor<64x512x1xf32>) outs(%34 : tensor<64x512x1xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = math.rsqrt %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x1xf32> | |
| %858 = linalg.generic {indexing_maps = [#map6, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%857 : tensor<64x512x1xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| %hoisted_100 = util.global.load @hoisted_100 : tensor<64x512x768xf32> | |
| %859 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%858, %hoisted_100 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %860 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%855, %859 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %hoisted_101 = util.global.load @hoisted_101 : tensor<64x512x768xf32> | |
| %861 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%860, %hoisted_101 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %hoisted_102 = util.global.load @hoisted_102 : tensor<768x2304xf32> | |
| %collapsed_309 = tensor.collapse_shape %861 [[0, 1], [2]] : tensor<64x512x768xf32> into tensor<32768x768xf32> | |
| %862 = linalg.matmul ins(%collapsed_309, %hoisted_102 : tensor<32768x768xf32>, tensor<768x2304xf32>) outs(%49 : tensor<32768x2304xf32>) -> tensor<32768x2304xf32> | |
| %expanded_310 = tensor.expand_shape %862 [[0, 1], [2]] : tensor<32768x2304xf32> into tensor<64x512x2304xf32> | |
| %863 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%cst_2 : tensor<2304xf32>) outs(%51 : tensor<64x512x2304xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x2304xf32> | |
| %864 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_310, %863 : tensor<64x512x2304xf32>, tensor<64x512x2304xf32>) outs(%51 : tensor<64x512x2304xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x2304xf32> | |
| %extracted_slice_311 = tensor.extract_slice %864[0, 0, 0] [64, 512, 768] [1, 1, 1] : tensor<64x512x2304xf32> to tensor<64x512x768xf32> | |
| %extracted_slice_312 = tensor.extract_slice %864[0, 0, 768] [64, 512, 768] [1, 1, 1] : tensor<64x512x2304xf32> to tensor<64x512x768xf32> | |
| %extracted_slice_313 = tensor.extract_slice %864[0, 0, 1536] [64, 512, 768] [1, 1, 1] : tensor<64x512x2304xf32> to tensor<64x512x768xf32> | |
| %expanded_314 = tensor.expand_shape %extracted_slice_311 [[0], [1], [2, 3]] : tensor<64x512x768xf32> into tensor<64x512x12x64xf32> | |
| %expanded_315 = tensor.expand_shape %extracted_slice_312 [[0], [1], [2, 3]] : tensor<64x512x768xf32> into tensor<64x512x12x64xf32> | |
| %expanded_316 = tensor.expand_shape %extracted_slice_313 [[0], [1], [2, 3]] : tensor<64x512x768xf32> into tensor<64x512x12x64xf32> | |
| %865 = linalg.generic {indexing_maps = [#map5, #map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_314, %67 : tensor<64x512x12x64xf32>, tensor<64x512x12x64xf32>) outs(%66 : tensor<64x512x12x64xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.divf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x12x64xf32> | |
| %866 = linalg.generic {indexing_maps = [#map13, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%865 : tensor<64x512x12x64xf32>) outs(%69 : tensor<64x12x512x64xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x12x512x64xf32> | |
| %867 = linalg.generic {indexing_maps = [#map14, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_315 : tensor<64x512x12x64xf32>) outs(%71 : tensor<64x12x64x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x12x64x512xf32> | |
| %collapsed_317 = tensor.collapse_shape %866 [[0, 1], [2], [3]] : tensor<64x12x512x64xf32> into tensor<768x512x64xf32> | |
| %collapsed_318 = tensor.collapse_shape %867 [[0, 1], [2], [3]] : tensor<64x12x64x512xf32> into tensor<768x64x512xf32> | |
| %868 = linalg.batch_matmul ins(%collapsed_317, %collapsed_318 : tensor<768x512x64xf32>, tensor<768x64x512xf32>) outs(%74 : tensor<768x512x512xf32>) -> tensor<768x512x512xf32> | |
| %expanded_319 = tensor.expand_shape %868 [[0, 1], [2], [3]] : tensor<768x512x512xf32> into tensor<64x12x512x512xf32> | |
| %869 = linalg.generic {indexing_maps = [#map5, #map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_319, %77 : tensor<64x12x512x512xf32>, tensor<64x12x512x512xf32>) outs(%76 : tensor<64x12x512x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x12x512x512xf32> | |
| %870 = linalg.generic {indexing_maps = [#map5, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%869 : tensor<64x12x512x512xf32>) outs(%80 : tensor<64x12x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.maxf %out, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x12x512xf32> | |
| %871 = linalg.generic {indexing_maps = [#map4, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%870 : tensor<64x12x512xf32>) outs(%76 : tensor<64x12x512x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x12x512x512xf32> | |
| %872 = linalg.generic {indexing_maps = [#map5, #map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%869, %871 : tensor<64x12x512x512xf32>, tensor<64x12x512x512xf32>) outs(%76 : tensor<64x12x512x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.subf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x12x512x512xf32> | |
| %873 = linalg.generic {indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%872 : tensor<64x12x512x512xf32>) outs(%76 : tensor<64x12x512x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = math.exp %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x12x512x512xf32> | |
| %874 = linalg.generic {indexing_maps = [#map5, #map4], iterator_types = ["parallel", "parallel", "parallel", "reduction"]} ins(%873 : tensor<64x12x512x512xf32>) outs(%85 : tensor<64x12x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.addf %out, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x12x512xf32> | |
| %875 = linalg.generic {indexing_maps = [#map4, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%874 : tensor<64x12x512xf32>) outs(%76 : tensor<64x12x512x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x12x512x512xf32> | |
| %876 = linalg.generic {indexing_maps = [#map5, #map5, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%873, %875 : tensor<64x12x512x512xf32>, tensor<64x12x512x512xf32>) outs(%76 : tensor<64x12x512x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.divf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x12x512x512xf32> | |
| %877 = linalg.generic {indexing_maps = [#map14, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_316 : tensor<64x512x12x64xf32>) outs(%71 : tensor<64x12x64x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x12x64x512xf32> | |
| %878 = linalg.generic {indexing_maps = [#map16, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%876 : tensor<64x12x512x512xf32>) outs(%76 : tensor<64x12x512x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x12x512x512xf32> | |
| %collapsed_320 = tensor.collapse_shape %877 [[0, 1], [2], [3]] : tensor<64x12x64x512xf32> into tensor<768x64x512xf32> | |
| %collapsed_321 = tensor.collapse_shape %878 [[0, 1], [2], [3]] : tensor<64x12x512x512xf32> into tensor<768x512x512xf32> | |
| %879 = linalg.batch_matmul ins(%collapsed_320, %collapsed_321 : tensor<768x64x512xf32>, tensor<768x512x512xf32>) outs(%92 : tensor<768x64x512xf32>) -> tensor<768x64x512xf32> | |
| %expanded_322 = tensor.expand_shape %879 [[0, 1], [2], [3]] : tensor<768x64x512xf32> into tensor<64x12x64x512xf32> | |
| %880 = linalg.generic {indexing_maps = [#map17, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_322 : tensor<64x12x64x512xf32>) outs(%66 : tensor<64x512x12x64xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x12x64xf32> | |
| %hoisted_103 = util.global.load @hoisted_103 : tensor<768x768xf32> | |
| %collapsed_323 = tensor.collapse_shape %880 [[0, 1], [2, 3]] : tensor<64x512x12x64xf32> into tensor<32768x768xf32> | |
| %881 = linalg.matmul ins(%collapsed_323, %hoisted_103 : tensor<32768x768xf32>, tensor<768x768xf32>) outs(%96 : tensor<32768x768xf32>) -> tensor<32768x768xf32> | |
| %expanded_324 = tensor.expand_shape %881 [[0, 1], [2]] : tensor<32768x768xf32> into tensor<64x512x768xf32> | |
| %882 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%cst_1 : tensor<768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| %883 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_324, %882 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %884 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%883, %845 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %885 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%884 : tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.mulf %in, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %886 = linalg.generic {indexing_maps = [#map1, #map3], iterator_types = ["parallel", "parallel", "reduction"]} ins(%885 : tensor<64x512x768xf32>) outs(%24 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.addf %out, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %887 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%886, %cst_57 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.divf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %888 = linalg.generic {indexing_maps = [#map1, #map3], iterator_types = ["parallel", "parallel", "reduction"]} ins(%884 : tensor<64x512x768xf32>) outs(%24 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.addf %out, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %889 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%888, %cst_57 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.divf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %890 = linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel"]} ins(%889 : tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.mulf %in, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %891 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%887, %890 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.subf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %892 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%891, %cst_56 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.maxf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %expanded_325 = tensor.expand_shape %892 [[0], [1, 2]] : tensor<64x512xf32> into tensor<64x512x1xf32> | |
| %893 = linalg.generic {indexing_maps = [#map3, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%889 : tensor<64x512xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| %894 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%884, %893 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.subf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %895 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_325, %cst_55 : tensor<64x512x1xf32>, tensor<64x512x1xf32>) outs(%34 : tensor<64x512x1xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x1xf32> | |
| %896 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%895 : tensor<64x512x1xf32>) outs(%34 : tensor<64x512x1xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = math.rsqrt %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x1xf32> | |
| %897 = linalg.generic {indexing_maps = [#map6, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%896 : tensor<64x512x1xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| %hoisted_104 = util.global.load @hoisted_104 : tensor<64x512x768xf32> | |
| %898 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%897, %hoisted_104 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %899 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%894, %898 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %hoisted_105 = util.global.load @hoisted_105 : tensor<64x512x768xf32> | |
| %900 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%899, %hoisted_105 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %hoisted_106 = util.global.load @hoisted_106 : tensor<768x3072xf32> | |
| %collapsed_326 = tensor.collapse_shape %900 [[0, 1], [2]] : tensor<64x512x768xf32> into tensor<32768x768xf32> | |
| %901 = linalg.matmul ins(%collapsed_326, %hoisted_106 : tensor<32768x768xf32>, tensor<768x3072xf32>) outs(%118 : tensor<32768x3072xf32>) -> tensor<32768x3072xf32> | |
| %expanded_327 = tensor.expand_shape %901 [[0, 1], [2]] : tensor<32768x3072xf32> into tensor<64x512x3072xf32> | |
| %902 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%cst_0 : tensor<3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %903 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_327, %902 : tensor<64x512x3072xf32>, tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %904 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%903 : tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.mulf %in, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %905 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%903, %904 : tensor<64x512x3072xf32>, tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %906 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%905, %cst_51 : tensor<64x512x3072xf32>, tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %907 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%903, %906 : tensor<64x512x3072xf32>, tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %908 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%907, %cst_50 : tensor<64x512x3072xf32>, tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %909 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%908 : tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = math.tanh %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %910 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%909, %cst_49 : tensor<64x512x3072xf32>, tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %911 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%910, %cst_48 : tensor<64x512x3072xf32>, tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %912 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%903, %911 : tensor<64x512x3072xf32>, tensor<64x512x3072xf32>) outs(%120 : tensor<64x512x3072xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x3072xf32> | |
| %hoisted_107 = util.global.load @hoisted_107 : tensor<3072x768xf32> | |
| %collapsed_328 = tensor.collapse_shape %912 [[0, 1], [2]] : tensor<64x512x3072xf32> into tensor<32768x3072xf32> | |
| %913 = linalg.matmul ins(%collapsed_328, %hoisted_107 : tensor<32768x3072xf32>, tensor<3072x768xf32>) outs(%96 : tensor<32768x768xf32>) -> tensor<32768x768xf32> | |
| %expanded_329 = tensor.expand_shape %913 [[0, 1], [2]] : tensor<32768x768xf32> into tensor<64x512x768xf32> | |
| %914 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%cst : tensor<768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| %915 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_329, %914 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %916 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%884, %915 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %917 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%916 : tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.mulf %in, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %918 = linalg.generic {indexing_maps = [#map1, #map3], iterator_types = ["parallel", "parallel", "reduction"]} ins(%917 : tensor<64x512x768xf32>) outs(%24 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.addf %out, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %919 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%918, %cst_57 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.divf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %920 = linalg.generic {indexing_maps = [#map1, #map3], iterator_types = ["parallel", "parallel", "reduction"]} ins(%916 : tensor<64x512x768xf32>) outs(%24 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.addf %out, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %921 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%920, %cst_57 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.divf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %922 = linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel"]} ins(%921 : tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = arith.mulf %in, %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %923 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%919, %922 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.subf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %924 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%923, %cst_56 : tensor<64x512xf32>, tensor<64x512xf32>) outs(%23 : tensor<64x512xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.maxf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512xf32> | |
| %expanded_330 = tensor.expand_shape %924 [[0], [1, 2]] : tensor<64x512xf32> into tensor<64x512x1xf32> | |
| %925 = linalg.generic {indexing_maps = [#map3, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%921 : tensor<64x512xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| %926 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%916, %925 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.subf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %927 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_330, %cst_55 : tensor<64x512x1xf32>, tensor<64x512x1xf32>) outs(%34 : tensor<64x512x1xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x1xf32> | |
| %928 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%927 : tensor<64x512x1xf32>) outs(%34 : tensor<64x512x1xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %937 = math.rsqrt %in : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x1xf32> | |
| %929 = linalg.generic {indexing_maps = [#map6, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%928 : tensor<64x512x1xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| %hoisted_108 = util.global.load @hoisted_108 : tensor<64x512x768xf32> | |
| %930 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%929, %hoisted_108 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %931 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%926, %930 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.mulf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %hoisted_109 = util.global.load @hoisted_109 : tensor<64x512x768xf32> | |
| %932 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%931, %hoisted_109 : tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%19 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %in_333: f32, %out: f32): | |
| %937 = arith.addf %in, %in_333 : f32 | |
| linalg.yield %937 : f32 | |
| } -> tensor<64x512x768xf32> | |
| %hoisted_110 = util.global.load @hoisted_110 : tensor<768x50257xf32> | |
| %collapsed_331 = tensor.collapse_shape %932 [[0, 1], [2]] : tensor<64x512x768xf32> into tensor<32768x768xf32> | |
| %933 = tensor.empty() : tensor<32768x50257xf32> | |
| %934 = linalg.fill ins(%cst_62 : f32) outs(%933 : tensor<32768x50257xf32>) -> tensor<32768x50257xf32> | |
| %935 = linalg.matmul ins(%collapsed_331, %hoisted_110 : tensor<32768x768xf32>, tensor<768x50257xf32>) outs(%934 : tensor<32768x50257xf32>) -> tensor<32768x50257xf32> | |
| %expanded_332 = tensor.expand_shape %935 [[0, 1], [2]] : tensor<32768x50257xf32> into tensor<64x512x50257xf32> | |
| %936 = hal.tensor.export %expanded_332 "output 0" : tensor<64x512x50257xf32> -> !hal.buffer_view | |
| return %936 : !hal.buffer_view | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %0 = tensor.empty() : tensor<512xi32> | |
| %1 = linalg.generic {indexing_maps = [#map18], iterator_types = ["parallel"]} outs(%0 : tensor<512xi32>) { | |
| ^bb0(%out: i32): | |
| %2 = linalg.index 0 : index | |
| %3 = arith.index_cast %2 : index to i32 | |
| linalg.yield %3 : i32 | |
| } -> tensor<512xi32> | |
| util.global.store %1, @hoisted : tensor<512xi32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %hoisted = util.global.load @hoisted : tensor<512xi32> | |
| %0 = tensor.empty() : tensor<1x512xi32> | |
| %1 = linalg.generic {indexing_maps = [#map19, #map], iterator_types = ["parallel", "parallel"]} ins(%hoisted : tensor<512xi32>) outs(%0 : tensor<1x512xi32>) { | |
| ^bb0(%in: i32, %out: i32): | |
| linalg.yield %in : i32 | |
| } -> tensor<1x512xi32> | |
| %collapsed = tensor.collapse_shape %1 [[0, 1]] : tensor<1x512xi32> into tensor<512xi32> | |
| util.global.store %collapsed, @hoisted_0 : tensor<512xi32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<0> : tensor<1x1xi32> | |
| %0 = tensor.empty() : tensor<1x1xi32> | |
| %cst_0 = arith.constant dense<[50257, 768]> : tensor<2xi32> | |
| %1 = linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel"]} ins(%cst : tensor<1x1xi32>) outs(%0 : tensor<1x1xi32>) { | |
| ^bb0(%in: i32, %out: i32): | |
| %2 = arith.index_cast %in : i32 to index | |
| %extracted = tensor.extract %cst_0[%2] : tensor<2xi32> | |
| linalg.yield %extracted : i32 | |
| } -> tensor<1x1xi32> | |
| util.global.store %1, @hoisted_1 : tensor<1x1xi32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<0> : tensor<1x1xi32> | |
| %0 = tensor.empty() : tensor<1x1xi32> | |
| %cst_0 = arith.constant dense<[1, 768]> : tensor<2xi32> | |
| %1 = linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel"]} ins(%cst : tensor<1x1xi32>) outs(%0 : tensor<1x1xi32>) { | |
| ^bb0(%in: i32, %out: i32): | |
| %2 = arith.index_cast %in : i32 to index | |
| %extracted = tensor.extract %cst_0[%2] : tensor<2xi32> | |
| linalg.yield %extracted : i32 | |
| } -> tensor<1x1xi32> | |
| util.global.store %1, @hoisted_2 : tensor<1x1xi32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %hoisted_1 = util.global.load @hoisted_1 : tensor<1x1xi32> | |
| %collapsed = tensor.collapse_shape %hoisted_1 [[0, 1]] : tensor<1x1xi32> into tensor<1xi32> | |
| %hoisted_2 = util.global.load @hoisted_2 : tensor<1x1xi32> | |
| %collapsed_0 = tensor.collapse_shape %hoisted_2 [[0, 1]] : tensor<1x1xi32> into tensor<1xi32> | |
| %0 = tensor.empty() : tensor<1xi32> | |
| %1 = linalg.generic {indexing_maps = [#map18, #map18, #map18], iterator_types = ["parallel"]} ins(%collapsed, %collapsed_0 : tensor<1xi32>, tensor<1xi32>) outs(%0 : tensor<1xi32>) { | |
| ^bb0(%in: i32, %in_1: i32, %out: i32): | |
| %2 = arith.subi %in, %in_1 : i32 | |
| linalg.yield %2 : i32 | |
| } -> tensor<1xi32> | |
| util.global.store %1, @hoisted_3 : tensor<1xi32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %hoisted_0 = util.global.load @hoisted_0 : tensor<512xi32> | |
| %0 = tensor.empty() : tensor<64x512xi32> | |
| %1 = linalg.generic {indexing_maps = [#map19, #map], iterator_types = ["parallel", "parallel"]} ins(%hoisted_0 : tensor<512xi32>) outs(%0 : tensor<64x512xi32>) { | |
| ^bb0(%in: i32, %out: i32): | |
| linalg.yield %in : i32 | |
| } -> tensor<64x512xi32> | |
| %cst = arith.constant dense<1024> : tensor<64x512xi32> | |
| %2 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%1, %cst : tensor<64x512xi32>, tensor<64x512xi32>) outs(%0 : tensor<64x512xi32>) { | |
| ^bb0(%in: i32, %in_0: i32, %out: i32): | |
| %3 = arith.addi %in, %in_0 : i32 | |
| linalg.yield %3 : i32 | |
| } -> tensor<64x512xi32> | |
| util.global.store %2, @hoisted_4 : tensor<64x512xi32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %hoisted_0 = util.global.load @hoisted_0 : tensor<512xi32> | |
| %0 = tensor.empty() : tensor<64x512xi32> | |
| %1 = linalg.generic {indexing_maps = [#map19, #map], iterator_types = ["parallel", "parallel"]} ins(%hoisted_0 : tensor<512xi32>) outs(%0 : tensor<64x512xi32>) { | |
| ^bb0(%in: i32, %out: i32): | |
| linalg.yield %in : i32 | |
| } -> tensor<64x512xi32> | |
| %cst = arith.constant dense<0> : tensor<64x512xi32> | |
| %2 = tensor.empty() : tensor<64x512xi1> | |
| %3 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%1, %cst : tensor<64x512xi32>, tensor<64x512xi32>) outs(%2 : tensor<64x512xi1>) { | |
| ^bb0(%in: i32, %in_0: i32, %out: i1): | |
| %5 = arith.cmpi slt, %in, %in_0 : i32 | |
| linalg.yield %5 : i1 | |
| } -> tensor<64x512xi1> | |
| %hoisted_4 = util.global.load @hoisted_4 : tensor<64x512xi32> | |
| %4 = linalg.generic {indexing_maps = [#map, #map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%3, %hoisted_4, %1 : tensor<64x512xi1>, tensor<64x512xi32>, tensor<64x512xi32>) outs(%0 : tensor<64x512xi32>) { | |
| ^bb0(%in: i1, %in_0: i32, %in_1: i32, %out: i32): | |
| %5 = arith.select %in, %in_0, %in_1 : i32 | |
| linalg.yield %5 : i32 | |
| } -> tensor<64x512xi32> | |
| %expanded = tensor.expand_shape %4 [[0], [1, 2]] : tensor<64x512xi32> into tensor<64x512x1xi32> | |
| util.global.store %expanded, @hoisted_5 : tensor<64x512x1xi32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<0> : tensor<1x1xi32> | |
| %0 = tensor.empty() : tensor<1x1xi32> | |
| %cst_0 = arith.constant dense<[1024, 768]> : tensor<2xi32> | |
| %1 = linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel"]} ins(%cst : tensor<1x1xi32>) outs(%0 : tensor<1x1xi32>) { | |
| ^bb0(%in: i32, %out: i32): | |
| %2 = arith.index_cast %in : i32 to index | |
| %extracted = tensor.extract %cst_0[%2] : tensor<2xi32> | |
| linalg.yield %extracted : i32 | |
| } -> tensor<1x1xi32> | |
| util.global.store %1, @hoisted_6 : tensor<1x1xi32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %hoisted_6 = util.global.load @hoisted_6 : tensor<1x1xi32> | |
| %collapsed = tensor.collapse_shape %hoisted_6 [[0, 1]] : tensor<1x1xi32> into tensor<1xi32> | |
| %hoisted_2 = util.global.load @hoisted_2 : tensor<1x1xi32> | |
| %collapsed_0 = tensor.collapse_shape %hoisted_2 [[0, 1]] : tensor<1x1xi32> into tensor<1xi32> | |
| %0 = tensor.empty() : tensor<1xi32> | |
| %1 = linalg.generic {indexing_maps = [#map18, #map18, #map18], iterator_types = ["parallel"]} ins(%collapsed, %collapsed_0 : tensor<1xi32>, tensor<1xi32>) outs(%0 : tensor<1xi32>) { | |
| ^bb0(%in: i32, %in_1: i32, %out: i32): | |
| %2 = arith.subi %in, %in_1 : i32 | |
| linalg.yield %2 : i32 | |
| } -> tensor<1xi32> | |
| util.global.store %1, @hoisted_7 : tensor<1xi32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %hoisted_5 = util.global.load @hoisted_5 : tensor<64x512x1xi32> | |
| %0 = tensor.empty() : tensor<64x512x1x768xf32> | |
| %cst = arith.constant dense<...> : tensor<1024x768xf32> | |
| %1 = linalg.generic {indexing_maps = [#map4, #map5], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%hoisted_5 : tensor<64x512x1xi32>) outs(%0 : tensor<64x512x1x768xf32>) { | |
| ^bb0(%in: i32, %out: f32): | |
| %2 = arith.index_cast %in : i32 to index | |
| %3 = linalg.index 3 : index | |
| %extracted = tensor.extract %cst[%2, %3] : tensor<1024x768xf32> | |
| linalg.yield %extracted : f32 | |
| } -> tensor<64x512x1x768xf32> | |
| util.global.store %1, @hoisted_8 : tensor<64x512x1x768xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %hoisted_5 = util.global.load @hoisted_5 : tensor<64x512x1xi32> | |
| %cst = arith.constant dense<0> : tensor<64x512x1xi32> | |
| %0 = tensor.empty() : tensor<64x512x1xi1> | |
| %1 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%hoisted_5, %cst : tensor<64x512x1xi32>, tensor<64x512x1xi32>) outs(%0 : tensor<64x512x1xi1>) { | |
| ^bb0(%in: i32, %in_1: i32, %out: i1): | |
| %13 = arith.cmpi sge, %in, %in_1 : i32 | |
| linalg.yield %13 : i1 | |
| } -> tensor<64x512x1xi1> | |
| %hoisted_7 = util.global.load @hoisted_7 : tensor<1xi32> | |
| %2 = tensor.empty() : tensor<64x512x1xi32> | |
| %3 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%hoisted_7 : tensor<1xi32>) outs(%2 : tensor<64x512x1xi32>) { | |
| ^bb0(%in: i32, %out: i32): | |
| linalg.yield %in : i32 | |
| } -> tensor<64x512x1xi32> | |
| %4 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%hoisted_5, %3 : tensor<64x512x1xi32>, tensor<64x512x1xi32>) outs(%0 : tensor<64x512x1xi1>) { | |
| ^bb0(%in: i32, %in_1: i32, %out: i1): | |
| %13 = arith.cmpi sle, %in, %in_1 : i32 | |
| linalg.yield %13 : i1 | |
| } -> tensor<64x512x1xi1> | |
| %5 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1, %4 : tensor<64x512x1xi1>, tensor<64x512x1xi1>) outs(%0 : tensor<64x512x1xi1>) { | |
| ^bb0(%in: i1, %in_1: i1, %out: i1): | |
| %13 = arith.andi %in, %in_1 : i1 | |
| linalg.yield %13 : i1 | |
| } -> tensor<64x512x1xi1> | |
| %true = arith.constant true | |
| %6 = tensor.empty() : tensor<64x512xi1> | |
| %7 = linalg.fill ins(%true : i1) outs(%6 : tensor<64x512xi1>) -> tensor<64x512xi1> | |
| %8 = linalg.generic {indexing_maps = [#map1, #map3], iterator_types = ["parallel", "parallel", "reduction"]} ins(%5 : tensor<64x512x1xi1>) outs(%7 : tensor<64x512xi1>) { | |
| ^bb0(%in: i1, %out: i1): | |
| %13 = arith.andi %out, %in : i1 | |
| linalg.yield %13 : i1 | |
| } -> tensor<64x512xi1> | |
| %9 = tensor.empty() : tensor<64x512x768xi1> | |
| %10 = linalg.generic {indexing_maps = [#map3, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%8 : tensor<64x512xi1>) outs(%9 : tensor<64x512x768xi1>) { | |
| ^bb0(%in: i1, %out: i1): | |
| linalg.yield %in : i1 | |
| } -> tensor<64x512x768xi1> | |
| %hoisted_8 = util.global.load @hoisted_8 : tensor<64x512x1x768xf32> | |
| %collapsed = tensor.collapse_shape %hoisted_8 [[0], [1], [2, 3]] : tensor<64x512x1x768xf32> into tensor<64x512x768xf32> | |
| %cst_0 = arith.constant dense<0x7FC00000> : tensor<64x512x768xf32> | |
| %11 = tensor.empty() : tensor<64x512x768xf32> | |
| %12 = linalg.generic {indexing_maps = [#map1, #map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%10, %collapsed, %cst_0 : tensor<64x512x768xi1>, tensor<64x512x768xf32>, tensor<64x512x768xf32>) outs(%11 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: i1, %in_1: f32, %in_2: f32, %out: f32): | |
| %13 = arith.select %in, %in_1, %in_2 : f32 | |
| linalg.yield %13 : f32 | |
| } -> tensor<64x512x768xf32> | |
| util.global.store %12, @hoisted_9 : tensor<64x512x768xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<...> : tensor<1x1x768xf32> | |
| %0 = tensor.empty() : tensor<64x512x768xf32> | |
| %1 = linalg.generic {indexing_maps = [#map20, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%cst : tensor<1x1x768xf32>) outs(%0 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| util.global.store %1, @hoisted_10 : tensor<64x512x768xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<...> : tensor<1x1x768xf32> | |
| %0 = tensor.empty() : tensor<64x512x768xf32> | |
| %1 = linalg.generic {indexing_maps = [#map20, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%cst : tensor<1x1x768xf32>) outs(%0 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| util.global.store %1, @hoisted_11 : tensor<64x512x768xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %0 = tensor.empty() : tensor<1024xi32> | |
| %1 = linalg.generic {indexing_maps = [#map18], iterator_types = ["parallel"]} outs(%0 : tensor<1024xi32>) { | |
| ^bb0(%out: i32): | |
| %2 = linalg.index 0 : index | |
| %3 = arith.index_cast %2 : index to i32 | |
| linalg.yield %3 : i32 | |
| } -> tensor<1024xi32> | |
| util.global.store %1, @hoisted_12 : tensor<1024xi32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<...> : tensor<2304x768xf32> | |
| %0 = tensor.empty() : tensor<768x2304xf32> | |
| %1 = linalg.generic {indexing_maps = [#map21, #map], iterator_types = ["parallel", "parallel"]} ins(%cst : tensor<2304x768xf32>) outs(%0 : tensor<768x2304xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<768x2304xf32> | |
| util.global.store %1, @hoisted_13 : tensor<768x2304xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<6.400000e+01> : tensor<f32> | |
| %0 = tensor.empty() : tensor<f32> | |
| %1 = linalg.generic {indexing_maps = [#map22, #map22], iterator_types = []} ins(%cst : tensor<f32>) outs(%0 : tensor<f32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| %2 = math.sqrt %in : f32 | |
| linalg.yield %2 : f32 | |
| } -> tensor<f32> | |
| util.global.store %1, @hoisted_14 : tensor<f32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<...> : tensor<768x768xf32> | |
| %0 = tensor.empty() : tensor<768x768xf32> | |
| %1 = linalg.generic {indexing_maps = [#map21, #map], iterator_types = ["parallel", "parallel"]} ins(%cst : tensor<768x768xf32>) outs(%0 : tensor<768x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<768x768xf32> | |
| util.global.store %1, @hoisted_15 : tensor<768x768xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<...> : tensor<1x1x768xf32> | |
| %0 = tensor.empty() : tensor<64x512x768xf32> | |
| %1 = linalg.generic {indexing_maps = [#map20, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%cst : tensor<1x1x768xf32>) outs(%0 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| util.global.store %1, @hoisted_16 : tensor<64x512x768xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<...> : tensor<1x1x768xf32> | |
| %0 = tensor.empty() : tensor<64x512x768xf32> | |
| %1 = linalg.generic {indexing_maps = [#map20, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%cst : tensor<1x1x768xf32>) outs(%0 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| util.global.store %1, @hoisted_17 : tensor<64x512x768xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<...> : tensor<3072x768xf32> | |
| %0 = tensor.empty() : tensor<768x3072xf32> | |
| %1 = linalg.generic {indexing_maps = [#map21, #map], iterator_types = ["parallel", "parallel"]} ins(%cst : tensor<3072x768xf32>) outs(%0 : tensor<768x3072xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<768x3072xf32> | |
| util.global.store %1, @hoisted_18 : tensor<768x3072xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<...> : tensor<768x3072xf32> | |
| %0 = tensor.empty() : tensor<3072x768xf32> | |
| %1 = linalg.generic {indexing_maps = [#map21, #map], iterator_types = ["parallel", "parallel"]} ins(%cst : tensor<768x3072xf32>) outs(%0 : tensor<3072x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<3072x768xf32> | |
| util.global.store %1, @hoisted_19 : tensor<3072x768xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<...> : tensor<1x1x768xf32> | |
| %0 = tensor.empty() : tensor<64x512x768xf32> | |
| %1 = linalg.generic {indexing_maps = [#map20, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%cst : tensor<1x1x768xf32>) outs(%0 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| util.global.store %1, @hoisted_20 : tensor<64x512x768xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<...> : tensor<1x1x768xf32> | |
| %0 = tensor.empty() : tensor<64x512x768xf32> | |
| %1 = linalg.generic {indexing_maps = [#map20, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%cst : tensor<1x1x768xf32>) outs(%0 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| util.global.store %1, @hoisted_21 : tensor<64x512x768xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<...> : tensor<2304x768xf32> | |
| %0 = tensor.empty() : tensor<768x2304xf32> | |
| %1 = linalg.generic {indexing_maps = [#map21, #map], iterator_types = ["parallel", "parallel"]} ins(%cst : tensor<2304x768xf32>) outs(%0 : tensor<768x2304xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<768x2304xf32> | |
| util.global.store %1, @hoisted_22 : tensor<768x2304xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<...> : tensor<768x768xf32> | |
| %0 = tensor.empty() : tensor<768x768xf32> | |
| %1 = linalg.generic {indexing_maps = [#map21, #map], iterator_types = ["parallel", "parallel"]} ins(%cst : tensor<768x768xf32>) outs(%0 : tensor<768x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<768x768xf32> | |
| util.global.store %1, @hoisted_23 : tensor<768x768xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<...> : tensor<1x1x768xf32> | |
| %0 = tensor.empty() : tensor<64x512x768xf32> | |
| %1 = linalg.generic {indexing_maps = [#map20, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%cst : tensor<1x1x768xf32>) outs(%0 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| util.global.store %1, @hoisted_24 : tensor<64x512x768xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<...> : tensor<1x1x768xf32> | |
| %0 = tensor.empty() : tensor<64x512x768xf32> | |
| %1 = linalg.generic {indexing_maps = [#map20, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%cst : tensor<1x1x768xf32>) outs(%0 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| util.global.store %1, @hoisted_25 : tensor<64x512x768xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<...> : tensor<3072x768xf32> | |
| %0 = tensor.empty() : tensor<768x3072xf32> | |
| %1 = linalg.generic {indexing_maps = [#map21, #map], iterator_types = ["parallel", "parallel"]} ins(%cst : tensor<3072x768xf32>) outs(%0 : tensor<768x3072xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<768x3072xf32> | |
| util.global.store %1, @hoisted_26 : tensor<768x3072xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<...> : tensor<768x3072xf32> | |
| %0 = tensor.empty() : tensor<3072x768xf32> | |
| %1 = linalg.generic {indexing_maps = [#map21, #map], iterator_types = ["parallel", "parallel"]} ins(%cst : tensor<768x3072xf32>) outs(%0 : tensor<3072x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<3072x768xf32> | |
| util.global.store %1, @hoisted_27 : tensor<3072x768xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<...> : tensor<1x1x768xf32> | |
| %0 = tensor.empty() : tensor<64x512x768xf32> | |
| %1 = linalg.generic {indexing_maps = [#map20, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%cst : tensor<1x1x768xf32>) outs(%0 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| util.global.store %1, @hoisted_28 : tensor<64x512x768xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<...> : tensor<1x1x768xf32> | |
| %0 = tensor.empty() : tensor<64x512x768xf32> | |
| %1 = linalg.generic {indexing_maps = [#map20, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%cst : tensor<1x1x768xf32>) outs(%0 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| util.global.store %1, @hoisted_29 : tensor<64x512x768xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<...> : tensor<2304x768xf32> | |
| %0 = tensor.empty() : tensor<768x2304xf32> | |
| %1 = linalg.generic {indexing_maps = [#map21, #map], iterator_types = ["parallel", "parallel"]} ins(%cst : tensor<2304x768xf32>) outs(%0 : tensor<768x2304xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<768x2304xf32> | |
| util.global.store %1, @hoisted_30 : tensor<768x2304xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<...> : tensor<768x768xf32> | |
| %0 = tensor.empty() : tensor<768x768xf32> | |
| %1 = linalg.generic {indexing_maps = [#map21, #map], iterator_types = ["parallel", "parallel"]} ins(%cst : tensor<768x768xf32>) outs(%0 : tensor<768x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<768x768xf32> | |
| util.global.store %1, @hoisted_31 : tensor<768x768xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<...> : tensor<1x1x768xf32> | |
| %0 = tensor.empty() : tensor<64x512x768xf32> | |
| %1 = linalg.generic {indexing_maps = [#map20, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%cst : tensor<1x1x768xf32>) outs(%0 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| util.global.store %1, @hoisted_32 : tensor<64x512x768xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<...> : tensor<1x1x768xf32> | |
| %0 = tensor.empty() : tensor<64x512x768xf32> | |
| %1 = linalg.generic {indexing_maps = [#map20, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%cst : tensor<1x1x768xf32>) outs(%0 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| util.global.store %1, @hoisted_33 : tensor<64x512x768xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<...> : tensor<3072x768xf32> | |
| %0 = tensor.empty() : tensor<768x3072xf32> | |
| %1 = linalg.generic {indexing_maps = [#map21, #map], iterator_types = ["parallel", "parallel"]} ins(%cst : tensor<3072x768xf32>) outs(%0 : tensor<768x3072xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<768x3072xf32> | |
| util.global.store %1, @hoisted_34 : tensor<768x3072xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<...> : tensor<768x3072xf32> | |
| %0 = tensor.empty() : tensor<3072x768xf32> | |
| %1 = linalg.generic {indexing_maps = [#map21, #map], iterator_types = ["parallel", "parallel"]} ins(%cst : tensor<768x3072xf32>) outs(%0 : tensor<3072x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<3072x768xf32> | |
| util.global.store %1, @hoisted_35 : tensor<3072x768xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<...> : tensor<1x1x768xf32> | |
| %0 = tensor.empty() : tensor<64x512x768xf32> | |
| %1 = linalg.generic {indexing_maps = [#map20, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%cst : tensor<1x1x768xf32>) outs(%0 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| util.global.store %1, @hoisted_36 : tensor<64x512x768xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<...> : tensor<1x1x768xf32> | |
| %0 = tensor.empty() : tensor<64x512x768xf32> | |
| %1 = linalg.generic {indexing_maps = [#map20, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%cst : tensor<1x1x768xf32>) outs(%0 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| util.global.store %1, @hoisted_37 : tensor<64x512x768xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<...> : tensor<2304x768xf32> | |
| %0 = tensor.empty() : tensor<768x2304xf32> | |
| %1 = linalg.generic {indexing_maps = [#map21, #map], iterator_types = ["parallel", "parallel"]} ins(%cst : tensor<2304x768xf32>) outs(%0 : tensor<768x2304xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<768x2304xf32> | |
| util.global.store %1, @hoisted_38 : tensor<768x2304xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<...> : tensor<768x768xf32> | |
| %0 = tensor.empty() : tensor<768x768xf32> | |
| %1 = linalg.generic {indexing_maps = [#map21, #map], iterator_types = ["parallel", "parallel"]} ins(%cst : tensor<768x768xf32>) outs(%0 : tensor<768x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<768x768xf32> | |
| util.global.store %1, @hoisted_39 : tensor<768x768xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<...> : tensor<1x1x768xf32> | |
| %0 = tensor.empty() : tensor<64x512x768xf32> | |
| %1 = linalg.generic {indexing_maps = [#map20, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%cst : tensor<1x1x768xf32>) outs(%0 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| util.global.store %1, @hoisted_40 : tensor<64x512x768xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<...> : tensor<1x1x768xf32> | |
| %0 = tensor.empty() : tensor<64x512x768xf32> | |
| %1 = linalg.generic {indexing_maps = [#map20, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%cst : tensor<1x1x768xf32>) outs(%0 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| util.global.store %1, @hoisted_41 : tensor<64x512x768xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<...> : tensor<3072x768xf32> | |
| %0 = tensor.empty() : tensor<768x3072xf32> | |
| %1 = linalg.generic {indexing_maps = [#map21, #map], iterator_types = ["parallel", "parallel"]} ins(%cst : tensor<3072x768xf32>) outs(%0 : tensor<768x3072xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<768x3072xf32> | |
| util.global.store %1, @hoisted_42 : tensor<768x3072xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<...> : tensor<768x3072xf32> | |
| %0 = tensor.empty() : tensor<3072x768xf32> | |
| %1 = linalg.generic {indexing_maps = [#map21, #map], iterator_types = ["parallel", "parallel"]} ins(%cst : tensor<768x3072xf32>) outs(%0 : tensor<3072x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<3072x768xf32> | |
| util.global.store %1, @hoisted_43 : tensor<3072x768xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<...> : tensor<1x1x768xf32> | |
| %0 = tensor.empty() : tensor<64x512x768xf32> | |
| %1 = linalg.generic {indexing_maps = [#map20, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%cst : tensor<1x1x768xf32>) outs(%0 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| util.global.store %1, @hoisted_44 : tensor<64x512x768xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<...> : tensor<1x1x768xf32> | |
| %0 = tensor.empty() : tensor<64x512x768xf32> | |
| %1 = linalg.generic {indexing_maps = [#map20, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%cst : tensor<1x1x768xf32>) outs(%0 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| util.global.store %1, @hoisted_45 : tensor<64x512x768xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<...> : tensor<2304x768xf32> | |
| %0 = tensor.empty() : tensor<768x2304xf32> | |
| %1 = linalg.generic {indexing_maps = [#map21, #map], iterator_types = ["parallel", "parallel"]} ins(%cst : tensor<2304x768xf32>) outs(%0 : tensor<768x2304xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<768x2304xf32> | |
| util.global.store %1, @hoisted_46 : tensor<768x2304xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<...> : tensor<768x768xf32> | |
| %0 = tensor.empty() : tensor<768x768xf32> | |
| %1 = linalg.generic {indexing_maps = [#map21, #map], iterator_types = ["parallel", "parallel"]} ins(%cst : tensor<768x768xf32>) outs(%0 : tensor<768x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<768x768xf32> | |
| util.global.store %1, @hoisted_47 : tensor<768x768xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<...> : tensor<1x1x768xf32> | |
| %0 = tensor.empty() : tensor<64x512x768xf32> | |
| %1 = linalg.generic {indexing_maps = [#map20, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%cst : tensor<1x1x768xf32>) outs(%0 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| util.global.store %1, @hoisted_48 : tensor<64x512x768xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<...> : tensor<1x1x768xf32> | |
| %0 = tensor.empty() : tensor<64x512x768xf32> | |
| %1 = linalg.generic {indexing_maps = [#map20, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%cst : tensor<1x1x768xf32>) outs(%0 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| util.global.store %1, @hoisted_49 : tensor<64x512x768xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<...> : tensor<3072x768xf32> | |
| %0 = tensor.empty() : tensor<768x3072xf32> | |
| %1 = linalg.generic {indexing_maps = [#map21, #map], iterator_types = ["parallel", "parallel"]} ins(%cst : tensor<3072x768xf32>) outs(%0 : tensor<768x3072xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<768x3072xf32> | |
| util.global.store %1, @hoisted_50 : tensor<768x3072xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<...> : tensor<768x3072xf32> | |
| %0 = tensor.empty() : tensor<3072x768xf32> | |
| %1 = linalg.generic {indexing_maps = [#map21, #map], iterator_types = ["parallel", "parallel"]} ins(%cst : tensor<768x3072xf32>) outs(%0 : tensor<3072x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<3072x768xf32> | |
| util.global.store %1, @hoisted_51 : tensor<3072x768xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<...> : tensor<1x1x768xf32> | |
| %0 = tensor.empty() : tensor<64x512x768xf32> | |
| %1 = linalg.generic {indexing_maps = [#map20, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%cst : tensor<1x1x768xf32>) outs(%0 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| util.global.store %1, @hoisted_52 : tensor<64x512x768xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<...> : tensor<1x1x768xf32> | |
| %0 = tensor.empty() : tensor<64x512x768xf32> | |
| %1 = linalg.generic {indexing_maps = [#map20, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%cst : tensor<1x1x768xf32>) outs(%0 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| util.global.store %1, @hoisted_53 : tensor<64x512x768xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<...> : tensor<2304x768xf32> | |
| %0 = tensor.empty() : tensor<768x2304xf32> | |
| %1 = linalg.generic {indexing_maps = [#map21, #map], iterator_types = ["parallel", "parallel"]} ins(%cst : tensor<2304x768xf32>) outs(%0 : tensor<768x2304xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<768x2304xf32> | |
| util.global.store %1, @hoisted_54 : tensor<768x2304xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<...> : tensor<768x768xf32> | |
| %0 = tensor.empty() : tensor<768x768xf32> | |
| %1 = linalg.generic {indexing_maps = [#map21, #map], iterator_types = ["parallel", "parallel"]} ins(%cst : tensor<768x768xf32>) outs(%0 : tensor<768x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<768x768xf32> | |
| util.global.store %1, @hoisted_55 : tensor<768x768xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<...> : tensor<1x1x768xf32> | |
| %0 = tensor.empty() : tensor<64x512x768xf32> | |
| %1 = linalg.generic {indexing_maps = [#map20, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%cst : tensor<1x1x768xf32>) outs(%0 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| util.global.store %1, @hoisted_56 : tensor<64x512x768xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<...> : tensor<1x1x768xf32> | |
| %0 = tensor.empty() : tensor<64x512x768xf32> | |
| %1 = linalg.generic {indexing_maps = [#map20, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%cst : tensor<1x1x768xf32>) outs(%0 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| util.global.store %1, @hoisted_57 : tensor<64x512x768xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<...> : tensor<3072x768xf32> | |
| %0 = tensor.empty() : tensor<768x3072xf32> | |
| %1 = linalg.generic {indexing_maps = [#map21, #map], iterator_types = ["parallel", "parallel"]} ins(%cst : tensor<3072x768xf32>) outs(%0 : tensor<768x3072xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<768x3072xf32> | |
| util.global.store %1, @hoisted_58 : tensor<768x3072xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<...> : tensor<768x3072xf32> | |
| %0 = tensor.empty() : tensor<3072x768xf32> | |
| %1 = linalg.generic {indexing_maps = [#map21, #map], iterator_types = ["parallel", "parallel"]} ins(%cst : tensor<768x3072xf32>) outs(%0 : tensor<3072x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<3072x768xf32> | |
| util.global.store %1, @hoisted_59 : tensor<3072x768xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<...> : tensor<1x1x768xf32> | |
| %0 = tensor.empty() : tensor<64x512x768xf32> | |
| %1 = linalg.generic {indexing_maps = [#map20, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%cst : tensor<1x1x768xf32>) outs(%0 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| util.global.store %1, @hoisted_60 : tensor<64x512x768xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<...> : tensor<1x1x768xf32> | |
| %0 = tensor.empty() : tensor<64x512x768xf32> | |
| %1 = linalg.generic {indexing_maps = [#map20, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%cst : tensor<1x1x768xf32>) outs(%0 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| util.global.store %1, @hoisted_61 : tensor<64x512x768xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<...> : tensor<2304x768xf32> | |
| %0 = tensor.empty() : tensor<768x2304xf32> | |
| %1 = linalg.generic {indexing_maps = [#map21, #map], iterator_types = ["parallel", "parallel"]} ins(%cst : tensor<2304x768xf32>) outs(%0 : tensor<768x2304xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<768x2304xf32> | |
| util.global.store %1, @hoisted_62 : tensor<768x2304xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<...> : tensor<768x768xf32> | |
| %0 = tensor.empty() : tensor<768x768xf32> | |
| %1 = linalg.generic {indexing_maps = [#map21, #map], iterator_types = ["parallel", "parallel"]} ins(%cst : tensor<768x768xf32>) outs(%0 : tensor<768x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<768x768xf32> | |
| util.global.store %1, @hoisted_63 : tensor<768x768xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<...> : tensor<1x1x768xf32> | |
| %0 = tensor.empty() : tensor<64x512x768xf32> | |
| %1 = linalg.generic {indexing_maps = [#map20, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%cst : tensor<1x1x768xf32>) outs(%0 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| util.global.store %1, @hoisted_64 : tensor<64x512x768xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<...> : tensor<1x1x768xf32> | |
| %0 = tensor.empty() : tensor<64x512x768xf32> | |
| %1 = linalg.generic {indexing_maps = [#map20, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%cst : tensor<1x1x768xf32>) outs(%0 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| util.global.store %1, @hoisted_65 : tensor<64x512x768xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<...> : tensor<3072x768xf32> | |
| %0 = tensor.empty() : tensor<768x3072xf32> | |
| %1 = linalg.generic {indexing_maps = [#map21, #map], iterator_types = ["parallel", "parallel"]} ins(%cst : tensor<3072x768xf32>) outs(%0 : tensor<768x3072xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<768x3072xf32> | |
| util.global.store %1, @hoisted_66 : tensor<768x3072xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<...> : tensor<768x3072xf32> | |
| %0 = tensor.empty() : tensor<3072x768xf32> | |
| %1 = linalg.generic {indexing_maps = [#map21, #map], iterator_types = ["parallel", "parallel"]} ins(%cst : tensor<768x3072xf32>) outs(%0 : tensor<3072x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<3072x768xf32> | |
| util.global.store %1, @hoisted_67 : tensor<3072x768xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<...> : tensor<1x1x768xf32> | |
| %0 = tensor.empty() : tensor<64x512x768xf32> | |
| %1 = linalg.generic {indexing_maps = [#map20, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%cst : tensor<1x1x768xf32>) outs(%0 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| util.global.store %1, @hoisted_68 : tensor<64x512x768xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<...> : tensor<1x1x768xf32> | |
| %0 = tensor.empty() : tensor<64x512x768xf32> | |
| %1 = linalg.generic {indexing_maps = [#map20, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%cst : tensor<1x1x768xf32>) outs(%0 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| util.global.store %1, @hoisted_69 : tensor<64x512x768xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<...> : tensor<2304x768xf32> | |
| %0 = tensor.empty() : tensor<768x2304xf32> | |
| %1 = linalg.generic {indexing_maps = [#map21, #map], iterator_types = ["parallel", "parallel"]} ins(%cst : tensor<2304x768xf32>) outs(%0 : tensor<768x2304xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<768x2304xf32> | |
| util.global.store %1, @hoisted_70 : tensor<768x2304xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<...> : tensor<768x768xf32> | |
| %0 = tensor.empty() : tensor<768x768xf32> | |
| %1 = linalg.generic {indexing_maps = [#map21, #map], iterator_types = ["parallel", "parallel"]} ins(%cst : tensor<768x768xf32>) outs(%0 : tensor<768x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<768x768xf32> | |
| util.global.store %1, @hoisted_71 : tensor<768x768xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<...> : tensor<1x1x768xf32> | |
| %0 = tensor.empty() : tensor<64x512x768xf32> | |
| %1 = linalg.generic {indexing_maps = [#map20, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%cst : tensor<1x1x768xf32>) outs(%0 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| util.global.store %1, @hoisted_72 : tensor<64x512x768xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<...> : tensor<1x1x768xf32> | |
| %0 = tensor.empty() : tensor<64x512x768xf32> | |
| %1 = linalg.generic {indexing_maps = [#map20, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%cst : tensor<1x1x768xf32>) outs(%0 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| util.global.store %1, @hoisted_73 : tensor<64x512x768xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<...> : tensor<3072x768xf32> | |
| %0 = tensor.empty() : tensor<768x3072xf32> | |
| %1 = linalg.generic {indexing_maps = [#map21, #map], iterator_types = ["parallel", "parallel"]} ins(%cst : tensor<3072x768xf32>) outs(%0 : tensor<768x3072xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<768x3072xf32> | |
| util.global.store %1, @hoisted_74 : tensor<768x3072xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<...> : tensor<768x3072xf32> | |
| %0 = tensor.empty() : tensor<3072x768xf32> | |
| %1 = linalg.generic {indexing_maps = [#map21, #map], iterator_types = ["parallel", "parallel"]} ins(%cst : tensor<768x3072xf32>) outs(%0 : tensor<3072x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<3072x768xf32> | |
| util.global.store %1, @hoisted_75 : tensor<3072x768xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<...> : tensor<1x1x768xf32> | |
| %0 = tensor.empty() : tensor<64x512x768xf32> | |
| %1 = linalg.generic {indexing_maps = [#map20, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%cst : tensor<1x1x768xf32>) outs(%0 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| util.global.store %1, @hoisted_76 : tensor<64x512x768xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<...> : tensor<1x1x768xf32> | |
| %0 = tensor.empty() : tensor<64x512x768xf32> | |
| %1 = linalg.generic {indexing_maps = [#map20, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%cst : tensor<1x1x768xf32>) outs(%0 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| util.global.store %1, @hoisted_77 : tensor<64x512x768xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<...> : tensor<2304x768xf32> | |
| %0 = tensor.empty() : tensor<768x2304xf32> | |
| %1 = linalg.generic {indexing_maps = [#map21, #map], iterator_types = ["parallel", "parallel"]} ins(%cst : tensor<2304x768xf32>) outs(%0 : tensor<768x2304xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<768x2304xf32> | |
| util.global.store %1, @hoisted_78 : tensor<768x2304xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<...> : tensor<768x768xf32> | |
| %0 = tensor.empty() : tensor<768x768xf32> | |
| %1 = linalg.generic {indexing_maps = [#map21, #map], iterator_types = ["parallel", "parallel"]} ins(%cst : tensor<768x768xf32>) outs(%0 : tensor<768x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<768x768xf32> | |
| util.global.store %1, @hoisted_79 : tensor<768x768xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<...> : tensor<1x1x768xf32> | |
| %0 = tensor.empty() : tensor<64x512x768xf32> | |
| %1 = linalg.generic {indexing_maps = [#map20, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%cst : tensor<1x1x768xf32>) outs(%0 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| util.global.store %1, @hoisted_80 : tensor<64x512x768xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<...> : tensor<1x1x768xf32> | |
| %0 = tensor.empty() : tensor<64x512x768xf32> | |
| %1 = linalg.generic {indexing_maps = [#map20, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%cst : tensor<1x1x768xf32>) outs(%0 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| util.global.store %1, @hoisted_81 : tensor<64x512x768xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<...> : tensor<3072x768xf32> | |
| %0 = tensor.empty() : tensor<768x3072xf32> | |
| %1 = linalg.generic {indexing_maps = [#map21, #map], iterator_types = ["parallel", "parallel"]} ins(%cst : tensor<3072x768xf32>) outs(%0 : tensor<768x3072xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<768x3072xf32> | |
| util.global.store %1, @hoisted_82 : tensor<768x3072xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<...> : tensor<768x3072xf32> | |
| %0 = tensor.empty() : tensor<3072x768xf32> | |
| %1 = linalg.generic {indexing_maps = [#map21, #map], iterator_types = ["parallel", "parallel"]} ins(%cst : tensor<768x3072xf32>) outs(%0 : tensor<3072x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<3072x768xf32> | |
| util.global.store %1, @hoisted_83 : tensor<3072x768xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<...> : tensor<1x1x768xf32> | |
| %0 = tensor.empty() : tensor<64x512x768xf32> | |
| %1 = linalg.generic {indexing_maps = [#map20, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%cst : tensor<1x1x768xf32>) outs(%0 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| util.global.store %1, @hoisted_84 : tensor<64x512x768xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<...> : tensor<1x1x768xf32> | |
| %0 = tensor.empty() : tensor<64x512x768xf32> | |
| %1 = linalg.generic {indexing_maps = [#map20, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%cst : tensor<1x1x768xf32>) outs(%0 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| util.global.store %1, @hoisted_85 : tensor<64x512x768xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<...> : tensor<2304x768xf32> | |
| %0 = tensor.empty() : tensor<768x2304xf32> | |
| %1 = linalg.generic {indexing_maps = [#map21, #map], iterator_types = ["parallel", "parallel"]} ins(%cst : tensor<2304x768xf32>) outs(%0 : tensor<768x2304xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<768x2304xf32> | |
| util.global.store %1, @hoisted_86 : tensor<768x2304xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<...> : tensor<768x768xf32> | |
| %0 = tensor.empty() : tensor<768x768xf32> | |
| %1 = linalg.generic {indexing_maps = [#map21, #map], iterator_types = ["parallel", "parallel"]} ins(%cst : tensor<768x768xf32>) outs(%0 : tensor<768x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<768x768xf32> | |
| util.global.store %1, @hoisted_87 : tensor<768x768xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<...> : tensor<1x1x768xf32> | |
| %0 = tensor.empty() : tensor<64x512x768xf32> | |
| %1 = linalg.generic {indexing_maps = [#map20, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%cst : tensor<1x1x768xf32>) outs(%0 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| util.global.store %1, @hoisted_88 : tensor<64x512x768xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<...> : tensor<1x1x768xf32> | |
| %0 = tensor.empty() : tensor<64x512x768xf32> | |
| %1 = linalg.generic {indexing_maps = [#map20, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%cst : tensor<1x1x768xf32>) outs(%0 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| util.global.store %1, @hoisted_89 : tensor<64x512x768xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<...> : tensor<3072x768xf32> | |
| %0 = tensor.empty() : tensor<768x3072xf32> | |
| %1 = linalg.generic {indexing_maps = [#map21, #map], iterator_types = ["parallel", "parallel"]} ins(%cst : tensor<3072x768xf32>) outs(%0 : tensor<768x3072xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<768x3072xf32> | |
| util.global.store %1, @hoisted_90 : tensor<768x3072xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<...> : tensor<768x3072xf32> | |
| %0 = tensor.empty() : tensor<3072x768xf32> | |
| %1 = linalg.generic {indexing_maps = [#map21, #map], iterator_types = ["parallel", "parallel"]} ins(%cst : tensor<768x3072xf32>) outs(%0 : tensor<3072x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<3072x768xf32> | |
| util.global.store %1, @hoisted_91 : tensor<3072x768xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<...> : tensor<1x1x768xf32> | |
| %0 = tensor.empty() : tensor<64x512x768xf32> | |
| %1 = linalg.generic {indexing_maps = [#map20, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%cst : tensor<1x1x768xf32>) outs(%0 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| util.global.store %1, @hoisted_92 : tensor<64x512x768xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<...> : tensor<1x1x768xf32> | |
| %0 = tensor.empty() : tensor<64x512x768xf32> | |
| %1 = linalg.generic {indexing_maps = [#map20, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%cst : tensor<1x1x768xf32>) outs(%0 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| util.global.store %1, @hoisted_93 : tensor<64x512x768xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<...> : tensor<2304x768xf32> | |
| %0 = tensor.empty() : tensor<768x2304xf32> | |
| %1 = linalg.generic {indexing_maps = [#map21, #map], iterator_types = ["parallel", "parallel"]} ins(%cst : tensor<2304x768xf32>) outs(%0 : tensor<768x2304xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<768x2304xf32> | |
| util.global.store %1, @hoisted_94 : tensor<768x2304xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<...> : tensor<768x768xf32> | |
| %0 = tensor.empty() : tensor<768x768xf32> | |
| %1 = linalg.generic {indexing_maps = [#map21, #map], iterator_types = ["parallel", "parallel"]} ins(%cst : tensor<768x768xf32>) outs(%0 : tensor<768x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<768x768xf32> | |
| util.global.store %1, @hoisted_95 : tensor<768x768xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<...> : tensor<1x1x768xf32> | |
| %0 = tensor.empty() : tensor<64x512x768xf32> | |
| %1 = linalg.generic {indexing_maps = [#map20, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%cst : tensor<1x1x768xf32>) outs(%0 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| util.global.store %1, @hoisted_96 : tensor<64x512x768xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<...> : tensor<1x1x768xf32> | |
| %0 = tensor.empty() : tensor<64x512x768xf32> | |
| %1 = linalg.generic {indexing_maps = [#map20, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%cst : tensor<1x1x768xf32>) outs(%0 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| util.global.store %1, @hoisted_97 : tensor<64x512x768xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<...> : tensor<3072x768xf32> | |
| %0 = tensor.empty() : tensor<768x3072xf32> | |
| %1 = linalg.generic {indexing_maps = [#map21, #map], iterator_types = ["parallel", "parallel"]} ins(%cst : tensor<3072x768xf32>) outs(%0 : tensor<768x3072xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<768x3072xf32> | |
| util.global.store %1, @hoisted_98 : tensor<768x3072xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<...> : tensor<768x3072xf32> | |
| %0 = tensor.empty() : tensor<3072x768xf32> | |
| %1 = linalg.generic {indexing_maps = [#map21, #map], iterator_types = ["parallel", "parallel"]} ins(%cst : tensor<768x3072xf32>) outs(%0 : tensor<3072x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<3072x768xf32> | |
| util.global.store %1, @hoisted_99 : tensor<3072x768xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<...> : tensor<1x1x768xf32> | |
| %0 = tensor.empty() : tensor<64x512x768xf32> | |
| %1 = linalg.generic {indexing_maps = [#map20, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%cst : tensor<1x1x768xf32>) outs(%0 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| util.global.store %1, @hoisted_100 : tensor<64x512x768xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<...> : tensor<1x1x768xf32> | |
| %0 = tensor.empty() : tensor<64x512x768xf32> | |
| %1 = linalg.generic {indexing_maps = [#map20, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%cst : tensor<1x1x768xf32>) outs(%0 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| util.global.store %1, @hoisted_101 : tensor<64x512x768xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<...> : tensor<2304x768xf32> | |
| %0 = tensor.empty() : tensor<768x2304xf32> | |
| %1 = linalg.generic {indexing_maps = [#map21, #map], iterator_types = ["parallel", "parallel"]} ins(%cst : tensor<2304x768xf32>) outs(%0 : tensor<768x2304xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<768x2304xf32> | |
| util.global.store %1, @hoisted_102 : tensor<768x2304xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<...> : tensor<768x768xf32> | |
| %0 = tensor.empty() : tensor<768x768xf32> | |
| %1 = linalg.generic {indexing_maps = [#map21, #map], iterator_types = ["parallel", "parallel"]} ins(%cst : tensor<768x768xf32>) outs(%0 : tensor<768x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<768x768xf32> | |
| util.global.store %1, @hoisted_103 : tensor<768x768xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<...> : tensor<1x1x768xf32> | |
| %0 = tensor.empty() : tensor<64x512x768xf32> | |
| %1 = linalg.generic {indexing_maps = [#map20, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%cst : tensor<1x1x768xf32>) outs(%0 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| util.global.store %1, @hoisted_104 : tensor<64x512x768xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<...> : tensor<1x1x768xf32> | |
| %0 = tensor.empty() : tensor<64x512x768xf32> | |
| %1 = linalg.generic {indexing_maps = [#map20, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%cst : tensor<1x1x768xf32>) outs(%0 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| util.global.store %1, @hoisted_105 : tensor<64x512x768xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<...> : tensor<3072x768xf32> | |
| %0 = tensor.empty() : tensor<768x3072xf32> | |
| %1 = linalg.generic {indexing_maps = [#map21, #map], iterator_types = ["parallel", "parallel"]} ins(%cst : tensor<3072x768xf32>) outs(%0 : tensor<768x3072xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<768x3072xf32> | |
| util.global.store %1, @hoisted_106 : tensor<768x3072xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<...> : tensor<768x3072xf32> | |
| %0 = tensor.empty() : tensor<3072x768xf32> | |
| %1 = linalg.generic {indexing_maps = [#map21, #map], iterator_types = ["parallel", "parallel"]} ins(%cst : tensor<768x3072xf32>) outs(%0 : tensor<3072x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<3072x768xf32> | |
| util.global.store %1, @hoisted_107 : tensor<3072x768xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<...> : tensor<1x1x768xf32> | |
| %0 = tensor.empty() : tensor<64x512x768xf32> | |
| %1 = linalg.generic {indexing_maps = [#map20, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%cst : tensor<1x1x768xf32>) outs(%0 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| util.global.store %1, @hoisted_108 : tensor<64x512x768xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<...> : tensor<1x1x768xf32> | |
| %0 = tensor.empty() : tensor<64x512x768xf32> | |
| %1 = linalg.generic {indexing_maps = [#map20, #map1], iterator_types = ["parallel", "parallel", "parallel"]} ins(%cst : tensor<1x1x768xf32>) outs(%0 : tensor<64x512x768xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<64x512x768xf32> | |
| util.global.store %1, @hoisted_109 : tensor<64x512x768xf32> | |
| util.initializer.return | |
| } | |
| util.initializer attributes {iree.compiler.consteval} { | |
| %cst = arith.constant dense<...> : tensor<50257x768xf32> | |
| %0 = tensor.empty() : tensor<768x50257xf32> | |
| %1 = linalg.generic {indexing_maps = [#map21, #map], iterator_types = ["parallel", "parallel"]} ins(%cst : tensor<50257x768xf32>) outs(%0 : tensor<768x50257xf32>) { | |
| ^bb0(%in: f32, %out: f32): | |
| linalg.yield %in : f32 | |
| } -> tensor<768x50257xf32> | |
| util.global.store %1, @hoisted_110 : tensor<768x50257xf32> | |
| util.initializer.return | |
| } | |
| } |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment