Patent Description:
RDMA is a technology widely used in modern data centers and computer clusters for low-latency and high-bandwidth networking. RDMA offloads memory operations from the Central Processing Unit (CPU) to the RDMA network interface card (NIC) (RNIC), which can directly access the memory. This offloading saves time for the CPU, and thus allows the CPU to perform other tasks.

The software-layer of RDMA uses "verbs" to perform RDMA operations, which are then transformed to work requests written to the RNIC's queues. Such a work request is called a work queue element (WQE), and RDMA operations are either tagged (one-side WRITE/READ/ATOMIC) or untagged (two-sided SEND/RECV). RDMA peers are communications over queue pairs (QPs) offering various transport services. The common QP types (published by IB specification) include Reliable Connection (RC) QP, Reliable Datagram (RD) QP, Extended Reliable Connection (XRC) QP, Unreliable Datagram (UD) QP, Unreliable Connection (UC) QP, and Dynamic Connection (DC) QP, etc..

Many applications or tasks require periodic messages with fixed-content, such as Heartbeats/Keep-Alive messages, messages for reporting machine load status, or storage usage status, messages for distributing configuration changes, or reporting round trip time (RTT) measurements (when there is no active traffic). Today, RDMA technologies do not support, for any QP type, a way that WQEs can be reused automatically. That is, the software is required to re-post a WQE after the previous one was processed. Therefore, applications and high-level protocols are using a software-based solution for reporting periodic messages in the current RDMA applications. However, such solution is more complex, less efficient, less accurate, and consumes CPU time. <CIT> discloses a distributed computing system that is provided having (host and I/O) end nodes, switches, routers, and links interconnecting these components. The end nodes use send and receive queue pairs to transmit and receive messages. <CIT> discloses a method for communication includes posting in a queue a sequence of work items pointing to buffer consisting of multiple strides of a common, fixed size in a memory.

In view of the above, embodiments of the disclosure aim to provide a device and a method for RDMA. An objective is to create a new RDMA QP behavior that is timed-based scheduled, and in particular, enables preconfigured WQEs to be sent on each re-scheduling event. One aim is to allow reusing WQEs over and over without software intervention.

These and other objectives are achieved by the embodiments of the disclosure as described in the enclosed independent claims. Advantageous implementations of the embodiments of the disclosure are further defined in the dependent claims.

A first aspect of the present disclosure provides an entity for RDMA. The entity is configured to: maintain a time-based QP, wherein the time-based QP comprises a first area associated with a time-based indication, wherein the first area is configured to hold one or more first WQEs, and the time-based indication indicates that the one or more WQEs in the first area are to be periodically processed; and periodically process the one or more first WQEs in the first area according to the time-based indication.

Embodiments of the present disclosure provide a solution for the entity of the first aspect to periodically schedule WQEs with no software involvement. This solution allows the entity to reuse the WQEs in the time-based QP over and over, and there is no need to involve an upper-layer application/software for re-posting a WQE. Notably, WQE and QP are terms from the RDMA specification. A WQE is an RDMA operation or transaction that is pushed into a QP, either to be transmitted to the peer or having been received from the peer. The QP represents a communication endpoint, which consists of a SEND Queue (SQ) and a Receive Queue (RQ), or alternatively a shared RQ. The time-based QP as defined in embodiments of this disclosure may also be referred to as Periodic-Auto-Scheduled (PAS) QP.

In an implementation form, the time-based indication comprises at least one of the following indications:.

In particular, the number of times this time-based QP needs to be re-scheduled can be limited or infinite (e.g., till QP tears down, or is instructed to stop).

In a further implementation form, a type of the time-based QP comprises one of the following: RC QP, RD QP, XRC QP, UD QP, UC QP, and DC QP.

It should be noted that above mentioned QP types are merely examples. The new approach as described in this disclosure applies to other existing QP types as well.

In a further implementation form, the one or more first WQEs comprise at least one of an SQ WQE, an RQ WQE, and an SRQ WQE.

In a further implementation form, the one or more first WQEs are associated with at least one of a first destination address and a second destination address, wherein the entity is configured to periodically process the one or more first WQEs to at least one of a first destination entity corresponding to the first destination address and a second destination entity corresponding to the second destination address.

The periodic QP can be used for a single destination or multiple destinations.

In a further implementation form, the entity is further configured to maintain a completion queue (CQ), wherein the first area is further associated with a completion indication, wherein the completion indication indicates a generation manner of completion.

Conventionally, RDMA QPs are always generating a completion on some opcodes (RQ processing, etc.). There is no control to manipulate a conditional completion. According to embodiments of this disclosure, completions may be configurable.

In a further implementation form, the completion indication comprises at least one of the following indications:.

In a further implementation form, the entity is further configured to stop processing the one or more first WQEs in the first area, when an error occurs.

In a further implementation form, the time-based QP comprises a second area, wherein the second area comprises one or more second WQEs, wherein the one or more second WQEs are processed following a doorbell ring.

Possibly, the time-based QP may also have an area for regular WQEs. That is, some of the WQEs in the QP may be periodic ones and the rest may be regular. Only the regular ones are processed following a doorbell ring.

In a further implementation form, the entity is further configured to: add one or more third WQEs into the first area; and periodically process the one or more third WQEs in a following cycle.

Optionally, SQ and RQ of the time-based QP are dynamic. It means that when posting WQE(s), there is no need to suspend the QP's scheduling, enlarge the SQ/RQ, and then resume it. According to this disclosure, in the next cycle the QP will be scheduled using the new WQE(s) that were additional posted.

In a further implementation form, the entity is further configured to obtain the time-based QP from at least one of a first application and a second application.

Optionally, a single PAS QP can be shared by multiple applications (multiplexing).

In a further implementation form, the entity is further configured to: maintain a memory area storing specific data for the entity; monitor the memory area and determine whether the specific data has changed; provide a content of the specific data to one or more other entities for RDMA, using one or more WQEs of the time-based QP, when it is determined that the specific data has changed.

The approach proposed in this disclosure may be used to distributing changes in memory, such as configuration changes.

A second aspect of the present disclosure provides a method for RDMA. The method comprises: maintaining a time-based QP, wherein the time-based QP comprises a first area associated with a time-based indication, wherein the first area is configured to hold one or more first WQEs, and the time-based indication indicates that the one or more WQEs in the first area are to be periodically processed; and periodically processing the one or more first WQEs in the first area according to the time-based indication.

In a further implementation form, the time-based indication comprises at least one of the following indications:.

In a further implementation form, a type of the time-based QP comprises one of the following: Reliable Connection QP, Reliable Datagram QP, Extended Reliable Connection QP, Unreliable Datagram QP, Unreliable Connection QP, and Dynamic Connection QP.

In a further implementation form, the one or more first WQEs comprise at least one of a send queue WQE, a receive queue WQE, and a shared receive queue WQE.

In a further implementation form, the method further comprises maintaining a completion queue, wherein the first area is further associated with a completion indication, wherein the completion indication indicates a generation manner of a completion.

In a further implementation form, the method further comprises stopping processing the one or more first WQEs in the first area, when an error occurs.

In a further implementation form, the method further comprises adding one or more third WQEs into the first area; and periodically processing the one or more third WQEs in a following cycle.

In a further implementation form, the method further comprises obtaining the time-based QP from at least one of a first application and a second application.

In a further implementation form, the method further comprises maintaining a memory area storing specific data for the entity; monitoring the memory area and determine whether the specific data has changed; providing a content of the specific data to one or more other entities for RDMA, using one or more WQEs of the time-based QP, when it is determined that the specific data has changed.

The method of the second aspect and its implementation forms provide the same advantages and effects as described above for the entity of the first aspect and its respective implementation forms.

A third aspect of the present disclosure provides a computer program comprising a program code for carrying out, when implemented on a processor, the method according to the second aspect or any of its implementation forms.

A fourth aspect of the present disclosure provides a computer readable storage medium comprising computer program code instructions, being executable by a computer, for performing a method according to the second aspect or any of its implementation forms when the computer program code instructions runs on a computer.

Illustrative embodiments of method, device, and program product for timed-based periodic QP scheduling in a communication system are described with reference to the figures. Although this description provides a detailed example of possible implementations, it should be noted that the details are intended to be exemplary and in no way limit the scope of the application.

Moreover, an embodiment/example may refer to other embodiments/examples. For example, any description including but not limited to terminology, element, process, explanation and/or technical advantage mentioned in one embodiment/example is applicative to the other embodiments/examples.

