925:   raw_ostream &Stream;

339:   raw_ostream &BaseStream;

343:   raw_string_ostream TextStream;

761: class ObjDumpStream {

788:   ~ObjDumpStream() { Flush(); }

939:   raw_string_ostream AssemblyStream;

943:   raw_string_ostream MessageStream;

952:   raw_string_ostream RecordStream;

207:   /// Base Stream. The viewing width is defined by LineWidth. The

521: inline raw_ostream &operator<<(raw_ostream &Stream,

526:   assert(&Stream == &Directive.GetFormatter().Tokens());

528:   return Stream;

780:   /// comments and errors into a single (user proved Stream).  When

786:   ObjDumpStream(raw_ostream &Stream, bool DumpRecords, bool DumpAssembly);

1: //===- NaClObjDumpStream.h --------------------------------------*- C++ -*-===//

210:   explicit TextFormatter(raw_ostream &BaseStream,

219:     return TextStream;

664: class ObjDumpStream;

670: /// The formatter used for dumping records in ObjDumpStream.

679:   explicit RecordTextFormatter(ObjDumpStream *ObjDump);

762:   ObjDumpStream(const ObjDumpStream&) = delete;

763:   void operator=(const ObjDumpStream&) = delete;

793:     return AssemblyStream;

799:     return RecordStream;

805:     return MessageStream;

96: class Stream {

765: class ASCII85Stream: public FilterStream {

51: enum StreamKind {

67: enum StreamColorSpaceMode {

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

249: class OutStream {

275: class FileOutStream : public OutStream {

301: class BaseStream: public Stream {

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

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

335: class FilterStream: public Stream {

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

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

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

361: class ImageStream {

408: class StreamPredictor {

450: class FileStream: public BaseStream {

525: class CachedFileStream: public BaseStream {

570: class BaseMemStream: public BaseStream {

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

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

668: class MemStream : public BaseMemStream<const char>

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

676: class AutoFreeMemStream : public BaseMemStream<char>

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

683:   ~AutoFreeMemStream()

698: class EmbedStream: public BaseStream {

742: class ASCIIHexStream: public FilterStream {

790: class LZWStream: public FilterStream {

850: class RunLengthStream: public FilterStream {

883: class CCITTFaxStream: public FilterStream {

971: class DCTStream: public FilterStream {

1078: class FlateStream: public FilterStream {

1153: class EOFStream: public FilterStream {

1170: class BufStream: public FilterStream {

448: #define fileStreamBufSize 256

523: #define cachedStreamBufSize 1024

3: // Stream.h

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

93: // Stream (base class)

100:   Stream();

103:   virtual ~Stream();

105:   Stream(const Stream &) = delete;

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

208:   virtual Stream *getUndecodedStream() = 0;

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

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

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

338:   FilterStream(Stream *strA);

354:   Stream *str;

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

393:   Stream *str;			// base stream

413:   StreamPredictor(Stream *strA, int predictorA,

431:   Stream *str;			// base stream

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

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

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

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

726:   Stream *str;

745:   ASCIIHexStream(Stream *strA);

762: // ASCII85Stream

768:   ASCII85Stream(Stream *strA);

769:   ~ASCII85Stream();

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

853:   RunLengthStream(Stream *strA);

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

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

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

1156:   EOFStream(Stream *strA);

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

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

1221:   ASCIIHexEncoder(Stream *strA);

1251:   ASCII85Encoder(Stream *strA);

1281:   RunLengthEncoder(Stream *strA);

1317:   LZWEncoder(Stream *strA);

1349:   CMYKGrayEncoder(Stream *strA);

1378:   RGBGrayEncoder(Stream *strA);

46: class BaseStream;

109:   virtual StreamKind getKind() = 0;

174:   // This is only used by StreamPredictor.

203:   // Get the BaseStream of this stream.

204:   virtual BaseStream *getBaseStream() = 0;

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

207:   // or a DecryptStream).

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

245: // OutStream

252:   OutStream ();

255:   virtual ~OutStream ();

257:   OutStream(const OutStream &) = delete;

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

273: // FileOutStream

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

279:   ~FileOutStream ();

296: // BaseStream

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

306:   ~BaseStream();

307:   virtual BaseStream *copy() = 0;

330: // FilterStream

339:   ~FilterStream();

358: // ImageStream

369:   ~ImageStream();

371:   ImageStream(const ImageStream &) = delete;

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

405: // StreamPredictor

416:   ~StreamPredictor();

418:   StreamPredictor(const StreamPredictor &) = delete;

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

445: // FileStream

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

455:   ~FileStream();

456:   BaseStream *copy() override;

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

520: // CachedFileStream

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

530:   ~CachedFileStream();

531:   BaseStream *copy() override;

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

566: // MemStream

581:   BaseStream *copy() override {

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

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

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

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

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

689: // EmbedStream

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

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

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

702:   ~EmbedStream();

703:   BaseStream *copy() override;

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

739: // ASCIIHexStream

746:   ~ASCIIHexStream();

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

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

787: // LZWStream

795:   ~LZWStream();

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

822:   StreamPredictor *pred;	// predictor

847: // RunLengthStream

854:   ~RunLengthStream();

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

878: // CCITTFaxStream

889:   ~CCITTFaxStream();

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

942: // DCTStream

975:   virtual ~DCTStream();

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

1051: // FlateStream

1083:   ~FlateStream();

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

1113:   StreamPredictor *pred;	// predictor

1150: // EOFStream

1157:   ~EOFStream();

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

1167: // BufStream

1174:   ~BufStream();

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

1195: class FixedLengthEncoder: public FilterStream {

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

1218: class ASCIIHexEncoder: public FilterStream {

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

1248: class ASCII85Encoder: public FilterStream {

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

1278: class RunLengthEncoder: public FilterStream {

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

1314: class LZWEncoder: public FilterStream {

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

1346: class CMYKGrayEncoder: public FilterStream {

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

1375: class RGBGrayEncoder: public FilterStream {

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

509:   char buf[fileStreamBufSize];

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

556:   char buf[cachedStreamBufSize];

92: Stream::Stream() {

1178: ASCII85Stream::ASCII85Stream(Stream *strA):

1184: ASCII85Stream::~ASCII85Stream() {

178: class BaseStreamStream : public Stream

181:   BaseStreamStream(Stream *strA) : str(strA)

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

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

353: OutStream::OutStream ()

357: OutStream::~OutStream ()

364: FileOutStream::FileOutStream (FILE* fa, Goffset startA)

370: FileOutStream::~FileOutStream ()

403: BaseStream::BaseStream(Object &&dictA, Goffset lengthA) {

408: BaseStream::~BaseStream() {

415: FilterStream::FilterStream(Stream *strA) {

419: FilterStream::~FilterStream() {

434: ImageStream::ImageStream(Stream *strA, int widthA, int nCompsA, int nBitsA) {

464: ImageStream::~ImageStream() {

554: StreamPredictor::StreamPredictor(Stream *strA, int predictorA,

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

766: FileStream::~FileStream() {

774: Stream *FileStream::makeSubStream(Goffset startA, bool limitedA,

844: CachedFileStream::CachedFileStream(CachedFile *ccA, Goffset startA,

858: CachedFileStream::~CachedFileStream()

869: Stream *CachedFileStream::makeSubStream(Goffset startA, bool limitedA,

948: EmbedStream::EmbedStream(Stream *strA, Object &&dictA,

965: EmbedStream::~EmbedStream() {

975: Stream *EmbedStream::makeSubStream(Goffset start, bool limitedA,

1086: ASCIIHexStream::ASCIIHexStream(Stream *strA):

1092: ASCIIHexStream::~ASCIIHexStream() {

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

1277: LZWStream::~LZWStream() {

1472: RunLengthStream::RunLengthStream(Stream *strA):

1478: RunLengthStream::~RunLengthStream() {

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

1595: CCITTFaxStream::~CCITTFaxStream() {

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

2437: DCTStream::~DCTStream() {

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

4495: FlateStream::~FlateStream() {

4947: EOFStream::EOFStream(Stream *strA):

4951: EOFStream::~EOFStream() {

4959: BufStream::BufStream(Stream *strA, int bufSizeA): FilterStream(strA) {

4964: BufStream::~BufStream() {

581: StreamPredictor::~StreamPredictor() {

3: // Stream.cc

64: #include "Stream.h"

66: #include "JBIG2Stream.h"

67: #include "Stream-CCITT.h"

79: #include "JPEG2000Stream.h"

89: // Stream (base class)

96: Stream::~Stream() = default;

98: void Stream::close() {

101: int Stream::getRawChar() {

106: int Stream::getChars(int nChars, unsigned char *buffer) {

111: void Stream::getRawChars(int nChars, int *buffer) {

115: char *Stream::getLine(char *buf, int size) {

136: GooString *Stream::getPSFilter(int psLevel, const char *indent) {

140: Stream *Stream::addFilters(Dict *dict, int recursion) {

143:   Stream *str;

200:   std::unique_ptr<Stream> str;

203: Stream *Stream::makeFilter(const char *name, Stream *str, Object *params, int recursion, Dict *dict) {

216:     str = new ASCII85Stream(str);

329:     str = new JBIG2Stream(str, std::move(globals), &obj);

1175: // ASCII85Stream

1188: void ASCII85Stream::reset() {

1194: int ASCII85Stream::lookChar() {

1238: GooString *ASCII85Stream::getPSFilter(int psLevel, const char *indent) {

1251: bool ASCII85Stream::isBinary(bool last) {

5005: FixedLengthEncoder::FixedLengthEncoder(Stream *strA, int lengthA):

5042: ASCIIHexEncoder::ASCIIHexEncoder(Stream *strA):

5089: ASCII85Encoder::ASCII85Encoder(Stream *strA):

5181: RunLengthEncoder::RunLengthEncoder(Stream *strA):

5286: LZWEncoder::LZWEncoder(Stream *strA):

5431: CMYKGrayEncoder::CMYKGrayEncoder(Stream *strA):

5474: RGBGrayEncoder::RGBGrayEncoder(Stream *strA):

71: #include "DCTStream.h"

75: #include "FlateStream.h"

81: #include "JPXStream.h"

168: 	str = new EOFStream(str);

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

186:   void reset() override { str->getBaseStream()->reset(); }

187:   int getChar() override { return str->getBaseStream()->getChar(); }

188:   int lookChar() override { return str->getBaseStream()->lookChar(); }

189:   bool isBinary(bool last = true) override { return str->getBaseStream()->isBinary(); }

190:   int getUnfilteredChar () override { return str->getBaseStream()->getUnfilteredChar(); }

191:   void unfilteredReset () override { str->getBaseStream()->unfilteredReset(); }

192:   Goffset getPos() override { return str->getBaseStream()->getPos(); }

193:   void setPos(Goffset pos, int dir) override { str->getBaseStream()->setPos(pos, dir); }

196:   Dict *getDict() override { return str->getBaseStream()->getDict(); }

197:   Object *getDictObject() override { return str->getBaseStream()->getDictObject(); }

214:     str = new ASCIIHexStream(str);

240:     str = new LZWStream(str, pred, columns, colors, bits, early);

242:     str = new RunLengthStream(str);

286:     str = new CCITTFaxStream(str, encoding, endOfLine, byteAlign,

297:     str = new DCTStream(str, colorXform, dict, recursion);

300:     str = new EOFStream(str);

321:     str = new FlateStream(str, pred, columns, colors, bits);

332:     str = new JPXStream(str);

335:     str = new EOFStream(str);

339:       str = new BaseStreamStream(str);

345:     str = new EOFStream(str);

351: // OutStream

362: // FileOutStream

375: void FileOutStream::close ()

380: Goffset FileOutStream::getPos ()

385: void FileOutStream::put (char c)

390: void FileOutStream::printf(const char *format, ...)

400: // BaseStream

412: // FilterStream

422: void FilterStream::close() {

426: void FilterStream::setPos(Goffset pos, int dir) {

427:   error(errInternal, -1, "Internal: called setPos() on FilterStream");

431: // ImageStream

471: void ImageStream::reset() {

475: void ImageStream::close() {

479: bool ImageStream::getPixel(unsigned char *pix) {

494: unsigned char *ImageStream::getLine() {

546: void ImageStream::skipLine() {

551: // StreamPredictor

585: int StreamPredictor::lookChar() {

594: int StreamPredictor::getChar() {

603: int StreamPredictor::getChars(int nChars, unsigned char *buffer) {

624: bool StreamPredictor::getNextLine() {

749: // FileStream

754:     BaseStream(std::move(dictA), lengthA) {

770: BaseStream *FileStream::copy() {

771:   return new FileStream(file, start, limited, length, dict.copy());

776:   return new FileStream(file, startA, limitedA, lengthA, std::move(dictA));

779: void FileStream::reset() {

787: void FileStream::close() {

794: bool FileStream::fillBuf() {

819: void FileStream::setPos(Goffset pos, int dir) {

834: void FileStream::moveStart(Goffset delta) {

841: // CachedFileStream

846:   : BaseStream(std::move(dictA), lengthA)

864: BaseStream *CachedFileStream::copy() {

866:   return new CachedFileStream(cc, start, limited, length, dict.copy());

873:   return new CachedFileStream(cc, startA, limitedA, lengthA, std::move(dictA));

876: void CachedFileStream::reset()

886: void CachedFileStream::close()

894: bool CachedFileStream::fillBuf()

916: void CachedFileStream::setPos(Goffset pos, int dir)

937: void CachedFileStream::moveStart(Goffset delta)

945: // EmbedStream

950:     BaseStream(std::move(dictA), lengthA) {

970: BaseStream *EmbedStream::copy() {

971:   error(errInternal, -1, "Called copy() on EmbedStream");

977:   error(errInternal, -1, "Called makeSubStream() on EmbedStream");

981: void EmbedStream::rewind() {

987: void EmbedStream::restore() {

991: Goffset EmbedStream::getPos() {

998: int EmbedStream::getChar() {

1022: int EmbedStream::lookChar() {

1036: int EmbedStream::getChars(int nChars, unsigned char *buffer) {

1069: void EmbedStream::setPos(Goffset pos, int dir) {

1070:   error(errInternal, -1, "Internal: called setPos() on EmbedStream");

1073: Goffset EmbedStream::getStart() {

1074:   error(errInternal, -1, "Internal: called getStart() on EmbedStream");

1078: void EmbedStream::moveStart(Goffset delta) {

1079:   error(errInternal, -1, "Internal: called moveStart() on EmbedStream");

1083: // ASCIIHexStream

1087:     FilterStream(strA) {

1096: void ASCIIHexStream::reset() {

1102: int ASCIIHexStream::lookChar() {

1157: GooString *ASCIIHexStream::getPSFilter(int psLevel, const char *indent) {

1170: bool ASCIIHexStream::isBinary(bool last) {

1179:     FilterStream(strA) {

1256: // LZWStream

1261:     FilterStream(strA) {

1263:     pred = new StreamPredictor(this, predictor, columns, colors, bits);

1284: int LZWStream::getChar() {

1299: int LZWStream::lookChar() {

1314: void LZWStream::getRawChars(int nChars, int *buffer) {

1319: int LZWStream::getRawChar() {

1323: int LZWStream::getChars(int nChars, unsigned char *buffer) {

1350: void LZWStream::reset() {

1357: bool LZWStream::processNextCode() {

1424: void LZWStream::clearTable() {

1432: int LZWStream::getCode() {

1447: GooString *LZWStream::getPSFilter(int psLevel, const char *indent) {

1464: bool LZWStream::isBinary(bool last) {

1469: // RunLengthStream

1473:     FilterStream(strA) {

1482: void RunLengthStream::reset() {

1488: int RunLengthStream::getChars(int nChars, unsigned char *buffer) {

1509: GooString *RunLengthStream::getPSFilter(int psLevel, const char *indent) {

1522: bool RunLengthStream::isBinary(bool last) {

1526: bool RunLengthStream::fillBuf() {

1553: // CCITTFaxStream

1559:     FilterStream(strA) {

1601: void CCITTFaxStream::ccittReset(bool unfiltered) {

1615: void CCITTFaxStream::unfilteredReset() {

1619: void CCITTFaxStream::reset() {

1646: inline void CCITTFaxStream::addPixels(int a1, int blackPixels) {

1661: inline void CCITTFaxStream::addPixelsNeg(int a1, int blackPixels) {

1686: int CCITTFaxStream::lookChar() {

2132: short CCITTFaxStream::getTwoDimCode() {

2166: short CCITTFaxStream::getWhiteCode() {

2224: short CCITTFaxStream::getBlackCode() {

2300: short CCITTFaxStream::lookBits(int n) {

2320: GooString *CCITTFaxStream::getPSFilter(int psLevel, const char *indent) {

2357: bool CCITTFaxStream::isBinary(bool last) {

2364: // DCTStream

2409:     FilterStream(strA) {

2442: void DCTStream::dctReset(bool unfiltered) {

2459: void DCTStream::unfilteredReset() {

2463: void DCTStream::reset() {

2558: void DCTStream::close() {

2569:   FilterStream::close();

2572: int DCTStream::getChar() {

2613: int DCTStream::lookChar() {

2633: void DCTStream::restart() {

2645: bool DCTStream::readMCURow() {

2770: void DCTStream::readScan() {

2875: bool DCTStream::readDataUnit(DCTHuffTable *dcHuffTable,

2925: bool DCTStream::readProgressiveDataUnit(DCTHuffTable *dcHuffTable,

3051: void DCTStream::decodeImage() {

3193: void DCTStream::transformDataUnit(unsigned short *quantTable,

3351: int DCTStream::readHuffSym(DCTHuffTable *table) {

3380: int DCTStream::readAmp(int size) {

3395: int DCTStream::readBit() {

3419: bool DCTStream::readHeader() {

3497: bool DCTStream::readBaselineSOF() {

3537: bool DCTStream::readProgressiveSOF() {

3578: bool DCTStream::readScanInfo() {

3639: bool DCTStream::readQuantTables() {

3670: bool DCTStream::readHuffmanTables() {

3716: bool DCTStream::readRestartInterval() {

3728: bool DCTStream::readJFIFMarker() {

3758: bool DCTStream::readAdobeMarker() {

3790: bool DCTStream::readTrailer() {

3801: int DCTStream::readMarker() {

3815: int DCTStream::read16() {

3825: GooString *DCTStream::getPSFilter(int psLevel, const char *indent) {

3838: bool DCTStream::isBinary(bool last) {

3846: // FlateStream

3849: const int FlateStream::codeLenCodeMap[flateMaxCodeLenCodes] = {

3853: const FlateDecode FlateStream::lengthDecode[flateMaxLitCodes-257] = {

3887: const FlateDecode FlateStream::distDecode[flateMaxDistCodes] = {

4435: FlateHuffmanTab FlateStream::fixedLitCodeTab = {

4474: FlateHuffmanTab FlateStream::fixedDistCodeTab = {

4480:     FilterStream(strA) {

4482:     pred = new StreamPredictor(this, predictor, columns, colors, bits);

4508: void FlateStream::flateReset(bool unfiltered) {

4523: void FlateStream::unfilteredReset() {

4527: void FlateStream::reset() {

4555: int FlateStream::getChar() {

4562: int FlateStream::getChars(int nChars, unsigned char *buffer) {

4575: int FlateStream::lookChar() {

4590: void FlateStream::getRawChars(int nChars, int *buffer) {

4595: int FlateStream::getRawChar() {

4599: GooString *FlateStream::getPSFilter(int psLevel, const char *indent) {

4612: bool FlateStream::isBinary(bool last) {

4616: void FlateStream::readSome() {

4681: bool FlateStream::startBlock() {

4748: void FlateStream::loadFixedCodes() {

4755: bool FlateStream::readDynamicCodes() {

4857: FlateCode *FlateStream::compHuffmanCodes(const int *lengths, int n, int *maxLen) {

4907: int FlateStream::getHuffmanCodeWord(FlateHuffmanTab *tab) {

4927: int FlateStream::getCodeWord(int bits) {

4944: // EOFStream

4948:     FilterStream(strA) {

4956: // BufStream

4969: void BufStream::reset() {

4978: int BufStream::getChar() {

4989: int BufStream::lookChar() {

4993: int BufStream::lookChar(int idx) {

4997: bool BufStream::isBinary(bool last) {

5006:     FilterStream(strA) {

5043:     FilterStream(strA) {

5090:     FilterStream(strA) {

5182:     FilterStream(strA) {

5287:   FilterStream(strA)

5432:     FilterStream(strA) {

5475:     FilterStream(strA) {

802:   if (limited && bufPos + fileStreamBufSize > start + length) {

805:     n = fileStreamBufSize;

903:   if (limited && bufPos + cachedStreamBufSize > start + length) {

906:     n = cachedStreamBufSize - (bufPos % cachedStreamBufSize);

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

49: class Stream : public Print

64:     Stream() {_timeout=1000;}

23: #define Stream_h

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

22: #ifndef Stream_h

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

24: class Stream {

44: class MemoryStream : public Stream {

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

63: class FileStream : public Stream {

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

74: class JavaInputStream : public Stream {

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

87:     const jobject mInputStream;

26:     Stream();

27:     virtual ~Stream();

78:             mInputStream(inputStream),

92: jint JavaStream_OnLoad(JNIEnv* env);

32: Stream::Stream()

38: Stream::~Stream() {

143: jint JavaStream_OnLoad(JNIEnv* env) {

30: } gInputStreamClassInfo;

17: #define LOG_TAG "Stream"

19: #include "Stream.h"

42: size_t Stream::peek(void* buffer, size_t size) {

60: size_t Stream::read(void* buffer, size_t size) {

82: uint8_t* Stream::getRawBufferAddr() {

86: jobject Stream::getRawBuffer() {

90: int Stream::getRawBufferSize() {

94: uint8_t* MemoryStream::getRawBufferAddr() {

98: jobject MemoryStream::getRawBuffer() {

102: int MemoryStream::getRawBufferSize() {

110: size_t MemoryStream::doRead(void* buffer, size_t size) {

118: size_t FileStream::doRead(void* buffer, size_t size) {

122: size_t JavaInputStream::doRead(void* dstBuffer, size_t size) {

128:         jint bytesRead = mEnv->CallIntMethod(mInputStream,

146:     jclass inputStreamClazz = env->FindClass("java/io/InputStream");

129:                 gInputStreamClassInfo.read, mByteArray, 0, requested);

147:     if (!inputStreamClazz) {

150:     gInputStreamClassInfo.read = env->GetMethodID(inputStreamClazz, "read", "([BII)I");

151:     gInputStreamClassInfo.reset = env->GetMethodID(inputStreamClazz, "reset", "()V");

152:     if (!gInputStreamClassInfo.read || !gInputStreamClassInfo.reset) {

38: class Stream : public Print

53:     Stream() {_timeout=1000;}

23: #define Stream_h

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

22: #ifndef Stream_h

26: class Stream : public Print

21: #define Stream_h

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

20: #ifndef Stream_h

250: Stream::Stream(StreamExecutor *parent)

259: Stream::Stream(StreamExecutor *parent,

269: Stream::~Stream() {

1875: Stream *Stream::GetOrCreateSubStream() {

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

5486: 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() {

292: Stream &Stream::Init() {

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

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

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

341: Stream &Stream::ThenBatchNormalizationForward(

372: Stream &Stream::ThenBatchNormalizationBackward(

397: Stream &Stream::ThenBatchNormalizationForward(

428: Stream &Stream::ThenBatchNormalizationBackward(

455: Stream &Stream::ThenFusedConvolveWithAlgorithm(

493: Stream &Stream::ThenFusedConvolveWithAlgorithm(

531: Stream &Stream::ThenFusedConvolveWithAlgorithm(

570: Stream &Stream::ThenFusedConvolveWithAlgorithm(

608: Stream &Stream::ThenFusedConvolveWithAlgorithm(

646: Stream &Stream::ThenConvolveWithAlgorithm(

688: Stream &Stream::ThenConvolveWithAlgorithm(

730: Stream &Stream::ThenConvolveWithAlgorithm(

772: Stream &Stream::ThenConvolveWithAlgorithm(

814: Stream &Stream::ThenConvolveWithAlgorithm(

856: Stream &Stream::ThenConvolve(

871: Stream &Stream::ThenConvolveQuantized(

901: Stream &Stream::ThenConvolveQuantized(

931: Stream &Stream::ThenSeparableConvolve(

958: Stream &Stream::ThenConvolveBackwardDataWithAlgorithm(

1003: Stream &Stream::ThenConvolveBackwardDataWithAlgorithm(

1048: Stream &Stream::ThenConvolveBackwardDataWithAlgorithm(

1093: Stream &Stream::ThenConvolveBackwardFilterWithAlgorithm(

1138: Stream &Stream::ThenConvolveBackwardFilterWithAlgorithm(

1183: Stream &Stream::ThenConvolveBackwardFilterWithAlgorithm(

1229: Stream &Stream::ThenConvolveBackwardBiasImpl(

1249: Stream &Stream::ThenConvolveBackwardBias(

1258: Stream &Stream::ThenConvolveBackwardBias(

1267: Stream &Stream::ThenConvolveBackwardBias(

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

1295: Stream &Stream::ThenMatMulQuantized(

1317: Stream &Stream::ThenMatMulQuantized(

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

1357: Stream &Stream::ThenPoolForward(

1382: Stream &Stream::ThenPoolForward(

1404: Stream &Stream::ThenPoolForward(

1427: Stream &Stream::ThenPoolForward(

1449: Stream &Stream::ThenPoolBackward(

1479: Stream &Stream::ThenPoolBackward(

1506: Stream &Stream::ThenPoolBackward(

1533: Stream &Stream::ThenNormalizeWithDimensions(

1551: Stream &Stream::ThenNormalizeBackwardWithDimensions(

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

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

1602: Stream &Stream::ThenDepthConcatenate(

1632: Stream &Stream::ThenSpaceConcatenate(

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

1697: Stream &Stream::ThenDepthToSpace(

1718: Stream &Stream::ThenSpaceToDepth(

1739: Stream &Stream::ThenElementwiseOperate(

1760: Stream &Stream::ThenElementwiseOperateScaledQuantized(

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

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

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

1841: Stream &Stream::ThenMemcpyD2HQuantized(

1858: Stream &Stream::ThenMemcpyH2DQuantized(

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

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

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

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

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

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

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

1930:   std::unique_ptr<Stream> bad_stream;

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

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

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

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

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

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

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

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

2036:   Stream &Run(Stream *stream,

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

3755: Stream &Stream::ThenBlasGemvWithProfiling(

3772: Stream &Stream::ThenBlasGemvWithProfiling(

3790: Stream &Stream::ThenBlasGemvWithProfiling(

3810: Stream &Stream::ThenBlasGemvWithProfiling(

3830: Stream &Stream::ThenBlasGemmWithProfiling(

3850: Stream &Stream::ThenBlasGemmWithProfiling(

3869: Stream &Stream::ThenBlasGemmWithProfiling(

3889: Stream &Stream::ThenBlasGemmWithProfiling(

3911: Stream &Stream::ThenBlasGemmWithProfiling(

3933: Stream &Stream::ThenBlasGemmWithAlgorithm(

3958: Stream &Stream::ThenBlasGemmWithAlgorithm(

3981: Stream &Stream::ThenBlasGemmWithAlgorithm(

4004: Stream &Stream::ThenBlasGemmWithAlgorithm(

4028: Stream &Stream::ThenBlasGemmWithAlgorithm(

4056: Stream &Stream::ThenBlasGemmWithAlgorithm(

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

4524: Stream &Stream::ThenBlasGemmBatched(

4536: Stream &Stream::ThenBlasGemmBatchedWithScratch(

4558: Stream &Stream::ThenBlasGemmBatched(

4569: Stream &Stream::ThenBlasGemmBatchedWithScratch(

4590: Stream &Stream::ThenBlasGemmBatched(

4601: Stream &Stream::ThenBlasGemmBatchedWithScratch(

4622: Stream &Stream::ThenBlasGemmBatched(

4635: Stream &Stream::ThenBlasGemmBatchedWithScratch(

4661: Stream &Stream::ThenBlasGemmBatched(

4674: Stream &Stream::ThenBlasGemmBatchedWithScratch(

4700: Stream &Stream::ThenBlasGemmStridedBatched(

4721: Stream &Stream::ThenBlasGemmStridedBatched(

4742: Stream &Stream::ThenBlasGemmStridedBatched(

4763: Stream &Stream::ThenBlasGemmStridedBatched(

4786: Stream &Stream::ThenBlasGemmStridedBatched(

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

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

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

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

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

4893: Stream &Stream::ThenPopulateRandUniform(

4910: Stream &Stream::ThenPopulateRandUniform(

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

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

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

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

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

4992: Stream &Stream::ThenRnnForward(

5029: Stream &Stream::ThenRnnForward(

5065: Stream &Stream::ThenRnnForward(

5102: Stream &Stream::ThenRnnBackward(

5149: Stream &Stream::ThenRnnBackward(

5195: Stream &Stream::ThenRnnBackward(

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

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

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

5309: Stream &Stream::ThenDoHostCallbackWithStatus(

5321: Stream &Stream::ThenRunAfterNextBlockHostUntilDone(

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

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

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

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

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

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

5443: Stream &Stream::ThenEnqueueOnBackgroundThread(

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

5475: void Stream::RunAfterBlockHostUntilDoneCallbacks() {

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

260:                internal::StreamInterface *implementation)

282:     parent_->DeallocateStream(this);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

5447:   StreamExecutor *stream_executor = this->parent_;

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

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

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

1891:                 << sub_stream->DebugStreamPointers();

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

1906:               << sub_stream->DebugStreamPointers();

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

1922:           << sub_stream->DebugStreamPointers();

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

1944:               << sub_stream->DebugStreamPointers();

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

1951:               << sub_stream->DebugStreamPointers();

1962:   LOG(FATAL) << DebugStreamPointers()

1964:              << sub_stream->DebugStreamPointers();

1973:     LOG(INFO) << DebugStreamPointers()

1985:     LOG(INFO) << DebugStreamPointers()

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

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

2000:               << other->DebugStreamPointers();

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

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

4820:     LOG(INFO) << DebugStreamPointers()

4835:       LOG(INFO) << DebugStreamPointers()

4852:       LOG(INFO) << DebugStreamPointers()

4869:       LOG(INFO) << DebugStreamPointers()

4885:       LOG(INFO) << DebugStreamPointers()

4902:       LOG(INFO) << DebugStreamPointers()

4919:       LOG(INFO) << DebugStreamPointers()

4934:     LOG(INFO) << DebugStreamPointers()

4947:     LOG(INFO) << DebugStreamPointers()

4960:     LOG(INFO) << DebugStreamPointers()

4972:     LOG(INFO) << DebugStreamPointers()

4985:     LOG(INFO) << DebugStreamPointers()

5302:     LOG(INFO) << DebugStreamPointers()

5314:     LOG(INFO) << DebugStreamPointers()

5326:     LOG(INFO) << DebugStreamPointers()

5345:       LOG(INFO) << DebugStreamPointers()

5363:       LOG(INFO) << DebugStreamPointers()

5380:       LOG(INFO) << DebugStreamPointers()

5397:       LOG(INFO) << DebugStreamPointers()

5415:       LOG(INFO) << DebugStreamPointers()

5433:       LOG(INFO) << DebugStreamPointers()

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

33: 	Stream     bool

462:                     "Stream": 29,

793:                     "GeometryStreams": 54,

1110:                     "OpEmitStreamVertex": 220,

1111:                     "OpEndStreamPrimitive": 221,

1322:                     "OpTypeAvcImeResultSingleReferenceStreamoutINTEL": 5707,

1323:                     "OpTypeAvcImeResultDualReferenceStreamoutINTEL": 5708,

1324:                     "OpTypeAvcImeSingleReferenceStreaminINTEL": 5709,

1325:                     "OpTypeAvcImeDualReferenceStreaminINTEL": 5710,

1374:                     "OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL": 5759,

1375:                     "OpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL": 5760,

1376:                     "OpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL": 5761,

1377:                     "OpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL": 5762,

1378:                     "OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL": 5763,

1379:                     "OpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL": 5764,

1381:                     "OpSubgroupAvcImeGetSingleReferenceStreaminINTEL": 5766,

1382:                     "OpSubgroupAvcImeGetDualReferenceStreaminINTEL": 5767,

1383:                     "OpSubgroupAvcImeStripSingleReferenceStreamoutINTEL": 5768,

1384:                     "OpSubgroupAvcImeStripDualReferenceStreamoutINTEL": 5769,

1385:                     "OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL": 5770,

1386:                     "OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL": 5771,

1387:                     "OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL": 5772,

1388:                     "OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL": 5773,

1389:                     "OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL": 5774,

1390:                     "OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL": 5775,

5433:         Stream,

1070:         default AdvancedJmsEndpointConsumerBuilder artemisStreamingEnabled(

1083:         default AdvancedJmsEndpointConsumerBuilder artemisStreamingEnabled(

3102:         default AdvancedJmsEndpointProducerBuilder artemisStreamingEnabled(

3115:         default AdvancedJmsEndpointProducerBuilder artemisStreamingEnabled(

4402:         default AdvancedJmsEndpointBuilder artemisStreamingEnabled(

4415:         default AdvancedJmsEndpointBuilder artemisStreamingEnabled(

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1071:                 boolean artemisStreamingEnabled) {

1072:             doSetProperty("artemisStreamingEnabled", artemisStreamingEnabled);

1084:                 String artemisStreamingEnabled) {

1085:             doSetProperty("artemisStreamingEnabled", artemisStreamingEnabled);

3103:                 boolean artemisStreamingEnabled) {

3104:             doSetProperty("artemisStreamingEnabled", artemisStreamingEnabled);

3116:                 String artemisStreamingEnabled) {

3117:             doSetProperty("artemisStreamingEnabled", artemisStreamingEnabled);

4403:                 boolean artemisStreamingEnabled) {

4404:             doSetProperty("artemisStreamingEnabled", artemisStreamingEnabled);

4416:                 String artemisStreamingEnabled) {

4417:             doSetProperty("artemisStreamingEnabled", artemisStreamingEnabled);

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