public:

// Instantiate a stream tied to parent as a platform executor. Work

// entrained onto this stream will be launched/managed on that

// StreamExecutor's platform.

explicit Stream(StreamExecutor *parent);

// Test only. Use an externally-populated value (like a mock) for the

// platform-specific stream implementation.

Stream(StreamExecutor *parent, internal::StreamInterface *implementation);

// Deallocates any stream resources that the parent StreamExecutor has

// bestowed

// upon this object.

~Stream();

// Returns whether any errors have occurred while entraining work for this

// stream.

bool ok() const { return !InErrorState(); }

// Initialize the stream. This must be performed before entraining any other

// operations.

Stream &Init();

// Initializes timer t via the StreamExecutor.

Stream &InitTimer(Timer *t);

// Convenience wrapper around Init() and InitTimer().

Stream &InitWithTimer(Timer *t);

// Warning! After calling BlockHostUntilDone(), all sub-streams will be

// returned and hence invalid. This may be a temporary solution to the issue

// b/18070215.

// Get or create a sub-stream from this stream. If there is any sub-stream

// in the pool that can be reused then just return this sub-stream.

// Otherwise

// create a new sub-stream.

Stream *GetOrCreateSubStream();

// Return the sub-stream back to the host stream so that it can be reused

// later.

void ReturnSubStream(Stream *sub_stream);

// Allocate temporary memories. The stream will deallocate them when blocked

// or destroyed.

template <typename T>

port::StatusOr<std::unique_ptr<TemporaryDeviceMemory<T>>>

AllocateTemporaryArray(uint64 element_count);

// Entrains onto the stream of operations: a kernel launch with the given

// (variadic) parameters for the invocation. These arguments can be things

// like DeviceMemory or primitive types such as int. What arguments you may

// pass to a given kernel are noted as the template parameters to the

// TypedKernel type that the machocc compiler generates.

//

// Template parameters:

// Params... The type list of formal parameters that the typed kernel

// expects, which is matched against Args...

// Args... The deduced type list for passed actual arguments

//

// Implementation: A compile-time compatibility check is performed that has

// some leniency versus an exact parameter pack match -- for example,

// `const DeviceMemory<T>` is considered "pack compatible" with a

// `const DeviceMemory<T>&` formal parameter; in part, because we don't have

// perfect forwarding support without rvalue references. It also attempts to

// spit out helpful static_assert error traces with information as to the

// argument number and types that were mismatched.

template <typename... Params, typename... Args>

Stream &ThenLaunch(ThreadDim thread_dims, BlockDim block_dims,

const TypedKernel<Params...> &kernel, Args... args);

// Record a "start" event for the interval timer at this point in the

// stream's

// execution (relative to the previously and subsequently enqueued items in

// the stream's execution). Streams may be started/stopped multiple times.

Stream &ThenStartTimer(Timer *t);

// Record a "stop" event for the interval timer at this point in the

// stream's

// execution. See also Stream::ThenStartTimer.

Stream &ThenStopTimer(Timer *t);

// TODO(leary) If work is added to the stream that is being depended upon,

// then what? Have to describe what happens.

template <typename... Params>

Stream &ThenWaitFor(Stream *other, Params... more_streams) {

return ThenWaitFor(more_streams...).ThenWaitFor(other);

}

// Create a dependency for this stream's next work on the other stream

// completing. Does not take ownership of other, and other must not be

// null.

//

// Checks that a stream does not wait for itself, and it is up to the

// user to guarantee that a stream does not come to wait on itself in a

// cyclic

// manner; in that case, behavior is undefined.

//

// N.B. Base recursion case for the variadic ThenWaitFor.

Stream &ThenWaitFor(Stream *other);

// Waits for all streams values in others.

// Checks that there is no shallow circular wait (i.e. that "this" is not in

// others).

Stream &ThenWaitFor(std::vector<std::unique_ptr<Stream>> *others);

// Waits for an event object to be set.

// Note that ThenRecordEvent must have been called on the event before

// you call this function; otherwise the event will be considered complete

// and this wait will do nothing.

Stream &ThenWaitFor(Event *event);

// Inserts the specified event into the end of this stream. Once the stream

// has processed all events prior to the insertion point, the event will be

// marked as completed.

// The stream does not take ownership of event - meaning that event's lifetime

// must extend past the point at which it is marked complete!

Stream &ThenRecordEvent(Event *event);

////////////////

// DNN support

//

// See DnnSupport::* for comments on the following methods.

Stream &ThenBatchNormalizationForward(

const DeviceMemory<float> &x, const DeviceMemory<float> &scale,

const DeviceMemory<float> &offset,

const DeviceMemory<float> &estimated_mean,

const DeviceMemory<float> &estimated_variance,

const dnn::BatchDescriptor &x_desc,

const dnn::BatchDescriptor &scale_offset_desc, const double epsilon,

DeviceMemory<float> *y, DeviceMemory<float> *batch_mean,

DeviceMemory<float> *batch_var, DeviceMemory<float> *saved_mean,

DeviceMemory<float> *saved_inv_var, bool is_training,

std::function<const DeviceMemory<float> &()> var_to_inv_var,

std::function<void()> inv_var_to_var);

Stream &ThenBatchNormalizationBackward(

const DeviceMemory<float> &y_backprop, const DeviceMemory<float> &x,

const DeviceMemory<float> &scale, const DeviceMemory<float> &mean,

const DeviceMemory<float> &variance, const dnn::BatchDescriptor &x_desc,

const dnn::BatchDescriptor &scale_offset_desc, const double epsilon,

DeviceMemory<float> *x_backprop, DeviceMemory<float> *scale_backprop,

DeviceMemory<float> *offset_backprop);

// TODO(leary) add double-precision version of this interface.

Stream &ThenConvolve(const dnn::BatchDescriptor &input_descriptor,

const DeviceMemory<float> &input_data,

const dnn::FilterDescriptor &filter_descriptor,

const DeviceMemory<float> &filter_data,

const dnn::ConvolutionDescriptor &convolution_descriptor,

const dnn::BatchDescriptor &output_descriptor,

DeviceMemory<float> *output);

Stream &ThenConvolveQuantized(

const dnn::BatchDescriptor &input_descriptor,

const DeviceMemory<float> &input_data,

const dnn::FilterDescriptor &filter_descriptor,

const DeviceMemory<int8> &filter_coefficients,

const DeviceMemory<float> &coefficient_scales,

const dnn::ConvolutionDescriptor &convolution_descriptor,

const dnn::BatchDescriptor &output_descriptor,

DeviceMemory<float> *output_data);

Stream &ThenConvolveQuantized(

const dnn::BatchDescriptor &input_descriptor,

const DeviceMemory<float> &input_data,

const dnn::FilterDescriptor &filter_descriptor,

const DeviceMemory<int16> &filter_coefficients,

const DeviceMemory<float> &coefficient_scales,

const dnn::ConvolutionDescriptor &convolution_descriptor,

const dnn::BatchDescriptor &output_descriptor,

DeviceMemory<float> *output_data);

Stream &ThenConvolveWithScratch(

const dnn::BatchDescriptor &input_descriptor,

const DeviceMemory<Eigen::half> &input_data,

const dnn::FilterDescriptor &filter_descriptor,

const DeviceMemory<Eigen::half> &filter_data,

const dnn::ConvolutionDescriptor &convolution_descriptor,

const dnn::BatchDescriptor &output_descriptor,

DeviceMemory<Eigen::half> *output, ScratchAllocator *scratch_allocator);

Stream &ThenConvolveWithScratch(

const dnn::BatchDescriptor &input_descriptor,

const DeviceMemory<float> &input_data,

const dnn::FilterDescriptor &filter_descriptor,

const DeviceMemory<float> &filter_data,

const dnn::ConvolutionDescriptor &convolution_descriptor,

const dnn::BatchDescriptor &output_descriptor,

DeviceMemory<float> *output, ScratchAllocator *scratch_allocator);

Stream &ThenConvolveWithAlgorithm(

const dnn::BatchDescriptor &input_descriptor,

const DeviceMemory<float> &input_data,

const dnn::FilterDescriptor &filter_descriptor,

const DeviceMemory<float> &filter_data,

const dnn::ConvolutionDescriptor &convolution_descriptor,

const dnn::BatchDescriptor &output_descriptor,

DeviceMemory<float> *output, ScratchAllocator *scratch_allocator,

const dnn::AlgorithmConfig &algorithm_config,

dnn::ProfileResult *output_profile_result);

Stream &ThenConvolveWithAlgorithm(

const dnn::BatchDescriptor &input_descriptor,

const DeviceMemory<Eigen::half> &input_data,

const dnn::FilterDescriptor &filter_descriptor,

const DeviceMemory<Eigen::half> &filter_data,

const dnn::ConvolutionDescriptor &convolution_descriptor,

const dnn::BatchDescriptor &output_descriptor,

DeviceMemory<Eigen::half> *output, ScratchAllocator *scratch_allocator,

const dnn::AlgorithmConfig &algorithm_config,

dnn::ProfileResult *output_profile_result);

Stream &ThenSeparableConvolve(

const dnn::BatchDescriptor &input_descriptor,

const DeviceMemory<float> &input_data,

const dnn::FilterDescriptor &filter_descriptor, int depth_multiplier,

const DeviceMemory<float> &first_weights,

const DeviceMemory<float> &second_weights,

const dnn::ConvolutionDescriptor &convolution_descriptor,

const dnn::BatchDescriptor &output_descriptor,

DeviceMemory<float> *output);

Stream &ThenConvolveBackwardData(

const dnn::FilterDescriptor &filter_descriptor,

const DeviceMemory<float> &filter_data,

const dnn::BatchDescriptor &output_descriptor,

DeviceMemory<float> backward_output_data,

const dnn::ConvolutionDescriptor &convolution_descriptor,

const dnn::BatchDescriptor &input_descriptor,

DeviceMemory<float> *backward_input_data);

Stream &ThenConvolveBackwardDataWithScratch(

const dnn::FilterDescriptor &filter_descriptor,

const DeviceMemory<float> &filter_data,

const dnn::BatchDescriptor &output_descriptor,

DeviceMemory<float> backward_output_data,

const dnn::ConvolutionDescriptor &convolution_descriptor,

const dnn::BatchDescriptor &input_descriptor,

DeviceMemory<float> *backward_input_data,

ScratchAllocator *scratch_allocator);

Stream &ThenConvolveBackwardDataWithScratch(

const dnn::FilterDescriptor &filter_descriptor,

const DeviceMemory<Eigen::half> &filter_data,

const dnn::BatchDescriptor &output_descriptor,

DeviceMemory<Eigen::half> backward_output_data,

const dnn::ConvolutionDescriptor &convolution_descriptor,

const dnn::BatchDescriptor &input_descriptor,

DeviceMemory<Eigen::half> *backward_input_data,

ScratchAllocator *scratch_allocator);

Stream &ThenConvolveBackwardDataWithAlgorithm(

const dnn::FilterDescriptor &filter_descriptor,

const DeviceMemory<float> &filter_data,

const dnn::BatchDescriptor &output_descriptor,

DeviceMemory<float> backward_output_data,

const dnn::ConvolutionDescriptor &convolution_descriptor,

const dnn::BatchDescriptor &input_descriptor,

DeviceMemory<float> *backward_input_data,

ScratchAllocator *scratch_allocator,

const dnn::AlgorithmConfig &algorithm_config,

dnn::ProfileResult *output_profile_result);