<FIG> shows an entity <NUM> adapted for RDMA according to an embodiment of the disclosure. The entity <NUM> may comprise processing circuitry (not shown) configured to perform, conduct or initiate the various operations of the entity <NUM> described herein. The processing circuitry may comprise hardware and software. The hardware may comprise analog circuitry or digital circuitry, or both analog and digital circuitry. The digital circuitry may comprise components such as application-specific integrated circuits (ASICs), field-programmable arrays (FPGAs), digital signal processors (DSPs), or multi-purpose processors. The entity <NUM> may further comprise memory circuitry, which stores one or more instruction(s) that can be executed by the processor or by the processing circuitry, in particular under control of the software. For instance, the memory circuitry may comprise a non-transitory storage medium storing executable software code which, when executed by the processor or the processing circuitry, causes the various operations of the entity <NUM> to be performed. In one embodiment, the processing circuitry comprises one or more processors and a non-transitory memory connected to the one or more processors. The non-transitory memory may carry executable program code which, when executed by the one or more processors, causes the entity <NUM> to perform, conduct or initiate the operations or methods described herein.

In particular, the entity <NUM> is configured to maintain a time-based QP <NUM>, wherein the time-based QP <NUM> comprises a first area <NUM> associated with a time-based indication. In particular, the first area <NUM> is configured to hold one or more first WQEs <NUM>, <NUM>', and the time-based indication indicates that the one or more WQEs in the first area <NUM> are to be periodically processed. The entity <NUM> is further configured to periodically process the one or more first WQEs <NUM>, <NUM>' in the first area <NUM> according to the time-based indication.

Embodiments of this disclosure introduce a new approach where any RDMA QP type can be periodically scheduled WQEs, either SQ or RQ WQEs. The WQEs in the time-based QP will be reused, over and over, and there is no need to manipulate any parameters such as producer index (PI) or consumer index (CI) to re-post the WQEs.

For instance, the type of the time-based QP <NUM> may be one of the following: RC QP, RD QP, XRC QP, UD QP, UC QP, and DC QP. It should be noted that above listed QP types are merely examples. The new approach as described in this disclosure applies to any other QP types as well. That is, according to embodiments of this disclosure, packets based on this new QP behavior, which are sent over the network, can be identical to any of the existing QP types (RC/UD/RD/XRC/UC/DC, etc.), while no change on the network packets is required.

The rescheduling of the same WQEs can be either limited for a certain number of iterations or infinite. According to an embodiment of the disclosure, the time-based indication comprises at least one of the following indications:.

According to an embodiment of the disclosure, the one or more first WQEs <NUM>, <NUM>' comprise at least one of an SQ WQE, an RQ WQE, and a shared RQ (SRQ) WQE. The new QP behavior can use either an RQ or an SRQ. A WQE on the RQ/SRQ is often called an RQ Element (RQE). Multiple RQEs can be posted to the RQ that will be used over and over.

According to an embodiment of the disclosure, the one or more first WQEs <NUM>, <NUM>' may be associated with at least one of a first destination address and a second destination address, wherein the entity <NUM> is configured to periodically process the one or more first WQEs <NUM>, <NUM>' to at least one of a first destination entity <NUM> corresponding to the first destination address and a second destination entity <NUM> corresponding to the second destination address.

Optionally, the one or more first WQEs <NUM>, <NUM>' may be processed more than once in each re-scheduling event, e.g. when multiple destinations are specified for this message or this QP (when the one or more first WQEs <NUM>, <NUM>' are associated with both of the first destination address and the second destination address).

According to an embodiment of the disclosure, the entity <NUM> as shown in <FIG> may be further configured to maintain a CQ, wherein the first area <NUM> is further associated with a completion indication, wherein the completion indication indicates a generation manner of a completion.

Optionally, the completion indication may comprise at least one of the following indications:.

Conventionally, RDMA QPs are always generating a completion on some opcodes (RQ processing, etc.). There is no control to manipulate a conditional completion. According to this disclosure, the completions can be generated upon configuration, e.g., per WQE, per a number of re-scheduling events, when reaching RQ's PI pointer, only on error, etc..

