InfiniBand Test Specification: C09_027_08
InfiniBand Test Specification  1.0.38
Public Member Functions | Protected Member Functions | List of all members
C09_027_08

Inherits C09_027.

Public Member Functions

 C09_027_08 ()
 
boolean execute () throws TestException
 

Protected Member Functions

boolean initialize () throws TestException
 
BigInteger sendFetch (final long psn) throws TestException
 
void sendReadRequests (final long psn) throws TestException
 

Detailed Description

9.5.0.1 V1C09-027 RELIABLE SERVICE TRANSACTION ORDERING

Abstract: This test verifies the ordering rules for Reliable Service requests from an HCA.

Coverage: v1c09-027

Topology Configuration: SimpleLink: Tester=Transport Tester; Width=1X, 4X, or 12X; DUT=xCA DUT Qualifiers: All HCAs must support RDMA operations in addition to Send and Receive functionality. Atomic operations are optional. However, if the HCA supports Atomic operations, it must fully support all of the related compliance items. Notes: For reliable services on an HCA, all acknowledge packets shall be strongly ordered, e.g. all previous RDMA Read responses and all Atomic responses shall be injected into the fabric before subsequent RDMA Send, RDMA Write responses, RDMA Read responses and Atomic operation responses. The first five parts of this test send a series of RDMA Read requests followed by an RDMA Send Only, and RDMA Write Only or an Atomic request to verify that the responses are returned in strict order. The final parts begin with Atomic operations which are then followed by other types to ensure ordering. The test implementer may choose to verify that the Atomic operations are performed correctly. However, the essence of this test is to verify that all acknowledge packets are strongly ordered, i.e. to verify the expected PSN.

Test Case Description

◆ C09_027_08()

C09_027_08 ( )

9.5.0.1.8 V1C09-027 RC Atomic FetchAdd after Atomic FetchAdd

Assertions: V1c09-027#08

Notes:

  • The TT (as requester) will transmit a RC_FETCHADD request after a series of RC_FETCHADD requests. The ordering of the responses (PSN) from the DUT (as responder) should be the same as the ordering of the requests.
  • Variable COUNTER of type Integer
  • Variable CC as structure of type ChannelContext_t
  • ATOMIC_DATA is a 64 bit value
  • Variables PACKET_IN, PACKET_OUT as structure of type PacketType_t

Developer: Llolsten Kaonga

Test Procedure

◆ execute()

boolean execute ( ) throws TestException

Test Procedure:

  1. Register memory region for receiving remote packets

  2. Post one receive request for each expected packet from DUT

  3. Transmit Atomic Fetch Add Packet with AckReq set in order to retrieve the original data for use in CMPSWAP

    see Send Fetch/Add for retrieving remote data

  4. Transmit 5 Atomic FetchADD Packets

    • PACKET_OUT.HeaderMask = LOCAL | FETCHADD
    • PACKET_OUT.BTH_OpCode = RC_FETCHADD
    • PACKET_OUT.BTH_AckReq = 1

  5. For COUNTER = 1 to 5

    • PACKET_OUT.Atomic_vaddr = DUT buffer address
    • PACKET_OUT.Atomic_rkey = DUT rkey
    • PACKET_OUT.Atomic_CMP = 0x0 // User specified CMP data
    • PACKET_OUT.Atomic_SWAP_ADD = 0x1111111111111111 // User specified SWAP/ADD
    • CC.TT_TxReqPSN = Mod( CC.Start_PSN + COUNTER, 2^24)
    • TransportTxPacket( CC, PACKET_OUT )

  6. End For Loop

  7. Receive each RC_ATOMIC_ACK and verify the PSN and the original remote data

    • PACKET_IN.HeaderMask = LOCAL | ATOMIC_ACK
    • PACKET_IN.BTH_OpCode = RC_ATOMIC_ACK
    • PACKET_IN.AETH_Syndrome = ACK

  8. For COUNTER = 1 to 5

    • CC.TT_RxExpectPSN = Mod( CC.Start_PSN + COUNTER, 2^24)
    • TransportRxPacket( CC, PACKET_IN )
    • Verify (PACKET_IN.AETH_Syndrome & ACK_MASK = ACK
    • Verify (PACKET_IN.BTH_PSN == Mod(CC.TT_Start_PSN + COUNTER, 2^24))
    • Verify (PACKET_IN.AtomicAckAETH_OrigRemDt = ATOMIC_DATA
    • ATOMIC_DATA = ATOMIC_DATA + 0x1111111111111111

  9. End For Loop

  10. CloseRcChannel( CC )

    • Remark: Flush unacknowledged WQE.

◆ initialize()

boolean initialize ( ) throws TestException
protectedinherited

Initialization:

  1. OpenRcChannel( CC ) // (reliable connection)

◆ sendFetch()

BigInteger sendFetch ( final long  psn) throws TestException
protectedinherited

Send Fetch/Add for retrieving remote data

  • PACKET_OUT.HeaderMask = LOCAL | FETCH_ADD
  • PACKET_OUT.BTH_OpCode = ATOMIC_FETCH_ADD
  • CC.TT_TxReqPSN = Mod( CC.Start_PSN, 2^24)
  • PACKET_OUT.BTH_AckReq = 1
  • PACKET_OUT.Atomic_vaddr = DUT buffer address
  • PACKET_OUT.Atomic_rkey = DUT rkey
  • PACKET_OUT.Atomic_SWAP_ADD = 0
  • TransportTxPacket( CC, PACKET_OUT )

Receive Atomic FetchAdd ACK packet

  • PACKET_IN.BTH_OpCode = RC_ATOMIC_ACK
  • CC.TT_RxReqPSN = Mod( CC.Start_PSN, 2^24)
  • PACKET_IN.AETH_Syndrome = ACK
  • TransportRxPacket( CC, PACKET_IN)
  • Verify ( PACKET_IN.AETH_Syndrome & ACK_MASK == ACK )
  • COMPARE = PACKET_IN.AtomicAck_ETH_OrigRemDt

◆ sendReadRequests()

void sendReadRequests ( final long  psn) throws TestException
protectedinherited

Send Read Requests

  1. Transmit 1 RDMA Read Request WQE from TT at size (5 * PMTU). The response message from DUT will contain 5 packets.

  2. Transmit RDMA Read Request Packet

    • PACKET_OUT.HeaderMask = LOCAL | RDMA_READ_REQ
    • PACKET_OUT.BTH_OpCode = RDMA_READ_REQ
    • CC.TT_TxReqPSN = Mod( CC.Start_PSN + 0, 2^24)
    • PACKET_OUT.BTH_AckReq = 1
    • PACKET_OUT.RETH_vaddr = DUT buffer address
    • PACKET_OUT.RETH_rkey = DUT rkey
    • PACKET_OUT.RETH_dmaLength = PMTU * 5
    • TransportTxPacket( CC, PACKET_OUT )

  3. Transmit a second RDMA Read Request Packet of size PMTU

    • PACKET_OUT.HeaderMask = LOCAL | RDMA_READ_REQ
    • PACKET_OUT.BTH_OpCode = RDMA_READ_REQ
    • CC.TT_TxReqPSN = Mod( CC.Start_PSN + 5, 2^24)
    • PACKET_OUT.BTH_AckReq = 1
    • PACKET_OUT.RETH_vaddr = DUT buffer address
    • PACKET_OUT.RETH_rkey = DUT rkey
    • PACKET_OUT.RETH_dmaLength = PMTU * 1
    • TransportTxPacket( CC, PACKET_OUT )

The documentation for this class was generated from the following file: