protected final BlockingQueue<RdmaWorkRequest> pendingRequests;

    // Connection state
    /** Current connection state */
    protected volatile RdmaConnectionState state;
    /** Credit management for SMB Direct */
    protected RdmaCredits credits;
    /** Maximum size for fragmented operations */
    protected int maxFragmentedSize;
    /** Maximum size for RDMA read/write operations */
    protected int maxReadWriteSize;

## Caveat

      interruptenator.shutdown();
      Thread.interrupted();
    }
  }

  /**
   * awaitFullGc() is not quite as reliable a way to ensure calling of a specific finalize method as
   * the more direct await* methods, but should be reliable enough in practice to avoid flakiness of
   * this test. (And if it isn't, we'd like to know about it first!)
   */
  public void testAwaitFullGc() {

func (p *Parser) registerIndirect(a *obj.Addr, prefix rune) {
	p.get('(')
	tok := p.next()
	name := tok.String()
	r1, r2, scale, ok := p.register(name, 0)
	if !ok {
		p.errorf("indirect through non-register %s", tok)
	}
	p.get(')')
	a.Type = obj.TYPE_MEM
	if r1 < 0 {
		// Pseudo-register reference.
		if r2 != 0 {
			p.errorf("cannot use pseudo-register in pair")
			return
		}

            off += fragSize;
        }
        throw new IOException();
    }

    /**
     * @param msg
     * @param in
     * @param off
     * @param isDirect
     * @return
     * @throws IOException
     * @throws DcerpcException
     * @throws NdrException
     */

**In our tests we also found ext4 does not honor POSIX O_DIRECT/Fdatasync semantics, ext4 trades performance for consistency guarantees. Please avoid ext4 in your setup.**

// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
// OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

import jcifs.SmbSession;
import jcifs.SmbTransport;
import jcifs.smb.SmbException;
import jcifs.smb.SmbTransportInternal;

/**
 * RDMA-enabled SMB transport that wraps existing SMB transport
 * and adds RDMA capabilities for direct memory access operations.
 */
public class RdmaTransport implements SmbTransportInternal {
    private static final Logger log = LoggerFactory.getLogger(RdmaTransport.class);

    private final SmbTransportInternal delegate;

         * the 'received' member of the response object will not
         * be set to true indicating the send and sendTransaction
         * methods that the next part should be sent. This is a
         * very indirect and simple batching control mechanism.
         */

        if (this.andx == null || !getConfig().isUseBatching()
                || this.batchLevel >= getBatchLimit(getConfig(), (byte) this.andx.getCommand())) {

      Map<? extends Class<? extends S>, ? extends S> map) {
    if (map instanceof ImmutableClassToInstanceMap) {
      @SuppressWarnings("rawtypes") // JDT-based J2KT Java frontend does not permit the direct cast
      Map rawMap = map;
      @SuppressWarnings("unchecked") // covariant casts safe (unmodifiable)
      ImmutableClassToInstanceMap<B> cast = (ImmutableClassToInstanceMap<B>) rawMap;
      return cast;
    }