Optionally, regular completion events are discarded, if they are mandatory for the specific QP type. The generation of the completions may be continuously scheduled, or not scheduled at all, or re-scheduled when an error occurs and let the application handle the reported error, e.g., delete the WQE, tear down the QP, etc..

According to an embodiment of this disclosure, the entity <NUM> may be configured to stop processing the one or more first WQEs <NUM>, <NUM>' in the first area <NUM>, when an error occurs.

Optionally, the time-based QP <NUM> may further comprise a second area, wherein the second area comprises one or more second WQEs, wherein the one or more second WQEs are processed following a doorbell ring. It should be noted that the same QP (PAS QP) may have a special area for periodic WQEs, and also have an area for regular WQEs (the regular ones are processed following a doorbell ring as defined in the existing RDMA specification).

According to an embodiment of this disclosure, the entity <NUM> may be configured to add one or more third WQEs into the first area <NUM>; and periodically process the one or more third WQEs in the following cycle.

Optionally, the SQ/RQ of the PAS QP are dynamic, meaning that when posting WQEs, there is no need to suspend the QP's scheduling, enlarge the SQ/RQ, and then resume it. Instead, the new periodic WQEs may be added into the first area, then the QP will schedule the new periodic WQEs together with the existing ones in the next (and the following) rescheduling event.

Optionally, a single PAS QP can be shared by multiple applications (multiplexing). According to an embodiment of this disclosure, the entity <NUM> may be configured to obtain the time-based QP <NUM> from at least one of a first application and a second application.

<FIG> shows a schematic diagram of an RNIC according to an embodiment of the disclosure. The PAS QP comprises a SQ, a RQ/SRQ, and a CQ. Any single WQE comprised in this QP could include multiple destinations in each (re)scheduling event.

The "tail" of a queue (SQ or RQ/SRQ) may be indicated using the parameter PI, and the "head" of the queue may be indicated using the parameter CI. Notably, when PI ≠ CI, it implies that there are one or more WQEs in the queue that are supposed to be processed; when PI = CI, it means the work has been finished. The "tail" is updated only when posting additional WQEs. The "head" is updated only when deleting a previously posted WQE, or when adding new WQEs.

The timer in the RNIC may set the periodic interval T for processing one or more WQEs in the PAS QP. Each time the timer expires, RNIC processes all WQEs between the "head" and the "tail" of the SQ. According to embodiments of this disclosure, packets to the network are formatted according to existing QP types.

Notably, RDMA operations comprise Read, Write, Send, Receive, Atomic, etc. The RQ/SRQ is required only if Write-with-Immediate or Send operation is required. The CQ is required when completions are generated or errors occurred.

RNIC may be a Requester RNIC or a Responder RNIC. In particular, the Requester RNIC processes all WQEs that are posted to the SQ, on every re-scheduling event. Responder RNIC uses the next WQE posted to the RQ/SRQ, every time a Send or Write-with-Immediate request is received. Upon reaching to the RQ's PI pointer it will continue from the RQE pointed by CI pointer, in a cyclic way.

The entity <NUM> as shown in <FIG> may be a Requester RNIC or a Responder RNIC.

As previously mentioned, many applications or tasks require periodic messages with fixed content. The new PAS QP as defined in embodiments of this disclosure is especially advantaged when applies to these use cases. Specific embodiments based on different use cases will be described in detail in the following.

"Heartbeat" is a periodic signal, generated by hardware or software, to indicate normal operation or to synchronize other parts of a computer system. Heartbeat messages are normally exchanged between endpoints (a sender node and a receiver node) at a regular interval in the order of seconds or milliseconds. If the receiver node does not receive a heartbeat for a time (usually a few heartbeat intervals), then the sender node is assumed to have failed.

Heartbeat messages may also be used for high-availability and fault-tolerance purposes.

Heartbeat messages are typically sent in a continuous, recurring, periodic manner from the time an endpoint (the sender node) is started until it is shut down, when a destination endpoint (the receiver node) identifies lost heartbeat messages, during an anticipated arrival period, then it may determine that the initiator endpoint (the sender node) has failed, shutdown, or is generally no longer available.

<FIG> shows a signaling flowchart at a sender node according to an embodiment of the disclosure. The sender node here may be an endpoint that needs to send a "Heartbeat" message. Notably, the sender node may also be any other devices that need to send a periodic signal.

