Found 351117 results in 36655 files, showing top 50 files (show more).
github.com/GoogleCloudPlatform/appengine-php-sdk:src/Api/UrlFetch/UrlFetchStream.php: [ master, ] 
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
github.com/sparkfun/Arduino_Boards:sparkfun/samd/cores/arduino/Stream.h: [ master, ] 
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
github.com/sparkfun/Arduino_Boards:sparkfun/samd/cores/arduino51/Stream.h: [ master, ] Duplicate result
android.googlesource.com/platform/frameworks/ex:framesequence/jni/Stream.h: [ master, ] 
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);
github.com/google/iree-llvm-sandbox:third_party/iree/compiler/src/iree/compiler/Dialect/Stream/IR/StreamOpFolders.cpp: [ main, ] 
38: namespace Stream {
 
10: #include "iree/compiler/Dialect/Stream/IR/StreamDialect.h"
 
11: #include "iree/compiler/Dialect/Stream/IR/StreamOps.h"
 
50: static Optional<IREE::Stream::YieldOp> getYieldIfOnlyOp(Block &block) {
 
53:   auto yieldOp = dyn_cast<IREE::Stream::YieldOp>(block.back());
 
141:   auto valueType = rootValue.getType().dyn_cast<IREE::Stream::ResourceType>();
 
147:   bool forceClone = valueType.getLifetime() == IREE::Stream::Lifetime::Constant;
 
161:     if (isa<IREE::Stream::TimepointAwaitOp>(use.getOwner())) continue;
 
180:   IREE::Stream::AffinityAttr sourceAffinity;
 
181:   if (auto affinityOp = dyn_cast_or_null<IREE::Stream::AffinityOpInterface>(
 
197:     IREE::Stream::AffinityAttr targetAffinity;
 
199:             dyn_cast<IREE::Stream::AffinityOpInterface>(tiedUse.user)) {
 
203:     auto cloneOp = builder.create<IREE::Stream::AsyncCloneOp>(
 
253:     for (auto yieldOp : op.template getOps<IREE::Stream::YieldOp>()) {
 
332:     auto trueSize = rewriter.createOrFold<IREE::Stream::ResourceSizeOp>(
 
334:     auto falseSize = rewriter.createOrFold<IREE::Stream::ResourceSizeOp>(
 
644:     if (!op.getType().isa<IREE::Stream::ResourceType>()) return failure();
 
645:     auto trueSubview = dyn_cast_or_null<IREE::Stream::ResourceSubviewOp>(
 
647:     auto falseSubview = dyn_cast_or_null<IREE::Stream::ResourceSubviewOp>(
 
657:     rewriter.replaceOpWithNewOp<IREE::Stream::ResourceSubviewOp>(
 
759:     auto resultSize = rewriter.createOrFold<IREE::Stream::TensorSizeOfOp>(
 
785:     auto resultType = IREE::Stream::ResourceType::get(constantOp.getContext());
 
786:     auto resultSize = rewriter.createOrFold<IREE::Stream::TensorSizeOfOp>(
 
1118:     rewriter.replaceOpWithNewOp<IREE::Stream::AsyncSplatOp>(
 
1234:         cloneOp.source().getDefiningOp<IREE::Stream::StreamableOpInterface>();
 
1284:     auto splatOp = sliceOp.source().getDefiningOp<IREE::Stream::AsyncSplatOp>();
 
1286:     rewriter.replaceOpWithNewOp<IREE::Stream::AsyncSplatOp>(
 
1322:       rewriter.replaceOpWithNewOp<IREE::Stream::AsyncSplatOp>(
 
1367:         updateOp.update().getDefiningOp<IREE::Stream::AsyncSplatOp>();
 
1369:     rewriter.replaceOpWithNewOp<IREE::Stream::AsyncFillOp>(
 
1399:         updateOp.update().getDefiningOp<IREE::Stream::AsyncSliceOp>();
 
1406:     rewriter.replaceOpWithNewOp<IREE::Stream::AsyncCopyOp>(
 
1448:       rewriter.replaceOpWithNewOp<IREE::Stream::AsyncUpdateOp>(
 
1565:   return builder.create<IREE::Stream::TimepointJoinOp>(
 
1566:       loc, builder.getType<IREE::Stream::TimepointType>(), joinTimepoints);
 
1643:       IREE::Stream::ResourceSubviewOp subviewOp;
 
2103:       IREE::Stream::ResourceSubviewOp subviewOp;
 
2219:   return IREE::Stream::TimepointAttr::get(getContext(), getResult().getType());
 
2247:     return IREE::Stream::TimepointAttr::get(getContext(),
 
2428:           operand.value().getDefiningOp<IREE::Stream::ResourceSubviewOp>();
 
2436:       auto newOp = rewriter.create<IREE::Stream::ResourceSubviewOp>(
 
2566:     auto newOp = rewriter.create<IREE::Stream::TimepointAwaitOp>(
 
2596: }  // namespace Stream
github.com/sparkfun/BadgerStick:badgerstick/avr/cores/arduino/Stream.h: [ master, ] 
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
github.com/google/gulava:java/gulava/Stream.java: [ master, ] 
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();
github.com/sparkfun/PSoC_Arduino_Support:Hardware/SparkFun/psoc/cores/arduino/Stream.h: [ master, ] 
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
github.com/apache/accumulo-testing:src/main/java/org/apache/accumulo/testing/stress/Stream.java: [ master, ] 
26: public abstract class Stream<T> implements Iterator<T> {
github.com/sparkfun/MaKeyMaKey:firmware/Arduino/hardware/MaKeyMaKey/cores/arduino/Stream.h: [ master, ] 
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
android.googlesource.com/platform/external/arduino:hardware/arduino/cores/arduino/Stream.h: [ master, ] 
26: class Stream : public Print
 
21: #define Stream_h
 
2:   Stream.h - base class for character-based streams.
 
20: #ifndef Stream_h
github.com/llvm-mirror/llvm:tools/llvm-pdbutil/llvm-pdbutil.cpp: [ master, ] 
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;
github.com/tensorflow/fold:tensorflow/tensorflow/stream_executor/stream.cc: [ master, ] 
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));
github.com/kubernetes/client-go:rest/request.go: [ master, ] 
70: 	Stream(context.Context) (io.ReadCloser, error)
 
803: func (r *Request) Stream(ctx context.Context) (io.ReadCloser, error) {
 
757: func (r *Request) newStreamWatcher(resp *http.Response) (watch.Interface, error) {
 
799: // Stream formats and executes the request, and offers streaming of the response.
 
1052: 			klog.V(2).Infof("Stream error %#v when reading response body, may be caused by closed connection.", err)
 
763: 	objectDecoder, streamingSerializer, framer, err := r.c.content.Negotiator.StreamDecoder(mediaType, params)
 
1044: 		case http2.StreamError:
 
724: 			return r.newStreamWatcher(resp)
 
773: 	return watch.NewStreamWatcher(
github.com/tensorflow/haskell:third_party/tensorflow/tensorflow/stream_executor/stream.cc: [ master, ] 
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;
github.com/google/highwayhash:highwayhash/vector256.h: [ master, ] 
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) {
github.com/tensorflow/deepmath:tensorflow/tensorflow/stream_executor/stream.cc: [ master, ] 
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,
 
215:                             " Called Stream::", function_name, "(");
 
284: port::Status Stream::RefreshStatus() {
 
290: Stream &Stream::Init() {
 
309: Stream &Stream::InitTimer(Timer *timer) {
 
320: Stream &Stream::InitWithTimer(Timer *timer) {
 
326: Stream &Stream::ThenRecordEvent(Event *event) {
 
339: Stream &Stream::ThenBatchNormalizationForward(
 
367: Stream &Stream::ThenBatchNormalizationBackward(
 
389: Stream &Stream::ThenBatchNormalizationForward(
 
417: Stream &Stream::ThenBatchNormalizationBackward(
 
440: Stream &Stream::ThenFusedConvolveWithAlgorithm(
 
478: Stream &Stream::ThenFusedConvolveWithAlgorithm(
 
516: Stream &Stream::ThenFusedConvolveWithAlgorithm(
 
555: Stream &Stream::ThenFusedConvolveWithAlgorithm(
 
593: Stream &Stream::ThenConvolveWithAlgorithm(
 
635: Stream &Stream::ThenConvolveWithAlgorithm(
 
677: Stream &Stream::ThenConvolveWithAlgorithm(
 
719: Stream &Stream::ThenConvolve(
 
734: Stream &Stream::ThenConvolveQuantized(
 
764: Stream &Stream::ThenConvolveQuantized(
 
794: Stream &Stream::ThenSeparableConvolve(
 
821: Stream &Stream::ThenConvolveBackwardDataWithAlgorithm(
 
866: Stream &Stream::ThenConvolveBackwardDataWithAlgorithm(
 
911: Stream &Stream::ThenConvolveBackwardDataWithAlgorithm(
 
956: Stream &Stream::ThenConvolveBackwardFilterWithAlgorithm(
 
1001: Stream &Stream::ThenConvolveBackwardFilterWithAlgorithm(
 
1046: Stream &Stream::ThenConvolveBackwardFilterWithAlgorithm(
 
1092: Stream &Stream::ThenConvolveBackwardBiasImpl(
 
1112: Stream &Stream::ThenConvolveBackwardBias(
 
1121: Stream &Stream::ThenConvolveBackwardBias(
 
1130: Stream &Stream::ThenConvolveBackwardBias(
 
1139: Stream &Stream::ThenMatMul(const DeviceMemory<float> &input_data,
 
1158: Stream &Stream::ThenMatMulQuantized(
 
1180: Stream &Stream::ThenMatMulQuantized(
 
1202: Stream &Stream::ThenBiasAdd(const DeviceMemory<float> &input_data,
 
1220: Stream &Stream::ThenPoolForward(
 
1245: Stream &Stream::ThenPoolForward(
 
1267: Stream &Stream::ThenPoolForward(
 
1290: Stream &Stream::ThenPoolForward(
 
1312: Stream &Stream::ThenPoolBackward(
 
1342: Stream &Stream::ThenPoolBackward(
 
1369: Stream &Stream::ThenPoolBackward(
 
1396: Stream &Stream::ThenNormalizeWithDimensions(
 
1414: Stream &Stream::ThenNormalizeBackwardWithDimensions(
 
1438: Stream &Stream::ThenActivate(dnn::ActivationMode activation_mode,
 
1446: Stream &Stream::ThenActivateWithOptions(dnn::ActivationMode activation_mode,
 
1465: Stream &Stream::ThenDepthConcatenate(
 
1495: Stream &Stream::ThenSpaceConcatenate(
 
1542: Stream &Stream::ThenReshape(const dnn::BatchDescriptor &input_dimensions,
 
1560: Stream &Stream::ThenDepthToSpace(
 
1581: Stream &Stream::ThenSpaceToDepth(
 
1602: Stream &Stream::ThenElementwiseOperate(
 
1623: Stream &Stream::ThenElementwiseOperateScaledQuantized(
 
1646: Stream &Stream::ThenXYPad(const dnn::BatchDescriptor &dimensions,
 
1665: Stream &Stream::ThenXYSlice(const dnn::BatchDescriptor &dimensions,
 
1686: Stream &Stream::ThenXYBroadcast(const dnn::BatchDescriptor &dimensions,
 
1704: Stream &Stream::ThenMemcpyD2HQuantized(
 
1721: Stream &Stream::ThenMemcpyH2DQuantized(
 
1744:     std::pair<std::unique_ptr<Stream>, bool> &pair = sub_streams_[index];
 
1747:       Stream *sub_stream = pair.first.get();
 
1772:   sub_streams_.emplace_back(std::unique_ptr<Stream>{new Stream{parent_}},
 
1774:   Stream *sub_stream = sub_streams_.back().first.get();
 
1790:     std::pair<std::unique_ptr<Stream>, bool> &pair = sub_streams_[index];
 
1820: Stream &Stream::ThenStartTimer(Timer *t) {
 
1832: Stream &Stream::ThenStopTimer(Timer *t) {
 
1844: Stream &Stream::ThenWaitFor(Stream *other) {
 
1858: Stream &Stream::ThenWaitFor(Event *event) {
 
1880:   // arguments except the first one of Stream* type.
 
1881:   Stream &operator()(Stream *stream,
 
1882:                      bool (blas::BlasSupport::*blas_func)(Stream *, Args...),
 
1889:   Stream &Run(Stream *stream,
 
1890:               bool (blas::BlasSupport::*blas_func)(Stream *, Args...),
 
1895: Stream &ThenBlasImpl<Args...>::Run(
 
1896:     Stream *stream, bool (blas::BlasSupport::*blas_func)(Stream *, Args...),
 
1915: Stream &Stream::ThenBlasAsum(uint64 elem_count, const DeviceMemory<float> &x,
 
1925: Stream &Stream::ThenBlasAsum(uint64 elem_count, const DeviceMemory<double> &x,
 
1935: Stream &Stream::ThenBlasAsum(uint64 elem_count,
 
1946: Stream &Stream::ThenBlasAsum(uint64 elem_count,
 
1957: Stream &Stream::ThenBlasAxpy(uint64 elem_count, float alpha,
 
1969: Stream &Stream::ThenBlasAxpy(uint64 elem_count, double alpha,
 
1981: Stream &Stream::ThenBlasAxpy(uint64 elem_count, std::complex<float> alpha,
 
1995: Stream &Stream::ThenBlasAxpy(uint64 elem_count, std::complex<double> alpha,
 
2009: Stream &Stream::ThenBlasCopy(uint64 elem_count, const DeviceMemory<float> &x,
 
2019: Stream &Stream::ThenBlasCopy(uint64 elem_count, const DeviceMemory<double> &x,
 
2029: Stream &Stream::ThenBlasCopy(uint64 elem_count,
 
2041: Stream &Stream::ThenBlasCopy(uint64 elem_count,
 
2053: Stream &Stream::ThenBlasDot(uint64 elem_count, const DeviceMemory<float> &x,
 
2065: Stream &Stream::ThenBlasDot(uint64 elem_count, const DeviceMemory<double> &x,
 
2077: Stream &Stream::ThenBlasDotc(uint64 elem_count,
 
2093: Stream &Stream::ThenBlasDotc(uint64 elem_count,
 
2109: Stream &Stream::ThenBlasDotu(uint64 elem_count,
 
2125: Stream &Stream::ThenBlasDotu(uint64 elem_count,
 
2141: Stream &Stream::ThenBlasNrm2(uint64 elem_count, const DeviceMemory<float> &x,
 
2151: Stream &Stream::ThenBlasNrm2(uint64 elem_count, const DeviceMemory<double> &x,
 
2161: Stream &Stream::ThenBlasNrm2(uint64 elem_count,
 
2172: Stream &Stream::ThenBlasNrm2(uint64 elem_count,
 
2183: Stream &Stream::ThenBlasRot(uint64 elem_count, DeviceMemory<float> *x, int incx,
 
2195: Stream &Stream::ThenBlasRot(uint64 elem_count, DeviceMemory<double> *x,
 
2207: Stream &Stream::ThenBlasRot(uint64 elem_count,
 
2220: Stream &Stream::ThenBlasRot(uint64 elem_count,
 
2233: Stream &Stream::ThenBlasRotg(DeviceMemory<float> *a, DeviceMemory<float> *b,
 
2242: Stream &Stream::ThenBlasRotg(DeviceMemory<double> *a, DeviceMemory<double> *b,
 
2251: Stream &Stream::ThenBlasRotg(DeviceMemory<std::complex<float>> *a,
 
2263: Stream &Stream::ThenBlasRotg(DeviceMemory<std::complex<double>> *a,
 
2275: Stream &Stream::ThenBlasRotm(uint64 elem_count, DeviceMemory<float> *x,
 
2287: Stream &Stream::ThenBlasRotm(uint64 elem_count, DeviceMemory<double> *x,
 
2299: Stream &Stream::ThenBlasRotmg(DeviceMemory<float> *d1, DeviceMemory<float> *d2,
 
2311: Stream &Stream::ThenBlasRotmg(DeviceMemory<double> *d1,
 
2324: Stream &Stream::ThenBlasScal(uint64 elem_count, float alpha,
 
2332: Stream &Stream::ThenBlasScal(uint64 elem_count, double alpha,
 
2340: Stream &Stream::ThenBlasScal(uint64 elem_count, float alpha,
 
2348: Stream &Stream::ThenBlasScal(uint64 elem_count, double alpha,
 
2356: Stream &Stream::ThenBlasScal(uint64 elem_count, std::complex<float> alpha,
 
2365: Stream &Stream::ThenBlasScal(uint64 elem_count, std::complex<double> alpha,
 
2374: Stream &Stream::ThenBlasSwap(uint64 elem_count, DeviceMemory<float> *x,
 
2384: Stream &Stream::ThenBlasSwap(uint64 elem_count, DeviceMemory<double> *x,
 
2394: Stream &Stream::ThenBlasSwap(uint64 elem_count,
 
2405: Stream &Stream::ThenBlasSwap(uint64 elem_count,
 
2416: Stream &Stream::ThenBlasIamax(uint64 elem_count, const DeviceMemory<float> &x,
 
2426: Stream &Stream::ThenBlasIamax(uint64 elem_count, const DeviceMemory<double> &x,
 
2436: Stream &Stream::ThenBlasIamax(uint64 elem_count,
 
2447: Stream &Stream::ThenBlasIamax(uint64 elem_count,
 
2458: Stream &Stream::ThenBlasIamin(uint64 elem_count, const DeviceMemory<float> &x,
 
2468: Stream &Stream::ThenBlasIamin(uint64 elem_count, const DeviceMemory<double> &x,
 
2478: Stream &Stream::ThenBlasIamin(uint64 elem_count,
 
2489: Stream &Stream::ThenBlasIamin(uint64 elem_count,
 
2500: Stream &Stream::ThenBlasGbmv(blas::Transpose trans, uint64 m, uint64 n,
 
2516: Stream &Stream::ThenBlasGbmv(blas::Transpose trans, uint64 m, uint64 n,
 
2532: Stream &Stream::ThenBlasGbmv(blas::Transpose trans, uint64 m, uint64 n,
 
2552: Stream &Stream::ThenBlasGbmv(blas::Transpose trans, uint64 m, uint64 n,
 
2572: Stream &Stream::ThenBlasGemv(blas::Transpose trans, uint64 m, uint64 n,
 
2587: Stream &Stream::ThenBlasGemv(blas::Transpose trans, uint64 m, uint64 n,
 
2602: Stream &Stream::ThenBlasGemv(blas::Transpose trans, uint64 m, uint64 n,
 
2622: Stream &Stream::ThenBlasGemv(blas::Transpose trans, uint64 m, uint64 n,
 
2642: Stream &Stream::ThenBlasGer(uint64 m, uint64 n, float alpha,
 
2656: Stream &Stream::ThenBlasGer(uint64 m, uint64 n, double alpha,
 
2670: Stream &Stream::ThenBlasGerc(uint64 m, uint64 n, std::complex<float> alpha,
 
2687: Stream &Stream::ThenBlasGerc(uint64 m, uint64 n, std::complex<double> alpha,
 
2704: Stream &Stream::ThenBlasGeru(uint64 m, uint64 n, std::complex<float> alpha,
 
2721: Stream &Stream::ThenBlasGeru(uint64 m, uint64 n, std::complex<double> alpha,
 
2738: Stream &Stream::ThenBlasHbmv(blas::UpperLower uplo, uint64 n, uint64 k,
 
2757: Stream &Stream::ThenBlasHbmv(blas::UpperLower uplo, uint64 n, uint64 k,
 
2776: Stream &Stream::ThenBlasHemv(blas::UpperLower uplo, uint64 n,
 
2795: Stream &Stream::ThenBlasHemv(blas::UpperLower uplo, uint64 n,
 
2814: Stream &Stream::ThenBlasHer(blas::UpperLower uplo, uint64 n, float alpha,
 
2828: Stream &Stream::ThenBlasHer(blas::UpperLower uplo, uint64 n, double alpha,
 
2842: Stream &Stream::ThenBlasHer2(blas::UpperLower uplo, uint64 n,
 
2860: Stream &Stream::ThenBlasHer2(blas::UpperLower uplo, uint64 n,
 
2878: Stream &Stream::ThenBlasHpmv(blas::UpperLower uplo, uint64 n,
 
2896: Stream &Stream::ThenBlasHpmv(blas::UpperLower uplo, uint64 n,
 
2914: Stream &Stream::ThenBlasHpr(blas::UpperLower uplo, uint64 n, float alpha,
 
2926: Stream &Stream::ThenBlasHpr(blas::UpperLower uplo, uint64 n, double alpha,
 
2938: Stream &Stream::ThenBlasHpr2(blas::UpperLower uplo, uint64 n,
 
2955: Stream &Stream::ThenBlasHpr2(blas::UpperLower uplo, uint64 n,
 
2972: Stream &Stream::ThenBlasSbmv(blas::UpperLower uplo, uint64 n, uint64 k,
 
2986: Stream &Stream::ThenBlasSbmv(blas::UpperLower uplo, uint64 n, uint64 k,
 
3000: Stream &Stream::ThenBlasSpmv(blas::UpperLower uplo, uint64 n, float alpha,
 
3014: Stream &Stream::ThenBlasSpmv(blas::UpperLower uplo, uint64 n, double alpha,
 
3028: Stream &Stream::ThenBlasSpr(blas::UpperLower uplo, uint64 n, float alpha,
 
3039: Stream &Stream::ThenBlasSpr(blas::UpperLower uplo, uint64 n, double alpha,
 
3050: Stream &Stream::ThenBlasSpr2(blas::UpperLower uplo, uint64 n, float alpha,
 
3064: Stream &Stream::ThenBlasSpr2(blas::UpperLower uplo, uint64 n, double alpha,
 
3078: Stream &Stream::ThenBlasSymv(blas::UpperLower uplo, uint64 n, float alpha,
 
3092: Stream &Stream::ThenBlasSymv(blas::UpperLower uplo, uint64 n, double alpha,
 
3106: Stream &Stream::ThenBlasSyr(blas::UpperLower uplo, uint64 n, float alpha,
 
3118: Stream &Stream::ThenBlasSyr(blas::UpperLower uplo, uint64 n, double alpha,
 
3130: Stream &Stream::ThenBlasSyr2(blas::UpperLower uplo, uint64 n, float alpha,
 
3144: Stream &Stream::ThenBlasSyr2(blas::UpperLower uplo, uint64 n, double alpha,
 
3158: Stream &Stream::ThenBlasTbmv(blas::UpperLower uplo, blas::Transpose trans,
 
3172: Stream &Stream::ThenBlasTbmv(blas::UpperLower uplo, blas::Transpose trans,
 
3186: Stream &Stream::ThenBlasTbmv(blas::UpperLower uplo, blas::Transpose trans,
 
3201: Stream &Stream::ThenBlasTbmv(blas::UpperLower uplo, blas::Transpose trans,
 
3216: Stream &Stream::ThenBlasTbsv(blas::UpperLower uplo, blas::Transpose trans,
 
3230: Stream &Stream::ThenBlasTbsv(blas::UpperLower uplo, blas::Transpose trans,
 
3244: Stream &Stream::ThenBlasTbsv(blas::UpperLower uplo, blas::Transpose trans,
 
3259: Stream &Stream::ThenBlasTbsv(blas::UpperLower uplo, blas::Transpose trans,
 
3274: Stream &Stream::ThenBlasTpmv(blas::UpperLower uplo, blas::Transpose trans,
 
3287: Stream &Stream::ThenBlasTpmv(blas::UpperLower uplo, blas::Transpose trans,
 
3300: Stream &Stream::ThenBlasTpmv(blas::UpperLower uplo, blas::Transpose trans,
 
3314: Stream &Stream::ThenBlasTpmv(blas::UpperLower uplo, blas::Transpose trans,
 
3328: Stream &Stream::ThenBlasTpsv(blas::UpperLower uplo, blas::Transpose trans,
 
3341: Stream &Stream::ThenBlasTpsv(blas::UpperLower uplo, blas::Transpose trans,
 
3354: Stream &Stream::ThenBlasTpsv(blas::UpperLower uplo, blas::Transpose trans,
 
3368: Stream &Stream::ThenBlasTpsv(blas::UpperLower uplo, blas::Transpose trans,
 
3382: Stream &Stream::ThenBlasTrmv(blas::UpperLower uplo, blas::Transpose trans,
 
3396: Stream &Stream::ThenBlasTrmv(blas::UpperLower uplo, blas::Transpose trans,
 
3410: Stream &Stream::ThenBlasTrmv(blas::UpperLower uplo, blas::Transpose trans,
 
3425: Stream &Stream::ThenBlasTrmv(blas::UpperLower uplo, blas::Transpose trans,
 
3440: Stream &Stream::ThenBlasTrsv(blas::UpperLower uplo, blas::Transpose trans,
 
3454: Stream &Stream::ThenBlasTrsv(blas::UpperLower uplo, blas::Transpose trans,
 
3468: Stream &Stream::ThenBlasTrsv(blas::UpperLower uplo, blas::Transpose trans,
 
3483: Stream &Stream::ThenBlasTrsv(blas::UpperLower uplo, blas::Transpose trans,
 
3498: Stream &Stream::ThenBlasGemm(blas::Transpose transa, blas::Transpose transb,
 
3516: Stream &Stream::ThenBlasGemm(blas::Transpose transa, blas::Transpose transb,
 
3532: Stream &Stream::ThenBlasGemm(blas::Transpose transa, blas::Transpose transb,
 
3548: Stream &Stream::ThenBlasGemm(blas::Transpose transa, blas::Transpose transb,
 
3569: Stream &Stream::ThenBlasGemm(blas::Transpose transa, blas::Transpose transb,
 
3597:   Stream &operator()(Stream *stream,
 
3599:                          Stream *, Args..., blas::ProfileResult *),
 
3608: Stream &Stream::ThenBlasGemvWithProfiling(
 
3625: Stream &Stream::ThenBlasGemvWithProfiling(
 
3643: Stream &Stream::ThenBlasGemvWithProfiling(
 
3663: Stream &Stream::ThenBlasGemvWithProfiling(
 
3683: Stream &Stream::ThenBlasGemmWithProfiling(
 
3703: Stream &Stream::ThenBlasGemmWithProfiling(
 
3722: Stream &Stream::ThenBlasGemmWithProfiling(
 
3742: Stream &Stream::ThenBlasGemmWithProfiling(
 
3764: Stream &Stream::ThenBlasGemmWithProfiling(
 
3786: Stream &Stream::ThenBlasGemmWithAlgorithm(
 
3811: Stream &Stream::ThenBlasGemmWithAlgorithm(
 
3834: Stream &Stream::ThenBlasGemmWithAlgorithm(
 
3857: Stream &Stream::ThenBlasGemmWithAlgorithm(
 
3881: Stream &Stream::ThenBlasGemmWithAlgorithm(
 
3909: Stream &Stream::ThenBlasGemmWithAlgorithm(
 
3937: Stream &Stream::ThenBlasHemm(blas::Side side, blas::UpperLower uplo, uint64 m,
 
3957: Stream &Stream::ThenBlasHemm(blas::Side side, blas::UpperLower uplo, uint64 m,
 
3977: Stream &Stream::ThenBlasHerk(blas::UpperLower uplo, blas::Transpose trans,
 
3992: Stream &Stream::ThenBlasHerk(blas::UpperLower uplo, blas::Transpose trans,
 
4007: Stream &Stream::ThenBlasHer2k(blas::UpperLower uplo, blas::Transpose trans,
 
4026: Stream &Stream::ThenBlasHer2k(blas::UpperLower uplo, blas::Transpose trans,
 
4045: Stream &Stream::ThenBlasSymm(blas::Side side, blas::UpperLower uplo, uint64 m,
 
4061: Stream &Stream::ThenBlasSymm(blas::Side side, blas::UpperLower uplo, uint64 m,
 
4077: Stream &Stream::ThenBlasSymm(blas::Side side, blas::UpperLower uplo, uint64 m,
 
4097: Stream &Stream::ThenBlasSymm(blas::Side side, blas::UpperLower uplo, uint64 m,
 
4117: Stream &Stream::ThenBlasSyrk(blas::UpperLower uplo, blas::Transpose trans,
 
4131: Stream &Stream::ThenBlasSyrk(blas::UpperLower uplo, blas::Transpose trans,
 
4145: Stream &Stream::ThenBlasSyrk(blas::UpperLower uplo, blas::Transpose trans,
 
4161: Stream &Stream::ThenBlasSyrk(blas::UpperLower uplo, blas::Transpose trans,
 
4177: Stream &Stream::ThenBlasSyr2k(blas::UpperLower uplo, blas::Transpose trans,
 
4193: Stream &Stream::ThenBlasSyr2k(blas::UpperLower uplo, blas::Transpose trans,
 
4209: Stream &Stream::ThenBlasSyr2k(blas::UpperLower uplo, blas::Transpose trans,
 
4229: Stream &Stream::ThenBlasSyr2k(blas::UpperLower uplo, blas::Transpose trans,
 
4249: Stream &Stream::ThenBlasTrmm(blas::Side side, blas::UpperLower uplo,
 
4264: Stream &Stream::ThenBlasTrmm(blas::Side side, blas::UpperLower uplo,
 
4279: Stream &Stream::ThenBlasTrmm(blas::Side side, blas::UpperLower uplo,
 
4296: Stream &Stream::ThenBlasTrmm(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,
 
4343: Stream &Stream::ThenBlasTrsm(blas::Side side, blas::UpperLower uplo,
 
4360: Stream &Stream::ThenBlasTrsm(blas::Side side, blas::UpperLower uplo,
 
4377: Stream &Stream::ThenBlasGemmBatched(
 
4389: Stream &Stream::ThenBlasGemmBatchedWithScratch(
 
4411: Stream &Stream::ThenBlasGemmBatched(
 
4422: Stream &Stream::ThenBlasGemmBatchedWithScratch(
 
4443: Stream &Stream::ThenBlasGemmBatched(
 
4454: Stream &Stream::ThenBlasGemmBatchedWithScratch(
 
4475: Stream &Stream::ThenBlasGemmBatched(
 
4488: Stream &Stream::ThenBlasGemmBatchedWithScratch(
 
4514: Stream &Stream::ThenBlasGemmBatched(
 
4527: Stream &Stream::ThenBlasGemmBatchedWithScratch(
 
4553: Stream &Stream::ThenBlasGemmStridedBatched(
 
4574: Stream &Stream::ThenBlasGemmStridedBatched(
 
4595: Stream &Stream::ThenBlasGemmStridedBatched(
 
4616: Stream &Stream::ThenBlasGemmStridedBatched(
 
4639: Stream &Stream::ThenBlasGemmStridedBatched(
 
4662: Stream &Stream::ThenSetRngSeed(const uint8 *seed, uint64 seed_bytes) {
 
4680: Stream &Stream::ThenPopulateRandUniform(DeviceMemory<float> *values) {
 
4696: Stream &Stream::ThenPopulateRandGaussian(float mean, float sd,
 
4713: Stream &Stream::ThenPopulateRandGaussian(double mean, double sd,
 
4730: Stream &Stream::ThenPopulateRandUniform(DeviceMemory<double> *values) {
 
4746: Stream &Stream::ThenPopulateRandUniform(
 
4763: Stream &Stream::ThenPopulateRandUniform(
 
4780: Stream &Stream::ThenMemcpy(void *host_dst, const DeviceMemoryBase &gpu_src,
 
4793: Stream &Stream::ThenMemcpy(DeviceMemoryBase *gpu_dst, const void *host_src,
 
4806: Stream &Stream::ThenMemcpy(DeviceMemoryBase *gpu_dst,
 
4819: Stream &Stream::ThenMemZero(DeviceMemoryBase *location, uint64 size) {
 
4831: Stream &Stream::ThenMemset32(DeviceMemoryBase *location, uint32 pattern,
 
4845: Stream &Stream::ThenRnnForward(
 
4882: Stream &Stream::ThenRnnForward(
 
4918: Stream &Stream::ThenRnnForward(
 
4955: Stream &Stream::ThenRnnBackward(
 
5002: Stream &Stream::ThenRnnBackward(
 
5048: Stream &Stream::ThenRnnBackward(
 
5095: Stream &Stream::ThenTransformTensor(const dnn::BatchDescriptor &input_desc,
 
5116: Stream &Stream::ThenDoHostCallback(std::function<void()> callback) {
 
5127: Stream &Stream::ThenDoHostCallbackWithStatus(
 
5139: Stream &Stream::ThenFft(fft::Plan *plan,
 
5157: Stream &Stream::ThenFft(fft::Plan *plan,
 
5175: Stream &Stream::ThenFft(fft::Plan *plan, const DeviceMemory<float> &input,
 
5192: Stream &Stream::ThenFft(fft::Plan *plan, const DeviceMemory<double> &input,
 
5209: Stream &Stream::ThenFft(fft::Plan *plan,
 
5227: Stream &Stream::ThenFft(fft::Plan *plan,
 
5247: Stream &Stream::ThenEnqueueOnBackgroundThread(
 
5259: port::Status Stream::BlockHostUntilDone() {
 
5283: void Stream::CheckStatus(port::Status status) {
 
259:                internal::StreamInterface *implementation)
 
280:     parent_->DeallocateStream(this);
 
298:   if (parent_->AllocateStream(this)) {
 
757:           << "attempting to perform DNN operation using StreamExecutor "
 
787:           << "attempting to perform DNN operation using StreamExecutor "
 
1238:           << "attempting to perform DNN operation using StreamExecutor "
 
1335:           << "attempting to perform DNN operation using StreamExecutor "
 
1755:       // The stream is reusable and not ok. Streams have a monotonic state
 
1801:       // The returned stream is not ok. Streams have a monotonic state
 
1904:           << "attempting to perform BLAS operation using StreamExecutor "
 
4689:                 << " attempting to perform RNG operation using StreamExecutor"
 
4706:                 << " attempting to perform RNG operation using StreamExecutor"
 
4723:                 << " attempting to perform RNG operation using StreamExecutor"
 
4739:                 << " attempting to perform RNG operation using StreamExecutor"
 
4756:                 << " attempting to perform RNG operation using StreamExecutor"
 
4773:                 << " attempting to perform RNG operation using StreamExecutor"
 
5150:                 << " attempting to perform FFT operation using StreamExecutor"
 
5168:                 << " attempting to perform FFT operation using StreamExecutor"
 
5185:                 << " attempting to perform FFT operation using StreamExecutor"
 
5202:                 << " attempting to perform FFT operation using StreamExecutor"
 
5220:                 << " attempting to perform FFT operation using StreamExecutor"
 
5238:                 << " attempting to perform FFT operation using StreamExecutor"
 
5248:     std::function<void(StreamExecutor *)> task) {
 
5251:   StreamExecutor *stream_executor = this->parent_;
 
214:   string str = absl::StrCat(stream->DebugStreamPointers(),
 
251:       implementation_(parent->implementation()->GetStreamImplementation()),
 
1749:         VLOG(1) << DebugStreamPointers() << " reusing sub_stream "
 
1750:                 << sub_stream->DebugStreamPointers();
 
1763:       VLOG(1) << DebugStreamPointers() << " dropped !ok sub_stream "
 
1764:               << sub_stream->DebugStreamPointers();
 
1779:   VLOG(1) << DebugStreamPointers() << " created new sub_stream "
 
1780:           << sub_stream->DebugStreamPointers();
 
1797:       VLOG(1) << DebugStreamPointers() << " returned ok sub_stream "
 
1798:               << sub_stream->DebugStreamPointers();
 
1804:       VLOG(1) << DebugStreamPointers() << " returned !ok sub_stream "
 
1805:               << sub_stream->DebugStreamPointers();
 
1815:   LOG(FATAL) << DebugStreamPointers()
 
1817:              << sub_stream->DebugStreamPointers();
 
1826:     LOG(INFO) << DebugStreamPointers()
 
1838:     LOG(INFO) << DebugStreamPointers()
 
1849:     CheckError(parent_->CreateStreamDependency(this, other));
 
1852:     LOG(INFO) << DebugStreamPointers() << " did not wait for "
 
1853:               << other->DebugStreamPointers();
 
1870:     LOG(INFO) << DebugStreamPointers() << " did not wait for an event.";
 
4670:       LOG(INFO) << DebugStreamPointers() << " unable to initialize RNG";
 
4673:     LOG(INFO) << DebugStreamPointers()
 
4688:       LOG(INFO) << DebugStreamPointers()
 
4705:       LOG(INFO) << DebugStreamPointers()
 
4722:       LOG(INFO) << DebugStreamPointers()
 
4738:       LOG(INFO) << DebugStreamPointers()
 
4755:       LOG(INFO) << DebugStreamPointers()
 
4772:       LOG(INFO) << DebugStreamPointers()
 
4787:     LOG(INFO) << DebugStreamPointers()
 
4800:     LOG(INFO) << DebugStreamPointers()
 
4813:     LOG(INFO) << DebugStreamPointers()
 
4825:     LOG(INFO) << DebugStreamPointers()
 
4838:     LOG(INFO) << DebugStreamPointers()
 
5120:     LOG(INFO) << DebugStreamPointers()
 
5132:     LOG(INFO) << DebugStreamPointers()
 
5149:       LOG(INFO) << DebugStreamPointers()
 
5167:       LOG(INFO) << DebugStreamPointers()
 
5184:       LOG(INFO) << DebugStreamPointers()
 
5201:       LOG(INFO) << DebugStreamPointers()
 
5219:       LOG(INFO) << DebugStreamPointers()
 
5237:       LOG(INFO) << DebugStreamPointers()
 
5266:     LOG(INFO) << DebugStreamPointers() << " " << status;
github.com/tensorflow/deepmath:fold/tensorflow/tensorflow/stream_executor/stream.cc: [ master, ] 
219: Stream::Stream(StreamExecutor *parent)
 
228: Stream::Stream(StreamExecutor *parent,
 
238: Stream::~Stream() {
 
1442: Stream *Stream::GetOrCreateSubStream() {
 
1459: void Stream::ReturnSubStream(Stream *sub_stream) {
 
178: // there are on Stream and how many parameters they each have.
 
179: string CallStr(const char *function_name, Stream *stream,
 
185:   string str = port::StrCat("Called Stream::", function_name, "(");
 
248: Stream &Stream::Init() {
 
267: Stream &Stream::InitTimer(Timer *timer) {
 
278: Stream &Stream::InitWithTimer(Timer *timer) {
 
284: Stream &Stream::ThenRecordEvent(Event *event) {
 
297: Stream &Stream::ThenBatchNormalizationForward(
 
325: Stream &Stream::ThenBatchNormalizationBackward(
 
347: Stream &Stream::ThenConvolveWithScratch(
 
375: Stream &Stream::ThenConvolveWithScratch(
 
402: Stream &Stream::ThenConvolveWithAlgorithm(
 
433: Stream &Stream::ThenConvolveWithAlgorithm(
 
464: Stream &Stream::ThenConvolve(
 
478: Stream &Stream::ThenConvolveQuantized(
 
508: Stream &Stream::ThenConvolveQuantized(
 
538: Stream &Stream::ThenSeparableConvolve(
 
565: Stream &Stream::ThenConvolveBackwardDataWithScratch(
 
593: Stream &Stream::ThenConvolveBackwardDataWithAlgorithm(
 
626: Stream &Stream::ThenConvolveBackwardDataWithAlgorithm(
 
659: Stream &Stream::ThenConvolveBackwardDataWithScratch(
 
687: Stream &Stream::ThenConvolveBackwardData(
 
701: Stream &Stream::ThenConvolveBackwardFilterWithScratch(
 
729: Stream &Stream::ThenConvolveBackwardFilterWithAlgorithm(
 
762: Stream &Stream::ThenConvolveBackwardFilterWithScratch(
 
790: Stream &Stream::ThenConvolveBackwardFilterWithAlgorithm(
 
823: Stream &Stream::ThenConvolveBackwardFilter(
 
838: Stream &Stream::ThenConvolveBackwardBiasImpl(
 
858: Stream &Stream::ThenConvolveBackwardBias(
 
867: Stream &Stream::ThenConvolveBackwardBias(
 
876: Stream &Stream::ThenConvolveBackwardBias(
 
885: Stream &Stream::ThenMatMul(const DeviceMemory<float> &input_data,
 
904: Stream &Stream::ThenMatMulQuantized(
 
926: Stream &Stream::ThenMatMulQuantized(
 
948: Stream &Stream::ThenBiasAdd(const DeviceMemory<float> &input_data,
 
966: Stream &Stream::ThenPoolForward(
 
987: Stream &Stream::ThenPoolForward(
 
1008: Stream &Stream::ThenPoolBackward(
 
1032: Stream &Stream::ThenPoolBackward(
 
1056: Stream &Stream::ThenNormalize(
 
1072: Stream &Stream::ThenNormalizeWithDimensions(
 
1090: Stream &Stream::ThenNormalizeBackwardWithDimensions(
 
1112: Stream &Stream::ThenActivate(dnn::ActivationMode activation_mode,
 
1120: Stream &Stream::ThenActivateWithOptions(dnn::ActivationMode activation_mode,
 
1139: Stream &Stream::ThenDepthConcatenate(
 
1169: Stream &Stream::ThenSpaceConcatenate(
 
1216: Stream &Stream::ThenReshape(const dnn::BatchDescriptor &input_dimensions,
 
1234: Stream &Stream::ThenDepthToSpace(
 
1255: Stream &Stream::ThenSpaceToDepth(
 
1276: Stream &Stream::ThenElementwiseOperate(
 
1297: Stream &Stream::ThenElementwiseOperateScaledQuantized(
 
1320: Stream &Stream::ThenXYPad(const dnn::BatchDescriptor &dimensions,
 
1339: Stream &Stream::ThenXYSlice(const dnn::BatchDescriptor &dimensions,
 
1360: Stream &Stream::ThenXYBroadcast(const dnn::BatchDescriptor &dimensions,
 
1378: Stream &Stream::ThenMemcpyD2HQuantized(
 
1395: Stream &Stream::ThenMemcpyH2DQuantized(
 
1412: Stream &Stream::ThenCopyHostBuffer2Device(
 
1427: Stream &Stream::ThenCopyDevice2HostBuffer(
 
1450:   sub_streams_.emplace_back(std::unique_ptr<Stream>{new Stream{parent_}},
 
1452:   Stream *sub_stream = sub_streams_.back().first.get();
 
1470: Stream &Stream::ThenStartTimer(Timer *t) {
 
1481: Stream &Stream::ThenStopTimer(Timer *t) {
 
1492: Stream &Stream::ThenWaitFor(Stream *other) {
 
1505: Stream &Stream::ThenWaitFor(Event *event) {
 
1527:   // arguments except the first one of Stream* type.
 
1528:   Stream &operator()(Stream *stream,
 
1529:                      bool (blas::BlasSupport::*blas_func)(Stream *, Args...),
 
1536:   Stream &Run(Stream *stream,
 
1537:               bool (blas::BlasSupport::*blas_func)(Stream *, Args...),
 
1542: Stream &ThenBlasImpl<Args...>::Run(
 
1543:     Stream *stream, bool (blas::BlasSupport::*blas_func)(Stream *, Args...),
 
1562: Stream &Stream::ThenBlasAsum(uint64 elem_count, const DeviceMemory<float> &x,
 
1572: Stream &Stream::ThenBlasAsum(uint64 elem_count, const DeviceMemory<double> &x,
 
1582: Stream &Stream::ThenBlasAsum(uint64 elem_count,
 
1593: Stream &Stream::ThenBlasAsum(uint64 elem_count,
 
1604: Stream &Stream::ThenBlasAxpy(uint64 elem_count, float alpha,
 
1616: Stream &Stream::ThenBlasAxpy(uint64 elem_count, double alpha,
 
1628: Stream &Stream::ThenBlasAxpy(uint64 elem_count, std::complex<float> alpha,
 
1642: Stream &Stream::ThenBlasAxpy(uint64 elem_count, std::complex<double> alpha,
 
1656: Stream &Stream::ThenBlasCopy(uint64 elem_count, const DeviceMemory<float> &x,
 
1666: Stream &Stream::ThenBlasCopy(uint64 elem_count, const DeviceMemory<double> &x,
 
1676: Stream &Stream::ThenBlasCopy(uint64 elem_count,
 
1688: Stream &Stream::ThenBlasCopy(uint64 elem_count,
 
1700: Stream &Stream::ThenBlasDot(uint64 elem_count, const DeviceMemory<float> &x,
 
1712: Stream &Stream::ThenBlasDot(uint64 elem_count, const DeviceMemory<double> &x,
 
1724: Stream &Stream::ThenBlasDotc(uint64 elem_count,
 
1740: Stream &Stream::ThenBlasDotc(uint64 elem_count,
 
1756: Stream &Stream::ThenBlasDotu(uint64 elem_count,
 
1772: Stream &Stream::ThenBlasDotu(uint64 elem_count,
 
1788: Stream &Stream::ThenBlasNrm2(uint64 elem_count, const DeviceMemory<float> &x,
 
1798: Stream &Stream::ThenBlasNrm2(uint64 elem_count, const DeviceMemory<double> &x,
 
1808: Stream &Stream::ThenBlasNrm2(uint64 elem_count,
 
1819: Stream &Stream::ThenBlasNrm2(uint64 elem_count,
 
1830: Stream &Stream::ThenBlasRot(uint64 elem_count, DeviceMemory<float> *x, int incx,
 
1842: Stream &Stream::ThenBlasRot(uint64 elem_count, DeviceMemory<double> *x,
 
1854: Stream &Stream::ThenBlasRot(uint64 elem_count,
 
1867: Stream &Stream::ThenBlasRot(uint64 elem_count,
 
1880: Stream &Stream::ThenBlasRotg(DeviceMemory<float> *a, DeviceMemory<float> *b,
 
1889: Stream &Stream::ThenBlasRotg(DeviceMemory<double> *a, DeviceMemory<double> *b,
 
1898: Stream &Stream::ThenBlasRotg(DeviceMemory<std::complex<float>> *a,
 
1910: Stream &Stream::ThenBlasRotg(DeviceMemory<std::complex<double>> *a,
 
1922: Stream &Stream::ThenBlasRotm(uint64 elem_count, DeviceMemory<float> *x,
 
1934: Stream &Stream::ThenBlasRotm(uint64 elem_count, DeviceMemory<double> *x,
 
1946: Stream &Stream::ThenBlasRotmg(DeviceMemory<float> *d1, DeviceMemory<float> *d2,
 
1958: Stream &Stream::ThenBlasRotmg(DeviceMemory<double> *d1,
 
1971: Stream &Stream::ThenBlasScal(uint64 elem_count, float alpha,
 
1979: Stream &Stream::ThenBlasScal(uint64 elem_count, double alpha,
 
1987: Stream &Stream::ThenBlasScal(uint64 elem_count, float alpha,
 
1995: Stream &Stream::ThenBlasScal(uint64 elem_count, double alpha,
 
2003: Stream &Stream::ThenBlasScal(uint64 elem_count, std::complex<float> alpha,
 
2012: Stream &Stream::ThenBlasScal(uint64 elem_count, std::complex<double> alpha,
 
2021: Stream &Stream::ThenBlasSwap(uint64 elem_count, DeviceMemory<float> *x,
 
2031: Stream &Stream::ThenBlasSwap(uint64 elem_count, DeviceMemory<double> *x,
 
2041: Stream &Stream::ThenBlasSwap(uint64 elem_count,
 
2052: Stream &Stream::ThenBlasSwap(uint64 elem_count,
 
2063: Stream &Stream::ThenBlasIamax(uint64 elem_count, const DeviceMemory<float> &x,
 
2073: Stream &Stream::ThenBlasIamax(uint64 elem_count, const DeviceMemory<double> &x,
 
2083: Stream &Stream::ThenBlasIamax(uint64 elem_count,
 
2094: Stream &Stream::ThenBlasIamax(uint64 elem_count,
 
2105: Stream &Stream::ThenBlasIamin(uint64 elem_count, const DeviceMemory<float> &x,
 
2115: Stream &Stream::ThenBlasIamin(uint64 elem_count, const DeviceMemory<double> &x,
 
2125: Stream &Stream::ThenBlasIamin(uint64 elem_count,
 
2136: Stream &Stream::ThenBlasIamin(uint64 elem_count,
 
2147: Stream &Stream::ThenBlasGbmv(blas::Transpose trans, uint64 m, uint64 n,
 
2163: Stream &Stream::ThenBlasGbmv(blas::Transpose trans, uint64 m, uint64 n,
 
2179: Stream &Stream::ThenBlasGbmv(blas::Transpose trans, uint64 m, uint64 n,
 
2199: Stream &Stream::ThenBlasGbmv(blas::Transpose trans, uint64 m, uint64 n,
 
2219: Stream &Stream::ThenBlasGemv(blas::Transpose trans, uint64 m, uint64 n,
 
2234: Stream &Stream::ThenBlasGemv(blas::Transpose trans, uint64 m, uint64 n,
 
2249: Stream &Stream::ThenBlasGemv(blas::Transpose trans, uint64 m, uint64 n,
 
2269: Stream &Stream::ThenBlasGemv(blas::Transpose trans, uint64 m, uint64 n,
 
2289: Stream &Stream::ThenBlasGer(uint64 m, uint64 n, float alpha,
 
2303: Stream &Stream::ThenBlasGer(uint64 m, uint64 n, double alpha,
 
2317: Stream &Stream::ThenBlasGerc(uint64 m, uint64 n, std::complex<float> alpha,
 
2334: Stream &Stream::ThenBlasGerc(uint64 m, uint64 n, std::complex<double> alpha,
 
2351: Stream &Stream::ThenBlasGeru(uint64 m, uint64 n, std::complex<float> alpha,
 
2368: Stream &Stream::ThenBlasGeru(uint64 m, uint64 n, std::complex<double> alpha,
 
2385: Stream &Stream::ThenBlasHbmv(blas::UpperLower uplo, uint64 n, uint64 k,
 
2404: Stream &Stream::ThenBlasHbmv(blas::UpperLower uplo, uint64 n, uint64 k,
 
2423: Stream &Stream::ThenBlasHemv(blas::UpperLower uplo, uint64 n,
 
2442: Stream &Stream::ThenBlasHemv(blas::UpperLower uplo, uint64 n,
 
2461: Stream &Stream::ThenBlasHer(blas::UpperLower uplo, uint64 n, float alpha,
 
2475: Stream &Stream::ThenBlasHer(blas::UpperLower uplo, uint64 n, double alpha,
 
2489: Stream &Stream::ThenBlasHer2(blas::UpperLower uplo, uint64 n,
 
2507: Stream &Stream::ThenBlasHer2(blas::UpperLower uplo, uint64 n,
 
2525: Stream &Stream::ThenBlasHpmv(blas::UpperLower uplo, uint64 n,
 
2543: Stream &Stream::ThenBlasHpmv(blas::UpperLower uplo, uint64 n,
 
2561: Stream &Stream::ThenBlasHpr(blas::UpperLower uplo, uint64 n, float alpha,
 
2573: Stream &Stream::ThenBlasHpr(blas::UpperLower uplo, uint64 n, double alpha,
 
2585: Stream &Stream::ThenBlasHpr2(blas::UpperLower uplo, uint64 n,
 
2602: Stream &Stream::ThenBlasHpr2(blas::UpperLower uplo, uint64 n,
 
2619: Stream &Stream::ThenBlasSbmv(blas::UpperLower uplo, uint64 n, uint64 k,
 
2633: Stream &Stream::ThenBlasSbmv(blas::UpperLower uplo, uint64 n, uint64 k,
 
2647: Stream &Stream::ThenBlasSpmv(blas::UpperLower uplo, uint64 n, float alpha,
 
2661: Stream &Stream::ThenBlasSpmv(blas::UpperLower uplo, uint64 n, double alpha,
 
2675: Stream &Stream::ThenBlasSpr(blas::UpperLower uplo, uint64 n, float alpha,
 
2686: Stream &Stream::ThenBlasSpr(blas::UpperLower uplo, uint64 n, double alpha,
 
2697: Stream &Stream::ThenBlasSpr2(blas::UpperLower uplo, uint64 n, float alpha,
 
2711: Stream &Stream::ThenBlasSpr2(blas::UpperLower uplo, uint64 n, double alpha,
 
2725: Stream &Stream::ThenBlasSymv(blas::UpperLower uplo, uint64 n, float alpha,
 
2739: Stream &Stream::ThenBlasSymv(blas::UpperLower uplo, uint64 n, double alpha,
 
2753: Stream &Stream::ThenBlasSyr(blas::UpperLower uplo, uint64 n, float alpha,
 
2765: Stream &Stream::ThenBlasSyr(blas::UpperLower uplo, uint64 n, double alpha,
 
2777: Stream &Stream::ThenBlasSyr2(blas::UpperLower uplo, uint64 n, float alpha,
 
2791: Stream &Stream::ThenBlasSyr2(blas::UpperLower uplo, uint64 n, double alpha,
 
2805: Stream &Stream::ThenBlasTbmv(blas::UpperLower uplo, blas::Transpose trans,
 
2819: Stream &Stream::ThenBlasTbmv(blas::UpperLower uplo, blas::Transpose trans,
 
2833: Stream &Stream::ThenBlasTbmv(blas::UpperLower uplo, blas::Transpose trans,
 
2848: Stream &Stream::ThenBlasTbmv(blas::UpperLower uplo, blas::Transpose trans,
 
2863: Stream &Stream::ThenBlasTbsv(blas::UpperLower uplo, blas::Transpose trans,
 
2877: Stream &Stream::ThenBlasTbsv(blas::UpperLower uplo, blas::Transpose trans,
 
2891: Stream &Stream::ThenBlasTbsv(blas::UpperLower uplo, blas::Transpose trans,
 
2906: Stream &Stream::ThenBlasTbsv(blas::UpperLower uplo, blas::Transpose trans,
 
2921: Stream &Stream::ThenBlasTpmv(blas::UpperLower uplo, blas::Transpose trans,
 
2934: Stream &Stream::ThenBlasTpmv(blas::UpperLower uplo, blas::Transpose trans,
 
2947: Stream &Stream::ThenBlasTpmv(blas::UpperLower uplo, blas::Transpose trans,
 
2961: Stream &Stream::ThenBlasTpmv(blas::UpperLower uplo, blas::Transpose trans,
 
2975: Stream &Stream::ThenBlasTpsv(blas::UpperLower uplo, blas::Transpose trans,
 
2988: Stream &Stream::ThenBlasTpsv(blas::UpperLower uplo, blas::Transpose trans,
 
3001: Stream &Stream::ThenBlasTpsv(blas::UpperLower uplo, blas::Transpose trans,
 
3015: Stream &Stream::ThenBlasTpsv(blas::UpperLower uplo, blas::Transpose trans,
 
3029: Stream &Stream::ThenBlasTrmv(blas::UpperLower uplo, blas::Transpose trans,
 
3043: Stream &Stream::ThenBlasTrmv(blas::UpperLower uplo, blas::Transpose trans,
 
3057: Stream &Stream::ThenBlasTrmv(blas::UpperLower uplo, blas::Transpose trans,
 
3072: Stream &Stream::ThenBlasTrmv(blas::UpperLower uplo, blas::Transpose trans,
 
3087: Stream &Stream::ThenBlasTrsv(blas::UpperLower uplo, blas::Transpose trans,
 
3101: Stream &Stream::ThenBlasTrsv(blas::UpperLower uplo, blas::Transpose trans,
 
3115: Stream &Stream::ThenBlasTrsv(blas::UpperLower uplo, blas::Transpose trans,
 
3130: Stream &Stream::ThenBlasTrsv(blas::UpperLower uplo, blas::Transpose trans,
 
3145: Stream &Stream::ThenBlasGemm(blas::Transpose transa, blas::Transpose transb,
 
3163: Stream &Stream::ThenBlasGemm(blas::Transpose transa, blas::Transpose transb,
 
3179: Stream &Stream::ThenBlasGemm(blas::Transpose transa, blas::Transpose transb,
 
3195: Stream &Stream::ThenBlasGemm(blas::Transpose transa, blas::Transpose transb,
 
3216: Stream &Stream::ThenBlasGemm(blas::Transpose transa, blas::Transpose transb,
 
3244:   Stream &operator()(Stream *stream,
 
3246:                          Stream *, Args..., blas::ProfileResult *),
 
3255: Stream &Stream::ThenBlasGemmWithAlgorithm(
 
3279: Stream &Stream::ThenBlasGemmWithAlgorithm(
 
3300: Stream &Stream::ThenBlasGemmWithAlgorithm(
 
3322: Stream &Stream::ThenBlasGemmWithAlgorithm(
 
3347: Stream &Stream::ThenBlasGemmWithAlgorithm(
 
3372: Stream &Stream::ThenBlasHemm(blas::Side side, blas::UpperLower uplo, uint64 m,
 
3392: Stream &Stream::ThenBlasHemm(blas::Side side, blas::UpperLower uplo, uint64 m,
 
3412: Stream &Stream::ThenBlasHerk(blas::UpperLower uplo, blas::Transpose trans,
 
3427: Stream &Stream::ThenBlasHerk(blas::UpperLower uplo, blas::Transpose trans,
 
3442: Stream &Stream::ThenBlasHer2k(blas::UpperLower uplo, blas::Transpose trans,
 
3461: Stream &Stream::ThenBlasHer2k(blas::UpperLower uplo, blas::Transpose trans,
 
3480: Stream &Stream::ThenBlasSymm(blas::Side side, blas::UpperLower uplo, uint64 m,
 
3496: Stream &Stream::ThenBlasSymm(blas::Side side, blas::UpperLower uplo, uint64 m,
 
3512: Stream &Stream::ThenBlasSymm(blas::Side side, blas::UpperLower uplo, uint64 m,
 
3532: Stream &Stream::ThenBlasSymm(blas::Side side, blas::UpperLower uplo, uint64 m,
 
3552: Stream &Stream::ThenBlasSyrk(blas::UpperLower uplo, blas::Transpose trans,
 
3566: Stream &Stream::ThenBlasSyrk(blas::UpperLower uplo, blas::Transpose trans,
 
3580: Stream &Stream::ThenBlasSyrk(blas::UpperLower uplo, blas::Transpose trans,
 
3596: Stream &Stream::ThenBlasSyrk(blas::UpperLower uplo, blas::Transpose trans,
 
3612: Stream &Stream::ThenBlasSyr2k(blas::UpperLower uplo, blas::Transpose trans,
 
3628: Stream &Stream::ThenBlasSyr2k(blas::UpperLower uplo, blas::Transpose trans,
 
3644: Stream &Stream::ThenBlasSyr2k(blas::UpperLower uplo, blas::Transpose trans,
 
3664: Stream &Stream::ThenBlasSyr2k(blas::UpperLower uplo, blas::Transpose trans,
 
3684: Stream &Stream::ThenBlasTrmm(blas::Side side, blas::UpperLower uplo,
 
3699: Stream &Stream::ThenBlasTrmm(blas::Side side, blas::UpperLower uplo,
 
3714: Stream &Stream::ThenBlasTrmm(blas::Side side, blas::UpperLower uplo,
 
3731: Stream &Stream::ThenBlasTrmm(blas::Side side, blas::UpperLower uplo,
 
3748: Stream &Stream::ThenBlasTrsm(blas::Side side, blas::UpperLower uplo,
 
3763: Stream &Stream::ThenBlasTrsm(blas::Side side, blas::UpperLower uplo,
 
3778: Stream &Stream::ThenBlasTrsm(blas::Side side, blas::UpperLower uplo,
 
3795: Stream &Stream::ThenBlasTrsm(blas::Side side, blas::UpperLower uplo,
 
3812: Stream &Stream::ThenBlasGemmBatched(
 
3823: Stream &Stream::ThenBlasGemmBatchedWithScratch(
 
3844: Stream &Stream::ThenBlasGemmBatched(
 
3855: Stream &Stream::ThenBlasGemmBatchedWithScratch(
 
3876: Stream &Stream::ThenBlasGemmBatched(
 
3889: Stream &Stream::ThenBlasGemmBatchedWithScratch(
 
3915: Stream &Stream::ThenBlasGemmBatched(
 
3928: Stream &Stream::ThenBlasGemmBatchedWithScratch(
 
3954: Stream &Stream::ThenSetRngSeed(const uint8 *seed, uint64 seed_bytes) {
 
3972: Stream &Stream::ThenPopulateRandUniform(DeviceMemory<float> *values) {
 
3987: Stream &Stream::ThenPopulateRandGaussian(float mean, float sd,
 
4003: Stream &Stream::ThenPopulateRandGaussian(double mean, double sd,
 
4019: Stream &Stream::ThenPopulateRandUniform(DeviceMemory<double> *values) {
 
4034: Stream &Stream::ThenPopulateRandUniform(
 
4050: Stream &Stream::ThenPopulateRandUniform(
 
4067: Stream &Stream::ThenMemcpy(void *host_dst, const DeviceMemoryBase &gpu_src,
 
4080: Stream &Stream::ThenMemcpy(DeviceMemoryBase *gpu_dst, const void *host_src,
 
4093: Stream &Stream::ThenMemcpy(DeviceMemoryBase *gpu_dst,
 
4106: Stream &Stream::ThenMemZero(DeviceMemoryBase *location, uint64 size) {
 
4118: Stream &Stream::ThenMemset32(DeviceMemoryBase *location, const uint32 &pattern,
 
4132: Stream &Stream::ThenRnnForward(
 
4164: Stream &Stream::ThenRnnBackward(
 
4205: Stream &Stream::ThenDoHostCallbackForTest(std::function<void()> callback) {
 
4211: Stream &Stream::ThenDoHostCallback(std::function<void()> callback) {
 
4223: Stream &Stream::ThenFft(fft::Plan *plan,
 
4240: Stream &Stream::ThenFft(fft::Plan *plan,
 
4257: Stream &Stream::ThenFft(fft::Plan *plan, const DeviceMemory<float> &input,
 
4273: Stream &Stream::ThenFft(fft::Plan *plan, const DeviceMemory<double> &input,
 
4289: Stream &Stream::ThenFft(fft::Plan *plan,
 
4306: Stream &Stream::ThenFft(fft::Plan *plan,
 
4325: Stream &Stream::ThenEnqueueOnBackgroundThread(
 
4337: bool Stream::BlockHostUntilDone() {
 
229:                internal::StreamInterface *implementation)
 
244:     parent_->DeallocateStream(this);
 
256:   if (parent_->AllocateStream(this)) {
 
501:           << "attempting to perform DNN operation using StreamExecutor "
 
531:           << "attempting to perform DNN operation using StreamExecutor "
 
1551:           << "attempting to perform BLAS operation using StreamExecutor "
 
3980:       LOG(INFO) << "attempting to perform RNG operation using StreamExecutor "
 
3996:       LOG(INFO) << "attempting to perform RNG operation using StreamExecutor "
 
4012:       LOG(INFO) << "attempting to perform RNG operation using StreamExecutor "
 
4027:       LOG(INFO) << "attempting to perform RNG operation using StreamExecutor "
 
4043:       LOG(INFO) << "attempting to perform RNG operation using StreamExecutor "
 
4060:                 << " attempting to perform RNG operation using StreamExecutor "
 
4233:       LOG(INFO) << "attempting to perform FFT operation using StreamExecutor "
 
4250:       LOG(INFO) << "attempting to perform FFT operation using StreamExecutor "
 
4266:       LOG(INFO) << "attempting to perform FFT operation using StreamExecutor "
 
4282:       LOG(INFO) << "attempting to perform FFT operation using StreamExecutor "
 
4299:       LOG(INFO) << "attempting to perform FFT operation using StreamExecutor "
 
4316:       LOG(INFO) << "attempting to perform FFT operation using StreamExecutor "
 
4326:     std::function<void(StreamExecutor *)> task) {
 
4329:   StreamExecutor *stream_executor = this->parent_;
 
221:       implementation_(parent->implementation()->GetStreamImplementation()),
 
1497:     CheckError(parent_->CreateStreamDependency(this, other));
github.com/googledatalab/datalab:third_party/externs/ts/node/node.d.ts: [ master, ] 
1131:     export interface Stream extends events.EventEmitter {

99:     export interface ReadableStream extends EventEmitter {

112:     export interface WritableStream extends EventEmitter {

123:     export interface ReadWriteStream extends ReadableStream, WritableStream {}

830:     export interface ReadStream extends stream.Readable {}

831:     export interface WriteStream extends stream.Writable {}

937:     export function createReadStream(path: string, options?: {

1027:     export interface ClearTextStream extends stream.Duplex {

1301:     export interface WriteStream extends net.Socket {

105:         pipe<T extends WritableStream>(destination: T, options?: { end?: boolean; }): T;

106:         unpipe<T extends WritableStream>(destination?: T): void;

109:         wrap(oldStream: ReadableStream): ReadableStream;

126:         stdout: WritableStream;

127:         stderr: WritableStream;

128:         stdin: ReadableStream;

561:         input?: NodeJS.ReadableStream;

562:         output?: NodeJS.WritableStream;

587:         input: NodeJS.ReadableStream;

588:         output: NodeJS.WritableStream;

930:     export function createReadStream(path: string, options?: {

936:     }): ReadStream;

943:     }): ReadStream;

944:     export function createWriteStream(path: string, options?: {

948:     }): WriteStream;

1049:     export function createServer(options: TlsOptions, secureConnectionListener?: (cleartextStream: ClearTextStream) =>void ): Server;

1050:     export function connect(options: TlsOptions, secureConnectionListener?: () =>void ): ClearTextStream;

1051: ...(32 bytes skipped)...: number, host?: string, options?: ConnectionOptions, secureConnectListener?: () =>void ): ClearTextStream;

1052: ...(17 bytes skipped)...on connect(port: number, options?: ConnectionOptions, secureConnectListener?: () =>void ): ClearTextStream;

1132:         pipe<T extends NodeJS.WritableStream>(destination: T, options?: { end?: boolean; }): T;

1141:     export class Readable extends events.EventEmitter implements NodeJS.ReadableStream {

1149:         pipe<T extends NodeJS.WritableStream>(destination: T, options?: { end?: boolean; }): T;

1150:         unpipe<T extends NodeJS.WritableStream>(destination?: T): void;

1153:         wrap(oldStream: NodeJS.ReadableStream): NodeJS.ReadableStream;

1162:     export class Writable extends events.EventEmitter implements NodeJS.WritableStream {

1181:     export class Duplex extends Readable implements NodeJS.ReadWriteStream {

1198:     export class Transform extends events.EventEmitter implements NodeJS.ReadWriteStream {

1209:         pipe<T extends NodeJS.WritableStream>(destination: T, options?: { end?: boolean; }): T;

1210:         unpipe<T extends NodeJS.WritableStream>(destination?: T): void;

1213:         wrap(oldStream: NodeJS.ReadableStream): NodeJS.ReadableStream;

1297:     export interface ReadStream extends net.Socket {
github.com/firebase/firebase-android-sdk:firebase-crashlytics-ndk/src/third_party/crashpad/third_party/cpp-httplib/cpp-httplib/httplib.h: [ master, ] 
161: class Stream {
 
163:     virtual ~Stream() {}
 
173: class SocketStream : public Stream {
 
308: class SSLSocketStream : public Stream {
 
1388: inline SocketStream::SocketStream(socket_t sock): sock_(sock)
 
1392: inline SocketStream::~SocketStream()
 
2221: inline SSLSocketStream::SSLSocketStream(socket_t sock, SSL* ssl)
 
2226: inline SSLSocketStream::~SSLSocketStream()
 
221:     bool process_request(Stream& strm, bool last_connection, bool& connection_close);
 
237:     void write_response(Stream& strm, bool last_connection, const Request& req, Response& res);
 
292:     bool process_request(Stream& strm, Request& req, Response& res, bool& connection_close);
 
301:     bool read_response_line(Stream& strm, Response& res);
 
302:     void write_request(Stream& strm, Request& req);
 
386:     stream_line_reader(Stream& strm, char* fixed_buffer, size_t fixed_buffer_size)
 
442:     Stream& strm_;
 
761: inline bool read_headers(Stream& strm, Headers& headers)
 
788: inline bool read_content_with_length(Stream& strm, std::string& out, size_t len, Progress progress)
 
808: inline bool read_content_without_length(Stream& strm, std::string& out)
 
824: inline bool read_content_chunked(Stream& strm, std::string& out)
 
870: bool read_content(Stream& strm, T& x, Progress progress = Progress())
 
890: inline void write_headers(Stream& strm, const T& info)
 
1358: inline void Stream::write_format(const char* fmt, const Args& ...args)
 
1539: inline void Server::write_response(Stream& strm, bool last_connection, const Request& req, Response& res)
 
1750: inline bool Server::process_request(Stream& strm, bool last_connection, bool& connection_close)
 
1837:         [this](Stream& strm, bool last_connection, bool& connection_close) {
 
1881: inline bool Client::read_response_line(Stream& strm, Response& res)
 
1917: inline void Client::write_request(Stream& strm, Request& req)
 
1964: inline bool Client::process_request(Stream& strm, Request& req, Response& res, bool& connection_close)
 
2001:         [&](Stream& strm, bool /*last_connection*/, bool& connection_close) {
 
2292:         [this](Stream& strm, bool last_connection, bool& connection_close) {
 
2325:         [&](Stream& strm, bool /*last_connection*/, bool& connection_close) {
 
175:     SocketStream(socket_t sock);
 
176:     virtual ~SocketStream();
 
310:     SSLSocketStream(socket_t sock, SSL* ssl);
 
311:     virtual ~SSLSocketStream();
 
510:             SocketStream strm(sock);
 
522:         SocketStream strm(sock);
 
1396: inline int SocketStream::read(char* ptr, size_t size)
 
1401: inline int SocketStream::write(const char* ptr, size_t size)
 
1406: inline int SocketStream::write(const char* ptr)
 
1411: inline std::string SocketStream::get_remote_addr() {
 
2179:             SSLSocketStream strm(sock, ssl);
 
2191:         SSLSocketStream strm(sock, ssl);
 
2230: inline int SSLSocketStream::read(char* ptr, size_t size)
 
2235: inline int SSLSocketStream::write(const char* ptr, size_t size)
 
2240: inline int SSLSocketStream::write(const char* ptr)
 
2245: inline std::string SSLSocketStream::get_remote_addr() {
android.googlesource.com/platform/external/mesa3d:src/mesa/main/mtypes.h: [ master, ] 
1809:    uint32_t Stream;
 
3268:    GLuint Stream;      /**< The stream */
 
1779:    uint32_t StreamId;
 
3053:       unsigned ActiveStreamMask;
 
3951:    GLuint MaxVertexStreams;
android.googlesource.com/platform/external/rust/crates/futures-core:src/stream.rs: [ master, ] 
27: pub trait Stream {
 
10: pub type BoxStream<'a, T> = Pin<alloc::boxed::Box<dyn Stream<Item = T> + Send + 'a>>;
 
14: pub type LocalBoxStream<'a, T> = Pin<alloc::boxed::Box<dyn Stream<Item = T> + 'a>>;
 
136: pub trait FusedStream: Stream {
 
167: pub trait TryStream: Stream + private_try_stream::Sealed {
 
7: /// An owned dynamically typed [`Stream`] for use in cases where you can't
 
18: /// If `Future<Output = T>` is an asynchronous version of `T`, then `Stream<Item
 
55:     /// problems; the `Stream` trait places no requirements on the effects of
 
100: impl<S: ?Sized + Stream + Unpin> Stream for &mut S {
 
112: impl<P> Stream for Pin<P>
 
115:     P::Target: Stream,
 
117:     type Item = <P::Target as Stream>::Item;
 
158:     use super::Stream;
 
162:     impl<S, T, E> Sealed for S where S: ?Sized + Stream<Item = Result<T, E>> {}
 
174:     /// Poll this `TryStream` as if it were a `Stream`.
 
177:     /// directly inheriting from the `Stream` trait; in the future it won't be
 
187:     S: ?Sized + Stream<Item = Result<T, E>>,
 
205:     impl<S: ?Sized + Stream + Unpin> Stream for Box<S> {
 
218:     impl<S: Stream> Stream for std::panic::AssertUnwindSafe<S> {
 
12: /// `BoxStream`, but without the `Send` requirement.
 
65:     /// [`fuse`]: https://docs.rs/futures/0.3/futures/stream/trait.StreamExt.html#method.fuse
 
141: impl<F: ?Sized + FusedStream + Unpin> FusedStream for &mut F {
 
143:         <F as FusedStream>::is_terminated(&**self)
 
147: impl<P> FusedStream for Pin<P>
 
150:     P::Target: FusedStream,
 
153:         <P::Target as FusedStream>::is_terminated(&**self)
 
185: impl<S, T, E> TryStream for S
 
230:     impl<S: ?Sized + FusedStream + Unpin> FusedStream for Box<S> {
 
232:             <S as FusedStream>::is_terminated(&**self)
android.googlesource.com/platform/external/rust/crates/atty:src/lib.rs: [ master, ] 
32: pub enum Stream {
 
7: //! if atty::is(atty::Stream::Stdout) {
 
13: //! if atty::isnt(atty::Stream::Stdout) {
 
40: pub fn is(stream: Stream) -> bool {
 
44:         Stream::Stdout => libc::STDOUT_FILENO,
 
45:         Stream::Stderr => libc::STDERR_FILENO,
 
46:         Stream::Stdin => libc::STDIN_FILENO,
 
53: pub fn is(stream: Stream) -> bool {
 
57:         Stream::Stdout => hermit_abi::STDOUT_FILENO,
 
58:         Stream::Stderr => hermit_abi::STDERR_FILENO,
 
59:         Stream::Stdin => hermit_abi::STDIN_FILENO,
 
66: pub fn is(stream: Stream) -> bool {
 
73:         Stream::Stdin => (STD_INPUT, [STD_ERROR, STD_OUTPUT]),
 
74:         Stream::Stderr => (STD_ERROR, [STD_INPUT, STD_OUTPUT]),
 
75:         Stream::Stdout => (STD_OUTPUT, [STD_INPUT, STD_ERROR]),
 
97: pub fn isnt(stream: Stream) -> bool {
 
158: pub fn is(_stream: Stream) -> bool {
 
164:     use super::{is, Stream};
 
170:         assert!(!is(Stream::Stderr))
 
177:         assert!(!is(Stream::Stdout))
 
183:         assert!(is(Stream::Stdin))
 
189:         assert!(is(Stream::Stderr))
 
195:         assert!(is(Stream::Stdout))
 
202:         assert!(is(Stream::Stdin))
 
208:         assert!(is(Stream::Stdin))
android.googlesource.com/platform/external/rust/crates/combine:src/stream/mod.rs: [ master, ] 
163: pub trait Stream: StreamOnce + ResetStream + Positioned {}
 
109: pub type StreamErrorFor<Input> = <<Input as StreamOnce>::Error as ParseError<
 
116: pub trait StreamOnce {
 
143: pub trait ResetStream: StreamOnce {
 
242: pub trait RangeStream: Stream + RangeStreamOnce {}
 
757: pub struct PartialStream<S>(pub S);
 
759: impl<S> From<S> for PartialStream<S> {
 
765: impl<S> Positioned for PartialStream<S>
 
775: impl<S> ResetStream for PartialStream<S>
 
792: impl<S> StreamOnce for PartialStream<S>
 
811: impl<S> RangeStreamOnce for PartialStream<S>
 
852: pub struct CompleteStream<S>(pub S);
 
854: impl<S> From<S> for CompleteStream<S> {
 
860: impl<'s, S> From<&'s mut S> for &'s mut CompleteStream<S> {
 
867: impl<S> Positioned for CompleteStream<S>
 
877: impl<S> ResetStream for CompleteStream<S>
 
894: impl<S> StreamOnce for CompleteStream<S>
 
913: impl<S> RangeStreamOnce for CompleteStream<S>
 
949: pub struct MaybePartialStream<S>(pub S, pub bool);
 
951: impl<S> Positioned for MaybePartialStream<S>
 
961: impl<S> ResetStream for MaybePartialStream<S>
 
978: impl<S> StreamOnce for MaybePartialStream<S>
 
997: impl<S> RangeStreamOnce for MaybePartialStream<S>
 
1034: pub struct SliceStream<'a, T>(pub &'a [T]);
 
1036: impl<'a, T> Clone for SliceStream<'a, T> {
 
1042: impl<'a, T> Positioned for SliceStream<'a, T>
 
1052: impl<'a, T> StreamOnce for SliceStream<'a, T>
 
1119: impl<'a, T> RangeStreamOnce for SliceStream<'a, T>
 
1172: pub struct IteratorStream<Input>(Input);
 
1174: impl<Input> IteratorStream<Input>
 
1190: impl<Input> Iterator for IteratorStream<Input>
 
1200: impl<Input: Iterator> StreamOnce for IteratorStream<Input>
 
184: pub trait RangeStreamOnce: StreamOnce + ResetStream {
 
5: //! which can be retrieved one by one. Where `Stream`s differ is that they are allowed to return
 
9: //! In addition to he functionality above, a proper `Stream` usable by a `Parser` must also have a
 
53: /// Stream wrapper which provides a `ResetStream` impl for `StreamOnce` impls which do not have
 
61: /// Stream wrapper which provides more detailed position information.
 
63: /// Stream wrapper allowing `std::io::Read` to be used
 
68: /// Stream wrapper allowing custom state to be used.
 
86: /// use combine::{easy, Parser, Stream, many1};
 
93: ///     where [ Input: Stream<Token = char>, ]
 
161: /// traits. If you need a custom `Stream` object then implement those traits and `Stream` is
 
165: impl<Input> Stream for Input
 
175:     Input: ?Sized + Stream,
 
241: /// A `RangeStream` is an extension of `Stream` which allows for zero copy parsing.
 
244: impl<Input> RangeStream for Input where Input: RangeStreamOnce + Stream {}
 
285:     Input: ?Sized + Stream,
 
755: /// Stream type which indicates that the stream is partial if end of input is reached
 
846: /// Stream type which indicates that the stream is complete if end of input is reached
 
1181:     ///     such as `BufferedStreamRef` and `State` to become a `Stream` which can be parsed
 
1402: ///         |input, _position| combine::easy::Stream::from(input),
 
1498: ///             |input, _position| combine::easy::Stream::from(input),
 
1592: ///             |input, _position| combine::easy::Stream::from(input),
 
1688: ///             |input, _position| combine::easy::Stream::from(input),
 
1784: ///             |input, _position| combine::easy::Stream::from(input),
 
4: //! Streams are similar to the `Iterator` trait in that they represent some sequential set of items
 
11: //! `ResetStream` trait). The former is used to ensure that errors at different points in the stream
 
21:         StreamError, StringStreamError, Tracked, UnexpectedParse,
 
33:         impl<$($params)*> ResetStream for $ty
 
34:             where Self: StreamOnce
 
76: pub trait Positioned: StreamOnce {
 
81: /// Convenience alias over the `StreamError` for the input stream `Input`
 
88: /// use combine::stream::StreamErrorFor;
 
89: /// use combine::error::{ParseError, StreamError};
 
99: ///                 // The alias makes it easy to refer to the `StreamError` type of `Input`
 
100: ///                 Err(StreamErrorFor::<Input>::expected_static_message("combine"))
 
110:     <Input as StreamOnce>::Token,
 
111:     <Input as StreamOnce>::Range,
 
112:     <Input as StreamOnce>::Position,
 
113: >>::StreamError;
 
115: /// `StreamOnce` represents a sequence of items that can be extracted one by one.
 
132:     fn uncons(&mut self) -> Result<Self::Token, StreamErrorFor<Self>>;
 
136:     /// See `PartialStream`.
 
142: /// A `StreamOnce` which can create checkpoints which the stream can be reset to
 
155: clone_resetable! {('a, T) SliceStream<'a, T> }
 
156: clone_resetable! {(T: Clone) IteratorStream<T>}
 
160: /// This is a trait over types which implement the `StreamOnce`, `ResetStream` and `Positioned`
 
167:     Input: StreamOnce + Positioned + ResetStream,
 
183: /// A `RangeStream` is an extension of `StreamOnce` which allows for zero copy parsing.
 
187:     fn uncons_range(&mut self, size: usize) -> Result<Self::Range, StreamErrorFor<Self>>;
 
191:     fn uncons_while<F>(&mut self, f: F) -> Result<Self::Range, StreamErrorFor<Self>>
 
202:     fn uncons_while1<F>(&mut self, mut f: F) -> ParseResult<Self::Range, StreamErrorFor<Self>>
 
220:             PeekErr(Tracked::from(StreamErrorFor::<Self>::end_of_input()))
 
223:                 StreamErrorFor::<Self>::unexpected_static_message(""),
 
249:     err: <Input::Error as ParseError<Input::Token, Input::Range, Input::Position>>::StreamError,
 
250: ) -> ParseResult<T, <Input as StreamOnce>::Error>
 
252:     Input: ?Sized + StreamOnce + Positioned,
 
266: ) -> ParseResult<Input::Range, <Input as StreamOnce>::Error>
 
268:     Input: ?Sized + RangeStream,
 
303:     Input: ?Sized + RangeStream,
 
314:                     StreamError::end_of_input(),
 
338:     Input: ?Sized + RangeStream,
 
347:                     StreamError::end_of_input(),
 
359:                     StreamError::end_of_input(),
 
371:                     StreamError::end_of_input(),
 
393: impl<'a, I> StreamOnce for &'a mut I
 
395:     I: StreamOnce + ?Sized,
 
404:     fn uncons(&mut self) -> Result<Self::Token, StreamErrorFor<Self>> {
 
423: impl<'a, I> ResetStream for &'a mut I
 
425:     I: ResetStream + ?Sized,
 
443:     fn uncons_while<F>(&mut self, f: F) -> Result<Self::Range, StreamErrorFor<Self>>
 
451:     fn uncons_while1<F>(&mut self, f: F) -> ParseResult<Self::Range, StreamErrorFor<Self>>
 
459:     fn uncons_range(&mut self, size: usize) -> Result<Self::Range, StreamErrorFor<Self>> {
 
482: impl<'a> StreamOnce for &'a str {
 
489:     fn uncons(&mut self) -> Result<char, StreamErrorFor<Self>> {
 
546:     fn uncons_while<F>(&mut self, f: F) -> Result<&'a str, StreamErrorFor<Self>>
 
554:     fn uncons_while1<F>(&mut self, mut f: F) -> ParseResult<Self::Range, StreamErrorFor<Self>>
 
572:     fn uncons_range(&mut self, size: usize) -> Result<&'a str, StreamErrorFor<Self>> {
 
677:     fn uncons_range(&mut self, size: usize) -> Result<&'a [T], StreamErrorFor<Self>> {
 
688:     fn uncons_while<F>(&mut self, f: F) -> Result<&'a [T], StreamErrorFor<Self>>
 
696:     fn uncons_while1<F>(&mut self, mut f: F) -> ParseResult<Self::Range, StreamErrorFor<Self>>
 
734: impl<'a, T> StreamOnce for &'a [T]
 
744:     fn uncons(&mut self) -> Result<T, StreamErrorFor<Self>> {
 
761:         PartialStream(t)
 
777:     S: ResetStream,
 
794:     S: StreamOnce,
 
802:     fn uncons(&mut self) -> Result<S::Token, StreamErrorFor<Self>> {
 
816:     fn uncons_range(&mut self, size: usize) -> Result<Self::Range, StreamErrorFor<Self>> {
 
821:     fn uncons_while<F>(&mut self, f: F) -> Result<Self::Range, StreamErrorFor<Self>>
 
828:     fn uncons_while1<F>(&mut self, f: F) -> ParseResult<Self::Range, StreamErrorFor<Self>>
 
849: /// `PartialStream`
 
856:         CompleteStream(t)
 
862:         // SAFETY repr(transparent) is specified on CompleteStream
 
863:         unsafe { &mut *(t as *mut S as *mut CompleteStream<S>) }
 
879:     S: ResetStream,
 
896:     S: StreamOnce,
 
904:     fn uncons(&mut self) -> Result<S::Token, StreamErrorFor<Self>> {
 
918:     fn uncons_range(&mut self, size: usize) -> Result<Self::Range, StreamErrorFor<Self>> {
 
923:     fn uncons_while<F>(&mut self, f: F) -> Result<Self::Range, StreamErrorFor<Self>>
 
930:     fn uncons_while1<F>(&mut self, f: F) -> ParseResult<Self::Range, StreamErrorFor<Self>>
 
963:     S: ResetStream,
 
980:     S: StreamOnce,
 
988:     fn uncons(&mut self) -> Result<S::Token, StreamErrorFor<Self>> {
 
1002:     fn uncons_range(&mut self, size: usize) -> Result<Self::Range, StreamErrorFor<Self>> {
 
1007:     fn uncons_while<F>(&mut self, f: F) -> Result<Self::Range, StreamErrorFor<Self>>
 
1014:     fn uncons_while1<F>(&mut self, f: F) -> ParseResult<Self::Range, StreamErrorFor<Self>>
 
1037:     fn clone(&self) -> SliceStream<'a, T> {
 
1038:         SliceStream(self.0)
 
1062:     fn uncons(&mut self) -> Result<&'a T, StreamErrorFor<Self>> {
 
1124:     fn uncons_range(&mut self, size: usize) -> Result<&'a [T], StreamErrorFor<Self>> {
 
1135:     fn uncons_while<F>(&mut self, f: F) -> Result<&'a [T], StreamErrorFor<Self>>
 
1143:     fn uncons_while1<F>(&mut self, mut f: F) -> ParseResult<Self::Range, StreamErrorFor<Self>>
 
1170: /// Returned by [`IteratorStream::new`].
 
1182:     pub fn new<T>(iter: T) -> IteratorStream<Input>
 
1186:         IteratorStream(iter.into_iter())
 
1210:     fn uncons(&mut self) -> Result<Self::Token, StreamErrorFor<Self>> {
 
1311: ) -> Result<(Option<P::Output>, usize), <Input as StreamOnce>::Error>
 
1314:     Input: RangeStream,
 
1350: ) -> Result<(Option<P::Output>, usize), <Input as StreamOnce>::Error>
 
1353:     Input: RangeStream,
 
1429:                             $crate::stream::MaybePartialStream(buffer, !end_of_input),
 
1527:                             $crate::stream::MaybePartialStream(buffer, !end_of_input),
 
1619:                             $crate::stream::MaybePartialStream(buffer, !end_of_input),
 
1715:                             $crate::stream::MaybePartialStream(buffer, !end_of_input),
 
1811:                             $crate::stream::MaybePartialStream(buffer, !end_of_input),
 
1878:         assert_eq!(SliceStream(s).uncons_range(0), Ok(&[][..]));
 
6: //! errors instead of just `None` and if they implement the `RangeStreamOnce` trait they are also
 
438: impl<'a, I> RangeStreamOnce for &'a mut I
 
440:     I: RangeStreamOnce + ?Sized,
 
486:     type Error = StringStreamError;
 
496:             None => Err(StringStreamError::Eoi),
 
545: impl<'a> RangeStreamOnce for &'a str {
 
562:                     return PeekErr(Tracked::from(StringStreamError::UnexpectedParse));
 
565:             None => return PeekErr(Tracked::from(StringStreamError::Eoi)),
 
588:                 Err(StringStreamError::CharacterBoundary)
 
591:             Err(StringStreamError::Eoi)
 
672: impl<'a, T> RangeStreamOnce for &'a [T]
 
813:     S: RangeStreamOnce,
 
915:     S: RangeStreamOnce,
 
999:     S: RangeStreamOnce,
android.googlesource.com/platform/frameworks/compile/libbcc:bcinfo/BitReader_2_7/BitcodeReader.cpp: [ master, ] 
191:   BitstreamCursor Stream;
 
190:   std::unique_ptr<BitstreamReader> StreamFile;
 
3416: std::error_code BitcodeReader::InitStream() {
 
3441: std::error_code BitcodeReader::InitLazyStream() {
 
192:   std::unique_ptr<DataStreamer> LazyStreamer;
 
3422: std::error_code BitcodeReader::InitStreamFromBuffer() {
 
838:   if (Stream.EnterSubBlock(bitc::PARAMATTR_BLOCK_ID))
 
850:     BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
 
865:     switch (Stream.readRecord(Entry.ID, Record)) {
 
896:   if (Stream.EnterSubBlock(bitc::TYPE_BLOCK_ID_NEW))
 
913:     BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
 
931:     switch (Stream.readRecord(Entry.ID, Record)) {
 
1105:   if (Stream.EnterSubBlock(TYPE_BLOCK_ID_OLD_3_0))
 
1115:   BitstreamCursor StartOfTypeBlockCursor(Stream);
 
1126:     unsigned Code = Stream.ReadCode();
 
1138:         Stream = StartOfTypeBlockCursor;
 
1142:       if (Stream.ReadBlockEnd())
 
1149:       Stream.ReadSubBlockID();
 
1150:       if (Stream.SkipBlock())
 
1156:       Stream.ReadAbbrevRecord();
 
1163:     switch (Stream.readRecord(Code, Record)) {
 
1294:   if (Stream.EnterSubBlock(TYPE_SYMTAB_BLOCK_ID_OLD_3_0))
 
1302:     unsigned Code = Stream.ReadCode();
 
1304:       if (Stream.ReadBlockEnd())
 
1311:       Stream.ReadSubBlockID();
 
1312:       if (Stream.SkipBlock())
 
1318:       Stream.ReadAbbrevRecord();
 
1324:     switch (Stream.readRecord(Code, Record)) {
 
1345:   if (Stream.EnterSubBlock(bitc::VALUE_SYMTAB_BLOCK_ID))
 
1353:     unsigned Code = Stream.ReadCode();
 
1355:       if (Stream.ReadBlockEnd())
 
1361:       Stream.ReadSubBlockID();
 
1362:       if (Stream.SkipBlock())
 
1368:       Stream.ReadAbbrevRecord();
 
1374:     switch (Stream.readRecord(Code, Record)) {
 
1407:   if (Stream.EnterSubBlock(bitc::METADATA_BLOCK_ID))
 
1414:     unsigned Code = Stream.ReadCode();
 
1416:       if (Stream.ReadBlockEnd())
 
1423:       Stream.ReadSubBlockID();
 
1424:       if (Stream.SkipBlock())
 
1430:       Stream.ReadAbbrevRecord();
 
1437:     Code = Stream.readRecord(Code, Record);
 
1449:       Code = Stream.ReadCode();
 
1452:       unsigned NextBitCode = Stream.readRecord(Code, Record);
 
1626:   if (Stream.EnterSubBlock(bitc::CONSTANTS_BLOCK_ID))
 
1635:     BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
 
1657:     unsigned BitCode = Stream.readRecord(Entry.ID, Record);
 
1961:   if (Stream.ReadBlockEnd())
 
1988:   uint64_t CurBit = Stream.GetCurrentBitNo();
 
1992:   if (Stream.SkipBlock())
 
2028:     Stream.JumpToBit(NextUnreadBit);
 
2029:   else if (Stream.EnterSubBlock(bitc::MODULE_BLOCK_ID))
 
2037:   while (!Stream.AtEndOfStream()) {
 
2038:     unsigned Code = Stream.ReadCode();
 
2040:       if (Stream.ReadBlockEnd())
 
2073:       switch (Stream.ReadSubBlockID()) {
 
2075:         if (Stream.SkipBlock())
 
2079:         if (Stream.ReadBlockInfoBlock())
 
2132:           NextUnreadBit = Stream.GetCurrentBitNo();
 
2142:       Stream.ReadAbbrevRecord();
 
2147:     switch (Stream.readRecord(Code, Record)) {
 
2347:   if (Stream.Read(8) != 'B' ||
 
2348:       Stream.Read(8) != 'C' ||
 
2349:       Stream.Read(4) != 0x0 ||
 
2350:       Stream.Read(4) != 0xC ||
 
2351:       Stream.Read(4) != 0xE ||
 
2352:       Stream.Read(4) != 0xD)
 
2358:     if (Stream.AtEndOfStream())
 
2362:       Stream.advance(BitstreamCursor::AF_DontAutoprocessAbbrevs);
 
2373:         if (Stream.ReadBlockInfoBlock())
 
2387:         if (Stream.SkipBlock())
 
2398:       if (Stream.getAbbrevIDWidth() == 2 && Entry.ID == 2 &&
 
2399:           Stream.Read(6) == 2 && Stream.Read(24) == 0xa0a0a &&
 
2400:           Stream.AtEndOfStream())
 
2409:   if (Stream.EnterSubBlock(bitc::MODULE_BLOCK_ID))
 
2417:     BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
 
2431:     switch (Stream.readRecord(Entry.ID, Record)) {
 
2459:   if (Stream.Read(8) != 'B' ||
 
2460:       Stream.Read(8) != 'C' ||
 
2461:       Stream.Read(4) != 0x0 ||
 
2462:       Stream.Read(4) != 0xC ||
 
2463:       Stream.Read(4) != 0xE ||
 
2464:       Stream.Read(4) != 0xD)
 
2470:     BitstreamEntry Entry = Stream.advance();
 
2483:       if (Stream.SkipBlock())
 
2488:       Stream.skipRecord(Entry.ID);
 
2496:   if (Stream.EnterSubBlock(bitc::METADATA_ATTACHMENT_ID))
 
2501:     BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
 
2516:     switch (Stream.readRecord(Entry.ID, Record)) {
 
2543:   if (Stream.EnterSubBlock(bitc::FUNCTION_BLOCK_ID))
 
2563:     unsigned Code = Stream.ReadCode();
 
2565:       if (Stream.ReadBlockEnd())
 
2571:       switch (Stream.ReadSubBlockID()) {
 
2573:         if (Stream.SkipBlock())
 
2598:       Stream.ReadAbbrevRecord();
 
2605:     unsigned BitCode = Stream.readRecord(Code, Record);
 
3332:   Stream.JumpToBit(DFII->second);
 
3436:   Stream.init(&*StreamFile);
 
3448:   Stream.init(&*StreamFile);
 
354:   std::error_code InitStream();
 
356:   std::error_code InitLazyStream();
 
2343:   if (std::error_code EC = InitStream())
 
2455:   if (std::error_code EC = InitStream())
 
3418:     return InitLazyStream();
 
3435:   StreamFile.reset(new BitstreamReader(BufPtr, BufEnd));
 
3444:   auto OwnedBytes = llvm::make_unique<StreamingMemoryObject>(
 
3446:   StreamingMemoryObject &Bytes = *OwnedBytes;
 
3447:   StreamFile = llvm::make_unique<BitstreamReader>(std::move(OwnedBytes));
 
355:   std::error_code InitStreamFromBuffer();
 
395:       TheModule(nullptr), Buffer(buffer), LazyStreamer(nullptr),
 
2131:         if (LazyStreamer && SeenValueSymbolTable) {
 
2299:         if (LazyStreamer)
 
2383:         if (LazyStreamer)
 
3417:   if (LazyStreamer)
 
3419:   return InitStreamFromBuffer();
 
3445:       std::move(LazyStreamer));
go.googlesource.com/grpc-review:transport/transport.go: [ master, ] 
165: type Stream struct {
 
309: func newContextWithStream(ctx context.Context, stream *Stream) context.Context {
 
314: func StreamFromContext(ctx context.Context) (s *Stream, ok bool) {
 
391: 	NewStream(ctx context.Context, callHdr *CallHdr) (*Stream, error)
 
397: 	CloseStream(stream *Stream, err error)
 
427: func StreamErrorf(c codes.Code, format string, a ...interface{}) StreamError {
 
455: type StreamError struct {
 
417: 	HandleStreams(func(*Stream))
 
164: // Stream represents an RPC in the transport layer.
 
167: 	// nil for client side Stream.
 
208: func (s *Stream) RecvCompress() string {
 
213: func (s *Stream) SetSendCompress(str string) {
 
220: func (s *Stream) Header() (metadata.MD, error) {
 
232: func (s *Stream) Trailer() metadata.MD {
 
240: func (s *Stream) ServerTransport() ServerTransport {
 
245: func (s *Stream) Context() context.Context {
 
250: func (s *Stream) TraceContext(tr trace.Trace) {
 
255: func (s *Stream) Method() string {
 
260: func (s *Stream) StatusCode() codes.Code {
 
265: func (s *Stream) StatusDesc() string {
 
275: func (s *Stream) SetTrailer(md metadata.MD) error {
 
285: func (s *Stream) write(m recvMsg) {
 
289: // Read reads all the data available for this Stream from the transport and
 
293: func (s *Stream) Read(p []byte) (n int, err error) {
 
304: // The key to save transport.Stream in the context.
 
315: 	s, ok = ctx.Value(streamKey).(*Stream)
 
388: 	Write(s *Stream, data []byte, opts *Options) error
 
390: 	// NewStream creates a Stream for an RPC.
 
411: 	WriteStatus(s *Stream, statusCode codes.Code, statusDesc string) error
 
413: 	Write(s *Stream, data []byte, opts *Options) error
 
415: 	WriteHeader(s *Stream, md metadata.MD) error
 
159: 	streamWriteDone             // EndStream sent
 
160: 	streamReadDone              // EndStream received
 
307: // newContextWithStream creates a new context from ctx and attaches stream
 
313: // StreamFromContext returns the stream saved in ctx.
 
393: 	// CloseStream clears the footprint of a stream when the stream is
 
395: 	// CloseStream is called. Must be called when a stream is finished
 
426: // StreamErrorf creates an StreamError with the specified error code and description.
 
428: 	return StreamError{
 
454: // StreamError is an error that only affects one stream within a connection.
 
460: func (e StreamError) Error() string {
 
464: // ContextErr converts the error from context package into a StreamError.
 
465: func ContextErr(err error) StreamError {
 
468: 		return StreamErrorf(codes.DeadlineExceeded, "%v", err)
 
470: 		return StreamErrorf(codes.Canceled, "%v", err)
 
476: // If it receives from ctx.Done, it returns 0, the StreamError for ctx.Err.
 
161: 	streamDone                  // sendDone and recvDone or RSTStreamFrame is sent or received.
 
330: func NewServerTransport(protocol string, conn net.Conn, maxStreams uint32, authInfo credentials.AuthInfo) (ServerTransport, error) {
 
331: 	return newHTTP2Server(conn, maxStreams, authInfo)
 
416: 	// HandleStreams receives incoming streams using the given handler.
chromium.googlesource.com/native_client/nacl-llvm-project-v10:polly/include/polly/ScopInfo.h: [ master, ] 
2867:   raw_ostream &Stream;
 
2863:   ScopInfoPrinterPass(raw_ostream &OS) : Stream(OS) {}
github.com/google/mediapipe:mediapipe/framework/api2/builder.h: [ master, ] 
256: using Stream = Source<T>;
 
242: //   Stream<Image> Resize(Stream<Image> image, const Size& size, Graph& graph) {
 
253: //   Stream<Image> input_image = graph.In("INPUT_IMAGE").Cast<Image>();
 
254: //   Stream<Image> resized_image = Resize(input_image, {64, 64}, graph);
chromium.googlesource.com/crashpad/crashpad:third_party/cpp-httplib/cpp-httplib/httplib.h: [ master, ] Duplicate result
android.googlesource.com/platform/external/mesa3d:include/D3D9/d3d9types.h: [ master, ] 
1751:     WORD Stream;
pdfium.googlesource.com/pdfium:third_party/lcms/src/cmscgats.c: [ master, ] 
136:         FILE*          Stream;                   // File stream or NULL if holded in memory
 
488:     if (it8 -> FileStack[it8 ->IncludeSP]->Stream) {
 
490:         it8 ->ch = fgetc(it8 ->FileStack[it8 ->IncludeSP]->Stream);
 
492:         if (feof(it8 -> FileStack[it8 ->IncludeSP]->Stream))  {
 
496:                 fclose(it8 ->FileStack[it8->IncludeSP--]->Stream);
 
936:                 FileNest->Stream = fopen(FileNest->FileName, "rt");
 
937:                 if (FileNest->Stream == NULL) {
 
2364:      it8 ->FileStack[0]->Stream = fopen(cFileName, "rt");
 
2366:      if (!it8 ->FileStack[0]->Stream) {
 
2377:             fclose(it8 ->FileStack[0]->Stream);
 
2385:     if (fclose(it8 ->FileStack[0]->Stream)!= 0) {
android.googlesource.com/platform/external/pigweed:pw_stream/public/pw_stream/stream.h: [ master, ] 
35: class Stream {
 
242:   constexpr Stream(bool readable, bool writable, Seekability seekability)
 
30: // return Status::Unimplemented(). Stream serves as the base for the Reader,
 
33: // Stream should NOT be used or extended directly. Instead, work with one of the
 
61:   virtual ~Stream() = default;
 
171:   // Stream::kUnknownPosition if the position is unknown.
 
208:   // The Stream class should not be extended directly, so its constructor is
 
209:   // private. To implement a new Stream, extend one of its derived classes.
 
267: // A Stream that supports reading but not writing. The Write() method is hidden.
 
280: class Reader : public Stream {
 
286:       : Stream(true, false, seekability) {}
 
288:   using Stream::Write;
 
352: // A Stream that supports writing but not reading. The Read() method is hidden.
 
365: class Writer : public Stream {
 
371:       : Stream(false, true, seekability) {}
 
373:   using Stream::Read;
 
439: // A Stream that supports both reading and writing.
 
453: class ReaderWriter : public Stream {
 
457:     return static_cast<Reader&>(static_cast<Stream&>(*this));
 
460:     return static_cast<const Reader&>(static_cast<const Stream&>(*this));
 
468:     return static_cast<Writer&>(static_cast<Stream&>(*this));
 
471:     return static_cast<const Writer&>(static_cast<const Stream&>(*this));
 
482:       : Stream(true, true, seekability) {}
 
505:     return static_cast<RelativeSeekableReader&>(static_cast<Stream&>(*this));
 
509:         static_cast<const Stream&>(*this));
 
512:     return static_cast<RelativeSeekableWriter&>(static_cast<Stream&>(*this));
 
516:         static_cast<const Stream&>(*this));
 
543:     return static_cast<SeekableReader&>(static_cast<Stream&>(*this));
 
547:         static_cast<const Stream&>(*this));
 
557:     return static_cast<SeekableWriter&>(static_cast<Stream&>(*this));
 
561:         static_cast<const Stream&>(*this));
 
589:     return static_cast<NonSeekableReader&>(static_cast<Stream&>(*this));
 
593:         static_cast<const Stream&>(*this));
 
596:     return static_cast<NonSeekableWriter&>(static_cast<Stream&>(*this));
 
600:         static_cast<const Stream&>(*this));
 
173:   // Streams that support seeking from the beginning always support Tell().
android.googlesource.com/platform/external/pdfium:third_party/lcms/src/cmscgats.c: [ master, ] 
136:         FILE*          Stream;                   // File stream or NULL if holded in memory
 
488:     if (it8 -> FileStack[it8 ->IncludeSP]->Stream) {
 
490:         it8 ->ch = fgetc(it8 ->FileStack[it8 ->IncludeSP]->Stream);
 
492:         if (feof(it8 -> FileStack[it8 ->IncludeSP]->Stream))  {
 
496:                 fclose(it8 ->FileStack[it8->IncludeSP--]->Stream);
 
936:                 FileNest->Stream = fopen(FileNest->FileName, "rt");
 
937:                 if (FileNest->Stream == NULL) {
 
2368:      it8 ->FileStack[0]->Stream = fopen(cFileName, "rt");
 
2370:      if (!it8 ->FileStack[0]->Stream) {
 
2381:             fclose(it8 ->FileStack[0]->Stream);
 
2389:     if (fclose(it8 ->FileStack[0]->Stream)!= 0) {
github.com/apache/rocketmq-externals:rocketmq-knative/source/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/otsprotocol/table_store.pb.go: [ master, ] 
2188: type Stream struct {

316: type StreamStatus int32

319: 	StreamStatus_STREAM_ENABLING StreamStatus = 1

320: 	StreamStatus_STREAM_ACTIVE   StreamStatus = 2

323: var StreamStatus_name = map[int32]string{

327: var StreamStatus_value = map[string]int32{

790: type StreamSpecification struct {

791: 	EnableStream     *bool  `protobuf:"varint,1,req,name=enable_stream" json:"enable_stream,omitempty"`

801: func (m *StreamSpecification) GetEnableStream() bool {

815: type StreamDetails struct {

816: 	EnableStream     *bool   `protobuf:"varint,1,req,name=enable_stream" json:"enable_stream,omitempty"`

817: 	StreamId         *string `protobuf:"bytes,2,opt,name=stream_id" json:"stream_id,omitempty"`

828: func (m *StreamDetails) GetEnableStream() bool {

871: 	StreamSpec         *StreamSpecification `protobuf:"bytes,5,opt,name=stream_spec" json:"stream_spec,omitempty"`

937: 	StreamSpec         *StreamSpecification `protobuf:"bytes,4,opt,name=stream_spec" json:"stream_spec,omitempty"`

977: 	StreamDetails             *StreamDetails             `protobuf:"bytes,3,opt,name=stream_details" json:"stream_details,omitempty"`

1030: 	StreamDetails             *StreamDetails             `protobuf:"bytes,5,opt,name=stream_details" json:"stream_details,omitempty"`

2189: 	StreamId         *string `protobuf:"bytes,1,req,name=stream_id" json:"stream_id,omitempty"`

2222: 	Streams          []*Stream `protobuf:"bytes,1,rep,name=streams" json:"streams,omitempty"`

2238: type StreamShard struct {

2272: 	StreamId              *string `protobuf:"bytes,1,req,name=stream_id" json:"stream_id,omitempty"`

2305: 	StreamId         *string        `protobuf:"bytes,1,req,name=stream_id" json:"stream_id,omitempty"`

2309: 	StreamStatus     *StreamStatus  `protobuf:"varint,5,req,name=stream_status,enum=otsprotocol.StreamStatus" json:"stream_status,omitempty"`

2370: 	StreamId         *string `protobuf:"bytes,1,req,name=stream_id" json:"stream_id,omitempty"`

2461: 	StreamRecords     []*GetStreamRecordResponse_StreamRecord `protobuf:"bytes,1,rep,name=stream_records" json:"stream_records,omitempty"`

2485: type GetStreamRecordResponse_StreamRecord struct {

835: func (m *StreamDetails) GetStreamId() string {

909: func (m *CreateTableRequest) GetStreamSpec() *StreamSpecification {

967: func (m *UpdateTableRequest) GetStreamSpec() *StreamSpecification {

1000: func (m *UpdateTableResponse) GetStreamDetails() *StreamDetails {

1069: func (m *DescribeTableResponse) GetStreamDetails() *StreamDetails {

2171: type ListStreamRequest struct {

2200: func (m *Stream) GetStreamId() string {

2221: type ListStreamResponse struct {

2231: func (m *ListStreamResponse) GetStreams() []*Stream {

2271: type DescribeStreamRequest struct {

2283: func (m *DescribeStreamRequest) GetStreamId() string {

2304: type DescribeStreamResponse struct {

2320: func (m *DescribeStreamResponse) GetStreamId() string {

2348: func (m *DescribeStreamResponse) GetStreamStatus() StreamStatus {

2382: func (m *GetShardIteratorRequest) GetStreamId() string {

2435: type GetStreamRecordRequest struct {

2460: type GetStreamRecordResponse struct {

2471: func (m *GetStreamRecordResponse) GetStreamRecords() []*GetStreamRecordResponse_StreamRecord {

2195: func (m *Stream) Reset()                    { *m = Stream{} }

2196: func (m *Stream) String() string            { return proto.CompactTextString(m) }

2197: func (*Stream) ProtoMessage()               {}

2198: func (*Stream) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{50} }

2207: func (m *Stream) GetTableName() string {

2214: func (m *Stream) GetCreationTime() int64 {

2993: 	proto.RegisterType((*Stream)(nil), "otsprotocol.Stream")

332: func (x StreamStatus) Enum() *StreamStatus {

333: 	p := new(StreamStatus)

337: func (x StreamStatus) String() string {

338: 	return proto.EnumName(StreamStatus_name, int32(x))

340: func (x *StreamStatus) UnmarshalJSON(data []byte) error {

341: 	value, err := proto.UnmarshalJSONEnum(StreamStatus_value, data, "StreamStatus")

345: 	*x = StreamStatus(value)

348: func (StreamStatus) EnumDescriptor() ([]byte, []int) { return fileDescriptor2, []int{8} }

796: func (m *StreamSpecification) Reset()                    { *m = StreamSpecification{} }

797: func (m *StreamSpecification) String() string            { return proto.CompactTextString(m) }

798: func (*StreamSpecification) ProtoMessage()               {}

799: func (*StreamSpecification) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{10} }

802: 	if m != nil && m.EnableStream != nil {

803: 		return *m.EnableStream

808: func (m *StreamSpecification) GetExpirationTime() int32 {

823: func (m *StreamDetails) Reset()                    { *m = StreamDetails{} }

824: func (m *StreamDetails) String() string            { return proto.CompactTextString(m) }

825: func (*StreamDetails) ProtoMessage()               {}

826: func (*StreamDetails) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{11} }

829: 	if m != nil && m.EnableStream != nil {

830: 		return *m.EnableStream

836: 	if m != nil && m.StreamId != nil {

837: 		return *m.StreamId

842: func (m *StreamDetails) GetExpirationTime() int32 {

849: func (m *StreamDetails) GetLastEnableTime() int64 {

911: 		return m.StreamSpec

969: 		return m.StreamSpec

1002: 		return m.StreamDetails

1071: 		return m.StreamDetails

2201: 	if m != nil && m.StreamId != nil {

2202: 		return *m.StreamId

2233: 		return m.Streams

2245: func (m *StreamShard) Reset()                    { *m = StreamShard{} }

2246: func (m *StreamShard) String() string            { return proto.CompactTextString(m) }

2247: func (*StreamShard) ProtoMessage()               {}

2248: func (*StreamShard) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{52} }

2250: func (m *StreamShard) GetShardId() string {

2257: func (m *StreamShard) GetParentId() string {

2264: func (m *StreamShard) GetParentSiblingId() string {

2284: 	if m != nil && m.StreamId != nil {

2285: 		return *m.StreamId

2310: 	Shards           []*StreamShard `protobuf:"bytes,6,rep,name=shards" json:"shards,omitempty"`

2321: 	if m != nil && m.StreamId != nil {

2322: 		return *m.StreamId

2349: 	if m != nil && m.StreamStatus != nil {

2350: 		return *m.StreamStatus

2352: 	return StreamStatus_STREAM_ENABLING

2355: func (m *DescribeStreamResponse) GetShards() []*StreamShard {

2383: 	if m != nil && m.StreamId != nil {

2384: 		return *m.StreamId

2473: 		return m.StreamRecords

2491: func (m *GetStreamRecordResponse_StreamRecord) Reset()         { *m = GetStreamRecordResponse_StreamRecord{} }

2492: func (m *GetStreamRecordResponse_StreamRecord) String() string { return proto.CompactTextString(m) }

2493: func (*GetStreamRecordResponse_StreamRecord) ProtoMessage()    {}

2494: func (*GetStreamRecordResponse_StreamRecord) Descriptor() ([]byte, []int) {

2498: func (m *GetStreamRecordResponse_StreamRecord) GetActionType() ActionType {

2505: func (m *GetStreamRecordResponse_StreamRecord) GetRecord() []byte {

2953: 	proto.RegisterType((*StreamSpecification)(nil), "otsprotocol.StreamSpecification")

2954: 	proto.RegisterType((*StreamDetails)(nil), "otsprotocol.StreamDetails")

2995: 	proto.RegisterType((*StreamShard)(nil), "otsprotocol.StreamShard")

3002: 	proto.RegisterType((*GetStreamRecordResponse_StreamRecord)(nil), "otsprotocol.GetStreamRecordResponse.StreamRecord")

3030: 	proto.RegisterEnum("otsprotocol.StreamStatus", StreamStatus_name, StreamStatus_value)

2176: func (m *ListStreamRequest) Reset()                    { *m = ListStreamRequest{} }

2177: func (m *ListStreamRequest) String() string            { return proto.CompactTextString(m) }

2178: func (*ListStreamRequest) ProtoMessage()               {}

2179: func (*ListStreamRequest) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{49} }

2181: func (m *ListStreamRequest) GetTableName() string {

2226: func (m *ListStreamResponse) Reset()                    { *m = ListStreamResponse{} }

2227: func (m *ListStreamResponse) String() string            { return proto.CompactTextString(m) }

2228: func (*ListStreamResponse) ProtoMessage()               {}

2229: func (*ListStreamResponse) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{51} }

2278: func (m *DescribeStreamRequest) Reset()                    { *m = DescribeStreamRequest{} }

2279: func (m *DescribeStreamRequest) String() string            { return proto.CompactTextString(m) }

2280: func (*DescribeStreamRequest) ProtoMessage()               {}

2281: func (*DescribeStreamRequest) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{53} }

2290: func (m *DescribeStreamRequest) GetInclusiveStartShardId() string {

2297: func (m *DescribeStreamRequest) GetShardLimit() int32 {

2315: func (m *DescribeStreamResponse) Reset()                    { *m = DescribeStreamResponse{} }

2316: func (m *DescribeStreamResponse) String() string            { return proto.CompactTextString(m) }

2317: func (*DescribeStreamResponse) ProtoMessage()               {}

2318: func (*DescribeStreamResponse) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{54} }

2327: func (m *DescribeStreamResponse) GetExpirationTime() int32 {

2334: func (m *DescribeStreamResponse) GetTableName() string {

2341: func (m *DescribeStreamResponse) GetCreationTime() int64 {

2362: func (m *DescribeStreamResponse) GetNextShardId() string {

2441: func (m *GetStreamRecordRequest) Reset()                    { *m = GetStreamRecordRequest{} }

2442: func (m *GetStreamRecordRequest) String() string            { return proto.CompactTextString(m) }

2443: func (*GetStreamRecordRequest) ProtoMessage()               {}

2444: func (*GetStreamRecordRequest) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{57} }

2446: func (m *GetStreamRecordRequest) GetShardIterator() string {

2453: func (m *GetStreamRecordRequest) GetLimit() int32 {

2466: func (m *GetStreamRecordResponse) Reset()                    { *m = GetStreamRecordResponse{} }

2467: func (m *GetStreamRecordResponse) String() string            { return proto.CompactTextString(m) }

2468: func (*GetStreamRecordResponse) ProtoMessage()               {}

2469: func (*GetStreamRecordResponse) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{58} }

2478: func (m *GetStreamRecordResponse) GetNextShardIterator() string {

2992: 	proto.RegisterType((*ListStreamRequest)(nil), "otsprotocol.ListStreamRequest")

2994: 	proto.RegisterType((*ListStreamResponse)(nil), "otsprotocol.ListStreamResponse")

2996: 	proto.RegisterType((*DescribeStreamRequest)(nil), "otsprotocol.DescribeStreamRequest")

2997: 	proto.RegisterType((*DescribeStreamResponse)(nil), "otsprotocol.DescribeStreamResponse")

3000: 	proto.RegisterType((*GetStreamRecordRequest)(nil), "otsprotocol.GetStreamRecordRequest")

3001: 	proto.RegisterType((*GetStreamRecordResponse)(nil), "otsprotocol.GetStreamRecordResponse")
github.com/apache/trafficcontrol:vendor/github.com/basho/riak-go-client/rpb/riak_kv/riak_kv.pb.go: [ master, ] 
585: 	Stream           *bool   `protobuf:"varint,2,opt,name=stream" json:"stream,omitempty"`
 
775: 	Stream       *bool                       `protobuf:"varint,8,opt,name=stream" json:"stream,omitempty"`
 
602: func (m *RpbListBucketsReq) GetStream() bool {
 
843: func (m *RpbIndexReq) GetStream() bool {
 
603: 	if m != nil && m.Stream != nil {
 
604: 		return *m.Stream
 
844: 	if m != nil && m.Stream != nil {
 
845: 		return *m.Stream
github.com/llvm-mirror/clang-tools-extra:clang-doc/BitcodeWriter.h: [ master, ] 
175:     llvm::BitstreamWriter &Stream;
 
215:   llvm::BitstreamWriter &Stream;
 
174:   class StreamSubBlockGuard {
 
178:     StreamSubBlockGuard(llvm::BitstreamWriter &Stream_, BlockId ID)
 
188:     ~StreamSubBlockGuard() { Stream.ExitBlock(); }
 
142:   ClangDocBitcodeWriter(llvm::BitstreamWriter &Stream) : Stream(Stream) {
 
179:         : Stream(Stream_) {
 
182:       Stream.EnterSubblock(ID, BitCodeConstants::SubblockIDSize);
 
185:     StreamSubBlockGuard(const StreamSubBlockGuard &) = delete;
 
186:     StreamSubBlockGuard &operator=(const StreamSubBlockGuard &) = delete;
android.googlesource.com/platform/frameworks/compile/libbcc:bcinfo/BitReader_3_0/BitcodeReader.cpp: [ master, ] 
433:   BitstreamCursor Stream;
 
432:   std::unique_ptr<BitstreamReader> StreamFile;
 
3758: std::error_code BitcodeReader::InitStream() {
 
3783: std::error_code BitcodeReader::InitLazyStream() {
 
434:   std::unique_ptr<DataStreamer> LazyStreamer;
 
3764: std::error_code BitcodeReader::InitStreamFromBuffer() {
 
1113:   if (Stream.EnterSubBlock(bitc::PARAMATTR_BLOCK_ID))
 
1125:     BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
 
1140:     switch (Stream.readRecord(Entry.ID, Record)) {
 
1172:   if (Stream.EnterSubBlock(bitc::TYPE_BLOCK_ID_NEW))
 
1189:     BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
 
1207:     switch (Stream.readRecord(Entry.ID, Record)) {
 
1400:   if (Stream.EnterSubBlock(TYPE_BLOCK_ID_OLD_3_0))
 
1410:   BitstreamCursor StartOfTypeBlockCursor(Stream);
 
1421:     unsigned Code = Stream.ReadCode();
 
1433:         Stream = StartOfTypeBlockCursor;
 
1437:       if (Stream.ReadBlockEnd())
 
1444:       Stream.ReadSubBlockID();
 
1445:       if (Stream.SkipBlock())
 
1451:       Stream.ReadAbbrevRecord();
 
1458:     switch (Stream.readRecord(Code, Record)) {
 
1606:   if (Stream.EnterSubBlock(TYPE_SYMTAB_BLOCK_ID_OLD_3_0))
 
1614:     unsigned Code = Stream.ReadCode();
 
1616:       if (Stream.ReadBlockEnd())
 
1623:       Stream.ReadSubBlockID();
 
1624:       if (Stream.SkipBlock())
 
1630:       Stream.ReadAbbrevRecord();
 
1636:     switch (Stream.readRecord(Code, Record)) {
 
1657:   if (Stream.EnterSubBlock(bitc::VALUE_SYMTAB_BLOCK_ID))
 
1665:     unsigned Code = Stream.ReadCode();
 
1667:       if (Stream.ReadBlockEnd())
 
1673:       Stream.ReadSubBlockID();
 
1674:       if (Stream.SkipBlock())
 
1680:       Stream.ReadAbbrevRecord();
 
1686:     switch (Stream.readRecord(Code, Record)) {
 
1719:   if (Stream.EnterSubBlock(bitc::METADATA_BLOCK_ID))
 
1726:     unsigned Code = Stream.ReadCode();
 
1728:       if (Stream.ReadBlockEnd())
 
1735:       Stream.ReadSubBlockID();
 
1736:       if (Stream.SkipBlock())
 
1742:       Stream.ReadAbbrevRecord();
 
1749:     Code = Stream.readRecord(Code, Record);
 
1757:       Code = Stream.ReadCode();
 
1760:       unsigned NextBitCode = Stream.readRecord(Code, Record);
 
1919:   if (Stream.EnterSubBlock(bitc::CONSTANTS_BLOCK_ID))
 
1928:     BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
 
1950:     unsigned BitCode = Stream.readRecord(Entry.ID, Record);
 
2254:   if (Stream.ReadBlockEnd())
 
2281:   uint64_t CurBit = Stream.GetCurrentBitNo();
 
2285:   if (Stream.SkipBlock())
 
2321:     Stream.JumpToBit(NextUnreadBit);
 
2322:   else if (Stream.EnterSubBlock(bitc::MODULE_BLOCK_ID))
 
2331:     BitstreamEntry Entry = Stream.advance();
 
2342:         if (Stream.SkipBlock())
 
2346:         if (Stream.ReadBlockInfoBlock())
 
2399:           NextUnreadBit = Stream.GetCurrentBitNo();
 
2414:     switch (Stream.readRecord(Entry.ID, Record)) {
 
2612:   if (Stream.Read(8) != 'B' ||
 
2613:       Stream.Read(8) != 'C' ||
 
2614:       Stream.Read(4) != 0x0 ||
 
2615:       Stream.Read(4) != 0xC ||
 
2616:       Stream.Read(4) != 0xE ||
 
2617:       Stream.Read(4) != 0xD)
 
2623:     if (Stream.AtEndOfStream())
 
2627:       Stream.advance(BitstreamCursor::AF_DontAutoprocessAbbrevs);
 
2638:         if (Stream.ReadBlockInfoBlock())
 
2652:         if (Stream.SkipBlock())
 
2663:       if (Stream.getAbbrevIDWidth() == 2 && Entry.ID == 2 &&
 
2664:           Stream.Read(6) == 2 && Stream.Read(24) == 0xa0a0a &&
 
2665:           Stream.AtEndOfStream())
 
2674:   if (Stream.EnterSubBlock(bitc::MODULE_BLOCK_ID))
 
2682:     BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
 
2696:     switch (Stream.readRecord(Entry.ID, Record)) {
 
2724:   if (Stream.Read(8) != 'B' ||
 
2725:       Stream.Read(8) != 'C' ||
 
2726:       Stream.Read(4) != 0x0 ||
 
2727:       Stream.Read(4) != 0xC ||
 
2728:       Stream.Read(4) != 0xE ||
 
2729:       Stream.Read(4) != 0xD)
 
2735:     BitstreamEntry Entry = Stream.advance();
 
2748:       if (Stream.SkipBlock())
 
2753:       Stream.skipRecord(Entry.ID);
 
2761:   if (Stream.EnterSubBlock(bitc::METADATA_ATTACHMENT_ID))
 
2766:     BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
 
2781:     switch (Stream.readRecord(Entry.ID, Record)) {
 
2806:   if (Stream.EnterSubBlock(bitc::FUNCTION_BLOCK_ID))
 
2826:     unsigned Code = Stream.ReadCode();
 
2828:       if (Stream.ReadBlockEnd())
 
2834:       switch (Stream.ReadSubBlockID()) {
 
2836:         if (Stream.SkipBlock())
 
2861:       Stream.ReadAbbrevRecord();
 
2868:     unsigned BitCode = Stream.readRecord(Code, Record);
 
3671:   Stream.JumpToBit(DFII->second);
 
3778:   Stream.init(&*StreamFile);
 
3790:   Stream.init(&*StreamFile);
 
591:   std::error_code InitStream();
 
593:   std::error_code InitLazyStream();
 
2608:   if (std::error_code EC = InitStream())
 
2720:   if (std::error_code EC = InitStream())
 
3760:     return InitLazyStream();
 
3777:   StreamFile.reset(new BitstreamReader(BufPtr, BufEnd));
 
3786:   auto OwnedBytes = llvm::make_unique<StreamingMemoryObject>(
 
3788:   StreamingMemoryObject &Bytes = *OwnedBytes;
 
3789:   StreamFile = llvm::make_unique<BitstreamReader>(std::move(OwnedBytes));
 
592:   std::error_code InitStreamFromBuffer();
 
633:       TheModule(nullptr), Buffer(buffer), LazyStreamer(nullptr),
 
2398:         if (LazyStreamer && SeenValueSymbolTable) {
 
2566:         if (LazyStreamer)
 
2648:         if (LazyStreamer)
 
3759:   if (LazyStreamer)
 
3761:   return InitStreamFromBuffer();
 
3787:       std::move(LazyStreamer));
chromium.googlesource.com/native_client/pnacl-gcc:gcc/go/gofrontend/import.h: [ master, ] 
26:   class Stream
 
261: class Stream_from_string : public Import::Stream
 
264:   Stream_from_string(const std::string& str)
 
291: class Stream_from_buffer : public Import::Stream
 
294:   Stream_from_buffer(char* buf, size_t length)
 
326: class Stream_from_file : public Import::Stream