Stream &ThenConvolveBackwardDataWithAlgorithm(

const dnn::FilterDescriptor &filter_descriptor,

const DeviceMemory<Eigen::half> &filter_data,

const dnn::BatchDescriptor &output_descriptor,

DeviceMemory<Eigen::half> backward_output_data,

const dnn::ConvolutionDescriptor &convolution_descriptor,

const dnn::BatchDescriptor &input_descriptor,

DeviceMemory<Eigen::half> *backward_input_data,

ScratchAllocator *scratch_allocator,

const dnn::AlgorithmConfig &algorithm_config,

dnn::ProfileResult *output_profile_result);

Stream &ThenConvolveBackwardFilter(

const dnn::BatchDescriptor &input_descriptor,

const DeviceMemory<float> &input_data,

const dnn::BatchDescriptor &output_descriptor,

DeviceMemory<float> backward_output_data,

const dnn::ConvolutionDescriptor &convolution_descriptor,

const dnn::FilterDescriptor &filter_descriptor,

DeviceMemory<float> *backward_filter_data);

Stream &ThenConvolveBackwardFilterWithScratch(

const dnn::BatchDescriptor &input_descriptor,

const DeviceMemory<float> &input_data,

const dnn::BatchDescriptor &output_descriptor,

DeviceMemory<float> backward_output_data,

const dnn::ConvolutionDescriptor &convolution_descriptor,

const dnn::FilterDescriptor &filter_descriptor,

DeviceMemory<float> *backward_filter_data,

ScratchAllocator *scratch_allocator);

Stream &ThenConvolveBackwardFilterWithScratch(

const dnn::BatchDescriptor &input_descriptor,

const DeviceMemory<Eigen::half> &input_data,

const dnn::BatchDescriptor &output_descriptor,

DeviceMemory<Eigen::half> backward_output_data,

const dnn::ConvolutionDescriptor &convolution_descriptor,

const dnn::FilterDescriptor &filter_descriptor,

DeviceMemory<Eigen::half> *backward_filter_data,

ScratchAllocator *scratch_allocator);

Stream &ThenConvolveBackwardFilterWithAlgorithm(

const dnn::BatchDescriptor &input_descriptor,

const DeviceMemory<float> &input_data,

const dnn::BatchDescriptor &output_descriptor,

DeviceMemory<float> backward_output_data,

const dnn::ConvolutionDescriptor &convolution_descriptor,

const dnn::FilterDescriptor &filter_descriptor,

DeviceMemory<float> *backward_filter_data,

ScratchAllocator *scratch_allocator,

const dnn::AlgorithmConfig &algorithm_config,

dnn::ProfileResult *output_profile_result);

Stream &ThenConvolveBackwardFilterWithAlgorithm(

const dnn::BatchDescriptor &input_descriptor,

const DeviceMemory<Eigen::half> &input_data,

const dnn::BatchDescriptor &output_descriptor,

DeviceMemory<Eigen::half> backward_output_data,

const dnn::ConvolutionDescriptor &convolution_descriptor,

const dnn::FilterDescriptor &filter_descriptor,

DeviceMemory<Eigen::half> *backward_filter_data,

ScratchAllocator *scratch_allocator,

const dnn::AlgorithmConfig &algorithm_config,

dnn::ProfileResult *output_profile_result);

Stream &ThenConvolveBackwardBias(const dnn::BatchDescriptor &input_descriptor,

const DeviceMemory<double> &input_data,

const dnn::BatchDescriptor &bias_descriptor,

DeviceMemory<double> *backward_bias_data);

Stream &ThenConvolveBackwardBias(const dnn::BatchDescriptor &input_descriptor,

const DeviceMemory<float> &input_data,

const dnn::BatchDescriptor &bias_descriptor,

DeviceMemory<float> *backward_bias_data);

Stream &ThenConvolveBackwardBias(

const dnn::BatchDescriptor &input_descriptor,

const DeviceMemory<Eigen::half> &input_data,

const dnn::BatchDescriptor &bias_descriptor,

DeviceMemory<Eigen::half> *backward_bias_data);

Stream &ThenMatMul(const DeviceMemory<float> &input_data,

const DeviceMemory<float> &weights,

const dnn::BatchDescriptor &input_dimensions,

const dnn::BatchDescriptor &output_dimensions,

DeviceMemory<float> *output_data);

Stream &ThenMatMulQuantized(const DeviceMemory<float> &input_data,

const DeviceMemory<int8> &weights,

const DeviceMemory<float> &weight_scales,

const dnn::BatchDescriptor &input_dimensions,

const dnn::BatchDescriptor &output_dimensions,

DeviceMemory<float> *output_data);

Stream &ThenMatMulQuantized(const DeviceMemory<float> &input_data,

const DeviceMemory<int16> &weights,

const DeviceMemory<float> &weight_scales,

const dnn::BatchDescriptor &input_dimensions,

const dnn::BatchDescriptor &output_dimensions,

DeviceMemory<float> *output_data);

Stream &ThenBiasAdd(const DeviceMemory<float> &input_data,

const DeviceMemory<float> &biases,

const dnn::BatchDescriptor &dimensions,

DeviceMemory<float> *output_data);

Stream &ThenPoolForward(const dnn::PoolingDescriptor &pooling_dimensions,

const dnn::BatchDescriptor &input_dimensions,

const DeviceMemory<float> &input_data,

const dnn::BatchDescriptor &output_dimensions,

DeviceMemory<float> *output_data);

