PTO-BLOCK-MODEL-DISPATCH-SHARED-TLSU

1// PTO-UNIT: {"id":"PTO-BLOCK-MODEL-DISPATCH-SHARED-TLSU","surface":"block","classification":["model","dispatch","shared-tlsu"],"depends_on":["PTO-BLOCK-MODEL-FAULTS-ROLLBACK","PTO-BLOCK-MODEL-OPERANDS-SHARED-GENERATION","PTO-ARCH-MEMORY-MODEL-GLOBAL-MEMORY-ACCESS"]}2readonly func BundleSharedTLSUSelected() => boolean3begin4    if !_BundleOperation.valid ||5       _BundleOperation.operation_class != BundleOperation_TileMemory ||6       !_BundleOperation.selector_valid then return FALSE; end;7    let function = UInt(_BundleOperation.selector[4:0]);8    return BundleSharedBindingCount() > 0;9end;10
11readonly func BundleSharedStoreValidColumns(shared_tile_id: SharedTileID)12    => integer {0..65535}13begin14    if _BundleDimensionPresent[[0]] then15        if UInt(_BundleDimensions[[0]]) <= 65535 then16            return UInt(_BundleDimensions[[0]]) as integer {0..65535};17        end;18        return 0;19    end;20    let shared = SharedTileRecord(shared_tile_id);21    if shared.descriptor_valid then return shared.tile.valid_columns; end;22    return 1;23end;24
25readonly func BundleSharedStoreValidRows(shared_tile_id: SharedTileID)26    => integer {0..65535}27begin28    if _BundleDimensionPresent[[1]] then29        if UInt(_BundleDimensions[[1]]) <= 65535 then30            return UInt(_BundleDimensions[[1]]) as integer {0..65535};31        end;32        return 0;33    end;34    let shared = SharedTileRecord(shared_tile_id);35    if shared.descriptor_valid then return shared.tile.valid_rows; end;36    return 1;37end;38
39readonly func BundleSharedStoreColumns(shared_tile_id: SharedTileID,40                                        valid_columns: integer {0..65535})41    => integer {0..65535}42begin43    if _BundleDimensionPresent[[2]] then44        if UInt(_BundleDimensions[[2]]) <= 65535 then45            return UInt(_BundleDimensions[[2]]) as integer {0..65535};46        end;47        return 0;48    end;49    let shared = SharedTileRecord(shared_tile_id);50    if shared.descriptor_valid then return shared.tile.columns; end;51    return valid_columns;52end;53
54readonly func BundleSharedTMOVLocalSchemaLegal() => boolean55begin56    if BundleSharedBindingCount() != 1 ||57       BundleTileBindingCount() != 1 then return FALSE; end;58    let binding = _BundleTileBindings[[0]];59    let shared_size = BundleSharedBindingSize(0);60    let shared_mask = BundleSharedBindingMask(0);61    if !binding.valid || binding.destination_valid ||62       !binding.source0_valid || binding.source1_valid || !binding.last ||63       binding.destination_size != 0 ||64       !TileSizeCodeIsLegal(shared_size) ||65       binding.pe_mask != shared_mask then return FALSE; end;66    if shared_mask == Zeros{4} then return TRUE; end;67    if !TileSourceContentsDefined(binding.source0) ||68       _Tiles[[binding.source0]].capacity_bytes !=69           TileSizeCodeBytes(shared_size as integer {1..12}) then70        return FALSE;71    end;72    var candidate = _Tiles[[binding.source0]];73    candidate.location = TileLocation_Any;74    return SharedTileUpdateCompatible(75        BundleSharedBindingId(0), candidate, shared_mask);76end;77
78readonly func BundleSharedTMOVDestinationSchemaLegal(79    shared_tile_id: SharedTileID, function: integer {0..31}) => boolean80begin81    if BundleSharedBindingCount() != 1 ||82       BundleTileBindingCount() != 1 then return FALSE; end;83    let binding = _BundleTileBindings[[0]];84    let shared_mask = BundleSharedBindingMask(0);85    if !binding.valid || !binding.destination_valid ||86       binding.source0_valid || binding.source1_valid || !binding.last ||87       !LocalTileSizeCodeIsLegal(binding.destination_size) ||88       BundleSharedBindingIsDestination(0) ||89       binding.pe_mask != shared_mask then return FALSE; end;90    if shared_mask == Zeros{4} then return TRUE; end;91    let capacity_bytes = TileSizeCodeBytes(92        binding.destination_size as integer {1..12});93    let valid_rows = BundleDestinationValidRows(FALSE, 0);94    let valid_columns = BundleDestinationValidColumns(FALSE, 0);95    let columns = BundleDestinationPhysicalColumns(FALSE, 0);96    if valid_rows < 1 || valid_columns < 1 || columns < 1 ||97       valid_columns > columns then return FALSE; end;98    let data_type = TileDataTypeFromEncoding(99        CurrentBundleTileOperationDataTypeCode() as TileDataTypeEncoding);100    let layout = CurrentBundleTileLayout();101    if _BundleSharedBindings[[0]].source0_subview.valid then102        if !BundleSharedSubviewLegal(0) then return FALSE; end;103        let view = MaterializeBundleSharedSubview(0);104        if view.capacity_bytes != capacity_bytes ||105           view.valid_rows != valid_rows ||106           view.valid_columns != valid_columns ||107           view.columns != columns || view.data_type != data_type ||108           view.layout != layout then109            return FALSE;110        end;111        return function == 2;112    end;113    if !SharedTileReadSchemaLegalAtCapacity(shared_tile_id, valid_rows,114           valid_columns, columns, data_type, layout, capacity_bytes) then115        return FALSE;116    end;117    return function == 2;118end;119
120func ExecuteBundleSharedTLSUOperation() => boolean121begin122    let function = UInt(_BundleOperation.selector[4:0]);123    if BundleSharedBindingCount() != 1 then124        SetFault(Fault_TileLegality, ReadTPC());125        return FALSE;126    end;127    let shared_tile_id = BundleSharedBindingId(0);128    let shared_size = BundleSharedBindingSize(0);129    let shared_mask = BundleSharedBindingMask(0);130    if shared_mask == Zeros{4} then return TRUE; end;131    let decoded = DecodeTileOperation(TileDecode_TLSU,132        BundleOperationDecodeCode(_BundleOperation));133    if decoded == PTO_TILE_OPERATION_COUNT then134        SetFault(Fault_IllegalInstruction, ReadTPC());135        return FALSE;136    end;137    let operation = decoded as integer {0..PTO_TILE_OPERATION_COUNT-1};138    let transfer_data_type = TileDataTypeFromEncoding(139        CurrentBundleTileOperationDataTypeCode() as TileDataTypeEncoding);140    if (function == 0 || function == 1) &&141       !TileRegularTLSUDataTypeSupported(transfer_data_type) then142        SetFault(Fault_TileLegality, ReadTPC());143        return FALSE;144    end;145    if !BundleOperationScalarBindingSchemaLegal(operation) then146        SetFault(Fault_BundleControl, ReadTPC());147        return FALSE;148    end;149    if !SelectedBundleTileDataAttributesLegal(operation) then150        return FALSE;151    end;152    if function == 0 then153        if !BundleSharedBindingIsDestination(0) ||154           !TileSizeCodeIsLegal(shared_size) ||155           BundleTileBindingCount() != 0 then156            SetFault(Fault_TileLegality, ReadTPC());157            return FALSE;158        end;159        let valid_columns = UInt(_BundleDimensions[[0]]);160        let valid_rows = UInt(_BundleDimensions[[1]]);161        let columns = UInt(_BundleDimensions[[2]]);162        if valid_columns < 1 || valid_columns > 65535 ||163           valid_rows < 1 || valid_rows > 65535 ||164           columns < 1 || columns > 65535 || valid_columns > columns then165            SetFault(Fault_TileLegality, ReadTPC());166            return FALSE;167        end;168        var load_base_addresses: CorePEWords;169        var load_row_stride_bytes: CorePEWords;170        for pe = 0 to PTO_MODEL_MEMORY_AGENTS - 1 do171            let agent = pe as MemoryAgentId;172            load_base_addresses[[agent]] =173                if _BundleScalarBindings[[0]].valid then174                    ReadPEAbsoluteGPROperand(agent,175                        _BundleScalarBindings[[0]].source0)176                else Zeros{PTO_XLEN};177            load_row_stride_bytes[[agent]] =178                if _BundleScalarBindings[[0]].valid then179                    ReadPEAbsoluteGPROperand(agent,180                        _BundleScalarBindings[[0]].source1)181                else TileDenseRowStrideBytes(182                    columns as integer {0..65535}, transfer_data_type);183        end;184        let assembling =185            _BundleSharedBindings[[0]].destination_assemble.valid;186        var prior_shared = SharedTileRecord(shared_tile_id);187        if assembling then188            prior_shared = BeginBundleSharedGenerationProbe(shared_tile_id);189        end;190        TLOADShared(shared_tile_id, load_base_addresses, load_row_stride_bytes,191            shared_size as integer {1..12}, valid_rows as integer {1..65535},192            columns as integer {1..65535},193            valid_rows as integer {1..65535},194            valid_columns as integer {1..65535},195            transfer_data_type,196            CurrentBundleTileLayout(), shared_mask);197        if assembling then198            let candidate = SharedTileRecord(shared_tile_id);199            RestoreBundleSharedGenerationProbe(shared_tile_id, prior_shared);200            if _LastFault == Fault_None &&201               !CommitBundleSharedGenerationCandidate(0, candidate) then202                SetFault(Fault_TileLegality, ReadTPC());203            end;204        end;205    elsif function == 1 then206        if !SharedStorePEMaskLegal(function, shared_mask) ||207           BundleSharedBindingIsDestination(0) ||208           BundleTileBindingCount() != 0 then209            SetFault(Fault_TileLegality, ReadTPC());210            return FALSE;211        end;212        // Shared source readiness is a parent-level hardware gate. Pending or213        // incomplete generations keep the block active for retry with no214        // payload read, binding consumption, or GM effect.215        if !SharedTilePublished(shared_tile_id) then216            return FALSE;217        end;218        let store_valid_columns = BundleSharedStoreValidColumns(shared_tile_id);219        let store_valid_rows = BundleSharedStoreValidRows(shared_tile_id);220        let store_columns = BundleSharedStoreColumns(221            shared_tile_id, store_valid_columns);222        let store_data_type = transfer_data_type;223        let store_layout = CurrentBundleTileLayout();224        let has_subview =225            _BundleSharedBindings[[0]].source0_subview.valid;226        if has_subview && !BundleSharedSubviewLegal(0) then227            SetFault(Fault_TileLegality, ReadTPC());228            return FALSE;229        end;230        if !has_subview && (store_valid_columns < 1 || store_valid_rows < 1 ||231           store_columns < 1 || store_valid_columns > store_columns ||232           !SharedTileReadSchemaLegal(shared_tile_id, store_valid_rows,233               store_valid_columns, store_columns, store_data_type,234               store_layout)) then235            SetFault(Fault_TileLegality, ReadTPC());236            return FALSE;237        end;238        var store_base_addresses: CorePEWords;239        var store_row_stride_bytes: CorePEWords;240        for pe = 0 to PTO_MODEL_MEMORY_AGENTS - 1 do241            let agent = pe as MemoryAgentId;242            store_base_addresses[[agent]] =243                if _BundleScalarBindings[[0]].valid then244                    ReadPEAbsoluteGPROperand(agent,245                        _BundleScalarBindings[[0]].source0)246                else Zeros{PTO_XLEN};247            store_row_stride_bytes[[agent]] =248                if _BundleScalarBindings[[0]].valid then249                    ReadPEAbsoluteGPROperand(agent,250                        _BundleScalarBindings[[0]].source1)251                else TileDenseRowStrideBytes(252                    store_columns as integer {0..65535}, store_data_type);253        end;254        if has_subview then255            var per_pe_store_tiles: CorePETileInfos;256            for pe = 0 to PTO_MODEL_MEMORY_AGENTS - 1 do257                let agent = pe as MemoryAgentId;258                per_pe_store_tiles[[agent]] =259                    MaterializeBundleSharedSubviewForPE(0, agent);260            end;261            TSTORESharedPerPE(store_base_addresses, store_row_stride_bytes,262                per_pe_store_tiles, shared_mask);263        else264            let store_tile = MaterializeSharedTileForReadSchema(265                shared_tile_id, store_valid_rows, store_valid_columns,266                store_columns, store_data_type, store_layout);267            TSTOREShared(store_base_addresses, store_row_stride_bytes,268                shared_tile_id, store_tile, shared_mask);269        end;270    elsif function == 2 then271        let shared_is_destination = BundleSharedBindingIsDestination(0);272        if shared_is_destination then273            if !BundleSharedTMOVLocalSchemaLegal() then274                SetFault(Fault_TileLegality, ReadTPC());275                return FALSE;276            end;277            let binding = _BundleTileBindings[[0]];278            let assembling =279                _BundleSharedBindings[[0]].destination_assemble.valid;280            var prior_shared = SharedTileRecord(shared_tile_id);281            if assembling then282                prior_shared = BeginBundleSharedGenerationProbe(shared_tile_id);283            end;284            TMOVLocalToShared(shared_tile_id, binding.source0,285                shared_size as integer {1..12}, shared_mask, !assembling);286            if assembling then287                let candidate = SharedTileRecord(shared_tile_id);288                RestoreBundleSharedGenerationProbe(shared_tile_id, prior_shared);289                if _LastFault == Fault_None &&290                   !CommitBundleSharedGenerationCandidate(0, candidate) then291                    SetFault(Fault_TileLegality, ReadTPC());292                end;293            end;294        else295            // The same parent-level readiness gate applies before any Local296            // destination allocation or Shared payload materialization. The297            // block remains active so completion can retry after publication.298            if !SharedTilePublished(shared_tile_id) then299                return FALSE;300            end;301            if !BundleSharedTMOVDestinationSchemaLegal(shared_tile_id, function) ||302               !SelectedBundleTileMasksLegal() then303                if _LastFault == Fault_None then304                    SetFault(Fault_TileLegality, ReadTPC());305                end;306                return FALSE;307            end;308            let binding = _BundleTileBindings[[0]];309            let capacity_bytes = TileSizeCodeBytes(310                binding.destination_size as integer {1..12});311            let valid_rows = BundleDestinationValidRows(FALSE, 0);312            let valid_columns = BundleDestinationValidColumns(FALSE, 0);313            let columns = BundleDestinationPhysicalColumns(FALSE, 0);314            let data_type = TileDataTypeFromEncoding(315                CurrentBundleTileOperationDataTypeCode()316                    as TileDataTypeEncoding);317            let has_subview =318                _BundleSharedBindings[[0]].source0_subview.valid;319            let shared_tile = if has_subview then320                MaterializeBundleSharedSubview(0)321            else MaterializeSharedTileForReadSchemaAtCapacity(322                shared_tile_id, valid_rows, valid_columns, columns, data_type,323                CurrentBundleTileLayout(), capacity_bytes);324            if !ResolveBundleTileDestinations() then return FALSE; end;325            let destination = _BundleTileBindings[[0]].destination;326            if _Tiles[[destination]].rows != shared_tile.rows ||327               _Tiles[[destination]].columns != shared_tile.columns ||328               _Tiles[[destination]].valid_rows != shared_tile.valid_rows ||329               _Tiles[[destination]].valid_columns != shared_tile.valid_columns ||330               _Tiles[[destination]].data_type != shared_tile.data_type ||331               _Tiles[[destination]].layout != shared_tile.layout then332                RollBackBundleTileDestinations();333                SetFault(Fault_TileLegality, ReadTPC());334                return FALSE;335            end;336            if has_subview then337                var per_pe_shared_tiles: CorePETileInfos;338                for pe = 0 to PTO_MODEL_MEMORY_AGENTS - 1 do339                    let agent = pe as MemoryAgentId;340                    per_pe_shared_tiles[[agent]] =341                        MaterializeBundleSharedSubviewForPE(0, agent);342                end;343                TMOVSharedToLocalPerPE(destination, per_pe_shared_tiles,344                    shared_mask);345            else346                TMOVSharedToLocal(destination, shared_tile_id, shared_tile,347                    shared_mask);348            end;349        end;350    else351        SetFault(Fault_TileLegality, ReadTPC());352        return FALSE;353    end;354    if _LastFault != Fault_None then355        RollBackBundleTileDestinations();356        return FALSE;357    end;358    ConsumeBundleSharedBindings(1);359    FinalizeBundleTileAttempt(TileExecution_Executed);360    return TRUE;361end;362