Add rope/mx_block_quant vmi/mi code

[Zhendong404]

No description provided.

[learning-chip]

This interleave branch has a different implementation logic than my intrinsics code. The math is equivalent, but the cycles might differ.. The version below mirrors the original intrinsics more closely:

        } else {
          // === INTERLEAVE mode (GPT-J layout) — v2(code here) vs rope_f16.mi.pto ===
          //
          // Same interleaved RoPE semantics; two equivalent spellings of complex rotation:
          //
          // rope_f16.mi.pto — Cartesian expansion form (even/odd deinterleaved compute):
          //   Treat (x_even, x_odd) as (Re, Im) per 2D block; expand (a+ib)(c+id):
          //     y_even = x_even*cos_even - x_odd*sin_even
          //     y_odd  = x_odd*cos_odd  + x_even*sin_odd
          //   vdintlv cos, sin, AND x → 8 arith ops → vintlv → store
          //   Fixed pge_b16 masks; no blk loop; no vbr.
          //
          // v2(code here) — complex-multiply form (rope_cce_compute.h ComputeF16 INTERLEAVE):
          //   y = x*cos + (i*x)*sin,  (i*x) = [-x1,x0,-x3,x2,...] in interleaved layout
          //   cos/sin dense load (no vdintlv on tables)
          //   Build i*x on x only: vdintlv(x) → vmul(odd,-1) → vintlv
          //   3 arith ops → single vsts; blk loop (64 f16/block); plt_b16; vbr(-1)
          %neg_one = pto.vbr %neg_one_f16 : f16 -> !pto.vreg<128xf16>

          scf.for %s = %c0 to %s_count step %c1 {
            %x_s_off = arith.muli %s, %x_s_step : index
            %cs_off = arith.muli %s, %cs_s_step : index
            %y_s_off = arith.muli %s, %y_s_step : index

            scf.for %blk = %c0 to %d_blocks step %c1 {
              // rope_f16.mi.pto: no blk loop — one cos/sin load at cs_off per s.
              %off = arith.muli %blk, %c64 : index
              %off_i32 = arith.index_cast %off : index to i32
              %remaining_i32 = arith.subi %c64_i32, %off_i32 : i32
              %lt_blk = arith.cmpi slt, %remaining_i32, %c64_i32 : i32
              %cnt_i32 = arith.select %lt_blk, %remaining_i32, %c64_i32 : i32
              %pair_cnt_plus = arith.addi %cnt_i32, %c1_i32 : i32
              %pair_cnt_i32 = arith.divui %pair_cnt_plus, %c2_i32 : i32

              %mask16, %mask16_next = pto.plt_b16 %cnt_i32 : i32 -> !pto.mask<b16>, i32
              %mask_pair, %mask_pair_next = pto.plt_b16 %pair_cnt_i32 : i32 -> !pto.mask<b16>, i32

              %cs_elem_off = arith.addi %cs_off, %off : index
              // rope_f16.mi.pto deinterleaves cos/sin here; v2 keeps tables dense.
              %cos = pto.vlds %cos_ub[%cs_elem_off] : !pto.ptr<f16, ub> -> !pto.vreg<128xf16>
              %sin = pto.vlds %sin_ub[%cs_elem_off] : !pto.ptr<f16, ub> -> !pto.vreg<128xf16>

              scf.for %n = %c0 to %n_count step %c1 {
                %x_n_off = arith.muli %n, %x_n_step : index
                %y_n_off = arith.muli %n, %y_n_step : index
                %x_off = arith.addi %x_s_off, %x_n_off : index
                %y_off = arith.addi %y_s_off, %y_n_off : index
                %x_elem_off = arith.addi %x_off, %off : index
                %y_elem_off = arith.addi %y_off, %off : index

                %x = pto.vlds %x_ub[%x_elem_off] : !pto.ptr<f16, ub> -> !pto.vreg<128xf16>

                // Build (i*x) for complex-multiply form — v1 builds i*x implicitly
                // via separate y_even/y_odd updates on deinterleaved streams.
                %x_even, %x_odd = pto.vdintlv %x, %x : !pto.vreg<128xf16>, !pto.vreg<128xf16> -> !pto.vreg<128xf16>, !pto.vreg<128xf16>
                %x_neg_odd = pto.vmul %x_odd, %neg_one, %mask_pair : !pto.vreg<128xf16>, !pto.vreg<128xf16>, !pto.mask<b16> -> !pto.vreg<128xf16>
                %x_rot, %x_rot_hi = pto.vintlv %x_neg_odd, %x_even : !pto.vreg<128xf16>, !pto.vreg<128xf16> -> !pto.vreg<128xf16>, !pto.vreg<128xf16>

                // complex-multiply: y = x*cos + (i*x)*sin  (3 ops)
                // vs Cartesian expansion: separate y_even/y_odd updates (8 ops)
                %x_cos = pto.vmul %x, %cos, %mask16 : !pto.vreg<128xf16>, !pto.vreg<128xf16>, !pto.mask<b16> -> !pto.vreg<128xf16>
                %rot_sin = pto.vmul %x_rot, %sin, %mask16 : !pto.vreg<128xf16>, !pto.vreg<128xf16>, !pto.mask<b16> -> !pto.vreg<128xf16>
                %y = pto.vadd %x_cos, %rot_sin, %mask16 : !pto.vreg<128xf16>, !pto.vreg<128xf16>, !pto.mask<b16> -> !pto.vreg<128xf16>

                pto.vsts %y, %y_ub[%y_elem_off], %mask16 : !pto.vreg<128xf16>, !pto.ptr<f16, ub>, !pto.mask<b16>
              }
            }
          }
        }