PTO-BLOCK-MODEL-COMMIT-EFFECTS

1// PTO-UNIT: {"id":"PTO-BLOCK-MODEL-COMMIT-EFFECTS","surface":"block","classification":["model","commit","effects"],"depends_on":["PTO-BLOCK-MODEL-LIFECYCLE-LIFETIME","PTO-ARCH-GQM"]}2func ExecuteQueueManagerMove(destination: Reg5Selector,3                             address: Word,4                             capacity_source: Word,5                             flags: bits(4))6begin7    let initialize = flags[3] == '1';8    let notify_event = flags[2] == '1';9    let suspend = flags[1] == '1';10    let restore = flags[0] == '1';11    var result = GQMResult(0, '01');12    var succeeded = FALSE;13
14    if initialize then15        let capacity = UInt(capacity_source[9:0]) as GQMQueueCapacity;16        - = InitializeGQMQueue(address, capacity);17        result = GQMResult((capacity * 8) as integer {0..8191}, '00');18        succeeded = TRUE;19    else20        let found = FindGQMQueue(address);21        if found != PTO_MODEL_GQM_QUEUE_SLOTS then22            let slot = found as GQMQueueSlot;23            if !_GQMQueueCorrupt[[slot]] then24                result = GQMResult(GQMQueueRemaining(address), '00');25                succeeded = TRUE;26            end;27        end;28    end;29
30    if succeeded then31        // Combined controls execute after the primary operation, in encoded32        // architectural order: event first, then suspension or restoration.33        if notify_event then34            BroadcastGQMEvent(address);35        end;36        if suspend then37            SetGQMQueueSuspended(address, TRUE);38        elsif restore then39            SetGQMQueueSuspended(address, FALSE);40        end;41    end;42
43    _LastQueueLeft = address;44    _LastQueueRight = capacity_source;45    _LastQueueFlags = flags;46    WriteScalarDestination(destination, result);47end;48
49func ExecuteQueueManagerPop(destination0: Reg5Selector,50                            destination1: Reg5Selector,51                            address: Word,52                            flags: bits(4))53begin54    let notify_event = flags[1] == '1';55    let relaxed = flags[0] == '1';56    let response = PopGQMQueueEntry(57        address,58        relaxed,59        notify_event);60
61    _LastQueueLeft = address;62    _LastQueueRight = Zeros{PTO_XLEN};63    _LastQueueFlags = flags;64    WriteScalarDestination(destination0, response.data);65    WriteScalarDestination(destination1, response.result);66end;67
68func ExecuteQueueManagerPush(destination: Reg5Selector,69                             address: Word,70                             entry: Word,71                             flags: bits(4))72begin73    let at_head = flags[3] == '1';74    let notify_event = flags[2] == '1';75    let relaxed = flags[0] == '1';76    let result = PushGQMQueueEntry(77        address,78        entry,79        at_head,80        relaxed,81        notify_event);82
83    _LastQueueLeft = address;84    _LastQueueRight = entry;85    _LastQueueFlags = flags;86    WriteScalarDestination(destination, result);87end;88
89pure func MemoryRangeWraps(address: Word, length: Word) => boolean90begin91    if length == Zeros{PTO_XLEN} then92        return FALSE;93    end;94    let end_address = address + length;95    return UInt(end_address) < UInt(address);96end;97
98pure func MemoryCopyRangesOverlap(destination: Word,99                                  source: Word,100                                  length: Word) => boolean101begin102    if length == Zeros{PTO_XLEN} then103        return FALSE;104    end;105    let destination_end = destination + length;106    let source_end = source + length;107    return UInt(destination) < UInt(source_end) &&108           UInt(source) < UInt(destination_end);109end;110
111pure func MemoryCopyStepSize(remaining: Word) => integer {1,2,4,8}112begin113    assert remaining != Zeros{PTO_XLEN};114    if UInt(remaining) >= 8 then115        return 8;116    elsif UInt(remaining) >= 4 then117        return 4;118    elsif UInt(remaining) >= 2 then119        return 2;120    else121        return 1;122    end;123end;124
125func StartMemoryCopyTemplate(destination: Word,126                             source: Word,127                             length: Word) => boolean128begin129    if MemoryRangeWraps(destination, length) ||130       MemoryRangeWraps(source, length) ||131       MemoryCopyRangesOverlap(destination, source, length) then132        SetFault(Fault_IllegalInstruction, ReadTPC());133        return FALSE;134    end;135
136    _MemoryCopyTemplate.active = TRUE;137    _MemoryCopyTemplate.instruction_pc = ReadTPC();138    _MemoryCopyTemplate.destination = destination;139    _MemoryCopyTemplate.source = source;140    _MemoryCopyTemplate.length = length;141    _MemoryCopyTemplate.progress = Zeros{PTO_XLEN};142    return TRUE;143end;144
145func CompleteMemoryCopyTemplate()146begin147    _LastMemoryCommandAddress = _MemoryCopyTemplate.destination;148    _LastMemoryCommandSize = _MemoryCopyTemplate.length;149    _MemoryCopyTemplate.active = FALSE;150end;151
152func ExecuteMemoryCopyStep()153begin154    let progress = _MemoryCopyTemplate.progress;155    let remaining = _MemoryCopyTemplate.length - progress;156    let step_size = MemoryCopyStepSize(remaining);157    let step_word = NaturalToWord(158        step_size as integer {0..262144});159    let source_address = _MemoryCopyTemplate.source + progress;160    let destination_address = _MemoryCopyTemplate.destination + progress;161
162    // Both accesses are probed before the source value is observed.  A163    // rejected destination therefore cannot leave a source read or event.164    let source_probe = ProbeDataAccess(165        source_address,166        step_size,167        1,168        FALSE);169    let destination_probe = ProbeDataAccess(170        destination_address,171        step_size,172        1,173        TRUE);174    if RaiseDataAccessFault(source_probe, source_address) then175        return;176    elsif RaiseDataAccessFault(destination_probe, destination_address) then177        return;178    end;179
180    let value = LoadTranslatedUnsigned(181        source_probe.translated_address,182        step_size);183    RecordLoadEvent(184        source_probe.translated_address,185        step_size,186        value,187        MemoryOrder_Relaxed);188    StoreTranslated(189        destination_address,190        destination_probe.translated_address,191        step_size,192        value);193    RecordStoreEvent(194        destination_probe.translated_address,195        step_size,196        value,197        MemoryOrder_Relaxed);198    _MemoryCopyTemplate.progress = progress + step_word;199end;200
201func ExecuteMemoryCopyTemplate(destination: Word,202                               source: Word,203                               length: Word)204begin205    if !_MemoryCopyTemplate.active then206        if !StartMemoryCopyTemplate(destination, source, length) then207            return;208        end;209    end;210
211    if _MemoryCopyTemplate.instruction_pc != ReadTPC() then212        SetFault(Fault_IllegalInstruction, ReadTPC());213        return;214    end;215
216    for step = 0 to PTO_MODEL_MEMORY_BYTES - 1217        looplimit PTO_MODEL_MEMORY_BYTES do218        if _MemoryCopyTemplate.active &&219           _LastFault == Fault_None then220            if _MemoryCopyTemplate.progress ==221               _MemoryCopyTemplate.length then222                CompleteMemoryCopyTemplate();223            else224                ExecuteMemoryCopyStep();225            end;226        end;227    end;228
229    if _MemoryCopyTemplate.active &&230       _LastFault == Fault_None &&231       _MemoryCopyTemplate.progress == _MemoryCopyTemplate.length then232        CompleteMemoryCopyTemplate();233    end;234end;235
236func ExecuteBoundedMemorySet(destination: Word, value: Word, length: Word)237begin238    if UInt(length) > 63 then239        SetFault(Fault_IllegalInstruction, ReadTPC());240        return;241    end;242    let byte_count = UInt(length) as integer {0..63};243    if byte_count != 0 then244        let access_size = byte_count as integer {1..262144};245        let write_probe = ProbeDataAccess(destination, access_size, 1, TRUE);246        if RaiseDataAccessFault(write_probe, destination) then247            return;248        else249            StoreTranslatedFillBounded(destination, write_probe.translated_address,250                byte_count, value[7:0]);251        end;252    end;253    if _LastFault == Fault_None then254        _LastMemoryCommandAddress = destination;255        _LastMemoryCommandSize = length;256    end;257end;258
259func ExecuteCrossBlockTransferState(acr_id: bits(10), block_id: bits(7))260begin261    _LastCrossBlockACR = acr_id;262    _LastCrossBlockID = block_id;263    _BARG.transfer_type = BundleTransfer_Indirect;264end;265