/**
 * @author mbechler
 *
 */
public interface CommonServerMessageBlockResponse extends CommonServerMessageBlock, Response {

    /**
     * 
     * @return is an async response
     */
    boolean isAsync ();


    /**
     * 
     * @return the next response
     */
    @Override
    CommonServerMessageBlockResponse getNextResponse ();


    /**
     * @param next
     */

    }


    /**
     * {@inheritDoc}
     *
     * @see jcifs.util.transport.Response#received()
     */
    @Override
    public final void received () {
        if ( isAsync() && getStatus() == NtStatus.NT_STATUS_PENDING ) {
            synchronized ( this ) {
                notifyAll();
            }
            return;
        }
        this.received = true;

    @Override
    public int size () {
        return 0;
    }


    /**
     * {@inheritDoc}
     *
     * @see jcifs.internal.CommonServerMessageBlockResponse#isAsync()
     */
    @Override
    public boolean isAsync () {
        return false;
    }


    /**
     * {@inheritDoc}
     *
     * @see jcifs.internal.CommonServerMessageBlockRequest#isResponseAsync()
     */

        synchronized ( resp ) {
            if ( resp.isAsync() && !resp.isAsyncHandled() && resp.getStatus() == NtStatus.NT_STATUS_PENDING && resp.getAsyncId() != 0 ) {
                resp.setAsyncHandled(true);
                boolean first = !req.isAsync();
                req.setAsyncId(resp.getAsyncId());
                Long exp = resp.getExpiration();

     *            the readSize to set
     */
    public void setReadSize ( int readSize ) {
        this.readSize = readSize;
    }


    /**
     * @return the async
     */
    public boolean isAsync () {
        return this.async;
    }


    /**
     * @param command
     *            the command to set
     */
    @Override
    public final void setCommand ( int command ) {

// deadlocks.
class DeviceThread {
 public:
  // Starts a background thread waiting for `StartExecute`.
  explicit DeviceThread(const std::string& device, const bool is_async,
                        const int in_flight_nodes_limit)
      : status_(TF_NewStatus()),
        // If the context's default exector is set to async, re-using that in

  // return a bad status the caller must run all of the `Join`s or any future
  // `StartExecute`s will deadlock).
  //
  // If `is_async=false` (constructor argument), `cancellation_manager` must
  // live until `Join` finishes. If `is_async=true` it must live until `Join` is
  // followed by `TFE_ContextAsyncWait` to clear pending operations. It will be
  // used to cancel all other operations if any fails.
  //

    TFE_Context* ctx = TFE_NewContext(opts, status);
    ASSERT_TRUE(TF_GetCode(status) == TF_OK) << TF_Message(status);
    TFE_DeleteContextOptions(opts);
    TFE_Executor* executor = TFE_NewExecutor(
        /*is_async=*/false, /*enable_streaming_enqueue=*/true,
        /*in_flight_nodes_limit=*/0);
    TFE_ContextSetExecutorForThread(ctx, executor);

    TFE_DeleteContext(ctx);
    TFE_DeleteExecutor(executor);
  }

pkg syscall (netbsd-386), const MS_ASYNC ideal-int
pkg syscall (netbsd-386), const MS_INVALIDATE = 2
pkg syscall (netbsd-386), const MS_INVALIDATE ideal-int
pkg syscall (netbsd-386), const MS_SYNC = 4
pkg syscall (netbsd-386), const MS_SYNC ideal-int
pkg syscall (netbsd-386), const PROT_EXEC = 4
pkg syscall (netbsd-386), const PROT_EXEC ideal-int
pkg syscall (netbsd-386), const PROT_NONE = 0

// referenced by the inflight nodes.
// A recommended value has not been established.
// A value of 0 removes the limit, which is the behavior of TensorFlow 2.11.
// When is_async is false, the value is ignored.
TF_CAPI_EXPORT extern TFE_Executor* TFE_NewExecutor(
    bool is_async, bool enable_streaming_enqueue, int in_flight_nodes_limit);

// Deletes the eager Executor without waiting for enqueued nodes. Please call