49: class Stream : public Print

63:     Stream() {_timeout=1000;}

23: #define Stream_h

2:   Stream.h - base class for character-based streams.

22: #ifndef Stream_h

114:   // Stream and used parseFloat/Int with a custom ignore character. To keep

24: class Stream {

44: class MemoryStream : public Stream {

46:     MemoryStream(void* buffer, size_t size, jobject buf) :

63: class FileStream : public Stream {

65:     FileStream(FILE* fd) : mFd(fd) {}

74: class JavaInputStream : public Stream {

76:     JavaInputStream(JNIEnv* env, jobject inputStream, jbyteArray byteArray) :

87:     const jobject mInputStream;

26:     Stream();

27:     virtual ~Stream();

78:             mInputStream(inputStream),

92: jint JavaStream_OnLoad(JNIEnv* env);

38: class Stream : public Print

53:     Stream() {_timeout=1000;}

23: #define Stream_h

2:   Stream.h - base class for character-based streams.

22: #ifndef Stream_h

31: public interface Stream {

35:    * which the solutions are returned depends on the implementations of {@code Stream} used.

37:   Stream mplus(Stream s2);

44:   Stream bind(Goal goal);

55:   Stream rest();

38: class Stream : public Print

54:     Stream() {_timeout=1000;}

23: #define Stream_h

48:     ~Stream(){}

2:   Stream.h - base class for character-based streams.

22: #ifndef Stream_h

26: public abstract class Stream<T> implements Iterator<T> {

38: class Stream : public Print

53:     Stream() {_timeout=1000;}

23: #define Stream_h

2:   Stream.h - base class for character-based streams.

22: #ifndef Stream_h

69: <p class='vspace'></p><h2>Stream</h2>

5:   <title>Arduino Reference - Stream </title>

70: <p>Stream is the base class for character and binary based streams. It is not called directly, but invoked wh...(44 bytes skipped)...

72: <p class='vspace'></p><p>Stream...(53 bytes skipped)... any core functionality that uses a read() or similar method, you can safely assume it calls on the Stream class. For functions like print(), Stream inherits from the Print class.

74: <p class='vspace'></p><p>Some of the libraries that rely on Stream include : 

82: <ul><li><a class='wikilink' href='StreamAvailable.html'>available</a>()

83: </li><li><a class='wikilink' href='StreamRead.html'>read</a>()

84: </li><li><a class='wikilink' href='StreamFlush.html'>flush</a>()

85: </li><li><a class='wikilink' href='StreamFind.html'>find</a>()

86: </li><li><a class='wikilink' href='StreamFindUntil.html'>findUntil</a>()

87: </li><li><a class='wikilink' href='StreamPeek.html'>peek</a>()

88: </li><li><a class='wikilink' href='StreamReadBytes.html'>readBytes</a>()

89: </li><li><a class='wikilink' href='StreamReadBytesUntil.html'>readBytesUntil</a>()

90: </li><li><a class='wikilink' href='StreamParseInt.html'>parseInt</a>()

91: </li><li><a class='wikilink' href='StreamParseFloat.html'>parsefloat</a>()

92: </li><li><a class='wikilink' href='StreamSetTimeout.html'>setTimeout</a>()<br /><br /><a class='wikilink' href='index.html'>Reference Home</a...(1 bytes skipped)...

26: class Stream : public Print

21: #define Stream_h

2:   Stream.h - base class for character-based streams.

20: #ifndef Stream_h

38: class Stream : public Print

53:     Stream() {_timeout=1000;}

23: #define Stream_h

2:   Stream.h - base class for character-based streams.

22: #ifndef Stream_h

251: Stream::Stream(StreamExecutor *parent)

260: Stream::Stream(StreamExecutor *parent,

270: Stream::~Stream() {

1876: Stream *Stream::GetOrCreateSubStream() {

1923: void Stream::ReturnSubStream(Stream *sub_stream) {

5475: std::string Stream::DebugStreamPointers() const {

209: // there are on Stream and how many parameters they each have.

210: std::string CallStr(const char *function_name, Stream *stream,

217:                                  " Called Stream::", function_name, "(");

287: port::Status Stream::RefreshStatus() {

293: Stream &Stream::Init() {

312: Stream &Stream::InitTimer(Timer *timer) {

323: Stream &Stream::InitWithTimer(Timer *timer) {

329: Stream &Stream::ThenRecordEvent(Event *event) {

342: Stream &Stream::ThenBatchNormalizationForward(

373: Stream &Stream::ThenBatchNormalizationBackward(

398: Stream &Stream::ThenBatchNormalizationForward(

429: Stream &Stream::ThenBatchNormalizationBackward(

456: Stream &Stream::ThenFusedConvolveWithAlgorithm(

494: Stream &Stream::ThenFusedConvolveWithAlgorithm(

532: Stream &Stream::ThenFusedConvolveWithAlgorithm(

571: Stream &Stream::ThenFusedConvolveWithAlgorithm(

609: Stream &Stream::ThenFusedConvolveWithAlgorithm(

647: Stream &Stream::ThenConvolveWithAlgorithm(

689: Stream &Stream::ThenConvolveWithAlgorithm(

731: Stream &Stream::ThenConvolveWithAlgorithm(

773: Stream &Stream::ThenConvolveWithAlgorithm(

815: Stream &Stream::ThenConvolveWithAlgorithm(

857: Stream &Stream::ThenConvolve(

872: Stream &Stream::ThenConvolveQuantized(

902: Stream &Stream::ThenConvolveQuantized(

932: Stream &Stream::ThenSeparableConvolve(

959: Stream &Stream::ThenConvolveBackwardDataWithAlgorithm(

1004: Stream &Stream::ThenConvolveBackwardDataWithAlgorithm(

1049: Stream &Stream::ThenConvolveBackwardDataWithAlgorithm(

1094: Stream &Stream::ThenConvolveBackwardFilterWithAlgorithm(

1139: Stream &Stream::ThenConvolveBackwardFilterWithAlgorithm(

1184: Stream &Stream::ThenConvolveBackwardFilterWithAlgorithm(

1230: Stream &Stream::ThenConvolveBackwardBiasImpl(

1250: Stream &Stream::ThenConvolveBackwardBias(

1259: Stream &Stream::ThenConvolveBackwardBias(

1268: Stream &Stream::ThenConvolveBackwardBias(

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

1296: Stream &Stream::ThenMatMulQuantized(

1318: Stream &Stream::ThenMatMulQuantized(

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

1358: Stream &Stream::ThenPoolForward(

1383: Stream &Stream::ThenPoolForward(

1405: Stream &Stream::ThenPoolForward(

1428: Stream &Stream::ThenPoolForward(

1450: Stream &Stream::ThenPoolBackward(

1480: Stream &Stream::ThenPoolBackward(

1507: Stream &Stream::ThenPoolBackward(

1534: Stream &Stream::ThenNormalizeWithDimensions(

1552: Stream &Stream::ThenNormalizeBackwardWithDimensions(

1576: Stream &Stream::ThenActivate(dnn::ActivationMode activation_mode,

1584: Stream &Stream::ThenActivateWithOptions(dnn::ActivationMode activation_mode,

1603: Stream &Stream::ThenDepthConcatenate(

1633: Stream &Stream::ThenSpaceConcatenate(

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

1698: Stream &Stream::ThenDepthToSpace(

1719: Stream &Stream::ThenSpaceToDepth(

1740: Stream &Stream::ThenElementwiseOperate(

1761: Stream &Stream::ThenElementwiseOperateScaledQuantized(

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

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

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

1842: Stream &Stream::ThenMemcpyD2HQuantized(

1859: Stream &Stream::ThenMemcpyH2DQuantized(

1882:     std::pair<std::unique_ptr<Stream>, bool> &pair = sub_streams_[index];

1885:       Stream *sub_stream = pair.first.get();

1910:   sub_streams_.emplace_back(std::unique_ptr<Stream>{new Stream{parent_}},

1912:   Stream *sub_stream = sub_streams_.back().first.get();

1928:     std::pair<std::unique_ptr<Stream>, bool> &pair = sub_streams_[index];

1958: Stream &Stream::ThenStartTimer(Timer *t) {

1970: Stream &Stream::ThenStopTimer(Timer *t) {

1982: Stream &Stream::ThenWaitFor(Stream *other) {

1996: Stream &Stream::ThenWaitFor(Event *event) {

2018:   // arguments except the first one of Stream* type.

2019:   Stream &operator()(Stream *stream,

2020:                      bool (blas::BlasSupport::*blas_func)(Stream *, Args...),

2027:   Stream &Run(Stream *stream,

2028:               bool (blas::BlasSupport::*blas_func)(Stream *, Args...),

2033: Stream &ThenBlasImpl<Args...>::Run(

2034:     Stream *stream, bool (blas::BlasSupport::*blas_func)(Stream *, Args...),

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

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

2073: Stream &Stream::ThenBlasAsum(uint64 elem_count,

2084: Stream &Stream::ThenBlasAsum(uint64 elem_count,

2095: Stream &Stream::ThenBlasAxpy(uint64 elem_count, float alpha,

2107: Stream &Stream::ThenBlasAxpy(uint64 elem_count, double alpha,

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

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

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

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

2167: Stream &Stream::ThenBlasCopy(uint64 elem_count,

2179: Stream &Stream::ThenBlasCopy(uint64 elem_count,

2191: Stream &Stream::ThenBlasDot(uint64 elem_count, const DeviceMemory<float> &x,

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

2215: Stream &Stream::ThenBlasDotc(uint64 elem_count,

2231: Stream &Stream::ThenBlasDotc(uint64 elem_count,

2247: Stream &Stream::ThenBlasDotu(uint64 elem_count,

2263: Stream &Stream::ThenBlasDotu(uint64 elem_count,

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

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

2299: Stream &Stream::ThenBlasNrm2(uint64 elem_count,

2310: Stream &Stream::ThenBlasNrm2(uint64 elem_count,

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

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

2345: Stream &Stream::ThenBlasRot(uint64 elem_count,

2358: Stream &Stream::ThenBlasRot(uint64 elem_count,

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

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

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

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

2413: Stream &Stream::ThenBlasRotm(uint64 elem_count, DeviceMemory<float> *x,

2425: Stream &Stream::ThenBlasRotm(uint64 elem_count, DeviceMemory<double> *x,

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

2449: Stream &Stream::ThenBlasRotmg(DeviceMemory<double> *d1,

2462: Stream &Stream::ThenBlasScal(uint64 elem_count, float alpha,

2470: Stream &Stream::ThenBlasScal(uint64 elem_count, double alpha,

2478: Stream &Stream::ThenBlasScal(uint64 elem_count, float alpha,

2486: Stream &Stream::ThenBlasScal(uint64 elem_count, double alpha,

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

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

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

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

2532: Stream &Stream::ThenBlasSwap(uint64 elem_count,

2543: Stream &Stream::ThenBlasSwap(uint64 elem_count,

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

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

2574: Stream &Stream::ThenBlasIamax(uint64 elem_count,

2585: Stream &Stream::ThenBlasIamax(uint64 elem_count,

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

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

2616: Stream &Stream::ThenBlasIamin(uint64 elem_count,

2627: Stream &Stream::ThenBlasIamin(uint64 elem_count,

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

3296: Stream &Stream::ThenBlasTbmv(blas::UpperLower uplo, blas::Transpose trans,

3310: Stream &Stream::ThenBlasTbmv(blas::UpperLower uplo, blas::Transpose trans,

3324: Stream &Stream::ThenBlasTbmv(blas::UpperLower uplo, blas::Transpose trans,

3339: Stream &Stream::ThenBlasTbmv(blas::UpperLower uplo, blas::Transpose trans,

3354: Stream &Stream::ThenBlasTbsv(blas::UpperLower uplo, blas::Transpose trans,

3368: Stream &Stream::ThenBlasTbsv(blas::UpperLower uplo, blas::Transpose trans,

3382: Stream &Stream::ThenBlasTbsv(blas::UpperLower uplo, blas::Transpose trans,

3397: Stream &Stream::ThenBlasTbsv(blas::UpperLower uplo, blas::Transpose trans,

3412: Stream &Stream::ThenBlasTpmv(blas::UpperLower uplo, blas::Transpose trans,

3425: Stream &Stream::ThenBlasTpmv(blas::UpperLower uplo, blas::Transpose trans,

3438: Stream &Stream::ThenBlasTpmv(blas::UpperLower uplo, blas::Transpose trans,

3452: Stream &Stream::ThenBlasTpmv(blas::UpperLower uplo, blas::Transpose trans,

3466: Stream &Stream::ThenBlasTpsv(blas::UpperLower uplo, blas::Transpose trans,

3479: Stream &Stream::ThenBlasTpsv(blas::UpperLower uplo, blas::Transpose trans,

3492: Stream &Stream::ThenBlasTpsv(blas::UpperLower uplo, blas::Transpose trans,

3506: Stream &Stream::ThenBlasTpsv(blas::UpperLower uplo, blas::Transpose trans,

3520: Stream &Stream::ThenBlasTrmv(blas::UpperLower uplo, blas::Transpose trans,

3534: Stream &Stream::ThenBlasTrmv(blas::UpperLower uplo, blas::Transpose trans,

3548: Stream &Stream::ThenBlasTrmv(blas::UpperLower uplo, blas::Transpose trans,

3563: Stream &Stream::ThenBlasTrmv(blas::UpperLower uplo, blas::Transpose trans,

3578: Stream &Stream::ThenBlasTrsv(blas::UpperLower uplo, blas::Transpose trans,

3592: Stream &Stream::ThenBlasTrsv(blas::UpperLower uplo, blas::Transpose trans,

3606: Stream &Stream::ThenBlasTrsv(blas::UpperLower uplo, blas::Transpose trans,

3621: Stream &Stream::ThenBlasTrsv(blas::UpperLower uplo, blas::Transpose trans,

3636: Stream &Stream::ThenBlasGemm(blas::Transpose transa, blas::Transpose transb,

3654: Stream &Stream::ThenBlasGemm(blas::Transpose transa, blas::Transpose transb,

3670: Stream &Stream::ThenBlasGemm(blas::Transpose transa, blas::Transpose transb,

3686: Stream &Stream::ThenBlasGemm(blas::Transpose transa, blas::Transpose transb,

3707: Stream &Stream::ThenBlasGemm(blas::Transpose transa, blas::Transpose transb,

3735:   Stream &operator()(Stream *stream,

3737:                          Stream *, Args..., blas::ProfileResult *),

3746: Stream &Stream::ThenBlasGemvWithProfiling(

3763: Stream &Stream::ThenBlasGemvWithProfiling(

3781: Stream &Stream::ThenBlasGemvWithProfiling(

3801: Stream &Stream::ThenBlasGemvWithProfiling(

3821: Stream &Stream::ThenBlasGemmWithProfiling(

3841: Stream &Stream::ThenBlasGemmWithProfiling(

3860: Stream &Stream::ThenBlasGemmWithProfiling(

3880: Stream &Stream::ThenBlasGemmWithProfiling(

3902: Stream &Stream::ThenBlasGemmWithProfiling(

3924: Stream &Stream::ThenBlasGemmWithAlgorithm(

3949: Stream &Stream::ThenBlasGemmWithAlgorithm(

3972: Stream &Stream::ThenBlasGemmWithAlgorithm(

3995: Stream &Stream::ThenBlasGemmWithAlgorithm(

4019: Stream &Stream::ThenBlasGemmWithAlgorithm(

4047: Stream &Stream::ThenBlasGemmWithAlgorithm(

4075: Stream &Stream::ThenBlasHemm(blas::Side side, blas::UpperLower uplo, uint64 m,

4095: Stream &Stream::ThenBlasHemm(blas::Side side, blas::UpperLower uplo, uint64 m,

4115: Stream &Stream::ThenBlasHerk(blas::UpperLower uplo, blas::Transpose trans,

4130: Stream &Stream::ThenBlasHerk(blas::UpperLower uplo, blas::Transpose trans,

4145: Stream &Stream::ThenBlasHer2k(blas::UpperLower uplo, blas::Transpose trans,

4164: Stream &Stream::ThenBlasHer2k(blas::UpperLower uplo, blas::Transpose trans,

4183: Stream &Stream::ThenBlasSymm(blas::Side side, blas::UpperLower uplo, uint64 m,

4199: Stream &Stream::ThenBlasSymm(blas::Side side, blas::UpperLower uplo, uint64 m,

4215: Stream &Stream::ThenBlasSymm(blas::Side side, blas::UpperLower uplo, uint64 m,

4235: Stream &Stream::ThenBlasSymm(blas::Side side, blas::UpperLower uplo, uint64 m,

4255: Stream &Stream::ThenBlasSyrk(blas::UpperLower uplo, blas::Transpose trans,

4269: Stream &Stream::ThenBlasSyrk(blas::UpperLower uplo, blas::Transpose trans,

4283: Stream &Stream::ThenBlasSyrk(blas::UpperLower uplo, blas::Transpose trans,

4299: Stream &Stream::ThenBlasSyrk(blas::UpperLower uplo, blas::Transpose trans,

4315: Stream &Stream::ThenBlasSyr2k(blas::UpperLower uplo, blas::Transpose trans,

4331: Stream &Stream::ThenBlasSyr2k(blas::UpperLower uplo, blas::Transpose trans,

4347: Stream &Stream::ThenBlasSyr2k(blas::UpperLower uplo, blas::Transpose trans,

4367: Stream &Stream::ThenBlasSyr2k(blas::UpperLower uplo, blas::Transpose trans,

4387: Stream &Stream::ThenBlasTrmm(blas::Side side, blas::UpperLower uplo,

4402: Stream &Stream::ThenBlasTrmm(blas::Side side, blas::UpperLower uplo,

4417: Stream &Stream::ThenBlasTrmm(blas::Side side, blas::UpperLower uplo,

4434: Stream &Stream::ThenBlasTrmm(blas::Side side, blas::UpperLower uplo,

4451: Stream &Stream::ThenBlasTrsm(blas::Side side, blas::UpperLower uplo,

4466: Stream &Stream::ThenBlasTrsm(blas::Side side, blas::UpperLower uplo,

4481: Stream &Stream::ThenBlasTrsm(blas::Side side, blas::UpperLower uplo,

4498: Stream &Stream::ThenBlasTrsm(blas::Side side, blas::UpperLower uplo,

4515: Stream &Stream::ThenBlasGemmBatched(

4527: Stream &Stream::ThenBlasGemmBatchedWithScratch(

4549: Stream &Stream::ThenBlasGemmBatched(

4560: Stream &Stream::ThenBlasGemmBatchedWithScratch(

4581: Stream &Stream::ThenBlasGemmBatched(

4592: Stream &Stream::ThenBlasGemmBatchedWithScratch(

4613: Stream &Stream::ThenBlasGemmBatched(

4626: Stream &Stream::ThenBlasGemmBatchedWithScratch(

4652: Stream &Stream::ThenBlasGemmBatched(

4665: Stream &Stream::ThenBlasGemmBatchedWithScratch(

4691: Stream &Stream::ThenBlasGemmStridedBatched(

4712: Stream &Stream::ThenBlasGemmStridedBatched(

4733: Stream &Stream::ThenBlasGemmStridedBatched(

4754: Stream &Stream::ThenBlasGemmStridedBatched(

4777: Stream &Stream::ThenBlasGemmStridedBatched(

4800: Stream &Stream::ThenSetRngSeed(const uint8 *seed, uint64 seed_bytes) {

4818: Stream &Stream::ThenPopulateRandUniform(DeviceMemory<float> *values) {

4834: Stream &Stream::ThenPopulateRandGaussian(float mean, float sd,

4851: Stream &Stream::ThenPopulateRandGaussian(double mean, double sd,

4868: Stream &Stream::ThenPopulateRandUniform(DeviceMemory<double> *values) {

4884: Stream &Stream::ThenPopulateRandUniform(

4901: Stream &Stream::ThenPopulateRandUniform(

4918: Stream &Stream::ThenMemcpy(void *host_dst, const DeviceMemoryBase &gpu_src,

4931: Stream &Stream::ThenMemcpy(DeviceMemoryBase *gpu_dst, const void *host_src,

4944: Stream &Stream::ThenMemcpy(DeviceMemoryBase *gpu_dst,

4957: Stream &Stream::ThenMemZero(DeviceMemoryBase *location, uint64 size) {

4969: Stream &Stream::ThenMemset32(DeviceMemoryBase *location, uint32 pattern,

4983: Stream &Stream::ThenRnnForward(

5020: Stream &Stream::ThenRnnForward(

5056: Stream &Stream::ThenRnnForward(

5093: Stream &Stream::ThenRnnBackward(

5140: Stream &Stream::ThenRnnBackward(

5186: Stream &Stream::ThenRnnBackward(

5233: Stream &Stream::ThenCtcLoss(const dnn::RnnStateTensorDescriptor &probs_desc,

5266: Stream &Stream::ThenTransformTensor(const dnn::BatchDescriptor &input_desc,

5287: Stream &Stream::ThenDoHostCallback(std::function<void()> callback) {

5298: Stream &Stream::ThenDoHostCallbackWithStatus(

5310: Stream &Stream::ThenRunAfterNextBlockHostUntilDone(

5324: Stream &Stream::ThenFft(fft::Plan *plan,

5342: Stream &Stream::ThenFft(fft::Plan *plan,

5360: Stream &Stream::ThenFft(fft::Plan *plan, const DeviceMemory<float> &input,

5377: Stream &Stream::ThenFft(fft::Plan *plan, const DeviceMemory<double> &input,

5394: Stream &Stream::ThenFft(fft::Plan *plan,

5412: Stream &Stream::ThenFft(fft::Plan *plan,

5432: Stream &Stream::ThenEnqueueOnBackgroundThread(

5444: port::Status Stream::BlockHostUntilDone() {

5464: void Stream::RunAfterBlockHostUntilDoneCallbacks() {

5481: void Stream::CheckStatus(port::Status status) {

261:                internal::StreamInterface *implementation)

283:     parent_->DeallocateStream(this);

301:   if (parent_->AllocateStream(this)) {

895:           << "attempting to perform DNN operation using StreamExecutor "

925:           << "attempting to perform DNN operation using StreamExecutor "

1376:           << "attempting to perform DNN operation using StreamExecutor "

1473:           << "attempting to perform DNN operation using StreamExecutor "

1893:       // The stream is reusable and not ok. Streams have a monotonic state

1939:       // The returned stream is not ok. Streams have a monotonic state

2042:           << "attempting to perform BLAS operation using StreamExecutor "

4827:                 << " attempting to perform RNG operation using StreamExecutor"

4844:                 << " attempting to perform RNG operation using StreamExecutor"

4861:                 << " attempting to perform RNG operation using StreamExecutor"

4877:                 << " attempting to perform RNG operation using StreamExecutor"

4894:                 << " attempting to perform RNG operation using StreamExecutor"

4911:                 << " attempting to perform RNG operation using StreamExecutor"

5335:                 << " attempting to perform FFT operation using StreamExecutor"

5353:                 << " attempting to perform FFT operation using StreamExecutor"

5370:                 << " attempting to perform FFT operation using StreamExecutor"

5387:                 << " attempting to perform FFT operation using StreamExecutor"

5405:                 << " attempting to perform FFT operation using StreamExecutor"

5423:                 << " attempting to perform FFT operation using StreamExecutor"

5433:     std::function<void(StreamExecutor *)> task) {

5436:   StreamExecutor *stream_executor = this->parent_;

216:   std::string str = absl::StrCat(stream->DebugStreamPointers(),

253:       implementation_(parent->implementation()->GetStreamImplementation()),

1887:         VLOG(1) << DebugStreamPointers() << " reusing sub_stream "

1888:                 << sub_stream->DebugStreamPointers();

1901:       VLOG(1) << DebugStreamPointers() << " dropped !ok sub_stream "

1902:               << sub_stream->DebugStreamPointers();

1917:   VLOG(1) << DebugStreamPointers() << " created new sub_stream "

1918:           << sub_stream->DebugStreamPointers();

1935:       VLOG(1) << DebugStreamPointers() << " returned ok sub_stream "

1936:               << sub_stream->DebugStreamPointers();

1942:       VLOG(1) << DebugStreamPointers() << " returned !ok sub_stream "

1943:               << sub_stream->DebugStreamPointers();

1953:   LOG(FATAL) << DebugStreamPointers()

1955:              << sub_stream->DebugStreamPointers();

1964:     LOG(INFO) << DebugStreamPointers()

1976:     LOG(INFO) << DebugStreamPointers()

1987:     CheckError(parent_->CreateStreamDependency(this, other));

1990:     LOG(INFO) << DebugStreamPointers() << " did not wait for "

1991:               << other->DebugStreamPointers();

2008:     LOG(INFO) << DebugStreamPointers() << " did not wait for an event.";

4808:       LOG(INFO) << DebugStreamPointers() << " unable to initialize RNG";

4811:     LOG(INFO) << DebugStreamPointers()

4826:       LOG(INFO) << DebugStreamPointers()

4843:       LOG(INFO) << DebugStreamPointers()

4860:       LOG(INFO) << DebugStreamPointers()

4876:       LOG(INFO) << DebugStreamPointers()

4893:       LOG(INFO) << DebugStreamPointers()

4910:       LOG(INFO) << DebugStreamPointers()

4925:     LOG(INFO) << DebugStreamPointers()

4938:     LOG(INFO) << DebugStreamPointers()

4951:     LOG(INFO) << DebugStreamPointers()

4963:     LOG(INFO) << DebugStreamPointers()

4976:     LOG(INFO) << DebugStreamPointers()

5291:     LOG(INFO) << DebugStreamPointers()

5303:     LOG(INFO) << DebugStreamPointers()

5315:     LOG(INFO) << DebugStreamPointers()

5334:       LOG(INFO) << DebugStreamPointers()

5352:       LOG(INFO) << DebugStreamPointers()

5369:       LOG(INFO) << DebugStreamPointers()

5386:       LOG(INFO) << DebugStreamPointers()

5404:       LOG(INFO) << DebugStreamPointers()

5422:       LOG(INFO) << DebugStreamPointers()

5451:     LOG(INFO) << DebugStreamPointers() << " " << status;

731:     Stream("stream", cl::Required,

641: cl::opt<bool> StreamMetadata(

645: cl::opt<bool> StreamDirectory(

649: cl::opt<bool> PdbStream("pdb-stream",

656: cl::opt<bool> DbiStream("dbi-stream",

660: cl::opt<bool> TpiStream("tpi-stream",

664: cl::opt<bool> IpiStream("ipi-stream",

668: cl::opt<bool> PublicsStream("publics-stream",

1356: static void exportStream() {

387:     DumpStreamData("stream-data", cl::CommaSeparated, cl::ZeroOrMore,

454: cl::opt<bool> DumpStreams("streams",

457: cl::opt<bool> DumpStreamBlocks(

591: cl::opt<bool> DumpNamedStreams("named-streams",

368: cl::OptionCategory DbiBytes("Dbi Stream Options");

369: cl::OptionCategory PdbBytes("PDB Stream Options");

650:                         cl::desc("Dump the PDB Stream (Stream 1)"),

657:                         cl::desc("Dump the DBI Stream Headers (Stream 2)"),

661:                         cl::desc("Dump the TPI Stream (Stream 3)"),

665:                         cl::desc("Dump the IPI Stream (Stream 5)"),

669:                             cl::desc("Dump the Publics Stream"),

1064:   auto &Stream = outs();

1066:                             ? Stream.has_colors()

1068:   LinePrinter Printer(2, UseColor, Stream);

1368:     if (to_integer(opts::exportstream::Stream, Index)) {

1381:     Index = ExitOnErr(IS.getNamedStreamIndex(opts::exportstream::Stream));

1382:     outs() << "Dumping contents of stream '" << opts::exportstream::Stream

53: #include "llvm/DebugInfo/PDB/Native/InfoStream.h"

61: #include "llvm/DebugInfo/PDB/Native/TpiStream.h"

75: #include "llvm/Support/BinaryByteStream.h"

713:                clEnumValN(InputFileType::PDBStream, "pdb-stream",

715:                clEnumValN(InputFileType::DBIStream, "dbi-stream",

719:                clEnumValN(InputFileType::ModuleStream, "mod-stream",

773:     ExitOnErr(Builder.getMsfBuilder().addStream(0));

783:   pdb::yaml::PdbInfoStream DefaultInfoStream;

784:   pdb::yaml::PdbDbiStream DefaultDbiStream;

785:   pdb::yaml::PdbTpiStream DefaultTpiStream;

786:   pdb::yaml::PdbTpiStream DefaultIpiStream;

788:   const auto &Info = YamlObj.PdbStream.getValueOr(DefaultInfoStream);

798:   const auto &Dbi = YamlObj.DbiStream.getValueOr(DefaultDbiStream);

814:       const auto &ModiStream = *MI.Modi;

815:       for (auto Symbol : ModiStream.Symbols) {

833:   const auto &Tpi = YamlObj.TpiStream.getValueOr(DefaultTpiStream);

841:   const auto &Ipi = YamlObj.IpiStream.getValueOr(DefaultIpiStream);

1304:     if (File.hasPDBTpiStream()) {

1305:       auto &Tpi = ExitOnErr(File.getPDBTpiStream());

1309:     if (File.hasPDBIpiStream()) {

1310:       auto &Ipi = ExitOnErr(File.getPDBIpiStream());

1322:     ExitOnErr(Builder.getMsfBuilder().addStream(0));

1360:   std::unique_ptr<MappedBlockStream> SourceStream;

1380:     InfoStream &IS = cantFail(File.getPDBInfoStream());

1386:   SourceStream = File.createIndexedStream(Index);

1388:       FileOutputBuffer::create(OutFileName, SourceStream->getLength()));

1389:   FileBufferByteStream DestStream(std::move(OutFile), llvm::support::little);

1390:   BinaryStreamWriter Writer(DestStream);

1391:   ExitOnErr(Writer.writeStreamRef(*SourceStream));

1392:   ExitOnErr(DestStream.commit());

1479:       opts::pdb2yaml::StreamMetadata = true;

1480:       opts::pdb2yaml::StreamDirectory = true;

1481:       opts::pdb2yaml::PdbStream = true;

1483:       opts::pdb2yaml::DbiStream = true;

1484:       opts::pdb2yaml::TpiStream = true;

1485:       opts::pdb2yaml::IpiStream = true;

1486:       opts::pdb2yaml::PublicsStream = true;

1499:       opts::pdb2yaml::DbiStream = true;

1566:     exportStream();

45: #include "llvm/DebugInfo/CodeView/TypeStreamMerger.h"

52: #include "llvm/DebugInfo/PDB/Native/DbiStreamBuilder.h"

54: #include "llvm/DebugInfo/PDB/Native/InfoStreamBuilder.h"

62: #include "llvm/DebugInfo/PDB/Native/TpiStreamBuilder.h"

772:   for (uint32_t I = 0; I < kSpecialStreamCount; ++I)

1321:   for (uint32_t I = 0; I < kSpecialStreamCount; ++I)

1369:       if (Index >= File.getNumStreams()) {

1463:       opts::dump::DumpStreams = true;

1464:       opts::dump::DumpStreamBlocks = true;

236: Stream::Stream(StreamExecutor *parent)

245: Stream::Stream(StreamExecutor *parent,

255: Stream::~Stream() {

1793: Stream *Stream::GetOrCreateSubStream() {

1810: void Stream::ReturnSubStream(Stream *sub_stream) {

195: // there are on Stream and how many parameters they each have.

196: string CallStr(const char *function_name, Stream *stream,

202:   string str = port::StrCat("Called Stream::", function_name, "(");

265: Stream &Stream::Init() {

284: Stream &Stream::InitTimer(Timer *timer) {

295: Stream &Stream::InitWithTimer(Timer *timer) {

301: Stream &Stream::ThenRecordEvent(Event *event) {

314: Stream &Stream::ThenBatchNormalizationForward(

342: Stream &Stream::ThenBatchNormalizationBackward(

364: Stream &Stream::ThenBatchNormalizationForward(

392: Stream &Stream::ThenBatchNormalizationBackward(

415: Stream &Stream::ThenFusedConvolveWithScratch(

448: Stream &Stream::ThenFusedConvolveWithScratch(

482: Stream &Stream::ThenFusedConvolveWithScratch(

515: Stream &Stream::ThenConvolveWithScratch(

542: Stream &Stream::ThenConvolveWithScratch(

569: Stream &Stream::ThenFusedConvolveWithAlgorithm(

607: Stream &Stream::ThenFusedConvolveWithAlgorithm(

646: Stream &Stream::ThenFusedConvolveWithAlgorithm(

684: Stream &Stream::ThenConvolveWithAlgorithm(

715: Stream &Stream::ThenConvolveWithAlgorithm(

746: Stream &Stream::ThenFusedConvolve(

764: Stream &Stream::ThenConvolve(

778: Stream &Stream::ThenConvolveQuantized(

808: Stream &Stream::ThenConvolveQuantized(

838: Stream &Stream::ThenSeparableConvolve(

865: Stream &Stream::ThenConvolveBackwardDataWithScratch(

893: Stream &Stream::ThenConvolveBackwardDataWithAlgorithm(

926: Stream &Stream::ThenConvolveBackwardDataWithAlgorithm(

959: Stream &Stream::ThenConvolveBackwardDataWithScratch(

987: Stream &Stream::ThenConvolveBackwardData(

1001: Stream &Stream::ThenConvolveBackwardFilterWithScratch(

1029: Stream &Stream::ThenConvolveBackwardFilterWithAlgorithm(

1062: Stream &Stream::ThenConvolveBackwardFilterWithScratch(

1090: Stream &Stream::ThenConvolveBackwardFilterWithAlgorithm(

1123: Stream &Stream::ThenConvolveBackwardFilter(

1138: Stream &Stream::ThenConvolveBackwardBiasImpl(

1158: Stream &Stream::ThenConvolveBackwardBias(

1167: Stream &Stream::ThenConvolveBackwardBias(

1176: Stream &Stream::ThenConvolveBackwardBias(

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

1204: Stream &Stream::ThenMatMulQuantized(

1226: Stream &Stream::ThenMatMulQuantized(

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

1266: Stream &Stream::ThenPoolForward(

1290: Stream &Stream::ThenPoolForward(

1311: Stream &Stream::ThenPoolForward(

1332: Stream &Stream::ThenPoolBackward(

1359: Stream &Stream::ThenPoolBackward(

1383: Stream &Stream::ThenPoolBackward(

1407: Stream &Stream::ThenNormalize(

1423: Stream &Stream::ThenNormalizeWithDimensions(

1441: Stream &Stream::ThenNormalizeBackwardWithDimensions(

1463: Stream &Stream::ThenActivate(dnn::ActivationMode activation_mode,

1471: Stream &Stream::ThenActivateWithOptions(dnn::ActivationMode activation_mode,

1490: Stream &Stream::ThenDepthConcatenate(

1520: Stream &Stream::ThenSpaceConcatenate(

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

1585: Stream &Stream::ThenDepthToSpace(

1606: Stream &Stream::ThenSpaceToDepth(

1627: Stream &Stream::ThenElementwiseOperate(

1648: Stream &Stream::ThenElementwiseOperateScaledQuantized(

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

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

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

1729: Stream &Stream::ThenMemcpyD2HQuantized(

1746: Stream &Stream::ThenMemcpyH2DQuantized(

1763: Stream &Stream::ThenCopyHostBuffer2Device(

1778: Stream &Stream::ThenCopyDevice2HostBuffer(

1801:   sub_streams_.emplace_back(std::unique_ptr<Stream>{new Stream{parent_}},

1803:   Stream *sub_stream = sub_streams_.back().first.get();

1821: Stream &Stream::ThenStartTimer(Timer *t) {

1832: Stream &Stream::ThenStopTimer(Timer *t) {

1843: Stream &Stream::ThenWaitFor(Stream *other) {

1856: Stream &Stream::ThenWaitFor(Event *event) {

1878:   // arguments except the first one of Stream* type.

1879:   Stream &operator()(Stream *stream,

1880:                      bool (blas::BlasSupport::*blas_func)(Stream *, Args...),

1887:   Stream &Run(Stream *stream,

1888:               bool (blas::BlasSupport::*blas_func)(Stream *, Args...),

1893: Stream &ThenBlasImpl<Args...>::Run(

1894:     Stream *stream, bool (blas::BlasSupport::*blas_func)(Stream *, Args...),

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

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

1933: Stream &Stream::ThenBlasAsum(uint64 elem_count,

1944: Stream &Stream::ThenBlasAsum(uint64 elem_count,

1955: Stream &Stream::ThenBlasAxpy(uint64 elem_count, float alpha,

1967: Stream &Stream::ThenBlasAxpy(uint64 elem_count, double alpha,

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

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

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

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

2027: Stream &Stream::ThenBlasCopy(uint64 elem_count,

2039: Stream &Stream::ThenBlasCopy(uint64 elem_count,

2051: Stream &Stream::ThenBlasDot(uint64 elem_count, const DeviceMemory<float> &x,

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

2075: Stream &Stream::ThenBlasDotc(uint64 elem_count,

2091: Stream &Stream::ThenBlasDotc(uint64 elem_count,

2107: Stream &Stream::ThenBlasDotu(uint64 elem_count,

2123: Stream &Stream::ThenBlasDotu(uint64 elem_count,

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

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

2159: Stream &Stream::ThenBlasNrm2(uint64 elem_count,

2170: Stream &Stream::ThenBlasNrm2(uint64 elem_count,

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

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

2205: Stream &Stream::ThenBlasRot(uint64 elem_count,

2218: Stream &Stream::ThenBlasRot(uint64 elem_count,

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

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

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

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

2273: Stream &Stream::ThenBlasRotm(uint64 elem_count, DeviceMemory<float> *x,

2285: Stream &Stream::ThenBlasRotm(uint64 elem_count, DeviceMemory<double> *x,

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

2309: Stream &Stream::ThenBlasRotmg(DeviceMemory<double> *d1,

2322: Stream &Stream::ThenBlasScal(uint64 elem_count, float alpha,

2330: Stream &Stream::ThenBlasScal(uint64 elem_count, double alpha,

2338: Stream &Stream::ThenBlasScal(uint64 elem_count, float alpha,

2346: Stream &Stream::ThenBlasScal(uint64 elem_count, double alpha,

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

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

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

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

2392: Stream &Stream::ThenBlasSwap(uint64 elem_count,

2403: Stream &Stream::ThenBlasSwap(uint64 elem_count,

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

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

2434: Stream &Stream::ThenBlasIamax(uint64 elem_count,

2445: Stream &Stream::ThenBlasIamax(uint64 elem_count,

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

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

2476: Stream &Stream::ThenBlasIamin(uint64 elem_count,

2487: Stream &Stream::ThenBlasIamin(uint64 elem_count,

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

3156: Stream &Stream::ThenBlasTbmv(blas::UpperLower uplo, blas::Transpose trans,

3170: Stream &Stream::ThenBlasTbmv(blas::UpperLower uplo, blas::Transpose trans,

3184: Stream &Stream::ThenBlasTbmv(blas::UpperLower uplo, blas::Transpose trans,

3199: Stream &Stream::ThenBlasTbmv(blas::UpperLower uplo, blas::Transpose trans,

3214: Stream &Stream::ThenBlasTbsv(blas::UpperLower uplo, blas::Transpose trans,

3228: Stream &Stream::ThenBlasTbsv(blas::UpperLower uplo, blas::Transpose trans,

3242: Stream &Stream::ThenBlasTbsv(blas::UpperLower uplo, blas::Transpose trans,

3257: Stream &Stream::ThenBlasTbsv(blas::UpperLower uplo, blas::Transpose trans,

3272: Stream &Stream::ThenBlasTpmv(blas::UpperLower uplo, blas::Transpose trans,

3285: Stream &Stream::ThenBlasTpmv(blas::UpperLower uplo, blas::Transpose trans,

3298: Stream &Stream::ThenBlasTpmv(blas::UpperLower uplo, blas::Transpose trans,

3312: Stream &Stream::ThenBlasTpmv(blas::UpperLower uplo, blas::Transpose trans,

3326: Stream &Stream::ThenBlasTpsv(blas::UpperLower uplo, blas::Transpose trans,

3339: Stream &Stream::ThenBlasTpsv(blas::UpperLower uplo, blas::Transpose trans,

3352: Stream &Stream::ThenBlasTpsv(blas::UpperLower uplo, blas::Transpose trans,

3366: Stream &Stream::ThenBlasTpsv(blas::UpperLower uplo, blas::Transpose trans,

3380: Stream &Stream::ThenBlasTrmv(blas::UpperLower uplo, blas::Transpose trans,

3394: Stream &Stream::ThenBlasTrmv(blas::UpperLower uplo, blas::Transpose trans,

3408: Stream &Stream::ThenBlasTrmv(blas::UpperLower uplo, blas::Transpose trans,

3423: Stream &Stream::ThenBlasTrmv(blas::UpperLower uplo, blas::Transpose trans,

3438: Stream &Stream::ThenBlasTrsv(blas::UpperLower uplo, blas::Transpose trans,

3452: Stream &Stream::ThenBlasTrsv(blas::UpperLower uplo, blas::Transpose trans,

3466: Stream &Stream::ThenBlasTrsv(blas::UpperLower uplo, blas::Transpose trans,

3481: Stream &Stream::ThenBlasTrsv(blas::UpperLower uplo, blas::Transpose trans,

3496: Stream &Stream::ThenBlasGemm(blas::Transpose transa, blas::Transpose transb,

3514: Stream &Stream::ThenBlasGemm(blas::Transpose transa, blas::Transpose transb,

3530: Stream &Stream::ThenBlasGemm(blas::Transpose transa, blas::Transpose transb,

3546: Stream &Stream::ThenBlasGemm(blas::Transpose transa, blas::Transpose transb,

3567: Stream &Stream::ThenBlasGemm(blas::Transpose transa, blas::Transpose transb,

3595:   Stream &operator()(Stream *stream,

3597:                          Stream *, Args..., blas::ProfileResult *),

3606: Stream &Stream::ThenBlasGemvWithProfiling(

3623: Stream &Stream::ThenBlasGemvWithProfiling(

3641: Stream &Stream::ThenBlasGemvWithProfiling(

3661: Stream &Stream::ThenBlasGemvWithProfiling(

3681: Stream &Stream::ThenBlasGemmWithProfiling(

3701: Stream &Stream::ThenBlasGemmWithProfiling(

3720: Stream &Stream::ThenBlasGemmWithProfiling(

3740: Stream &Stream::ThenBlasGemmWithProfiling(

3762: Stream &Stream::ThenBlasGemmWithProfiling(

3784: Stream &Stream::ThenBlasGemmWithAlgorithm(

3808: Stream &Stream::ThenBlasGemmWithAlgorithm(

3829: Stream &Stream::ThenBlasGemmWithAlgorithm(

3850: Stream &Stream::ThenBlasGemmWithAlgorithm(

3872: Stream &Stream::ThenBlasGemmWithAlgorithm(

3897: Stream &Stream::ThenBlasGemmWithAlgorithm(

3922: Stream &Stream::ThenBlasHemm(blas::Side side, blas::UpperLower uplo, uint64 m,

3942: Stream &Stream::ThenBlasHemm(blas::Side side, blas::UpperLower uplo, uint64 m,

3962: Stream &Stream::ThenBlasHerk(blas::UpperLower uplo, blas::Transpose trans,

3977: Stream &Stream::ThenBlasHerk(blas::UpperLower uplo, blas::Transpose trans,

3992: Stream &Stream::ThenBlasHer2k(blas::UpperLower uplo, blas::Transpose trans,

4011: Stream &Stream::ThenBlasHer2k(blas::UpperLower uplo, blas::Transpose trans,

4030: Stream &Stream::ThenBlasSymm(blas::Side side, blas::UpperLower uplo, uint64 m,

4046: Stream &Stream::ThenBlasSymm(blas::Side side, blas::UpperLower uplo, uint64 m,

4062: Stream &Stream::ThenBlasSymm(blas::Side side, blas::UpperLower uplo, uint64 m,

4082: Stream &Stream::ThenBlasSymm(blas::Side side, blas::UpperLower uplo, uint64 m,

4102: Stream &Stream::ThenBlasSyrk(blas::UpperLower uplo, blas::Transpose trans,

4116: Stream &Stream::ThenBlasSyrk(blas::UpperLower uplo, blas::Transpose trans,

4130: Stream &Stream::ThenBlasSyrk(blas::UpperLower uplo, blas::Transpose trans,

4146: Stream &Stream::ThenBlasSyrk(blas::UpperLower uplo, blas::Transpose trans,

4162: Stream &Stream::ThenBlasSyr2k(blas::UpperLower uplo, blas::Transpose trans,

4178: Stream &Stream::ThenBlasSyr2k(blas::UpperLower uplo, blas::Transpose trans,

4194: Stream &Stream::ThenBlasSyr2k(blas::UpperLower uplo, blas::Transpose trans,

4214: Stream &Stream::ThenBlasSyr2k(blas::UpperLower uplo, blas::Transpose trans,

4234: Stream &Stream::ThenBlasTrmm(blas::Side side, blas::UpperLower uplo,

4249: Stream &Stream::ThenBlasTrmm(blas::Side side, blas::UpperLower uplo,

4264: Stream &Stream::ThenBlasTrmm(blas::Side side, blas::UpperLower uplo,

4281: Stream &Stream::ThenBlasTrmm(blas::Side side, blas::UpperLower uplo,

4298: Stream &Stream::ThenBlasTrsm(blas::Side side, blas::UpperLower uplo,

4313: Stream &Stream::ThenBlasTrsm(blas::Side side, blas::UpperLower uplo,

4328: Stream &Stream::ThenBlasTrsm(blas::Side side, blas::UpperLower uplo,

4345: Stream &Stream::ThenBlasTrsm(blas::Side side, blas::UpperLower uplo,

4362: Stream &Stream::ThenBlasGemmBatched(

4373: Stream &Stream::ThenBlasGemmBatchedWithScratch(

4394: Stream &Stream::ThenBlasGemmBatched(

4405: Stream &Stream::ThenBlasGemmBatchedWithScratch(

4426: Stream &Stream::ThenBlasGemmBatched(

4439: Stream &Stream::ThenBlasGemmBatchedWithScratch(

4465: Stream &Stream::ThenBlasGemmBatched(

4478: Stream &Stream::ThenBlasGemmBatchedWithScratch(

4504: Stream &Stream::ThenSetRngSeed(const uint8 *seed, uint64 seed_bytes) {

4522: Stream &Stream::ThenPopulateRandUniform(DeviceMemory<float> *values) {

4537: Stream &Stream::ThenPopulateRandGaussian(float mean, float sd,

4553: Stream &Stream::ThenPopulateRandGaussian(double mean, double sd,

4569: Stream &Stream::ThenPopulateRandUniform(DeviceMemory<double> *values) {

4584: Stream &Stream::ThenPopulateRandUniform(

4600: Stream &Stream::ThenPopulateRandUniform(

4617: Stream &Stream::ThenMemcpy(void *host_dst, const DeviceMemoryBase &gpu_src,

4630: Stream &Stream::ThenMemcpy(DeviceMemoryBase *gpu_dst, const void *host_src,

4643: Stream &Stream::ThenMemcpy(DeviceMemoryBase *gpu_dst,

4656: Stream &Stream::ThenMemZero(DeviceMemoryBase *location, uint64 size) {

4668: Stream &Stream::ThenMemset32(DeviceMemoryBase *location, uint32 pattern,

4682: Stream &Stream::ThenRnnForward(

4714: Stream &Stream::ThenRnnForward(

4747: Stream &Stream::ThenRnnBackward(

4788: Stream &Stream::ThenRnnBackward(

4830: Stream &Stream::ThenTransformTensor(const dnn::BatchDescriptor &input_desc,

4851: Stream &Stream::ThenDoHostCallbackForTest(std::function<void()> callback) {

4857: Stream &Stream::ThenDoHostCallback(std::function<void()> callback) {

4869: Stream &Stream::ThenFft(fft::Plan *plan,

4886: Stream &Stream::ThenFft(fft::Plan *plan,

4903: Stream &Stream::ThenFft(fft::Plan *plan, const DeviceMemory<float> &input,

4919: Stream &Stream::ThenFft(fft::Plan *plan, const DeviceMemory<double> &input,

4935: Stream &Stream::ThenFft(fft::Plan *plan,

4952: Stream &Stream::ThenFft(fft::Plan *plan,

4971: Stream &Stream::ThenEnqueueOnBackgroundThread(

4983: bool Stream::BlockHostUntilDone() {

246:                internal::StreamInterface *implementation)

261:     parent_->DeallocateStream(this);

273:   if (parent_->AllocateStream(this)) {

801:           << "attempting to perform DNN operation using StreamExecutor "

831:           << "attempting to perform DNN operation using StreamExecutor "

1283:           << "attempting to perform DNN operation using StreamExecutor "

1352:           << "attempting to perform DNN operation using StreamExecutor "

1902:           << "attempting to perform BLAS operation using StreamExecutor "

4530:       LOG(INFO) << "attempting to perform RNG operation using StreamExecutor "

4546:       LOG(INFO) << "attempting to perform RNG operation using StreamExecutor "

4562:       LOG(INFO) << "attempting to perform RNG operation using StreamExecutor "

4577:       LOG(INFO) << "attempting to perform RNG operation using StreamExecutor "

4593:       LOG(INFO) << "attempting to perform RNG operation using StreamExecutor "

4610:                 << " attempting to perform RNG operation using StreamExecutor "

4879:       LOG(INFO) << "attempting to perform FFT operation using StreamExecutor "

4896:       LOG(INFO) << "attempting to perform FFT operation using StreamExecutor "

4912:       LOG(INFO) << "attempting to perform FFT operation using StreamExecutor "

4928:       LOG(INFO) << "attempting to perform FFT operation using StreamExecutor "

4945:       LOG(INFO) << "attempting to perform FFT operation using StreamExecutor "

4962:       LOG(INFO) << "attempting to perform FFT operation using StreamExecutor "

4972:     std::function<void(StreamExecutor *)> task) {

4975:   StreamExecutor *stream_executor = this->parent_;

238:       implementation_(parent->implementation()->GetStreamImplementation()),

1848:     CheckError(parent_->CreateStreamDependency(this, other));

252: Stream::Stream(StreamExecutor *parent)

261: Stream::Stream(StreamExecutor *parent,

271: Stream::~Stream() {

1965: Stream *Stream::GetOrCreateSubStream() {

2012: void Stream::ReturnSubStream(Stream *sub_stream) {

5504: string Stream::DebugStreamPointers() const {

210: // there are on Stream and how many parameters they each have.

211: string CallStr(const char *function_name, Stream *stream,

218:                             " Called Stream::", function_name, "(");

287: Stream &Stream::Init() {

306: Stream &Stream::InitTimer(Timer *timer) {

317: Stream &Stream::InitWithTimer(Timer *timer) {

323: Stream &Stream::ThenRecordEvent(Event *event) {

336: Stream &Stream::ThenBatchNormalizationForward(

364: Stream &Stream::ThenBatchNormalizationBackward(

386: Stream &Stream::ThenBatchNormalizationForward(

414: Stream &Stream::ThenBatchNormalizationBackward(

437: Stream &Stream::ThenFusedConvolveWithScratch(

470: Stream &Stream::ThenFusedConvolveWithScratch(

504: Stream &Stream::ThenFusedConvolveWithScratch(

537: Stream &Stream::ThenConvolveWithScratch(

564: Stream &Stream::ThenConvolveWithScratch(

591: Stream &Stream::ThenFusedConvolveWithAlgorithm(

629: Stream &Stream::ThenFusedConvolveWithAlgorithm(

667: Stream &Stream::ThenFusedConvolveWithAlgorithm(

706: Stream &Stream::ThenFusedConvolveWithAlgorithm(

744: Stream &Stream::ThenConvolveWithAlgorithm(

775: Stream &Stream::ThenConvolveWithAlgorithm(

806: Stream &Stream::ThenConvolveWithAlgorithm(

837: Stream &Stream::ThenFusedConvolve(

855: Stream &Stream::ThenConvolve(

869: Stream &Stream::ThenConvolveQuantized(

899: Stream &Stream::ThenConvolveQuantized(

929: Stream &Stream::ThenSeparableConvolve(

956: Stream &Stream::ThenConvolveBackwardDataWithScratch(

984: Stream &Stream::ThenConvolveBackwardDataWithAlgorithm(

1017: Stream &Stream::ThenConvolveBackwardDataWithAlgorithm(

1050: Stream &Stream::ThenConvolveBackwardDataWithAlgorithm(

1083: Stream &Stream::ThenConvolveBackwardDataWithScratch(

1111: Stream &Stream::ThenConvolveBackwardData(

1125: Stream &Stream::ThenConvolveBackwardFilterWithScratch(

1153: Stream &Stream::ThenConvolveBackwardFilterWithAlgorithm(

1186: Stream &Stream::ThenConvolveBackwardFilterWithAlgorithm(

1219: Stream &Stream::ThenConvolveBackwardFilterWithScratch(

1247: Stream &Stream::ThenConvolveBackwardFilterWithAlgorithm(

1280: Stream &Stream::ThenConvolveBackwardFilter(

1295: Stream &Stream::ThenConvolveBackwardBiasImpl(

1315: Stream &Stream::ThenConvolveBackwardBias(

1324: Stream &Stream::ThenConvolveBackwardBias(

1333: Stream &Stream::ThenConvolveBackwardBias(

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

1361: Stream &Stream::ThenMatMulQuantized(

1383: Stream &Stream::ThenMatMulQuantized(

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

1423: Stream &Stream::ThenPoolForward(

1448: Stream &Stream::ThenPoolForward(

1470: Stream &Stream::ThenPoolForward(

1493: Stream &Stream::ThenPoolBackward(

1523: Stream &Stream::ThenPoolBackward(

1550: Stream &Stream::ThenPoolBackward(

1577: Stream &Stream::ThenNormalize(

1593: Stream &Stream::ThenNormalizeWithDimensions(

1611: Stream &Stream::ThenNormalizeBackwardWithDimensions(

1635: Stream &Stream::ThenActivate(dnn::ActivationMode activation_mode,

1643: Stream &Stream::ThenActivateWithOptions(dnn::ActivationMode activation_mode,

1662: Stream &Stream::ThenDepthConcatenate(

1692: Stream &Stream::ThenSpaceConcatenate(

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

1757: Stream &Stream::ThenDepthToSpace(

1778: Stream &Stream::ThenSpaceToDepth(

1799: Stream &Stream::ThenElementwiseOperate(

1820: Stream &Stream::ThenElementwiseOperateScaledQuantized(

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

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

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

1901: Stream &Stream::ThenMemcpyD2HQuantized(

1918: Stream &Stream::ThenMemcpyH2DQuantized(

1935: Stream &Stream::ThenCopyHostBuffer2Device(

1950: Stream &Stream::ThenCopyDevice2HostBuffer(

1971:     std::pair<std::unique_ptr<Stream>, bool> &pair = sub_streams_[index];

1974:       Stream *sub_stream = pair.first.get();

1999:   sub_streams_.emplace_back(std::unique_ptr<Stream>{new Stream{parent_}},

2001:   Stream *sub_stream = sub_streams_.back().first.get();

2017:     std::pair<std::unique_ptr<Stream>, bool> &pair = sub_streams_[index];

2047: Stream &Stream::ThenStartTimer(Timer *t) {

2059: Stream &Stream::ThenStopTimer(Timer *t) {

2071: Stream &Stream::ThenWaitFor(Stream *other) {

2085: Stream &Stream::ThenWaitFor(Event *event) {

2107:   // arguments except the first one of Stream* type.

2108:   Stream &operator()(Stream *stream,

2109:                      bool (blas::BlasSupport::*blas_func)(Stream *, Args...),

2116:   Stream &Run(Stream *stream,

2117:               bool (blas::BlasSupport::*blas_func)(Stream *, Args...),

2122: Stream &ThenBlasImpl<Args...>::Run(

2123:     Stream *stream, bool (blas::BlasSupport::*blas_func)(Stream *, Args...),

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

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

2162: Stream &Stream::ThenBlasAsum(uint64 elem_count,

2173: Stream &Stream::ThenBlasAsum(uint64 elem_count,

2184: Stream &Stream::ThenBlasAxpy(uint64 elem_count, float alpha,

2196: Stream &Stream::ThenBlasAxpy(uint64 elem_count, double alpha,

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

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

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

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

2256: Stream &Stream::ThenBlasCopy(uint64 elem_count,

2268: Stream &Stream::ThenBlasCopy(uint64 elem_count,

2280: Stream &Stream::ThenBlasDot(uint64 elem_count, const DeviceMemory<float> &x,

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

2304: Stream &Stream::ThenBlasDotc(uint64 elem_count,

2320: Stream &Stream::ThenBlasDotc(uint64 elem_count,

2336: Stream &Stream::ThenBlasDotu(uint64 elem_count,

2352: Stream &Stream::ThenBlasDotu(uint64 elem_count,

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

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

2388: Stream &Stream::ThenBlasNrm2(uint64 elem_count,

2399: Stream &Stream::ThenBlasNrm2(uint64 elem_count,

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

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

2434: Stream &Stream::ThenBlasRot(uint64 elem_count,

2447: Stream &Stream::ThenBlasRot(uint64 elem_count,

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

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

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

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

2502: Stream &Stream::ThenBlasRotm(uint64 elem_count, DeviceMemory<float> *x,

2514: Stream &Stream::ThenBlasRotm(uint64 elem_count, DeviceMemory<double> *x,

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

2538: Stream &Stream::ThenBlasRotmg(DeviceMemory<double> *d1,

2551: Stream &Stream::ThenBlasScal(uint64 elem_count, float alpha,

2559: Stream &Stream::ThenBlasScal(uint64 elem_count, double alpha,

2567: Stream &Stream::ThenBlasScal(uint64 elem_count, float alpha,

2575: Stream &Stream::ThenBlasScal(uint64 elem_count, double alpha,

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

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

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

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

2621: Stream &Stream::ThenBlasSwap(uint64 elem_count,

2632: Stream &Stream::ThenBlasSwap(uint64 elem_count,

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

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

2663: Stream &Stream::ThenBlasIamax(uint64 elem_count,

2674: Stream &Stream::ThenBlasIamax(uint64 elem_count,

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

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

2705: Stream &Stream::ThenBlasIamin(uint64 elem_count,

2716: Stream &Stream::ThenBlasIamin(uint64 elem_count,

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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