In this embodiment, the application creates a time-based QP, and requests the QP to send a packet P with an interval T to a destination D. The packet P here may be a heartbeat signal. Accordingly, the NIC starts sending the packet P to the destination D periodically based on the timer. That is, the NIC starts the timer and sends the packet P to the destination D after the interval T expires in every cycle. This continues forever until stopped (e.g., the sender fails).

<FIG> shows a signaling flowchart at a receiver node according to an embodiment of the disclosure. The receiver node here may be a destination endpoint that receives a "Heartbeat" message. Notably, the receiver node may also be any other devices that need to receive a periodic signal.

In this embodiment, the application creates a time-based QP, and requests the QP to receive a packet P with an interval T from a destination D. The packet P here may be a heartbeat signal. Optionally, failing to get the packet P from destination D in interval T may activate a Call Back C. Accordingly, the NIC waits for the packets P from the destination D, unless a request from the application to remove the QP or to remove the destination D is received. Optionally, if a packet P from the destination D did not arrive in interval T, the NIC may active a Call Back C. According to QP configuration, the NIC will decide whether to continue to wait for the packets P or wait for the application to request NIC QP to wait again for the packets P from destination D in interval T.

<FIG> shows packets exchange between multiple sender nodes and a receiver node according to an embodiment of the disclosure. The sender node D1 and the sender node Dn may be the sender node shown in <FIG>. The receiver node may be the receiver node shown in <FIG>.

Each of the sender node D1,. , Dn periodically sends a packet P to the destination D, i.e., the receiver node. The QP of the receiver node is requested to receive packet P from destinations (the sender nodes) D1,. , Dn in interval T. Notably, in step <NUM> at the receiver node, a packet P did not arrive from the sender node D1 in interval T. Accordingly, the NIC at the receiver node activates Call Back C in application on the sender node D1. According to QP configuration, the NIC will decide whether to continue waiting for the next packets P from the sender node D1.

<FIG> shows packets exchange among multiple destinations according to an embodiment of the disclosure. Each destination may be a sender nodes, a receiver node, or a sender receiver node. In the example shown in <FIG>, each of Node D1, D2 and D3 are a sender receiver node.

For a particular NIC, a timer for a send interval St for sending packets P, and/or a timer for a receive interval Rt for receiving packets P, may be configured. Taking Node D1 as an example, the periodic QP of Node D1 is requested to send packet P with interval St to Nodes D2 and D3, and it is also requested to receive packet P with interval Rt from Nodes D2 and D3. Failing to get packet P from Node D2 or D3 in interval T activates Call Back C. Notably, Node D2 and D3 may be configured in a similar manner.

Load balancing refers to a process of distributing a set of tasks over a set of resources (computing units), with the aim of making their overall processing more efficient. Load balancing techniques can optimize the response time for each task, avoiding unevenly overloading computing units, while other computing units are idle.

Two main approaches exist for load balancing. One is referred to as static algorithms, which do not take into account the state of the different computing units. The other one is referred to as dynamic algorithms, which are more general and more efficient, but require an exchange of information between the different computing units, at the risk of lower efficiency.

Numerous scheduling algorithms, also called load-balancing methods, are used by load balancers to determine which computing unit to send a task to. Simple algorithms include random choice, round-robin, least number of connections, etc. More sophisticated load balancers may take additional factors into account, such as a computing unit's reported load, least response times, operational/shutdown status (determined by a monitoring poll of some kind), number of active connections, geographic location, capabilities, amount of network traffic sent or received, etc..

<FIG> shows a signaling flowchart at a Load Balancer node according to an embodiment of the disclosure. In this embodiment, the application creates a time-based QP, and requests the QP to issue RDMA Read operation and load report with an interval T from a destination D. Accordingly, the NIC starts periodically issuing RDMA Read and loading report from the destination D based on the timer of the interval T. That is, the NIC starts the timer, issues RDMA Read, and load report from the destination D after the interval T expires in every cycle. This continues forever until the application stops, or terminates the QP, or changes the timer (the interval T), or when the application is killed.

