96: class Stream {

765: class ASCII85Stream: public FilterStream {

51: enum StreamKind {

67: enum StreamColorSpaceMode {

222:   virtual Stream *getNextStream() { return nullptr; }

249: class OutStream {

275: class FileOutStream : public OutStream {

301: class BaseStream: public Stream {

312:   BaseStream *getBaseStream() override { return this; }

313:   Stream *getUndecodedStream() override { return this; }

335: class FilterStream: public Stream {

343:   BaseStream *getBaseStream() override { return str->getBaseStream(); }

344:   Stream *getUndecodedStream() override { return str->getUndecodedStream(); }

347:   Stream *getNextStream() override { return str; }

361: class ImageStream {

408: class StreamPredictor {

450: class FileStream: public BaseStream {

525: class CachedFileStream: public BaseStream {

570: class BaseMemStream: public BaseStream {

573:   BaseMemStream(T *bufA, Goffset startA, Goffset lengthA, Object &&dictA) : BaseStream(std::move(dictA), lengthA) {

585:   Stream *makeSubStream(Goffset startA, bool limited, Goffset lengthA, Object &&dictA) override {

668: class MemStream : public BaseMemStream<const char>

671:   MemStream(const char *bufA, Goffset startA, Goffset lengthA, Object &&dictA)

676: class AutoFreeMemStream : public BaseMemStream<char>

679:   AutoFreeMemStream(char *bufA, Goffset startA, Goffset lengthA, Object &&dictA)

683:   ~AutoFreeMemStream()

698: class EmbedStream: public BaseStream {

742: class ASCIIHexStream: public FilterStream {

790: class LZWStream: public FilterStream {

850: class RunLengthStream: public FilterStream {

883: class CCITTFaxStream: public FilterStream {

971: class DCTStream: public FilterStream {

1078: class FlateStream: public FilterStream {

1153: class EOFStream: public FilterStream {

1170: class BufStream: public FilterStream {

448: #define fileStreamBufSize 256

523: #define cachedStreamBufSize 1024

3: // Stream.h

76: // This is in Stream.h instead of Decrypt.h to avoid really annoying

93: // Stream (base class)

100:   Stream();

103:   virtual ~Stream();

105:   Stream(const Stream &) = delete;

106:   Stream& operator=(const Stream &other) = delete;

208:   virtual Stream *getUndecodedStream() = 0;

226:   Stream *addFilters(Dict *dict, int recursion = 0);

238:   Stream *makeFilter(const char *name, Stream *str, Object *params, int recursion = 0, Dict *dict = nullptr);

308:   virtual Stream *makeSubStream(Goffset start, bool limited,

338:   FilterStream(Stream *strA);

354:   Stream *str;

367:   ImageStream(Stream *strA, int widthA, int nCompsA, int nBitsA);

393:   Stream *str;			// base stream

413:   StreamPredictor(Stream *strA, int predictorA,

431:   Stream *str;			// base stream

457:   Stream *makeSubStream(Goffset startA, bool limitedA,

532:   Stream *makeSubStream(Goffset startA, bool limitedA,

701:   EmbedStream(Stream *strA, Object &&dictA, bool limitedA, Goffset lengthA, bool reusableA = false);

704:   Stream *makeSubStream(Goffset start, bool limitedA,

726:   Stream *str;

745:   ASCIIHexStream(Stream *strA);

762: // ASCII85Stream

768:   ASCII85Stream(Stream *strA);

769:   ~ASCII85Stream();

793:   LZWStream(Stream *strA, int predictor, int columns, int colors,

853:   RunLengthStream(Stream *strA);

886:   CCITTFaxStream(Stream *strA, int encodingA, bool endOfLineA,

974:   DCTStream(Stream *strA, int colorXformA, Dict *dict, int recursion);

1081:   FlateStream(Stream *strA, int predictor, int columns,

1156:   EOFStream(Stream *strA);

1173:   BufStream(Stream *strA, int bufSizeA);

1198:   FixedLengthEncoder(Stream *strA, int lengthA);

1221:   ASCIIHexEncoder(Stream *strA);

1251:   ASCII85Encoder(Stream *strA);

1281:   RunLengthEncoder(Stream *strA);

1317:   LZWEncoder(Stream *strA);

1349:   CMYKGrayEncoder(Stream *strA);

1378:   RGBGrayEncoder(Stream *strA);

46: class BaseStream;

109:   virtual StreamKind getKind() = 0;

174:   // This is only used by StreamPredictor.

203:   // Get the BaseStream of this stream.

204:   virtual BaseStream *getBaseStream() = 0;

206:   // Get the stream after the last decoder (this may be a BaseStream

207:   // or a DecryptStream).

219: 			      StreamColorSpaceMode * /*csMode*/) {}

245: // OutStream

252:   OutStream ();

255:   virtual ~OutStream ();

257:   OutStream(const OutStream &) = delete;

258:   OutStream& operator=(const OutStream &other) = delete;

273: // FileOutStream

277:   FileOutStream (FILE* fa, Goffset startA);

279:   ~FileOutStream ();

296: // BaseStream

305:   BaseStream(Object &&dictA, Goffset lengthA);

306:   ~BaseStream();

307:   virtual BaseStream *copy() = 0;

330: // FilterStream

339:   ~FilterStream();

358: // ImageStream

369:   ~ImageStream();

371:   ImageStream(const ImageStream &) = delete;

372:   ImageStream& operator=(const ImageStream &other) = delete;

405: // StreamPredictor

416:   ~StreamPredictor();

418:   StreamPredictor(const StreamPredictor &) = delete;

419:   StreamPredictor& operator=(const StreamPredictor &) = delete;

445: // FileStream

453:   FileStream(GooFile* fileA, Goffset startA, bool limitedA,

455:   ~FileStream();

456:   BaseStream *copy() override;

459:   StreamKind getKind() override { return strFile; }

520: // CachedFileStream

528:   CachedFileStream(CachedFile *ccA, Goffset startA, bool limitedA,

530:   ~CachedFileStream();

531:   BaseStream *copy() override;

534:   StreamKind getKind() override { return strCachedFile; }

566: // MemStream

581:   BaseStream *copy() override {

582:     return new BaseMemStream(buf, start, length, dict.copy());

593:     return new BaseMemStream(buf, startA, newLength, std::move(dictA));

596:   StreamKind getKind() override { return strWeird; }

672:    : BaseMemStream(bufA, startA, lengthA, std::move(dictA))

680:    : BaseMemStream(bufA, startA, lengthA, std::move(dictA))

689: // EmbedStream

693: // EmbedStream is deleted, reads from the base stream will proceed where

694: // the BaseStream left off.  Note that this is very different behavior

695: // that creating a new FileStream (using makeSubStream).

702:   ~EmbedStream();

703:   BaseStream *copy() override;

706:   StreamKind getKind() override { return str->getKind(); }

739: // ASCIIHexStream

746:   ~ASCIIHexStream();

747:   StreamKind getKind() override { return strASCIIHex; }

770:   StreamKind getKind() override { return strASCII85; }

787: // LZWStream

795:   ~LZWStream();

796:   StreamKind getKind() override { return strLZW; }

822:   StreamPredictor *pred;	// predictor

847: // RunLengthStream

854:   ~RunLengthStream();

855:   StreamKind getKind() override { return strRunLength; }

878: // CCITTFaxStream

889:   ~CCITTFaxStream();

890:   StreamKind getKind() override { return strCCITTFax; }

942: // DCTStream

975:   virtual ~DCTStream();

976:   StreamKind getKind() override { return strDCT; }

1051: // FlateStream

1083:   ~FlateStream();

1084:   StreamKind getKind() override { return strFlate; }

1113:   StreamPredictor *pred;	// predictor

1150: // EOFStream

1157:   ~EOFStream();

1158:   StreamKind getKind() override { return strWeird; }

1167: // BufStream

1174:   ~BufStream();

1175:   StreamKind getKind() override { return strWeird; }

1195: class FixedLengthEncoder: public FilterStream {

1200:   StreamKind getKind() override { return strWeird; }

1218: class ASCIIHexEncoder: public FilterStream {

1223:   StreamKind getKind() override { return strWeird; }

1248: class ASCII85Encoder: public FilterStream {

1253:   StreamKind getKind() override { return strWeird; }

1278: class RunLengthEncoder: public FilterStream {

1283:   StreamKind getKind() override { return strWeird; }

1314: class LZWEncoder: public FilterStream {

1319:   StreamKind getKind() override { return strWeird; }

1346: class CMYKGrayEncoder: public FilterStream {

1351:   StreamKind getKind() override { return strWeird; }

1375: class RGBGrayEncoder: public FilterStream {

1380:   StreamKind getKind() override { return strWeird; }

509:   char buf[fileStreamBufSize];

515:   bool needsEncryptionOnSave;   // Needed for FileStreams that point to "external" files

556:   char buf[cachedStreamBufSize];

25: use GuzzleHttp\Stream\Stream;

26: use GuzzleHttp\Stream\CachingStream;

32: class UrlFetchStream implements IteratorAggregate, ArrayAccess 

259:      * Opens URL Stream.

302:             $this->stream = new CachingStream(Stream::factory($resp->getContent()));

315:      * Closes URL Stream.

263:      * @param int $optionsStream UNUSED in the context of URLs.

270:     public function stream_open(string $url, string $mode, int $optionsStream, &$openedPath): bool

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

26: class Stream : public Print

21: #define Stream_h

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

20: #ifndef Stream_h

6682:         Stream,

1392:         default AdvancedJmsEndpointConsumerBuilder artemisStreamingEnabled(

1409:         default AdvancedJmsEndpointConsumerBuilder artemisStreamingEnabled(

3877:         default AdvancedJmsEndpointProducerBuilder artemisStreamingEnabled(

3894:         default AdvancedJmsEndpointProducerBuilder artemisStreamingEnabled(

5481:         default AdvancedJmsEndpointBuilder artemisStreamingEnabled(

5498:         default AdvancedJmsEndpointBuilder artemisStreamingEnabled(

162:          * Map, Object, Stream, Text. By default, Camel would determine which

182:          * Map, Object, Stream, Text. By default, Camel would determine which

2720:          * Map, Object, Stream, Text. By default, Camel would determine which

2740:          * Map, Object, Stream, Text. By default, Camel would determine which

5204:          * Map, Object, Stream, Text. By default, Camel would determine which

5223:          * Map, Object, Stream, Text. By default, Camel would determine which

3783:          * Sets whether StreamMessage type is enabled or not. Message payloads

3784:          * of streaming kind such as files, InputStream, etc will either by sent

3785:          * as BytesMessage or StreamMessage. This option controls which kind

3789:          * chunk is then written to the StreamMessage until no more data.

3805:          * Sets whether StreamMessage type is enabled or not. Message payloads

3806:          * of streaming kind such as files, InputStream, etc will either by sent

3807:          * as BytesMessage or StreamMessage. This option controls which kind

3811:          * chunk is then written to the StreamMessage until no more data.

1389:          * @param artemisStreamingEnabled the value to set

1393:                 boolean artemisStreamingEnabled) {

1394:             doSetProperty("artemisStreamingEnabled", artemisStreamingEnabled);

1406:          * @param artemisStreamingEnabled the value to set

1410:                 String artemisStreamingEnabled) {

1411:             doSetProperty("artemisStreamingEnabled", artemisStreamingEnabled);

3874:          * @param artemisStreamingEnabled the value to set

3878:                 boolean artemisStreamingEnabled) {

3879:             doSetProperty("artemisStreamingEnabled", artemisStreamingEnabled);

3891:          * @param artemisStreamingEnabled the value to set

3895:                 String artemisStreamingEnabled) {

3896:             doSetProperty("artemisStreamingEnabled", artemisStreamingEnabled);

5478:          * @param artemisStreamingEnabled the value to set

5482:                 boolean artemisStreamingEnabled) {

5483:             doSetProperty("artemisStreamingEnabled", artemisStreamingEnabled);

5495:          * @param artemisStreamingEnabled the value to set

5499:                 String artemisStreamingEnabled) {

5500:             doSetProperty("artemisStreamingEnabled", artemisStreamingEnabled);

238: type Stream struct {

144: 	closeStream func(error) // Closes the client transport stream with the given error and nil trailer metadata.

635: 	NewStream(ctx context.Context, callHdr *CallHdr) (*Stream, error)

641: 	CloseStream(stream *Stream, err error)

521: 	MaxStreams            uint32

676: 	HandleStreams(func(*Stream), func(context.Context, string) context.Context)

750: 	errStreamDrain = status.Error(codes.Unavailable, "the connection is draining")

753: 	errStreamDone = errors.New("the stream is done")

790: 	lastStreamCreatedTime int64

237: // Stream represents an RPC in the transport layer.

240: 	st           ServerTransport    // nil for client side Stream

241: 	ct           *http2Client       // nil for server side Stream

243: 	cancel       context.CancelFunc // always nil for client side Stream

295: func (s *Stream) isHeaderSent() bool {

301: func (s *Stream) updateHeaderSent() bool {

305: func (s *Stream) swapState(st streamState) streamState {

309: func (s *Stream) compareAndSwapState(oldState, newState streamState) bool {

313: func (s *Stream) getState() streamState {

317: func (s *Stream) waitOnHeader() {

337: func (s *Stream) RecvCompress() string {

343: func (s *Stream) SetSendCompress(str string) {

349: func (s *Stream) Done() <-chan struct{} {

361: func (s *Stream) Header() (metadata.MD, error) {

377: func (s *Stream) TrailersOnly() bool {

387: func (s *Stream) Trailer() metadata.MD {

397: func (s *Stream) ContentSubtype() string {

402: func (s *Stream) Context() context.Context {

407: func (s *Stream) Method() string {

414: func (s *Stream) Status() *status.Status {

421: func (s *Stream) SetHeader(md metadata.MD) error {

437: func (s *Stream) SendHeader(md metadata.MD) error {

444: func (s *Stream) SetTrailer(md metadata.MD) error {

457: func (s *Stream) write(m recvMsg) {

462: func (s *Stream) Read(p []byte) (n int, err error) {

471: // tranportReader reads all the data available for this Stream from the transport and

494: func (s *Stream) BytesReceived() bool {

500: func (s *Stream) Unprocessed() bool {

504: // GoString is implemented by Stream so context.String() won't

506: func (s *Stream) GoString() string {

632: 	Write(s *Stream, hdr []byte, data []byte, opts *Options) error

634: 	// NewStream creates a Stream for an RPC.

673: // Write methods for a given Stream will be called serially.

680: 	WriteHeader(s *Stream, md metadata.MD) error

684: 	Write(s *Stream, hdr []byte, data []byte, opts *Options) error

688: 	WriteStatus(s *Stream, st *status.Status) error

169: 	if r.closeStream != nil {

188: 	// closeStream writes its error parameter to r.recv as a recvMsg.

199: 		// was not marked as done when trailer is received. This closeStream

205: 		r.closeStream(ContextErr(r.ctx.Err()))

232: 	streamWriteDone             // EndStream sent

233: 	streamReadDone              // EndStream received

327: 		s.ct.CloseStream(s, ContextErr(s.ctx.Err()))

328: 		// headerChan could possibly not be closed yet if closeStream raced

624: 	// accepting new RPCs and NewStream will return error. Once all streams are

637: 	// CloseStream clears the footprint of a stream when the stream is

639: 	// CloseStream is called. Must be called when a stream is finished

675: 	// HandleStreams receives incoming streams using the given handler.

747: 	// errStreamDrain indicates that the stream is rejected because the

751: 	// errStreamDone is returned from write at the client side to indiacte application

787: 	// lastStreamCreatedTime stores the timestamp that the last stream gets created. It is of int64 type

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));

250: Stream::Stream(StreamExecutor *parent)

259: Stream::Stream(StreamExecutor *parent,

269: Stream::~Stream() {

1880: Stream *Stream::GetOrCreateSubStream() {

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

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

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

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

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

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

297: Stream &Stream::Init() {

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

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

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

346: Stream &Stream::ThenBatchNormalizationForward(

377: Stream &Stream::ThenBatchNormalizationBackward(

402: Stream &Stream::ThenBatchNormalizationForward(

433: Stream &Stream::ThenBatchNormalizationBackward(

460: Stream &Stream::ThenFusedConvolveWithAlgorithm(

498: Stream &Stream::ThenFusedConvolveWithAlgorithm(

536: Stream &Stream::ThenFusedConvolveWithAlgorithm(

575: Stream &Stream::ThenFusedConvolveWithAlgorithm(

613: Stream &Stream::ThenFusedConvolveWithAlgorithm(

651: Stream &Stream::ThenConvolveWithAlgorithm(

693: Stream &Stream::ThenConvolveWithAlgorithm(

735: Stream &Stream::ThenConvolveWithAlgorithm(

777: Stream &Stream::ThenConvolveWithAlgorithm(

819: Stream &Stream::ThenConvolveWithAlgorithm(

861: Stream &Stream::ThenConvolve(

876: Stream &Stream::ThenConvolveQuantized(

906: Stream &Stream::ThenConvolveQuantized(

936: Stream &Stream::ThenSeparableConvolve(

963: Stream &Stream::ThenConvolveBackwardDataWithAlgorithm(

1008: Stream &Stream::ThenConvolveBackwardDataWithAlgorithm(

1053: Stream &Stream::ThenConvolveBackwardDataWithAlgorithm(

1098: Stream &Stream::ThenConvolveBackwardFilterWithAlgorithm(

1143: Stream &Stream::ThenConvolveBackwardFilterWithAlgorithm(

1188: Stream &Stream::ThenConvolveBackwardFilterWithAlgorithm(

1234: Stream &Stream::ThenConvolveBackwardBiasImpl(

1254: Stream &Stream::ThenConvolveBackwardBias(

1263: Stream &Stream::ThenConvolveBackwardBias(

1272: Stream &Stream::ThenConvolveBackwardBias(

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

1300: Stream &Stream::ThenMatMulQuantized(

1322: Stream &Stream::ThenMatMulQuantized(

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

1362: Stream &Stream::ThenPoolForward(

1387: Stream &Stream::ThenPoolForward(

1409: Stream &Stream::ThenPoolForward(

1432: Stream &Stream::ThenPoolForward(

1454: Stream &Stream::ThenPoolBackward(

1484: Stream &Stream::ThenPoolBackward(

1511: Stream &Stream::ThenPoolBackward(

1538: Stream &Stream::ThenNormalizeWithDimensions(

1556: Stream &Stream::ThenNormalizeBackwardWithDimensions(

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

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

1607: Stream &Stream::ThenDepthConcatenate(

1637: Stream &Stream::ThenSpaceConcatenate(

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

1702: Stream &Stream::ThenDepthToSpace(

1723: Stream &Stream::ThenSpaceToDepth(

1744: Stream &Stream::ThenElementwiseOperate(

1765: Stream &Stream::ThenElementwiseOperateScaledQuantized(

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

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

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

1846: Stream &Stream::ThenMemcpyD2HQuantized(

1863: Stream &Stream::ThenMemcpyH2DQuantized(

1881:   // Do not destroy bad streams when holding mu_ because ~Stream() may

1883:   std::vector<std::unique_ptr<Stream>> bad_streams;

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

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

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

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

1933:   // Do not destroy bad streams when holding mu_ because ~Stream() may

1935:   std::unique_ptr<Stream> bad_stream;

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

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

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

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

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

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

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

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

2041:   Stream &Run(Stream *stream,

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

3353: Stream &Stream::ThenBlasTbmv(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,

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

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

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

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

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

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

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

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

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

3520: Stream &Stream::ThenBlasTpsv(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,

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

3577: Stream &Stream::ThenBlasTrmv(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,

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

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

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

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

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

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

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

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

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

3760: Stream &Stream::ThenBlasGemvWithProfiling(

3777: Stream &Stream::ThenBlasGemvWithProfiling(

3795: Stream &Stream::ThenBlasGemvWithProfiling(

3815: Stream &Stream::ThenBlasGemvWithProfiling(

3835: Stream &Stream::ThenBlasGemmWithProfiling(

3855: Stream &Stream::ThenBlasGemmWithProfiling(

3874: Stream &Stream::ThenBlasGemmWithProfiling(

3894: Stream &Stream::ThenBlasGemmWithProfiling(

3916: Stream &Stream::ThenBlasGemmWithProfiling(

3938: Stream &Stream::ThenBlasGemmWithAlgorithm(

3963: Stream &Stream::ThenBlasGemmWithAlgorithm(

3986: Stream &Stream::ThenBlasGemmWithAlgorithm(

4009: Stream &Stream::ThenBlasGemmWithAlgorithm(

4033: Stream &Stream::ThenBlasGemmWithAlgorithm(

4061: Stream &Stream::ThenBlasGemmWithAlgorithm(

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

4529: Stream &Stream::ThenBlasGemmBatched(

4541: Stream &Stream::ThenBlasGemmBatchedWithScratch(

4563: Stream &Stream::ThenBlasGemmBatched(

4574: Stream &Stream::ThenBlasGemmBatchedWithScratch(

4595: Stream &Stream::ThenBlasGemmBatched(

4606: Stream &Stream::ThenBlasGemmBatchedWithScratch(

4627: Stream &Stream::ThenBlasGemmBatched(

4640: Stream &Stream::ThenBlasGemmBatchedWithScratch(

4666: Stream &Stream::ThenBlasGemmBatched(

4679: Stream &Stream::ThenBlasGemmBatchedWithScratch(

4705: Stream &Stream::ThenBlasGemmStridedBatched(

4726: Stream &Stream::ThenBlasGemmStridedBatched(

4747: Stream &Stream::ThenBlasGemmStridedBatched(

4768: Stream &Stream::ThenBlasGemmStridedBatched(

4791: Stream &Stream::ThenBlasGemmStridedBatched(

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

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

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

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

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

4898: Stream &Stream::ThenPopulateRandUniform(

4915: Stream &Stream::ThenPopulateRandUniform(

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

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

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

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

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

4997: Stream &Stream::ThenRnnForward(

5034: Stream &Stream::ThenRnnForward(

5070: Stream &Stream::ThenRnnForward(

5107: Stream &Stream::ThenRnnBackward(

5154: Stream &Stream::ThenRnnBackward(

5200: Stream &Stream::ThenRnnBackward(

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

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

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

5314: Stream &Stream::ThenDoHostCallbackWithStatus(

5326: Stream &Stream::ThenRunAfterNextBlockHostUntilDone(

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

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

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

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

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

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

5448: Stream &Stream::ThenEnqueueOnBackgroundThread(

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

5480: void Stream::RunAfterBlockHostUntilDoneCallbacks() {

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

260:                internal::StreamInterface *implementation)

282:     parent_->DeallocateStream(this);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

5452:   StreamExecutor *stream_executor = this->parent_;

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

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

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

1896:                 << sub_stream->DebugStreamPointers();

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

1911:               << sub_stream->DebugStreamPointers();

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

1927:           << sub_stream->DebugStreamPointers();

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

1949:               << sub_stream->DebugStreamPointers();

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

1956:               << sub_stream->DebugStreamPointers();

1967:   LOG(FATAL) << DebugStreamPointers()

1969:              << sub_stream->DebugStreamPointers();

1978:     LOG(INFO) << DebugStreamPointers()

1990:     LOG(INFO) << DebugStreamPointers()

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

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

2005:               << other->DebugStreamPointers();

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

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

4825:     LOG(INFO) << DebugStreamPointers()

4840:       LOG(INFO) << DebugStreamPointers()

4857:       LOG(INFO) << DebugStreamPointers()

4874:       LOG(INFO) << DebugStreamPointers()

4890:       LOG(INFO) << DebugStreamPointers()

4907:       LOG(INFO) << DebugStreamPointers()

4924:       LOG(INFO) << DebugStreamPointers()

4939:     LOG(INFO) << DebugStreamPointers()

4952:     LOG(INFO) << DebugStreamPointers()

4965:     LOG(INFO) << DebugStreamPointers()

4977:     LOG(INFO) << DebugStreamPointers()

4990:     LOG(INFO) << DebugStreamPointers()

5307:     LOG(INFO) << DebugStreamPointers()

5319:     LOG(INFO) << DebugStreamPointers()

5331:     LOG(INFO) << DebugStreamPointers()

5350:       LOG(INFO) << DebugStreamPointers()

5368:       LOG(INFO) << DebugStreamPointers()

5385:       LOG(INFO) << DebugStreamPointers()

5402:       LOG(INFO) << DebugStreamPointers()

5420:       LOG(INFO) << DebugStreamPointers()

5438:       LOG(INFO) << DebugStreamPointers()

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

671: HH_INLINE void Stream(const V256<T>& v, T* const HH_RESTRICT to) {

674: HH_INLINE void Stream(const V256<float>& v, float* const HH_RESTRICT to) {

677: HH_INLINE void Stream(const V256<double>& v, double* const HH_RESTRICT to) {

249: Stream::Stream(StreamExecutor *parent)

258: Stream::Stream(StreamExecutor *parent,

268: Stream::~Stream() {

1738: Stream *Stream::GetOrCreateSubStream() {

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

5277: string Stream::DebugStreamPointers() const {

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

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