private int length; // 4 bytes: Length of buffer

    /**
     * Create SMB2 RDMA Transform
     *
     * @param offset offset within registered buffer
     * @param token RDMA provider token (steering tag/memory handle)
     * @param length length of buffer
     */
    public Smb2RdmaTransform(long offset, int token, int length) {
        this.offset = offset;
        this.token = token;
        this.length = length;
    }

   * {@snippet :
   * Stream.of("foo", "quux", "banana", "elephant")
   *     .collect(least(2, comparingInt(String::length)))
   * // returns {"foo", "quux"}
   * }
   *
   * <p>This {@code Collector} uses O(k) memory and takes expected time O(n) (worst-case O(n log
   * k)), as opposed to e.g. {@code Stream.sorted(comparator).limit(k)}, which currently takes O(n
   * log n) time and O(n) space.
   *

        /** File system errors (not found, access denied, etc.) */
        FILE_SYSTEM,
        /** Protocol errors (invalid message, unsupported operation, etc.) */
        PROTOCOL,
        /** Resource errors (out of memory, disk space, etc.) */
        RESOURCE,
        /** Configuration errors */
        CONFIGURATION,
        /** Transient errors that may succeed on retry */
        TRANSIENT,
        /** Unknown or unclassified errors */

models or graphs is equivalent to running untrusted code.

If you need to run untrusted models, execute them inside a
[**sandbox**](https://developers.google.com/code-sandboxing). Memory corruptions
in TensorFlow ops can be recognized as security issues only if they are
reachable and exploitable through production-grade, benign models.

### Compilation

 * }
 * public void testFooLeak() {
 *   GcFinalization.awaitClear(fooWeakRef());
 * }
 * }
 *
 * <p>This class cannot currently be used to test soft references, since this class does not try to
 * create the memory pressure required to cause soft references to be cleared.
 *
 * <p>This class only provides testing utilities. It is not designed for direct use in production or
 * for benchmarking.
 *
 * @author mike nonemacher

        EnumSet<RdmaAccess> access = EnumSet.of(RdmaAccess.LOCAL_READ, RdmaAccess.LOCAL_WRITE);

        RdmaMemoryRegion region = provider.registerMemory(buffer, access);
        assertNotNull(region, "Memory region should not be null");
        assertEquals(buffer, region.getBuffer(), "Buffer should match");
        assertEquals(1024, region.getSize(), "Size should match buffer size");

    false

-   type: input id: Cuda attributes: label: CUDA/cuDNN version description:
    placeholder: validations: required: false

-   type: input id: Gpu attributes: label: GPU model and memory description: if
    compiling from source placeholder: validations: required: false

-   type: textarea id: what-happened attributes: label: Current Behaviour?

    int NT_STATUS_NOT_IMPLEMENTED = 0xC0000002;
    /** The specified information class is invalid */
    int NT_STATUS_INVALID_INFO_CLASS = 0xC0000003;
    /** Invalid access to memory location */
    int NT_STATUS_ACCESS_VIOLATION = 0xC0000005;
    /** The handle is invalid */
    int NT_STATUS_INVALID_HANDLE = 0xC0000008;
    /** The parameter is incorrect */

	}

	cache := store.lock()
	defer store.unlock()

	// We should only update the in-memory cache if there were no changes
	// to the in-memory cache since the disk loading began. If there
	// were changes to the in-memory cache we should wait for the next
	// cycle until we can safely update the in-memory cache.
	//
	// An in-memory cache must be replaced only if we know for sure that the

//
// Returns a TF_Buffer. The memory pointed to by the result is owned by
// lib_handle. The data in the buffer will be the serialized OpList proto for
// ops defined in the library.
TF_CAPI_EXPORT extern TF_Buffer TF_GetOpList(TF_Library* lib_handle);

// Frees the memory associated with the library handle.
// Does NOT unload the library.