Stream &ThenPoolForward(const dnn::PoolingDescriptor &pooling_dimensions,

const dnn::BatchDescriptor &input_dimensions,

const DeviceMemory<Eigen::half> &input_data,

const dnn::BatchDescriptor &output_dimensions,

DeviceMemory<Eigen::half> *output_data);

Stream &ThenPoolBackward(const dnn::PoolingDescriptor &pooling_dimensions,

const dnn::BatchDescriptor &input_dimensions,

const DeviceMemory<float> &input_data,

const dnn::BatchDescriptor &output_dimensions,

const DeviceMemory<float> &output_data,

const DeviceMemory<float> &input_diff_data,

DeviceMemory<float> *output_diff_data);

Stream &ThenPoolBackward(const dnn::PoolingDescriptor &pooling_dimensions,

const dnn::BatchDescriptor &input_dimensions,

const DeviceMemory<Eigen::half> &input_data,

const dnn::BatchDescriptor &output_dimensions,

const DeviceMemory<Eigen::half> &output_data,

const DeviceMemory<Eigen::half> &input_diff_data,

DeviceMemory<Eigen::half> *output_diff_data);

Stream &ThenNormalize(const dnn::NormalizeDescriptor &normalize_descriptor,

const DeviceMemory<float> &input_data,

DeviceMemory<float> *output_data);

// Similar to ThenNormalize, but normalizes across feature maps and allows for

// specifying the dimensions of the tensor.

Stream &ThenNormalizeWithDimensions(

const dnn::NormalizeDescriptor &normalize_descriptor,

const dnn::BatchDescriptor &dimensions,

const DeviceMemory<float> &input_data, DeviceMemory<float> *output_data);

Stream &ThenNormalizeBackwardWithDimensions(

const dnn::NormalizeDescriptor &normalize_descriptor,

const dnn::BatchDescriptor &dimensions,

const DeviceMemory<float> &raw_data,

const DeviceMemory<float> &normalized_data,

const DeviceMemory<float> &normalized_variable_gradient,

DeviceMemory<float> *raw_variable_gradient);

Stream &ThenActivate(dnn::ActivationMode activation_mode,

const dnn::BatchDescriptor &dimensions,

const DeviceMemory<float> &input_data,

DeviceMemory<float> *output_data);

// Same as ThenActivate, but also takes an options argument that can be used

// for platform-specific option flags.

Stream &ThenActivateWithOptions(dnn::ActivationMode activation_mode,

const dnn::BatchDescriptor &dimensions,

const DeviceMemory<float> &input_data,

DeviceMemory<float> *output_data,

uint64 options);

Stream &ThenDepthConcatenate(

port::ArraySlice<dnn::BatchDescriptor> input_dimensions,

port::ArraySlice<const DeviceMemory<float> *> input_data,

DeviceMemory<float> *output_data);

Stream &ThenSpaceConcatenate(

port::ArraySlice<dnn::BatchDescriptor> input_dimensions,

port::ArraySlice<const DeviceMemory<float> *> input_data,

DeviceMemory<float> *output_data,

dnn::SpaceConcatenateMode concat_direction);

// Change the layout of the data by shrinking one dimension (or set of

// dimensions) and growing another dimension (or set of dimensions), while

// keeping the total number of data elements constant, and maintaining the

// current data ordering.

Stream &ThenReshape(const dnn::BatchDescriptor &input_dimensions,

const DeviceMemory<float> &input_data,

const dnn::BatchDescriptor &output_dimensions,

DeviceMemory<float> *output_data);

// Depth to space takes an X by Y image with depth D*M² and changes it to an

// MX x MY image with depth D. Each input location (x,y) with depth D*M² in

// the input image is changed to an MxM contiguous area in the output image,

// with the values being laid out in raster order specified by

// DepthToSpaceLayout, and will have a new depth of D.

// See the DoDepthToSpace comment for more information.

Stream &ThenDepthToSpace(const dnn::BatchDescriptor &input_dimensions,

const DeviceMemory<float> &input_data,

const dnn::DepthToSpaceLayout &depth_to_space_layout,

const int sqrt_depth_reduction,

DeviceMemory<float> *output_data);

// Space to depth is the inverse of depth to space. Space to depth takes each

// non-overlapping M by M patch (in the X and Y dimensions) with depth D of

// the input, and transforms it to a 1 by 1 patch with depth D*M². If the

// input has size (MX, MY, D), the output has size (X, Y, D*M²). The number of

// data elements is not changed.

Stream &ThenSpaceToDepth(const dnn::BatchDescriptor &input_dimensions,

const DeviceMemory<float> &input_data,

const dnn::DepthToSpaceLayout &space_to_depth_layout,

const int sqrt_depth_increase,

DeviceMemory<float> *output_data);

Stream &ThenElementwiseOperate(

dnn::ElementwiseOperation operation,

port::ArraySlice<dnn::BatchDescriptor> input_dimensions,

port::ArraySlice<const DeviceMemory<float> *> input_data,

const dnn::BatchDescriptor &output_dimensions,

DeviceMemory<float> *output_data);

Stream &ThenElementwiseOperateScaledQuantized(

dnn::ElementwiseOperation operation,

port::ArraySlice<int> input_multiplicands, int output_divisor,

port::ArraySlice<dnn::BatchDescriptor> input_dimensions,

port::ArraySlice<const DeviceMemory<float> *> input_data,

const dnn::BatchDescriptor &output_dimensions,

DeviceMemory<float> *output_data);

Stream &ThenXYPad(const dnn::BatchDescriptor &dimensions,

const DeviceMemory<float> &input_data, int64 left_pad,

int64 right_pad, int64 top_pad, int64 bottom_pad,

DeviceMemory<float> *output_data);