<FIG> shows a signaling flowchart at a Load Balancer node according to an embodiment of the disclosure. In this embodiment, the application creates a time-based QP, and requests the QP to issue RDMA Read operation and load report with an interval T from multiple destinations, i.e., D, E and F. Accordingly, the NIC starts periodically issuing RDMA Read and loading report from each of the destinations D, E and F based on the timer of the interval T. That is, the NIC starts the timer, issues RDMA Read, and load report from each of the destinations D, E and F after the interval T expires in every cycle. Similar to the embodiment shown in <FIG>, this process continues forever until the application stops, or terminates the QP, or changes the timer (the interval T), or when the application is killed.

<FIG> shows a signaling flowchart at a server node according to an embodiment of the disclosure. In this embodiment, the application creates a regular QP, and requests a memory region, which stores the server's load information and can be read by the Load Balancer. The application updates load information locally from time to time. Incoming RDMA Read requests from the Load Balancer node will read and return the server's load information directly from the application's memory.

<FIG> shows packets exchange between a Load Balancer node and a server node according to an embodiment of the disclosure. The Load Balancer node shown in <FIG> may be the Load Balancer node shown in <FIG>. The server node shown in <FIG> may be the server node shown in <FIG>.

<FIG> shows packets exchange between a Load Balancer node and multiple server nodes according to an embodiment of the disclosure. The Load Balancer node shown in <FIG> may be the Load Balancer node shown in <FIG>. Each of the server nodes D, E and F shown in <FIG> may be the server node shown in <FIG>.

The application at the Load Balancer node creates a time-based QP, and requests the QP to issue RDMA Read operation and load report with an interval T from each of the server node D, E and F. Accordingly, the NIC starts periodically issuing RDMA Read and loading report from the destination D based on the timer of the interval T. That is, the NIC starts the timer, issues RDMA Read, and load report from each of the server node D, E and F after the interval T expires in every cycle. This continues forever until the application stops, or terminates the QP, or changes the timer (the interval T), or when the application is killed.

As configuration changes need to be delivered to all nodes of a cluster, distributing configuration changes is applied to clusters of many nodes. A configuration change may include nodes' failures, new nodes joining the cluster, or global parameters change, etc..

Configuration changes are usually managed by a cluster controller, when a node in a cluster receives a configuration change, it acts according to the requested specific change.

The process of distributing configuration changes requires a vast amount of CPU time. In the cluster controller, it needs a complex software to code and deploy, and involves a reliable network protocol. Offloading this process to another entity, such as a SmartNIC, removes a huge burden from the application developer.

According to an embodiment of this disclosure, the entity <NUM> may be further configured to maintain a memory area storing specific data for the entity <NUM>. The entity <NUM> may monitor the memory area and determine whether the specific data has changed. When it is determined that the specific data has changed, the entity <NUM> may be configured to provide a content of the specific data to one or more other entities for RDMA, using one or more WQEs of the time-based QP <NUM>.

<FIG> shows a signaling flowchart of a sender node distributing changes according to an embodiment of the disclosure. In this embodiment, the application of the sender node D1 creates a time-based QP, and requests the QP to send packets with an interval T to each of the receiver nodes D2, D2,. The NIC continuously checks whether contents in certain memory (e.g., addresses A1 to An) have been changed. The content may include configurations or parameters for the receiving nodes. If the contents or a part of the contents have been changed, the NIC takes the whole content in the memory and sends it to each of the receiver node D2, D3,. This procedure is repeated until it has been instructed to stop.

It should be noted that any data modification compared to a previous cycle will trigger a transmission (i.e., the distribution of changes). If the data remains the same, it will go to sleep till the next period. The new approach of this disclosure can be applied to distributing configuration data, either one sender to one receiver, or one sender to multiple receivers.

To summarize, embodiments of this disclosure propose a new RDMA QP behavior which is timed-based scheduled. In particular, preconfigured WQEs in the QP are to be sent on each re-scheduling event. The WQEs in the QP will be reused without re-posting them. Notably, the number of times this QP needs to be re-scheduled can be either limited or infinite (i.e. till QP tears down). Any existing types of QP can be used for implementing this new QP behavior, while no changes on the network packets are needed. The periodic QP can be used for a single destination or multiple destinations, and multiplex different applications messages on the same QP. The messages can be unicast or multicast, and it depends on the QP type capabilities (Only UD QP can multicast).

