From b3604d97d3ee37ab9861d59040586edc1f91f64b Mon Sep 17 00:00:00 2001 From: LinxISA Automation Date: Wed, 21 Oct 2026 10:18:30 +0800 Subject: [PATCH] Restore linx to PTO 0.58.7 stable baseline --- Makefile | 4 +- README.md | 29 +- contracts/README.md | 24 +- contracts/linxisa-v0.58-engine-ops.json | 362 +-- ...on => pto-isa-0.58.7-tile-operations.json} | 245 +- docs/tileop-usage/README.md | 28 +- docs/tileop-usage/b-subview-b-assemble.md | 2 +- docs/tileop-usage/element-if.md | 171 +- .../transcendental/TEXPDIF.md | 2 +- docs/tileop-usage/generated/engines.md | 253 +- .../format-conversion/TDEQUANT.md | 122 +- .../format-conversion/TQUANT.md | 118 +- .../initialization/THISTOGRAM.md | 119 +- .../irregular-and-complex/sorting/TMRGSORT.md | 123 +- .../irregular-and-complex/sorting/TSORT.md | 128 +- .../layout/TCONCAT.md | 120 +- .../layout/TEXTRACT.md | 108 +- .../layout/TINSERT.md | 109 +- .../layout-and-rearrangement/layout/TTRANS.md | 118 +- docs/tileop-usage/options.md | 16 +- docs/tileop-usage/support-status.md | 33 +- .../arithmetic/TLEA.md | 112 - .../tlsu/load-store-move/TLOAD.md | 2 +- .../tileop-usage/tlsu/load-store-move/TMOV.md | 4 +- include/common/pto_tile_region_inline_asm.hpp | 76 +- include/common/pto_tileop_api_revision.hpp | 4 +- include/jcore/template_asm.hpp | 2404 ++++++++--------- test/test_dense_f16_element_tile_api.py | 4 +- test/test_element_tile_api.py | 5 +- test/test_issue_272_276_contract.py | 2 +- test/test_pto0585_layout_interfaces.py | 4 +- test/test_tpack_element_assembly_api.py | 2 +- test/test_v058_engine_contract.py | 234 +- test/test_version_header.py | 4 +- test/test_weight_tload_contract.py | 4 +- test/tileop_api/pto0583_asm_contract.s | 21 +- test/tileop_api/src/MGatherAtomics.cpp | 2 +- test/tileop_api/src/MGatherCas.cpp | 2 +- test/tileop_api/src/MScatterAtomics.cpp | 2 +- test/tileop_api/src/TeplAssSpecial.cpp | 2 + test/tileop_api/verify_pto0583_asm.sh | 44 +- test/tileop_api/verify_pto_identity.py | 12 +- test/tileop_api/verify_target_cxx_frontend.sh | 8 +- tools/check_issue_49_docs.py | 7 +- tools/check_pto_catalog_alignment.py | 41 +- tools/generate_engine_docs.py | 69 +- tools/generate_tileop_usage_docs.py | 2 +- tools/sync_linxisa_v058_contract.py | 155 ++ tools/sync_pto_isa_0590_contract.py | 293 -- 49 files changed, 2893 insertions(+), 2862 deletions(-) rename contracts/{pto-isa-0.59.0-tile-operations.json => pto-isa-0.58.7-tile-operations.json} (96%) delete mode 100644 docs/tileop-usage/tile-scalar-and-immediate/arithmetic/TLEA.md create mode 100644 tools/sync_linxisa_v058_contract.py delete mode 100644 tools/sync_pto_isa_0590_contract.py diff --git a/Makefile b/Makefile index 8b7f66b1..bc56e796 100644 --- a/Makefile +++ b/Makefile @@ -1,5 +1,5 @@ LIBNAME = tileop-api -VERSION = 0.59.0 +VERSION = 0.58.7 HEADERS = $(wildcard include/*.h) $(wildcard include/*.hpp) include/jcore include/cpu_sim include/aarch64 include/common TILEOP_API_REVISION ?= $(shell git rev-parse HEAD 2>/dev/null || printf unknown) TILEOP_API_REVISION_IS_EXACT ?= $(shell test -z "$$(git status --porcelain --untracked-files=all 2>/dev/null)" && printf 1 || printf 0) @@ -53,7 +53,7 @@ install: echo '#define PTO_TILEOP_API_REVISION_HPP'; \ echo ''; \ echo '#define PTO_TILEOP_API_VERSION "$(VERSION)"'; \ - echo '#define PTO_TILEOP_API_SPEC_VERSION "0.59.0"'; \ + echo '#define PTO_TILEOP_API_SPEC_VERSION "0.58.7"'; \ echo '#define PTO_TILEOP_API_REVISION "$(TILEOP_API_REVISION)"'; \ echo '#define PTO_TILEOP_API_REVISION_IS_EXACT $(TILEOP_API_REVISION_IS_EXACT)'; \ echo ''; \ diff --git a/README.md b/README.md index d503c3f2..36a7feca 100644 --- a/README.md +++ b/README.md @@ -1,15 +1,8 @@ # Linx TileOP API -Header-only C++ TileOP bindings for the LinxISA / PTO ISA 0.59.0 architectural -contract. The checked-in catalog and documentation are generated against the -published PTO ISA `v0.59.0.0` release (commit `b016532`, ABI -`pto-isa-0.59.0-mode-function-v1`). The release manifest records -`specification_status: draft` and limits implementation conformance to -`b-fpatr-and-tcvt-e8m0-asl-proven-other-numeric-domains-unproven`; this binding -carries that identity without claiming a finalized specification or full -numeric conformance. The semantic engine inventory remains the LinxISA v0.58 -authority projection, whose 119-operation Tile catalog is byte-identical to the -release catalog. +Header-only C++ TileOP bindings for the LinxISA / PTO ISA 0.58.7 architectural contract. +The checked-in catalog and documentation are generated against the PTO ISA 0.58.7 +baseline (`0.58.7.0`, ABI `pto-isa-0.58.7-mode-function-v1`). Installed headers expose their provenance through ``. `PTO_TILEOP_API_VERSION` and @@ -19,7 +12,7 @@ Installed headers expose their provenance through allow consumers to reject toolchains that predate a required fix. The normative operation inventory comes from the checked-in PTO catalog at -[`contracts/pto-isa-0.59.0-tile-operations.json`](contracts/pto-isa-0.59.0-tile-operations.json). +[`contracts/pto-isa-0.58.7-tile-operations.json`](contracts/pto-isa-0.58.7-tile-operations.json). The public bindings retain the unique compiled `BSTART.TEPL` carrier for VEC/SFU source compatibility and emit the named TLSU/CUBE operation forms accepted by the current Linx compiler. The generated engine index is a wrapper compatibility @@ -32,7 +25,7 @@ view, not a replacement for the PTO ASL/NDF semantics. - [CUBE operations](docs/tileop-usage/cube/matrix-matrix/TMATMUL.md) - [Tile and Shared-register constraints](docs/tileop-usage/concepts/tile-constraints.md) - [Layout helpers](docs/tileop-usage/layout-and-rearrangement/layout/TCONCAT.md) -- [PTO ISA 0.59.0 CUBE layout operations](docs/tileop-usage/layout-and-rearrangement/layout/TPERMUTE.md) +- [PTO ISA 0.58.7 CUBE layout operations](docs/tileop-usage/layout-and-rearrangement/layout/TPERMUTE.md) - [Comparison operations](docs/tileop-usage/elementwise-tile-tile/logical/TCMP.md) - [TEXPDIF](docs/tileop-usage/elementwise-tile-tile/transcendental/TEXPDIF.md) - [Sorting operations](docs/tileop-usage/irregular-and-complex/sorting/TSORT.md) @@ -44,20 +37,18 @@ view, not a replacement for the PTO ASL/NDF semantics. make check ``` -Target compilation requires a Linx LLVM build supporting the PTO ISA 0.59.0 +Target compilation requires a Linx LLVM build supporting the PTO ISA 0.58.7 encoding ABI. The old PTO ISA 0.58.3 Linx LLVM requirement belongs only to the historical migration fixtures under `test/tileop_api` and `docs/tileop-usage/migration/pto-0583-migration.md`; it is not the current API baseline. Run the catalog and documentation checks before target compilation. -To refresh the pinned projection, provide the clean, exact reviewed LinxISA -v0.58 authority commit together with a clean checkout of `PTO-ISA/pto-spec` at -the `v0.59.0.0` release commit: +To refresh the pinned projection from the clean, exact reviewed LinxISA +authority commit recorded by the generator: ```sh -python3 tools/sync_pto_isa_0590_contract.py \ - /path/to/linx-isa/isa/v0.58/linxisa-v0.58.json \ - --pto-root /path/to/pto-spec +python3 tools/sync_linxisa_v058_contract.py \ + /path/to/linx-isa/isa/v0.58/linxisa-v0.58.json python3 tools/generate_engine_docs.py make check ``` diff --git a/contracts/README.md b/contracts/README.md index 2d2eef69..256293c9 100644 --- a/contracts/README.md +++ b/contracts/README.md @@ -1,25 +1,19 @@ # LinxISA contract projections -`pto-isa-0.59.0-tile-operations.json` is the checked-in machine-readable snapshot -of the published PTO ISA 0.59.0.0 release Tile catalog. It records all 119 accepted direct +`pto-isa-0.58.7-tile-operations.json` is the checked-in machine-readable snapshot +of the PTO ISA 0.58.7 active Tile catalog. It records all 118 accepted direct operations plus the catalog's deleted and rejected inventories. Its source of truth is `PTO-ISA/pto-spec/spec/catalog/tile-operations.json`; refresh it only -from the `v0.59.0.0` release commit `b0165320a4b575b18d2f4d93faf40178f661ab49` -and review the resulting diff. These bytes are identical to the PTO 0.58.7 -development golden catalog (SHA-256 533db9b8...); only the surrounding encoding -identity moved to the release. +from the pinned PTO release and review the resulting diff. -`linxisa-v0.58-engine-ops.json` is a generated, provenance-pinned projection of -the LinxISA v0.58 authority onto the PTO ISA 0.59.0.0 release encoding identity. -It records operation ownership and encodings; it does not claim that this -repository implements every projected operation. There is no LinxISA 0.59 -profile, so the LinxISA `source` stays v0.58 and the development-golden lock it -carried is preserved under `pto_source.development_lock`: +`linxisa-v0.58-engine-ops.json` remains a generated, provenance-pinned +**historical** LinxISA/PTO 0.58.3 projection. It is retained only for legacy +engine/compiler compatibility tests and must not be used to claim current +operation availability: ```bash -python3 tools/sync_pto_isa_0590_contract.py \ - /path/to/linx-isa/isa/v0.58/linxisa-v0.58.json \ - --pto-root /path/to/pto-spec +python3 tools/sync_linxisa_v058_contract.py \ + /path/to/linx-isa/isa/v0.58/linxisa-v0.58.json ``` The catalog drives current operation inventory and documentation checks. ASL/NDF diff --git a/contracts/linxisa-v0.58-engine-ops.json b/contracts/linxisa-v0.58-engine-ops.json index 3da686e7..804ce3a8 100644 --- a/contracts/linxisa-v0.58-engine-ops.json +++ b/contracts/linxisa-v0.58-engine-ops.json @@ -3,73 +3,73 @@ { "engine": "CUBE", "function": 0, - "mnemonic": "BSTART.TMATMUL", + "mnemonic": "BSTART.CUBE TMATMUL", "name": "TMATMUL" }, { "engine": "CUBE", "function": 1, - "mnemonic": "BSTART.TMATMUL.BIAS", + "mnemonic": "BSTART.CUBE TMATMUL.BIAS", "name": "TMATMUL_BIAS" }, { "engine": "CUBE", "function": 2, - "mnemonic": "BSTART.TMATMUL.ACC", + "mnemonic": "BSTART.CUBE TMATMUL.ACC", "name": "TMATMUL_ACC" }, { "engine": "CUBE", "function": 4, - "mnemonic": "BSTART.TMATMULMX", + "mnemonic": "BSTART.CUBE TMATMULMX", "name": "TMATMUL_MX" }, { "engine": "CUBE", "function": 5, - "mnemonic": "BSTART.TMATMULMX.BIAS", + "mnemonic": "BSTART.CUBE TMATMULMX.BIAS", "name": "TMATMUL_MX_BIAS" }, { "engine": "CUBE", "function": 6, - "mnemonic": "BSTART.TMATMULMX.ACC", + "mnemonic": "BSTART.CUBE TMATMULMX.ACC", "name": "TMATMUL_MX_ACC" }, { "engine": "CUBE", "function": 16, - "mnemonic": "BSTART.TGEMV", + "mnemonic": "BSTART.CUBE TGEMV", "name": "TGEMV" }, { "engine": "CUBE", "function": 17, - "mnemonic": "BSTART.TGEMV.BIAS", + "mnemonic": "BSTART.CUBE TGEMV.BIAS", "name": "TGEMV_BIAS" }, { "engine": "CUBE", "function": 18, - "mnemonic": "BSTART.TGEMV.ACC", + "mnemonic": "BSTART.CUBE TGEMV.ACC", "name": "TGEMV_ACC" }, { "engine": "CUBE", "function": 20, - "mnemonic": "BSTART.TGEMVMX", + "mnemonic": "BSTART.CUBE TGEMVMX", "name": "TGEMV_MX" }, { "engine": "CUBE", "function": 21, - "mnemonic": "BSTART.TGEMVMX.BIAS", + "mnemonic": "BSTART.CUBE TGEMVMX.BIAS", "name": "TGEMV_MX_BIAS" }, { "engine": "CUBE", "function": 22, - "mnemonic": "BSTART.TGEMVMX.ACC", + "mnemonic": "BSTART.CUBE TGEMVMX.ACC", "name": "TGEMV_MX_ACC" } ], @@ -79,17 +79,12 @@ "TADDSC", "TALLOC", "TAXPY", - "TCONCAT", "TDEINTERLEAVE", - "TDEQUANT", "TFILLPAD", "TFMOD", "TFMODS", "TFREE", - "TEXTRACT", "TGATHERB", - "THISTOGRAM", - "TINSERT", "TINTERLEAVE", "TLRELU", "TPARTADD", @@ -101,63 +96,40 @@ "TPOP", "TPRELU", "TPUSH", - "TQUANT", + "TRANDOM", "TRESHAPE", - "TSORT", "TSORT32", - "TTRANS", - "TMRGSORT" + "TSUBC", + "TSUBSC", + "TTRANS" ], "profile": "v0.58", "pto_source": { - "commit": "b0165320a4b575b18d2f4d93faf40178f661ab49", - "content_sha256": "a3e71975e7f753864f7ec09c57515e60f5a6e3e72dfdbce8e444c815a20b2835", - "development_lock": { - "catalog_sha256_matches_release": true, - "commit": "f0a876e449a95d26841c5ee7affb4c905ebc5f5b", - "development_manifest": { - "path": "spec/development-manifest.json", - "sha256": "0c6d0b2a1ec0b49e32e13971e751a5ea19946351a3880bfdfcef0f50351944f7" - }, - "note": "The LinxISA v0.58 authority locked the PTO development golden; its Tile catalog bytes equal the 0.59.0.0 release Tile catalog (both SHA-256 533db9b8...), so the v0.58 engine projection remains valid against the published release.", - "release": "0.58.7", - "tree": "fe9e8e050375fbce3f526d08acca13c37cd15830" - }, - "encoding_abi": "pto-isa-0.59.0-mode-function-v1", - "encoding_projection_sha256": "91509080ca656eb124f47830dcb09c50389dc177266b3b8df9d2d11dc37d5697", - "publication_version": "0.59.0.0", - "release": "0.59.0", - "release_manifest": { - "path": "spec/release-manifest.json", - "sha256": "3c6b20623e73822c0bd26021c10beb233b8809328b5515f57609eadad1749dc4" - }, - "release_tag": "v0.59.0.0", + "commit": "e599a3d36ebfad43362ff591ea5e128816c684c7", + "content_sha256": "f299fe3d256c5d071e57bb4aaa2be2de2e4a386ae090048df1f73ae92d392678", + "encoding_abi": "pto-isa-0.58.3-mode-function-v1", + "encoding_projection_sha256": "8a48b80e04484c70870f155bf9efc79d2a805cf99e809f4e4e8a7e6a7eb34172", + "release": "0.58.3", "repo": "https://github.com/PTO-ISA/pto-spec.git", - "specification_status": "draft", - "tile_catalog": { - "count": 119, - "path": "spec/catalog/tile-operations.json", - "sha256": "533db9b8f31f118af5978de813cfaa3fa738de820ee24655faa2ee71f343a706" - }, - "tree": "31ff0c2d39cbed714baf5be7929bfd06887be9fb" + "tree": "abb6899d2e664e378ac9c1b77062670daa4d31b4" }, - "schema": "linx-tileop-api.engine-ops-projection.v2", + "schema": "linx-tileop-api.engine-ops-projection.v1", "semantic_engine_counts": { "CUBE": 12, - "SFU": 47, - "TLSU": 28, - "VEC": 32 + "SFU": 57, + "TLSU": 10, + "VEC": 31 }, "source": { - "commit": "f77a8960f61f97c264a90b7aee757f99891b0943", + "commit": "dd52a2e579d8058c0d8e33043e705122b340e73f", "path": "isa/v0.58/linxisa-v0.58.json", - "release": "0.58.7", + "release": "0.58.3", "repo": "https://github.com/LinxISA/linx-isa", - "sha256": "51ca9be275518d29ec48bed570b7a9bd441a65b9c5e6d4f79072f650ee732925", - "tree": "da085d3f000a5b92031c9694024dc9a7f3cdaa89" + "sha256": "34ecbcfa075166490b622647eb53c13a9c360848d6c7acb2e034d3e47f8c9a8a", + "tree": "1cfc7343e714489f95f67592475e8b9f079241ee" }, "tepl_carrier": { - "accepted_selector_count": 79, + "accepted_selector_count": 87, "canonical_aliases": [ "BSTART.VEC", "BSTART.SFU" @@ -366,6 +338,14 @@ "mode": 0, "name": "TFMA" }, + { + "classification": "elementwise-tile-tile", + "engine": "SFU", + "function": 29, + "logical_selector": 29, + "mode": 0, + "name": "TEXPDIF" + }, { "classification": "tile-scalar-and-immediate", "engine": "VEC", @@ -710,6 +690,46 @@ "mode": 2, "name": "TCOLARGMIN" }, + { + "classification": "layout-and-rearrangement", + "engine": "SFU", + "function": 0, + "logical_selector": 96, + "mode": 3, + "name": "TCONCAT" + }, + { + "classification": "layout-and-rearrangement", + "engine": "SFU", + "function": 2, + "logical_selector": 98, + "mode": 3, + "name": "TEXTRACT" + }, + { + "classification": "layout-and-rearrangement", + "engine": "SFU", + "function": 3, + "logical_selector": 99, + "mode": 3, + "name": "TINSERT" + }, + { + "classification": "layout-and-rearrangement", + "engine": "SFU", + "function": 4, + "logical_selector": 100, + "mode": 3, + "name": "TIMG2COL" + }, + { + "classification": "layout-and-rearrangement", + "engine": "SFU", + "function": 5, + "logical_selector": 101, + "mode": 3, + "name": "TFILLPAD" + }, { "classification": "irregular-and-complex", "engine": "SFU", @@ -729,129 +749,153 @@ { "classification": "irregular-and-complex", "engine": "SFU", - "function": 15, - "logical_selector": 111, + "function": 8, + "logical_selector": 104, "mode": 3, - "name": "TGATHER" + "name": "THISTOGRAM" }, { "classification": "irregular-and-complex", "engine": "SFU", - "function": 16, - "logical_selector": 112, + "function": 10, + "logical_selector": 106, "mode": 3, - "name": "TSCATTER" + "name": "TQUANT" }, { - "classification": "layout-and-rearrangement", + "classification": "irregular-and-complex", "engine": "SFU", - "function": 21, - "logical_selector": 117, + "function": 11, + "logical_selector": 107, "mode": 3, - "name": "TPERMUTE" + "name": "TDEQUANT" }, { - "classification": "layout-and-rearrangement", + "classification": "irregular-and-complex", "engine": "SFU", - "function": 22, - "logical_selector": 118, + "function": 12, + "logical_selector": 108, "mode": 3, - "name": "TSHUF" + "name": "TSORT" }, { - "classification": "layout-and-rearrangement", + "classification": "irregular-and-complex", "engine": "SFU", - "function": 23, - "logical_selector": 119, + "function": 13, + "logical_selector": 109, "mode": 3, - "name": "TPACK" + "name": "TMRGSORT" }, { "classification": "layout-and-rearrangement", "engine": "SFU", - "function": 24, - "logical_selector": 120, + "function": 14, + "logical_selector": 110, "mode": 3, - "name": "TUNPACK" + "name": "TTRANS" }, { - "classification": "layout-and-rearrangement", + "classification": "irregular-and-complex", "engine": "SFU", - "function": 30, - "logical_selector": 126, + "function": 15, + "logical_selector": 111, "mode": 3, - "name": "TGPR2T" + "name": "TGATHER" }, { - "classification": "elementwise-tile-tile", + "classification": "irregular-and-complex", "engine": "SFU", - "function": 29, - "logical_selector": 29, - "mode": 0, - "name": "TEXPDIF" + "function": 16, + "logical_selector": 112, + "mode": 3, + "name": "TSCATTER" }, { - "classification": "tile-scalar-and-immediate", - "engine": "VEC", - "function": 14, - "logical_selector": 46, - "mode": 1, - "name": "TLEA" + "classification": "irregular-and-complex", + "engine": "SFU", + "function": 17, + "logical_selector": 113, + "mode": 3, + "name": "TPARTADD" + }, + { + "classification": "irregular-and-complex", + "engine": "SFU", + "function": 18, + "logical_selector": 114, + "mode": 3, + "name": "TPARTMUL" + }, + { + "classification": "irregular-and-complex", + "engine": "SFU", + "function": 19, + "logical_selector": 115, + "mode": 3, + "name": "TPARTMAX" + }, + { + "classification": "irregular-and-complex", + "engine": "SFU", + "function": 20, + "logical_selector": 116, + "mode": 3, + "name": "TPARTMIN" } ], "tlsu_ops": [ { "engine": "TLSU", "function": 0, - "mnemonic": "BSTART.TLOAD", + "mnemonic": "BSTART.TLSU TLOAD", "name": "TLOAD" }, { "engine": "TLSU", "function": 1, - "mnemonic": "BSTART.TSTORE", + "mnemonic": "BSTART.TLSU TSTORE", "name": "TSTORE" }, { "engine": "TLSU", "function": 2, - "mnemonic": "BSTART.TMOV", + "mnemonic": "BSTART.TLSU TMOV", "name": "TMOV" }, { "engine": "TLSU", "function": 3, - "mnemonic": "BSTART.TPREFETCH", + "mnemonic": "BSTART.TLSU TPREFETCH", "name": "TPREFETCH" }, { "engine": "TLSU", "function": 4, - "mnemonic": "BSTART.MGATHER", + "mnemonic": "BSTART.TLSU MGATHER", "name": "MGATHER" }, { "engine": "TLSU", "function": 5, - "mnemonic": "BSTART.MSCATTER", + "mnemonic": "BSTART.TLSU MSCATTER", "name": "MSCATTER" }, { "engine": "TLSU", "function": 6, - "mnemonic": "BSTART.MGATHER.MASK", + "mnemonic": "BSTART.TLSU MGATHER.MASK", "name": "MGATHER_MASK" }, { "engine": "TLSU", "function": 7, - "mnemonic": "BSTART.MSCATTER.MASK", + "mnemonic": "BSTART.TLSU MSCATTER.MASK", "name": "MSCATTER_MASK" }, { "engine": "TLSU", "function": 8, - "mnemonic": "BSTART.MGATHER.CAS", + "mnemonic": "BSTART.TLSU MGATHER.CAS", "name": "MGATHER_CAS" }, { @@ -859,114 +903,6 @@ "function": 13, "mnemonic": "BSTART.GMOV", "name": "GMOV" - }, - { - "engine": "TLSU", - "function": 9, - "mnemonic": "BSTART.MGATHER.EXCH", - "name": "MGATHER_EXCH" - }, - { - "engine": "TLSU", - "function": 10, - "mnemonic": "BSTART.MGATHER.MAX", - "name": "MGATHER_MAX" - }, - { - "engine": "TLSU", - "function": 11, - "mnemonic": "BSTART.MGATHER.MIN", - "name": "MGATHER_MIN" - }, - { - "engine": "TLSU", - "function": 12, - "mnemonic": "BSTART.MGATHER.ADD", - "name": "MGATHER_ADD" - }, - { - "engine": "TLSU", - "function": 14, - "mnemonic": "BSTART.MGATHER.INC", - "name": "MGATHER_INC" - }, - { - "engine": "TLSU", - "function": 15, - "mnemonic": "BSTART.MGATHER.DEC", - "name": "MGATHER_DEC" - }, - { - "engine": "TLSU", - "function": 16, - "mnemonic": "BSTART.MGATHER.AND", - "name": "MGATHER_AND" - }, - { - "engine": "TLSU", - "function": 17, - "mnemonic": "BSTART.MGATHER.OR", - "name": "MGATHER_OR" - }, - { - "engine": "TLSU", - "function": 18, - "mnemonic": "BSTART.MGATHER.XOR", - "name": "MGATHER_XOR" - }, - { - "engine": "TLSU", - "function": 19, - "mnemonic": "BSTART.MSCATTER.MAX", - "name": "MSCATTER_MAX" - }, - { - "engine": "TLSU", - "function": 20, - "mnemonic": "BSTART.MSCATTER.MIN", - "name": "MSCATTER_MIN" - }, - { - "engine": "TLSU", - "function": 21, - "mnemonic": "BSTART.MSCATTER.ADD", - "name": "MSCATTER_ADD" - }, - { - "engine": "TLSU", - "function": 22, - "mnemonic": "BSTART.MSCATTER.INC", - "name": "MSCATTER_INC" - }, - { - "engine": "TLSU", - "function": 23, - "mnemonic": "BSTART.MSCATTER.DEC", - "name": "MSCATTER_DEC" - }, - { - "engine": "TLSU", - "function": 24, - "mnemonic": "BSTART.MSCATTER.AND", - "name": "MSCATTER_AND" - }, - { - "engine": "TLSU", - "function": 25, - "mnemonic": "BSTART.MSCATTER.OR", - "name": "MSCATTER_OR" - }, - { - "engine": "TLSU", - "function": 26, - "mnemonic": "BSTART.MSCATTER.XOR", - "name": "MSCATTER_XOR" - }, - { - "engine": "TLSU", - "function": 27, - "mnemonic": "BSTART.MSCATTER.POPC", - "name": "MSCATTER_POPC" } ] -} +} \ No newline at end of file diff --git a/contracts/pto-isa-0.59.0-tile-operations.json b/contracts/pto-isa-0.58.7-tile-operations.json similarity index 96% rename from contracts/pto-isa-0.59.0-tile-operations.json rename to contracts/pto-isa-0.58.7-tile-operations.json index c53bc63b..a646c1a6 100644 --- a/contracts/pto-isa-0.59.0-tile-operations.json +++ b/contracts/pto-isa-0.58.7-tile-operations.json @@ -1,6 +1,6 @@ { "isa": "PTO Instruction Set Architecture", - "operation_count": 119, + "operation_count": 118, "rejected_review_only_codes": { "CUBE": [], "TEPL": [ @@ -2302,7 +2302,7 @@ "operands": [ { "field": "destination0", - "role": "new Local operation-type numeric destination" + "role": "new Local same-type numeric destination" }, { "field": "source0", @@ -2313,7 +2313,7 @@ "selector": "0x040", "semantic_handler": "ExecuteTileReduction", "state_effects": [ - "operand:destination0:new-local-operation-type-destination", + "operand:destination0:new-local-same-type-destination", "operand:source0:persistent-local-numeric-source", "runtime:CurrentBundlePadValue:numeric-padding" ], @@ -2355,7 +2355,7 @@ "operands": [ { "field": "destination0", - "role": "new Local operation-type numeric destination" + "role": "new Local same-type numeric destination" }, { "field": "source0", @@ -2366,7 +2366,7 @@ "selector": "0x041", "semantic_handler": "ExecuteTileReduction", "state_effects": [ - "operand:destination0:new-local-operation-type-destination", + "operand:destination0:new-local-same-type-destination", "operand:source0:persistent-local-numeric-source", "runtime:CurrentBundlePadValue:numeric-padding" ], @@ -2408,7 +2408,7 @@ "operands": [ { "field": "destination0", - "role": "new Local operation-type numeric destination" + "role": "new Local same-type numeric destination" }, { "field": "source0", @@ -2419,7 +2419,7 @@ "selector": "0x042", "semantic_handler": "ExecuteTileReduction", "state_effects": [ - "operand:destination0:new-local-operation-type-destination", + "operand:destination0:new-local-same-type-destination", "operand:source0:persistent-local-numeric-source", "runtime:CurrentBundlePadValue:numeric-padding" ], @@ -2461,7 +2461,7 @@ "operands": [ { "field": "destination0", - "role": "new Local operation-type numeric destination" + "role": "new Local same-type numeric destination" }, { "field": "source0", @@ -2472,7 +2472,7 @@ "selector": "0x043", "semantic_handler": "ExecuteTileReduction", "state_effects": [ - "operand:destination0:new-local-operation-type-destination", + "operand:destination0:new-local-same-type-destination", "operand:source0:persistent-local-numeric-source", "runtime:CurrentBundlePadValue:numeric-padding" ], @@ -2502,22 +2502,9 @@ "datr_contract": { "allowed_nonzero_fields": [ "Layout", - "PadValueOrByteId", - "RMode" + "PadValueOrByteId" ], - "pad_union": "pad-value", - "conditional_nonzero_fields": { - "RMode": { - "semantic_name": "BroadcastByteOffset", - "encoded_bits": "B.DATR[17:15]", - "applies_when": [ - "CUBE_M16", - "CUBE_M32" - ], - "otherwise": "RowMajor requires zero", - "default": 0 - } - } + "pad_union": "pad-value" }, "disposition": "accepted-direct-operation", "effect_contract": "ExecuteTileExpand", @@ -2534,7 +2521,7 @@ }, { "field": "source0", - "role": "persistent Local row-broadcast source; CUBE_M16/M32 select an operation-typed slot within the first bound CELL" + "role": "persistent Local row-broadcast source" } ], "restart_contract": "CompleteBundleAtWithAcceptedApplicabilityRules", @@ -2571,22 +2558,9 @@ "datr_contract": { "allowed_nonzero_fields": [ "Layout", - "PadValueOrByteId", - "RMode" + "PadValueOrByteId" ], - "pad_union": "pad-value", - "conditional_nonzero_fields": { - "RMode": { - "semantic_name": "BroadcastByteOffset", - "encoded_bits": "B.DATR[17:15]", - "applies_when": [ - "CUBE_M16", - "CUBE_M32" - ], - "otherwise": "RowMajor requires zero", - "default": 0 - } - } + "pad_union": "pad-value" }, "disposition": "accepted-direct-operation", "effect_contract": "ExecuteTileExpand", @@ -2607,7 +2581,7 @@ }, { "field": "source1", - "role": "persistent Local row-broadcast source; CUBE_M16/M32 select an operation-typed slot within the first bound CELL" + "role": "persistent Local row-broadcast source" } ], "restart_contract": "CompleteBundleAtWithAcceptedApplicabilityRules", @@ -2645,22 +2619,9 @@ "datr_contract": { "allowed_nonzero_fields": [ "Layout", - "PadValueOrByteId", - "RMode" + "PadValueOrByteId" ], - "pad_union": "pad-value", - "conditional_nonzero_fields": { - "RMode": { - "semantic_name": "BroadcastByteOffset", - "encoded_bits": "B.DATR[17:15]", - "applies_when": [ - "CUBE_M16", - "CUBE_M32" - ], - "otherwise": "RowMajor requires zero", - "default": 0 - } - } + "pad_union": "pad-value" }, "disposition": "accepted-direct-operation", "effect_contract": "ExecuteTileExpand", @@ -2681,7 +2642,7 @@ }, { "field": "source1", - "role": "persistent Local row-broadcast source; CUBE_M16/M32 select an operation-typed slot within the first bound CELL" + "role": "persistent Local row-broadcast source" } ], "restart_contract": "CompleteBundleAtWithAcceptedApplicabilityRules", @@ -2719,22 +2680,9 @@ "datr_contract": { "allowed_nonzero_fields": [ "Layout", - "PadValueOrByteId", - "RMode" + "PadValueOrByteId" ], - "pad_union": "pad-value", - "conditional_nonzero_fields": { - "RMode": { - "semantic_name": "BroadcastByteOffset", - "encoded_bits": "B.DATR[17:15]", - "applies_when": [ - "CUBE_M16", - "CUBE_M32" - ], - "otherwise": "RowMajor requires zero", - "default": 0 - } - } + "pad_union": "pad-value" }, "disposition": "accepted-direct-operation", "effect_contract": "ExecuteTileExpand", @@ -2755,7 +2703,7 @@ }, { "field": "source1", - "role": "persistent Local row-broadcast source; CUBE_M16/M32 select an operation-typed slot within the first bound CELL" + "role": "persistent Local row-broadcast source" } ], "restart_contract": "CompleteBundleAtWithAcceptedApplicabilityRules", @@ -2793,22 +2741,9 @@ "datr_contract": { "allowed_nonzero_fields": [ "Layout", - "PadValueOrByteId", - "RMode" + "PadValueOrByteId" ], - "pad_union": "pad-value", - "conditional_nonzero_fields": { - "RMode": { - "semantic_name": "BroadcastByteOffset", - "encoded_bits": "B.DATR[17:15]", - "applies_when": [ - "CUBE_M16", - "CUBE_M32" - ], - "otherwise": "RowMajor requires zero", - "default": 0 - } - } + "pad_union": "pad-value" }, "disposition": "accepted-direct-operation", "effect_contract": "ExecuteTileExpand", @@ -2829,7 +2764,7 @@ }, { "field": "source1", - "role": "persistent Local row-broadcast source; CUBE_M16/M32 select an operation-typed slot within the first bound CELL" + "role": "persistent Local row-broadcast source" } ], "restart_contract": "CompleteBundleAtWithAcceptedApplicabilityRules", @@ -2867,22 +2802,9 @@ "datr_contract": { "allowed_nonzero_fields": [ "Layout", - "PadValueOrByteId", - "RMode" + "PadValueOrByteId" ], - "pad_union": "pad-value", - "conditional_nonzero_fields": { - "RMode": { - "semantic_name": "BroadcastByteOffset", - "encoded_bits": "B.DATR[17:15]", - "applies_when": [ - "CUBE_M16", - "CUBE_M32" - ], - "otherwise": "RowMajor requires zero", - "default": 0 - } - } + "pad_union": "pad-value" }, "disposition": "accepted-direct-operation", "effect_contract": "ExecuteTileExpand", @@ -2903,7 +2825,7 @@ }, { "field": "source1", - "role": "persistent Local row-broadcast source; CUBE_M16/M32 select an operation-typed slot within the first bound CELL" + "role": "persistent Local row-broadcast source" } ], "restart_contract": "CompleteBundleAtWithAcceptedApplicabilityRules", @@ -2941,22 +2863,9 @@ "datr_contract": { "allowed_nonzero_fields": [ "Layout", - "PadValueOrByteId", - "RMode" + "PadValueOrByteId" ], - "pad_union": "pad-value", - "conditional_nonzero_fields": { - "RMode": { - "semantic_name": "BroadcastByteOffset", - "encoded_bits": "B.DATR[17:15]", - "applies_when": [ - "CUBE_M16", - "CUBE_M32" - ], - "otherwise": "RowMajor requires zero", - "default": 0 - } - } + "pad_union": "pad-value" }, "disposition": "accepted-direct-operation", "effect_contract": "ExecuteTileExpand", @@ -2977,7 +2886,7 @@ }, { "field": "source1", - "role": "persistent Local row-broadcast source; CUBE_M16/M32 select an operation-typed slot within the first bound CELL" + "role": "persistent Local row-broadcast source" } ], "restart_contract": "CompleteBundleAtWithAcceptedApplicabilityRules", @@ -3016,22 +2925,9 @@ "allowed_nonzero_fields": [ "Layout", "DataType", - "PadValueOrByteId", - "RMode" + "PadValueOrByteId" ], - "pad_union": "pad-value", - "conditional_nonzero_fields": { - "RMode": { - "semantic_name": "BroadcastByteOffset", - "encoded_bits": "B.DATR[17:15]", - "applies_when": [ - "CUBE_M16", - "CUBE_M32" - ], - "otherwise": "RowMajor requires zero", - "default": 0 - } - } + "pad_union": "pad-value" }, "disposition": "accepted-direct-operation", "effect_contract": "ExecuteTileExpand", @@ -3052,7 +2948,7 @@ }, { "field": "source1", - "role": "persistent Local row-broadcast source; CUBE_M16/M32 select an operation-typed slot within the first bound CELL" + "role": "persistent Local row-broadcast source" } ], "restart_contract": "CompleteBundleAtWithAcceptedApplicabilityRules", @@ -3208,7 +3104,7 @@ "operands": [ { "field": "destination0", - "role": "new Local operation-type numeric destination" + "role": "new Local same-type numeric destination" }, { "field": "source0", @@ -3219,7 +3115,7 @@ "selector": "0x050", "semantic_handler": "ExecuteTileReduction", "state_effects": [ - "operand:destination0:new-local-operation-type-destination", + "operand:destination0:new-local-same-type-destination", "operand:source0:persistent-local-numeric-source", "runtime:CurrentBundlePadValue:numeric-padding" ], @@ -3261,7 +3157,7 @@ "operands": [ { "field": "destination0", - "role": "new Local operation-type numeric destination" + "role": "new Local same-type numeric destination" }, { "field": "source0", @@ -3272,7 +3168,7 @@ "selector": "0x051", "semantic_handler": "ExecuteTileReduction", "state_effects": [ - "operand:destination0:new-local-operation-type-destination", + "operand:destination0:new-local-same-type-destination", "operand:source0:persistent-local-numeric-source", "runtime:CurrentBundlePadValue:numeric-padding" ], @@ -3314,7 +3210,7 @@ "operands": [ { "field": "destination0", - "role": "new Local operation-type numeric destination" + "role": "new Local same-type numeric destination" }, { "field": "source0", @@ -3325,7 +3221,7 @@ "selector": "0x052", "semantic_handler": "ExecuteTileReduction", "state_effects": [ - "operand:destination0:new-local-operation-type-destination", + "operand:destination0:new-local-same-type-destination", "operand:source0:persistent-local-numeric-source", "runtime:CurrentBundlePadValue:numeric-padding" ], @@ -3367,7 +3263,7 @@ "operands": [ { "field": "destination0", - "role": "new Local operation-type numeric destination" + "role": "new Local same-type numeric destination" }, { "field": "source0", @@ -3378,7 +3274,7 @@ "selector": "0x053", "semantic_handler": "ExecuteTileReduction", "state_effects": [ - "operand:destination0:new-local-operation-type-destination", + "operand:destination0:new-local-same-type-destination", "operand:source0:persistent-local-numeric-source", "runtime:CurrentBundlePadValue:numeric-padding" ], @@ -4007,7 +3903,7 @@ "operands": [ { "field": "destination0", - "role": "new Local S64, S32, S16, U64, U32, or U16 destination" + "role": "new Local S32, S16, U32, or U16 destination" }, { "field": "scalar0", @@ -7110,61 +7006,6 @@ ], "classification": "elementwise-tile-tile", "engine": "SFU" - }, - { - "arguments": [ - { - "operand": "destination0" - }, - { - "operand": "source0" - }, - { - "operand": "scalar0" - } - ], - "command_mnemonic": "BSTART.TEPL", - "contract_status": "reviewed-complete", - "datr_contract": { - "allowed_nonzero_fields": [ - "PadValueOrByteId", - "Layout" - ], - "pad_union": "pad-value" - }, - "disposition": "accepted-direct-operation", - "effect_contract": "TLEA", - "family": "TEPL", - "fault_contract": "ExecuteTileInstruction", - "function": 14, - "legality_handler": "TileOperandsLegal_TLEA", - "mode": 1, - "name": "TLEA", - "operands": [ - { - "field": "destination0", - "role": "new Local S64/U64 byte-offset destination" - }, - { - "field": "source0", - "role": "persistent Local S32/U32/S64/U64 element indices" - }, - { - "field": "scalar0", - "role": "per-PE element width in bits" - } - ], - "restart_contract": "CompleteBundleAtWithAcceptedApplicabilityRules", - "selector": "0x02E", - "semantic_handler": "TLEA", - "state_effects": [ - "operand:destination0:new-local-byte-offset-destination", - "operand:source0:persistent-local-element-indices", - "operand:scalar0:element-width-bits", - "runtime:CurrentBundlePadValue:numeric-padding" - ], - "classification": "tile-scalar-and-immediate", - "engine": "VEC" } ], "reserved": { @@ -7204,7 +7045,7 @@ "0x025" ], [ - "0x02F", + "0x02E", "0x039" ], [ diff --git a/docs/tileop-usage/README.md b/docs/tileop-usage/README.md index 164dfc3f..ebc6fe16 100644 --- a/docs/tileop-usage/README.md +++ b/docs/tileop-usage/README.md @@ -6,20 +6,16 @@ ## 版本与兼容性 -本目录当前以 PTO-ISA/pto-spec 的 **0.59.0.0** 发布规范为对照基线： - -- architecture version：`0.59.0` -- publication version：`0.59.0.0` -- release tag：`v0.59.0.0` -- release commit：`b0165320a4b575b18d2f4d93faf40178f661ab49` -- encoding ABI：`pto-isa-0.59.0-mode-function-v1` -- specification status：`draft`（发布 manifest 自身记为 draft，实现 conformance 限定为 - `b-fpatr-and-tcvt-e8m0-asl-proven-other-numeric-domains-unproven`） - -PTO `main` 是开发分支；需要可复现构建时应锁定上面的 release commit。119 个操作的 -Tile catalog 与 PTO 0.58.7 development golden 逐字节一致，只是 encoding identity 移到了 -发布版本。本文档描述的是架构规范和本仓库 wrapper 的交集，并不表示 wrapper 已实现 -0.59.0 的全部操作，也不表示该发布规范已最终定稿或数值 conformance 已全部证明。 +本目录当前以 PTO-ISA/pto-spec 的 **0.58.7** 架构规范为对照基线： + +- architecture version：`0.58.7` +- publication version：`0.58.7.0` +- stable release commit：`de57af400cf607f03730aa522a4e9bfb160596de` +- release tag：`v0.58.7.0` +- encoding ABI：`pto-isa-0.58.7-mode-function-v1` + +PTO `main` 是开发分支；需要可复现构建时应锁定上面的 release commit。本文档描述 +的是架构规范和本仓库 wrapper 的交集，并不表示 wrapper 已实现 0.58.7 的全部操作。 每个操作页中的 C++ 签名以本仓库头文件为准，PTO ASL/NDF 是架构合法性的权威来源。 [0.58.3 迁移说明](migration/pto-0583-migration.md)是历史文档，保留用于迁移旧 @@ -35,7 +31,7 @@ kernel；其中的旧版本数量、旧 engine inventory 和旧 encoding identit - `PTO_TILEOP_API_REVISION_IS_EXACT`：revision 是否来自干净 checkout； - `PTO_TILEOP_API_HAS_LOCAL_B_KN_FIX`：local Right B 使用逻辑 `[K,N]` 契约。 -当前 wrapper 与 PTO 0.59.0 catalog 的覆盖边界见 +当前 wrapper 与 PTO 0.58.7 catalog 的覆盖边界见 [统一支持状态表](support-status.md)。该表区分“已实现”“仅部分 layout 支持”“尚无 wrapper”和“仅历史参考”，并单独记录 CPU simulator/JCORE、LLVM MC、LLVM compiler lowering 及 AArch64/SME 的 backend 能力；PTO catalog 中存在某个操作名， @@ -157,7 +153,7 @@ clang++ --target=linx64v5-unknown-linux-musl -mlxbc -fenable-matrix \ 也在该页面说明。 - 常规逐元素算子从 [TADD](elementwise-tile-tile/arithmetic/TADD.md) 开始；按目录选择 算术、逻辑、转换、归约、布局和不规则操作。 -- PTO ISA 0.59.0 的 CUBE layout 重排操作从 +- PTO ISA v0.58.7 的 CUBE layout 重排操作从 [TPERMUTE](layout-and-rearrangement/layout/TPERMUTE.md) 开始； [TSHUF](layout-and-rearrangement/layout/TSHUF.md)、 [TPACK](layout-and-rearrangement/layout/TPACK.md)、 diff --git a/docs/tileop-usage/b-subview-b-assemble.md b/docs/tileop-usage/b-subview-b-assemble.md index adfe1414..d0142160 100644 --- a/docs/tileop-usage/b-subview-b-assemble.md +++ b/docs/tileop-usage/b-subview-b-assemble.md @@ -217,7 +217,7 @@ void store_runtime_base(Src &tile, GM &gm, uintptr_t base_units) { 对应发射： ```asm -BSTART.TSTORE F32 +BSTART.TLSU TSTORE, F32 B.DIM , 0, ->lb0 B.DIM , 0, ->lb1 B.DIM zero, , ->lb2 diff --git a/docs/tileop-usage/element-if.md b/docs/tileop-usage/element-if.md index 6f356fc5..a124bff9 100644 --- a/docs/tileop-usage/element-if.md +++ b/docs/tileop-usage/element-if.md @@ -7,21 +7,12 @@ Tile 指令和 execution mask。开发者不需要手工拼接 `TCMP + TADD/TSUB 本页描述已经合入以下组件的接口： - Linx LLVM `#118`：pragma、条件控制流、Tile SSA 和后端 lowering； -- Linx LLVM `#131`：fused masked element regions、严格的 Tile/element 内存合同和 - PE-domain 边界保持； - TileOP API `#255`：`ElementTile`、typed element view、Tile/element 交替和 assembly； - SuperNPUBench `#202`：实际 workload 的推荐写法和验证方法。 Element-if 不是任意 C++ 循环的自动并行器。编译器只接受能够证明满足当前 Tile 执行合同的循环、数据类型、控制流和内存访问；不支持的写法会在编译期 fail closed。 -本页中的 `#pragma pto element for` 必须与包含 generic element-region 支持的 -Linx LLVM 配套使用。当前 generic masked lowering 不是默认路径；需要显式传入 -`-mllvm -linxv5-enable-generic-element=true`。没有该选项时，编译器应明确拒绝 -需要 generic masked lowering 的 region，而不是退回旧的 gather/publication 识别器 -或标量循环。`-O2` 是推荐配置；带 marked region 的 `-O0`/`optnone` 函数不支持 -masked native lowering。 - ## 1. 两种入口 ### 1.1 TileOP API 入口：`#pragma pto element for` @@ -39,13 +30,9 @@ masked native lowering。 using namespace pto; -void add_if_positive(float *output, const float *left, const float *right) { - ElementTile lhs_tile, rhs_tile, out_tile; - global_tensor> left_memory(left); - global_tensor> right_memory(right); - global_tensor> output_memory(output); - TLOAD(lhs_tile, left_memory); - TLOAD(rhs_tile, right_memory); +void add_if_positive(ElementTile &out_tile, + ElementTile &lhs_tile, + ElementTile &rhs_tile) { auto &out = TPARTELEMENT(out_tile); auto &lhs = TPARTELEMENT(lhs_tile); auto &rhs = TPARTELEMENT(rhs_tile); @@ -57,7 +44,6 @@ void add_if_positive(float *output, const float *left, const float *right) { else out[element] = lhs[element] - rhs[element]; } - TSTORE(output_memory, out_tile); } ``` @@ -65,22 +51,29 @@ void add_if_positive(float *output, const float *left, const float *right) { 物理 layout 合同传给编译器。不要用裸 `tile_size` vector、`reinterpret_cast` 或 同字节数的普通 Tile 替代 typed view。 -### 1.2 兼容 pragma：`#pragma linx elementwise` +### 1.2 Scalar-style 入口：`#pragma linx elementwise` + +不直接使用 TileOP wrapper 的编译器测试或底层 kernel，也可以对一个 +`tile_size(N)` 类型编写 scalar-style 循环： + +```cpp +using tile = float tile_size(128); -这个拼写仍可在 compiler frontend 中标记普通循环，但不是旧 AST pattern -recognizer 的兼容开关，也不保证裸 `tile_size(128)` 参数可以直接生成对象。 -当前 generic 路径仍要求支持的 iteration domain、typed view 和真正的 Tile -producer；普通 vector load/参数不等同于 `TLOAD`、Tile operation 或合法 Local -Tile ABI 产生的 carrier。不要把历史 scalar-style demo 当作当前可执行 profile。 +void scalar_style(tile &out, const tile &lhs, const tile &rhs) { +#pragma linx elementwise + for (unsigned element = 0; element < 128; ++element) { + if (lhs[element] > 0.0f) + out[element] = lhs[element] + rhs[element]; + else + out[element] = lhs[element] - rhs[element]; + } +} +``` -TileOP 应用使用 +这个入口主要属于 compiler frontend。TileOP 应用优先使用 `ElementTile + TPARTELEMENT + #pragma pto element for`，因为公共 API 会提供 稳定的类型、分片、valid region 和 assembly 合同。 -下文以 Tile-reference 参数展示的循环片段，需要在实际 kernel 中接入合法的 -Local Tile ABI，或内联到拥有 `TLOAD`/Tile producer 的调用点；仅通过 C++ 类型 -检查并不等于已验证 target object。独立编译可先采用 1.1 节的完整 GM 入口。 - 两个 pragma 都必须**直接位于 `for` 循环之前**。以下写法会被拒绝： ```cpp @@ -108,10 +101,9 @@ for (unsigned element = 0; element < 32; ++element) { - loop body 内使用当前 induction variable 访问 typed element view； - 不要修改 induction variable，不要从循环中 `goto`、抛异常或执行不可证明的调用； - 优先把循环外不变的值、pointer 和 part index 在 pragma 前计算好； -- 使用 `-O2` 编译；带 marked region 的 `-O0`/`optnone` 会明确拒绝； -- logical32 profile 通常使用 32 次迭代；F16/U16 logical64 profile 使用 64 次迭代。 - logical32 和 logical64 的 generic masked region 都需要上面的 generic-element - lowering 选项；该选项不是 F16/U16 专用开关。 +- 使用 `-O2` 编译。typed Tile 在 `-O0` 下可能需要不受支持的 spill/reload； +- logical32 profile 通常使用 32 次迭代；F16/U16 logical64 profile 使用 64 次迭代， + 并需要 generic-element lowering。 ## 3. 条件控制流 @@ -258,43 +250,9 @@ void gather(ElementTile &out_tile, 当前 compiler 会为受支持的 indexed access 构造 Tile 地址并降低为 masked gather。 pointer 应尽量使用明确的 element type 和 `__restrict` ownership；复杂别名、循环内 -pointer mutation 或无法证明的 byte offset 会被拒绝。读取流可以共享地址，但普通 -写入流必须证明跨 iteration 不重叠；单独证明 `a[i]` 与 `a[i+1]` 不别名并不足够。 +pointer mutation 或无法证明的 byte offset 会被拒绝。 -当同一个 element region 先读取输入、再更新独立 histogram 或其他独立目的对象时， -编译器可以在 closed、local、非递归 helper 的所有直接调用上下文中证明 whole-object -separation，包括 local forwarding helper 以及 argument/global-root 组合。这个证明 -只附着到已证明的访问对，不会给函数或指针隐式添加 `restrict`。exported、 -address-taken、indirect、unknown、recursive 或 mixed-alias 的调用上下文仍然 -fail closed。 - -### 5.2 Fused input + histogram - -普通 GM 输入也可以在同一个 region 中直接读取并更新 histogram，无需先人为 -拆成两个 region。以下示例要求 `keys[element]` 在 active element 上小于 -histogram 容量，且调用者确实保证两个存储对象不重叠： - -```cpp -void fused_histogram(const uint32_t *__restrict keys, - uint32_t *__restrict histogram, unsigned valid) { -#pragma pto element for - for (unsigned element = 0; element < 32; ++element) { - if (element < valid) - __atomic_fetch_add(&histogram[keys[element]], 1u, __ATOMIC_RELAXED); - } -} -``` - -`__restrict` 是调用者必须履行的真实合同，不是遇到编译错误时随意添加的修饰。 -也可由编译器依据上一节的 closed-callgraph 规则证明对象独立；无法证明时仍拒绝。 -即使没有使用 atomic 的返回值，也不得删除 atomic effect 或改变 active element -的执行次数。不同 element 的 atomic 可以命中同一 bin，不承诺它们之间的次序。 - -fused clear 的例外同样很窄：只有普通 unit-stride 写入、相同类型、相同零常量且 -各自按完整存储宽度对齐时才允许可能重叠的两个写入流交换。该例外不覆盖读取、 -非零值、不足的对齐或任何 atomic/ordinary 混合访问。 - -### 5.3 U32 histogram atomic +### 5.2 U32 histogram atomic ```cpp void histogram(ElementTile &old_values_tile, @@ -314,15 +272,10 @@ void histogram(ElementTile &old_values_tile, } ``` -当前公开验收的 atomic profile 是 U32、32-element、System-scope、Monotonic/relaxed -`fetch_add`，降低为 +当前公开验收的 atomic profile 是 U32、32-element、relaxed `fetch_add`，降低为 带 execution mask 的 `MGATHER.ADD`。不要据此假设任意 dtype、memory order、atomic operation 或 volatile pointer 都已支持；以 compiler 诊断和配套测试为准。 -atomic/atomic 访问可以包含重复索引；atomic 与普通 memory effect 混合时仍需要 -whole-object separation。volatile、非自然对齐、非 System scope、较强 ordering、 -其他 atomic operation 和不支持的 dtype 必须被诊断，而不是通过放宽 alias 合同接受。 - ## 6. F16/U16 logical64 F16/U16 的 dense element part 是 `ElementTile`，物理布局为 32x2。它的 @@ -388,25 +341,19 @@ llvm-objdump -d --no-show-raw-insn \ - Tile load/view/element/assembly/store 交替； - 受支持的 indexed gather； - U32 relaxed atomic add； -- fused direct load + atomic update（仅限已证明的 whole-object separation）； -- 相同类型、相同零值且按完整存储宽度对齐的 fused clear； - 多层 `TASSEMBLY` storage hierarchy。 以下写法不应假设可用： - 任意 trip count、非 canonical induction 或循环内修改 induction； -- 退出 marked loop 的 `break`、跨 region 的 `return`/`goto`、异常和递归； +- `break`、`continue`、`goto`、异常和递归； - 未经允许的函数调用、虚函数、动态分配和复杂对象生命周期； - 无法证明 ownership/alias 的 Tile 或 pointer； - 不受支持的 volatile、atomic dtype/order/operation； -- 普通 indexed 写入之间无法证明的跨 iteration overlap； - 在 `-O0` 下依赖 typed Tile spill/reload； - 把普通 vector、同宽 Tile 或 raw assembly carrier 冒充 typed element view； - 忽略 compiler/API/model 版本配套关系。 -当前 generic CFG 支持外层 marked loop 的 `continue`。前端允许的嵌套控制流 -不等于后端已支持任意嵌套循环；应分别检查 frontend boundary 与 target lowering。 - ## 9. 常见诊断 ### `requires a proven ... iteration domain` @@ -420,13 +367,7 @@ llvm-objdump -d --no-show-raw-insn \ 把循环不变量移到 region 外，使用 `TPARTVIEW`/`logical_index` 表达公共逻辑映射， 并简化 pointer ownership。 -### `predication: memory streams may overlap across elements` - -检查跨 iteration 的完整访问流，而不仅是同一个 element 内的两个地址。普通读写 -或 mixed atomic/ordinary 访问需要已证明的对象独立；不能随意添加 `__restrict` -掩盖真实重叠。fused clear 仅适用 5.2 节列出的零写入例外。 - -### 不支持的 region 内调用 +### `calls are not in the ... arithmetic region` loop body 中存在未被内联或不属于支持集合的调用。不要在 element region 内调用 普通 helper；必要时将纯表达式内联，或使用已经明确支持的 intrinsic/API。 @@ -434,18 +375,13 @@ loop body 中存在未被内联或不属于支持集合的调用。不要在 ele ### `unsupported logical view contract` compiler 与 TileOP headers 不匹配，或 view dtype/shape/layout 不受支持。确认使用 -包含 LLVM #131 和 TileOP #255 的配套工具链，并检查安装 resource directory 中的 +包含 LLVM #118 和 TileOP #255 的配套工具链，并检查安装 resource directory 中的 `tileop-api` headers 是否来自同一 revision。 -### `masked native lowering requires -linxv5-enable-generic-element=true` - -logical32 和 logical64 的 generic region 都需要显式启用该选项。不要通过恢复 -旧 recognizer、去掉 pragma 或接受标量 fallback 来绕过诊断。 - -### `masked native lowering is unsupported at -O0` +### `typed Tile spill/reload is unsupported at -O0` -改用 `-O2`，并检查 helper 是否仍带 `optnone`。后续 typed Tile spill/reload 也 -可能单独诊断；不应通过把 typed view 改成 raw pointer 或删除 metadata 来绕过。 +改用 `-O2`。这是 lowering 前 Tile SSA promotion 的要求，不应通过把 typed view +改成 raw pointer 或删除 metadata 来绕过。 ## 10. 推荐验证清单 @@ -456,46 +392,7 @@ logical32 和 logical64 的 generic region 都需要显式启用该选项。不 3. runtime/model 比较完整输出内存和 guard，而不只比较返回码； 4. negative canary 确认不支持的 alias、call、volatile 或 atomic 会被拒绝； 5. 记录 compiler、TileOP API 和 model 的精确 commit； -6. logical32/logical64 workload 按需使用 generic-element lowering，但不污染无关 - fixture；同时验证没有把普通 vector 或 raw carrier 当作 typed element view。 - -## 11. PE-domain 和 Element-if - -Element execution mask 与 function PE-domain 是两个不同层次的合同：前者描述 -region 内哪些逻辑元素有效，后者描述哪些 PE 可以执行 Local Tile 操作。不要把 -element predicate 当成 PE mask，也不要在应用中手工拼接 `.pto_pe_domain` assembly -来替代函数边界。 - -LLVM #131 提供 `__LINX_PTO_PE_DOMAIN__` feature macro 和 -`__attribute__((annotate("pto.pe_domain", mask), noinline))` 函数注解。 -**当前本仓头文件尚未提供 `PTO_PE_DOMAIN(mask)` 公共 wrapper**；只有 compiler -feature macro 并不代表可以直接调用该 wrapper，不要把未来接口当成已发布 API。 -架构 bit order 中 `8`（`1000`）表示 PE0；合法 mask 为 -`1, 2, 4, 8, 12, 14, 15`。调用者负责只让参与的 PE 进入函数；该注解不会 -predicate 普通 C++ scalar statement 或 scalar memory access。 - -PE-domain 跨函数调用需要 closed direct call graph。默认 domain 的 helper 可以与 -specialized domain helper 并存；unknown external、indirect、recursive nondefault -和 conflicting domain call 会被拒绝。Local Tile carrier 不得跨 domain boundary， -而 scalar/GM interface 可以跨越。native Tile 指令上的默认 `1111` mask 继承 -function domain，显式非默认 mask 必须是该 domain 的子集；producer、assembly -writer、consumer 和 compiler-generated copy 都适用。generic profile 中的保守 -`.reuse` 保留是编译器的生命周期决策，不要求应用恢复旧的手工 last-use 写法。 -使用 PE-domain 的 element-if workload 时，应 -同时验证 assembly round-trip 中的 `.pto_pe_domain`、Local Tile producer/consumer -和 element region 的 execution mask。 - -## 12. 版本与验证依据 - -本次刷新对应 LLVM #131，合入 `dev-llvm15_56` 的 commit 为 -`084bbc3119365d45b8538a6705356a9173e521eb`。编译器合同详见该版本 -`llvm/docs/PTOElementFor.rst`；对应回归包括 -`element-ordinary-call-context-alias.ll`、`element-predication-commuting-stores.ll`、 -`pto-element-generic-codegen.cpp` 和 `pe-domain-*` 测试。 - -API 具备某种 storage/view 类型不等于每个编译器 revision 都能执行该 dtype/shape -的 region。特别是 logical64/层级 storage 应分别做类型接口、target object 和 -runtime 验证，不要把 host 类型测试或其他 revision 的模型结果当成本版本完整支持。 +6. logical64 workload 使用 generic-element lowering，但不污染无关 fixture。 完整 workload 写法可参考 SuperNPUBench #202；API 类型和 assembly 细节另见 [TileOP 使用指南首页](README.md)与 diff --git a/docs/tileop-usage/elementwise-tile-tile/transcendental/TEXPDIF.md b/docs/tileop-usage/elementwise-tile-tile/transcendental/TEXPDIF.md index 18e7e100..7d0f228a 100644 --- a/docs/tileop-usage/elementwise-tile-tile/transcendental/TEXPDIF.md +++ b/docs/tileop-usage/elementwise-tile-tile/transcendental/TEXPDIF.md @@ -1,6 +1,6 @@ # TEXPDIF -`TEXPDIF` 是 PTO ISA 0.59.0 的 SFU 直接操作，对两个同形状 Local Tile +`TEXPDIF` 是 PTO ISA 0.58.7 的 SFU 直接操作，对两个同形状 Local Tile 逐元素计算 `dst = exp(src0 - src1)`。它不是 broadcast expansion，也不能用 `TSUB` 后接 `TEXP` 替代。 diff --git a/docs/tileop-usage/generated/engines.md b/docs/tileop-usage/generated/engines.md index e91aa8fe..9b511976 100644 --- a/docs/tileop-usage/generated/engines.md +++ b/docs/tileop-usage/generated/engines.md @@ -1,160 +1,141 @@ -# LinxISA v0.58 / PTO ISA 0.59.0.0 wrapper engine compatibility view +# LinxISA / PTO ISA v0.58.7 wrapper engine compatibility view 架构定义的引擎类别只有 **VEC**, **TLSU**, **CUBE**, and **SFU**。 VEC 只包含逐元素操作；SFU 包含归约、广播、变换、排序以及其他需要更复杂硬件的操作。 TEPL 仍是唯一的编译 carrier 标识。`BSTART.VEC` 和 `BSTART.SFU` 是特定引擎的汇编别名； inline wrapper 保留 `BSTART.TEPL`，以兼容之前的工具链源码。 -下表根据本仓库固定的 LinxISA v0.58 authority 投影生成（其操作清单与 PTO ISA 0.59.0.0 -发布 catalog 逐字节一致），数据记录在 +下表根据本仓库固定的 LinxISA 历史投影生成，数据记录在 [`contracts/linxisa-v0.58-engine-ops.json`](../../../contracts/linxisa-v0.58-engine-ops.json) 中。 -投影共 119 项；其中 119 项在 `include/` 有名称引用， -0 项明确没有 wrapper。名称引用不证明 ASL/NDF 语义完整实现。 ## VEC -| Golden 操作 | 规范汇编 | 逻辑 selector | 分类 | Wrapper 状态 | -| --- | --- | ---: | --- | --- | -| `TADD` | `BSTART.VEC TADD` | 0 | elementwise-tile-tile | 源码有引用；不代表完整语义一致 | -| `TSUB` | `BSTART.VEC TSUB` | 1 | elementwise-tile-tile | 源码有引用；不代表完整语义一致 | -| `TMUL` | `BSTART.VEC TMUL` | 2 | elementwise-tile-tile | 源码有引用；不代表完整语义一致 | -| `TAND` | `BSTART.VEC TAND` | 6 | elementwise-tile-tile | 源码有引用；不代表完整语义一致 | -| `TOR` | `BSTART.VEC TOR` | 7 | elementwise-tile-tile | 源码有引用；不代表完整语义一致 | -| `TXOR` | `BSTART.VEC TXOR` | 8 | elementwise-tile-tile | 源码有引用；不代表完整语义一致 | -| `TSHL` | `BSTART.VEC TSHL` | 9 | elementwise-tile-tile | 源码有引用；不代表完整语义一致 | -| `TSHR` | `BSTART.VEC TSHR` | 10 | elementwise-tile-tile | 源码有引用；不代表完整语义一致 | -| `TMAX` | `BSTART.VEC TMAX` | 11 | elementwise-tile-tile | 源码有引用；不代表完整语义一致 | -| `TMIN` | `BSTART.VEC TMIN` | 12 | elementwise-tile-tile | 源码有引用；不代表完整语义一致 | -| `TCMP` | `BSTART.VEC TCMP` | 13 | elementwise-tile-tile | 源码有引用；不代表完整语义一致 | -| `TABS` | `BSTART.VEC TABS` | 15 | elementwise-tile-tile | 源码有引用；不代表完整语义一致 | -| `TNOT` | `BSTART.VEC TNOT` | 16 | elementwise-tile-tile | 源码有引用；不代表完整语义一致 | -| `TNEG` | `BSTART.VEC TNEG` | 17 | elementwise-tile-tile | 源码有引用；不代表完整语义一致 | -| `TRELU` | `BSTART.VEC TRELU` | 23 | elementwise-tile-tile | 源码有引用；不代表完整语义一致 | -| `TSEL` | `BSTART.VEC TSEL` | 26 | elementwise-tile-tile | 源码有引用；不代表完整语义一致 | -| `TCVT` | `BSTART.VEC TCVT` | 27 | elementwise-tile-tile | 源码有引用；不代表完整语义一致 | -| `TFMA` | `BSTART.VEC TFMA` | 28 | elementwise-tile-tile | 源码有引用；不代表完整语义一致 | -| `TADDS` | `BSTART.VEC TADDS` | 32 | tile-scalar-and-immediate | 源码有引用；不代表完整语义一致 | -| `TSUBS` | `BSTART.VEC TSUBS` | 33 | tile-scalar-and-immediate | 源码有引用；不代表完整语义一致 | -| `TMULS` | `BSTART.VEC TMULS` | 34 | tile-scalar-and-immediate | 源码有引用；不代表完整语义一致 | -| `TANDS` | `BSTART.VEC TANDS` | 38 | tile-scalar-and-immediate | 源码有引用；不代表完整语义一致 | -| `TORS` | `BSTART.VEC TORS` | 39 | tile-scalar-and-immediate | 源码有引用；不代表完整语义一致 | -| `TXORS` | `BSTART.VEC TXORS` | 40 | tile-scalar-and-immediate | 源码有引用；不代表完整语义一致 | -| `TSHLS` | `BSTART.VEC TSHLS` | 41 | tile-scalar-and-immediate | 源码有引用；不代表完整语义一致 | -| `TSHRS` | `BSTART.VEC TSHRS` | 42 | tile-scalar-and-immediate | 源码有引用；不代表完整语义一致 | -| `TMAXS` | `BSTART.VEC TMAXS` | 43 | tile-scalar-and-immediate | 源码有引用；不代表完整语义一致 | -| `TMINS` | `BSTART.VEC TMINS` | 44 | tile-scalar-and-immediate | 源码有引用；不代表完整语义一致 | -| `TCMPS` | `BSTART.VEC TCMPS` | 45 | tile-scalar-and-immediate | 源码有引用；不代表完整语义一致 | -| `TSELS` | `BSTART.VEC TSELS` | 58 | tile-scalar-and-immediate | 源码有引用；不代表完整语义一致 | -| `TEXPANDS` | `BSTART.VEC TEXPANDS` | 59 | tile-scalar-and-immediate | 源码有引用；不代表完整语义一致 | -| `TLEA` | `BSTART.VEC TLEA` | 46 | tile-scalar-and-immediate | 源码有引用；不代表完整语义一致 | +| API / 操作 | 规范汇编 | 逻辑 selector | 分类 | +| --- | --- | ---: | --- | +| `TADD` | `BSTART.VEC TADD` | 0 | elementwise-tile-tile | +| `TSUB` | `BSTART.VEC TSUB` | 1 | elementwise-tile-tile | +| `TMUL` | `BSTART.VEC TMUL` | 2 | elementwise-tile-tile | +| `TAND` | `BSTART.VEC TAND` | 6 | elementwise-tile-tile | +| `TOR` | `BSTART.VEC TOR` | 7 | elementwise-tile-tile | +| `TXOR` | `BSTART.VEC TXOR` | 8 | elementwise-tile-tile | +| `TSHL` | `BSTART.VEC TSHL` | 9 | elementwise-tile-tile | +| `TSHR` | `BSTART.VEC TSHR` | 10 | elementwise-tile-tile | +| `TMAX` | `BSTART.VEC TMAX` | 11 | elementwise-tile-tile | +| `TMIN` | `BSTART.VEC TMIN` | 12 | elementwise-tile-tile | +| `TCMP` | `BSTART.VEC TCMP` | 13 | elementwise-tile-tile | +| `TABS` | `BSTART.VEC TABS` | 15 | elementwise-tile-tile | +| `TNOT` | `BSTART.VEC TNOT` | 16 | elementwise-tile-tile | +| `TNEG` | `BSTART.VEC TNEG` | 17 | elementwise-tile-tile | +| `TRELU` | `BSTART.VEC TRELU` | 23 | elementwise-tile-tile | +| `TSEL` | `BSTART.VEC TSEL` | 26 | elementwise-tile-tile | +| `TCVT` | `BSTART.VEC TCVT` | 27 | elementwise-tile-tile | +| `TFMA` | `BSTART.VEC TFMA` | 28 | elementwise-tile-tile | +| `TADDS` | `BSTART.VEC TADDS` | 32 | tile-scalar-and-immediate | +| `TSUBS` | `BSTART.VEC TSUBS` | 33 | tile-scalar-and-immediate | +| `TMULS` | `BSTART.VEC TMULS` | 34 | tile-scalar-and-immediate | +| `TANDS` | `BSTART.VEC TANDS` | 38 | tile-scalar-and-immediate | +| `TORS` | `BSTART.VEC TORS` | 39 | tile-scalar-and-immediate | +| `TXORS` | `BSTART.VEC TXORS` | 40 | tile-scalar-and-immediate | +| `TSHLS` | `BSTART.VEC TSHLS` | 41 | tile-scalar-and-immediate | +| `TSHRS` | `BSTART.VEC TSHRS` | 42 | tile-scalar-and-immediate | +| `TMAXS` | `BSTART.VEC TMAXS` | 43 | tile-scalar-and-immediate | +| `TMINS` | `BSTART.VEC TMINS` | 44 | tile-scalar-and-immediate | +| `TCMPS` | `BSTART.VEC TCMPS` | 45 | tile-scalar-and-immediate | +| `TSELS` | `BSTART.VEC TSELS` | 58 | tile-scalar-and-immediate | +| `TEXPANDS` | `BSTART.VEC TEXPANDS` | 59 | tile-scalar-and-immediate | ## SFU -| Golden 操作 | 规范汇编 | 逻辑 selector | 分类 | Wrapper 状态 | -| --- | --- | ---: | --- | --- | -| `TDIV` | `BSTART.SFU TDIV` | 3 | elementwise-tile-tile | 源码有引用；不代表完整语义一致 | -| `TREM` | `BSTART.SFU TREM` | 4 | elementwise-tile-tile | 源码有引用；不代表完整语义一致 | -| `TEXP` | `BSTART.SFU TEXP` | 18 | elementwise-tile-tile | 源码有引用；不代表完整语义一致 | -| `TLOG` | `BSTART.SFU TLOG` | 19 | elementwise-tile-tile | 源码有引用；不代表完整语义一致 | -| `TRECIP` | `BSTART.SFU TRECIP` | 20 | elementwise-tile-tile | 源码有引用；不代表完整语义一致 | -| `TSQRT` | `BSTART.SFU TSQRT` | 21 | elementwise-tile-tile | 源码有引用；不代表完整语义一致 | -| `TRSQRT` | `BSTART.SFU TRSQRT` | 22 | elementwise-tile-tile | 源码有引用；不代表完整语义一致 | -| `TDIVS` | `BSTART.SFU TDIVS` | 35 | tile-scalar-and-immediate | 源码有引用；不代表完整语义一致 | -| `TREMS` | `BSTART.SFU TREMS` | 36 | tile-scalar-and-immediate | 源码有引用；不代表完整语义一致 | -| `TROWSUM` | `BSTART.SFU TROWSUM` | 64 | reduce-and-expand | 源码有引用；不代表完整语义一致 | -| `TROWMAX` | `BSTART.SFU TROWMAX` | 65 | reduce-and-expand | 源码有引用；不代表完整语义一致 | -| `TROWMIN` | `BSTART.SFU TROWMIN` | 66 | reduce-and-expand | 源码有引用；不代表完整语义一致 | -| `TROWPROD` | `BSTART.SFU TROWPROD` | 67 | reduce-and-expand | 源码有引用；不代表完整语义一致 | -| `TROWEXPAND` | `BSTART.SFU TROWEXPAND` | 68 | reduce-and-expand | 源码有引用；不代表完整语义一致 | -| `TROWEXPANDADD` | `BSTART.SFU TROWEXPANDADD` | 69 | reduce-and-expand | 源码有引用；不代表完整语义一致 | -| `TROWEXPANDSUB` | `BSTART.SFU TROWEXPANDSUB` | 70 | reduce-and-expand | 源码有引用；不代表完整语义一致 | -| `TROWEXPANDMUL` | `BSTART.SFU TROWEXPANDMUL` | 71 | reduce-and-expand | 源码有引用；不代表完整语义一致 | -| `TROWEXPANDDIV` | `BSTART.SFU TROWEXPANDDIV` | 72 | reduce-and-expand | 源码有引用；不代表完整语义一致 | -| `TROWEXPANDMAX` | `BSTART.SFU TROWEXPANDMAX` | 73 | reduce-and-expand | 源码有引用；不代表完整语义一致 | -| `TROWEXPANDMIN` | `BSTART.SFU TROWEXPANDMIN` | 74 | reduce-and-expand | 源码有引用；不代表完整语义一致 | -| `TROWEXPANDEXPDIF` | `BSTART.SFU TROWEXPANDEXPDIF` | 75 | reduce-and-expand | 源码有引用；不代表完整语义一致 | -| `TROWARGMAX` | `BSTART.SFU TROWARGMAX` | 76 | reduce-and-expand | 源码有引用；不代表完整语义一致 | -| `TROWARGMIN` | `BSTART.SFU TROWARGMIN` | 77 | reduce-and-expand | 源码有引用；不代表完整语义一致 | -| `TCOLSUM` | `BSTART.SFU TCOLSUM` | 80 | reduce-and-expand | 源码有引用；不代表完整语义一致 | -| `TCOLMAX` | `BSTART.SFU TCOLMAX` | 81 | reduce-and-expand | 源码有引用；不代表完整语义一致 | -| `TCOLMIN` | `BSTART.SFU TCOLMIN` | 82 | reduce-and-expand | 源码有引用；不代表完整语义一致 | -| `TCOLPROD` | `BSTART.SFU TCOLPROD` | 83 | reduce-and-expand | 源码有引用；不代表完整语义一致 | -| `TCOLEXPAND` | `BSTART.SFU TCOLEXPAND` | 84 | reduce-and-expand | 源码有引用；不代表完整语义一致 | -| `TCOLEXPANDADD` | `BSTART.SFU TCOLEXPANDADD` | 85 | reduce-and-expand | 源码有引用；不代表完整语义一致 | -| `TCOLEXPANDSUB` | `BSTART.SFU TCOLEXPANDSUB` | 86 | reduce-and-expand | 源码有引用；不代表完整语义一致 | -| `TCOLEXPANDMUL` | `BSTART.SFU TCOLEXPANDMUL` | 87 | reduce-and-expand | 源码有引用；不代表完整语义一致 | -| `TCOLEXPANDDIV` | `BSTART.SFU TCOLEXPANDDIV` | 88 | reduce-and-expand | 源码有引用；不代表完整语义一致 | -| `TCOLEXPANDMAX` | `BSTART.SFU TCOLEXPANDMAX` | 89 | reduce-and-expand | 源码有引用；不代表完整语义一致 | -| `TCOLEXPANDMIN` | `BSTART.SFU TCOLEXPANDMIN` | 90 | reduce-and-expand | 源码有引用；不代表完整语义一致 | -| `TCOLEXPANDEXPDIF` | `BSTART.SFU TCOLEXPANDEXPDIF` | 91 | reduce-and-expand | 源码有引用；不代表完整语义一致 | -| `TCOLARGMAX` | `BSTART.SFU TCOLARGMAX` | 92 | reduce-and-expand | 源码有引用；不代表完整语义一致 | -| `TCOLARGMIN` | `BSTART.SFU TCOLARGMIN` | 93 | reduce-and-expand | 源码有引用；不代表完整语义一致 | -| `TCI` | `BSTART.SFU TCI` | 102 | irregular-and-complex | 源码有引用；不代表完整语义一致 | -| `TTRI` | `BSTART.SFU TTRI` | 103 | irregular-and-complex | 源码有引用；不代表完整语义一致 | -| `TGATHER` | `BSTART.SFU TGATHER` | 111 | irregular-and-complex | 源码有引用；不代表完整语义一致 | -| `TSCATTER` | `BSTART.SFU TSCATTER` | 112 | irregular-and-complex | 源码有引用；不代表完整语义一致 | -| `TPERMUTE` | `BSTART.SFU TPERMUTE` | 117 | layout-and-rearrangement | 源码有引用；不代表完整语义一致 | -| `TSHUF` | `BSTART.SFU TSHUF` | 118 | layout-and-rearrangement | 源码有引用；不代表完整语义一致 | -| `TPACK` | `BSTART.SFU TPACK` | 119 | layout-and-rearrangement | 源码有引用；不代表完整语义一致 | -| `TUNPACK` | `BSTART.SFU TUNPACK` | 120 | layout-and-rearrangement | 源码有引用；不代表完整语义一致 | -| `TGPR2T` | `BSTART.SFU TGPR2T` | 126 | layout-and-rearrangement | 源码有引用；不代表完整语义一致 | -| `TEXPDIF` | `BSTART.SFU TEXPDIF` | 29 | elementwise-tile-tile | 源码有引用；不代表完整语义一致 | +| API / 操作 | 规范汇编 | 逻辑 selector | 分类 | +| --- | --- | ---: | --- | +| `TDIV` | `BSTART.SFU TDIV` | 3 | elementwise-tile-tile | +| `TREM` | `BSTART.SFU TREM` | 4 | elementwise-tile-tile | +| `TEXP` | `BSTART.SFU TEXP` | 18 | elementwise-tile-tile | +| `TLOG` | `BSTART.SFU TLOG` | 19 | elementwise-tile-tile | +| `TRECIP` | `BSTART.SFU TRECIP` | 20 | elementwise-tile-tile | +| `TSQRT` | `BSTART.SFU TSQRT` | 21 | elementwise-tile-tile | +| `TRSQRT` | `BSTART.SFU TRSQRT` | 22 | elementwise-tile-tile | +| `TEXPDIF` | `BSTART.SFU TEXPDIF` | 29 | elementwise-tile-tile | +| `TDIVS` | `BSTART.SFU TDIVS` | 35 | tile-scalar-and-immediate | +| `TREMS` | `BSTART.SFU TREMS` | 36 | tile-scalar-and-immediate | +| `TROWSUM` | `BSTART.SFU TROWSUM` | 64 | reduce-and-expand | +| `TROWMAX` | `BSTART.SFU TROWMAX` | 65 | reduce-and-expand | +| `TROWMIN` | `BSTART.SFU TROWMIN` | 66 | reduce-and-expand | +| `TROWPROD` | `BSTART.SFU TROWPROD` | 67 | reduce-and-expand | +| `TROWEXPAND` | `BSTART.SFU TROWEXPAND` | 68 | reduce-and-expand | +| `TROWEXPANDADD` | `BSTART.SFU TROWEXPANDADD` | 69 | reduce-and-expand | +| `TROWEXPANDSUB` | `BSTART.SFU TROWEXPANDSUB` | 70 | reduce-and-expand | +| `TROWEXPANDMUL` | `BSTART.SFU TROWEXPANDMUL` | 71 | reduce-and-expand | +| `TROWEXPANDDIV` | `BSTART.SFU TROWEXPANDDIV` | 72 | reduce-and-expand | +| `TROWEXPANDMAX` | `BSTART.SFU TROWEXPANDMAX` | 73 | reduce-and-expand | +| `TROWEXPANDMIN` | `BSTART.SFU TROWEXPANDMIN` | 74 | reduce-and-expand | +| `TROWEXPANDEXPDIF` | `BSTART.SFU TROWEXPANDEXPDIF` | 75 | reduce-and-expand | +| `TROWARGMAX` | `BSTART.SFU TROWARGMAX` | 76 | reduce-and-expand | +| `TROWARGMIN` | `BSTART.SFU TROWARGMIN` | 77 | reduce-and-expand | +| `TCOLSUM` | `BSTART.SFU TCOLSUM` | 80 | reduce-and-expand | +| `TCOLMAX` | `BSTART.SFU TCOLMAX` | 81 | reduce-and-expand | +| `TCOLMIN` | `BSTART.SFU TCOLMIN` | 82 | reduce-and-expand | +| `TCOLPROD` | `BSTART.SFU TCOLPROD` | 83 | reduce-and-expand | +| `TCOLEXPAND` | `BSTART.SFU TCOLEXPAND` | 84 | reduce-and-expand | +| `TCOLEXPANDADD` | `BSTART.SFU TCOLEXPANDADD` | 85 | reduce-and-expand | +| `TCOLEXPANDSUB` | `BSTART.SFU TCOLEXPANDSUB` | 86 | reduce-and-expand | +| `TCOLEXPANDMUL` | `BSTART.SFU TCOLEXPANDMUL` | 87 | reduce-and-expand | +| `TCOLEXPANDDIV` | `BSTART.SFU TCOLEXPANDDIV` | 88 | reduce-and-expand | +| `TCOLEXPANDMAX` | `BSTART.SFU TCOLEXPANDMAX` | 89 | reduce-and-expand | +| `TCOLEXPANDMIN` | `BSTART.SFU TCOLEXPANDMIN` | 90 | reduce-and-expand | +| `TCOLEXPANDEXPDIF` | `BSTART.SFU TCOLEXPANDEXPDIF` | 91 | reduce-and-expand | +| `TCOLARGMAX` | `BSTART.SFU TCOLARGMAX` | 92 | reduce-and-expand | +| `TCOLARGMIN` | `BSTART.SFU TCOLARGMIN` | 93 | reduce-and-expand | +| `TCONCAT` | `BSTART.SFU TCONCAT` | 96 | layout-and-rearrangement | +| `TEXTRACT` | `BSTART.SFU TEXTRACT` | 98 | layout-and-rearrangement | +| `TINSERT` | `BSTART.SFU TINSERT` | 99 | layout-and-rearrangement | +| `TIMG2COL` | `BSTART.SFU TIMG2COL` | 100 | layout-and-rearrangement | +| `TCI` | `BSTART.SFU TCI` | 102 | irregular-and-complex | +| `TTRI` | `BSTART.SFU TTRI` | 103 | irregular-and-complex | +| `THISTOGRAM` | `BSTART.SFU THISTOGRAM` | 104 | irregular-and-complex | +| `TQUANT` | `BSTART.SFU TQUANT` | 106 | irregular-and-complex | +| `TDEQUANT` | `BSTART.SFU TDEQUANT` | 107 | irregular-and-complex | +| `TSORT` | `BSTART.SFU TSORT` | 108 | irregular-and-complex | +| `TMRGSORT` | `BSTART.SFU TMRGSORT` | 109 | irregular-and-complex | +| `TGATHER` | `BSTART.SFU TGATHER` | 111 | irregular-and-complex | +| `TSCATTER` | `BSTART.SFU TSCATTER` | 112 | irregular-and-complex | ## TLSU -| Golden 操作 | 规范 block 起始指令 | Function | Wrapper 状态 | -| --- | --- | ---: | --- | -| `TLOAD` | `BSTART.TLOAD` | 0 | 源码有引用；不代表完整语义一致 | -| `TSTORE` | `BSTART.TSTORE` | 1 | 源码有引用；不代表完整语义一致 | -| `TMOV` | `BSTART.TMOV` | 2 | 源码有引用；不代表完整语义一致 | -| `TPREFETCH` | `BSTART.TPREFETCH` | 3 | 源码有引用；不代表完整语义一致 | -| `MGATHER` | `BSTART.MGATHER` | 4 | 源码有引用；不代表完整语义一致 | -| `MSCATTER` | `BSTART.MSCATTER` | 5 | 源码有引用；不代表完整语义一致 | -| `MGATHER_MASK` | `BSTART.MGATHER.MASK` | 6 | 源码有引用；不代表完整语义一致 | -| `MSCATTER_MASK` | `BSTART.MSCATTER.MASK` | 7 | 源码有引用；不代表完整语义一致 | -| `MGATHER_CAS` | `BSTART.MGATHER.CAS` | 8 | 源码有引用；不代表完整语义一致 | -| `GMOV` | `BSTART.GMOV` | 13 | 源码有引用；不代表完整语义一致 | -| `MGATHER_EXCH` | `BSTART.MGATHER.EXCH` | 9 | 源码有引用；不代表完整语义一致 | -| `MGATHER_MAX` | `BSTART.MGATHER.MAX` | 10 | 源码有引用；不代表完整语义一致 | -| `MGATHER_MIN` | `BSTART.MGATHER.MIN` | 11 | 源码有引用；不代表完整语义一致 | -| `MGATHER_ADD` | `BSTART.MGATHER.ADD` | 12 | 源码有引用；不代表完整语义一致 | -| `MGATHER_INC` | `BSTART.MGATHER.INC` | 14 | 源码有引用；不代表完整语义一致 | -| `MGATHER_DEC` | `BSTART.MGATHER.DEC` | 15 | 源码有引用；不代表完整语义一致 | -| `MGATHER_AND` | `BSTART.MGATHER.AND` | 16 | 源码有引用；不代表完整语义一致 | -| `MGATHER_OR` | `BSTART.MGATHER.OR` | 17 | 源码有引用；不代表完整语义一致 | -| `MGATHER_XOR` | `BSTART.MGATHER.XOR` | 18 | 源码有引用；不代表完整语义一致 | -| `MSCATTER_MAX` | `BSTART.MSCATTER.MAX` | 19 | 源码有引用；不代表完整语义一致 | -| `MSCATTER_MIN` | `BSTART.MSCATTER.MIN` | 20 | 源码有引用；不代表完整语义一致 | -| `MSCATTER_ADD` | `BSTART.MSCATTER.ADD` | 21 | 源码有引用；不代表完整语义一致 | -| `MSCATTER_INC` | `BSTART.MSCATTER.INC` | 22 | 源码有引用；不代表完整语义一致 | -| `MSCATTER_DEC` | `BSTART.MSCATTER.DEC` | 23 | 源码有引用；不代表完整语义一致 | -| `MSCATTER_AND` | `BSTART.MSCATTER.AND` | 24 | 源码有引用；不代表完整语义一致 | -| `MSCATTER_OR` | `BSTART.MSCATTER.OR` | 25 | 源码有引用；不代表完整语义一致 | -| `MSCATTER_XOR` | `BSTART.MSCATTER.XOR` | 26 | 源码有引用；不代表完整语义一致 | -| `MSCATTER_POPC` | `BSTART.MSCATTER.POPC` | 27 | 源码有引用；不代表完整语义一致 | +| 操作 | 规范 block 起始指令 | Function | +| --- | --- | ---: | +| `TLOAD` | `BSTART.TLSU TLOAD` | 0 | +| `TSTORE` | `BSTART.TLSU TSTORE` | 1 | +| `TMOV` | `BSTART.TLSU TMOV` | 2 | +| `TPREFETCH` | `BSTART.TLSU TPREFETCH` | 3 | +| `MGATHER` | `BSTART.TLSU MGATHER` | 4 | +| `MSCATTER` | `BSTART.TLSU MSCATTER` | 5 | +| `MGATHER_MASK` | `BSTART.TLSU MGATHER.MASK` | 6 | +| `MSCATTER_MASK` | `BSTART.TLSU MSCATTER.MASK` | 7 | +| `MGATHER_CAS` | `BSTART.TLSU MGATHER.CAS` | 8 | +| `GMOV` | `BSTART.GMOV` | 13 | ## CUBE -| Golden 操作 | 规范 block 起始指令 | Function | Wrapper 状态 | -| --- | --- | ---: | --- | -| `TMATMUL` | `BSTART.TMATMUL` | 0 | 源码有引用；不代表完整语义一致 | -| `TMATMUL_BIAS` | `BSTART.TMATMUL.BIAS` | 1 | 源码有引用；不代表完整语义一致 | -| `TMATMUL_ACC` | `BSTART.TMATMUL.ACC` | 2 | 源码有引用；不代表完整语义一致 | -| `TMATMUL_MX` | `BSTART.TMATMULMX` | 4 | 源码有引用；不代表完整语义一致 | -| `TMATMUL_MX_BIAS` | `BSTART.TMATMULMX.BIAS` | 5 | 源码有引用；不代表完整语义一致 | -| `TMATMUL_MX_ACC` | `BSTART.TMATMULMX.ACC` | 6 | 源码有引用；不代表完整语义一致 | -| `TGEMV` | `BSTART.TGEMV` | 16 | 源码有引用；不代表完整语义一致 | -| `TGEMV_BIAS` | `BSTART.TGEMV.BIAS` | 17 | 源码有引用；不代表完整语义一致 | -| `TGEMV_ACC` | `BSTART.TGEMV.ACC` | 18 | 源码有引用；不代表完整语义一致 | -| `TGEMV_MX` | `BSTART.TGEMVMX` | 20 | 源码有引用；不代表完整语义一致 | -| `TGEMV_MX_BIAS` | `BSTART.TGEMVMX.BIAS` | 21 | 源码有引用；不代表完整语义一致 | -| `TGEMV_MX_ACC` | `BSTART.TGEMVMX.ACC` | 22 | 源码有引用；不代表完整语义一致 | +| 操作 | 规范 block 起始指令 | Function | +| --- | --- | ---: | +| `TMATMUL` | `BSTART.CUBE TMATMUL` | 0 | +| `TMATMUL_BIAS` | `BSTART.CUBE TMATMUL.BIAS` | 1 | +| `TMATMUL_ACC` | `BSTART.CUBE TMATMUL.ACC` | 2 | +| `TMATMUL_MX` | `BSTART.CUBE TMATMULMX` | 4 | +| `TMATMUL_MX_BIAS` | `BSTART.CUBE TMATMULMX.BIAS` | 5 | +| `TMATMUL_MX_ACC` | `BSTART.CUBE TMATMULMX.ACC` | 6 | +| `TGEMV` | `BSTART.CUBE TGEMV` | 16 | +| `TGEMV_BIAS` | `BSTART.CUBE TGEMV.BIAS` | 17 | +| `TGEMV_ACC` | `BSTART.CUBE TGEMV.ACC` | 18 | +| `TGEMV_MX` | `BSTART.CUBE TGEMVMX` | 20 | +| `TGEMV_MX_BIAS` | `BSTART.CUBE TGEMVMX.BIAS` | 21 | +| `TGEMV_MX_ACC` | `BSTART.CUBE TGEMVMX.ACC` | 22 | ## 分类语义 -PTO ISA 0.59.0 将执行引擎与操作分类解耦。本表是 wrapper compatibility view； -其底层投影记录 LinxISA v0.58 authority 的 selector 数据（与 0.59.0.0 发布 catalog 一致）。 -`elementwise-tile-tile` +PTO ISA 0.58.7 将执行引擎与操作分类解耦。本表是 wrapper compatibility view； +其底层投影仍保留历史版本的 selector 数据。`elementwise-tile-tile` 和 `tile-scalar-and-immediate` 类别在 VEC 上执行逐元素操作，但其中的 `TEXP`、`TLOG`、`TRECIP`、`TSQRT`、`TRSQRT` 由 SFU 执行。 `reduce-and-expand`、`layout-and-rearrangement` 和 `irregular-and-complex` 类别由 SFU 执行。 @@ -163,7 +144,7 @@ PTO ISA 0.59.0 将执行引擎与操作分类解耦。本表是 wrapper compatib ## 早期版本中移除的操作 -历史版本还提供了一些已从 PTO 0.59.0 active catalog 移除的 Tile 操作（例如 ACC 风格的后处理辅助操作）。 +历史版本还提供了一些已从 PTO 0.58.7 active catalog 移除的 Tile 操作（例如 ACC 风格的后处理辅助操作）。 本库不会把已退役的操作生成到当前目录；退役名称的规范列表记录在 contract 的 `deleted_tile_names` 字段中。 ## 使用示例 diff --git a/docs/tileop-usage/irregular-and-complex/format-conversion/TDEQUANT.md b/docs/tileop-usage/irregular-and-complex/format-conversion/TDEQUANT.md index 61b683b8..c67b6ed7 100644 --- a/docs/tileop-usage/irregular-and-complex/format-conversion/TDEQUANT.md +++ b/docs/tileop-usage/irregular-and-complex/format-conversion/TDEQUANT.md @@ -1,7 +1,119 @@ -# TDEQUANT（仅历史参考） +# TDEQUANT (unreleased) -`TDEQUANT` 已从 PTO ISA 0.59.0 active Tile catalog 删除。旧 SFU/TEPL -selector 107 不得由当前 wrapper 或手写别名发出。 +`TDEQUANT` 对每个有效的 S8 或 U8 源元素计算 FP32 结果 `(q - zero_point) * multiplier`。 -本仓库只保留 `TDEQUANT(...)` 名称用于模板实例化时给出稳定的编译错误；它不是 -可执行 wrapper。需要反量化时应使用当前 golden 定义的矩阵后处理或软件序列。 +## C++ 接口 + +当前 API 中可用的调用形式： + +```text +template < + RoundMode Mode = RoundMode::RNE, + is_tile_data_v tile_shape_out, + is_tile_data_v tile_shape_in> +void TDEQUANT( + tile_shape_out &dst, + tile_shape_in &src, + float multiplier = 1.0f, + int32_t zeroPoint = 0); +template +void TDEQUANT(tile_shape_out &dst, tile_shape_in &src); +``` + +### 支持的数据类型 + +支持源 Tile 类型 S8、U8；支持目标 Tile 类型 FP32。 + + + +### 参数说明 + +| 参数 | 说明 | +| --- | --- | +| `dst` | 输出 Tile；成功调用后写入操作结果。 | +| `src` | 输入 Tile 或源数据。 | +| `multiplier` | 量化或反量化使用的乘数。 | +| `zeroPoint` | 量化使用的零点。 | + +### 重载选择 + +这些重载覆盖不同的 Tile location、返回方式或可选操作数。优先选择参数最少且能表达当前数据流的形式；不要通过传入无意义的零值来模拟另一个重载。 + + +## 使用要求 + +- Tile 类型必须满足接口模板约束； +- 数据类型、形状、有效区域、布局、容量和存储位置必须满足该操作要求； +- 输入 Tile 必须已初始化，输出 Tile 必须具有足够容量； +- 参数顺序必须与接口声明一致，不要添加接口未声明的操作数。 + +## 约束 + +输入与输出的 Tile location、layout、dtype、物理 shape 和 valid region 必须满足该操作的 逐项规则；除非本页明确允许，不应假定可原地执行或允许 alias。 + + 操作数角色、数据类型组合、容量、PE mask 和 alias 必须符合上方约束；只能使用所选重载声明的操作数形式。 + +### 有效区域与 padding + +| 项目 | 规则 | +| --- | --- | +| 有效元素 | 逐元素操作通常仅对输入和输出共同的有效区域定义结果；未明确规定的 padding 不应读取或依赖。 | +| 物理容量 / SizeCode | 只决定容量，不重新定义逻辑 shape。 | +| 输出 padding | 除非本操作明确规定填充值或传播规则，否则视为不可依赖。 | + + + +## 默认值 + + 以下是 C++ 声明中可直接省略的默认实参： + +| 参数 | 默认值 | +| --- | --- | +| `multiplier` | `1.0f` | +| `zeroPoint` | `0` | + +### 编码字段和省略值 + +- `LB0` 给出 `ValidCol`，必须存在且非零；省略 `LB1` 时 `ValidRow=1`，省略 `LB2` 时物理列数等于 `ValidCol`。显式给出的维度不能为零。 +- 省略 `B.IOR` 时使用本操作规定的寄存器或控制默认值；显式编码为零表示实际的零值，不等同于省略该描述符。 +- 物理 padding 始终使用 `Null`。 + +`fixp::Options` 内部字段的默认值和合法组合见 [Options 指南](../../options.md)。 + +## 异常和边界行为 + + 类型不匹配、非法形状或布局、未初始化的输入、输出容量不足、非法 PE mask、错误的 Tile 位置或不合法的属性组合，会在编译期或执行前检查阶段被拒绝。`PE_MASK=0000` 时操作不产生状态或内存影响；非法调用不会发布部分输出或部分副作用。padding、alias、NaN/无穷值及 fault 行为以本页已经列出的约束和边界说明为准，未明确声明的状态不可依赖。 + +## 结果说明 + + 成功调用后，`TDEQUANT` 更新输出 Tile 的有效区域；输入 Tile 通常保持不变，输出 padding 和未明确声明的副作用不可依赖。若操作的约束或参数说明另有规定，以对应说明为准。 + +## Bundle 组成 + +开发者通常直接调用 C++ 接口，无需手工编写 bundle。下面保留对应汇编结构供核对： + +```asm +BSTART.SFU TDEQUANT, S8|U8 +B.DATR FP32, RMode +B.DIM rValidCol, 0, ->LB0 +B.DIM rValidRow, 0, ->LB1 ; (optional, default 1) +B.DIM rCol, 0, ->LB2 ; (optional, default ValidCol) +B.IOR MultiplierFP32, ZeroPoint (optional; omission selects 1.0 and 0) +B.IOT SrcTile, mask=PE_MASK, last, ->DstTile +BSTOP +``` + +## 使用示例 + +```text +#include + +using namespace pto; +using InputTile = Tile; +using OutputTile = Tile; +InputTile src; +OutputTile dst; +TDEQUANT(dst, src, 2.0f, 0); +``` + +涉及标量、索引、scale 或 bias 的操作，请按上方实际重载替换示例参数。 \ No newline at end of file diff --git a/docs/tileop-usage/irregular-and-complex/format-conversion/TQUANT.md b/docs/tileop-usage/irregular-and-complex/format-conversion/TQUANT.md index 425e4e54..25769c04 100644 --- a/docs/tileop-usage/irregular-and-complex/format-conversion/TQUANT.md +++ b/docs/tileop-usage/irregular-and-complex/format-conversion/TQUANT.md @@ -1,7 +1,115 @@ -# TQUANT（仅历史参考） +# TQUANT (unreleased) -`TQUANT` 已从 PTO ISA 0.59.0 active Tile catalog 删除。旧 SFU/TEPL -selector 106 不得由当前 wrapper 或手写别名发出。 +`TQUANT` 对 Local FP32 Tile 执行仿射量化，生成新的 Local S8 或 U8 Tile。 -本仓库只保留 `TQUANT(...)` 名称用于模板实例化时给出稳定的编译错误；它不是 -可执行 wrapper。需要量化时应使用当前 golden 定义的矩阵后处理或软件序列。 +## C++ 接口 + +当前 API 中可用的调用形式： + +```text +template < + RoundMode Mode = RoundMode::RNE, + bool Saturate = false, + is_tile_data_v tile_shape_out, + is_tile_data_v tile_shape_in> +void TQUANT( + tile_shape_out &dst, + tile_shape_in &src, + float multiplier = 1.0f, + int32_t zeroPoint = 0); +``` + +### 支持的数据类型 + +支持源 Tile 类型 FP32；支持目标 Tile 类型 S8、U8。 + + + +### 参数说明 + +| 参数 | 说明 | +| --- | --- | +| `dst` | 输出 Tile；成功调用后写入操作结果。 | +| `src` | 输入 Tile 或源数据。 | +| `multiplier` | 量化或反量化使用的乘数。 | +| `zeroPoint` | 量化使用的零点。 | + + + +## 使用要求 + +- Tile 类型必须满足接口模板约束； +- 数据类型、形状、有效区域、布局、容量和存储位置必须满足该操作要求； +- 输入 Tile 必须已初始化，输出 Tile 必须具有足够容量； +- 参数顺序必须与接口声明一致，不要添加接口未声明的操作数。 + +## 约束 + +输入与输出的 Tile location、layout、dtype、物理 shape 和 valid region 必须满足该操作的 逐项规则；除非本页明确允许，不应假定可原地执行或允许 alias。 + + 操作数角色、数据类型组合、容量、PE mask 和 alias 必须符合上方约束；只能使用所选重载声明的操作数形式。 + +### 有效区域与 padding + +| 项目 | 规则 | +| --- | --- | +| 有效元素 | 逐元素操作通常仅对输入和输出共同的有效区域定义结果；未明确规定的 padding 不应读取或依赖。 | +| 物理容量 / SizeCode | 只决定容量，不重新定义逻辑 shape。 | +| 输出 padding | 除非本操作明确规定填充值或传播规则，否则视为不可依赖。 | + + + +## 默认值 + + 以下是 C++ 声明中可直接省略的默认实参： + +| 参数 | 默认值 | +| --- | --- | +| `multiplier` | `1.0f` | +| `zeroPoint` | `0` | + +### 编码字段和省略值 + +- `LB0` 给出 `ValidCol`，必须存在且非零；省略 `LB1` 时 `ValidRow=1`，省略 `LB2` 时物理列数等于 `ValidCol`。显式给出的维度不能为零。 +- 省略 `B.IOR` 时使用本操作规定的寄存器或控制默认值；显式编码为零表示实际的零值，不等同于省略该描述符。 +- 物理 padding 始终使用 `Null`。 + +`fixp::Options` 内部字段的默认值和合法组合见 [Options 指南](../../options.md)。 + +## 异常和边界行为 + + 类型不匹配、非法形状或布局、未初始化的输入、输出容量不足、非法 PE mask、错误的 Tile 位置或不合法的属性组合，会在编译期或执行前检查阶段被拒绝。`PE_MASK=0000` 时操作不产生状态或内存影响；非法调用不会发布部分输出或部分副作用。padding、alias、NaN/无穷值及 fault 行为以本页已经列出的约束和边界说明为准，未明确声明的状态不可依赖。 + +## 结果说明 + + 成功调用后，`TQUANT` 更新输出 Tile 的有效区域；输入 Tile 通常保持不变，输出 padding 和未明确声明的副作用不可依赖。若操作的约束或参数说明另有规定，以对应说明为准。 + +## Bundle 组成 + +开发者通常直接调用 C++ 接口，无需手工编写 bundle。下面保留对应汇编结构供核对： + +```asm +BSTART.SFU TQUANT, FP32 +B.DATR S8|U8, RMode, Sat +B.DIM rValidCol, 0, ->LB0 +B.DIM rValidRow, 0, ->LB1 ; (optional, default 1) +B.DIM rCol, 0, ->LB2 ; (optional, default ValidCol) +B.IOR MultiplierFP32, ZeroPoint (optional; omission selects 1.0 and 0) +B.IOT SrcTile, mask=PE_MASK, last, ->DstTile +BSTOP +``` + +## 使用示例 + +```text +#include + +using namespace pto; +using InputTile = Tile; +using OutputTile = Tile; +InputTile src; +OutputTile dst; +TQUANT(dst, src, 0.5f, 1); +``` + +涉及标量、索引、scale 或 bias 的操作，请按上方实际重载替换示例参数。 \ No newline at end of file diff --git a/docs/tileop-usage/irregular-and-complex/initialization/THISTOGRAM.md b/docs/tileop-usage/irregular-and-complex/initialization/THISTOGRAM.md index a27f01b2..05738ba1 100644 --- a/docs/tileop-usage/irregular-and-complex/initialization/THISTOGRAM.md +++ b/docs/tileop-usage/irregular-and-complex/initialization/THISTOGRAM.md @@ -1,7 +1,116 @@ -# THISTOGRAM（仅历史参考） +# THISTOGRAM (unreleased) -`THISTOGRAM` 已从 PTO ISA 0.59.0 active Tile catalog 删除，当前没有可分配的 -SFU/TEPL selector。 +`THISTOGRAM` 为每个源行构造包含 256 个 U32 bin 的前缀直方图。 -本仓库只保留 `THISTOGRAM(...)` 名称用于模板实例化时给出稳定的编译错误；它不是 -可执行 wrapper，也没有 PTO ISA 0.59.0 bundle 组成。 +## C++ 接口 + +当前 API 中可用的调用形式： + +```text +template +void THISTOGRAM(tile_shape_out &dst, tile_shape_in &src, tile_shape_in &Idx, int ByteId); +``` + +### 支持的数据类型 + +支持U32、U16类型。 + + + +### 参数说明 + +| 参数 | 说明 | +| --- | --- | +| `dst` | 输出 Tile；成功调用后写入操作结果。 | +| `src` | 输入 Tile 或源数据。 | +| `Idx` | 索引 Tile 或索引描述符；其 dtype 和范围由对应重载约束。 | +| `ByteId` | 按字节寻址的标识或偏移；不得与元素索引混用。 | + + + +## 使用要求 + +- Tile 类型必须满足接口模板约束； +- 数据类型、形状、有效区域、布局、容量和存储位置必须满足该操作要求； +- 输入 Tile 必须已初始化，输出 Tile 必须具有足够容量； +- 参数顺序必须与接口声明一致，不要添加接口未声明的操作数。 + +## 约束 + +输入与输出的 Tile location、layout、dtype、物理 shape 和 valid region 必须满足该操作的 逐项规则；除非本页明确允许，不应假定可原地执行或允许 alias。 + +### 数据规模与结果形状限制 + +- 每个源行的结果固定包含 **256 个 U32 bin**，因此输出 Tile 的 `ValidCol` 必须为 **256**。 +- 输出 Tile 的 `ValidRow` 必须等于源 Tile 的 `ValidRow`；物理 `Row` 至少能够容纳该行数，物理 `Col` 至少能够容纳 256 个 bin。 +- 输出 Tile 必须具有足够容量，且必须与源 Tile、filter Tile 分离；容量不足或结果形状不匹配时，操作在产生结果前被拒绝。 +- 源 Tile 必须为 RowMajor 的 U16 或 U32 Local Tile，filter Tile 必须为 U8 Local Tile。U16 源仅允许 `ByteId=0` 或 `1`；U32 源允许 `ByteId=0..3`。 +- 对 U16，`ByteId=0` 需要每个源行的 filter `[row,0]`，`ByteId=1` 不读取 filter；对 U32，`ByteId=0..2` 分别需要长度为 3、2、1 的全局前缀 filter，`ByteId=3` 不筛选。 + + 操作数角色、数据类型组合、容量、PE mask 和 alias 必须符合上方约束；只能使用所选重载声明的操作数形式。 + +### 有效区域与 padding + +| 项目 | 规则 | +| --- | --- | +| 有效元素 | 逐元素操作通常仅对输入和输出共同的有效区域定义结果；未明确规定的 padding 不应读取或依赖。 | +| 物理容量 / SizeCode | 只决定容量，不重新定义逻辑 shape。 | +| 输出 padding | 除非本操作明确规定填充值或传播规则，否则视为不可依赖。 | + + + +## 默认值 + + 此页面列出的 C++ 形参没有默认实参；不要把省略某个操作数与传入零值视为等价。 + +### 编码字段和省略值 + +- `B.IOR` 是必需描述符；未使用的选择器和字段必须编码为零。 +- 物理 padding 始终使用 `Null`。 + +`fixp::Options` 内部字段的默认值和合法组合见 [Options 指南](../../options.md)。 + +## 异常和边界行为 + + 类型不匹配、非法形状或布局、未初始化的输入、输出容量不足、非法 PE mask、错误的 Tile 位置或不合法的属性组合，会在编译期或执行前检查阶段被拒绝。`PE_MASK=0000` 时操作不产生状态或内存影响；非法调用不会发布部分输出或部分副作用。padding、alias、NaN/无穷值及 fault 行为以本页已经列出的约束和边界说明为准，未明确声明的状态不可依赖。 + +## 结果说明 + + 成功调用后，`THISTOGRAM` 更新输出 Tile 的有效区域；输入 Tile 通常保持不变，输出 padding 和未明确声明的副作用不可依赖。若操作的约束或参数说明另有规定，以对应说明为准。 + +## Bundle 组成 + +开发者通常直接调用 C++ 接口，无需手工编写 bundle。下面保留对应汇编结构供核对： + +```asm +BSTART.SFU THISTOGRAM, U16|U32 +B.DATR DstDataType=U32, ByteId=0..3 (mandatory) +B.IOT SourceTile, FilterTile, mask=PE_MASK, last, ->DstTile +BSTOP +``` + +## 使用示例 + +```text +#include + +using namespace pto; +using Samples = Tile; +using Histogram = Tile; +using GMSamples = global_tensor>; +using GMHistogram = global_tensor>; + +void histogram_rows(uint32_t *out, const uint32_t *input) { + GMSamples input_gm(input); + GMHistogram out_gm(out); + Samples src, filter; + Histogram dst; + TLOAD(src, input_gm); + TLOAD(filter, input_gm); + // 当前 C++ API 的 Idx 参数与 src 共用 tile_shape_in；U32 ByteId=3 不筛选。 + THISTOGRAM(dst, src, filter, 3); + TSTORE(out_gm, dst); +} +``` + +涉及标量、索引、scale 或 bias 的操作，请按上方实际重载替换示例参数。 \ No newline at end of file diff --git a/docs/tileop-usage/irregular-and-complex/sorting/TMRGSORT.md b/docs/tileop-usage/irregular-and-complex/sorting/TMRGSORT.md index d4566ff3..61925e4a 100644 --- a/docs/tileop-usage/irregular-and-complex/sorting/TMRGSORT.md +++ b/docs/tileop-usage/irregular-and-complex/sorting/TMRGSORT.md @@ -1,7 +1,120 @@ -# TMRGSORT（仅历史参考） +# TMRGSORT (unreleased) -`TMRGSORT` 已从 PTO ISA 0.59.0 active Tile catalog 删除。旧 SFU/TEPL -selector 109 不得由当前 wrapper 或手写别名发出。 +`TMRGSORT` 稳定合并两个已排序的单行 Local RowMajor 数据流。 -本仓库只保留 `TMRGSORT(...)` 名称用于模板实例化时给出稳定的编译错误；它不是 -可执行 wrapper，也没有 PTO ISA 0.59.0 bundle 组成。 +## C++ 接口 + +当前 API 中可用的调用形式： + +```text +template +void TMRGSORT(DstTile &dst, LeftTile &left, RightTile &right, bool descending = false); +``` + +### 支持的数据类型 + +支持FP32、FP16类型。 + +| 操作数角色 | 类型要求 | +| --- | --- | +值输入 / 值输出 | 支持FP32、FP16 类型，三者 dtype 必须一致。 +| 索引输出 | 本接口没有索引输出；如需值和 U32 组内索引，使用 `TSORT`。 | + +### 参数说明 + +| 参数 | 说明 | +| --- | --- | +| `dst` | 输出 Tile；成功调用后写入操作结果。 | +| `left` | 左输入 Tile。 | +| `right` | 右输入 Tile。 | +| `descending` | 排序方向；`false`（默认）为升序，`true` 为降序；稳定性不因方向改变。 | + + + +## 使用要求 + +- Tile 类型必须满足接口模板约束； +- 数据类型、形状、有效区域、布局、容量和存储位置必须满足该操作要求； +- 输入 Tile 必须已初始化，输出 Tile 必须具有足够容量； +- 参数顺序必须与接口声明一致，不要添加接口未声明的操作数。 + +## 约束 + +三个 Tile 必须都是 Vector Local、非 boxed 的 RowMajor Tile，且物理行数均为 +`1`。两个 source 的 valid columns 必须非零；`dst` 的 valid columns 必须等于 +两者 valid columns 之和，且 `dst` physical columns 足以容纳该结果。physical columns +还必须是 2 的幂，且 `dst.Cols / 2 < combined_valid_columns`。输入各自必须已按 +相同方向排序；`TMRGSORT` 不会执行预排序。 + + 操作数角色、数据类型组合、容量、PE mask 和 alias 必须符合上方约束；只能使用所选重载声明的操作数形式。 + +### 有效区域与 padding + +| 项目 | 规则 | +| --- | --- | +| 有效元素 | 仅合并两个 source 的有效列，输出 valid shape 为 `1 x (L + R)`；padding 不参与合并。 | +| 物理容量 / SizeCode | 只决定容量，不重新定义逻辑 shape。 | +| 输出 padding | 除非本操作明确规定填充值或传播规则，否则视为不可依赖。 | + + + +## 默认值 + + 以下是 C++ 声明中可直接省略的默认实参： + +| 参数 | 默认值 | +| --- | --- | +| `descending` | `false` | + +### 编码字段和省略值 + +- 省略 `B.DATR` 时使用该操作规定的默认编码；若显式提供该描述符，未使用的字段必须保持为零。 +- 省略 `B.IOR` 时使用本操作规定的寄存器或控制默认值；显式编码为零表示实际的零值，不等同于省略该描述符。 +- 物理 padding 始终使用 `Null`。 + +`fixp::Options` 内部字段的默认值和合法组合见 [Options 指南](../../options.md)。 + +## 异常和边界行为 + + 类型不匹配、非法形状或布局、未初始化的输入、输出容量不足、非法 PE mask、错误的 Tile 位置或不合法的属性组合，会在编译期或执行前检查阶段被拒绝。`PE_MASK=0000` 时操作不产生状态或内存影响；非法调用不会发布部分输出或部分副作用。padding、alias、NaN/无穷值及 fault 行为以本页已经列出的约束和边界说明为准，未明确声明的状态不可依赖。 + +## 结果说明 + + 成功调用后，`TMRGSORT` 更新输出 Tile 的有效区域；输入 Tile 通常保持不变，输出 padding 和未明确声明的副作用不可依赖。若操作的约束或参数说明另有规定，以对应说明为准。 + +## Bundle 组成 + +开发者通常直接调用 C++ 接口，无需手工编写 bundle。下面保留对应汇编结构供核对： + +```asm +BSTART.SFU TMRGSORT, FP32|FP16 +B.DATR all-zero (optional) +B.IOR Descending (optional; omission defaults to ascending) +B.IOT two Local sources and one new Local destination, common PE_MASK, last +BSTOP +``` + +## 使用示例 + +```text +#include + +using namespace pto; +using SortedHalf = Tile; +using SortedFull = Tile; +using GMHalf128 = global_tensor<__half, RowMajor<1, 128>>; +using GMHalf256 = global_tensor<__half, RowMajor<1, 256>>; + +void merge_sorted(__half *out, const __half *left_ptr, const __half *right_ptr) { + GMHalf128 left_gm(left_ptr), right_gm(right_ptr); + GMHalf256 out_gm(out); + SortedHalf left, right; + SortedFull dst; + TLOAD(left, left_gm); + TLOAD(right, right_gm); + TMRGSORT(dst, left, right, false); + TSTORE(out_gm, dst); +} +``` + +涉及标量、索引、scale 或 bias 的操作，请按上方实际重载替换示例参数。 \ No newline at end of file diff --git a/docs/tileop-usage/irregular-and-complex/sorting/TSORT.md b/docs/tileop-usage/irregular-and-complex/sorting/TSORT.md index dfa7d9ce..13f6bf92 100644 --- a/docs/tileop-usage/irregular-and-complex/sorting/TSORT.md +++ b/docs/tileop-usage/irregular-and-complex/sorting/TSORT.md @@ -1,7 +1,125 @@ -# TSORT（仅历史参考） +# TSORT (unreleased) -`TSORT` 已从 PTO ISA 0.59.0 active Tile catalog 删除。旧 SFU/TEPL -selector 108 不得由当前 wrapper 或手写别名发出。 +`TSORT` 稳定地排序相互独立的行组，并发布带有组内原始 U32 索引的值。 -本仓库只保留 `TSORT(...)` 与 `TSORT32(...)` 名称用于模板实例化时给出稳定的 -编译错误；它们不是可执行 wrapper，也没有 PTO ISA 0.59.0 bundle 组成。 +## C++ 接口 + +当前 API 中可用的调用形式： + +```text +template +void TSORT( + ValueDstTile &valueDst, + IndexDstTile &indexDst, + SourceTile &source, + uint32_t sortWidth = 32, + bool descending = false); +``` + +### 支持的数据类型 + +支持FP32、FP16类型。 + +| 操作数角色 | 类型要求 | +| --- | --- | +| 值输入 / 值输出 | 支持FP32、FP16类型。 | +| 索引输出 | `U32`，保存组内原始位置。 | + +### 参数说明 + +| 参数 | 说明 | +| --- | --- | +| `valueDst` | 排序后的值输出 Tile；shape 与 source 相同。 | +| `indexDst` | U32 索引输出 Tile；每个元素保存其在原行组内的原始索引。 | +| `source` | 输入 Tile 或源数据。 | +| `sortWidth` | 每个独立行组的宽度；默认 32，必须满足该操作规定的分组宽度和源 Tile 列数约束。 | +| `descending` | 排序方向；`false`（默认）为升序，`true` 为降序；稳定性不因方向改变。 | + + + +## 使用要求 + +- Tile 类型必须满足接口模板约束； +- 数据类型、形状、有效区域、布局、容量和存储位置必须满足该操作要求； +- 输入 Tile 必须已初始化，输出 Tile 必须具有足够容量； +- 参数顺序必须与接口声明一致，不要添加接口未声明的操作数。 + +## 约束 + +排序输出值与输入的有效区域对应；索引输出使用 U32 的组内原始位置。排序宽度、行组形状和 输入的已排序前提（仅 merge sort）必须满足该操作定义。 + + 操作数角色、数据类型组合、容量、PE mask 和 alias 必须符合上方约束；只能使用所选重载声明的操作数形式。 + +### 有效区域与 padding + +| 项目 | 规则 | +| --- | --- | +| 有效元素 | 仅在各独立行组的有效范围内排序或合并；索引以该有效行组为基准。 | +| 物理容量 / SizeCode | 只决定容量，不重新定义逻辑 shape。 | +| 输出 padding | 除非本操作明确规定填充值或传播规则，否则视为不可依赖。 | + + + +## 默认值 + + 以下是 C++ 声明中可直接省略的默认实参： + +| 参数 | 默认值 | +| --- | --- | +| `sortWidth` | `32` | +| `descending` | `false` | + +### 编码字段和省略值 + +- 省略 `B.DATR` 时使用该操作规定的默认编码；若显式提供该描述符，未使用的字段必须保持为零。 +- 省略维度描述符时使用本操作规定的维度默认值；显式给出的维度必须满足本操作的非零约束。 +- 省略 `B.IOR` 时使用本操作规定的寄存器或控制默认值；显式编码为零表示实际的零值，不等同于省略该描述符。 +- 物理 padding 始终使用 `Null`。 + +`fixp::Options` 内部字段的默认值和合法组合见 [Options 指南](../../options.md)。 + +## 异常和边界行为 + + 类型不匹配、非法形状或布局、未初始化的输入、输出容量不足、非法 PE mask、错误的 Tile 位置或不合法的属性组合，会在编译期或执行前检查阶段被拒绝。`PE_MASK=0000` 时操作不产生状态或内存影响；非法调用不会发布部分输出或部分副作用。padding、alias、NaN/无穷值及 fault 行为以本页已经列出的约束和边界说明为准，未明确声明的状态不可依赖。 + +## 结果说明 + + 成功调用后，`TSORT` 更新输出 Tile 的有效区域；输入 Tile 通常保持不变，输出 padding 和未明确声明的副作用不可依赖。若操作的约束或参数说明另有规定，以对应说明为准。 + +## Bundle 组成 + +开发者通常直接调用 C++ 接口，无需手工编写 bundle。下面保留对应汇编结构供核对： + +```asm +BSTART.SFU TSORT, FP32|FP16 +B.DATR all-zero (optional) +B.DIM rsort_width, 0, ->LB0 ; (optional; zero or omission defaults to 32) +B.IOR Descending (optional; omission defaults to ascending) +B.IOT Local source and two new Local destinations, common PE_MASK, last +BSTOP +``` + +## 使用示例 + +```text +#include + +using namespace pto; +using Values = Tile; +using Indices = Tile; +using GMValues = global_tensor>; +using GMIndices = global_tensor>; + +void sort_rows(float *out_values, uint32_t *out_indices, const float *input) { + GMValues input_gm(input), values_gm(out_values); + GMIndices indices_gm(out_indices); + Values source, value_dst; + Indices index_dst; + TLOAD(source, input_gm); + TSORT(value_dst, index_dst, source, 32, false); + TSTORE(values_gm, value_dst); + TSTORE(indices_gm, index_dst); +} +``` + +涉及标量、索引、scale 或 bias 的操作，请按上方实际重载替换示例参数。 \ No newline at end of file diff --git a/docs/tileop-usage/layout-and-rearrangement/layout/TCONCAT.md b/docs/tileop-usage/layout-and-rearrangement/layout/TCONCAT.md index 42563ccc..97330852 100644 --- a/docs/tileop-usage/layout-and-rearrangement/layout/TCONCAT.md +++ b/docs/tileop-usage/layout-and-rearrangement/layout/TCONCAT.md @@ -1,20 +1,116 @@ -# TCONCAT（仅历史参考） +# TCONCAT (unreleased) -`TCONCAT` 已从 PTO ISA 0.59.0 active Tile catalog 删除。旧 TEPL selector 96 -不得由当前 wrapper、associated wrapper 或手写兼容别名发出。 +`TCONCAT` 沿列维度连接左、右源 Tile。 -## 当前 API 行为 +## C++ 接口 -为给旧源码提供稳定、明确的迁移诊断，本仓库保留以下函数名： +当前 API 中可用的调用形式： + +```text +template < + is_tile_data_v tile_shape_out, + is_tile_data_v tile_shape_in0, + is_tile_data_v tile_shape_in1> +void TCONCAT(tile_shape_out &dst, tile_shape_in0 &src0, tile_shape_in1 &src1); +``` + +### Destination assembly：`TCONCAT_ASS` ```cpp -TCONCAT(dst, src0, src1); -TCONCAT_ASS(assembled_dst, src0, src1); +template +void TCONCAT_ASS(D &assembled_dst, A &src0, B &src1); ``` -两种调用都会在模板实例化时触发编译错误；它们不是可执行 wrapper，也没有 -PTO ISA 0.59.0 bundle 组成。`TCONCAT_ASS` 不得借 associated 路径重新启用 -selector 96。 +`assembled_dst` 必须由 `range::assemble` 系列 factory 构造；输入在前、destination +在后，源与目标的 dtype、layout 和拼接形状约束沿用 `TCONCAT`。 + +### 支持的数据类型 + +支持FP64、FP32、TF32、HF32、FP16、BF16、HiF8、E4M3、E5M2、E3M2、E2M3、E8M0、E2M1X2、E1M2X2、S4X2、U4X2、S64、S32、S16、S8、U64、U32、U16、U8类型。 + + + +### 参数说明 + +| 参数 | 说明 | +| --- | --- | +| `dst` | 输出 Tile；成功调用后写入操作结果。 | +| `src0` | 第一个输入 Tile。 | +| `src1` | 第二个输入 Tile。 | + + + +## 使用要求 + +- Tile 类型必须满足接口模板约束； +- 数据类型、形状、有效区域、布局、容量和存储位置必须满足该操作要求； +- 输入 Tile 必须已初始化，输出 Tile 必须具有足够容量； +- 参数顺序必须与接口声明一致，不要添加接口未声明的操作数。 + +## 约束 + +输入与输出的 Tile location、layout、dtype、物理 shape 和 valid region 必须满足该操作的 逐项规则；除非本页明确允许，不应假定可原地执行或允许 alias。 + + 操作数角色、数据类型组合、容量、PE mask 和 alias 必须符合上方约束；只能使用所选重载声明的操作数形式。 + +### 有效区域与 padding + +| 项目 | 规则 | +| --- | --- | +| 有效元素 | 输出 valid region 由布局、偏移或拼接描述符计算；物理 padding 不等于有效数据。 | +| 物理容量 / SizeCode | 只决定容量，不重新定义逻辑 shape。 | +| 输出 padding | 除非本操作明确规定填充值或传播规则，否则视为不可依赖。 | + + + +## 默认值 + + 此页面列出的 C++ 形参没有默认实参；不要把省略某个操作数与传入零值视为等价。 + +### 编码字段和省略值 + +- `B.IOR` 是必需描述符；未使用的选择器和字段必须编码为零。 + +`fixp::Options` 内部字段的默认值和合法组合见 [Options 指南](../../options.md)。 + +## 异常和边界行为 + + 类型不匹配、非法形状或布局、未初始化的输入、输出容量不足、非法 PE mask、错误的 Tile 位置或不合法的属性组合，会在编译期或执行前检查阶段被拒绝。`PE_MASK=0000` 时操作不产生状态或内存影响；非法调用不会发布部分输出或部分副作用。padding、alias、NaN/无穷值及 fault 行为以本页已经列出的约束和边界说明为准，未明确声明的状态不可依赖。 + +## 结果说明 + + 成功调用后，`TCONCAT` 更新输出 Tile 的有效区域；输入 Tile 通常保持不变，输出 padding 和未明确声明的副作用不可依赖。若操作的约束或参数说明另有规定，以对应说明为准。 + +## Bundle 组成 + +开发者通常直接调用 C++ 接口，无需手工编写 bundle。下面保留对应汇编结构供核对： + +```asm +BSTART.SFU TCONCAT, DataType +B.DATR (optional) +B.DIM LB0 +B.DIM (LB1/LB2 for 2D) +B.IOT +BSTOP +``` + +## 使用示例 + +```text +#include + +using namespace pto; +using GM0 = global_tensor>; +using GM1 = global_tensor>; +using GMO = global_tensor>; +using Tile0 = Tile; +using TileO = Tile; +float a[16 * 8] = {}, b[16 * 8] = {}, out[16 * 16] = {}; +GM0 g0(a); GM1 g1(b); GMO go(out); +Tile0 src0, src1; TileO dst; +TLOAD(src0, g0); TLOAD(src1, g1); +TCONCAT(dst, src0, src1); +TSTORE(go, dst); +``` -需要拼接数据时，应使用当前 golden 中已定义的操作或显式的数据搬移序列， -并按所选替代方案的 ASL/NDF 合法性、布局和生命周期约束重新验证。 +涉及标量、索引、scale 或 bias 的操作，请按上方实际重载替换示例参数。 \ No newline at end of file diff --git a/docs/tileop-usage/layout-and-rearrangement/layout/TEXTRACT.md b/docs/tileop-usage/layout-and-rearrangement/layout/TEXTRACT.md index e168315f..e9518dd9 100644 --- a/docs/tileop-usage/layout-and-rearrangement/layout/TEXTRACT.md +++ b/docs/tileop-usage/layout-and-rearrangement/layout/TEXTRACT.md @@ -1,8 +1,104 @@ -# TEXTRACT（仅历史参考） +# TEXTRACT (unreleased) -`TEXTRACT` 已从 PTO ISA 0.59.0 active Tile catalog 删除。旧 SFU/TEPL -selector 98 不得由当前 wrapper 或手写别名发出。 +`TEXTRACT` 从编码的行、列偏移起始位置，将矩形区域复制到目标 Tile。 -本仓库只保留 `TEXTRACT(...)` 名称用于模板实例化时给出稳定的编译错误；它不是 -可执行 wrapper，也没有 PTO ISA 0.59.0 bundle 组成。需要子区域访问时请使用当前 -golden 定义的 `B.SUBVIEW`/region API，并重新验证布局、范围和生命周期约束。 +## C++ 接口 + +当前 API 中可用的调用形式： + +```text +template +void TEXTRACT(tile_shape_out &dst, tile_shape_in &src, int32_t indexRow, int32_t indexCol); +``` + +### 支持的数据类型 + +支持FP64、FP32、TF32、HF32、FP16、BF16、HiF8、E4M3、E5M2、E3M2、E2M3、E8M0、E2M1X2、E1M2X2、S4X2、U4X2、S64、S32、S16、S8、U64、U32、U16、U8类型。 + + + +### 参数说明 + +| 参数 | 说明 | +| --- | --- | +| `dst` | 输出 Tile；成功调用后写入操作结果。 | +| `src` | 输入 Tile 或源数据。 | +| `indexRow` | 行索引 Tile；其元素选择对应的源或目标行。 | +| `indexCol` | 列索引 Tile；其元素选择对应的源或目标列。 | + + + +## 使用要求 + +- Tile 类型必须满足接口模板约束； +- 数据类型、形状、有效区域、布局、容量和存储位置必须满足该操作要求； +- 输入 Tile 必须已初始化，输出 Tile 必须具有足够容量； +- 参数顺序必须与接口声明一致，不要添加接口未声明的操作数。 + +## 约束 + +输入与输出的 Tile location、layout、dtype、物理 shape 和 valid region 必须满足该操作的 逐项规则；除非本页明确允许，不应假定可原地执行或允许 alias。 + + 操作数角色、数据类型组合、容量、PE mask 和 alias 必须符合上方约束；只能使用所选重载声明的操作数形式。 + +### 有效区域与 padding + +| 项目 | 规则 | +| --- | --- | +| 有效元素 | 输出 valid region 由布局、偏移或拼接描述符计算；物理 padding 不等于有效数据。 | +| 物理容量 / SizeCode | 只决定容量，不重新定义逻辑 shape。 | +| 输出 padding | 除非本操作明确规定填充值或传播规则，否则视为不可依赖。 | + + + +## 默认值 + + 此页面列出的 C++ 形参没有默认实参；不要把省略某个操作数与传入零值视为等价。 + +### 编码字段和省略值 + +- `B.IOR` 是必需描述符；未使用的选择器和字段必须编码为零。 + +`fixp::Options` 内部字段的默认值和合法组合见 [Options 指南](../../options.md)。 + +## 异常和边界行为 + + 类型不匹配、非法形状或布局、未初始化的输入、输出容量不足、非法 PE mask、错误的 Tile 位置或不合法的属性组合，会在编译期或执行前检查阶段被拒绝。`PE_MASK=0000` 时操作不产生状态或内存影响；非法调用不会发布部分输出或部分副作用。padding、alias、NaN/无穷值及 fault 行为以本页已经列出的约束和边界说明为准，未明确声明的状态不可依赖。 + +## 结果说明 + + 成功调用后，`TEXTRACT` 更新输出 Tile 的有效区域；输入 Tile 通常保持不变，输出 padding 和未明确声明的副作用不可依赖。若操作的约束或参数说明另有规定，以对应说明为准。 + +## Bundle 组成 + +开发者通常直接调用 C++ 接口，无需手工编写 bundle。下面保留对应汇编结构供核对： + +```asm +BSTART.SFU TEXTRACT, DataType +B.DATR (optional) +B.DIM LB0 +B.DIM (LB1/LB2 for 2D) +B.IOT +B.IOR +BSTOP +``` + +## 使用示例 + +```text +#include + +using namespace pto; +using InGM = global_tensor>; +using OutGM = global_tensor>; +using InTile = Tile; +using OutTile = Tile; +float src_data[32 * 16] = {}, dst_data[16 * 8] = {}; +InGM src_global(src_data); OutGM dst_global(dst_data); +InTile src; OutTile dst; +TLOAD(src, src_global); +TEXTRACT(dst, src, 16, 8); +TSTORE(dst_global, dst); +``` + +涉及标量、索引、scale 或 bias 的操作，请按上方实际重载替换示例参数。 \ No newline at end of file diff --git a/docs/tileop-usage/layout-and-rearrangement/layout/TINSERT.md b/docs/tileop-usage/layout-and-rearrangement/layout/TINSERT.md index 93d5fecf..17308c67 100644 --- a/docs/tileop-usage/layout-and-rearrangement/layout/TINSERT.md +++ b/docs/tileop-usage/layout-and-rearrangement/layout/TINSERT.md @@ -1,8 +1,105 @@ -# TINSERT（仅历史参考） +# TINSERT (unreleased) -`TINSERT` 已从 PTO ISA 0.59.0 active Tile catalog 删除。旧 SFU/TEPL -selector 99 不得由当前 wrapper 或手写别名发出。 +`TINSERT` 按编码偏移将源 Tile 插入目标 Tile 的旧值快照。 -本仓库只保留 `TINSERT(...)` 名称用于模板实例化时给出稳定的编译错误；它不是 -可执行 wrapper，也没有 PTO ISA 0.59.0 bundle 组成。需要区域更新时请使用当前 -golden 定义的 region/assemble API，并重新验证发布和生命周期约束。 +## C++ 接口 + +当前 API 中可用的调用形式： + +```text +template +void TINSERT(tile_shape_out &dst, tile_shape_in &src, int32_t indexRow, int32_t indexCol); +``` + +### 支持的数据类型 + +支持FP64、FP32、TF32、HF32、FP16、BF16、HiF8、E4M3、E5M2、E3M2、E2M3、E8M0、E2M1X2、E1M2X2、S4X2、U4X2、S64、S32、S16、S8、U64、U32、U16、U8类型。 + + + +### 参数说明 + +| 参数 | 说明 | +| --- | --- | +| `dst` | 输出 Tile；成功调用后写入操作结果。 | +| `src` | 输入 Tile 或源数据。 | +| `indexRow` | 行索引 Tile；其元素选择对应的源或目标行。 | +| `indexCol` | 列索引 Tile；其元素选择对应的源或目标列。 | + + + +## 使用要求 + +- Tile 类型必须满足接口模板约束； +- 数据类型、形状、有效区域、布局、容量和存储位置必须满足该操作要求； +- 输入 Tile 必须已初始化，输出 Tile 必须具有足够容量； +- 参数顺序必须与接口声明一致，不要添加接口未声明的操作数。 + +## 约束 + +输入与输出的 Tile location、layout、dtype、物理 shape 和 valid region 必须满足该操作的 逐项规则；除非本页明确允许，不应假定可原地执行或允许 alias。 + + 操作数角色、数据类型组合、容量、PE mask 和 alias 必须符合上方约束；只能使用所选重载声明的操作数形式。 + +### 有效区域与 padding + +| 项目 | 规则 | +| --- | --- | +| 有效元素 | 输出 valid region 由布局、偏移或拼接描述符计算；物理 padding 不等于有效数据。 | +| 物理容量 / SizeCode | 只决定容量，不重新定义逻辑 shape。 | +| 输出 padding | 除非本操作明确规定填充值或传播规则，否则视为不可依赖。 | + + + +## 默认值 + + 此页面列出的 C++ 形参没有默认实参；不要把省略某个操作数与传入零值视为等价。 + +### 编码字段和省略值 + +- `B.IOR` 是必需描述符；未使用的选择器和字段必须编码为零。 + +`fixp::Options` 内部字段的默认值和合法组合见 [Options 指南](../../options.md)。 + +## 异常和边界行为 + + 类型不匹配、非法形状或布局、未初始化的输入、输出容量不足、非法 PE mask、错误的 Tile 位置或不合法的属性组合，会在编译期或执行前检查阶段被拒绝。`PE_MASK=0000` 时操作不产生状态或内存影响；非法调用不会发布部分输出或部分副作用。padding、alias、NaN/无穷值及 fault 行为以本页已经列出的约束和边界说明为准，未明确声明的状态不可依赖。 + +## 结果说明 + + 成功调用后，`TINSERT` 更新输出 Tile 的有效区域；输入 Tile 通常保持不变，输出 padding 和未明确声明的副作用不可依赖。若操作的约束或参数说明另有规定，以对应说明为准。 + +## Bundle 组成 + +开发者通常直接调用 C++ 接口，无需手工编写 bundle。下面保留对应汇编结构供核对： + +```asm +BSTART.SFU TINSERT, DataType +B.DATR (optional) +B.DIM LB0 +B.DIM (LB1/LB2 for 2D) +B.IOT +B.IOR +BSTOP +``` + +## 使用示例 + +```text +#include + +using namespace pto; +using InputGM = global_tensor>; +using OutputGM = global_tensor>; +using InputTile = Tile; +using OutputTile = Tile; +float src_data[16 * 16] = {}; +float dst_data[32 * 32] = {}; +InputGM src_global(src_data); OutputGM dst_global(dst_data); +InputTile src; OutputTile dst; +TLOAD(src, src_global); +TINSERT(dst, src, 8, 8); +TSTORE(dst_global, dst); +``` + +涉及标量、索引、scale 或 bias 的操作，请按上方实际重载替换示例参数。 \ No newline at end of file diff --git a/docs/tileop-usage/layout-and-rearrangement/layout/TTRANS.md b/docs/tileop-usage/layout-and-rearrangement/layout/TTRANS.md index 68c026c4..cfadcc17 100644 --- a/docs/tileop-usage/layout-and-rearrangement/layout/TTRANS.md +++ b/docs/tileop-usage/layout-and-rearrangement/layout/TTRANS.md @@ -1,8 +1,114 @@ -# TTRANS（仅历史参考） +# TTRANS (unreleased) -`TTRANS` 已从 PTO ISA 0.59.0 active Tile catalog 删除。旧 SFU/TEPL -selector 110 不得由当前 wrapper、associated wrapper 或手写别名发出。 +> **注意**：`TTRANS` 已从 PTO ISA 0.58.6 active catalog 移除（deleted_names）。本页保留作历史参考；新代码不应使用该操作。 -本仓库只保留 `TTRANS(...)` 和 `TTRANS_ASS(...)` 名称用于模板实例化时给出稳定的 -编译错误；它们不是可执行 wrapper，也没有 PTO ISA 0.59.0 bundle 组成。需要转置 -时请使用当前 golden 定义的 TLOAD/TSTORE layout transport 或矩阵 Shared 转置控制。 +`TTRANS` 将源 Tile 转置后写入目标 Tile。 + +## C++ 接口 + +当前 API 中可用的调用形式： + +```text +template +void TTRANS(tile_shape_out &dst, tile_shape_in &src); +``` + +### Destination assembly：`TTRANS_ASS` + +```cpp +template +void TTRANS_ASS(D &assembled_dst, S &src); +``` + +这是历史接口对应的 assembly 版本；`assembled_dst` 必须是 `range::assemble` +carrier，参数顺序为 destination、source。该接口与普通 `TTRANS` 一样受当前 +ISA catalog 状态约束，不改变本页关于该操作已移除的兼容性说明。 + +### 支持的数据类型 + +支持FP64、FP32、TF32、HF32、FP16、BF16、HiF8、E4M3、E5M2、E3M2、E2M3、E8M0、E2M1X2、E1M2X2、S4X2、U4X2、S64、S32、S16、S8、U64、U32、U16、U8类型。 + + + +### 参数说明 + +| 参数 | 说明 | +| --- | --- | +| `dst` | 输出 Tile；成功调用后写入操作结果。 | +| `src` | 输入 Tile 或源数据。 | + + + +## 使用要求 + +- Tile 类型必须满足接口模板约束； +- 数据类型、形状、有效区域、布局、容量和存储位置必须满足该操作要求； +- 输入 Tile 必须已初始化，输出 Tile 必须具有足够容量； +- 参数顺序必须与接口声明一致，不要添加接口未声明的操作数。 + +## 约束 + +输入与输出的 Tile location、layout、dtype、物理 shape 和 valid region 必须满足该操作的 逐项规则；除非本页明确允许，不应假定可原地执行或允许 alias。 + + 操作数角色、数据类型组合、容量、PE mask 和 alias 必须符合上方约束；只能使用所选重载声明的操作数形式。 + +### 有效区域与 padding + +| 项目 | 规则 | +| --- | --- | +| 有效元素 | 输出 valid region 由布局、偏移或拼接描述符计算；物理 padding 不等于有效数据。 | +| 物理容量 / SizeCode | 只决定容量，不重新定义逻辑 shape。 | +| 输出 padding | 除非本操作明确规定填充值或传播规则，否则视为不可依赖。 | + + + +## 默认值 + + 此页面列出的 C++ 形参没有默认实参；不要把省略某个操作数与传入零值视为等价。 + +### 编码字段和省略值 + +- `B.IOR` 是必需描述符；未使用的选择器和字段必须编码为零。 + +`fixp::Options` 内部字段的默认值和合法组合见 [Options 指南](../../options.md)。 + +## 异常和边界行为 + + 类型不匹配、非法形状或布局、未初始化的输入、输出容量不足、非法 PE mask、错误的 Tile 位置或不合法的属性组合，会在编译期或执行前检查阶段被拒绝。`PE_MASK=0000` 时操作不产生状态或内存影响；非法调用不会发布部分输出或部分副作用。padding、alias、NaN/无穷值及 fault 行为以本页已经列出的约束和边界说明为准，未明确声明的状态不可依赖。 + +## 结果说明 + + 成功调用后，`TTRANS` 更新输出 Tile 的有效区域；输入 Tile 通常保持不变，输出 padding 和未明确声明的副作用不可依赖。若操作的约束或参数说明另有规定，以对应说明为准。 + +## Bundle 组成 + +开发者通常直接调用 C++ 接口，无需手工编写 bundle。下面保留对应汇编结构供核对： + +```asm +BSTART.SFU TTRANS, DataType +B.DATR (optional) +B.DIM LB0 +B.DIM (LB1/LB2 for 2D) +B.IOT +BSTOP +``` + +## 使用示例 + +```text +#include + +using namespace pto; +using InputGM = global_tensor>; +using OutputGM = global_tensor>; +using InputTile = Tile; +using OutputTile = Tile; +float src_data[32 * 16] = {}, dst_data[16 * 32] = {}; +InputGM src_global(src_data); OutputGM dst_global(dst_data); +InputTile src; OutputTile dst; +TLOAD(src, src_global); +TTRANS(dst, src); +TSTORE(dst_global, dst); +``` + +涉及标量、索引、scale 或 bias 的操作，请按上方实际重载替换示例参数。 \ No newline at end of file diff --git a/docs/tileop-usage/options.md b/docs/tileop-usage/options.md index 25b52e02..9c0d9856 100644 --- a/docs/tileop-usage/options.md +++ b/docs/tileop-usage/options.md @@ -444,7 +444,7 @@ Matrix 使用或完整组合不合法，会在 operand consumption、allocation C++ 调用者无需手写汇编；生成代码可按以下结构核对： ```asm -BSTART.TMATMUL AType +BSTART.CUBE TMATMUL, AType B.DATR BType, RMode, Sat B.FPATR PreQuant, Relu, GroupNCode, RowMaxEn, GroupMaxEn, RowMaxInit, MaxAbsEn, @@ -525,20 +525,6 @@ exact TileOP-API checkout through `PTO_TILEOP_API_REVISION`; consumers should use capability macros such as `PTO_TILEOP_API_HAS_LOCAL_B_KN_FIX` for compile-time requirements instead of ordering raw Git hashes. -### Element-if compiler options - -`#pragma pto element for` 的 generic masked lowering 需要 `-O2` 和 -`-mllvm -linxv5-enable-generic-element=true`；该 opt-in 同时适用于 logical32 -与 logical64，不仅是 F16/U16 的开关。生成 Tile object 时还需配套的 -`-mllvm -enable-all-vector-as-tilereg=true` 配置。带 region 的 `-O0`/`optnone` -不支持 masked native lowering，缺少 opt-in 时也不会退回旧的 recognizer 或标量循环。 -这些是编译器开关，不是 CUBE `fixp::Options` 字段。 - -LLVM #131 的 `__LINX_PTO_PE_DOMAIN__` 表示编译器理解 PE-domain 函数注解， -不表示本仓已经发布同名公共 wrapper。当前头文件尚无 `PTO_PE_DOMAIN(mask)`； -调用者 PE 选择、Local Tile 边界与完整示例见 -[Element-if 开发者使用手册](element-if.md)。 - ## Shared-slot matrix operands For a CUBE pipeline whose Shared inputs are produced by separate TLSU or diff --git a/docs/tileop-usage/support-status.md b/docs/tileop-usage/support-status.md index 772a4a5a..403e1bb3 100644 --- a/docs/tileop-usage/support-status.md +++ b/docs/tileop-usage/support-status.md @@ -1,6 +1,6 @@ -# PTO ISA 0.59.0 wrapper 支持状态 +# PTO ISA 0.58.7 wrapper 支持状态 -本表以 `contracts/pto-isa-0.59.0-tile-operations.json` 的 119 个 +本表以 `contracts/pto-isa-0.58.7-tile-operations.json` 的 118 个 `accepted-direct-operation` 为操作清单。它描述 Linx TileOP C++ wrapper 的 公开实现状态，不替代 PTO-ISA/pto-spec 的 ASL/NDF 合法性、fault、completion、 rollback、definedness 或 memory-order 语义。 @@ -10,41 +10,28 @@ rollback、definedness 或 memory-order 语义。 | **已实现** | 当前 `include/` 有可调用 wrapper；本地测试覆盖其至少一个有效路径。 | | **仅部分 layout 支持** | wrapper 存在，但只覆盖 catalog 合法 layout/shape/属性组合的子集；其他组合必须以编译期约束拒绝，不能推断为缺陷或自动支持。 | | **尚无 wrapper** | PTO catalog 有操作，但本仓库没有公开的 C++ wrapper；不能通过拼接汇编或复用相近 API 冒充支持。 | -| **仅历史参考** | 名称来自旧版本或已删除清单；保留页面/禁用 stub 只用于迁移，不能生成当前 PTO 0.59.0 指令。 | +| **仅历史参考** | 名称来自旧版本或已删除清单；保留页面/禁用 stub 只用于迁移，不能生成当前 PTO 0.58.7 指令。 | ## 当前覆盖 | PTO catalog 范围 | 状态 | 说明 | | --- | --- | --- | -| TEPL elementwise、scalar、reduce/expand、irregular（除 `TLEA`） | 已实现 | 逐操作页面和 `jcore/template_asm.hpp` 为 wrapper 权威；dtype、valid region、padding 和 selector 仍受 ASL 约束。 | -| `TLEA` | JCORE inline-asm wrapper 已实现（RowMajor 与 CUBE_M32）；CPU simulator 未实现；AArch64/SME 未实现；LLVM MC / compiler lowering 分别判断 | PTO catalog 将 TLEA 列为 `accepted-direct-operation`（`BSTART.TEPL`，**VEC** 引擎，selector `0x2E`=46，function 14/mode 1）；操作数为 S32/U32/S64/U64 element index、per-PE element-width 标量与 S64/U64 byte-offset 目标。`include/jcore/template_asm.hpp` 的 wrapper 以编译期约束限定 dtype/layout/logical-shape（RowMajor/CUBE_M32，Shared/CUBE_N8/CUBE_M16 拒绝）；signed→S64/unsigned→U64 的严格配对由 ASL `lea-operands.asl` 要求，当前 wrapper 仅校验目标为 S64/U64，配对以指令 legality 为准。element-width 的运行时合法性（8/16/32/64）由指令 legality 检查，不是编译期静态拒绝。wrapper 存在不代表 CPU simulator、AArch64 或 LLVM 端到端已具备 TLEA 支持。 | -| `TEXPDIF` | CPU simulator、JCORE inline-asm 已实现；LLVM MC catalog 已实现；LLVM compiler lowering 尚未完成；AArch64/SME 不支持 | PTO selector 29。已有 wrapper 不等于 LLVM compiler 已具备从 IR/builtin 到 TEXPDIF 的端到端 lowering。 | +| TEPL elementwise、scalar、reduce/expand、irregular | 已实现 | 逐操作页面和 `jcore/template_asm.hpp` 为 wrapper 权威；dtype、valid region、padding 和 selector 仍受 ASL 约束。 | +| `TEXPDIF` | CPU simulator、JCORE inline-asm 已实现；LLVM MC catalog 已实现；LLVM compiler lowering 尚未完成；AArch64/SME 不支持 | PTO 0.58.7 selector 29。已有 wrapper 不等于 LLVM compiler 已具备从 IR/builtin 到 TEXPDIF 的端到端 lowering。 | | TLSU `TLOAD`/`TSTORE`/`TMOV`/`TPREFETCH`/`GMOV` | 已实现 | 传输、peer move 和 prefetch 有独立 C++ 入口；layout conversion 仅对页面列出的组合开放。 | | TLSU `MGATHER`/`MSCATTER` 及 atomic/reduction variants | 仅部分 layout 支持 | wrapper 覆盖当前公开 selector；ColumnMajor selector、mask/索引 dtype 和不同 atomic 组合不得由普通 gather/scatter 重载推断。 | | CUBE TMATMUL/TGEMV 及 bias/acc/MX variants | 仅部分 layout 支持 | CUBE_M16/CUBE_M32、Shared physical shape、scale layout 和 InternalAcc 由具体 wrapper/操作页限制。 | | TEPL layout/rearrangement（`TPERMUTE`、`TSHUF`、`TPACK`、`TUNPACK`、`TGPR2T`） | 仅部分 layout 支持 | 只覆盖已实现的 CUBE/Local 路径和控制字段；未列出的组合保持拒绝。 | -| `MGATHER`/`MSCATTER` family（byte-displacement 索引） | 已适配 | 自 PTO 0.58.7 起 GM row-stride 操作数被移除、index tile 解释为显式 byte displacement，该语义在 0.59.0.0 发布 catalog 中保持不变；wrapper 与 contract test 使用 base-only `B.IOR`。 | -| `TROWEXPAND*`/`TCOLEXPAND*` roles | 已适配 | Source roles 使用 row-broadcast/column-broadcast operation view；wrapper 约束、注释及操作文档已同步。 | +| 0.58.7 `MGATHER`/`MSCATTER` family | 已适配 | 0.58.7 removes the GM row-stride operand and interprets index tiles as explicit byte displacements；wrapper 与 contract test 已改为 base-only `B.IOR`。 | +| 0.58.7 `TROWEXPAND*`/`TCOLEXPAND*` roles | 已适配 | Source roles 使用 row-broadcast/column-broadcast operation view；wrapper 约束、注释及操作文档已同步。 | | `deleted_names`、`rejected_names`，以及 `TTRANS`/`TFILLPAD` 等历史页面 | 仅历史参考 | 不属于 active catalog；页面必须保留明确的 retired 标识。 | ## 版本边界 -- 当前 API/spec 基线：已发布的 PTO ISA `v0.59.0.0` release（commit `b016532`），ABI - `pto-isa-0.59.0-mode-function-v1`、encoding projection SHA-256 - `91509080…`、ELF release 字段 `0.59.0`（见 `contracts/pto-isa-0.59.0-tile-operations.json`、 - `contracts/linxisa-v0.58-engine-ops.json` 的 `pto_source` 与 provenance 测试）。 -- 发布 manifest（`spec/release-manifest.json`）自身记为 - `specification_status: draft`，并把 implementation conformance 限定为 - `b-fpatr-and-tcvt-e8m0-asl-proven-other-numeric-domains-unproven`；本页据此 - 不宣称该规范已最终定稿或全部数值域已证明。119 个操作的 Tile catalog 与 PTO 0.58.7 - development golden 逐字节一致（SHA-256 `533db9b8…`），因此 `TLEA` 等条目在两者之间保持一致， - 只是 encoding identity 移到了发布版本。 -- 语义 authority 仍是 LinxISA v0.58 profile（无 0.59 profile）与 PTO ASL/NDF： - engine-ops 投影保留真实 LinxISA v0.58 来源，并在 `pto_source.development_lock` - 记录其曾锁定的 PTO development golden，不把旧来源伪标为 v0.59。 +- 当前 API/spec 基线：PTO ISA `0.58.7`，publication `0.58.7.0`，ABI + `pto-isa-0.58.7-mode-function-v1`。 - backend 能力必须分别判断：CPU simulator/JCORE wrapper、LLVM MC assembler/parser、LLVM compiler lowering 以及 AArch64/SME 并不是同一个状态。 - `TLEA` 目前只有 JCORE inline-asm wrapper（RowMajor 与 CUBE_M32），没有 CPU simulator 语义。 - `TEXPDIF` 当前已有 CPU simulator 实现、JCORE inline-asm wrapper 和 LLVM MC catalog 条目；LLVM compiler lowering 尚未完成，因此当前不能宣称 LLVM 端到端支持。 @@ -52,4 +39,4 @@ rollback、definedness 或 memory-order 语义。 0.58.3 compiler、ELF identity 和旧 engine projection 不表示当前实现基线。 - 需要核对精确 fault ordering、completion、rollback、memory ordering 或编码位域时， 必须回到 `PTO-ISA/pto-spec` 对应 ASL/NDF owner；Markdown wrapper 文档不构成完整 - 规范镜像。 + 规范镜像。 \ No newline at end of file diff --git a/docs/tileop-usage/tile-scalar-and-immediate/arithmetic/TLEA.md b/docs/tileop-usage/tile-scalar-and-immediate/arithmetic/TLEA.md deleted file mode 100644 index 26512473..00000000 --- a/docs/tileop-usage/tile-scalar-and-immediate/arithmetic/TLEA.md +++ /dev/null @@ -1,112 +0,0 @@ -# TLEA - -`TLEA` 将 Local 源 Tile 中的逻辑元素索引扩展为 64 位,并按每 PE 的元素位宽显式缩放为字节偏移(`dst[i] = extend64(src[i]) * (element_bits / 8)`,保留低 64 位)。它只生成字节偏移,不做 BaseGPR 相加、访存或数值状态更新。 - -## C++ 接口 - -当前 API 中可用的调用形式: - -```cpp -template -void TLEA(tile_shape_out &dst, tile_shape_in &src, unsigned element_bits); -``` - -参数顺序为 destination、source、element_bits。源有符号索引按符号扩展到 S64,无符号索引按零扩展到 U64,再乘以 `element_bits / 8`;结果保留低 64 位,不做饱和,也不产生溢出 fault。 - -### 支持的数据类型 - -- `src`(元素索引):S32、U32、S64、U64。 -- `dst`(字节偏移):S64 或 U64。 -- `element_bits`(每 PE 元素位宽):8、16、32 或 64;四位 packed 宽度拒绝。 -- 源与目的共享同一 layout,只能是 RowMajor 或 CUBE_M32;Shared、CUBE_N8、CUBE_M16 拒绝。 - -### 参数说明 - -| 参数 | 说明 | -| --- | --- | -| `dst` | 输出 Tile;成功调用后写入新的 S64/U64 字节偏移。物理 geometry 与容量独立于源。 | -| `src` | 输入 Tile,持有 Local 元素索引(S32/U32/S64/U64)。 | -| `element_bits` | 每 PE 元素位宽(bit),经 `B.IOR` 的私有 GPR 传入;无隐含宽度,零寄存器为非法宽度。 | - -## 使用要求 - -- Tile 类型必须满足接口模板约束; -- 数据类型、形状、有效区域、布局、容量和存储位置必须满足该操作要求; -- 源与目的必须具有相同的逻辑 valid shape(ValidRow × ValidCol),物理容量与 geometry 可独立; -- 输入 Tile 必须已初始化,输出 Tile 必须具有足够容量; -- 参数顺序必须与接口声明一致,不要添加接口未声明的操作数。 - -## 约束 - -输入与输出的 Tile location、layout、dtype、物理 shape 和 valid region 必须满足该操作的逐项规则;除非本页明确允许,不应假定可原地执行或允许 alias。直接 S64/U64 aliasing 读取的是旧的源负载。 - -操作数角色、数据类型组合、容量、PE mask 和 alias 必须符合上方约束;只能使用所选重载声明的操作数形式。 - -### 有效区域与 padding - -| 项目 | 规则 | -| --- | --- | -| 有效元素 | 仅对源和目的共同的有效区域定义结果;未明确规定的 padding 不应读取或依赖。 | -| 物理容量 / SizeCode | 只决定容量,不重新定义逻辑 shape;源与目的容量各自匹配自身 DataType。 | -| 输出 padding | 由 `CurrentBundlePadValue` 数值 padding 决定;除非明确规定,否则不可依赖。 | - -## 默认值 - -此页面列出的 C++ 形参没有默认实参;不要把省略某个操作数与传入零值视为等价。 - -### 编码字段和省略值 - -- 省略 `B.DATR` 时,PadValue 使用 `Null`,layout 使用 RowMajor;Layout 字段 29/31 分别选择 CUBE_M32/CUBE_M16(CUBE_M16 b64 输出未分配)。 -- `LB0` 给出 `ValidCol`,必须存在且非零;省略 `LB1` 时 `ValidRow=1`,省略 `LB2` 时目的物理列数等于 `ValidCol`。 -- `B.IOR` 必须存在,`RegSrc0` 提供元素位宽;没有隐含宽度或基址。其余字段编码为零。 -- `PE_MASK=0000` 在任何读取、分配和 fault 之前都是严格 no-op。 - -## 异常和边界行为 - -不支持的索引类型或元素宽度、非法 layout/descriptor/schema、逻辑 shape 不匹配,会在效果产生前被拒绝;目的容量不足走 `Fault_TileAllocation`。`TLEA` 不引入溢出、访存或数值状态 fault。`PE_MASK=0000` 时不产生状态或内存影响;非法调用不会发布部分输出或部分副作用。padding、alias 及 fault 行为以本页已经列出的约束为准,未明确声明的状态不可依赖。 - -## 结果说明 - -成功调用后,`TLEA` 将源索引缩放为字节偏移并原子发布到目的 Tile 的有效区域;源 Tile 保持不变。完整的合法性/分配预检与源快照先于目的发布完成。输出 padding 和未明确声明的副作用不可依赖。 - -## Bundle 组成 - -开发者通常直接调用 C++ 接口,无需手工编写 bundle。下面保留对应汇编结构供核对: - -```asm -BSTART.VEC TLEA, SrcDataType -B.DATR PadValue, Layout (optional) -B.DIM ValidCol, 0, ->LB0 -B.DIM ValidRow, 0, ->LB1 ; (optional) -B.DIM DstCol, 0, ->LB2 ; (optional) -B.IOT IndexTile, mask=PE_MASK, last, ->ByteOffsetTile -B.IOR ElementBitsGPR, zero, zero, ->zero -BSTOP -``` - -对应编码为 TEPL Mode 1 Function 14(selector `0x02E`)。 - -## 使用示例 - -```cpp -#include - -using namespace pto; -// 逻辑元素索引(S32)缩放为 S64 字节偏移。 -using IndexTile = Tile; -using OffsetTile = Tile; -using IndexGM = global_tensor>; -using OffsetGM = global_tensor>; - -int32_t index_data[8 * 32] = {}; -int64_t offset_data[8 * 32] = {}; -IndexGM index_global(index_data); -OffsetGM offset_global(offset_data); -IndexTile indices; -OffsetTile offsets; - -TLOAD(indices, index_global); -// 针对 16 位(2 字节)元素,将元素索引缩放为字节偏移。 -TLEA(offsets, indices, 16u); -TSTORE(offset_global, offsets); -``` diff --git a/docs/tileop-usage/tlsu/load-store-move/TLOAD.md b/docs/tileop-usage/tlsu/load-store-move/TLOAD.md index dff6ef92..640cd06c 100644 --- a/docs/tileop-usage/tlsu/load-store-move/TLOAD.md +++ b/docs/tileop-usage/tlsu/load-store-move/TLOAD.md @@ -291,7 +291,7 @@ void load_vector_cubes(float *data16, float *data32, 开发者通常直接调用 C++ 接口，无需手工编写 bundle。下面保留对应汇编结构供核对： ```asm -BSTART.TLOAD FP16 +BSTART.TLSU TLOAD, FP16 B.DIM rValidCol, 0, ->LB0 B.DIM rValidRow, 0, ->LB1 B.DIM rCol, 0, ->LB2 diff --git a/docs/tileop-usage/tlsu/load-store-move/TMOV.md b/docs/tileop-usage/tlsu/load-store-move/TMOV.md index 8a6e4fda..b0396140 100644 --- a/docs/tileop-usage/tlsu/load-store-move/TMOV.md +++ b/docs/tileop-usage/tlsu/load-store-move/TMOV.md @@ -83,7 +83,7 @@ Shared Tile 必须使用 `TMOV_L2S_INSERT` / `TMOV_L2S_PUBLISH` 或 开发者通常直接调用 C++ 接口，无需手工编写 bundle。下面保留对应汇编结构供核对： ```asm -BSTART.TMOV DataType +BSTART.TLSU TMOV, DataType B.DIM LB0 B.DIM (LB1/LB2 for 2D) B.IOT @@ -102,4 +102,4 @@ TileT dst; TMOV(dst, src); ``` -涉及标量、索引、scale 或 bias 的操作，请按上方实际重载替换示例参数。 +涉及标量、索引、scale 或 bias 的操作，请按上方实际重载替换示例参数。 \ No newline at end of file diff --git a/include/common/pto_tile_region_inline_asm.hpp b/include/common/pto_tile_region_inline_asm.hpp index 35e76287..56936de6 100644 --- a/include/common/pto_tile_region_inline_asm.hpp +++ b/include/common/pto_tile_region_inline_asm.hpp @@ -25,7 +25,7 @@ pto_region_unary(Out &dst, region::SubTileView &src) { "B.DIM zero, %c3, ->lb0\n" "B.DIM zero, %c4, ->lb1\n" "B.DIM zero, %c5, ->lb2\n" - "B.IOT %2.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %2, mask=1111, last, ->%0<%Z6>\n" "B.SUBVIEW 0, %9, 0, %c7\n" : [Dst] "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -60,7 +60,7 @@ PTO_REGION_ALWAYS_INLINE void pto_region_scalar( "B.DIM zero, %c3, ->lb0\n" "B.DIM zero, %c4, ->lb1\n" "B.DIM zero, %c5, ->lb2\n" - "B.IOT %2.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %2, mask=1111, last, ->%0<%Z6>\n" "B.SUBVIEW 0, %9, 0, %c7\n" "B.IOR [%8],[]\n" : [Dst] "=Tr"(dst.data()) @@ -149,7 +149,7 @@ PTO_REGION_ALWAYS_INLINE void pto_region_unary_assemble( "B.DIM zero, %c3, ->lb0\n" \ "B.DIM zero, %c4, ->lb1\n" \ "B.DIM zero, %c5, ->lb2\n" \ - "B.IOT %2.reuse, mask=1111, last, ->%0<%Z6>\n" \ + "B.IOT %2, mask=1111, last, ->%0<%Z6>\n" \ "B.ASSEMBLE %c10, %c11, %8, 0, %c9\n" #define PTO_REGION_UNARY_ASSEMBLY_INPUTS \ "i"(type_traits::TypeCode), \ @@ -174,7 +174,7 @@ PTO_REGION_ALWAYS_INLINE void pto_region_unary_assemble( "B.DIM zero, %c3, ->lb0\n" "B.DIM zero, %c4, ->lb1\n" "B.DIM zero, %c5, ->lb2\n" - "B.IOT %2.reuse, %0.reuse, mask=1111, last\n" + "B.IOT %2, %0, mask=1111, last\n" "B.ASSEMBLE %c10, %c11, %8, 0, %c9\n" : : [Dst] "Tr"(dst.template parent_data()), @@ -254,7 +254,7 @@ PTO_REGION_ALWAYS_INLINE void pto_region_scalar_assemble( "B.DIM zero, %c3, ->lb0\n" \ "B.DIM zero, %c4, ->lb1\n" \ "B.DIM zero, %c5, ->lb2\n" \ - "B.IOT %2.reuse, mask=1111, last, ->%0<%Z6>\n" \ + "B.IOT %2, mask=1111, last, ->%0<%Z6>\n" \ "B.IOR [%[Scalar]],[]\n" \ "B.ASSEMBLE %c10, %c11, %8, 0, %c9\n" #define PTO_REGION_SCALAR_ASSEMBLY_INPUTS \ @@ -279,7 +279,7 @@ PTO_REGION_ALWAYS_INLINE void pto_region_scalar_assemble( "B.DIM zero, %c3, ->lb0\n" "B.DIM zero, %c4, ->lb1\n" "B.DIM zero, %c5, ->lb2\n" - "B.IOT %2.reuse, %0.reuse, mask=1111, last\n" + "B.IOT %2, %0, mask=1111, last\n" "B.IOR [%[Scalar]],[]\n" "B.ASSEMBLE %c10, %c11, %8, 0, %c9\n" : @@ -375,7 +375,7 @@ PTO_REGION_ALWAYS_INLINE void pto_region_scalar_subview_assemble( "B.DIM zero, %c3, ->lb0\n" \ "B.DIM zero, %c4, ->lb1\n" \ "B.DIM zero, %c5, ->lb2\n" \ - "B.IOT %2.reuse, mask=1111, last, ->%0<%Z6>\n" \ + "B.IOT %2, mask=1111, last, ->%0<%Z6>\n" \ "B.SUBVIEW 0, %8, 0, %c9\n" \ "B.IOR [%14],[]\n" \ "B.ASSEMBLE %c12, %c13, %10, 0, %c11\n" @@ -384,7 +384,7 @@ PTO_REGION_ALWAYS_INLINE void pto_region_scalar_subview_assemble( "B.DIM zero, %c3, ->lb0\n" \ "B.DIM zero, %c4, ->lb1\n" \ "B.DIM zero, %c5, ->lb2\n" \ - "B.IOT %2.reuse, %0.reuse, mask=1111, last\n" \ + "B.IOT %2, %0, mask=1111, last\n" \ "B.SUBVIEW 0, %8, 0, %c9\n" \ "B.IOR [%14],[]\n" \ "B.ASSEMBLE %c12, %c13, %10, 0, %c11\n" @@ -502,7 +502,7 @@ PTO_REGION_ALWAYS_INLINE void pto_region_unary_subview_assemble( "B.DIM zero, %c3, ->lb0\n" \ "B.DIM zero, %c4, ->lb1\n" \ "B.DIM zero, %c5, ->lb2\n" \ - "B.IOT %2.reuse, mask=1111, last, ->%0<%Z6>\n" \ + "B.IOT %2, mask=1111, last, ->%0<%Z6>\n" \ "B.SUBVIEW 0, %8, 0, %c9\n" \ "B.ASSEMBLE %c12, %c13, %10, 0, %c11\n" #define PTO_REGION_UNARY_SUBVIEW_CONT_BODY \ @@ -510,7 +510,7 @@ PTO_REGION_ALWAYS_INLINE void pto_region_unary_subview_assemble( "B.DIM zero, %c3, ->lb0\n" \ "B.DIM zero, %c4, ->lb1\n" \ "B.DIM zero, %c5, ->lb2\n" \ - "B.IOT %2.reuse, %0.reuse, mask=1111, last\n" \ + "B.IOT %2, %0, mask=1111, last\n" \ "B.SUBVIEW 0, %8, 0, %c9\n" \ "B.ASSEMBLE %c12, %c13, %10, 0, %c11\n" #define PTO_REGION_UNARY_SUBVIEW_ASSEMBLY_INPUTS \ @@ -705,7 +705,7 @@ PTO_REGION_ALWAYS_INLINE void pto_region_tmov_assemble( "fragment"); const uintptr_t offset = dst.range_base_units(); #define PTO_REGION_TMOV_PREFIX \ - "BSTART.TMOV %D[DataType]\n" \ + "BSTART.TLSU TMOV, %D[DataType]\n" \ PTO_TMOV_LAYOUT_ASM \ "B.DIM zero, %c[ValidCol], ->lb0\n" \ "B.DIM zero, %c[ValidRow], ->lb1\n" \ @@ -722,15 +722,15 @@ PTO_REGION_ALWAYS_INLINE void pto_region_tmov_assemble( [ElemLayout] "i"(local_layout_code_v) if constexpr (Init) { asm volatile(PTO_REGION_TMOV_PREFIX - "B.IOT %[Src].reuse, mask=1111, last, ->%[Dst]<%Z[ParentSize]>\n" + "B.IOT %[Src], mask=1111, last, ->%[Dst]<%Z[ParentSize]>\n" PTO_REGION_TMOV_ASSEMBLE : [Dst] "=Tr"(dst.template parent_data()) : PTO_REGION_TMOV_INPUTS : "memory"); } else { asm volatile(PTO_REGION_TMOV_PREFIX - "B.IOT %[Src].reuse, mask=1111, last\n" - "B.IOT %[Dst].reuse, mask=1111\n" + "B.IOT %[Src], mask=1111, last\n" + "B.IOT %[Dst], mask=1111\n" PTO_REGION_TMOV_ASSEMBLE : : [Dst] "Tr"(dst.template parent_data()), @@ -845,7 +845,7 @@ pto_region_tcvt_assemble(region::TileArrayOutputRef &dst, In &src) { "B.DIM zero, %c4, ->lb0\n" \ "B.DIM zero, %c5, ->lb1\n" #define PTO_REGION_TCVT_ASSEMBLY_SUFFIX \ - "B.IOT %3.reuse, mask=1111, last, ->%0<%Z7>\n" \ + "B.IOT %3, mask=1111, last, ->%0<%Z7>\n" \ "B.ASSEMBLE %c10, %c11, %8, 0, %c9\n" #define PTO_REGION_TCVT_ASSEMBLY_INPUTS \ "i"(type_traits::TypeCode), \ @@ -878,7 +878,7 @@ pto_region_tcvt_assemble(region::TileArrayOutputRef &dst, In &src) { // record has L=1). The math input shares the final record. if constexpr (SourceCubeM) { asm volatile(PTO_REGION_TCVT_ASSEMBLY_PREFIX - "B.IOT %3.reuse, %0.reuse, mask=1111, last\n" + "B.IOT %3, %0, mask=1111, last\n" "B.ASSEMBLE %c10, %c11, %8, 0, %c9\n" : : [Dst] "Tr"(dst.template parent_data()), @@ -887,7 +887,7 @@ pto_region_tcvt_assemble(region::TileArrayOutputRef &dst, In &src) { } else { asm volatile(PTO_REGION_TCVT_ASSEMBLY_PREFIX "B.DIM zero, %c6, ->lb2\n" - "B.IOT %3.reuse, %0.reuse, mask=1111, last\n" + "B.IOT %3, %0, mask=1111, last\n" "B.ASSEMBLE %c10, %c11, %8, 0, %c9\n" : : [Dst] "Tr"(dst.template parent_data()), @@ -979,7 +979,7 @@ PTO_REGION_ALWAYS_INLINE void pto_region_tcvt_subview_assemble( "B.DIM zero, %c4, ->lb0\n" \ "B.DIM zero, %c5, ->lb1\n" \ "B.DIM zero, %c6, ->lb2\n" \ - "B.IOT %3.reuse, mask=1111, last, ->%0<%Z7>\n" \ + "B.IOT %3, mask=1111, last, ->%0<%Z7>\n" \ "B.SUBVIEW 0, %8, 0, %c9\n" \ "B.ASSEMBLE %c12, %c13, %10, 0, %c11\n" #define PTO_REGION_TCVT_SUBVIEW_CONT_BODY \ @@ -988,7 +988,7 @@ PTO_REGION_ALWAYS_INLINE void pto_region_tcvt_subview_assemble( "B.DIM zero, %c4, ->lb0\n" \ "B.DIM zero, %c5, ->lb1\n" \ "B.DIM zero, %c6, ->lb2\n" \ - "B.IOT %3.reuse, %0.reuse, mask=1111, last\n" \ + "B.IOT %3, %0, mask=1111, last\n" \ "B.SUBVIEW 0, %8, 0, %c9\n" \ "B.ASSEMBLE %c12, %c13, %10, 0, %c11\n" #define PTO_REGION_TCVT_SUBVIEW_ASSEMBLY_INPUTS \ @@ -1087,7 +1087,7 @@ TCVT(Out &dst, region::SubTileView &src) { "B.DATR %D2, RNONE\n" "B.DIM zero, %c4, ->lb0\n" "B.DIM zero, %c5, ->lb1\n" - "B.IOT %3.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %3, mask=1111, last, ->%0<%Z6>\n" "B.SUBVIEW 0, %7, 0, %c8\n" : [Dst] "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -1105,7 +1105,7 @@ TCVT(Out &dst, region::SubTileView &src) { "B.DIM zero, %c4, ->lb0\n" "B.DIM zero, %c5, ->lb1\n" "B.DIM zero, %c6, ->lb2\n" - "B.IOT %3.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %3, mask=1111, last, ->%0<%Z7>\n" "B.SUBVIEW 0, %8, 0, %c9\n" : [Dst] "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -1149,7 +1149,7 @@ PTO_REGION_ALWAYS_INLINE void pto_region_binary( "B.DIM zero, %c4, ->lb0\n" "B.DIM zero, %c5, ->lb1\n" "B.DIM zero, %c6, ->lb2\n" - "B.IOT %2.reuse, %3.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %2, %3, mask=1111, last, ->%0<%Z7>\n" "B.SUBVIEW 0, %8, 0, %c11\n" "B.SUBVIEW 1, %9, 0, %c11\n" : [Dst] "=Tr"(dst.data()) @@ -1185,7 +1185,7 @@ PTO_REGION_ALWAYS_INLINE void pto_region_binary( "B.DIM zero, %c3, ->lb0\n" "B.DIM zero, %c4, ->lb1\n" "B.DIM zero, %c5, ->lb2\n" - "B.IOT %2.reuse, %6.reuse, mask=1111, last, ->%0<%Z9>\n" + "B.IOT %2, %6, mask=1111, last, ->%0<%Z9>\n" "B.SUBVIEW 0, %7, 0, %c8\n" : [Dst] "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -1218,7 +1218,7 @@ PTO_REGION_ALWAYS_INLINE void pto_region_binary( "B.DIM zero, %c3, ->lb0\n" "B.DIM zero, %c4, ->lb1\n" "B.DIM zero, %c5, ->lb2\n" - "B.IOT %6.reuse, %2.reuse, mask=1111, last, ->%0<%Z9>\n" + "B.IOT %6, %2, mask=1111, last, ->%0<%Z9>\n" "B.SUBVIEW 1, %7, 0, %c8\n" : [Dst] "=Tr"(dst.data()) : "i"(type_traits::TypeCode), "Tr"(src1.data()), @@ -1319,7 +1319,7 @@ PTO_REGION_ALWAYS_INLINE void pto_region_expand( "B.DIM zero, %c4, ->lb0\n" "B.DIM zero, %c5, ->lb1\n" "B.DIM zero, %c6, ->lb2\n" - "B.IOT %2.reuse, %3.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %2, %3, mask=1111, last, ->%0<%Z7>\n" "B.SUBVIEW 0, %8, 0, %c11\n" "B.SUBVIEW 1, %9, 0, %c14\n" ".if %c12 == 29\n" @@ -1384,7 +1384,7 @@ PTO_REGION_ALWAYS_INLINE void pto_region_row_expand( "B.DIM zero, %c3, ->lb0\n" "B.DIM zero, %c4, ->lb1\n" "B.DIM zero, %c5, ->lb2\n" - "B.IOT %2.reuse, %6.reuse, mask=1111, last, ->%0<%Z9>\n" + "B.IOT %2, %6, mask=1111, last, ->%0<%Z9>\n" "B.SUBVIEW 0, %7, 0, %c8\n" ".if %c11 == 29\n" ".if %c12 == 0\n" @@ -1447,7 +1447,7 @@ PTO_REGION_ALWAYS_INLINE void pto_region_row_expand( "B.DIM zero, %c3, ->lb0\n" "B.DIM zero, %c4, ->lb1\n" "B.DIM zero, %c5, ->lb2\n" - "B.IOT %6.reuse, %2.reuse, mask=1111, last, ->%0<%Z9>\n" + "B.IOT %6, %2, mask=1111, last, ->%0<%Z9>\n" "B.SUBVIEW 1, %7, 0, %c8\n" ".if %c11 == 29\n" ".if %c12 == 0\n" @@ -1498,7 +1498,7 @@ PTO_REGION_ALWAYS_INLINE void pto_region_col_expand( "B.DIM zero, %c3, ->lb0\n" "B.DIM zero, %c4, ->lb1\n" "B.DIM zero, %c5, ->lb2\n" - "B.IOT %2.reuse, %6.reuse, mask=1111, last, ->%0<%Z9>\n" + "B.IOT %2, %6, mask=1111, last, ->%0<%Z9>\n" "B.SUBVIEW 0, %7, 0, %c8\n" : [Dst] "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -1537,7 +1537,7 @@ PTO_REGION_ALWAYS_INLINE void pto_region_col_expand( "B.DIM zero, %c3, ->lb0\n" "B.DIM zero, %c4, ->lb1\n" "B.DIM zero, %c5, ->lb2\n" - "B.IOT %6.reuse, %2.reuse, mask=1111, last, ->%0<%Z9>\n" + "B.IOT %6, %2, mask=1111, last, ->%0<%Z9>\n" "B.SUBVIEW 1, %7, 0, %c8\n" : [Dst] "=Tr"(dst.data()) : "i"(type_traits::TypeCode), "Tr"(src1.data()), @@ -1645,7 +1645,7 @@ PTO_REGION_ALWAYS_INLINE void pto_region_binary_reduction_prefix( "B.DIM zero, %c4, ->lb0\n" "B.DIM %[DynValidRow], 0, ->lb1\n" "B.DIM zero, %c5, ->lb2\n" - "B.IOT %2.reuse, %3.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %2, %3, mask=1111, last, ->%0<%Z6>\n" "B.SUBVIEW 1, %7, 0, %c9\n" : [Dst] "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -1664,7 +1664,7 @@ PTO_REGION_ALWAYS_INLINE void pto_region_binary_reduction_prefix( "B.DIM zero, %c4, ->lb0\n" "B.DIM zero, %c5, ->lb1\n" "B.DIM zero, %c6, ->lb2\n" - "B.IOT %2.reuse, %3.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %2, %3, mask=1111, last, ->%0<%Z7>\n" "B.SUBVIEW 1, %8, 0, %c10\n" : [Dst] "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -1704,7 +1704,7 @@ PTO_REGION_ALWAYS_INLINE void pto_region_binary_reduction_prefix( "B.DIM zero, %c4, ->lb0\n" "B.DIM %[DynValidRow], 0, ->lb1\n" "B.DIM zero, %c5, ->lb2\n" - "B.IOT %2.reuse, %3.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %2, %3, mask=1111, last, ->%0<%Z6>\n" "B.SUBVIEW 0, %7, 0, %c9\n" : [Dst] "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -1723,7 +1723,7 @@ PTO_REGION_ALWAYS_INLINE void pto_region_binary_reduction_prefix( "B.DIM zero, %c4, ->lb0\n" "B.DIM zero, %c5, ->lb1\n" "B.DIM zero, %c6, ->lb2\n" - "B.IOT %2.reuse, %3.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %2, %3, mask=1111, last, ->%0<%Z7>\n" "B.SUBVIEW 0, %8, 0, %c10\n" : [Dst] "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -1769,7 +1769,7 @@ PTO_REGION_ALWAYS_INLINE void pto_region_binary_reduction_prefix( "B.DIM zero, %c4, ->lb0\n" "B.DIM %[DynValidRow], 0, ->lb1\n" "B.DIM zero, %c5, ->lb2\n" - "B.IOT %2.reuse, %3.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %2, %3, mask=1111, last, ->%0<%Z6>\n" "B.SUBVIEW 0, %7, 0, %c10\n" "B.SUBVIEW 1, %8, 0, %c10\n" : [Dst] "=Tr"(dst.data()) @@ -1789,7 +1789,7 @@ PTO_REGION_ALWAYS_INLINE void pto_region_binary_reduction_prefix( "B.DIM zero, %c4, ->lb0\n" "B.DIM zero, %c5, ->lb1\n" "B.DIM zero, %c6, ->lb2\n" - "B.IOT %2.reuse, %3.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %2, %3, mask=1111, last, ->%0<%Z7>\n" "B.SUBVIEW 0, %8, 0, %c11\n" "B.SUBVIEW 1, %9, 0, %c11\n" : [Dst] "=Tr"(dst.data()) @@ -1889,7 +1889,7 @@ PTO_REGION_ALWAYS_INLINE void pto_region_binary_assemble( "B.DIM zero, %c4, ->lb0\n" \ "B.DIM zero, %c5, ->lb1\n" \ "B.DIM zero, %c6, ->lb2\n" \ - "B.IOT %2.reuse, %3.reuse, mask=1111, last, ->%0<%Z7>\n" \ + "B.IOT %2, %3, mask=1111, last, ->%0<%Z7>\n" \ "B.SUBVIEW 0, %8, 0, %c12\n" \ "B.SUBVIEW 1, %9, 0, %c12\n" \ "B.ASSEMBLE %c14, %c15, %10, 0, %c13\n" @@ -1898,10 +1898,10 @@ PTO_REGION_ALWAYS_INLINE void pto_region_binary_assemble( "B.DIM zero, %c4, ->lb0\n" \ "B.DIM zero, %c5, ->lb1\n" \ "B.DIM zero, %c6, ->lb2\n" \ - "B.IOT %2.reuse, %3.reuse, mask=1111\n" \ + "B.IOT %2, %3, mask=1111\n" \ "B.SUBVIEW 0, %8, 0, %c12\n" \ "B.SUBVIEW 1, %9, 0, %c12\n" \ - "B.IOT %0.reuse, mask=1111, last\n" \ + "B.IOT %0, mask=1111, last\n" \ "B.ASSEMBLE %c14, %c15, %10, 0, %c13\n" #define PTO_REGION_BINARY_ASSEMBLY_INPUTS \ "i"(type_traits::TypeCode), \ diff --git a/include/common/pto_tileop_api_revision.hpp b/include/common/pto_tileop_api_revision.hpp index 4d5f3a4d..0cf926a1 100644 --- a/include/common/pto_tileop_api_revision.hpp +++ b/include/common/pto_tileop_api_revision.hpp @@ -1,8 +1,8 @@ #ifndef PTO_TILEOP_API_REVISION_HPP #define PTO_TILEOP_API_REVISION_HPP -#define PTO_TILEOP_API_VERSION "0.59.0" -#define PTO_TILEOP_API_SPEC_VERSION "0.59.0" +#define PTO_TILEOP_API_VERSION "0.58.7" +#define PTO_TILEOP_API_SPEC_VERSION "0.58.7" // Source-tree consumers do not necessarily build from a Git checkout. The // install target replaces these two macros with the exact checked-out commit. diff --git a/include/jcore/template_asm.hpp b/include/jcore/template_asm.hpp index d9d19ac5..1656ad31 100644 --- a/include/jcore/template_asm.hpp +++ b/include/jcore/template_asm.hpp @@ -269,7 +269,7 @@ asm volatile( PTO_CUBE_TCVT_DATR_ASM "B.DIM zero, %c5, ->lb0\n" "B.DIM zero, %c6, ->lb1\n" - "B.IOT %3.reuse, mask=1111, last, ->%0<%Z4>\n" + "B.IOT %3, mask=1111, last, ->%0<%Z4>\n" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), "i"(type_traits::TypeCode), @@ -286,7 +286,7 @@ asm volatile( PTO_CUBE_TCVT_DATR_ASM "B.DIM zero, %c5, ->lb0\n" "B.DIM %[tcvt_row], 0, ->lb1\n" - "B.IOT %3.reuse, mask=1111, last, ->%0<%Z4>\n" + "B.IOT %3, mask=1111, last, ->%0<%Z4>\n" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), "i"(type_traits::TypeCode), @@ -303,7 +303,7 @@ asm volatile( PTO_CUBE_TCVT_DATR_ASM "B.DIM %[tcvt_col], 0, ->lb0\n" "B.DIM zero, %c6, ->lb1\n" - "B.IOT %3.reuse, mask=1111, last, ->%0<%Z4>\n" + "B.IOT %3, mask=1111, last, ->%0<%Z4>\n" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), "i"(type_traits::TypeCode), @@ -320,7 +320,7 @@ asm volatile( PTO_CUBE_TCVT_DATR_ASM "B.DIM %[tcvt_col], 0, ->lb0\n" "B.DIM %[tcvt_row], 0, ->lb1\n" - "B.IOT %3.reuse, mask=1111, last, ->%0<%Z4>\n" + "B.IOT %3, mask=1111, last, ->%0<%Z4>\n" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), "i"(type_traits::TypeCode), @@ -380,7 +380,7 @@ asm volatile( "B.DIM zero, %c5, ->lb0\n" "B.DIM zero, %c6, ->lb1\n" "B.DIM zero, %c7, ->lb2\n" - "B.IOT %3.reuse, mask=1111, last, ->%0<%Z4>\n" + "B.IOT %3, mask=1111, last, ->%0<%Z4>\n" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), "i"(type_traits::TypeCode), @@ -406,7 +406,7 @@ asm volatile( "B.DIM zero, %c5, ->lb0\n" "B.DIM %[tcvt_row], 0, ->lb1\n" "B.DIM zero, %c7, ->lb2\n" - "B.IOT %3.reuse, mask=1111, last, ->%0<%Z4>\n" + "B.IOT %3, mask=1111, last, ->%0<%Z4>\n" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), "i"(type_traits::TypeCode), @@ -432,7 +432,7 @@ asm volatile( "B.DIM %[tcvt_col], 0, ->lb0\n" "B.DIM zero, %c6, ->lb1\n" "B.DIM zero, %c7, ->lb2\n" - "B.IOT %3.reuse, mask=1111, last, ->%0<%Z4>\n" + "B.IOT %3, mask=1111, last, ->%0<%Z4>\n" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), "i"(type_traits::TypeCode), @@ -458,7 +458,7 @@ asm volatile( "B.DIM %[tcvt_col], 0, ->lb0\n" "B.DIM %[tcvt_row], 0, ->lb1\n" "B.DIM zero, %c7, ->lb2\n" - "B.IOT %3.reuse, mask=1111, last, ->%0<%Z4>\n" + "B.IOT %3, mask=1111, last, ->%0<%Z4>\n" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), "i"(type_traits::TypeCode), @@ -492,12 +492,12 @@ inline void TMOV(Tile &dst, const Tile &src) { const size_t valid_row = src.GetValidRow(); if constexpr (Tile::ValidCol > 0 && Tile::ValidRow > 0) { asm volatile( - "BSTART.TMOV %D[DataType]\n" + "BSTART.TLSU TMOV, %D[DataType]\n" PTO_TMOV_LAYOUT_ASM "B.DIM zero, %c[ValidCol], ->lb0\n" "B.DIM zero, %c[ValidRow], ->lb1\n" "B.DIM zero, %c[PhysicalCol], ->lb2\n" - "B.IOT %[Src].reuse, mask=1111, last, ->%[Dst]<%Z[TileSize]>\n" + "B.IOT %[Src], mask=1111, last, ->%[Dst]<%Z[TileSize]>\n" : [Dst] "=&Tr"(dst.data()) : [Src] "Tr"(src.data()), [DataType] "i"(type_traits::TypeCode), @@ -508,12 +508,12 @@ asm volatile( [ElemLayout] "i"(local_layout_code_v)); } else if constexpr (Tile::ValidCol > 0 && Tile::ValidRow < 0) { asm volatile( - "BSTART.TMOV %D[DataType]\n" + "BSTART.TLSU TMOV, %D[DataType]\n" PTO_TMOV_LAYOUT_ASM "B.DIM zero, %c[ValidCol], ->lb0\n" "B.DIM %[ValidRow], 0, ->lb1\n" "B.DIM zero, %c[PhysicalCol], ->lb2\n" - "B.IOT %[Src].reuse, mask=1111, last, ->%[Dst]<%Z[TileSize]>\n" + "B.IOT %[Src], mask=1111, last, ->%[Dst]<%Z[TileSize]>\n" : [Dst] "=&Tr"(dst.data()) : [Src] "Tr"(src.data()), [DataType] "i"(type_traits::TypeCode), @@ -524,12 +524,12 @@ asm volatile( [ElemLayout] "i"(local_layout_code_v)); } else if constexpr (Tile::ValidCol < 0 && Tile::ValidRow > 0) { asm volatile( - "BSTART.TMOV %D[DataType]\n" + "BSTART.TLSU TMOV, %D[DataType]\n" PTO_TMOV_LAYOUT_ASM "B.DIM %[ValidCol], 0, ->lb0\n" "B.DIM zero, %c[ValidRow], ->lb1\n" "B.DIM zero, %c[PhysicalCol], ->lb2\n" - "B.IOT %[Src].reuse, mask=1111, last, ->%[Dst]<%Z[TileSize]>\n" + "B.IOT %[Src], mask=1111, last, ->%[Dst]<%Z[TileSize]>\n" : [Dst] "=&Tr"(dst.data()) : [Src] "Tr"(src.data()), [DataType] "i"(type_traits::TypeCode), @@ -540,12 +540,12 @@ asm volatile( [ElemLayout] "i"(local_layout_code_v)); } else { asm volatile( - "BSTART.TMOV %D[DataType]\n" + "BSTART.TLSU TMOV, %D[DataType]\n" PTO_TMOV_LAYOUT_ASM "B.DIM %[ValidCol], 0, ->lb0\n" "B.DIM %[ValidRow], 0, ->lb1\n" "B.DIM zero, %c[PhysicalCol], ->lb2\n" - "B.IOT %[Src].reuse, mask=1111, last, ->%[Dst]<%Z[TileSize]>\n" + "B.IOT %[Src], mask=1111, last, ->%[Dst]<%Z[TileSize]>\n" : [Dst] "=&Tr"(dst.data()) : [Src] "Tr"(src.data()), [DataType] "i"(type_traits::TypeCode), @@ -574,12 +574,12 @@ PTO_SHARED_INLINE void TMOV(Tile &dst, "Local B.SUBVIEW size must fit SizeCode 1..10"); const uintptr_t range_base = src.GetRangeBase(); asm volatile( - "BSTART.TMOV %D[DataType]\n" + "BSTART.TLSU TMOV, %D[DataType]\n" PTO_TMOV_LAYOUT_ASM "B.DIM zero, %c[ValidCol], ->lb0\n" "B.DIM zero, %c[ValidRow], ->lb1\n" "B.DIM zero, %c[PhysicalCol], ->lb2\n" - "B.IOT %[Src].reuse, mask=1111, last, ->%[Dst]<%Z[TileSize]>\n" + "B.IOT %[Src], mask=1111, last, ->%[Dst]<%Z[TileSize]>\n" "B.SUBVIEW 0, %[RangeBase], 0, %c[SubviewSize]\n" : [Dst] "=&Tr"(dst.data()) : [Src] "Tr"(src.data()), @@ -608,7 +608,7 @@ void TLOAD2_ND2NZ(tile_shape &dst1, tile_shape &dst0, gm_shape &src) { "GM_SHAPE should ND and TILE_SHAPE should be Nz "); if constexpr (tile_shape::ValidCol > 0 && tile_shape::ValidRow > 0) { asm volatile( - "BSTART.TLOAD %D[__pto_SrcType]\n" + "BSTART.TLSU TLOAD, %D[__pto_SrcType]\n" "B.DATR ND2NZ, %D[__pto_DstType], Null\n" "B.DIM zero, %c[__pto_VCOL], ->lb0\n" "B.DIM zero, %c[__pto_VROW], ->lb1\n" @@ -626,7 +626,7 @@ asm volatile( : "memory"); } else if constexpr (tile_shape::ValidCol > 0 && tile_shape::ValidRow < 0) { asm volatile( - "BSTART.TLOAD %D[__pto_SrcType]\n" + "BSTART.TLSU TLOAD, %D[__pto_SrcType]\n" "B.DATR ND2NZ, %D[__pto_DstType], Null\n" "B.DIM zero, %c[__pto_VCOL], ->lb0\n" "B.DIM %[__pto_VROW], 0, ->lb1\n" @@ -644,7 +644,7 @@ asm volatile( : "memory"); } else if constexpr (tile_shape::ValidCol < 0 && tile_shape::ValidRow > 0) { asm volatile( - "BSTART.TLOAD %D[__pto_SrcType]\n" + "BSTART.TLSU TLOAD, %D[__pto_SrcType]\n" "B.DATR ND2NZ, %D[__pto_DstType], Null\n" "B.DIM %[__pto_VCOL], 0, ->lb0\n" "B.DIM zero, %c[__pto_VROW], ->lb1\n" @@ -662,7 +662,7 @@ asm volatile( : "memory"); } else { asm volatile( - "BSTART.TLOAD %D[__pto_SrcType]\n" + "BSTART.TLSU TLOAD, %D[__pto_SrcType]\n" "B.DATR ND2NZ, %D[__pto_DstType], Null\n" "B.DIM %[__pto_VCOL], 0, ->lb0\n" "B.DIM %[__pto_VROW], 0, ->lb1\n" @@ -686,7 +686,7 @@ void TLOAD2_ND2ZN(tile_shape &dst1, tile_shape &dst0, gm_shape &src) { "GM_SHAPE should ND and TILE_SHAPE should be Zn "); if constexpr (tile_shape::ValidCol > 0 && tile_shape::ValidRow > 0) { asm volatile( - "BSTART.TLOAD %D[__pto_SrcType]\n" + "BSTART.TLSU TLOAD, %D[__pto_SrcType]\n" "B.DATR ND2ZN, %D[__pto_DstType], Null\n" "B.DIM zero, %c[__pto_VCOL], ->lb0\n" "B.DIM zero, %c[__pto_VROW], ->lb1\n" @@ -704,7 +704,7 @@ asm volatile( : "memory"); } else if constexpr (tile_shape::ValidCol > 0 && tile_shape::ValidRow < 0) { asm volatile( - "BSTART.TLOAD %D[__pto_SrcType]\n" + "BSTART.TLSU TLOAD, %D[__pto_SrcType]\n" "B.DATR ND2ZN, %D[__pto_DstType], Null\n" "B.DIM zero, %c[__pto_VCOL], ->lb0\n" "B.DIM %[__pto_VROW], 0, ->lb1\n" @@ -722,7 +722,7 @@ asm volatile( : "memory"); } else if constexpr (tile_shape::ValidCol < 0 && tile_shape::ValidRow > 0) { asm volatile( - "BSTART.TLOAD %D[__pto_SrcType]\n" + "BSTART.TLSU TLOAD, %D[__pto_SrcType]\n" "B.DATR ND2ZN, %D[__pto_DstType], Null\n" "B.DIM %[__pto_VCOL], 0, ->lb0\n" "B.DIM zero, %c[__pto_VROW], ->lb1\n" @@ -740,7 +740,7 @@ asm volatile( : "memory"); } else { asm volatile( - "BSTART.TLOAD %D[__pto_SrcType]\n" + "BSTART.TLSU TLOAD, %D[__pto_SrcType]\n" "B.DATR ND2ZN, %D[__pto_DstType], Null\n" "B.DIM %[__pto_VCOL], 0, ->lb0\n" "B.DIM %[__pto_VROW], 0, ->lb1\n" @@ -763,7 +763,7 @@ void TLOAD2_DN2ZN(tile_shape &dst1, tile_shape &dst0, gm_shape &src) { static_assert(!gm_shape::isRowMajor && is_Nz_layout::value, "GM_SHAPE should DN and TILE_SHAPE should be Zn "); asm volatile( - "BSTART.TLOAD %D[__pto_SrcType]\n" + "BSTART.TLSU TLOAD, %D[__pto_SrcType]\n" "B.DATR DN2ZN, %D[__pto_DstType], Null\n" "B.DIM %[__pto_VCOL], 0, ->lb0\n" "B.DIM %[__pto_VROW], 0, ->lb1\n" @@ -787,12 +787,12 @@ void TSTORE2_DN2DN(gm_shape &dst, tile_shape &src1, tile_shape &src0) { "GM_SHAPE should DN and TILE_SHAPE should be DN"); if constexpr (tile_shape::ValidCol > 0 && tile_shape::ValidRow > 0) { asm volatile( - "BSTART.TSTORE %D[__pto_SrcType]\n" + "BSTART.TLSU TSTORE, %D[__pto_SrcType]\n" "B.DATR NORM, %D[__pto_DstType], Null\n" "B.DIM zero, %c[__pto_VCOL], ->lb0\n" "B.DIM zero, %c[__pto_VROW], ->lb1\n" "B.DIM zero, %c[__pto_COL], ->lb2\n" - "B.IOT %[__pto_s0].reuse, %[s1].reuse, mask=1111, last\n" + "B.IOT %[__pto_s0], %[s1], mask=1111, last\n" "B.IOR [%[__pto_d0],%[__pto_GmStride]], []\n" : : [__pto_d0]"r"(dst.data()), [__pto_s0]"Tr"(src0.data()), [s1]"Tr"(src1.data()), @@ -803,12 +803,12 @@ asm volatile( : "memory"); } else if constexpr (tile_shape::ValidCol > 0 && tile_shape::ValidRow < 0) { asm volatile( - "BSTART.TSTORE %D[__pto_SrcType]\n" + "BSTART.TLSU TSTORE, %D[__pto_SrcType]\n" "B.DATR NORM, %D[__pto_DstType], Null\n" "B.DIM zero, %c[__pto_VCOL], ->lb0\n" "B.DIM %[__pto_VROW], 0, ->lb1\n" "B.DIM zero, %c[__pto_COL], ->lb2\n" - "B.IOT %[__pto_s0].reuse, %[s1].reuse, mask=1111, last\n" + "B.IOT %[__pto_s0], %[s1], mask=1111, last\n" "B.IOR [%[__pto_d0],%[__pto_GmStride]], []\n" : : [__pto_d0]"r"(dst.data()), [__pto_s0]"Tr"(src0.data()), [s1]"Tr"(src1.data()), @@ -819,12 +819,12 @@ asm volatile( : "memory"); } else if constexpr (tile_shape::ValidCol < 0 && tile_shape::ValidRow > 0) { asm volatile( - "BSTART.TSTORE %D[__pto_SrcType]\n" + "BSTART.TLSU TSTORE, %D[__pto_SrcType]\n" "B.DATR NORM, %D[__pto_DstType], Null\n" "B.DIM %[__pto_VCOL], 0, ->lb0\n" "B.DIM zero, %c[__pto_VROW], ->lb1\n" "B.DIM zero, %c[__pto_COL], ->lb2\n" - "B.IOT %[__pto_s0].reuse, %[s1].reuse, mask=1111, last\n" + "B.IOT %[__pto_s0], %[s1], mask=1111, last\n" "B.IOR [%[__pto_d0],%[__pto_GmStride]], []\n" : : [__pto_d0]"r"(dst.data()), [__pto_s0]"Tr"(src0.data()), [s1]"Tr"(src1.data()), @@ -835,12 +835,12 @@ asm volatile( : "memory"); } else { asm volatile( - "BSTART.TSTORE %D[__pto_SrcType]\n" + "BSTART.TLSU TSTORE, %D[__pto_SrcType]\n" "B.DATR NORM, %D[__pto_DstType], Null\n" "B.DIM %[__pto_VCOL], 0, ->lb0\n" "B.DIM %[__pto_VROW], 0, ->lb1\n" "B.DIM zero, %c[__pto_COL], ->lb2\n" - "B.IOT %[__pto_s0].reuse, %[s1].reuse, mask=1111, last\n" + "B.IOT %[__pto_s0], %[s1], mask=1111, last\n" "B.IOR [%[__pto_d0],%[__pto_GmStride]], []\n" : : [__pto_d0]"r"(dst.data()), [__pto_s0]"Tr"(src0.data()), [s1]"Tr"(src1.data()), @@ -856,7 +856,7 @@ void TLOAD4_ND2NZ(tile_shape &dst3, tile_shape &dst2, tile_shape &dst1, tile_sha static_assert(gm_shape::isRowMajor && is_Nz_layout::value, "GM_SHAPE should ND and TILE_SHAPE should be Nz "); asm volatile( - "BSTART.TLOAD %D[__pto_SrcType]\n" + "BSTART.TLSU TLOAD, %D[__pto_SrcType]\n" "B.DATR ND2NZ, %D[__pto_DstType], Null\n" "B.DIM %[__pto_VCOL], 0, ->lb0\n" "B.DIM %[__pto_VROW], 0, ->lb1\n" @@ -881,7 +881,7 @@ void TLOAD4_ND2ZN(tile_shape &dst3, tile_shape &dst2, tile_shape &dst1, tile_sha static_assert(gm_shape::isRowMajor && is_Zn_layout::value, "GM_SHAPE should ND and TILE_SHAPE should be Nz "); asm volatile( - "BSTART.TLOAD %D[__pto_SrcType]\n" + "BSTART.TLSU TLOAD, %D[__pto_SrcType]\n" "B.DATR ND2ZN, %D[__pto_DstType], Null\n" "B.DIM %[__pto_VCOL], 0, ->lb0\n" "B.DIM %[__pto_VROW], 0, ->lb1\n" @@ -906,7 +906,7 @@ void TLOAD4_DN2ZN(tile_shape &dst3, tile_shape &dst2, tile_shape &dst1, tile_sha static_assert(!gm_shape::isRowMajor && is_Zn_layout::value, "GM_SHAPE should DN and TILE_SHAPE should be Zn "); asm volatile( - "BSTART.TLOAD %D[__pto_SrcType]\n" + "BSTART.TLSU TLOAD, %D[__pto_SrcType]\n" "B.DATR DN2ZN, %D[__pto_DstType], Null\n" "B.DIM %[__pto_VCOL], 0, ->lb0\n" "B.DIM %[__pto_VROW], 0, ->lb1\n" @@ -968,12 +968,12 @@ inline void MGATHER(tile_shape_out &dst, const gm_shape &src, "per DavinciOO v5 B.IOT encoding"); if constexpr (tile_shape_offset::ValidCol > 0 && tile_shape_offset::ValidRow > 0) { asm volatile( - "BSTART.MGATHER %D[DataType]\n" + "BSTART.TLSU MGATHER, %D[DataType]\n" PTO_GATHER_PAD_ASM "B.DIM zero, %c[ValidCol], ->LB0\n" "B.DIM zero, %c[ValidRow], ->LB1\n" "B.DIM zero, %c[Col], ->LB2\n" - "B.IOT %[off].reuse, mask=1111, last, ->%[dst]<%Z[TileSize]>\n" + "B.IOT %[off], mask=1111, last, ->%[dst]<%Z[TileSize]>\n" "B.IOR [%[base]], []\n" : [dst] "=Tr"(dst.data()) : [base] "r"(src.data()), [off] "Tr"(offset.data()), @@ -988,12 +988,12 @@ asm volatile( : "memory"); } else if constexpr (tile_shape_offset::ValidCol > 0 && tile_shape_offset::ValidRow < 0) { asm volatile( - "BSTART.MGATHER %D[DataType]\n" + "BSTART.TLSU MGATHER, %D[DataType]\n" PTO_GATHER_PAD_ASM "B.DIM zero, %c[ValidCol], ->LB0\n" "B.DIM %[ValidRow], 0, ->LB1\n" "B.DIM zero, %c[Col], ->LB2\n" - "B.IOT %[off].reuse, mask=1111, last, ->%[dst]<%Z[TileSize]>\n" + "B.IOT %[off], mask=1111, last, ->%[dst]<%Z[TileSize]>\n" "B.IOR [%[base]], []\n" : [dst] "=Tr"(dst.data()) : [base] "r"(src.data()), [off] "Tr"(offset.data()), @@ -1008,12 +1008,12 @@ asm volatile( : "memory"); } else if constexpr (tile_shape_offset::ValidCol < 0 && tile_shape_offset::ValidRow > 0) { asm volatile( - "BSTART.MGATHER %D[DataType]\n" + "BSTART.TLSU MGATHER, %D[DataType]\n" PTO_GATHER_PAD_ASM "B.DIM %[ValidCol], 0, ->LB0\n" "B.DIM zero, %c[ValidRow], ->LB1\n" "B.DIM zero, %c[Col], ->LB2\n" - "B.IOT %[off].reuse, mask=1111, last, ->%[dst]<%Z[TileSize]>\n" + "B.IOT %[off], mask=1111, last, ->%[dst]<%Z[TileSize]>\n" "B.IOR [%[base]], []\n" : [dst] "=Tr"(dst.data()) : [base] "r"(src.data()), [off] "Tr"(offset.data()), @@ -1028,12 +1028,12 @@ asm volatile( : "memory"); } else { asm volatile( - "BSTART.MGATHER %D[DataType]\n" + "BSTART.TLSU MGATHER, %D[DataType]\n" PTO_GATHER_PAD_ASM "B.DIM %[ValidCol], 0, ->LB0\n" "B.DIM %[ValidRow], 0, ->LB1\n" "B.DIM zero, %c[Col], ->LB2\n" - "B.IOT %[off].reuse, mask=1111, last, ->%[dst]<%Z[TileSize]>\n" + "B.IOT %[off], mask=1111, last, ->%[dst]<%Z[TileSize]>\n" "B.IOR [%[base]], []\n" : [dst] "=Tr"(dst.data()) : [base] "r"(src.data()), [off] "Tr"(offset.data()), @@ -1058,12 +1058,12 @@ inline void MSCATTER(gm_shape &dst, const tile_shape_in &src, "per DavinciOO v5 B.IOT encoding"); if constexpr (tile_shape_offset::ValidCol > 0 && tile_shape_offset::ValidRow > 0) { asm volatile( - "BSTART.MSCATTER %D[DataType]\n" + "BSTART.TLSU MSCATTER, %D[DataType]\n" PTO_SCATTER_LAYOUT_ASM "B.DIM zero, %c[ValidCol], ->LB0\n" "B.DIM zero, %c[ValidRow], ->LB1\n" "B.DIM zero, %c[Col], ->LB2\n" - "B.IOT %[src].reuse, %[off].reuse, mask=1111, last\n" + "B.IOT %[src], %[off], mask=1111, last\n" "B.IOR [%[base]], []\n" : : [base] "r"(dst.data()), [src] "Tr"(src.data()), @@ -1076,12 +1076,12 @@ asm volatile( : "memory"); } else if constexpr (tile_shape_offset::ValidCol > 0 && tile_shape_offset::ValidRow < 0) { asm volatile( - "BSTART.MSCATTER %D[DataType]\n" + "BSTART.TLSU MSCATTER, %D[DataType]\n" PTO_SCATTER_LAYOUT_ASM "B.DIM zero, %c[ValidCol], ->LB0\n" "B.DIM %[ValidRow], 0, ->LB1\n" "B.DIM zero, %c[Col], ->LB2\n" - "B.IOT %[src].reuse, %[off].reuse, mask=1111, last\n" + "B.IOT %[src], %[off], mask=1111, last\n" "B.IOR [%[base]], []\n" : : [base] "r"(dst.data()), [src] "Tr"(src.data()), @@ -1094,12 +1094,12 @@ asm volatile( : "memory"); } else if constexpr (tile_shape_offset::ValidCol < 0 && tile_shape_offset::ValidRow > 0) { asm volatile( - "BSTART.MSCATTER %D[DataType]\n" + "BSTART.TLSU MSCATTER, %D[DataType]\n" PTO_SCATTER_LAYOUT_ASM "B.DIM %[ValidCol], 0, ->LB0\n" "B.DIM zero, %c[ValidRow], ->LB1\n" "B.DIM zero, %c[Col], ->LB2\n" - "B.IOT %[src].reuse, %[off].reuse, mask=1111, last\n" + "B.IOT %[src], %[off], mask=1111, last\n" "B.IOR [%[base]], []\n" : : [base] "r"(dst.data()), [src] "Tr"(src.data()), @@ -1112,12 +1112,12 @@ asm volatile( : "memory"); } else { asm volatile( - "BSTART.MSCATTER %D[DataType]\n" + "BSTART.TLSU MSCATTER, %D[DataType]\n" PTO_SCATTER_LAYOUT_ASM "B.DIM %[ValidCol], 0, ->LB0\n" "B.DIM %[ValidRow], 0, ->LB1\n" "B.DIM zero, %c[Col], ->LB2\n" - "B.IOT %[src].reuse, %[off].reuse, mask=1111, last\n" + "B.IOT %[src], %[off], mask=1111, last\n" "B.IOR [%[base]], []\n" : : [base] "r"(dst.data()), [src] "Tr"(src.data()), @@ -1142,12 +1142,12 @@ inline void MGATHER_MASK(tile_shape_out &dst, const gm_shape &src, "per DavinciOO v5 B.IOT encoding"); if constexpr (tile_shape_offset::ValidCol > 0 && tile_shape_offset::ValidRow > 0) { asm volatile( - "BSTART.MGATHER.MASK %D[DataType]\n" + "BSTART.TLSU MGATHER.MASK, %D[DataType]\n" PTO_GATHER_PAD_ASM "B.DIM zero, %c[ValidCol], ->LB0\n" "B.DIM zero, %c[ValidRow], ->LB1\n" "B.DIM zero, %c[Col], ->LB2\n" - "B.IOT %[off].reuse, %[mask].reuse, mask=1111, last, ->%[dst]<%Z[TileSize]>\n" + "B.IOT %[off], %[mask], mask=1111, last, ->%[dst]<%Z[TileSize]>\n" "B.IOR [%[base]], []\n" : [dst] "=Tr"(dst.data()) : [base] "r"(src.data()), [off] "Tr"(offset.data()), @@ -1163,12 +1163,12 @@ asm volatile( : "memory"); } else if constexpr (tile_shape_offset::ValidCol > 0 && tile_shape_offset::ValidRow < 0) { asm volatile( - "BSTART.MGATHER.MASK %D[DataType]\n" + "BSTART.TLSU MGATHER.MASK, %D[DataType]\n" PTO_GATHER_PAD_ASM "B.DIM zero, %c[ValidCol], ->LB0\n" "B.DIM %[ValidRow], 0, ->LB1\n" "B.DIM zero, %c[Col], ->LB2\n" - "B.IOT %[off].reuse, %[mask].reuse, mask=1111, last, ->%[dst]<%Z[TileSize]>\n" + "B.IOT %[off], %[mask], mask=1111, last, ->%[dst]<%Z[TileSize]>\n" "B.IOR [%[base]], []\n" : [dst] "=Tr"(dst.data()) : [base] "r"(src.data()), [off] "Tr"(offset.data()), @@ -1184,12 +1184,12 @@ asm volatile( : "memory"); } else if constexpr (tile_shape_offset::ValidCol < 0 && tile_shape_offset::ValidRow > 0) { asm volatile( - "BSTART.MGATHER.MASK %D[DataType]\n" + "BSTART.TLSU MGATHER.MASK, %D[DataType]\n" PTO_GATHER_PAD_ASM "B.DIM %[ValidCol], 0, ->LB0\n" "B.DIM zero, %c[ValidRow], ->LB1\n" "B.DIM zero, %c[Col], ->LB2\n" - "B.IOT %[off].reuse, %[mask].reuse, mask=1111, last, ->%[dst]<%Z[TileSize]>\n" + "B.IOT %[off], %[mask], mask=1111, last, ->%[dst]<%Z[TileSize]>\n" "B.IOR [%[base]], []\n" : [dst] "=Tr"(dst.data()) : [base] "r"(src.data()), [off] "Tr"(offset.data()), @@ -1205,12 +1205,12 @@ asm volatile( : "memory"); } else { asm volatile( - "BSTART.MGATHER.MASK %D[DataType]\n" + "BSTART.TLSU MGATHER.MASK, %D[DataType]\n" PTO_GATHER_PAD_ASM "B.DIM %[ValidCol], 0, ->LB0\n" "B.DIM %[ValidRow], 0, ->LB1\n" "B.DIM zero, %c[Col], ->LB2\n" - "B.IOT %[off].reuse, %[mask].reuse, mask=1111, last, ->%[dst]<%Z[TileSize]>\n" + "B.IOT %[off], %[mask], mask=1111, last, ->%[dst]<%Z[TileSize]>\n" "B.IOR [%[base]], []\n" : [dst] "=Tr"(dst.data()) : [base] "r"(src.data()), [off] "Tr"(offset.data()), @@ -1237,13 +1237,13 @@ inline void MSCATTER_MASK(gm_shape &dst, const tile_shape_in &src, "per DavinciOO v5 B.IOT encoding"); if constexpr (tile_shape_offset::ValidCol > 0 && tile_shape_offset::ValidRow > 0) { asm volatile( - "BSTART.MSCATTER.MASK %D[DataType]\n" + "BSTART.TLSU MSCATTER.MASK, %D[DataType]\n" PTO_SCATTER_LAYOUT_ASM "B.DIM zero, %c[ValidCol], ->LB0\n" "B.DIM zero, %c[ValidRow], ->LB1\n" "B.DIM zero, %c[Col], ->LB2\n" - "B.IOT %[src].reuse, %[off].reuse, mask=1111\n" - "B.IOT %[mask].reuse, mask=1111, last\n" + "B.IOT %[src], %[off], mask=1111\n" + "B.IOT %[mask], mask=1111, last\n" "B.IOR [%[base]], []\n" : : [base] "r"(dst.data()), [src] "Tr"(src.data()), @@ -1256,13 +1256,13 @@ asm volatile( : "memory"); } else if constexpr (tile_shape_offset::ValidCol > 0 && tile_shape_offset::ValidRow < 0) { asm volatile( - "BSTART.MSCATTER.MASK %D[DataType]\n" + "BSTART.TLSU MSCATTER.MASK, %D[DataType]\n" PTO_SCATTER_LAYOUT_ASM "B.DIM zero, %c[ValidCol], ->LB0\n" "B.DIM %[ValidRow], 0, ->LB1\n" "B.DIM zero, %c[Col], ->LB2\n" - "B.IOT %[src].reuse, %[off].reuse, mask=1111\n" - "B.IOT %[mask].reuse, mask=1111, last\n" + "B.IOT %[src], %[off], mask=1111\n" + "B.IOT %[mask], mask=1111, last\n" "B.IOR [%[base]], []\n" : : [base] "r"(dst.data()), [src] "Tr"(src.data()), @@ -1275,13 +1275,13 @@ asm volatile( : "memory"); } else if constexpr (tile_shape_offset::ValidCol < 0 && tile_shape_offset::ValidRow > 0) { asm volatile( - "BSTART.MSCATTER.MASK %D[DataType]\n" + "BSTART.TLSU MSCATTER.MASK, %D[DataType]\n" PTO_SCATTER_LAYOUT_ASM "B.DIM %[ValidCol], 0, ->LB0\n" "B.DIM zero, %c[ValidRow], ->LB1\n" "B.DIM zero, %c[Col], ->LB2\n" - "B.IOT %[src].reuse, %[off].reuse, mask=1111\n" - "B.IOT %[mask].reuse, mask=1111, last\n" + "B.IOT %[src], %[off], mask=1111\n" + "B.IOT %[mask], mask=1111, last\n" "B.IOR [%[base]], []\n" : : [base] "r"(dst.data()), [src] "Tr"(src.data()), @@ -1294,13 +1294,13 @@ asm volatile( : "memory"); } else { asm volatile( - "BSTART.MSCATTER.MASK %D[DataType]\n" + "BSTART.TLSU MSCATTER.MASK, %D[DataType]\n" PTO_SCATTER_LAYOUT_ASM "B.DIM %[ValidCol], 0, ->LB0\n" "B.DIM %[ValidRow], 0, ->LB1\n" "B.DIM zero, %c[Col], ->LB2\n" - "B.IOT %[src].reuse, %[off].reuse, mask=1111\n" - "B.IOT %[mask].reuse, mask=1111, last\n" + "B.IOT %[src], %[off], mask=1111\n" + "B.IOT %[mask], mask=1111, last\n" "B.IOR [%[base]], []\n" : : [base] "r"(dst.data()), [src] "Tr"(src.data()), @@ -2488,7 +2488,7 @@ blkv_bf16x2_max(const BLKV_BF16X2_TYPE &src_l, // // Block-start function values per the pinned LinxISA v0.58 catalog // (contracts/linxisa-v0.58-engine-ops.json): -// named TLSU starts: BSTART.TLOAD/TSTORE/TMOV/TPREFETCH/MGATHER/MSCATTER +// named TLSU starts: BSTART.TLSU TLOAD/TSTORE/TMOV/TPREFETCH/MGATHER/MSCATTER // MGATHER_MASK=6 MSCATTER_MASK=7 MGATHER_CAS=8 GMOV=13 // named CUBE starts: TMATMUL, TMATMUL.BIAS, TMATMUL.ACC, TMATMULMX, // TMATMULMX.BIAS=5, TMATMULMX.ACC=6, @@ -2498,11 +2498,11 @@ blkv_bf16x2_max(const BLKV_BF16X2_TYPE &src_l, // are rendered from the TEPL Mode/Function carrier without changing encoding. // The historical `TMATMUL*.FIXP` suffix was an implementation-local name; // PTO-ISA 0.58 carries post-processing through the B.FPATR attribute, so the -// canonical emission is `BSTART.TMATMUL` + `B.FPATR`. +// canonical emission is `BSTART.CUBE TMATMUL` + `B.FPATR`. // All variants below are the NORM (no layout conversion) generic form. //===----------------------------------------------------------------------===// -// TLOAD: GM -> Local Tile (BSTART.TLOAD). dst[i,j] = src[r0+i, c0+j]. +// TLOAD: GM -> Local Tile (BSTART.TLSU TLOAD). dst[i,j] = src[r0+i, c0+j]. template requires(!tile_shape::IsCubeLayout) void TLOAD(tile_shape &dst, gm_shape &src) { @@ -2539,7 +2539,7 @@ void TLOAD(tile_shape &dst, gm_shape &src) { const uintptr_t range_base = static_cast(dst.GetRangeBase()); asm volatile( - "BSTART.TLOAD %D[SrcType]\n" + "BSTART.TLSU TLOAD, %D[SrcType]\n" "B.DIM zero, %c[VCOL], ->lb0\n" "B.DIM zero, %c[VROW], ->lb1\n" "B.DIM zero, %c[COL], ->lb2\n" @@ -2565,7 +2565,7 @@ void TLOAD(tile_shape &dst, gm_shape &src) { register uintptr_t range_base asm("r" #N) = \ static_cast(dst.GetRangeBase()); \ asm volatile( \ - "BSTART.TLOAD %D[SrcType]\n" \ + "BSTART.TLSU TLOAD, %D[SrcType]\n" \ "B.DIM zero, %c[VCOL], ->lb0\n" \ "B.DIM zero, %c[VROW], ->lb1\n" \ "B.DIM zero, %c[COL], ->lb2\n" \ @@ -2608,7 +2608,7 @@ void TLOAD(tile_shape &dst, gm_shape &src) { const uintptr_t range_base = static_cast(dst.GetRangeBase()); asm volatile( - "BSTART.TLOAD %D[SrcType]\n" + "BSTART.TLSU TLOAD, %D[SrcType]\n" "B.DIM zero, %c[VCOL], ->lb0\n" "B.DIM zero, %c[VROW], ->lb1\n" "B.DIM zero, %c[COL], ->lb2\n" @@ -2634,7 +2634,7 @@ void TLOAD(tile_shape &dst, gm_shape &src) { register uintptr_t range_base asm("r" #N) = \ static_cast(dst.GetRangeBase()); \ asm volatile( \ - "BSTART.TLOAD %D[SrcType]\n" \ + "BSTART.TLSU TLOAD, %D[SrcType]\n" \ "B.DIM zero, %c[VCOL], ->lb0\n" \ "B.DIM zero, %c[VROW], ->lb1\n" \ "B.DIM zero, %c[COL], ->lb2\n" \ @@ -2676,7 +2676,7 @@ void TLOAD(tile_shape &dst, gm_shape &src) { // form. Per-dim SS/SD/DS/DD dispatch mirrors TLOAD_CUBE. if constexpr (tile_shape::ValidCol > 0 && tile_shape::ValidRow > 0) { asm volatile( - "BSTART.TLOAD %D[SrcType]\n" + "BSTART.TLSU TLOAD, %D[SrcType]\n" "B.DIM zero, %c[VCOL], ->lb0\n" "B.DIM zero, %c[VROW], ->lb1\n" "B.DIM zero, %c[COL], ->lb2\n" @@ -2692,7 +2692,7 @@ void TLOAD(tile_shape &dst, gm_shape &src) { : "memory"); } else if constexpr (tile_shape::ValidCol > 0 && tile_shape::ValidRow < 0) { asm volatile( - "BSTART.TLOAD %D[SrcType]\n" + "BSTART.TLSU TLOAD, %D[SrcType]\n" "B.DIM zero, %c[VCOL], ->lb0\n" "B.DIM %[VROW], 0, ->lb1\n" "B.DIM zero, %c[COL], ->lb2\n" @@ -2708,7 +2708,7 @@ void TLOAD(tile_shape &dst, gm_shape &src) { : "memory"); } else if constexpr (tile_shape::ValidCol < 0 && tile_shape::ValidRow > 0) { asm volatile( - "BSTART.TLOAD %D[SrcType]\n" + "BSTART.TLSU TLOAD, %D[SrcType]\n" "B.DIM %[VCOL], 0, ->lb0\n" "B.DIM zero, %c[VROW], ->lb1\n" "B.DIM zero, %c[COL], ->lb2\n" @@ -2724,7 +2724,7 @@ void TLOAD(tile_shape &dst, gm_shape &src) { : "memory"); } else { asm volatile( - "BSTART.TLOAD %D[SrcType]\n" + "BSTART.TLSU TLOAD, %D[SrcType]\n" "B.DIM %[VCOL], 0, ->lb0\n" "B.DIM %[VROW], 0, ->lb1\n" "B.DIM zero, %c[COL], ->lb2\n" @@ -2755,11 +2755,11 @@ void TLOAD_ASS(tile_shape &dst, const gm_shape &src) { const size_t valid_col = dst.GetValidCol(); const size_t valid_row = dst.GetValidRow(); asm volatile( - "BSTART.TLOAD %D[SrcType]\n" + "BSTART.TLSU TLOAD, %D[SrcType]\n" "B.DIM zero, %c[VCOL], ->lb0\n" "B.DIM zero, %c[VROW], ->lb1\n" "B.DIM zero, %c[COL], ->lb2\n" - "B.IOT %[d0].reuse, mask=1111, last\n" + "B.IOT %[d0], mask=1111, last\n" "B.IOR [%[s0],%[GmStride]], []\n" : : [d0] "Tr"(dst.data()), [s0] "r"(src.data()), @@ -2791,11 +2791,11 @@ void TLOAD_ASS( if constexpr (RegSrc == 0 || RegSrc == range::AutoRegSrc) { const uintptr_t range_base = static_cast(dst.GetRangeBase()); asm volatile( - "BSTART.TLOAD %D[SrcType]\n" + "BSTART.TLSU TLOAD, %D[SrcType]\n" "B.DIM zero, %c[VCOL], ->lb0\n" "B.DIM zero, %c[VROW], ->lb1\n" "B.DIM zero, %c[COL], ->lb2\n" - "B.IOT %[d0].reuse, mask=1111, last\n" + "B.IOT %[d0], mask=1111, last\n" "B.ASSEMBLE %c[Init], %c[Last], %[RegSrc], %c[Off], %c[WriterSize]\n" "B.IOR [%[s0],%[GmStride]], []\n" : @@ -2813,11 +2813,11 @@ void TLOAD_ASS( register uintptr_t range_base asm("r" #N) = \ static_cast(dst.GetRangeBase()); \ asm volatile( \ - "BSTART.TLOAD %D[SrcType]\n" \ + "BSTART.TLSU TLOAD, %D[SrcType]\n" \ "B.DIM zero, %c[VCOL], ->lb0\n" \ "B.DIM zero, %c[VROW], ->lb1\n" \ "B.DIM zero, %c[COL], ->lb2\n" \ - "B.IOT %[d0].reuse, mask=1111, last\n" \ + "B.IOT %[d0], mask=1111, last\n" \ "B.ASSEMBLE %c[Init], %c[Last], r" #N ", %c[Off], %c[WriterSize]\n" \ "B.IOR [%[s0],%[GmStride]], []\n" \ : \ @@ -2861,7 +2861,7 @@ PTO_SHARED_INLINE SharedTile TLOAD(const gm_shape &src) { // ASL B.DIM: dynamic dims load from a GPR; per-dim SS/SD/DS/DD dispatch. if constexpr (shp::ValidCol > 0 && shp::ValidRow > 0) { asm volatile( - "BSTART.TLOAD %D[SrcType]\n" + "BSTART.TLSU TLOAD, %D[SrcType]\n" "B.DIM zero, %c[VCOL], ->lb0\n" "B.DIM zero, %c[VROW], ->lb1\n" "B.DIM zero, %c[COL], ->lb2\n" @@ -2878,7 +2878,7 @@ PTO_SHARED_INLINE SharedTile TLOAD(const gm_shape &src) { : "memory"); } else if constexpr (shp::ValidCol > 0 && shp::ValidRow < 0) { asm volatile( - "BSTART.TLOAD %D[SrcType]\n" + "BSTART.TLSU TLOAD, %D[SrcType]\n" "B.DIM zero, %c[VCOL], ->lb0\n" "B.DIM %[VROW], 0, ->lb1\n" "B.DIM zero, %c[COL], ->lb2\n" @@ -2895,7 +2895,7 @@ PTO_SHARED_INLINE SharedTile TLOAD(const gm_shape &src) { : "memory"); } else if constexpr (shp::ValidCol < 0 && shp::ValidRow > 0) { asm volatile( - "BSTART.TLOAD %D[SrcType]\n" + "BSTART.TLSU TLOAD, %D[SrcType]\n" "B.DIM %[VCOL], 0, ->lb0\n" "B.DIM zero, %c[VROW], ->lb1\n" "B.DIM zero, %c[COL], ->lb2\n" @@ -2912,7 +2912,7 @@ PTO_SHARED_INLINE SharedTile TLOAD(const gm_shape &src) { : "memory"); } else { asm volatile( - "BSTART.TLOAD %D[SrcType]\n" + "BSTART.TLSU TLOAD, %D[SrcType]\n" "B.DIM %[VCOL], 0, ->lb0\n" "B.DIM %[VROW], 0, ->lb1\n" "B.DIM zero, %c[COL], ->lb2\n" @@ -2944,7 +2944,7 @@ PTO_SHARED_INLINE void TLOAD(SharedTile &dst, const gm_shape &src) { // ASL B.DIM: dynamic dims load from a GPR; per-dim SS/SD/DS/DD dispatch. if constexpr (shp::ValidCol > 0 && shp::ValidRow > 0) { asm volatile( - "BSTART.TLOAD %D[SrcType]\n" + "BSTART.TLSU TLOAD, %D[SrcType]\n" "B.DIM zero, %c[VCOL], ->lb0\n" "B.DIM zero, %c[VROW], ->lb1\n" "B.DIM zero, %c[COL], ->lb2\n" @@ -2961,7 +2961,7 @@ PTO_SHARED_INLINE void TLOAD(SharedTile &dst, const gm_shape &src) { : "memory"); } else if constexpr (shp::ValidCol > 0 && shp::ValidRow < 0) { asm volatile( - "BSTART.TLOAD %D[SrcType]\n" + "BSTART.TLSU TLOAD, %D[SrcType]\n" "B.DIM zero, %c[VCOL], ->lb0\n" "B.DIM %[VROW], 0, ->lb1\n" "B.DIM zero, %c[COL], ->lb2\n" @@ -2978,7 +2978,7 @@ PTO_SHARED_INLINE void TLOAD(SharedTile &dst, const gm_shape &src) { : "memory"); } else if constexpr (shp::ValidCol < 0 && shp::ValidRow > 0) { asm volatile( - "BSTART.TLOAD %D[SrcType]\n" + "BSTART.TLSU TLOAD, %D[SrcType]\n" "B.DIM %[VCOL], 0, ->lb0\n" "B.DIM zero, %c[VROW], ->lb1\n" "B.DIM zero, %c[COL], ->lb2\n" @@ -2995,7 +2995,7 @@ PTO_SHARED_INLINE void TLOAD(SharedTile &dst, const gm_shape &src) { : "memory"); } else { asm volatile( - "BSTART.TLOAD %D[SrcType]\n" + "BSTART.TLSU TLOAD, %D[SrcType]\n" "B.DIM %[VCOL], 0, ->lb0\n" "B.DIM %[VROW], 0, ->lb1\n" "B.DIM zero, %c[COL], ->lb2\n" @@ -3053,7 +3053,7 @@ PTO_SHARED_INLINE void TLOAD(SharedTile &dst, const gm_shape &src, uint64_t start_word = params.start_word; asm("" : "+r"(start_word)); asm volatile( - "BSTART.TLOAD %D[SrcType]\n" + "BSTART.TLSU TLOAD, %D[SrcType]\n" ".if %c[WeightLayout] == 10\nB.DATR OHWI2NK, DTYPE_NONE, Zero\n" ".elseif %c[WeightLayout] == 11\nB.DATR OIHW2NK, DTYPE_NONE, Zero\n" ".endif\n" @@ -3096,7 +3096,7 @@ PTO_SHARED_INLINE void TLOAD_SLOT(const gm_shape &src, asm("" : "+r"(shape_word)); asm("" : "+r"(start_word)); asm volatile( - "BSTART.TLOAD %D[SrcType]\n" + "BSTART.TLSU TLOAD, %D[SrcType]\n" ".if %c[WeightLayout] == 10\nB.DATR OHWI2NK, DTYPE_NONE, Zero\n" ".elseif %c[WeightLayout] == 11\nB.DATR OIHW2NK, DTYPE_NONE, Zero\n" ".endif\n" @@ -3131,11 +3131,11 @@ PTO_SHARED_INLINE void TLOAD_ASS(SharedTile &dst, const gm_shape &src) { const size_t valid_col = dst.GetValidCol(); const size_t valid_row = dst.GetValidRow(); asm volatile( - "BSTART.TLOAD %D[SrcType]\n" + "BSTART.TLSU TLOAD, %D[SrcType]\n" "B.DIM zero, %c[VCOL], ->lb0\n" "B.DIM zero, %c[VROW], ->lb1\n" "B.DIM zero, %c[COL], ->lb2\n" - "B.IOS %S[d0].reuse, mask=1111\n" + "B.IOS %S[d0], mask=1111\n" "B.IOR [%[s0],%[GmStride]], []\n" : : [d0] "Sr"(dst.handle_ref()), [s0] "r"(src.data()), @@ -3176,11 +3176,11 @@ PTO_SHARED_INLINE void TLOAD_ASS( "not supported; use the default or *_at_reg plain forms"); const uintptr_t range_base = static_cast(dst.GetRangeBase()); asm volatile( - "BSTART.TLOAD %D[SrcType]\n" + "BSTART.TLSU TLOAD, %D[SrcType]\n" "B.DIM %[VCOL], 0, ->lb0\n" "B.DIM %[VROW], 0, ->lb1\n" "B.DIM zero, %c[COL], ->lb2\n" - "B.IOS %S[d0].reuse, mask=1111\n" + "B.IOS %S[d0], mask=1111\n" "B.ASSEMBLE %c[Init], %c[Last], %[RegSrc], %c[Off], %c[WriterSize]\n" "B.IOR [%[s0],%[GmStride]], []\n" : @@ -3214,11 +3214,11 @@ void TLOAD_CUBE_ASS(cube_shape &dst, const gm_shape &src) { const size_t valid_col = dst.GetValidCol(); const size_t valid_row = dst.GetValidRow(); asm volatile( - "BSTART.TLOAD %D[DataType]\n" + "BSTART.TLSU TLOAD, %D[DataType]\n" PTO_CUBE_LOAD_DATR_ASM "B.DIM %[VCOL], 0, ->lb0\n" "B.DIM %[VROW], 0, ->lb1\n" - "B.IOT %[Dst].reuse, mask=1111, last\n" + "B.IOT %[Dst], mask=1111, last\n" "B.IOR [%[Base],%[RowStrideBytes]], []\n" : : [Dst] "Tr"(dst.data()), [Base] "r"(src.data()), @@ -3230,7 +3230,7 @@ void TLOAD_CUBE_ASS(cube_shape &dst, const gm_shape &src) { : "memory"); } -// TSTORE: Tile -> GM (BSTART.TSTORE). dst[r0+i, c0+j] = src[i,j]. +// TSTORE: Tile -> GM (BSTART.TLSU TSTORE). dst[r0+i, c0+j] = src[i,j]. template requires(!tile_shape::IsCubeLayout || is_subview_v || is_assemble_v) @@ -3255,11 +3255,11 @@ void TSTORE(gm_shape &dst, tile_shape &src) { const uintptr_t range_base = static_cast(src.GetRangeBase()); asm volatile( - "BSTART.TSTORE %D[SrcType]\n" + "BSTART.TLSU TSTORE, %D[SrcType]\n" "B.DIM zero, %c[VCOL], ->lb0\n" "B.DIM zero, %c[VROW], ->lb1\n" "B.DIM zero, %c[COL], ->lb2\n" - "B.IOS %S[s0].reuse, mask=1111\n" + "B.IOS %S[s0], mask=1111\n" "B.SUBVIEW %c[SrcSelect], %[RegSrc], %c[Off], %c[SubSize]\n" "B.IOR [%[d0],%[GmStride]], []\n" : @@ -3278,11 +3278,11 @@ void TSTORE(gm_shape &dst, tile_shape &src) { register uintptr_t range_base asm("r" #N) = \ static_cast(src.GetRangeBase()); \ asm volatile( \ - "BSTART.TSTORE %D[SrcType]\n" \ + "BSTART.TLSU TSTORE, %D[SrcType]\n" \ "B.DIM zero, %c[VCOL], ->lb0\n" \ "B.DIM zero, %c[VROW], ->lb1\n" \ "B.DIM zero, %c[COL], ->lb2\n" \ - "B.IOS %S[s0].reuse, mask=1111\n" \ + "B.IOS %S[s0], mask=1111\n" \ "B.SUBVIEW %c[SrcSelect], r" #N ", %c[Off], %c[SubSize]\n" \ "B.IOR [%[d0],%[GmStride]], []\n" \ : \ @@ -3317,11 +3317,11 @@ void TSTORE(gm_shape &dst, tile_shape &src) { const uintptr_t range_base = static_cast(src.GetRangeBase()); asm volatile( - "BSTART.TSTORE %D[SrcType]\n" + "BSTART.TLSU TSTORE, %D[SrcType]\n" "B.DIM zero, %c[VCOL], ->lb0\n" "B.DIM zero, %c[VROW], ->lb1\n" "B.DIM zero, %c[COL], ->lb2\n" - "B.IOT %[s0].reuse, mask=1111, last\n" + "B.IOT %[s0], mask=1111, last\n" "B.SUBVIEW %c[SrcSelect], %[RegSrc], %c[Off], %c[SubSize]\n" "B.IOR [%[d0],%[GmStride]], []\n" : @@ -3340,11 +3340,11 @@ void TSTORE(gm_shape &dst, tile_shape &src) { register uintptr_t range_base asm("r" #N) = \ static_cast(src.GetRangeBase()); \ asm volatile( \ - "BSTART.TSTORE %D[SrcType]\n" \ + "BSTART.TLSU TSTORE, %D[SrcType]\n" \ "B.DIM zero, %c[VCOL], ->lb0\n" \ "B.DIM zero, %c[VROW], ->lb1\n" \ "B.DIM zero, %c[COL], ->lb2\n" \ - "B.IOT %[s0].reuse, mask=1111, last\n" \ + "B.IOT %[s0], mask=1111, last\n" \ "B.SUBVIEW %c[SrcSelect], r" #N ", %c[Off], %c[SubSize]\n" \ "B.IOR [%[d0],%[GmStride]], []\n" \ : \ @@ -3378,11 +3378,11 @@ void TSTORE(gm_shape &dst, tile_shape &src) { // ASL B.DIM: dynamic dims load from a GPR; per-dim SS/SD/DS/DD dispatch. if constexpr (tile_shape::ValidCol > 0 && tile_shape::ValidRow > 0) { asm volatile( - "BSTART.TSTORE %D[SrcType]\n" + "BSTART.TLSU TSTORE, %D[SrcType]\n" "B.DIM zero, %c[VCOL], ->lb0\n" "B.DIM zero, %c[VROW], ->lb1\n" "B.DIM zero, %c[COL], ->lb2\n" - "B.IOT %[s0].reuse, mask=1111, last\n" + "B.IOT %[s0], mask=1111, last\n" "B.IOR [%[d0],%[GmStride]], []\n" : : [d0]"r"(dst.data()), [s0]"Tr"(src.data()), @@ -3393,11 +3393,11 @@ void TSTORE(gm_shape &dst, tile_shape &src) { : "memory"); } else if constexpr (tile_shape::ValidCol > 0 && tile_shape::ValidRow < 0) { asm volatile( - "BSTART.TSTORE %D[SrcType]\n" + "BSTART.TLSU TSTORE, %D[SrcType]\n" "B.DIM zero, %c[VCOL], ->lb0\n" "B.DIM %[VROW], 0, ->lb1\n" "B.DIM zero, %c[COL], ->lb2\n" - "B.IOT %[s0].reuse, mask=1111, last\n" + "B.IOT %[s0], mask=1111, last\n" "B.IOR [%[d0],%[GmStride]], []\n" : : [d0]"r"(dst.data()), [s0]"Tr"(src.data()), @@ -3408,11 +3408,11 @@ void TSTORE(gm_shape &dst, tile_shape &src) { : "memory"); } else if constexpr (tile_shape::ValidCol < 0 && tile_shape::ValidRow > 0) { asm volatile( - "BSTART.TSTORE %D[SrcType]\n" + "BSTART.TLSU TSTORE, %D[SrcType]\n" "B.DIM %[VCOL], 0, ->lb0\n" "B.DIM zero, %c[VROW], ->lb1\n" "B.DIM zero, %c[COL], ->lb2\n" - "B.IOT %[s0].reuse, mask=1111, last\n" + "B.IOT %[s0], mask=1111, last\n" "B.IOR [%[d0],%[GmStride]], []\n" : : [d0]"r"(dst.data()), [s0]"Tr"(src.data()), @@ -3423,11 +3423,11 @@ void TSTORE(gm_shape &dst, tile_shape &src) { : "memory"); } else { asm volatile( - "BSTART.TSTORE %D[SrcType]\n" + "BSTART.TLSU TSTORE, %D[SrcType]\n" "B.DIM %[VCOL], 0, ->lb0\n" "B.DIM %[VROW], 0, ->lb1\n" "B.DIM zero, %c[COL], ->lb2\n" - "B.IOT %[s0].reuse, mask=1111, last\n" + "B.IOT %[s0], mask=1111, last\n" "B.IOR [%[d0],%[GmStride]], []\n" : : [d0]"r"(dst.data()), [s0]"Tr"(src.data()), @@ -3468,7 +3468,7 @@ void TLOAD_CUBE(cube_shape &dst, gm_shape &src) { if constexpr (cube_shape::BFractal == BLayout::CubeM32) { if constexpr (cube_shape::ValidCol > 0 && cube_shape::ValidRow > 0) { asm volatile( - "BSTART.TLOAD %D[DataType]\n" + "BSTART.TLSU TLOAD, %D[DataType]\n" PTO_CUBE_LOAD_DATR_ASM "B.DIM zero, %c[VCOL], ->lb0\n" "B.DIM zero, %c[VROW], ->lb1\n" @@ -3485,7 +3485,7 @@ asm volatile( : "memory"); } else if constexpr (cube_shape::ValidCol > 0 && cube_shape::ValidRow < 0) { asm volatile( - "BSTART.TLOAD %D[DataType]\n" + "BSTART.TLSU TLOAD, %D[DataType]\n" PTO_CUBE_LOAD_DATR_ASM "B.DIM zero, %c[VCOL], ->lb0\n" "B.DIM %[VROW], 0, ->lb1\n" @@ -3502,7 +3502,7 @@ asm volatile( : "memory"); } else if constexpr (cube_shape::ValidCol < 0 && cube_shape::ValidRow > 0) { asm volatile( - "BSTART.TLOAD %D[DataType]\n" + "BSTART.TLSU TLOAD, %D[DataType]\n" PTO_CUBE_LOAD_DATR_ASM "B.DIM %[VCOL], 0, ->lb0\n" "B.DIM zero, %c[VROW], ->lb1\n" @@ -3519,7 +3519,7 @@ asm volatile( : "memory"); } else { asm volatile( - "BSTART.TLOAD %D[DataType]\n" + "BSTART.TLSU TLOAD, %D[DataType]\n" PTO_CUBE_LOAD_DATR_ASM "B.DIM %[VCOL], 0, ->lb0\n" "B.DIM %[VROW], 0, ->lb1\n" @@ -3537,7 +3537,7 @@ asm volatile( } else if constexpr (cube_shape::BFractal == BLayout::CubeM16) { if constexpr (cube_shape::ValidCol > 0 && cube_shape::ValidRow > 0) { asm volatile( - "BSTART.TLOAD %D[DataType]\n" + "BSTART.TLSU TLOAD, %D[DataType]\n" PTO_CUBE_LOAD_DATR_ASM "B.DIM zero, %c[VCOL], ->lb0\n" "B.DIM zero, %c[VROW], ->lb1\n" @@ -3554,7 +3554,7 @@ asm volatile( : "memory"); } else if constexpr (cube_shape::ValidCol > 0 && cube_shape::ValidRow < 0) { asm volatile( - "BSTART.TLOAD %D[DataType]\n" + "BSTART.TLSU TLOAD, %D[DataType]\n" PTO_CUBE_LOAD_DATR_ASM "B.DIM zero, %c[VCOL], ->lb0\n" "B.DIM %[VROW], 0, ->lb1\n" @@ -3571,7 +3571,7 @@ asm volatile( : "memory"); } else if constexpr (cube_shape::ValidCol < 0 && cube_shape::ValidRow > 0) { asm volatile( - "BSTART.TLOAD %D[DataType]\n" + "BSTART.TLSU TLOAD, %D[DataType]\n" PTO_CUBE_LOAD_DATR_ASM "B.DIM %[VCOL], 0, ->lb0\n" "B.DIM zero, %c[VROW], ->lb1\n" @@ -3588,7 +3588,7 @@ asm volatile( : "memory"); } else { asm volatile( - "BSTART.TLOAD %D[DataType]\n" + "BSTART.TLSU TLOAD, %D[DataType]\n" PTO_CUBE_LOAD_DATR_ASM "B.DIM %[VCOL], 0, ->lb0\n" "B.DIM %[VROW], 0, ->lb1\n" @@ -3606,7 +3606,7 @@ asm volatile( } else { // CubeN8 if constexpr (cube_shape::ValidCol > 0 && cube_shape::ValidRow > 0) { asm volatile( - "BSTART.TLOAD %D[DataType]\n" + "BSTART.TLSU TLOAD, %D[DataType]\n" PTO_CUBE_LOAD_DATR_ASM "B.DIM zero, %c[VCOL], ->lb0\n" "B.DIM zero, %c[VROW], ->lb1\n" @@ -3623,7 +3623,7 @@ asm volatile( : "memory"); } else if constexpr (cube_shape::ValidCol > 0 && cube_shape::ValidRow < 0) { asm volatile( - "BSTART.TLOAD %D[DataType]\n" + "BSTART.TLSU TLOAD, %D[DataType]\n" PTO_CUBE_LOAD_DATR_ASM "B.DIM zero, %c[VCOL], ->lb0\n" "B.DIM %[VROW], 0, ->lb1\n" @@ -3640,7 +3640,7 @@ asm volatile( : "memory"); } else if constexpr (cube_shape::ValidCol < 0 && cube_shape::ValidRow > 0) { asm volatile( - "BSTART.TLOAD %D[DataType]\n" + "BSTART.TLSU TLOAD, %D[DataType]\n" PTO_CUBE_LOAD_DATR_ASM "B.DIM %[VCOL], 0, ->lb0\n" "B.DIM zero, %c[VROW], ->lb1\n" @@ -3657,7 +3657,7 @@ asm volatile( : "memory"); } else { asm volatile( - "BSTART.TLOAD %D[DataType]\n" + "BSTART.TLSU TLOAD, %D[DataType]\n" PTO_CUBE_LOAD_DATR_ASM "B.DIM %[VCOL], 0, ->lb0\n" "B.DIM %[VROW], 0, ->lb1\n" @@ -3699,11 +3699,11 @@ void TSTORE_CUBE(gm_shape &dst, const cube_shape &src) { if constexpr (cube_shape::BFractal == BLayout::CubeM32) { if constexpr (cube_shape::ValidCol > 0 && cube_shape::ValidRow > 0) { asm volatile( - "BSTART.TSTORE %D[DataType]\n" + "BSTART.TLSU TSTORE, %D[DataType]\n" "B.DATR M322ND.normal, Null\n" "B.DIM zero, %c[VCOL], ->lb0\n" "B.DIM zero, %c[VROW], ->lb1\n" - "B.IOT %[Src].reuse, mask=1111, last\n" + "B.IOT %[Src], mask=1111, last\n" "B.IOR [%[Base],%[RowStrideBytes]], []\n" : : [Base] "r"(dst.data()), [Src] "Tr"(src.data()), @@ -3713,11 +3713,11 @@ asm volatile( : "memory"); } else if constexpr (cube_shape::ValidCol > 0 && cube_shape::ValidRow < 0) { asm volatile( - "BSTART.TSTORE %D[DataType]\n" + "BSTART.TLSU TSTORE, %D[DataType]\n" "B.DATR M322ND.normal, Null\n" "B.DIM zero, %c[VCOL], ->lb0\n" "B.DIM %[VROW], 0, ->lb1\n" - "B.IOT %[Src].reuse, mask=1111, last\n" + "B.IOT %[Src], mask=1111, last\n" "B.IOR [%[Base],%[RowStrideBytes]], []\n" : : [Base] "r"(dst.data()), [Src] "Tr"(src.data()), @@ -3727,11 +3727,11 @@ asm volatile( : "memory"); } else if constexpr (cube_shape::ValidCol < 0 && cube_shape::ValidRow > 0) { asm volatile( - "BSTART.TSTORE %D[DataType]\n" + "BSTART.TLSU TSTORE, %D[DataType]\n" "B.DATR M322ND.normal, Null\n" "B.DIM %[VCOL], 0, ->lb0\n" "B.DIM zero, %c[VROW], ->lb1\n" - "B.IOT %[Src].reuse, mask=1111, last\n" + "B.IOT %[Src], mask=1111, last\n" "B.IOR [%[Base],%[RowStrideBytes]], []\n" : : [Base] "r"(dst.data()), [Src] "Tr"(src.data()), @@ -3741,11 +3741,11 @@ asm volatile( : "memory"); } else { asm volatile( - "BSTART.TSTORE %D[DataType]\n" + "BSTART.TLSU TSTORE, %D[DataType]\n" "B.DATR M322ND.normal, Null\n" "B.DIM %[VCOL], 0, ->lb0\n" "B.DIM %[VROW], 0, ->lb1\n" - "B.IOT %[Src].reuse, mask=1111, last\n" + "B.IOT %[Src], mask=1111, last\n" "B.IOR [%[Base],%[RowStrideBytes]], []\n" : : [Base] "r"(dst.data()), [Src] "Tr"(src.data()), @@ -3756,11 +3756,11 @@ asm volatile( } else if constexpr (cube_shape::BFractal == BLayout::CubeM16) { if constexpr (cube_shape::ValidCol > 0 && cube_shape::ValidRow > 0) { asm volatile( - "BSTART.TSTORE %D[DataType]\n" + "BSTART.TLSU TSTORE, %D[DataType]\n" "B.DATR M162ND.normal, Null\n" "B.DIM zero, %c[VCOL], ->lb0\n" "B.DIM zero, %c[VROW], ->lb1\n" - "B.IOT %[Src].reuse, mask=1111, last\n" + "B.IOT %[Src], mask=1111, last\n" "B.IOR [%[Base],%[RowStrideBytes]], []\n" : : [Base] "r"(dst.data()), [Src] "Tr"(src.data()), @@ -3770,11 +3770,11 @@ asm volatile( : "memory"); } else if constexpr (cube_shape::ValidCol > 0 && cube_shape::ValidRow < 0) { asm volatile( - "BSTART.TSTORE %D[DataType]\n" + "BSTART.TLSU TSTORE, %D[DataType]\n" "B.DATR M162ND.normal, Null\n" "B.DIM zero, %c[VCOL], ->lb0\n" "B.DIM %[VROW], 0, ->lb1\n" - "B.IOT %[Src].reuse, mask=1111, last\n" + "B.IOT %[Src], mask=1111, last\n" "B.IOR [%[Base],%[RowStrideBytes]], []\n" : : [Base] "r"(dst.data()), [Src] "Tr"(src.data()), @@ -3784,11 +3784,11 @@ asm volatile( : "memory"); } else if constexpr (cube_shape::ValidCol < 0 && cube_shape::ValidRow > 0) { asm volatile( - "BSTART.TSTORE %D[DataType]\n" + "BSTART.TLSU TSTORE, %D[DataType]\n" "B.DATR M162ND.normal, Null\n" "B.DIM %[VCOL], 0, ->lb0\n" "B.DIM zero, %c[VROW], ->lb1\n" - "B.IOT %[Src].reuse, mask=1111, last\n" + "B.IOT %[Src], mask=1111, last\n" "B.IOR [%[Base],%[RowStrideBytes]], []\n" : : [Base] "r"(dst.data()), [Src] "Tr"(src.data()), @@ -3798,11 +3798,11 @@ asm volatile( : "memory"); } else { asm volatile( - "BSTART.TSTORE %D[DataType]\n" + "BSTART.TLSU TSTORE, %D[DataType]\n" "B.DATR M162ND.normal, Null\n" "B.DIM %[VCOL], 0, ->lb0\n" "B.DIM %[VROW], 0, ->lb1\n" - "B.IOT %[Src].reuse, mask=1111, last\n" + "B.IOT %[Src], mask=1111, last\n" "B.IOR [%[Base],%[RowStrideBytes]], []\n" : : [Base] "r"(dst.data()), [Src] "Tr"(src.data()), @@ -3813,11 +3813,11 @@ asm volatile( } else { // CubeN8 if constexpr (cube_shape::ValidCol > 0 && cube_shape::ValidRow > 0) { asm volatile( - "BSTART.TSTORE %D[DataType]\n" + "BSTART.TLSU TSTORE, %D[DataType]\n" "B.DATR N82ND.normal, Null\n" "B.DIM zero, %c[VCOL], ->lb0\n" "B.DIM zero, %c[VROW], ->lb1\n" - "B.IOT %[Src].reuse, mask=1111, last\n" + "B.IOT %[Src], mask=1111, last\n" "B.IOR [%[Base],%[RowStrideBytes]], []\n" : : [Base] "r"(dst.data()), [Src] "Tr"(src.data()), @@ -3827,11 +3827,11 @@ asm volatile( : "memory"); } else if constexpr (cube_shape::ValidCol > 0 && cube_shape::ValidRow < 0) { asm volatile( - "BSTART.TSTORE %D[DataType]\n" + "BSTART.TLSU TSTORE, %D[DataType]\n" "B.DATR N82ND.normal, Null\n" "B.DIM zero, %c[VCOL], ->lb0\n" "B.DIM %[VROW], 0, ->lb1\n" - "B.IOT %[Src].reuse, mask=1111, last\n" + "B.IOT %[Src], mask=1111, last\n" "B.IOR [%[Base],%[RowStrideBytes]], []\n" : : [Base] "r"(dst.data()), [Src] "Tr"(src.data()), @@ -3841,11 +3841,11 @@ asm volatile( : "memory"); } else if constexpr (cube_shape::ValidCol < 0 && cube_shape::ValidRow > 0) { asm volatile( - "BSTART.TSTORE %D[DataType]\n" + "BSTART.TLSU TSTORE, %D[DataType]\n" "B.DATR N82ND.normal, Null\n" "B.DIM %[VCOL], 0, ->lb0\n" "B.DIM zero, %c[VROW], ->lb1\n" - "B.IOT %[Src].reuse, mask=1111, last\n" + "B.IOT %[Src], mask=1111, last\n" "B.IOR [%[Base],%[RowStrideBytes]], []\n" : : [Base] "r"(dst.data()), [Src] "Tr"(src.data()), @@ -3855,11 +3855,11 @@ asm volatile( : "memory"); } else { asm volatile( - "BSTART.TSTORE %D[DataType]\n" + "BSTART.TLSU TSTORE, %D[DataType]\n" "B.DATR N82ND.normal, Null\n" "B.DIM %[VCOL], 0, ->lb0\n" "B.DIM %[VROW], 0, ->lb1\n" - "B.IOT %[Src].reuse, mask=1111, last\n" + "B.IOT %[Src], mask=1111, last\n" "B.IOR [%[Base],%[RowStrideBytes]], []\n" : : [Base] "r"(dst.data()), [Src] "Tr"(src.data()), @@ -4008,11 +4008,11 @@ void TSTORE(typename TileType::DType *block_base, const TileType &src, const uint64_t predicate = parts.store_predicate(count); auto memory = parts.logical_region(block_base, part); asm volatile( - "BSTART.TSTORE %D[DataType]\n" + "BSTART.TLSU TSTORE, %D[DataType]\n" "B.DATR M322ND, DTYPE_NONE, Null, byte0, Eq, RNONE, nosat, 0, 0\n" "B.DIM zero, 2, ->lb0\n" "B.DIM zero, 32, ->lb1\n" - "B.IOT %[Src].reuse, mask=1111, last\n" + "B.IOT %[Src], mask=1111, last\n" "B.IOR [%[Base],%[RowStrideBytes],%[Predicate]], ExecMaskPresent\n" : : [Base] "r"(memory.data()), [Src] "Tr"(src.data()), @@ -4040,11 +4040,11 @@ PTO_SHARED_INLINE void TSTORE(gm_shape &dst, const SharedTileT &src) { const size_t valid_row = src.GetValidRow(); if constexpr (SharedTileT::ValidCol > 0 && SharedTileT::ValidRow > 0) { asm volatile( - "BSTART.TSTORE %D[SrcType]\n" + "BSTART.TLSU TSTORE, %D[SrcType]\n" "B.DIM zero, %c[VCOL], ->lb0\n" "B.DIM zero, %c[VROW], ->lb1\n" "B.DIM zero, %c[COL], ->lb2\n" - "B.IOS %S[Shared].reuse, mask=1111\n" + "B.IOS %S[Shared], mask=1111\n" "B.IOR [%[d0],%[GmStride]], []\n" : : [d0] "r"(dst.data()), [Shared] "Sr"(src.handle()), @@ -4055,11 +4055,11 @@ asm volatile( : "memory"); } else if constexpr (SharedTileT::ValidCol > 0 && SharedTileT::ValidRow < 0) { asm volatile( - "BSTART.TSTORE %D[SrcType]\n" + "BSTART.TLSU TSTORE, %D[SrcType]\n" "B.DIM zero, %c[VCOL], ->lb0\n" "B.DIM %[VROW], 0, ->lb1\n" "B.DIM zero, %c[COL], ->lb2\n" - "B.IOS %S[Shared].reuse, mask=1111\n" + "B.IOS %S[Shared], mask=1111\n" "B.IOR [%[d0],%[GmStride]], []\n" : : [d0] "r"(dst.data()), [Shared] "Sr"(src.handle()), @@ -4070,11 +4070,11 @@ asm volatile( : "memory"); } else if constexpr (SharedTileT::ValidCol < 0 && SharedTileT::ValidRow > 0) { asm volatile( - "BSTART.TSTORE %D[SrcType]\n" + "BSTART.TLSU TSTORE, %D[SrcType]\n" "B.DIM %[VCOL], 0, ->lb0\n" "B.DIM zero, %c[VROW], ->lb1\n" "B.DIM zero, %c[COL], ->lb2\n" - "B.IOS %S[Shared].reuse, mask=1111\n" + "B.IOS %S[Shared], mask=1111\n" "B.IOR [%[d0],%[GmStride]], []\n" : : [d0] "r"(dst.data()), [Shared] "Sr"(src.handle()), @@ -4085,11 +4085,11 @@ asm volatile( : "memory"); } else { asm volatile( - "BSTART.TSTORE %D[SrcType]\n" + "BSTART.TLSU TSTORE, %D[SrcType]\n" "B.DIM %[VCOL], 0, ->lb0\n" "B.DIM %[VROW], 0, ->lb1\n" "B.DIM zero, %c[COL], ->lb2\n" - "B.IOS %S[Shared].reuse, mask=1111\n" + "B.IOS %S[Shared], mask=1111\n" "B.IOR [%[d0],%[GmStride]], []\n" : : [d0] "r"(dst.data()), [Shared] "Sr"(src.handle()), @@ -4120,11 +4120,11 @@ PTO_SHARED_INLINE void TSTORE_PART(gm_shape &dst, const SharedTileT &src) { const size_t valid_row = src.GetValidRow(); if constexpr (SharedTileT::ValidCol > 0 && SharedTileT::ValidRow > 0) { asm volatile( - "BSTART.TSTORE.SPART %D[SrcType]\n" + "BSTART.TLSU TSTORE.SPART, %D[SrcType]\n" "B.DIM zero, %c[VCOL], ->lb0\n" "B.DIM zero, %c[VROW], ->lb1\n" "B.DIM zero, %c[COL], ->lb2\n" - PTO_PE_MASK_ASM("B.IOS %S[Shared].reuse, mask=", "\n") + PTO_PE_MASK_ASM("B.IOS %S[Shared], mask=", "\n") "B.IOR [%[d0],%[GmStride]], []\n" : : [d0] "r"(dst.data()), [Shared] "Sr"(src.handle()), @@ -4136,11 +4136,11 @@ asm volatile( : "memory"); } else if constexpr (SharedTileT::ValidCol > 0 && SharedTileT::ValidRow < 0) { asm volatile( - "BSTART.TSTORE.SPART %D[SrcType]\n" + "BSTART.TLSU TSTORE.SPART, %D[SrcType]\n" "B.DIM zero, %c[VCOL], ->lb0\n" "B.DIM %[VROW], 0, ->lb1\n" "B.DIM zero, %c[COL], ->lb2\n" - PTO_PE_MASK_ASM("B.IOS %S[Shared].reuse, mask=", "\n") + PTO_PE_MASK_ASM("B.IOS %S[Shared], mask=", "\n") "B.IOR [%[d0],%[GmStride]], []\n" : : [d0] "r"(dst.data()), [Shared] "Sr"(src.handle()), @@ -4152,11 +4152,11 @@ asm volatile( : "memory"); } else if constexpr (SharedTileT::ValidCol < 0 && SharedTileT::ValidRow > 0) { asm volatile( - "BSTART.TSTORE.SPART %D[SrcType]\n" + "BSTART.TLSU TSTORE.SPART, %D[SrcType]\n" "B.DIM %[VCOL], 0, ->lb0\n" "B.DIM zero, %c[VROW], ->lb1\n" "B.DIM zero, %c[COL], ->lb2\n" - PTO_PE_MASK_ASM("B.IOS %S[Shared].reuse, mask=", "\n") + PTO_PE_MASK_ASM("B.IOS %S[Shared], mask=", "\n") "B.IOR [%[d0],%[GmStride]], []\n" : : [d0] "r"(dst.data()), [Shared] "Sr"(src.handle()), @@ -4168,11 +4168,11 @@ asm volatile( : "memory"); } else { asm volatile( - "BSTART.TSTORE.SPART %D[SrcType]\n" + "BSTART.TLSU TSTORE.SPART, %D[SrcType]\n" "B.DIM %[VCOL], 0, ->lb0\n" "B.DIM %[VROW], 0, ->lb1\n" "B.DIM zero, %c[COL], ->lb2\n" - PTO_PE_MASK_ASM("B.IOS %S[Shared].reuse, mask=", "\n") + PTO_PE_MASK_ASM("B.IOS %S[Shared], mask=", "\n") "B.IOR [%[d0],%[GmStride]], []\n" : : [d0] "r"(dst.data()), [Shared] "Sr"(src.handle()), @@ -4200,7 +4200,7 @@ void TPREFETCH(const gm_shape &src, uint32_t valid_col, uint32_t valid_row) { // register form. LB0/LB1 are runtime function arguments by contract. if constexpr (gm_shape::Cols != DYNAMIC) { asm volatile( - "BSTART.TPREFETCH %D[DataType]\n" + "BSTART.TLSU TPREFETCH, %D[DataType]\n" "B.DIM %[VCOL], 0, ->lb0\n" "B.DIM %[VROW], 0, ->lb1\n" "B.DIM zero, %c[Col], ->lb2\n" @@ -4213,7 +4213,7 @@ void TPREFETCH(const gm_shape &src, uint32_t valid_col, uint32_t valid_row) { : "memory"); } else { asm volatile( - "BSTART.TPREFETCH %D[DataType]\n" + "BSTART.TLSU TPREFETCH, %D[DataType]\n" "B.DIM %[VCOL], 0, ->lb0\n" "B.DIM %[VROW], 0, ->lb1\n" "B.DIM %[Col], 0, ->lb2\n" @@ -4269,13 +4269,13 @@ void MGATHER_CAS(DstTile &observedOld, uint64_t base, "layouts must match"); if constexpr (DstTile::ValidCol > 0 && DstTile::ValidRow > 0) { asm volatile( - "BSTART.MGATHER.CAS %D[DataType]\n" + "BSTART.TLSU MGATHER.CAS, %D[DataType]\n" PTO_ATOM_LAYOUT_ASM "B.DIM zero, %c[VCOL], ->lb0\n" "B.DIM zero, %c[VROW], ->lb1\n" "B.DIM zero, %c[Col], ->lb2\n" - "B.IOT %[Idx].reuse, %[Exp].reuse, mask=1111\n" - "B.IOT %[Rep].reuse, mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" + "B.IOT %[Idx], %[Exp], mask=1111\n" + "B.IOT %[Rep], mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" "B.IOR [%[Base]], []\n" : [Dst] "=&Tr"(observedOld.data()) : [Idx] "Tr"(byteDisplacements.data()), [Exp] "Tr"(expected.data()), @@ -4289,13 +4289,13 @@ asm volatile( : "memory"); } else if constexpr (DstTile::ValidCol > 0 && DstTile::ValidRow < 0) { asm volatile( - "BSTART.MGATHER.CAS %D[DataType]\n" + "BSTART.TLSU MGATHER.CAS, %D[DataType]\n" PTO_ATOM_LAYOUT_ASM "B.DIM zero, %c[VCOL], ->lb0\n" "B.DIM %[VROW], 0, ->lb1\n" "B.DIM zero, %c[Col], ->lb2\n" - "B.IOT %[Idx].reuse, %[Exp].reuse, mask=1111\n" - "B.IOT %[Rep].reuse, mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" + "B.IOT %[Idx], %[Exp], mask=1111\n" + "B.IOT %[Rep], mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" "B.IOR [%[Base]], []\n" : [Dst] "=&Tr"(observedOld.data()) : [Idx] "Tr"(byteDisplacements.data()), [Exp] "Tr"(expected.data()), @@ -4309,13 +4309,13 @@ asm volatile( : "memory"); } else if constexpr (DstTile::ValidCol < 0 && DstTile::ValidRow > 0) { asm volatile( - "BSTART.MGATHER.CAS %D[DataType]\n" + "BSTART.TLSU MGATHER.CAS, %D[DataType]\n" PTO_ATOM_LAYOUT_ASM "B.DIM %[VCOL], 0, ->lb0\n" "B.DIM zero, %c[VROW], ->lb1\n" "B.DIM zero, %c[Col], ->lb2\n" - "B.IOT %[Idx].reuse, %[Exp].reuse, mask=1111\n" - "B.IOT %[Rep].reuse, mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" + "B.IOT %[Idx], %[Exp], mask=1111\n" + "B.IOT %[Rep], mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" "B.IOR [%[Base]], []\n" : [Dst] "=&Tr"(observedOld.data()) : [Idx] "Tr"(byteDisplacements.data()), [Exp] "Tr"(expected.data()), @@ -4329,13 +4329,13 @@ asm volatile( : "memory"); } else { asm volatile( - "BSTART.MGATHER.CAS %D[DataType]\n" + "BSTART.TLSU MGATHER.CAS, %D[DataType]\n" PTO_ATOM_LAYOUT_ASM "B.DIM %[VCOL], 0, ->lb0\n" "B.DIM %[VROW], 0, ->lb1\n" "B.DIM zero, %c[Col], ->lb2\n" - "B.IOT %[Idx].reuse, %[Exp].reuse, mask=1111\n" - "B.IOT %[Rep].reuse, mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" + "B.IOT %[Idx], %[Exp], mask=1111\n" + "B.IOT %[Rep], mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" "B.IOR [%[Base]], []\n" : [Dst] "=&Tr"(observedOld.data()) : [Idx] "Tr"(byteDisplacements.data()), [Exp] "Tr"(expected.data()), @@ -4390,12 +4390,12 @@ asm volatile( #FnName " tiles must match the resolved ValidRow x ValidCol");\ if constexpr (DstTile::ValidCol > 0 && DstTile::ValidRow > 0) { \ asm volatile( \ - "BSTART." Mnem " %D[DataType]\n" \ + "BSTART.TLSU " Mnem ", %D[DataType]\n" \ PTO_ATOM_LAYOUT_ASM \ "B.DIM zero, %c[VCOL], ->lb0\n" \ "B.DIM zero, %c[VROW], ->lb1\n" \ "B.DIM zero, %c[Col], ->lb2\n" \ - "B.IOT %[Idx].reuse, %[Val].reuse, mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" \ + "B.IOT %[Idx], %[Val], mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" \ "B.IOR [%[Base]], []\n" \ : [Dst] "=&Tr"(observedOld.data()) \ : [Idx] "Tr"(elementIndices.data()), \ @@ -4407,12 +4407,12 @@ asm volatile( : "memory"); \ } else if constexpr (DstTile::ValidCol > 0 && DstTile::ValidRow < 0) { \ asm volatile( \ - "BSTART." Mnem " %D[DataType]\n" \ + "BSTART.TLSU " Mnem ", %D[DataType]\n" \ PTO_ATOM_LAYOUT_ASM \ "B.DIM zero, %c[VCOL], ->lb0\n" \ "B.DIM %[VROW], 0, ->lb1\n" \ "B.DIM zero, %c[Col], ->lb2\n" \ - "B.IOT %[Idx].reuse, %[Val].reuse, mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" \ + "B.IOT %[Idx], %[Val], mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" \ "B.IOR [%[Base]], []\n" \ : [Dst] "=&Tr"(observedOld.data()) \ : [Idx] "Tr"(elementIndices.data()), \ @@ -4424,12 +4424,12 @@ asm volatile( : "memory"); \ } else if constexpr (DstTile::ValidCol < 0 && DstTile::ValidRow > 0) { \ asm volatile( \ - "BSTART." Mnem " %D[DataType]\n" \ + "BSTART.TLSU " Mnem ", %D[DataType]\n" \ PTO_ATOM_LAYOUT_ASM \ "B.DIM %[VCOL], 0, ->lb0\n" \ "B.DIM zero, %c[VROW], ->lb1\n" \ "B.DIM zero, %c[Col], ->lb2\n" \ - "B.IOT %[Idx].reuse, %[Val].reuse, mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" \ + "B.IOT %[Idx], %[Val], mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" \ "B.IOR [%[Base]], []\n" \ : [Dst] "=&Tr"(observedOld.data()) \ : [Idx] "Tr"(elementIndices.data()), \ @@ -4441,12 +4441,12 @@ asm volatile( : "memory"); \ } else { \ asm volatile( \ - "BSTART." Mnem " %D[DataType]\n" \ + "BSTART.TLSU " Mnem ", %D[DataType]\n" \ PTO_ATOM_LAYOUT_ASM \ "B.DIM %[VCOL], 0, ->lb0\n" \ "B.DIM %[VROW], 0, ->lb1\n" \ "B.DIM zero, %c[Col], ->lb2\n" \ - "B.IOT %[Idx].reuse, %[Val].reuse, mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" \ + "B.IOT %[Idx], %[Val], mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" \ "B.IOR [%[Base]], []\n" \ : [Dst] "=&Tr"(observedOld.data()) \ : [Idx] "Tr"(elementIndices.data()), \ @@ -4523,12 +4523,12 @@ PTO_DEFINE_MGATHER_ATOM(MGATHER_XOR, "MGATHER.XOR", value, #FnName " tiles must match the resolved ValidRow x ValidCol");\ if constexpr (IndexTile::ValidCol > 0 && IndexTile::ValidRow > 0) { \ asm volatile( \ - "BSTART." Mnem " %D[DataType]\n" \ + "BSTART.TLSU " Mnem ", %D[DataType]\n" \ PTO_ATOM_LAYOUT_ASM \ "B.DIM zero, %c[VCOL], ->lb0\n" \ "B.DIM zero, %c[VROW], ->lb1\n" \ "B.DIM zero, %c[Col], ->lb2\n" \ - "B.IOT %[Idx].reuse, %[Val].reuse, mask=1111, last\n" \ + "B.IOT %[Idx], %[Val], mask=1111, last\n" \ "B.IOR [%[Base]], []\n" \ : \ : [Idx] "Tr"(elementIndices.data()), \ @@ -4539,12 +4539,12 @@ PTO_DEFINE_MGATHER_ATOM(MGATHER_XOR, "MGATHER.XOR", value, : "memory"); \ } else if constexpr (IndexTile::ValidCol > 0 && IndexTile::ValidRow < 0) { \ asm volatile( \ - "BSTART." Mnem " %D[DataType]\n" \ + "BSTART.TLSU " Mnem ", %D[DataType]\n" \ PTO_ATOM_LAYOUT_ASM \ "B.DIM zero, %c[VCOL], ->lb0\n" \ "B.DIM %[VROW], 0, ->lb1\n" \ "B.DIM zero, %c[Col], ->lb2\n" \ - "B.IOT %[Idx].reuse, %[Val].reuse, mask=1111, last\n" \ + "B.IOT %[Idx], %[Val], mask=1111, last\n" \ "B.IOR [%[Base]], []\n" \ : \ : [Idx] "Tr"(elementIndices.data()), \ @@ -4555,12 +4555,12 @@ PTO_DEFINE_MGATHER_ATOM(MGATHER_XOR, "MGATHER.XOR", value, : "memory"); \ } else if constexpr (IndexTile::ValidCol < 0 && IndexTile::ValidRow > 0) { \ asm volatile( \ - "BSTART." Mnem " %D[DataType]\n" \ + "BSTART.TLSU " Mnem ", %D[DataType]\n" \ PTO_ATOM_LAYOUT_ASM \ "B.DIM %[VCOL], 0, ->lb0\n" \ "B.DIM zero, %c[VROW], ->lb1\n" \ "B.DIM zero, %c[Col], ->lb2\n" \ - "B.IOT %[Idx].reuse, %[Val].reuse, mask=1111, last\n" \ + "B.IOT %[Idx], %[Val], mask=1111, last\n" \ "B.IOR [%[Base]], []\n" \ : \ : [Idx] "Tr"(elementIndices.data()), \ @@ -4571,12 +4571,12 @@ PTO_DEFINE_MGATHER_ATOM(MGATHER_XOR, "MGATHER.XOR", value, : "memory"); \ } else { \ asm volatile( \ - "BSTART." Mnem " %D[DataType]\n" \ + "BSTART.TLSU " Mnem ", %D[DataType]\n" \ PTO_ATOM_LAYOUT_ASM \ "B.DIM %[VCOL], 0, ->lb0\n" \ "B.DIM %[VROW], 0, ->lb1\n" \ "B.DIM zero, %c[Col], ->lb2\n" \ - "B.IOT %[Idx].reuse, %[Val].reuse, mask=1111, last\n" \ + "B.IOT %[Idx], %[Val], mask=1111, last\n" \ "B.IOR [%[Base]], []\n" \ : \ : [Idx] "Tr"(elementIndices.data()), \ @@ -4637,12 +4637,12 @@ void MSCATTER_POPC(uint64_t base, IndexTile &elementIndices, uint32_t validCol, "MSCATTER_POPC index tile must use S32, U32, S64, or U64"); if constexpr (IndexTile::ValidCol > 0 && IndexTile::ValidRow > 0) { asm volatile( - "BSTART.MSCATTER.POPC %D[DataType]\n" + "BSTART.TLSU MSCATTER.POPC, %D[DataType]\n" PTO_ATOM_LAYOUT_ASM "B.DIM zero, %c[VCOL], ->lb0\n" "B.DIM zero, %c[VROW], ->lb1\n" "B.DIM zero, %c[Col], ->lb2\n" - "B.IOT %[Idx].reuse, mask=1111, last\n" + "B.IOT %[Idx], mask=1111, last\n" "B.IOR [%[Base]], []\n" : : [Idx] "Tr"(elementIndices.data()), [Base] "r"(base), @@ -4653,12 +4653,12 @@ void MSCATTER_POPC(uint64_t base, IndexTile &elementIndices, uint32_t validCol, : "memory"); } else if constexpr (IndexTile::ValidCol > 0 && IndexTile::ValidRow < 0) { asm volatile( - "BSTART.MSCATTER.POPC %D[DataType]\n" + "BSTART.TLSU MSCATTER.POPC, %D[DataType]\n" PTO_ATOM_LAYOUT_ASM "B.DIM zero, %c[VCOL], ->lb0\n" "B.DIM %[VROW], 0, ->lb1\n" "B.DIM zero, %c[Col], ->lb2\n" - "B.IOT %[Idx].reuse, mask=1111, last\n" + "B.IOT %[Idx], mask=1111, last\n" "B.IOR [%[Base]], []\n" : : [Idx] "Tr"(elementIndices.data()), [Base] "r"(base), @@ -4669,12 +4669,12 @@ void MSCATTER_POPC(uint64_t base, IndexTile &elementIndices, uint32_t validCol, : "memory"); } else if constexpr (IndexTile::ValidCol < 0 && IndexTile::ValidRow > 0) { asm volatile( - "BSTART.MSCATTER.POPC %D[DataType]\n" + "BSTART.TLSU MSCATTER.POPC, %D[DataType]\n" PTO_ATOM_LAYOUT_ASM "B.DIM %[VCOL], 0, ->lb0\n" "B.DIM zero, %c[VROW], ->lb1\n" "B.DIM zero, %c[Col], ->lb2\n" - "B.IOT %[Idx].reuse, mask=1111, last\n" + "B.IOT %[Idx], mask=1111, last\n" "B.IOR [%[Base]], []\n" : : [Idx] "Tr"(elementIndices.data()), [Base] "r"(base), @@ -4685,12 +4685,12 @@ void MSCATTER_POPC(uint64_t base, IndexTile &elementIndices, uint32_t validCol, : "memory"); } else { asm volatile( - "BSTART.MSCATTER.POPC %D[DataType]\n" + "BSTART.TLSU MSCATTER.POPC, %D[DataType]\n" PTO_ATOM_LAYOUT_ASM "B.DIM %[VCOL], 0, ->lb0\n" "B.DIM %[VROW], 0, ->lb1\n" "B.DIM zero, %c[Col], ->lb2\n" - "B.IOT %[Idx].reuse, mask=1111, last\n" + "B.IOT %[Idx], mask=1111, last\n" "B.IOR [%[Base]], []\n" : : [Idx] "Tr"(elementIndices.data()), [Base] "r"(base), @@ -4746,7 +4746,7 @@ void GMOV(tile_shape_dst &dst, uint64_t peer_tid, const tile_shape_src &src) { asm volatile( "BSTART.GMOV %D[DataType]\n" PTO_ZERO_PAD_LAYOUT_ASM - PTO_PE_MASK_ASM("B.IOT %[src].reuse, mask=", + PTO_PE_MASK_ASM("B.IOT %[src], mask=", ", last, ->%[dst]<%Z[TileSize]>\n") "B.IOR [%[peer]],[]\n" : [dst] "=Tr"(dst.data()) @@ -4775,9 +4775,9 @@ TMOV_L2S_INSERT(SharedTile &dst, "TMOV.L2S.INSERT logical Tile size must be 128 B..256 KB (SizeCode=1..12)"); dst.SetValidShape(src); asm volatile( - "BSTART.TMOV.L2S.INSERT %D[DataType]\n" + "BSTART.TLSU TMOV.L2S.INSERT, %D[DataType]\n" PTO_PE_MASK_ASM("B.IOS mask=", ", ->%S[Shared]<%Z[TileSize]>\n") - PTO_PE_MASK_ASM("B.IOT %[src].reuse, mask=", ", last\n") + PTO_PE_MASK_ASM("B.IOT %[src], mask=", ", last\n") : [Shared] "=Sr"(dst.handle_ref()) : [src] "Tr"(src.data()), [PEMask] "i"(PEMask), @@ -4806,9 +4806,9 @@ TMOV_L2S_PUBLISH(SharedTile &dst, "TMOV.L2S.PUBLISH logical Tile size must be 128 B..256 KB (SizeCode=1..12)"); dst.SetValidShape(src); asm volatile( - "BSTART.TMOV.L2S.PUBLISH %D[DataType]\n" + "BSTART.TLSU TMOV.L2S.PUBLISH, %D[DataType]\n" PTO_PE_MASK_ASM("B.IOS mask=", ", ->%S[Shared]<%Z[TileSize]>\n") - PTO_PE_MASK_ASM("B.IOT %[src].reuse, mask=", ", last\n") + PTO_PE_MASK_ASM("B.IOT %[src], mask=", ", last\n") : [Shared] "=Sr"(dst.handle_ref()) : [src] "Tr"(src.data()), [PEMask] "i"(PEMask), @@ -4836,8 +4836,8 @@ TMOV_S2L_BROADCAST(tile_shape_dst &dst, tile_type_traits::IsValidActiveSize, "TMOV.S2L.BROADCAST logical Tile size must be 128 B..256 KiB (SizeCode=1..12)"); asm volatile( - "BSTART.TMOV.S2L.BROADCAST %D[DataType]\n" - PTO_PE_MASK_ASM("B.IOS %S[Shared].reuse, mask=", "\n") + "BSTART.TLSU TMOV.S2L.BROADCAST, %D[DataType]\n" + PTO_PE_MASK_ASM("B.IOS %S[Shared], mask=", "\n") PTO_PE_MASK_ASM("B.IOT mask=", ", last, ->%[dst]<%Z[TileSize]>\n") : [dst] "=Tr"(dst.data()) : [Shared] "Sr"(shared.handle()), [PEMask] "i"(PEMask), @@ -4856,8 +4856,8 @@ PTO_SHARED_INLINE void TMOV_S2L_EXTRACT( tile_type_traits::IsValidActiveSize, "TMOV.S2L.EXTRACT logical Tile size must be 128 B..256 KiB (SizeCode=1..12)"); asm volatile( - "BSTART.TMOV.S2L.EXTRACT %D[DataType]\n" - PTO_PE_MASK_ASM("B.IOS %S[Shared].reuse, mask=", "\n") + "BSTART.TLSU TMOV.S2L.EXTRACT, %D[DataType]\n" + PTO_PE_MASK_ASM("B.IOS %S[Shared], mask=", "\n") PTO_PE_MASK_ASM("B.IOT mask=", ", last, ->%[dst]<%Z[TileSize]>\n") : [dst] "=Tr"(dst.data()) : [Shared] "Sr"(shared.handle()), [PEMask] "i"(PEMask), @@ -4890,7 +4890,7 @@ namespace pto_matmul_detail { // must emit RNONE. Only the programmable integer pre-quant modes retain // the RNE spelling through the trailing fallback. #define PTO_MATMUL_HEADER(OPCODE, EXTRA_ATTRS) \ - "BSTART." OPCODE " %D[DataTypeA]\n" \ + "BSTART.CUBE " OPCODE ", %D[DataTypeA]\n" \ ".if %c[PreQuant] == 0 && %c[CCTRL] == 0\n" \ "B.DATR %D[DataTypeB], byte0, Zero, RNONE, NOSAT\n" \ ".elseif %c[PreQuant] == 0 && %c[CCTRL] == 1\n" \ @@ -5479,7 +5479,7 @@ PTO_SHARED_INLINE void matmul(Dst &dst, A &a, B &b, size_t M, size_t N, if constexpr (!is_shared_tile_v && !is_shared_tile_v) { asm volatile( PTO_MATMUL_HEADER("TMATMUL", PTO_FIXP_ATTR) - "B.IOT %[A].reuse, %[B].reuse, mask=1111, last, ->%[Dst]<%Z[TileSize]>\n" + "B.IOT %[A], %[B], mask=1111, last, ->%[Dst]<%Z[TileSize]>\n" : [Dst] "=&Tr"(dst.data()) : [A] "Tr"(a.data()), [B] "Tr"(b.data()), PTO_FIXP_ATTR_INPUTS, @@ -5488,8 +5488,8 @@ PTO_SHARED_INLINE void matmul(Dst &dst, A &a, B &b, size_t M, size_t N, } else if constexpr (is_shared_tile_v && !is_shared_tile_v) { asm volatile( PTO_MATMUL_HEADER("TMATMUL", PTO_FIXP_ATTR) - "B.IOS %S[SharedA].reuse, mask=1111\n" - "B.IOT %[B].reuse, mask=1111, last, ->%[Dst]<%Z[TileSize]>\n" + "B.IOS %S[SharedA], mask=1111\n" + "B.IOT %[B], mask=1111, last, ->%[Dst]<%Z[TileSize]>\n" : [Dst] "=&Tr"(dst.data()) : [SharedA] "Sr"(a.handle()), [B] "Tr"(b.data()), PTO_FIXP_ATTR_INPUTS, @@ -5498,8 +5498,8 @@ PTO_SHARED_INLINE void matmul(Dst &dst, A &a, B &b, size_t M, size_t N, } else if constexpr (!is_shared_tile_v && is_shared_tile_v) { asm volatile( PTO_MATMUL_HEADER("TMATMUL", PTO_FIXP_ATTR) - "B.IOS %S[SharedB].reuse, mask=1111\n" - "B.IOT %[A].reuse, mask=1111, last, ->%[Dst]<%Z[TileSize]>\n" + "B.IOS %S[SharedB], mask=1111\n" + "B.IOT %[A], mask=1111, last, ->%[Dst]<%Z[TileSize]>\n" : [Dst] "=&Tr"(dst.data()) : [A] "Tr"(a.data()), [SharedB] "Sr"(b.handle()), PTO_FIXP_ATTR_INPUTS, @@ -5508,8 +5508,8 @@ PTO_SHARED_INLINE void matmul(Dst &dst, A &a, B &b, size_t M, size_t N, } else { asm volatile( PTO_MATMUL_HEADER("TMATMUL", PTO_FIXP_ATTR) - "B.IOS %S[SharedA].reuse, mask=1111\n" - "B.IOS %S[SharedB].reuse, mask=1111\n" + "B.IOS %S[SharedA], mask=1111\n" + "B.IOS %S[SharedB], mask=1111\n" "B.IOT mask=1111, last, ->%[Dst]<%Z[TileSize]>\n" : [Dst] "=&Tr"(dst.data()) : [SharedA] "Sr"(a.handle()), [SharedB] "Sr"(b.handle()), @@ -5540,14 +5540,14 @@ PTO_SHARED_INLINE void matmul_slot_impl(Dst &dst) { constexpr int TileSize = tile_type_traits::TilesizeCode; asm volatile( - "BSTART.TMATMUL FP32\n" + "BSTART.CUBE TMATMUL, FP32\n" "B.DATR FP32, byte0, Zero, RNONE, NOSAT\n" PTO_FIXP_ATTR "B.DIM zero, %c[M], ->lb0\n" "B.DIM zero, %c[N], ->lb1\n" "B.DIM zero, %c[K], ->lb2\n" - "B.IOS S%c[SharedA].reuse, mask=1111\n" - "B.IOS S%c[SharedB].reuse, mask=1111\n" + "B.IOS S%c[SharedA], mask=1111\n" + "B.IOS S%c[SharedB], mask=1111\n" "B.IOT mask=1111, last, ->%[Dst]<%Z[TileSize]>\n" : [Dst] "=&Tr"(dst.data()) : [SharedA] "i"(SlotA), [SharedB] "i"(SlotB), @@ -5568,8 +5568,8 @@ PTO_SHARED_INLINE void Name(Dst &dst, A &a, B &b, Extra &extra, if constexpr (!is_shared_tile_v && !is_shared_tile_v) { \ asm volatile( \ PTO_MATMUL_HEADER(Opcode, PTO_FIXP_ATTR) \ - "B.IOT %[A].reuse, %[B].reuse, mask=1111\n" \ - "B.IOT %[Extra].reuse, mask=1111, last, ->%[Dst]<%Z[TileSize]>\n" \ + "B.IOT %[A], %[B], mask=1111\n" \ + "B.IOT %[Extra], mask=1111, last, ->%[Dst]<%Z[TileSize]>\n" \ : [Dst] "=&Tr"(dst.data()) \ : [A] "Tr"(a.data()), [B] "Tr"(b.data()), \ [Extra] "Tr"(extra.data()), \ @@ -5579,8 +5579,8 @@ PTO_SHARED_INLINE void Name(Dst &dst, A &a, B &b, Extra &extra, } else if constexpr (is_shared_tile_v && !is_shared_tile_v) { \ asm volatile( \ PTO_MATMUL_HEADER(Opcode, PTO_FIXP_ATTR) \ - "B.IOS %S[SharedA].reuse, mask=1111\n" \ - "B.IOT %[B].reuse, %[Extra].reuse, mask=1111, last, ->%[Dst]<%Z[TileSize]>\n" \ + "B.IOS %S[SharedA], mask=1111\n" \ + "B.IOT %[B], %[Extra], mask=1111, last, ->%[Dst]<%Z[TileSize]>\n" \ : [Dst] "=&Tr"(dst.data()) \ : [SharedA] "Sr"(a.handle()), [B] "Tr"(b.data()), \ [Extra] "Tr"(extra.data()), \ @@ -5590,8 +5590,8 @@ PTO_SHARED_INLINE void Name(Dst &dst, A &a, B &b, Extra &extra, } else if constexpr (!is_shared_tile_v && is_shared_tile_v) { \ asm volatile( \ PTO_MATMUL_HEADER(Opcode, PTO_FIXP_ATTR) \ - "B.IOS %S[SharedB].reuse, mask=1111\n" \ - "B.IOT %[A].reuse, %[Extra].reuse, mask=1111, last, ->%[Dst]<%Z[TileSize]>\n" \ + "B.IOS %S[SharedB], mask=1111\n" \ + "B.IOT %[A], %[Extra], mask=1111, last, ->%[Dst]<%Z[TileSize]>\n" \ : [Dst] "=&Tr"(dst.data()) \ : [A] "Tr"(a.data()), [SharedB] "Sr"(b.handle()), \ [Extra] "Tr"(extra.data()), \ @@ -5601,9 +5601,9 @@ PTO_SHARED_INLINE void Name(Dst &dst, A &a, B &b, Extra &extra, } else { \ asm volatile( \ PTO_MATMUL_HEADER(Opcode, PTO_FIXP_ATTR) \ - "B.IOS %S[SharedA].reuse, mask=1111\n" \ - "B.IOS %S[SharedB].reuse, mask=1111\n" \ - "B.IOT %[Extra].reuse, mask=1111, last, ->%[Dst]<%Z[TileSize]>\n" \ + "B.IOS %S[SharedA], mask=1111\n" \ + "B.IOS %S[SharedB], mask=1111\n" \ + "B.IOT %[Extra], mask=1111, last, ->%[Dst]<%Z[TileSize]>\n" \ : [Dst] "=&Tr"(dst.data()) \ : [SharedA] "Sr"(a.handle()), [SharedB] "Sr"(b.handle()), \ [Extra] "Tr"(extra.data()), \ @@ -5625,8 +5625,8 @@ PTO_SHARED_INLINE void matmul_acc(Dst &dst, C &c, A &a, B &b, size_t M, if constexpr (!is_shared_tile_v && !is_shared_tile_v) { asm volatile( PTO_MATMUL_HEADER("TMATMUL.ACC", PTO_FIXP_ATTR) - "B.IOT %[C].reuse, mask=1111\n" - "B.IOT %[A].reuse, %[B].reuse, mask=1111, last, ->%[Dst]<%Z[TileSize]>\n" + "B.IOT %[C], mask=1111\n" + "B.IOT %[A], %[B], mask=1111, last, ->%[Dst]<%Z[TileSize]>\n" : [Dst] "=&Tr"(dst.data()) : [C] "Tr"(c.data()), [A] "Tr"(a.data()), [B] "Tr"(b.data()), PTO_FIXP_ATTR_INPUTS, @@ -5635,8 +5635,8 @@ PTO_SHARED_INLINE void matmul_acc(Dst &dst, C &c, A &a, B &b, size_t M, } else if constexpr (is_shared_tile_v && !is_shared_tile_v) { asm volatile( PTO_MATMUL_HEADER("TMATMUL.ACC", PTO_FIXP_ATTR) - "B.IOS %S[SharedA].reuse, mask=1111\n" - "B.IOT %[C].reuse, %[B].reuse, mask=1111, last, ->%[Dst]<%Z[TileSize]>\n" + "B.IOS %S[SharedA], mask=1111\n" + "B.IOT %[C], %[B], mask=1111, last, ->%[Dst]<%Z[TileSize]>\n" : [Dst] "=&Tr"(dst.data()) : [C] "Tr"(c.data()), [SharedA] "Sr"(a.handle()), [B] "Tr"(b.data()), PTO_FIXP_ATTR_INPUTS, @@ -5645,8 +5645,8 @@ PTO_SHARED_INLINE void matmul_acc(Dst &dst, C &c, A &a, B &b, size_t M, } else if constexpr (!is_shared_tile_v && is_shared_tile_v) { asm volatile( PTO_MATMUL_HEADER("TMATMUL.ACC", PTO_FIXP_ATTR) - "B.IOS %S[SharedB].reuse, mask=1111\n" - "B.IOT %[C].reuse, %[A].reuse, mask=1111, last, ->%[Dst]<%Z[TileSize]>\n" + "B.IOS %S[SharedB], mask=1111\n" + "B.IOT %[C], %[A], mask=1111, last, ->%[Dst]<%Z[TileSize]>\n" : [Dst] "=&Tr"(dst.data()) : [C] "Tr"(c.data()), [A] "Tr"(a.data()), [SharedB] "Sr"(b.handle()), PTO_FIXP_ATTR_INPUTS, @@ -5655,9 +5655,9 @@ PTO_SHARED_INLINE void matmul_acc(Dst &dst, C &c, A &a, B &b, size_t M, } else { asm volatile( PTO_MATMUL_HEADER("TMATMUL.ACC", PTO_FIXP_ATTR) - "B.IOS %S[SharedA].reuse, mask=1111\n" - "B.IOS %S[SharedB].reuse, mask=1111\n" - "B.IOT %[C].reuse, mask=1111, last, ->%[Dst]<%Z[TileSize]>\n" + "B.IOS %S[SharedA], mask=1111\n" + "B.IOS %S[SharedB], mask=1111\n" + "B.IOT %[C], mask=1111, last, ->%[Dst]<%Z[TileSize]>\n" : [Dst] "=&Tr"(dst.data()) : [C] "Tr"(c.data()), [SharedA] "Sr"(a.handle()), [SharedB] "Sr"(b.handle()), PTO_FIXP_ATTR_INPUTS, @@ -5675,24 +5675,24 @@ PTO_SHARED_INLINE void matmul_acc(Dst &dst, C &c, A &a, B &b, size_t M, // first and then reference the matching PTO_FIXP_PPSRC_. #define PTO_FIXP_PPSRC_0 #define PTO_FIXP_PPSRC_1 \ - "B.IOT %[RowIn].reuse, mask=1111\n" + "B.IOT %[RowIn], mask=1111\n" #define PTO_FIXP_PPSRC_2 \ - "B.IOT %[QuantTile].reuse, mask=1111\n" + "B.IOT %[QuantTile], mask=1111\n" #define PTO_FIXP_PPSRC_3 \ - "B.IOT %[RowIn].reuse, %[QuantTile].reuse, mask=1111\n" + "B.IOT %[RowIn], %[QuantTile], mask=1111\n" #define PTO_FIXP_PPSRC_4 \ - "B.IOT %[ReluTile].reuse, mask=1111\n" + "B.IOT %[ReluTile], mask=1111\n" #define PTO_FIXP_PPSRC_5 \ - "B.IOT %[RowIn].reuse, %[ReluTile].reuse, mask=1111\n" + "B.IOT %[RowIn], %[ReluTile], mask=1111\n" #define PTO_FIXP_PPSRC_6 \ - "B.IOT %[QuantTile].reuse, %[ReluTile].reuse, mask=1111\n" + "B.IOT %[QuantTile], %[ReluTile], mask=1111\n" #define PTO_FIXP_PPSRC_7 \ - "B.IOT %[RowIn].reuse, %[QuantTile].reuse, mask=1111\n" \ - "B.IOT %[ReluTile].reuse, mask=1111\n" + "B.IOT %[RowIn], %[QuantTile], mask=1111\n" \ + "B.IOT %[ReluTile], mask=1111\n" #define PTO_FIXP_ACC_CSCALE \ ".if %c[CScaleEn]\n" \ - "B.IOT %[CScaleOperand].reuse, mask=1111\n" \ + "B.IOT %[CScaleOperand], mask=1111\n" \ ".endif\n" #define PTO_FIXP_ACC_PPSRC_0 PTO_FIXP_ACC_CSCALE PTO_FIXP_PPSRC_0 @@ -5784,131 +5784,131 @@ PTO_SHARED_INLINE void matmul_acc(Dst &dst, C &c, A &a, B &b, size_t M, ".else\n" PTO_FIXP_BIOT_2(X, "%[RowIn]") PTO_FIXP_BIOT_2("%[QuantTile]", "%[ReluTile]") ".endif\n" #define PTO_FIXP_ACC_L_SRC_0 \ - "B.IOT %[C].reuse, %[A].reuse, mask=1111\n" "B.IOT %[B].reuse, mask=1111\n" \ + "B.IOT %[C], %[A], mask=1111\n" "B.IOT %[B], mask=1111\n" \ PTO_FIXP_ACC_PPSRC_0 #define PTO_FIXP_ACC_L_SRC_1 \ - "B.IOT %[C].reuse, %[A].reuse, mask=1111\n" "B.IOT %[B].reuse, mask=1111\n" \ + "B.IOT %[C], %[A], mask=1111\n" "B.IOT %[B], mask=1111\n" \ PTO_FIXP_ACC_PPSRC_1 #define PTO_FIXP_ACC_L_SRC_2 \ - "B.IOT %[C].reuse, %[A].reuse, mask=1111\n" "B.IOT %[B].reuse, mask=1111\n" \ + "B.IOT %[C], %[A], mask=1111\n" "B.IOT %[B], mask=1111\n" \ PTO_FIXP_ACC_PPSRC_2 #define PTO_FIXP_ACC_L_SRC_3 \ - "B.IOT %[C].reuse, %[A].reuse, mask=1111\n" "B.IOT %[B].reuse, mask=1111\n" \ + "B.IOT %[C], %[A], mask=1111\n" "B.IOT %[B], mask=1111\n" \ PTO_FIXP_ACC_PPSRC_3 #define PTO_FIXP_ACC_L_SRC_4 \ - "B.IOT %[C].reuse, %[A].reuse, mask=1111\n" "B.IOT %[B].reuse, mask=1111\n" \ + "B.IOT %[C], %[A], mask=1111\n" "B.IOT %[B], mask=1111\n" \ PTO_FIXP_ACC_PPSRC_4 #define PTO_FIXP_ACC_L_SRC_5 \ - "B.IOT %[C].reuse, %[A].reuse, mask=1111\n" "B.IOT %[B].reuse, mask=1111\n" \ + "B.IOT %[C], %[A], mask=1111\n" "B.IOT %[B], mask=1111\n" \ PTO_FIXP_ACC_PPSRC_5 #define PTO_FIXP_ACC_L_SRC_6 \ - "B.IOT %[C].reuse, %[A].reuse, mask=1111\n" "B.IOT %[B].reuse, mask=1111\n" \ + "B.IOT %[C], %[A], mask=1111\n" "B.IOT %[B], mask=1111\n" \ PTO_FIXP_ACC_PPSRC_6 #define PTO_FIXP_ACC_L_SRC_7 \ - "B.IOT %[C].reuse, %[A].reuse, mask=1111\n" "B.IOT %[B].reuse, mask=1111\n" \ + "B.IOT %[C], %[A], mask=1111\n" "B.IOT %[B], mask=1111\n" \ PTO_FIXP_ACC_PPSRC_7 #define PTO_FIXP_ACC_SB_SRC_0 \ - "B.IOS %S[SharedB].reuse, mask=1111\n" "B.IOT %[C].reuse, %[A].reuse, mask=1111\n" \ + "B.IOS %S[SharedB], mask=1111\n" "B.IOT %[C], %[A], mask=1111\n" \ PTO_FIXP_ACC_PPSRC_0 #define PTO_FIXP_ACC_SB_SRC_1 \ - "B.IOS %S[SharedB].reuse, mask=1111\n" "B.IOT %[C].reuse, %[A].reuse, mask=1111\n" \ + "B.IOS %S[SharedB], mask=1111\n" "B.IOT %[C], %[A], mask=1111\n" \ PTO_FIXP_ACC_PPSRC_1 #define PTO_FIXP_ACC_SB_SRC_2 \ - "B.IOS %S[SharedB].reuse, mask=1111\n" "B.IOT %[C].reuse, %[A].reuse, mask=1111\n" \ + "B.IOS %S[SharedB], mask=1111\n" "B.IOT %[C], %[A], mask=1111\n" \ PTO_FIXP_ACC_PPSRC_2 #define PTO_FIXP_ACC_SB_SRC_3 \ - "B.IOS %S[SharedB].reuse, mask=1111\n" "B.IOT %[C].reuse, %[A].reuse, mask=1111\n" \ + "B.IOS %S[SharedB], mask=1111\n" "B.IOT %[C], %[A], mask=1111\n" \ PTO_FIXP_ACC_PPSRC_3 #define PTO_FIXP_ACC_SB_SRC_4 \ - "B.IOS %S[SharedB].reuse, mask=1111\n" "B.IOT %[C].reuse, %[A].reuse, mask=1111\n" \ + "B.IOS %S[SharedB], mask=1111\n" "B.IOT %[C], %[A], mask=1111\n" \ PTO_FIXP_ACC_PPSRC_4 #define PTO_FIXP_ACC_SB_SRC_5 \ - "B.IOS %S[SharedB].reuse, mask=1111\n" "B.IOT %[C].reuse, %[A].reuse, mask=1111\n" \ + "B.IOS %S[SharedB], mask=1111\n" "B.IOT %[C], %[A], mask=1111\n" \ PTO_FIXP_ACC_PPSRC_5 #define PTO_FIXP_ACC_SB_SRC_6 \ - "B.IOS %S[SharedB].reuse, mask=1111\n" "B.IOT %[C].reuse, %[A].reuse, mask=1111\n" \ + "B.IOS %S[SharedB], mask=1111\n" "B.IOT %[C], %[A], mask=1111\n" \ PTO_FIXP_ACC_PPSRC_6 #define PTO_FIXP_ACC_SB_SRC_7 \ - "B.IOS %S[SharedB].reuse, mask=1111\n" "B.IOT %[C].reuse, %[A].reuse, mask=1111\n" \ + "B.IOS %S[SharedB], mask=1111\n" "B.IOT %[C], %[A], mask=1111\n" \ PTO_FIXP_ACC_PPSRC_7 #define PTO_FIXP_ACC_SA_SRC_0 \ - "B.IOS %S[SharedA].reuse, mask=1111\n" "B.IOT %[C].reuse, %[B].reuse, mask=1111\n" \ + "B.IOS %S[SharedA], mask=1111\n" "B.IOT %[C], %[B], mask=1111\n" \ PTO_FIXP_ACC_PPSRC_0 #define PTO_FIXP_ACC_SA_SRC_1 \ - "B.IOS %S[SharedA].reuse, mask=1111\n" "B.IOT %[C].reuse, %[B].reuse, mask=1111\n" \ + "B.IOS %S[SharedA], mask=1111\n" "B.IOT %[C], %[B], mask=1111\n" \ PTO_FIXP_ACC_PPSRC_1 #define PTO_FIXP_ACC_SA_SRC_2 \ - "B.IOS %S[SharedA].reuse, mask=1111\n" "B.IOT %[C].reuse, %[B].reuse, mask=1111\n" \ + "B.IOS %S[SharedA], mask=1111\n" "B.IOT %[C], %[B], mask=1111\n" \ PTO_FIXP_ACC_PPSRC_2 #define PTO_FIXP_ACC_SA_SRC_3 \ - "B.IOS %S[SharedA].reuse, mask=1111\n" "B.IOT %[C].reuse, %[B].reuse, mask=1111\n" \ + "B.IOS %S[SharedA], mask=1111\n" "B.IOT %[C], %[B], mask=1111\n" \ PTO_FIXP_ACC_PPSRC_3 #define PTO_FIXP_ACC_SA_SRC_4 \ - "B.IOS %S[SharedA].reuse, mask=1111\n" "B.IOT %[C].reuse, %[B].reuse, mask=1111\n" \ + "B.IOS %S[SharedA], mask=1111\n" "B.IOT %[C], %[B], mask=1111\n" \ PTO_FIXP_ACC_PPSRC_4 #define PTO_FIXP_ACC_SA_SRC_5 \ - "B.IOS %S[SharedA].reuse, mask=1111\n" "B.IOT %[C].reuse, %[B].reuse, mask=1111\n" \ + "B.IOS %S[SharedA], mask=1111\n" "B.IOT %[C], %[B], mask=1111\n" \ PTO_FIXP_ACC_PPSRC_5 #define PTO_FIXP_ACC_SA_SRC_6 \ - "B.IOS %S[SharedA].reuse, mask=1111\n" "B.IOT %[C].reuse, %[B].reuse, mask=1111\n" \ + "B.IOS %S[SharedA], mask=1111\n" "B.IOT %[C], %[B], mask=1111\n" \ PTO_FIXP_ACC_PPSRC_6 #define PTO_FIXP_ACC_SA_SRC_7 \ - "B.IOS %S[SharedA].reuse, mask=1111\n" "B.IOT %[C].reuse, %[B].reuse, mask=1111\n" \ + "B.IOS %S[SharedA], mask=1111\n" "B.IOT %[C], %[B], mask=1111\n" \ PTO_FIXP_ACC_PPSRC_7 #define PTO_FIXP_ACC_SAB_SRC_0 \ - "B.IOS %S[SharedA].reuse, mask=1111\n" "B.IOS %S[SharedB].reuse, mask=1111\n" "B.IOT %[C].reuse, mask=1111\n" \ + "B.IOS %S[SharedA], mask=1111\n" "B.IOS %S[SharedB], mask=1111\n" "B.IOT %[C], mask=1111\n" \ PTO_FIXP_ACC_PPSRC_0 #define PTO_FIXP_ACC_SAB_SRC_1 \ - "B.IOS %S[SharedA].reuse, mask=1111\n" "B.IOS %S[SharedB].reuse, mask=1111\n" "B.IOT %[C].reuse, mask=1111\n" \ + "B.IOS %S[SharedA], mask=1111\n" "B.IOS %S[SharedB], mask=1111\n" "B.IOT %[C], mask=1111\n" \ PTO_FIXP_ACC_PPSRC_1 #define PTO_FIXP_ACC_SAB_SRC_2 \ - "B.IOS %S[SharedA].reuse, mask=1111\n" "B.IOS %S[SharedB].reuse, mask=1111\n" "B.IOT %[C].reuse, mask=1111\n" \ + "B.IOS %S[SharedA], mask=1111\n" "B.IOS %S[SharedB], mask=1111\n" "B.IOT %[C], mask=1111\n" \ PTO_FIXP_ACC_PPSRC_2 #define PTO_FIXP_ACC_SAB_SRC_3 \ - "B.IOS %S[SharedA].reuse, mask=1111\n" "B.IOS %S[SharedB].reuse, mask=1111\n" "B.IOT %[C].reuse, mask=1111\n" \ + "B.IOS %S[SharedA], mask=1111\n" "B.IOS %S[SharedB], mask=1111\n" "B.IOT %[C], mask=1111\n" \ PTO_FIXP_ACC_PPSRC_3 #define PTO_FIXP_ACC_SAB_SRC_4 \ - "B.IOS %S[SharedA].reuse, mask=1111\n" "B.IOS %S[SharedB].reuse, mask=1111\n" "B.IOT %[C].reuse, mask=1111\n" \ + "B.IOS %S[SharedA], mask=1111\n" "B.IOS %S[SharedB], mask=1111\n" "B.IOT %[C], mask=1111\n" \ PTO_FIXP_ACC_PPSRC_4 #define PTO_FIXP_ACC_SAB_SRC_5 \ - "B.IOS %S[SharedA].reuse, mask=1111\n" "B.IOS %S[SharedB].reuse, mask=1111\n" "B.IOT %[C].reuse, mask=1111\n" \ + "B.IOS %S[SharedA], mask=1111\n" "B.IOS %S[SharedB], mask=1111\n" "B.IOT %[C], mask=1111\n" \ PTO_FIXP_ACC_PPSRC_5 #define PTO_FIXP_ACC_SAB_SRC_6 \ - "B.IOS %S[SharedA].reuse, mask=1111\n" "B.IOS %S[SharedB].reuse, mask=1111\n" "B.IOT %[C].reuse, mask=1111\n" \ + "B.IOS %S[SharedA], mask=1111\n" "B.IOS %S[SharedB], mask=1111\n" "B.IOT %[C], mask=1111\n" \ PTO_FIXP_ACC_PPSRC_6 #define PTO_FIXP_ACC_SAB_SRC_7 \ - "B.IOS %S[SharedA].reuse, mask=1111\n" "B.IOS %S[SharedB].reuse, mask=1111\n" "B.IOT %[C].reuse, mask=1111\n" \ + "B.IOS %S[SharedA], mask=1111\n" "B.IOS %S[SharedB], mask=1111\n" "B.IOT %[C], mask=1111\n" \ PTO_FIXP_ACC_PPSRC_7 // Re-declare ACC source families with the CScale/PostProcess tail folded into @@ -5922,14 +5922,14 @@ PTO_SHARED_INLINE void matmul_acc(Dst &dst, C &c, A &a, B &b, size_t M, #undef PTO_FIXP_ACC_L_SRC_5 #undef PTO_FIXP_ACC_L_SRC_6 #undef PTO_FIXP_ACC_L_SRC_7 -#define PTO_FIXP_ACC_L_SRC_0 "B.IOT %[C].reuse, %[A].reuse, mask=1111\n" PTO_FIXP_ACC_ODD_TAIL_0("%[B]") -#define PTO_FIXP_ACC_L_SRC_1 "B.IOT %[C].reuse, %[A].reuse, mask=1111\n" PTO_FIXP_ACC_ODD_TAIL_1("%[B]") -#define PTO_FIXP_ACC_L_SRC_2 "B.IOT %[C].reuse, %[A].reuse, mask=1111\n" PTO_FIXP_ACC_ODD_TAIL_2("%[B]") -#define PTO_FIXP_ACC_L_SRC_3 "B.IOT %[C].reuse, %[A].reuse, mask=1111\n" PTO_FIXP_ACC_ODD_TAIL_3("%[B]") -#define PTO_FIXP_ACC_L_SRC_4 "B.IOT %[C].reuse, %[A].reuse, mask=1111\n" PTO_FIXP_ACC_ODD_TAIL_4("%[B]") -#define PTO_FIXP_ACC_L_SRC_5 "B.IOT %[C].reuse, %[A].reuse, mask=1111\n" PTO_FIXP_ACC_ODD_TAIL_5("%[B]") -#define PTO_FIXP_ACC_L_SRC_6 "B.IOT %[C].reuse, %[A].reuse, mask=1111\n" PTO_FIXP_ACC_ODD_TAIL_6("%[B]") -#define PTO_FIXP_ACC_L_SRC_7 "B.IOT %[C].reuse, %[A].reuse, mask=1111\n" PTO_FIXP_ACC_ODD_TAIL_7("%[B]") +#define PTO_FIXP_ACC_L_SRC_0 "B.IOT %[C], %[A], mask=1111\n" PTO_FIXP_ACC_ODD_TAIL_0("%[B]") +#define PTO_FIXP_ACC_L_SRC_1 "B.IOT %[C], %[A], mask=1111\n" PTO_FIXP_ACC_ODD_TAIL_1("%[B]") +#define PTO_FIXP_ACC_L_SRC_2 "B.IOT %[C], %[A], mask=1111\n" PTO_FIXP_ACC_ODD_TAIL_2("%[B]") +#define PTO_FIXP_ACC_L_SRC_3 "B.IOT %[C], %[A], mask=1111\n" PTO_FIXP_ACC_ODD_TAIL_3("%[B]") +#define PTO_FIXP_ACC_L_SRC_4 "B.IOT %[C], %[A], mask=1111\n" PTO_FIXP_ACC_ODD_TAIL_4("%[B]") +#define PTO_FIXP_ACC_L_SRC_5 "B.IOT %[C], %[A], mask=1111\n" PTO_FIXP_ACC_ODD_TAIL_5("%[B]") +#define PTO_FIXP_ACC_L_SRC_6 "B.IOT %[C], %[A], mask=1111\n" PTO_FIXP_ACC_ODD_TAIL_6("%[B]") +#define PTO_FIXP_ACC_L_SRC_7 "B.IOT %[C], %[A], mask=1111\n" PTO_FIXP_ACC_ODD_TAIL_7("%[B]") #undef PTO_FIXP_ACC_SB_SRC_0 #undef PTO_FIXP_ACC_SB_SRC_1 #undef PTO_FIXP_ACC_SB_SRC_2 @@ -5938,14 +5938,14 @@ PTO_SHARED_INLINE void matmul_acc(Dst &dst, C &c, A &a, B &b, size_t M, #undef PTO_FIXP_ACC_SB_SRC_5 #undef PTO_FIXP_ACC_SB_SRC_6 #undef PTO_FIXP_ACC_SB_SRC_7 -#define PTO_FIXP_ACC_SB_SRC_0 "B.IOS %S[SharedB].reuse, mask=1111\n" "B.IOT %[C].reuse, %[A].reuse, mask=1111\n" PTO_FIXP_ACC_EVEN_TAIL_0 -#define PTO_FIXP_ACC_SB_SRC_1 "B.IOS %S[SharedB].reuse, mask=1111\n" "B.IOT %[C].reuse, %[A].reuse, mask=1111\n" PTO_FIXP_ACC_EVEN_TAIL_1 -#define PTO_FIXP_ACC_SB_SRC_2 "B.IOS %S[SharedB].reuse, mask=1111\n" "B.IOT %[C].reuse, %[A].reuse, mask=1111\n" PTO_FIXP_ACC_EVEN_TAIL_2 -#define PTO_FIXP_ACC_SB_SRC_3 "B.IOS %S[SharedB].reuse, mask=1111\n" "B.IOT %[C].reuse, %[A].reuse, mask=1111\n" PTO_FIXP_ACC_EVEN_TAIL_3 -#define PTO_FIXP_ACC_SB_SRC_4 "B.IOS %S[SharedB].reuse, mask=1111\n" "B.IOT %[C].reuse, %[A].reuse, mask=1111\n" PTO_FIXP_ACC_EVEN_TAIL_4 -#define PTO_FIXP_ACC_SB_SRC_5 "B.IOS %S[SharedB].reuse, mask=1111\n" "B.IOT %[C].reuse, %[A].reuse, mask=1111\n" PTO_FIXP_ACC_EVEN_TAIL_5 -#define PTO_FIXP_ACC_SB_SRC_6 "B.IOS %S[SharedB].reuse, mask=1111\n" "B.IOT %[C].reuse, %[A].reuse, mask=1111\n" PTO_FIXP_ACC_EVEN_TAIL_6 -#define PTO_FIXP_ACC_SB_SRC_7 "B.IOS %S[SharedB].reuse, mask=1111\n" "B.IOT %[C].reuse, %[A].reuse, mask=1111\n" PTO_FIXP_ACC_EVEN_TAIL_7 +#define PTO_FIXP_ACC_SB_SRC_0 "B.IOS %S[SharedB], mask=1111\n" "B.IOT %[C], %[A], mask=1111\n" PTO_FIXP_ACC_EVEN_TAIL_0 +#define PTO_FIXP_ACC_SB_SRC_1 "B.IOS %S[SharedB], mask=1111\n" "B.IOT %[C], %[A], mask=1111\n" PTO_FIXP_ACC_EVEN_TAIL_1 +#define PTO_FIXP_ACC_SB_SRC_2 "B.IOS %S[SharedB], mask=1111\n" "B.IOT %[C], %[A], mask=1111\n" PTO_FIXP_ACC_EVEN_TAIL_2 +#define PTO_FIXP_ACC_SB_SRC_3 "B.IOS %S[SharedB], mask=1111\n" "B.IOT %[C], %[A], mask=1111\n" PTO_FIXP_ACC_EVEN_TAIL_3 +#define PTO_FIXP_ACC_SB_SRC_4 "B.IOS %S[SharedB], mask=1111\n" "B.IOT %[C], %[A], mask=1111\n" PTO_FIXP_ACC_EVEN_TAIL_4 +#define PTO_FIXP_ACC_SB_SRC_5 "B.IOS %S[SharedB], mask=1111\n" "B.IOT %[C], %[A], mask=1111\n" PTO_FIXP_ACC_EVEN_TAIL_5 +#define PTO_FIXP_ACC_SB_SRC_6 "B.IOS %S[SharedB], mask=1111\n" "B.IOT %[C], %[A], mask=1111\n" PTO_FIXP_ACC_EVEN_TAIL_6 +#define PTO_FIXP_ACC_SB_SRC_7 "B.IOS %S[SharedB], mask=1111\n" "B.IOT %[C], %[A], mask=1111\n" PTO_FIXP_ACC_EVEN_TAIL_7 #undef PTO_FIXP_ACC_SA_SRC_0 #undef PTO_FIXP_ACC_SA_SRC_1 #undef PTO_FIXP_ACC_SA_SRC_2 @@ -5954,14 +5954,14 @@ PTO_SHARED_INLINE void matmul_acc(Dst &dst, C &c, A &a, B &b, size_t M, #undef PTO_FIXP_ACC_SA_SRC_5 #undef PTO_FIXP_ACC_SA_SRC_6 #undef PTO_FIXP_ACC_SA_SRC_7 -#define PTO_FIXP_ACC_SA_SRC_0 "B.IOS %S[SharedA].reuse, mask=1111\n" "B.IOT %[C].reuse, %[B].reuse, mask=1111\n" PTO_FIXP_ACC_EVEN_TAIL_0 -#define PTO_FIXP_ACC_SA_SRC_1 "B.IOS %S[SharedA].reuse, mask=1111\n" "B.IOT %[C].reuse, %[B].reuse, mask=1111\n" PTO_FIXP_ACC_EVEN_TAIL_1 -#define PTO_FIXP_ACC_SA_SRC_2 "B.IOS %S[SharedA].reuse, mask=1111\n" "B.IOT %[C].reuse, %[B].reuse, mask=1111\n" PTO_FIXP_ACC_EVEN_TAIL_2 -#define PTO_FIXP_ACC_SA_SRC_3 "B.IOS %S[SharedA].reuse, mask=1111\n" "B.IOT %[C].reuse, %[B].reuse, mask=1111\n" PTO_FIXP_ACC_EVEN_TAIL_3 -#define PTO_FIXP_ACC_SA_SRC_4 "B.IOS %S[SharedA].reuse, mask=1111\n" "B.IOT %[C].reuse, %[B].reuse, mask=1111\n" PTO_FIXP_ACC_EVEN_TAIL_4 -#define PTO_FIXP_ACC_SA_SRC_5 "B.IOS %S[SharedA].reuse, mask=1111\n" "B.IOT %[C].reuse, %[B].reuse, mask=1111\n" PTO_FIXP_ACC_EVEN_TAIL_5 -#define PTO_FIXP_ACC_SA_SRC_6 "B.IOS %S[SharedA].reuse, mask=1111\n" "B.IOT %[C].reuse, %[B].reuse, mask=1111\n" PTO_FIXP_ACC_EVEN_TAIL_6 -#define PTO_FIXP_ACC_SA_SRC_7 "B.IOS %S[SharedA].reuse, mask=1111\n" "B.IOT %[C].reuse, %[B].reuse, mask=1111\n" PTO_FIXP_ACC_EVEN_TAIL_7 +#define PTO_FIXP_ACC_SA_SRC_0 "B.IOS %S[SharedA], mask=1111\n" "B.IOT %[C], %[B], mask=1111\n" PTO_FIXP_ACC_EVEN_TAIL_0 +#define PTO_FIXP_ACC_SA_SRC_1 "B.IOS %S[SharedA], mask=1111\n" "B.IOT %[C], %[B], mask=1111\n" PTO_FIXP_ACC_EVEN_TAIL_1 +#define PTO_FIXP_ACC_SA_SRC_2 "B.IOS %S[SharedA], mask=1111\n" "B.IOT %[C], %[B], mask=1111\n" PTO_FIXP_ACC_EVEN_TAIL_2 +#define PTO_FIXP_ACC_SA_SRC_3 "B.IOS %S[SharedA], mask=1111\n" "B.IOT %[C], %[B], mask=1111\n" PTO_FIXP_ACC_EVEN_TAIL_3 +#define PTO_FIXP_ACC_SA_SRC_4 "B.IOS %S[SharedA], mask=1111\n" "B.IOT %[C], %[B], mask=1111\n" PTO_FIXP_ACC_EVEN_TAIL_4 +#define PTO_FIXP_ACC_SA_SRC_5 "B.IOS %S[SharedA], mask=1111\n" "B.IOT %[C], %[B], mask=1111\n" PTO_FIXP_ACC_EVEN_TAIL_5 +#define PTO_FIXP_ACC_SA_SRC_6 "B.IOS %S[SharedA], mask=1111\n" "B.IOT %[C], %[B], mask=1111\n" PTO_FIXP_ACC_EVEN_TAIL_6 +#define PTO_FIXP_ACC_SA_SRC_7 "B.IOS %S[SharedA], mask=1111\n" "B.IOT %[C], %[B], mask=1111\n" PTO_FIXP_ACC_EVEN_TAIL_7 #undef PTO_FIXP_ACC_SAB_SRC_0 #undef PTO_FIXP_ACC_SAB_SRC_1 #undef PTO_FIXP_ACC_SAB_SRC_2 @@ -5970,551 +5970,551 @@ PTO_SHARED_INLINE void matmul_acc(Dst &dst, C &c, A &a, B &b, size_t M, #undef PTO_FIXP_ACC_SAB_SRC_5 #undef PTO_FIXP_ACC_SAB_SRC_6 #undef PTO_FIXP_ACC_SAB_SRC_7 -#define PTO_FIXP_ACC_SAB_SRC_0 "B.IOS %S[SharedA].reuse, mask=1111\n" "B.IOS %S[SharedB].reuse, mask=1111\n" PTO_FIXP_ACC_ODD_TAIL_0("%[C]") -#define PTO_FIXP_ACC_SAB_SRC_1 "B.IOS %S[SharedA].reuse, mask=1111\n" "B.IOS %S[SharedB].reuse, mask=1111\n" PTO_FIXP_ACC_ODD_TAIL_1("%[C]") -#define PTO_FIXP_ACC_SAB_SRC_2 "B.IOS %S[SharedA].reuse, mask=1111\n" "B.IOS %S[SharedB].reuse, mask=1111\n" PTO_FIXP_ACC_ODD_TAIL_2("%[C]") -#define PTO_FIXP_ACC_SAB_SRC_3 "B.IOS %S[SharedA].reuse, mask=1111\n" "B.IOS %S[SharedB].reuse, mask=1111\n" PTO_FIXP_ACC_ODD_TAIL_3("%[C]") -#define PTO_FIXP_ACC_SAB_SRC_4 "B.IOS %S[SharedA].reuse, mask=1111\n" "B.IOS %S[SharedB].reuse, mask=1111\n" PTO_FIXP_ACC_ODD_TAIL_4("%[C]") -#define PTO_FIXP_ACC_SAB_SRC_5 "B.IOS %S[SharedA].reuse, mask=1111\n" "B.IOS %S[SharedB].reuse, mask=1111\n" PTO_FIXP_ACC_ODD_TAIL_5("%[C]") -#define PTO_FIXP_ACC_SAB_SRC_6 "B.IOS %S[SharedA].reuse, mask=1111\n" "B.IOS %S[SharedB].reuse, mask=1111\n" PTO_FIXP_ACC_ODD_TAIL_6("%[C]") -#define PTO_FIXP_ACC_SAB_SRC_7 "B.IOS %S[SharedA].reuse, mask=1111\n" "B.IOS %S[SharedB].reuse, mask=1111\n" PTO_FIXP_ACC_ODD_TAIL_7("%[C]") +#define PTO_FIXP_ACC_SAB_SRC_0 "B.IOS %S[SharedA], mask=1111\n" "B.IOS %S[SharedB], mask=1111\n" PTO_FIXP_ACC_ODD_TAIL_0("%[C]") +#define PTO_FIXP_ACC_SAB_SRC_1 "B.IOS %S[SharedA], mask=1111\n" "B.IOS %S[SharedB], mask=1111\n" PTO_FIXP_ACC_ODD_TAIL_1("%[C]") +#define PTO_FIXP_ACC_SAB_SRC_2 "B.IOS %S[SharedA], mask=1111\n" "B.IOS %S[SharedB], mask=1111\n" PTO_FIXP_ACC_ODD_TAIL_2("%[C]") +#define PTO_FIXP_ACC_SAB_SRC_3 "B.IOS %S[SharedA], mask=1111\n" "B.IOS %S[SharedB], mask=1111\n" PTO_FIXP_ACC_ODD_TAIL_3("%[C]") +#define PTO_FIXP_ACC_SAB_SRC_4 "B.IOS %S[SharedA], mask=1111\n" "B.IOS %S[SharedB], mask=1111\n" PTO_FIXP_ACC_ODD_TAIL_4("%[C]") +#define PTO_FIXP_ACC_SAB_SRC_5 "B.IOS %S[SharedA], mask=1111\n" "B.IOS %S[SharedB], mask=1111\n" PTO_FIXP_ACC_ODD_TAIL_5("%[C]") +#define PTO_FIXP_ACC_SAB_SRC_6 "B.IOS %S[SharedA], mask=1111\n" "B.IOS %S[SharedB], mask=1111\n" PTO_FIXP_ACC_ODD_TAIL_6("%[C]") +#define PTO_FIXP_ACC_SAB_SRC_7 "B.IOS %S[SharedA], mask=1111\n" "B.IOS %S[SharedB], mask=1111\n" PTO_FIXP_ACC_ODD_TAIL_7("%[C]") #define PTO_FIXP_BIAS_L_SRC_0 \ - "B.IOT %[A].reuse, %[B].reuse, mask=1111\n" "B.IOT %[Bias].reuse, mask=1111\n" \ + "B.IOT %[A], %[B], mask=1111\n" "B.IOT %[Bias], mask=1111\n" \ PTO_FIXP_PPSRC_0 #define PTO_FIXP_BIAS_L_SRC_1 \ - "B.IOT %[A].reuse, %[B].reuse, mask=1111\n" "B.IOT %[Bias].reuse, mask=1111\n" \ + "B.IOT %[A], %[B], mask=1111\n" "B.IOT %[Bias], mask=1111\n" \ PTO_FIXP_PPSRC_1 #define PTO_FIXP_BIAS_L_SRC_2 \ - "B.IOT %[A].reuse, %[B].reuse, mask=1111\n" "B.IOT %[Bias].reuse, mask=1111\n" \ + "B.IOT %[A], %[B], mask=1111\n" "B.IOT %[Bias], mask=1111\n" \ PTO_FIXP_PPSRC_2 #define PTO_FIXP_BIAS_L_SRC_3 \ - "B.IOT %[A].reuse, %[B].reuse, mask=1111\n" "B.IOT %[Bias].reuse, mask=1111\n" \ + "B.IOT %[A], %[B], mask=1111\n" "B.IOT %[Bias], mask=1111\n" \ PTO_FIXP_PPSRC_3 #define PTO_FIXP_BIAS_L_SRC_4 \ - "B.IOT %[A].reuse, %[B].reuse, mask=1111\n" "B.IOT %[Bias].reuse, mask=1111\n" \ + "B.IOT %[A], %[B], mask=1111\n" "B.IOT %[Bias], mask=1111\n" \ PTO_FIXP_PPSRC_4 #define PTO_FIXP_BIAS_L_SRC_5 \ - "B.IOT %[A].reuse, %[B].reuse, mask=1111\n" "B.IOT %[Bias].reuse, mask=1111\n" \ + "B.IOT %[A], %[B], mask=1111\n" "B.IOT %[Bias], mask=1111\n" \ PTO_FIXP_PPSRC_5 #define PTO_FIXP_BIAS_L_SRC_6 \ - "B.IOT %[A].reuse, %[B].reuse, mask=1111\n" "B.IOT %[Bias].reuse, mask=1111\n" \ + "B.IOT %[A], %[B], mask=1111\n" "B.IOT %[Bias], mask=1111\n" \ PTO_FIXP_PPSRC_6 #define PTO_FIXP_BIAS_L_SRC_7 \ - "B.IOT %[A].reuse, %[B].reuse, mask=1111\n" "B.IOT %[Bias].reuse, mask=1111\n" \ + "B.IOT %[A], %[B], mask=1111\n" "B.IOT %[Bias], mask=1111\n" \ PTO_FIXP_PPSRC_7 #define PTO_FIXP_BIAS_SB_SRC_0 \ - "B.IOS %S[SharedB].reuse, mask=1111\n" "B.IOT %[A].reuse, %[Bias].reuse, mask=1111\n" \ + "B.IOS %S[SharedB], mask=1111\n" "B.IOT %[A], %[Bias], mask=1111\n" \ PTO_FIXP_PPSRC_0 #define PTO_FIXP_BIAS_SB_SRC_1 \ - "B.IOS %S[SharedB].reuse, mask=1111\n" "B.IOT %[A].reuse, %[Bias].reuse, mask=1111\n" \ + "B.IOS %S[SharedB], mask=1111\n" "B.IOT %[A], %[Bias], mask=1111\n" \ PTO_FIXP_PPSRC_1 #define PTO_FIXP_BIAS_SB_SRC_2 \ - "B.IOS %S[SharedB].reuse, mask=1111\n" "B.IOT %[A].reuse, %[Bias].reuse, mask=1111\n" \ + "B.IOS %S[SharedB], mask=1111\n" "B.IOT %[A], %[Bias], mask=1111\n" \ PTO_FIXP_PPSRC_2 #define PTO_FIXP_BIAS_SB_SRC_3 \ - "B.IOS %S[SharedB].reuse, mask=1111\n" "B.IOT %[A].reuse, %[Bias].reuse, mask=1111\n" \ + "B.IOS %S[SharedB], mask=1111\n" "B.IOT %[A], %[Bias], mask=1111\n" \ PTO_FIXP_PPSRC_3 #define PTO_FIXP_BIAS_SB_SRC_4 \ - "B.IOS %S[SharedB].reuse, mask=1111\n" "B.IOT %[A].reuse, %[Bias].reuse, mask=1111\n" \ + "B.IOS %S[SharedB], mask=1111\n" "B.IOT %[A], %[Bias], mask=1111\n" \ PTO_FIXP_PPSRC_4 #define PTO_FIXP_BIAS_SB_SRC_5 \ - "B.IOS %S[SharedB].reuse, mask=1111\n" "B.IOT %[A].reuse, %[Bias].reuse, mask=1111\n" \ + "B.IOS %S[SharedB], mask=1111\n" "B.IOT %[A], %[Bias], mask=1111\n" \ PTO_FIXP_PPSRC_5 #define PTO_FIXP_BIAS_SB_SRC_6 \ - "B.IOS %S[SharedB].reuse, mask=1111\n" "B.IOT %[A].reuse, %[Bias].reuse, mask=1111\n" \ + "B.IOS %S[SharedB], mask=1111\n" "B.IOT %[A], %[Bias], mask=1111\n" \ PTO_FIXP_PPSRC_6 #define PTO_FIXP_BIAS_SB_SRC_7 \ - "B.IOS %S[SharedB].reuse, mask=1111\n" "B.IOT %[A].reuse, %[Bias].reuse, mask=1111\n" \ + "B.IOS %S[SharedB], mask=1111\n" "B.IOT %[A], %[Bias], mask=1111\n" \ PTO_FIXP_PPSRC_7 #define PTO_FIXP_BIAS_SA_SRC_0 \ - "B.IOS %S[SharedA].reuse, mask=1111\n" "B.IOT %[B].reuse, %[Bias].reuse, mask=1111\n" \ + "B.IOS %S[SharedA], mask=1111\n" "B.IOT %[B], %[Bias], mask=1111\n" \ PTO_FIXP_PPSRC_0 #define PTO_FIXP_BIAS_SA_SRC_1 \ - "B.IOS %S[SharedA].reuse, mask=1111\n" "B.IOT %[B].reuse, %[Bias].reuse, mask=1111\n" \ + "B.IOS %S[SharedA], mask=1111\n" "B.IOT %[B], %[Bias], mask=1111\n" \ PTO_FIXP_PPSRC_1 #define PTO_FIXP_BIAS_SA_SRC_2 \ - "B.IOS %S[SharedA].reuse, mask=1111\n" "B.IOT %[B].reuse, %[Bias].reuse, mask=1111\n" \ + "B.IOS %S[SharedA], mask=1111\n" "B.IOT %[B], %[Bias], mask=1111\n" \ PTO_FIXP_PPSRC_2 #define PTO_FIXP_BIAS_SA_SRC_3 \ - "B.IOS %S[SharedA].reuse, mask=1111\n" "B.IOT %[B].reuse, %[Bias].reuse, mask=1111\n" \ + "B.IOS %S[SharedA], mask=1111\n" "B.IOT %[B], %[Bias], mask=1111\n" \ PTO_FIXP_PPSRC_3 #define PTO_FIXP_BIAS_SA_SRC_4 \ - "B.IOS %S[SharedA].reuse, mask=1111\n" "B.IOT %[B].reuse, %[Bias].reuse, mask=1111\n" \ + "B.IOS %S[SharedA], mask=1111\n" "B.IOT %[B], %[Bias], mask=1111\n" \ PTO_FIXP_PPSRC_4 #define PTO_FIXP_BIAS_SA_SRC_5 \ - "B.IOS %S[SharedA].reuse, mask=1111\n" "B.IOT %[B].reuse, %[Bias].reuse, mask=1111\n" \ + "B.IOS %S[SharedA], mask=1111\n" "B.IOT %[B], %[Bias], mask=1111\n" \ PTO_FIXP_PPSRC_5 #define PTO_FIXP_BIAS_SA_SRC_6 \ - "B.IOS %S[SharedA].reuse, mask=1111\n" "B.IOT %[B].reuse, %[Bias].reuse, mask=1111\n" \ + "B.IOS %S[SharedA], mask=1111\n" "B.IOT %[B], %[Bias], mask=1111\n" \ PTO_FIXP_PPSRC_6 #define PTO_FIXP_BIAS_SA_SRC_7 \ - "B.IOS %S[SharedA].reuse, mask=1111\n" "B.IOT %[B].reuse, %[Bias].reuse, mask=1111\n" \ + "B.IOS %S[SharedA], mask=1111\n" "B.IOT %[B], %[Bias], mask=1111\n" \ PTO_FIXP_PPSRC_7 #define PTO_FIXP_BIAS_SAB_SRC_0 \ - "B.IOS %S[SharedA].reuse, mask=1111\n" "B.IOS %S[SharedB].reuse, mask=1111\n" "B.IOT %[Bias].reuse, mask=1111\n" \ + "B.IOS %S[SharedA], mask=1111\n" "B.IOS %S[SharedB], mask=1111\n" "B.IOT %[Bias], mask=1111\n" \ PTO_FIXP_PPSRC_0 #define PTO_FIXP_BIAS_SAB_SRC_1 \ - "B.IOS %S[SharedA].reuse, mask=1111\n" "B.IOS %S[SharedB].reuse, mask=1111\n" "B.IOT %[Bias].reuse, mask=1111\n" \ + "B.IOS %S[SharedA], mask=1111\n" "B.IOS %S[SharedB], mask=1111\n" "B.IOT %[Bias], mask=1111\n" \ PTO_FIXP_PPSRC_1 #define PTO_FIXP_BIAS_SAB_SRC_2 \ - "B.IOS %S[SharedA].reuse, mask=1111\n" "B.IOS %S[SharedB].reuse, mask=1111\n" "B.IOT %[Bias].reuse, mask=1111\n" \ + "B.IOS %S[SharedA], mask=1111\n" "B.IOS %S[SharedB], mask=1111\n" "B.IOT %[Bias], mask=1111\n" \ PTO_FIXP_PPSRC_2 #define PTO_FIXP_BIAS_SAB_SRC_3 \ - "B.IOS %S[SharedA].reuse, mask=1111\n" "B.IOS %S[SharedB].reuse, mask=1111\n" "B.IOT %[Bias].reuse, mask=1111\n" \ + "B.IOS %S[SharedA], mask=1111\n" "B.IOS %S[SharedB], mask=1111\n" "B.IOT %[Bias], mask=1111\n" \ PTO_FIXP_PPSRC_3 #define PTO_FIXP_BIAS_SAB_SRC_4 \ - "B.IOS %S[SharedA].reuse, mask=1111\n" "B.IOS %S[SharedB].reuse, mask=1111\n" "B.IOT %[Bias].reuse, mask=1111\n" \ + "B.IOS %S[SharedA], mask=1111\n" "B.IOS %S[SharedB], mask=1111\n" "B.IOT %[Bias], mask=1111\n" \ PTO_FIXP_PPSRC_4 #define PTO_FIXP_BIAS_SAB_SRC_5 \ - "B.IOS %S[SharedA].reuse, mask=1111\n" "B.IOS %S[SharedB].reuse, mask=1111\n" "B.IOT %[Bias].reuse, mask=1111\n" \ + "B.IOS %S[SharedA], mask=1111\n" "B.IOS %S[SharedB], mask=1111\n" "B.IOT %[Bias], mask=1111\n" \ PTO_FIXP_PPSRC_5 #define PTO_FIXP_BIAS_SAB_SRC_6 \ - "B.IOS %S[SharedA].reuse, mask=1111\n" "B.IOS %S[SharedB].reuse, mask=1111\n" "B.IOT %[Bias].reuse, mask=1111\n" \ + "B.IOS %S[SharedA], mask=1111\n" "B.IOS %S[SharedB], mask=1111\n" "B.IOT %[Bias], mask=1111\n" \ PTO_FIXP_PPSRC_6 #define PTO_FIXP_BIAS_SAB_SRC_7 \ - "B.IOS %S[SharedA].reuse, mask=1111\n" "B.IOS %S[SharedB].reuse, mask=1111\n" "B.IOT %[Bias].reuse, mask=1111\n" \ + "B.IOS %S[SharedA], mask=1111\n" "B.IOS %S[SharedB], mask=1111\n" "B.IOT %[Bias], mask=1111\n" \ PTO_FIXP_PPSRC_7 #define PTO_FIXP_MX_L_SRC_0 \ - "B.IOT %[A].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleA].reuse, mask=1111\n" ".endif\n" \ - "B.IOT %[B].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleB].reuse, mask=1111\n" ".endif\n" \ + "B.IOT %[A], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleA], mask=1111\n" ".endif\n" \ + "B.IOT %[B], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleB], mask=1111\n" ".endif\n" \ PTO_FIXP_PPSRC_0 #define PTO_FIXP_MX_L_SRC_1 \ - "B.IOT %[A].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleA].reuse, mask=1111\n" ".endif\n" \ - "B.IOT %[B].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleB].reuse, mask=1111\n" ".endif\n" \ + "B.IOT %[A], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleA], mask=1111\n" ".endif\n" \ + "B.IOT %[B], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleB], mask=1111\n" ".endif\n" \ PTO_FIXP_PPSRC_1 #define PTO_FIXP_MX_L_SRC_2 \ - "B.IOT %[A].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleA].reuse, mask=1111\n" ".endif\n" \ - "B.IOT %[B].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleB].reuse, mask=1111\n" ".endif\n" \ + "B.IOT %[A], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleA], mask=1111\n" ".endif\n" \ + "B.IOT %[B], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleB], mask=1111\n" ".endif\n" \ PTO_FIXP_PPSRC_2 #define PTO_FIXP_MX_L_SRC_3 \ - "B.IOT %[A].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleA].reuse, mask=1111\n" ".endif\n" \ - "B.IOT %[B].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleB].reuse, mask=1111\n" ".endif\n" \ + "B.IOT %[A], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleA], mask=1111\n" ".endif\n" \ + "B.IOT %[B], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleB], mask=1111\n" ".endif\n" \ PTO_FIXP_PPSRC_3 #define PTO_FIXP_MX_L_SRC_4 \ - "B.IOT %[A].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleA].reuse, mask=1111\n" ".endif\n" \ - "B.IOT %[B].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleB].reuse, mask=1111\n" ".endif\n" \ + "B.IOT %[A], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleA], mask=1111\n" ".endif\n" \ + "B.IOT %[B], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleB], mask=1111\n" ".endif\n" \ PTO_FIXP_PPSRC_4 #define PTO_FIXP_MX_L_SRC_5 \ - "B.IOT %[A].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleA].reuse, mask=1111\n" ".endif\n" \ - "B.IOT %[B].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleB].reuse, mask=1111\n" ".endif\n" \ + "B.IOT %[A], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleA], mask=1111\n" ".endif\n" \ + "B.IOT %[B], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleB], mask=1111\n" ".endif\n" \ PTO_FIXP_PPSRC_5 #define PTO_FIXP_MX_L_SRC_6 \ - "B.IOT %[A].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleA].reuse, mask=1111\n" ".endif\n" \ - "B.IOT %[B].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleB].reuse, mask=1111\n" ".endif\n" \ + "B.IOT %[A], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleA], mask=1111\n" ".endif\n" \ + "B.IOT %[B], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleB], mask=1111\n" ".endif\n" \ PTO_FIXP_PPSRC_6 #define PTO_FIXP_MX_L_SRC_7 \ - "B.IOT %[A].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleA].reuse, mask=1111\n" ".endif\n" \ - "B.IOT %[B].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleB].reuse, mask=1111\n" ".endif\n" \ + "B.IOT %[A], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleA], mask=1111\n" ".endif\n" \ + "B.IOT %[B], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleB], mask=1111\n" ".endif\n" \ PTO_FIXP_PPSRC_7 #define PTO_FIXP_MX_SB_SRC_0 \ - "B.IOS %S[SharedB].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOS %S[ScaleB].reuse, mask=1111\n" ".endif\n" "B.IOT %[A].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleA].reuse, mask=1111\n" ".endif\n" \ + "B.IOS %S[SharedB], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOS %S[ScaleB], mask=1111\n" ".endif\n" "B.IOT %[A], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleA], mask=1111\n" ".endif\n" \ PTO_FIXP_PPSRC_0 #define PTO_FIXP_MX_SB_SRC_1 \ - "B.IOS %S[SharedB].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOS %S[ScaleB].reuse, mask=1111\n" ".endif\n" "B.IOT %[A].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleA].reuse, mask=1111\n" ".endif\n" \ + "B.IOS %S[SharedB], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOS %S[ScaleB], mask=1111\n" ".endif\n" "B.IOT %[A], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleA], mask=1111\n" ".endif\n" \ PTO_FIXP_PPSRC_1 #define PTO_FIXP_MX_SB_SRC_2 \ - "B.IOS %S[SharedB].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOS %S[ScaleB].reuse, mask=1111\n" ".endif\n" "B.IOT %[A].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleA].reuse, mask=1111\n" ".endif\n" \ + "B.IOS %S[SharedB], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOS %S[ScaleB], mask=1111\n" ".endif\n" "B.IOT %[A], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleA], mask=1111\n" ".endif\n" \ PTO_FIXP_PPSRC_2 #define PTO_FIXP_MX_SB_SRC_3 \ - "B.IOS %S[SharedB].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOS %S[ScaleB].reuse, mask=1111\n" ".endif\n" "B.IOT %[A].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleA].reuse, mask=1111\n" ".endif\n" \ + "B.IOS %S[SharedB], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOS %S[ScaleB], mask=1111\n" ".endif\n" "B.IOT %[A], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleA], mask=1111\n" ".endif\n" \ PTO_FIXP_PPSRC_3 #define PTO_FIXP_MX_SB_SRC_4 \ - "B.IOS %S[SharedB].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOS %S[ScaleB].reuse, mask=1111\n" ".endif\n" "B.IOT %[A].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleA].reuse, mask=1111\n" ".endif\n" \ + "B.IOS %S[SharedB], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOS %S[ScaleB], mask=1111\n" ".endif\n" "B.IOT %[A], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleA], mask=1111\n" ".endif\n" \ PTO_FIXP_PPSRC_4 #define PTO_FIXP_MX_SB_SRC_5 \ - "B.IOS %S[SharedB].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOS %S[ScaleB].reuse, mask=1111\n" ".endif\n" "B.IOT %[A].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleA].reuse, mask=1111\n" ".endif\n" \ + "B.IOS %S[SharedB], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOS %S[ScaleB], mask=1111\n" ".endif\n" "B.IOT %[A], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleA], mask=1111\n" ".endif\n" \ PTO_FIXP_PPSRC_5 #define PTO_FIXP_MX_SB_SRC_6 \ - "B.IOS %S[SharedB].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOS %S[ScaleB].reuse, mask=1111\n" ".endif\n" "B.IOT %[A].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleA].reuse, mask=1111\n" ".endif\n" \ + "B.IOS %S[SharedB], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOS %S[ScaleB], mask=1111\n" ".endif\n" "B.IOT %[A], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleA], mask=1111\n" ".endif\n" \ PTO_FIXP_PPSRC_6 #define PTO_FIXP_MX_SB_SRC_7 \ - "B.IOS %S[SharedB].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOS %S[ScaleB].reuse, mask=1111\n" ".endif\n" "B.IOT %[A].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleA].reuse, mask=1111\n" ".endif\n" \ + "B.IOS %S[SharedB], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOS %S[ScaleB], mask=1111\n" ".endif\n" "B.IOT %[A], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleA], mask=1111\n" ".endif\n" \ PTO_FIXP_PPSRC_7 #define PTO_FIXP_MX_SA_SRC_0 \ - "B.IOS %S[SharedA].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOS %S[ScaleA].reuse, mask=1111\n" ".endif\n" "B.IOT %[B].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleB].reuse, mask=1111\n" ".endif\n" \ + "B.IOS %S[SharedA], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOS %S[ScaleA], mask=1111\n" ".endif\n" "B.IOT %[B], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleB], mask=1111\n" ".endif\n" \ PTO_FIXP_PPSRC_0 #define PTO_FIXP_MX_SA_SRC_1 \ - "B.IOS %S[SharedA].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOS %S[ScaleA].reuse, mask=1111\n" ".endif\n" "B.IOT %[B].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleB].reuse, mask=1111\n" ".endif\n" \ + "B.IOS %S[SharedA], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOS %S[ScaleA], mask=1111\n" ".endif\n" "B.IOT %[B], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleB], mask=1111\n" ".endif\n" \ PTO_FIXP_PPSRC_1 #define PTO_FIXP_MX_SA_SRC_2 \ - "B.IOS %S[SharedA].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOS %S[ScaleA].reuse, mask=1111\n" ".endif\n" "B.IOT %[B].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleB].reuse, mask=1111\n" ".endif\n" \ + "B.IOS %S[SharedA], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOS %S[ScaleA], mask=1111\n" ".endif\n" "B.IOT %[B], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleB], mask=1111\n" ".endif\n" \ PTO_FIXP_PPSRC_2 #define PTO_FIXP_MX_SA_SRC_3 \ - "B.IOS %S[SharedA].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOS %S[ScaleA].reuse, mask=1111\n" ".endif\n" "B.IOT %[B].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleB].reuse, mask=1111\n" ".endif\n" \ + "B.IOS %S[SharedA], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOS %S[ScaleA], mask=1111\n" ".endif\n" "B.IOT %[B], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleB], mask=1111\n" ".endif\n" \ PTO_FIXP_PPSRC_3 #define PTO_FIXP_MX_SA_SRC_4 \ - "B.IOS %S[SharedA].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOS %S[ScaleA].reuse, mask=1111\n" ".endif\n" "B.IOT %[B].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleB].reuse, mask=1111\n" ".endif\n" \ + "B.IOS %S[SharedA], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOS %S[ScaleA], mask=1111\n" ".endif\n" "B.IOT %[B], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleB], mask=1111\n" ".endif\n" \ PTO_FIXP_PPSRC_4 #define PTO_FIXP_MX_SA_SRC_5 \ - "B.IOS %S[SharedA].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOS %S[ScaleA].reuse, mask=1111\n" ".endif\n" "B.IOT %[B].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleB].reuse, mask=1111\n" ".endif\n" \ + "B.IOS %S[SharedA], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOS %S[ScaleA], mask=1111\n" ".endif\n" "B.IOT %[B], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleB], mask=1111\n" ".endif\n" \ PTO_FIXP_PPSRC_5 #define PTO_FIXP_MX_SA_SRC_6 \ - "B.IOS %S[SharedA].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOS %S[ScaleA].reuse, mask=1111\n" ".endif\n" "B.IOT %[B].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleB].reuse, mask=1111\n" ".endif\n" \ + "B.IOS %S[SharedA], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOS %S[ScaleA], mask=1111\n" ".endif\n" "B.IOT %[B], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleB], mask=1111\n" ".endif\n" \ PTO_FIXP_PPSRC_6 #define PTO_FIXP_MX_SA_SRC_7 \ - "B.IOS %S[SharedA].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOS %S[ScaleA].reuse, mask=1111\n" ".endif\n" "B.IOT %[B].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleB].reuse, mask=1111\n" ".endif\n" \ + "B.IOS %S[SharedA], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOS %S[ScaleA], mask=1111\n" ".endif\n" "B.IOT %[B], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleB], mask=1111\n" ".endif\n" \ PTO_FIXP_PPSRC_7 #define PTO_FIXP_MX_SAB_SRC_0 \ - "B.IOS %S[SharedA].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOS %S[ScaleA].reuse, mask=1111\n" ".endif\n" "B.IOS %S[SharedB].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOS %S[ScaleB].reuse, mask=1111\n" ".endif\n" \ + "B.IOS %S[SharedA], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOS %S[ScaleA], mask=1111\n" ".endif\n" "B.IOS %S[SharedB], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOS %S[ScaleB], mask=1111\n" ".endif\n" \ PTO_FIXP_PPSRC_0 #define PTO_FIXP_MX_SAB_SRC_1 \ - "B.IOS %S[SharedA].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOS %S[ScaleA].reuse, mask=1111\n" ".endif\n" "B.IOS %S[SharedB].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOS %S[ScaleB].reuse, mask=1111\n" ".endif\n" \ + "B.IOS %S[SharedA], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOS %S[ScaleA], mask=1111\n" ".endif\n" "B.IOS %S[SharedB], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOS %S[ScaleB], mask=1111\n" ".endif\n" \ PTO_FIXP_PPSRC_1 #define PTO_FIXP_MX_SAB_SRC_2 \ - "B.IOS %S[SharedA].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOS %S[ScaleA].reuse, mask=1111\n" ".endif\n" "B.IOS %S[SharedB].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOS %S[ScaleB].reuse, mask=1111\n" ".endif\n" \ + "B.IOS %S[SharedA], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOS %S[ScaleA], mask=1111\n" ".endif\n" "B.IOS %S[SharedB], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOS %S[ScaleB], mask=1111\n" ".endif\n" \ PTO_FIXP_PPSRC_2 #define PTO_FIXP_MX_SAB_SRC_3 \ - "B.IOS %S[SharedA].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOS %S[ScaleA].reuse, mask=1111\n" ".endif\n" "B.IOS %S[SharedB].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOS %S[ScaleB].reuse, mask=1111\n" ".endif\n" \ + "B.IOS %S[SharedA], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOS %S[ScaleA], mask=1111\n" ".endif\n" "B.IOS %S[SharedB], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOS %S[ScaleB], mask=1111\n" ".endif\n" \ PTO_FIXP_PPSRC_3 #define PTO_FIXP_MX_SAB_SRC_4 \ - "B.IOS %S[SharedA].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOS %S[ScaleA].reuse, mask=1111\n" ".endif\n" "B.IOS %S[SharedB].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOS %S[ScaleB].reuse, mask=1111\n" ".endif\n" \ + "B.IOS %S[SharedA], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOS %S[ScaleA], mask=1111\n" ".endif\n" "B.IOS %S[SharedB], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOS %S[ScaleB], mask=1111\n" ".endif\n" \ PTO_FIXP_PPSRC_4 #define PTO_FIXP_MX_SAB_SRC_5 \ - "B.IOS %S[SharedA].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOS %S[ScaleA].reuse, mask=1111\n" ".endif\n" "B.IOS %S[SharedB].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOS %S[ScaleB].reuse, mask=1111\n" ".endif\n" \ + "B.IOS %S[SharedA], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOS %S[ScaleA], mask=1111\n" ".endif\n" "B.IOS %S[SharedB], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOS %S[ScaleB], mask=1111\n" ".endif\n" \ PTO_FIXP_PPSRC_5 #define PTO_FIXP_MX_SAB_SRC_6 \ - "B.IOS %S[SharedA].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOS %S[ScaleA].reuse, mask=1111\n" ".endif\n" "B.IOS %S[SharedB].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOS %S[ScaleB].reuse, mask=1111\n" ".endif\n" \ + "B.IOS %S[SharedA], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOS %S[ScaleA], mask=1111\n" ".endif\n" "B.IOS %S[SharedB], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOS %S[ScaleB], mask=1111\n" ".endif\n" \ PTO_FIXP_PPSRC_6 #define PTO_FIXP_MX_SAB_SRC_7 \ - "B.IOS %S[SharedA].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOS %S[ScaleA].reuse, mask=1111\n" ".endif\n" "B.IOS %S[SharedB].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOS %S[ScaleB].reuse, mask=1111\n" ".endif\n" \ + "B.IOS %S[SharedA], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOS %S[ScaleA], mask=1111\n" ".endif\n" "B.IOS %S[SharedB], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOS %S[ScaleB], mask=1111\n" ".endif\n" \ PTO_FIXP_PPSRC_7 // CScale-aware MX ACC source streams keep the CScale source after all matrix and MX scale sources. #define PTO_FIXP_MX_ACC_L_SRC_0 \ - "B.IOT %[A].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleA].reuse, mask=1111\n" ".endif\n" \ - "B.IOT %[B].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleB].reuse, mask=1111\n" ".endif\n" \ + "B.IOT %[A], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleA], mask=1111\n" ".endif\n" \ + "B.IOT %[B], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleB], mask=1111\n" ".endif\n" \ PTO_FIXP_ACC_PPSRC_0 #define PTO_FIXP_MX_ACC_L_SRC_1 \ - "B.IOT %[A].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleA].reuse, mask=1111\n" ".endif\n" \ - "B.IOT %[B].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleB].reuse, mask=1111\n" ".endif\n" \ + "B.IOT %[A], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleA], mask=1111\n" ".endif\n" \ + "B.IOT %[B], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleB], mask=1111\n" ".endif\n" \ PTO_FIXP_ACC_PPSRC_1 #define PTO_FIXP_MX_ACC_L_SRC_2 \ - "B.IOT %[A].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleA].reuse, mask=1111\n" ".endif\n" \ - "B.IOT %[B].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleB].reuse, mask=1111\n" ".endif\n" \ + "B.IOT %[A], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleA], mask=1111\n" ".endif\n" \ + "B.IOT %[B], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleB], mask=1111\n" ".endif\n" \ PTO_FIXP_ACC_PPSRC_2 #define PTO_FIXP_MX_ACC_L_SRC_3 \ - "B.IOT %[A].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleA].reuse, mask=1111\n" ".endif\n" \ - "B.IOT %[B].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleB].reuse, mask=1111\n" ".endif\n" \ + "B.IOT %[A], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleA], mask=1111\n" ".endif\n" \ + "B.IOT %[B], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleB], mask=1111\n" ".endif\n" \ PTO_FIXP_ACC_PPSRC_3 #define PTO_FIXP_MX_ACC_L_SRC_4 \ - "B.IOT %[A].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleA].reuse, mask=1111\n" ".endif\n" \ - "B.IOT %[B].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleB].reuse, mask=1111\n" ".endif\n" \ + "B.IOT %[A], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleA], mask=1111\n" ".endif\n" \ + "B.IOT %[B], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleB], mask=1111\n" ".endif\n" \ PTO_FIXP_ACC_PPSRC_4 #define PTO_FIXP_MX_ACC_L_SRC_5 \ - "B.IOT %[A].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleA].reuse, mask=1111\n" ".endif\n" \ - "B.IOT %[B].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleB].reuse, mask=1111\n" ".endif\n" \ + "B.IOT %[A], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleA], mask=1111\n" ".endif\n" \ + "B.IOT %[B], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleB], mask=1111\n" ".endif\n" \ PTO_FIXP_ACC_PPSRC_5 #define PTO_FIXP_MX_ACC_L_SRC_6 \ - "B.IOT %[A].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleA].reuse, mask=1111\n" ".endif\n" \ - "B.IOT %[B].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleB].reuse, mask=1111\n" ".endif\n" \ + "B.IOT %[A], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleA], mask=1111\n" ".endif\n" \ + "B.IOT %[B], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleB], mask=1111\n" ".endif\n" \ PTO_FIXP_ACC_PPSRC_6 #define PTO_FIXP_MX_ACC_L_SRC_7 \ - "B.IOT %[A].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleA].reuse, mask=1111\n" ".endif\n" \ - "B.IOT %[B].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleB].reuse, mask=1111\n" ".endif\n" \ + "B.IOT %[A], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleA], mask=1111\n" ".endif\n" \ + "B.IOT %[B], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleB], mask=1111\n" ".endif\n" \ PTO_FIXP_ACC_PPSRC_7 #define PTO_FIXP_MX_ACC_SB_SRC_0 \ - "B.IOS %S[SharedB].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOS %S[ScaleB].reuse, mask=1111\n" ".endif\n" "B.IOT %[A].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleA].reuse, mask=1111\n" ".endif\n" \ + "B.IOS %S[SharedB], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOS %S[ScaleB], mask=1111\n" ".endif\n" "B.IOT %[A], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleA], mask=1111\n" ".endif\n" \ PTO_FIXP_ACC_PPSRC_0 #define PTO_FIXP_MX_ACC_SB_SRC_1 \ - "B.IOS %S[SharedB].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOS %S[ScaleB].reuse, mask=1111\n" ".endif\n" "B.IOT %[A].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleA].reuse, mask=1111\n" ".endif\n" \ + "B.IOS %S[SharedB], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOS %S[ScaleB], mask=1111\n" ".endif\n" "B.IOT %[A], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleA], mask=1111\n" ".endif\n" \ PTO_FIXP_ACC_PPSRC_1 #define PTO_FIXP_MX_ACC_SB_SRC_2 \ - "B.IOS %S[SharedB].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOS %S[ScaleB].reuse, mask=1111\n" ".endif\n" "B.IOT %[A].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleA].reuse, mask=1111\n" ".endif\n" \ + "B.IOS %S[SharedB], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOS %S[ScaleB], mask=1111\n" ".endif\n" "B.IOT %[A], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleA], mask=1111\n" ".endif\n" \ PTO_FIXP_ACC_PPSRC_2 #define PTO_FIXP_MX_ACC_SB_SRC_3 \ - "B.IOS %S[SharedB].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOS %S[ScaleB].reuse, mask=1111\n" ".endif\n" "B.IOT %[A].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleA].reuse, mask=1111\n" ".endif\n" \ + "B.IOS %S[SharedB], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOS %S[ScaleB], mask=1111\n" ".endif\n" "B.IOT %[A], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleA], mask=1111\n" ".endif\n" \ PTO_FIXP_ACC_PPSRC_3 #define PTO_FIXP_MX_ACC_SB_SRC_4 \ - "B.IOS %S[SharedB].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOS %S[ScaleB].reuse, mask=1111\n" ".endif\n" "B.IOT %[A].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleA].reuse, mask=1111\n" ".endif\n" \ + "B.IOS %S[SharedB], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOS %S[ScaleB], mask=1111\n" ".endif\n" "B.IOT %[A], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleA], mask=1111\n" ".endif\n" \ PTO_FIXP_ACC_PPSRC_4 #define PTO_FIXP_MX_ACC_SB_SRC_5 \ - "B.IOS %S[SharedB].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOS %S[ScaleB].reuse, mask=1111\n" ".endif\n" "B.IOT %[A].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleA].reuse, mask=1111\n" ".endif\n" \ + "B.IOS %S[SharedB], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOS %S[ScaleB], mask=1111\n" ".endif\n" "B.IOT %[A], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleA], mask=1111\n" ".endif\n" \ PTO_FIXP_ACC_PPSRC_5 #define PTO_FIXP_MX_ACC_SB_SRC_6 \ - "B.IOS %S[SharedB].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOS %S[ScaleB].reuse, mask=1111\n" ".endif\n" "B.IOT %[A].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleA].reuse, mask=1111\n" ".endif\n" \ + "B.IOS %S[SharedB], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOS %S[ScaleB], mask=1111\n" ".endif\n" "B.IOT %[A], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleA], mask=1111\n" ".endif\n" \ PTO_FIXP_ACC_PPSRC_6 #define PTO_FIXP_MX_ACC_SB_SRC_7 \ - "B.IOS %S[SharedB].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOS %S[ScaleB].reuse, mask=1111\n" ".endif\n" "B.IOT %[A].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleA].reuse, mask=1111\n" ".endif\n" \ + "B.IOS %S[SharedB], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOS %S[ScaleB], mask=1111\n" ".endif\n" "B.IOT %[A], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleA], mask=1111\n" ".endif\n" \ PTO_FIXP_ACC_PPSRC_7 #define PTO_FIXP_MX_ACC_SA_SRC_0 \ - "B.IOS %S[SharedA].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOS %S[ScaleA].reuse, mask=1111\n" ".endif\n" "B.IOT %[B].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleB].reuse, mask=1111\n" ".endif\n" \ + "B.IOS %S[SharedA], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOS %S[ScaleA], mask=1111\n" ".endif\n" "B.IOT %[B], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleB], mask=1111\n" ".endif\n" \ PTO_FIXP_ACC_PPSRC_0 #define PTO_FIXP_MX_ACC_SA_SRC_1 \ - "B.IOS %S[SharedA].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOS %S[ScaleA].reuse, mask=1111\n" ".endif\n" "B.IOT %[B].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleB].reuse, mask=1111\n" ".endif\n" \ + "B.IOS %S[SharedA], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOS %S[ScaleA], mask=1111\n" ".endif\n" "B.IOT %[B], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleB], mask=1111\n" ".endif\n" \ PTO_FIXP_ACC_PPSRC_1 #define PTO_FIXP_MX_ACC_SA_SRC_2 \ - "B.IOS %S[SharedA].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOS %S[ScaleA].reuse, mask=1111\n" ".endif\n" "B.IOT %[B].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleB].reuse, mask=1111\n" ".endif\n" \ + "B.IOS %S[SharedA], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOS %S[ScaleA], mask=1111\n" ".endif\n" "B.IOT %[B], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleB], mask=1111\n" ".endif\n" \ PTO_FIXP_ACC_PPSRC_2 #define PTO_FIXP_MX_ACC_SA_SRC_3 \ - "B.IOS %S[SharedA].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOS %S[ScaleA].reuse, mask=1111\n" ".endif\n" "B.IOT %[B].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleB].reuse, mask=1111\n" ".endif\n" \ + "B.IOS %S[SharedA], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOS %S[ScaleA], mask=1111\n" ".endif\n" "B.IOT %[B], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleB], mask=1111\n" ".endif\n" \ PTO_FIXP_ACC_PPSRC_3 #define PTO_FIXP_MX_ACC_SA_SRC_4 \ - "B.IOS %S[SharedA].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOS %S[ScaleA].reuse, mask=1111\n" ".endif\n" "B.IOT %[B].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleB].reuse, mask=1111\n" ".endif\n" \ + "B.IOS %S[SharedA], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOS %S[ScaleA], mask=1111\n" ".endif\n" "B.IOT %[B], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleB], mask=1111\n" ".endif\n" \ PTO_FIXP_ACC_PPSRC_4 #define PTO_FIXP_MX_ACC_SA_SRC_5 \ - "B.IOS %S[SharedA].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOS %S[ScaleA].reuse, mask=1111\n" ".endif\n" "B.IOT %[B].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleB].reuse, mask=1111\n" ".endif\n" \ + "B.IOS %S[SharedA], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOS %S[ScaleA], mask=1111\n" ".endif\n" "B.IOT %[B], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleB], mask=1111\n" ".endif\n" \ PTO_FIXP_ACC_PPSRC_5 #define PTO_FIXP_MX_ACC_SA_SRC_6 \ - "B.IOS %S[SharedA].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOS %S[ScaleA].reuse, mask=1111\n" ".endif\n" "B.IOT %[B].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleB].reuse, mask=1111\n" ".endif\n" \ + "B.IOS %S[SharedA], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOS %S[ScaleA], mask=1111\n" ".endif\n" "B.IOT %[B], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleB], mask=1111\n" ".endif\n" \ PTO_FIXP_ACC_PPSRC_6 #define PTO_FIXP_MX_ACC_SA_SRC_7 \ - "B.IOS %S[SharedA].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOS %S[ScaleA].reuse, mask=1111\n" ".endif\n" "B.IOT %[B].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleB].reuse, mask=1111\n" ".endif\n" \ + "B.IOS %S[SharedA], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOS %S[ScaleA], mask=1111\n" ".endif\n" "B.IOT %[B], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleB], mask=1111\n" ".endif\n" \ PTO_FIXP_ACC_PPSRC_7 #define PTO_FIXP_MX_ACC_SAB_SRC_0 \ - "B.IOS %S[SharedA].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOS %S[ScaleA].reuse, mask=1111\n" ".endif\n" "B.IOS %S[SharedB].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOS %S[ScaleB].reuse, mask=1111\n" ".endif\n" \ + "B.IOS %S[SharedA], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOS %S[ScaleA], mask=1111\n" ".endif\n" "B.IOS %S[SharedB], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOS %S[ScaleB], mask=1111\n" ".endif\n" \ PTO_FIXP_ACC_PPSRC_0 #define PTO_FIXP_MX_ACC_SAB_SRC_1 \ - "B.IOS %S[SharedA].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOS %S[ScaleA].reuse, mask=1111\n" ".endif\n" "B.IOS %S[SharedB].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOS %S[ScaleB].reuse, mask=1111\n" ".endif\n" \ + "B.IOS %S[SharedA], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOS %S[ScaleA], mask=1111\n" ".endif\n" "B.IOS %S[SharedB], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOS %S[ScaleB], mask=1111\n" ".endif\n" \ PTO_FIXP_ACC_PPSRC_1 #define PTO_FIXP_MX_ACC_SAB_SRC_2 \ - "B.IOS %S[SharedA].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOS %S[ScaleA].reuse, mask=1111\n" ".endif\n" "B.IOS %S[SharedB].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOS %S[ScaleB].reuse, mask=1111\n" ".endif\n" \ + "B.IOS %S[SharedA], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOS %S[ScaleA], mask=1111\n" ".endif\n" "B.IOS %S[SharedB], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOS %S[ScaleB], mask=1111\n" ".endif\n" \ PTO_FIXP_ACC_PPSRC_2 #define PTO_FIXP_MX_ACC_SAB_SRC_3 \ - "B.IOS %S[SharedA].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOS %S[ScaleA].reuse, mask=1111\n" ".endif\n" "B.IOS %S[SharedB].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOS %S[ScaleB].reuse, mask=1111\n" ".endif\n" \ + "B.IOS %S[SharedA], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOS %S[ScaleA], mask=1111\n" ".endif\n" "B.IOS %S[SharedB], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOS %S[ScaleB], mask=1111\n" ".endif\n" \ PTO_FIXP_ACC_PPSRC_3 #define PTO_FIXP_MX_ACC_SAB_SRC_4 \ - "B.IOS %S[SharedA].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOS %S[ScaleA].reuse, mask=1111\n" ".endif\n" "B.IOS %S[SharedB].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOS %S[ScaleB].reuse, mask=1111\n" ".endif\n" \ + "B.IOS %S[SharedA], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOS %S[ScaleA], mask=1111\n" ".endif\n" "B.IOS %S[SharedB], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOS %S[ScaleB], mask=1111\n" ".endif\n" \ PTO_FIXP_ACC_PPSRC_4 #define PTO_FIXP_MX_ACC_SAB_SRC_5 \ - "B.IOS %S[SharedA].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOS %S[ScaleA].reuse, mask=1111\n" ".endif\n" "B.IOS %S[SharedB].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOS %S[ScaleB].reuse, mask=1111\n" ".endif\n" \ + "B.IOS %S[SharedA], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOS %S[ScaleA], mask=1111\n" ".endif\n" "B.IOS %S[SharedB], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOS %S[ScaleB], mask=1111\n" ".endif\n" \ PTO_FIXP_ACC_PPSRC_5 #define PTO_FIXP_MX_ACC_SAB_SRC_6 \ - "B.IOS %S[SharedA].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOS %S[ScaleA].reuse, mask=1111\n" ".endif\n" "B.IOS %S[SharedB].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOS %S[ScaleB].reuse, mask=1111\n" ".endif\n" \ + "B.IOS %S[SharedA], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOS %S[ScaleA], mask=1111\n" ".endif\n" "B.IOS %S[SharedB], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOS %S[ScaleB], mask=1111\n" ".endif\n" \ PTO_FIXP_ACC_PPSRC_6 #define PTO_FIXP_MX_ACC_SAB_SRC_7 \ - "B.IOS %S[SharedA].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOS %S[ScaleA].reuse, mask=1111\n" ".endif\n" "B.IOS %S[SharedB].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOS %S[ScaleB].reuse, mask=1111\n" ".endif\n" \ + "B.IOS %S[SharedA], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOS %S[ScaleA], mask=1111\n" ".endif\n" "B.IOS %S[SharedB], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOS %S[ScaleB], mask=1111\n" ".endif\n" \ PTO_FIXP_ACC_PPSRC_7 #define PTO_FIXP_MX_BIAS_L_SRC_0 \ - "B.IOT %[A].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleA].reuse, mask=1111\n" ".endif\n" \ - "B.IOT %[B].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleB].reuse, mask=1111\n" ".endif\n" "B.IOT %[Bias].reuse, mask=1111\n" \ + "B.IOT %[A], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleA], mask=1111\n" ".endif\n" \ + "B.IOT %[B], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleB], mask=1111\n" ".endif\n" "B.IOT %[Bias], mask=1111\n" \ PTO_FIXP_PPSRC_0 #define PTO_FIXP_MX_BIAS_L_SRC_1 \ - "B.IOT %[A].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleA].reuse, mask=1111\n" ".endif\n" \ - "B.IOT %[B].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleB].reuse, mask=1111\n" ".endif\n" "B.IOT %[Bias].reuse, mask=1111\n" \ + "B.IOT %[A], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleA], mask=1111\n" ".endif\n" \ + "B.IOT %[B], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleB], mask=1111\n" ".endif\n" "B.IOT %[Bias], mask=1111\n" \ PTO_FIXP_PPSRC_1 #define PTO_FIXP_MX_BIAS_L_SRC_2 \ - "B.IOT %[A].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleA].reuse, mask=1111\n" ".endif\n" \ - "B.IOT %[B].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleB].reuse, mask=1111\n" ".endif\n" "B.IOT %[Bias].reuse, mask=1111\n" \ + "B.IOT %[A], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleA], mask=1111\n" ".endif\n" \ + "B.IOT %[B], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleB], mask=1111\n" ".endif\n" "B.IOT %[Bias], mask=1111\n" \ PTO_FIXP_PPSRC_2 #define PTO_FIXP_MX_BIAS_L_SRC_3 \ - "B.IOT %[A].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleA].reuse, mask=1111\n" ".endif\n" \ - "B.IOT %[B].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleB].reuse, mask=1111\n" ".endif\n" "B.IOT %[Bias].reuse, mask=1111\n" \ + "B.IOT %[A], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleA], mask=1111\n" ".endif\n" \ + "B.IOT %[B], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleB], mask=1111\n" ".endif\n" "B.IOT %[Bias], mask=1111\n" \ PTO_FIXP_PPSRC_3 #define PTO_FIXP_MX_BIAS_L_SRC_4 \ - "B.IOT %[A].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleA].reuse, mask=1111\n" ".endif\n" \ - "B.IOT %[B].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleB].reuse, mask=1111\n" ".endif\n" "B.IOT %[Bias].reuse, mask=1111\n" \ + "B.IOT %[A], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleA], mask=1111\n" ".endif\n" \ + "B.IOT %[B], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleB], mask=1111\n" ".endif\n" "B.IOT %[Bias], mask=1111\n" \ PTO_FIXP_PPSRC_4 #define PTO_FIXP_MX_BIAS_L_SRC_5 \ - "B.IOT %[A].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleA].reuse, mask=1111\n" ".endif\n" \ - "B.IOT %[B].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleB].reuse, mask=1111\n" ".endif\n" "B.IOT %[Bias].reuse, mask=1111\n" \ + "B.IOT %[A], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleA], mask=1111\n" ".endif\n" \ + "B.IOT %[B], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleB], mask=1111\n" ".endif\n" "B.IOT %[Bias], mask=1111\n" \ PTO_FIXP_PPSRC_5 #define PTO_FIXP_MX_BIAS_L_SRC_6 \ - "B.IOT %[A].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleA].reuse, mask=1111\n" ".endif\n" \ - "B.IOT %[B].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleB].reuse, mask=1111\n" ".endif\n" "B.IOT %[Bias].reuse, mask=1111\n" \ + "B.IOT %[A], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleA], mask=1111\n" ".endif\n" \ + "B.IOT %[B], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleB], mask=1111\n" ".endif\n" "B.IOT %[Bias], mask=1111\n" \ PTO_FIXP_PPSRC_6 #define PTO_FIXP_MX_BIAS_L_SRC_7 \ - "B.IOT %[A].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleA].reuse, mask=1111\n" ".endif\n" \ - "B.IOT %[B].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleB].reuse, mask=1111\n" ".endif\n" "B.IOT %[Bias].reuse, mask=1111\n" \ + "B.IOT %[A], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleA], mask=1111\n" ".endif\n" \ + "B.IOT %[B], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleB], mask=1111\n" ".endif\n" "B.IOT %[Bias], mask=1111\n" \ PTO_FIXP_PPSRC_7 #define PTO_FIXP_MX_BIAS_SB_SRC_0 \ - "B.IOS %S[SharedB].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOS %S[ScaleB].reuse, mask=1111\n" ".endif\n" "B.IOT %[A].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleA].reuse, mask=1111\n" ".endif\n" "B.IOT %[Bias].reuse, mask=1111\n" \ + "B.IOS %S[SharedB], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOS %S[ScaleB], mask=1111\n" ".endif\n" "B.IOT %[A], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleA], mask=1111\n" ".endif\n" "B.IOT %[Bias], mask=1111\n" \ PTO_FIXP_PPSRC_0 #define PTO_FIXP_MX_BIAS_SB_SRC_1 \ - "B.IOS %S[SharedB].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOS %S[ScaleB].reuse, mask=1111\n" ".endif\n" "B.IOT %[A].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleA].reuse, mask=1111\n" ".endif\n" "B.IOT %[Bias].reuse, mask=1111\n" \ + "B.IOS %S[SharedB], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOS %S[ScaleB], mask=1111\n" ".endif\n" "B.IOT %[A], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleA], mask=1111\n" ".endif\n" "B.IOT %[Bias], mask=1111\n" \ PTO_FIXP_PPSRC_1 #define PTO_FIXP_MX_BIAS_SB_SRC_2 \ - "B.IOS %S[SharedB].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOS %S[ScaleB].reuse, mask=1111\n" ".endif\n" "B.IOT %[A].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleA].reuse, mask=1111\n" ".endif\n" "B.IOT %[Bias].reuse, mask=1111\n" \ + "B.IOS %S[SharedB], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOS %S[ScaleB], mask=1111\n" ".endif\n" "B.IOT %[A], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleA], mask=1111\n" ".endif\n" "B.IOT %[Bias], mask=1111\n" \ PTO_FIXP_PPSRC_2 #define PTO_FIXP_MX_BIAS_SB_SRC_3 \ - "B.IOS %S[SharedB].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOS %S[ScaleB].reuse, mask=1111\n" ".endif\n" "B.IOT %[A].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleA].reuse, mask=1111\n" ".endif\n" "B.IOT %[Bias].reuse, mask=1111\n" \ + "B.IOS %S[SharedB], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOS %S[ScaleB], mask=1111\n" ".endif\n" "B.IOT %[A], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleA], mask=1111\n" ".endif\n" "B.IOT %[Bias], mask=1111\n" \ PTO_FIXP_PPSRC_3 #define PTO_FIXP_MX_BIAS_SB_SRC_4 \ - "B.IOS %S[SharedB].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOS %S[ScaleB].reuse, mask=1111\n" ".endif\n" "B.IOT %[A].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleA].reuse, mask=1111\n" ".endif\n" "B.IOT %[Bias].reuse, mask=1111\n" \ + "B.IOS %S[SharedB], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOS %S[ScaleB], mask=1111\n" ".endif\n" "B.IOT %[A], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleA], mask=1111\n" ".endif\n" "B.IOT %[Bias], mask=1111\n" \ PTO_FIXP_PPSRC_4 #define PTO_FIXP_MX_BIAS_SB_SRC_5 \ - "B.IOS %S[SharedB].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOS %S[ScaleB].reuse, mask=1111\n" ".endif\n" "B.IOT %[A].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleA].reuse, mask=1111\n" ".endif\n" "B.IOT %[Bias].reuse, mask=1111\n" \ + "B.IOS %S[SharedB], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOS %S[ScaleB], mask=1111\n" ".endif\n" "B.IOT %[A], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleA], mask=1111\n" ".endif\n" "B.IOT %[Bias], mask=1111\n" \ PTO_FIXP_PPSRC_5 #define PTO_FIXP_MX_BIAS_SB_SRC_6 \ - "B.IOS %S[SharedB].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOS %S[ScaleB].reuse, mask=1111\n" ".endif\n" "B.IOT %[A].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleA].reuse, mask=1111\n" ".endif\n" "B.IOT %[Bias].reuse, mask=1111\n" \ + "B.IOS %S[SharedB], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOS %S[ScaleB], mask=1111\n" ".endif\n" "B.IOT %[A], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleA], mask=1111\n" ".endif\n" "B.IOT %[Bias], mask=1111\n" \ PTO_FIXP_PPSRC_6 #define PTO_FIXP_MX_BIAS_SB_SRC_7 \ - "B.IOS %S[SharedB].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOS %S[ScaleB].reuse, mask=1111\n" ".endif\n" "B.IOT %[A].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleA].reuse, mask=1111\n" ".endif\n" "B.IOT %[Bias].reuse, mask=1111\n" \ + "B.IOS %S[SharedB], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOS %S[ScaleB], mask=1111\n" ".endif\n" "B.IOT %[A], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleA], mask=1111\n" ".endif\n" "B.IOT %[Bias], mask=1111\n" \ PTO_FIXP_PPSRC_7 #define PTO_FIXP_MX_BIAS_SA_SRC_0 \ - "B.IOS %S[SharedA].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOS %S[ScaleA].reuse, mask=1111\n" ".endif\n" "B.IOT %[B].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleB].reuse, mask=1111\n" ".endif\n" "B.IOT %[Bias].reuse, mask=1111\n" \ + "B.IOS %S[SharedA], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOS %S[ScaleA], mask=1111\n" ".endif\n" "B.IOT %[B], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleB], mask=1111\n" ".endif\n" "B.IOT %[Bias], mask=1111\n" \ PTO_FIXP_PPSRC_0 #define PTO_FIXP_MX_BIAS_SA_SRC_1 \ - "B.IOS %S[SharedA].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOS %S[ScaleA].reuse, mask=1111\n" ".endif\n" "B.IOT %[B].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleB].reuse, mask=1111\n" ".endif\n" "B.IOT %[Bias].reuse, mask=1111\n" \ + "B.IOS %S[SharedA], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOS %S[ScaleA], mask=1111\n" ".endif\n" "B.IOT %[B], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleB], mask=1111\n" ".endif\n" "B.IOT %[Bias], mask=1111\n" \ PTO_FIXP_PPSRC_1 #define PTO_FIXP_MX_BIAS_SA_SRC_2 \ - "B.IOS %S[SharedA].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOS %S[ScaleA].reuse, mask=1111\n" ".endif\n" "B.IOT %[B].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleB].reuse, mask=1111\n" ".endif\n" "B.IOT %[Bias].reuse, mask=1111\n" \ + "B.IOS %S[SharedA], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOS %S[ScaleA], mask=1111\n" ".endif\n" "B.IOT %[B], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleB], mask=1111\n" ".endif\n" "B.IOT %[Bias], mask=1111\n" \ PTO_FIXP_PPSRC_2 #define PTO_FIXP_MX_BIAS_SA_SRC_3 \ - "B.IOS %S[SharedA].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOS %S[ScaleA].reuse, mask=1111\n" ".endif\n" "B.IOT %[B].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleB].reuse, mask=1111\n" ".endif\n" "B.IOT %[Bias].reuse, mask=1111\n" \ + "B.IOS %S[SharedA], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOS %S[ScaleA], mask=1111\n" ".endif\n" "B.IOT %[B], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleB], mask=1111\n" ".endif\n" "B.IOT %[Bias], mask=1111\n" \ PTO_FIXP_PPSRC_3 #define PTO_FIXP_MX_BIAS_SA_SRC_4 \ - "B.IOS %S[SharedA].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOS %S[ScaleA].reuse, mask=1111\n" ".endif\n" "B.IOT %[B].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleB].reuse, mask=1111\n" ".endif\n" "B.IOT %[Bias].reuse, mask=1111\n" \ + "B.IOS %S[SharedA], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOS %S[ScaleA], mask=1111\n" ".endif\n" "B.IOT %[B], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleB], mask=1111\n" ".endif\n" "B.IOT %[Bias], mask=1111\n" \ PTO_FIXP_PPSRC_4 #define PTO_FIXP_MX_BIAS_SA_SRC_5 \ - "B.IOS %S[SharedA].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOS %S[ScaleA].reuse, mask=1111\n" ".endif\n" "B.IOT %[B].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleB].reuse, mask=1111\n" ".endif\n" "B.IOT %[Bias].reuse, mask=1111\n" \ + "B.IOS %S[SharedA], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOS %S[ScaleA], mask=1111\n" ".endif\n" "B.IOT %[B], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleB], mask=1111\n" ".endif\n" "B.IOT %[Bias], mask=1111\n" \ PTO_FIXP_PPSRC_5 #define PTO_FIXP_MX_BIAS_SA_SRC_6 \ - "B.IOS %S[SharedA].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOS %S[ScaleA].reuse, mask=1111\n" ".endif\n" "B.IOT %[B].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleB].reuse, mask=1111\n" ".endif\n" "B.IOT %[Bias].reuse, mask=1111\n" \ + "B.IOS %S[SharedA], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOS %S[ScaleA], mask=1111\n" ".endif\n" "B.IOT %[B], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleB], mask=1111\n" ".endif\n" "B.IOT %[Bias], mask=1111\n" \ PTO_FIXP_PPSRC_6 #define PTO_FIXP_MX_BIAS_SA_SRC_7 \ - "B.IOS %S[SharedA].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOS %S[ScaleA].reuse, mask=1111\n" ".endif\n" "B.IOT %[B].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleB].reuse, mask=1111\n" ".endif\n" "B.IOT %[Bias].reuse, mask=1111\n" \ + "B.IOS %S[SharedA], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOS %S[ScaleA], mask=1111\n" ".endif\n" "B.IOT %[B], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleB], mask=1111\n" ".endif\n" "B.IOT %[Bias], mask=1111\n" \ PTO_FIXP_PPSRC_7 #define PTO_FIXP_MX_BIAS_SAB_SRC_0 \ - "B.IOS %S[SharedA].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOS %S[ScaleA].reuse, mask=1111\n" ".endif\n" "B.IOS %S[SharedB].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOS %S[ScaleB].reuse, mask=1111\n" ".endif\n" "B.IOT %[Bias].reuse, mask=1111\n" \ + "B.IOS %S[SharedA], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOS %S[ScaleA], mask=1111\n" ".endif\n" "B.IOS %S[SharedB], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOS %S[ScaleB], mask=1111\n" ".endif\n" "B.IOT %[Bias], mask=1111\n" \ PTO_FIXP_PPSRC_0 #define PTO_FIXP_MX_BIAS_SAB_SRC_1 \ - "B.IOS %S[SharedA].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOS %S[ScaleA].reuse, mask=1111\n" ".endif\n" "B.IOS %S[SharedB].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOS %S[ScaleB].reuse, mask=1111\n" ".endif\n" "B.IOT %[Bias].reuse, mask=1111\n" \ + "B.IOS %S[SharedA], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOS %S[ScaleA], mask=1111\n" ".endif\n" "B.IOS %S[SharedB], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOS %S[ScaleB], mask=1111\n" ".endif\n" "B.IOT %[Bias], mask=1111\n" \ PTO_FIXP_PPSRC_1 #define PTO_FIXP_MX_BIAS_SAB_SRC_2 \ - "B.IOS %S[SharedA].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOS %S[ScaleA].reuse, mask=1111\n" ".endif\n" "B.IOS %S[SharedB].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOS %S[ScaleB].reuse, mask=1111\n" ".endif\n" "B.IOT %[Bias].reuse, mask=1111\n" \ + "B.IOS %S[SharedA], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOS %S[ScaleA], mask=1111\n" ".endif\n" "B.IOS %S[SharedB], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOS %S[ScaleB], mask=1111\n" ".endif\n" "B.IOT %[Bias], mask=1111\n" \ PTO_FIXP_PPSRC_2 #define PTO_FIXP_MX_BIAS_SAB_SRC_3 \ - "B.IOS %S[SharedA].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOS %S[ScaleA].reuse, mask=1111\n" ".endif\n" "B.IOS %S[SharedB].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOS %S[ScaleB].reuse, mask=1111\n" ".endif\n" "B.IOT %[Bias].reuse, mask=1111\n" \ + "B.IOS %S[SharedA], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOS %S[ScaleA], mask=1111\n" ".endif\n" "B.IOS %S[SharedB], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOS %S[ScaleB], mask=1111\n" ".endif\n" "B.IOT %[Bias], mask=1111\n" \ PTO_FIXP_PPSRC_3 #define PTO_FIXP_MX_BIAS_SAB_SRC_4 \ - "B.IOS %S[SharedA].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOS %S[ScaleA].reuse, mask=1111\n" ".endif\n" "B.IOS %S[SharedB].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOS %S[ScaleB].reuse, mask=1111\n" ".endif\n" "B.IOT %[Bias].reuse, mask=1111\n" \ + "B.IOS %S[SharedA], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOS %S[ScaleA], mask=1111\n" ".endif\n" "B.IOS %S[SharedB], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOS %S[ScaleB], mask=1111\n" ".endif\n" "B.IOT %[Bias], mask=1111\n" \ PTO_FIXP_PPSRC_4 #define PTO_FIXP_MX_BIAS_SAB_SRC_5 \ - "B.IOS %S[SharedA].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOS %S[ScaleA].reuse, mask=1111\n" ".endif\n" "B.IOS %S[SharedB].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOS %S[ScaleB].reuse, mask=1111\n" ".endif\n" "B.IOT %[Bias].reuse, mask=1111\n" \ + "B.IOS %S[SharedA], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOS %S[ScaleA], mask=1111\n" ".endif\n" "B.IOS %S[SharedB], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOS %S[ScaleB], mask=1111\n" ".endif\n" "B.IOT %[Bias], mask=1111\n" \ PTO_FIXP_PPSRC_5 #define PTO_FIXP_MX_BIAS_SAB_SRC_6 \ - "B.IOS %S[SharedA].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOS %S[ScaleA].reuse, mask=1111\n" ".endif\n" "B.IOS %S[SharedB].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOS %S[ScaleB].reuse, mask=1111\n" ".endif\n" "B.IOT %[Bias].reuse, mask=1111\n" \ + "B.IOS %S[SharedA], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOS %S[ScaleA], mask=1111\n" ".endif\n" "B.IOS %S[SharedB], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOS %S[ScaleB], mask=1111\n" ".endif\n" "B.IOT %[Bias], mask=1111\n" \ PTO_FIXP_PPSRC_6 #define PTO_FIXP_MX_BIAS_SAB_SRC_7 \ - "B.IOS %S[SharedA].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOS %S[ScaleA].reuse, mask=1111\n" ".endif\n" "B.IOS %S[SharedB].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOS %S[ScaleB].reuse, mask=1111\n" ".endif\n" "B.IOT %[Bias].reuse, mask=1111\n" \ + "B.IOS %S[SharedA], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOS %S[ScaleA], mask=1111\n" ".endif\n" "B.IOS %S[SharedB], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOS %S[ScaleB], mask=1111\n" ".endif\n" "B.IOT %[Bias], mask=1111\n" \ PTO_FIXP_PPSRC_7 // ScaleMask==3 uses the FIXP source families above. Keep the complete @@ -6531,7 +6531,7 @@ PTO_SHARED_INLINE void matmul_acc(Dst &dst, C &c, A &a, B &b, size_t M, #undef PTO_FIXP_MX_L_SRC_5 #undef PTO_FIXP_MX_L_SRC_6 #undef PTO_FIXP_MX_L_SRC_7 -#define PTO_FIXP_MX_L_PACKED "B.IOT %[A].reuse, %[ScaleA].reuse, mask=1111\n" "B.IOT %[B].reuse, %[ScaleB].reuse, mask=1111\n" +#define PTO_FIXP_MX_L_PACKED "B.IOT %[A], %[ScaleA], mask=1111\n" "B.IOT %[B], %[ScaleB], mask=1111\n" #define PTO_FIXP_MX_L_SRC_0 PTO_FIXP_MX_L_PACKED PTO_FIXP_PPSRC_0 #define PTO_FIXP_MX_L_SRC_1 PTO_FIXP_MX_L_PACKED PTO_FIXP_PPSRC_1 #define PTO_FIXP_MX_L_SRC_2 PTO_FIXP_MX_L_PACKED PTO_FIXP_PPSRC_2 @@ -6549,7 +6549,7 @@ PTO_SHARED_INLINE void matmul_acc(Dst &dst, C &c, A &a, B &b, size_t M, #undef PTO_FIXP_MX_SB_SRC_5 #undef PTO_FIXP_MX_SB_SRC_6 #undef PTO_FIXP_MX_SB_SRC_7 -#define PTO_FIXP_MX_SB_PACKED "B.IOS %S[SharedB].reuse, mask=1111\n" "B.IOS %S[ScaleB].reuse, mask=1111\n" "B.IOT %[A].reuse, %[ScaleA].reuse, mask=1111\n" +#define PTO_FIXP_MX_SB_PACKED "B.IOS %S[SharedB], mask=1111\n" "B.IOS %S[ScaleB], mask=1111\n" "B.IOT %[A], %[ScaleA], mask=1111\n" #define PTO_FIXP_MX_SB_SRC_0 PTO_FIXP_MX_SB_PACKED PTO_FIXP_PPSRC_0 #define PTO_FIXP_MX_SB_SRC_1 PTO_FIXP_MX_SB_PACKED PTO_FIXP_PPSRC_1 #define PTO_FIXP_MX_SB_SRC_2 PTO_FIXP_MX_SB_PACKED PTO_FIXP_PPSRC_2 @@ -6567,7 +6567,7 @@ PTO_SHARED_INLINE void matmul_acc(Dst &dst, C &c, A &a, B &b, size_t M, #undef PTO_FIXP_MX_SA_SRC_5 #undef PTO_FIXP_MX_SA_SRC_6 #undef PTO_FIXP_MX_SA_SRC_7 -#define PTO_FIXP_MX_SA_PACKED "B.IOS %S[SharedA].reuse, mask=1111\n" "B.IOS %S[ScaleA].reuse, mask=1111\n" "B.IOT %[B].reuse, %[ScaleB].reuse, mask=1111\n" +#define PTO_FIXP_MX_SA_PACKED "B.IOS %S[SharedA], mask=1111\n" "B.IOS %S[ScaleA], mask=1111\n" "B.IOT %[B], %[ScaleB], mask=1111\n" #define PTO_FIXP_MX_SA_SRC_0 PTO_FIXP_MX_SA_PACKED PTO_FIXP_PPSRC_0 #define PTO_FIXP_MX_SA_SRC_1 PTO_FIXP_MX_SA_PACKED PTO_FIXP_PPSRC_1 #define PTO_FIXP_MX_SA_SRC_2 PTO_FIXP_MX_SA_PACKED PTO_FIXP_PPSRC_2 @@ -6585,7 +6585,7 @@ PTO_SHARED_INLINE void matmul_acc(Dst &dst, C &c, A &a, B &b, size_t M, #undef PTO_FIXP_MX_ACC_L_SRC_5 #undef PTO_FIXP_MX_ACC_L_SRC_6 #undef PTO_FIXP_MX_ACC_L_SRC_7 -#define PTO_FIXP_MX_ACC_L_PACKED "B.IOT %[C].reuse, %[A].reuse, mask=1111\n" "B.IOT %[ScaleA].reuse, %[B].reuse, mask=1111\n" +#define PTO_FIXP_MX_ACC_L_PACKED "B.IOT %[C], %[A], mask=1111\n" "B.IOT %[ScaleA], %[B], mask=1111\n" #define PTO_FIXP_MX_ACC_L_SRC_0 PTO_FIXP_MX_ACC_L_PACKED PTO_FIXP_ACC_EVEN_X_TAIL_0("%[ScaleB]") #define PTO_FIXP_MX_ACC_L_SRC_1 PTO_FIXP_MX_ACC_L_PACKED PTO_FIXP_ACC_EVEN_X_TAIL_1("%[ScaleB]") #define PTO_FIXP_MX_ACC_L_SRC_2 PTO_FIXP_MX_ACC_L_PACKED PTO_FIXP_ACC_EVEN_X_TAIL_2("%[ScaleB]") @@ -6603,7 +6603,7 @@ PTO_SHARED_INLINE void matmul_acc(Dst &dst, C &c, A &a, B &b, size_t M, #undef PTO_FIXP_MX_ACC_SB_SRC_5 #undef PTO_FIXP_MX_ACC_SB_SRC_6 #undef PTO_FIXP_MX_ACC_SB_SRC_7 -#define PTO_FIXP_MX_ACC_SB_PACKED "B.IOS %S[SharedB].reuse, mask=1111\n" "B.IOS %S[ScaleB].reuse, mask=1111\n" "B.IOT %[C].reuse, %[A].reuse, mask=1111\n" +#define PTO_FIXP_MX_ACC_SB_PACKED "B.IOS %S[SharedB], mask=1111\n" "B.IOS %S[ScaleB], mask=1111\n" "B.IOT %[C], %[A], mask=1111\n" #define PTO_FIXP_MX_ACC_SB_SRC_0 PTO_FIXP_MX_ACC_SB_PACKED PTO_FIXP_ACC_ODD_TAIL_0("%[ScaleA]") #define PTO_FIXP_MX_ACC_SB_SRC_1 PTO_FIXP_MX_ACC_SB_PACKED PTO_FIXP_ACC_ODD_TAIL_1("%[ScaleA]") #define PTO_FIXP_MX_ACC_SB_SRC_2 PTO_FIXP_MX_ACC_SB_PACKED PTO_FIXP_ACC_ODD_TAIL_2("%[ScaleA]") @@ -6621,7 +6621,7 @@ PTO_SHARED_INLINE void matmul_acc(Dst &dst, C &c, A &a, B &b, size_t M, #undef PTO_FIXP_MX_ACC_SA_SRC_5 #undef PTO_FIXP_MX_ACC_SA_SRC_6 #undef PTO_FIXP_MX_ACC_SA_SRC_7 -#define PTO_FIXP_MX_ACC_SA_PACKED "B.IOS %S[SharedA].reuse, mask=1111\n" "B.IOS %S[ScaleA].reuse, mask=1111\n" "B.IOT %[C].reuse, %[B].reuse, mask=1111\n" +#define PTO_FIXP_MX_ACC_SA_PACKED "B.IOS %S[SharedA], mask=1111\n" "B.IOS %S[ScaleA], mask=1111\n" "B.IOT %[C], %[B], mask=1111\n" #define PTO_FIXP_MX_ACC_SA_SRC_0 PTO_FIXP_MX_ACC_SA_PACKED PTO_FIXP_ACC_ODD_TAIL_0("%[ScaleB]") #define PTO_FIXP_MX_ACC_SA_SRC_1 PTO_FIXP_MX_ACC_SA_PACKED PTO_FIXP_ACC_ODD_TAIL_1("%[ScaleB]") #define PTO_FIXP_MX_ACC_SA_SRC_2 PTO_FIXP_MX_ACC_SA_PACKED PTO_FIXP_ACC_ODD_TAIL_2("%[ScaleB]") @@ -6639,7 +6639,7 @@ PTO_SHARED_INLINE void matmul_acc(Dst &dst, C &c, A &a, B &b, size_t M, #undef PTO_FIXP_MX_ACC_SAB_SRC_5 #undef PTO_FIXP_MX_ACC_SAB_SRC_6 #undef PTO_FIXP_MX_ACC_SAB_SRC_7 -#define PTO_FIXP_MX_ACC_SAB_PACKED "B.IOS %S[SharedA].reuse, mask=1111\n" "B.IOS %S[ScaleA].reuse, mask=1111\n" "B.IOS %S[SharedB].reuse, mask=1111\n" "B.IOS %S[ScaleB].reuse, mask=1111\n" +#define PTO_FIXP_MX_ACC_SAB_PACKED "B.IOS %S[SharedA], mask=1111\n" "B.IOS %S[ScaleA], mask=1111\n" "B.IOS %S[SharedB], mask=1111\n" "B.IOS %S[ScaleB], mask=1111\n" #define PTO_FIXP_MX_ACC_SAB_SRC_0 PTO_FIXP_MX_ACC_SAB_PACKED PTO_FIXP_ACC_ODD_TAIL_0("%[C]") #define PTO_FIXP_MX_ACC_SAB_SRC_1 PTO_FIXP_MX_ACC_SAB_PACKED PTO_FIXP_ACC_ODD_TAIL_1("%[C]") #define PTO_FIXP_MX_ACC_SAB_SRC_2 PTO_FIXP_MX_ACC_SAB_PACKED PTO_FIXP_ACC_ODD_TAIL_2("%[C]") @@ -6657,7 +6657,7 @@ PTO_SHARED_INLINE void matmul_acc(Dst &dst, C &c, A &a, B &b, size_t M, #undef PTO_FIXP_MX_BIAS_L_SRC_5 #undef PTO_FIXP_MX_BIAS_L_SRC_6 #undef PTO_FIXP_MX_BIAS_L_SRC_7 -#define PTO_FIXP_MX_BIAS_L_PACKED PTO_FIXP_MX_L_PACKED "B.IOT %[Bias].reuse, mask=1111\n" +#define PTO_FIXP_MX_BIAS_L_PACKED PTO_FIXP_MX_L_PACKED "B.IOT %[Bias], mask=1111\n" #define PTO_FIXP_MX_BIAS_L_SRC_0 PTO_FIXP_MX_BIAS_L_PACKED PTO_FIXP_PPSRC_0 #define PTO_FIXP_MX_BIAS_L_SRC_1 PTO_FIXP_MX_BIAS_L_PACKED PTO_FIXP_PPSRC_1 #define PTO_FIXP_MX_BIAS_L_SRC_2 PTO_FIXP_MX_BIAS_L_PACKED PTO_FIXP_PPSRC_2 @@ -6675,7 +6675,7 @@ PTO_SHARED_INLINE void matmul_acc(Dst &dst, C &c, A &a, B &b, size_t M, #undef PTO_FIXP_MX_BIAS_SB_SRC_5 #undef PTO_FIXP_MX_BIAS_SB_SRC_6 #undef PTO_FIXP_MX_BIAS_SB_SRC_7 -#define PTO_FIXP_MX_BIAS_SB_PACKED PTO_FIXP_MX_SB_PACKED "B.IOT %[Bias].reuse, mask=1111\n" +#define PTO_FIXP_MX_BIAS_SB_PACKED PTO_FIXP_MX_SB_PACKED "B.IOT %[Bias], mask=1111\n" #define PTO_FIXP_MX_BIAS_SB_SRC_0 PTO_FIXP_MX_BIAS_SB_PACKED PTO_FIXP_PPSRC_0 #define PTO_FIXP_MX_BIAS_SB_SRC_1 PTO_FIXP_MX_BIAS_SB_PACKED PTO_FIXP_PPSRC_1 #define PTO_FIXP_MX_BIAS_SB_SRC_2 PTO_FIXP_MX_BIAS_SB_PACKED PTO_FIXP_PPSRC_2 @@ -6693,7 +6693,7 @@ PTO_SHARED_INLINE void matmul_acc(Dst &dst, C &c, A &a, B &b, size_t M, #undef PTO_FIXP_MX_BIAS_SA_SRC_5 #undef PTO_FIXP_MX_BIAS_SA_SRC_6 #undef PTO_FIXP_MX_BIAS_SA_SRC_7 -#define PTO_FIXP_MX_BIAS_SA_PACKED PTO_FIXP_MX_SA_PACKED "B.IOT %[Bias].reuse, mask=1111\n" +#define PTO_FIXP_MX_BIAS_SA_PACKED PTO_FIXP_MX_SA_PACKED "B.IOT %[Bias], mask=1111\n" #define PTO_FIXP_MX_BIAS_SA_SRC_0 PTO_FIXP_MX_BIAS_SA_PACKED PTO_FIXP_PPSRC_0 #define PTO_FIXP_MX_BIAS_SA_SRC_1 PTO_FIXP_MX_BIAS_SA_PACKED PTO_FIXP_PPSRC_1 #define PTO_FIXP_MX_BIAS_SA_SRC_2 PTO_FIXP_MX_BIAS_SA_PACKED PTO_FIXP_PPSRC_2 @@ -6707,195 +6707,195 @@ PTO_SHARED_INLINE void matmul_acc(Dst &dst, C &c, A &a, B &b, size_t M, // handoff Sec 1.5 (any B.IOS is illegal). A=1xK vector (M=1), B=KxN // matrix, C=1xN output. Scales follow their matrix/vector shape. #define PTO_FIXP_GV_GV_L_SRC_0 \ - "B.IOT %[Vec].reuse, %[Mtx].reuse, mask=1111\n" \ + "B.IOT %[Vec], %[Mtx], mask=1111\n" \ PTO_FIXP_PPSRC_0 #define PTO_FIXP_GV_GV_L_SRC_1 \ - "B.IOT %[Vec].reuse, %[Mtx].reuse, mask=1111\n" \ + "B.IOT %[Vec], %[Mtx], mask=1111\n" \ PTO_FIXP_PPSRC_1 #define PTO_FIXP_GV_GV_L_SRC_2 \ - "B.IOT %[Vec].reuse, %[Mtx].reuse, mask=1111\n" \ + "B.IOT %[Vec], %[Mtx], mask=1111\n" \ PTO_FIXP_PPSRC_2 #define PTO_FIXP_GV_GV_L_SRC_3 \ - "B.IOT %[Vec].reuse, %[Mtx].reuse, mask=1111\n" \ + "B.IOT %[Vec], %[Mtx], mask=1111\n" \ PTO_FIXP_PPSRC_3 #define PTO_FIXP_GV_GV_L_SRC_4 \ - "B.IOT %[Vec].reuse, %[Mtx].reuse, mask=1111\n" \ + "B.IOT %[Vec], %[Mtx], mask=1111\n" \ PTO_FIXP_PPSRC_4 #define PTO_FIXP_GV_GV_L_SRC_5 \ - "B.IOT %[Vec].reuse, %[Mtx].reuse, mask=1111\n" \ + "B.IOT %[Vec], %[Mtx], mask=1111\n" \ PTO_FIXP_PPSRC_5 #define PTO_FIXP_GV_GV_L_SRC_6 \ - "B.IOT %[Vec].reuse, %[Mtx].reuse, mask=1111\n" \ + "B.IOT %[Vec], %[Mtx], mask=1111\n" \ PTO_FIXP_PPSRC_6 #define PTO_FIXP_GV_GV_L_SRC_7 \ - "B.IOT %[Vec].reuse, %[Mtx].reuse, mask=1111\n" \ + "B.IOT %[Vec], %[Mtx], mask=1111\n" \ PTO_FIXP_PPSRC_7 #define PTO_FIXP_GV_GVB_L_SRC_0 \ - "B.IOT %[Vec].reuse, %[Mtx].reuse, mask=1111\n" "B.IOT %[Bias].reuse, mask=1111\n" \ + "B.IOT %[Vec], %[Mtx], mask=1111\n" "B.IOT %[Bias], mask=1111\n" \ PTO_FIXP_PPSRC_0 #define PTO_FIXP_GV_GVB_L_SRC_1 \ - "B.IOT %[Vec].reuse, %[Mtx].reuse, mask=1111\n" "B.IOT %[Bias].reuse, mask=1111\n" \ + "B.IOT %[Vec], %[Mtx], mask=1111\n" "B.IOT %[Bias], mask=1111\n" \ PTO_FIXP_PPSRC_1 #define PTO_FIXP_GV_GVB_L_SRC_2 \ - "B.IOT %[Vec].reuse, %[Mtx].reuse, mask=1111\n" "B.IOT %[Bias].reuse, mask=1111\n" \ + "B.IOT %[Vec], %[Mtx], mask=1111\n" "B.IOT %[Bias], mask=1111\n" \ PTO_FIXP_PPSRC_2 #define PTO_FIXP_GV_GVB_L_SRC_3 \ - "B.IOT %[Vec].reuse, %[Mtx].reuse, mask=1111\n" "B.IOT %[Bias].reuse, mask=1111\n" \ + "B.IOT %[Vec], %[Mtx], mask=1111\n" "B.IOT %[Bias], mask=1111\n" \ PTO_FIXP_PPSRC_3 #define PTO_FIXP_GV_GVB_L_SRC_4 \ - "B.IOT %[Vec].reuse, %[Mtx].reuse, mask=1111\n" "B.IOT %[Bias].reuse, mask=1111\n" \ + "B.IOT %[Vec], %[Mtx], mask=1111\n" "B.IOT %[Bias], mask=1111\n" \ PTO_FIXP_PPSRC_4 #define PTO_FIXP_GV_GVB_L_SRC_5 \ - "B.IOT %[Vec].reuse, %[Mtx].reuse, mask=1111\n" "B.IOT %[Bias].reuse, mask=1111\n" \ + "B.IOT %[Vec], %[Mtx], mask=1111\n" "B.IOT %[Bias], mask=1111\n" \ PTO_FIXP_PPSRC_5 #define PTO_FIXP_GV_GVB_L_SRC_6 \ - "B.IOT %[Vec].reuse, %[Mtx].reuse, mask=1111\n" "B.IOT %[Bias].reuse, mask=1111\n" \ + "B.IOT %[Vec], %[Mtx], mask=1111\n" "B.IOT %[Bias], mask=1111\n" \ PTO_FIXP_PPSRC_6 #define PTO_FIXP_GV_GVB_L_SRC_7 \ - "B.IOT %[Vec].reuse, %[Mtx].reuse, mask=1111\n" "B.IOT %[Bias].reuse, mask=1111\n" \ + "B.IOT %[Vec], %[Mtx], mask=1111\n" "B.IOT %[Bias], mask=1111\n" \ PTO_FIXP_PPSRC_7 #define PTO_FIXP_GV_GVA_L_SRC_0 \ - "B.IOT %[C].reuse, mask=1111\n" "B.IOT %[Vec].reuse, %[Mtx].reuse, mask=1111\n" \ + "B.IOT %[C], mask=1111\n" "B.IOT %[Vec], %[Mtx], mask=1111\n" \ PTO_FIXP_PPSRC_0 #define PTO_FIXP_GV_GVA_L_SRC_1 \ - "B.IOT %[C].reuse, mask=1111\n" "B.IOT %[Vec].reuse, %[Mtx].reuse, mask=1111\n" \ + "B.IOT %[C], mask=1111\n" "B.IOT %[Vec], %[Mtx], mask=1111\n" \ PTO_FIXP_PPSRC_1 #define PTO_FIXP_GV_GVA_L_SRC_2 \ - "B.IOT %[C].reuse, mask=1111\n" "B.IOT %[Vec].reuse, %[Mtx].reuse, mask=1111\n" \ + "B.IOT %[C], mask=1111\n" "B.IOT %[Vec], %[Mtx], mask=1111\n" \ PTO_FIXP_PPSRC_2 #define PTO_FIXP_GV_GVA_L_SRC_3 \ - "B.IOT %[C].reuse, mask=1111\n" "B.IOT %[Vec].reuse, %[Mtx].reuse, mask=1111\n" \ + "B.IOT %[C], mask=1111\n" "B.IOT %[Vec], %[Mtx], mask=1111\n" \ PTO_FIXP_PPSRC_3 #define PTO_FIXP_GV_GVA_L_SRC_4 \ - "B.IOT %[C].reuse, mask=1111\n" "B.IOT %[Vec].reuse, %[Mtx].reuse, mask=1111\n" \ + "B.IOT %[C], mask=1111\n" "B.IOT %[Vec], %[Mtx], mask=1111\n" \ PTO_FIXP_PPSRC_4 #define PTO_FIXP_GV_GVA_L_SRC_5 \ - "B.IOT %[C].reuse, mask=1111\n" "B.IOT %[Vec].reuse, %[Mtx].reuse, mask=1111\n" \ + "B.IOT %[C], mask=1111\n" "B.IOT %[Vec], %[Mtx], mask=1111\n" \ PTO_FIXP_PPSRC_5 #define PTO_FIXP_GV_GVA_L_SRC_6 \ - "B.IOT %[C].reuse, mask=1111\n" "B.IOT %[Vec].reuse, %[Mtx].reuse, mask=1111\n" \ + "B.IOT %[C], mask=1111\n" "B.IOT %[Vec], %[Mtx], mask=1111\n" \ PTO_FIXP_PPSRC_6 #define PTO_FIXP_GV_GVA_L_SRC_7 \ - "B.IOT %[C].reuse, mask=1111\n" "B.IOT %[Vec].reuse, %[Mtx].reuse, mask=1111\n" \ + "B.IOT %[C], mask=1111\n" "B.IOT %[Vec], %[Mtx], mask=1111\n" \ PTO_FIXP_PPSRC_7 #define PTO_FIXP_GV_GVMX_L_SRC_0 \ - "B.IOT %[Vec].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleVec].reuse, mask=1111\n" ".endif\n" "B.IOT %[Mtx].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleMtx].reuse, mask=1111\n" ".endif\n" \ + "B.IOT %[Vec], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleVec], mask=1111\n" ".endif\n" "B.IOT %[Mtx], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleMtx], mask=1111\n" ".endif\n" \ PTO_FIXP_PPSRC_0 #define PTO_FIXP_GV_GVMX_L_SRC_1 \ - "B.IOT %[Vec].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleVec].reuse, mask=1111\n" ".endif\n" "B.IOT %[Mtx].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleMtx].reuse, mask=1111\n" ".endif\n" \ + "B.IOT %[Vec], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleVec], mask=1111\n" ".endif\n" "B.IOT %[Mtx], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleMtx], mask=1111\n" ".endif\n" \ PTO_FIXP_PPSRC_1 #define PTO_FIXP_GV_GVMX_L_SRC_2 \ - "B.IOT %[Vec].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleVec].reuse, mask=1111\n" ".endif\n" "B.IOT %[Mtx].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleMtx].reuse, mask=1111\n" ".endif\n" \ + "B.IOT %[Vec], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleVec], mask=1111\n" ".endif\n" "B.IOT %[Mtx], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleMtx], mask=1111\n" ".endif\n" \ PTO_FIXP_PPSRC_2 #define PTO_FIXP_GV_GVMX_L_SRC_3 \ - "B.IOT %[Vec].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleVec].reuse, mask=1111\n" ".endif\n" "B.IOT %[Mtx].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleMtx].reuse, mask=1111\n" ".endif\n" \ + "B.IOT %[Vec], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleVec], mask=1111\n" ".endif\n" "B.IOT %[Mtx], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleMtx], mask=1111\n" ".endif\n" \ PTO_FIXP_PPSRC_3 #define PTO_FIXP_GV_GVMX_L_SRC_4 \ - "B.IOT %[Vec].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleVec].reuse, mask=1111\n" ".endif\n" "B.IOT %[Mtx].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleMtx].reuse, mask=1111\n" ".endif\n" \ + "B.IOT %[Vec], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleVec], mask=1111\n" ".endif\n" "B.IOT %[Mtx], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleMtx], mask=1111\n" ".endif\n" \ PTO_FIXP_PPSRC_4 #define PTO_FIXP_GV_GVMX_L_SRC_5 \ - "B.IOT %[Vec].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleVec].reuse, mask=1111\n" ".endif\n" "B.IOT %[Mtx].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleMtx].reuse, mask=1111\n" ".endif\n" \ + "B.IOT %[Vec], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleVec], mask=1111\n" ".endif\n" "B.IOT %[Mtx], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleMtx], mask=1111\n" ".endif\n" \ PTO_FIXP_PPSRC_5 #define PTO_FIXP_GV_GVMX_L_SRC_6 \ - "B.IOT %[Vec].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleVec].reuse, mask=1111\n" ".endif\n" "B.IOT %[Mtx].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleMtx].reuse, mask=1111\n" ".endif\n" \ + "B.IOT %[Vec], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleVec], mask=1111\n" ".endif\n" "B.IOT %[Mtx], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleMtx], mask=1111\n" ".endif\n" \ PTO_FIXP_PPSRC_6 #define PTO_FIXP_GV_GVMX_L_SRC_7 \ - "B.IOT %[Vec].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleVec].reuse, mask=1111\n" ".endif\n" "B.IOT %[Mtx].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleMtx].reuse, mask=1111\n" ".endif\n" \ + "B.IOT %[Vec], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleVec], mask=1111\n" ".endif\n" "B.IOT %[Mtx], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleMtx], mask=1111\n" ".endif\n" \ PTO_FIXP_PPSRC_7 #define PTO_FIXP_GV_GVMXB_L_SRC_0 \ - "B.IOT %[Vec].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleVec].reuse, mask=1111\n" ".endif\n" "B.IOT %[Mtx].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleMtx].reuse, mask=1111\n" ".endif\n" "B.IOT %[Bias].reuse, mask=1111\n" \ + "B.IOT %[Vec], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleVec], mask=1111\n" ".endif\n" "B.IOT %[Mtx], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleMtx], mask=1111\n" ".endif\n" "B.IOT %[Bias], mask=1111\n" \ PTO_FIXP_PPSRC_0 #define PTO_FIXP_GV_GVMXB_L_SRC_1 \ - "B.IOT %[Vec].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleVec].reuse, mask=1111\n" ".endif\n" "B.IOT %[Mtx].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleMtx].reuse, mask=1111\n" ".endif\n" "B.IOT %[Bias].reuse, mask=1111\n" \ + "B.IOT %[Vec], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleVec], mask=1111\n" ".endif\n" "B.IOT %[Mtx], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleMtx], mask=1111\n" ".endif\n" "B.IOT %[Bias], mask=1111\n" \ PTO_FIXP_PPSRC_1 #define PTO_FIXP_GV_GVMXB_L_SRC_2 \ - "B.IOT %[Vec].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleVec].reuse, mask=1111\n" ".endif\n" "B.IOT %[Mtx].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleMtx].reuse, mask=1111\n" ".endif\n" "B.IOT %[Bias].reuse, mask=1111\n" \ + "B.IOT %[Vec], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleVec], mask=1111\n" ".endif\n" "B.IOT %[Mtx], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleMtx], mask=1111\n" ".endif\n" "B.IOT %[Bias], mask=1111\n" \ PTO_FIXP_PPSRC_2 #define PTO_FIXP_GV_GVMXB_L_SRC_3 \ - "B.IOT %[Vec].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleVec].reuse, mask=1111\n" ".endif\n" "B.IOT %[Mtx].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleMtx].reuse, mask=1111\n" ".endif\n" "B.IOT %[Bias].reuse, mask=1111\n" \ + "B.IOT %[Vec], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleVec], mask=1111\n" ".endif\n" "B.IOT %[Mtx], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleMtx], mask=1111\n" ".endif\n" "B.IOT %[Bias], mask=1111\n" \ PTO_FIXP_PPSRC_3 #define PTO_FIXP_GV_GVMXB_L_SRC_4 \ - "B.IOT %[Vec].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleVec].reuse, mask=1111\n" ".endif\n" "B.IOT %[Mtx].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleMtx].reuse, mask=1111\n" ".endif\n" "B.IOT %[Bias].reuse, mask=1111\n" \ + "B.IOT %[Vec], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleVec], mask=1111\n" ".endif\n" "B.IOT %[Mtx], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleMtx], mask=1111\n" ".endif\n" "B.IOT %[Bias], mask=1111\n" \ PTO_FIXP_PPSRC_4 #define PTO_FIXP_GV_GVMXB_L_SRC_5 \ - "B.IOT %[Vec].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleVec].reuse, mask=1111\n" ".endif\n" "B.IOT %[Mtx].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleMtx].reuse, mask=1111\n" ".endif\n" "B.IOT %[Bias].reuse, mask=1111\n" \ + "B.IOT %[Vec], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleVec], mask=1111\n" ".endif\n" "B.IOT %[Mtx], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleMtx], mask=1111\n" ".endif\n" "B.IOT %[Bias], mask=1111\n" \ PTO_FIXP_PPSRC_5 #define PTO_FIXP_GV_GVMXB_L_SRC_6 \ - "B.IOT %[Vec].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleVec].reuse, mask=1111\n" ".endif\n" "B.IOT %[Mtx].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleMtx].reuse, mask=1111\n" ".endif\n" "B.IOT %[Bias].reuse, mask=1111\n" \ + "B.IOT %[Vec], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleVec], mask=1111\n" ".endif\n" "B.IOT %[Mtx], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleMtx], mask=1111\n" ".endif\n" "B.IOT %[Bias], mask=1111\n" \ PTO_FIXP_PPSRC_6 #define PTO_FIXP_GV_GVMXB_L_SRC_7 \ - "B.IOT %[Vec].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleVec].reuse, mask=1111\n" ".endif\n" "B.IOT %[Mtx].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleMtx].reuse, mask=1111\n" ".endif\n" "B.IOT %[Bias].reuse, mask=1111\n" \ + "B.IOT %[Vec], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleVec], mask=1111\n" ".endif\n" "B.IOT %[Mtx], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleMtx], mask=1111\n" ".endif\n" "B.IOT %[Bias], mask=1111\n" \ PTO_FIXP_PPSRC_7 #define PTO_FIXP_GV_GVMXA_L_SRC_0 \ - "B.IOT %[C].reuse, %[Vec].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleVec].reuse, mask=1111\n" ".endif\n" "B.IOT %[Mtx].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleMtx].reuse, mask=1111\n" ".endif\n" \ + "B.IOT %[C], %[Vec], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleVec], mask=1111\n" ".endif\n" "B.IOT %[Mtx], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleMtx], mask=1111\n" ".endif\n" \ PTO_FIXP_PPSRC_0 #define PTO_FIXP_GV_GVMXA_L_SRC_1 \ - "B.IOT %[C].reuse, %[Vec].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleVec].reuse, mask=1111\n" ".endif\n" "B.IOT %[Mtx].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleMtx].reuse, mask=1111\n" ".endif\n" \ + "B.IOT %[C], %[Vec], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleVec], mask=1111\n" ".endif\n" "B.IOT %[Mtx], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleMtx], mask=1111\n" ".endif\n" \ PTO_FIXP_PPSRC_1 #define PTO_FIXP_GV_GVMXA_L_SRC_2 \ - "B.IOT %[C].reuse, %[Vec].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleVec].reuse, mask=1111\n" ".endif\n" "B.IOT %[Mtx].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleMtx].reuse, mask=1111\n" ".endif\n" \ + "B.IOT %[C], %[Vec], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleVec], mask=1111\n" ".endif\n" "B.IOT %[Mtx], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleMtx], mask=1111\n" ".endif\n" \ PTO_FIXP_PPSRC_2 #define PTO_FIXP_GV_GVMXA_L_SRC_3 \ - "B.IOT %[C].reuse, %[Vec].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleVec].reuse, mask=1111\n" ".endif\n" "B.IOT %[Mtx].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleMtx].reuse, mask=1111\n" ".endif\n" \ + "B.IOT %[C], %[Vec], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleVec], mask=1111\n" ".endif\n" "B.IOT %[Mtx], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleMtx], mask=1111\n" ".endif\n" \ PTO_FIXP_PPSRC_3 #define PTO_FIXP_GV_GVMXA_L_SRC_4 \ - "B.IOT %[C].reuse, %[Vec].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleVec].reuse, mask=1111\n" ".endif\n" "B.IOT %[Mtx].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleMtx].reuse, mask=1111\n" ".endif\n" \ + "B.IOT %[C], %[Vec], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleVec], mask=1111\n" ".endif\n" "B.IOT %[Mtx], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleMtx], mask=1111\n" ".endif\n" \ PTO_FIXP_PPSRC_4 #define PTO_FIXP_GV_GVMXA_L_SRC_5 \ - "B.IOT %[C].reuse, %[Vec].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleVec].reuse, mask=1111\n" ".endif\n" "B.IOT %[Mtx].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleMtx].reuse, mask=1111\n" ".endif\n" \ + "B.IOT %[C], %[Vec], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleVec], mask=1111\n" ".endif\n" "B.IOT %[Mtx], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleMtx], mask=1111\n" ".endif\n" \ PTO_FIXP_PPSRC_5 #define PTO_FIXP_GV_GVMXA_L_SRC_6 \ - "B.IOT %[C].reuse, %[Vec].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleVec].reuse, mask=1111\n" ".endif\n" "B.IOT %[Mtx].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleMtx].reuse, mask=1111\n" ".endif\n" \ + "B.IOT %[C], %[Vec], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleVec], mask=1111\n" ".endif\n" "B.IOT %[Mtx], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleMtx], mask=1111\n" ".endif\n" \ PTO_FIXP_PPSRC_6 #define PTO_FIXP_GV_GVMXA_L_SRC_7 \ - "B.IOT %[C].reuse, %[Vec].reuse, mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleVec].reuse, mask=1111\n" ".endif\n" "B.IOT %[Mtx].reuse, mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleMtx].reuse, mask=1111\n" ".endif\n" \ + "B.IOT %[C], %[Vec], mask=1111\n" ".if %c[HasScaleA]\n" "B.IOT %[ScaleVec], mask=1111\n" ".endif\n" "B.IOT %[Mtx], mask=1111\n" ".if %c[HasScaleB]\n" "B.IOT %[ScaleMtx], mask=1111\n" ".endif\n" \ PTO_FIXP_PPSRC_7 // TGEMVMX is Local-only. Pack its ScaleMask==3 math stream for every @@ -6908,7 +6908,7 @@ PTO_SHARED_INLINE void matmul_acc(Dst &dst, C &c, A &a, B &b, size_t M, #undef PTO_FIXP_GV_GVMX_L_SRC_5 #undef PTO_FIXP_GV_GVMX_L_SRC_6 #undef PTO_FIXP_GV_GVMX_L_SRC_7 -#define PTO_FIXP_GV_GVMX_L_PACKED "B.IOT %[Vec].reuse, %[ScaleVec].reuse, mask=1111\n" "B.IOT %[Mtx].reuse, %[ScaleMtx].reuse, mask=1111\n" +#define PTO_FIXP_GV_GVMX_L_PACKED "B.IOT %[Vec], %[ScaleVec], mask=1111\n" "B.IOT %[Mtx], %[ScaleMtx], mask=1111\n" #define PTO_FIXP_GV_GVMX_L_SRC_0 PTO_FIXP_GV_GVMX_L_PACKED PTO_FIXP_PPSRC_0 #define PTO_FIXP_GV_GVMX_L_SRC_1 PTO_FIXP_GV_GVMX_L_PACKED PTO_FIXP_PPSRC_1 #define PTO_FIXP_GV_GVMX_L_SRC_2 PTO_FIXP_GV_GVMX_L_PACKED PTO_FIXP_PPSRC_2 @@ -6926,7 +6926,7 @@ PTO_SHARED_INLINE void matmul_acc(Dst &dst, C &c, A &a, B &b, size_t M, #undef PTO_FIXP_GV_GVMXB_L_SRC_5 #undef PTO_FIXP_GV_GVMXB_L_SRC_6 #undef PTO_FIXP_GV_GVMXB_L_SRC_7 -#define PTO_FIXP_GV_GVMXB_L_PACKED PTO_FIXP_GV_GVMX_L_PACKED "B.IOT %[Bias].reuse, mask=1111\n" +#define PTO_FIXP_GV_GVMXB_L_PACKED PTO_FIXP_GV_GVMX_L_PACKED "B.IOT %[Bias], mask=1111\n" #define PTO_FIXP_GV_GVMXB_L_SRC_0 PTO_FIXP_GV_GVMXB_L_PACKED PTO_FIXP_PPSRC_0 #define PTO_FIXP_GV_GVMXB_L_SRC_1 PTO_FIXP_GV_GVMXB_L_PACKED PTO_FIXP_PPSRC_1 #define PTO_FIXP_GV_GVMXB_L_SRC_2 PTO_FIXP_GV_GVMXB_L_PACKED PTO_FIXP_PPSRC_2 @@ -6944,7 +6944,7 @@ PTO_SHARED_INLINE void matmul_acc(Dst &dst, C &c, A &a, B &b, size_t M, #undef PTO_FIXP_GV_GVMXA_L_SRC_5 #undef PTO_FIXP_GV_GVMXA_L_SRC_6 #undef PTO_FIXP_GV_GVMXA_L_SRC_7 -#define PTO_FIXP_GV_GVMXA_L_PACKED "B.IOT %[C].reuse, %[Vec].reuse, mask=1111\n" "B.IOT %[ScaleVec].reuse, %[Mtx].reuse, mask=1111\n" "B.IOT %[ScaleMtx].reuse, mask=1111\n" +#define PTO_FIXP_GV_GVMXA_L_PACKED "B.IOT %[C], %[Vec], mask=1111\n" "B.IOT %[ScaleVec], %[Mtx], mask=1111\n" "B.IOT %[ScaleMtx], mask=1111\n" #define PTO_FIXP_GV_GVMXA_L_SRC_0 PTO_FIXP_GV_GVMXA_L_PACKED PTO_FIXP_PPSRC_0 #define PTO_FIXP_GV_GVMXA_L_SRC_1 PTO_FIXP_GV_GVMXA_L_PACKED PTO_FIXP_PPSRC_1 #define PTO_FIXP_GV_GVMXA_L_SRC_2 PTO_FIXP_GV_GVMXA_L_PACKED PTO_FIXP_PPSRC_2 @@ -6955,83 +6955,83 @@ PTO_SHARED_INLINE void matmul_acc(Dst &dst, C &c, A &a, B &b, size_t M, #define PTO_FIXP_GV_GVMXA_L_SRC_7 PTO_FIXP_GV_GVMXA_L_PACKED PTO_FIXP_PPSRC_7 #define PTO_FIXP_SRC_0 \ - "B.IOT %[A].reuse, %[B].reuse, mask=1111\n" + "B.IOT %[A], %[B], mask=1111\n" #define PTO_FIXP_SRC_1 \ - "B.IOT %[A].reuse, %[B].reuse, mask=1111\n" "B.IOT %[RowIn].reuse, mask=1111\n" + "B.IOT %[A], %[B], mask=1111\n" "B.IOT %[RowIn], mask=1111\n" #define PTO_FIXP_SRC_2 \ - "B.IOT %[A].reuse, %[B].reuse, mask=1111\n" "B.IOT %[QuantTile].reuse, mask=1111\n" + "B.IOT %[A], %[B], mask=1111\n" "B.IOT %[QuantTile], mask=1111\n" #define PTO_FIXP_SRC_3 \ - "B.IOT %[A].reuse, %[B].reuse, mask=1111\n" "B.IOT %[RowIn].reuse, %[QuantTile].reuse, mask=1111\n" + "B.IOT %[A], %[B], mask=1111\n" "B.IOT %[RowIn], %[QuantTile], mask=1111\n" #define PTO_FIXP_SRC_4 \ - "B.IOT %[A].reuse, %[B].reuse, mask=1111\n" "B.IOT %[ReluTile].reuse, mask=1111\n" + "B.IOT %[A], %[B], mask=1111\n" "B.IOT %[ReluTile], mask=1111\n" #define PTO_FIXP_SRC_5 \ - "B.IOT %[A].reuse, %[B].reuse, mask=1111\n" "B.IOT %[RowIn].reuse, %[ReluTile].reuse, mask=1111\n" + "B.IOT %[A], %[B], mask=1111\n" "B.IOT %[RowIn], %[ReluTile], mask=1111\n" #define PTO_FIXP_SRC_6 \ - "B.IOT %[A].reuse, %[B].reuse, mask=1111\n" "B.IOT %[QuantTile].reuse, %[ReluTile].reuse, mask=1111\n" + "B.IOT %[A], %[B], mask=1111\n" "B.IOT %[QuantTile], %[ReluTile], mask=1111\n" #define PTO_FIXP_SRC_7 \ - "B.IOT %[A].reuse, %[B].reuse, mask=1111\n" \ - "B.IOT %[RowIn].reuse, %[QuantTile].reuse, mask=1111\n" \ - "B.IOT %[ReluTile].reuse, mask=1111\n" + "B.IOT %[A], %[B], mask=1111\n" \ + "B.IOT %[RowIn], %[QuantTile], mask=1111\n" \ + "B.IOT %[ReluTile], mask=1111\n" #define PTO_FIXP_SHARED_B_SRC_0 \ - "B.IOS %S[SharedB].reuse, mask=1111\n" "B.IOT %[A].reuse, mask=1111\n" + "B.IOS %S[SharedB], mask=1111\n" "B.IOT %[A], mask=1111\n" #define PTO_FIXP_SHARED_B_SRC_1 \ - "B.IOS %S[SharedB].reuse, mask=1111\n" "B.IOT %[A].reuse, %[RowIn].reuse, mask=1111\n" + "B.IOS %S[SharedB], mask=1111\n" "B.IOT %[A], %[RowIn], mask=1111\n" #define PTO_FIXP_SHARED_B_SRC_2 \ - "B.IOS %S[SharedB].reuse, mask=1111\n" "B.IOT %[A].reuse, %[QuantTile].reuse, mask=1111\n" + "B.IOS %S[SharedB], mask=1111\n" "B.IOT %[A], %[QuantTile], mask=1111\n" #define PTO_FIXP_SHARED_B_SRC_3 \ - "B.IOS %S[SharedB].reuse, mask=1111\n" "B.IOT %[A].reuse, mask=1111\n" \ - "B.IOT %[RowIn].reuse, %[QuantTile].reuse, mask=1111\n" + "B.IOS %S[SharedB], mask=1111\n" "B.IOT %[A], mask=1111\n" \ + "B.IOT %[RowIn], %[QuantTile], mask=1111\n" #define PTO_FIXP_SHARED_B_SRC_4 \ - "B.IOS %S[SharedB].reuse, mask=1111\n" "B.IOT %[A].reuse, %[ReluTile].reuse, mask=1111\n" + "B.IOS %S[SharedB], mask=1111\n" "B.IOT %[A], %[ReluTile], mask=1111\n" #define PTO_FIXP_SHARED_B_SRC_5 \ - "B.IOS %S[SharedB].reuse, mask=1111\n" "B.IOT %[A].reuse, mask=1111\n" \ - "B.IOT %[RowIn].reuse, %[ReluTile].reuse, mask=1111\n" + "B.IOS %S[SharedB], mask=1111\n" "B.IOT %[A], mask=1111\n" \ + "B.IOT %[RowIn], %[ReluTile], mask=1111\n" #define PTO_FIXP_SHARED_B_SRC_6 \ - "B.IOS %S[SharedB].reuse, mask=1111\n" "B.IOT %[A].reuse, mask=1111\n" \ - "B.IOT %[QuantTile].reuse, %[ReluTile].reuse, mask=1111\n" + "B.IOS %S[SharedB], mask=1111\n" "B.IOT %[A], mask=1111\n" \ + "B.IOT %[QuantTile], %[ReluTile], mask=1111\n" #define PTO_FIXP_SHARED_B_SRC_7 \ - "B.IOS %S[SharedB].reuse, mask=1111\n" "B.IOT %[A].reuse, mask=1111\n" \ - "B.IOT %[RowIn].reuse, %[QuantTile].reuse, mask=1111\n" "B.IOT %[ReluTile].reuse, mask=1111\n" + "B.IOS %S[SharedB], mask=1111\n" "B.IOT %[A], mask=1111\n" \ + "B.IOT %[RowIn], %[QuantTile], mask=1111\n" "B.IOT %[ReluTile], mask=1111\n" #define PTO_FIXP_SHARED_A_SRC_0 \ - "B.IOS %S[SharedA].reuse, mask=1111\n" "B.IOT %[B].reuse, mask=1111\n" + "B.IOS %S[SharedA], mask=1111\n" "B.IOT %[B], mask=1111\n" #define PTO_FIXP_SHARED_A_SRC_1 \ - "B.IOS %S[SharedA].reuse, mask=1111\n" "B.IOT %[B].reuse, %[RowIn].reuse, mask=1111\n" + "B.IOS %S[SharedA], mask=1111\n" "B.IOT %[B], %[RowIn], mask=1111\n" #define PTO_FIXP_SHARED_A_SRC_2 \ - "B.IOS %S[SharedA].reuse, mask=1111\n" "B.IOT %[B].reuse, %[QuantTile].reuse, mask=1111\n" + "B.IOS %S[SharedA], mask=1111\n" "B.IOT %[B], %[QuantTile], mask=1111\n" #define PTO_FIXP_SHARED_A_SRC_3 \ - "B.IOS %S[SharedA].reuse, mask=1111\n" "B.IOT %[B].reuse, %[RowIn].reuse, mask=1111\n" \ - "B.IOT %[QuantTile].reuse, mask=1111\n" + "B.IOS %S[SharedA], mask=1111\n" "B.IOT %[B], %[RowIn], mask=1111\n" \ + "B.IOT %[QuantTile], mask=1111\n" #define PTO_FIXP_SHARED_A_SRC_4 \ - "B.IOS %S[SharedA].reuse, mask=1111\n" "B.IOT %[B].reuse, %[ReluTile].reuse, mask=1111\n" + "B.IOS %S[SharedA], mask=1111\n" "B.IOT %[B], %[ReluTile], mask=1111\n" #define PTO_FIXP_SHARED_A_SRC_5 \ - "B.IOS %S[SharedA].reuse, mask=1111\n" "B.IOT %[B].reuse, %[RowIn].reuse, mask=1111\n" \ - "B.IOT %[ReluTile].reuse, mask=1111\n" + "B.IOS %S[SharedA], mask=1111\n" "B.IOT %[B], %[RowIn], mask=1111\n" \ + "B.IOT %[ReluTile], mask=1111\n" #define PTO_FIXP_SHARED_A_SRC_6 \ - "B.IOS %S[SharedA].reuse, mask=1111\n" "B.IOT %[B].reuse, %[QuantTile].reuse, mask=1111\n" \ - "B.IOT %[ReluTile].reuse, mask=1111\n" + "B.IOS %S[SharedA], mask=1111\n" "B.IOT %[B], %[QuantTile], mask=1111\n" \ + "B.IOT %[ReluTile], mask=1111\n" #define PTO_FIXP_SHARED_A_SRC_7 \ - "B.IOS %S[SharedA].reuse, mask=1111\n" "B.IOT %[B].reuse, %[RowIn].reuse, mask=1111\n" \ - "B.IOT %[QuantTile].reuse, %[ReluTile].reuse, mask=1111\n" + "B.IOS %S[SharedA], mask=1111\n" "B.IOT %[B], %[RowIn], mask=1111\n" \ + "B.IOT %[QuantTile], %[ReluTile], mask=1111\n" #define PTO_FIXP_SHARED_AB_SRC_0 \ - "B.IOS %S[SharedA].reuse, mask=1111\n" "B.IOS %S[SharedB].reuse, mask=1111\n" + "B.IOS %S[SharedA], mask=1111\n" "B.IOS %S[SharedB], mask=1111\n" #define PTO_FIXP_SHARED_AB_SRC_1 \ - PTO_FIXP_SHARED_AB_SRC_0 "B.IOT %[RowIn].reuse, mask=1111\n" + PTO_FIXP_SHARED_AB_SRC_0 "B.IOT %[RowIn], mask=1111\n" #define PTO_FIXP_SHARED_AB_SRC_2 \ - PTO_FIXP_SHARED_AB_SRC_0 "B.IOT %[QuantTile].reuse, mask=1111\n" + PTO_FIXP_SHARED_AB_SRC_0 "B.IOT %[QuantTile], mask=1111\n" #define PTO_FIXP_SHARED_AB_SRC_3 \ - PTO_FIXP_SHARED_AB_SRC_0 "B.IOT %[RowIn].reuse, %[QuantTile].reuse, mask=1111\n" + PTO_FIXP_SHARED_AB_SRC_0 "B.IOT %[RowIn], %[QuantTile], mask=1111\n" #define PTO_FIXP_SHARED_AB_SRC_4 \ - PTO_FIXP_SHARED_AB_SRC_0 "B.IOT %[ReluTile].reuse, mask=1111\n" + PTO_FIXP_SHARED_AB_SRC_0 "B.IOT %[ReluTile], mask=1111\n" #define PTO_FIXP_SHARED_AB_SRC_5 \ - PTO_FIXP_SHARED_AB_SRC_0 "B.IOT %[RowIn].reuse, %[ReluTile].reuse, mask=1111\n" + PTO_FIXP_SHARED_AB_SRC_0 "B.IOT %[RowIn], %[ReluTile], mask=1111\n" #define PTO_FIXP_SHARED_AB_SRC_6 \ - PTO_FIXP_SHARED_AB_SRC_0 "B.IOT %[QuantTile].reuse, %[ReluTile].reuse, mask=1111\n" + PTO_FIXP_SHARED_AB_SRC_0 "B.IOT %[QuantTile], %[ReluTile], mask=1111\n" #define PTO_FIXP_SHARED_AB_SRC_7 \ - PTO_FIXP_SHARED_AB_SRC_0 "B.IOT %[RowIn].reuse, %[QuantTile].reuse, mask=1111\n" \ - "B.IOT %[ReluTile].reuse, mask=1111\n" + PTO_FIXP_SHARED_AB_SRC_0 "B.IOT %[RowIn], %[QuantTile], mask=1111\n" \ + "B.IOT %[ReluTile], mask=1111\n" #define PTO_FIXP_IOR_0 "" #define PTO_FIXP_IOR_1 "B.IOR [%[QuantGpr]],[]\n" @@ -7186,11 +7186,11 @@ PTO_SHARED_INLINE void matmul_acc(Dst &dst, C &c, A &a, B &b, size_t M, // no trailing Local source, so it keeps the sourceless dest). #define PTO_FIXP_ACC_FOLD_LOCAL(IOR) \ asm volatile(PTO_MATMUL_HEADER("TMATMUL.ACC", PTO_FIXP_ATTR) \ - "B.IOT %[C].reuse, %[A].reuse, mask=1111\n" \ + "B.IOT %[C], %[A], mask=1111\n" \ ".if %c[CScaleEn]\n" \ - "B.IOT %[B].reuse, %[CScaleOperand].reuse, mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" \ + "B.IOT %[B], %[CScaleOperand], mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" \ ".else\n" \ - "B.IOT %[B].reuse, mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" \ + "B.IOT %[B], mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" \ ".endif\n" PTO_FIXP_IOR_##IOR \ : PTO_FIXP_OUT_DECL_0 \ : [C] "Tr"(c.data()), [A] "Tr"(a.data()), [B] "Tr"(b.data()), [CScaleOperand] "Tr"(cscale.data()), \ @@ -7198,11 +7198,11 @@ PTO_SHARED_INLINE void matmul_acc(Dst &dst, C &c, A &a, B &b, size_t M, : "memory") #define PTO_FIXP_ACC_FOLD_SHARED_B(IOR) \ asm volatile(PTO_MATMUL_HEADER("TMATMUL.ACC", PTO_FIXP_ATTR) \ - "B.IOS %S[SharedB].reuse, mask=1111\n" \ + "B.IOS %S[SharedB], mask=1111\n" \ ".if %c[CScaleEn]\n" \ - "B.IOT %[C].reuse, %[A].reuse, mask=1111\n" "B.IOT %[CScaleOperand].reuse, mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" \ + "B.IOT %[C], %[A], mask=1111\n" "B.IOT %[CScaleOperand], mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" \ ".else\n" \ - "B.IOT %[C].reuse, %[A].reuse, mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" \ + "B.IOT %[C], %[A], mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" \ ".endif\n" PTO_FIXP_IOR_##IOR \ : PTO_FIXP_OUT_DECL_0 \ : [C] "Tr"(c.data()), [A] "Tr"(a.data()), [SharedB] "Sr"(b.handle()), [CScaleOperand] "Tr"(cscale.data()), \ @@ -7210,11 +7210,11 @@ PTO_SHARED_INLINE void matmul_acc(Dst &dst, C &c, A &a, B &b, size_t M, : "memory") #define PTO_FIXP_ACC_FOLD_SHARED_A(IOR) \ asm volatile(PTO_MATMUL_HEADER("TMATMUL.ACC", PTO_FIXP_ATTR) \ - "B.IOS %S[SharedA].reuse, mask=1111\n" \ + "B.IOS %S[SharedA], mask=1111\n" \ ".if %c[CScaleEn]\n" \ - "B.IOT %[C].reuse, %[B].reuse, mask=1111\n" "B.IOT %[CScaleOperand].reuse, mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" \ + "B.IOT %[C], %[B], mask=1111\n" "B.IOT %[CScaleOperand], mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" \ ".else\n" \ - "B.IOT %[C].reuse, %[B].reuse, mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" \ + "B.IOT %[C], %[B], mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" \ ".endif\n" PTO_FIXP_IOR_##IOR \ : PTO_FIXP_OUT_DECL_0 \ : [C] "Tr"(c.data()), [SharedA] "Sr"(a.handle()), [B] "Tr"(b.data()), [CScaleOperand] "Tr"(cscale.data()), \ @@ -7222,11 +7222,11 @@ PTO_SHARED_INLINE void matmul_acc(Dst &dst, C &c, A &a, B &b, size_t M, : "memory") #define PTO_FIXP_ACC_FOLD_SHARED_AB(IOR) \ asm volatile(PTO_MATMUL_HEADER("TMATMUL.ACC", PTO_FIXP_ATTR) \ - "B.IOS %S[SharedA].reuse, mask=1111\n" "B.IOS %S[SharedB].reuse, mask=1111\n" \ + "B.IOS %S[SharedA], mask=1111\n" "B.IOS %S[SharedB], mask=1111\n" \ ".if %c[CScaleEn]\n" \ - "B.IOT %[C].reuse, %[CScaleOperand].reuse, mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" \ + "B.IOT %[C], %[CScaleOperand], mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" \ ".else\n" \ - "B.IOT %[C].reuse, mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" \ + "B.IOT %[C], mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" \ ".endif\n" PTO_FIXP_IOR_##IOR \ : PTO_FIXP_OUT_DECL_0 \ : [C] "Tr"(c.data()), [SharedA] "Sr"(a.handle()), [SharedB] "Sr"(b.handle()), [CScaleOperand] "Tr"(cscale.data()), \ @@ -7235,28 +7235,28 @@ PTO_SHARED_INLINE void matmul_acc(Dst &dst, C &c, A &a, B &b, size_t M, #define PTO_FIXP_BIAS_FOLD_LOCAL(IOR) \ asm volatile(PTO_MATMUL_HEADER("TMATMUL.BIAS", PTO_FIXP_ATTR) \ - "B.IOT %[A].reuse, %[B].reuse, mask=1111\n" "B.IOT %[Bias].reuse, mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" PTO_FIXP_IOR_##IOR \ + "B.IOT %[A], %[B], mask=1111\n" "B.IOT %[Bias], mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" PTO_FIXP_IOR_##IOR \ : PTO_FIXP_OUT_DECL_0 \ : [A] "Tr"(a.data()), [B] "Tr"(b.data()), [Bias] "Tr"(bias.data()), \ [QuantGpr] "r"(quant_gpr), [LReluGpr] "r"(lrelu_gpr), PTO_FIXP_ATTR_INPUTS, PTO_MATMUL_COMMON_INPUTS(Dst, A, B, M, N, K), [DstSize] "i"(tile_type_traits::TilesizeCode), [RowSize] "i"(tile_type_traits::TilesizeCode), [GroupSize] "i"(tile_type_traits::TilesizeCode) \ : "memory") #define PTO_FIXP_BIAS_FOLD_SHARED_B(IOR) \ asm volatile(PTO_MATMUL_HEADER("TMATMUL.BIAS", PTO_FIXP_ATTR) \ - "B.IOS %S[SharedB].reuse, mask=1111\n" "B.IOT %[A].reuse, %[Bias].reuse, mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" PTO_FIXP_IOR_##IOR \ + "B.IOS %S[SharedB], mask=1111\n" "B.IOT %[A], %[Bias], mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" PTO_FIXP_IOR_##IOR \ : PTO_FIXP_OUT_DECL_0 \ : [A] "Tr"(a.data()), [SharedB] "Sr"(b.handle()), [Bias] "Tr"(bias.data()), \ [QuantGpr] "r"(quant_gpr), [LReluGpr] "r"(lrelu_gpr), PTO_FIXP_ATTR_INPUTS, PTO_MATMUL_COMMON_INPUTS(Dst, A, B, M, N, K), [DstSize] "i"(tile_type_traits::TilesizeCode), [RowSize] "i"(tile_type_traits::TilesizeCode), [GroupSize] "i"(tile_type_traits::TilesizeCode) \ : "memory") #define PTO_FIXP_BIAS_FOLD_SHARED_A(IOR) \ asm volatile(PTO_MATMUL_HEADER("TMATMUL.BIAS", PTO_FIXP_ATTR) \ - "B.IOS %S[SharedA].reuse, mask=1111\n" "B.IOT %[B].reuse, %[Bias].reuse, mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" PTO_FIXP_IOR_##IOR \ + "B.IOS %S[SharedA], mask=1111\n" "B.IOT %[B], %[Bias], mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" PTO_FIXP_IOR_##IOR \ : PTO_FIXP_OUT_DECL_0 \ : [SharedA] "Sr"(a.handle()), [B] "Tr"(b.data()), [Bias] "Tr"(bias.data()), \ [QuantGpr] "r"(quant_gpr), [LReluGpr] "r"(lrelu_gpr), PTO_FIXP_ATTR_INPUTS, PTO_MATMUL_COMMON_INPUTS(Dst, A, B, M, N, K), [DstSize] "i"(tile_type_traits::TilesizeCode), [RowSize] "i"(tile_type_traits::TilesizeCode), [GroupSize] "i"(tile_type_traits::TilesizeCode) \ : "memory") #define PTO_FIXP_BIAS_FOLD_SHARED_AB(IOR) \ asm volatile(PTO_MATMUL_HEADER("TMATMUL.BIAS", PTO_FIXP_ATTR) \ - "B.IOS %S[SharedA].reuse, mask=1111\n" "B.IOS %S[SharedB].reuse, mask=1111\n" "B.IOT %[Bias].reuse, mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" PTO_FIXP_IOR_##IOR \ + "B.IOS %S[SharedA], mask=1111\n" "B.IOS %S[SharedB], mask=1111\n" "B.IOT %[Bias], mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" PTO_FIXP_IOR_##IOR \ : PTO_FIXP_OUT_DECL_0 \ : [SharedA] "Sr"(a.handle()), [SharedB] "Sr"(b.handle()), [Bias] "Tr"(bias.data()), \ [QuantGpr] "r"(quant_gpr), [LReluGpr] "r"(lrelu_gpr), PTO_FIXP_ATTR_INPUTS, PTO_MATMUL_COMMON_INPUTS(Dst, A, B, M, N, K), [DstSize] "i"(tile_type_traits::TilesizeCode), [RowSize] "i"(tile_type_traits::TilesizeCode), [GroupSize] "i"(tile_type_traits::TilesizeCode) \ @@ -7306,8 +7306,8 @@ PTO_SHARED_INLINE void matmul_acc(Dst &dst, C &c, A &a, B &b, size_t M, #define PTO_FIXP_MX_FOLD_LOCAL(IOR) \ asm volatile( \ PTO_MATMUL_HEADER("TMATMULMX", PTO_FIXP_ATTR) \ - "B.IOT %[A].reuse, %[ScaleA].reuse, mask=1111\n" \ - "B.IOT %[B].reuse, %[ScaleB].reuse, mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" \ + "B.IOT %[A], %[ScaleA], mask=1111\n" \ + "B.IOT %[B], %[ScaleB], mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" \ PTO_FIXP_IOR_##IOR \ : PTO_FIXP_OUT_DECL_0 \ : [A] "Tr"(a.data()), [ScaleA] "Tr"(ascale.data()), [B] "Tr"(b.data()), [ScaleB] "Tr"(bscale.data()), PTO_MX_SCALE_INPUTS,\ @@ -7317,9 +7317,9 @@ PTO_SHARED_INLINE void matmul_acc(Dst &dst, C &c, A &a, B &b, size_t M, #define PTO_FIXP_MX_FOLD_SHARED_B(IOR) \ asm volatile( \ PTO_MATMUL_HEADER("TMATMULMX", PTO_FIXP_ATTR) \ - "B.IOS %S[SharedB].reuse, mask=1111\n" \ - "B.IOS %S[ScaleB].reuse, mask=1111\n" \ - "B.IOT %[A].reuse, %[ScaleA].reuse, mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" \ + "B.IOS %S[SharedB], mask=1111\n" \ + "B.IOS %S[ScaleB], mask=1111\n" \ + "B.IOT %[A], %[ScaleA], mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" \ PTO_FIXP_IOR_##IOR \ : PTO_FIXP_OUT_DECL_0 \ : [A] "Tr"(a.data()), [ScaleA] "Tr"(ascale.data()), [SharedB] "Sr"(b.handle()), [ScaleB] "Sr"(bscale.handle()), PTO_MX_SCALE_INPUTS,\ @@ -7329,9 +7329,9 @@ PTO_SHARED_INLINE void matmul_acc(Dst &dst, C &c, A &a, B &b, size_t M, #define PTO_FIXP_MX_FOLD_SHARED_A(IOR) \ asm volatile( \ PTO_MATMUL_HEADER("TMATMULMX", PTO_FIXP_ATTR) \ - "B.IOS %S[SharedA].reuse, mask=1111\n" \ - "B.IOS %S[ScaleA].reuse, mask=1111\n" \ - "B.IOT %[B].reuse, %[ScaleB].reuse, mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" \ + "B.IOS %S[SharedA], mask=1111\n" \ + "B.IOS %S[ScaleA], mask=1111\n" \ + "B.IOT %[B], %[ScaleB], mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" \ PTO_FIXP_IOR_##IOR \ : PTO_FIXP_OUT_DECL_0 \ : [SharedA] "Sr"(a.handle()), [ScaleA] "Sr"(ascale.handle()), [B] "Tr"(b.data()), [ScaleB] "Tr"(bscale.data()), PTO_MX_SCALE_INPUTS,\ @@ -7398,12 +7398,12 @@ PTO_SHARED_INLINE void matmul_acc(Dst &dst, C &c, A &a, B &b, size_t M, #define PTO_FIXP_MX_ACC_FOLD_LOCAL(IOR) \ asm volatile( \ PTO_MATMUL_HEADER("TMATMULMX.ACC", PTO_FIXP_ATTR) \ - "B.IOT %[C].reuse, %[A].reuse, mask=1111\n" \ - "B.IOT %[ScaleA].reuse, %[B].reuse, mask=1111\n" \ + "B.IOT %[C], %[A], mask=1111\n" \ + "B.IOT %[ScaleA], %[B], mask=1111\n" \ ".if %c[CScaleEn]\n" \ - "B.IOT %[ScaleB].reuse, %[CScaleOperand].reuse, mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" \ + "B.IOT %[ScaleB], %[CScaleOperand], mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" \ ".else\n" \ - "B.IOT %[ScaleB].reuse, mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" \ + "B.IOT %[ScaleB], mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" \ ".endif\n" \ PTO_FIXP_IOR_##IOR \ : PTO_FIXP_OUT_DECL_0 \ @@ -7414,13 +7414,13 @@ PTO_SHARED_INLINE void matmul_acc(Dst &dst, C &c, A &a, B &b, size_t M, #define PTO_FIXP_MX_ACC_FOLD_SHARED_B(IOR) \ asm volatile( \ PTO_MATMUL_HEADER("TMATMULMX.ACC", PTO_FIXP_ATTR) \ - "B.IOS %S[SharedB].reuse, mask=1111\n" \ - "B.IOS %S[ScaleB].reuse, mask=1111\n" \ - "B.IOT %[C].reuse, %[A].reuse, mask=1111\n" \ + "B.IOS %S[SharedB], mask=1111\n" \ + "B.IOS %S[ScaleB], mask=1111\n" \ + "B.IOT %[C], %[A], mask=1111\n" \ ".if %c[CScaleEn]\n" \ - "B.IOT %[ScaleA].reuse, %[CScaleOperand].reuse, mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" \ + "B.IOT %[ScaleA], %[CScaleOperand], mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" \ ".else\n" \ - "B.IOT %[ScaleA].reuse, mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" \ + "B.IOT %[ScaleA], mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" \ ".endif\n" \ PTO_FIXP_IOR_##IOR \ : PTO_FIXP_OUT_DECL_0 \ @@ -7431,13 +7431,13 @@ PTO_SHARED_INLINE void matmul_acc(Dst &dst, C &c, A &a, B &b, size_t M, #define PTO_FIXP_MX_ACC_FOLD_SHARED_A(IOR) \ asm volatile( \ PTO_MATMUL_HEADER("TMATMULMX.ACC", PTO_FIXP_ATTR) \ - "B.IOS %S[SharedA].reuse, mask=1111\n" \ - "B.IOS %S[ScaleA].reuse, mask=1111\n" \ - "B.IOT %[C].reuse, %[B].reuse, mask=1111\n" \ + "B.IOS %S[SharedA], mask=1111\n" \ + "B.IOS %S[ScaleA], mask=1111\n" \ + "B.IOT %[C], %[B], mask=1111\n" \ ".if %c[CScaleEn]\n" \ - "B.IOT %[ScaleB].reuse, %[CScaleOperand].reuse, mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" \ + "B.IOT %[ScaleB], %[CScaleOperand], mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" \ ".else\n" \ - "B.IOT %[ScaleB].reuse, mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" \ + "B.IOT %[ScaleB], mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" \ ".endif\n" \ PTO_FIXP_IOR_##IOR \ : PTO_FIXP_OUT_DECL_0 \ @@ -7448,14 +7448,14 @@ PTO_SHARED_INLINE void matmul_acc(Dst &dst, C &c, A &a, B &b, size_t M, #define PTO_FIXP_MX_ACC_FOLD_SHARED_AB(IOR) \ asm volatile( \ PTO_MATMUL_HEADER("TMATMULMX.ACC", PTO_FIXP_ATTR) \ - "B.IOS %S[SharedA].reuse, mask=1111\n" \ - "B.IOS %S[ScaleA].reuse, mask=1111\n" \ - "B.IOS %S[SharedB].reuse, mask=1111\n" \ - "B.IOS %S[ScaleB].reuse, mask=1111\n" \ + "B.IOS %S[SharedA], mask=1111\n" \ + "B.IOS %S[ScaleA], mask=1111\n" \ + "B.IOS %S[SharedB], mask=1111\n" \ + "B.IOS %S[ScaleB], mask=1111\n" \ ".if %c[CScaleEn]\n" \ - "B.IOT %[C].reuse, %[CScaleOperand].reuse, mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" \ + "B.IOT %[C], %[CScaleOperand], mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" \ ".else\n" \ - "B.IOT %[C].reuse, mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" \ + "B.IOT %[C], mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" \ ".endif\n" \ PTO_FIXP_IOR_##IOR \ : PTO_FIXP_OUT_DECL_0 \ @@ -7512,9 +7512,9 @@ PTO_SHARED_INLINE void matmul_acc(Dst &dst, C &c, A &a, B &b, size_t M, #define PTO_FIXP_MX_BIAS_FOLD_LOCAL(IOR) \ asm volatile( \ PTO_MATMUL_HEADER("TMATMULMX.BIAS", PTO_FIXP_ATTR) \ - "B.IOT %[A].reuse, %[ScaleA].reuse, mask=1111\n" \ - "B.IOT %[B].reuse, %[ScaleB].reuse, mask=1111\n" \ - "B.IOT %[Bias].reuse, mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" \ + "B.IOT %[A], %[ScaleA], mask=1111\n" \ + "B.IOT %[B], %[ScaleB], mask=1111\n" \ + "B.IOT %[Bias], mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" \ PTO_FIXP_IOR_##IOR \ : PTO_FIXP_OUT_DECL_0 \ : [A] "Tr"(a.data()), [ScaleA] "Tr"(ascale.data()), [B] "Tr"(b.data()), [ScaleB] "Tr"(bscale.data()), PTO_MX_SCALE_INPUTS, [Bias] "Tr"(bias.data()),\ @@ -7524,10 +7524,10 @@ PTO_SHARED_INLINE void matmul_acc(Dst &dst, C &c, A &a, B &b, size_t M, #define PTO_FIXP_MX_BIAS_FOLD_SHARED_B(IOR) \ asm volatile( \ PTO_MATMUL_HEADER("TMATMULMX.BIAS", PTO_FIXP_ATTR) \ - "B.IOS %S[SharedB].reuse, mask=1111\n" \ - "B.IOS %S[ScaleB].reuse, mask=1111\n" \ - "B.IOT %[A].reuse, %[ScaleA].reuse, mask=1111\n" \ - "B.IOT %[Bias].reuse, mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" \ + "B.IOS %S[SharedB], mask=1111\n" \ + "B.IOS %S[ScaleB], mask=1111\n" \ + "B.IOT %[A], %[ScaleA], mask=1111\n" \ + "B.IOT %[Bias], mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" \ PTO_FIXP_IOR_##IOR \ : PTO_FIXP_OUT_DECL_0 \ : [A] "Tr"(a.data()), [ScaleA] "Tr"(ascale.data()), [SharedB] "Sr"(b.handle()), [ScaleB] "Sr"(bscale.handle()), PTO_MX_SCALE_INPUTS, [Bias] "Tr"(bias.data()),\ @@ -7537,10 +7537,10 @@ PTO_SHARED_INLINE void matmul_acc(Dst &dst, C &c, A &a, B &b, size_t M, #define PTO_FIXP_MX_BIAS_FOLD_SHARED_A(IOR) \ asm volatile( \ PTO_MATMUL_HEADER("TMATMULMX.BIAS", PTO_FIXP_ATTR) \ - "B.IOS %S[SharedA].reuse, mask=1111\n" \ - "B.IOS %S[ScaleA].reuse, mask=1111\n" \ - "B.IOT %[B].reuse, %[ScaleB].reuse, mask=1111\n" \ - "B.IOT %[Bias].reuse, mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" \ + "B.IOS %S[SharedA], mask=1111\n" \ + "B.IOS %S[ScaleA], mask=1111\n" \ + "B.IOT %[B], %[ScaleB], mask=1111\n" \ + "B.IOT %[Bias], mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" \ PTO_FIXP_IOR_##IOR \ : PTO_FIXP_OUT_DECL_0 \ : [SharedA] "Sr"(a.handle()), [ScaleA] "Sr"(ascale.handle()), [B] "Tr"(b.data()), [ScaleB] "Tr"(bscale.data()), PTO_MX_SCALE_INPUTS, [Bias] "Tr"(bias.data()),\ @@ -7550,11 +7550,11 @@ PTO_SHARED_INLINE void matmul_acc(Dst &dst, C &c, A &a, B &b, size_t M, #define PTO_FIXP_MX_BIAS_FOLD_SHARED_AB(IOR) \ asm volatile( \ PTO_MATMUL_HEADER("TMATMULMX.BIAS", PTO_FIXP_ATTR) \ - "B.IOS %S[SharedA].reuse, mask=1111\n" \ - "B.IOS %S[ScaleA].reuse, mask=1111\n" \ - "B.IOS %S[SharedB].reuse, mask=1111\n" \ - "B.IOS %S[ScaleB].reuse, mask=1111\n" \ - "B.IOT %[Bias].reuse, mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" \ + "B.IOS %S[SharedA], mask=1111\n" \ + "B.IOS %S[ScaleA], mask=1111\n" \ + "B.IOS %S[SharedB], mask=1111\n" \ + "B.IOS %S[ScaleB], mask=1111\n" \ + "B.IOT %[Bias], mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" \ PTO_FIXP_IOR_##IOR \ : PTO_FIXP_OUT_DECL_0 \ : [SharedA] "Sr"(a.handle()), [ScaleA] "Sr"(ascale.handle()), [SharedB] "Sr"(b.handle()), [ScaleB] "Sr"(bscale.handle()), PTO_MX_SCALE_INPUTS, [Bias] "Tr"(bias.data()),\ @@ -7564,30 +7564,30 @@ PTO_SHARED_INLINE void matmul_acc(Dst &dst, C &c, A &a, B &b, size_t M, // Optional MX scale paths must omit absent operands from the LLVM IR inline- // asm constraint list. These fragments describe exactly the architectural // source stream for ScaleMask 0/1/2; ScaleMask 3 uses the established emitters. -#define PTO_MX_L_SRC_0 "B.IOT %[A].reuse, %[B].reuse, mask=1111\n" -#define PTO_MX_L_SRC_1 "B.IOT %[A].reuse, %[ScaleA].reuse, mask=1111\n" "B.IOT %[B].reuse, mask=1111\n" -#define PTO_MX_L_SRC_2 "B.IOT %[A].reuse, mask=1111\n" "B.IOT %[B].reuse, %[ScaleB].reuse, mask=1111\n" +#define PTO_MX_L_SRC_0 "B.IOT %[A], %[B], mask=1111\n" +#define PTO_MX_L_SRC_1 "B.IOT %[A], %[ScaleA], mask=1111\n" "B.IOT %[B], mask=1111\n" +#define PTO_MX_L_SRC_2 "B.IOT %[A], mask=1111\n" "B.IOT %[B], %[ScaleB], mask=1111\n" #define PTO_MX_L_INPUTS_0 [A] "Tr"(a.data()), [B] "Tr"(b.data()) #define PTO_MX_L_INPUTS_1 [A] "Tr"(a.data()), [ScaleA] "Tr"(ascale.data()), [B] "Tr"(b.data()) #define PTO_MX_L_INPUTS_2 [A] "Tr"(a.data()), [B] "Tr"(b.data()), [ScaleB] "Tr"(bscale.data()) -#define PTO_MX_SB_SRC_0 "B.IOS %S[SharedB].reuse, mask=1111\n" "B.IOT %[A].reuse, mask=1111\n" -#define PTO_MX_SB_SRC_1 "B.IOS %S[SharedB].reuse, mask=1111\n" "B.IOT %[A].reuse, %[ScaleA].reuse, mask=1111\n" -#define PTO_MX_SB_SRC_2 "B.IOS %S[SharedB].reuse, mask=1111\n" "B.IOS %S[ScaleB].reuse, mask=1111\n" "B.IOT %[A].reuse, mask=1111\n" +#define PTO_MX_SB_SRC_0 "B.IOS %S[SharedB], mask=1111\n" "B.IOT %[A], mask=1111\n" +#define PTO_MX_SB_SRC_1 "B.IOS %S[SharedB], mask=1111\n" "B.IOT %[A], %[ScaleA], mask=1111\n" +#define PTO_MX_SB_SRC_2 "B.IOS %S[SharedB], mask=1111\n" "B.IOS %S[ScaleB], mask=1111\n" "B.IOT %[A], mask=1111\n" #define PTO_MX_SB_INPUTS_0 [A] "Tr"(a.data()), [SharedB] "Sr"(b.handle()) #define PTO_MX_SB_INPUTS_1 [A] "Tr"(a.data()), [ScaleA] "Tr"(ascale.data()), [SharedB] "Sr"(b.handle()) #define PTO_MX_SB_INPUTS_2 [A] "Tr"(a.data()), [SharedB] "Sr"(b.handle()), [ScaleB] "Sr"(bscale.handle()) -#define PTO_MX_SA_SRC_0 "B.IOS %S[SharedA].reuse, mask=1111\n" "B.IOT %[B].reuse, mask=1111\n" -#define PTO_MX_SA_SRC_1 "B.IOS %S[SharedA].reuse, mask=1111\n" "B.IOS %S[ScaleA].reuse, mask=1111\n" "B.IOT %[B].reuse, mask=1111\n" -#define PTO_MX_SA_SRC_2 "B.IOS %S[SharedA].reuse, mask=1111\n" "B.IOT %[B].reuse, %[ScaleB].reuse, mask=1111\n" +#define PTO_MX_SA_SRC_0 "B.IOS %S[SharedA], mask=1111\n" "B.IOT %[B], mask=1111\n" +#define PTO_MX_SA_SRC_1 "B.IOS %S[SharedA], mask=1111\n" "B.IOS %S[ScaleA], mask=1111\n" "B.IOT %[B], mask=1111\n" +#define PTO_MX_SA_SRC_2 "B.IOS %S[SharedA], mask=1111\n" "B.IOT %[B], %[ScaleB], mask=1111\n" #define PTO_MX_SA_INPUTS_0 [SharedA] "Sr"(a.handle()), [B] "Tr"(b.data()) #define PTO_MX_SA_INPUTS_1 [SharedA] "Sr"(a.handle()), [ScaleA] "Sr"(ascale.handle()), [B] "Tr"(b.data()) #define PTO_MX_SA_INPUTS_2 [SharedA] "Sr"(a.handle()), [B] "Tr"(b.data()), [ScaleB] "Tr"(bscale.data()) -#define PTO_MX_SAB_SRC_0 "B.IOS %S[SharedA].reuse, mask=1111\n" "B.IOS %S[SharedB].reuse, mask=1111\n" -#define PTO_MX_SAB_SRC_1 "B.IOS %S[SharedA].reuse, mask=1111\n" "B.IOS %S[ScaleA].reuse, mask=1111\n" "B.IOS %S[SharedB].reuse, mask=1111\n" -#define PTO_MX_SAB_SRC_2 "B.IOS %S[SharedA].reuse, mask=1111\n" "B.IOS %S[SharedB].reuse, mask=1111\n" "B.IOS %S[ScaleB].reuse, mask=1111\n" +#define PTO_MX_SAB_SRC_0 "B.IOS %S[SharedA], mask=1111\n" "B.IOS %S[SharedB], mask=1111\n" +#define PTO_MX_SAB_SRC_1 "B.IOS %S[SharedA], mask=1111\n" "B.IOS %S[ScaleA], mask=1111\n" "B.IOS %S[SharedB], mask=1111\n" +#define PTO_MX_SAB_SRC_2 "B.IOS %S[SharedA], mask=1111\n" "B.IOS %S[SharedB], mask=1111\n" "B.IOS %S[ScaleB], mask=1111\n" #define PTO_MX_SAB_INPUTS_0 [SharedA] "Sr"(a.handle()), [SharedB] "Sr"(b.handle()) #define PTO_MX_SAB_INPUTS_1 [SharedA] "Sr"(a.handle()), [ScaleA] "Sr"(ascale.handle()), [SharedB] "Sr"(b.handle()) #define PTO_MX_SAB_INPUTS_2 [SharedA] "Sr"(a.handle()), [SharedB] "Sr"(b.handle()), [ScaleB] "Sr"(bscale.handle()) @@ -7611,36 +7611,36 @@ PTO_SHARED_INLINE void matmul_acc(Dst &dst, C &c, A &a, B &b, size_t M, #define PTO_MX_ACC_CSCALE \ ".if %c[CScaleEn]\n" \ - "B.IOT %[CScaleOperand].reuse, mask=1111\n" \ + "B.IOT %[CScaleOperand], mask=1111\n" \ ".endif\n" // Optional-scale ACC source streams. Shared operands are emitted first; the // remaining Local stream starts with C and is packed continuously through the // optional CScale/PostProcess tail. -#define PTO_MX_ACC_L_PREFIX_0 "B.IOT %[C].reuse, %[A].reuse, mask=1111\n" -#define PTO_MX_ACC_L_PREFIX_1 "B.IOT %[C].reuse, %[A].reuse, mask=1111\n" "B.IOT %[ScaleA].reuse, %[B].reuse, mask=1111\n" -#define PTO_MX_ACC_L_PREFIX_2 "B.IOT %[C].reuse, %[A].reuse, mask=1111\n" "B.IOT %[B].reuse, %[ScaleB].reuse, mask=1111\n" +#define PTO_MX_ACC_L_PREFIX_0 "B.IOT %[C], %[A], mask=1111\n" +#define PTO_MX_ACC_L_PREFIX_1 "B.IOT %[C], %[A], mask=1111\n" "B.IOT %[ScaleA], %[B], mask=1111\n" +#define PTO_MX_ACC_L_PREFIX_2 "B.IOT %[C], %[A], mask=1111\n" "B.IOT %[B], %[ScaleB], mask=1111\n" #define PTO_MX_ACC_L_TAIL_0(SRC) PTO_FIXP_ACC_EVEN_TAIL_##SRC #define PTO_MX_ACC_L_TAIL_1(SRC) PTO_FIXP_ACC_EVEN_TAIL_##SRC #define PTO_MX_ACC_L_TAIL_2(SRC) PTO_FIXP_ACC_EVEN_TAIL_##SRC -#define PTO_MX_ACC_SB_PREFIX_0 "B.IOS %S[SharedB].reuse, mask=1111\n" "B.IOT %[C].reuse, %[A].reuse, mask=1111\n" -#define PTO_MX_ACC_SB_PREFIX_1 "B.IOS %S[SharedB].reuse, mask=1111\n" "B.IOT %[C].reuse, %[A].reuse, mask=1111\n" -#define PTO_MX_ACC_SB_PREFIX_2 "B.IOS %S[SharedB].reuse, mask=1111\n" "B.IOS %S[ScaleB].reuse, mask=1111\n" "B.IOT %[C].reuse, %[A].reuse, mask=1111\n" +#define PTO_MX_ACC_SB_PREFIX_0 "B.IOS %S[SharedB], mask=1111\n" "B.IOT %[C], %[A], mask=1111\n" +#define PTO_MX_ACC_SB_PREFIX_1 "B.IOS %S[SharedB], mask=1111\n" "B.IOT %[C], %[A], mask=1111\n" +#define PTO_MX_ACC_SB_PREFIX_2 "B.IOS %S[SharedB], mask=1111\n" "B.IOS %S[ScaleB], mask=1111\n" "B.IOT %[C], %[A], mask=1111\n" #define PTO_MX_ACC_SB_TAIL_0(SRC) PTO_FIXP_ACC_EVEN_TAIL_##SRC #define PTO_MX_ACC_SB_TAIL_1(SRC) PTO_FIXP_ACC_ODD_TAIL_##SRC("%[ScaleA]") #define PTO_MX_ACC_SB_TAIL_2(SRC) PTO_FIXP_ACC_EVEN_TAIL_##SRC -#define PTO_MX_ACC_SA_PREFIX_0 "B.IOS %S[SharedA].reuse, mask=1111\n" "B.IOT %[C].reuse, %[B].reuse, mask=1111\n" -#define PTO_MX_ACC_SA_PREFIX_1 "B.IOS %S[SharedA].reuse, mask=1111\n" "B.IOS %S[ScaleA].reuse, mask=1111\n" "B.IOT %[C].reuse, %[B].reuse, mask=1111\n" -#define PTO_MX_ACC_SA_PREFIX_2 "B.IOS %S[SharedA].reuse, mask=1111\n" "B.IOT %[C].reuse, %[B].reuse, mask=1111\n" +#define PTO_MX_ACC_SA_PREFIX_0 "B.IOS %S[SharedA], mask=1111\n" "B.IOT %[C], %[B], mask=1111\n" +#define PTO_MX_ACC_SA_PREFIX_1 "B.IOS %S[SharedA], mask=1111\n" "B.IOS %S[ScaleA], mask=1111\n" "B.IOT %[C], %[B], mask=1111\n" +#define PTO_MX_ACC_SA_PREFIX_2 "B.IOS %S[SharedA], mask=1111\n" "B.IOT %[C], %[B], mask=1111\n" #define PTO_MX_ACC_SA_TAIL_0(SRC) PTO_FIXP_ACC_EVEN_TAIL_##SRC #define PTO_MX_ACC_SA_TAIL_1(SRC) PTO_FIXP_ACC_EVEN_TAIL_##SRC #define PTO_MX_ACC_SA_TAIL_2(SRC) PTO_FIXP_ACC_ODD_TAIL_##SRC("%[ScaleB]") -#define PTO_MX_ACC_SAB_PREFIX_0 "B.IOS %S[SharedA].reuse, mask=1111\n" "B.IOS %S[SharedB].reuse, mask=1111\n" -#define PTO_MX_ACC_SAB_PREFIX_1 "B.IOS %S[SharedA].reuse, mask=1111\n" "B.IOS %S[ScaleA].reuse, mask=1111\n" "B.IOS %S[SharedB].reuse, mask=1111\n" -#define PTO_MX_ACC_SAB_PREFIX_2 "B.IOS %S[SharedA].reuse, mask=1111\n" "B.IOS %S[SharedB].reuse, mask=1111\n" "B.IOS %S[ScaleB].reuse, mask=1111\n" +#define PTO_MX_ACC_SAB_PREFIX_0 "B.IOS %S[SharedA], mask=1111\n" "B.IOS %S[SharedB], mask=1111\n" +#define PTO_MX_ACC_SAB_PREFIX_1 "B.IOS %S[SharedA], mask=1111\n" "B.IOS %S[ScaleA], mask=1111\n" "B.IOS %S[SharedB], mask=1111\n" +#define PTO_MX_ACC_SAB_PREFIX_2 "B.IOS %S[SharedA], mask=1111\n" "B.IOS %S[SharedB], mask=1111\n" "B.IOS %S[ScaleB], mask=1111\n" #define PTO_MX_ACC_SAB_TAIL_0(SRC) PTO_FIXP_ACC_ODD_TAIL_##SRC("%[C]") #define PTO_MX_ACC_SAB_TAIL_1(SRC) PTO_FIXP_ACC_ODD_TAIL_##SRC("%[C]") #define PTO_MX_ACC_SAB_TAIL_2(SRC) PTO_FIXP_ACC_ODD_TAIL_##SRC("%[C]") @@ -7668,10 +7668,10 @@ PTO_SHARED_INLINE void matmul_acc(Dst &dst, C &c, A &a, B &b, size_t M, #define PTO_MX_OPT_ACC_SB(M,S,O,I) PTO_MX_ACC_OPTIONAL_EMIT(M,S,O,I,SB) #define PTO_MX_OPT_ACC_SA(M,S,O,I) PTO_MX_ACC_OPTIONAL_EMIT(M,S,O,I,SA) #define PTO_MX_OPT_ACC_SAB(M,S,O,I) PTO_MX_ACC_OPTIONAL_EMIT(M,S,O,I,SAB) -#define PTO_MX_OPT_BIAS_L(M,S,O,I) PTO_MX_OPTIONAL_EMIT("TMATMULMX.BIAS",L,"","B.IOT %[Bias].reuse, mask=1111\n",BIAS,M,S,O,I) -#define PTO_MX_OPT_BIAS_SB(M,S,O,I) PTO_MX_OPTIONAL_EMIT("TMATMULMX.BIAS",SB,"","B.IOT %[Bias].reuse, mask=1111\n",BIAS,M,S,O,I) -#define PTO_MX_OPT_BIAS_SA(M,S,O,I) PTO_MX_OPTIONAL_EMIT("TMATMULMX.BIAS",SA,"","B.IOT %[Bias].reuse, mask=1111\n",BIAS,M,S,O,I) -#define PTO_MX_OPT_BIAS_SAB(M,S,O,I) PTO_MX_OPTIONAL_EMIT("TMATMULMX.BIAS",SAB,"","B.IOT %[Bias].reuse, mask=1111\n",BIAS,M,S,O,I) +#define PTO_MX_OPT_BIAS_L(M,S,O,I) PTO_MX_OPTIONAL_EMIT("TMATMULMX.BIAS",L,"","B.IOT %[Bias], mask=1111\n",BIAS,M,S,O,I) +#define PTO_MX_OPT_BIAS_SB(M,S,O,I) PTO_MX_OPTIONAL_EMIT("TMATMULMX.BIAS",SB,"","B.IOT %[Bias], mask=1111\n",BIAS,M,S,O,I) +#define PTO_MX_OPT_BIAS_SA(M,S,O,I) PTO_MX_OPTIONAL_EMIT("TMATMULMX.BIAS",SA,"","B.IOT %[Bias], mask=1111\n",BIAS,M,S,O,I) +#define PTO_MX_OPT_BIAS_SAB(M,S,O,I) PTO_MX_OPTIONAL_EMIT("TMATMULMX.BIAS",SAB,"","B.IOT %[Bias], mask=1111\n",BIAS,M,S,O,I) #define PTO_MX_OPT_PLAIN_L_0(S,O,I) PTO_MX_OPT_PLAIN_L(0,S,O,I) #define PTO_MX_OPT_PLAIN_L_1(S,O,I) PTO_MX_OPT_PLAIN_L(1,S,O,I) #define PTO_MX_OPT_PLAIN_L_2(S,O,I) PTO_MX_OPT_PLAIN_L(2,S,O,I) @@ -7721,15 +7721,15 @@ PTO_SHARED_INLINE void matmul_acc(Dst &dst, C &c, A &a, B &b, size_t M, // destination (+ last) folded onto their final Local B.IOT, removing that // extra binder. SAB has no Local source, so its "fold" keeps the sourceless // dest (no change) -- kept here only so the dispatch is uniform across storage. -#define PTO_MXF_L_SRC_0 "B.IOT %[A].reuse, %[B].reuse, mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" -#define PTO_MXF_L_SRC_1 "B.IOT %[A].reuse, %[ScaleA].reuse, mask=1111\n" "B.IOT %[B].reuse, mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" -#define PTO_MXF_L_SRC_2 "B.IOT %[A].reuse, mask=1111\n" "B.IOT %[B].reuse, %[ScaleB].reuse, mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" -#define PTO_MXF_SB_SRC_0 "B.IOS %S[SharedB].reuse, mask=1111\n" "B.IOT %[A].reuse, mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" -#define PTO_MXF_SB_SRC_1 "B.IOS %S[SharedB].reuse, mask=1111\n" "B.IOT %[A].reuse, %[ScaleA].reuse, mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" -#define PTO_MXF_SB_SRC_2 "B.IOS %S[SharedB].reuse, mask=1111\n" "B.IOS %S[ScaleB].reuse, mask=1111\n" "B.IOT %[A].reuse, mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" -#define PTO_MXF_SA_SRC_0 "B.IOS %S[SharedA].reuse, mask=1111\n" "B.IOT %[B].reuse, mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" -#define PTO_MXF_SA_SRC_1 "B.IOS %S[SharedA].reuse, mask=1111\n" "B.IOS %S[ScaleA].reuse, mask=1111\n" "B.IOT %[B].reuse, mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" -#define PTO_MXF_SA_SRC_2 "B.IOS %S[SharedA].reuse, mask=1111\n" "B.IOT %[B].reuse, %[ScaleB].reuse, mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" +#define PTO_MXF_L_SRC_0 "B.IOT %[A], %[B], mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" +#define PTO_MXF_L_SRC_1 "B.IOT %[A], %[ScaleA], mask=1111\n" "B.IOT %[B], mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" +#define PTO_MXF_L_SRC_2 "B.IOT %[A], mask=1111\n" "B.IOT %[B], %[ScaleB], mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" +#define PTO_MXF_SB_SRC_0 "B.IOS %S[SharedB], mask=1111\n" "B.IOT %[A], mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" +#define PTO_MXF_SB_SRC_1 "B.IOS %S[SharedB], mask=1111\n" "B.IOT %[A], %[ScaleA], mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" +#define PTO_MXF_SB_SRC_2 "B.IOS %S[SharedB], mask=1111\n" "B.IOS %S[ScaleB], mask=1111\n" "B.IOT %[A], mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" +#define PTO_MXF_SA_SRC_0 "B.IOS %S[SharedA], mask=1111\n" "B.IOT %[B], mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" +#define PTO_MXF_SA_SRC_1 "B.IOS %S[SharedA], mask=1111\n" "B.IOS %S[ScaleA], mask=1111\n" "B.IOT %[B], mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" +#define PTO_MXF_SA_SRC_2 "B.IOS %S[SharedA], mask=1111\n" "B.IOT %[B], %[ScaleB], mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" #define PTO_MXF_SAB_SRC_0 PTO_MX_SAB_SRC_0 "B.IOT mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" #define PTO_MXF_SAB_SRC_1 PTO_MX_SAB_SRC_1 "B.IOT mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" #define PTO_MXF_SAB_SRC_2 PTO_MX_SAB_SRC_2 "B.IOT mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" @@ -7751,7 +7751,7 @@ PTO_SHARED_INLINE void matmul_acc(Dst &dst, C &c, A &a, B &b, size_t M, #define PTO_MX_FOLD_BIAS(STORAGE, MASK, IOR) \ asm volatile(PTO_MATMUL_HEADER("TMATMULMX.BIAS", PTO_FIXP_ATTR) \ PTO_MX_##STORAGE##_SRC_##MASK \ - "B.IOT %[Bias].reuse, mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" PTO_FIXP_IOR_##IOR \ + "B.IOT %[Bias], mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" PTO_FIXP_IOR_##IOR \ : PTO_FIXP_OUT_DECL_0 \ : [Bias] "Tr"(bias.data()), PTO_MX_##STORAGE##_INPUTS_##MASK, \ [QuantGpr] "r"(quant_gpr), [LReluGpr] "r"(lrelu_gpr), PTO_FIXP_ATTR_INPUTS, \ @@ -7767,47 +7767,47 @@ PTO_SHARED_INLINE void matmul_acc(Dst &dst, C &c, A &a, B &b, size_t M, #define PTO_MX_ACCF_IOS_L_0 #define PTO_MX_ACCF_IOS_L_1 #define PTO_MX_ACCF_IOS_L_2 -#define PTO_MX_ACCF_IOS_SB_0 "B.IOS %S[SharedB].reuse, mask=1111\n" -#define PTO_MX_ACCF_IOS_SB_1 "B.IOS %S[SharedB].reuse, mask=1111\n" -#define PTO_MX_ACCF_IOS_SB_2 "B.IOS %S[SharedB].reuse, mask=1111\n" "B.IOS %S[ScaleB].reuse, mask=1111\n" -#define PTO_MX_ACCF_IOS_SA_0 "B.IOS %S[SharedA].reuse, mask=1111\n" -#define PTO_MX_ACCF_IOS_SA_1 "B.IOS %S[SharedA].reuse, mask=1111\n" "B.IOS %S[ScaleA].reuse, mask=1111\n" -#define PTO_MX_ACCF_IOS_SA_2 "B.IOS %S[SharedA].reuse, mask=1111\n" -#define PTO_MX_ACCF_IOS_SAB_0 "B.IOS %S[SharedA].reuse, mask=1111\n" "B.IOS %S[SharedB].reuse, mask=1111\n" -#define PTO_MX_ACCF_IOS_SAB_1 "B.IOS %S[SharedA].reuse, mask=1111\n" "B.IOS %S[ScaleA].reuse, mask=1111\n" "B.IOS %S[SharedB].reuse, mask=1111\n" -#define PTO_MX_ACCF_IOS_SAB_2 "B.IOS %S[SharedA].reuse, mask=1111\n" "B.IOS %S[SharedB].reuse, mask=1111\n" "B.IOS %S[ScaleB].reuse, mask=1111\n" +#define PTO_MX_ACCF_IOS_SB_0 "B.IOS %S[SharedB], mask=1111\n" +#define PTO_MX_ACCF_IOS_SB_1 "B.IOS %S[SharedB], mask=1111\n" +#define PTO_MX_ACCF_IOS_SB_2 "B.IOS %S[SharedB], mask=1111\n" "B.IOS %S[ScaleB], mask=1111\n" +#define PTO_MX_ACCF_IOS_SA_0 "B.IOS %S[SharedA], mask=1111\n" +#define PTO_MX_ACCF_IOS_SA_1 "B.IOS %S[SharedA], mask=1111\n" "B.IOS %S[ScaleA], mask=1111\n" +#define PTO_MX_ACCF_IOS_SA_2 "B.IOS %S[SharedA], mask=1111\n" +#define PTO_MX_ACCF_IOS_SAB_0 "B.IOS %S[SharedA], mask=1111\n" "B.IOS %S[SharedB], mask=1111\n" +#define PTO_MX_ACCF_IOS_SAB_1 "B.IOS %S[SharedA], mask=1111\n" "B.IOS %S[ScaleA], mask=1111\n" "B.IOS %S[SharedB], mask=1111\n" +#define PTO_MX_ACCF_IOS_SAB_2 "B.IOS %S[SharedA], mask=1111\n" "B.IOS %S[SharedB], mask=1111\n" "B.IOS %S[ScaleB], mask=1111\n" #define PTO_MX_ACCF_LOCAL_L_0 \ - "B.IOT %[C].reuse, %[A].reuse, mask=1111\n" \ - ".if %c[CScaleEn]\n" "B.IOT %[B].reuse, %[CScaleOperand].reuse, mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" \ - ".else\n" "B.IOT %[B].reuse, mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" ".endif\n" + "B.IOT %[C], %[A], mask=1111\n" \ + ".if %c[CScaleEn]\n" "B.IOT %[B], %[CScaleOperand], mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" \ + ".else\n" "B.IOT %[B], mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" ".endif\n" #define PTO_MX_ACCF_LOCAL_L_1 \ - "B.IOT %[C].reuse, %[A].reuse, mask=1111\n" \ - ".if %c[CScaleEn]\n" "B.IOT %[ScaleA].reuse, %[B].reuse, mask=1111\n" "B.IOT %[CScaleOperand].reuse, mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" \ - ".else\n" "B.IOT %[ScaleA].reuse, %[B].reuse, mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" ".endif\n" + "B.IOT %[C], %[A], mask=1111\n" \ + ".if %c[CScaleEn]\n" "B.IOT %[ScaleA], %[B], mask=1111\n" "B.IOT %[CScaleOperand], mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" \ + ".else\n" "B.IOT %[ScaleA], %[B], mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" ".endif\n" #define PTO_MX_ACCF_LOCAL_L_2 \ - "B.IOT %[C].reuse, %[A].reuse, mask=1111\n" \ - ".if %c[CScaleEn]\n" "B.IOT %[B].reuse, %[ScaleB].reuse, mask=1111\n" "B.IOT %[CScaleOperand].reuse, mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" \ - ".else\n" "B.IOT %[B].reuse, %[ScaleB].reuse, mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" ".endif\n" + "B.IOT %[C], %[A], mask=1111\n" \ + ".if %c[CScaleEn]\n" "B.IOT %[B], %[ScaleB], mask=1111\n" "B.IOT %[CScaleOperand], mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" \ + ".else\n" "B.IOT %[B], %[ScaleB], mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" ".endif\n" #define PTO_MX_ACCF_LOCAL_SB_0 \ - ".if %c[CScaleEn]\n" "B.IOT %[C].reuse, %[A].reuse, mask=1111\n" "B.IOT %[CScaleOperand].reuse, mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" \ - ".else\n" "B.IOT %[C].reuse, %[A].reuse, mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" ".endif\n" + ".if %c[CScaleEn]\n" "B.IOT %[C], %[A], mask=1111\n" "B.IOT %[CScaleOperand], mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" \ + ".else\n" "B.IOT %[C], %[A], mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" ".endif\n" #define PTO_MX_ACCF_LOCAL_SB_1 \ - "B.IOT %[C].reuse, %[A].reuse, mask=1111\n" \ - ".if %c[CScaleEn]\n" "B.IOT %[ScaleA].reuse, %[CScaleOperand].reuse, mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" \ - ".else\n" "B.IOT %[ScaleA].reuse, mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" ".endif\n" + "B.IOT %[C], %[A], mask=1111\n" \ + ".if %c[CScaleEn]\n" "B.IOT %[ScaleA], %[CScaleOperand], mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" \ + ".else\n" "B.IOT %[ScaleA], mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" ".endif\n" #define PTO_MX_ACCF_LOCAL_SB_2 PTO_MX_ACCF_LOCAL_SB_0 #define PTO_MX_ACCF_LOCAL_SA_0 \ - ".if %c[CScaleEn]\n" "B.IOT %[C].reuse, %[B].reuse, mask=1111\n" "B.IOT %[CScaleOperand].reuse, mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" \ - ".else\n" "B.IOT %[C].reuse, %[B].reuse, mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" ".endif\n" + ".if %c[CScaleEn]\n" "B.IOT %[C], %[B], mask=1111\n" "B.IOT %[CScaleOperand], mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" \ + ".else\n" "B.IOT %[C], %[B], mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" ".endif\n" #define PTO_MX_ACCF_LOCAL_SA_1 PTO_MX_ACCF_LOCAL_SA_0 #define PTO_MX_ACCF_LOCAL_SA_2 \ - "B.IOT %[C].reuse, %[B].reuse, mask=1111\n" \ - ".if %c[CScaleEn]\n" "B.IOT %[ScaleB].reuse, %[CScaleOperand].reuse, mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" \ - ".else\n" "B.IOT %[ScaleB].reuse, mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" ".endif\n" + "B.IOT %[C], %[B], mask=1111\n" \ + ".if %c[CScaleEn]\n" "B.IOT %[ScaleB], %[CScaleOperand], mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" \ + ".else\n" "B.IOT %[ScaleB], mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" ".endif\n" #define PTO_MX_ACCF_LOCAL_SAB_0 \ - ".if %c[CScaleEn]\n" "B.IOT %[C].reuse, %[CScaleOperand].reuse, mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" \ - ".else\n" "B.IOT %[C].reuse, mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" ".endif\n" + ".if %c[CScaleEn]\n" "B.IOT %[C], %[CScaleOperand], mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" \ + ".else\n" "B.IOT %[C], mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" ".endif\n" #define PTO_MX_ACCF_LOCAL_SAB_1 PTO_MX_ACCF_LOCAL_SAB_0 #define PTO_MX_ACCF_LOCAL_SAB_2 PTO_MX_ACCF_LOCAL_SAB_0 @@ -7837,9 +7837,9 @@ PTO_SHARED_INLINE void matmul_acc(Dst &dst, C &c, A &a, B &b, size_t M, else if constexpr (ScaleMask == 1) { PTO_MX_DISPATCH_FOLD_I(OP, STORAGE, 1); } \ else { PTO_MX_DISPATCH_FOLD_I(OP, STORAGE, 2); } -#define PTO_GV_MX_SRC_0 "B.IOT %[Vec].reuse, %[Mtx].reuse, mask=1111\n" -#define PTO_GV_MX_SRC_1 "B.IOT %[Vec].reuse, %[ScaleVec].reuse, mask=1111\n" "B.IOT %[Mtx].reuse, mask=1111\n" -#define PTO_GV_MX_SRC_2 "B.IOT %[Vec].reuse, mask=1111\n" "B.IOT %[Mtx].reuse, %[ScaleMtx].reuse, mask=1111\n" +#define PTO_GV_MX_SRC_0 "B.IOT %[Vec], %[Mtx], mask=1111\n" +#define PTO_GV_MX_SRC_1 "B.IOT %[Vec], %[ScaleVec], mask=1111\n" "B.IOT %[Mtx], mask=1111\n" +#define PTO_GV_MX_SRC_2 "B.IOT %[Vec], mask=1111\n" "B.IOT %[Mtx], %[ScaleMtx], mask=1111\n" #define PTO_GV_MX_INPUTS_0 [Vec] "Tr"(vec.data()), [Mtx] "Tr"(mtx.data()) #define PTO_GV_MX_INPUTS_1 [Vec] "Tr"(vec.data()), [ScaleVec] "Tr"(svec.data()), [Mtx] "Tr"(mtx.data()) #define PTO_GV_MX_INPUTS_2 [Vec] "Tr"(vec.data()), [Mtx] "Tr"(mtx.data()), [ScaleMtx] "Tr"(smtx.data()) @@ -7847,9 +7847,9 @@ PTO_SHARED_INLINE void matmul_acc(Dst &dst, C &c, A &a, B &b, size_t M, // TGEMVMX ScaleMask 0/1/2 dest-fold (SrcMask==0, OutMask==0). The optional // source macros already pack each Local scale with its primary; these fold D // onto the final Local B.IOT and drop the sourceless dest binder. -#define PTO_GVF_MX_SRC_0 "B.IOT %[Vec].reuse, %[Mtx].reuse, mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" -#define PTO_GVF_MX_SRC_1 "B.IOT %[Vec].reuse, %[ScaleVec].reuse, mask=1111\n" "B.IOT %[Mtx].reuse, mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" -#define PTO_GVF_MX_SRC_2 "B.IOT %[Vec].reuse, mask=1111\n" "B.IOT %[Mtx].reuse, %[ScaleMtx].reuse, mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" +#define PTO_GVF_MX_SRC_0 "B.IOT %[Vec], %[Mtx], mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" +#define PTO_GVF_MX_SRC_1 "B.IOT %[Vec], %[ScaleVec], mask=1111\n" "B.IOT %[Mtx], mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" +#define PTO_GVF_MX_SRC_2 "B.IOT %[Vec], mask=1111\n" "B.IOT %[Mtx], %[ScaleMtx], mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" #define PTO_GV_FOLD_PLAIN(MASK, IOR) \ asm volatile(PTO_MATMUL_HEADER("TGEMVMX", PTO_FIXP_ATTR) \ @@ -7860,14 +7860,14 @@ PTO_SHARED_INLINE void matmul_acc(Dst &dst, C &c, A &a, B &b, size_t M, : "memory") #define PTO_GV_FOLD_ACC(MASK, IOR) \ asm volatile(PTO_MATMUL_HEADER("TGEMVMX.ACC", PTO_FIXP_ATTR) \ - "B.IOT %[C].reuse, mask=1111\n" PTO_GVF_MX_SRC_##MASK PTO_FIXP_IOR_##IOR \ + "B.IOT %[C], mask=1111\n" PTO_GVF_MX_SRC_##MASK PTO_FIXP_IOR_##IOR \ : PTO_FIXP_OUT_DECL_0 \ : [C] "Tr"(c.data()), PTO_GV_MX_INPUTS_##MASK, \ [QuantGpr] "r"(quant_gpr), [LReluGpr] "r"(lrelu_gpr), PTO_FIXP_ATTR_INPUTS, PTO_MATMUL_COMMON_INPUTS(Dst, Vec, Mtx, M, N, K), [DstSize] "i"(tile_type_traits::TilesizeCode), [RowSize] "i"(tile_type_traits::TilesizeCode), [GroupSize] "i"(tile_type_traits::TilesizeCode) \ : "memory") #define PTO_GV_FOLD_BIAS(MASK, IOR) \ asm volatile(PTO_MATMUL_HEADER("TGEMVMX.BIAS", PTO_FIXP_ATTR) \ - PTO_GV_MX_SRC_##MASK "B.IOT %[Bias].reuse, mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" PTO_FIXP_IOR_##IOR \ + PTO_GV_MX_SRC_##MASK "B.IOT %[Bias], mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" PTO_FIXP_IOR_##IOR \ : PTO_FIXP_OUT_DECL_0 \ : [Bias] "Tr"(bias.data()), PTO_GV_MX_INPUTS_##MASK, \ [QuantGpr] "r"(quant_gpr), [LReluGpr] "r"(lrelu_gpr), PTO_FIXP_ATTR_INPUTS, PTO_MATMUL_COMMON_INPUTS(Dst, Vec, Mtx, M, N, K), [DstSize] "i"(tile_type_traits::TilesizeCode), [RowSize] "i"(tile_type_traits::TilesizeCode), [GroupSize] "i"(tile_type_traits::TilesizeCode) \ @@ -7895,8 +7895,8 @@ PTO_SHARED_INLINE void matmul_acc(Dst &dst, C &c, A &a, B &b, size_t M, [GroupSize] "i"(tile_type_traits::TilesizeCode) \ : "memory") #define PTO_GV_OPT_PLAIN(M,S,O,I) PTO_GV_MX_OPTIONAL_EMIT("TGEMVMX","","",NONE,M,S,O,I) -#define PTO_GV_OPT_ACC(M,S,O,I) PTO_GV_MX_OPTIONAL_EMIT("TGEMVMX.ACC","B.IOT %[C].reuse, mask=1111\n","",ACC,M,S,O,I) -#define PTO_GV_OPT_BIAS(M,S,O,I) PTO_GV_MX_OPTIONAL_EMIT("TGEMVMX.BIAS","","B.IOT %[Bias].reuse, mask=1111\n",BIAS,M,S,O,I) +#define PTO_GV_OPT_ACC(M,S,O,I) PTO_GV_MX_OPTIONAL_EMIT("TGEMVMX.ACC","B.IOT %[C], mask=1111\n","",ACC,M,S,O,I) +#define PTO_GV_OPT_BIAS(M,S,O,I) PTO_GV_MX_OPTIONAL_EMIT("TGEMVMX.BIAS","","B.IOT %[Bias], mask=1111\n",BIAS,M,S,O,I) #define PTO_GV_OPT_PLAIN_0(S,O,I) PTO_GV_OPT_PLAIN(0,S,O,I) #define PTO_GV_OPT_PLAIN_1(S,O,I) PTO_GV_OPT_PLAIN(1,S,O,I) #define PTO_GV_OPT_PLAIN_2(S,O,I) PTO_GV_OPT_PLAIN(2,S,O,I) @@ -8298,7 +8298,7 @@ PTO_SHARED_INLINE void emit_matmul_mx_bias_fixp( // GVA: C,Vec,Mtx GVMXA: C,Vec,ScaleVec,Mtx,ScaleMtx #define PTO_FIXP_GV_GV_FOLD(IOR) \ asm volatile(PTO_MATMUL_HEADER("TGEMV", PTO_FIXP_ATTR) \ - "B.IOT %[Vec].reuse, %[Mtx].reuse, mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" PTO_FIXP_IOR_##IOR \ + "B.IOT %[Vec], %[Mtx], mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" PTO_FIXP_IOR_##IOR \ : PTO_FIXP_OUT_DECL_0 \ : [Mtx] "Tr"(mtx.data()), [Vec] "Tr"(vec.data()), \ [QuantGpr] "r"(quant_gpr), [LReluGpr] "r"(lrelu_gpr), PTO_FIXP_ATTR_INPUTS, PTO_MATMUL_COMMON_INPUTS(Dst, Vec, Mtx, M, N, K), [DstSize] "i"(tile_type_traits::TilesizeCode), [RowSize] "i"(tile_type_traits::TilesizeCode), [GroupSize] "i"(tile_type_traits::TilesizeCode) \ @@ -8306,8 +8306,8 @@ PTO_SHARED_INLINE void emit_matmul_mx_bias_fixp( #define PTO_FIXP_GV_GVB_FOLD(IOR) \ asm volatile(PTO_MATMUL_HEADER("TGEMV.BIAS", PTO_FIXP_ATTR) \ - "B.IOT %[Vec].reuse, %[Mtx].reuse, mask=1111\n" \ - "B.IOT %[Bias].reuse, mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" PTO_FIXP_IOR_##IOR \ + "B.IOT %[Vec], %[Mtx], mask=1111\n" \ + "B.IOT %[Bias], mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" PTO_FIXP_IOR_##IOR \ : PTO_FIXP_OUT_DECL_0 \ : [Mtx] "Tr"(mtx.data()), [Vec] "Tr"(vec.data()), [Bias] "Tr"(bias.data()), \ [QuantGpr] "r"(quant_gpr), [LReluGpr] "r"(lrelu_gpr), PTO_FIXP_ATTR_INPUTS, PTO_MATMUL_COMMON_INPUTS(Dst, Vec, Mtx, M, N, K), [DstSize] "i"(tile_type_traits::TilesizeCode), [RowSize] "i"(tile_type_traits::TilesizeCode), [GroupSize] "i"(tile_type_traits::TilesizeCode) \ @@ -8315,8 +8315,8 @@ PTO_SHARED_INLINE void emit_matmul_mx_bias_fixp( #define PTO_FIXP_GV_GVA_FOLD(IOR) \ asm volatile(PTO_MATMUL_HEADER("TGEMV.ACC", PTO_FIXP_ATTR) \ - "B.IOT %[C].reuse, mask=1111\n" \ - "B.IOT %[Vec].reuse, %[Mtx].reuse, mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" PTO_FIXP_IOR_##IOR \ + "B.IOT %[C], mask=1111\n" \ + "B.IOT %[Vec], %[Mtx], mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" PTO_FIXP_IOR_##IOR \ : PTO_FIXP_OUT_DECL_0 \ : [C] "Tr"(c.data()), [Mtx] "Tr"(mtx.data()), [Vec] "Tr"(vec.data()), \ [QuantGpr] "r"(quant_gpr), [LReluGpr] "r"(lrelu_gpr), PTO_FIXP_ATTR_INPUTS, PTO_MATMUL_COMMON_INPUTS(Dst, Vec, Mtx, M, N, K), [DstSize] "i"(tile_type_traits::TilesizeCode), [RowSize] "i"(tile_type_traits::TilesizeCode), [GroupSize] "i"(tile_type_traits::TilesizeCode) \ @@ -8324,8 +8324,8 @@ PTO_SHARED_INLINE void emit_matmul_mx_bias_fixp( #define PTO_FIXP_GV_GVMX_FOLD(IOR) \ asm volatile(PTO_MATMUL_HEADER("TGEMVMX", PTO_FIXP_ATTR) \ - "B.IOT %[Vec].reuse, %[ScaleVec].reuse, mask=1111\n" \ - "B.IOT %[Mtx].reuse, %[ScaleMtx].reuse, mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" PTO_FIXP_IOR_##IOR \ + "B.IOT %[Vec], %[ScaleVec], mask=1111\n" \ + "B.IOT %[Mtx], %[ScaleMtx], mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" PTO_FIXP_IOR_##IOR \ : PTO_FIXP_OUT_DECL_0 \ : [Mtx] "Tr"(mtx.data()), [ScaleMtx] "Tr"(smtx.data()), [Vec] "Tr"(vec.data()), [ScaleVec] "Tr"(svec.data()), PTO_MX_SCALE_INPUTS, \ [QuantGpr] "r"(quant_gpr), [LReluGpr] "r"(lrelu_gpr), PTO_FIXP_ATTR_INPUTS, PTO_MATMUL_COMMON_INPUTS(Dst, Vec, Mtx, M, N, K), [DstSize] "i"(tile_type_traits::TilesizeCode), [RowSize] "i"(tile_type_traits::TilesizeCode), [GroupSize] "i"(tile_type_traits::TilesizeCode) \ @@ -8333,9 +8333,9 @@ PTO_SHARED_INLINE void emit_matmul_mx_bias_fixp( #define PTO_FIXP_GV_GVMXB_FOLD(IOR) \ asm volatile(PTO_MATMUL_HEADER("TGEMVMX.BIAS", PTO_FIXP_ATTR) \ - "B.IOT %[Vec].reuse, %[ScaleVec].reuse, mask=1111\n" \ - "B.IOT %[Mtx].reuse, %[ScaleMtx].reuse, mask=1111\n" \ - "B.IOT %[Bias].reuse, mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" PTO_FIXP_IOR_##IOR \ + "B.IOT %[Vec], %[ScaleVec], mask=1111\n" \ + "B.IOT %[Mtx], %[ScaleMtx], mask=1111\n" \ + "B.IOT %[Bias], mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" PTO_FIXP_IOR_##IOR \ : PTO_FIXP_OUT_DECL_0 \ : [Mtx] "Tr"(mtx.data()), [ScaleMtx] "Tr"(smtx.data()), [Vec] "Tr"(vec.data()), [ScaleVec] "Tr"(svec.data()), PTO_MX_SCALE_INPUTS, [Bias] "Tr"(bias.data()), \ [QuantGpr] "r"(quant_gpr), [LReluGpr] "r"(lrelu_gpr), PTO_FIXP_ATTR_INPUTS, PTO_MATMUL_COMMON_INPUTS(Dst, Vec, Mtx, M, N, K), [DstSize] "i"(tile_type_traits::TilesizeCode), [RowSize] "i"(tile_type_traits::TilesizeCode), [GroupSize] "i"(tile_type_traits::TilesizeCode) \ @@ -8343,9 +8343,9 @@ PTO_SHARED_INLINE void emit_matmul_mx_bias_fixp( #define PTO_FIXP_GV_GVMXA_FOLD(IOR) \ asm volatile(PTO_MATMUL_HEADER("TGEMVMX.ACC", PTO_FIXP_ATTR) \ - "B.IOT %[C].reuse, %[Vec].reuse, mask=1111\n" \ - "B.IOT %[ScaleVec].reuse, %[Mtx].reuse, mask=1111\n" \ - "B.IOT %[ScaleMtx].reuse, mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" PTO_FIXP_IOR_##IOR \ + "B.IOT %[C], %[Vec], mask=1111\n" \ + "B.IOT %[ScaleVec], %[Mtx], mask=1111\n" \ + "B.IOT %[ScaleMtx], mask=1111, last, ->%[Dst]<%Z[DstSize]>\n" PTO_FIXP_IOR_##IOR \ : PTO_FIXP_OUT_DECL_0 \ : [C] "Tr"(c.data()), [Mtx] "Tr"(mtx.data()), [ScaleMtx] "Tr"(smtx.data()), [Vec] "Tr"(vec.data()), [ScaleVec] "Tr"(svec.data()), PTO_MX_SCALE_INPUTS, \ [QuantGpr] "r"(quant_gpr), [LReluGpr] "r"(lrelu_gpr), PTO_FIXP_ATTR_INPUTS, PTO_MATMUL_COMMON_INPUTS(Dst, Vec, Mtx, M, N, K), [DstSize] "i"(tile_type_traits::TilesizeCode), [RowSize] "i"(tile_type_traits::TilesizeCode), [GroupSize] "i"(tile_type_traits::TilesizeCode) \ @@ -8569,8 +8569,8 @@ PTO_SHARED_INLINE void Name(Dst &dst, A &a, ScaleA &scale_a, B &b, \ if constexpr (!is_shared_tile_v && !is_shared_tile_v) { \ asm volatile( \ PTO_MATMUL_HEADER(Opcode, PTO_FIXP_ATTR) \ - "B.IOT %[A].reuse, %[ScaleA].reuse, mask=1111\n" \ - "B.IOT %[B].reuse, %[ScaleB].reuse, mask=1111, last, ->%[Dst]<%Z[TileSize]>\n" \ + "B.IOT %[A], %[ScaleA], mask=1111\n" \ + "B.IOT %[B], %[ScaleB], mask=1111, last, ->%[Dst]<%Z[TileSize]>\n" \ : [Dst] "=&Tr"(dst.data()) \ : [A] "Tr"(a.data()), [ScaleA] "Tr"(scale_a.data()), \ [B] "Tr"(b.data()), [ScaleB] "Tr"(scale_b.data()), \ @@ -8580,9 +8580,9 @@ PTO_SHARED_INLINE void Name(Dst &dst, A &a, ScaleA &scale_a, B &b, \ } else if constexpr (is_shared_tile_v && !is_shared_tile_v) { \ asm volatile( \ PTO_MATMUL_HEADER(Opcode, PTO_FIXP_ATTR) \ - "B.IOS %S[SharedA].reuse, mask=1111\n" \ - "B.IOS %S[ScaleA].reuse, mask=1111\n" \ - "B.IOT %[B].reuse, %[ScaleB].reuse, mask=1111, last, ->%[Dst]<%Z[TileSize]>\n" \ + "B.IOS %S[SharedA], mask=1111\n" \ + "B.IOS %S[ScaleA], mask=1111\n" \ + "B.IOT %[B], %[ScaleB], mask=1111, last, ->%[Dst]<%Z[TileSize]>\n" \ : [Dst] "=&Tr"(dst.data()) \ : [SharedA] "Sr"(a.handle()), [ScaleA] "Sr"(scale_a.handle()), \ [B] "Tr"(b.data()), [ScaleB] "Tr"(scale_b.data()), \ @@ -8592,9 +8592,9 @@ PTO_SHARED_INLINE void Name(Dst &dst, A &a, ScaleA &scale_a, B &b, \ } else if constexpr (!is_shared_tile_v && is_shared_tile_v) { \ asm volatile( \ PTO_MATMUL_HEADER(Opcode, PTO_FIXP_ATTR) \ - "B.IOS %S[SharedB].reuse, mask=1111\n" \ - ".if %c[HasScaleB]\n" "B.IOS %S[ScaleB].reuse, mask=1111\n" ".endif\n" \ - "B.IOT %[A].reuse, %[ScaleA].reuse, mask=1111, last, ->%[Dst]<%Z[TileSize]>\n" \ + "B.IOS %S[SharedB], mask=1111\n" \ + ".if %c[HasScaleB]\n" "B.IOS %S[ScaleB], mask=1111\n" ".endif\n" \ + "B.IOT %[A], %[ScaleA], mask=1111, last, ->%[Dst]<%Z[TileSize]>\n" \ : [Dst] "=&Tr"(dst.data()) \ : [A] "Tr"(a.data()), [ScaleA] "Tr"(scale_a.data()), \ [SharedB] "Sr"(b.handle()), [ScaleB] "Sr"(scale_b.handle()), \ @@ -8604,10 +8604,10 @@ PTO_SHARED_INLINE void Name(Dst &dst, A &a, ScaleA &scale_a, B &b, \ } else { \ asm volatile( \ PTO_MATMUL_HEADER(Opcode, PTO_FIXP_ATTR) \ - "B.IOS %S[SharedA].reuse, mask=1111\n" \ - "B.IOS %S[ScaleA].reuse, mask=1111\n" \ - "B.IOS %S[SharedB].reuse, mask=1111\n" \ - "B.IOS %S[ScaleB].reuse, mask=1111\n" \ + "B.IOS %S[SharedA], mask=1111\n" \ + "B.IOS %S[ScaleA], mask=1111\n" \ + "B.IOS %S[SharedB], mask=1111\n" \ + "B.IOS %S[ScaleB], mask=1111\n" \ "B.IOT mask=1111, last, ->%[Dst]<%Z[TileSize]>\n" \ : [Dst] "=&Tr"(dst.data()) \ : [SharedA] "Sr"(a.handle()), [ScaleA] "Sr"(scale_a.handle()), \ @@ -8628,7 +8628,7 @@ PTO_SHARED_INLINE void matmul_mx_no_scale_local( validate_matrix_scale_contract(); asm volatile( PTO_MATMUL_HEADER("TMATMULMX", PTO_FIXP_ATTR) - "B.IOT %[A].reuse, %[B].reuse, mask=1111, last, ->%[Dst]<%Z[TileSize]>\n" + "B.IOT %[A], %[B], mask=1111, last, ->%[Dst]<%Z[TileSize]>\n" : [Dst] "=&Tr"(dst.data()) : [A] "Tr"(a.data()), [B] "Tr"(b.data()), PTO_FIXP_ATTR_INPUTS, PTO_MATMUL_COMMON_INPUTS(Dst, A, B, M, N, K) @@ -8644,8 +8644,8 @@ PTO_SHARED_INLINE void matmul_mx_scale_a_local( validate_matrix_scale_contract(); asm volatile( PTO_MATMUL_HEADER("TMATMULMX", PTO_FIXP_ATTR) - "B.IOT %[A].reuse, %[ScaleA].reuse, mask=1111\n" - "B.IOT %[B].reuse, mask=1111, last, ->%[Dst]<%Z[TileSize]>\n" + "B.IOT %[A], %[ScaleA], mask=1111\n" + "B.IOT %[B], mask=1111, last, ->%[Dst]<%Z[TileSize]>\n" : [Dst] "=&Tr"(dst.data()) : [A] "Tr"(a.data()), [ScaleA] "Tr"(scale_a.data()), [B] "Tr"(b.data()), PTO_FIXP_ATTR_INPUTS, @@ -8662,8 +8662,8 @@ PTO_SHARED_INLINE void matmul_mx_scale_b_local( validate_matrix_scale_contract(); asm volatile( PTO_MATMUL_HEADER("TMATMULMX", PTO_FIXP_ATTR) - "B.IOT %[A].reuse, mask=1111\n" - "B.IOT %[B].reuse, %[ScaleB].reuse, mask=1111, last, ->%[Dst]<%Z[TileSize]>\n" + "B.IOT %[A], mask=1111\n" + "B.IOT %[B], %[ScaleB], mask=1111, last, ->%[Dst]<%Z[TileSize]>\n" : [Dst] "=&Tr"(dst.data()) : [A] "Tr"(a.data()), [B] "Tr"(b.data()), [ScaleB] "Tr"(scale_b.data()), PTO_FIXP_ATTR_INPUTS, @@ -8689,9 +8689,9 @@ PTO_SHARED_INLINE void Name(Dst &dst, A &a, ScaleA &scale_a, B &b, \ if constexpr (!is_shared_tile_v && !is_shared_tile_v) { \ asm volatile( \ PTO_MATMUL_HEADER(Opcode, PTO_FIXP_ATTR) \ - "B.IOT %[A].reuse, %[ScaleA].reuse, mask=1111\n" \ - "B.IOT %[B].reuse, %[ScaleB].reuse, mask=1111\n" \ - "B.IOT %[Extra].reuse, mask=1111, last, ->%[Dst]<%Z[TileSize]>\n" \ + "B.IOT %[A], %[ScaleA], mask=1111\n" \ + "B.IOT %[B], %[ScaleB], mask=1111\n" \ + "B.IOT %[Extra], mask=1111, last, ->%[Dst]<%Z[TileSize]>\n" \ : [Dst] "=&Tr"(dst.data()) \ : [A] "Tr"(a.data()), [ScaleA] "Tr"(scale_a.data()), \ [B] "Tr"(b.data()), [ScaleB] "Tr"(scale_b.data()), \ @@ -8702,10 +8702,10 @@ PTO_SHARED_INLINE void Name(Dst &dst, A &a, ScaleA &scale_a, B &b, \ } else if constexpr (is_shared_tile_v && !is_shared_tile_v) { \ asm volatile( \ PTO_MATMUL_HEADER(Opcode, PTO_FIXP_ATTR) \ - "B.IOS %S[SharedA].reuse, mask=1111\n" \ - "B.IOS %S[ScaleA].reuse, mask=1111\n" \ - "B.IOT %[B].reuse, %[ScaleB].reuse, mask=1111\n" \ - "B.IOT %[Extra].reuse, mask=1111, last, ->%[Dst]<%Z[TileSize]>\n" \ + "B.IOS %S[SharedA], mask=1111\n" \ + "B.IOS %S[ScaleA], mask=1111\n" \ + "B.IOT %[B], %[ScaleB], mask=1111\n" \ + "B.IOT %[Extra], mask=1111, last, ->%[Dst]<%Z[TileSize]>\n" \ : [Dst] "=&Tr"(dst.data()) \ : [SharedA] "Sr"(a.handle()), [ScaleA] "Sr"(scale_a.handle()), \ [B] "Tr"(b.data()), [ScaleB] "Tr"(scale_b.data()), \ @@ -8716,10 +8716,10 @@ PTO_SHARED_INLINE void Name(Dst &dst, A &a, ScaleA &scale_a, B &b, \ } else if constexpr (!is_shared_tile_v && is_shared_tile_v) { \ asm volatile( \ PTO_MATMUL_HEADER(Opcode, PTO_FIXP_ATTR) \ - "B.IOS %S[SharedB].reuse, mask=1111\n" \ - "B.IOS %S[ScaleB].reuse, mask=1111\n" \ - "B.IOT %[A].reuse, %[ScaleA].reuse, mask=1111\n" \ - "B.IOT %[Extra].reuse, mask=1111, last, ->%[Dst]<%Z[TileSize]>\n" \ + "B.IOS %S[SharedB], mask=1111\n" \ + "B.IOS %S[ScaleB], mask=1111\n" \ + "B.IOT %[A], %[ScaleA], mask=1111\n" \ + "B.IOT %[Extra], mask=1111, last, ->%[Dst]<%Z[TileSize]>\n" \ : [Dst] "=&Tr"(dst.data()) \ : [A] "Tr"(a.data()), [ScaleA] "Tr"(scale_a.data()), \ [SharedB] "Sr"(b.handle()), [ScaleB] "Sr"(scale_b.handle()), \ @@ -8730,11 +8730,11 @@ PTO_SHARED_INLINE void Name(Dst &dst, A &a, ScaleA &scale_a, B &b, \ } else { \ asm volatile( \ PTO_MATMUL_HEADER(Opcode, PTO_FIXP_ATTR) \ - "B.IOS %S[SharedA].reuse, mask=1111\n" \ - "B.IOS %S[ScaleA].reuse, mask=1111\n" \ - "B.IOS %S[SharedB].reuse, mask=1111\n" \ - "B.IOS %S[ScaleB].reuse, mask=1111\n" \ - "B.IOT %[Extra].reuse, mask=1111, last, ->%[Dst]<%Z[TileSize]>\n" \ + "B.IOS %S[SharedA], mask=1111\n" \ + "B.IOS %S[ScaleA], mask=1111\n" \ + "B.IOS %S[SharedB], mask=1111\n" \ + "B.IOS %S[ScaleB], mask=1111\n" \ + "B.IOT %[Extra], mask=1111, last, ->%[Dst]<%Z[TileSize]>\n" \ : [Dst] "=&Tr"(dst.data()) \ : [SharedA] "Sr"(a.handle()), [ScaleA] "Sr"(scale_a.handle()), \ [SharedB] "Sr"(b.handle()), [ScaleB] "Sr"(scale_b.handle()), \ @@ -9465,7 +9465,7 @@ TMATMUL(tile_shape_d &d, tile_shape_a &a, quant_gpr, lrelu_gpr, M, N, K); } -// TMATMUL_BIAS: C = A*B + bias (BSTART.TMATMUL.BIAS). +// TMATMUL_BIAS: C = A*B + bias (BSTART.CUBE TMATMUL.BIAS). template (c, a, b, bias, row_in, quant_tile, relu_tile, row_out, group_out, quant_gpr, lrelu_gpr, groupM, N, K); } -// TMATMUL_MX: C = (A * aScale) * (B * bScale) (BSTART.TMATMULMX). +// TMATMUL_MX: C = (A * aScale) * (B * bScale) (BSTART.CUBE TMATMULMX). template lb0\n" "B.DIM %[Row], 0, ->lb1\n" "B.DIM zero, %c[Cols], ->lb2\n" - "B.IOT %[Src0].reuse, %[Src1].reuse, mask=1111, last, ->%[Dst]<%Z[TileSize]>\n" + "B.IOT %[Src0], %[Src1], mask=1111, last, ->%[Dst]<%Z[TileSize]>\n" "B.ASSEMBLE %c[Init], %c[Last], %[RegSrc], %c[Off], %c[WriterSize]\n" : [Dst] "=Tr"(dst.data()) : [Type] "i"(type_traits::TypeCode), @@ -11151,7 +11151,7 @@ PTO_SHARED_INLINE void emit_binary_user( "B.DIM %[ucol], 0, ->lb0\n" "B.DIM %[urow], 0, ->lb1\n" "B.DIM zero, %c[Cols], ->lb2\n" - "B.IOT %[Src0].reuse, %[Src1].reuse, mask=1111, last, ->%[Dst]<%Z[TileSize]>\n" + "B.IOT %[Src0], %[Src1], mask=1111, last, ->%[Dst]<%Z[TileSize]>\n" : [Dst] "=Tr"(dst.data()) : [ucol] "r"(Col), [urow] "r"(Row), [Type] "i"(type_traits::TypeCode), @@ -11186,7 +11186,7 @@ void TADD(tile_shape &dst, tile_shape &src0, tile_shape &src1, "B.DIM zero, %c2, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -11204,7 +11204,7 @@ void TADD(tile_shape &dst, tile_shape &src0, tile_shape &src1, "B.DIM zero, %c2, ->lb0\n" "B.DIM %[src0____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -11222,7 +11222,7 @@ void TADD(tile_shape &dst, tile_shape &src0, tile_shape &src1, "B.DIM %[src0____dimcol], 0, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -11240,7 +11240,7 @@ void TADD(tile_shape &dst, tile_shape &src0, tile_shape &src1, "B.DIM %[src0____dimcol], 0, ->lb0\n" "B.DIM %[src0____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -11313,7 +11313,7 @@ void TSUB(tile_shape &dst, tile_shape &src0, tile_shape &src1, "B.DIM zero, %c2, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -11331,7 +11331,7 @@ void TSUB(tile_shape &dst, tile_shape &src0, tile_shape &src1, "B.DIM zero, %c2, ->lb0\n" "B.DIM %[src0____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -11349,7 +11349,7 @@ void TSUB(tile_shape &dst, tile_shape &src0, tile_shape &src1, "B.DIM %[src0____dimcol], 0, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -11367,7 +11367,7 @@ void TSUB(tile_shape &dst, tile_shape &src0, tile_shape &src1, "B.DIM %[src0____dimcol], 0, ->lb0\n" "B.DIM %[src0____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -11413,7 +11413,7 @@ void TMUL(Dst &dst, Src0 &src0, Src1 &src1, "B.DIM zero, %c2, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -11432,7 +11432,7 @@ void TMUL(Dst &dst, Src0 &src0, Src1 &src1, "B.DIM zero, %c2, ->lb0\n" "B.DIM %[valid_row], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -11451,7 +11451,7 @@ void TMUL(Dst &dst, Src0 &src0, Src1 &src1, "B.DIM %[valid_col], 0, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -11471,7 +11471,7 @@ void TMUL(Dst &dst, Src0 &src0, Src1 &src1, "B.DIM %[valid_col], 0, ->lb0\n" "B.DIM %[valid_row], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -11501,7 +11501,7 @@ void TDIV(tile_shape &dst, tile_shape &src0, tile_shape &src1, "B.DIM zero, %c2, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -11519,7 +11519,7 @@ void TDIV(tile_shape &dst, tile_shape &src0, tile_shape &src1, "B.DIM zero, %c2, ->lb0\n" "B.DIM %[src0____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -11537,7 +11537,7 @@ void TDIV(tile_shape &dst, tile_shape &src0, tile_shape &src1, "B.DIM %[src0____dimcol], 0, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -11555,7 +11555,7 @@ void TDIV(tile_shape &dst, tile_shape &src0, tile_shape &src1, "B.DIM %[src0____dimcol], 0, ->lb0\n" "B.DIM %[src0____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -11579,7 +11579,7 @@ void TREM(tile_shape &dst, tile_shape &src0, tile_shape &src1) { "B.DIM zero, %c2, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -11597,7 +11597,7 @@ void TREM(tile_shape &dst, tile_shape &src0, tile_shape &src1) { "B.DIM zero, %c2, ->lb0\n" "B.DIM %[src0____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -11615,7 +11615,7 @@ void TREM(tile_shape &dst, tile_shape &src0, tile_shape &src1) { "B.DIM %[src0____dimcol], 0, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -11633,7 +11633,7 @@ void TREM(tile_shape &dst, tile_shape &src0, tile_shape &src1) { "B.DIM %[src0____dimcol], 0, ->lb0\n" "B.DIM %[src0____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -11671,7 +11671,7 @@ void TAND(tile_shape &dst, tile_shape &src0, tile_shape &src1, "B.DIM zero, %c2, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -11689,7 +11689,7 @@ void TAND(tile_shape &dst, tile_shape &src0, tile_shape &src1, "B.DIM zero, %c2, ->lb0\n" "B.DIM %[src0____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -11707,7 +11707,7 @@ void TAND(tile_shape &dst, tile_shape &src0, tile_shape &src1, "B.DIM %[src0____dimcol], 0, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -11725,7 +11725,7 @@ void TAND(tile_shape &dst, tile_shape &src0, tile_shape &src1, "B.DIM %[src0____dimcol], 0, ->lb0\n" "B.DIM %[src0____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -11755,7 +11755,7 @@ void TOR(tile_shape &dst, tile_shape &src0, tile_shape &src1, "B.DIM zero, %c2, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -11773,7 +11773,7 @@ void TOR(tile_shape &dst, tile_shape &src0, tile_shape &src1, "B.DIM zero, %c2, ->lb0\n" "B.DIM %[src0____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -11791,7 +11791,7 @@ void TOR(tile_shape &dst, tile_shape &src0, tile_shape &src1, "B.DIM %[src0____dimcol], 0, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -11809,7 +11809,7 @@ void TOR(tile_shape &dst, tile_shape &src0, tile_shape &src1, "B.DIM %[src0____dimcol], 0, ->lb0\n" "B.DIM %[src0____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -11839,7 +11839,7 @@ void TXOR(tile_shape &dst, tile_shape &src0, tile_shape &src1, "B.DIM zero, %c2, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -11857,7 +11857,7 @@ void TXOR(tile_shape &dst, tile_shape &src0, tile_shape &src1, "B.DIM zero, %c2, ->lb0\n" "B.DIM %[src0____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -11875,7 +11875,7 @@ void TXOR(tile_shape &dst, tile_shape &src0, tile_shape &src1, "B.DIM %[src0____dimcol], 0, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -11893,7 +11893,7 @@ void TXOR(tile_shape &dst, tile_shape &src0, tile_shape &src1, "B.DIM %[src0____dimcol], 0, ->lb0\n" "B.DIM %[src0____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -11923,7 +11923,7 @@ void TSHL(tile_shape &dst, tile_shape &src0, tile_shape &src1, "B.DIM zero, %c2, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -11941,7 +11941,7 @@ void TSHL(tile_shape &dst, tile_shape &src0, tile_shape &src1, "B.DIM zero, %c2, ->lb0\n" "B.DIM %[src0____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -11959,7 +11959,7 @@ void TSHL(tile_shape &dst, tile_shape &src0, tile_shape &src1, "B.DIM %[src0____dimcol], 0, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -11977,7 +11977,7 @@ void TSHL(tile_shape &dst, tile_shape &src0, tile_shape &src1, "B.DIM %[src0____dimcol], 0, ->lb0\n" "B.DIM %[src0____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -12007,7 +12007,7 @@ void TSHR(tile_shape &dst, tile_shape &src0, tile_shape &src1, "B.DIM zero, %c2, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -12025,7 +12025,7 @@ void TSHR(tile_shape &dst, tile_shape &src0, tile_shape &src1, "B.DIM zero, %c2, ->lb0\n" "B.DIM %[src0____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -12043,7 +12043,7 @@ void TSHR(tile_shape &dst, tile_shape &src0, tile_shape &src1, "B.DIM %[src0____dimcol], 0, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -12061,7 +12061,7 @@ void TSHR(tile_shape &dst, tile_shape &src0, tile_shape &src1, "B.DIM %[src0____dimcol], 0, ->lb0\n" "B.DIM %[src0____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -12091,7 +12091,7 @@ void TMAX(tile_shape &dst, tile_shape &src0, tile_shape &src1, "B.DIM zero, %c2, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -12109,7 +12109,7 @@ void TMAX(tile_shape &dst, tile_shape &src0, tile_shape &src1, "B.DIM zero, %c2, ->lb0\n" "B.DIM %[src0____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -12127,7 +12127,7 @@ void TMAX(tile_shape &dst, tile_shape &src0, tile_shape &src1, "B.DIM %[src0____dimcol], 0, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -12145,7 +12145,7 @@ void TMAX(tile_shape &dst, tile_shape &src0, tile_shape &src1, "B.DIM %[src0____dimcol], 0, ->lb0\n" "B.DIM %[src0____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -12175,7 +12175,7 @@ void TMIN(tile_shape &dst, tile_shape &src0, tile_shape &src1, "B.DIM zero, %c2, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -12193,7 +12193,7 @@ void TMIN(tile_shape &dst, tile_shape &src0, tile_shape &src1, "B.DIM zero, %c2, ->lb0\n" "B.DIM %[src0____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -12211,7 +12211,7 @@ void TMIN(tile_shape &dst, tile_shape &src0, tile_shape &src1, "B.DIM %[src0____dimcol], 0, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -12229,7 +12229,7 @@ void TMIN(tile_shape &dst, tile_shape &src0, tile_shape &src1, "B.DIM %[src0____dimcol], 0, ->lb0\n" "B.DIM %[src0____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -12273,7 +12273,7 @@ asm volatile( "B.DIM zero, %c[VCOL], ->lb0\n" "B.DIM zero, %c[VROW], ->lb1\n" "B.DIM zero, %c[Cols], ->lb2\n" - "B.IOT %[S0].reuse, %[S1].reuse, mask=1111, last, ->%[D]<%Z[TSize]>\n" + "B.IOT %[S0], %[S1], mask=1111, last, ->%[D]<%Z[TSize]>\n" "" : [D] "=Tr"(dst.data()) : [TCode] "i"(type_traits::TypeCode), @@ -12291,7 +12291,7 @@ asm volatile( "B.DIM zero, %c[VCOL], ->lb0\n" "B.DIM %[VROW], 0, ->lb1\n" "B.DIM zero, %c[Cols], ->lb2\n" - "B.IOT %[S0].reuse, %[S1].reuse, mask=1111, last, ->%[D]<%Z[TSize]>\n" + "B.IOT %[S0], %[S1], mask=1111, last, ->%[D]<%Z[TSize]>\n" "" : [D] "=Tr"(dst.data()) : [TCode] "i"(type_traits::TypeCode), @@ -12309,7 +12309,7 @@ asm volatile( "B.DIM %[VCOL], 0, ->lb0\n" "B.DIM zero, %c[VROW], ->lb1\n" "B.DIM zero, %c[Cols], ->lb2\n" - "B.IOT %[S0].reuse, %[S1].reuse, mask=1111, last, ->%[D]<%Z[TSize]>\n" + "B.IOT %[S0], %[S1], mask=1111, last, ->%[D]<%Z[TSize]>\n" "" : [D] "=Tr"(dst.data()) : [TCode] "i"(type_traits::TypeCode), @@ -12327,7 +12327,7 @@ asm volatile( "B.DIM %[VCOL], 0, ->lb0\n" "B.DIM %[VROW], 0, ->lb1\n" "B.DIM zero, %c[Cols], ->lb2\n" - "B.IOT %[S0].reuse, %[S1].reuse, mask=1111, last, ->%[D]<%Z[TSize]>\n" + "B.IOT %[S0], %[S1], mask=1111, last, ->%[D]<%Z[TSize]>\n" "" : [D] "=Tr"(dst.data()) : [TCode] "i"(type_traits::TypeCode), @@ -12346,7 +12346,7 @@ asm volatile( "B.DIM zero, %c[VCOL], ->lb0\n" "B.DIM zero, %c[VROW], ->lb1\n" "B.DIM zero, %c[Cols], ->lb2\n" - "B.IOT %[S0].reuse, %[S1].reuse, mask=1111, last, ->%[D]<%Z[TSize]>\n" + "B.IOT %[S0], %[S1], mask=1111, last, ->%[D]<%Z[TSize]>\n" "" : [D] "=Tr"(dst.data()) : [TCode] "i"(type_traits::TypeCode), @@ -12364,7 +12364,7 @@ asm volatile( "B.DIM zero, %c[VCOL], ->lb0\n" "B.DIM %[VROW], 0, ->lb1\n" "B.DIM zero, %c[Cols], ->lb2\n" - "B.IOT %[S0].reuse, %[S1].reuse, mask=1111, last, ->%[D]<%Z[TSize]>\n" + "B.IOT %[S0], %[S1], mask=1111, last, ->%[D]<%Z[TSize]>\n" "" : [D] "=Tr"(dst.data()) : [TCode] "i"(type_traits::TypeCode), @@ -12382,7 +12382,7 @@ asm volatile( "B.DIM %[VCOL], 0, ->lb0\n" "B.DIM zero, %c[VROW], ->lb1\n" "B.DIM zero, %c[Cols], ->lb2\n" - "B.IOT %[S0].reuse, %[S1].reuse, mask=1111, last, ->%[D]<%Z[TSize]>\n" + "B.IOT %[S0], %[S1], mask=1111, last, ->%[D]<%Z[TSize]>\n" "" : [D] "=Tr"(dst.data()) : [TCode] "i"(type_traits::TypeCode), @@ -12400,7 +12400,7 @@ asm volatile( "B.DIM %[VCOL], 0, ->lb0\n" "B.DIM %[VROW], 0, ->lb1\n" "B.DIM zero, %c[Cols], ->lb2\n" - "B.IOT %[S0].reuse, %[S1].reuse, mask=1111, last, ->%[D]<%Z[TSize]>\n" + "B.IOT %[S0], %[S1], mask=1111, last, ->%[D]<%Z[TSize]>\n" "" : [D] "=Tr"(dst.data()) : [TCode] "i"(type_traits::TypeCode), @@ -12419,7 +12419,7 @@ asm volatile( "B.DIM zero, %c[VCOL], ->lb0\n" "B.DIM zero, %c[VROW], ->lb1\n" "B.DIM zero, %c[Cols], ->lb2\n" - "B.IOT %[S0].reuse, %[S1].reuse, mask=1111, last, ->%[D]<%Z[TSize]>\n" + "B.IOT %[S0], %[S1], mask=1111, last, ->%[D]<%Z[TSize]>\n" "" : [D] "=Tr"(dst.data()) : [TCode] "i"(type_traits::TypeCode), @@ -12437,7 +12437,7 @@ asm volatile( "B.DIM zero, %c[VCOL], ->lb0\n" "B.DIM %[VROW], 0, ->lb1\n" "B.DIM zero, %c[Cols], ->lb2\n" - "B.IOT %[S0].reuse, %[S1].reuse, mask=1111, last, ->%[D]<%Z[TSize]>\n" + "B.IOT %[S0], %[S1], mask=1111, last, ->%[D]<%Z[TSize]>\n" "" : [D] "=Tr"(dst.data()) : [TCode] "i"(type_traits::TypeCode), @@ -12455,7 +12455,7 @@ asm volatile( "B.DIM %[VCOL], 0, ->lb0\n" "B.DIM zero, %c[VROW], ->lb1\n" "B.DIM zero, %c[Cols], ->lb2\n" - "B.IOT %[S0].reuse, %[S1].reuse, mask=1111, last, ->%[D]<%Z[TSize]>\n" + "B.IOT %[S0], %[S1], mask=1111, last, ->%[D]<%Z[TSize]>\n" "" : [D] "=Tr"(dst.data()) : [TCode] "i"(type_traits::TypeCode), @@ -12473,7 +12473,7 @@ asm volatile( "B.DIM %[VCOL], 0, ->lb0\n" "B.DIM %[VROW], 0, ->lb1\n" "B.DIM zero, %c[Cols], ->lb2\n" - "B.IOT %[S0].reuse, %[S1].reuse, mask=1111, last, ->%[D]<%Z[TSize]>\n" + "B.IOT %[S0], %[S1], mask=1111, last, ->%[D]<%Z[TSize]>\n" "" : [D] "=Tr"(dst.data()) : [TCode] "i"(type_traits::TypeCode), @@ -12492,7 +12492,7 @@ asm volatile( "B.DIM zero, %c[VCOL], ->lb0\n" "B.DIM zero, %c[VROW], ->lb1\n" "B.DIM zero, %c[Cols], ->lb2\n" - "B.IOT %[S0].reuse, %[S1].reuse, mask=1111, last, ->%[D]<%Z[TSize]>\n" + "B.IOT %[S0], %[S1], mask=1111, last, ->%[D]<%Z[TSize]>\n" "" : [D] "=Tr"(dst.data()) : [TCode] "i"(type_traits::TypeCode), @@ -12510,7 +12510,7 @@ asm volatile( "B.DIM zero, %c[VCOL], ->lb0\n" "B.DIM %[VROW], 0, ->lb1\n" "B.DIM zero, %c[Cols], ->lb2\n" - "B.IOT %[S0].reuse, %[S1].reuse, mask=1111, last, ->%[D]<%Z[TSize]>\n" + "B.IOT %[S0], %[S1], mask=1111, last, ->%[D]<%Z[TSize]>\n" "" : [D] "=Tr"(dst.data()) : [TCode] "i"(type_traits::TypeCode), @@ -12528,7 +12528,7 @@ asm volatile( "B.DIM %[VCOL], 0, ->lb0\n" "B.DIM zero, %c[VROW], ->lb1\n" "B.DIM zero, %c[Cols], ->lb2\n" - "B.IOT %[S0].reuse, %[S1].reuse, mask=1111, last, ->%[D]<%Z[TSize]>\n" + "B.IOT %[S0], %[S1], mask=1111, last, ->%[D]<%Z[TSize]>\n" "" : [D] "=Tr"(dst.data()) : [TCode] "i"(type_traits::TypeCode), @@ -12546,7 +12546,7 @@ asm volatile( "B.DIM %[VCOL], 0, ->lb0\n" "B.DIM %[VROW], 0, ->lb1\n" "B.DIM zero, %c[Cols], ->lb2\n" - "B.IOT %[S0].reuse, %[S1].reuse, mask=1111, last, ->%[D]<%Z[TSize]>\n" + "B.IOT %[S0], %[S1], mask=1111, last, ->%[D]<%Z[TSize]>\n" "" : [D] "=Tr"(dst.data()) : [TCode] "i"(type_traits::TypeCode), @@ -12565,7 +12565,7 @@ asm volatile( "B.DIM zero, %c[VCOL], ->lb0\n" "B.DIM zero, %c[VROW], ->lb1\n" "B.DIM zero, %c[Cols], ->lb2\n" - "B.IOT %[S0].reuse, %[S1].reuse, mask=1111, last, ->%[D]<%Z[TSize]>\n" + "B.IOT %[S0], %[S1], mask=1111, last, ->%[D]<%Z[TSize]>\n" "" : [D] "=Tr"(dst.data()) : [TCode] "i"(type_traits::TypeCode), @@ -12583,7 +12583,7 @@ asm volatile( "B.DIM zero, %c[VCOL], ->lb0\n" "B.DIM %[VROW], 0, ->lb1\n" "B.DIM zero, %c[Cols], ->lb2\n" - "B.IOT %[S0].reuse, %[S1].reuse, mask=1111, last, ->%[D]<%Z[TSize]>\n" + "B.IOT %[S0], %[S1], mask=1111, last, ->%[D]<%Z[TSize]>\n" "" : [D] "=Tr"(dst.data()) : [TCode] "i"(type_traits::TypeCode), @@ -12601,7 +12601,7 @@ asm volatile( "B.DIM %[VCOL], 0, ->lb0\n" "B.DIM zero, %c[VROW], ->lb1\n" "B.DIM zero, %c[Cols], ->lb2\n" - "B.IOT %[S0].reuse, %[S1].reuse, mask=1111, last, ->%[D]<%Z[TSize]>\n" + "B.IOT %[S0], %[S1], mask=1111, last, ->%[D]<%Z[TSize]>\n" "" : [D] "=Tr"(dst.data()) : [TCode] "i"(type_traits::TypeCode), @@ -12619,7 +12619,7 @@ asm volatile( "B.DIM %[VCOL], 0, ->lb0\n" "B.DIM %[VROW], 0, ->lb1\n" "B.DIM zero, %c[Cols], ->lb2\n" - "B.IOT %[S0].reuse, %[S1].reuse, mask=1111, last, ->%[D]<%Z[TSize]>\n" + "B.IOT %[S0], %[S1], mask=1111, last, ->%[D]<%Z[TSize]>\n" "" : [D] "=Tr"(dst.data()) : [TCode] "i"(type_traits::TypeCode), @@ -12638,7 +12638,7 @@ asm volatile( "B.DIM zero, %c[VCOL], ->lb0\n" "B.DIM zero, %c[VROW], ->lb1\n" "B.DIM zero, %c[Cols], ->lb2\n" - "B.IOT %[S0].reuse, %[S1].reuse, mask=1111, last, ->%[D]<%Z[TSize]>\n" + "B.IOT %[S0], %[S1], mask=1111, last, ->%[D]<%Z[TSize]>\n" "" : [D] "=Tr"(dst.data()) : [TCode] "i"(type_traits::TypeCode), @@ -12656,7 +12656,7 @@ asm volatile( "B.DIM zero, %c[VCOL], ->lb0\n" "B.DIM %[VROW], 0, ->lb1\n" "B.DIM zero, %c[Cols], ->lb2\n" - "B.IOT %[S0].reuse, %[S1].reuse, mask=1111, last, ->%[D]<%Z[TSize]>\n" + "B.IOT %[S0], %[S1], mask=1111, last, ->%[D]<%Z[TSize]>\n" "" : [D] "=Tr"(dst.data()) : [TCode] "i"(type_traits::TypeCode), @@ -12674,7 +12674,7 @@ asm volatile( "B.DIM %[VCOL], 0, ->lb0\n" "B.DIM zero, %c[VROW], ->lb1\n" "B.DIM zero, %c[Cols], ->lb2\n" - "B.IOT %[S0].reuse, %[S1].reuse, mask=1111, last, ->%[D]<%Z[TSize]>\n" + "B.IOT %[S0], %[S1], mask=1111, last, ->%[D]<%Z[TSize]>\n" "" : [D] "=Tr"(dst.data()) : [TCode] "i"(type_traits::TypeCode), @@ -12692,7 +12692,7 @@ asm volatile( "B.DIM %[VCOL], 0, ->lb0\n" "B.DIM %[VROW], 0, ->lb1\n" "B.DIM zero, %c[Cols], ->lb2\n" - "B.IOT %[S0].reuse, %[S1].reuse, mask=1111, last, ->%[D]<%Z[TSize]>\n" + "B.IOT %[S0], %[S1], mask=1111, last, ->%[D]<%Z[TSize]>\n" "" : [D] "=Tr"(dst.data()) : [TCode] "i"(type_traits::TypeCode), @@ -12751,8 +12751,8 @@ void TSEL(tile_shape &dst, mask_shape &mask, true_shape &true_src) { "B.DIM zero, %c3, ->lb0\n" "B.DIM zero, %c4, ->lb1\n" "B.DIM zero, %c5, ->lb2\n" - "B.IOT %6.reuse, %7.reuse, mask=1111\n" - "B.IOT %1.reuse, mask=1111, last, ->%0<%Z8>\n" + "B.IOT %6, %7, mask=1111\n" + "B.IOT %1, mask=1111, last, ->%0<%Z8>\n" "" : [Dst] "=Tr"(dst.data()) : [Prior] "0"(dst.data()), @@ -12769,8 +12769,8 @@ void TSEL(tile_shape &dst, mask_shape &mask, true_shape &true_src) { "B.DIM zero, %c3, ->lb0\n" "B.DIM %[mask____dimrow], 0, ->lb1\n" "B.DIM zero, %c5, ->lb2\n" - "B.IOT %6.reuse, %7.reuse, mask=1111\n" - "B.IOT %1.reuse, mask=1111, last, ->%0<%Z8>\n" + "B.IOT %6, %7, mask=1111\n" + "B.IOT %1, mask=1111, last, ->%0<%Z8>\n" "" : [Dst] "=Tr"(dst.data()) : [Prior] "0"(dst.data()), @@ -12787,8 +12787,8 @@ void TSEL(tile_shape &dst, mask_shape &mask, true_shape &true_src) { "B.DIM %[mask____dimcol], 0, ->lb0\n" "B.DIM zero, %c4, ->lb1\n" "B.DIM zero, %c5, ->lb2\n" - "B.IOT %6.reuse, %7.reuse, mask=1111\n" - "B.IOT %1.reuse, mask=1111, last, ->%0<%Z8>\n" + "B.IOT %6, %7, mask=1111\n" + "B.IOT %1, mask=1111, last, ->%0<%Z8>\n" "" : [Dst] "=Tr"(dst.data()) : [Prior] "0"(dst.data()), @@ -12805,8 +12805,8 @@ void TSEL(tile_shape &dst, mask_shape &mask, true_shape &true_src) { "B.DIM %[mask____dimcol], 0, ->lb0\n" "B.DIM %[mask____dimrow], 0, ->lb1\n" "B.DIM zero, %c5, ->lb2\n" - "B.IOT %6.reuse, %7.reuse, mask=1111\n" - "B.IOT %1.reuse, mask=1111, last, ->%0<%Z8>\n" + "B.IOT %6, %7, mask=1111\n" + "B.IOT %1, mask=1111, last, ->%0<%Z8>\n" "" : [Dst] "=Tr"(dst.data()) : [Prior] "0"(dst.data()), @@ -12838,7 +12838,7 @@ void TABS(tile_shape_out &dst, const tile_shape_in &src) { "B.DIM zero, %c2, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -12855,7 +12855,7 @@ void TABS(tile_shape_out &dst, const tile_shape_in &src) { "B.DIM zero, %c2, ->lb0\n" "B.DIM %[src____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -12872,7 +12872,7 @@ void TABS(tile_shape_out &dst, const tile_shape_in &src) { "B.DIM %[src____dimcol], 0, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -12889,7 +12889,7 @@ void TABS(tile_shape_out &dst, const tile_shape_in &src) { "B.DIM %[src____dimcol], 0, ->lb0\n" "B.DIM %[src____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -12912,7 +12912,7 @@ void TNOT(tile_shape &dst, tile_shape &src) { "B.DIM zero, %c2, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -12929,7 +12929,7 @@ void TNOT(tile_shape &dst, tile_shape &src) { "B.DIM zero, %c2, ->lb0\n" "B.DIM %[src____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -12946,7 +12946,7 @@ void TNOT(tile_shape &dst, tile_shape &src) { "B.DIM %[src____dimcol], 0, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -12963,7 +12963,7 @@ void TNOT(tile_shape &dst, tile_shape &src) { "B.DIM %[src____dimcol], 0, ->lb0\n" "B.DIM %[src____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -12986,7 +12986,7 @@ void TNEG(tile_shape &dst, tile_shape &src) { "B.DIM zero, %c2, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -13003,7 +13003,7 @@ void TNEG(tile_shape &dst, tile_shape &src) { "B.DIM zero, %c2, ->lb0\n" "B.DIM %[src____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -13020,7 +13020,7 @@ void TNEG(tile_shape &dst, tile_shape &src) { "B.DIM %[src____dimcol], 0, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -13037,7 +13037,7 @@ void TNEG(tile_shape &dst, tile_shape &src) { "B.DIM %[src____dimcol], 0, ->lb0\n" "B.DIM %[src____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -13060,7 +13060,7 @@ void TEXP(tile_shape &dst, tile_shape &src) { "B.DIM zero, %c2, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -13077,7 +13077,7 @@ void TEXP(tile_shape &dst, tile_shape &src) { "B.DIM zero, %c2, ->lb0\n" "B.DIM %[src____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -13094,7 +13094,7 @@ void TEXP(tile_shape &dst, tile_shape &src) { "B.DIM %[src____dimcol], 0, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -13111,7 +13111,7 @@ void TEXP(tile_shape &dst, tile_shape &src) { "B.DIM %[src____dimcol], 0, ->lb0\n" "B.DIM %[src____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -13151,7 +13151,7 @@ void TEXPDIF(D &dst, A &src0, B &src1) { "B.DIM zero, %c[ValidCol], ->lb0\n" "B.DIM zero, %c[ValidRow], ->lb1\n" "B.DIM zero, %c[Cols], ->lb2\n" - "B.IOT %[Src0].reuse, %[Src1].reuse, mask=1111, last, ->%[Dst]<%Z[Size]>\n" + "B.IOT %[Src0], %[Src1], mask=1111, last, ->%[Dst]<%Z[Size]>\n" "" : [Dst] "=Tr"(dst.data()) : [SrcType] "i"(type_traits::TypeCode), @@ -13174,7 +13174,7 @@ void TLOG(tile_shape &dst, tile_shape &src) { "B.DIM zero, %c2, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -13191,7 +13191,7 @@ void TLOG(tile_shape &dst, tile_shape &src) { "B.DIM zero, %c2, ->lb0\n" "B.DIM %[src____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -13208,7 +13208,7 @@ void TLOG(tile_shape &dst, tile_shape &src) { "B.DIM %[src____dimcol], 0, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -13225,7 +13225,7 @@ void TLOG(tile_shape &dst, tile_shape &src) { "B.DIM %[src____dimcol], 0, ->lb0\n" "B.DIM %[src____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -13250,7 +13250,7 @@ asm volatile( "B.DIM zero, %c2, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -13267,7 +13267,7 @@ asm volatile( "B.DIM zero, %c2, ->lb0\n" "B.DIM %[dyn_row], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -13284,7 +13284,7 @@ asm volatile( "B.DIM %[dyn_col], 0, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -13301,7 +13301,7 @@ asm volatile( "B.DIM %[dyn_col], 0, ->lb0\n" "B.DIM %[dyn_row], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -13323,7 +13323,7 @@ void TSQRT(tile_shape &dst, tile_shape &src) { "B.DIM zero, %c2, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -13340,7 +13340,7 @@ void TSQRT(tile_shape &dst, tile_shape &src) { "B.DIM zero, %c2, ->lb0\n" "B.DIM %[src____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -13357,7 +13357,7 @@ void TSQRT(tile_shape &dst, tile_shape &src) { "B.DIM %[src____dimcol], 0, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -13374,7 +13374,7 @@ void TSQRT(tile_shape &dst, tile_shape &src) { "B.DIM %[src____dimcol], 0, ->lb0\n" "B.DIM %[src____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -13397,7 +13397,7 @@ void TRSQRT(tile_shape &dst, tile_shape &src) { "B.DIM zero, %c2, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -13414,7 +13414,7 @@ void TRSQRT(tile_shape &dst, tile_shape &src) { "B.DIM zero, %c2, ->lb0\n" "B.DIM %[src____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -13431,7 +13431,7 @@ void TRSQRT(tile_shape &dst, tile_shape &src) { "B.DIM %[src____dimcol], 0, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -13448,7 +13448,7 @@ void TRSQRT(tile_shape &dst, tile_shape &src) { "B.DIM %[src____dimcol], 0, ->lb0\n" "B.DIM %[src____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -13471,7 +13471,7 @@ void TRELU(tile_shape &dst, tile_shape &src) { "B.DIM zero, %c2, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -13488,7 +13488,7 @@ void TRELU(tile_shape &dst, tile_shape &src) { "B.DIM zero, %c2, ->lb0\n" "B.DIM %[src____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -13505,7 +13505,7 @@ void TRELU(tile_shape &dst, tile_shape &src) { "B.DIM %[src____dimcol], 0, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -13522,7 +13522,7 @@ void TRELU(tile_shape &dst, tile_shape &src) { "B.DIM %[src____dimcol], 0, ->lb0\n" "B.DIM %[src____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -13561,126 +13561,6 @@ void TCVT(tile_shape_out &dst, tile_shape_in &src) { //===--- TEPL Mode 1: tile-scalar elementwise ops (BSTART.TEPL) ---===// // opcode = Mode(1) * 32 + Function = 32 + Function. -// TLEA: extend logical element indices to 64 bits and scale them to byte -// offsets. dst[i] = extend64(src[i]) * (element_bits / 8), keeping the low -// 64 bits (signed src sign-extends, unsigned src zero-extends; no saturation -// or overflow fault). `src` holds persistent Local S32/U32/S64/U64 element -// indices; `dst` is a new Local S64/U64 byte-offset tile with the same logical -// valid shape; `element_bits` is the per-PE element width in bits (8/16/32/64). -// PTO ISA: TEPL Mode 1 Function 14 (selector 0x02E, BSTART.TEPL on the source -// DataType). RowMajor or CUBE_M32 only; Shared and CUBE_N8/CUBE_M16 reject. -// Generates byte offsets only -- no BaseGPR add, no memory access, no -// numeric-status update. (spec: asl/tile/tile-scalar-and-immediate/arithmetic/ -// TLEA.asl, PTO-TILE-TLEA.) -template -void TLEA(tile_shape_out &dst, tile_shape_in &src, unsigned element_bits) { - constexpr int SrcType = type_traits::TypeCode; - constexpr int DstType = type_traits::TypeCode; - static_assert(SrcType == __type_int32 || SrcType == __type_uint32 || - SrcType == __type_int64 || SrcType == __type_uint64, - "TLEA source index tile must use S32, U32, S64, or U64"); - static_assert(DstType == __type_int64 || DstType == __type_uint64, - "TLEA destination must be an S64 or U64 byte-offset tile"); - static_assert(tile_shape_out::BFractal == BLayout::RowMajor || - tile_shape_out::BFractal == BLayout::CubeM32, - "TLEA destination layout must be RowMajor or CUBE_M32 " - "(Shared, CUBE_N8, and CUBE_M16 reject)"); - static_assert(tile_shape_in::BFractal == tile_shape_out::BFractal, - "TLEA source and destination must share the RowMajor/CUBE_M32 " - "layout"); - static_assert((tile_shape_in::ValidCol == DYNAMIC || - tile_shape_out::ValidCol == DYNAMIC || - tile_shape_in::ValidCol == tile_shape_out::ValidCol) && - (tile_shape_in::ValidRow == DYNAMIC || - tile_shape_out::ValidRow == DYNAMIC || - tile_shape_in::ValidRow == tile_shape_out::ValidRow), - "TLEA source and destination must share one logical valid " - "shape (ValidRow x ValidCol)"); - // Anti-fold: keep a compile-time-constant width (e.g. 8) off the zero - // register so B.IOR [width],[] still matches an instruction. The zero - // register is an illegal (zero) element width for an active block. - unsigned ebits = element_bits; - asm("" : "+r"(ebits)); - const size_t valid_col = src.GetValidCol(); - const size_t valid_row = src.GetValidRow(); - if constexpr (tile_shape_in::ValidCol > 0 && tile_shape_in::ValidRow > 0) { -asm volatile( - "BSTART.TEPL 46, %D1\n" - PTO_ELEMENTWISE_LAYOUT_ASM - "B.DIM zero, %c2, ->lb0\n" - "B.DIM zero, %c3, ->lb1\n" - "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" - "B.IOR [%7],[]\n" - "" - : "=Tr"(dst.data()) - : "i"(type_traits::TypeCode), - "i"(tile_shape_in::ValidCol), "i"(tile_shape_in::ValidRow), - "i"(tile_shape_out::Cols), - "Tr"(src.data()), - "i"(tile_type_traits::TilesizeCode), - "r"(ebits), - [ElemLayout] "i"(local_layout_code_v) - ); } - else if constexpr (tile_shape_in::ValidCol > 0 && tile_shape_in::ValidRow < 0) { -asm volatile( - "BSTART.TEPL 46, %D1\n" - PTO_ELEMENTWISE_LAYOUT_ASM - "B.DIM zero, %c2, ->lb0\n" - "B.DIM %[dyn_row], 0, ->lb1\n" - "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" - "B.IOR [%7],[]\n" - "" - : "=Tr"(dst.data()) - : "i"(type_traits::TypeCode), - "i"(tile_shape_in::ValidCol), [dyn_row] "r"(valid_row), - "i"(tile_shape_out::Cols), - "Tr"(src.data()), - "i"(tile_type_traits::TilesizeCode), - "r"(ebits), - [ElemLayout] "i"(local_layout_code_v) - ); } - else if constexpr (tile_shape_in::ValidCol < 0 && tile_shape_in::ValidRow > 0) { -asm volatile( - "BSTART.TEPL 46, %D1\n" - PTO_ELEMENTWISE_LAYOUT_ASM - "B.DIM %[dyn_col], 0, ->lb0\n" - "B.DIM zero, %c3, ->lb1\n" - "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" - "B.IOR [%7],[]\n" - "" - : "=Tr"(dst.data()) - : "i"(type_traits::TypeCode), - [dyn_col] "r"(valid_col), "i"(tile_shape_in::ValidRow), - "i"(tile_shape_out::Cols), - "Tr"(src.data()), - "i"(tile_type_traits::TilesizeCode), - "r"(ebits), - [ElemLayout] "i"(local_layout_code_v) - ); } - else { -asm volatile( - "BSTART.TEPL 46, %D1\n" - PTO_ELEMENTWISE_LAYOUT_ASM - "B.DIM %[dyn_col], 0, ->lb0\n" - "B.DIM %[dyn_row], 0, ->lb1\n" - "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" - "B.IOR [%7],[]\n" - "" - : "=Tr"(dst.data()) - : "i"(type_traits::TypeCode), - [dyn_col] "r"(valid_col), [dyn_row] "r"(valid_row), - "i"(tile_shape_out::Cols), - "Tr"(src.data()), - "i"(tile_type_traits::TilesizeCode), - "r"(ebits), - [ElemLayout] "i"(local_layout_code_v) - ); } -} - // TADDS: dst = src + scalar template void TADDS(tile_shape &dst, tile_shape &src, typename tile_shape::DType s) { @@ -13697,7 +13577,7 @@ asm volatile( "B.DIM zero, %c2, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "B.IOR [%7],[]\n" "" : "=Tr"(dst.data()) @@ -13716,7 +13596,7 @@ asm volatile( "B.DIM zero, %c2, ->lb0\n" "B.DIM %[dyn_row], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "B.IOR [%7],[]\n" "" : "=Tr"(dst.data()) @@ -13735,7 +13615,7 @@ asm volatile( "B.DIM %[dyn_col], 0, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "B.IOR [%7],[]\n" "" : "=Tr"(dst.data()) @@ -13754,7 +13634,7 @@ asm volatile( "B.DIM %[dyn_col], 0, ->lb0\n" "B.DIM %[dyn_row], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "B.IOR [%7],[]\n" "" : "=Tr"(dst.data()) @@ -13782,7 +13662,7 @@ void TSUBS(tile_shape &dst, tile_shape &src, typename tile_shape::DType s) { "B.DIM zero, %c2, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "B.IOR [%7],[]\n" "" : "=Tr"(dst.data()) @@ -13805,7 +13685,7 @@ void TSUBS(tile_shape &dst, tile_shape &src, typename tile_shape::DType s) { "B.DIM zero, %c2, ->lb0\n" "B.DIM %[src____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "B.IOR [%7],[]\n" "" : "=Tr"(dst.data()) @@ -13828,7 +13708,7 @@ void TSUBS(tile_shape &dst, tile_shape &src, typename tile_shape::DType s) { "B.DIM %[src____dimcol], 0, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "B.IOR [%7],[]\n" "" : "=Tr"(dst.data()) @@ -13851,7 +13731,7 @@ void TSUBS(tile_shape &dst, tile_shape &src, typename tile_shape::DType s) { "B.DIM %[src____dimcol], 0, ->lb0\n" "B.DIM %[src____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "B.IOR [%7],[]\n" "" : "=Tr"(dst.data()) @@ -13882,7 +13762,7 @@ asm volatile( "B.DIM zero, %c2, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "B.IOR [%7],[]\n" "" : "=Tr"(dst.data()) @@ -13901,7 +13781,7 @@ asm volatile( "B.DIM zero, %c2, ->lb0\n" "B.DIM %[dyn_row], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "B.IOR [%7],[]\n" "" : "=Tr"(dst.data()) @@ -13920,7 +13800,7 @@ asm volatile( "B.DIM %[dyn_col], 0, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "B.IOR [%7],[]\n" "" : "=Tr"(dst.data()) @@ -13939,7 +13819,7 @@ asm volatile( "B.DIM %[dyn_col], 0, ->lb0\n" "B.DIM %[dyn_row], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "B.IOR [%7],[]\n" "" : "=Tr"(dst.data()) @@ -13967,7 +13847,7 @@ void TDIVS(tile_shape &dst, tile_shape &src, typename tile_shape::DType s) { "B.DIM zero, %c2, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "B.IOR [%7],[]\n" "" : "=Tr"(dst.data()) @@ -13990,7 +13870,7 @@ void TDIVS(tile_shape &dst, tile_shape &src, typename tile_shape::DType s) { "B.DIM zero, %c2, ->lb0\n" "B.DIM %[src____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "B.IOR [%7],[]\n" "" : "=Tr"(dst.data()) @@ -14013,7 +13893,7 @@ void TDIVS(tile_shape &dst, tile_shape &src, typename tile_shape::DType s) { "B.DIM %[src____dimcol], 0, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "B.IOR [%7],[]\n" "" : "=Tr"(dst.data()) @@ -14036,7 +13916,7 @@ void TDIVS(tile_shape &dst, tile_shape &src, typename tile_shape::DType s) { "B.DIM %[src____dimcol], 0, ->lb0\n" "B.DIM %[src____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "B.IOR [%7],[]\n" "" : "=Tr"(dst.data()) @@ -14065,7 +13945,7 @@ void TREMS(tile_shape &dst, tile_shape &src, typename tile_shape::DType s) { "B.DIM zero, %c2, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "B.IOR [%7],[]\n" "" : "=Tr"(dst.data()) @@ -14088,7 +13968,7 @@ void TREMS(tile_shape &dst, tile_shape &src, typename tile_shape::DType s) { "B.DIM zero, %c2, ->lb0\n" "B.DIM %[src____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "B.IOR [%7],[]\n" "" : "=Tr"(dst.data()) @@ -14111,7 +13991,7 @@ void TREMS(tile_shape &dst, tile_shape &src, typename tile_shape::DType s) { "B.DIM %[src____dimcol], 0, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "B.IOR [%7],[]\n" "" : "=Tr"(dst.data()) @@ -14134,7 +14014,7 @@ void TREMS(tile_shape &dst, tile_shape &src, typename tile_shape::DType s) { "B.DIM %[src____dimcol], 0, ->lb0\n" "B.DIM %[src____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "B.IOR [%7],[]\n" "" : "=Tr"(dst.data()) @@ -14171,7 +14051,7 @@ void TANDS(tile_shape &dst, tile_shape &src, typename tile_shape::DType s) { "B.DIM zero, %c2, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "B.IOR [%7],[]\n" "" : "=Tr"(dst.data()) @@ -14194,7 +14074,7 @@ void TANDS(tile_shape &dst, tile_shape &src, typename tile_shape::DType s) { "B.DIM zero, %c2, ->lb0\n" "B.DIM %[src____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "B.IOR [%7],[]\n" "" : "=Tr"(dst.data()) @@ -14217,7 +14097,7 @@ void TANDS(tile_shape &dst, tile_shape &src, typename tile_shape::DType s) { "B.DIM %[src____dimcol], 0, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "B.IOR [%7],[]\n" "" : "=Tr"(dst.data()) @@ -14240,7 +14120,7 @@ void TANDS(tile_shape &dst, tile_shape &src, typename tile_shape::DType s) { "B.DIM %[src____dimcol], 0, ->lb0\n" "B.DIM %[src____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "B.IOR [%7],[]\n" "" : "=Tr"(dst.data()) @@ -14269,7 +14149,7 @@ void TORS(tile_shape &dst, tile_shape &src, typename tile_shape::DType s) { "B.DIM zero, %c2, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "B.IOR [%7],[]\n" "" : "=Tr"(dst.data()) @@ -14292,7 +14172,7 @@ void TORS(tile_shape &dst, tile_shape &src, typename tile_shape::DType s) { "B.DIM zero, %c2, ->lb0\n" "B.DIM %[src____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "B.IOR [%7],[]\n" "" : "=Tr"(dst.data()) @@ -14315,7 +14195,7 @@ void TORS(tile_shape &dst, tile_shape &src, typename tile_shape::DType s) { "B.DIM %[src____dimcol], 0, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "B.IOR [%7],[]\n" "" : "=Tr"(dst.data()) @@ -14338,7 +14218,7 @@ void TORS(tile_shape &dst, tile_shape &src, typename tile_shape::DType s) { "B.DIM %[src____dimcol], 0, ->lb0\n" "B.DIM %[src____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "B.IOR [%7],[]\n" "" : "=Tr"(dst.data()) @@ -14367,7 +14247,7 @@ void TXORS(tile_shape &dst, tile_shape &src, typename tile_shape::DType s) { "B.DIM zero, %c2, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "B.IOR [%7],[]\n" "" : "=Tr"(dst.data()) @@ -14390,7 +14270,7 @@ void TXORS(tile_shape &dst, tile_shape &src, typename tile_shape::DType s) { "B.DIM zero, %c2, ->lb0\n" "B.DIM %[src____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "B.IOR [%7],[]\n" "" : "=Tr"(dst.data()) @@ -14413,7 +14293,7 @@ void TXORS(tile_shape &dst, tile_shape &src, typename tile_shape::DType s) { "B.DIM %[src____dimcol], 0, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "B.IOR [%7],[]\n" "" : "=Tr"(dst.data()) @@ -14436,7 +14316,7 @@ void TXORS(tile_shape &dst, tile_shape &src, typename tile_shape::DType s) { "B.DIM %[src____dimcol], 0, ->lb0\n" "B.DIM %[src____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "B.IOR [%7],[]\n" "" : "=Tr"(dst.data()) @@ -14465,7 +14345,7 @@ void TSHLS(tile_shape &dst, tile_shape &src, typename tile_shape::DType s) { "B.DIM zero, %c2, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "B.IOR [%7],[]\n" "" : "=Tr"(dst.data()) @@ -14488,7 +14368,7 @@ void TSHLS(tile_shape &dst, tile_shape &src, typename tile_shape::DType s) { "B.DIM zero, %c2, ->lb0\n" "B.DIM %[src____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "B.IOR [%7],[]\n" "" : "=Tr"(dst.data()) @@ -14511,7 +14391,7 @@ void TSHLS(tile_shape &dst, tile_shape &src, typename tile_shape::DType s) { "B.DIM %[src____dimcol], 0, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "B.IOR [%7],[]\n" "" : "=Tr"(dst.data()) @@ -14534,7 +14414,7 @@ void TSHLS(tile_shape &dst, tile_shape &src, typename tile_shape::DType s) { "B.DIM %[src____dimcol], 0, ->lb0\n" "B.DIM %[src____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "B.IOR [%7],[]\n" "" : "=Tr"(dst.data()) @@ -14563,7 +14443,7 @@ void TSHRS(tile_shape &dst, tile_shape &src, typename tile_shape::DType s) { "B.DIM zero, %c2, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "B.IOR [%7],[]\n" "" : "=Tr"(dst.data()) @@ -14586,7 +14466,7 @@ void TSHRS(tile_shape &dst, tile_shape &src, typename tile_shape::DType s) { "B.DIM zero, %c2, ->lb0\n" "B.DIM %[src____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "B.IOR [%7],[]\n" "" : "=Tr"(dst.data()) @@ -14609,7 +14489,7 @@ void TSHRS(tile_shape &dst, tile_shape &src, typename tile_shape::DType s) { "B.DIM %[src____dimcol], 0, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "B.IOR [%7],[]\n" "" : "=Tr"(dst.data()) @@ -14632,7 +14512,7 @@ void TSHRS(tile_shape &dst, tile_shape &src, typename tile_shape::DType s) { "B.DIM %[src____dimcol], 0, ->lb0\n" "B.DIM %[src____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "B.IOR [%7],[]\n" "" : "=Tr"(dst.data()) @@ -14661,7 +14541,7 @@ void TMAXS(tile_shape &dst, tile_shape &src, typename tile_shape::DType s) { "B.DIM zero, %c2, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "B.IOR [%7],[]\n" "" : "=Tr"(dst.data()) @@ -14684,7 +14564,7 @@ void TMAXS(tile_shape &dst, tile_shape &src, typename tile_shape::DType s) { "B.DIM zero, %c2, ->lb0\n" "B.DIM %[src____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "B.IOR [%7],[]\n" "" : "=Tr"(dst.data()) @@ -14707,7 +14587,7 @@ void TMAXS(tile_shape &dst, tile_shape &src, typename tile_shape::DType s) { "B.DIM %[src____dimcol], 0, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "B.IOR [%7],[]\n" "" : "=Tr"(dst.data()) @@ -14730,7 +14610,7 @@ void TMAXS(tile_shape &dst, tile_shape &src, typename tile_shape::DType s) { "B.DIM %[src____dimcol], 0, ->lb0\n" "B.DIM %[src____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "B.IOR [%7],[]\n" "" : "=Tr"(dst.data()) @@ -14759,7 +14639,7 @@ void TMINS(tile_shape &dst, tile_shape &src, typename tile_shape::DType s) { "B.DIM zero, %c2, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "B.IOR [%7],[]\n" "" : "=Tr"(dst.data()) @@ -14782,7 +14662,7 @@ void TMINS(tile_shape &dst, tile_shape &src, typename tile_shape::DType s) { "B.DIM zero, %c2, ->lb0\n" "B.DIM %[src____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "B.IOR [%7],[]\n" "" : "=Tr"(dst.data()) @@ -14805,7 +14685,7 @@ void TMINS(tile_shape &dst, tile_shape &src, typename tile_shape::DType s) { "B.DIM %[src____dimcol], 0, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "B.IOR [%7],[]\n" "" : "=Tr"(dst.data()) @@ -14828,7 +14708,7 @@ void TMINS(tile_shape &dst, tile_shape &src, typename tile_shape::DType s) { "B.DIM %[src____dimcol], 0, ->lb0\n" "B.DIM %[src____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "B.IOR [%7],[]\n" "" : "=Tr"(dst.data()) @@ -14859,7 +14739,7 @@ void pto_prefix_unary(tile_shape &dst, View &src) { "B.DIM zero, %c2, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "B.SUBVIEW 0, %7, 0, 1\n" "" : "=Tr"(dst.data()) @@ -14890,7 +14770,7 @@ void pto_prefix_scalar(tile_shape &dst, View &src, "B.DIM zero, %c2, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "B.SUBVIEW 0, %7, 0, 1\n" "B.IOR [%8],[]\n" "" @@ -14972,7 +14852,7 @@ void TCVT(tile_shape_out &dst, View &src) { PTO_CUBE_TCVT_DATR_ASM "B.DIM zero, %c5, ->lb0\n" "B.DIM zero, %c6, ->lb1\n" - "B.IOT %3.reuse, mask=1111, last, ->%0<%Z4>\n" + "B.IOT %3, mask=1111, last, ->%0<%Z4>\n" "B.SUBVIEW 0, %7, 0, 1\n" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -15010,7 +14890,7 @@ asm volatile( "B.DIM zero, %c[VCOL], ->lb0\n" "B.DIM zero, %c[VROW], ->lb1\n" "B.DIM zero, %c[Cols], ->lb2\n" - "B.IOT %[S].reuse, mask=1111, last, ->%[D]<%Z[TSize]>\n" + "B.IOT %[S], mask=1111, last, ->%[D]<%Z[TSize]>\n" "B.IOR [%[Scalar]],[]\n" "" : [D] "=Tr"(dst.data()) @@ -15029,7 +14909,7 @@ asm volatile( "B.DIM zero, %c[VCOL], ->lb0\n" "B.DIM %[VROW], 0, ->lb1\n" "B.DIM zero, %c[Cols], ->lb2\n" - "B.IOT %[S].reuse, mask=1111, last, ->%[D]<%Z[TSize]>\n" + "B.IOT %[S], mask=1111, last, ->%[D]<%Z[TSize]>\n" "B.IOR [%[Scalar]],[]\n" "" : [D] "=Tr"(dst.data()) @@ -15048,7 +14928,7 @@ asm volatile( "B.DIM %[VCOL], 0, ->lb0\n" "B.DIM zero, %c[VROW], ->lb1\n" "B.DIM zero, %c[Cols], ->lb2\n" - "B.IOT %[S].reuse, mask=1111, last, ->%[D]<%Z[TSize]>\n" + "B.IOT %[S], mask=1111, last, ->%[D]<%Z[TSize]>\n" "B.IOR [%[Scalar]],[]\n" "" : [D] "=Tr"(dst.data()) @@ -15067,7 +14947,7 @@ asm volatile( "B.DIM %[VCOL], 0, ->lb0\n" "B.DIM %[VROW], 0, ->lb1\n" "B.DIM zero, %c[Cols], ->lb2\n" - "B.IOT %[S].reuse, mask=1111, last, ->%[D]<%Z[TSize]>\n" + "B.IOT %[S], mask=1111, last, ->%[D]<%Z[TSize]>\n" "B.IOR [%[Scalar]],[]\n" "" : [D] "=Tr"(dst.data()) @@ -15087,7 +14967,7 @@ asm volatile( "B.DIM zero, %c[VCOL], ->lb0\n" "B.DIM zero, %c[VROW], ->lb1\n" "B.DIM zero, %c[Cols], ->lb2\n" - "B.IOT %[S].reuse, mask=1111, last, ->%[D]<%Z[TSize]>\n" + "B.IOT %[S], mask=1111, last, ->%[D]<%Z[TSize]>\n" "B.IOR [%[Scalar]],[]\n" "" : [D] "=Tr"(dst.data()) @@ -15106,7 +14986,7 @@ asm volatile( "B.DIM zero, %c[VCOL], ->lb0\n" "B.DIM %[VROW], 0, ->lb1\n" "B.DIM zero, %c[Cols], ->lb2\n" - "B.IOT %[S].reuse, mask=1111, last, ->%[D]<%Z[TSize]>\n" + "B.IOT %[S], mask=1111, last, ->%[D]<%Z[TSize]>\n" "B.IOR [%[Scalar]],[]\n" "" : [D] "=Tr"(dst.data()) @@ -15125,7 +15005,7 @@ asm volatile( "B.DIM %[VCOL], 0, ->lb0\n" "B.DIM zero, %c[VROW], ->lb1\n" "B.DIM zero, %c[Cols], ->lb2\n" - "B.IOT %[S].reuse, mask=1111, last, ->%[D]<%Z[TSize]>\n" + "B.IOT %[S], mask=1111, last, ->%[D]<%Z[TSize]>\n" "B.IOR [%[Scalar]],[]\n" "" : [D] "=Tr"(dst.data()) @@ -15144,7 +15024,7 @@ asm volatile( "B.DIM %[VCOL], 0, ->lb0\n" "B.DIM %[VROW], 0, ->lb1\n" "B.DIM zero, %c[Cols], ->lb2\n" - "B.IOT %[S].reuse, mask=1111, last, ->%[D]<%Z[TSize]>\n" + "B.IOT %[S], mask=1111, last, ->%[D]<%Z[TSize]>\n" "B.IOR [%[Scalar]],[]\n" "" : [D] "=Tr"(dst.data()) @@ -15164,7 +15044,7 @@ asm volatile( "B.DIM zero, %c[VCOL], ->lb0\n" "B.DIM zero, %c[VROW], ->lb1\n" "B.DIM zero, %c[Cols], ->lb2\n" - "B.IOT %[S].reuse, mask=1111, last, ->%[D]<%Z[TSize]>\n" + "B.IOT %[S], mask=1111, last, ->%[D]<%Z[TSize]>\n" "B.IOR [%[Scalar]],[]\n" "" : [D] "=Tr"(dst.data()) @@ -15183,7 +15063,7 @@ asm volatile( "B.DIM zero, %c[VCOL], ->lb0\n" "B.DIM %[VROW], 0, ->lb1\n" "B.DIM zero, %c[Cols], ->lb2\n" - "B.IOT %[S].reuse, mask=1111, last, ->%[D]<%Z[TSize]>\n" + "B.IOT %[S], mask=1111, last, ->%[D]<%Z[TSize]>\n" "B.IOR [%[Scalar]],[]\n" "" : [D] "=Tr"(dst.data()) @@ -15202,7 +15082,7 @@ asm volatile( "B.DIM %[VCOL], 0, ->lb0\n" "B.DIM zero, %c[VROW], ->lb1\n" "B.DIM zero, %c[Cols], ->lb2\n" - "B.IOT %[S].reuse, mask=1111, last, ->%[D]<%Z[TSize]>\n" + "B.IOT %[S], mask=1111, last, ->%[D]<%Z[TSize]>\n" "B.IOR [%[Scalar]],[]\n" "" : [D] "=Tr"(dst.data()) @@ -15221,7 +15101,7 @@ asm volatile( "B.DIM %[VCOL], 0, ->lb0\n" "B.DIM %[VROW], 0, ->lb1\n" "B.DIM zero, %c[Cols], ->lb2\n" - "B.IOT %[S].reuse, mask=1111, last, ->%[D]<%Z[TSize]>\n" + "B.IOT %[S], mask=1111, last, ->%[D]<%Z[TSize]>\n" "B.IOR [%[Scalar]],[]\n" "" : [D] "=Tr"(dst.data()) @@ -15241,7 +15121,7 @@ asm volatile( "B.DIM zero, %c[VCOL], ->lb0\n" "B.DIM zero, %c[VROW], ->lb1\n" "B.DIM zero, %c[Cols], ->lb2\n" - "B.IOT %[S].reuse, mask=1111, last, ->%[D]<%Z[TSize]>\n" + "B.IOT %[S], mask=1111, last, ->%[D]<%Z[TSize]>\n" "B.IOR [%[Scalar]],[]\n" "" : [D] "=Tr"(dst.data()) @@ -15260,7 +15140,7 @@ asm volatile( "B.DIM zero, %c[VCOL], ->lb0\n" "B.DIM %[VROW], 0, ->lb1\n" "B.DIM zero, %c[Cols], ->lb2\n" - "B.IOT %[S].reuse, mask=1111, last, ->%[D]<%Z[TSize]>\n" + "B.IOT %[S], mask=1111, last, ->%[D]<%Z[TSize]>\n" "B.IOR [%[Scalar]],[]\n" "" : [D] "=Tr"(dst.data()) @@ -15279,7 +15159,7 @@ asm volatile( "B.DIM %[VCOL], 0, ->lb0\n" "B.DIM zero, %c[VROW], ->lb1\n" "B.DIM zero, %c[Cols], ->lb2\n" - "B.IOT %[S].reuse, mask=1111, last, ->%[D]<%Z[TSize]>\n" + "B.IOT %[S], mask=1111, last, ->%[D]<%Z[TSize]>\n" "B.IOR [%[Scalar]],[]\n" "" : [D] "=Tr"(dst.data()) @@ -15298,7 +15178,7 @@ asm volatile( "B.DIM %[VCOL], 0, ->lb0\n" "B.DIM %[VROW], 0, ->lb1\n" "B.DIM zero, %c[Cols], ->lb2\n" - "B.IOT %[S].reuse, mask=1111, last, ->%[D]<%Z[TSize]>\n" + "B.IOT %[S], mask=1111, last, ->%[D]<%Z[TSize]>\n" "B.IOR [%[Scalar]],[]\n" "" : [D] "=Tr"(dst.data()) @@ -15318,7 +15198,7 @@ asm volatile( "B.DIM zero, %c[VCOL], ->lb0\n" "B.DIM zero, %c[VROW], ->lb1\n" "B.DIM zero, %c[Cols], ->lb2\n" - "B.IOT %[S].reuse, mask=1111, last, ->%[D]<%Z[TSize]>\n" + "B.IOT %[S], mask=1111, last, ->%[D]<%Z[TSize]>\n" "B.IOR [%[Scalar]],[]\n" "" : [D] "=Tr"(dst.data()) @@ -15337,7 +15217,7 @@ asm volatile( "B.DIM zero, %c[VCOL], ->lb0\n" "B.DIM %[VROW], 0, ->lb1\n" "B.DIM zero, %c[Cols], ->lb2\n" - "B.IOT %[S].reuse, mask=1111, last, ->%[D]<%Z[TSize]>\n" + "B.IOT %[S], mask=1111, last, ->%[D]<%Z[TSize]>\n" "B.IOR [%[Scalar]],[]\n" "" : [D] "=Tr"(dst.data()) @@ -15356,7 +15236,7 @@ asm volatile( "B.DIM %[VCOL], 0, ->lb0\n" "B.DIM zero, %c[VROW], ->lb1\n" "B.DIM zero, %c[Cols], ->lb2\n" - "B.IOT %[S].reuse, mask=1111, last, ->%[D]<%Z[TSize]>\n" + "B.IOT %[S], mask=1111, last, ->%[D]<%Z[TSize]>\n" "B.IOR [%[Scalar]],[]\n" "" : [D] "=Tr"(dst.data()) @@ -15375,7 +15255,7 @@ asm volatile( "B.DIM %[VCOL], 0, ->lb0\n" "B.DIM %[VROW], 0, ->lb1\n" "B.DIM zero, %c[Cols], ->lb2\n" - "B.IOT %[S].reuse, mask=1111, last, ->%[D]<%Z[TSize]>\n" + "B.IOT %[S], mask=1111, last, ->%[D]<%Z[TSize]>\n" "B.IOR [%[Scalar]],[]\n" "" : [D] "=Tr"(dst.data()) @@ -15395,7 +15275,7 @@ asm volatile( "B.DIM zero, %c[VCOL], ->lb0\n" "B.DIM zero, %c[VROW], ->lb1\n" "B.DIM zero, %c[Cols], ->lb2\n" - "B.IOT %[S].reuse, mask=1111, last, ->%[D]<%Z[TSize]>\n" + "B.IOT %[S], mask=1111, last, ->%[D]<%Z[TSize]>\n" "B.IOR [%[Scalar]],[]\n" "" : [D] "=Tr"(dst.data()) @@ -15414,7 +15294,7 @@ asm volatile( "B.DIM zero, %c[VCOL], ->lb0\n" "B.DIM %[VROW], 0, ->lb1\n" "B.DIM zero, %c[Cols], ->lb2\n" - "B.IOT %[S].reuse, mask=1111, last, ->%[D]<%Z[TSize]>\n" + "B.IOT %[S], mask=1111, last, ->%[D]<%Z[TSize]>\n" "B.IOR [%[Scalar]],[]\n" "" : [D] "=Tr"(dst.data()) @@ -15433,7 +15313,7 @@ asm volatile( "B.DIM %[VCOL], 0, ->lb0\n" "B.DIM zero, %c[VROW], ->lb1\n" "B.DIM zero, %c[Cols], ->lb2\n" - "B.IOT %[S].reuse, mask=1111, last, ->%[D]<%Z[TSize]>\n" + "B.IOT %[S], mask=1111, last, ->%[D]<%Z[TSize]>\n" "B.IOR [%[Scalar]],[]\n" "" : [D] "=Tr"(dst.data()) @@ -15452,7 +15332,7 @@ asm volatile( "B.DIM %[VCOL], 0, ->lb0\n" "B.DIM %[VROW], 0, ->lb1\n" "B.DIM zero, %c[Cols], ->lb2\n" - "B.IOT %[S].reuse, mask=1111, last, ->%[D]<%Z[TSize]>\n" + "B.IOT %[S], mask=1111, last, ->%[D]<%Z[TSize]>\n" "B.IOR [%[Scalar]],[]\n" "" : [D] "=Tr"(dst.data()) @@ -15519,7 +15399,7 @@ uint64_t TCMPS(tile_shape_in &src, typename tile_shape_in::DType s) { "B.DIM zero, %c[VCOL], ->lb0\n" \ "B.DIM zero, %c[VROW], ->lb1\n" \ "B.DIM zero, %c[Cols], ->lb2\n" \ - "B.IOT %[Src].reuse, mask=1111, last\n" \ + "B.IOT %[Src], mask=1111, last\n" \ "B.IOR [%[Scalar]], %[Dst]\n" \ : [Dst] "=r"(result) \ : [Type] "i"(TypeCode), [VCOL] "i"(tile_shape_in::ValidCol), \ @@ -15591,7 +15471,7 @@ asm volatile( "B.DIM zero, %c2, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "B.IOR [%8],[]\n" "" : "=Tr"(dst.data()) @@ -15609,7 +15489,7 @@ asm volatile( "B.DIM zero, %c2, ->lb0\n" "B.DIM %[src0____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "B.IOR [%8],[]\n" "" : "=Tr"(dst.data()) @@ -15627,7 +15507,7 @@ asm volatile( "B.DIM %[src0____dimcol], 0, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "B.IOR [%8],[]\n" "" : "=Tr"(dst.data()) @@ -15645,7 +15525,7 @@ asm volatile( "B.DIM %[src0____dimcol], 0, ->lb0\n" "B.DIM %[src0____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "B.IOR [%8],[]\n" "" : "=Tr"(dst.data()) @@ -15766,8 +15646,8 @@ void TFMA(tile_shape &dst, tile_shape &src0, tile_shape &src1, tile_shape &src2) "B.DIM zero, %c2, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111\n" - "B.IOT %7.reuse, mask=1111, last, ->%0<%Z8>\n" + "B.IOT %5, %6, mask=1111\n" + "B.IOT %7, mask=1111, last, ->%0<%Z8>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -15786,8 +15666,8 @@ void TFMA(tile_shape &dst, tile_shape &src0, tile_shape &src1, tile_shape &src2) "B.DIM zero, %c2, ->lb0\n" "B.DIM %[src0____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111\n" - "B.IOT %7.reuse, mask=1111, last, ->%0<%Z8>\n" + "B.IOT %5, %6, mask=1111\n" + "B.IOT %7, mask=1111, last, ->%0<%Z8>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -15806,8 +15686,8 @@ void TFMA(tile_shape &dst, tile_shape &src0, tile_shape &src1, tile_shape &src2) "B.DIM %[src0____dimcol], 0, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111\n" - "B.IOT %7.reuse, mask=1111, last, ->%0<%Z8>\n" + "B.IOT %5, %6, mask=1111\n" + "B.IOT %7, mask=1111, last, ->%0<%Z8>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -15826,8 +15706,8 @@ void TFMA(tile_shape &dst, tile_shape &src0, tile_shape &src1, tile_shape &src2) "B.DIM %[src0____dimcol], 0, ->lb0\n" "B.DIM %[src0____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111\n" - "B.IOT %7.reuse, mask=1111, last, ->%0<%Z8>\n" + "B.IOT %5, %6, mask=1111\n" + "B.IOT %7, mask=1111, last, ->%0<%Z8>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -15860,8 +15740,8 @@ void TFMA(tile_shape &dst, mul0 &src0, mul1 &src1, View &src2) { "B.DIM zero, %c2, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111\n" - "B.IOT %7.reuse, mask=1111, last, ->%0<%Z8>\n" + "B.IOT %5, %6, mask=1111\n" + "B.IOT %7, mask=1111, last, ->%0<%Z8>\n" "B.SUBVIEW 0, %9, 0, 1\n" "" : "=Tr"(dst.data()) @@ -15882,8 +15762,8 @@ void TFMA(tile_shape &dst, mul0 &src0, mul1 &src1, View &src2) { "B.DIM zero, %c2, ->lb0\n" "B.DIM %[src0____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111\n" - "B.IOT %7.reuse, mask=1111, last, ->%0<%Z8>\n" + "B.IOT %5, %6, mask=1111\n" + "B.IOT %7, mask=1111, last, ->%0<%Z8>\n" "B.SUBVIEW 0, %9, 0, 1\n" "" : "=Tr"(dst.data()) @@ -15904,8 +15784,8 @@ void TFMA(tile_shape &dst, mul0 &src0, mul1 &src1, View &src2) { "B.DIM %[src0____dimcol], 0, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111\n" - "B.IOT %7.reuse, mask=1111, last, ->%0<%Z8>\n" + "B.IOT %5, %6, mask=1111\n" + "B.IOT %7, mask=1111, last, ->%0<%Z8>\n" "B.SUBVIEW 0, %9, 0, 1\n" "" : "=Tr"(dst.data()) @@ -15926,8 +15806,8 @@ void TFMA(tile_shape &dst, mul0 &src0, mul1 &src1, View &src2) { "B.DIM %[src0____dimcol], 0, ->lb0\n" "B.DIM %[src0____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111\n" - "B.IOT %7.reuse, mask=1111, last, ->%0<%Z8>\n" + "B.IOT %5, %6, mask=1111\n" + "B.IOT %7, mask=1111, last, ->%0<%Z8>\n" "B.SUBVIEW 0, %9, 0, 1\n" "" : "=Tr"(dst.data()) @@ -16609,7 +16489,7 @@ void TGATHER(tile_shape_out &dst, tile_shape_in &src, tile_shape_off &off) { "B.DIM zero, %c2, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %7.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, %7, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -16625,7 +16505,7 @@ void TGATHER(tile_shape_out &dst, tile_shape_in &src, tile_shape_off &off) { "B.DIM zero, %c2, ->lb0\n" "B.DIM %[off____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %7.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, %7, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -16641,7 +16521,7 @@ void TGATHER(tile_shape_out &dst, tile_shape_in &src, tile_shape_off &off) { "B.DIM %[off____dimcol], 0, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %7.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, %7, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -16657,7 +16537,7 @@ void TGATHER(tile_shape_out &dst, tile_shape_in &src, tile_shape_off &off) { "B.DIM %[off____dimcol], 0, ->lb0\n" "B.DIM %[off____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %7.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, %7, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -16679,7 +16559,7 @@ void TSCATTER(tile_shape_out &dst, tile_shape_in &src, tile_shape_off &off) { "B.DIM zero, %c2, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %7.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, %7, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -16695,7 +16575,7 @@ void TSCATTER(tile_shape_out &dst, tile_shape_in &src, tile_shape_off &off) { "B.DIM zero, %c2, ->lb0\n" "B.DIM %[off____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %7.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, %7, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -16711,7 +16591,7 @@ void TSCATTER(tile_shape_out &dst, tile_shape_in &src, tile_shape_off &off) { "B.DIM %[off____dimcol], 0, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %7.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, %7, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -16727,7 +16607,7 @@ void TSCATTER(tile_shape_out &dst, tile_shape_in &src, tile_shape_off &off) { "B.DIM %[off____dimcol], 0, ->lb0\n" "B.DIM %[off____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %7.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, %7, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -16818,7 +16698,7 @@ void TROWSUM(tile_shape_out &dst, tile_shape_in &src) { DIM_COL \ DIM_ROW \ "B.DIM zero, %c4, ->lb2\n" \ - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" \ + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" \ "B.ASSEMBLE 1, %c8, %[RegSrc], %c7, %c[WriterSize]\n" #define PTO_TROWSUM_ASM_INIT_INPUTS \ : "=Tr"(dst.data()) \ @@ -16861,7 +16741,7 @@ void TROWSUM(tile_shape_out &dst, tile_shape_in &src) { "B.DIM zero, %c2, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -16879,7 +16759,7 @@ void TROWSUM(tile_shape_out &dst, tile_shape_in &src) { "B.DIM zero, %c2, ->lb0\n" "B.DIM %[valid_row], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -16897,7 +16777,7 @@ void TROWSUM(tile_shape_out &dst, tile_shape_in &src) { "B.DIM %[valid_col], 0, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -16916,7 +16796,7 @@ void TROWSUM(tile_shape_out &dst, tile_shape_in &src) { "B.DIM %[valid_col], 0, ->lb0\n" "B.DIM %[valid_row], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -16948,7 +16828,7 @@ void TROWMAX(tile_shape_out &dst, tile_shape_in &src) { "B.DIM zero, %c2, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -16965,7 +16845,7 @@ void TROWMAX(tile_shape_out &dst, tile_shape_in &src) { "B.DIM zero, %c2, ->lb0\n" "B.DIM %[src____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -16982,7 +16862,7 @@ void TROWMAX(tile_shape_out &dst, tile_shape_in &src) { "B.DIM %[src____dimcol], 0, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -16999,7 +16879,7 @@ void TROWMAX(tile_shape_out &dst, tile_shape_in &src) { "B.DIM %[src____dimcol], 0, ->lb0\n" "B.DIM %[src____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -17031,7 +16911,7 @@ void TROWMIN(tile_shape_out &dst, tile_shape_in &src) { "B.DIM zero, %c2, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -17048,7 +16928,7 @@ void TROWMIN(tile_shape_out &dst, tile_shape_in &src) { "B.DIM zero, %c2, ->lb0\n" "B.DIM %[src____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -17065,7 +16945,7 @@ void TROWMIN(tile_shape_out &dst, tile_shape_in &src) { "B.DIM %[src____dimcol], 0, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -17082,7 +16962,7 @@ void TROWMIN(tile_shape_out &dst, tile_shape_in &src) { "B.DIM %[src____dimcol], 0, ->lb0\n" "B.DIM %[src____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -17114,7 +16994,7 @@ void TROWPROD(tile_shape_out &dst, tile_shape_in &src) { "B.DIM zero, %c2, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -17131,7 +17011,7 @@ void TROWPROD(tile_shape_out &dst, tile_shape_in &src) { "B.DIM zero, %c2, ->lb0\n" "B.DIM %[src____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -17148,7 +17028,7 @@ void TROWPROD(tile_shape_out &dst, tile_shape_in &src) { "B.DIM %[src____dimcol], 0, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -17165,7 +17045,7 @@ void TROWPROD(tile_shape_out &dst, tile_shape_in &src) { "B.DIM %[src____dimcol], 0, ->lb0\n" "B.DIM %[src____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -17199,7 +17079,7 @@ void TROWEXPAND(tile_shape_out &dst, tile_shape_in &src) { "B.DIM zero, %c2, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -17217,7 +17097,7 @@ void TROWEXPAND(tile_shape_out &dst, tile_shape_in &src) { "B.DIM zero, %c2, ->lb0\n" "B.DIM %[dst____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -17235,7 +17115,7 @@ void TROWEXPAND(tile_shape_out &dst, tile_shape_in &src) { "B.DIM %[dst____dimcol], 0, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -17253,7 +17133,7 @@ void TROWEXPAND(tile_shape_out &dst, tile_shape_in &src) { "B.DIM %[dst____dimcol], 0, ->lb0\n" "B.DIM %[dst____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -17286,7 +17166,7 @@ void TROWARGMAX(tile_shape_out &dst, tile_shape_in &src) { "B.DIM zero, %c2, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -17303,7 +17183,7 @@ void TROWARGMAX(tile_shape_out &dst, tile_shape_in &src) { "B.DIM zero, %c2, ->lb0\n" "B.DIM %[src____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -17320,7 +17200,7 @@ void TROWARGMAX(tile_shape_out &dst, tile_shape_in &src) { "B.DIM %[src____dimcol], 0, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -17337,7 +17217,7 @@ void TROWARGMAX(tile_shape_out &dst, tile_shape_in &src) { "B.DIM %[src____dimcol], 0, ->lb0\n" "B.DIM %[src____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -17369,7 +17249,7 @@ void TROWARGMIN(tile_shape_out &dst, tile_shape_in &src) { "B.DIM zero, %c2, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -17386,7 +17266,7 @@ void TROWARGMIN(tile_shape_out &dst, tile_shape_in &src) { "B.DIM zero, %c2, ->lb0\n" "B.DIM %[src____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -17403,7 +17283,7 @@ void TROWARGMIN(tile_shape_out &dst, tile_shape_in &src) { "B.DIM %[src____dimcol], 0, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -17420,7 +17300,7 @@ void TROWARGMIN(tile_shape_out &dst, tile_shape_in &src) { "B.DIM %[src____dimcol], 0, ->lb0\n" "B.DIM %[src____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -17461,7 +17341,7 @@ void TCOLSUM(tile_shape_out &dst, tile_shape_in &src) { "B.DIM zero, %c2, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -17478,7 +17358,7 @@ void TCOLSUM(tile_shape_out &dst, tile_shape_in &src) { "B.DIM zero, %c2, ->lb0\n" "B.DIM %[src____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -17495,7 +17375,7 @@ void TCOLSUM(tile_shape_out &dst, tile_shape_in &src) { "B.DIM %[src____dimcol], 0, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -17512,7 +17392,7 @@ void TCOLSUM(tile_shape_out &dst, tile_shape_in &src) { "B.DIM %[src____dimcol], 0, ->lb0\n" "B.DIM %[src____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -17549,7 +17429,7 @@ void TCOLMAX(tile_shape_out &dst, tile_shape_in &src) { "B.DIM zero, %c2, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -17566,7 +17446,7 @@ void TCOLMAX(tile_shape_out &dst, tile_shape_in &src) { "B.DIM zero, %c2, ->lb0\n" "B.DIM %[src____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -17583,7 +17463,7 @@ void TCOLMAX(tile_shape_out &dst, tile_shape_in &src) { "B.DIM %[src____dimcol], 0, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -17600,7 +17480,7 @@ void TCOLMAX(tile_shape_out &dst, tile_shape_in &src) { "B.DIM %[src____dimcol], 0, ->lb0\n" "B.DIM %[src____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -17637,7 +17517,7 @@ void TCOLMIN(tile_shape_out &dst, tile_shape_in &src) { "B.DIM zero, %c2, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -17654,7 +17534,7 @@ void TCOLMIN(tile_shape_out &dst, tile_shape_in &src) { "B.DIM zero, %c2, ->lb0\n" "B.DIM %[src____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -17671,7 +17551,7 @@ void TCOLMIN(tile_shape_out &dst, tile_shape_in &src) { "B.DIM %[src____dimcol], 0, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -17688,7 +17568,7 @@ void TCOLMIN(tile_shape_out &dst, tile_shape_in &src) { "B.DIM %[src____dimcol], 0, ->lb0\n" "B.DIM %[src____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -17725,7 +17605,7 @@ void TCOLPROD(tile_shape_out &dst, tile_shape_in &src) { "B.DIM zero, %c2, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -17742,7 +17622,7 @@ void TCOLPROD(tile_shape_out &dst, tile_shape_in &src) { "B.DIM zero, %c2, ->lb0\n" "B.DIM %[src____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -17759,7 +17639,7 @@ void TCOLPROD(tile_shape_out &dst, tile_shape_in &src) { "B.DIM %[src____dimcol], 0, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -17776,7 +17656,7 @@ void TCOLPROD(tile_shape_out &dst, tile_shape_in &src) { "B.DIM %[src____dimcol], 0, ->lb0\n" "B.DIM %[src____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -17807,7 +17687,7 @@ void TCOLEXPAND(tile_shape_out &dst, tile_shape_in &src) { "B.DIM zero, %c2, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -17824,7 +17704,7 @@ void TCOLEXPAND(tile_shape_out &dst, tile_shape_in &src) { "B.DIM zero, %c2, ->lb0\n" "B.DIM %[dst____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -17841,7 +17721,7 @@ void TCOLEXPAND(tile_shape_out &dst, tile_shape_in &src) { "B.DIM %[dst____dimcol], 0, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -17858,7 +17738,7 @@ void TCOLEXPAND(tile_shape_out &dst, tile_shape_in &src) { "B.DIM %[dst____dimcol], 0, ->lb0\n" "B.DIM %[dst____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -17895,7 +17775,7 @@ void TCOLARGMAX(tile_shape_out &dst, tile_shape_in &src) { "B.DIM zero, %c2, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -17912,7 +17792,7 @@ void TCOLARGMAX(tile_shape_out &dst, tile_shape_in &src) { "B.DIM zero, %c2, ->lb0\n" "B.DIM %[src____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -17929,7 +17809,7 @@ void TCOLARGMAX(tile_shape_out &dst, tile_shape_in &src) { "B.DIM %[src____dimcol], 0, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -17946,7 +17826,7 @@ void TCOLARGMAX(tile_shape_out &dst, tile_shape_in &src) { "B.DIM %[src____dimcol], 0, ->lb0\n" "B.DIM %[src____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -17983,7 +17863,7 @@ void TCOLARGMIN(tile_shape_out &dst, tile_shape_in &src) { "B.DIM zero, %c2, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -18000,7 +17880,7 @@ void TCOLARGMIN(tile_shape_out &dst, tile_shape_in &src) { "B.DIM zero, %c2, ->lb0\n" "B.DIM %[src____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -18017,7 +17897,7 @@ void TCOLARGMIN(tile_shape_out &dst, tile_shape_in &src) { "B.DIM %[src____dimcol], 0, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -18034,7 +17914,7 @@ void TCOLARGMIN(tile_shape_out &dst, tile_shape_in &src) { "B.DIM %[src____dimcol], 0, ->lb0\n" "B.DIM %[src____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, mask=1111, last, ->%0<%Z6>\n" + "B.IOT %5, mask=1111, last, ->%0<%Z6>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -18081,7 +17961,7 @@ void TROWEXPANDADD(tile_shape_out &dst, tile_shape_in0 &src0, tile_shape_in1 &sr "B.DIM zero, %c2, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -18108,7 +17988,7 @@ void TROWEXPANDADD(tile_shape_out &dst, tile_shape_in0 &src0, tile_shape_in1 &sr "B.DIM zero, %c2, ->lb0\n" "B.DIM %[dst____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -18135,7 +18015,7 @@ void TROWEXPANDADD(tile_shape_out &dst, tile_shape_in0 &src0, tile_shape_in1 &sr "B.DIM %[dst____dimcol], 0, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -18162,7 +18042,7 @@ void TROWEXPANDADD(tile_shape_out &dst, tile_shape_in0 &src0, tile_shape_in1 &sr "B.DIM %[dst____dimcol], 0, ->lb0\n" "B.DIM %[dst____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -18211,7 +18091,7 @@ void TROWEXPANDSUB(tile_shape_out &dst, tile_shape_in0 &src0, tile_shape_in1 &sr "B.DIM zero, %c2, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -18238,7 +18118,7 @@ void TROWEXPANDSUB(tile_shape_out &dst, tile_shape_in0 &src0, tile_shape_in1 &sr "B.DIM zero, %c2, ->lb0\n" "B.DIM %[dst____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -18265,7 +18145,7 @@ void TROWEXPANDSUB(tile_shape_out &dst, tile_shape_in0 &src0, tile_shape_in1 &sr "B.DIM %[dst____dimcol], 0, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -18292,7 +18172,7 @@ void TROWEXPANDSUB(tile_shape_out &dst, tile_shape_in0 &src0, tile_shape_in1 &sr "B.DIM %[dst____dimcol], 0, ->lb0\n" "B.DIM %[dst____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -18341,7 +18221,7 @@ void TROWEXPANDMUL(tile_shape_out &dst, tile_shape_in0 &src0, tile_shape_in1 &sr "B.DIM zero, %c2, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -18369,7 +18249,7 @@ void TROWEXPANDMUL(tile_shape_out &dst, tile_shape_in0 &src0, tile_shape_in1 &sr "B.DIM zero, %c2, ->lb0\n" "B.DIM %[valid_row], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -18397,7 +18277,7 @@ void TROWEXPANDMUL(tile_shape_out &dst, tile_shape_in0 &src0, tile_shape_in1 &sr "B.DIM %[valid_col], 0, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -18426,7 +18306,7 @@ void TROWEXPANDMUL(tile_shape_out &dst, tile_shape_in0 &src0, tile_shape_in1 &sr "B.DIM %[valid_col], 0, ->lb0\n" "B.DIM %[valid_row], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -18475,7 +18355,7 @@ void TROWEXPANDDIV(tile_shape_out &dst, tile_shape_in0 &src0, tile_shape_in1 &sr "B.DIM zero, %c2, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -18502,7 +18382,7 @@ void TROWEXPANDDIV(tile_shape_out &dst, tile_shape_in0 &src0, tile_shape_in1 &sr "B.DIM zero, %c2, ->lb0\n" "B.DIM %[dst____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -18529,7 +18409,7 @@ void TROWEXPANDDIV(tile_shape_out &dst, tile_shape_in0 &src0, tile_shape_in1 &sr "B.DIM %[dst____dimcol], 0, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -18556,7 +18436,7 @@ void TROWEXPANDDIV(tile_shape_out &dst, tile_shape_in0 &src0, tile_shape_in1 &sr "B.DIM %[dst____dimcol], 0, ->lb0\n" "B.DIM %[dst____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -18605,7 +18485,7 @@ void TROWEXPANDMAX(tile_shape_out &dst, tile_shape_in0 &src0, tile_shape_in1 &sr "B.DIM zero, %c2, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -18632,7 +18512,7 @@ void TROWEXPANDMAX(tile_shape_out &dst, tile_shape_in0 &src0, tile_shape_in1 &sr "B.DIM zero, %c2, ->lb0\n" "B.DIM %[dst____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -18659,7 +18539,7 @@ void TROWEXPANDMAX(tile_shape_out &dst, tile_shape_in0 &src0, tile_shape_in1 &sr "B.DIM %[dst____dimcol], 0, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -18686,7 +18566,7 @@ void TROWEXPANDMAX(tile_shape_out &dst, tile_shape_in0 &src0, tile_shape_in1 &sr "B.DIM %[dst____dimcol], 0, ->lb0\n" "B.DIM %[dst____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -18735,7 +18615,7 @@ void TROWEXPANDMIN(tile_shape_out &dst, tile_shape_in0 &src0, tile_shape_in1 &sr "B.DIM zero, %c2, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -18762,7 +18642,7 @@ void TROWEXPANDMIN(tile_shape_out &dst, tile_shape_in0 &src0, tile_shape_in1 &sr "B.DIM zero, %c2, ->lb0\n" "B.DIM %[dst____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -18789,7 +18669,7 @@ void TROWEXPANDMIN(tile_shape_out &dst, tile_shape_in0 &src0, tile_shape_in1 &sr "B.DIM %[dst____dimcol], 0, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -18816,7 +18696,7 @@ void TROWEXPANDMIN(tile_shape_out &dst, tile_shape_in0 &src0, tile_shape_in1 &sr "B.DIM %[dst____dimcol], 0, ->lb0\n" "B.DIM %[dst____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -18865,7 +18745,7 @@ void TROWEXPANDEXPDIF(tile_shape_out &dst, tile_shape_in0 &src0, tile_shape_in1 "B.DIM zero, %c2, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -18892,7 +18772,7 @@ void TROWEXPANDEXPDIF(tile_shape_out &dst, tile_shape_in0 &src0, tile_shape_in1 "B.DIM zero, %c2, ->lb0\n" "B.DIM %[dst____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -18919,7 +18799,7 @@ void TROWEXPANDEXPDIF(tile_shape_out &dst, tile_shape_in0 &src0, tile_shape_in1 "B.DIM %[dst____dimcol], 0, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -18946,7 +18826,7 @@ void TROWEXPANDEXPDIF(tile_shape_out &dst, tile_shape_in0 &src0, tile_shape_in1 "B.DIM %[dst____dimcol], 0, ->lb0\n" "B.DIM %[dst____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -18988,7 +18868,7 @@ void pto_prefix_row_expand(tile_shape_out &dst, matrix &src0, View &src1) { "B.DIM zero, %c[DstValidCol], ->lb0\n" "B.DIM zero, %c[DstValidRow], ->lb1\n" "B.DIM zero, %c[DstCols], ->lb2\n" - "B.IOT %2.reuse, %3.reuse, mask=1111, last, ->%0<%Z4>\n" + "B.IOT %2, %3, mask=1111, last, ->%0<%Z4>\n" "B.SUBVIEW 1, %5, 0, 1\n" "" : "=Tr"(dst.data()) @@ -19058,7 +18938,7 @@ void TCOLEXPANDADD(tile_shape_out &dst, tile_shape_in0 &src0, tile_shape_in1 &sr "B.DIM zero, %c2, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -19084,7 +18964,7 @@ void TCOLEXPANDADD(tile_shape_out &dst, tile_shape_in0 &src0, tile_shape_in1 &sr "B.DIM zero, %c2, ->lb0\n" "B.DIM %[dst____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -19110,7 +18990,7 @@ void TCOLEXPANDADD(tile_shape_out &dst, tile_shape_in0 &src0, tile_shape_in1 &sr "B.DIM %[dst____dimcol], 0, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -19136,7 +19016,7 @@ void TCOLEXPANDADD(tile_shape_out &dst, tile_shape_in0 &src0, tile_shape_in1 &sr "B.DIM %[dst____dimcol], 0, ->lb0\n" "B.DIM %[dst____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -19181,7 +19061,7 @@ void TCOLEXPANDSUB(tile_shape_out &dst, tile_shape_in0 &src0, tile_shape_in1 &sr "B.DIM zero, %c2, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -19207,7 +19087,7 @@ void TCOLEXPANDSUB(tile_shape_out &dst, tile_shape_in0 &src0, tile_shape_in1 &sr "B.DIM zero, %c2, ->lb0\n" "B.DIM %[dst____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -19233,7 +19113,7 @@ void TCOLEXPANDSUB(tile_shape_out &dst, tile_shape_in0 &src0, tile_shape_in1 &sr "B.DIM %[dst____dimcol], 0, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -19259,7 +19139,7 @@ void TCOLEXPANDSUB(tile_shape_out &dst, tile_shape_in0 &src0, tile_shape_in1 &sr "B.DIM %[dst____dimcol], 0, ->lb0\n" "B.DIM %[dst____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -19304,7 +19184,7 @@ void TCOLEXPANDMUL(tile_shape_out &dst, tile_shape_in0 &src0, tile_shape_in1 &sr "B.DIM zero, %c2, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -19330,7 +19210,7 @@ void TCOLEXPANDMUL(tile_shape_out &dst, tile_shape_in0 &src0, tile_shape_in1 &sr "B.DIM zero, %c2, ->lb0\n" "B.DIM %[dst____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -19356,7 +19236,7 @@ void TCOLEXPANDMUL(tile_shape_out &dst, tile_shape_in0 &src0, tile_shape_in1 &sr "B.DIM %[dst____dimcol], 0, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -19382,7 +19262,7 @@ void TCOLEXPANDMUL(tile_shape_out &dst, tile_shape_in0 &src0, tile_shape_in1 &sr "B.DIM %[dst____dimcol], 0, ->lb0\n" "B.DIM %[dst____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -19427,7 +19307,7 @@ void TCOLEXPANDDIV(tile_shape_out &dst, tile_shape_in0 &src0, tile_shape_in1 &sr "B.DIM zero, %c2, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -19453,7 +19333,7 @@ void TCOLEXPANDDIV(tile_shape_out &dst, tile_shape_in0 &src0, tile_shape_in1 &sr "B.DIM zero, %c2, ->lb0\n" "B.DIM %[dst____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -19479,7 +19359,7 @@ void TCOLEXPANDDIV(tile_shape_out &dst, tile_shape_in0 &src0, tile_shape_in1 &sr "B.DIM %[dst____dimcol], 0, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -19505,7 +19385,7 @@ void TCOLEXPANDDIV(tile_shape_out &dst, tile_shape_in0 &src0, tile_shape_in1 &sr "B.DIM %[dst____dimcol], 0, ->lb0\n" "B.DIM %[dst____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -19550,7 +19430,7 @@ void TCOLEXPANDMAX(tile_shape_out &dst, tile_shape_in0 &src0, tile_shape_in1 &sr "B.DIM zero, %c2, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -19576,7 +19456,7 @@ void TCOLEXPANDMAX(tile_shape_out &dst, tile_shape_in0 &src0, tile_shape_in1 &sr "B.DIM zero, %c2, ->lb0\n" "B.DIM %[dst____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -19602,7 +19482,7 @@ void TCOLEXPANDMAX(tile_shape_out &dst, tile_shape_in0 &src0, tile_shape_in1 &sr "B.DIM %[dst____dimcol], 0, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -19628,7 +19508,7 @@ void TCOLEXPANDMAX(tile_shape_out &dst, tile_shape_in0 &src0, tile_shape_in1 &sr "B.DIM %[dst____dimcol], 0, ->lb0\n" "B.DIM %[dst____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -19673,7 +19553,7 @@ void TCOLEXPANDMIN(tile_shape_out &dst, tile_shape_in0 &src0, tile_shape_in1 &sr "B.DIM zero, %c2, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -19699,7 +19579,7 @@ void TCOLEXPANDMIN(tile_shape_out &dst, tile_shape_in0 &src0, tile_shape_in1 &sr "B.DIM zero, %c2, ->lb0\n" "B.DIM %[dst____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -19725,7 +19605,7 @@ void TCOLEXPANDMIN(tile_shape_out &dst, tile_shape_in0 &src0, tile_shape_in1 &sr "B.DIM %[dst____dimcol], 0, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -19751,7 +19631,7 @@ void TCOLEXPANDMIN(tile_shape_out &dst, tile_shape_in0 &src0, tile_shape_in1 &sr "B.DIM %[dst____dimcol], 0, ->lb0\n" "B.DIM %[dst____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -19796,7 +19676,7 @@ void TCOLEXPANDEXPDIF(tile_shape_out &dst, tile_shape_in0 &src0, tile_shape_in1 "B.DIM zero, %c2, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -19822,7 +19702,7 @@ void TCOLEXPANDEXPDIF(tile_shape_out &dst, tile_shape_in0 &src0, tile_shape_in1 "B.DIM zero, %c2, ->lb0\n" "B.DIM %[dst____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -19848,7 +19728,7 @@ void TCOLEXPANDEXPDIF(tile_shape_out &dst, tile_shape_in0 &src0, tile_shape_in1 "B.DIM %[dst____dimcol], 0, ->lb0\n" "B.DIM zero, %c3, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -19874,7 +19754,7 @@ void TCOLEXPANDEXPDIF(tile_shape_out &dst, tile_shape_in0 &src0, tile_shape_in1 "B.DIM %[dst____dimcol], 0, ->lb0\n" "B.DIM %[dst____dimrow], 0, ->lb1\n" "B.DIM zero, %c4, ->lb2\n" - "B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\n" + "B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\n" "" : "=Tr"(dst.data()) : "i"(type_traits::TypeCode), @@ -19927,8 +19807,8 @@ void TPERMUTE(D &dst, A &src0, B &src1, I &indices) { "B.DIM zero, %c[Cols], ->lb0\n" "B.DIM zero, %c[Rows], ->lb1\n" "B.DIM zero, %c[FullCols], ->lb2\n" - "B.IOT %[Src0].reuse, %[Src1].reuse, mask=1111\n" - "B.IOT %[Indices].reuse, mask=1111, last, ->%[Dst]<%Z[Size]>\n" + "B.IOT %[Src0], %[Src1], mask=1111\n" + "B.IOT %[Indices], mask=1111, last, ->%[Dst]<%Z[Size]>\n" : [Dst] "=Tr"(dst.data()) : [Src0] "Tr"(src0.data()), [Src1] "Tr"(src1.data()), [Indices] "Tr"(indices.data()), @@ -19960,7 +19840,7 @@ void TSHUF(D &dst, S &src, C &controls, uint64_t control) { "B.DIM zero, %c[Cols], ->lb0\n" "B.DIM zero, %c[Rows], ->lb1\n" "B.DIM zero, %c[FullCols], ->lb2\n" - "B.IOT %[Src].reuse, %[Controls].reuse, mask=1111, last, ->%[Dst]<%Z[Size]>\n" + "B.IOT %[Src], %[Controls], mask=1111, last, ->%[Dst]<%Z[Size]>\n" "B.IOR [%[Control]],[]\n" : [Dst] "=Tr"(dst.data()) : [Src] "Tr"(src.data()), [Controls] "Tr"(controls.data()), @@ -20174,14 +20054,14 @@ void tpack_emit(D &dst, A &src0, B &src1, uint64_t control) { "B.DIM zero, %c[Cols], ->lb0\n" "B.DIM zero, %c[Rows], ->lb1\n" "B.DIM zero, %c[FullCols], ->lb2\n" - "B.IOT %[Src0].reuse, %[Src1].reuse, mask=1111\n" + "B.IOT %[Src0], %[Src1], mask=1111\n" ".if %c[HasSrc0View]\n" "B.SUBVIEW 0, %[Src0Base], %c[Src0Off], %c[Src0Size]\n" ".endif\n" ".if %c[HasSrc1View]\n" "B.SUBVIEW 1, %[Src1Base], %c[Src1Off], %c[Src1Size]\n" ".endif\n" - "B.IOT %[ParentRef].reuse, mask=1111, last\n" + "B.IOT %[ParentRef], mask=1111, last\n" "B.ASSEMBLE %c[Init], %c[Last], %[RegSrc], %c[Off], %c[WriterSize]\n" "B.IOR [%[Control]],[]\n" : @@ -20209,7 +20089,7 @@ void tpack_emit(D &dst, A &src0, B &src1, uint64_t control) { "B.DIM zero, %c[Cols], ->lb0\n" "B.DIM zero, %c[Rows], ->lb1\n" "B.DIM zero, %c[FullCols], ->lb2\n" - "B.IOT %[Src0].reuse, %[Src1].reuse, mask=1111, last, ->%[Dst]<%Z[Size]>\n" + "B.IOT %[Src0], %[Src1], mask=1111, last, ->%[Dst]<%Z[Size]>\n" ".if %c[HasSrc0View]\n" "B.SUBVIEW 0, %[Src0Base], %c[Src0Off], %c[Src0Size]\n" ".endif\n" @@ -20243,7 +20123,7 @@ void tpack_emit(D &dst, A &src0, B &src1, uint64_t control) { "B.DIM zero, %c[Cols], ->lb0\n" "B.DIM zero, %c[Rows], ->lb1\n" "B.DIM zero, %c[FullCols], ->lb2\n" - "B.IOT %[Src0].reuse, %[Src1].reuse, mask=1111, last, ->%[Dst]<%Z[Size]>\n" + "B.IOT %[Src0], %[Src1], mask=1111, last, ->%[Dst]<%Z[Size]>\n" ".if %c[HasSrc0View]\n" "B.SUBVIEW 0, %[Src0Base], %c[Src0Off], %c[Src0Size]\n" ".endif\n" @@ -20302,7 +20182,7 @@ void TUNPACK(D &dst, S &src, uint64_t control) { "B.DIM zero, %c[Cols], ->lb0\n" "B.DIM zero, %c[Rows], ->lb1\n" "B.DIM zero, %c[FullCols], ->lb2\n" - "B.IOT %[Src].reuse, mask=1111, last, ->%[Dst]<%Z[Size]>\n" + "B.IOT %[Src], mask=1111, last, ->%[Dst]<%Z[Size]>\n" "B.IOR [%[Control]],[]\n" : [Dst] "=Tr"(dst.data()) : [Src] "Tr"(src.data()), [Control] "r"(controlValue), @@ -20437,14 +20317,14 @@ PTO_SHARED_INLINE void binary(D &dst, A &src0, B &src1) { "B.DIM %[Col], 0, ->lb0\n" "B.DIM %[Row], 0, ->lb1\n" "B.DIM zero, %c[Cols], ->lb2\n" - "B.IOT %[Src0].reuse, %[Src1].reuse, mask=1111\n" + "B.IOT %[Src0], %[Src1], mask=1111\n" ".if %c[HasSrc0View]\n" "B.SUBVIEW 0, %[Src0Base], %c[Src0Off], %c[Src0Size]\n" ".endif\n" ".if %c[HasSrc1View]\n" "B.SUBVIEW 1, %[Src1Base], %c[Src1Off], %c[Src1Size]\n" ".endif\n" - "B.IOT %[Dst].reuse, mask=1111, last\n" + "B.IOT %[Dst], mask=1111, last\n" "B.ASSEMBLE %c[Init], %c[Last], %[RegSrc], %c[Off], %c[WriterSize]\n" : : [Type] "i"(type_traits::TypeCode), @@ -20469,8 +20349,8 @@ PTO_SHARED_INLINE void binary(D &dst, A &src0, B &src1) { "B.DIM %[Col], 0, ->lb0\n" "B.DIM %[Row], 0, ->lb1\n" "B.DIM zero, %c[Cols], ->lb2\n" - "B.IOT %[Src0].reuse, %[Src1].reuse, mask=1111\n" - "B.IOT %[Dst].reuse, mask=1111, last\n" + "B.IOT %[Src0], %[Src1], mask=1111\n" + "B.IOT %[Dst], mask=1111, last\n" "B.ASSEMBLE %c[Init], %c[Last], %[RegSrc], %c[Off], %c[WriterSize]\n" : : [Type] "i"(type_traits::TypeCode), @@ -20512,7 +20392,7 @@ PTO_SHARED_INLINE void unary(D &dst, S &src) { "B.DIM %[Col], 0, ->lb0\n" "B.DIM %[Row], 0, ->lb1\n" "B.DIM zero, %c[Cols], ->lb2\n" - "B.IOT %[Src].reuse, %[Dst].reuse, mask=1111, last\n" + "B.IOT %[Src], %[Dst], mask=1111, last\n" "B.ASSEMBLE %c[Init], %c[Last], %[RegSrc], %c[Off], %c[WriterSize]\n" : : [Type] "i"(type_traits::TypeCode), @@ -20555,7 +20435,7 @@ PTO_SHARED_INLINE void scalar(D &dst, S &src, typename S::DType value) { "B.DIM %[Col], 0, ->lb0\n" "B.DIM %[Row], 0, ->lb1\n" "B.DIM zero, %c[Cols], ->lb2\n" - "B.IOT %[Src].reuse, %[Dst].reuse, mask=1111, last\n" + "B.IOT %[Src], %[Dst], mask=1111, last\n" "B.IOR [%[Scalar]],[]\n" "B.ASSEMBLE %c[Init], %c[Last], %[RegSrc], %c[Off], %c[WriterSize]\n" : @@ -20650,7 +20530,7 @@ PTO_SHARED_INLINE void unary_special(D &dst, S &src) { "B.DIM %[Col], 0, ->lb0\n" "B.DIM %[Row], 0, ->lb1\n" "B.DIM zero, %c[Cols], ->lb2\n" - "B.IOT %[Src].reuse, %[Dst].reuse, mask=1111, last\n" + "B.IOT %[Src], %[Dst], mask=1111, last\n" "B.ASSEMBLE %c[Init], %c[Last], %[RegSrc], %c[Off], %c[WriterSize]\n" : : [Opcode] "i"(Opcode), @@ -20685,8 +20565,8 @@ PTO_SHARED_INLINE void ternary(D &dst, A &a, B &b, A &c) { "B.DIM %[Col], 0, ->lb0\n" "B.DIM %[Row], 0, ->lb1\n" "B.DIM zero, %c[Cols], ->lb2\n" - "B.IOT %[A].reuse, %[B].reuse, mask=1111\n" - "B.IOT %[C].reuse, %[Dst].reuse, mask=1111, last\n" + "B.IOT %[A], %[B], mask=1111\n" + "B.IOT %[C], %[Dst], mask=1111, last\n" "B.ASSEMBLE %c[Init], %c[Last], %[RegSrc], %c[Off], %c[WriterSize]\n" : : [Opcode] "i"(Opcode), [Type] "i"(type_traits::TypeCode), @@ -20716,7 +20596,7 @@ PTO_SHARED_INLINE void convert(D &dst, S &src) { "B.DIM %[Col], 0, ->lb0\n" "B.DIM %[Row], 0, ->lb1\n" "B.DIM zero, %c[Cols], ->lb2\n" - "B.IOT %[Src].reuse, %[Dst].reuse, mask=1111, last\n" + "B.IOT %[Src], %[Dst], mask=1111, last\n" "B.ASSEMBLE %c[Init], %c[Last], %[RegSrc], %c[Off], %c[WriterSize]\n" : : [Opcode] "i"(Opcode), @@ -20753,8 +20633,8 @@ PTO_SHARED_INLINE void binary_special(D &dst, A &a, B &b) { "B.DIM %[Col], 0, ->lb0\n" "B.DIM %[Row], 0, ->lb1\n" "B.DIM zero, %c[Cols], ->lb2\n" - "B.IOT %[A].reuse, %[B].reuse, mask=1111\n" - "B.IOT %[Dst].reuse, mask=1111, last\n" + "B.IOT %[A], %[B], mask=1111\n" + "B.IOT %[Dst], mask=1111, last\n" "B.ASSEMBLE %c[Init], %c[Last], %[RegSrc], %c[Off], %c[WriterSize]\n" : : [Opcode] "i"(Opcode), [Type] "i"(type_traits::TypeCode), @@ -20804,7 +20684,7 @@ PTO_SHARED_INLINE void reduce(D &dst, S &src) { "B.DIM %[Col], 0, ->lb0\n" "B.DIM %[Row], 0, ->lb1\n" "B.DIM zero, %c[Cols], ->lb2\n" - "B.IOT %[Src].reuse, %[Dst].reuse, mask=1111, last\n" + "B.IOT %[Src], %[Dst], mask=1111, last\n" "B.ASSEMBLE %c[Init], %c[Last], %[RegSrc], %c[Off], %c[WriterSize]\n" : : [Opcode] "i"(Opcode), @@ -20832,7 +20712,7 @@ PTO_SHARED_INLINE void expand(D &dst, S &src) { "B.DIM %[Col], 0, ->lb0\n" "B.DIM %[Row], 0, ->lb1\n" "B.DIM zero, %c[Cols], ->lb2\n" - "B.IOT %[Src].reuse, %[Dst].reuse, mask=1111, last\n" + "B.IOT %[Src], %[Dst], mask=1111, last\n" "B.ASSEMBLE %c[Init], %c[Last], %[RegSrc], %c[Off], %c[WriterSize]\n" : : [Opcode] "i"(Opcode), @@ -20857,8 +20737,8 @@ PTO_SHARED_INLINE void output_geometry_binary(D &dst, A &a, B &b) { "B.DIM %[Col], 0, ->lb0\n" "B.DIM %[Row], 0, ->lb1\n" "B.DIM zero, %c[Cols], ->lb2\n" - "B.IOT %[A].reuse, %[B].reuse, mask=1111\n" - "B.IOT %[Dst].reuse, mask=1111, last\n" + "B.IOT %[A], %[B], mask=1111\n" + "B.IOT %[Dst], mask=1111, last\n" "B.ASSEMBLE %c[Init], %c[Last], %[RegSrc], %c[Off], %c[WriterSize]\n" : : [Opcode] "i"(Opcode), @@ -20887,8 +20767,8 @@ PTO_SHARED_INLINE void compare(D &dst, A &a, B &b) { "B.DIM %[Col], 0, ->lb0\n" \ "B.DIM %[Row], 0, ->lb1\n" \ "B.DIM zero, %c[Cols], ->lb2\n" \ - "B.IOT %[A].reuse, %[B].reuse, mask=1111\n" \ - "B.IOT %[Dst].reuse, mask=1111, last\n" \ + "B.IOT %[A], %[B], mask=1111\n" \ + "B.IOT %[Dst], mask=1111, last\n" \ "B.ASSEMBLE %c[Init], %c[Last], %[RegSrc], %c[Off], %c[WriterSize]\n" \ : \ : [Type] "i"(type_traits::TypeCode), \ @@ -20925,7 +20805,7 @@ PTO_SHARED_INLINE void compare_scalar(D &dst, S &src, "B.DIM %[Col], 0, ->lb0\n" \ "B.DIM %[Row], 0, ->lb1\n" \ "B.DIM zero, %c[Cols], ->lb2\n" \ - "B.IOT %[Src].reuse, %[Dst].reuse, mask=1111, last\n" \ + "B.IOT %[Src], %[Dst], mask=1111, last\n" \ "B.IOR [%[Scalar]],[]\n" \ "B.ASSEMBLE %c[Init], %c[Last], %[RegSrc], %c[Off], %c[WriterSize]\n" \ : \ @@ -20975,13 +20855,7 @@ PTO_TEPL_ASS_CONVERT(TCVT, 27) PTO_TEPL_ASS_UNARY_SPECIAL(TSQRT, 21) PTO_TEPL_ASS_UNARY_SPECIAL(TRSQRT, 22) PTO_TEPL_ASS_UNARY_SPECIAL(TRELU, 23) - -template -PTO_SHARED_INLINE void TTRANS_ASS(D &, S &) { - static_assert(pto_dependent_false_v, - "TTRANS_ASS is retired (PTO-ISA 0.58.5); the TEPL 110 " - "selector must not be emitted"); -} +PTO_TEPL_ASS_UNARY_SPECIAL(TTRANS, 110) #define PTO_TEPL_ASS_REDUCE(NAME, OPCODE) \ template \ @@ -21025,13 +20899,7 @@ PTO_TEPL_ASS_OUTPUT_BINARY(TCOLEXPANDDIV, 88) PTO_TEPL_ASS_OUTPUT_BINARY(TCOLEXPANDMAX, 89) PTO_TEPL_ASS_OUTPUT_BINARY(TCOLEXPANDMIN, 90) PTO_TEPL_ASS_OUTPUT_BINARY(TCOLEXPANDEXPDIF, 91) - -template -PTO_SHARED_INLINE void TCONCAT_ASS(D &, A &, B &) { - static_assert(pto_dependent_false_v, - "TCONCAT_ASS is retired (PTO-ISA 0.58.5); the TEPL 96 " - "selector must not be emitted"); -} +PTO_TEPL_ASS_OUTPUT_BINARY(TCONCAT, 96) template PTO_SHARED_INLINE void TCMP_ASS(D &dst, A &a, B &b) { diff --git a/test/test_dense_f16_element_tile_api.py b/test/test_dense_f16_element_tile_api.py index 283ac52a..819499da 100644 --- a/test/test_dense_f16_element_tile_api.py +++ b/test/test_dense_f16_element_tile_api.py @@ -282,7 +282,7 @@ def test_native_counted_store_ir_and_object(self): if body.startswith("define ") and "copy_dense_partI" in body] self.assertEqual(len(bodies), 4) for body in bodies: - self.assertIn("BSTART.TMOV", body) + self.assertIn("BSTART.TLSU TMOV", body) self.assertIn("B.DATR CUBE_M32, Zero", body) self.assertIn("B.SUBVIEW", body) self.assertIn("B.DIM zero, ${6:c}, ->lb2", body) @@ -293,7 +293,7 @@ def test_native_counted_store_ir_and_object(self): if body.startswith("define ") and "copy_dense_tileI" in body] self.assertEqual(len(direct), 4) for body in direct: - self.assertIn("BSTART.TMOV", body) + self.assertIn("BSTART.TLSU TMOV", body) self.assertIn("B.DATR CUBE_M32, Zero", body) self.assertIn("B.DIM zero, ${6:c}, ->lb2", body) self.assertRegex(body, r"i32 2, i32 32, i32 2, i32 29\)") diff --git a/test/test_element_tile_api.py b/test/test_element_tile_api.py index c901ea27..1cf5c2d3 100644 --- a/test/test_element_tile_api.py +++ b/test/test_element_tile_api.py @@ -446,10 +446,7 @@ def test_release_rejects_bad_ranges(self): run=True, release=True, runtime_reject=True) def test_reject_unsupported_dtype(self): - # unsigned long can be uint64_t on Linux, so it is not a portable - # unsupported dtype now that the integer64 profile is available. - self.compile('pto::ElementTile supported;\n') - self.compile('pto::ElementTile unsupported;\n', accepts=False) + self.compile('pto::ElementTile unsupported;\n', accepts=False) self.compile('pto::ElementTile unsupported;\n', accepts=False) def test_reject_unsupported_capacity(self): diff --git a/test/test_issue_272_276_contract.py b/test/test_issue_272_276_contract.py index b77ce5d1..aa49d28d 100644 --- a/test/test_issue_272_276_contract.py +++ b/test/test_issue_272_276_contract.py @@ -42,7 +42,7 @@ def test_tpack_emits_distinct_plain_init_and_continuation_forms(self): self.assertIn('B.ASSEMBLE %c[Init]', init) self.assertEqual(init.count('"B.IOT '), 1) self.assertNotIn('->%[Dst]<%Z[Size]>', associated) - self.assertIn('B.IOT %[ParentRef].reuse, mask=1111, last', associated) + self.assertIn('B.IOT %[ParentRef], mask=1111, last', associated) self.assertIn('[ParentRef] "Tr"(dst.data())', associated) self.assertIn('B.ASSEMBLE %c[Init]', associated) self.assertEqual(associated.count('"B.IOT '), 2) diff --git a/test/test_pto0585_layout_interfaces.py b/test/test_pto0585_layout_interfaces.py index 0deaf9c9..3a1677df 100644 --- a/test/test_pto0585_layout_interfaces.py +++ b/test/test_pto0585_layout_interfaces.py @@ -22,9 +22,9 @@ def test_selectors(self): self.assertIn(f'"BSTART.TEPL {selector},', HEADER) def test_operand_schemas(self): - self.assertIn('"B.IOT %[Src0].reuse, %[Src1].reuse, mask=1111\\n"', HEADER) + self.assertIn('"B.IOT %[Src0], %[Src1], mask=1111\\n"', HEADER) self.assertIn( - '"B.IOT %[Indices].reuse, mask=1111, last, ->%[Dst]<%Z[Size]>\\n"', + '"B.IOT %[Indices], mask=1111, last, ->%[Dst]<%Z[Size]>\\n"', HEADER, ) # TPACK has three compile-time-distinct templates (plain, INIT, and diff --git a/test/test_tpack_element_assembly_api.py b/test/test_tpack_element_assembly_api.py index 41c49549..6fb483d1 100644 --- a/test/test_tpack_element_assembly_api.py +++ b/test/test_tpack_element_assembly_api.py @@ -103,7 +103,7 @@ def test_plain_has_no_assembly_modifier_and_continuation_is_source_form(self): ) self.assertIn("B.ASSEMBLE ${17:c}, ${18:c}", init) self.assertRegex(continuation, r"B\.IOT \$2, mask=1111, last") - self.assertNotIn("B.IOT $2.reuse, mask=1111, last, ->", continuation) + self.assertNotIn("B.IOT $2, mask=1111, last, ->", continuation) self.assertRegex(continuation, r'"@2Tr,@2Tr,@2Tr,') obj = work / "assemble.o" diff --git a/test/test_v058_engine_contract.py b/test/test_v058_engine_contract.py index a26049ef..d8f69f13 100644 --- a/test/test_v058_engine_contract.py +++ b/test/test_v058_engine_contract.py @@ -1,14 +1,11 @@ #!/usr/bin/env python3 -# Engine-contract tests for the jcore inline-asm surface. The semantic engine -# inventory is the LinxISA v0.58 authority projection; the active PTO encoding -# identity is the published PTO ISA 0.59.0.0 release (see -# test_contract_carries_release_provenance). +# PTO ISA 0.58.3 engine-contract tests for the jcore inline-asm surface. # # Rebuilt per handoff Work Package B6: the assertions reflect the current # real toolchain ABI (Tr Tile constraints + %Z TileSize printer; the %q/%D # ABI is retired) and the actual block carriers used by LLVM -# (`BSTART.TEPL` for VEC/SFU and canonical named TLSU/CUBE starts). -# Deleted/reserved operations are +# (BSTART.TEPL / BSTART.TLSU / BSTART.CUBE; canonical BSTART.VEC/SFU/TLOAD +# aliases are not implemented in LLVM yet). Deleted/reserved operations are # checked as a negative inventory (they must not be emitted); the new # TSORT / MGATHER_CAS / TIMG2COL / TQUANT / TDEQUANT bundles are validated # directly from the header text. @@ -63,87 +60,56 @@ def test_contract_carries_release_provenance(self) -> None: self.assertEqual(self.contract["profile"], "v0.58") self.assertEqual( self.contract["semantic_engine_counts"], - {"CUBE": 12, "SFU": 47, "TLSU": 28, "VEC": 32}, + {"CUBE": 12, "SFU": 57, "TLSU": 10, "VEC": 31}, ) src = self.contract.get("source", {}) - self.assertEqual(src.get("release"), "0.58.7") + self.assertEqual(src.get("release"), "0.58.3") self.assertEqual( - src.get("commit"), "f77a8960f61f97c264a90b7aee757f99891b0943" + src.get("commit"), "dd52a2e579d8058c0d8e33043e705122b340e73f" ) self.assertEqual( - src.get("tree"), "da085d3f000a5b92031c9694024dc9a7f3cdaa89" + src.get("tree"), "1cfc7343e714489f95f67592475e8b9f079241ee" ) self.assertEqual( src.get("sha256"), - "51ca9be275518d29ec48bed570b7a9bd441a65b9c5e6d4f79072f650ee732925", + "34ecbcfa075166490b622647eb53c13a9c360848d6c7acb2e034d3e47f8c9a8a", ) - # The active PTO encoding identity is the published 0.59.0.0 release. pto = self.contract.get("pto_source", {}) - self.assertEqual(pto.get("release"), "0.59.0") - self.assertEqual(pto.get("publication_version"), "0.59.0.0") - self.assertEqual(pto.get("release_tag"), "v0.59.0.0") - # The release manifest is itself still a draft specification; record - # that faithfully rather than claiming a finalized specification. - self.assertEqual(pto.get("specification_status"), "draft") + self.assertEqual(pto.get("release"), "0.58.3") self.assertEqual( - pto.get("commit"), "b0165320a4b575b18d2f4d93faf40178f661ab49" + pto.get("commit"), "e599a3d36ebfad43362ff591ea5e128816c684c7" ) self.assertEqual( - pto.get("tree"), "31ff0c2d39cbed714baf5be7929bfd06887be9fb" - ) - self.assertEqual( - pto.get("encoding_abi"), "pto-isa-0.59.0-mode-function-v1" + pto.get("tree"), "abb6899d2e664e378ac9c1b77062670daa4d31b4" ) self.assertEqual( pto.get("encoding_projection_sha256"), - "91509080ca656eb124f47830dcb09c50389dc177266b3b8df9d2d11dc37d5697", - ) - self.assertEqual( - pto.get("release_manifest", {}).get("sha256"), - "3c6b20623e73822c0bd26021c10beb233b8809328b5515f57609eadad1749dc4", - ) - self.assertEqual(pto.get("tile_catalog", {}).get("count"), 119) - self.assertEqual( - pto.get("tile_catalog", {}).get("sha256"), - "533db9b8f31f118af5978de813cfaa3fa738de820ee24655faa2ee71f343a706", + "8a48b80e04484c70870f155bf9efc79d2a805cf99e809f4e4e8a7e6a7eb34172", ) - # The LinxISA v0.58 authority locked the PTO development golden; its - # Tile catalog bytes equal the release catalog, which is why this v0.58 - # engine projection is valid against the 0.59.0.0 release. - lock = pto.get("development_lock", {}) - self.assertEqual(lock.get("release"), "0.58.7") - self.assertEqual( - lock.get("commit"), "f0a876e449a95d26841c5ee7affb4c905ebc5f5b" - ) - self.assertTrue(lock.get("catalog_sha256_matches_release")) - def test_0587_engine_mapping_is_exact(self) -> None: + def test_0583_vec_sfu_reclassification_is_exact(self) -> None: engines = {row["name"]: row["engine"] for row in self.contract["tepl_ops"]} for operation in ("TDIV", "TREM", "TEXP", "TLOG"): self.assertEqual(engines[operation], "SFU") self.assertEqual( - sum(op["engine"] == "VEC" for op in self.contract["tepl_ops"]), 32 + sum(op["engine"] == "SFU" for op in self.contract["tepl_ops"]), 57 ) self.assertEqual( - sum(row["engine"] == "SFU" for row in self.contract["tepl_ops"]), 47 + sum(row["engine"] == "SFU" for row in self.contract["tepl_ops"]), 57 ) - def test_engine_projection_covers_the_exact_pto_catalog(self) -> None: - catalog = json.loads( - (ROOT / "contracts" / "pto-isa-0.59.0-tile-operations.json").read_text( - encoding="utf-8" - ) - ) - projected = { - row["name"] - for key in ("tepl_ops", "tlsu_ops", "cube_ops") - for row in self.contract[key] - } - golden = {row["name"] for row in catalog["operations"]} - self.assertEqual(projected, golden) - self.assertEqual(len(self.contract["tepl_ops"]), 79) - self.assertEqual(len(self.contract["tlsu_ops"]), 28) - self.assertEqual(len(self.contract["cube_ops"]), 12) + # 12 CUBE + 6 TGEMV functions are in the catalog; our surface should + # reference each active operation's carrier somewhere in the header. + def test_active_cube_and_tlsu_surface_is_referenced(self) -> None: + for row in self.contract.get("cube_ops", []): + if row["name"].startswith("TGEMV"): + continue + self.assertIn('"BSTART.CUBE " OPCODE', self.header, row["name"]) + break + for row in self.contract.get("tlsu_ops", []): + if row["name"] in {"TPREFETCH", "MGATHER_CAS"}: + continue + self.assertIn(row["mnemonic"], self.header, row["name"]) # --- inline-asm ABI: Tr + %Z + %D --- @@ -169,13 +135,13 @@ def test_packed_shared_capacity_uses_isa_element_bits(self) -> None: self.assertIn("SharedE2M1X2::LogicalTileBytes == 8192", contract) self.assertIn("SharedFP8::LogicalTileBytes == 16384", contract) - # --- block carriers: TEPL plus named TLSU/CUBE starts --- + # --- block carriers: TEPL / TLSU / CUBE (current LLVM spelling) --- def test_jcore_uses_current_block_carriers(self) -> None: - # TEPL remains the raw VEC/SFU carrier; TLSU/CUBE use named starts. + # TEPL remains the raw VEC/SFU carrier; TLSU/CUBE use exact named starts. self.assertIn("BSTART.TEPL", self.header) - self.assertIn("BSTART.TLOAD", self.header) - self.assertIn('"BSTART." OPCODE', self.header) + self.assertIn("BSTART.TLSU TLOAD", self.header) + self.assertIn('"BSTART.CUBE " OPCODE', self.header) # TGEMV enters through the TLSU/CUBE surface too. self.assertIn("TGEMV", self.header) @@ -195,7 +161,7 @@ def test_tcvt_emits_dimensions_before_terminating_iot(self) -> None: '"B.DIM zero, %c5, ->lb0\\n"', '"B.DIM zero, %c6, ->lb1\\n"', '"B.DIM zero, %c7, ->lb2\\n"', - '"B.IOT %3.reuse, mask=1111, last, ->%0<%Z4>\\n"'): + '"B.IOT %3, mask=1111, last, ->%0<%Z4>\\n"'): self.assertIn(instruction, ordinary_branch) def test_tcvt_same_type_rounding_scope_is_compile_time_checked(self) -> None: @@ -625,31 +591,11 @@ def test_pe_masks_are_four_binary_digits(self) -> None: # the mask=15 form is only a legacy carrier not touched by B6. self.assertRegex(self.header, r"mask=1111") - def test_every_emitted_binder_source_is_explicit_reuse(self) -> None: - source_count = 0 - for path in (ROOT / "include").rglob("*.hpp"): - text = path.read_text(encoding="utf-8", errors="ignore") - source_binders = re.finditer( - r'"B\.IO[TS]\s+(?!mask=)([^"\\]*?)mask=', text - ) - for binder in source_binders: - source_count += 1 - operands = [ - operand.strip() - for operand in binder.group(1).rstrip(", ").split(",") - ] - self.assertTrue( - all(operand.endswith(".reuse") for operand in operands), - f"{path.relative_to(ROOT)}: {binder.group(0)}", - ) - self.assertNotRegex(text, r'->[^"\n]*\.reuse', path.relative_to(ROOT)) - self.assertGreater(source_count, 0) - # --- Shared bindings use B.IOS --- def test_shared_tile_bindings_use_b_ios(self) -> None: self.assertNotIn("C.B.IOS", self.header) - self.assertRegex(self.header, r"B\.IOS %S\[Shared[AB]\]\.reuse, mask=1111") + self.assertRegex(self.header, r"B\.IOS %S\[Shared[AB]\], mask=1111") def test_tload_ass_binds_existing_shared_handle_as_input(self) -> None: local_start = self.header.index("// TLOAD_ASS:") @@ -661,7 +607,7 @@ def test_tload_ass_binds_existing_shared_handle_as_input(self) -> None: shared = self.header[shared_start:shared_end] self.assertEqual(local.count("void TLOAD_ASS("), 2) self.assertEqual(shared.count("void TLOAD_ASS("), 2) - self.assertEqual(shared.count('"B.IOS %S[d0].reuse, mask=1111\\n"'), 2) + self.assertEqual(shared.count('"B.IOS %S[d0], mask=1111\\n"'), 2) self.assertEqual(shared.count('[d0] "Sr"(dst.handle_ref())'), 2) self.assertNotIn("->%S[d0]", shared) self.assertNotIn("<%Z[TileSize]>", shared) @@ -678,7 +624,7 @@ def test_tload_ass_covers_local_cube_and_unified_dispatch(self) -> None: dispatch_end = self.header.index("// TSTORE: Shared Tile", unified) dispatch = self.header[unified:dispatch_end] self.assertIn("void TLOAD_CUBE_ASS(", cube) - self.assertIn('"B.IOT %[Dst].reuse, mask=1111, last\\n"', cube) + self.assertIn('"B.IOT %[Dst], mask=1111, last\\n"', cube) self.assertIn('[Dst] "Tr"(dst.data())', cube) self.assertNotIn("->%[Dst]", cube) self.assertIn("void TLOAD_ASS(cube_shape &dst, const gm_shape &src)", dispatch) @@ -709,7 +655,7 @@ def test_tepl_ass_surface_is_destination_first_and_packs_iot(self) -> None: ): self.assertRegex(block, rf"PTO_TEPL_ASS_[A-Z]+\({name},") packed_scalar = ( - '"B.IOT %[Src].reuse, %[Dst].reuse, mask=1111, last\\n"' + '"B.IOT %[Src], %[Dst], mask=1111, last\\n"' ) self.assertGreaterEqual(block.count(packed_scalar), 2) scalar = re.search( @@ -739,8 +685,8 @@ def test_tepl_ass_surface_is_destination_first_and_packs_iot(self) -> None: r'"B\.IOT %\[Dst\], mask=1111, last\\n"' ) self.assertIsNone(old_scalar_split.search(block)) - self.assertIn('"B.IOT %[Src0].reuse, %[Src1].reuse, mask=1111\\n"', block) - self.assertIn('"B.IOT %[Dst].reuse, mask=1111, last\\n"', block) + self.assertIn('"B.IOT %[Src0], %[Src1], mask=1111\\n"', block) + self.assertIn('"B.IOT %[Dst], mask=1111, last\\n"', block) # Keep the invalid legacy spelling out of actual instruction strings; # the explanatory comment above names it as a negative example. asm_block = block[block.index("namespace pto_tepl_ass_detail") :] @@ -758,9 +704,9 @@ def test_tepl_ass_surface_is_destination_first_and_packs_iot(self) -> None: for call in ("TCMP_ASS(f, a, b);", "TCMPS_ASS(f, a, 0.0f);", "TFMA_ASS(f, a, b, c);", - "TSQRT_ASS(f, a);", "TCVT_ASS(d, a);"): + "TSQRT_ASS(f, a);", "TCVT_ASS(d, a);", "TTRANS_ASS(f, a);"): self.assertIn(call, special) - self.assertIn('"B.IOT %[C].reuse, %[Dst].reuse, mask=1111, last\\n"', block) + self.assertIn('"B.IOT %[C], %[Dst], mask=1111, last\\n"', block) self.assertIn('"B.DATR %D[__pto_DstType], RNONE\\n"', block) self.assertNotIn("[DType]", block) @@ -778,11 +724,11 @@ def test_tsel_binds_explicit_false_source_on_both_shape_paths(self) -> None: # Per-dimension dispatch: four B.DIM combinations, each a full asm # statement with the same binder shape. self.assertEqual( - tsel.count('"B.IOT %6.reuse, %7.reuse, mask=1111\\n"'), 4 + tsel.count('"B.IOT %6, %7, mask=1111\\n"'), 4 ) self.assertEqual( tsel.count( - '"B.IOT %1.reuse, mask=1111, last, ->%0<%Z8>\\n"' + '"B.IOT %1, mask=1111, last, ->%0<%Z8>\\n"' ), 4, ) @@ -793,7 +739,7 @@ def test_tsel_binds_explicit_false_source_on_both_shape_paths(self) -> None: self.assertIn('"B.DIM %[mask____dimrow], 0, ->lb1\\n"', tsel) self.assertIn("::ValidCol > 0 && ", tsel) self.assertNotIn( - '"B.IOT %5.reuse, %6.reuse, mask=1111, last, ->%0<%Z7>\\n"', tsel + '"B.IOT %5, %6, mask=1111, last, ->%0<%Z7>\\n"', tsel ) def test_valid_shape_immediate_fixture_separates_static_and_dynamic_paths(self) -> None: @@ -866,21 +812,21 @@ def test_cube_cell_and_transport_contract_is_exposed(self) -> None: self.assertIn("TSTORE_CUBE", self.header) def test_cube_shared_operands_use_common_nonzero_mask(self) -> None: - self.assertRegex(self.header, r"B\.IOS %S\[Shared[AB]\]\.reuse, mask=1111") - self.assertNotRegex(self.header, r"B\.IOS %S\[Shared[AB]\]\.reuse, mask=0000") + self.assertRegex(self.header, r"B\.IOS %S\[Shared[AB]\], mask=1111") + self.assertNotRegex(self.header, r"B\.IOS %S\[Shared[AB]\], mask=0000") def test_cube_accumulator_is_explicit_and_destination_is_distinct(self) -> None: - self.assertIn('"B.IOT %[C].reuse, mask=1111\\n"', self.header) + self.assertIn('"B.IOT %[C], mask=1111\\n"', self.header) self.assertIn('[Dst] "=&Tr"(dst.data())', self.header) def test_tgemv_uses_a_then_b_source_and_type_order(self) -> None: - self.assertIn('"B.IOT %[Vec].reuse, %[Mtx].reuse, mask=1111\\n"', self.header) - self.assertNotIn('"B.IOT %[Mtx].reuse, %[Vec].reuse, mask=1111\\n"', self.header) + self.assertIn('"B.IOT %[Vec], %[Mtx], mask=1111\\n"', self.header) + self.assertNotIn('"B.IOT %[Mtx], %[Vec], mask=1111\\n"', self.header) self.assertIn( - '"B.IOT %[Vec].reuse, mask=1111\\n" ".if %c[HasScaleA]\\n" ' - '"B.IOT %[ScaleVec].reuse, mask=1111\\n" ".endif\\n" ' - '"B.IOT %[Mtx].reuse, mask=1111\\n" ".if %c[HasScaleB]\\n" ' - '"B.IOT %[ScaleMtx].reuse, mask=1111\\n"', + '"B.IOT %[Vec], mask=1111\\n" ".if %c[HasScaleA]\\n" ' + '"B.IOT %[ScaleVec], mask=1111\\n" ".endif\\n" ' + '"B.IOT %[Mtx], mask=1111\\n" ".if %c[HasScaleB]\\n" ' + '"B.IOT %[ScaleMtx], mask=1111\\n"', self.header, ) self.assertIn("PTO_MATMUL_COMMON_INPUTS(Dst, Vec, Mtx", self.header) @@ -899,10 +845,10 @@ def test_mx_scale_presence_is_validated_per_input_side(self) -> None: # ScaleMask 3 has all scale operands at compile time, so every adjacent # Local primary/scale pair must use the architectural 2-source B.IOT. for packed_source in ( - '"B.IOT %[A].reuse, %[ScaleA].reuse, mask=1111\\n"', - '"B.IOT %[B].reuse, %[ScaleB].reuse, mask=1111\\n"', - '"B.IOT %[Vec].reuse, %[ScaleVec].reuse, mask=1111\\n"', - '"B.IOT %[Mtx].reuse, %[ScaleMtx].reuse, mask=1111\\n"', + '"B.IOT %[A], %[ScaleA], mask=1111\\n"', + '"B.IOT %[B], %[ScaleB], mask=1111\\n"', + '"B.IOT %[Vec], %[ScaleVec], mask=1111\\n"', + '"B.IOT %[Mtx], %[ScaleMtx], mask=1111\\n"', ): self.assertIn(packed_source, self.header) @@ -929,7 +875,7 @@ def test_mx_scale_presence_is_validated_per_input_side(self) -> None: # the ISA does not define a two-source B.IOS encoding. self.assertNotRegex(self.header, r'"B\.IOS[^"\\n]*,\s*%S\[') self.assertIn( - '"B.IOS %S[SharedB].reuse, mask=1111\\n" "B.IOS %S[ScaleB].reuse, mask=1111\\n"', + '"B.IOS %S[SharedB], mask=1111\\n" "B.IOS %S[ScaleB], mask=1111\\n"', self.header, ) fixture = (ROOT / "test" / "tileop_api" / "src" / @@ -997,15 +943,15 @@ def test_matrix_dtype_and_effective_shape_contract_is_centralized(self) -> None: def test_mc_gate_requires_canonical_cube_layout_names(self) -> None: gate = (ROOT / "test" / "tileop_api" / "verify_pto0583_asm.sh").read_text() - self.assertIn(r"ND2M32, DTYPE_NONE, Zero", gate) - self.assertIn(r"N82ND, DTYPE_NONE, Null", gate) + self.assertIn(r"ND2M32\.normal", gate) + self.assertIn(r"N82ND\.normal", gate) self.assertIn("missing canonical $description", gate) - def test_active_inline_asm_uses_exact_pto0587_surface(self) -> None: + def test_active_inline_asm_uses_exact_pto0583_surface(self) -> None: # CUBE transport (TLOAD_CUBE/TSTORE_CUBE) legitimately uses the - # canonical named starts ("BSTART.TLOAD/TSTORE") and the + # canonical TLSU carrier ("BSTART.TLSU TLOAD/TSTORE") and the # ".normal" CUBE selectors (ND2M16/ND2M32/ND2N8/M162ND/M322ND/ - # N82ND); ordinary non-CUBE code must keep the exact 0.58.7 surface. + # N82ND); ordinary non-CUBE code must keep the exact 0.58.3 surface. self.assertNotRegex(self.header, r'"[^"\n]*mask=15(?:\D|$)') self.assertNotIn("mask=%c[PEMask]", self.header) self.assertNotRegex( @@ -1017,15 +963,15 @@ def test_active_inline_asm_uses_exact_pto0587_surface(self) -> None: self.header, r'"B\.DATR (?!ND2M(?:16|32)|ND2N8|M(?:16|32)2ND|N82ND)[^"\n]*\.normal', ) - self.assertIn('"BSTART.TLOAD %D[DataType]\\n"', self.header) - self.assertIn('"BSTART.TSTORE %D[DataType]\\n"', self.header) + self.assertIn('"BSTART.TLSU TLOAD, %D[DataType]\\n"', self.header) + self.assertIn('"BSTART.TLSU TSTORE, %D[DataType]\\n"', self.header) # TLOAD_CUBE 的 CUBE selector+pad 已收进 PTO_CUBE_LOAD_DATR_ASM #（PTO-ISA TLOAD: Local CUBE 允许全部四种 PadValue；默认 Zero）。 self.assertIn('PTO_CUBE_LOAD_DATR_ASM', self.header) self.assertNotIn( '"B.DATR %c[DataTypeB], byte0, Zero\\n"', self.header ) - self.assertIn('"BSTART." OPCODE " %D[DataTypeA]\\n"', self.header) + self.assertIn('"BSTART.CUBE " OPCODE ", %D[DataTypeA]\\n"', self.header) def test_pe_mode_rejects_unassigned_masks(self) -> None: type_header = (ROOT / "include" / "jcore" / "type.hpp").read_text( @@ -1063,10 +1009,10 @@ def test_fp6_cube_cell_instantiation_uses_byte_carriers(self) -> None: def test_shared_tmov_uses_unique_source_forms_and_shared_registers(self) -> None: for source_form in ( - "BSTART.TMOV.L2S.INSERT", - "BSTART.TMOV.L2S.PUBLISH", - "BSTART.TMOV.S2L.BROADCAST", - "BSTART.TMOV.S2L.EXTRACT", + "BSTART.TLSU TMOV.L2S.INSERT", + "BSTART.TLSU TMOV.L2S.PUBLISH", + "BSTART.TLSU TMOV.S2L.BROADCAST", + "BSTART.TLSU TMOV.S2L.EXTRACT", ): self.assertIn(source_form, self.header, source_form) self.assertRegex(self.header, r'\[Shared\]\s+"=Sr"') @@ -1077,32 +1023,14 @@ def test_shared_tmov_uses_unique_source_forms_and_shared_registers(self) -> None def test_deleted_tile_operations_are_migration_stubs(self) -> None: # Every deleted tile operation either has no wrapper (truly absent) # or is an instance-time static_assert stub; in no case is a - # retired TEPL selector emitted by an asm block. TFMOD (5), - # TRANDOM (105) etc. must not appear next to BSTART.TEPL. - # NB: selector 46 (0x2E) was the deleted TLRELU but the current - # catalog reassigns it to the accepted TLEA (TEPL Mode 1 Function 14), - # so 46 is intentionally not in this list. - for sel in (5, 14, 24, 25, 37, 47, 56, 57, 96, 97, 105, 110): + # retired TEPL selector emitted by an asm block. TFMOD (5), TLRELU + # (46), TRANDOM (105) etc. must not appear next to BSTART.TEPL. + for sel in (5, 14, 24, 25, 37, 46, 47, 56, 57, 97, 105): self.assertNotRegex( self.header, rf'BSTART\.TEPL\s+{sel},', f"deleted selector {sel} must not be emitted", ) - for name in self.contract["deleted_tile_names"]: - self.assertNotRegex( - self.header, - rf"PTO_TEPL_ASS_[A-Z_]+\({re.escape(name)},", - f"deleted operation {name} must not use an associated emitter macro", - ) - for name in ( - "TCONCAT", "TDEQUANT", "TEXTRACT", "THISTOGRAM", "TIMG2COL", - "TINSERT", "TMRGSORT", "TQUANT", "TSORT", - ): - self.assertNotRegex( - self._active_impl(), - rf'"BSTART\.(?:VEC|SFU)\s+{name}\b', - f"stale named TEPL alias {name} must not be emitted", - ) def test_retired_block_spellings_are_not_emitted(self) -> None: impl = self._active_impl() @@ -1137,12 +1065,8 @@ def test_mgather_cas_bundle_is_two_b_iot_with_base_ior(self) -> None: # ReplacementTile+last -> Dst; byte-displacement indices make B.IOR # base-only in PTO-ISA 0.58.7. body = self.header[self.header.index("void MGATHER_CAS"):] - self.assertRegex( - body, r"B\.IOT %\[Idx\]\.reuse, %\[Exp\]\.reuse, mask=1111\\n" - ) - self.assertRegex( - body, r"B\.IOT %\[Rep\]\.reuse, mask=1111, last, ->%\[Dst\]" - ) + self.assertRegex(body, r"B\.IOT %\[Idx\], %\[Exp\], mask=1111\\n") + self.assertRegex(body, r"B\.IOT %\[Rep\], mask=1111, last, ->%\[Dst\]") self.assertRegex(body, r"B\.IOR \[%\[Base\]\], \[\]") self.assertNotIn("%[Stride]", body) @@ -1243,10 +1167,10 @@ def test_compile_all_aggregates_active_object_failures(self) -> None: def test_pto_identity_verifier_rejects_hostile_elf_notes(self) -> None: verifier = ROOT / "test" / "tileop_api" / "verify_pto_identity.py" expected = ( - b'{"encoding_abi":"pto-isa-0.59.0-mode-function-v1",' + b'{"encoding_abi":"pto-isa-0.58.3-mode-function-v1",' b'"encoding_projection_sha256":' - b'"91509080ca656eb124f47830dcb09c50389dc177266b3b8df9d2d11dc37d5697",' - b'"release":"0.59.0"}' + b'"8a48b80e04484c70870f155bf9efc79d2a805cf99e809f4e4e8a7e6a7eb34172",' + b'"release":"0.58.3"}' ) def make_elf(desc: bytes = expected, owner: bytes = b"PTO\0", @@ -1303,11 +1227,11 @@ def make_note(note_desc: bytes) -> bytes: "missing": make_elf(owner=b"GNU\0"), "corrupt": make_elf(magic=b"BAD!"), "wrong-machine": make_elf(machine=0x3E), - "wrong-identity": make_elf(desc=expected.replace(b"0.59.0", b"0.59.1")), + "wrong-identity": make_elf(desc=expected.replace(b"0.58.3", b"0.58.2")), "trailing-nul": make_elf(desc=expected + b"\0"), "duplicate-segment": make_elf(extra_desc=expected), "conflicting-segment": make_elf( - extra_desc=expected.replace(b"0.59.0", b"0.59.1")), + extra_desc=expected.replace(b"0.58.3", b"0.58.2")), } for name, contents in variants.items(): path = temporary_path / f"{name}.elf" diff --git a/test/test_version_header.py b/test/test_version_header.py index 3c8f1c24..e61a9e7e 100644 --- a/test/test_version_header.py +++ b/test/test_version_header.py @@ -13,8 +13,8 @@ class TileOpApiVersionHeaderTest(unittest.TestCase): def test_source_header_exposes_version_and_feature(self): header = SOURCE_HEADER.read_text(encoding="utf-8") - self.assertIn('#define PTO_TILEOP_API_VERSION "0.59.0"', header) - self.assertIn('#define PTO_TILEOP_API_SPEC_VERSION "0.59.0"', header) + self.assertIn('#define PTO_TILEOP_API_VERSION "0.58.7"', header) + self.assertIn('#define PTO_TILEOP_API_SPEC_VERSION "0.58.7"', header) self.assertIn('#define PTO_TILEOP_API_REVISION "source-tree"', header) self.assertIn('#define PTO_TILEOP_API_REVISION_IS_EXACT 0', header) self.assertIn('#define PTO_TILEOP_API_HAS_LOCAL_B_KN_FIX 1', header) diff --git a/test/test_weight_tload_contract.py b/test/test_weight_tload_contract.py index a5192ca9..fa84a125 100644 --- a/test/test_weight_tload_contract.py +++ b/test/test_weight_tload_contract.py @@ -37,7 +37,7 @@ def test_weight_bundle_uses_shared_nk_contract(self): end = ASM.index("// TLOAD_ASS: GM -> an already-associated Shared Tile", start) block = ASM[start:end] for command in ( - '"BSTART.TLOAD %D[SrcType]\\n"', + '"BSTART.TLSU TLOAD, %D[SrcType]\\n"', '"B.DATR layout%c[WeightLayout], DTYPE_NONE, Zero\\n"', '"B.DIM %[ValidK], 0, ->lb0\\n"', '"B.DIM %[ValidN], 0, ->lb1\\n"', @@ -55,4 +55,4 @@ def test_compile_fixture_exercises_weight_overload(self): if __name__ == "__main__": - unittest.main() + unittest.main() \ No newline at end of file diff --git a/test/tileop_api/pto0583_asm_contract.s b/test/tileop_api/pto0583_asm_contract.s index 2b51b8e7..066f170a 100644 --- a/test/tileop_api/pto0583_asm_contract.s +++ b/test/tileop_api/pto0583_asm_contract.s @@ -1,18 +1,17 @@ .text -# PTO ISA 0.58.7 development descriptor surface used by the TileOP headers. This fixture +# PTO ISA 0.58.4 descriptor surface used by the TileOP headers. This fixture # is intentionally register-concrete so the integrated assembler/disassembler # can be validated even when the C++ Tile register frontend is unavailable. -BSTART.TLOAD FP32 +BSTART.TLSU TLOAD, FP32 B.DATR ND2M32.normal, Zero -BSTART.TSTORE FP32 +BSTART.TLSU TSTORE, FP32 B.DATR N82ND.normal, Null -BSTART.TMATMUL FP32 +BSTART.CUBE TMATMUL, FP32 B.FPATR 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 B.IOR [a0, a1], [] -B.IOT t#1.reuse, mask=1100, last, ->m<64KB> -B.IOS S1.reuse, mask=1111 -B.IOT t#1.reuse, u#2.reuse, mask=1111, last +B.IOT t#1, mask=1100, last, ->m<64KB> +B.IOS S1, mask=1111 B.IOS mask=1111, ->S63<256KB> BSTART.TIMG2COL FP32 B.DATR ND2M32, DTYPE_NONE, Zero @@ -27,15 +26,15 @@ B.IOT mask=1111, last, ->t<64KB> # substitution. Prove the matching MC accepts the form and fully elides the # absent source while retaining the present source. .if 0 -B.IOT t#2.reuse, mask=1111 +B.IOT t#2, mask=1111 .endif .if 1 -B.IOT t#3.reuse, mask=1111, last, ->t<1KB> +B.IOT t#3, mask=1111, last, ->t<1KB> .endif -# PTO-ISA 0.58.7 range modifiers (ADR-0098): each modifier is immediately +# PTO-ISA 0.58.4 range modifiers (ADR-0098): each modifier is immediately # adjacent to the binder and uses the binder's storage class and role. -B.IOT t#4.reuse, mask=1111, last, ->t<1KB> +B.IOT t#4, mask=1111, last, ->t<1KB> B.SUBVIEW 0, a0, 0, 1 B.IOS mask=1111, ->S2<1KB> B.ASSEMBLE 1, 0, zero, 100, 12 diff --git a/test/tileop_api/src/MGatherAtomics.cpp b/test/tileop_api/src/MGatherAtomics.cpp index 14debb08..9d9bebdc 100644 --- a/test/tileop_api/src/MGatherAtomics.cpp +++ b/test/tileop_api/src/MGatherAtomics.cpp @@ -1,6 +1,6 @@ // TLSU GM_ATOM_VALUE family: atomic RMW gather at logical element indices with // observed-old-value publication (PTO ISA functions 9-18; canonical -// BSTART.MGATHER.). Requires a function-aware assembler (0.58.6+) to +// BSTART.TLSU MGATHER.). Requires a function-aware assembler (0.58.6+) to // lower the bundles. U32 is legal for every member below, so one transfer tile // covers ADD/MAX/MIN/AND/OR/XOR/EXCH/INC/DEC. #include diff --git a/test/tileop_api/src/MGatherCas.cpp b/test/tileop_api/src/MGatherCas.cpp index e7791d62..1a982c6e 100644 --- a/test/tileop_api/src/MGatherCas.cpp +++ b/test/tileop_api/src/MGatherCas.cpp @@ -1,5 +1,5 @@ // MGATHER_CAS: atomic compare-and-swap at logical element indices -// (PTO ISA 0.58.7 TLSU function 8; canonical BSTART.MGATHER.CAS). +// (PTO ISA 0.58.7 TLSU function 8; canonical BSTART.TLSU MGATHER.CAS). #include using namespace pto; diff --git a/test/tileop_api/src/MScatterAtomics.cpp b/test/tileop_api/src/MScatterAtomics.cpp index 7decf4d5..d3913513 100644 --- a/test/tileop_api/src/MScatterAtomics.cpp +++ b/test/tileop_api/src/MScatterAtomics.cpp @@ -1,6 +1,6 @@ // TLSU GM_RED_VALUE / GM_RED_POPC family: atomic reduction scatter at logical // element indices with no destination (PTO ISA functions 19-27; canonical -// BSTART.MSCATTER.). Requires a function-aware assembler (0.58.6+) to +// BSTART.TLSU MSCATTER.). Requires a function-aware assembler (0.58.6+) to // lower the bundles. U32 is legal for every reduction member; POPC takes only // an index tile. #include diff --git a/test/tileop_api/src/TeplAssSpecial.cpp b/test/tileop_api/src/TeplAssSpecial.cpp index fe78e947..3bbeb389 100644 --- a/test/tileop_api/src/TeplAssSpecial.cpp +++ b/test/tileop_api/src/TeplAssSpecial.cpp @@ -23,11 +23,13 @@ __attribute__((noinline)) void tepl_ass_special(F &a, F &b, F &c, F &fd, TRSQRT_ASS(f, a); TRELU_ASS(f, a); TCVT_ASS(d, a); + TTRANS_ASS(f, a); TROWSUM_ASS(r, a); TROWMAX_ASS(r, a); TCOLSUM_ASS(c0, a); TROWEXPAND_ASS(f, row); TCOLEXPAND_ASS(f, col); + TCONCAT_ASS(f, left, right); } int main() { diff --git a/test/tileop_api/verify_pto0583_asm.sh b/test/tileop_api/verify_pto0583_asm.sh index 7d7216a5..074a9151 100755 --- a/test/tileop_api/verify_pto0583_asm.sh +++ b/test/tileop_api/verify_pto0583_asm.sh @@ -13,35 +13,11 @@ trap 'rm -rf "$OUT"' EXIT "$ROOT/test/tileop_api/pto0583_asm_contract.s" -o "$OUT/contract.o" "$OBJDUMP" -d "$OUT/contract.o" >"$OUT/contract.diss" -# Every named TLSU/CUBE start emitted by this header must be accepted by the -# same LLVM MC catalog. VEC/SFU wrappers intentionally retain the raw TEPL -# carrier; their architectural alias inventory is checked in LinxISA/LLVM. -python3 - "$ROOT/contracts/linxisa-v0.58-engine-ops.json" \ - "$OUT/named-engine-starts.s" <<'PY' -import json -import sys -from pathlib import Path - -contract = json.loads(Path(sys.argv[1]).read_text(encoding="utf-8")) -lines = [".text"] -for key in ("tlsu_ops", "cube_ops"): - lines.extend(f"{row['mnemonic']} FP16" for row in contract[key]) -Path(sys.argv[2]).write_text("\n".join(lines) + "\n", encoding="utf-8") -PY -"$MC" -triple="$MC_TRIPLE" -filetype=obj \ - "$OUT/named-engine-starts.s" -o "$OUT/named-engine-starts.o" -"$OBJDUMP" -d "$OUT/named-engine-starts.o" >"$OUT/named-engine-starts.diss" -if [[ $(grep -c 'BSTART\.' "$OUT/named-engine-starts.diss") -ne 40 ]]; then - echo 'FAIL: not all 40 golden TLSU/CUBE named starts survived MC round-trip' >&2 - sed -n '1,160p' "$OUT/named-engine-starts.diss" >&2 - exit 1 -fi - require_disassembly() { local pattern=$1 local description=$2 if ! grep -Eq "$pattern" "$OUT/contract.diss"; then - echo "FAIL: missing canonical $description in PTO 0.58.7 disassembly" >&2 + echo "FAIL: missing canonical $description in PTO 0.58.4 disassembly" >&2 sed -n '1,120p' "$OUT/contract.diss" >&2 exit 1 fi @@ -49,22 +25,18 @@ require_disassembly() { require_disassembly 'B\.FPATR[[:space:]]+0, 0, 0, 0, 0, 0, 0, 0, 0, 0' \ 'ten-field B.FPATR' -require_disassembly 'B\.IOT[[:space:]]+t#1\.reuse, mask=1100, last,.*->m<64KB>' \ +require_disassembly 'B\.IOT[[:space:]]+t#1, mask=1100, last,.*->m<64KB>' \ 'Local SizeCode=10 form' -require_disassembly 'B\.IOS[[:space:]]+S1\.reuse, mask=1111' \ - 'Shared retained-source form' -require_disassembly 'B\.IOT[[:space:]]+t#1\.reuse, u#2\.reuse, mask=1111, last' \ - 'two-source retained Local form' require_disassembly 'B\.IOS[[:space:]]+mask=1111, ->S63<256KB>' \ 'Shared SizeCode=12 form' -require_disassembly 'B\.DATR[[:space:]]+ND2M32, DTYPE_NONE, Zero' \ +require_disassembly 'B\.DATR[[:space:]]+ND2M32\.normal, Zero' \ 'ND2M32 CUBE load layout' -require_disassembly 'B\.DATR[[:space:]]+N82ND, DTYPE_NONE, Null' \ +require_disassembly 'B\.DATR[[:space:]]+N82ND\.normal, Null' \ 'N82ND CUBE store layout' require_disassembly 'B\.SUBVIEW[[:space:]]+0, a0, 0, 1' \ 'B.SUBVIEW range modifier' if ! awk ' - /B\.IOT[[:space:]]+t#4\.reuse, mask=1111, last/ { binder=NR; next } + /B\.IOT[[:space:]]+t#4, mask=1111, last/ { binder=NR; next } /B\.SUBVIEW[[:space:]]+0, a0, 0, 1/ { if (NR == binder + 1) adjacent=1 } END { exit adjacent ? 0 : 1 } ' "$OUT/contract.diss"; then @@ -76,9 +48,9 @@ require_disassembly 'B\.ASSEMBLE[[:space:]]+1, 0, a0, 100, 12' \ 'B.ASSEMBLE range modifier' require_disassembly 'B\.ASSEMBLE[[:space:]]+1, 0, zero, 100, 12' \ 'Shared-destination B.ASSEMBLE range modifier' -require_disassembly 'B\.IOT[[:space:]]+t#3\.reuse, mask=1111, last,.*->t<1KB>' \ +require_disassembly 'B\.IOT[[:space:]]+t#3, mask=1111, last,.*->t<1KB>' \ 'present conditional MX scale binder' -if grep -Eq 'B\.IOT[[:space:]]+t#2\.reuse, mask=1111' "$OUT/contract.diss"; then +if grep -Eq 'B\.IOT[[:space:]]+t#2, mask=1111' "$OUT/contract.diss"; then echo "FAIL: absent conditional MX scale binder survived assembly" >&2 sed -n '1,120p' "$OUT/contract.diss" >&2 exit 1 @@ -97,4 +69,4 @@ for invalid in \ fi done -echo "PTO ISA 0.58.7 MC/disassembly/negative contract: PASS" +echo "PTO ISA 0.58.4 MC/disassembly/negative contract: PASS" diff --git a/test/tileop_api/verify_pto_identity.py b/test/tileop_api/verify_pto_identity.py index 05a52d0a..0d49026d 100644 --- a/test/tileop_api/verify_pto_identity.py +++ b/test/tileop_api/verify_pto_identity.py @@ -1,5 +1,5 @@ #!/usr/bin/env python3 -"""Fail-closed validation of the exact PTO 0.59.0 release ELF note.""" +"""Fail-closed validation of the exact PTO 0.58.3 ELF note.""" from __future__ import annotations @@ -12,10 +12,10 @@ PT_NOTE = 4 SHT_NOTE = 7 EXPECTED_DESC = ( - b'{"encoding_abi":"pto-isa-0.59.0-mode-function-v1",' + b'{"encoding_abi":"pto-isa-0.58.3-mode-function-v1",' b'"encoding_projection_sha256":' - b'"91509080ca656eb124f47830dcb09c50389dc177266b3b8df9d2d11dc37d5697",' - b'"release":"0.59.0"}' + b'"8a48b80e04484c70870f155bf9efc79d2a805cf99e809f4e4e8a7e6a7eb34172",' + b'"release":"0.58.3"}' ) @@ -138,7 +138,7 @@ def validate(path: Path) -> None: require(not identity_desc.endswith(b"\0"), "PTO JSON must not have a trailing NUL") require(identity_desc == EXPECTED_DESC, - "PTO identity JSON is not the exact 0.59.0 release identity") + "PTO identity JSON is not exact 0.58.3") require(len(identities) == 1, "PTO identity must have exactly one note range") @@ -157,7 +157,7 @@ def main(argv: list[str]) -> int: except (OSError, IdentityError, struct.error) as error: print(f"FAIL PTO identity: {error}", file=sys.stderr) return 1 - print("PTO ISA 0.59.0 release ELF identity: PASS") + print("PTO ISA 0.58.3 ELF identity: PASS") return 0 diff --git a/test/tileop_api/verify_target_cxx_frontend.sh b/test/tileop_api/verify_target_cxx_frontend.sh index e658f967..79850841 100755 --- a/test/tileop_api/verify_target_cxx_frontend.sh +++ b/test/tileop_api/verify_target_cxx_frontend.sh @@ -284,12 +284,12 @@ PY # zero-instruction and non-owning. "$TC_DIR/clang++" "${FLAGS[@]}" -S -emit-llvm \ "$ROOT/test/tileop_api/src/SharedRoleView.cpp" -o "$OUT/SharedRoleView.ll" -grep -q 'BSTART.TMATMUL' "$OUT/SharedRoleView.ll" +grep -q 'BSTART.CUBE TMATMUL' "$OUT/SharedRoleView.ll" if grep -Eq 'BSTART\.(TLOAD|TMOV)' "$OUT/SharedRoleView.ll"; then echo "FAIL: SharedRoleView emitted a load or Shared move" >&2 exit 1 fi -if [[ $(grep -c 'BSTART.TMATMUL' "$OUT/SharedRoleView.ll") -ne 2 ]]; then +if [[ $(grep -c 'BSTART.CUBE TMATMUL' "$OUT/SharedRoleView.ll") -ne 2 ]]; then echo "FAIL: SharedRoleView did not emit exactly two TMATMUL operations" >&2 exit 1 fi @@ -439,7 +439,7 @@ for name, counts in expected.items(): raise SystemExit(f"missing object-producing function {name}") calls = [line for line in body.splitlines() if "asm sideeffect" in line and - ("BSTART.TMATMULMX" in line or "BSTART.TGEMVMX" in line)] + ("BSTART.CUBE TMATMULMX" in line or "BSTART.CUBE TGEMVMX" in line)] if len(calls) != 3: raise SystemExit(f"{name}: expected 3 MX family calls, got {len(calls)}") constraints = [line.split('"', 4)[3] for line in calls] @@ -450,7 +450,7 @@ for name, counts in expected.items(): post = next(part for part in functions if "carrier_postprocess_all_sources" in part) post_calls = [line for line in post.splitlines() - if "asm sideeffect" in line and "BSTART.TMATMULMX" in line] + if "asm sideeffect" in line and "BSTART.CUBE TMATMULMX" in line] if len(post_calls) != 1: raise SystemExit("postprocess carrier must emit exactly one MX call") constraints = post_calls[0].split('"', 4)[3] diff --git a/tools/check_issue_49_docs.py b/tools/check_issue_49_docs.py index 489c99e8..2238a1b0 100644 --- a/tools/check_issue_49_docs.py +++ b/tools/check_issue_49_docs.py @@ -25,9 +25,8 @@ def main() -> int: "offset examples must use uint32_t"), ("TSTORE_PART" in text and "TMOV_L2S_INSERT" in text, "Shared partial-store and Local-to-Shared contracts must be documented"), - ("TMRGSORT（仅历史参考）" in text and - "没有 PTO ISA 0.59.0 bundle 组成" in text, - "retired TMRGSORT must not retain an active physical-shape contract"), + ("TMRGSORT" in text and "physical columns" in text, + "TMRGSORT physical-shape contract must be documented"), ("TROWSUM" in text and "R x 1" in text and "TCOLSUM" in text and "1 x C" in text, "reduction output shapes must be documented"), (all(token in text for token in ( @@ -65,4 +64,4 @@ def main() -> int: return 0 if __name__ == "__main__": - sys.exit(main()) + sys.exit(main()) \ No newline at end of file diff --git a/tools/check_pto_catalog_alignment.py b/tools/check_pto_catalog_alignment.py index 6d2d9e88..3ad3b230 100644 --- a/tools/check_pto_catalog_alignment.py +++ b/tools/check_pto_catalog_alignment.py @@ -1,26 +1,21 @@ #!/usr/bin/env python3 -"""Fail-closed checks for the pinned PTO ISA 0.59.0 Tile catalog. +"""Fail-closed checks for the pinned PTO ISA 0.58.7 Tile catalog. This check deliberately verifies inventory and provenance, not the full ASL/NDF -semantics. The latter remains owned by PTO-ISA/pto-spec. The 119-operation Tile -catalog is byte-identical between the PTO 0.58.7 development golden and the -published PTO ISA 0.59.0.0 release (both SHA-256 533db9b8...), so the pinned -bytes did not change when the active encoding identity moved to the release. +semantics. The latter remains owned by PTO-ISA/pto-spec. """ from __future__ import annotations import json -import hashlib import re import sys from pathlib import Path ROOT = Path(__file__).resolve().parents[1] -CATALOG = ROOT / "contracts" / "pto-isa-0.59.0-tile-operations.json" +CATALOG = ROOT / "contracts" / "pto-isa-0.58.7-tile-operations.json" INCLUDE = ROOT / "include" DOCS = ROOT / "docs" / "tileop-usage" -EXPECTED_TILE_CATALOG_SHA256 = "533db9b8f31f118af5978de813cfaa3fa738de820ee24655faa2ee71f343a706" def text(paths: list[Path]) -> str: @@ -30,10 +25,8 @@ def text(paths: list[Path]) -> str: def main() -> int: catalog = json.loads(CATALOG.read_text(encoding="utf-8")) failures: list[str] = [] - if hashlib.sha256(CATALOG.read_bytes()).hexdigest() != EXPECTED_TILE_CATALOG_SHA256: - failures.append("catalog bytes do not match the reviewed PTO 0.59.0.0 release Tile catalog") - if catalog.get("operation_count") != 119: - failures.append("catalog operation_count is not 119") + if catalog.get("operation_count") != 118: + failures.append("catalog operation_count is not 118") operations = catalog.get("operations", []) if len(operations) != catalog.get("operation_count"): failures.append("catalog operation_count does not match operations length") @@ -45,18 +38,12 @@ def main() -> int: include_text = text([p for p in INCLUDE.rglob("*") if p.is_file()]) docs_text = text([p for p in DOCS.rglob("*.md") if p.is_file()]) - source_referenced = { - name for name in names if re.search(rf"\b{re.escape(name)}\b", include_text) - } - explicitly_unsupported = { - name - for name in names - if re.search(rf"`{re.escape(name)}`[^\n]{{0,180}}尚无 wrapper", docs_text) - } for name in names: - if name not in source_referenced and name not in explicitly_unsupported: + if not re.search(rf"\b{re.escape(name)}\b", include_text) and not re.search( + rf"`{re.escape(name)}`[^\n]{{0,180}}尚无 wrapper", docs_text + ): failures.append( - f"active catalog operation has neither source reference nor explicit unsupported marker: {name}" + f"active catalog operation has neither wrapper nor explicit unsupported marker: {name}" ) for name in catalog.get("deleted_names", []): active = re.search(rf"\b{re.escape(name)}\s*\(", include_text) @@ -95,17 +82,13 @@ def main() -> int: failures.append(f"TEXPDIF support status is missing backend dimension: {marker}") if failures: - print("FAIL: PTO 0.59.0 catalog alignment", file=sys.stderr) + print("FAIL: PTO 0.58.7 catalog alignment", file=sys.stderr) for failure in failures: print(f" - {failure}", file=sys.stderr) return 1 - print( - "PASS: PTO 0.59.0.0 release catalog alignment " - f"({len(names)} release operations; {len(source_referenced)} source-referenced; " - f"{len(explicitly_unsupported)} explicitly unsupported)" - ) + print(f"PASS: PTO 0.58.7 catalog alignment ({len(names)} active operations)") return 0 if __name__ == "__main__": - raise SystemExit(main()) + raise SystemExit(main()) \ No newline at end of file diff --git a/tools/generate_engine_docs.py b/tools/generate_engine_docs.py index ffa6b434..65cdc8a4 100644 --- a/tools/generate_engine_docs.py +++ b/tools/generate_engine_docs.py @@ -1,24 +1,23 @@ #!/usr/bin/env python3 """Generate the wrapper engine compatibility view from the pinned projection. -The output mirrors the PTO ISA 0.59.0.0 release Tile catalog +The output mirrors the active portion exposed by this wrapper. The checked-in +projection is historical LinxISA/PTO 0.58.3 data and is not a replacement for +the PTO ISA 0.58.7 catalog. (spec/catalog/tile-operations.json) for the four architectural engine -classes: **VEC**, **SFU**, **TLSU**, and **CUBE**. The engine inventory is the -LinxISA v0.58 authority projection; its 119-operation catalog is byte-identical -to the published PTO ISA 0.59.0.0 release. Engine and classification are -decoupled (per ADR 0057): TEXP/TLOG/... are SFU-executed elementwise -operations, TGATHER/TSCATTER/TCONCAT are SFU-executed layout/irregular -operations, and TMOV is a TLSU-executed layout operation. TEPL is the unique -compiled carrier identity. `BSTART.VEC` / `BSTART.SFU` are engine-specific -assembly aliases; current inline wrappers retain TEPL so the same source also -compiles with the preceding 0.58 toolchain. +classes: **VEC**, **SFU**, **TLSU**, and **CUBE**. Engine and +classification are decoupled (per ADR 0057): TEXP/TLOG/... are SFU-executed +elementwise operations, TGATHER/TSCATTER/TCONCAT are SFU-executed +layout/irregular operations, and TMOV is a TLSU-executed layout operation. +TEPL is the unique compiled carrier identity. `BSTART.VEC` / `BSTART.SFU` are +engine-specific assembly aliases; current inline wrappers retain TEPL so the +same source also compiles with the preceding 0.58 toolchain. """ from __future__ import annotations import argparse import json -import re from pathlib import Path @@ -30,37 +29,16 @@ def render() -> str: contract = json.loads(CONTRACT.read_text(encoding="utf-8")) deleted_names = set(contract.get("deleted_tile_names", [])) - implementation_text = "\n".join( - path.read_text(encoding="utf-8", errors="ignore") - for path in (ROOT / "include").rglob("*") - if path.is_file() - ) - - def wrapper_status(name: str) -> str: - if re.search(rf"\b{re.escape(name)}\b", implementation_text): - return "源码有引用；不代表完整语义一致" - return "尚无 wrapper" - - operation_names = { - row["name"] - for key in ("tepl_ops", "tlsu_ops", "cube_ops") - for row in contract[key] - } - source_referenced = sum(wrapper_status(name).startswith("源码有引用") - for name in operation_names) lines = [ - "# LinxISA v0.58 / PTO ISA 0.59.0.0 wrapper engine compatibility view", + "# LinxISA / PTO ISA v0.58.7 wrapper engine compatibility view", "", "架构定义的引擎类别只有 **VEC**, **TLSU**, **CUBE**, and **SFU**。", "VEC 只包含逐元素操作；SFU 包含归约、广播、变换、排序以及其他需要更复杂硬件的操作。", "TEPL 仍是唯一的编译 carrier 标识。`BSTART.VEC` 和 `BSTART.SFU` 是特定引擎的汇编别名；", "inline wrapper 保留 `BSTART.TEPL`，以兼容之前的工具链源码。", "", - "下表根据本仓库固定的 LinxISA v0.58 authority 投影生成（其操作清单与 PTO ISA 0.59.0.0", - "发布 catalog 逐字节一致），数据记录在", + "下表根据本仓库固定的 LinxISA 历史投影生成，数据记录在", "[`contracts/linxisa-v0.58-engine-ops.json`](../../../contracts/linxisa-v0.58-engine-ops.json) 中。", - f"投影共 {len(operation_names)} 项；其中 {source_referenced} 项在 `include/` 有名称引用，", - f"{len(operation_names) - source_referenced} 项明确没有 wrapper。名称引用不证明 ASL/NDF 语义完整实现。", "", ] @@ -70,8 +48,8 @@ def wrapper_status(name: str) -> str: [ f"## {engine}", "", - "| Golden 操作 | 规范汇编 | 逻辑 selector | 分类 | Wrapper 状态 |", - "| --- | --- | ---: | --- | --- |", + "| API / 操作 | 规范汇编 | 逻辑 selector | 分类 |", + "| --- | --- | ---: | --- |", ] ) for row in rows: @@ -79,8 +57,7 @@ def wrapper_status(name: str) -> str: continue lines.append( f"| `{row['name']}` | `BSTART.{engine} {row['name']}` | " - f"{row['logical_selector']} | {row['classification']} | " - f"{wrapper_status(row['name'])} |" + f"{row['logical_selector']} | {row['classification']} |" ) lines.append("") @@ -89,26 +66,22 @@ def wrapper_status(name: str) -> str: [ f"## {engine}", "", - "| Golden 操作 | 规范 block 起始指令 | Function | Wrapper 状态 |", - "| --- | --- | ---: | --- |", + "| 操作 | 规范 block 起始指令 | Function |", + "| --- | --- | ---: |", ] ) for row in contract[key]: if row["name"] in deleted_names: continue - lines.append( - f"| `{row['name']}` | `{row['mnemonic']}` | {row['function']} | " - f"{wrapper_status(row['name'])} |" - ) + lines.append(f"| `{row['name']}` | `{row['mnemonic']}` | {row['function']} |") lines.append("") lines.extend( [ "## 分类语义", "", - "PTO ISA 0.59.0 将执行引擎与操作分类解耦。本表是 wrapper compatibility view；", - "其底层投影记录 LinxISA v0.58 authority 的 selector 数据（与 0.59.0.0 发布 catalog 一致）。", - "`elementwise-tile-tile`", + "PTO ISA 0.58.7 将执行引擎与操作分类解耦。本表是 wrapper compatibility view；", + "其底层投影仍保留历史版本的 selector 数据。`elementwise-tile-tile`", "和 `tile-scalar-and-immediate` 类别在 VEC 上执行逐元素操作，但其中的", "`TEXP`、`TLOG`、`TRECIP`、`TSQRT`、`TRSQRT` 由 SFU 执行。", "`reduce-and-expand`、`layout-and-rearrangement` 和 `irregular-and-complex` 类别由 SFU 执行。", @@ -124,7 +97,7 @@ def wrapper_status(name: str) -> str: [ "## 早期版本中移除的操作", "", - "历史版本还提供了一些已从 PTO 0.59.0 active catalog 移除的 Tile 操作（例如 ACC 风格的后处理辅助操作）。", + "历史版本还提供了一些已从 PTO 0.58.7 active catalog 移除的 Tile 操作（例如 ACC 风格的后处理辅助操作）。", "本库不会把已退役的操作生成到当前目录；退役名称的规范列表记录在 contract 的 `deleted_tile_names` 字段中。", "", ] diff --git a/tools/generate_tileop_usage_docs.py b/tools/generate_tileop_usage_docs.py index 11f10b92..7b10c78d 100644 --- a/tools/generate_tileop_usage_docs.py +++ b/tools/generate_tileop_usage_docs.py @@ -15,7 +15,7 @@ DOC_ROOT = ROOT / "docs/tileop-usage" SPEC_DOC_ROOT = SPEC_ROOT / "docs/tile" ASL_ROOT = SPEC_ROOT / "asl/tile" -PTO_SPEC_REF = "v0.59.0.0" +PTO_SPEC_REF = "v0.58.7" # Names used by the TileDataType encoding. Keeping this list here makes the # documentation generator independent of prose wording in individual SPEC diff --git a/tools/sync_linxisa_v058_contract.py b/tools/sync_linxisa_v058_contract.py new file mode 100644 index 00000000..f8fe4989 --- /dev/null +++ b/tools/sync_linxisa_v058_contract.py @@ -0,0 +1,155 @@ +#!/usr/bin/env python3 +"""Project the reviewed LinxISA/PTO 0.58.3 engine catalog into this API.""" + +from __future__ import annotations + +import argparse +import hashlib +import json +import subprocess +from pathlib import Path + + +ROOT = Path(__file__).resolve().parents[1] +DEFAULT_OUTPUT = ROOT / "contracts" / "linxisa-v0.58-engine-ops.json" +EXPECTED_COUNTS = {"CUBE": 12, "SFU": 57, "TLSU": 10, "VEC": 31} +EXPECTED_COMMIT = "dd52a2e579d8058c0d8e33043e705122b340e73f" +EXPECTED_TREE = "1cfc7343e714489f95f67592475e8b9f079241ee" +EXPECTED_CATALOG_SHA256 = "34ecbcfa075166490b622647eb53c13a9c360848d6c7acb2e034d3e47f8c9a8a" +EXPECTED_PTO_COMMIT = "e599a3d36ebfad43362ff591ea5e128816c684c7" +EXPECTED_PTO_TREE = "abb6899d2e664e378ac9c1b77062670daa4d31b4" +EXPECTED_PTO_ENCODING_SHA256 = "8a48b80e04484c70870f155bf9efc79d2a805cf99e809f4e4e8a7e6a7eb34172" +EXPECTED_PTO_CONTENT_SHA256 = "f299fe3d256c5d071e57bb4aaa2be2de2e4a386ae090048df1f73ae92d392678" + + +def git(repo: Path, *args: str) -> str: + result = subprocess.run( + ["git", "-C", str(repo), *args], + check=True, + text=True, + stdout=subprocess.PIPE, + ) + return result.stdout.strip() + + +def build_projection(source: Path) -> dict[str, object]: + source = source.resolve() + repo = Path(git(source.parent, "rev-parse", "--show-toplevel")) + if git(repo, "status", "--porcelain=v1", "--untracked-files=all"): + raise SystemExit(f"refusing dirty LinxISA source tree: {repo}") + commit = git(repo, "rev-parse", "HEAD") + tree = git(repo, "rev-parse", "HEAD^{tree}") + source_sha256 = hashlib.sha256(source.read_bytes()).hexdigest() + if (commit, tree, source_sha256) != (EXPECTED_COMMIT, EXPECTED_TREE, EXPECTED_CATALOG_SHA256): + raise SystemExit("LinxISA v0.58 source identity does not match the reviewed release") + + data = json.loads(source.read_text(encoding="utf-8")) + if data.get("isa") != "LinxISA" or data.get("version") != "0.58.3": + raise SystemExit("source is not the LinxISA/PTO 0.58.3 canonical catalog") + engine_ops = data["state"]["engine_ops"] + if engine_ops["semantic_engine_counts"] != EXPECTED_COUNTS: + raise SystemExit("unexpected LinxISA v0.58 engine counts") + pto_lock_path = source.parent / "pto-spec.lock.json" + pto_lock = json.loads(pto_lock_path.read_text(encoding="utf-8")) + pto_identity = ( + pto_lock.get("release"), + pto_lock.get("source", {}).get("commit"), + pto_lock.get("source", {}).get("tree"), + pto_lock.get("encoding_projection_sha256"), + pto_lock.get("content_sha256"), + ) + expected_pto_identity = ( + "0.58.3", + EXPECTED_PTO_COMMIT, + EXPECTED_PTO_TREE, + EXPECTED_PTO_ENCODING_SHA256, + EXPECTED_PTO_CONTENT_SHA256, + ) + if pto_identity != expected_pto_identity: + raise SystemExit("LinxISA authority does not carry the reviewed PTO 0.58.3 lock") + + relative = source.relative_to(repo).as_posix() + return { + "schema": "linx-tileop-api.engine-ops-projection.v1", + "profile": "v0.58", + "source": { + "repo": "https://github.com/LinxISA/linx-isa", + "release": "0.58.3", + "commit": commit, + "tree": tree, + "path": relative, + "sha256": source_sha256, + }, + "pto_source": { + "repo": pto_lock["source"]["repository"], + "release": pto_lock["release"], + "commit": pto_lock["source"]["commit"], + "tree": pto_lock["source"]["tree"], + "encoding_abi": pto_lock["encoding_abi"], + "encoding_projection_sha256": pto_lock["encoding_projection_sha256"], + "content_sha256": pto_lock["content_sha256"], + }, + "semantic_engine_counts": engine_ops["semantic_engine_counts"], + "tepl_carrier": { + "selector_formula": engine_ops["tepl"]["selector_formula"], + "accepted_selector_count": engine_ops["tepl"]["accepted_selector_count"], + "canonical_aliases": ["BSTART.VEC", "BSTART.SFU"], + "compatibility_spelling": "BSTART.TEPL", + }, + "tepl_ops": [ + { + "name": row["name"], + "logical_selector": row["logical_selector"], + "mode": row["mode"], + "function": row["function"], + "engine": row["engine"], + "classification": row["classification"], + } + for row in engine_ops["tepl"]["ops"] + ], + "tlsu_ops": [ + { + "name": row["name"], + "function": row["function"], + "mnemonic": row["mnemonic"], + "engine": row["engine"], + } + for row in engine_ops["tlsu"]["legal_aliases"] + ], + "cube_ops": [ + { + "name": row["name"], + "function": row["function"], + "mnemonic": row["mnemonic"], + "engine": row["engine"], + } + for row in engine_ops["cube"]["legal_aliases"] + ], + "deleted_tile_names": data["retired_encodings"]["deleted_tile_names"], + } + + +def render(projection: dict[str, object]) -> str: + return json.dumps(projection, indent=2, sort_keys=True) + "\n" + + +def main() -> int: + parser = argparse.ArgumentParser() + parser.add_argument("source", type=Path, help="released isa/v0.58/linxisa-v0.58.json") + parser.add_argument("--output", type=Path, default=DEFAULT_OUTPUT) + parser.add_argument("--check", action="store_true") + args = parser.parse_args() + + expected = render(build_projection(args.source)) + if args.check: + if not args.output.exists() or args.output.read_text(encoding="utf-8") != expected: + raise SystemExit(f"stale LinxISA v0.58 projection: {args.output}") + return 0 + + args.output.parent.mkdir(parents=True, exist_ok=True) + args.output.write_text(expected, encoding="utf-8") + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/tools/sync_pto_isa_0590_contract.py b/tools/sync_pto_isa_0590_contract.py deleted file mode 100644 index 1a340251..00000000 --- a/tools/sync_pto_isa_0590_contract.py +++ /dev/null @@ -1,293 +0,0 @@ -#!/usr/bin/env python3 -"""Project the reviewed LinxISA v0.58 authority and the published PTO ISA -0.59.0.0 release into this API. - -Provenance model ----------------- -* The LinxISA v0.58 authority is unchanged: it still owns the semantic engine - projection (VEC/SFU/TLSU/CUBE operation inventory and selectors) and it - locked the PTO *development* golden through ``pto-scalar-proposal.lock.json``. -* The active PTO *encoding identity* (ABI, encoding-projection SHA-256 and ELF - ``release`` field) is the published PTO ISA ``v0.59.0.0`` release, read from a - clean ``spec/release-manifest.json``. -* There is no LinxISA ``0.59`` profile, so this tool does not fabricate one: - the LinxISA ``source`` stays ``v0.58`` and the development-golden lock is - recorded verbatim. The 119-operation Tile catalog is byte-identical between - the development golden and the 0.59.0.0 release (both SHA-256 533db9b8...), - which is what makes the v0.58 engine projection valid against the release. - -The release manifest records ``specification_status: draft``; this tool carries -that status faithfully rather than claiming a finalized specification. -""" - -from __future__ import annotations - -import argparse -import hashlib -import json -import subprocess -from pathlib import Path - - -ROOT = Path(__file__).resolve().parents[1] -DEFAULT_OUTPUT = ROOT / "contracts" / "linxisa-v0.58-engine-ops.json" -DEFAULT_PTO_OUTPUT = ROOT / "contracts" / "pto-isa-0.59.0-tile-operations.json" -EXPECTED_COUNTS = {"CUBE": 12, "SFU": 47, "TLSU": 28, "VEC": 32} - -# LinxISA v0.58 authority (unchanged). -EXPECTED_COMMIT = "f77a8960f61f97c264a90b7aee757f99891b0943" -EXPECTED_TREE = "da085d3f000a5b92031c9694024dc9a7f3cdaa89" -EXPECTED_CATALOG_SHA256 = "51ca9be275518d29ec48bed570b7a9bd441a65b9c5e6d4f79072f650ee732925" - -# PTO development golden that the LinxISA v0.58 authority locked. -EXPECTED_DEV_COMMIT = "f0a876e449a95d26841c5ee7affb4c905ebc5f5b" -EXPECTED_DEV_TREE = "fe9e8e050375fbce3f526d08acca13c37cd15830" -EXPECTED_DEV_MANIFEST_SHA256 = "0c6d0b2a1ec0b49e32e13971e751a5ea19946351a3880bfdfcef0f50351944f7" - -# Published PTO ISA 0.59.0.0 release (the active encoding identity). -EXPECTED_PTO_COMMIT = "b0165320a4b575b18d2f4d93faf40178f661ab49" -EXPECTED_PTO_TREE = "31ff0c2d39cbed714baf5be7929bfd06887be9fb" -EXPECTED_PTO_RELEASE_MANIFEST_SHA256 = ( - "3c6b20623e73822c0bd26021c10beb233b8809328b5515f57609eadad1749dc4" -) -EXPECTED_PTO_TILE_SHA256 = "533db9b8f31f118af5978de813cfaa3fa738de820ee24655faa2ee71f343a706" -EXPECTED_RELEASE_IDENTITY = { - "release": "0.59.0", - "publication_version": "0.59.0.0", - "encoding_abi": "pto-isa-0.59.0-mode-function-v1", - "encoding_projection_sha256": ( - "91509080ca656eb124f47830dcb09c50389dc177266b3b8df9d2d11dc37d5697" - ), - "content_sha256": ( - "a3e71975e7f753864f7ec09c57515e60f5a6e3e72dfdbce8e444c815a20b2835" - ), -} - - -def git(repo: Path, *args: str) -> str: - result = subprocess.run( - ["git", "-C", str(repo), *args], - check=True, - text=True, - stdout=subprocess.PIPE, - ) - return result.stdout.strip() - - -def sha256(path: Path) -> str: - return hashlib.sha256(path.read_bytes()).hexdigest() - - -def require_clean_exact_repo(repo: Path, commit: str, tree: str, label: str) -> None: - if git(repo, "status", "--porcelain=v1", "--untracked-files=all"): - raise SystemExit(f"refusing dirty {label} source tree: {repo}") - actual = (git(repo, "rev-parse", "HEAD"), git(repo, "rev-parse", "HEAD^{tree}")) - if actual != (commit, tree): - raise SystemExit(f"{label} source identity does not match the reviewed pin") - - -def load_sources( - source: Path, pto_root: Path -) -> tuple[dict[str, object], dict[str, object], Path]: - source = source.resolve() - linx_repo = Path(git(source.parent, "rev-parse", "--show-toplevel")) - require_clean_exact_repo(linx_repo, EXPECTED_COMMIT, EXPECTED_TREE, "LinxISA v0.58.7") - if sha256(source) != EXPECTED_CATALOG_SHA256: - raise SystemExit("LinxISA catalog bytes do not match the reviewed authority") - - pto_repo = Path(git(pto_root.resolve(), "rev-parse", "--show-toplevel")) - require_clean_exact_repo( - pto_repo, EXPECTED_PTO_COMMIT, EXPECTED_PTO_TREE, "PTO ISA 0.59.0.0 release" - ) - manifest_path = pto_repo / "spec" / "release-manifest.json" - tile_catalog_path = pto_repo / "spec" / "catalog" / "tile-operations.json" - if sha256(manifest_path) != EXPECTED_PTO_RELEASE_MANIFEST_SHA256: - raise SystemExit("PTO release manifest bytes do not match the reviewed release") - if sha256(tile_catalog_path) != EXPECTED_PTO_TILE_SHA256: - raise SystemExit("PTO Tile catalog bytes do not match the reviewed release") - - linx_data = json.loads(source.read_text(encoding="utf-8")) - manifest = json.loads(manifest_path.read_text(encoding="utf-8")) - tile_catalog = json.loads(tile_catalog_path.read_text(encoding="utf-8")) - if linx_data.get("isa") != "LinxISA" or linx_data.get("version") != "0.58.7": - raise SystemExit("source is not the reviewed LinxISA 0.58.7 catalog") - - release_identity = { - "release": manifest.get("release"), - "publication_version": manifest.get("publication_version"), - "encoding_abi": manifest.get("encoding_abi"), - "encoding_projection_sha256": manifest.get("encoding_projection_sha256"), - "content_sha256": manifest.get("content_sha256"), - } - if release_identity != EXPECTED_RELEASE_IDENTITY: - raise SystemExit("unexpected PTO 0.59.0.0 release identity") - counts = manifest.get("catalog_counts", {}).get("tile_operations_total") - if counts != 119: - raise SystemExit("unexpected PTO release Tile operation count") - if tile_catalog.get("operation_count") != 119 or len(tile_catalog.get("operations", [])) != 119: - raise SystemExit("unexpected PTO Tile catalog inventory") - - # The LinxISA v0.58 authority locked the PTO development golden. Keep that - # lock fail-closed and additionally require its Tile catalog bytes to equal - # the release Tile catalog, which is what makes this projection valid. - lock_path = source.parent / "pto-scalar-proposal.lock.json" - lock = json.loads(lock_path.read_text(encoding="utf-8")) - lock_identity = ( - lock.get("status"), - lock.get("source", {}).get("commit"), - lock.get("source", {}).get("tree"), - lock.get("development_manifest", {}).get("sha256"), - lock.get("catalogs", {}).get("tile_operations", {}).get("sha256"), - lock.get("catalogs", {}).get("tile_operations", {}).get("count"), - ) - expected_lock_identity = ( - "development-not-published", - EXPECTED_DEV_COMMIT, - EXPECTED_DEV_TREE, - EXPECTED_DEV_MANIFEST_SHA256, - EXPECTED_PTO_TILE_SHA256, - 119, - ) - if lock_identity != expected_lock_identity: - raise SystemExit("LinxISA authority does not carry the reviewed PTO development lock") - return linx_data, manifest, tile_catalog_path - - -def build_projection(source: Path, pto_root: Path) -> tuple[dict[str, object], bytes]: - linx_data, manifest, tile_catalog_path = load_sources(source, pto_root) - engine_ops = linx_data["state"]["engine_ops"] - if engine_ops["semantic_engine_counts"] != EXPECTED_COUNTS: - raise SystemExit("unexpected LinxISA v0.58.7 engine counts") - if sum(EXPECTED_COUNTS.values()) != 119: - raise SystemExit("engine counts do not cover the PTO release Tile catalog") - - linx_repo = Path(git(source.resolve().parent, "rev-parse", "--show-toplevel")) - relative = source.resolve().relative_to(linx_repo).as_posix() - projection = { - "schema": "linx-tileop-api.engine-ops-projection.v2", - "profile": "v0.58", - "source": { - "repo": "https://github.com/LinxISA/linx-isa", - "release": "0.58.7", - "commit": EXPECTED_COMMIT, - "tree": EXPECTED_TREE, - "path": relative, - "sha256": EXPECTED_CATALOG_SHA256, - }, - "pto_source": { - "repo": "https://github.com/PTO-ISA/pto-spec.git", - "release": EXPECTED_RELEASE_IDENTITY["release"], - "publication_version": EXPECTED_RELEASE_IDENTITY["publication_version"], - "release_tag": "v0.59.0.0", - "specification_status": manifest["specification_status"], - "commit": EXPECTED_PTO_COMMIT, - "tree": EXPECTED_PTO_TREE, - "release_manifest": { - "path": "spec/release-manifest.json", - "sha256": EXPECTED_PTO_RELEASE_MANIFEST_SHA256, - }, - "encoding_abi": EXPECTED_RELEASE_IDENTITY["encoding_abi"], - "encoding_projection_sha256": EXPECTED_RELEASE_IDENTITY[ - "encoding_projection_sha256" - ], - "content_sha256": EXPECTED_RELEASE_IDENTITY["content_sha256"], - "tile_catalog": { - "path": "spec/catalog/tile-operations.json", - "sha256": EXPECTED_PTO_TILE_SHA256, - "count": 119, - }, - "development_lock": { - "release": "0.58.7", - "commit": EXPECTED_DEV_COMMIT, - "tree": EXPECTED_DEV_TREE, - "development_manifest": { - "path": "spec/development-manifest.json", - "sha256": EXPECTED_DEV_MANIFEST_SHA256, - }, - "catalog_sha256_matches_release": True, - "note": ( - "The LinxISA v0.58 authority locked the PTO development " - "golden; its Tile catalog bytes equal the 0.59.0.0 release " - "Tile catalog (both SHA-256 533db9b8...), so the v0.58 " - "engine projection remains valid against the published " - "release." - ), - }, - }, - "semantic_engine_counts": engine_ops["semantic_engine_counts"], - "tepl_carrier": { - "selector_formula": engine_ops["tepl"]["selector_formula"], - "accepted_selector_count": engine_ops["tepl"]["accepted_selector_count"], - "canonical_aliases": ["BSTART.VEC", "BSTART.SFU"], - "compatibility_spelling": "BSTART.TEPL", - }, - "tepl_ops": [ - { - "name": row["name"], - "logical_selector": row["logical_selector"], - "mode": row["mode"], - "function": row["function"], - "engine": row["engine"], - "classification": row["classification"], - } - for row in engine_ops["tepl"]["ops"] - ], - "tlsu_ops": [ - { - "name": row["name"], - "function": row["function"], - "mnemonic": row["mnemonic"], - "engine": row["engine"], - } - for row in engine_ops["tlsu"]["legal_aliases"] - ], - "cube_ops": [ - { - "name": row["name"], - "function": row["function"], - "mnemonic": row["mnemonic"], - "engine": row["engine"], - } - for row in engine_ops["cube"]["legal_aliases"] - ], - "deleted_tile_names": linx_data["retired_encodings"]["deleted_tile_names"], - } - return projection, tile_catalog_path.read_bytes() - - -def render(projection: dict[str, object]) -> str: - return json.dumps(projection, indent=2, sort_keys=True) + "\n" - - -def main() -> int: - parser = argparse.ArgumentParser() - parser.add_argument("source", type=Path, help="reviewed isa/v0.58/linxisa-v0.58.json") - parser.add_argument( - "--pto-root", - type=Path, - required=True, - help="clean checkout of PTO-ISA/pto-spec at the v0.59.0.0 release commit", - ) - parser.add_argument("--output", type=Path, default=DEFAULT_OUTPUT) - parser.add_argument("--pto-output", type=Path, default=DEFAULT_PTO_OUTPUT) - parser.add_argument("--check", action="store_true") - args = parser.parse_args() - - projection, tile_catalog = build_projection(args.source, args.pto_root) - expected = render(projection) - if args.check: - if not args.output.exists() or args.output.read_text(encoding="utf-8") != expected: - raise SystemExit(f"stale LinxISA v0.58 projection: {args.output}") - if not args.pto_output.exists() or args.pto_output.read_bytes() != tile_catalog: - raise SystemExit(f"stale PTO 0.59.0.0 release Tile catalog: {args.pto_output}") - return 0 - - args.output.parent.mkdir(parents=True, exist_ok=True) - args.output.write_text(expected, encoding="utf-8") - args.pto_output.parent.mkdir(parents=True, exist_ok=True) - args.pto_output.write_bytes(tile_catalog) - return 0 - - -if __name__ == "__main__": - raise SystemExit(main())