Stream &ThenXYSlice(const dnn::BatchDescriptor &dimensions,

const DeviceMemory<float> &input_data, int64 left_trim,

int64 right_trim, int64 top_trim, int64 bottom_trim,

DeviceMemory<float> *output_data);

// Grows the input tensor by replicating the X and Y dimensions. The batch and

// depth/feature_map dimensions are unchanged. Currently, the input tensor is

// limited to X=1 and Y=1.

Stream &ThenXYBroadcast(const dnn::BatchDescriptor &dimensions,

const DeviceMemory<float> &input_data,

int64 replicate_x, int64 replicate_y,

DeviceMemory<float> *output_data);

// See DnnSupport::DoMemcpyD2HQuantized.

Stream &ThenMemcpyD2HQuantized(const DeviceMemory<float> &gpu_unquantized_src,

dnn::QuantizedActivationMode mode,

void *host_dst, uint64 size);

// Template version of ThenMemcpyD2HQuantized that takes a MutableArraySlice

// and uses the Quantization trait to call the generic version of

// ThenMemcpyD2HQuantized with the correct QuantizedActivationMode.

template <typename ElementType>

Stream &ThenMemcpyD2HQuantized(

const DeviceMemory<float> &gpu_unquantized_src,

port::MutableArraySlice<ElementType> host_dst) {

return ThenMemcpyD2HQuantized(

gpu_unquantized_src, Quantization<ElementType>::kModeId,

host_dst.data(), host_dst.size() * sizeof(ElementType));

}

// See DnnSupport::DoMemcpyH2DQuantized.

Stream &ThenMemcpyH2DQuantized(const void *host_src, uint64 size,

dnn::QuantizedActivationMode mode,

DeviceMemory<float> *gpu_unquantized_dst);

// Template version of ThenMemcpyH2DQuantized that takes an ArraySlice

// and uses the Quantization trait to call the generic version of

// ThenMemcpyH2DQuantized with the correct QuantizedActivationMode.

template <typename ElementType>

Stream &ThenMemcpyH2DQuantized(port::ArraySlice<ElementType> host_src,

DeviceMemory<float> *gpu_unquantized_dst) {

return ThenMemcpyH2DQuantized(

host_src.data(), host_src.size() * sizeof(ElementType),

Quantization<ElementType>::kModeId, gpu_unquantized_dst);

}

// See DnnSupport::DoCopyHostBuffer2Device.

Stream &ThenCopyHostBuffer2Device(HostBuffer *buffer_src,

DeviceMemory<float> *gpu_unquantized_dst);

// See DnnSupport::DoCopyDevice2HostBuffer.

Stream &ThenCopyDevice2HostBuffer(

const DeviceMemory<float> &gpu_unquantized_src, HostBuffer *buffer_dst);

/////////////////

// BLAS support

// See BlasSupport::DoBlasAsum.

Stream &ThenBlasAsum(uint64 elem_count, const DeviceMemory<float> &x,

int incx, DeviceMemory<float> *result);

Stream &ThenBlasAsum(uint64 elem_count, const DeviceMemory<double> &x,

int incx, DeviceMemory<double> *result);

Stream &ThenBlasAsum(uint64 elem_count,

const DeviceMemory<std::complex<float>> &x, int incx,

DeviceMemory<float> *result);

Stream &ThenBlasAsum(uint64 elem_count,

const DeviceMemory<std::complex<double>> &x, int incx,

DeviceMemory<double> *result);

// See BlasSupport::DoBlasAxpy. Note that, even for the case where alpha is

// present in DeviceMemory, it must be an execution-time constant (i.e. a

// value

// that the stream does not change or populate during the course of

// execution). The value is effectively captured at stream-enqueue time.

Stream &ThenBlasAxpy(uint64 elem_count, float alpha,

const DeviceMemory<float> &x, int incx,

DeviceMemory<float> *y, int incy);

Stream &ThenBlasAxpy(uint64 elem_count, double alpha,

const DeviceMemory<double> &x, int incx,

DeviceMemory<double> *y, int incy);

Stream &ThenBlasAxpy(uint64 elem_count, std::complex<float> alpha,

const DeviceMemory<std::complex<float>> &x, int incx,

DeviceMemory<std::complex<float>> *y, int incy);

Stream &ThenBlasAxpy(uint64 elem_count, std::complex<double> alpha,

const DeviceMemory<std::complex<double>> &x, int incx,

DeviceMemory<std::complex<double>> *y, int incy);

// See BlasSupport::DoBlasCopy.

Stream &ThenBlasCopy(uint64 elem_count, const DeviceMemory<float> &x,

int incx, DeviceMemory<float> *y, int incy);

Stream &ThenBlasCopy(uint64 elem_count, const DeviceMemory<double> &x,

int incx, DeviceMemory<double> *y, int incy);

Stream &ThenBlasCopy(uint64 elem_count,

const DeviceMemory<std::complex<float>> &x, int incx,

DeviceMemory<std::complex<float>> *y, int incy);

Stream &ThenBlasCopy(uint64 elem_count,

const DeviceMemory<std::complex<double>> &x, int incx,

DeviceMemory<std::complex<double>> *y, int incy);

// See BlasSupport::DoBlasDot.

Stream &ThenBlasDot(uint64 elem_count, const DeviceMemory<float> &x, int incx,

const DeviceMemory<float> &y, int incy,

DeviceMemory<float> *result);

Stream &ThenBlasDot(uint64 elem_count, const DeviceMemory<double> &x,

int incx, const DeviceMemory<double> &y, int incy,

DeviceMemory<double> *result);

// See BlasSupport::DoBlasDotc.