It may be worth mentioning that the common existing programming model for periodic messages is to perform this kind of logic in the upper-layer application by the main CPU, which makes it more complex, less efficient, less accurate and also consumes CPU time. Based on embodiments of this disclosure, even a non RDMA application can use this QP behavior to offload periodic messages to the hardware without software intervention.

<FIG> shows a method <NUM> for RDMA according to an embodiment of the disclosure. In a particular embodiment of the disclosure, the method <NUM> is performed by an entity <NUM> shown in <FIG>. The method <NUM> comprises a step <NUM> of maintaining a time-based QP <NUM>. In particular, the time-based QP <NUM> comprises a first area <NUM> associated with a time-based indication. The first area <NUM> is configured to hold one or more first WQEs <NUM>, <NUM>', and the time-based indication indicates that the one or more WQEs in the first area <NUM> are to be periodically processed. The method <NUM> further comprises a step <NUM> of periodically processing the one or more first WQEs <NUM>, <NUM>' in the first area <NUM> according to the time-based indication.

Optionally, the time-based indication may comprise at least one of the following indications:.

Optionally, the one or more first WQEs <NUM>, <NUM>' are associated with at least one of a first destination address and a second destination address, wherein the method further comprises periodically processing the one or more first WQEs <NUM>, <NUM>' to at least one of a first destination entity <NUM> corresponding to the first destination address and a second destination entity <NUM> corresponding to the second destination address.

Optionally, the method <NUM> further comprises maintaining a CQ, wherein the first area <NUM> is further associated with a completion indication, wherein the completion indication indicates a generation manner of a completion.

Optionally, the method <NUM> further comprises stopping processing the one or more first WQEs <NUM>, <NUM>' in the first area <NUM>, when an error occurs.

Optionally, the method <NUM> further comprises adding one or more third WQEs into the first area <NUM>; and periodically processing the one or more third WQEs in the following cycle.

Optionally, the method <NUM> further comprises obtaining the time-based QP <NUM> from at least one of a first application and a second application.

Optionally, the method <NUM> further comprises maintaining a memory area storing specific data for the entity <NUM>; monitoring the memory area and determine whether the specific data has changed; providing a content of the specific data to one or more other entities for RDMA, using one or more WQEs of the time-based QP <NUM>, when it is determined that the specific data has changed.

The present disclosure has been described in conjunction with various embodiments as examples as well as implementations. However, other variations can be understood and effected by those persons skilled in the art and practicing the claimed disclosure, from the studies of the drawings, this disclosure and the independent claims. In the claims as well as in the description the word "comprising" does not exclude other elements or steps and the indefinite article "a" or "an" does not exclude a plurality. A single element or other unit may fulfill the functions of several entities or items recited in the claims. The mere fact that certain measures are recited in the mutual different dependent claims does not indicate that a combination of these measures cannot be used in an advantageous implementation.

Furthermore, any method according to embodiments of the disclosure may be implemented in a computer program, having code means, which when run by processing means causes the processing means to execute the steps of the method.

Moreover, it is realized by the skilled person that embodiments of the entity <NUM> comprises the necessary communication capabilities in the form of e.g., functions, means, units, elements, etc., for performing the solution. Examples of other such means, units, elements and functions are: processors, memory, buffers, control logic, encoders, decoders, rate matchers, de-rate matchers, mapping units, multipliers, decision units, selecting units, switches, interleavers, de-interleavers, modulators, demodulators, inputs, outputs, antennas, amplifiers, receiver units, transmitter units, DSPs, trellis-coded modulation (TCM) encoder, TCM decoder, power supply units, power feeders, communication interfaces, communication protocols, etc. which are suitably arranged together for performing the solution.

Claim 1:
An entity (<NUM>) for Remote Direct Memory Access, RDMA, wherein the entity (<NUM>) is configured to:
maintain a time-based queue pair, QP (<NUM>), wherein the time-based QP (<NUM>) comprises a first area (<NUM>) associated with a time-based indication, wherein the first area (<NUM>) is configured to hold one or more first working queue elements, WQEs (<NUM>, <NUM>'), and the time-based indication indicates that the one or more WQEs in the first area (<NUM>) are to be periodically processed; and
periodically process the one or more first WQEs (<NUM>, <NUM>') in the first area (<NUM>) according to the time-based indication.