Stream &ThenBlasDotc(uint64 elem_count,

const DeviceMemory<std::complex<float>> &x, int incx,

const DeviceMemory<std::complex<float>> &y, int incy,

DeviceMemory<std::complex<float>> *result);

Stream &ThenBlasDotc(uint64 elem_count,

const DeviceMemory<std::complex<double>> &x, int incx,

const DeviceMemory<std::complex<double>> &y, int incy,

DeviceMemory<std::complex<double>> *result);

// See BlasSupport::DoBlasDotu.

Stream &ThenBlasDotu(uint64 elem_count,

const DeviceMemory<std::complex<float>> &x, int incx,

const DeviceMemory<std::complex<float>> &y, int incy,

DeviceMemory<std::complex<float>> *result);

Stream &ThenBlasDotu(uint64 elem_count,

const DeviceMemory<std::complex<double>> &x, int incx,

const DeviceMemory<std::complex<double>> &y, int incy,

DeviceMemory<std::complex<double>> *result);

// See BlasSupport::DoBlasNrm2.

Stream &ThenBlasNrm2(uint64 elem_count, const DeviceMemory<float> &x,

int incx, DeviceMemory<float> *result);

Stream &ThenBlasNrm2(uint64 elem_count, const DeviceMemory<double> &x,

int incx, DeviceMemory<double> *result);

Stream &ThenBlasNrm2(uint64 elem_count,

const DeviceMemory<std::complex<float>> &x, int incx,

DeviceMemory<float> *result);

Stream &ThenBlasNrm2(uint64 elem_count,

const DeviceMemory<std::complex<double>> &x, int incx,

DeviceMemory<double> *result);

// See BlasSupport::DoBlasRot.

Stream &ThenBlasRot(uint64 elem_count, DeviceMemory<float> *x, int incx,

DeviceMemory<float> *y, int incy, float c, float s);

Stream &ThenBlasRot(uint64 elem_count, DeviceMemory<double> *x, int incx,

DeviceMemory<double> *y, int incy, double c, double s);

Stream &ThenBlasRot(uint64 elem_count, DeviceMemory<std::complex<float>> *x,

int incx, DeviceMemory<std::complex<float>> *y, int incy,

float c, float s);

Stream &ThenBlasRot(uint64 elem_count, DeviceMemory<std::complex<double>> *x,

int incx, DeviceMemory<std::complex<double>> *y, int incy,

double c, double s);

// See BlasSupport::DoBlasRotg.

Stream &ThenBlasRotg(DeviceMemory<float> *a, DeviceMemory<float> *b,

DeviceMemory<float> *c, DeviceMemory<float> *s);

Stream &ThenBlasRotg(DeviceMemory<double> *a, DeviceMemory<double> *b,

DeviceMemory<double> *c, DeviceMemory<double> *s);

Stream &ThenBlasRotg(DeviceMemory<std::complex<float>> *a,

DeviceMemory<std::complex<float>> *b,

DeviceMemory<float> *c,

DeviceMemory<std::complex<float>> *s);

Stream &ThenBlasRotg(DeviceMemory<std::complex<double>> *a,

DeviceMemory<std::complex<double>> *b,

DeviceMemory<double> *c,

DeviceMemory<std::complex<double>> *s);

// See BlasSupport::DoBlasRotm.

Stream &ThenBlasRotm(uint64 elem_count, DeviceMemory<float> *x, int incx,

DeviceMemory<float> *y, int incy,

const DeviceMemory<float> &param);

Stream &ThenBlasRotm(uint64 elem_count, DeviceMemory<double> *x, int incx,

DeviceMemory<double> *y, int incy,

const DeviceMemory<double> &param);

// See BlasSupport::DoBlasRotmg.

Stream &ThenBlasRotmg(DeviceMemory<float> *d1, DeviceMemory<float> *d2,

DeviceMemory<float> *x1, const DeviceMemory<float> &y1,

DeviceMemory<float> *param);

Stream &ThenBlasRotmg(DeviceMemory<double> *d1, DeviceMemory<double> *d2,

DeviceMemory<double> *x1,

const DeviceMemory<double> &y1,

DeviceMemory<double> *param);

// See BlasSupport::DoBlasScal.

Stream &ThenBlasScal(uint64 elem_count, float alpha, DeviceMemory<float> *x,

int incx);

Stream &ThenBlasScal(uint64 elem_count, double alpha, DeviceMemory<double> *x,

int incx);

Stream &ThenBlasScal(uint64 elem_count, float alpha,

DeviceMemory<std::complex<float>> *x, int incx);

Stream &ThenBlasScal(uint64 elem_count, double alpha,

DeviceMemory<std::complex<double>> *x, int incx);

Stream &ThenBlasScal(uint64 elem_count, std::complex<float> alpha,

DeviceMemory<std::complex<float>> *x, int incx);

Stream &ThenBlasScal(uint64 elem_count, std::complex<double> alpha,

DeviceMemory<std::complex<double>> *x, int incx);

// See BlasSupport::DoBlasSwap.

Stream &ThenBlasSwap(uint64 elem_count, DeviceMemory<float> *x, int incx,

DeviceMemory<float> *y, int incy);

Stream &ThenBlasSwap(uint64 elem_count, DeviceMemory<double> *x, int incx,

DeviceMemory<double> *y, int incy);

Stream &ThenBlasSwap(uint64 elem_count, DeviceMemory<std::complex<float>> *x,

int incx, DeviceMemory<std::complex<float>> *y,

int incy);

Stream &ThenBlasSwap(uint64 elem_count, DeviceMemory<std::complex<double>> *x,

int incx, DeviceMemory<std::complex<double>> *y,

int incy);

// See BlasSupport::DoBlasIamax.

Stream &ThenBlasIamax(uint64 elem_count, const DeviceMemory<float> &x,

int incx, DeviceMemory<int> *result);

Stream &ThenBlasIamax(uint64 elem_count, const DeviceMemory<double> &x,

int incx, DeviceMemory<int> *result);

Stream &ThenBlasIamax(uint64 elem_count,

const DeviceMemory<std::complex<float>> &x, int incx,

DeviceMemory<int> *result);

Stream &ThenBlasIamax(uint64 elem_count,

const DeviceMemory<std::complex<double>> &x, int incx,

DeviceMemory<int> *result);

// See BlasSupport::DoBlasIamin.

Stream &ThenBlasIamin(uint64 elem_count, const DeviceMemory<float> &x,

int incx, DeviceMemory<int> *result);

Stream &ThenBlasIamin(uint64 elem_count, const DeviceMemory<double> &x,

int incx, DeviceMemory<int> *result);

Stream &ThenBlasIamin(uint64 elem_count,

const DeviceMemory<std::complex<float>> &x, int incx,

DeviceMemory<int> *result);

Stream &ThenBlasIamin(uint64 elem_count,

const DeviceMemory<std::complex<double>> &x, int incx,

DeviceMemory<int> *result);

// See BlasSupport::DoBlasGbmv.

Stream &ThenBlasGbmv(blas::Transpose trans, uint64 m, uint64 n, uint64 kl,

uint64 ku, float alpha, const DeviceMemory<float> &a,

int lda, const DeviceMemory<float> &x, int incx,

float beta, DeviceMemory<float> *y, int incy);

Stream &ThenBlasGbmv(blas::Transpose trans, uint64 m, uint64 n, uint64 kl,

uint64 ku, double alpha, const DeviceMemory<double> &a,

int lda, const DeviceMemory<double> &x, int incx,

double beta, DeviceMemory<double> *y, int incy);

Stream &ThenBlasGbmv(blas::Transpose trans, uint64 m, uint64 n, uint64 kl,

uint64 ku, std::complex<float> alpha,

const DeviceMemory<std::complex<float>> &a, int lda,

const DeviceMemory<std::complex<float>> &x, int incx,

std::complex<float> beta,

DeviceMemory<std::complex<float>> *y, int incy);

Stream &ThenBlasGbmv(blas::Transpose trans, uint64 m, uint64 n, uint64 kl,

uint64 ku, std::complex<double> alpha,

const DeviceMemory<std::complex<double>> &a, int lda,

const DeviceMemory<std::complex<double>> &x, int incx,

std::complex<double> beta,

DeviceMemory<std::complex<double>> *y, int incy);

// See BlasSupport::DoBlasGemv.

Stream &ThenBlasGemv(blas::Transpose trans, uint64 m, uint64 n, float alpha,

const DeviceMemory<float> &a, int lda,

const DeviceMemory<float> &x, int incx, float beta,

DeviceMemory<float> *y, int incy);

Stream &ThenBlasGemv(blas::Transpose trans, uint64 m, uint64 n, double alpha,

const DeviceMemory<double> &a, int lda,

const DeviceMemory<double> &x, int incx, double beta,

DeviceMemory<double> *y, int incy);

Stream &ThenBlasGemv(blas::Transpose trans, uint64 m, uint64 n,

std::complex<float> alpha,

const DeviceMemory<std::complex<float>> &a, int lda,

const DeviceMemory<std::complex<float>> &x, int incx,

std::complex<float> beta,

DeviceMemory<std::complex<float>> *y, int incy);

Stream &ThenBlasGemv(blas::Transpose trans, uint64 m, uint64 n,

std::complex<double> alpha,

const DeviceMemory<std::complex<double>> &a, int lda,

const DeviceMemory<std::complex<double>> &x, int incx,

std::complex<double> beta,

DeviceMemory<std::complex<double>> *y, int incy);

// See BlasSupport::DoBlasGer.

Stream &ThenBlasGer(uint64 m, uint64 n, float alpha,

const DeviceMemory<float> &x, int incx,

const DeviceMemory<float> &y, int incy,

DeviceMemory<float> *a, int lda);

Stream &ThenBlasGer(uint64 m, uint64 n, double alpha,

const DeviceMemory<double> &x, int incx,

const DeviceMemory<double> &y, int incy,

DeviceMemory<double> *a, int lda);

// See BlasSupport::DoBlasGerc.

Stream &ThenBlasGerc(uint64 m, uint64 n, std::complex<float> alpha,

const DeviceMemory<std::complex<float>> &x, int incx,

const DeviceMemory<std::complex<float>> &y, int incy,

DeviceMemory<std::complex<float>> *a, int lda);

Stream &ThenBlasGerc(uint64 m, uint64 n, std::complex<double> alpha,

const DeviceMemory<std::complex<double>> &x, int incx,

const DeviceMemory<std::complex<double>> &y, int incy,

DeviceMemory<std::complex<double>> *a, int lda);

// See BlasSupport::DoBlasGeru.

Stream &ThenBlasGeru(uint64 m, uint64 n, std::complex<float> alpha,

const DeviceMemory<std::complex<float>> &x, int incx,

const DeviceMemory<std::complex<float>> &y, int incy,

DeviceMemory<std::complex<float>> *a, int lda);

Stream &ThenBlasGeru(uint64 m, uint64 n, std::complex<double> alpha,

const DeviceMemory<std::complex<double>> &x, int incx,

const DeviceMemory<std::complex<double>> &y, int incy,

DeviceMemory<std::complex<double>> *a, int lda);

// See BlasSupport::DoBlasHbmv.

Stream &ThenBlasHbmv(blas::UpperLower uplo, uint64 n, uint64 k,

std::complex<float> alpha,

const DeviceMemory<std::complex<float>> &a, int lda,

const DeviceMemory<std::complex<float>> &x, int incx,

std::complex<float> beta,

DeviceMemory<std::complex<float>> *y, int incy);

Stream &ThenBlasHbmv(blas::UpperLower uplo, uint64 n, uint64 k,

std::complex<double> alpha,

const DeviceMemory<std::complex<double>> &a, int lda,

const DeviceMemory<std::complex<double>> &x, int incx,

std::complex<double> beta,

DeviceMemory<std::complex<double>> *y, int incy);

// See BlasSupport::DoBlasHemv.

Stream &ThenBlasHemv(blas::UpperLower uplo, uint64 n,

std::complex<float> alpha,

const DeviceMemory<std::complex<float>> &a, int lda,

const DeviceMemory<std::complex<float>> &x, int incx,

std::complex<float> beta,

DeviceMemory<std::complex<float>> *y, int incy);

Stream &ThenBlasHemv(blas::UpperLower uplo, uint64 n,

std::complex<double> alpha,

const DeviceMemory<std::complex<double>> &a, int lda,

const DeviceMemory<std::complex<double>> &x, int incx,

std::complex<double> beta,

DeviceMemory<std::complex<double>> *y, int incy);

// See BlasSupport::DoBlasHer.

Stream &ThenBlasHer(blas::UpperLower uplo, uint64 n, float alpha,

const DeviceMemory<std::complex<float>> &x, int incx,

DeviceMemory<std::complex<float>> *a, int lda);

Stream &ThenBlasHer(blas::UpperLower uplo, uint64 n, double alpha,

const DeviceMemory<std::complex<double>> &x, int incx,

DeviceMemory<std::complex<double>> *a, int lda);

// See BlasSupport::DoBlasHer2.

Stream &ThenBlasHer2(blas::UpperLower uplo, uint64 n,

std::complex<float> alpha,

const DeviceMemory<std::complex<float>> &x, int incx,

const DeviceMemory<std::complex<float>> &y, int incy,

DeviceMemory<std::complex<float>> *a, int lda);

Stream &ThenBlasHer2(blas::UpperLower uplo, uint64 n,

std::complex<double> alpha,

const DeviceMemory<std::complex<double>> &x, int incx,

const DeviceMemory<std::complex<double>> &y, int incy,

DeviceMemory<std::complex<double>> *a, int lda);

// See BlasSupport::DoBlasHpmv.

Stream &ThenBlasHpmv(blas::UpperLower uplo, uint64 n,

std::complex<float> alpha,

const DeviceMemory<std::complex<float>> &ap,

const DeviceMemory<std::complex<float>> &x, int incx,

std::complex<float> beta,

DeviceMemory<std::complex<float>> *y, int incy);

Stream &ThenBlasHpmv(blas::UpperLower uplo, uint64 n,

std::complex<double> alpha,

const DeviceMemory<std::complex<double>> &ap,

const DeviceMemory<std::complex<double>> &x, int incx,

std::complex<double> beta,

DeviceMemory<std::complex<double>> *y, int incy);

// See BlasSupport::DoBlasHpr.

Stream &ThenBlasHpr(blas::UpperLower uplo, uint64 n, float alpha,

const DeviceMemory<std::complex<float>> &x, int incx,

DeviceMemory<std::complex<float>> *ap);

Stream &ThenBlasHpr(blas::UpperLower uplo, uint64 n, double alpha,

const DeviceMemory<std::complex<double>> &x, int incx,

DeviceMemory<std::complex<double>> *ap);

// See BlasSupport::DoBlasHpr2.

Stream &ThenBlasHpr2(blas::UpperLower uplo, uint64 n,

std::complex<float> alpha,

const DeviceMemory<std::complex<float>> &x, int incx,

const DeviceMemory<std::complex<float>> &y, int incy,

DeviceMemory<std::complex<float>> *ap);

Stream &ThenBlasHpr2(blas::UpperLower uplo, uint64 n,

std::complex<double> alpha,

const DeviceMemory<std::complex<double>> &x, int incx,

const DeviceMemory<std::complex<double>> &y, int incy,

DeviceMemory<std::complex<double>> *ap);

// See BlasSupport::DoBlasSbmv.

Stream &ThenBlasSbmv(blas::UpperLower uplo, uint64 n, uint64 k, float alpha,

const DeviceMemory<float> &a, int lda,

const DeviceMemory<float> &x, int incx, float beta,

DeviceMemory<float> *y, int incy);

Stream &ThenBlasSbmv(blas::UpperLower uplo, uint64 n, uint64 k, double alpha,

const DeviceMemory<double> &a, int lda,

const DeviceMemory<double> &x, int incx, double beta,

DeviceMemory<double> *y, int incy);

// See BlasSupport::DoBlasSpmv.

Stream &ThenBlasSpmv(blas::UpperLower uplo, uint64 n, float alpha,

const DeviceMemory<float> &ap,

const DeviceMemory<float> &x, int incx, float beta,

DeviceMemory<float> *y, int incy);

Stream &ThenBlasSpmv(blas::UpperLower uplo, uint64 n, double alpha,

const DeviceMemory<double> &ap,

const DeviceMemory<double> &x, int incx, double beta,

DeviceMemory<double> *y, int incy);

// See BlasSupport::DoBlasSpr.

Stream &ThenBlasSpr(blas::UpperLower uplo, uint64 n, float alpha,

const DeviceMemory<float> &x, int incx,

DeviceMemory<float> *ap);

Stream &ThenBlasSpr(blas::UpperLower uplo, uint64 n, double alpha,