_ZN4Json11OurFeatures3allEv: 876| 17.5k|OurFeatures OurFeatures::all() { return {}; } _ZN4Json9OurReader15containsNewLineEPKcS2_: 998| 7| OurReader::Location end) { 999| 7| return std::any_of(begin, end, [](char b) { return b == '\n' || b == '\r'; }); 1000| 7|} _ZN4Json9OurReaderC2ERKNS_11OurFeaturesE: 1002| 17.5k|OurReader::OurReader(OurFeatures const& features) : features_(features) {} _ZN4Json9OurReader5parseEPKcS2_RNS_5ValueEb: 1005| 17.5k| bool collectComments) { 1006| 17.5k| if (!features_.allowComments_) { ------------------ | Branch (1006:7): [True: 0, False: 17.5k] ------------------ 1007| 0| collectComments = false; 1008| 0| } 1009| | 1010| 17.5k| begin_ = beginDoc; 1011| 17.5k| end_ = endDoc; 1012| 17.5k| collectComments_ = collectComments; 1013| 17.5k| current_ = begin_; 1014| 17.5k| lastValueEnd_ = nullptr; 1015| 17.5k| lastValue_ = nullptr; 1016| 17.5k| commentsBefore_.clear(); 1017| 17.5k| errors_.clear(); 1018| 17.5k| while (!nodes_.empty()) ------------------ | Branch (1018:10): [True: 0, False: 17.5k] ------------------ 1019| 0| nodes_.pop(); 1020| 17.5k| nodes_.push(&root); 1021| | 1022| | // skip byte order mark if it exists at the beginning of the UTF-8 text. 1023| 17.5k| skipBom(features_.skipBom_); 1024| 17.5k| bool successful = readValue(); 1025| 17.5k| nodes_.pop(); 1026| 17.5k| Token token; 1027| 17.5k| skipCommentTokens(token); 1028| 17.5k| if (features_.failIfExtra_ && (token.type_ != tokenEndOfStream)) { ------------------ | Branch (1028:7): [True: 0, False: 17.5k] | Branch (1028:33): [True: 0, False: 0] ------------------ 1029| 0| addError("Extra non-whitespace after JSON value.", token); 1030| 0| return false; 1031| 0| } 1032| 17.5k| if (collectComments_ && !commentsBefore_.empty()) ------------------ | Branch (1032:7): [True: 17.5k, False: 0] | Branch (1032:27): [True: 0, False: 17.5k] ------------------ 1033| 0| root.setComment(commentsBefore_, commentAfter); 1034| 17.5k| if (features_.strictRoot_) { ------------------ | Branch (1034:7): [True: 0, False: 17.5k] ------------------ 1035| 0| if (!root.isArray() && !root.isObject()) { ------------------ | Branch (1035:9): [True: 0, False: 0] | Branch (1035:28): [True: 0, False: 0] ------------------ 1036| | // Set error location to start of doc, ideally should be first token found 1037| | // in doc 1038| 0| token.type_ = tokenError; 1039| 0| token.start_ = beginDoc; 1040| 0| token.end_ = endDoc; 1041| 0| addError( 1042| 0| "A valid JSON document must be either an array or an object value.", 1043| 0| token); 1044| 0| return false; 1045| 0| } 1046| 0| } 1047| 17.5k| return successful; 1048| 17.5k|} _ZN4Json9OurReader9readValueEv: 1050| 36.0k|bool OurReader::readValue() { 1051| | // To preserve the old behaviour we cast size_t to int. 1052| 36.0k| if (nodes_.size() > features_.stackLimit_) ------------------ | Branch (1052:7): [True: 0, False: 36.0k] ------------------ 1053| 0| throwRuntimeError("Exceeded stackLimit in readValue()."); 1054| 36.0k| Token token; 1055| 36.0k| skipCommentTokens(token); 1056| 36.0k| bool successful = true; 1057| | 1058| 36.0k| if (collectComments_ && !commentsBefore_.empty()) { ------------------ | Branch (1058:7): [True: 36.0k, False: 0] | Branch (1058:27): [True: 9, False: 36.0k] ------------------ 1059| 9| currentValue().setComment(commentsBefore_, commentBefore); 1060| 9| commentsBefore_.clear(); 1061| 9| } 1062| | 1063| 36.0k| switch (token.type_) { 1064| 16| case tokenObjectBegin: ------------------ | Branch (1064:3): [True: 16, False: 36.0k] ------------------ 1065| 16| successful = readObject(token); 1066| 16| currentValue().setOffsetLimit(current_ - begin_); 1067| 16| break; 1068| 17.1k| case tokenArrayBegin: ------------------ | Branch (1068:3): [True: 17.1k, False: 18.9k] ------------------ 1069| 17.1k| successful = readArray(token); 1070| 17.1k| currentValue().setOffsetLimit(current_ - begin_); 1071| 17.1k| break; 1072| 15.5k| case tokenNumber: ------------------ | Branch (1072:3): [True: 15.5k, False: 20.4k] ------------------ 1073| 15.5k| successful = decodeNumber(token); 1074| 15.5k| break; 1075| 469| case tokenString: ------------------ | Branch (1075:3): [True: 469, False: 35.5k] ------------------ 1076| 469| successful = decodeString(token); 1077| 469| break; 1078| 0| case tokenTrue: { ------------------ | Branch (1078:3): [True: 0, False: 36.0k] ------------------ 1079| 0| Value v(true); 1080| 0| currentValue().swapPayload(v); 1081| 0| currentValue().setOffsetStart(token.start_ - begin_); 1082| 0| currentValue().setOffsetLimit(token.end_ - begin_); 1083| 0| } break; 1084| 0| case tokenFalse: { ------------------ | Branch (1084:3): [True: 0, False: 36.0k] ------------------ 1085| 0| Value v(false); 1086| 0| currentValue().swapPayload(v); 1087| 0| currentValue().setOffsetStart(token.start_ - begin_); 1088| 0| currentValue().setOffsetLimit(token.end_ - begin_); 1089| 0| } break; 1090| 0| case tokenNull: { ------------------ | Branch (1090:3): [True: 0, False: 36.0k] ------------------ 1091| 0| Value v; 1092| 0| currentValue().swapPayload(v); 1093| 0| currentValue().setOffsetStart(token.start_ - begin_); 1094| 0| currentValue().setOffsetLimit(token.end_ - begin_); 1095| 0| } break; 1096| 0| case tokenNaN: { ------------------ | Branch (1096:3): [True: 0, False: 36.0k] ------------------ 1097| 0| Value v(std::numeric_limits::quiet_NaN()); 1098| 0| currentValue().swapPayload(v); 1099| 0| currentValue().setOffsetStart(token.start_ - begin_); 1100| 0| currentValue().setOffsetLimit(token.end_ - begin_); 1101| 0| } break; 1102| 0| case tokenPosInf: { ------------------ | Branch (1102:3): [True: 0, False: 36.0k] ------------------ 1103| 0| Value v(std::numeric_limits::infinity()); 1104| 0| currentValue().swapPayload(v); 1105| 0| currentValue().setOffsetStart(token.start_ - begin_); 1106| 0| currentValue().setOffsetLimit(token.end_ - begin_); 1107| 0| } break; 1108| 0| case tokenNegInf: { ------------------ | Branch (1108:3): [True: 0, False: 36.0k] ------------------ 1109| 0| Value v(-std::numeric_limits::infinity()); 1110| 0| currentValue().swapPayload(v); 1111| 0| currentValue().setOffsetStart(token.start_ - begin_); 1112| 0| currentValue().setOffsetLimit(token.end_ - begin_); 1113| 0| } break; 1114| 0| case tokenArraySeparator: ------------------ | Branch (1114:3): [True: 0, False: 36.0k] ------------------ 1115| 0| case tokenObjectEnd: ------------------ | Branch (1115:3): [True: 0, False: 36.0k] ------------------ 1116| 0| case tokenArrayEnd: ------------------ | Branch (1116:3): [True: 0, False: 36.0k] ------------------ 1117| 0| if (features_.allowDroppedNullPlaceholders_) { ------------------ | Branch (1117:9): [True: 0, False: 0] ------------------ 1118| | // "Un-read" the current token and mark the current value as a null 1119| | // token. 1120| 0| current_--; 1121| 0| Value v; 1122| 0| currentValue().swapPayload(v); 1123| 0| currentValue().setOffsetStart(current_ - begin_ - 1); 1124| 0| currentValue().setOffsetLimit(current_ - begin_); 1125| 0| break; 1126| 0| } // else, fall through ... 1127| 2.86k| default: ------------------ | Branch (1127:3): [True: 2.86k, False: 33.1k] ------------------ 1128| 2.86k| currentValue().setOffsetStart(token.start_ - begin_); 1129| 2.86k| currentValue().setOffsetLimit(token.end_ - begin_); 1130| 2.86k| return addError("Syntax error: value, object or array expected.", token); 1131| 36.0k| } 1132| | 1133| 33.1k| if (collectComments_) { ------------------ | Branch (1133:7): [True: 33.1k, False: 0] ------------------ 1134| 33.1k| lastValueEnd_ = current_; 1135| 33.1k| lastValueHasAComment_ = false; 1136| 33.1k| lastValue_ = ¤tValue(); 1137| 33.1k| } 1138| | 1139| 33.1k| return successful; 1140| 36.0k|} _ZN4Json9OurReader17skipCommentTokensERNS0_5TokenE: 1142| 53.6k|void OurReader::skipCommentTokens(Token& token) { 1143| 53.6k| if (features_.allowComments_) { ------------------ | Branch (1143:7): [True: 53.6k, False: 0] ------------------ 1144| 53.6k| do { 1145| 53.6k| readToken(token); 1146| 53.6k| } while (token.type_ == tokenComment); ------------------ | Branch (1146:14): [True: 9, False: 53.6k] ------------------ 1147| 53.6k| } else { 1148| 0| readToken(token); 1149| 0| } 1150| 53.6k|} _ZN4Json9OurReader9readTokenERNS0_5TokenE: 1152| 177k|bool OurReader::readToken(Token& token) { 1153| 177k| skipSpaces(); 1154| 177k| token.start_ = current_; 1155| 177k| Char c = getNextChar(); 1156| 177k| bool ok = true; 1157| 177k| switch (c) { 1158| 626| case '{': ------------------ | Branch (1158:3): [True: 626, False: 176k] ------------------ 1159| 626| token.type_ = tokenObjectBegin; 1160| 626| break; 1161| 16| case '}': ------------------ | Branch (1161:3): [True: 16, False: 177k] ------------------ 1162| 16| token.type_ = tokenObjectEnd; 1163| 16| break; 1164| 18.8k| case '[': ------------------ | Branch (1164:3): [True: 18.8k, False: 158k] ------------------ 1165| 18.8k| token.type_ = tokenArrayBegin; 1166| 18.8k| break; 1167| 2.31k| case ']': ------------------ | Branch (1167:3): [True: 2.31k, False: 174k] ------------------ 1168| 2.31k| token.type_ = tokenArrayEnd; 1169| 2.31k| break; 1170| 1.10k| case '"': ------------------ | Branch (1170:3): [True: 1.10k, False: 175k] ------------------ 1171| 1.10k| token.type_ = tokenString; 1172| 1.10k| ok = readString(); 1173| 1.10k| break; 1174| 228| case '\'': ------------------ | Branch (1174:3): [True: 228, False: 176k] ------------------ 1175| 228| if (features_.allowSingleQuotes_) { ------------------ | Branch (1175:9): [True: 0, False: 228] ------------------ 1176| 0| token.type_ = tokenString; 1177| 0| ok = readStringSingleQuote(); 1178| 0| break; 1179| 0| } // else fall through 1180| 251| case '/': ------------------ | Branch (1180:3): [True: 23, False: 176k] ------------------ 1181| 251| token.type_ = tokenComment; 1182| 251| ok = readComment(); 1183| 251| break; 1184| 0| case '0': ------------------ | Branch (1184:3): [True: 0, False: 177k] ------------------ 1185| 791| case '1': ------------------ | Branch (1185:3): [True: 791, False: 176k] ------------------ 1186| 2.15k| case '2': ------------------ | Branch (1186:3): [True: 1.35k, False: 175k] ------------------ 1187| 3.76k| case '3': ------------------ | Branch (1187:3): [True: 1.61k, False: 175k] ------------------ 1188| 4.31k| case '4': ------------------ | Branch (1188:3): [True: 545, False: 176k] ------------------ 1189| 4.79k| case '5': ------------------ | Branch (1189:3): [True: 482, False: 176k] ------------------ 1190| 13.3k| case '6': ------------------ | Branch (1190:3): [True: 8.51k, False: 168k] ------------------ 1191| 13.3k| case '7': ------------------ | Branch (1191:3): [True: 0, False: 177k] ------------------ 1192| 13.9k| case '8': ------------------ | Branch (1192:3): [True: 640, False: 176k] ------------------ 1193| 28.8k| case '9': ------------------ | Branch (1193:3): [True: 14.8k, False: 162k] ------------------ 1194| 28.8k| token.type_ = tokenNumber; 1195| 28.8k| readNumber(false); 1196| 28.8k| break; 1197| 6| case '-': ------------------ | Branch (1197:3): [True: 6, False: 177k] ------------------ 1198| 6| if (readNumber(true)) { ------------------ | Branch (1198:9): [True: 6, False: 0] ------------------ 1199| 6| token.type_ = tokenNumber; 1200| 6| } else { 1201| 0| token.type_ = tokenNegInf; 1202| 0| ok = features_.allowSpecialFloats_ && match("nfinity", 7); ------------------ | Branch (1202:12): [True: 0, False: 0] | Branch (1202:45): [True: 0, False: 0] ------------------ 1203| 0| } 1204| 6| break; 1205| 36| case '+': ------------------ | Branch (1205:3): [True: 36, False: 176k] ------------------ 1206| 36| if (readNumber(true)) { ------------------ | Branch (1206:9): [True: 30, False: 6] ------------------ 1207| 30| token.type_ = tokenNumber; 1208| 30| } else { 1209| 6| token.type_ = tokenPosInf; 1210| 6| ok = features_.allowSpecialFloats_ && match("nfinity", 7); ------------------ | Branch (1210:12): [True: 0, False: 6] | Branch (1210:45): [True: 0, False: 0] ------------------ 1211| 6| } 1212| 36| break; 1213| 16| case 't': ------------------ | Branch (1213:3): [True: 16, False: 177k] ------------------ 1214| 16| token.type_ = tokenTrue; 1215| 16| ok = match("rue", 3); 1216| 16| break; 1217| 0| case 'f': ------------------ | Branch (1217:3): [True: 0, False: 177k] ------------------ 1218| 0| token.type_ = tokenFalse; 1219| 0| ok = match("alse", 4); 1220| 0| break; 1221| 0| case 'n': ------------------ | Branch (1221:3): [True: 0, False: 177k] ------------------ 1222| 0| token.type_ = tokenNull; 1223| 0| ok = match("ull", 3); 1224| 0| break; 1225| 0| case 'N': ------------------ | Branch (1225:3): [True: 0, False: 177k] ------------------ 1226| 0| if (features_.allowSpecialFloats_) { ------------------ | Branch (1226:9): [True: 0, False: 0] ------------------ 1227| 0| token.type_ = tokenNaN; 1228| 0| ok = match("aN", 2); 1229| 0| } else { 1230| 0| ok = false; 1231| 0| } 1232| 0| break; 1233| 64.6k| case 'I': ------------------ | Branch (1233:3): [True: 64.6k, False: 112k] ------------------ 1234| 64.6k| if (features_.allowSpecialFloats_) { ------------------ | Branch (1234:9): [True: 0, False: 64.6k] ------------------ 1235| 0| token.type_ = tokenPosInf; 1236| 0| ok = match("nfinity", 7); 1237| 64.6k| } else { 1238| 64.6k| ok = false; 1239| 64.6k| } 1240| 64.6k| break; 1241| 2.06k| case ',': ------------------ | Branch (1241:3): [True: 2.06k, False: 174k] ------------------ 1242| 2.06k| token.type_ = tokenArraySeparator; 1243| 2.06k| break; 1244| 0| case ':': ------------------ | Branch (1244:3): [True: 0, False: 177k] ------------------ 1245| 0| token.type_ = tokenMemberSeparator; 1246| 0| break; 1247| 32.7k| case 0: ------------------ | Branch (1247:3): [True: 32.7k, False: 144k] ------------------ 1248| 32.7k| token.type_ = tokenEndOfStream; 1249| 32.7k| break; 1250| 25.5k| default: ------------------ | Branch (1250:3): [True: 25.5k, False: 151k] ------------------ 1251| 25.5k| ok = false; 1252| 25.5k| break; 1253| 177k| } 1254| 177k| if (!ok) ------------------ | Branch (1254:7): [True: 91.0k, False: 85.9k] ------------------ 1255| 91.0k| token.type_ = tokenError; 1256| 177k| token.end_ = current_; 1257| 177k| return ok; 1258| 177k|} _ZN4Json9OurReader10skipSpacesEv: 1260| 195k|void OurReader::skipSpaces() { 1261| 195k| while (current_ != end_) { ------------------ | Branch (1261:10): [True: 166k, False: 28.9k] ------------------ 1262| 166k| Char c = *current_; 1263| 166k| if (c == ' ' || c == '\t' || c == '\r' || c == '\n') ------------------ | Branch (1263:9): [True: 8, False: 166k] | Branch (1263:21): [True: 0, False: 166k] | Branch (1263:34): [True: 0, False: 166k] | Branch (1263:47): [True: 261, False: 166k] ------------------ 1264| 269| ++current_; 1265| 166k| else 1266| 166k| break; 1267| 166k| } 1268| 195k|} _ZN4Json9OurReader7skipBomEb: 1270| 17.5k|void OurReader::skipBom(bool skipBom) { 1271| | // The default behavior is to skip BOM. 1272| 17.5k| if (skipBom) { ------------------ | Branch (1272:7): [True: 17.5k, False: 0] ------------------ 1273| 17.5k| if ((end_ - begin_) >= 3 && strncmp(begin_, "\xEF\xBB\xBF", 3) == 0) { ------------------ | Branch (1273:9): [True: 16.6k, False: 871] | Branch (1273:33): [True: 0, False: 16.6k] ------------------ 1274| 0| begin_ += 3; 1275| 0| current_ = begin_; 1276| 0| } 1277| 17.5k| } 1278| 17.5k|} _ZN4Json9OurReader5matchEPKci: 1280| 16|bool OurReader::match(const Char* pattern, int patternLength) { 1281| 16| if (end_ - current_ < patternLength) ------------------ | Branch (1281:7): [True: 0, False: 16] ------------------ 1282| 0| return false; 1283| 16| int index = patternLength; 1284| 24| while (index--) ------------------ | Branch (1284:10): [True: 24, False: 0] ------------------ 1285| 24| if (current_[index] != pattern[index]) ------------------ | Branch (1285:9): [True: 16, False: 8] ------------------ 1286| 16| return false; 1287| 0| current_ += patternLength; 1288| 0| return true; 1289| 16|} _ZN4Json9OurReader11readCommentEv: 1291| 251|bool OurReader::readComment() { 1292| 251| const Location commentBegin = current_ - 1; 1293| 251| const Char c = getNextChar(); 1294| 251| bool successful = false; 1295| 251| bool cStyleWithEmbeddedNewline = false; 1296| | 1297| 251| const bool isCStyleComment = (c == '*'); 1298| 251| const bool isCppStyleComment = (c == '/'); 1299| 251| if (isCStyleComment) { ------------------ | Branch (1299:7): [True: 0, False: 251] ------------------ 1300| 0| successful = readCStyleComment(&cStyleWithEmbeddedNewline); 1301| 251| } else if (isCppStyleComment) { ------------------ | Branch (1301:14): [True: 16, False: 235] ------------------ 1302| 16| successful = readCppStyleComment(); 1303| 16| } 1304| | 1305| 251| if (!successful) ------------------ | Branch (1305:7): [True: 235, False: 16] ------------------ 1306| 235| return false; 1307| | 1308| 16| if (collectComments_) { ------------------ | Branch (1308:7): [True: 16, False: 0] ------------------ 1309| 16| CommentPlacement placement = commentBefore; 1310| | 1311| 16| if (!lastValueHasAComment_) { ------------------ | Branch (1311:9): [True: 16, False: 0] ------------------ 1312| 16| if (lastValueEnd_ && !containsNewLine(lastValueEnd_, commentBegin)) { ------------------ | Branch (1312:11): [True: 7, False: 9] | Branch (1312:28): [True: 7, False: 0] ------------------ 1313| 7| if (isCppStyleComment || !cStyleWithEmbeddedNewline) { ------------------ | Branch (1313:13): [True: 7, False: 0] | Branch (1313:34): [True: 0, False: 0] ------------------ 1314| 7| placement = commentAfterOnSameLine; 1315| 7| lastValueHasAComment_ = true; 1316| 7| } 1317| 7| } 1318| 16| } 1319| | 1320| 16| addComment(commentBegin, current_, placement); 1321| 16| } 1322| 16| return true; 1323| 251|} _ZN4Json9OurReader12normalizeEOLEPKcS2_: 1326| 16| OurReader::Location end) { 1327| 16| String normalized; 1328| 16| normalized.reserve(static_cast(end - begin)); 1329| 16| OurReader::Location current = begin; 1330| 195| while (current != end) { ------------------ | Branch (1330:10): [True: 179, False: 16] ------------------ 1331| 179| char c = *current++; 1332| 179| if (c == '\r') { ------------------ | Branch (1332:9): [True: 7, False: 172] ------------------ 1333| 7| if (current != end && *current == '\n') ------------------ | Branch (1333:11): [True: 0, False: 7] | Branch (1333:29): [True: 0, False: 0] ------------------ 1334| | // convert dos EOL 1335| 0| ++current; 1336| | // convert Mac EOL 1337| 7| normalized += '\n'; 1338| 172| } else { 1339| 172| normalized += c; 1340| 172| } 1341| 179| } 1342| 16| return normalized; 1343| 16|} _ZN4Json9OurReader10addCommentEPKcS2_NS_16CommentPlacementE: 1346| 16| CommentPlacement placement) { 1347| 16| assert(collectComments_); 1348| 16| const String& normalized = normalizeEOL(begin, end); 1349| 16| if (placement == commentAfterOnSameLine) { ------------------ | Branch (1349:7): [True: 7, False: 9] ------------------ 1350| 7| assert(lastValue_ != nullptr); 1351| 7| lastValue_->setComment(normalized, placement); 1352| 9| } else { 1353| 9| commentsBefore_ += normalized; 1354| 9| } 1355| 16|} _ZN4Json9OurReader19readCppStyleCommentEv: 1371| 16|bool OurReader::readCppStyleComment() { 1372| 156| while (current_ != end_) { ------------------ | Branch (1372:10): [True: 147, False: 9] ------------------ 1373| 147| Char c = getNextChar(); 1374| 147| if (c == '\n') ------------------ | Branch (1374:9): [True: 0, False: 147] ------------------ 1375| 0| break; 1376| 147| if (c == '\r') { ------------------ | Branch (1376:9): [True: 7, False: 140] ------------------ 1377| | // Consume DOS EOL. It will be normalized in addComment. 1378| 7| if (current_ != end_ && *current_ == '\n') ------------------ | Branch (1378:11): [True: 7, False: 0] | Branch (1378:31): [True: 0, False: 7] ------------------ 1379| 0| getNextChar(); 1380| | // Break on Moc OS 9 EOL. 1381| 7| break; 1382| 7| } 1383| 147| } 1384| 16| return true; 1385| 16|} _ZN4Json9OurReader10readNumberEb: 1387| 28.8k|bool OurReader::readNumber(bool checkInf) { 1388| 28.8k| Location p = current_; 1389| 28.8k| if (checkInf && p != end_ && *p == 'I') { ------------------ | Branch (1389:7): [True: 42, False: 28.8k] | Branch (1389:19): [True: 42, False: 0] | Branch (1389:32): [True: 6, False: 36] ------------------ 1390| 6| current_ = ++p; 1391| 6| return false; 1392| 6| } 1393| 28.8k| char c = '0'; // stopgap for already consumed character 1394| | // integral part 1395| 110k| while (c >= '0' && c <= '9') ------------------ | Branch (1395:10): [True: 107k, False: 3.22k] | Branch (1395:22): [True: 81.6k, False: 25.6k] ------------------ 1396| 81.6k| c = (current_ = p) < end_ ? *p++ : '\0'; ------------------ | Branch (1396:9): [True: 80.9k, False: 723] ------------------ 1397| | // fractional part 1398| 28.8k| if (c == '.') { ------------------ | Branch (1398:7): [True: 490, False: 28.3k] ------------------ 1399| 490| c = (current_ = p) < end_ ? *p++ : '\0'; ------------------ | Branch (1399:9): [True: 490, False: 0] ------------------ 1400| 980| while (c >= '0' && c <= '9') ------------------ | Branch (1400:12): [True: 838, False: 142] | Branch (1400:24): [True: 490, False: 348] ------------------ 1401| 490| c = (current_ = p) < end_ ? *p++ : '\0'; ------------------ | Branch (1401:11): [True: 490, False: 0] ------------------ 1402| 490| } 1403| | // exponential part 1404| 28.8k| if (c == 'e' || c == 'E') { ------------------ | Branch (1404:7): [True: 12.9k, False: 15.8k] | Branch (1404:19): [True: 0, False: 15.8k] ------------------ 1405| 12.9k| c = (current_ = p) < end_ ? *p++ : '\0'; ------------------ | Branch (1405:9): [True: 12.9k, False: 0] ------------------ 1406| 12.9k| if (c == '+' || c == '-') ------------------ | Branch (1406:9): [True: 0, False: 12.9k] | Branch (1406:21): [True: 0, False: 12.9k] ------------------ 1407| 0| c = (current_ = p) < end_ ? *p++ : '\0'; ------------------ | Branch (1407:11): [True: 0, False: 0] ------------------ 1408| 33.4k| while (c >= '0' && c <= '9') ------------------ | Branch (1408:12): [True: 31.7k, False: 1.71k] | Branch (1408:24): [True: 20.4k, False: 11.2k] ------------------ 1409| 20.4k| c = (current_ = p) < end_ ? *p++ : '\0'; ------------------ | Branch (1409:11): [True: 18.7k, False: 1.69k] ------------------ 1410| 12.9k| } 1411| 28.8k| return true; 1412| 28.8k|} _ZN4Json9OurReader10readStringEv: 1413| 1.10k|bool OurReader::readString() { 1414| 1.10k| Char c = 0; 1415| 8.65k| while (current_ != end_) { ------------------ | Branch (1415:10): [True: 8.01k, False: 637] ------------------ 1416| 8.01k| c = getNextChar(); 1417| 8.01k| if (c == '\\') ------------------ | Branch (1417:9): [True: 458, False: 7.55k] ------------------ 1418| 458| getNextChar(); 1419| 7.55k| else if (c == '"') ------------------ | Branch (1419:14): [True: 469, False: 7.08k] ------------------ 1420| 469| break; 1421| 8.01k| } 1422| 1.10k| return c == '"'; 1423| 1.10k|} _ZN4Json9OurReader10readObjectERNS0_5TokenE: 1437| 16|bool OurReader::readObject(Token& token) { 1438| 16| Token tokenName; 1439| 16| String name; 1440| 16| Value init(objectValue); 1441| 16| currentValue().swapPayload(init); 1442| 16| currentValue().setOffsetStart(token.start_ - begin_); 1443| 16| while (readToken(tokenName)) { ------------------ | Branch (1443:10): [True: 0, False: 16] ------------------ 1444| 0| bool initialTokenOk = true; 1445| 0| while (tokenName.type_ == tokenComment && initialTokenOk) ------------------ | Branch (1445:12): [True: 0, False: 0] | Branch (1445:47): [True: 0, False: 0] ------------------ 1446| 0| initialTokenOk = readToken(tokenName); 1447| 0| if (!initialTokenOk) ------------------ | Branch (1447:9): [True: 0, False: 0] ------------------ 1448| 0| break; 1449| 0| if (tokenName.type_ == tokenObjectEnd && ------------------ | Branch (1449:9): [True: 0, False: 0] ------------------ 1450| 0| (name.empty() || ------------------ | Branch (1450:10): [True: 0, False: 0] ------------------ 1451| 0| features_.allowTrailingCommas_)) // empty object or trailing comma ------------------ | Branch (1451:10): [True: 0, False: 0] ------------------ 1452| 0| return true; 1453| 0| name.clear(); 1454| 0| if (tokenName.type_ == tokenString) { ------------------ | Branch (1454:9): [True: 0, False: 0] ------------------ 1455| 0| if (!decodeString(tokenName, name)) ------------------ | Branch (1455:11): [True: 0, False: 0] ------------------ 1456| 0| return recoverFromError(tokenObjectEnd); 1457| 0| } else if (tokenName.type_ == tokenNumber && features_.allowNumericKeys_) { ------------------ | Branch (1457:16): [True: 0, False: 0] | Branch (1457:50): [True: 0, False: 0] ------------------ 1458| 0| Value numberName; 1459| 0| if (!decodeNumber(tokenName, numberName)) ------------------ | Branch (1459:11): [True: 0, False: 0] ------------------ 1460| 0| return recoverFromError(tokenObjectEnd); 1461| 0| name = numberName.asString(); 1462| 0| } else { 1463| 0| break; 1464| 0| } 1465| 0| if (name.length() >= (1U << 30)) ------------------ | Branch (1465:9): [True: 0, False: 0] ------------------ 1466| 0| throwRuntimeError("keylength >= 2^30"); 1467| 0| if (features_.rejectDupKeys_ && currentValue().isMember(name)) { ------------------ | Branch (1467:9): [True: 0, False: 0] | Branch (1467:37): [True: 0, False: 0] ------------------ 1468| 0| String msg = "Duplicate key: '" + name + "'"; 1469| 0| return addErrorAndRecover(msg, tokenName, tokenObjectEnd); 1470| 0| } 1471| | 1472| 0| Token colon; 1473| 0| if (!readToken(colon) || colon.type_ != tokenMemberSeparator) { ------------------ | Branch (1473:9): [True: 0, False: 0] | Branch (1473:30): [True: 0, False: 0] ------------------ 1474| 0| return addErrorAndRecover("Missing ':' after object member name", colon, 1475| 0| tokenObjectEnd); 1476| 0| } 1477| 0| Value& value = currentValue()[name]; 1478| 0| nodes_.push(&value); 1479| 0| bool ok = readValue(); 1480| 0| nodes_.pop(); 1481| 0| if (!ok) // error already set ------------------ | Branch (1481:9): [True: 0, False: 0] ------------------ 1482| 0| return recoverFromError(tokenObjectEnd); 1483| | 1484| 0| Token comma; 1485| 0| if (!readToken(comma) || ------------------ | Branch (1485:9): [True: 0, False: 0] ------------------ 1486| 0| (comma.type_ != tokenObjectEnd && comma.type_ != tokenArraySeparator && ------------------ | Branch (1486:10): [True: 0, False: 0] | Branch (1486:43): [True: 0, False: 0] ------------------ 1487| 0| comma.type_ != tokenComment)) { ------------------ | Branch (1487:10): [True: 0, False: 0] ------------------ 1488| 0| return addErrorAndRecover("Missing ',' or '}' in object declaration", 1489| 0| comma, tokenObjectEnd); 1490| 0| } 1491| 0| bool finalizeTokenOk = true; 1492| 0| while (comma.type_ == tokenComment && finalizeTokenOk) ------------------ | Branch (1492:12): [True: 0, False: 0] | Branch (1492:43): [True: 0, False: 0] ------------------ 1493| 0| finalizeTokenOk = readToken(comma); 1494| 0| if (comma.type_ == tokenObjectEnd) ------------------ | Branch (1494:9): [True: 0, False: 0] ------------------ 1495| 0| return true; 1496| 0| } 1497| 16| return addErrorAndRecover("Missing '}' or object member name", tokenName, 1498| 16| tokenObjectEnd); 1499| 16|} _ZN4Json9OurReader9readArrayERNS0_5TokenE: 1501| 17.1k|bool OurReader::readArray(Token& token) { 1502| 17.1k| Value init(arrayValue); 1503| 17.1k| currentValue().swapPayload(init); 1504| 17.1k| currentValue().setOffsetStart(token.start_ - begin_); 1505| 17.1k| int index = 0; 1506| 18.5k| for (;;) { 1507| 18.5k| skipSpaces(); 1508| 18.5k| if (current_ != end_ && *current_ == ']' && ------------------ | Branch (1508:9): [True: 18.5k, False: 0] | Branch (1508:29): [True: 0, False: 18.5k] ------------------ 1509| 18.5k| (index == 0 || ------------------ | Branch (1509:10): [True: 0, False: 0] ------------------ 1510| 0| (features_.allowTrailingCommas_ && ------------------ | Branch (1510:11): [True: 0, False: 0] ------------------ 1511| 0| !features_.allowDroppedNullPlaceholders_))) // empty array or trailing ------------------ | Branch (1511:11): [True: 0, False: 0] ------------------ 1512| | // comma 1513| 0| { 1514| 0| Token endArray; 1515| 0| readToken(endArray); 1516| 0| return true; 1517| 0| } 1518| 18.5k| Value& value = currentValue()[index++]; 1519| 18.5k| nodes_.push(&value); 1520| 18.5k| bool ok = readValue(); 1521| 18.5k| nodes_.pop(); 1522| 18.5k| if (!ok) // error already set ------------------ | Branch (1522:9): [True: 13.5k, False: 4.99k] ------------------ 1523| 13.5k| return recoverFromError(tokenArrayEnd); 1524| | 1525| 4.99k| Token currentToken; 1526| | // Accept Comment after last item in the array. 1527| 4.99k| ok = readToken(currentToken); 1528| 4.99k| while (currentToken.type_ == tokenComment && ok) { ------------------ | Branch (1528:12): [True: 0, False: 4.99k] | Branch (1528:50): [True: 0, False: 0] ------------------ 1529| 0| ok = readToken(currentToken); 1530| 0| } 1531| 4.99k| bool badTokenType = (currentToken.type_ != tokenArraySeparator && ------------------ | Branch (1531:26): [True: 3.61k, False: 1.38k] ------------------ 1532| 4.99k| currentToken.type_ != tokenArrayEnd); ------------------ | Branch (1532:26): [True: 2.20k, False: 1.41k] ------------------ 1533| 4.99k| if (!ok || badTokenType) { ------------------ | Branch (1533:9): [True: 2.19k, False: 2.79k] | Branch (1533:16): [True: 6, False: 2.79k] ------------------ 1534| 2.20k| return addErrorAndRecover("Missing ',' or ']' in array declaration", 1535| 2.20k| currentToken, tokenArrayEnd); 1536| 2.20k| } 1537| 2.79k| if (currentToken.type_ == tokenArrayEnd) ------------------ | Branch (1537:9): [True: 1.41k, False: 1.38k] ------------------ 1538| 1.41k| break; 1539| 2.79k| } 1540| 1.41k| return true; 1541| 17.1k|} _ZN4Json9OurReader12decodeNumberERNS0_5TokenE: 1543| 15.5k|bool OurReader::decodeNumber(Token& token) { 1544| 15.5k| Value decoded; 1545| 15.5k| if (!decodeNumber(token, decoded)) ------------------ | Branch (1545:7): [True: 11.2k, False: 4.29k] ------------------ 1546| 11.2k| return false; 1547| 4.29k| currentValue().swapPayload(decoded); 1548| 4.29k| currentValue().setOffsetStart(token.start_ - begin_); 1549| 4.29k| currentValue().setOffsetLimit(token.end_ - begin_); 1550| 4.29k| return true; 1551| 15.5k|} _ZN4Json9OurReader12decodeNumberERNS0_5TokenERNS_5ValueE: 1553| 15.5k|bool OurReader::decodeNumber(Token& token, Value& decoded) { 1554| | // Attempts to parse the number as an integer. If the number is 1555| | // larger than the maximum supported value of an integer then 1556| | // we decode the number as a double. 1557| 15.5k| Location current = token.start_; 1558| 15.5k| const bool isNegative = *current == '-'; 1559| 15.5k| if (isNegative) { ------------------ | Branch (1559:7): [True: 0, False: 15.5k] ------------------ 1560| 0| ++current; 1561| 0| } 1562| | 1563| | // We assume we can represent the largest and smallest integer types as 1564| | // unsigned integers with separate sign. This is only true if they can fit 1565| | // into an unsigned integer. 1566| 15.5k| static_assert(Value::maxLargestInt <= Value::maxLargestUInt, 1567| 15.5k| "Int must be smaller than UInt"); 1568| | 1569| | // We need to convert minLargestInt into a positive number. The easiest way 1570| | // to do this conversion is to assume our "threshold" value of minLargestInt 1571| | // divided by 10 can fit in maxLargestInt when absolute valued. This should 1572| | // be a safe assumption. 1573| 15.5k| static_assert(Value::minLargestInt <= -Value::maxLargestInt, 1574| 15.5k| "The absolute value of minLargestInt must be greater than or " 1575| 15.5k| "equal to maxLargestInt"); 1576| 15.5k| static_assert(Value::minLargestInt / 10 >= -Value::maxLargestInt, 1577| 15.5k| "The absolute value of minLargestInt must be only 1 magnitude " 1578| 15.5k| "larger than maxLargest Int"); 1579| | 1580| 15.5k| static constexpr Value::LargestUInt positive_threshold = 1581| 15.5k| Value::maxLargestUInt / 10; 1582| 15.5k| static constexpr Value::UInt positive_last_digit = Value::maxLargestUInt % 10; 1583| | 1584| | // For the negative values, we have to be more careful. Since typically 1585| | // -Value::minLargestInt will cause an overflow, we first divide by 10 and 1586| | // then take the inverse. This assumes that minLargestInt is only a single 1587| | // power of 10 different in magnitude, which we check above. For the last 1588| | // digit, we take the modulus before negating for the same reason. 1589| 15.5k| static constexpr auto negative_threshold = 1590| 15.5k| Value::LargestUInt(-(Value::minLargestInt / 10)); 1591| 15.5k| static constexpr auto negative_last_digit = 1592| 15.5k| Value::UInt(-(Value::minLargestInt % 10)); 1593| | 1594| 15.5k| const Value::LargestUInt threshold = 1595| 15.5k| isNegative ? negative_threshold : positive_threshold; ------------------ | Branch (1595:7): [True: 0, False: 15.5k] ------------------ 1596| 15.5k| const Value::UInt max_last_digit = 1597| 15.5k| isNegative ? negative_last_digit : positive_last_digit; ------------------ | Branch (1597:7): [True: 0, False: 15.5k] ------------------ 1598| | 1599| 15.5k| Value::LargestUInt value = 0; 1600| 57.3k| while (current < token.end_) { ------------------ | Branch (1600:10): [True: 53.5k, False: 3.85k] ------------------ 1601| 53.5k| Char c = *current++; 1602| 53.5k| if (c < '0' || c > '9') ------------------ | Branch (1602:9): [True: 440, False: 53.0k] | Branch (1602:20): [True: 11.2k, False: 41.8k] ------------------ 1603| 11.7k| return decodeDouble(token, decoded); 1604| | 1605| 41.8k| const auto digit(static_cast(c - '0')); 1606| 41.8k| if (value >= threshold) { ------------------ | Branch (1606:9): [True: 0, False: 41.8k] ------------------ 1607| | // We've hit or exceeded the max value divided by 10 (rounded down). If 1608| | // a) we've only just touched the limit, meaing value == threshold, 1609| | // b) this is the last digit, or 1610| | // c) it's small enough to fit in that rounding delta, we're okay. 1611| | // Otherwise treat this number as a double to avoid overflow. 1612| 0| if (value > threshold || current != token.end_ || ------------------ | Branch (1612:11): [True: 0, False: 0] | Branch (1612:32): [True: 0, False: 0] ------------------ 1613| 0| digit > max_last_digit) { ------------------ | Branch (1613:11): [True: 0, False: 0] ------------------ 1614| 0| return decodeDouble(token, decoded); 1615| 0| } 1616| 0| } 1617| 41.8k| value = value * 10 + digit; 1618| 41.8k| } 1619| | 1620| 3.85k| if (isNegative) { ------------------ | Branch (1620:7): [True: 0, False: 3.85k] ------------------ 1621| | // We use the same magnitude assumption here, just in case. 1622| 0| const auto last_digit = static_cast(value % 10); 1623| 0| decoded = -Value::LargestInt(value / 10) * 10 - last_digit; 1624| 3.85k| } else if (value <= Value::LargestUInt(Value::maxLargestInt)) { ------------------ | Branch (1624:14): [True: 3.85k, False: 0] ------------------ 1625| 3.85k| decoded = Value::LargestInt(value); 1626| 3.85k| } else { 1627| 0| decoded = value; 1628| 0| } 1629| | 1630| 3.85k| return true; 1631| 15.5k|} _ZN4Json9OurReader12decodeDoubleERNS0_5TokenERNS_5ValueE: 1643| 11.7k|bool OurReader::decodeDouble(Token& token, Value& decoded) { 1644| 11.7k| double value = 0; 1645| 11.7k| const String buffer(token.start_, token.end_); 1646| 11.7k| IStringStream is(buffer); 1647| 11.7k| if (!(is >> value)) { ------------------ | Branch (1647:7): [True: 11.2k, False: 440] ------------------ 1648| 11.2k| return addError( 1649| 11.2k| "'" + String(token.start_, token.end_) + "' is not a number.", token); 1650| 11.2k| } 1651| 440| decoded = value; 1652| 440| return true; 1653| 11.7k|} _ZN4Json9OurReader12decodeStringERNS0_5TokenE: 1655| 469|bool OurReader::decodeString(Token& token) { 1656| 469| String decoded_string; 1657| 469| if (!decodeString(token, decoded_string)) ------------------ | Branch (1657:7): [True: 0, False: 469] ------------------ 1658| 0| return false; 1659| 469| Value decoded(decoded_string); 1660| 469| currentValue().swapPayload(decoded); 1661| 469| currentValue().setOffsetStart(token.start_ - begin_); 1662| 469| currentValue().setOffsetLimit(token.end_ - begin_); 1663| 469| return true; 1664| 469|} _ZN4Json9OurReader12decodeStringERNS0_5TokenERNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE: 1666| 469|bool OurReader::decodeString(Token& token, String& decoded) { 1667| 469| decoded.reserve(static_cast(token.end_ - token.start_ - 2)); 1668| 469| Location current = token.start_ + 1; // skip '"' 1669| 469| Location end = token.end_ - 1; // do not include '"' 1670| 3.82k| while (current != end) { ------------------ | Branch (1670:10): [True: 3.35k, False: 469] ------------------ 1671| 3.35k| Char c = *current++; 1672| 3.35k| if (c == '"') ------------------ | Branch (1672:9): [True: 0, False: 3.35k] ------------------ 1673| 0| break; 1674| 3.35k| if (c == '\\') { ------------------ | Branch (1674:9): [True: 458, False: 2.89k] ------------------ 1675| 458| if (current == end) ------------------ | Branch (1675:11): [True: 0, False: 458] ------------------ 1676| 0| return addError("Empty escape sequence in string", token, current); 1677| 458| Char escape = *current++; 1678| 458| switch (escape) { 1679| 0| case '"': ------------------ | Branch (1679:7): [True: 0, False: 458] ------------------ 1680| 0| decoded += '"'; 1681| 0| break; 1682| 0| case '/': ------------------ | Branch (1682:7): [True: 0, False: 458] ------------------ 1683| 0| decoded += '/'; 1684| 0| break; 1685| 0| case '\\': ------------------ | Branch (1685:7): [True: 0, False: 458] ------------------ 1686| 0| decoded += '\\'; 1687| 0| break; 1688| 0| case 'b': ------------------ | Branch (1688:7): [True: 0, False: 458] ------------------ 1689| 0| decoded += '\b'; 1690| 0| break; 1691| 0| case 'f': ------------------ | Branch (1691:7): [True: 0, False: 458] ------------------ 1692| 0| decoded += '\f'; 1693| 0| break; 1694| 122| case 'n': ------------------ | Branch (1694:7): [True: 122, False: 336] ------------------ 1695| 122| decoded += '\n'; 1696| 122| break; 1697| 0| case 'r': ------------------ | Branch (1697:7): [True: 0, False: 458] ------------------ 1698| 0| decoded += '\r'; 1699| 0| break; 1700| 0| case 't': ------------------ | Branch (1700:7): [True: 0, False: 458] ------------------ 1701| 0| decoded += '\t'; 1702| 0| break; 1703| 336| case 'u': { ------------------ | Branch (1703:7): [True: 336, False: 122] ------------------ 1704| 336| unsigned int unicode; 1705| 336| if (!decodeUnicodeCodePoint(token, current, end, unicode)) ------------------ | Branch (1705:13): [True: 0, False: 336] ------------------ 1706| 0| return false; 1707| 336| decoded += codePointToUTF8(unicode); 1708| 336| } break; 1709| 0| default: ------------------ | Branch (1709:7): [True: 0, False: 458] ------------------ 1710| 0| return addError("Bad escape sequence in string", token, current); 1711| 458| } 1712| 2.89k| } else { 1713| 2.89k| decoded += c; 1714| 2.89k| } 1715| 3.35k| } 1716| 469| return true; 1717| 469|} _ZN4Json9OurReader22decodeUnicodeCodePointERNS0_5TokenERPKcS4_Rj: 1720| 336| Location end, unsigned int& unicode) { 1721| | 1722| 336| if (!decodeUnicodeEscapeSequence(token, current, end, unicode)) ------------------ | Branch (1722:7): [True: 0, False: 336] ------------------ 1723| 0| return false; 1724| 336| if (unicode >= 0xD800 && unicode <= 0xDBFF) { ------------------ | Branch (1724:7): [True: 0, False: 336] | Branch (1724:28): [True: 0, False: 0] ------------------ 1725| | // surrogate pairs 1726| 0| if (end - current < 6) ------------------ | Branch (1726:9): [True: 0, False: 0] ------------------ 1727| 0| return addError( 1728| 0| "additional six characters expected to parse unicode surrogate pair.", 1729| 0| token, current); 1730| 0| if (*(current++) == '\\' && *(current++) == 'u') { ------------------ | Branch (1730:9): [True: 0, False: 0] | Branch (1730:33): [True: 0, False: 0] ------------------ 1731| 0| unsigned int surrogatePair; 1732| 0| if (decodeUnicodeEscapeSequence(token, current, end, surrogatePair)) { ------------------ | Branch (1732:11): [True: 0, False: 0] ------------------ 1733| 0| unicode = 0x10000 + ((unicode & 0x3FF) << 10) + (surrogatePair & 0x3FF); 1734| 0| } else 1735| 0| return false; 1736| 0| } else 1737| 0| return addError("expecting another \\u token to begin the second half of " 1738| 0| "a unicode surrogate pair", 1739| 0| token, current); 1740| 0| } 1741| 336| return true; 1742| 336|} _ZN4Json9OurReader27decodeUnicodeEscapeSequenceERNS0_5TokenERPKcS4_Rj: 1746| 336| unsigned int& ret_unicode) { 1747| 336| if (end - current < 4) ------------------ | Branch (1747:7): [True: 0, False: 336] ------------------ 1748| 0| return addError( 1749| 0| "Bad unicode escape sequence in string: four digits expected.", token, 1750| 0| current); 1751| 336| int unicode = 0; 1752| 1.68k| for (int index = 0; index < 4; ++index) { ------------------ | Branch (1752:23): [True: 1.34k, False: 336] ------------------ 1753| 1.34k| Char c = *current++; 1754| 1.34k| unicode *= 16; 1755| 1.34k| if (c >= '0' && c <= '9') ------------------ | Branch (1755:9): [True: 1.34k, False: 0] | Branch (1755:21): [True: 1.00k, False: 336] ------------------ 1756| 1.00k| unicode += c - '0'; 1757| 336| else if (c >= 'a' && c <= 'f') ------------------ | Branch (1757:14): [True: 0, False: 336] | Branch (1757:26): [True: 0, False: 0] ------------------ 1758| 0| unicode += c - 'a' + 10; 1759| 336| else if (c >= 'A' && c <= 'F') ------------------ | Branch (1759:14): [True: 336, False: 0] | Branch (1759:26): [True: 336, False: 0] ------------------ 1760| 336| unicode += c - 'A' + 10; 1761| 0| else 1762| 0| return addError( 1763| 0| "Bad unicode escape sequence in string: hexadecimal digit expected.", 1764| 0| token, current); 1765| 1.34k| } 1766| 336| ret_unicode = static_cast(unicode); 1767| 336| return true; 1768| 336|} _ZN4Json9OurReader8addErrorERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERNS0_5TokenEPKc: 1770| 16.3k|bool OurReader::addError(const String& message, Token& token, Location extra) { 1771| 16.3k| ErrorInfo info; 1772| 16.3k| info.token_ = token; 1773| 16.3k| info.message_ = message; 1774| 16.3k| info.extra_ = extra; 1775| 16.3k| errors_.push_back(info); 1776| 16.3k| return false; 1777| 16.3k|} _ZN4Json9OurReader16recoverFromErrorENS0_9TokenTypeE: 1779| 15.7k|bool OurReader::recoverFromError(TokenType skipUntilToken) { 1780| 15.7k| size_t errorCount = errors_.size(); 1781| 15.7k| Token skip; 1782| 118k| for (;;) { 1783| 118k| if (!readToken(skip)) ------------------ | Branch (1783:9): [True: 86.3k, False: 32.0k] ------------------ 1784| 86.3k| errors_.resize(errorCount); // discard errors caused by recovery 1785| 118k| if (skip.type_ == skipUntilToken || skip.type_ == tokenEndOfStream) ------------------ | Branch (1785:9): [True: 562, False: 117k] | Branch (1785:41): [True: 15.1k, False: 102k] ------------------ 1786| 15.7k| break; 1787| 118k| } 1788| 15.7k| errors_.resize(errorCount); 1789| 15.7k| return false; 1790| 15.7k|} _ZN4Json9OurReader18addErrorAndRecoverERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERNS0_5TokenENS0_9TokenTypeE: 1793| 2.21k| TokenType skipUntilToken) { 1794| 2.21k| addError(message, token); 1795| 2.21k| return recoverFromError(skipUntilToken); 1796| 2.21k|} _ZN4Json9OurReader12currentValueEv: 1798| 123k|Value& OurReader::currentValue() { return *(nodes_.top()); } _ZN4Json9OurReader11getNextCharEv: 1800| 185k|OurReader::Char OurReader::getNextChar() { 1801| 185k| if (current_ == end_) ------------------ | Branch (1801:7): [True: 28.9k, False: 156k] ------------------ 1802| 28.9k| return 0; 1803| 156k| return *current_++; 1804| 185k|} _ZN4Json17CharReaderBuilderC2Ev: 1878| 17.5k|CharReaderBuilder::CharReaderBuilder() { setDefaults(&settings_); } _ZN4Json17CharReaderBuilderD2Ev: 1879| 17.5k|CharReaderBuilder::~CharReaderBuilder() = default; _ZNK4Json17CharReaderBuilder13newCharReaderEv: 1880| 17.5k|CharReader* CharReaderBuilder::newCharReader() const { 1881| 17.5k| bool collectComments = settings_["collectComments"].asBool(); 1882| 17.5k| OurFeatures features = OurFeatures::all(); 1883| 17.5k| features.allowComments_ = settings_["allowComments"].asBool(); 1884| 17.5k| features.allowTrailingCommas_ = settings_["allowTrailingCommas"].asBool(); 1885| 17.5k| features.strictRoot_ = settings_["strictRoot"].asBool(); 1886| 17.5k| features.allowDroppedNullPlaceholders_ = 1887| 17.5k| settings_["allowDroppedNullPlaceholders"].asBool(); 1888| 17.5k| features.allowNumericKeys_ = settings_["allowNumericKeys"].asBool(); 1889| 17.5k| features.allowSingleQuotes_ = settings_["allowSingleQuotes"].asBool(); 1890| | 1891| | // Stack limit is always a size_t, so we get this as an unsigned int 1892| | // regardless of it we have 64-bit integer support enabled. 1893| 17.5k| features.stackLimit_ = static_cast(settings_["stackLimit"].asUInt()); 1894| 17.5k| features.failIfExtra_ = settings_["failIfExtra"].asBool(); 1895| 17.5k| features.rejectDupKeys_ = settings_["rejectDupKeys"].asBool(); 1896| 17.5k| features.allowSpecialFloats_ = settings_["allowSpecialFloats"].asBool(); 1897| 17.5k| features.skipBom_ = settings_["skipBom"].asBool(); 1898| 17.5k| return new OurCharReader(collectComments, features); 1899| 17.5k|} _ZN4Json17CharReaderBuilder11setDefaultsEPNS_5ValueE: 1948| 17.5k|void CharReaderBuilder::setDefaults(Json::Value* settings) { 1949| | //! [CharReaderBuilderDefaults] 1950| 17.5k| (*settings)["collectComments"] = true; 1951| 17.5k| (*settings)["allowComments"] = true; 1952| 17.5k| (*settings)["allowTrailingCommas"] = true; 1953| 17.5k| (*settings)["strictRoot"] = false; 1954| 17.5k| (*settings)["allowDroppedNullPlaceholders"] = false; 1955| 17.5k| (*settings)["allowNumericKeys"] = false; 1956| 17.5k| (*settings)["allowSingleQuotes"] = false; 1957| 17.5k| (*settings)["stackLimit"] = 1000; 1958| 17.5k| (*settings)["failIfExtra"] = false; 1959| 17.5k| (*settings)["rejectDupKeys"] = false; 1960| 17.5k| (*settings)["allowSpecialFloats"] = false; 1961| 17.5k| (*settings)["skipBom"] = true; 1962| | //! [CharReaderBuilderDefaults] 1963| 17.5k|} _ZN4Json13OurCharReaderC2EbRKNS_11OurFeaturesE: 1867| 17.5k| : collectComments_(collectComments), reader_(features) {} _ZN4Json13OurCharReader5parseEPKcS2_PNS_5ValueEPNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEE: 1869| 17.5k| String* errs) override { 1870| 17.5k| bool ok = reader_.parse(beginDoc, endDoc, *root, collectComments_); 1871| 17.5k| if (errs) { ------------------ | Branch (1871:9): [True: 0, False: 17.5k] ------------------ 1872| 0| *errs = reader_.getFormattedErrorMessages(); 1873| 0| } 1874| 17.5k| return ok; 1875| 17.5k| } json_reader.cpp:_ZZN4Json9OurReader15containsNewLineEPKcS2_ENK3$_0clEc: 999| 28| return std::any_of(begin, end, [](char b) { return b == '\n' || b == '\r'; }); ------------------ | Branch (999:54): [True: 0, False: 28] | Branch (999:67): [True: 0, False: 28] ------------------ json_reader.cpp:_ZN4JsonL15codePointToUTF8Ej: 39| 336|static inline String codePointToUTF8(unsigned int cp) { 40| 336| String result; 41| | 42| | // based on description from http://en.wikipedia.org/wiki/UTF-8 43| | 44| 336| if (cp <= 0x7f) { ------------------ | Branch (44:7): [True: 0, False: 336] ------------------ 45| 0| result.resize(1); 46| 0| result[0] = static_cast(cp); 47| 336| } else if (cp <= 0x7FF) { ------------------ | Branch (47:14): [True: 336, False: 0] ------------------ 48| 336| result.resize(2); 49| 336| result[1] = static_cast(0x80 | (0x3f & cp)); 50| 336| result[0] = static_cast(0xC0 | (0x1f & (cp >> 6))); 51| 336| } else if (cp <= 0xFFFF) { ------------------ | Branch (51:14): [True: 0, False: 0] ------------------ 52| 0| result.resize(3); 53| 0| result[2] = static_cast(0x80 | (0x3f & cp)); 54| 0| result[1] = static_cast(0x80 | (0x3f & (cp >> 6))); 55| 0| result[0] = static_cast(0xE0 | (0xf & (cp >> 12))); 56| 0| } else if (cp <= 0x10FFFF) { ------------------ | Branch (56:14): [True: 0, False: 0] ------------------ 57| 0| result.resize(4); 58| 0| result[3] = static_cast(0x80 | (0x3f & cp)); 59| 0| result[2] = static_cast(0x80 | (0x3f & (cp >> 6))); 60| 0| result[1] = static_cast(0x80 | (0x3f & (cp >> 12))); 61| 0| result[0] = static_cast(0xF0 | (0x7 & (cp >> 18))); 62| 0| } 63| | 64| 336| return result; 65| 336|} _ZN4Json5Value13nullSingletonEv: 70| 229k|Value const& Value::nullSingleton() { 71| 229k| static Value const nullStatic; 72| 229k| return nullStatic; 73| 229k|} _ZN4Json5Value8CZStringC2Ej: 236| 18.5k|Value::CZString::CZString(ArrayIndex index) : cstr_(nullptr), index_(index) {} _ZN4Json5Value8CZStringC2EPKcjNS1_17DuplicationPolicyE: 240| 421k| : cstr_(str) { 241| | // allocate != duplicate 242| 421k| storage_.policy_ = allocate & 0x3; 243| 421k| storage_.length_ = length & 0x3FFFFFFF; 244| 421k|} _ZN4Json5Value8CZStringC2ERKS1_: 246| 458k|Value::CZString::CZString(const CZString& other) { 247| 458k| cstr_ = (other.storage_.policy_ != noDuplication && other.cstr_ != nullptr ------------------ | Branch (247:12): [True: 423k, False: 34.2k] | Branch (247:55): [True: 421k, False: 2.76k] ------------------ 248| 458k| ? duplicateStringValue(other.cstr_, other.storage_.length_) 249| 458k| : other.cstr_); 250| 458k| storage_.policy_ = 251| 458k| static_cast( 252| 458k| other.cstr_ ------------------ | Branch (252:11): [True: 421k, False: 37.0k] ------------------ 253| 458k| ? (static_cast(other.storage_.policy_) == ------------------ | Branch (253:18): [True: 0, False: 421k] ------------------ 254| 421k| noDuplication 255| 421k| ? noDuplication 256| 421k| : duplicate) 257| 458k| : static_cast(other.storage_.policy_)) & 258| 458k| 3U; 259| 458k| storage_.length_ = other.storage_.length_; 260| 458k|} _ZN4Json5Value8CZStringD2Ev: 267| 897k|Value::CZString::~CZString() { 268| 897k| if (cstr_ && storage_.policy_ == duplicate) { ------------------ | Branch (268:7): [True: 842k, False: 55.5k] | Branch (268:16): [True: 421k, False: 421k] ------------------ 269| 421k| releaseStringValue(const_cast(cstr_), 270| 421k| storage_.length_ + 1U); // +1 for null terminating 271| | // character for sake of 272| | // completeness but not actually 273| | // necessary 274| 421k| } 275| 897k|} _ZNK4Json5Value8CZStringltERKS1_: 295| 1.93M|bool Value::CZString::operator<(const CZString& other) const { 296| 1.93M| if (!cstr_) ------------------ | Branch (296:7): [True: 3.43k, False: 1.93M] ------------------ 297| 3.43k| return index_ < other.index_; 298| | // return strcmp(cstr_, other.cstr_) < 0; 299| | // Assume both are strings. 300| 1.93M| unsigned this_len = this->storage_.length_; 301| 1.93M| unsigned other_len = other.storage_.length_; 302| 1.93M| unsigned min_len = std::min(this_len, other_len); 303| 1.93M| JSON_ASSERT(this->cstr_ && other.cstr_); 304| 1.93M| int comp = memcmp(this->cstr_, other.cstr_, min_len); 305| 1.93M| if (comp < 0) ------------------ | Branch (305:7): [True: 1.12M, False: 807k] ------------------ 306| 1.12M| return true; 307| 807k| if (comp > 0) ------------------ | Branch (307:7): [True: 386k, False: 421k] ------------------ 308| 386k| return false; 309| 421k| return (this_len < other_len); 310| 807k|} _ZNK4Json5Value8CZStringeqERKS1_: 312| 175k|bool Value::CZString::operator==(const CZString& other) const { 313| 175k| if (!cstr_) ------------------ | Branch (313:7): [True: 0, False: 175k] ------------------ 314| 0| return index_ == other.index_; 315| | // return strcmp(cstr_, other.cstr_) == 0; 316| | // Assume both are strings. 317| 175k| unsigned this_len = this->storage_.length_; 318| 175k| unsigned other_len = other.storage_.length_; 319| 175k| if (this_len != other_len) ------------------ | Branch (319:7): [True: 157k, False: 17.5k] ------------------ 320| 157k| return false; 321| 17.5k| JSON_ASSERT(this->cstr_ && other.cstr_); 322| 17.5k| int comp = memcmp(this->cstr_, other.cstr_, this_len); 323| 17.5k| return comp == 0; 324| 175k|} _ZN4Json5ValueC2ENS_9ValueTypeE: 347| 85.3k|Value::Value(ValueType type) { 348| 85.3k| static char const emptyString[] = ""; 349| 85.3k| initBasic(type); 350| 85.3k| switch (type) { 351| 50.6k| case nullValue: ------------------ | Branch (351:3): [True: 50.6k, False: 34.7k] ------------------ 352| 50.6k| break; 353| 0| case intValue: ------------------ | Branch (353:3): [True: 0, False: 85.3k] ------------------ 354| 0| case uintValue: ------------------ | Branch (354:3): [True: 0, False: 85.3k] ------------------ 355| 0| value_.int_ = 0; 356| 0| break; 357| 0| case realValue: ------------------ | Branch (357:3): [True: 0, False: 85.3k] ------------------ 358| 0| value_.real_ = 0.0; 359| 0| break; 360| 0| case stringValue: ------------------ | Branch (360:3): [True: 0, False: 85.3k] ------------------ 361| | // allocated_ == false, so this is safe. 362| 0| value_.string_ = const_cast(static_cast(emptyString)); 363| 0| break; 364| 17.1k| case arrayValue: ------------------ | Branch (364:3): [True: 17.1k, False: 68.2k] ------------------ 365| 34.7k| case objectValue: ------------------ | Branch (365:3): [True: 17.5k, False: 67.8k] ------------------ 366| 34.7k| value_.map_ = new ObjectValues(); 367| 34.7k| break; 368| 0| case booleanValue: ------------------ | Branch (368:3): [True: 0, False: 85.3k] ------------------ 369| 0| value_.bool_ = false; 370| 0| break; 371| 0| default: ------------------ | Branch (371:3): [True: 0, False: 85.3k] ------------------ 372| 0| JSON_ASSERT_UNREACHABLE; ------------------ | | 48| 0|#define JSON_ASSERT_UNREACHABLE assert(false) ------------------ 373| 85.3k| } 374| 85.3k|} _ZN4Json5ValueC2Ei: 376| 17.5k|Value::Value(Int value) { 377| 17.5k| initBasic(intValue); 378| 17.5k| value_.int_ = value; 379| 17.5k|} _ZN4Json5ValueC2El: 386| 3.85k|Value::Value(Int64 value) { 387| 3.85k| initBasic(intValue); 388| 3.85k| value_.int_ = value; 389| 3.85k|} _ZN4Json5ValueC2Ed: 396| 440|Value::Value(double value) { 397| 440| initBasic(realValue); 398| 440| value_.real_ = value; 399| 440|} _ZN4Json5ValueC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE: 415| 469|Value::Value(const String& value) { 416| 469| initBasic(stringValue, true); 417| 469| value_.string_ = duplicateAndPrefixStringValue( 418| 469| value.data(), static_cast(value.length())); 419| 469|} _ZN4Json5ValueC2Eb: 426| 193k|Value::Value(bool value) { 427| 193k| initBasic(booleanValue); 428| 193k| value_.bool_ = value; 429| 193k|} _ZN4Json5ValueC2ERKS0_: 431| 458k|Value::Value(const Value& other) { 432| 458k| dupPayload(other); 433| 458k| dupMeta(other); 434| 458k|} _ZN4Json5ValueC2EOS0_: 436| 1.17k|Value::Value(Value&& other) { 437| 1.17k| initBasic(nullValue); 438| 1.17k| swap(other); 439| 1.17k|} _ZN4Json5ValueD2Ev: 441| 760k|Value::~Value() { 442| 760k| releasePayload(); 443| 760k| value_.uint_ = 0; 444| 760k|} _ZN4Json5ValueaSEOS0_: 451| 232k|Value& Value::operator=(Value&& other) { 452| 232k| other.swap(*this); 453| 232k| return *this; 454| 232k|} _ZN4Json5Value11swapPayloadERS0_: 456| 255k|void Value::swapPayload(Value& other) { 457| 255k| std::swap(bits_, other.bits_); 458| 255k| std::swap(value_, other.value_); 459| 255k|} _ZN4Json5Value4swapERS0_: 466| 233k|void Value::swap(Value& other) { 467| 233k| swapPayload(other); 468| 233k| std::swap(comments_, other.comments_); 469| 233k| std::swap(start_, other.start_); 470| 233k| std::swap(limit_, other.limit_); 471| 233k|} _ZNK4Json5Value4typeEv: 478| 3.22M|ValueType Value::type() const { 479| 3.22M| return static_cast(bits_.value_type_); 480| 3.22M|} _ZNK4Json5Value8asStringEv: 628| 469|String Value::asString() const { 629| 469| switch (type()) { 630| 0| case nullValue: ------------------ | Branch (630:3): [True: 0, False: 469] ------------------ 631| 0| return ""; 632| 469| case stringValue: { ------------------ | Branch (632:3): [True: 469, False: 0] ------------------ 633| 469| if (value_.string_ == nullptr) ------------------ | Branch (633:9): [True: 0, False: 469] ------------------ 634| 0| return ""; 635| 469| unsigned this_len; 636| 469| char const* this_str; 637| 469| decodePrefixedString(this->isAllocated(), this->value_.string_, &this_len, 638| 469| &this_str); 639| 469| return String(this_str, this_len); 640| 469| } 641| 0| case booleanValue: ------------------ | Branch (641:3): [True: 0, False: 469] ------------------ 642| 0| return value_.bool_ ? "true" : "false"; ------------------ | Branch (642:12): [True: 0, False: 0] ------------------ 643| 0| case intValue: ------------------ | Branch (643:3): [True: 0, False: 469] ------------------ 644| 0| return valueToString(value_.int_); 645| 0| case uintValue: ------------------ | Branch (645:3): [True: 0, False: 469] ------------------ 646| 0| return valueToString(value_.uint_); 647| 0| case realValue: ------------------ | Branch (647:3): [True: 0, False: 469] ------------------ 648| 0| return valueToString(value_.real_); 649| 0| default: ------------------ | Branch (649:3): [True: 0, False: 469] ------------------ 650| 0| JSON_FAIL_MESSAGE("Type is not convertible to string"); 651| 469| } 652| 469|} _ZNK4Json5Value6asUIntEv: 676| 17.5k|Value::UInt Value::asUInt() const { 677| 17.5k| switch (type()) { 678| 17.5k| case intValue: ------------------ | Branch (678:3): [True: 17.5k, False: 0] ------------------ 679| 17.5k| JSON_ASSERT_MESSAGE(isUInt(), "LargestInt out of UInt range"); 680| 17.5k| return UInt(value_.int_); 681| 0| case uintValue: ------------------ | Branch (681:3): [True: 0, False: 17.5k] ------------------ 682| 0| JSON_ASSERT_MESSAGE(isUInt(), "LargestUInt out of UInt range"); 683| 0| return UInt(value_.uint_); 684| 0| case realValue: ------------------ | Branch (684:3): [True: 0, False: 17.5k] ------------------ 685| 0| JSON_ASSERT_MESSAGE(InRange(value_.real_, 0, maxUInt), 686| 0| "double out of UInt range"); 687| 0| return UInt(value_.real_); 688| 0| case nullValue: ------------------ | Branch (688:3): [True: 0, False: 17.5k] ------------------ 689| 0| return 0; 690| 0| case booleanValue: ------------------ | Branch (690:3): [True: 0, False: 17.5k] ------------------ 691| 0| return value_.bool_ ? 1 : 0; ------------------ | Branch (691:12): [True: 0, False: 0] ------------------ 692| 0| default: ------------------ | Branch (692:3): [True: 0, False: 17.5k] ------------------ 693| 0| break; 694| 17.5k| } 695| 17.5k| JSON_FAIL_MESSAGE("Value is not convertible to UInt."); 696| 0|} _ZNK4Json5Value7asInt64Ev: 700| 1.65k|Value::Int64 Value::asInt64() const { 701| 1.65k| switch (type()) { 702| 1.65k| case intValue: ------------------ | Branch (702:3): [True: 1.65k, False: 0] ------------------ 703| 1.65k| return Int64(value_.int_); 704| 0| case uintValue: ------------------ | Branch (704:3): [True: 0, False: 1.65k] ------------------ 705| 0| JSON_ASSERT_MESSAGE(isInt64(), "LargestUInt out of Int64 range"); 706| 0| return Int64(value_.uint_); 707| 0| case realValue: ------------------ | Branch (707:3): [True: 0, False: 1.65k] ------------------ 708| 0| JSON_ASSERT_MESSAGE(InRange(value_.real_, minInt64, maxInt64), 709| 0| "double out of Int64 range"); 710| 0| return Int64(value_.real_); 711| 0| case nullValue: ------------------ | Branch (711:3): [True: 0, False: 1.65k] ------------------ 712| 0| return 0; 713| 0| case booleanValue: ------------------ | Branch (713:3): [True: 0, False: 1.65k] ------------------ 714| 0| return value_.bool_ ? 1 : 0; ------------------ | Branch (714:12): [True: 0, False: 0] ------------------ 715| 0| default: ------------------ | Branch (715:3): [True: 0, False: 1.65k] ------------------ 716| 0| break; 717| 1.65k| } 718| 1.65k| JSON_FAIL_MESSAGE("Value is not convertible to Int64."); 719| 0|} _ZNK4Json5Value8asDoubleEv: 759| 440|double Value::asDouble() const { 760| 440| switch (type()) { 761| 0| case intValue: ------------------ | Branch (761:3): [True: 0, False: 440] ------------------ 762| 0| return static_cast(value_.int_); 763| 0| case uintValue: ------------------ | Branch (763:3): [True: 0, False: 440] ------------------ 764| |#if !defined(JSON_USE_INT64_DOUBLE_CONVERSION) 765| | return static_cast(value_.uint_); 766| |#else // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION) 767| 0| return integerToDouble(value_.uint_); 768| 0|#endif // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION) 769| 440| case realValue: ------------------ | Branch (769:3): [True: 440, False: 0] ------------------ 770| 440| return value_.real_; 771| 0| case nullValue: ------------------ | Branch (771:3): [True: 0, False: 440] ------------------ 772| 0| return 0.0; 773| 0| case booleanValue: ------------------ | Branch (773:3): [True: 0, False: 440] ------------------ 774| 0| return value_.bool_ ? 1.0 : 0.0; ------------------ | Branch (774:12): [True: 0, False: 0] ------------------ 775| 0| default: ------------------ | Branch (775:3): [True: 0, False: 440] ------------------ 776| 0| break; 777| 440| } 778| 440| JSON_FAIL_MESSAGE("Value is not convertible to double."); 779| 0|} _ZNK4Json5Value6asBoolEv: 804| 193k|bool Value::asBool() const { 805| 193k| switch (type()) { 806| 193k| case booleanValue: ------------------ | Branch (806:3): [True: 193k, False: 0] ------------------ 807| 193k| return value_.bool_; 808| 0| case nullValue: ------------------ | Branch (808:3): [True: 0, False: 193k] ------------------ 809| 0| return false; 810| 0| case intValue: ------------------ | Branch (810:3): [True: 0, False: 193k] ------------------ 811| 0| return value_.int_ != 0; 812| 0| case uintValue: ------------------ | Branch (812:3): [True: 0, False: 193k] ------------------ 813| 0| return value_.uint_ != 0; 814| 0| case realValue: { ------------------ | Branch (814:3): [True: 0, False: 193k] ------------------ 815| | // According to JavaScript language zero or NaN is regarded as false 816| 0| const auto value_classification = std::fpclassify(value_.real_); 817| 0| return value_classification != FP_ZERO && value_classification != FP_NAN; ------------------ | Branch (817:12): [True: 0, False: 0] | Branch (817:47): [True: 0, False: 0] ------------------ 818| 0| } 819| 0| default: ------------------ | Branch (819:3): [True: 0, False: 193k] ------------------ 820| 0| break; 821| 193k| } 822| 193k| JSON_FAIL_MESSAGE("Value is not convertible to bool."); 823| 0|} _ZN4Json5ValueixEj: 924| 18.5k|Value& Value::operator[](ArrayIndex index) { 925| 18.5k| JSON_ASSERT_MESSAGE( 926| 18.5k| type() == nullValue || type() == arrayValue, 927| 18.5k| "in Json::Value::operator[](ArrayIndex): requires arrayValue"); 928| 18.5k| if (type() == nullValue) ------------------ | Branch (928:7): [True: 0, False: 18.5k] ------------------ 929| 0| *this = Value(arrayValue); 930| 18.5k| CZString key(index); 931| 18.5k| auto it = value_.map_->lower_bound(key); 932| 18.5k| if (it != value_.map_->end() && (*it).first == key) ------------------ | Branch (932:7): [True: 0, False: 18.5k] | Branch (932:7): [True: 0, False: 18.5k] | Branch (932:35): [True: 0, False: 0] ------------------ 933| 0| return (*it).second; 934| | 935| 18.5k| ObjectValues::value_type defaultValue(key, nullSingleton()); 936| 18.5k| it = value_.map_->insert(it, defaultValue); 937| 18.5k| return (*it).second; 938| 18.5k|} _ZN4Json5ValueixEi: 940| 18.5k|Value& Value::operator[](int index) { 941| 18.5k| JSON_ASSERT_MESSAGE( 942| 18.5k| index >= 0, 943| 18.5k| "in Json::Value::operator[](int index): index cannot be negative"); 944| 18.5k| return (*this)[ArrayIndex(index)]; 945| 18.5k|} _ZN4Json5Value9initBasicENS_9ValueTypeEb: 967| 301k|void Value::initBasic(ValueType type, bool allocated) { 968| 301k| setType(type); 969| 301k| setIsAllocated(allocated); 970| 301k| comments_ = Comments{}; 971| 301k| start_ = 0; 972| 301k| limit_ = 0; 973| 301k|} _ZN4Json5Value10dupPayloadERKS0_: 975| 458k|void Value::dupPayload(const Value& other) { 976| 458k| setType(other.type()); 977| 458k| setIsAllocated(false); 978| 458k| switch (type()) { 979| 458k| case nullValue: ------------------ | Branch (979:3): [True: 458k, False: 0] ------------------ 980| 458k| case intValue: ------------------ | Branch (980:3): [True: 0, False: 458k] ------------------ 981| 458k| case uintValue: ------------------ | Branch (981:3): [True: 0, False: 458k] ------------------ 982| 458k| case realValue: ------------------ | Branch (982:3): [True: 0, False: 458k] ------------------ 983| 458k| case booleanValue: ------------------ | Branch (983:3): [True: 0, False: 458k] ------------------ 984| 458k| value_ = other.value_; 985| 458k| break; 986| 0| case stringValue: ------------------ | Branch (986:3): [True: 0, False: 458k] ------------------ 987| 0| if (other.value_.string_ && other.isAllocated()) { ------------------ | Branch (987:9): [True: 0, False: 0] | Branch (987:33): [True: 0, False: 0] ------------------ 988| 0| unsigned len; 989| 0| char const* str; 990| 0| decodePrefixedString(other.isAllocated(), other.value_.string_, &len, 991| 0| &str); 992| 0| value_.string_ = duplicateAndPrefixStringValue(str, len); 993| 0| setIsAllocated(true); 994| 0| } else { 995| 0| value_.string_ = other.value_.string_; 996| 0| } 997| 0| break; 998| 0| case arrayValue: ------------------ | Branch (998:3): [True: 0, False: 458k] ------------------ 999| 0| case objectValue: ------------------ | Branch (999:3): [True: 0, False: 458k] ------------------ 1000| 0| value_.map_ = new ObjectValues(*other.value_.map_); 1001| 0| break; 1002| 0| default: ------------------ | Branch (1002:3): [True: 0, False: 458k] ------------------ 1003| 0| JSON_ASSERT_UNREACHABLE; ------------------ | | 48| 0|#define JSON_ASSERT_UNREACHABLE assert(false) ------------------ 1004| 458k| } 1005| 458k|} _ZN4Json5Value14releasePayloadEv: 1007| 760k|void Value::releasePayload() { 1008| 760k| switch (type()) { 1009| 510k| case nullValue: ------------------ | Branch (1009:3): [True: 510k, False: 250k] ------------------ 1010| 531k| case intValue: ------------------ | Branch (1010:3): [True: 21.4k, False: 738k] ------------------ 1011| 531k| case uintValue: ------------------ | Branch (1011:3): [True: 0, False: 760k] ------------------ 1012| 531k| case realValue: ------------------ | Branch (1012:3): [True: 440, False: 759k] ------------------ 1013| 724k| case booleanValue: ------------------ | Branch (1013:3): [True: 193k, False: 567k] ------------------ 1014| 724k| break; 1015| 469| case stringValue: ------------------ | Branch (1015:3): [True: 469, False: 759k] ------------------ 1016| 469| if (isAllocated()) ------------------ | Branch (1016:9): [True: 469, False: 0] ------------------ 1017| 469| releasePrefixedStringValue(value_.string_); 1018| 469| break; 1019| 17.1k| case arrayValue: ------------------ | Branch (1019:3): [True: 17.1k, False: 742k] ------------------ 1020| 34.7k| case objectValue: ------------------ | Branch (1020:3): [True: 17.5k, False: 742k] ------------------ 1021| 34.7k| delete value_.map_; 1022| 34.7k| break; 1023| 0| default: ------------------ | Branch (1023:3): [True: 0, False: 760k] ------------------ 1024| 0| JSON_ASSERT_UNREACHABLE; ------------------ | | 48| 0|#define JSON_ASSERT_UNREACHABLE assert(false) ------------------ 1025| 760k| } 1026| 760k|} _ZN4Json5Value7dupMetaERKS0_: 1028| 458k|void Value::dupMeta(const Value& other) { 1029| 458k| comments_ = other.comments_; 1030| 458k| start_ = other.start_; 1031| 458k| limit_ = other.limit_; 1032| 458k|} _ZN4Json5Value16resolveReferenceEPKcS2_: 1056| 210k|Value& Value::resolveReference(char const* key, char const* end) { 1057| 210k| JSON_ASSERT_MESSAGE( 1058| 210k| type() == nullValue || type() == objectValue, 1059| 210k| "in Json::Value::resolveReference(key, end): requires objectValue"); 1060| 210k| if (type() == nullValue) ------------------ | Branch (1060:7): [True: 17.5k, False: 193k] ------------------ 1061| 17.5k| *this = Value(objectValue); 1062| 210k| CZString actualKey(key, static_cast(end - key), 1063| 210k| CZString::duplicateOnCopy); 1064| 210k| auto it = value_.map_->lower_bound(actualKey); 1065| 210k| if (it != value_.map_->end() && (*it).first == actualKey) ------------------ | Branch (1065:7): [True: 175k, False: 35.0k] | Branch (1065:7): [True: 0, False: 210k] | Branch (1065:35): [True: 0, False: 175k] ------------------ 1066| 0| return (*it).second; 1067| | 1068| 210k| ObjectValues::value_type defaultValue(actualKey, nullSingleton()); 1069| 210k| it = value_.map_->insert(it, defaultValue); 1070| 210k| Value& value = (*it).second; 1071| 210k| return value; 1072| 210k|} _ZNK4Json5Value4findEPKcS2_: 1081| 210k|Value const* Value::find(char const* begin, char const* end) const { 1082| 210k| JSON_ASSERT_MESSAGE(type() == nullValue || type() == objectValue, 1083| 210k| "in Json::Value::find(begin, end): requires " 1084| 210k| "objectValue or nullValue"); 1085| 210k| if (type() == nullValue) ------------------ | Branch (1085:7): [True: 0, False: 210k] ------------------ 1086| 0| return nullptr; 1087| 210k| CZString actualKey(begin, static_cast(end - begin), 1088| 210k| CZString::noDuplication); 1089| 210k| ObjectValues::const_iterator it = value_.map_->find(actualKey); 1090| 210k| if (it == value_.map_->end()) ------------------ | Branch (1090:7): [True: 0, False: 210k] ------------------ 1091| 0| return nullptr; 1092| 210k| return &(*it).second; 1093| 210k|} _ZNK4Json5ValueixEPKc: 1100| 210k|const Value& Value::operator[](const char* key) const { 1101| 210k| Value const* found = find(key, key + strlen(key)); 1102| 210k| if (!found) ------------------ | Branch (1102:7): [True: 0, False: 210k] ------------------ 1103| 0| return nullSingleton(); 1104| 210k| return *found; 1105| 210k|} _ZN4Json5ValueixEPKc: 1113| 210k|Value& Value::operator[](const char* key) { 1114| 210k| return resolveReference(key, key + strlen(key)); 1115| 210k|} _ZNK4Json5Value6isUIntEv: 1276| 17.5k|bool Value::isUInt() const { 1277| 17.5k| switch (type()) { 1278| 17.5k| case intValue: ------------------ | Branch (1278:3): [True: 17.5k, False: 0] ------------------ 1279| 17.5k|#if defined(JSON_HAS_INT64) 1280| 17.5k| return value_.int_ >= 0 && LargestUInt(value_.int_) <= LargestUInt(maxUInt); ------------------ | Branch (1280:12): [True: 17.5k, False: 0] | Branch (1280:32): [True: 17.5k, False: 0] ------------------ 1281| |#else 1282| | return value_.int_ >= 0; 1283| |#endif 1284| 0| case uintValue: ------------------ | Branch (1284:3): [True: 0, False: 17.5k] ------------------ 1285| 0|#if defined(JSON_HAS_INT64) 1286| 0| return value_.uint_ <= maxUInt; 1287| |#else 1288| | return true; 1289| |#endif 1290| 0| case realValue: ------------------ | Branch (1290:3): [True: 0, False: 17.5k] ------------------ 1291| 0| return value_.real_ >= 0 && value_.real_ <= maxUInt && ------------------ | Branch (1291:12): [True: 0, False: 0] | Branch (1291:33): [True: 0, False: 0] ------------------ 1292| 0| IsIntegral(value_.real_); ------------------ | Branch (1292:12): [True: 0, False: 0] ------------------ 1293| 0| default: ------------------ | Branch (1293:3): [True: 0, False: 17.5k] ------------------ 1294| 0| break; 1295| 17.5k| } 1296| 0| return false; 1297| 17.5k|} _ZNK4Json5Value7isArrayEv: 1369| 3.97k|bool Value::isArray() const { return type() == arrayValue; } _ZNK4Json5Value8isObjectEv: 1371| 3.97k|bool Value::isObject() const { return type() == objectValue; } _ZN4Json5Value8CommentsC2EOS1_: 1376| 233k|Value::Comments::Comments(Comments&& that) : ptr_{std::move(that.ptr_)} {} _ZN4Json5Value8CommentsaSERKS1_: 1378| 458k|Value::Comments& Value::Comments::operator=(const Comments& that) { 1379| 458k| ptr_ = cloneUnique(that.ptr_); 1380| 458k| return *this; 1381| 458k|} _ZN4Json5Value8CommentsaSEOS1_: 1383| 769k|Value::Comments& Value::Comments::operator=(Comments&& that) { 1384| 769k| ptr_ = std::move(that.ptr_); 1385| 769k| return *this; 1386| 769k|} _ZN4Json5Value8Comments3setENS_16CommentPlacementENSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE: 1398| 16|void Value::Comments::set(CommentPlacement slot, String comment) { 1399| 16| if (!ptr_) { ------------------ | Branch (1399:7): [True: 16, False: 0] ------------------ 1400| 16| ptr_ = std::unique_ptr(new Array()); 1401| 16| } 1402| | // check comments array boundry. 1403| 16| if (slot < CommentPlacement::numberOfCommentPlacement) { ------------------ | Branch (1403:7): [True: 16, False: 0] ------------------ 1404| 16| (*ptr_)[slot] = std::move(comment); 1405| 16| } 1406| 16|} _ZN4Json5Value10setCommentENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_16CommentPlacementE: 1408| 16|void Value::setComment(String comment, CommentPlacement placement) { 1409| 16| if (!comment.empty() && (comment.back() == '\n')) { ------------------ | Branch (1409:7): [True: 16, False: 0] | Branch (1409:27): [True: 7, False: 9] ------------------ 1410| | // Always discard trailing newline, to aid indentation. 1411| 7| comment.pop_back(); 1412| 7| } 1413| 16| JSON_ASSERT(!comment.empty()); 1414| 16| JSON_ASSERT_MESSAGE( 1415| 16| comment[0] == '\0' || comment[0] == '/', 1416| 16| "in Json::Value::setComment(): Comments must start with /"); 1417| 16| comments_.set(placement, std::move(comment)); 1418| 16|} _ZN4Json5Value14setOffsetStartEl: 1428| 24.7k|void Value::setOffsetStart(ptrdiff_t start) { start_ = start; } _ZN4Json5Value14setOffsetLimitEl: 1430| 24.7k|void Value::setOffsetLimit(ptrdiff_t limit) { limit_ = limit; } _ZNK4Json5Value5beginEv: 1446| 1.41k|Value::const_iterator Value::begin() const { 1447| 1.41k| switch (type()) { 1448| 1.41k| case arrayValue: ------------------ | Branch (1448:3): [True: 1.41k, False: 0] ------------------ 1449| 1.41k| case objectValue: ------------------ | Branch (1449:3): [True: 0, False: 1.41k] ------------------ 1450| 1.41k| if (value_.map_) ------------------ | Branch (1450:9): [True: 1.41k, False: 0] ------------------ 1451| 1.41k| return const_iterator(value_.map_->begin()); 1452| 0| break; 1453| 0| default: ------------------ | Branch (1453:3): [True: 0, False: 1.41k] ------------------ 1454| 0| break; 1455| 1.41k| } 1456| 0| return {}; 1457| 1.41k|} _ZNK4Json5Value3endEv: 1459| 4.20k|Value::const_iterator Value::end() const { 1460| 4.20k| switch (type()) { 1461| 4.20k| case arrayValue: ------------------ | Branch (1461:3): [True: 4.20k, False: 0] ------------------ 1462| 4.20k| case objectValue: ------------------ | Branch (1462:3): [True: 0, False: 4.20k] ------------------ 1463| 4.20k| if (value_.map_) ------------------ | Branch (1463:9): [True: 4.20k, False: 0] ------------------ 1464| 4.20k| return const_iterator(value_.map_->end()); 1465| 0| break; 1466| 0| default: ------------------ | Branch (1466:3): [True: 0, False: 4.20k] ------------------ 1467| 0| break; 1468| 4.20k| } 1469| 0| return {}; 1470| 4.20k|} json_value.cpp:_ZN4JsonL20duplicateStringValueEPKcm: 115| 421k|static inline char* duplicateStringValue(const char* value, size_t length) { 116| | // Avoid an integer overflow in the call to malloc below by limiting length 117| | // to a sane value. 118| 421k| if (length >= static_cast(Value::maxInt)) ------------------ | Branch (118:7): [True: 0, False: 421k] ------------------ 119| 0| length = Value::maxInt - 1; 120| | 121| 421k| auto newString = static_cast(malloc(length + 1)); 122| 421k| if (newString == nullptr) { ------------------ | Branch (122:7): [True: 0, False: 421k] ------------------ 123| 0| throwRuntimeError("in Json::Value::duplicateStringValue(): " 124| 0| "Failed to allocate string value buffer"); 125| 0| } 126| 421k| memcpy(newString, value, length); 127| 421k| newString[length] = 0; 128| 421k| return newString; 129| 421k|} json_value.cpp:_ZN4JsonL18releaseStringValueEPcj: 183| 421k|static inline void releaseStringValue(char* value, unsigned) { free(value); } json_value.cpp:_ZN4JsonL29duplicateAndPrefixStringValueEPKcj: 134| 469| unsigned int length) { 135| | // Avoid an integer overflow in the call to malloc below by limiting length 136| | // to a sane value. 137| 469| JSON_ASSERT_MESSAGE(length <= static_cast(Value::maxInt) - 138| 469| sizeof(unsigned) - 1U, 139| 469| "in Json::Value::duplicateAndPrefixStringValue(): " 140| 469| "length too big for prefixing"); 141| 469| size_t actualLength = sizeof(length) + length + 1; 142| 469| auto newString = static_cast(malloc(actualLength)); 143| 469| if (newString == nullptr) { ------------------ | Branch (143:7): [True: 0, False: 469] ------------------ 144| 0| throwRuntimeError("in Json::Value::duplicateAndPrefixStringValue(): " 145| 0| "Failed to allocate string value buffer"); 146| 0| } 147| 469| *reinterpret_cast(newString) = length; 148| 469| memcpy(newString + sizeof(unsigned), value, length); 149| 469| newString[actualLength - 1U] = 150| 469| 0; // to avoid buffer over-run accidents by users later 151| 469| return newString; 152| 469|} json_value.cpp:_ZN4JsonL20decodePrefixedStringEbPKcPjPS1_: 154| 469| unsigned* length, char const** value) { 155| 469| if (!isPrefixed) { ------------------ | Branch (155:7): [True: 0, False: 469] ------------------ 156| 0| *length = static_cast(strlen(prefixed)); 157| 0| *value = prefixed; 158| 469| } else { 159| 469| *length = *reinterpret_cast(prefixed); 160| 469| *value = prefixed + sizeof(unsigned); 161| 469| } 162| 469|} json_value.cpp:_ZN4JsonL26releasePrefixedStringValueEPc: 182| 469|static inline void releasePrefixedStringValue(char* value) { free(value); } json_value.cpp:_ZN4JsonL11cloneUniqueINSt3__15arrayINS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEELm3EEEEENS1_10unique_ptrIT_NS1_14default_deleteISB_EEEERKSE_: 52| 458k|static std::unique_ptr cloneUnique(const std::unique_ptr& p) { 53| 458k| std::unique_ptr r; 54| 458k| if (p) { ------------------ | Branch (54:7): [True: 0, False: 458k] ------------------ 55| 0| r = std::unique_ptr(new T(*p)); 56| 0| } 57| 458k| return r; 58| 458k|} _ZN4Json17ValueIteratorBaseC2ERKNSt3__114__map_iteratorINS1_15__tree_iteratorINS1_12__value_typeINS_5Value8CZStringES5_EEPNS1_11__tree_nodeIS7_PvEElEEEE: 22| 5.61k| : current_(current), isNull_(false) {} _ZNK4Json17ValueIteratorBase5derefEv: 25| 2.79k|const Value& ValueIteratorBase::deref() const { return current_->second; } _ZN4Json17ValueIteratorBase9incrementEv: 27| 2.79k|void ValueIteratorBase::increment() { ++current_; } _ZNK4Json17ValueIteratorBase7isEqualERKS0_: 55| 4.20k|bool ValueIteratorBase::isEqual(const SelfType& other) const { 56| 4.20k| if (isNull_) { ------------------ | Branch (56:7): [True: 0, False: 4.20k] ------------------ 57| 0| return other.isNull_; 58| 0| } 59| 4.20k| return current_ == other.current_; 60| 4.20k|} _ZN4Json18ValueConstIteratorC2ERKNSt3__114__map_iteratorINS1_15__tree_iteratorINS1_12__value_typeINS_5Value8CZStringES5_EEPNS1_11__tree_nodeIS7_PvEElEEEE: 120| 5.61k| : ValueIteratorBase(current) {} adler32_z: 72| 318|{ 73| 318| unsigned long sum2; 74| 318| unsigned n; 75| | 76| |#if defined(ADLER32_SIMD_SSSE3) 77| | if (buf != Z_NULL && len >= 64 && x86_cpu_enable_ssse3) 78| | return adler32_simd_(adler, buf, len); 79| |#elif defined(ADLER32_SIMD_NEON) 80| | if (buf != Z_NULL && len >= 64) 81| | return adler32_simd_(adler, buf, len); 82| |#endif 83| | 84| | /* split Adler-32 into component sums */ 85| 318| sum2 = (adler >> 16) & 0xffff; 86| 318| adler &= 0xffff; 87| | 88| | /* in case user likes doing a byte at a time, keep it fast */ 89| 318| if (len == 1) { ------------------ | Branch (89:9): [True: 159, False: 159] ------------------ 90| 159| adler += buf[0]; 91| 159| if (adler >= BASE) ------------------ | | 12| 159|#define BASE 65521U /* largest prime smaller than 65536 */ ------------------ | Branch (91:13): [True: 0, False: 159] ------------------ 92| 0| adler -= BASE; ------------------ | | 12| 0|#define BASE 65521U /* largest prime smaller than 65536 */ ------------------ 93| 159| sum2 += adler; 94| 159| if (sum2 >= BASE) ------------------ | | 12| 159|#define BASE 65521U /* largest prime smaller than 65536 */ ------------------ | Branch (94:13): [True: 0, False: 159] ------------------ 95| 0| sum2 -= BASE; ------------------ | | 12| 0|#define BASE 65521U /* largest prime smaller than 65536 */ ------------------ 96| 159| return adler | (sum2 << 16); 97| 159| } 98| | 99| |#if defined(ADLER32_SIMD_SSSE3) 100| | /* 101| | * Use SSSE3 to compute the adler32. Since this routine can be 102| | * freely used, check CPU features here. zlib convention is to 103| | * call adler32(0, NULL, 0), before making calls to adler32(). 104| | * So this is a good early (and infrequent) place to cache CPU 105| | * features for those later, more interesting adler32() calls. 106| | */ 107| | if (buf == Z_NULL) { 108| | if (!len) /* Assume user is calling adler32(0, NULL, 0); */ 109| | cpu_check_features(); 110| | return 1L; 111| | } 112| |#else 113| | /* initial Adler-32 value (deferred check for len == 1 speed) */ 114| 159| if (buf == Z_NULL) ------------------ | | 212| 159|#define Z_NULL 0 /* for initializing zalloc, zfree, opaque */ ------------------ | Branch (114:9): [True: 159, False: 0] ------------------ 115| 159| return 1L; 116| 0|#endif 117| | 118| | /* in case short lengths are provided, keep it somewhat fast */ 119| 0| if (len < 16) { ------------------ | Branch (119:9): [True: 0, False: 0] ------------------ 120| 0| while (len--) { ------------------ | Branch (120:16): [True: 0, False: 0] ------------------ 121| 0| adler += *buf++; 122| 0| sum2 += adler; 123| 0| } 124| 0| if (adler >= BASE) ------------------ | | 12| 0|#define BASE 65521U /* largest prime smaller than 65536 */ ------------------ | Branch (124:13): [True: 0, False: 0] ------------------ 125| 0| adler -= BASE; ------------------ | | 12| 0|#define BASE 65521U /* largest prime smaller than 65536 */ ------------------ 126| 0| MOD28(sum2); /* only added so many BASE's */ ------------------ | | 58| 0|# define MOD28(a) a %= BASE | | ------------------ | | | | 12| 0|#define BASE 65521U /* largest prime smaller than 65536 */ | | ------------------ ------------------ 127| 0| return adler | (sum2 << 16); 128| 0| } 129| | 130| | /* do length NMAX blocks -- requires just one modulo operation */ 131| 0| while (len >= NMAX) { ------------------ | | 13| 0|#define NMAX 5552 ------------------ | Branch (131:12): [True: 0, False: 0] ------------------ 132| 0| len -= NMAX; ------------------ | | 13| 0|#define NMAX 5552 ------------------ 133| 0| n = NMAX / 16; /* NMAX is divisible by 16 */ ------------------ | | 13| 0|#define NMAX 5552 ------------------ 134| 0| do { 135| 0| DO16(buf); /* 16 sums unrolled */ ------------------ | | 20| 0|#define DO16(buf) DO8(buf,0); DO8(buf,8); | | ------------------ | | | | 19| 0|#define DO8(buf,i) DO4(buf,i); DO4(buf,i+4); | | | | ------------------ | | | | | | 18| 0|#define DO4(buf,i) DO2(buf,i); DO2(buf,i+2); | | | | | | ------------------ | | | | | | | | 17| 0|#define DO2(buf,i) DO1(buf,i); DO1(buf,i+1); | | | | | | | | ------------------ | | | | | | | | | | 16| 0|#define DO1(buf,i) {adler += (buf)[i]; sum2 += adler;} | | | | | | | | ------------------ | | | | | | | | #define DO2(buf,i) DO1(buf,i); DO1(buf,i+1); | | | | | | | | ------------------ | | | | | | | | | | 16| 0|#define DO1(buf,i) {adler += (buf)[i]; sum2 += adler;} | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define DO4(buf,i) DO2(buf,i); DO2(buf,i+2); | | | | | | ------------------ | | | | | | | | 17| 0|#define DO2(buf,i) DO1(buf,i); DO1(buf,i+1); | | | | | | | | ------------------ | | | | | | | | | | 16| 0|#define DO1(buf,i) {adler += (buf)[i]; sum2 += adler;} | | | | | | | | ------------------ | | | | | | | | #define DO2(buf,i) DO1(buf,i); DO1(buf,i+1); | | | | | | | | ------------------ | | | | | | | | | | 16| 0|#define DO1(buf,i) {adler += (buf)[i]; sum2 += adler;} | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | #define DO8(buf,i) DO4(buf,i); DO4(buf,i+4); | | | | ------------------ | | | | | | 18| 0|#define DO4(buf,i) DO2(buf,i); DO2(buf,i+2); | | | | | | ------------------ | | | | | | | | 17| 0|#define DO2(buf,i) DO1(buf,i); DO1(buf,i+1); | | | | | | | | ------------------ | | | | | | | | | | 16| 0|#define DO1(buf,i) {adler += (buf)[i]; sum2 += adler;} | | | | | | | | ------------------ | | | | | | | | #define DO2(buf,i) DO1(buf,i); DO1(buf,i+1); | | | | | | | | ------------------ | | | | | | | | | | 16| 0|#define DO1(buf,i) {adler += (buf)[i]; sum2 += adler;} | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define DO4(buf,i) DO2(buf,i); DO2(buf,i+2); | | | | | | ------------------ | | | | | | | | 17| 0|#define DO2(buf,i) DO1(buf,i); DO1(buf,i+1); | | | | | | | | ------------------ | | | | | | | | | | 16| 0|#define DO1(buf,i) {adler += (buf)[i]; sum2 += adler;} | | | | | | | | ------------------ | | | | | | | | #define DO2(buf,i) DO1(buf,i); DO1(buf,i+1); | | | | | | | | ------------------ | | | | | | | | | | 16| 0|#define DO1(buf,i) {adler += (buf)[i]; sum2 += adler;} | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define DO16(buf) DO8(buf,0); DO8(buf,8); | | ------------------ | | | | 19| 0|#define DO8(buf,i) DO4(buf,i); DO4(buf,i+4); | | | | ------------------ | | | | | | 18| 0|#define DO4(buf,i) DO2(buf,i); DO2(buf,i+2); | | | | | | ------------------ | | | | | | | | 17| 0|#define DO2(buf,i) DO1(buf,i); DO1(buf,i+1); | | | | | | | | ------------------ | | | | | | | | | | 16| 0|#define DO1(buf,i) {adler += (buf)[i]; sum2 += adler;} | | | | | | | | ------------------ | | | | | | | | #define DO2(buf,i) DO1(buf,i); DO1(buf,i+1); | | | | | | | | ------------------ | | | | | | | | | | 16| 0|#define DO1(buf,i) {adler += (buf)[i]; sum2 += adler;} | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define DO4(buf,i) DO2(buf,i); DO2(buf,i+2); | | | | | | ------------------ | | | | | | | | 17| 0|#define DO2(buf,i) DO1(buf,i); DO1(buf,i+1); | | | | | | | | ------------------ | | | | | | | | | | 16| 0|#define DO1(buf,i) {adler += (buf)[i]; sum2 += adler;} | | | | | | | | ------------------ | | | | | | | | #define DO2(buf,i) DO1(buf,i); DO1(buf,i+1); | | | | | | | | ------------------ | | | | | | | | | | 16| 0|#define DO1(buf,i) {adler += (buf)[i]; sum2 += adler;} | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | #define DO8(buf,i) DO4(buf,i); DO4(buf,i+4); | | | | ------------------ | | | | | | 18| 0|#define DO4(buf,i) DO2(buf,i); DO2(buf,i+2); | | | | | | ------------------ | | | | | | | | 17| 0|#define DO2(buf,i) DO1(buf,i); DO1(buf,i+1); | | | | | | | | ------------------ | | | | | | | | | | 16| 0|#define DO1(buf,i) {adler += (buf)[i]; sum2 += adler;} | | | | | | | | ------------------ | | | | | | | | #define DO2(buf,i) DO1(buf,i); DO1(buf,i+1); | | | | | | | | ------------------ | | | | | | | | | | 16| 0|#define DO1(buf,i) {adler += (buf)[i]; sum2 += adler;} | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define DO4(buf,i) DO2(buf,i); DO2(buf,i+2); | | | | | | ------------------ | | | | | | | | 17| 0|#define DO2(buf,i) DO1(buf,i); DO1(buf,i+1); | | | | | | | | ------------------ | | | | | | | | | | 16| 0|#define DO1(buf,i) {adler += (buf)[i]; sum2 += adler;} | | | | | | | | ------------------ | | | | | | | | #define DO2(buf,i) DO1(buf,i); DO1(buf,i+1); | | | | | | | | ------------------ | | | | | | | | | | 16| 0|#define DO1(buf,i) {adler += (buf)[i]; sum2 += adler;} | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 136| 0| buf += 16; 137| 0| } while (--n); ------------------ | Branch (137:18): [True: 0, False: 0] ------------------ 138| 0| MOD(adler); ------------------ | | 57| 0|# define MOD(a) a %= BASE | | ------------------ | | | | 12| 0|#define BASE 65521U /* largest prime smaller than 65536 */ | | ------------------ ------------------ 139| 0| MOD(sum2); ------------------ | | 57| 0|# define MOD(a) a %= BASE | | ------------------ | | | | 12| 0|#define BASE 65521U /* largest prime smaller than 65536 */ | | ------------------ ------------------ 140| 0| } 141| | 142| | /* do remaining bytes (less than NMAX, still just one modulo) */ 143| 0| if (len) { /* avoid modulos if none remaining */ ------------------ | Branch (143:9): [True: 0, False: 0] ------------------ 144| 0| while (len >= 16) { ------------------ | Branch (144:16): [True: 0, False: 0] ------------------ 145| 0| len -= 16; 146| 0| DO16(buf); ------------------ | | 20| 0|#define DO16(buf) DO8(buf,0); DO8(buf,8); | | ------------------ | | | | 19| 0|#define DO8(buf,i) DO4(buf,i); DO4(buf,i+4); | | | | ------------------ | | | | | | 18| 0|#define DO4(buf,i) DO2(buf,i); DO2(buf,i+2); | | | | | | ------------------ | | | | | | | | 17| 0|#define DO2(buf,i) DO1(buf,i); DO1(buf,i+1); | | | | | | | | ------------------ | | | | | | | | | | 16| 0|#define DO1(buf,i) {adler += (buf)[i]; sum2 += adler;} | | | | | | | | ------------------ | | | | | | | | #define DO2(buf,i) DO1(buf,i); DO1(buf,i+1); | | | | | | | | ------------------ | | | | | | | | | | 16| 0|#define DO1(buf,i) {adler += (buf)[i]; sum2 += adler;} | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define DO4(buf,i) DO2(buf,i); DO2(buf,i+2); | | | | | | ------------------ | | | | | | | | 17| 0|#define DO2(buf,i) DO1(buf,i); DO1(buf,i+1); | | | | | | | | ------------------ | | | | | | | | | | 16| 0|#define DO1(buf,i) {adler += (buf)[i]; sum2 += adler;} | | | | | | | | ------------------ | | | | | | | | #define DO2(buf,i) DO1(buf,i); DO1(buf,i+1); | | | | | | | | ------------------ | | | | | | | | | | 16| 0|#define DO1(buf,i) {adler += (buf)[i]; sum2 += adler;} | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | #define DO8(buf,i) DO4(buf,i); DO4(buf,i+4); | | | | ------------------ | | | | | | 18| 0|#define DO4(buf,i) DO2(buf,i); DO2(buf,i+2); | | | | | | ------------------ | | | | | | | | 17| 0|#define DO2(buf,i) DO1(buf,i); DO1(buf,i+1); | | | | | | | | ------------------ | | | | | | | | | | 16| 0|#define DO1(buf,i) {adler += (buf)[i]; sum2 += adler;} | | | | | | | | ------------------ | | | | | | | | #define DO2(buf,i) DO1(buf,i); DO1(buf,i+1); | | | | | | | | ------------------ | | | | | | | | | | 16| 0|#define DO1(buf,i) {adler += (buf)[i]; sum2 += adler;} | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define DO4(buf,i) DO2(buf,i); DO2(buf,i+2); | | | | | | ------------------ | | | | | | | | 17| 0|#define DO2(buf,i) DO1(buf,i); DO1(buf,i+1); | | | | | | | | ------------------ | | | | | | | | | | 16| 0|#define DO1(buf,i) {adler += (buf)[i]; sum2 += adler;} | | | | | | | | ------------------ | | | | | | | | #define DO2(buf,i) DO1(buf,i); DO1(buf,i+1); | | | | | | | | ------------------ | | | | | | | | | | 16| 0|#define DO1(buf,i) {adler += (buf)[i]; sum2 += adler;} | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define DO16(buf) DO8(buf,0); DO8(buf,8); | | ------------------ | | | | 19| 0|#define DO8(buf,i) DO4(buf,i); DO4(buf,i+4); | | | | ------------------ | | | | | | 18| 0|#define DO4(buf,i) DO2(buf,i); DO2(buf,i+2); | | | | | | ------------------ | | | | | | | | 17| 0|#define DO2(buf,i) DO1(buf,i); DO1(buf,i+1); | | | | | | | | ------------------ | | | | | | | | | | 16| 0|#define DO1(buf,i) {adler += (buf)[i]; sum2 += adler;} | | | | | | | | ------------------ | | | | | | | | #define DO2(buf,i) DO1(buf,i); DO1(buf,i+1); | | | | | | | | ------------------ | | | | | | | | | | 16| 0|#define DO1(buf,i) {adler += (buf)[i]; sum2 += adler;} | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define DO4(buf,i) DO2(buf,i); DO2(buf,i+2); | | | | | | ------------------ | | | | | | | | 17| 0|#define DO2(buf,i) DO1(buf,i); DO1(buf,i+1); | | | | | | | | ------------------ | | | | | | | | | | 16| 0|#define DO1(buf,i) {adler += (buf)[i]; sum2 += adler;} | | | | | | | | ------------------ | | | | | | | | #define DO2(buf,i) DO1(buf,i); DO1(buf,i+1); | | | | | | | | ------------------ | | | | | | | | | | 16| 0|#define DO1(buf,i) {adler += (buf)[i]; sum2 += adler;} | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | #define DO8(buf,i) DO4(buf,i); DO4(buf,i+4); | | | | ------------------ | | | | | | 18| 0|#define DO4(buf,i) DO2(buf,i); DO2(buf,i+2); | | | | | | ------------------ | | | | | | | | 17| 0|#define DO2(buf,i) DO1(buf,i); DO1(buf,i+1); | | | | | | | | ------------------ | | | | | | | | | | 16| 0|#define DO1(buf,i) {adler += (buf)[i]; sum2 += adler;} | | | | | | | | ------------------ | | | | | | | | #define DO2(buf,i) DO1(buf,i); DO1(buf,i+1); | | | | | | | | ------------------ | | | | | | | | | | 16| 0|#define DO1(buf,i) {adler += (buf)[i]; sum2 += adler;} | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define DO4(buf,i) DO2(buf,i); DO2(buf,i+2); | | | | | | ------------------ | | | | | | | | 17| 0|#define DO2(buf,i) DO1(buf,i); DO1(buf,i+1); | | | | | | | | ------------------ | | | | | | | | | | 16| 0|#define DO1(buf,i) {adler += (buf)[i]; sum2 += adler;} | | | | | | | | ------------------ | | | | | | | | #define DO2(buf,i) DO1(buf,i); DO1(buf,i+1); | | | | | | | | ------------------ | | | | | | | | | | 16| 0|#define DO1(buf,i) {adler += (buf)[i]; sum2 += adler;} | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 147| 0| buf += 16; 148| 0| } 149| 0| while (len--) { ------------------ | Branch (149:16): [True: 0, False: 0] ------------------ 150| 0| adler += *buf++; 151| 0| sum2 += adler; 152| 0| } 153| 0| MOD(adler); ------------------ | | 57| 0|# define MOD(a) a %= BASE | | ------------------ | | | | 12| 0|#define BASE 65521U /* largest prime smaller than 65536 */ | | ------------------ ------------------ 154| 0| MOD(sum2); ------------------ | | 57| 0|# define MOD(a) a %= BASE | | ------------------ | | | | 12| 0|#define BASE 65521U /* largest prime smaller than 65536 */ | | ------------------ ------------------ 155| 0| } 156| | 157| | /* return recombined sums */ 158| 0| return adler | (sum2 << 16); 159| 0|} adler32: 166| 318|{ 167| 318| return adler32_z(adler, buf, len); 168| 318|} inflate_fast: 57| 159|{ 58| 159| struct inflate_state FAR *state; 59| 159| z_const unsigned char FAR *in; /* local strm->next_in */ 60| 159| z_const unsigned char FAR *last; /* have enough input while in < last */ 61| 159| unsigned char FAR *out; /* local strm->next_out */ 62| 159| unsigned char FAR *beg; /* inflate()'s initial strm->next_out */ 63| 159| unsigned char FAR *end; /* while out < end, enough space available */ 64| |#ifdef INFLATE_STRICT 65| | unsigned dmax; /* maximum distance from zlib header */ 66| |#endif 67| 159| unsigned wsize; /* window size or zero if not using window */ 68| 159| unsigned whave; /* valid bytes in the window */ 69| 159| unsigned wnext; /* window write index */ 70| 159| unsigned char FAR *window; /* allocated sliding window, if wsize != 0 */ 71| 159| unsigned long hold; /* local strm->hold */ 72| 159| unsigned bits; /* local strm->bits */ 73| 159| code const FAR *lcode; /* local strm->lencode */ 74| 159| code const FAR *dcode; /* local strm->distcode */ 75| 159| unsigned lmask; /* mask for first level of length codes */ 76| 159| unsigned dmask; /* mask for first level of distance codes */ 77| 159| code const *here; /* retrieved table entry */ 78| 159| unsigned op; /* code bits, operation, extra bits, or */ 79| | /* window position, window bytes to copy */ 80| 159| unsigned len; /* match length, unused bytes */ 81| 159| unsigned dist; /* match distance */ 82| 159| unsigned char FAR *from; /* where to copy match from */ 83| | 84| | /* copy state to local variables */ 85| 159| state = (struct inflate_state FAR *)strm->state; 86| 159| in = strm->next_in; 87| 159| last = in + (strm->avail_in - (INFLATE_FAST_MIN_INPUT - 1)); ------------------ | | 17| 159|#define INFLATE_FAST_MIN_INPUT 6 ------------------ 88| 159| out = strm->next_out; 89| 159| beg = out - (start - strm->avail_out); 90| 159| end = out + (strm->avail_out - (INFLATE_FAST_MIN_OUTPUT - 1)); ------------------ | | 24| 159|#define INFLATE_FAST_MIN_OUTPUT 258 ------------------ 91| |#ifdef INFLATE_STRICT 92| | dmax = state->dmax; 93| |#endif 94| 159| wsize = state->wsize; 95| 159| whave = state->whave; 96| 159| wnext = state->wnext; 97| 159| window = state->window; 98| 159| hold = state->hold; 99| 159| bits = state->bits; 100| 159| lcode = state->lencode; 101| 159| dcode = state->distcode; 102| 159| lmask = (1U << state->lenbits) - 1; 103| 159| dmask = (1U << state->distbits) - 1; 104| | 105| | /* decode literals and length/distances until end-of-block or not enough 106| | input data or output space */ 107| 318| do { 108| 318| if (bits < 15) { ------------------ | Branch (108:13): [True: 318, False: 0] ------------------ 109| 318| hold += (unsigned long)(*in++) << bits; 110| 318| bits += 8; 111| 318| hold += (unsigned long)(*in++) << bits; 112| 318| bits += 8; 113| 318| } 114| 318| here = lcode + (hold & lmask); 115| 318| dolen: 116| 318| op = (unsigned)(here->bits); 117| 318| hold >>= op; 118| 318| bits -= op; 119| 318| op = (unsigned)(here->op); 120| 318| if (op == 0) { /* literal */ ------------------ | Branch (120:13): [True: 159, False: 159] ------------------ 121| 159| Tracevv((stderr, here->val >= 0x20 && here->val < 0x7f ? 122| 159| "inflate: literal '%c'\n" : 123| 159| "inflate: literal 0x%02x\n", here->val)); 124| 159| *out++ = (unsigned char)(here->val); 125| 159| } 126| 159| else if (op & 16) { /* length base */ ------------------ | Branch (126:18): [True: 0, False: 159] ------------------ 127| 0| len = (unsigned)(here->val); 128| 0| op &= 15; /* number of extra bits */ 129| 0| if (op) { ------------------ | Branch (129:17): [True: 0, False: 0] ------------------ 130| 0| if (bits < op) { ------------------ | Branch (130:21): [True: 0, False: 0] ------------------ 131| 0| hold += (unsigned long)(*in++) << bits; 132| 0| bits += 8; 133| 0| } 134| 0| len += (unsigned)hold & ((1U << op) - 1); 135| 0| hold >>= op; 136| 0| bits -= op; 137| 0| } 138| 0| Tracevv((stderr, "inflate: length %u\n", len)); 139| 0| if (bits < 15) { ------------------ | Branch (139:17): [True: 0, False: 0] ------------------ 140| 0| hold += (unsigned long)(*in++) << bits; 141| 0| bits += 8; 142| 0| hold += (unsigned long)(*in++) << bits; 143| 0| bits += 8; 144| 0| } 145| 0| here = dcode + (hold & dmask); 146| 0| dodist: 147| 0| op = (unsigned)(here->bits); 148| 0| hold >>= op; 149| 0| bits -= op; 150| 0| op = (unsigned)(here->op); 151| 0| if (op & 16) { /* distance base */ ------------------ | Branch (151:17): [True: 0, False: 0] ------------------ 152| 0| dist = (unsigned)(here->val); 153| 0| op &= 15; /* number of extra bits */ 154| 0| if (bits < op) { ------------------ | Branch (154:21): [True: 0, False: 0] ------------------ 155| 0| hold += (unsigned long)(*in++) << bits; 156| 0| bits += 8; 157| 0| if (bits < op) { ------------------ | Branch (157:25): [True: 0, False: 0] ------------------ 158| 0| hold += (unsigned long)(*in++) << bits; 159| 0| bits += 8; 160| 0| } 161| 0| } 162| 0| dist += (unsigned)hold & ((1U << op) - 1); 163| |#ifdef INFLATE_STRICT 164| | if (dist > dmax) { 165| | strm->msg = (char *)"invalid distance too far back"; 166| | state->mode = BAD; 167| | break; 168| | } 169| |#endif 170| 0| hold >>= op; 171| 0| bits -= op; 172| 0| Tracevv((stderr, "inflate: distance %u\n", dist)); 173| 0| op = (unsigned)(out - beg); /* max distance in output */ 174| 0| if (dist > op) { /* see if copy from window */ ------------------ | Branch (174:21): [True: 0, False: 0] ------------------ 175| 0| op = dist - op; /* distance back in window */ 176| 0| if (op > whave) { ------------------ | Branch (176:25): [True: 0, False: 0] ------------------ 177| 0| if (state->sane) { ------------------ | Branch (177:29): [True: 0, False: 0] ------------------ 178| 0| strm->msg = 179| 0| (char *)"invalid distance too far back"; 180| 0| state->mode = BAD; 181| 0| break; 182| 0| } 183| |#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR 184| | if (len <= op - whave) { 185| | do { 186| | *out++ = 0; 187| | } while (--len); 188| | continue; 189| | } 190| | len -= op - whave; 191| | do { 192| | *out++ = 0; 193| | } while (--op > whave); 194| | if (op == 0) { 195| | from = out - dist; 196| | do { 197| | *out++ = *from++; 198| | } while (--len); 199| | continue; 200| | } 201| |#endif 202| 0| } 203| 0| from = window; 204| 0| if (wnext == 0) { /* very common case */ ------------------ | Branch (204:25): [True: 0, False: 0] ------------------ 205| 0| from += wsize - op; 206| 0| if (op < len) { /* some from window */ ------------------ | Branch (206:29): [True: 0, False: 0] ------------------ 207| 0| len -= op; 208| 0| do { 209| 0| *out++ = *from++; 210| 0| } while (--op); ------------------ | Branch (210:38): [True: 0, False: 0] ------------------ 211| 0| from = out - dist; /* rest from output */ 212| 0| } 213| 0| } 214| 0| else if (wnext < op) { /* wrap around window */ ------------------ | Branch (214:30): [True: 0, False: 0] ------------------ 215| 0| from += wsize + wnext - op; 216| 0| op -= wnext; 217| 0| if (op < len) { /* some from end of window */ ------------------ | Branch (217:29): [True: 0, False: 0] ------------------ 218| 0| len -= op; 219| 0| do { 220| 0| *out++ = *from++; 221| 0| } while (--op); ------------------ | Branch (221:38): [True: 0, False: 0] ------------------ 222| 0| from = window; 223| 0| if (wnext < len) { /* some from start of window */ ------------------ | Branch (223:33): [True: 0, False: 0] ------------------ 224| 0| op = wnext; 225| 0| len -= op; 226| 0| do { 227| 0| *out++ = *from++; 228| 0| } while (--op); ------------------ | Branch (228:42): [True: 0, False: 0] ------------------ 229| 0| from = out - dist; /* rest from output */ 230| 0| } 231| 0| } 232| 0| } 233| 0| else { /* contiguous in window */ 234| 0| from += wnext - op; 235| 0| if (op < len) { /* some from window */ ------------------ | Branch (235:29): [True: 0, False: 0] ------------------ 236| 0| len -= op; 237| 0| do { 238| 0| *out++ = *from++; 239| 0| } while (--op); ------------------ | Branch (239:38): [True: 0, False: 0] ------------------ 240| 0| from = out - dist; /* rest from output */ 241| 0| } 242| 0| } 243| 0| while (len > 2) { ------------------ | Branch (243:28): [True: 0, False: 0] ------------------ 244| 0| *out++ = *from++; 245| 0| *out++ = *from++; 246| 0| *out++ = *from++; 247| 0| len -= 3; 248| 0| } 249| 0| if (len) { ------------------ | Branch (249:25): [True: 0, False: 0] ------------------ 250| 0| *out++ = *from++; 251| 0| if (len > 1) ------------------ | Branch (251:29): [True: 0, False: 0] ------------------ 252| 0| *out++ = *from++; 253| 0| } 254| 0| } 255| 0| else { 256| 0| from = out - dist; /* copy direct from output */ 257| 0| do { /* minimum length is three */ 258| 0| *out++ = *from++; 259| 0| *out++ = *from++; 260| 0| *out++ = *from++; 261| 0| len -= 3; 262| 0| } while (len > 2); ------------------ | Branch (262:30): [True: 0, False: 0] ------------------ 263| 0| if (len) { ------------------ | Branch (263:25): [True: 0, False: 0] ------------------ 264| 0| *out++ = *from++; 265| 0| if (len > 1) ------------------ | Branch (265:29): [True: 0, False: 0] ------------------ 266| 0| *out++ = *from++; 267| 0| } 268| 0| } 269| 0| } 270| 0| else if ((op & 64) == 0) { /* 2nd level distance code */ ------------------ | Branch (270:22): [True: 0, False: 0] ------------------ 271| 0| here = dcode + here->val + (hold & ((1U << op) - 1)); 272| 0| goto dodist; 273| 0| } 274| 0| else { 275| 0| strm->msg = (char *)"invalid distance code"; 276| 0| state->mode = BAD; 277| 0| break; 278| 0| } 279| 0| } 280| 159| else if ((op & 64) == 0) { /* 2nd level length code */ ------------------ | Branch (280:18): [True: 0, False: 159] ------------------ 281| 0| here = lcode + here->val + (hold & ((1U << op) - 1)); 282| 0| goto dolen; 283| 0| } 284| 159| else if (op & 32) { /* end-of-block */ ------------------ | Branch (284:18): [True: 159, False: 0] ------------------ 285| 159| Tracevv((stderr, "inflate: end of block\n")); 286| 159| state->mode = TYPE; 287| 159| break; 288| 159| } 289| 0| else { 290| 0| strm->msg = (char *)"invalid literal/length code"; 291| 0| state->mode = BAD; 292| 0| break; 293| 0| } 294| 318| } while (in < last && out < end); ------------------ | Branch (294:14): [True: 159, False: 0] | Branch (294:27): [True: 159, False: 0] ------------------ 295| | 296| | /* return unused bytes (on entry, bits < 8, so in won't go too far back) */ 297| 159| len = bits >> 3; 298| 159| in -= len; 299| 159| bits -= len << 3; 300| 159| hold &= (1U << bits) - 1; 301| | 302| | /* update state and return */ 303| 159| strm->next_in = in; 304| 159| strm->next_out = out; 305| 159| strm->avail_in = (unsigned)(in < last ? ------------------ | Branch (305:33): [True: 159, False: 0] ------------------ 306| 159| (INFLATE_FAST_MIN_INPUT - 1) + (last - in) : ------------------ | | 17| 159|#define INFLATE_FAST_MIN_INPUT 6 ------------------ 307| 159| (INFLATE_FAST_MIN_INPUT - 1) - (in - last)); ------------------ | | 17| 0|#define INFLATE_FAST_MIN_INPUT 6 ------------------ 308| 159| strm->avail_out = (unsigned)(out < end ? ------------------ | Branch (308:34): [True: 159, False: 0] ------------------ 309| 159| (INFLATE_FAST_MIN_OUTPUT - 1) + (end - out) : ------------------ | | 24| 159|#define INFLATE_FAST_MIN_OUTPUT 258 ------------------ 310| 159| (INFLATE_FAST_MIN_OUTPUT - 1) - (out - end)); ------------------ | | 24| 0|#define INFLATE_FAST_MIN_OUTPUT 258 ------------------ 311| 159| state->hold = hold; 312| 159| state->bits = bits; 313| 159| return; 314| 159|} inflateResetKeep: 121| 2.18k|{ 122| 2.18k| struct inflate_state FAR *state; 123| | 124| 2.18k| if (inflateStateCheck(strm)) return Z_STREAM_ERROR; ------------------ | | 181| 0|#define Z_STREAM_ERROR (-2) ------------------ | Branch (124:9): [True: 0, False: 2.18k] ------------------ 125| 2.18k| state = (struct inflate_state FAR *)strm->state; 126| 2.18k| strm->total_in = strm->total_out = state->total = 0; 127| 2.18k| strm->msg = Z_NULL; ------------------ | | 212| 2.18k|#define Z_NULL 0 /* for initializing zalloc, zfree, opaque */ ------------------ 128| 2.18k| if (state->wrap) /* to support ill-conceived Java test suite */ ------------------ | Branch (128:9): [True: 2.18k, False: 0] ------------------ 129| 2.18k| strm->adler = state->wrap & 1; 130| 2.18k| state->mode = HEAD; 131| 2.18k| state->last = 0; 132| 2.18k| state->havedict = 0; 133| 2.18k| state->flags = -1; 134| 2.18k| state->dmax = 32768U; 135| 2.18k| state->head = Z_NULL; ------------------ | | 212| 2.18k|#define Z_NULL 0 /* for initializing zalloc, zfree, opaque */ ------------------ 136| 2.18k| state->hold = 0; 137| 2.18k| state->bits = 0; 138| 2.18k| state->lencode = state->distcode = state->next = state->codes; 139| 2.18k| state->sane = 1; 140| 2.18k| state->back = -1; 141| 2.18k| Tracev((stderr, "inflate: reset\n")); 142| 2.18k| return Z_OK; ------------------ | | 177| 2.18k|#define Z_OK 0 ------------------ 143| 2.18k|} inflateReset: 147| 2.18k|{ 148| 2.18k| struct inflate_state FAR *state; 149| | 150| 2.18k| if (inflateStateCheck(strm)) return Z_STREAM_ERROR; ------------------ | | 181| 0|#define Z_STREAM_ERROR (-2) ------------------ | Branch (150:9): [True: 0, False: 2.18k] ------------------ 151| 2.18k| state = (struct inflate_state FAR *)strm->state; 152| 2.18k| state->wsize = 0; 153| 2.18k| state->whave = 0; 154| 2.18k| state->wnext = 0; 155| 2.18k| return inflateResetKeep(strm); 156| 2.18k|} inflateReset2: 161| 2.02k|{ 162| 2.02k| int wrap; 163| 2.02k| struct inflate_state FAR *state; 164| | 165| | /* get the state */ 166| 2.02k| if (inflateStateCheck(strm)) return Z_STREAM_ERROR; ------------------ | | 181| 0|#define Z_STREAM_ERROR (-2) ------------------ | Branch (166:9): [True: 0, False: 2.02k] ------------------ 167| 2.02k| state = (struct inflate_state FAR *)strm->state; 168| | 169| | /* extract wrap request from windowBits parameter */ 170| 2.02k| if (windowBits < 0) { ------------------ | Branch (170:9): [True: 0, False: 2.02k] ------------------ 171| 0| if (windowBits < -15) ------------------ | Branch (171:13): [True: 0, False: 0] ------------------ 172| 0| return Z_STREAM_ERROR; ------------------ | | 181| 0|#define Z_STREAM_ERROR (-2) ------------------ 173| 0| wrap = 0; 174| 0| windowBits = -windowBits; 175| 0| } 176| 2.02k| else { 177| 2.02k| wrap = (windowBits >> 4) + 5; 178| 2.02k|#ifdef GUNZIP 179| 2.02k| if (windowBits < 48) ------------------ | Branch (179:13): [True: 2.02k, False: 0] ------------------ 180| 2.02k| windowBits &= 15; 181| 2.02k|#endif 182| 2.02k| } 183| | 184| | /* set number of window bits, free window if different */ 185| 2.02k| if (windowBits && (windowBits < 8 || windowBits > 15)) ------------------ | Branch (185:9): [True: 2.02k, False: 0] | Branch (185:24): [True: 0, False: 2.02k] | Branch (185:42): [True: 0, False: 2.02k] ------------------ 186| 0| return Z_STREAM_ERROR; ------------------ | | 181| 0|#define Z_STREAM_ERROR (-2) ------------------ 187| 2.02k| if (state->window != Z_NULL && state->wbits != (unsigned)windowBits) { ------------------ | | 212| 4.05k|#define Z_NULL 0 /* for initializing zalloc, zfree, opaque */ ------------------ | Branch (187:9): [True: 0, False: 2.02k] | Branch (187:36): [True: 0, False: 0] ------------------ 188| 0| ZFREE(strm, state->window); ------------------ | | 283| 0|#define ZFREE(strm, addr) (*((strm)->zfree))((strm)->opaque, (voidpf)(addr)) ------------------ 189| 0| state->window = Z_NULL; ------------------ | | 212| 0|#define Z_NULL 0 /* for initializing zalloc, zfree, opaque */ ------------------ 190| 0| } 191| | 192| | /* update state and reset the rest of it */ 193| 2.02k| state->wrap = wrap; 194| 2.02k| state->wbits = (unsigned)windowBits; 195| 2.02k| return inflateReset(strm); 196| 2.02k|} inflateInit2_: 203| 2.02k|{ 204| 2.02k| int ret; 205| 2.02k| struct inflate_state FAR *state; 206| | 207| 2.02k| if (version == Z_NULL || version[0] != ZLIB_VERSION[0] || ------------------ | | 212| 4.05k|#define Z_NULL 0 /* for initializing zalloc, zfree, opaque */ ------------------ if (version == Z_NULL || version[0] != ZLIB_VERSION[0] || ------------------ | | 40| 2.02k|#define ZLIB_VERSION "1.2.13" ------------------ | Branch (207:9): [True: 0, False: 2.02k] | Branch (207:30): [True: 0, False: 2.02k] ------------------ 208| 2.02k| stream_size != (int)(sizeof(z_stream))) ------------------ | Branch (208:9): [True: 0, False: 2.02k] ------------------ 209| 0| return Z_VERSION_ERROR; ------------------ | | 185| 0|#define Z_VERSION_ERROR (-6) ------------------ 210| 2.02k| if (strm == Z_NULL) return Z_STREAM_ERROR; ------------------ | | 212| 2.02k|#define Z_NULL 0 /* for initializing zalloc, zfree, opaque */ ------------------ if (strm == Z_NULL) return Z_STREAM_ERROR; ------------------ | | 181| 0|#define Z_STREAM_ERROR (-2) ------------------ | Branch (210:9): [True: 0, False: 2.02k] ------------------ 211| 2.02k| strm->msg = Z_NULL; /* in case we return an error */ ------------------ | | 212| 2.02k|#define Z_NULL 0 /* for initializing zalloc, zfree, opaque */ ------------------ 212| 2.02k| if (strm->zalloc == (alloc_func)0) { ------------------ | Branch (212:9): [True: 2.02k, False: 0] ------------------ 213| |#ifdef Z_SOLO 214| | return Z_STREAM_ERROR; 215| |#else 216| 2.02k| strm->zalloc = zcalloc; 217| 2.02k| strm->opaque = (voidpf)0; 218| 2.02k|#endif 219| 2.02k| } 220| 2.02k| if (strm->zfree == (free_func)0) ------------------ | Branch (220:9): [True: 2.02k, False: 0] ------------------ 221| |#ifdef Z_SOLO 222| | return Z_STREAM_ERROR; 223| |#else 224| 2.02k| strm->zfree = zcfree; 225| 2.02k|#endif 226| 2.02k| state = (struct inflate_state FAR *) 227| 2.02k| ZALLOC(strm, 1, sizeof(struct inflate_state)); ------------------ | | 282| 2.02k| (*((strm)->zalloc))((strm)->opaque, (items), (size)) ------------------ 228| 2.02k| if (state == Z_NULL) return Z_MEM_ERROR; ------------------ | | 212| 2.02k|#define Z_NULL 0 /* for initializing zalloc, zfree, opaque */ ------------------ if (state == Z_NULL) return Z_MEM_ERROR; ------------------ | | 183| 0|#define Z_MEM_ERROR (-4) ------------------ | Branch (228:9): [True: 0, False: 2.02k] ------------------ 229| 2.02k| Tracev((stderr, "inflate: allocated\n")); 230| 2.02k| strm->state = (struct internal_state FAR *)state; 231| 2.02k| state->strm = strm; 232| 2.02k| state->window = Z_NULL; ------------------ | | 212| 2.02k|#define Z_NULL 0 /* for initializing zalloc, zfree, opaque */ ------------------ 233| 2.02k| state->mode = HEAD; /* to pass state test in inflateReset2() */ 234| 2.02k| state->check = 1L; /* 1L is the result of adler32() zero length data */ 235| 2.02k| ret = inflateReset2(strm, windowBits); 236| 2.02k| if (ret != Z_OK) { ------------------ | | 177| 2.02k|#define Z_OK 0 ------------------ | Branch (236:9): [True: 0, False: 2.02k] ------------------ 237| 0| ZFREE(strm, state); ------------------ | | 283| 0|#define ZFREE(strm, addr) (*((strm)->zfree))((strm)->opaque, (voidpf)(addr)) ------------------ 238| 0| strm->state = Z_NULL; ------------------ | | 212| 0|#define Z_NULL 0 /* for initializing zalloc, zfree, opaque */ ------------------ 239| 0| } 240| 2.02k| return ret; 241| 2.02k|} inflate: 629| 159|{ 630| 159| struct inflate_state FAR *state; 631| 159| z_const unsigned char FAR *next; /* next input */ 632| 159| unsigned char FAR *put; /* next output */ 633| 159| unsigned have, left; /* available input and output */ 634| 159| unsigned long hold; /* bit buffer */ 635| 159| unsigned bits; /* bits in bit buffer */ 636| 159| unsigned in, out; /* save starting available input and output */ 637| 159| unsigned copy; /* number of stored or match bytes to copy */ 638| 159| unsigned char FAR *from; /* where to copy match bytes from */ 639| 159| code here; /* current decoding table entry */ 640| 159| code last; /* parent table entry */ 641| 159| unsigned len; /* length to copy for repeats, bits to drop */ 642| 159| int ret; /* return code */ 643| 159|#ifdef GUNZIP 644| 159| unsigned char hbuf[4]; /* buffer for gzip header crc calculation */ 645| 159|#endif 646| 159| static const unsigned short order[19] = /* permutation of code lengths */ 647| 159| {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15}; 648| | 649| 159| if (inflateStateCheck(strm) || strm->next_out == Z_NULL || ------------------ | | 212| 318|#define Z_NULL 0 /* for initializing zalloc, zfree, opaque */ ------------------ | Branch (649:9): [True: 0, False: 159] | Branch (649:36): [True: 0, False: 159] ------------------ 650| 159| (strm->next_in == Z_NULL && strm->avail_in != 0)) ------------------ | | 212| 318|#define Z_NULL 0 /* for initializing zalloc, zfree, opaque */ ------------------ | Branch (650:10): [True: 0, False: 159] | Branch (650:37): [True: 0, False: 0] ------------------ 651| 0| return Z_STREAM_ERROR; ------------------ | | 181| 0|#define Z_STREAM_ERROR (-2) ------------------ 652| | 653| 159| state = (struct inflate_state FAR *)strm->state; 654| 159| if (state->mode == TYPE) state->mode = TYPEDO; /* skip check */ ------------------ | Branch (654:9): [True: 0, False: 159] ------------------ 655| 159| LOAD(); ------------------ | | 481| 159| do { \ | | 482| 159| put = strm->next_out; \ | | 483| 159| left = strm->avail_out; \ | | 484| 159| next = strm->next_in; \ | | 485| 159| have = strm->avail_in; \ | | 486| 159| hold = state->hold; \ | | 487| 159| bits = state->bits; \ | | 488| 159| } while (0) | | ------------------ | | | Branch (488:14): [Folded - Ignored] | | ------------------ ------------------ 656| 159| in = have; 657| 159| out = left; 658| 159| ret = Z_OK; ------------------ | | 177| 159|#define Z_OK 0 ------------------ 659| 159| for (;;) 660| 795| switch (state->mode) { 661| 159| case HEAD: ------------------ | Branch (661:9): [True: 159, False: 636] ------------------ 662| 159| if (state->wrap == 0) { ------------------ | Branch (662:17): [True: 0, False: 159] ------------------ 663| 0| state->mode = TYPEDO; 664| 0| break; 665| 0| } 666| 159| NEEDBITS(16); ------------------ | | 521| 159| do { \ | | 522| 477| while (bits < (unsigned)(n)) \ | | ------------------ | | | Branch (522:16): [True: 318, False: 159] | | ------------------ | | 523| 318| PULLBYTE(); \ | | ------------------ | | | | 511| 318| do { \ | | | | 512| 318| if (have == 0) goto inf_leave; \ | | | | ------------------ | | | | | Branch (512:13): [True: 0, False: 318] | | | | ------------------ | | | | 513| 318| have--; \ | | | | 514| 318| hold += (unsigned long)(*next++) << bits; \ | | | | 515| 318| bits += 8; \ | | | | 516| 318| } while (0) | | | | ------------------ | | | | | Branch (516:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 524| 159| } while (0) | | ------------------ | | | Branch (524:14): [Folded - Ignored] | | ------------------ ------------------ 667| 159|#ifdef GUNZIP 668| 159| if ((state->wrap & 2) && hold == 0x8b1f) { /* gzip header */ ------------------ | Branch (668:17): [True: 159, False: 0] | Branch (668:38): [True: 0, False: 159] ------------------ 669| 0| if (state->wbits == 0) ------------------ | Branch (669:21): [True: 0, False: 0] ------------------ 670| 0| state->wbits = 15; 671| 0| state->check = crc32(0L, Z_NULL, 0); ------------------ | | 212| 0|#define Z_NULL 0 /* for initializing zalloc, zfree, opaque */ ------------------ 672| 0| CRC2(state->check, hold); ------------------ | | 463| 0| do { \ | | 464| 0| hbuf[0] = (unsigned char)(word); \ | | 465| 0| hbuf[1] = (unsigned char)((word) >> 8); \ | | 466| 0| check = crc32(check, hbuf, 2); \ | | 467| 0| } while (0) | | ------------------ | | | Branch (467:14): [Folded - Ignored] | | ------------------ ------------------ 673| 0| INITBITS(); ------------------ | | 503| 0| do { \ | | 504| 0| hold = 0; \ | | 505| 0| bits = 0; \ | | 506| 0| } while (0) | | ------------------ | | | Branch (506:14): [Folded - Ignored] | | ------------------ ------------------ 674| 0| state->mode = FLAGS; 675| 0| break; 676| 0| } 677| 159| if (state->head != Z_NULL) ------------------ | | 212| 159|#define Z_NULL 0 /* for initializing zalloc, zfree, opaque */ ------------------ | Branch (677:17): [True: 0, False: 159] ------------------ 678| 0| state->head->done = -1; 679| 159| if (!(state->wrap & 1) || /* check if zlib header allowed */ ------------------ | Branch (679:17): [True: 0, False: 159] ------------------ 680| |#else 681| | if ( 682| |#endif 683| 159| ((BITS(8) << 8) + (hold >> 8)) % 31) { ------------------ | | 528| 159| ((unsigned)hold & ((1U << (n)) - 1)) ------------------ | Branch (683:17): [True: 0, False: 159] ------------------ 684| 0| strm->msg = (char *)"incorrect header check"; 685| 0| state->mode = BAD; 686| 0| break; 687| 0| } 688| 159| if (BITS(4) != Z_DEFLATED) { ------------------ | | 528| 159| ((unsigned)hold & ((1U << (n)) - 1)) ------------------ if (BITS(4) != Z_DEFLATED) { ------------------ | | 209| 159|#define Z_DEFLATED 8 ------------------ | Branch (688:17): [True: 0, False: 159] ------------------ 689| 0| strm->msg = (char *)"unknown compression method"; 690| 0| state->mode = BAD; 691| 0| break; 692| 0| } 693| 159| DROPBITS(4); ------------------ | | 532| 159| do { \ | | 533| 159| hold >>= (n); \ | | 534| 159| bits -= (unsigned)(n); \ | | 535| 159| } while (0) | | ------------------ | | | Branch (535:14): [Folded - Ignored] | | ------------------ ------------------ 694| 159| len = BITS(4) + 8; ------------------ | | 528| 159| ((unsigned)hold & ((1U << (n)) - 1)) ------------------ 695| 159| if (state->wbits == 0) ------------------ | Branch (695:17): [True: 0, False: 159] ------------------ 696| 0| state->wbits = len; 697| 159| if (len > 15 || len > state->wbits) { ------------------ | Branch (697:17): [True: 0, False: 159] | Branch (697:29): [True: 0, False: 159] ------------------ 698| 0| strm->msg = (char *)"invalid window size"; 699| 0| state->mode = BAD; 700| 0| break; 701| 0| } 702| 159| state->dmax = 1U << len; 703| 159| state->flags = 0; /* indicate zlib header */ 704| 159| Tracev((stderr, "inflate: zlib header ok\n")); 705| 159| strm->adler = state->check = adler32(0L, Z_NULL, 0); ------------------ | | 212| 159|#define Z_NULL 0 /* for initializing zalloc, zfree, opaque */ ------------------ 706| 159| state->mode = hold & 0x200 ? DICTID : TYPE; ------------------ | Branch (706:27): [True: 0, False: 159] ------------------ 707| 159| INITBITS(); ------------------ | | 503| 159| do { \ | | 504| 159| hold = 0; \ | | 505| 159| bits = 0; \ | | 506| 159| } while (0) | | ------------------ | | | Branch (506:14): [Folded - Ignored] | | ------------------ ------------------ 708| 159| break; 709| 0|#ifdef GUNZIP 710| 0| case FLAGS: ------------------ | Branch (710:9): [True: 0, False: 795] ------------------ 711| 0| NEEDBITS(16); ------------------ | | 521| 0| do { \ | | 522| 0| while (bits < (unsigned)(n)) \ | | ------------------ | | | Branch (522:16): [True: 0, False: 0] | | ------------------ | | 523| 0| PULLBYTE(); \ | | ------------------ | | | | 511| 0| do { \ | | | | 512| 0| if (have == 0) goto inf_leave; \ | | | | ------------------ | | | | | Branch (512:13): [True: 0, False: 0] | | | | ------------------ | | | | 513| 0| have--; \ | | | | 514| 0| hold += (unsigned long)(*next++) << bits; \ | | | | 515| 0| bits += 8; \ | | | | 516| 0| } while (0) | | | | ------------------ | | | | | Branch (516:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 524| 0| } while (0) | | ------------------ | | | Branch (524:14): [Folded - Ignored] | | ------------------ ------------------ 712| 0| state->flags = (int)(hold); 713| 0| if ((state->flags & 0xff) != Z_DEFLATED) { ------------------ | | 209| 0|#define Z_DEFLATED 8 ------------------ | Branch (713:17): [True: 0, False: 0] ------------------ 714| 0| strm->msg = (char *)"unknown compression method"; 715| 0| state->mode = BAD; 716| 0| break; 717| 0| } 718| 0| if (state->flags & 0xe000) { ------------------ | Branch (718:17): [True: 0, False: 0] ------------------ 719| 0| strm->msg = (char *)"unknown header flags set"; 720| 0| state->mode = BAD; 721| 0| break; 722| 0| } 723| 0| if (state->head != Z_NULL) ------------------ | | 212| 0|#define Z_NULL 0 /* for initializing zalloc, zfree, opaque */ ------------------ | Branch (723:17): [True: 0, False: 0] ------------------ 724| 0| state->head->text = (int)((hold >> 8) & 1); 725| 0| if ((state->flags & 0x0200) && (state->wrap & 4)) ------------------ | Branch (725:17): [True: 0, False: 0] | Branch (725:44): [True: 0, False: 0] ------------------ 726| 0| CRC2(state->check, hold); ------------------ | | 463| 0| do { \ | | 464| 0| hbuf[0] = (unsigned char)(word); \ | | 465| 0| hbuf[1] = (unsigned char)((word) >> 8); \ | | 466| 0| check = crc32(check, hbuf, 2); \ | | 467| 0| } while (0) | | ------------------ | | | Branch (467:14): [Folded - Ignored] | | ------------------ ------------------ 727| 0| INITBITS(); ------------------ | | 503| 0| do { \ | | 504| 0| hold = 0; \ | | 505| 0| bits = 0; \ | | 506| 0| } while (0) | | ------------------ | | | Branch (506:14): [Folded - Ignored] | | ------------------ ------------------ 728| 0| state->mode = TIME; 729| | /* fallthrough */ 730| 0| case TIME: ------------------ | Branch (730:9): [True: 0, False: 795] ------------------ 731| 0| NEEDBITS(32); ------------------ | | 521| 0| do { \ | | 522| 0| while (bits < (unsigned)(n)) \ | | ------------------ | | | Branch (522:16): [True: 0, False: 0] | | ------------------ | | 523| 0| PULLBYTE(); \ | | ------------------ | | | | 511| 0| do { \ | | | | 512| 0| if (have == 0) goto inf_leave; \ | | | | ------------------ | | | | | Branch (512:13): [True: 0, False: 0] | | | | ------------------ | | | | 513| 0| have--; \ | | | | 514| 0| hold += (unsigned long)(*next++) << bits; \ | | | | 515| 0| bits += 8; \ | | | | 516| 0| } while (0) | | | | ------------------ | | | | | Branch (516:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 524| 0| } while (0) | | ------------------ | | | Branch (524:14): [Folded - Ignored] | | ------------------ ------------------ 732| 0| if (state->head != Z_NULL) ------------------ | | 212| 0|#define Z_NULL 0 /* for initializing zalloc, zfree, opaque */ ------------------ | Branch (732:17): [True: 0, False: 0] ------------------ 733| 0| state->head->time = hold; 734| 0| if ((state->flags & 0x0200) && (state->wrap & 4)) ------------------ | Branch (734:17): [True: 0, False: 0] | Branch (734:44): [True: 0, False: 0] ------------------ 735| 0| CRC4(state->check, hold); ------------------ | | 470| 0| do { \ | | 471| 0| hbuf[0] = (unsigned char)(word); \ | | 472| 0| hbuf[1] = (unsigned char)((word) >> 8); \ | | 473| 0| hbuf[2] = (unsigned char)((word) >> 16); \ | | 474| 0| hbuf[3] = (unsigned char)((word) >> 24); \ | | 475| 0| check = crc32(check, hbuf, 4); \ | | 476| 0| } while (0) | | ------------------ | | | Branch (476:14): [Folded - Ignored] | | ------------------ ------------------ 736| 0| INITBITS(); ------------------ | | 503| 0| do { \ | | 504| 0| hold = 0; \ | | 505| 0| bits = 0; \ | | 506| 0| } while (0) | | ------------------ | | | Branch (506:14): [Folded - Ignored] | | ------------------ ------------------ 737| 0| state->mode = OS; 738| | /* fallthrough */ 739| 0| case OS: ------------------ | Branch (739:9): [True: 0, False: 795] ------------------ 740| 0| NEEDBITS(16); ------------------ | | 521| 0| do { \ | | 522| 0| while (bits < (unsigned)(n)) \ | | ------------------ | | | Branch (522:16): [True: 0, False: 0] | | ------------------ | | 523| 0| PULLBYTE(); \ | | ------------------ | | | | 511| 0| do { \ | | | | 512| 0| if (have == 0) goto inf_leave; \ | | | | ------------------ | | | | | Branch (512:13): [True: 0, False: 0] | | | | ------------------ | | | | 513| 0| have--; \ | | | | 514| 0| hold += (unsigned long)(*next++) << bits; \ | | | | 515| 0| bits += 8; \ | | | | 516| 0| } while (0) | | | | ------------------ | | | | | Branch (516:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 524| 0| } while (0) | | ------------------ | | | Branch (524:14): [Folded - Ignored] | | ------------------ ------------------ 741| 0| if (state->head != Z_NULL) { ------------------ | | 212| 0|#define Z_NULL 0 /* for initializing zalloc, zfree, opaque */ ------------------ | Branch (741:17): [True: 0, False: 0] ------------------ 742| 0| state->head->xflags = (int)(hold & 0xff); 743| 0| state->head->os = (int)(hold >> 8); 744| 0| } 745| 0| if ((state->flags & 0x0200) && (state->wrap & 4)) ------------------ | Branch (745:17): [True: 0, False: 0] | Branch (745:44): [True: 0, False: 0] ------------------ 746| 0| CRC2(state->check, hold); ------------------ | | 463| 0| do { \ | | 464| 0| hbuf[0] = (unsigned char)(word); \ | | 465| 0| hbuf[1] = (unsigned char)((word) >> 8); \ | | 466| 0| check = crc32(check, hbuf, 2); \ | | 467| 0| } while (0) | | ------------------ | | | Branch (467:14): [Folded - Ignored] | | ------------------ ------------------ 747| 0| INITBITS(); ------------------ | | 503| 0| do { \ | | 504| 0| hold = 0; \ | | 505| 0| bits = 0; \ | | 506| 0| } while (0) | | ------------------ | | | Branch (506:14): [Folded - Ignored] | | ------------------ ------------------ 748| 0| state->mode = EXLEN; 749| | /* fallthrough */ 750| 0| case EXLEN: ------------------ | Branch (750:9): [True: 0, False: 795] ------------------ 751| 0| if (state->flags & 0x0400) { ------------------ | Branch (751:17): [True: 0, False: 0] ------------------ 752| 0| NEEDBITS(16); ------------------ | | 521| 0| do { \ | | 522| 0| while (bits < (unsigned)(n)) \ | | ------------------ | | | Branch (522:16): [True: 0, False: 0] | | ------------------ | | 523| 0| PULLBYTE(); \ | | ------------------ | | | | 511| 0| do { \ | | | | 512| 0| if (have == 0) goto inf_leave; \ | | | | ------------------ | | | | | Branch (512:13): [True: 0, False: 0] | | | | ------------------ | | | | 513| 0| have--; \ | | | | 514| 0| hold += (unsigned long)(*next++) << bits; \ | | | | 515| 0| bits += 8; \ | | | | 516| 0| } while (0) | | | | ------------------ | | | | | Branch (516:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 524| 0| } while (0) | | ------------------ | | | Branch (524:14): [Folded - Ignored] | | ------------------ ------------------ 753| 0| state->length = (unsigned)(hold); 754| 0| if (state->head != Z_NULL) ------------------ | | 212| 0|#define Z_NULL 0 /* for initializing zalloc, zfree, opaque */ ------------------ | Branch (754:21): [True: 0, False: 0] ------------------ 755| 0| state->head->extra_len = (unsigned)hold; 756| 0| if ((state->flags & 0x0200) && (state->wrap & 4)) ------------------ | Branch (756:21): [True: 0, False: 0] | Branch (756:48): [True: 0, False: 0] ------------------ 757| 0| CRC2(state->check, hold); ------------------ | | 463| 0| do { \ | | 464| 0| hbuf[0] = (unsigned char)(word); \ | | 465| 0| hbuf[1] = (unsigned char)((word) >> 8); \ | | 466| 0| check = crc32(check, hbuf, 2); \ | | 467| 0| } while (0) | | ------------------ | | | Branch (467:14): [Folded - Ignored] | | ------------------ ------------------ 758| 0| INITBITS(); ------------------ | | 503| 0| do { \ | | 504| 0| hold = 0; \ | | 505| 0| bits = 0; \ | | 506| 0| } while (0) | | ------------------ | | | Branch (506:14): [Folded - Ignored] | | ------------------ ------------------ 759| 0| } 760| 0| else if (state->head != Z_NULL) ------------------ | | 212| 0|#define Z_NULL 0 /* for initializing zalloc, zfree, opaque */ ------------------ | Branch (760:22): [True: 0, False: 0] ------------------ 761| 0| state->head->extra = Z_NULL; ------------------ | | 212| 0|#define Z_NULL 0 /* for initializing zalloc, zfree, opaque */ ------------------ 762| 0| state->mode = EXTRA; 763| | /* fallthrough */ 764| 0| case EXTRA: ------------------ | Branch (764:9): [True: 0, False: 795] ------------------ 765| 0| if (state->flags & 0x0400) { ------------------ | Branch (765:17): [True: 0, False: 0] ------------------ 766| 0| copy = state->length; 767| 0| if (copy > have) copy = have; ------------------ | Branch (767:21): [True: 0, False: 0] ------------------ 768| 0| if (copy) { ------------------ | Branch (768:21): [True: 0, False: 0] ------------------ 769| 0| if (state->head != Z_NULL && ------------------ | | 212| 0|#define Z_NULL 0 /* for initializing zalloc, zfree, opaque */ ------------------ | Branch (769:25): [True: 0, False: 0] ------------------ 770| 0| state->head->extra != Z_NULL && ------------------ | | 212| 0|#define Z_NULL 0 /* for initializing zalloc, zfree, opaque */ ------------------ | Branch (770:25): [True: 0, False: 0] ------------------ 771| 0| (len = state->head->extra_len - state->length) < ------------------ | Branch (771:25): [True: 0, False: 0] ------------------ 772| 0| state->head->extra_max) { 773| 0| zmemcpy(state->head->extra + len, next, ------------------ | | 245| 0|# define zmemcpy memcpy ------------------ 774| 0| len + copy > state->head->extra_max ? ------------------ | Branch (774:33): [True: 0, False: 0] ------------------ 775| 0| state->head->extra_max - len : copy); 776| 0| } 777| 0| if ((state->flags & 0x0200) && (state->wrap & 4)) ------------------ | Branch (777:25): [True: 0, False: 0] | Branch (777:52): [True: 0, False: 0] ------------------ 778| 0| state->check = crc32(state->check, next, copy); 779| 0| have -= copy; 780| 0| next += copy; 781| 0| state->length -= copy; 782| 0| } 783| 0| if (state->length) goto inf_leave; ------------------ | Branch (783:21): [True: 0, False: 0] ------------------ 784| 0| } 785| 0| state->length = 0; 786| 0| state->mode = NAME; 787| | /* fallthrough */ 788| 0| case NAME: ------------------ | Branch (788:9): [True: 0, False: 795] ------------------ 789| 0| if (state->flags & 0x0800) { ------------------ | Branch (789:17): [True: 0, False: 0] ------------------ 790| 0| if (have == 0) goto inf_leave; ------------------ | Branch (790:21): [True: 0, False: 0] ------------------ 791| 0| copy = 0; 792| 0| do { 793| 0| len = (unsigned)(next[copy++]); 794| 0| if (state->head != Z_NULL && ------------------ | | 212| 0|#define Z_NULL 0 /* for initializing zalloc, zfree, opaque */ ------------------ | Branch (794:25): [True: 0, False: 0] ------------------ 795| 0| state->head->name != Z_NULL && ------------------ | | 212| 0|#define Z_NULL 0 /* for initializing zalloc, zfree, opaque */ ------------------ | Branch (795:29): [True: 0, False: 0] ------------------ 796| 0| state->length < state->head->name_max) ------------------ | Branch (796:29): [True: 0, False: 0] ------------------ 797| 0| state->head->name[state->length++] = (Bytef)len; 798| 0| } while (len && copy < have); ------------------ | Branch (798:26): [True: 0, False: 0] | Branch (798:33): [True: 0, False: 0] ------------------ 799| 0| if ((state->flags & 0x0200) && (state->wrap & 4)) ------------------ | Branch (799:21): [True: 0, False: 0] | Branch (799:48): [True: 0, False: 0] ------------------ 800| 0| state->check = crc32(state->check, next, copy); 801| 0| have -= copy; 802| 0| next += copy; 803| 0| if (len) goto inf_leave; ------------------ | Branch (803:21): [True: 0, False: 0] ------------------ 804| 0| } 805| 0| else if (state->head != Z_NULL) ------------------ | | 212| 0|#define Z_NULL 0 /* for initializing zalloc, zfree, opaque */ ------------------ | Branch (805:22): [True: 0, False: 0] ------------------ 806| 0| state->head->name = Z_NULL; ------------------ | | 212| 0|#define Z_NULL 0 /* for initializing zalloc, zfree, opaque */ ------------------ 807| 0| state->length = 0; 808| 0| state->mode = COMMENT; 809| | /* fallthrough */ 810| 0| case COMMENT: ------------------ | Branch (810:9): [True: 0, False: 795] ------------------ 811| 0| if (state->flags & 0x1000) { ------------------ | Branch (811:17): [True: 0, False: 0] ------------------ 812| 0| if (have == 0) goto inf_leave; ------------------ | Branch (812:21): [True: 0, False: 0] ------------------ 813| 0| copy = 0; 814| 0| do { 815| 0| len = (unsigned)(next[copy++]); 816| 0| if (state->head != Z_NULL && ------------------ | | 212| 0|#define Z_NULL 0 /* for initializing zalloc, zfree, opaque */ ------------------ | Branch (816:25): [True: 0, False: 0] ------------------ 817| 0| state->head->comment != Z_NULL && ------------------ | | 212| 0|#define Z_NULL 0 /* for initializing zalloc, zfree, opaque */ ------------------ | Branch (817:29): [True: 0, False: 0] ------------------ 818| 0| state->length < state->head->comm_max) ------------------ | Branch (818:29): [True: 0, False: 0] ------------------ 819| 0| state->head->comment[state->length++] = (Bytef)len; 820| 0| } while (len && copy < have); ------------------ | Branch (820:26): [True: 0, False: 0] | Branch (820:33): [True: 0, False: 0] ------------------ 821| 0| if ((state->flags & 0x0200) && (state->wrap & 4)) ------------------ | Branch (821:21): [True: 0, False: 0] | Branch (821:48): [True: 0, False: 0] ------------------ 822| 0| state->check = crc32(state->check, next, copy); 823| 0| have -= copy; 824| 0| next += copy; 825| 0| if (len) goto inf_leave; ------------------ | Branch (825:21): [True: 0, False: 0] ------------------ 826| 0| } 827| 0| else if (state->head != Z_NULL) ------------------ | | 212| 0|#define Z_NULL 0 /* for initializing zalloc, zfree, opaque */ ------------------ | Branch (827:22): [True: 0, False: 0] ------------------ 828| 0| state->head->comment = Z_NULL; ------------------ | | 212| 0|#define Z_NULL 0 /* for initializing zalloc, zfree, opaque */ ------------------ 829| 0| state->mode = HCRC; 830| | /* fallthrough */ 831| 0| case HCRC: ------------------ | Branch (831:9): [True: 0, False: 795] ------------------ 832| 0| if (state->flags & 0x0200) { ------------------ | Branch (832:17): [True: 0, False: 0] ------------------ 833| 0| NEEDBITS(16); ------------------ | | 521| 0| do { \ | | 522| 0| while (bits < (unsigned)(n)) \ | | ------------------ | | | Branch (522:16): [True: 0, False: 0] | | ------------------ | | 523| 0| PULLBYTE(); \ | | ------------------ | | | | 511| 0| do { \ | | | | 512| 0| if (have == 0) goto inf_leave; \ | | | | ------------------ | | | | | Branch (512:13): [True: 0, False: 0] | | | | ------------------ | | | | 513| 0| have--; \ | | | | 514| 0| hold += (unsigned long)(*next++) << bits; \ | | | | 515| 0| bits += 8; \ | | | | 516| 0| } while (0) | | | | ------------------ | | | | | Branch (516:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 524| 0| } while (0) | | ------------------ | | | Branch (524:14): [Folded - Ignored] | | ------------------ ------------------ 834| 0| if ((state->wrap & 4) && hold != (state->check & 0xffff)) { ------------------ | Branch (834:21): [True: 0, False: 0] | Branch (834:42): [True: 0, False: 0] ------------------ 835| 0| strm->msg = (char *)"header crc mismatch"; 836| 0| state->mode = BAD; 837| 0| break; 838| 0| } 839| 0| INITBITS(); ------------------ | | 503| 0| do { \ | | 504| 0| hold = 0; \ | | 505| 0| bits = 0; \ | | 506| 0| } while (0) | | ------------------ | | | Branch (506:14): [Folded - Ignored] | | ------------------ ------------------ 840| 0| } 841| 0| if (state->head != Z_NULL) { ------------------ | | 212| 0|#define Z_NULL 0 /* for initializing zalloc, zfree, opaque */ ------------------ | Branch (841:17): [True: 0, False: 0] ------------------ 842| 0| state->head->hcrc = (int)((state->flags >> 9) & 1); 843| 0| state->head->done = 1; 844| 0| } 845| 0| strm->adler = state->check = crc32(0L, Z_NULL, 0); ------------------ | | 212| 0|#define Z_NULL 0 /* for initializing zalloc, zfree, opaque */ ------------------ 846| 0| state->mode = TYPE; 847| 0| break; 848| 0|#endif 849| 0| case DICTID: ------------------ | Branch (849:9): [True: 0, False: 795] ------------------ 850| 0| NEEDBITS(32); ------------------ | | 521| 0| do { \ | | 522| 0| while (bits < (unsigned)(n)) \ | | ------------------ | | | Branch (522:16): [True: 0, False: 0] | | ------------------ | | 523| 0| PULLBYTE(); \ | | ------------------ | | | | 511| 0| do { \ | | | | 512| 0| if (have == 0) goto inf_leave; \ | | | | ------------------ | | | | | Branch (512:13): [True: 0, False: 0] | | | | ------------------ | | | | 513| 0| have--; \ | | | | 514| 0| hold += (unsigned long)(*next++) << bits; \ | | | | 515| 0| bits += 8; \ | | | | 516| 0| } while (0) | | | | ------------------ | | | | | Branch (516:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 524| 0| } while (0) | | ------------------ | | | Branch (524:14): [Folded - Ignored] | | ------------------ ------------------ 851| 0| strm->adler = state->check = ZSWAP32(hold); ------------------ | | 287| 0|#define ZSWAP32(q) ((((q) >> 24) & 0xff) + (((q) >> 8) & 0xff00) + \ | | 288| 0| (((q) & 0xff00) << 8) + (((q) & 0xff) << 24)) ------------------ 852| 0| INITBITS(); ------------------ | | 503| 0| do { \ | | 504| 0| hold = 0; \ | | 505| 0| bits = 0; \ | | 506| 0| } while (0) | | ------------------ | | | Branch (506:14): [Folded - Ignored] | | ------------------ ------------------ 853| 0| state->mode = DICT; 854| | /* fallthrough */ 855| 0| case DICT: ------------------ | Branch (855:9): [True: 0, False: 795] ------------------ 856| 0| if (state->havedict == 0) { ------------------ | Branch (856:17): [True: 0, False: 0] ------------------ 857| 0| RESTORE(); ------------------ | | 492| 0| do { \ | | 493| 0| strm->next_out = put; \ | | 494| 0| strm->avail_out = left; \ | | 495| 0| strm->next_in = next; \ | | 496| 0| strm->avail_in = have; \ | | 497| 0| state->hold = hold; \ | | 498| 0| state->bits = bits; \ | | 499| 0| } while (0) | | ------------------ | | | Branch (499:14): [Folded - Ignored] | | ------------------ ------------------ 858| 0| return Z_NEED_DICT; ------------------ | | 179| 0|#define Z_NEED_DICT 2 ------------------ 859| 0| } 860| 0| strm->adler = state->check = adler32(0L, Z_NULL, 0); ------------------ | | 212| 0|#define Z_NULL 0 /* for initializing zalloc, zfree, opaque */ ------------------ 861| 0| state->mode = TYPE; 862| | /* fallthrough */ 863| 318| case TYPE: ------------------ | Branch (863:9): [True: 318, False: 477] ------------------ 864| 318| if (flush == Z_BLOCK || flush == Z_TREES) goto inf_leave; ------------------ | | 173| 636|#define Z_BLOCK 5 ------------------ if (flush == Z_BLOCK || flush == Z_TREES) goto inf_leave; ------------------ | | 174| 318|#define Z_TREES 6 ------------------ | Branch (864:17): [True: 0, False: 318] | Branch (864:37): [True: 0, False: 318] ------------------ 865| | /* fallthrough */ 866| 318| case TYPEDO: ------------------ | Branch (866:9): [True: 0, False: 795] ------------------ 867| 318| if (state->last) { ------------------ | Branch (867:17): [True: 159, False: 159] ------------------ 868| 159| BYTEBITS(); ------------------ | | 539| 159| do { \ | | 540| 159| hold >>= bits & 7; \ | | 541| 159| bits -= bits & 7; \ | | 542| 159| } while (0) | | ------------------ | | | Branch (542:14): [Folded - Ignored] | | ------------------ ------------------ 869| 159| state->mode = CHECK; 870| 159| break; 871| 159| } 872| 159| NEEDBITS(3); ------------------ | | 521| 159| do { \ | | 522| 318| while (bits < (unsigned)(n)) \ | | ------------------ | | | Branch (522:16): [True: 159, False: 159] | | ------------------ | | 523| 159| PULLBYTE(); \ | | ------------------ | | | | 511| 159| do { \ | | | | 512| 159| if (have == 0) goto inf_leave; \ | | | | ------------------ | | | | | Branch (512:13): [True: 0, False: 159] | | | | ------------------ | | | | 513| 159| have--; \ | | | | 514| 159| hold += (unsigned long)(*next++) << bits; \ | | | | 515| 159| bits += 8; \ | | | | 516| 159| } while (0) | | | | ------------------ | | | | | Branch (516:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 524| 159| } while (0) | | ------------------ | | | Branch (524:14): [Folded - Ignored] | | ------------------ ------------------ 873| 159| state->last = BITS(1); ------------------ | | 528| 159| ((unsigned)hold & ((1U << (n)) - 1)) ------------------ 874| 159| DROPBITS(1); ------------------ | | 532| 159| do { \ | | 533| 159| hold >>= (n); \ | | 534| 159| bits -= (unsigned)(n); \ | | 535| 159| } while (0) | | ------------------ | | | Branch (535:14): [Folded - Ignored] | | ------------------ ------------------ 875| 159| switch (BITS(2)) { ------------------ | | 528| 159| ((unsigned)hold & ((1U << (n)) - 1)) | | ------------------ | | | Branch (528:5): [True: 0, False: 159] | | ------------------ ------------------ 876| 0| case 0: /* stored block */ ------------------ | Branch (876:13): [True: 0, False: 159] ------------------ 877| 0| Tracev((stderr, "inflate: stored block%s\n", 878| 0| state->last ? " (last)" : "")); 879| 0| state->mode = STORED; 880| 0| break; 881| 159| case 1: /* fixed block */ ------------------ | Branch (881:13): [True: 159, False: 0] ------------------ 882| 159| fixedtables(state); 883| 159| Tracev((stderr, "inflate: fixed codes block%s\n", 884| 159| state->last ? " (last)" : "")); 885| 159| state->mode = LEN_; /* decode codes */ 886| 159| if (flush == Z_TREES) { ------------------ | | 174| 159|#define Z_TREES 6 ------------------ | Branch (886:21): [True: 0, False: 159] ------------------ 887| 0| DROPBITS(2); ------------------ | | 532| 0| do { \ | | 533| 0| hold >>= (n); \ | | 534| 0| bits -= (unsigned)(n); \ | | 535| 0| } while (0) | | ------------------ | | | Branch (535:14): [Folded - Ignored] | | ------------------ ------------------ 888| 0| goto inf_leave; 889| 0| } 890| 159| break; 891| 159| case 2: /* dynamic block */ ------------------ | Branch (891:13): [True: 0, False: 159] ------------------ 892| 0| Tracev((stderr, "inflate: dynamic codes block%s\n", 893| 0| state->last ? " (last)" : "")); 894| 0| state->mode = TABLE; 895| 0| break; 896| 0| case 3: ------------------ | Branch (896:13): [True: 0, False: 159] ------------------ 897| 0| strm->msg = (char *)"invalid block type"; 898| 0| state->mode = BAD; 899| 159| } 900| 159| DROPBITS(2); ------------------ | | 532| 159| do { \ | | 533| 159| hold >>= (n); \ | | 534| 159| bits -= (unsigned)(n); \ | | 535| 159| } while (0) | | ------------------ | | | Branch (535:14): [Folded - Ignored] | | ------------------ ------------------ 901| 159| break; 902| 0| case STORED: ------------------ | Branch (902:9): [True: 0, False: 795] ------------------ 903| 0| BYTEBITS(); /* go to byte boundary */ ------------------ | | 539| 0| do { \ | | 540| 0| hold >>= bits & 7; \ | | 541| 0| bits -= bits & 7; \ | | 542| 0| } while (0) | | ------------------ | | | Branch (542:14): [Folded - Ignored] | | ------------------ ------------------ 904| 0| NEEDBITS(32); ------------------ | | 521| 0| do { \ | | 522| 0| while (bits < (unsigned)(n)) \ | | ------------------ | | | Branch (522:16): [True: 0, False: 0] | | ------------------ | | 523| 0| PULLBYTE(); \ | | ------------------ | | | | 511| 0| do { \ | | | | 512| 0| if (have == 0) goto inf_leave; \ | | | | ------------------ | | | | | Branch (512:13): [True: 0, False: 0] | | | | ------------------ | | | | 513| 0| have--; \ | | | | 514| 0| hold += (unsigned long)(*next++) << bits; \ | | | | 515| 0| bits += 8; \ | | | | 516| 0| } while (0) | | | | ------------------ | | | | | Branch (516:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 524| 0| } while (0) | | ------------------ | | | Branch (524:14): [Folded - Ignored] | | ------------------ ------------------ 905| 0| if ((hold & 0xffff) != ((hold >> 16) ^ 0xffff)) { ------------------ | Branch (905:17): [True: 0, False: 0] ------------------ 906| 0| strm->msg = (char *)"invalid stored block lengths"; 907| 0| state->mode = BAD; 908| 0| break; 909| 0| } 910| 0| state->length = (unsigned)hold & 0xffff; 911| 0| Tracev((stderr, "inflate: stored length %u\n", 912| 0| state->length)); 913| 0| INITBITS(); ------------------ | | 503| 0| do { \ | | 504| 0| hold = 0; \ | | 505| 0| bits = 0; \ | | 506| 0| } while (0) | | ------------------ | | | Branch (506:14): [Folded - Ignored] | | ------------------ ------------------ 914| 0| state->mode = COPY_; 915| 0| if (flush == Z_TREES) goto inf_leave; ------------------ | | 174| 0|#define Z_TREES 6 ------------------ | Branch (915:17): [True: 0, False: 0] ------------------ 916| | /* fallthrough */ 917| 0| case COPY_: ------------------ | Branch (917:9): [True: 0, False: 795] ------------------ 918| 0| state->mode = COPY; 919| | /* fallthrough */ 920| 0| case COPY: ------------------ | Branch (920:9): [True: 0, False: 795] ------------------ 921| 0| copy = state->length; 922| 0| if (copy) { ------------------ | Branch (922:17): [True: 0, False: 0] ------------------ 923| 0| if (copy > have) copy = have; ------------------ | Branch (923:21): [True: 0, False: 0] ------------------ 924| 0| if (copy > left) copy = left; ------------------ | Branch (924:21): [True: 0, False: 0] ------------------ 925| 0| if (copy == 0) goto inf_leave; ------------------ | Branch (925:21): [True: 0, False: 0] ------------------ 926| 0| zmemcpy(put, next, copy); ------------------ | | 245| 0|# define zmemcpy memcpy ------------------ 927| 0| have -= copy; 928| 0| next += copy; 929| 0| left -= copy; 930| 0| put += copy; 931| 0| state->length -= copy; 932| 0| break; 933| 0| } 934| 0| Tracev((stderr, "inflate: stored end\n")); 935| 0| state->mode = TYPE; 936| 0| break; 937| 0| case TABLE: ------------------ | Branch (937:9): [True: 0, False: 795] ------------------ 938| 0| NEEDBITS(14); ------------------ | | 521| 0| do { \ | | 522| 0| while (bits < (unsigned)(n)) \ | | ------------------ | | | Branch (522:16): [True: 0, False: 0] | | ------------------ | | 523| 0| PULLBYTE(); \ | | ------------------ | | | | 511| 0| do { \ | | | | 512| 0| if (have == 0) goto inf_leave; \ | | | | ------------------ | | | | | Branch (512:13): [True: 0, False: 0] | | | | ------------------ | | | | 513| 0| have--; \ | | | | 514| 0| hold += (unsigned long)(*next++) << bits; \ | | | | 515| 0| bits += 8; \ | | | | 516| 0| } while (0) | | | | ------------------ | | | | | Branch (516:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 524| 0| } while (0) | | ------------------ | | | Branch (524:14): [Folded - Ignored] | | ------------------ ------------------ 939| 0| state->nlen = BITS(5) + 257; ------------------ | | 528| 0| ((unsigned)hold & ((1U << (n)) - 1)) ------------------ 940| 0| DROPBITS(5); ------------------ | | 532| 0| do { \ | | 533| 0| hold >>= (n); \ | | 534| 0| bits -= (unsigned)(n); \ | | 535| 0| } while (0) | | ------------------ | | | Branch (535:14): [Folded - Ignored] | | ------------------ ------------------ 941| 0| state->ndist = BITS(5) + 1; ------------------ | | 528| 0| ((unsigned)hold & ((1U << (n)) - 1)) ------------------ 942| 0| DROPBITS(5); ------------------ | | 532| 0| do { \ | | 533| 0| hold >>= (n); \ | | 534| 0| bits -= (unsigned)(n); \ | | 535| 0| } while (0) | | ------------------ | | | Branch (535:14): [Folded - Ignored] | | ------------------ ------------------ 943| 0| state->ncode = BITS(4) + 4; ------------------ | | 528| 0| ((unsigned)hold & ((1U << (n)) - 1)) ------------------ 944| 0| DROPBITS(4); ------------------ | | 532| 0| do { \ | | 533| 0| hold >>= (n); \ | | 534| 0| bits -= (unsigned)(n); \ | | 535| 0| } while (0) | | ------------------ | | | Branch (535:14): [Folded - Ignored] | | ------------------ ------------------ 945| 0|#ifndef PKZIP_BUG_WORKAROUND 946| 0| if (state->nlen > 286 || state->ndist > 30) { ------------------ | Branch (946:17): [True: 0, False: 0] | Branch (946:38): [True: 0, False: 0] ------------------ 947| 0| strm->msg = (char *)"too many length or distance symbols"; 948| 0| state->mode = BAD; 949| 0| break; 950| 0| } 951| 0|#endif 952| 0| Tracev((stderr, "inflate: table sizes ok\n")); 953| 0| state->have = 0; 954| 0| state->mode = LENLENS; 955| | /* fallthrough */ 956| 0| case LENLENS: ------------------ | Branch (956:9): [True: 0, False: 795] ------------------ 957| 0| while (state->have < state->ncode) { ------------------ | Branch (957:20): [True: 0, False: 0] ------------------ 958| 0| NEEDBITS(3); ------------------ | | 521| 0| do { \ | | 522| 0| while (bits < (unsigned)(n)) \ | | ------------------ | | | Branch (522:16): [True: 0, False: 0] | | ------------------ | | 523| 0| PULLBYTE(); \ | | ------------------ | | | | 511| 0| do { \ | | | | 512| 0| if (have == 0) goto inf_leave; \ | | | | ------------------ | | | | | Branch (512:13): [True: 0, False: 0] | | | | ------------------ | | | | 513| 0| have--; \ | | | | 514| 0| hold += (unsigned long)(*next++) << bits; \ | | | | 515| 0| bits += 8; \ | | | | 516| 0| } while (0) | | | | ------------------ | | | | | Branch (516:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 524| 0| } while (0) | | ------------------ | | | Branch (524:14): [Folded - Ignored] | | ------------------ ------------------ 959| 0| state->lens[order[state->have++]] = (unsigned short)BITS(3); ------------------ | | 528| 0| ((unsigned)hold & ((1U << (n)) - 1)) ------------------ 960| 0| DROPBITS(3); ------------------ | | 532| 0| do { \ | | 533| 0| hold >>= (n); \ | | 534| 0| bits -= (unsigned)(n); \ | | 535| 0| } while (0) | | ------------------ | | | Branch (535:14): [Folded - Ignored] | | ------------------ ------------------ 961| 0| } 962| 0| while (state->have < 19) ------------------ | Branch (962:20): [True: 0, False: 0] ------------------ 963| 0| state->lens[order[state->have++]] = 0; 964| 0| state->next = state->codes; 965| 0| state->lencode = (const code FAR *)(state->next); 966| 0| state->lenbits = 7; 967| 0| ret = inflate_table(CODES, state->lens, 19, &(state->next), 968| 0| &(state->lenbits), state->work); 969| 0| if (ret) { ------------------ | Branch (969:17): [True: 0, False: 0] ------------------ 970| 0| strm->msg = (char *)"invalid code lengths set"; 971| 0| state->mode = BAD; 972| 0| break; 973| 0| } 974| 0| Tracev((stderr, "inflate: code lengths ok\n")); 975| 0| state->have = 0; 976| 0| state->mode = CODELENS; 977| | /* fallthrough */ 978| 0| case CODELENS: ------------------ | Branch (978:9): [True: 0, False: 795] ------------------ 979| 0| while (state->have < state->nlen + state->ndist) { ------------------ | Branch (979:20): [True: 0, False: 0] ------------------ 980| 0| for (;;) { 981| 0| here = state->lencode[BITS(state->lenbits)]; ------------------ | | 528| 0| ((unsigned)hold & ((1U << (n)) - 1)) ------------------ 982| 0| if ((unsigned)(here.bits) <= bits) break; ------------------ | Branch (982:25): [True: 0, False: 0] ------------------ 983| 0| PULLBYTE(); ------------------ | | 511| 0| do { \ | | 512| 0| if (have == 0) goto inf_leave; \ | | ------------------ | | | Branch (512:13): [True: 0, False: 0] | | ------------------ | | 513| 0| have--; \ | | 514| 0| hold += (unsigned long)(*next++) << bits; \ | | 515| 0| bits += 8; \ | | 516| 0| } while (0) | | ------------------ | | | Branch (516:14): [Folded - Ignored] | | ------------------ ------------------ 984| 0| } 985| 0| if (here.val < 16) { ------------------ | Branch (985:21): [True: 0, False: 0] ------------------ 986| 0| DROPBITS(here.bits); ------------------ | | 532| 0| do { \ | | 533| 0| hold >>= (n); \ | | 534| 0| bits -= (unsigned)(n); \ | | 535| 0| } while (0) | | ------------------ | | | Branch (535:14): [Folded - Ignored] | | ------------------ ------------------ 987| 0| state->lens[state->have++] = here.val; 988| 0| } 989| 0| else { 990| 0| if (here.val == 16) { ------------------ | Branch (990:25): [True: 0, False: 0] ------------------ 991| 0| NEEDBITS(here.bits + 2); ------------------ | | 521| 0| do { \ | | 522| 0| while (bits < (unsigned)(n)) \ | | ------------------ | | | Branch (522:16): [True: 0, False: 0] | | ------------------ | | 523| 0| PULLBYTE(); \ | | ------------------ | | | | 511| 0| do { \ | | | | 512| 0| if (have == 0) goto inf_leave; \ | | | | ------------------ | | | | | Branch (512:13): [True: 0, False: 0] | | | | ------------------ | | | | 513| 0| have--; \ | | | | 514| 0| hold += (unsigned long)(*next++) << bits; \ | | | | 515| 0| bits += 8; \ | | | | 516| 0| } while (0) | | | | ------------------ | | | | | Branch (516:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 524| 0| } while (0) | | ------------------ | | | Branch (524:14): [Folded - Ignored] | | ------------------ ------------------ 992| 0| DROPBITS(here.bits); ------------------ | | 532| 0| do { \ | | 533| 0| hold >>= (n); \ | | 534| 0| bits -= (unsigned)(n); \ | | 535| 0| } while (0) | | ------------------ | | | Branch (535:14): [Folded - Ignored] | | ------------------ ------------------ 993| 0| if (state->have == 0) { ------------------ | Branch (993:29): [True: 0, False: 0] ------------------ 994| 0| strm->msg = (char *)"invalid bit length repeat"; 995| 0| state->mode = BAD; 996| 0| break; 997| 0| } 998| 0| len = state->lens[state->have - 1]; 999| 0| copy = 3 + BITS(2); ------------------ | | 528| 0| ((unsigned)hold & ((1U << (n)) - 1)) ------------------ 1000| 0| DROPBITS(2); ------------------ | | 532| 0| do { \ | | 533| 0| hold >>= (n); \ | | 534| 0| bits -= (unsigned)(n); \ | | 535| 0| } while (0) | | ------------------ | | | Branch (535:14): [Folded - Ignored] | | ------------------ ------------------ 1001| 0| } 1002| 0| else if (here.val == 17) { ------------------ | Branch (1002:30): [True: 0, False: 0] ------------------ 1003| 0| NEEDBITS(here.bits + 3); ------------------ | | 521| 0| do { \ | | 522| 0| while (bits < (unsigned)(n)) \ | | ------------------ | | | Branch (522:16): [True: 0, False: 0] | | ------------------ | | 523| 0| PULLBYTE(); \ | | ------------------ | | | | 511| 0| do { \ | | | | 512| 0| if (have == 0) goto inf_leave; \ | | | | ------------------ | | | | | Branch (512:13): [True: 0, False: 0] | | | | ------------------ | | | | 513| 0| have--; \ | | | | 514| 0| hold += (unsigned long)(*next++) << bits; \ | | | | 515| 0| bits += 8; \ | | | | 516| 0| } while (0) | | | | ------------------ | | | | | Branch (516:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 524| 0| } while (0) | | ------------------ | | | Branch (524:14): [Folded - Ignored] | | ------------------ ------------------ 1004| 0| DROPBITS(here.bits); ------------------ | | 532| 0| do { \ | | 533| 0| hold >>= (n); \ | | 534| 0| bits -= (unsigned)(n); \ | | 535| 0| } while (0) | | ------------------ | | | Branch (535:14): [Folded - Ignored] | | ------------------ ------------------ 1005| 0| len = 0; 1006| 0| copy = 3 + BITS(3); ------------------ | | 528| 0| ((unsigned)hold & ((1U << (n)) - 1)) ------------------ 1007| 0| DROPBITS(3); ------------------ | | 532| 0| do { \ | | 533| 0| hold >>= (n); \ | | 534| 0| bits -= (unsigned)(n); \ | | 535| 0| } while (0) | | ------------------ | | | Branch (535:14): [Folded - Ignored] | | ------------------ ------------------ 1008| 0| } 1009| 0| else { 1010| 0| NEEDBITS(here.bits + 7); ------------------ | | 521| 0| do { \ | | 522| 0| while (bits < (unsigned)(n)) \ | | ------------------ | | | Branch (522:16): [True: 0, False: 0] | | ------------------ | | 523| 0| PULLBYTE(); \ | | ------------------ | | | | 511| 0| do { \ | | | | 512| 0| if (have == 0) goto inf_leave; \ | | | | ------------------ | | | | | Branch (512:13): [True: 0, False: 0] | | | | ------------------ | | | | 513| 0| have--; \ | | | | 514| 0| hold += (unsigned long)(*next++) << bits; \ | | | | 515| 0| bits += 8; \ | | | | 516| 0| } while (0) | | | | ------------------ | | | | | Branch (516:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 524| 0| } while (0) | | ------------------ | | | Branch (524:14): [Folded - Ignored] | | ------------------ ------------------ 1011| 0| DROPBITS(here.bits); ------------------ | | 532| 0| do { \ | | 533| 0| hold >>= (n); \ | | 534| 0| bits -= (unsigned)(n); \ | | 535| 0| } while (0) | | ------------------ | | | Branch (535:14): [Folded - Ignored] | | ------------------ ------------------ 1012| 0| len = 0; 1013| 0| copy = 11 + BITS(7); ------------------ | | 528| 0| ((unsigned)hold & ((1U << (n)) - 1)) ------------------ 1014| 0| DROPBITS(7); ------------------ | | 532| 0| do { \ | | 533| 0| hold >>= (n); \ | | 534| 0| bits -= (unsigned)(n); \ | | 535| 0| } while (0) | | ------------------ | | | Branch (535:14): [Folded - Ignored] | | ------------------ ------------------ 1015| 0| } 1016| 0| if (state->have + copy > state->nlen + state->ndist) { ------------------ | Branch (1016:25): [True: 0, False: 0] ------------------ 1017| 0| strm->msg = (char *)"invalid bit length repeat"; 1018| 0| state->mode = BAD; 1019| 0| break; 1020| 0| } 1021| 0| while (copy--) ------------------ | Branch (1021:28): [True: 0, False: 0] ------------------ 1022| 0| state->lens[state->have++] = (unsigned short)len; 1023| 0| } 1024| 0| } 1025| | 1026| | /* handle error breaks in while */ 1027| 0| if (state->mode == BAD) break; ------------------ | Branch (1027:17): [True: 0, False: 0] ------------------ 1028| | 1029| | /* check for end-of-block code (better have one) */ 1030| 0| if (state->lens[256] == 0) { ------------------ | Branch (1030:17): [True: 0, False: 0] ------------------ 1031| 0| strm->msg = (char *)"invalid code -- missing end-of-block"; 1032| 0| state->mode = BAD; 1033| 0| break; 1034| 0| } 1035| | 1036| | /* build code tables -- note: do not change the lenbits or distbits 1037| | values here (10 and 9) without reading the comments in inftrees.h 1038| | concerning the ENOUGH constants, which depend on those values */ 1039| 0| state->next = state->codes; 1040| 0| state->lencode = (const code FAR *)(state->next); 1041| 0| state->lenbits = 10; 1042| 0| ret = inflate_table(LENS, state->lens, state->nlen, &(state->next), 1043| 0| &(state->lenbits), state->work); 1044| 0| if (ret) { ------------------ | Branch (1044:17): [True: 0, False: 0] ------------------ 1045| 0| strm->msg = (char *)"invalid literal/lengths set"; 1046| 0| state->mode = BAD; 1047| 0| break; 1048| 0| } 1049| 0| state->distcode = (const code FAR *)(state->next); 1050| 0| state->distbits = 9; 1051| 0| ret = inflate_table(DISTS, state->lens + state->nlen, state->ndist, 1052| 0| &(state->next), &(state->distbits), state->work); 1053| 0| if (ret) { ------------------ | Branch (1053:17): [True: 0, False: 0] ------------------ 1054| 0| strm->msg = (char *)"invalid distances set"; 1055| 0| state->mode = BAD; 1056| 0| break; 1057| 0| } 1058| 0| Tracev((stderr, "inflate: codes ok\n")); 1059| 0| state->mode = LEN_; 1060| 0| if (flush == Z_TREES) goto inf_leave; ------------------ | | 174| 0|#define Z_TREES 6 ------------------ | Branch (1060:17): [True: 0, False: 0] ------------------ 1061| | /* fallthrough */ 1062| 159| case LEN_: ------------------ | Branch (1062:9): [True: 159, False: 636] ------------------ 1063| 159| state->mode = LEN; 1064| | /* fallthrough */ 1065| 159| case LEN: ------------------ | Branch (1065:9): [True: 0, False: 795] ------------------ 1066| 159| if (have >= INFLATE_FAST_MIN_INPUT && ------------------ | | 17| 318|#define INFLATE_FAST_MIN_INPUT 6 ------------------ | Branch (1066:17): [True: 159, False: 0] ------------------ 1067| 159| left >= INFLATE_FAST_MIN_OUTPUT) { ------------------ | | 24| 159|#define INFLATE_FAST_MIN_OUTPUT 258 ------------------ | Branch (1067:17): [True: 159, False: 0] ------------------ 1068| 159| RESTORE(); ------------------ | | 492| 159| do { \ | | 493| 159| strm->next_out = put; \ | | 494| 159| strm->avail_out = left; \ | | 495| 159| strm->next_in = next; \ | | 496| 159| strm->avail_in = have; \ | | 497| 159| state->hold = hold; \ | | 498| 159| state->bits = bits; \ | | 499| 159| } while (0) | | ------------------ | | | Branch (499:14): [Folded - Ignored] | | ------------------ ------------------ 1069| 159| inflate_fast(strm, out); 1070| 159| LOAD(); ------------------ | | 481| 159| do { \ | | 482| 159| put = strm->next_out; \ | | 483| 159| left = strm->avail_out; \ | | 484| 159| next = strm->next_in; \ | | 485| 159| have = strm->avail_in; \ | | 486| 159| hold = state->hold; \ | | 487| 159| bits = state->bits; \ | | 488| 159| } while (0) | | ------------------ | | | Branch (488:14): [Folded - Ignored] | | ------------------ ------------------ 1071| 159| if (state->mode == TYPE) ------------------ | Branch (1071:21): [True: 159, False: 0] ------------------ 1072| 159| state->back = -1; 1073| 159| break; 1074| 159| } 1075| 0| state->back = 0; 1076| 0| for (;;) { 1077| 0| here = state->lencode[BITS(state->lenbits)]; ------------------ | | 528| 0| ((unsigned)hold & ((1U << (n)) - 1)) ------------------ 1078| 0| if ((unsigned)(here.bits) <= bits) break; ------------------ | Branch (1078:21): [True: 0, False: 0] ------------------ 1079| 0| PULLBYTE(); ------------------ | | 511| 0| do { \ | | 512| 0| if (have == 0) goto inf_leave; \ | | ------------------ | | | Branch (512:13): [True: 0, False: 0] | | ------------------ | | 513| 0| have--; \ | | 514| 0| hold += (unsigned long)(*next++) << bits; \ | | 515| 0| bits += 8; \ | | 516| 0| } while (0) | | ------------------ | | | Branch (516:14): [Folded - Ignored] | | ------------------ ------------------ 1080| 0| } 1081| 0| if (here.op && (here.op & 0xf0) == 0) { ------------------ | Branch (1081:17): [True: 0, False: 0] | Branch (1081:28): [True: 0, False: 0] ------------------ 1082| 0| last = here; 1083| 0| for (;;) { 1084| 0| here = state->lencode[last.val + 1085| 0| (BITS(last.bits + last.op) >> last.bits)]; ------------------ | | 528| 0| ((unsigned)hold & ((1U << (n)) - 1)) ------------------ 1086| 0| if ((unsigned)(last.bits + here.bits) <= bits) break; ------------------ | Branch (1086:25): [True: 0, False: 0] ------------------ 1087| 0| PULLBYTE(); ------------------ | | 511| 0| do { \ | | 512| 0| if (have == 0) goto inf_leave; \ | | ------------------ | | | Branch (512:13): [True: 0, False: 0] | | ------------------ | | 513| 0| have--; \ | | 514| 0| hold += (unsigned long)(*next++) << bits; \ | | 515| 0| bits += 8; \ | | 516| 0| } while (0) | | ------------------ | | | Branch (516:14): [Folded - Ignored] | | ------------------ ------------------ 1088| 0| } 1089| 0| DROPBITS(last.bits); ------------------ | | 532| 0| do { \ | | 533| 0| hold >>= (n); \ | | 534| 0| bits -= (unsigned)(n); \ | | 535| 0| } while (0) | | ------------------ | | | Branch (535:14): [Folded - Ignored] | | ------------------ ------------------ 1090| 0| state->back += last.bits; 1091| 0| } 1092| 0| DROPBITS(here.bits); ------------------ | | 532| 0| do { \ | | 533| 0| hold >>= (n); \ | | 534| 0| bits -= (unsigned)(n); \ | | 535| 0| } while (0) | | ------------------ | | | Branch (535:14): [Folded - Ignored] | | ------------------ ------------------ 1093| 0| state->back += here.bits; 1094| 0| state->length = (unsigned)here.val; 1095| 0| if ((int)(here.op) == 0) { ------------------ | Branch (1095:17): [True: 0, False: 0] ------------------ 1096| 0| Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ? 1097| 0| "inflate: literal '%c'\n" : 1098| 0| "inflate: literal 0x%02x\n", here.val)); 1099| 0| state->mode = LIT; 1100| 0| break; 1101| 0| } 1102| 0| if (here.op & 32) { ------------------ | Branch (1102:17): [True: 0, False: 0] ------------------ 1103| 0| Tracevv((stderr, "inflate: end of block\n")); 1104| 0| state->back = -1; 1105| 0| state->mode = TYPE; 1106| 0| break; 1107| 0| } 1108| 0| if (here.op & 64) { ------------------ | Branch (1108:17): [True: 0, False: 0] ------------------ 1109| 0| strm->msg = (char *)"invalid literal/length code"; 1110| 0| state->mode = BAD; 1111| 0| break; 1112| 0| } 1113| 0| state->extra = (unsigned)(here.op) & 15; 1114| 0| state->mode = LENEXT; 1115| | /* fallthrough */ 1116| 0| case LENEXT: ------------------ | Branch (1116:9): [True: 0, False: 795] ------------------ 1117| 0| if (state->extra) { ------------------ | Branch (1117:17): [True: 0, False: 0] ------------------ 1118| 0| NEEDBITS(state->extra); ------------------ | | 521| 0| do { \ | | 522| 0| while (bits < (unsigned)(n)) \ | | ------------------ | | | Branch (522:16): [True: 0, False: 0] | | ------------------ | | 523| 0| PULLBYTE(); \ | | ------------------ | | | | 511| 0| do { \ | | | | 512| 0| if (have == 0) goto inf_leave; \ | | | | ------------------ | | | | | Branch (512:13): [True: 0, False: 0] | | | | ------------------ | | | | 513| 0| have--; \ | | | | 514| 0| hold += (unsigned long)(*next++) << bits; \ | | | | 515| 0| bits += 8; \ | | | | 516| 0| } while (0) | | | | ------------------ | | | | | Branch (516:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 524| 0| } while (0) | | ------------------ | | | Branch (524:14): [Folded - Ignored] | | ------------------ ------------------ 1119| 0| state->length += BITS(state->extra); ------------------ | | 528| 0| ((unsigned)hold & ((1U << (n)) - 1)) ------------------ 1120| 0| DROPBITS(state->extra); ------------------ | | 532| 0| do { \ | | 533| 0| hold >>= (n); \ | | 534| 0| bits -= (unsigned)(n); \ | | 535| 0| } while (0) | | ------------------ | | | Branch (535:14): [Folded - Ignored] | | ------------------ ------------------ 1121| 0| state->back += state->extra; 1122| 0| } 1123| 0| Tracevv((stderr, "inflate: length %u\n", state->length)); 1124| 0| state->was = state->length; 1125| 0| state->mode = DIST; 1126| | /* fallthrough */ 1127| 0| case DIST: ------------------ | Branch (1127:9): [True: 0, False: 795] ------------------ 1128| 0| for (;;) { 1129| 0| here = state->distcode[BITS(state->distbits)]; ------------------ | | 528| 0| ((unsigned)hold & ((1U << (n)) - 1)) ------------------ 1130| 0| if ((unsigned)(here.bits) <= bits) break; ------------------ | Branch (1130:21): [True: 0, False: 0] ------------------ 1131| 0| PULLBYTE(); ------------------ | | 511| 0| do { \ | | 512| 0| if (have == 0) goto inf_leave; \ | | ------------------ | | | Branch (512:13): [True: 0, False: 0] | | ------------------ | | 513| 0| have--; \ | | 514| 0| hold += (unsigned long)(*next++) << bits; \ | | 515| 0| bits += 8; \ | | 516| 0| } while (0) | | ------------------ | | | Branch (516:14): [Folded - Ignored] | | ------------------ ------------------ 1132| 0| } 1133| 0| if ((here.op & 0xf0) == 0) { ------------------ | Branch (1133:17): [True: 0, False: 0] ------------------ 1134| 0| last = here; 1135| 0| for (;;) { 1136| 0| here = state->distcode[last.val + 1137| 0| (BITS(last.bits + last.op) >> last.bits)]; ------------------ | | 528| 0| ((unsigned)hold & ((1U << (n)) - 1)) ------------------ 1138| 0| if ((unsigned)(last.bits + here.bits) <= bits) break; ------------------ | Branch (1138:25): [True: 0, False: 0] ------------------ 1139| 0| PULLBYTE(); ------------------ | | 511| 0| do { \ | | 512| 0| if (have == 0) goto inf_leave; \ | | ------------------ | | | Branch (512:13): [True: 0, False: 0] | | ------------------ | | 513| 0| have--; \ | | 514| 0| hold += (unsigned long)(*next++) << bits; \ | | 515| 0| bits += 8; \ | | 516| 0| } while (0) | | ------------------ | | | Branch (516:14): [Folded - Ignored] | | ------------------ ------------------ 1140| 0| } 1141| 0| DROPBITS(last.bits); ------------------ | | 532| 0| do { \ | | 533| 0| hold >>= (n); \ | | 534| 0| bits -= (unsigned)(n); \ | | 535| 0| } while (0) | | ------------------ | | | Branch (535:14): [Folded - Ignored] | | ------------------ ------------------ 1142| 0| state->back += last.bits; 1143| 0| } 1144| 0| DROPBITS(here.bits); ------------------ | | 532| 0| do { \ | | 533| 0| hold >>= (n); \ | | 534| 0| bits -= (unsigned)(n); \ | | 535| 0| } while (0) | | ------------------ | | | Branch (535:14): [Folded - Ignored] | | ------------------ ------------------ 1145| 0| state->back += here.bits; 1146| 0| if (here.op & 64) { ------------------ | Branch (1146:17): [True: 0, False: 0] ------------------ 1147| 0| strm->msg = (char *)"invalid distance code"; 1148| 0| state->mode = BAD; 1149| 0| break; 1150| 0| } 1151| 0| state->offset = (unsigned)here.val; 1152| 0| state->extra = (unsigned)(here.op) & 15; 1153| 0| state->mode = DISTEXT; 1154| | /* fallthrough */ 1155| 0| case DISTEXT: ------------------ | Branch (1155:9): [True: 0, False: 795] ------------------ 1156| 0| if (state->extra) { ------------------ | Branch (1156:17): [True: 0, False: 0] ------------------ 1157| 0| NEEDBITS(state->extra); ------------------ | | 521| 0| do { \ | | 522| 0| while (bits < (unsigned)(n)) \ | | ------------------ | | | Branch (522:16): [True: 0, False: 0] | | ------------------ | | 523| 0| PULLBYTE(); \ | | ------------------ | | | | 511| 0| do { \ | | | | 512| 0| if (have == 0) goto inf_leave; \ | | | | ------------------ | | | | | Branch (512:13): [True: 0, False: 0] | | | | ------------------ | | | | 513| 0| have--; \ | | | | 514| 0| hold += (unsigned long)(*next++) << bits; \ | | | | 515| 0| bits += 8; \ | | | | 516| 0| } while (0) | | | | ------------------ | | | | | Branch (516:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 524| 0| } while (0) | | ------------------ | | | Branch (524:14): [Folded - Ignored] | | ------------------ ------------------ 1158| 0| state->offset += BITS(state->extra); ------------------ | | 528| 0| ((unsigned)hold & ((1U << (n)) - 1)) ------------------ 1159| 0| DROPBITS(state->extra); ------------------ | | 532| 0| do { \ | | 533| 0| hold >>= (n); \ | | 534| 0| bits -= (unsigned)(n); \ | | 535| 0| } while (0) | | ------------------ | | | Branch (535:14): [Folded - Ignored] | | ------------------ ------------------ 1160| 0| state->back += state->extra; 1161| 0| } 1162| |#ifdef INFLATE_STRICT 1163| | if (state->offset > state->dmax) { 1164| | strm->msg = (char *)"invalid distance too far back"; 1165| | state->mode = BAD; 1166| | break; 1167| | } 1168| |#endif 1169| 0| Tracevv((stderr, "inflate: distance %u\n", state->offset)); 1170| 0| state->mode = MATCH; 1171| | /* fallthrough */ 1172| 0| case MATCH: ------------------ | Branch (1172:9): [True: 0, False: 795] ------------------ 1173| 0| if (left == 0) goto inf_leave; ------------------ | Branch (1173:17): [True: 0, False: 0] ------------------ 1174| 0| copy = out - left; 1175| 0| if (state->offset > copy) { /* copy from window */ ------------------ | Branch (1175:17): [True: 0, False: 0] ------------------ 1176| 0| copy = state->offset - copy; 1177| 0| if (copy > state->whave) { ------------------ | Branch (1177:21): [True: 0, False: 0] ------------------ 1178| 0| if (state->sane) { ------------------ | Branch (1178:25): [True: 0, False: 0] ------------------ 1179| 0| strm->msg = (char *)"invalid distance too far back"; 1180| 0| state->mode = BAD; 1181| 0| break; 1182| 0| } 1183| |#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR 1184| | Trace((stderr, "inflate.c too far\n")); 1185| | copy -= state->whave; 1186| | if (copy > state->length) copy = state->length; 1187| | if (copy > left) copy = left; 1188| | left -= copy; 1189| | state->length -= copy; 1190| | do { 1191| | *put++ = 0; 1192| | } while (--copy); 1193| | if (state->length == 0) state->mode = LEN; 1194| | break; 1195| |#endif 1196| 0| } 1197| 0| if (copy > state->wnext) { ------------------ | Branch (1197:21): [True: 0, False: 0] ------------------ 1198| 0| copy -= state->wnext; 1199| 0| from = state->window + (state->wsize - copy); 1200| 0| } 1201| 0| else 1202| 0| from = state->window + (state->wnext - copy); 1203| 0| if (copy > state->length) copy = state->length; ------------------ | Branch (1203:21): [True: 0, False: 0] ------------------ 1204| 0| } 1205| 0| else { /* copy from output */ 1206| 0| from = put - state->offset; 1207| 0| copy = state->length; 1208| 0| } 1209| 0| if (copy > left) copy = left; ------------------ | Branch (1209:17): [True: 0, False: 0] ------------------ 1210| 0| left -= copy; 1211| 0| state->length -= copy; 1212| 0| do { 1213| 0| *put++ = *from++; 1214| 0| } while (--copy); ------------------ | Branch (1214:22): [True: 0, False: 0] ------------------ 1215| 0| if (state->length == 0) state->mode = LEN; ------------------ | Branch (1215:17): [True: 0, False: 0] ------------------ 1216| 0| break; 1217| 0| case LIT: ------------------ | Branch (1217:9): [True: 0, False: 795] ------------------ 1218| 0| if (left == 0) goto inf_leave; ------------------ | Branch (1218:17): [True: 0, False: 0] ------------------ 1219| 0| *put++ = (unsigned char)(state->length); 1220| 0| left--; 1221| 0| state->mode = LEN; 1222| 0| break; 1223| 159| case CHECK: ------------------ | Branch (1223:9): [True: 159, False: 636] ------------------ 1224| 159| if (state->wrap) { ------------------ | Branch (1224:17): [True: 159, False: 0] ------------------ 1225| 159| NEEDBITS(32); ------------------ | | 521| 159| do { \ | | 522| 795| while (bits < (unsigned)(n)) \ | | ------------------ | | | Branch (522:16): [True: 636, False: 159] | | ------------------ | | 523| 636| PULLBYTE(); \ | | ------------------ | | | | 511| 636| do { \ | | | | 512| 636| if (have == 0) goto inf_leave; \ | | | | ------------------ | | | | | Branch (512:13): [True: 0, False: 636] | | | | ------------------ | | | | 513| 636| have--; \ | | | | 514| 636| hold += (unsigned long)(*next++) << bits; \ | | | | 515| 636| bits += 8; \ | | | | 516| 636| } while (0) | | | | ------------------ | | | | | Branch (516:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 524| 159| } while (0) | | ------------------ | | | Branch (524:14): [Folded - Ignored] | | ------------------ ------------------ 1226| 159| out -= left; 1227| 159| strm->total_out += out; 1228| 159| state->total += out; 1229| 159| if ((state->wrap & 4) && out) ------------------ | Branch (1229:21): [True: 159, False: 0] | Branch (1229:42): [True: 159, False: 0] ------------------ 1230| 159| strm->adler = state->check = 1231| 159| UPDATE_CHECK(state->check, put - out, out); ------------------ | | 455| 159| (state->flags ? crc32(check, buf, len) : adler32(check, buf, len)) | | ------------------ | | | Branch (455:6): [True: 0, False: 159] | | ------------------ ------------------ 1232| 159| out = left; 1233| 159| if ((state->wrap & 4) && ( ------------------ | Branch (1233:21): [True: 159, False: 0] | Branch (1233:42): [True: 0, False: 159] ------------------ 1234| 159|#ifdef GUNZIP 1235| 159| state->flags ? hold : ------------------ | Branch (1235:22): [True: 0, False: 159] ------------------ 1236| 159|#endif 1237| 159| ZSWAP32(hold)) != state->check) { ------------------ | | 287| 159|#define ZSWAP32(q) ((((q) >> 24) & 0xff) + (((q) >> 8) & 0xff00) + \ | | 288| 159| (((q) & 0xff00) << 8) + (((q) & 0xff) << 24)) ------------------ 1238| 0| strm->msg = (char *)"incorrect data check"; 1239| 0| state->mode = BAD; 1240| 0| break; 1241| 0| } 1242| 159| INITBITS(); ------------------ | | 503| 159| do { \ | | 504| 159| hold = 0; \ | | 505| 159| bits = 0; \ | | 506| 159| } while (0) | | ------------------ | | | Branch (506:14): [Folded - Ignored] | | ------------------ ------------------ 1243| 159| Tracev((stderr, "inflate: check matches trailer\n")); 1244| 159| } 1245| 159|#ifdef GUNZIP 1246| 159| state->mode = LENGTH; 1247| | /* fallthrough */ 1248| 159| case LENGTH: ------------------ | Branch (1248:9): [True: 0, False: 795] ------------------ 1249| 159| if (state->wrap && state->flags) { ------------------ | Branch (1249:17): [True: 159, False: 0] | Branch (1249:32): [True: 0, False: 159] ------------------ 1250| 0| NEEDBITS(32); ------------------ | | 521| 0| do { \ | | 522| 0| while (bits < (unsigned)(n)) \ | | ------------------ | | | Branch (522:16): [True: 0, False: 0] | | ------------------ | | 523| 0| PULLBYTE(); \ | | ------------------ | | | | 511| 0| do { \ | | | | 512| 0| if (have == 0) goto inf_leave; \ | | | | ------------------ | | | | | Branch (512:13): [True: 0, False: 0] | | | | ------------------ | | | | 513| 0| have--; \ | | | | 514| 0| hold += (unsigned long)(*next++) << bits; \ | | | | 515| 0| bits += 8; \ | | | | 516| 0| } while (0) | | | | ------------------ | | | | | Branch (516:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 524| 0| } while (0) | | ------------------ | | | Branch (524:14): [Folded - Ignored] | | ------------------ ------------------ 1251| 0| if ((state->wrap & 4) && hold != (state->total & 0xffffffff)) { ------------------ | Branch (1251:21): [True: 0, False: 0] | Branch (1251:42): [True: 0, False: 0] ------------------ 1252| 0| strm->msg = (char *)"incorrect length check"; 1253| 0| state->mode = BAD; 1254| 0| break; 1255| 0| } 1256| 0| INITBITS(); ------------------ | | 503| 0| do { \ | | 504| 0| hold = 0; \ | | 505| 0| bits = 0; \ | | 506| 0| } while (0) | | ------------------ | | | Branch (506:14): [Folded - Ignored] | | ------------------ ------------------ 1257| 0| Tracev((stderr, "inflate: length matches trailer\n")); 1258| 0| } 1259| 159|#endif 1260| 159| state->mode = DONE; 1261| | /* fallthrough */ 1262| 159| case DONE: ------------------ | Branch (1262:9): [True: 0, False: 795] ------------------ 1263| 159| ret = Z_STREAM_END; ------------------ | | 178| 159|#define Z_STREAM_END 1 ------------------ 1264| 159| goto inf_leave; 1265| 0| case BAD: ------------------ | Branch (1265:9): [True: 0, False: 795] ------------------ 1266| 0| ret = Z_DATA_ERROR; ------------------ | | 182| 0|#define Z_DATA_ERROR (-3) ------------------ 1267| 0| goto inf_leave; 1268| 0| case MEM: ------------------ | Branch (1268:9): [True: 0, False: 795] ------------------ 1269| 0| return Z_MEM_ERROR; ------------------ | | 183| 0|#define Z_MEM_ERROR (-4) ------------------ 1270| 0| case SYNC: ------------------ | Branch (1270:9): [True: 0, False: 795] ------------------ 1271| | /* fallthrough */ 1272| 0| default: ------------------ | Branch (1272:9): [True: 0, False: 795] ------------------ 1273| 0| return Z_STREAM_ERROR; ------------------ | | 181| 0|#define Z_STREAM_ERROR (-2) ------------------ 1274| 795| } 1275| | 1276| | /* 1277| | Return from inflate(), updating the total counts and the check value. 1278| | If there was no progress during the inflate() call, return a buffer 1279| | error. Call updatewindow() to create and/or update the window state. 1280| | Note: a memory error from inflate() is non-recoverable. 1281| | */ 1282| 159| inf_leave: 1283| 159| RESTORE(); ------------------ | | 492| 159| do { \ | | 493| 159| strm->next_out = put; \ | | 494| 159| strm->avail_out = left; \ | | 495| 159| strm->next_in = next; \ | | 496| 159| strm->avail_in = have; \ | | 497| 159| state->hold = hold; \ | | 498| 159| state->bits = bits; \ | | 499| 159| } while (0) | | ------------------ | | | Branch (499:14): [Folded - Ignored] | | ------------------ ------------------ 1284| 159| if (state->wsize || (out != strm->avail_out && state->mode < BAD && ------------------ | Branch (1284:9): [True: 0, False: 159] | Branch (1284:26): [True: 0, False: 159] | Branch (1284:52): [True: 0, False: 0] ------------------ 1285| 159| (state->mode < CHECK || flush != Z_FINISH))) ------------------ | | 172| 0|#define Z_FINISH 4 ------------------ | Branch (1285:14): [True: 0, False: 0] | Branch (1285:37): [True: 0, False: 0] ------------------ 1286| 0| if (updatewindow(strm, strm->next_out, out - strm->avail_out)) { ------------------ | Branch (1286:13): [True: 0, False: 0] ------------------ 1287| 0| state->mode = MEM; 1288| 0| return Z_MEM_ERROR; ------------------ | | 183| 0|#define Z_MEM_ERROR (-4) ------------------ 1289| 0| } 1290| 159| in -= strm->avail_in; 1291| 159| out -= strm->avail_out; 1292| 159| strm->total_in += in; 1293| 159| strm->total_out += out; 1294| 159| state->total += out; 1295| 159| if ((state->wrap & 4) && out) ------------------ | Branch (1295:9): [True: 159, False: 0] | Branch (1295:30): [True: 0, False: 159] ------------------ 1296| 0| strm->adler = state->check = 1297| 0| UPDATE_CHECK(state->check, strm->next_out - out, out); ------------------ | | 455| 0| (state->flags ? crc32(check, buf, len) : adler32(check, buf, len)) | | ------------------ | | | Branch (455:6): [True: 0, False: 0] | | ------------------ ------------------ 1298| 159| strm->data_type = (int)state->bits + (state->last ? 64 : 0) + ------------------ | Branch (1298:43): [True: 159, False: 0] ------------------ 1299| 159| (state->mode == TYPE ? 128 : 0) + ------------------ | Branch (1299:24): [True: 0, False: 159] ------------------ 1300| 159| (state->mode == LEN_ || state->mode == COPY_ ? 256 : 0); ------------------ | Branch (1300:24): [True: 0, False: 159] | Branch (1300:47): [True: 0, False: 159] ------------------ 1301| 159| if (((in == 0 && out == 0) || flush == Z_FINISH) && ret == Z_OK) ------------------ | | 172| 159|#define Z_FINISH 4 ------------------ if (((in == 0 && out == 0) || flush == Z_FINISH) && ret == Z_OK) ------------------ | | 177| 0|#define Z_OK 0 ------------------ | Branch (1301:11): [True: 0, False: 159] | Branch (1301:22): [True: 0, False: 0] | Branch (1301:35): [True: 0, False: 159] | Branch (1301:57): [True: 0, False: 0] ------------------ 1302| 0| ret = Z_BUF_ERROR; ------------------ | | 184| 0|#define Z_BUF_ERROR (-5) ------------------ 1303| 159| return ret; 1304| 159|} inflateEnd: 1308| 2.02k|{ 1309| 2.02k| struct inflate_state FAR *state; 1310| 2.02k| if (inflateStateCheck(strm)) ------------------ | Branch (1310:9): [True: 0, False: 2.02k] ------------------ 1311| 0| return Z_STREAM_ERROR; ------------------ | | 181| 0|#define Z_STREAM_ERROR (-2) ------------------ 1312| 2.02k| state = (struct inflate_state FAR *)strm->state; 1313| 2.02k| if (state->window != Z_NULL) ZFREE(strm, state->window); ------------------ | | 212| 2.02k|#define Z_NULL 0 /* for initializing zalloc, zfree, opaque */ ------------------ if (state->window != Z_NULL) ZFREE(strm, state->window); ------------------ | | 283| 0|#define ZFREE(strm, addr) (*((strm)->zfree))((strm)->opaque, (voidpf)(addr)) ------------------ | Branch (1313:9): [True: 0, False: 2.02k] ------------------ 1314| 2.02k| ZFREE(strm, strm->state); ------------------ | | 283| 2.02k|#define ZFREE(strm, addr) (*((strm)->zfree))((strm)->opaque, (voidpf)(addr)) ------------------ 1315| 2.02k| strm->state = Z_NULL; ------------------ | | 212| 2.02k|#define Z_NULL 0 /* for initializing zalloc, zfree, opaque */ ------------------ 1316| 2.02k| Tracev((stderr, "inflate: end\n")); 1317| 2.02k| return Z_OK; ------------------ | | 177| 2.02k|#define Z_OK 0 ------------------ 1318| 2.02k|} inflate.c:inflateStateCheck: 107| 8.58k|{ 108| 8.58k| struct inflate_state FAR *state; 109| 8.58k| if (strm == Z_NULL || ------------------ | | 212| 17.1k|#define Z_NULL 0 /* for initializing zalloc, zfree, opaque */ ------------------ | Branch (109:9): [True: 0, False: 8.58k] ------------------ 110| 8.58k| strm->zalloc == (alloc_func)0 || strm->zfree == (free_func)0) ------------------ | Branch (110:9): [True: 0, False: 8.58k] | Branch (110:42): [True: 0, False: 8.58k] ------------------ 111| 0| return 1; 112| 8.58k| state = (struct inflate_state FAR *)strm->state; 113| 8.58k| if (state == Z_NULL || state->strm != strm || ------------------ | | 212| 17.1k|#define Z_NULL 0 /* for initializing zalloc, zfree, opaque */ ------------------ | Branch (113:9): [True: 0, False: 8.58k] | Branch (113:28): [True: 0, False: 8.58k] ------------------ 114| 8.58k| state->mode < HEAD || state->mode > SYNC) ------------------ | Branch (114:9): [True: 0, False: 8.58k] | Branch (114:31): [True: 0, False: 8.58k] ------------------ 115| 0| return 1; 116| 8.58k| return 0; 117| 8.58k|} inflate.c:fixedtables: 284| 159|{ 285| |#ifdef BUILDFIXED 286| | static int virgin = 1; 287| | static code *lenfix, *distfix; 288| | static code fixed[544]; 289| | 290| | /* build fixed huffman tables if first call (may not be thread safe) */ 291| | if (virgin) { 292| | unsigned sym, bits; 293| | static code *next; 294| | 295| | /* literal/length table */ 296| | sym = 0; 297| | while (sym < 144) state->lens[sym++] = 8; 298| | while (sym < 256) state->lens[sym++] = 9; 299| | while (sym < 280) state->lens[sym++] = 7; 300| | while (sym < 288) state->lens[sym++] = 8; 301| | next = fixed; 302| | lenfix = next; 303| | bits = 9; 304| | inflate_table(LENS, state->lens, 288, &(next), &(bits), state->work); 305| | 306| | /* distance table */ 307| | sym = 0; 308| | while (sym < 32) state->lens[sym++] = 5; 309| | distfix = next; 310| | bits = 5; 311| | inflate_table(DISTS, state->lens, 32, &(next), &(bits), state->work); 312| | 313| | /* do this just once */ 314| | virgin = 0; 315| | } 316| |#else /* !BUILDFIXED */ 317| 159|# include "inffixed.h" ------------------ | | 1| | /* inffixed.h -- table for decoding fixed codes | | 2| | * Generated automatically by makefixed(). | | 3| | */ | | 4| | | | 5| | /* WARNING: this file should *not* be used by applications. | | 6| | It is part of the implementation of this library and is | | 7| | subject to change. Applications should only use zlib.h. | | 8| | */ | | 9| | | | 10| 159| static const code lenfix[512] = { | | 11| 159| {96,7,0},{0,8,80},{0,8,16},{20,8,115},{18,7,31},{0,8,112},{0,8,48}, | | 12| 159| {0,9,192},{16,7,10},{0,8,96},{0,8,32},{0,9,160},{0,8,0},{0,8,128}, | | 13| 159| {0,8,64},{0,9,224},{16,7,6},{0,8,88},{0,8,24},{0,9,144},{19,7,59}, | | 14| 159| {0,8,120},{0,8,56},{0,9,208},{17,7,17},{0,8,104},{0,8,40},{0,9,176}, | | 15| 159| {0,8,8},{0,8,136},{0,8,72},{0,9,240},{16,7,4},{0,8,84},{0,8,20}, | | 16| 159| {21,8,227},{19,7,43},{0,8,116},{0,8,52},{0,9,200},{17,7,13},{0,8,100}, | | 17| 159| {0,8,36},{0,9,168},{0,8,4},{0,8,132},{0,8,68},{0,9,232},{16,7,8}, | | 18| 159| {0,8,92},{0,8,28},{0,9,152},{20,7,83},{0,8,124},{0,8,60},{0,9,216}, | | 19| 159| {18,7,23},{0,8,108},{0,8,44},{0,9,184},{0,8,12},{0,8,140},{0,8,76}, | | 20| 159| {0,9,248},{16,7,3},{0,8,82},{0,8,18},{21,8,163},{19,7,35},{0,8,114}, | | 21| 159| {0,8,50},{0,9,196},{17,7,11},{0,8,98},{0,8,34},{0,9,164},{0,8,2}, | | 22| 159| {0,8,130},{0,8,66},{0,9,228},{16,7,7},{0,8,90},{0,8,26},{0,9,148}, | | 23| 159| {20,7,67},{0,8,122},{0,8,58},{0,9,212},{18,7,19},{0,8,106},{0,8,42}, | | 24| 159| {0,9,180},{0,8,10},{0,8,138},{0,8,74},{0,9,244},{16,7,5},{0,8,86}, | | 25| 159| {0,8,22},{64,8,0},{19,7,51},{0,8,118},{0,8,54},{0,9,204},{17,7,15}, | | 26| 159| {0,8,102},{0,8,38},{0,9,172},{0,8,6},{0,8,134},{0,8,70},{0,9,236}, | | 27| 159| {16,7,9},{0,8,94},{0,8,30},{0,9,156},{20,7,99},{0,8,126},{0,8,62}, | | 28| 159| {0,9,220},{18,7,27},{0,8,110},{0,8,46},{0,9,188},{0,8,14},{0,8,142}, | | 29| 159| {0,8,78},{0,9,252},{96,7,0},{0,8,81},{0,8,17},{21,8,131},{18,7,31}, | | 30| 159| {0,8,113},{0,8,49},{0,9,194},{16,7,10},{0,8,97},{0,8,33},{0,9,162}, | | 31| 159| {0,8,1},{0,8,129},{0,8,65},{0,9,226},{16,7,6},{0,8,89},{0,8,25}, | | 32| 159| {0,9,146},{19,7,59},{0,8,121},{0,8,57},{0,9,210},{17,7,17},{0,8,105}, | | 33| 159| {0,8,41},{0,9,178},{0,8,9},{0,8,137},{0,8,73},{0,9,242},{16,7,4}, | | 34| 159| {0,8,85},{0,8,21},{16,8,258},{19,7,43},{0,8,117},{0,8,53},{0,9,202}, | | 35| 159| {17,7,13},{0,8,101},{0,8,37},{0,9,170},{0,8,5},{0,8,133},{0,8,69}, | | 36| 159| {0,9,234},{16,7,8},{0,8,93},{0,8,29},{0,9,154},{20,7,83},{0,8,125}, | | 37| 159| {0,8,61},{0,9,218},{18,7,23},{0,8,109},{0,8,45},{0,9,186},{0,8,13}, | | 38| 159| {0,8,141},{0,8,77},{0,9,250},{16,7,3},{0,8,83},{0,8,19},{21,8,195}, | | 39| 159| {19,7,35},{0,8,115},{0,8,51},{0,9,198},{17,7,11},{0,8,99},{0,8,35}, | | 40| 159| {0,9,166},{0,8,3},{0,8,131},{0,8,67},{0,9,230},{16,7,7},{0,8,91}, | | 41| 159| {0,8,27},{0,9,150},{20,7,67},{0,8,123},{0,8,59},{0,9,214},{18,7,19}, | | 42| 159| {0,8,107},{0,8,43},{0,9,182},{0,8,11},{0,8,139},{0,8,75},{0,9,246}, | | 43| 159| {16,7,5},{0,8,87},{0,8,23},{64,8,0},{19,7,51},{0,8,119},{0,8,55}, | | 44| 159| {0,9,206},{17,7,15},{0,8,103},{0,8,39},{0,9,174},{0,8,7},{0,8,135}, | | 45| 159| {0,8,71},{0,9,238},{16,7,9},{0,8,95},{0,8,31},{0,9,158},{20,7,99}, | | 46| 159| {0,8,127},{0,8,63},{0,9,222},{18,7,27},{0,8,111},{0,8,47},{0,9,190}, | | 47| 159| {0,8,15},{0,8,143},{0,8,79},{0,9,254},{96,7,0},{0,8,80},{0,8,16}, | | 48| 159| {20,8,115},{18,7,31},{0,8,112},{0,8,48},{0,9,193},{16,7,10},{0,8,96}, | | 49| 159| {0,8,32},{0,9,161},{0,8,0},{0,8,128},{0,8,64},{0,9,225},{16,7,6}, | | 50| 159| {0,8,88},{0,8,24},{0,9,145},{19,7,59},{0,8,120},{0,8,56},{0,9,209}, | | 51| 159| {17,7,17},{0,8,104},{0,8,40},{0,9,177},{0,8,8},{0,8,136},{0,8,72}, | | 52| 159| {0,9,241},{16,7,4},{0,8,84},{0,8,20},{21,8,227},{19,7,43},{0,8,116}, | | 53| 159| {0,8,52},{0,9,201},{17,7,13},{0,8,100},{0,8,36},{0,9,169},{0,8,4}, | | 54| 159| {0,8,132},{0,8,68},{0,9,233},{16,7,8},{0,8,92},{0,8,28},{0,9,153}, | | 55| 159| {20,7,83},{0,8,124},{0,8,60},{0,9,217},{18,7,23},{0,8,108},{0,8,44}, | | 56| 159| {0,9,185},{0,8,12},{0,8,140},{0,8,76},{0,9,249},{16,7,3},{0,8,82}, | | 57| 159| {0,8,18},{21,8,163},{19,7,35},{0,8,114},{0,8,50},{0,9,197},{17,7,11}, | | 58| 159| {0,8,98},{0,8,34},{0,9,165},{0,8,2},{0,8,130},{0,8,66},{0,9,229}, | | 59| 159| {16,7,7},{0,8,90},{0,8,26},{0,9,149},{20,7,67},{0,8,122},{0,8,58}, | | 60| 159| {0,9,213},{18,7,19},{0,8,106},{0,8,42},{0,9,181},{0,8,10},{0,8,138}, | | 61| 159| {0,8,74},{0,9,245},{16,7,5},{0,8,86},{0,8,22},{64,8,0},{19,7,51}, | | 62| 159| {0,8,118},{0,8,54},{0,9,205},{17,7,15},{0,8,102},{0,8,38},{0,9,173}, | | 63| 159| {0,8,6},{0,8,134},{0,8,70},{0,9,237},{16,7,9},{0,8,94},{0,8,30}, | | 64| 159| {0,9,157},{20,7,99},{0,8,126},{0,8,62},{0,9,221},{18,7,27},{0,8,110}, | | 65| 159| {0,8,46},{0,9,189},{0,8,14},{0,8,142},{0,8,78},{0,9,253},{96,7,0}, | | 66| 159| {0,8,81},{0,8,17},{21,8,131},{18,7,31},{0,8,113},{0,8,49},{0,9,195}, | | 67| 159| {16,7,10},{0,8,97},{0,8,33},{0,9,163},{0,8,1},{0,8,129},{0,8,65}, | | 68| 159| {0,9,227},{16,7,6},{0,8,89},{0,8,25},{0,9,147},{19,7,59},{0,8,121}, | | 69| 159| {0,8,57},{0,9,211},{17,7,17},{0,8,105},{0,8,41},{0,9,179},{0,8,9}, | | 70| 159| {0,8,137},{0,8,73},{0,9,243},{16,7,4},{0,8,85},{0,8,21},{16,8,258}, | | 71| 159| {19,7,43},{0,8,117},{0,8,53},{0,9,203},{17,7,13},{0,8,101},{0,8,37}, | | 72| 159| {0,9,171},{0,8,5},{0,8,133},{0,8,69},{0,9,235},{16,7,8},{0,8,93}, | | 73| 159| {0,8,29},{0,9,155},{20,7,83},{0,8,125},{0,8,61},{0,9,219},{18,7,23}, | | 74| 159| {0,8,109},{0,8,45},{0,9,187},{0,8,13},{0,8,141},{0,8,77},{0,9,251}, | | 75| 159| {16,7,3},{0,8,83},{0,8,19},{21,8,195},{19,7,35},{0,8,115},{0,8,51}, | | 76| 159| {0,9,199},{17,7,11},{0,8,99},{0,8,35},{0,9,167},{0,8,3},{0,8,131}, | | 77| 159| {0,8,67},{0,9,231},{16,7,7},{0,8,91},{0,8,27},{0,9,151},{20,7,67}, | | 78| 159| {0,8,123},{0,8,59},{0,9,215},{18,7,19},{0,8,107},{0,8,43},{0,9,183}, | | 79| 159| {0,8,11},{0,8,139},{0,8,75},{0,9,247},{16,7,5},{0,8,87},{0,8,23}, | | 80| 159| {64,8,0},{19,7,51},{0,8,119},{0,8,55},{0,9,207},{17,7,15},{0,8,103}, | | 81| 159| {0,8,39},{0,9,175},{0,8,7},{0,8,135},{0,8,71},{0,9,239},{16,7,9}, | | 82| 159| {0,8,95},{0,8,31},{0,9,159},{20,7,99},{0,8,127},{0,8,63},{0,9,223}, | | 83| 159| {18,7,27},{0,8,111},{0,8,47},{0,9,191},{0,8,15},{0,8,143},{0,8,79}, | | 84| 159| {0,9,255} | | 85| 159| }; | | 86| | | | 87| 159| static const code distfix[32] = { | | 88| 159| {16,5,1},{23,5,257},{19,5,17},{27,5,4097},{17,5,5},{25,5,1025}, | | 89| 159| {21,5,65},{29,5,16385},{16,5,3},{24,5,513},{20,5,33},{28,5,8193}, | | 90| 159| {18,5,9},{26,5,2049},{22,5,129},{64,5,0},{16,5,2},{23,5,385}, | | 91| 159| {19,5,25},{27,5,6145},{17,5,7},{25,5,1537},{21,5,97},{29,5,24577}, | | 92| 159| {16,5,4},{24,5,769},{20,5,49},{28,5,12289},{18,5,13},{26,5,3073}, | | 93| 159| {22,5,193},{64,5,0} | | 94| 159| }; ------------------ 318| 159|#endif /* BUILDFIXED */ 319| 159| state->lencode = lenfix; 320| 159| state->lenbits = 9; 321| 159| state->distcode = distfix; 322| 159| state->distbits = 5; 323| 159|} zcalloc: 311| 2.02k|{ 312| 2.02k| (void)opaque; 313| 2.02k| return sizeof(uInt) > 2 ? (voidpf)malloc(items * size) : ------------------ | Branch (313:12): [Folded - Ignored] ------------------ 314| 2.02k| (voidpf)calloc(items, size); 315| 2.02k|} zcfree: 320| 2.02k|{ 321| 2.02k| (void)opaque; 322| 2.02k| free(ptr); 323| 2.02k|} _ZN8perfetto4base13ignore_resultIJA18_cPKcEEEvDpRKT_: 157| 16.7k|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJPNS_15trace_processor6tables12MachineTableEEEEvDpRKT_: 157| 434|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJPNS_15trace_processor6tables12ProcessTableEEEEvDpRKT_: 157| 434|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJPNS_15trace_processor6tables11ThreadTableEEEEvDpRKT_: 157| 434|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJPNS_15trace_processor6tables8ArgTableEEEEvDpRKT_: 157| 434|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJPNS_15trace_processor6tables14ChromeRawTableEEEEvDpRKT_: 157| 434|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJPNS_15trace_processor6tables18ClockSnapshotTableEEEEvDpRKT_: 157| 434|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJPNS_15trace_processor6tables8CpuTableEEEEvDpRKT_: 157| 434|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJPNS_15trace_processor6tables12CpuFreqTableEEEEvDpRKT_: 157| 434|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJPNS_15trace_processor6tables25ExpMissingChromeProcTableEEEEvDpRKT_: 157| 434|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJPNS_15trace_processor6tables19FiledescriptorTableEEEEvDpRKT_: 157| 434|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJPNS_15trace_processor6tables16FtraceEventTableEEEEvDpRKT_: 157| 434|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJPNS_15trace_processor6tables13MetadataTableEEEEvDpRKT_: 157| 434|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJPNS_15trace_processor6tables14TraceFileTableEEEEvDpRKT_: 157| 434|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJPNS_15trace_processor6tables15AndroidLogTableEEEEvDpRKT_: 157| 434|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJPNS_15trace_processor6tables21AndroidDumpstateTableEEEEvDpRKT_: 157| 434|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJPNS_15trace_processor6tables32AndroidGameInterventionListTableEEEEvDpRKT_: 157| 434|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJPNS_15trace_processor6tables21AndroidKeyEventsTableEEEEvDpRKT_: 157| 434|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJPNS_15trace_processor6tables24AndroidMotionEventsTableEEEEvDpRKT_: 157| 434|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJPNS_15trace_processor6tables30AndroidInputEventDispatchTableEEEEvDpRKT_: 157| 434|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJPNS_15trace_processor6tables10TrackTableEEEEvDpRKT_: 157| 434|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJPNS_15trace_processor6tables12CounterTableEEEEvDpRKT_: 157| 434|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJPNS_15trace_processor6tables23EtmV4ConfigurationTableEEEEvDpRKT_: 157| 434|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJPNS_15trace_processor6tables17EtmV4SessionTableEEEEvDpRKT_: 157| 434|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJPNS_15trace_processor6tables15EtmV4TraceTableEEEEvDpRKT_: 157| 434|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJPNS_15trace_processor6tables9FileTableEEEEvDpRKT_: 157| 434|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJPNS_15trace_processor6tables12ElfFileTableEEEEvDpRKT_: 157| 434|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJPNS_15trace_processor6tables10SliceTableEEEEvDpRKT_: 157| 434|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJPNS_15trace_processor6tables26AndroidNetworkPacketsTableEEEEvDpRKT_: 157| 434|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJPNS_15trace_processor6tables9FlowTableEEEEvDpRKT_: 157| 434|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJPNS_15trace_processor6tables24StackProfileMappingTableEEEEvDpRKT_: 157| 434|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJPNS_15trace_processor6tables22StackProfileFrameTableEEEEvDpRKT_: 157| 434|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJPNS_15trace_processor6tables25StackProfileCallsiteTableEEEEvDpRKT_: 157| 434|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJPNS_15trace_processor6tables26CpuProfileStackSampleTableEEEEvDpRKT_: 157| 434|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJPNS_15trace_processor6tables20GpuCounterGroupTableEEEEvDpRKT_: 157| 434|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJPNS_15trace_processor6tables19HeapGraphClassTableEEEEvDpRKT_: 157| 434|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJPNS_15trace_processor6tables20HeapGraphObjectTableEEEEvDpRKT_: 157| 434|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJPNS_15trace_processor6tables23HeapGraphReferenceTableEEEEvDpRKT_: 157| 434|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJPNS_15trace_processor6tables22InstrumentsSampleTableEEEEvDpRKT_: 157| 434|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJPNS_15trace_processor6tables26HeapProfileAllocationTableEEEEvDpRKT_: 157| 434|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJPNS_15trace_processor6tables16PackageListTableEEEEvDpRKT_: 157| 434|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJPNS_15trace_processor6tables16PerfSessionTableEEEEvDpRKT_: 157| 434|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJPNS_15trace_processor6tables15PerfSampleTableEEEEvDpRKT_: 157| 434|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJPNS_15trace_processor6tables18ProfilerSmapsTableEEEEvDpRKT_: 157| 434|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJPNS_15trace_processor6tables11SymbolTableEEEEvDpRKT_: 157| 434|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJPNS_15trace_processor6tables28VulkanMemoryAllocationsTableEEEEvDpRKT_: 157| 434|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJPNS_15trace_processor6tables12JitCodeTableEEEEvDpRKT_: 157| 434|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJPNS_15trace_processor6tables13JitFrameTableEEEEvDpRKT_: 157| 434|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJPNS_15trace_processor6tables19MemorySnapshotTableEEEEvDpRKT_: 157| 434|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJPNS_15trace_processor6tables26ProcessMemorySnapshotTableEEEEvDpRKT_: 157| 434|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJPNS_15trace_processor6tables23MemorySnapshotNodeTableEEEEvDpRKT_: 157| 434|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJPNS_15trace_processor6tables23MemorySnapshotEdgeTableEEEEvDpRKT_: 157| 434|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJPNS_15trace_processor6tables14SpeRecordTableEEEEvDpRKT_: 157| 434|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJPNS_15trace_processor6tables15MmapRecordTableEEEEvDpRKT_: 157| 434|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJPNS_15trace_processor6tables15SchedSliceTableEEEEvDpRKT_: 157| 434|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJPNS_15trace_processor6tables24SpuriousSchedWakeupTableEEEEvDpRKT_: 157| 434|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJPNS_15trace_processor6tables16ThreadStateTableEEEEvDpRKT_: 157| 434|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJPNS_15trace_processor6tables26ExperimentalProtoPathTableEEEEvDpRKT_: 157| 434|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJPNS_15trace_processor6tables29ExperimentalProtoContentTableEEEEvDpRKT_: 157| 434|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJPNS_15trace_processor6tables14V8IsolateTableEEEEvDpRKT_: 157| 434|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJPNS_15trace_processor6tables15V8JsScriptTableEEEEvDpRKT_: 157| 434|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJPNS_15trace_processor6tables17V8WasmScriptTableEEEEvDpRKT_: 157| 434|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJPNS_15trace_processor6tables17V8JsFunctionTableEEEEvDpRKT_: 157| 434|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJPNS_15trace_processor6tables13V8JsCodeTableEEEEvDpRKT_: 157| 434|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJPNS_15trace_processor6tables19V8InternalCodeTableEEEEvDpRKT_: 157| 434|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJPNS_15trace_processor6tables15V8WasmCodeTableEEEEvDpRKT_: 157| 434|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJPNS_15trace_processor6tables17V8RegexpCodeTableEEEEvDpRKT_: 157| 434|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJPNS_15trace_processor6tables13ProtoLogTableEEEEvDpRKT_: 157| 434|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJPNS_15trace_processor6tables23InputMethodClientsTableEEEEvDpRKT_: 157| 434|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJPNS_15trace_processor6tables30InputMethodManagerServiceTableEEEEvDpRKT_: 157| 434|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJPNS_15trace_processor6tables23InputMethodServiceTableEEEEvDpRKT_: 157| 434|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJPNS_15trace_processor6tables33SurfaceFlingerLayersSnapshotTableEEEEvDpRKT_: 157| 434|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJPNS_15trace_processor6tables24SurfaceFlingerLayerTableEEEEvDpRKT_: 157| 434|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJPNS_15trace_processor6tables31SurfaceFlingerTransactionsTableEEEEvDpRKT_: 157| 434|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJPNS_15trace_processor6tables16ViewCaptureTableEEEEvDpRKT_: 157| 434|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJPNS_15trace_processor6tables20ViewCaptureViewTableEEEEvDpRKT_: 157| 434|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJPNS_15trace_processor6tables28ViewCaptureInternedDataTableEEEEvDpRKT_: 157| 434|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJPNS_15trace_processor6tables34WindowManagerShellTransitionsTableEEEEvDpRKT_: 157| 434|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJPNS_15trace_processor6tables41WindowManagerShellTransitionHandlersTableEEEEvDpRKT_: 157| 434|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJPNS_15trace_processor6tables39WindowManagerShellTransitionProtosTableEEEEvDpRKT_: 157| 434|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJPNS_15trace_processor6tables18WindowManagerTableEEEEvDpRKT_: 157| 434|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJjEEEvDpRKT_: 157| 263M|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJPKNS_15trace_processor6tracks22DimensionBlueprintBaseEEEEvDpRKT_: 157| 737k|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJDnDnEEEvDpRKT_: 157| 109k|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJiEEEvDpRKT_: 157| 1.08M|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJA29_chEEEvDpRKT_: 157| 423k|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJA38_cjjEEEvDpRKT_: 157| 24.2k|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJA41_clEEEvDpRKT_: 157| 845|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJNS_15trace_processor10StringPool2IdEDnEEEvDpRKT_: 157| 147k|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJA15_cPKcEEEvDpRKT_: 157| 16.3k|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJA35_cEEEvDpRKT_: 157| 16.3k|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJA140_cPKclllEEEvDpRKT_: 157| 46|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJA53_ciEEEvDpRKT_: 157| 20.4k|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJA38_cEEEvDpRKT_: 157| 99.5k|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJA3_cPKcEEEvDpRKT_: 157| 26.3k|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJA30_cPKcEEEvDpRKT_: 157| 1.20M|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJA26_cPKcEEEvDpRKT_: 157| 65.6k|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJA62_cEEEvDpRKT_: 157| 212|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJA107_cmEEEvDpRKT_: 157| 1|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJA84_cEEEvDpRKT_: 157| 16|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJA72_cmEEEvDpRKT_: 157| 15.2k|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJA105_cjjmmlEEEvDpRKT_: 157| 1.90k|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJNS_15trace_processor10StringPool2IdES4_EEEvDpRKT_: 157| 10.5k|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJA97_cjmmlEEEvDpRKT_: 157| 6.44k|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJA36_cmEEEvDpRKT_: 157| 2.17k|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJNS_15trace_processor15TracePacketDataEEEEvDpRKT_: 157| 1.37M|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJNS_15trace_processor14TrackEventDataEEEEvDpRKT_: 157| 84.3k|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJPNS_15trace_processor9TraceBlobEEEEvDpRKT_: 157| 3.71M|inline void ignore_result(const T&...) {} _ZN8perfetto4base13ignore_resultIJPNS_15trace_processor29PacketSequenceStateGenerationEEEEvDpRKT_: 157| 3.64M|inline void ignore_result(const T&...) {} _ZNK8perfetto4base6Status2okEv: 55| 22.9M| bool ok() const { return ok_; } _ZN8perfetto4base6StatusC2Ev: 42| 20.5M| Status() : ok_(true) {} _ZN8perfetto4base6StatusC2ENSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE: 43| 1.32M| explicit Status(std::string msg) : ok_(false), message_(std::move(msg)) { 44| 1.32M| PERFETTO_CHECK(!message_.empty()); 45| 1.32M| } _ZNK8perfetto4base6Status9c_messageEv: 60| 1.29M| const char* c_message() const { return message_.c_str(); } _ZN8perfetto4base8OkStatusEv: 108| 20.5M|inline Status OkStatus() { 109| 20.5M| return Status(); 110| 20.5M|} _ZN8perfetto4base6StatusC2ERKS1_: 48| 42.6k| Status(const Status&) = default; _ZN8perfetto4base6StatusC2EOS1_: 52| 1.32M| Status(Status&&) noexcept = default; _ZN8perfetto4base6StatusaSEOS1_: 53| 961k| Status& operator=(Status&&) = default; _ZN8perfetto4base13GetWallTimeNsEv: 239| 214k|inline TimeNanos GetWallTimeNs() { 240| 214k| return GetTimeInternalNs(kWallTimeClockSource); 241| 214k|} _ZN8perfetto4base17GetTimeInternalNsEi: 221| 214k|inline TimeNanos GetTimeInternalNs(clockid_t clk_id) { 222| 214k| struct timespec ts = {}; 223| 214k| PERFETTO_CHECK(clock_gettime(clk_id, &ts) == 0); 224| 214k| return FromPosixTimespec(ts); 225| 214k|} _ZN8perfetto4base17FromPosixTimespecERK8timespec: 54| 214k|inline TimeNanos FromPosixTimespec(const struct timespec& ts) { 55| 214k| return TimeNanos(ts.tv_sec * 1000000000LL + ts.tv_nsec); 56| 214k|} _ZN8perfetto4base13GetWallTimeMsEv: 260| 212k|inline TimeMillis GetWallTimeMs() { 261| 212k| return std::chrono::duration_cast(GetWallTimeNs()); 262| 212k|} _ZN8perfetto4base13Base64EncSizeEm: 31| 14|inline size_t Base64EncSize(size_t src_size) { 32| 14| return (src_size + 2) / 3 * 4; 33| 14|} _ZNK8perfetto4base13CircularQueueINS_15trace_processor4util19TraceBlobViewReader5EntryEE8IteratorptEv: 78| 259M| T* operator->() const { 79| |#if PERFETTO_DCHECK_IS_ON() 80| | PERFETTO_DCHECK(generation_ == queue_->generation()); 81| |#endif 82| 259M| return queue_->Get(pos_); 83| 259M| } _ZN8perfetto4base13CircularQueueINS_15trace_processor4util19TraceBlobViewReader5EntryEE3GetEm: 311| 259M| inline T* Get(uint64_t pos) { 312| 259M| PERFETTO_DCHECK(pos >= begin_ && pos < end_); 313| 259M| PERFETTO_DCHECK((capacity_ & (capacity_ - 1)) == 0); // Must be a pow2. 314| 259M| auto index = static_cast(pos & (capacity_ - 1)); 315| 259M| return &entries_[index]; 316| 259M| } _ZN8perfetto4base13CircularQueueINS_15trace_processor4util19TraceBlobViewReader5EntryEE5beginEv: 253| 259M| Iterator begin() { return Iterator(this, begin_, generation()); } _ZNK8perfetto4base13CircularQueueINS_15trace_processor4util19TraceBlobViewReader5EntryEE10generationEv: 271| 259M| uint32_t generation() const { return 0; } _ZNK8perfetto4base13CircularQueueINS_15trace_processor4util19TraceBlobViewReader5EntryEE5emptyEv: 258| 166M| bool empty() const { return size() == 0; } _ZNK8perfetto4base13CircularQueueINS_15trace_processor4util19TraceBlobViewReader5EntryEE4sizeEv: 260| 166M| size_t size() const { 261| 166M| PERFETTO_DCHECK(end_ - begin_ <= capacity_); 262| 166M| return static_cast(end_ - begin_); 263| 166M| } _ZN8perfetto4base13CircularQueueINS_15trace_processor4util19TraceBlobViewReader5EntryEE5frontEv: 255| 259M| T& front() { return *begin(); } _ZNK8perfetto4base13CircularQueueINS_15trace_processor4util19TraceBlobViewReader5EntryEE8IteratordeEv: 85| 259M| T& operator*() const { return *(operator->()); } _ZNK8perfetto4base13CircularQueueINS_15trace_processor13BumpAllocator5ChunkEE5emptyEv: 258| 3.73M| bool empty() const { return size() == 0; } _ZNK8perfetto4base13CircularQueueINS_15trace_processor13BumpAllocator5ChunkEE4sizeEv: 260| 7.48M| size_t size() const { 261| 7.48M| PERFETTO_DCHECK(end_ - begin_ <= capacity_); 262| 7.48M| return static_cast(end_ - begin_); 263| 7.48M| } _ZNK8perfetto4base13CircularQueueINS_15trace_processor11TraceSorter16TimestampedEventEE5emptyEv: 258| 966k| bool empty() const { return size() == 0; } _ZN8perfetto4base13CircularQueueINS_15trace_processor11TraceSorter16TimestampedEventEE5clearEv: 236| 2.02k| void clear() { erase_front(size()); } _ZN8perfetto4base13CircularQueueINS_15trace_processor11TraceSorter16TimestampedEventEE11erase_frontEm: 226| 15.2k| void erase_front(size_t n) { 227| 15.2k| increment_generation(); 228| 3.73M| for (; n && (begin_ < end_); --n) { ------------------ | Branch (228:12): [True: 3.71M, False: 15.2k] | Branch (228:17): [True: 3.71M, False: 0] ------------------ 229| 3.71M| Get(begin_)->~T(); 230| 3.71M| begin_++; // This needs to be its own statement, Get() checks begin_. 231| 3.71M| } 232| 15.2k| } _ZN8perfetto4base13CircularQueueINS_15trace_processor11TraceSorter16TimestampedEventEE20increment_generationEv: 272| 3.73M| void increment_generation() {} _ZN8perfetto4base13CircularQueueINS_15trace_processor11TraceSorter16TimestampedEventEE3GetEm: 311| 3.69G| inline T* Get(uint64_t pos) { 312| 3.69G| PERFETTO_DCHECK(pos >= begin_ && pos < end_); 313| 3.69G| PERFETTO_DCHECK((capacity_ & (capacity_ - 1)) == 0); // Must be a pow2. 314| 3.69G| auto index = static_cast(pos & (capacity_ - 1)); 315| 3.69G| return &entries_[index]; 316| 3.69G| } _ZN8perfetto4base13CircularQueueINS_15trace_processor11TraceSorter16TimestampedEventEE12emplace_backIJS4_EEEvDpOT_: 218| 3.71M| void emplace_back(Args&&... args) { 219| 3.71M| increment_generation(); 220| 3.71M| if (PERFETTO_UNLIKELY(size() >= capacity_)) ------------------ | | 24| 3.71M|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 1.17k, False: 3.71M] | | ------------------ ------------------ 221| 1.17k| Grow(); 222| 3.71M| T* slot = Get(end_++); 223| 3.71M| new (slot) T(std::forward(args)...); 224| 3.71M| } _ZN8perfetto4base13CircularQueueINS_15trace_processor11TraceSorter16TimestampedEventEE4GrowEm: 276| 3.19k| void Grow(size_t new_capacity = 0) { 277| | // Capacity must be always a power of two. This allows Get() to use a simple 278| | // bitwise-AND for handling the wrapping instead of a full division. 279| 3.19k| new_capacity = new_capacity ? new_capacity : capacity_ * 2; ------------------ | Branch (279:20): [True: 2.02k, False: 1.17k] ------------------ 280| 3.19k| PERFETTO_CHECK((new_capacity & (new_capacity - 1)) == 0); // Must be pow2. 281| | 282| | // On 32-bit systems this might hit the 4GB wall and overflow. We can't do 283| | // anything other than crash in this case. 284| 3.19k| PERFETTO_CHECK(new_capacity > capacity_); 285| | 286| 3.19k| ChangeCapacity(new_capacity); 287| 3.19k| } _ZN8perfetto4base13CircularQueueINS_15trace_processor11TraceSorter16TimestampedEventEE14ChangeCapacityEm: 289| 3.41k| void ChangeCapacity(size_t new_capacity) { 290| | // We should still have enough space to fit all the elements in the queue. 291| 3.41k| PERFETTO_CHECK(new_capacity >= size()); 292| | 293| 3.41k| AlignedUniquePtr new_vec = AlignedAllocTyped(new_capacity); 294| | 295| | // Move all elements in the expanded array. 296| 3.41k| size_t new_size = 0; 297| 4.74M| for (uint64_t i = begin_; i < end_; i++) ------------------ | Branch (297:31): [True: 4.74M, False: 3.41k] ------------------ 298| 4.74M| new (&new_vec[new_size++]) T(std::move(*Get(i))); // Placement move ctor. 299| | 300| | // Even if all the elements are std::move()-d and likely empty, we are still 301| | // required to call the dtor for them. 302| 4.74M| for (uint64_t i = begin_; i < end_; i++) ------------------ | Branch (302:31): [True: 4.74M, False: 3.41k] ------------------ 303| 4.74M| Get(i)->~T(); 304| | 305| 3.41k| begin_ = 0; 306| 3.41k| end_ = new_size; 307| 3.41k| capacity_ = new_capacity; 308| 3.41k| entries_ = std::move(new_vec); 309| 3.41k| } _ZNK8perfetto4base13CircularQueueINS_15trace_processor11TraceSorter16TimestampedEventEE4sizeEv: 260| 4.71M| size_t size() const { 261| 4.71M| PERFETTO_DCHECK(end_ - begin_ <= capacity_); 262| 4.71M| return static_cast(end_ - begin_); 263| 4.71M| } _ZN8perfetto4base13CircularQueueINS_15trace_processor11TraceSorter16TimestampedEventEED2Ev: 208| 2.02k| ~CircularQueue() { 209| 2.02k| if (!entries_) { ------------------ | Branch (209:9): [True: 0, False: 2.02k] ------------------ 210| 0| PERFETTO_DCHECK(empty()); 211| 0| return; 212| 0| } 213| 2.02k| clear(); // Invoke destructors on all alive entries. 214| 2.02k| PERFETTO_DCHECK(empty()); 215| 2.02k| } _ZN8perfetto4base13CircularQueueINS_15trace_processor11TraceSorter16TimestampedEventEEC2Em: 176| 2.02k| explicit CircularQueue(size_t initial_capacity = 1024) { 177| 2.02k| Grow(initial_capacity); 178| 2.02k| } _ZN8perfetto4base13CircularQueueINS_15trace_processor4util19TraceBlobViewReader5EntryEED2Ev: 208| 2.02k| ~CircularQueue() { 209| 2.02k| if (!entries_) { ------------------ | Branch (209:9): [True: 0, False: 2.02k] ------------------ 210| 0| PERFETTO_DCHECK(empty()); 211| 0| return; 212| 0| } 213| 2.02k| clear(); // Invoke destructors on all alive entries. 214| 2.02k| PERFETTO_DCHECK(empty()); 215| 2.02k| } _ZN8perfetto4base13CircularQueueINS_15trace_processor4util19TraceBlobViewReader5EntryEE5clearEv: 236| 2.02k| void clear() { erase_front(size()); } _ZN8perfetto4base13CircularQueueINS_15trace_processor4util19TraceBlobViewReader5EntryEE11erase_frontEm: 226| 2.13k| void erase_front(size_t n) { 227| 2.13k| increment_generation(); 228| 2.55k| for (; n && (begin_ < end_); --n) { ------------------ | Branch (228:12): [True: 424, False: 2.13k] | Branch (228:17): [True: 424, False: 0] ------------------ 229| 424| Get(begin_)->~T(); 230| 424| begin_++; // This needs to be its own statement, Get() checks begin_. 231| 424| } 232| 2.13k| } _ZN8perfetto4base13CircularQueueINS_15trace_processor4util19TraceBlobViewReader5EntryEE20increment_generationEv: 272| 2.55k| void increment_generation() {} _ZN8perfetto4base13CircularQueueINS_15trace_processor4util19TraceBlobViewReader5EntryEE8IteratorC2EPS6_mj: 63| 259M| : queue_(queue), 64| 259M| pos_(pos) 65| |#if PERFETTO_DCHECK_IS_ON() 66| | , 67| | generation_(generation) 68| |#endif 69| 259M| { 70| 259M| ignore_result(generation); 71| 259M| } _ZN8perfetto4base13CircularQueueINS_15trace_processor4util19TraceBlobViewReader5EntryEEC2Em: 176| 2.02k| explicit CircularQueue(size_t initial_capacity = 1024) { 177| 2.02k| Grow(initial_capacity); 178| 2.02k| } _ZN8perfetto4base13CircularQueueINS_15trace_processor4util19TraceBlobViewReader5EntryEE4GrowEm: 276| 2.02k| void Grow(size_t new_capacity = 0) { 277| | // Capacity must be always a power of two. This allows Get() to use a simple 278| | // bitwise-AND for handling the wrapping instead of a full division. 279| 2.02k| new_capacity = new_capacity ? new_capacity : capacity_ * 2; ------------------ | Branch (279:20): [True: 2.02k, False: 0] ------------------ 280| 2.02k| PERFETTO_CHECK((new_capacity & (new_capacity - 1)) == 0); // Must be pow2. 281| | 282| | // On 32-bit systems this might hit the 4GB wall and overflow. We can't do 283| | // anything other than crash in this case. 284| 2.02k| PERFETTO_CHECK(new_capacity > capacity_); 285| | 286| 2.02k| ChangeCapacity(new_capacity); 287| 2.02k| } _ZN8perfetto4base13CircularQueueINS_15trace_processor4util19TraceBlobViewReader5EntryEE14ChangeCapacityEm: 289| 2.02k| void ChangeCapacity(size_t new_capacity) { 290| | // We should still have enough space to fit all the elements in the queue. 291| 2.02k| PERFETTO_CHECK(new_capacity >= size()); 292| | 293| 2.02k| AlignedUniquePtr new_vec = AlignedAllocTyped(new_capacity); 294| | 295| | // Move all elements in the expanded array. 296| 2.02k| size_t new_size = 0; 297| 2.02k| for (uint64_t i = begin_; i < end_; i++) ------------------ | Branch (297:31): [True: 0, False: 2.02k] ------------------ 298| 0| new (&new_vec[new_size++]) T(std::move(*Get(i))); // Placement move ctor. 299| | 300| | // Even if all the elements are std::move()-d and likely empty, we are still 301| | // required to call the dtor for them. 302| 2.02k| for (uint64_t i = begin_; i < end_; i++) ------------------ | Branch (302:31): [True: 0, False: 2.02k] ------------------ 303| 0| Get(i)->~T(); 304| | 305| 2.02k| begin_ = 0; 306| 2.02k| end_ = new_size; 307| 2.02k| capacity_ = new_capacity; 308| 2.02k| entries_ = std::move(new_vec); 309| 2.02k| } _ZN8perfetto4base13CircularQueueINSt3__16vectorINS_15trace_processor16TraceTokenBuffer14BlobWithOffsetENS2_9allocatorIS6_EEEEEC2Em: 176| 424| explicit CircularQueue(size_t initial_capacity = 1024) { 177| 424| Grow(initial_capacity); 178| 424| } _ZN8perfetto4base13CircularQueueINSt3__16vectorINS_15trace_processor16TraceTokenBuffer14BlobWithOffsetENS2_9allocatorIS6_EEEEE4GrowEm: 276| 424| void Grow(size_t new_capacity = 0) { 277| | // Capacity must be always a power of two. This allows Get() to use a simple 278| | // bitwise-AND for handling the wrapping instead of a full division. 279| 424| new_capacity = new_capacity ? new_capacity : capacity_ * 2; ------------------ | Branch (279:20): [True: 424, False: 0] ------------------ 280| 424| PERFETTO_CHECK((new_capacity & (new_capacity - 1)) == 0); // Must be pow2. 281| | 282| | // On 32-bit systems this might hit the 4GB wall and overflow. We can't do 283| | // anything other than crash in this case. 284| 424| PERFETTO_CHECK(new_capacity > capacity_); 285| | 286| 424| ChangeCapacity(new_capacity); 287| 424| } _ZN8perfetto4base13CircularQueueINSt3__16vectorINS_15trace_processor16TraceTokenBuffer14BlobWithOffsetENS2_9allocatorIS6_EEEEE14ChangeCapacityEm: 289| 424| void ChangeCapacity(size_t new_capacity) { 290| | // We should still have enough space to fit all the elements in the queue. 291| 424| PERFETTO_CHECK(new_capacity >= size()); 292| | 293| 424| AlignedUniquePtr new_vec = AlignedAllocTyped(new_capacity); 294| | 295| | // Move all elements in the expanded array. 296| 424| size_t new_size = 0; 297| 424| for (uint64_t i = begin_; i < end_; i++) ------------------ | Branch (297:31): [True: 0, False: 424] ------------------ 298| 0| new (&new_vec[new_size++]) T(std::move(*Get(i))); // Placement move ctor. 299| | 300| | // Even if all the elements are std::move()-d and likely empty, we are still 301| | // required to call the dtor for them. 302| 424| for (uint64_t i = begin_; i < end_; i++) ------------------ | Branch (302:31): [True: 0, False: 424] ------------------ 303| 0| Get(i)->~T(); 304| | 305| 424| begin_ = 0; 306| 424| end_ = new_size; 307| 424| capacity_ = new_capacity; 308| 424| entries_ = std::move(new_vec); 309| 424| } _ZNK8perfetto4base13CircularQueueINSt3__16vectorINS_15trace_processor16TraceTokenBuffer14BlobWithOffsetENS2_9allocatorIS6_EEEEE4sizeEv: 260| 3.73M| size_t size() const { 261| 3.73M| PERFETTO_DCHECK(end_ - begin_ <= capacity_); 262| 3.73M| return static_cast(end_ - begin_); 263| 3.73M| } _ZN8perfetto4base13CircularQueueINSt3__16vectorINS_15trace_processor16TraceTokenBuffer14BlobWithOffsetENS2_9allocatorIS6_EEEEE3GetEm: 311| 11.1M| inline T* Get(uint64_t pos) { 312| 11.1M| PERFETTO_DCHECK(pos >= begin_ && pos < end_); 313| 11.1M| PERFETTO_DCHECK((capacity_ & (capacity_ - 1)) == 0); // Must be a pow2. 314| 11.1M| auto index = static_cast(pos & (capacity_ - 1)); 315| 11.1M| return &entries_[index]; 316| 11.1M| } _ZN8perfetto4base13CircularQueueINSt3__16vectorIPNS_15trace_processor29PacketSequenceStateGenerationENS2_9allocatorIS6_EEEEEC2Em: 176| 424| explicit CircularQueue(size_t initial_capacity = 1024) { 177| 424| Grow(initial_capacity); 178| 424| } _ZN8perfetto4base13CircularQueueINSt3__16vectorIPNS_15trace_processor29PacketSequenceStateGenerationENS2_9allocatorIS6_EEEEE4GrowEm: 276| 424| void Grow(size_t new_capacity = 0) { 277| | // Capacity must be always a power of two. This allows Get() to use a simple 278| | // bitwise-AND for handling the wrapping instead of a full division. 279| 424| new_capacity = new_capacity ? new_capacity : capacity_ * 2; ------------------ | Branch (279:20): [True: 424, False: 0] ------------------ 280| 424| PERFETTO_CHECK((new_capacity & (new_capacity - 1)) == 0); // Must be pow2. 281| | 282| | // On 32-bit systems this might hit the 4GB wall and overflow. We can't do 283| | // anything other than crash in this case. 284| 424| PERFETTO_CHECK(new_capacity > capacity_); 285| | 286| 424| ChangeCapacity(new_capacity); 287| 424| } _ZN8perfetto4base13CircularQueueINSt3__16vectorIPNS_15trace_processor29PacketSequenceStateGenerationENS2_9allocatorIS6_EEEEE14ChangeCapacityEm: 289| 424| void ChangeCapacity(size_t new_capacity) { 290| | // We should still have enough space to fit all the elements in the queue. 291| 424| PERFETTO_CHECK(new_capacity >= size()); 292| | 293| 424| AlignedUniquePtr new_vec = AlignedAllocTyped(new_capacity); 294| | 295| | // Move all elements in the expanded array. 296| 424| size_t new_size = 0; 297| 424| for (uint64_t i = begin_; i < end_; i++) ------------------ | Branch (297:31): [True: 0, False: 424] ------------------ 298| 0| new (&new_vec[new_size++]) T(std::move(*Get(i))); // Placement move ctor. 299| | 300| | // Even if all the elements are std::move()-d and likely empty, we are still 301| | // required to call the dtor for them. 302| 424| for (uint64_t i = begin_; i < end_; i++) ------------------ | Branch (302:31): [True: 0, False: 424] ------------------ 303| 0| Get(i)->~T(); 304| | 305| 424| begin_ = 0; 306| 424| end_ = new_size; 307| 424| capacity_ = new_capacity; 308| 424| entries_ = std::move(new_vec); 309| 424| } _ZNK8perfetto4base13CircularQueueINSt3__16vectorIPNS_15trace_processor29PacketSequenceStateGenerationENS2_9allocatorIS6_EEEEE4sizeEv: 260| 16.2k| size_t size() const { 261| 16.2k| PERFETTO_DCHECK(end_ - begin_ <= capacity_); 262| 16.2k| return static_cast(end_ - begin_); 263| 16.2k| } _ZN8perfetto4base13CircularQueueINSt3__16vectorIPNS_15trace_processor29PacketSequenceStateGenerationENS2_9allocatorIS6_EEEEE3GetEm: 311| 7.44M| inline T* Get(uint64_t pos) { 312| 7.44M| PERFETTO_DCHECK(pos >= begin_ && pos < end_); 313| 7.44M| PERFETTO_DCHECK((capacity_ & (capacity_ - 1)) == 0); // Must be a pow2. 314| 7.44M| auto index = static_cast(pos & (capacity_ - 1)); 315| 7.44M| return &entries_[index]; 316| 7.44M| } _ZN8perfetto4base13CircularQueueINSt3__16vectorIPNS_15trace_processor29PacketSequenceStateGenerationENS2_9allocatorIS6_EEEEED2Ev: 208| 424| ~CircularQueue() { 209| 424| if (!entries_) { ------------------ | Branch (209:9): [True: 0, False: 424] ------------------ 210| 0| PERFETTO_DCHECK(empty()); 211| 0| return; 212| 0| } 213| 424| clear(); // Invoke destructors on all alive entries. 214| 424| PERFETTO_DCHECK(empty()); 215| 424| } _ZN8perfetto4base13CircularQueueINSt3__16vectorIPNS_15trace_processor29PacketSequenceStateGenerationENS2_9allocatorIS6_EEEEE5clearEv: 236| 424| void clear() { erase_front(size()); } _ZN8perfetto4base13CircularQueueINSt3__16vectorIPNS_15trace_processor29PacketSequenceStateGenerationENS2_9allocatorIS6_EEEEE11erase_frontEm: 226| 13.6k| void erase_front(size_t n) { 227| 13.6k| increment_generation(); 228| 15.8k| for (; n && (begin_ < end_); --n) { ------------------ | Branch (228:12): [True: 2.18k, False: 13.6k] | Branch (228:17): [True: 2.18k, False: 0] ------------------ 229| 2.18k| Get(begin_)->~T(); 230| 2.18k| begin_++; // This needs to be its own statement, Get() checks begin_. 231| 2.18k| } 232| 13.6k| } _ZN8perfetto4base13CircularQueueINSt3__16vectorIPNS_15trace_processor29PacketSequenceStateGenerationENS2_9allocatorIS6_EEEEE20increment_generationEv: 272| 15.8k| void increment_generation() {} _ZN8perfetto4base13CircularQueueINSt3__16vectorINS_15trace_processor16TraceTokenBuffer14BlobWithOffsetENS2_9allocatorIS6_EEEEED2Ev: 208| 424| ~CircularQueue() { 209| 424| if (!entries_) { ------------------ | Branch (209:9): [True: 0, False: 424] ------------------ 210| 0| PERFETTO_DCHECK(empty()); 211| 0| return; 212| 0| } 213| 424| clear(); // Invoke destructors on all alive entries. 214| 424| PERFETTO_DCHECK(empty()); 215| 424| } _ZN8perfetto4base13CircularQueueINSt3__16vectorINS_15trace_processor16TraceTokenBuffer14BlobWithOffsetENS2_9allocatorIS6_EEEEE5clearEv: 236| 424| void clear() { erase_front(size()); } _ZN8perfetto4base13CircularQueueINSt3__16vectorINS_15trace_processor16TraceTokenBuffer14BlobWithOffsetENS2_9allocatorIS6_EEEEE11erase_frontEm: 226| 13.6k| void erase_front(size_t n) { 227| 13.6k| increment_generation(); 228| 15.8k| for (; n && (begin_ < end_); --n) { ------------------ | Branch (228:12): [True: 2.18k, False: 13.6k] | Branch (228:17): [True: 2.18k, False: 0] ------------------ 229| 2.18k| Get(begin_)->~T(); 230| 2.18k| begin_++; // This needs to be its own statement, Get() checks begin_. 231| 2.18k| } 232| 13.6k| } _ZN8perfetto4base13CircularQueueINSt3__16vectorINS_15trace_processor16TraceTokenBuffer14BlobWithOffsetENS2_9allocatorIS6_EEEEE20increment_generationEv: 272| 15.8k| void increment_generation() {} _ZN8perfetto4base13CircularQueueINS_15trace_processor11TraceSorter16TimestampedEventEE5beginEv: 253| 63.1k| Iterator begin() { return Iterator(this, begin_, generation()); } _ZNK8perfetto4base13CircularQueueINS_15trace_processor11TraceSorter16TimestampedEventEE10generationEv: 271| 102k| uint32_t generation() const { return 0; } _ZN8perfetto4base13CircularQueueINS_15trace_processor11TraceSorter16TimestampedEventEE8IteratorC2EPS5_mj: 63| 102k| : queue_(queue), 64| 102k| pos_(pos) 65| |#if PERFETTO_DCHECK_IS_ON() 66| | , 67| | generation_(generation) 68| |#endif 69| 102k| { 70| 102k| ignore_result(generation); 71| 102k| } _ZN8perfetto4base13CircularQueueINS_15trace_processor11TraceSorter16TimestampedEventEE3endEv: 254| 39.5k| Iterator end() { return Iterator(this, end_, generation()); } _ZN8perfetto4baseneERKNS0_13CircularQueueINS_15trace_processor11TraceSorter16TimestampedEventEE8IteratorES8_: 142| 259M| friend bool operator!=(const Iterator& lhs, const Iterator& rhs) { 143| 259M| return lhs.pos_ != rhs.pos_; 144| 259M| } _ZN8perfetto4base13CircularQueueINS_15trace_processor11TraceSorter16TimestampedEventEE8IteratorppEv: 89| 784M| Iterator& operator++() { 90| 784M| Add(1); 91| 784M| return *this; 92| 784M| } _ZN8perfetto4base13CircularQueueINS_15trace_processor11TraceSorter16TimestampedEventEE8Iterator3AddEl: 163| 2.63G| inline void Add(difference_type offset) { 164| 2.63G| pos_ = static_cast(static_cast(pos_) + offset); 165| 2.63G| PERFETTO_DCHECK(pos_ <= queue_->end_); 166| 2.63G| } _ZNK8perfetto4base13CircularQueueINS_15trace_processor11TraceSorter16TimestampedEventEE8IteratordeEv: 85| 3.68G| T& operator*() const { return *(operator->()); } _ZNK8perfetto4base13CircularQueueINS_15trace_processor11TraceSorter16TimestampedEventEE8IteratorptEv: 78| 3.68G| T* operator->() const { 79| |#if PERFETTO_DCHECK_IS_ON() 80| | PERFETTO_DCHECK(generation_ == queue_->generation()); 81| |#endif 82| 3.68G| return queue_->Get(pos_); 83| 3.68G| } _ZN8perfetto4baseplERKNS0_13CircularQueueINS_15trace_processor11TraceSorter16TimestampedEventEE8IteratorEl: 111| 41.1M| friend Iterator operator+(const Iterator& iter, difference_type offset) { 112| 41.1M| Iterator ret = iter; 113| 41.1M| ret.Add(offset); 114| 41.1M| return ret; 115| 41.1M| } _ZN8perfetto4basemiERKNS0_13CircularQueueINS_15trace_processor11TraceSorter16TimestampedEventEE8IteratorES8_: 133| 20.4M| friend ptrdiff_t operator-(const Iterator& lhs, const Iterator& rhs) { 134| 20.4M| return static_cast(lhs.pos_) - 135| 20.4M| static_cast(rhs.pos_); 136| 20.4M| } _ZN8perfetto4base13CircularQueueINS_15trace_processor11TraceSorter16TimestampedEventEE8IteratorpLEl: 117| 1.37M| Iterator& operator+=(difference_type offset) { 118| 1.37M| Add(offset); 119| 1.37M| return *this; 120| 1.37M| } _ZN8perfetto4base13CircularQueueINS_15trace_processor11TraceSorter16TimestampedEventEE8IteratormmEv: 100| 1.68G| Iterator& operator--() { 101| 1.68G| Add(-1); 102| 1.68G| return *this; 103| 1.68G| } _ZN8perfetto4baseeqERKNS0_13CircularQueueINS_15trace_processor11TraceSorter16TimestampedEventEE8IteratorES8_: 138| 15.6M| friend bool operator==(const Iterator& lhs, const Iterator& rhs) { 139| 15.6M| return lhs.pos_ == rhs.pos_; 140| 15.6M| } _ZN8perfetto4basemiERKNS0_13CircularQueueINS_15trace_processor11TraceSorter16TimestampedEventEE8IteratorEl: 122| 124M| friend Iterator operator-(const Iterator& iter, difference_type offset) { 123| 124M| Iterator ret = iter; 124| 124M| ret.Add(-offset); 125| 124M| return ret; 126| 124M| } _ZN8perfetto4baseltERKNS0_13CircularQueueINS_15trace_processor11TraceSorter16TimestampedEventEE8IteratorES8_: 146| 79.9M| friend bool operator<(const Iterator& lhs, const Iterator& rhs) { 147| 79.9M| return lhs.pos_ < rhs.pos_; 148| 79.9M| } _ZN8perfetto4basegeERKNS0_13CircularQueueINS_15trace_processor11TraceSorter16TimestampedEventEE8IteratorES8_: 158| 9.96M| friend bool operator>=(const Iterator& lhs, const Iterator& rhs) { 159| 9.96M| return lhs.pos_ >= rhs.pos_; 160| 9.96M| } _ZN8perfetto4base13CircularQueueINS_15trace_processor11TraceSorter16TimestampedEventEE5frontEv: 255| 10.7k| T& front() { return *begin(); } _ZN8perfetto4base13CircularQueueINS_15trace_processor11TraceSorter16TimestampedEventEE13shrink_to_fitEv: 238| 13.2k| void shrink_to_fit() { 239| | // We only bother shrinking if we can fit in quarter of the capacity we are 240| | // currently using. Moreover, don't bother shrinking below 4096 elements as 241| | // that will cause a lot of reallocations for little benefit. 242| 13.2k| if (size() > capacity() / 2 || capacity() <= 4096) { ------------------ | Branch (242:9): [True: 8.73k, False: 4.48k] | Branch (242:36): [True: 4.26k, False: 221] ------------------ 243| 13.0k| return; 244| 13.0k| } 245| 221| ChangeCapacity(capacity() / 2); 246| 221| } _ZNK8perfetto4base13CircularQueueINS_15trace_processor11TraceSorter16TimestampedEventEE8capacityEv: 265| 17.9k| size_t capacity() const { return capacity_; } _ZN8perfetto4base13CircularQueueINSt3__16vectorINS_15trace_processor16TraceTokenBuffer14BlobWithOffsetENS2_9allocatorIS6_EEEEE2atEm: 248| 11.1M| T& at(size_t idx) { 249| 11.1M| PERFETTO_DCHECK(idx < size()); 250| 11.1M| return *Get(begin_ + idx); 251| 11.1M| } _ZN8perfetto4base13CircularQueueINSt3__16vectorIPNS_15trace_processor29PacketSequenceStateGenerationENS2_9allocatorIS6_EEEEE2atEm: 248| 7.43M| T& at(size_t idx) { 249| 7.43M| PERFETTO_DCHECK(idx < size()); 250| 7.43M| return *Get(begin_ + idx); 251| 7.43M| } _ZN8perfetto4base13CircularQueueINSt3__16vectorINS_15trace_processor16TraceTokenBuffer14BlobWithOffsetENS2_9allocatorIS6_EEEEE12emplace_backIJEEEvDpOT_: 218| 2.18k| void emplace_back(Args&&... args) { 219| 2.18k| increment_generation(); 220| 2.18k| if (PERFETTO_UNLIKELY(size() >= capacity_)) ------------------ | | 24| 2.18k|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 0, False: 2.18k] | | ------------------ ------------------ 221| 0| Grow(); 222| 2.18k| T* slot = Get(end_++); 223| 2.18k| new (slot) T(std::forward(args)...); 224| 2.18k| } _ZN8perfetto4base13CircularQueueINSt3__16vectorIPNS_15trace_processor29PacketSequenceStateGenerationENS2_9allocatorIS6_EEEEE12emplace_backIJEEEvDpOT_: 218| 2.18k| void emplace_back(Args&&... args) { 219| 2.18k| increment_generation(); 220| 2.18k| if (PERFETTO_UNLIKELY(size() >= capacity_)) ------------------ | | 24| 2.18k|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 0, False: 2.18k] | | ------------------ ------------------ 221| 0| Grow(); 222| 2.18k| T* slot = Get(end_++); 223| 2.18k| new (slot) T(std::forward(args)...); 224| 2.18k| } _ZN8perfetto4base13CircularQueueINS_15trace_processor13BumpAllocator5ChunkEEC2Em: 176| 424| explicit CircularQueue(size_t initial_capacity = 1024) { 177| 424| Grow(initial_capacity); 178| 424| } _ZN8perfetto4base13CircularQueueINS_15trace_processor13BumpAllocator5ChunkEE4GrowEm: 276| 424| void Grow(size_t new_capacity = 0) { 277| | // Capacity must be always a power of two. This allows Get() to use a simple 278| | // bitwise-AND for handling the wrapping instead of a full division. 279| 424| new_capacity = new_capacity ? new_capacity : capacity_ * 2; ------------------ | Branch (279:20): [True: 424, False: 0] ------------------ 280| 424| PERFETTO_CHECK((new_capacity & (new_capacity - 1)) == 0); // Must be pow2. 281| | 282| | // On 32-bit systems this might hit the 4GB wall and overflow. We can't do 283| | // anything other than crash in this case. 284| 424| PERFETTO_CHECK(new_capacity > capacity_); 285| | 286| 424| ChangeCapacity(new_capacity); 287| 424| } _ZN8perfetto4base13CircularQueueINS_15trace_processor13BumpAllocator5ChunkEE14ChangeCapacityEm: 289| 424| void ChangeCapacity(size_t new_capacity) { 290| | // We should still have enough space to fit all the elements in the queue. 291| 424| PERFETTO_CHECK(new_capacity >= size()); 292| | 293| 424| AlignedUniquePtr new_vec = AlignedAllocTyped(new_capacity); 294| | 295| | // Move all elements in the expanded array. 296| 424| size_t new_size = 0; 297| 424| for (uint64_t i = begin_; i < end_; i++) ------------------ | Branch (297:31): [True: 0, False: 424] ------------------ 298| 0| new (&new_vec[new_size++]) T(std::move(*Get(i))); // Placement move ctor. 299| | 300| | // Even if all the elements are std::move()-d and likely empty, we are still 301| | // required to call the dtor for them. 302| 424| for (uint64_t i = begin_; i < end_; i++) ------------------ | Branch (302:31): [True: 0, False: 424] ------------------ 303| 0| Get(i)->~T(); 304| | 305| 424| begin_ = 0; 306| 424| end_ = new_size; 307| 424| capacity_ = new_capacity; 308| 424| entries_ = std::move(new_vec); 309| 424| } _ZN8perfetto4base13CircularQueueINS_15trace_processor13BumpAllocator5ChunkEE3GetEm: 311| 14.9M| inline T* Get(uint64_t pos) { 312| 14.9M| PERFETTO_DCHECK(pos >= begin_ && pos < end_); 313| 14.9M| PERFETTO_DCHECK((capacity_ & (capacity_ - 1)) == 0); // Must be a pow2. 314| 14.9M| auto index = static_cast(pos & (capacity_ - 1)); 315| 14.9M| return &entries_[index]; 316| 14.9M| } _ZN8perfetto4base13CircularQueueINS_15trace_processor13BumpAllocator5ChunkEED2Ev: 208| 424| ~CircularQueue() { 209| 424| if (!entries_) { ------------------ | Branch (209:9): [True: 0, False: 424] ------------------ 210| 0| PERFETTO_DCHECK(empty()); 211| 0| return; 212| 0| } 213| 424| clear(); // Invoke destructors on all alive entries. 214| 424| PERFETTO_DCHECK(empty()); 215| 424| } _ZN8perfetto4base13CircularQueueINS_15trace_processor13BumpAllocator5ChunkEE5clearEv: 236| 424| void clear() { erase_front(size()); } _ZN8perfetto4base13CircularQueueINS_15trace_processor13BumpAllocator5ChunkEE5beginEv: 253| 424| Iterator begin() { return Iterator(this, begin_, generation()); } _ZNK8perfetto4base13CircularQueueINS_15trace_processor13BumpAllocator5ChunkEE10generationEv: 271| 3.74M| uint32_t generation() const { return 0; } _ZN8perfetto4base13CircularQueueINS_15trace_processor13BumpAllocator5ChunkEE8IteratorC2EPS5_mj: 63| 3.74M| : queue_(queue), 64| 3.74M| pos_(pos) 65| |#if PERFETTO_DCHECK_IS_ON() 66| | , 67| | generation_(generation) 68| |#endif 69| 3.74M| { 70| 3.74M| ignore_result(generation); 71| 3.74M| } _ZN8perfetto4base13CircularQueueINS_15trace_processor13BumpAllocator5ChunkEE3endEv: 254| 3.74M| Iterator end() { return Iterator(this, end_, generation()); } _ZN8perfetto4baseneERKNS0_13CircularQueueINS_15trace_processor13BumpAllocator5ChunkEE8IteratorES8_: 142| 733| friend bool operator!=(const Iterator& lhs, const Iterator& rhs) { 143| 733| return lhs.pos_ != rhs.pos_; 144| 733| } _ZN8perfetto4base13CircularQueueINS_15trace_processor13BumpAllocator5ChunkEE8IteratorppEv: 89| 309| Iterator& operator++() { 90| 309| Add(1); 91| 309| return *this; 92| 309| } _ZN8perfetto4base13CircularQueueINS_15trace_processor13BumpAllocator5ChunkEE8Iterator3AddEl: 163| 3.74M| inline void Add(difference_type offset) { 164| 3.74M| pos_ = static_cast(static_cast(pos_) + offset); 165| 3.74M| PERFETTO_DCHECK(pos_ <= queue_->end_); 166| 3.74M| } _ZNK8perfetto4base13CircularQueueINS_15trace_processor13BumpAllocator5ChunkEE8IteratordeEv: 85| 3.74M| T& operator*() const { return *(operator->()); } _ZNK8perfetto4base13CircularQueueINS_15trace_processor13BumpAllocator5ChunkEE8IteratorptEv: 78| 3.74M| T* operator->() const { 79| |#if PERFETTO_DCHECK_IS_ON() 80| | PERFETTO_DCHECK(generation_ == queue_->generation()); 81| |#endif 82| 3.74M| return queue_->Get(pos_); 83| 3.74M| } _ZN8perfetto4base13CircularQueueINS_15trace_processor13BumpAllocator5ChunkEE12emplace_backIJS4_EEEvDpOT_: 218| 2.18k| void emplace_back(Args&&... args) { 219| 2.18k| increment_generation(); 220| 2.18k| if (PERFETTO_UNLIKELY(size() >= capacity_)) ------------------ | | 24| 2.18k|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 0, False: 2.18k] | | ------------------ ------------------ 221| 0| Grow(); 222| 2.18k| T* slot = Get(end_++); 223| 2.18k| new (slot) T(std::forward(args)...); 224| 2.18k| } _ZN8perfetto4base13CircularQueueINS_15trace_processor13BumpAllocator5ChunkEE20increment_generationEv: 272| 15.8k| void increment_generation() {} _ZN8perfetto4base13CircularQueueINS_15trace_processor13BumpAllocator5ChunkEE2atEm: 248| 11.1M| T& at(size_t idx) { 249| 11.1M| PERFETTO_DCHECK(idx < size()); 250| 11.1M| return *Get(begin_ + idx); 251| 11.1M| } _ZN8perfetto4base13CircularQueueINS_15trace_processor13BumpAllocator5ChunkEE11erase_frontEm: 226| 13.6k| void erase_front(size_t n) { 227| 13.6k| increment_generation(); 228| 15.8k| for (; n && (begin_ < end_); --n) { ------------------ | Branch (228:12): [True: 2.18k, False: 13.6k] | Branch (228:17): [True: 2.18k, False: 0] ------------------ 229| 2.18k| Get(begin_)->~T(); 230| 2.18k| begin_++; // This needs to be its own statement, Get() checks begin_. 231| 2.18k| } 232| 13.6k| } _ZN8perfetto4base13CircularQueueINS_15trace_processor13BumpAllocator5ChunkEE4backEv: 256| 3.74M| T& back() { return *(end() - 1); } _ZN8perfetto4basemiERKNS0_13CircularQueueINS_15trace_processor13BumpAllocator5ChunkEE8IteratorEl: 122| 3.74M| friend Iterator operator-(const Iterator& iter, difference_type offset) { 123| 3.74M| Iterator ret = iter; 124| 3.74M| ret.Add(-offset); 125| 3.74M| return ret; 126| 3.74M| } _ZN8perfetto4base13CircularQueueINS_15trace_processor4util19TraceBlobViewReader5EntryEE12emplace_backIJS5_EEEvDpOT_: 218| 424| void emplace_back(Args&&... args) { 219| 424| increment_generation(); 220| 424| if (PERFETTO_UNLIKELY(size() >= capacity_)) ------------------ | | 24| 424|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 0, False: 424] | | ------------------ ------------------ 221| 0| Grow(); 222| 424| T* slot = Get(end_++); 223| 424| new (slot) T(std::forward(args)...); 224| 424| } _ZN8perfetto4base13CircularQueueINS_15trace_processor4util19TraceBlobViewReader5EntryEE9pop_frontEv: 234| 104| void pop_front() { erase_front(1); } _ZN8perfetto4base8CrashKey3SetENS0_10StringViewE: 114| 434| void Set(StringView sv) { 115| 434| size_t len = std::min(sv.size(), sizeof(str_value_) - 1); 116| 13.8k| for (size_t i = 0; i < len; ++i) ------------------ | Branch (116:24): [True: 13.4k, False: 434] ------------------ 117| 13.4k| str_value_[i].store(sv.data()[i], std::memory_order_relaxed); 118| 434| str_value_[len].store('\0', std::memory_order_relaxed); 119| 434| type_.store(Type::kStr, std::memory_order_relaxed); 120| 434| if (PERFETTO_UNLIKELY(!registered_.load(std::memory_order_relaxed))) ------------------ | | 24| 434|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 1, False: 433] | | ------------------ ------------------ 121| 1| Register(); 122| 434| } _ZN8perfetto4base11LinearProbe4CalcEmmm: 62| 24.1M| static inline size_t Calc(size_t key_hash, size_t step, size_t capacity) { 63| 24.1M| return (key_hash + step) & (capacity - 1); // Linear probe 64| 24.1M| } _ZN8perfetto4base14QuadraticProbe4CalcEmmm: 72| 139M| static inline size_t Calc(size_t key_hash, size_t step, size_t capacity) { 73| 139M| return (key_hash + 2 * step * step + step) & (capacity - 1); 74| 139M| } _ZN8perfetto4base11FlatHashMapImNS_15trace_processor10StringPool2IdENS0_13AlreadyHashedImEENS0_11LinearProbeELb1EE6InsertEmS4_: 166| 23.5M| std::pair Insert(Key key, Value value) { 167| 23.5M| const size_t key_hash = Hasher{}(key); 168| 23.5M| const uint8_t tag = HashToTag(key_hash); 169| 23.5M| static constexpr size_t kSlotNotFound = std::numeric_limits::max(); 170| | 171| | // This for loop does in reality at most two attempts: 172| | // The first iteration either: 173| | // - Early-returns, because the key exists already, 174| | // - Finds an insertion slot and proceeds because the load is < limit. 175| | // The second iteration is only hit in the unlikely case of this insertion 176| | // bringing the table beyond the target |load_limit_| (or the edge case 177| | // of the HT being full, if |load_limit_pct_| = 100). 178| | // We cannot simply pre-grow the table before insertion, because we must 179| | // guarantee that calling Insert() with a key that already exists doesn't 180| | // invalidate iterators. 181| 23.5M| size_t insertion_slot; 182| 23.5M| size_t probe_len; 183| 23.5M| for (;;) { 184| 23.5M| PERFETTO_DCHECK((capacity_ & (capacity_ - 1)) == 0); // Must be a pow2. 185| 23.5M| insertion_slot = kSlotNotFound; 186| | // Start the iteration at the desired slot (key_hash % capacity_) 187| | // searching either for a free slot or a tombstone. In the worst case we 188| | // might end up scanning the whole array of slots. The Probe functions are 189| | // guaranteed to visit all the slots within |capacity_| steps. If we find 190| | // a free slot, we can stop the search immediately (a free slot acts as an 191| | // "end of chain for entries having the same hash". If we find a 192| | // tombstones (a deleted slot) we remember its position, but have to keep 193| | // searching until a free slot to make sure we don't insert a duplicate 194| | // key. 195| 24.1M| for (probe_len = 0; probe_len < capacity_;) { ------------------ | Branch (195:27): [True: 24.1M, False: 0] ------------------ 196| 24.1M| const size_t idx = Probe::Calc(key_hash, probe_len, capacity_); 197| 24.1M| PERFETTO_DCHECK(idx < capacity_); 198| 24.1M| const uint8_t tag_idx = tags_[idx]; 199| 24.1M| ++probe_len; 200| 24.1M| if (tag_idx == kFreeSlot) { ------------------ | Branch (200:13): [True: 163k, False: 23.9M] ------------------ 201| | // Rationale for "insertion_slot == kSlotNotFound": if we encountered 202| | // a tombstone while iterating we should reuse that rather than 203| | // taking another slot. 204| 163k| if (AppendOnly || insertion_slot == kSlotNotFound) ------------------ | Branch (204:15): [Folded - Ignored] | Branch (204:29): [True: 0, False: 0] ------------------ 205| 163k| insertion_slot = idx; 206| 163k| break; 207| 163k| } 208| | // We should never encounter tombstones in AppendOnly mode. 209| 23.9M| PERFETTO_DCHECK(!(tag_idx == kTombstone && AppendOnly)); 210| 23.9M| if (!AppendOnly && tag_idx == kTombstone) { ------------------ | Branch (210:13): [Folded - Ignored] | Branch (210:28): [True: 0, False: 0] ------------------ 211| 0| insertion_slot = idx; 212| 0| continue; 213| 0| } 214| 23.9M| if (tag_idx == tag && keys_[idx] == key) { ------------------ | Branch (214:13): [True: 23.3M, False: 569k] | Branch (214:31): [True: 23.3M, False: 826] ------------------ 215| | // The key is already in the map. 216| 23.3M| return std::make_pair(&values_[idx], false); 217| 23.3M| } 218| 23.9M| } // for (idx) 219| | 220| | // If we got to this point the key does not exist (otherwise we would have 221| | // hit the return above) and we are going to insert a new entry. 222| | // Before doing so, ensure we stay under the target load limit. 223| 163k| if (PERFETTO_UNLIKELY(size_ >= load_limit_)) { ------------------ | | 24| 163k|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 3, False: 163k] | | ------------------ ------------------ 224| 3| MaybeGrowAndRehash(/*grow=*/true); 225| 3| continue; 226| 3| } 227| 163k| PERFETTO_DCHECK(insertion_slot != kSlotNotFound); 228| 163k| break; 229| 163k| } // for (attempt) 230| | 231| 163k| PERFETTO_CHECK(insertion_slot < capacity_); 232| | 233| | // We found a free slot (or a tombstone). Proceed with the insertion. 234| 163k| Value* value_idx = &values_[insertion_slot]; 235| 163k| new (&keys_[insertion_slot]) Key(std::move(key)); 236| 163k| new (value_idx) Value(std::move(value)); 237| 163k| tags_[insertion_slot] = tag; 238| 163k| PERFETTO_DCHECK(probe_len > 0 && probe_len <= capacity_); 239| 163k| max_probe_length_ = std::max(max_probe_length_, probe_len); 240| 163k| size_++; 241| | 242| 163k| return std::make_pair(value_idx, true); 243| 163k| } _ZN8perfetto4base11FlatHashMapImNS_15trace_processor10StringPool2IdENS0_13AlreadyHashedImEENS0_11LinearProbeELb1EE9HashToTagEm: 374| 23.6M| static inline uint8_t HashToTag(size_t full_hash) { 375| 23.6M| uint8_t tag = full_hash >> (sizeof(full_hash) * 8 - 8); 376| | // Ensure the hash is always >= 2. We use 0, 1 for kFreeSlot and kTombstone. 377| 23.6M| tag += (tag <= kTombstone) << 1; 378| 23.6M| PERFETTO_DCHECK(tag > kTombstone); 379| 23.6M| return tag; 380| 23.6M| } _ZN8perfetto4base11FlatHashMapImNS_15trace_processor10StringPool2IdENS0_13AlreadyHashedImEENS0_11LinearProbeELb1EE18MaybeGrowAndRehashEb: 323| 437| PERFETTO_NO_INLINE void MaybeGrowAndRehash(bool grow) { 324| 437| PERFETTO_DCHECK(size_ <= capacity_); 325| 437| const size_t old_capacity = capacity_; 326| | 327| | // Grow quickly up to 1MB, then chill. 328| 437| const size_t old_size_bytes = old_capacity * (sizeof(Key) + sizeof(Value)); 329| 437| const size_t grow_factor = old_size_bytes < (1024u * 1024u) ? 8 : 2; ------------------ | Branch (329:32): [True: 437, False: 0] ------------------ 330| 437| const size_t new_capacity = 331| 437| grow ? std::max(old_capacity * grow_factor, size_t(1024)) ------------------ | Branch (331:9): [True: 3, False: 434] ------------------ 332| 437| : old_capacity; 333| | 334| 437| auto old_tags(std::move(tags_)); 335| 437| auto old_keys(std::move(keys_)); 336| 437| auto old_values(std::move(values_)); 337| 437| size_t old_size = size_; 338| | 339| | // This must be a CHECK (i.e. not just a DCHECK) to prevent UAF attacks on 340| | // 32-bit archs that try to double the size of the table until wrapping. 341| 437| PERFETTO_CHECK(new_capacity >= old_capacity); 342| 437| Reset(new_capacity); 343| | 344| 437| size_t new_size = 0; // Recompute the size. 345| 1.87M| for (size_t i = 0; i < old_capacity; ++i) { ------------------ | Branch (345:24): [True: 1.87M, False: 437] ------------------ 346| 1.87M| const uint8_t old_tag = old_tags[i]; 347| 1.87M| if (old_tag != kFreeSlot && old_tag != kTombstone) { ------------------ | Branch (347:11): [True: 163k, False: 1.71M] | Branch (347:35): [True: 9.21k, False: 153k] ------------------ 348| 9.21k| Insert(std::move(old_keys[i]), std::move(old_values[i])); 349| 9.21k| old_keys[i].~Key(); // Destroy the old objects. 350| 9.21k| old_values[i].~Value(); 351| 9.21k| new_size++; 352| 9.21k| } 353| 1.87M| } 354| 437| PERFETTO_DCHECK(new_size == old_size); 355| 437| size_ = new_size; 356| 437| } _ZN8perfetto4base11FlatHashMapImNS_15trace_processor10StringPool2IdENS0_13AlreadyHashedImEENS0_11LinearProbeELb1EE5ResetEm: 359| 871| PERFETTO_NO_INLINE void Reset(size_t n) { 360| 871| PERFETTO_DCHECK((n & (n - 1)) == 0); // Must be a pow2. 361| | 362| 871| capacity_ = n; 363| 871| max_probe_length_ = 0; 364| 871| size_ = 0; 365| 871| load_limit_ = n * static_cast(load_limit_percent_) / 100; 366| 871| load_limit_ = std::min(load_limit_, n); 367| | 368| 871| tags_.reset(new uint8_t[n]); 369| 871| memset(&tags_[0], 0, n); // Clear all tags. 370| 871| keys_ = AlignedAllocTyped(n); // Deliberately not 0-initialized. 371| 871| values_ = AlignedAllocTyped(n); // Deliberately not 0-initialized. 372| 871| } _ZNK8perfetto4base11FlatHashMapImNS_15trace_processor10StringPool2IdENS0_13AlreadyHashedImEENS0_11LinearProbeELb1EE4FindERKm: 245| 71.8k| Value* Find(const Key& key) const { 246| 71.8k| const size_t idx = FindInternal(key); 247| 71.8k| if (idx == kNotFound) ------------------ | Branch (247:9): [True: 0, False: 71.8k] ------------------ 248| 0| return nullptr; 249| 71.8k| return &values_[idx]; 250| 71.8k| } _ZNK8perfetto4base11FlatHashMapImNS_15trace_processor10StringPool2IdENS0_13AlreadyHashedImEENS0_11LinearProbeELb1EE12FindInternalERKm: 293| 71.8k| size_t FindInternal(const Key& key) const { 294| 71.8k| const size_t key_hash = Hasher{}(key); 295| 71.8k| const uint8_t tag = HashToTag(key_hash); 296| 71.8k| PERFETTO_DCHECK((capacity_ & (capacity_ - 1)) == 0); // Must be a pow2. 297| 71.8k| PERFETTO_DCHECK(max_probe_length_ <= capacity_); 298| 71.8k| for (size_t i = 0; i < max_probe_length_; ++i) { ------------------ | Branch (298:24): [True: 71.8k, False: 0] ------------------ 299| 71.8k| const size_t idx = Probe::Calc(key_hash, i, capacity_); 300| 71.8k| const uint8_t tag_idx = tags_[idx]; 301| | 302| 71.8k| if (tag_idx == kFreeSlot) ------------------ | Branch (302:11): [True: 0, False: 71.8k] ------------------ 303| 0| return kNotFound; 304| | // HashToTag() never returns kTombstone, so the tag-check below cannot 305| | // possibly match. Also we just want to skip tombstones. 306| 71.8k| if (tag_idx == tag && keys_[idx] == key) { ------------------ | Branch (306:11): [True: 71.8k, False: 0] | Branch (306:29): [True: 71.8k, False: 0] ------------------ 307| 71.8k| PERFETTO_DCHECK(tag_idx > kTombstone); 308| 71.8k| return idx; 309| 71.8k| } 310| 71.8k| } // for (idx) 311| 0| return kNotFound; 312| 71.8k| } _ZN8perfetto4base11FlatHashMapImjNS0_13AlreadyHashedImEENS0_14QuadraticProbeELb0EE6InsertEmj: 166| 3.31M| std::pair Insert(Key key, Value value) { 167| 3.31M| const size_t key_hash = Hasher{}(key); 168| 3.31M| const uint8_t tag = HashToTag(key_hash); 169| 3.31M| static constexpr size_t kSlotNotFound = std::numeric_limits::max(); 170| | 171| | // This for loop does in reality at most two attempts: 172| | // The first iteration either: 173| | // - Early-returns, because the key exists already, 174| | // - Finds an insertion slot and proceeds because the load is < limit. 175| | // The second iteration is only hit in the unlikely case of this insertion 176| | // bringing the table beyond the target |load_limit_| (or the edge case 177| | // of the HT being full, if |load_limit_pct_| = 100). 178| | // We cannot simply pre-grow the table before insertion, because we must 179| | // guarantee that calling Insert() with a key that already exists doesn't 180| | // invalidate iterators. 181| 3.31M| size_t insertion_slot; 182| 3.31M| size_t probe_len; 183| 3.31M| for (;;) { 184| 3.31M| PERFETTO_DCHECK((capacity_ & (capacity_ - 1)) == 0); // Must be a pow2. 185| 3.31M| insertion_slot = kSlotNotFound; 186| | // Start the iteration at the desired slot (key_hash % capacity_) 187| | // searching either for a free slot or a tombstone. In the worst case we 188| | // might end up scanning the whole array of slots. The Probe functions are 189| | // guaranteed to visit all the slots within |capacity_| steps. If we find 190| | // a free slot, we can stop the search immediately (a free slot acts as an 191| | // "end of chain for entries having the same hash". If we find a 192| | // tombstones (a deleted slot) we remember its position, but have to keep 193| | // searching until a free slot to make sure we don't insert a duplicate 194| | // key. 195| 4.17M| for (probe_len = 0; probe_len < capacity_;) { ------------------ | Branch (195:27): [True: 4.16M, False: 412] ------------------ 196| 4.16M| const size_t idx = Probe::Calc(key_hash, probe_len, capacity_); 197| 4.16M| PERFETTO_DCHECK(idx < capacity_); 198| 4.16M| const uint8_t tag_idx = tags_[idx]; 199| 4.16M| ++probe_len; 200| 4.16M| if (tag_idx == kFreeSlot) { ------------------ | Branch (200:13): [True: 1.58M, False: 2.58M] ------------------ 201| | // Rationale for "insertion_slot == kSlotNotFound": if we encountered 202| | // a tombstone while iterating we should reuse that rather than 203| | // taking another slot. 204| 1.58M| if (AppendOnly || insertion_slot == kSlotNotFound) ------------------ | Branch (204:15): [Folded - Ignored] | Branch (204:29): [True: 1.58M, False: 0] ------------------ 205| 1.58M| insertion_slot = idx; 206| 1.58M| break; 207| 1.58M| } 208| | // We should never encounter tombstones in AppendOnly mode. 209| 2.58M| PERFETTO_DCHECK(!(tag_idx == kTombstone && AppendOnly)); 210| 2.58M| if (!AppendOnly && tag_idx == kTombstone) { ------------------ | Branch (210:13): [Folded - Ignored] | Branch (210:28): [True: 0, False: 2.58M] ------------------ 211| 0| insertion_slot = idx; 212| 0| continue; 213| 0| } 214| 2.58M| if (tag_idx == tag && keys_[idx] == key) { ------------------ | Branch (214:13): [True: 1.73M, False: 849k] | Branch (214:31): [True: 1.73M, False: 3.16k] ------------------ 215| | // The key is already in the map. 216| 1.73M| return std::make_pair(&values_[idx], false); 217| 1.73M| } 218| 2.58M| } // for (idx) 219| | 220| | // If we got to this point the key does not exist (otherwise we would have 221| | // hit the return above) and we are going to insert a new entry. 222| | // Before doing so, ensure we stay under the target load limit. 223| 1.58M| if (PERFETTO_UNLIKELY(size_ >= load_limit_)) { ------------------ | | 24| 1.58M|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 701, False: 1.58M] | | ------------------ ------------------ 224| 701| MaybeGrowAndRehash(/*grow=*/true); 225| 701| continue; 226| 701| } 227| 1.58M| PERFETTO_DCHECK(insertion_slot != kSlotNotFound); 228| 1.58M| break; 229| 1.58M| } // for (attempt) 230| | 231| 1.58M| PERFETTO_CHECK(insertion_slot < capacity_); 232| | 233| | // We found a free slot (or a tombstone). Proceed with the insertion. 234| 1.58M| Value* value_idx = &values_[insertion_slot]; 235| 1.58M| new (&keys_[insertion_slot]) Key(std::move(key)); 236| 1.58M| new (value_idx) Value(std::move(value)); 237| 1.58M| tags_[insertion_slot] = tag; 238| 1.58M| PERFETTO_DCHECK(probe_len > 0 && probe_len <= capacity_); 239| 1.58M| max_probe_length_ = std::max(max_probe_length_, probe_len); 240| 1.58M| size_++; 241| | 242| 1.58M| return std::make_pair(value_idx, true); 243| 1.58M| } _ZN8perfetto4base11FlatHashMapImjNS0_13AlreadyHashedImEENS0_14QuadraticProbeELb0EE9HashToTagEm: 374| 3.31M| static inline uint8_t HashToTag(size_t full_hash) { 375| 3.31M| uint8_t tag = full_hash >> (sizeof(full_hash) * 8 - 8); 376| | // Ensure the hash is always >= 2. We use 0, 1 for kFreeSlot and kTombstone. 377| 3.31M| tag += (tag <= kTombstone) << 1; 378| 3.31M| PERFETTO_DCHECK(tag > kTombstone); 379| 3.31M| return tag; 380| 3.31M| } _ZN8perfetto4base11FlatHashMapImjNS0_13AlreadyHashedImEENS0_14QuadraticProbeELb0EE18MaybeGrowAndRehashEb: 323| 1.11k| PERFETTO_NO_INLINE void MaybeGrowAndRehash(bool grow) { 324| 1.11k| PERFETTO_DCHECK(size_ <= capacity_); 325| 1.11k| const size_t old_capacity = capacity_; 326| | 327| | // Grow quickly up to 1MB, then chill. 328| 1.11k| const size_t old_size_bytes = old_capacity * (sizeof(Key) + sizeof(Value)); 329| 1.11k| const size_t grow_factor = old_size_bytes < (1024u * 1024u) ? 8 : 2; ------------------ | Branch (329:32): [True: 1.11k, False: 0] ------------------ 330| 1.11k| const size_t new_capacity = 331| 1.11k| grow ? std::max(old_capacity * grow_factor, size_t(1024)) ------------------ | Branch (331:9): [True: 701, False: 412] ------------------ 332| 1.11k| : old_capacity; 333| | 334| 1.11k| auto old_tags(std::move(tags_)); 335| 1.11k| auto old_keys(std::move(keys_)); 336| 1.11k| auto old_values(std::move(values_)); 337| 1.11k| size_t old_size = size_; 338| | 339| | // This must be a CHECK (i.e. not just a DCHECK) to prevent UAF attacks on 340| | // 32-bit archs that try to double the size of the table until wrapping. 341| 1.11k| PERFETTO_CHECK(new_capacity >= old_capacity); 342| 1.11k| Reset(new_capacity); 343| | 344| 1.11k| size_t new_size = 0; // Recompute the size. 345| 6.23M| for (size_t i = 0; i < old_capacity; ++i) { ------------------ | Branch (345:24): [True: 6.23M, False: 1.11k] ------------------ 346| 6.23M| const uint8_t old_tag = old_tags[i]; 347| 6.23M| if (old_tag != kFreeSlot && old_tag != kTombstone) { ------------------ | Branch (347:11): [True: 1.58M, False: 4.64M] | Branch (347:35): [True: 544k, False: 1.03M] ------------------ 348| 544k| Insert(std::move(old_keys[i]), std::move(old_values[i])); 349| 544k| old_keys[i].~Key(); // Destroy the old objects. 350| 544k| old_values[i].~Value(); 351| 544k| new_size++; 352| 544k| } 353| 6.23M| } 354| 1.11k| PERFETTO_DCHECK(new_size == old_size); 355| 1.11k| size_ = new_size; 356| 1.11k| } _ZN8perfetto4base11FlatHashMapImjNS0_13AlreadyHashedImEENS0_14QuadraticProbeELb0EE5ResetEm: 359| 1.11k| PERFETTO_NO_INLINE void Reset(size_t n) { 360| 1.11k| PERFETTO_DCHECK((n & (n - 1)) == 0); // Must be a pow2. 361| | 362| 1.11k| capacity_ = n; 363| 1.11k| max_probe_length_ = 0; 364| 1.11k| size_ = 0; 365| 1.11k| load_limit_ = n * static_cast(load_limit_percent_) / 100; 366| 1.11k| load_limit_ = std::min(load_limit_, n); 367| | 368| 1.11k| tags_.reset(new uint8_t[n]); 369| 1.11k| memset(&tags_[0], 0, n); // Clear all tags. 370| 1.11k| keys_ = AlignedAllocTyped(n); // Deliberately not 0-initialized. 371| 1.11k| values_ = AlignedAllocTyped(n); // Deliberately not 0-initialized. 372| 1.11k| } _ZNK8perfetto4base11FlatHashMapIjjNS0_4HashIjEENS0_14QuadraticProbeELb0EE4FindERKj: 245| 90.8M| Value* Find(const Key& key) const { 246| 90.8M| const size_t idx = FindInternal(key); 247| 90.8M| if (idx == kNotFound) ------------------ | Branch (247:9): [True: 0, False: 90.8M] ------------------ 248| 0| return nullptr; 249| 90.8M| return &values_[idx]; 250| 90.8M| } _ZNK8perfetto4base11FlatHashMapIjjNS0_4HashIjEENS0_14QuadraticProbeELb0EE12FindInternalERKj: 293| 90.8M| size_t FindInternal(const Key& key) const { 294| 90.8M| const size_t key_hash = Hasher{}(key); 295| 90.8M| const uint8_t tag = HashToTag(key_hash); 296| 90.8M| PERFETTO_DCHECK((capacity_ & (capacity_ - 1)) == 0); // Must be a pow2. 297| 90.8M| PERFETTO_DCHECK(max_probe_length_ <= capacity_); 298| 112M| for (size_t i = 0; i < max_probe_length_; ++i) { ------------------ | Branch (298:24): [True: 112M, False: 0] ------------------ 299| 112M| const size_t idx = Probe::Calc(key_hash, i, capacity_); 300| 112M| const uint8_t tag_idx = tags_[idx]; 301| | 302| 112M| if (tag_idx == kFreeSlot) ------------------ | Branch (302:11): [True: 0, False: 112M] ------------------ 303| 0| return kNotFound; 304| | // HashToTag() never returns kTombstone, so the tag-check below cannot 305| | // possibly match. Also we just want to skip tombstones. 306| 112M| if (tag_idx == tag && keys_[idx] == key) { ------------------ | Branch (306:11): [True: 90.8M, False: 21.9M] | Branch (306:29): [True: 90.8M, False: 55.4k] ------------------ 307| 90.8M| PERFETTO_DCHECK(tag_idx > kTombstone); 308| 90.8M| return idx; 309| 90.8M| } 310| 112M| } // for (idx) 311| 0| return kNotFound; 312| 90.8M| } _ZN8perfetto4base11FlatHashMapIjjNS0_4HashIjEENS0_14QuadraticProbeELb0EE9HashToTagEm: 374| 92.2M| static inline uint8_t HashToTag(size_t full_hash) { 375| 92.2M| uint8_t tag = full_hash >> (sizeof(full_hash) * 8 - 8); 376| | // Ensure the hash is always >= 2. We use 0, 1 for kFreeSlot and kTombstone. 377| 92.2M| tag += (tag <= kTombstone) << 1; 378| 92.2M| PERFETTO_DCHECK(tag > kTombstone); 379| 92.2M| return tag; 380| 92.2M| } _ZN8perfetto4base11FlatHashMapIjNSt3__16vectorIjNS2_9allocatorIjEEEENS0_4HashIjEENS0_14QuadraticProbeELb0EEixEj: 276| 680k| Value& operator[](Key key) { 277| 680k| auto it_and_inserted = Insert(std::move(key), Value{}); 278| 680k| return *it_and_inserted.first; 279| 680k| } _ZN8perfetto4base11FlatHashMapIjNSt3__16vectorIjNS2_9allocatorIjEEEENS0_4HashIjEENS0_14QuadraticProbeELb0EE6InsertEjS6_: 166| 915k| std::pair Insert(Key key, Value value) { 167| 915k| const size_t key_hash = Hasher{}(key); 168| 915k| const uint8_t tag = HashToTag(key_hash); 169| 915k| static constexpr size_t kSlotNotFound = std::numeric_limits::max(); 170| | 171| | // This for loop does in reality at most two attempts: 172| | // The first iteration either: 173| | // - Early-returns, because the key exists already, 174| | // - Finds an insertion slot and proceeds because the load is < limit. 175| | // The second iteration is only hit in the unlikely case of this insertion 176| | // bringing the table beyond the target |load_limit_| (or the edge case 177| | // of the HT being full, if |load_limit_pct_| = 100). 178| | // We cannot simply pre-grow the table before insertion, because we must 179| | // guarantee that calling Insert() with a key that already exists doesn't 180| | // invalidate iterators. 181| 915k| size_t insertion_slot; 182| 915k| size_t probe_len; 183| 917k| for (;;) { 184| 917k| PERFETTO_DCHECK((capacity_ & (capacity_ - 1)) == 0); // Must be a pow2. 185| 917k| insertion_slot = kSlotNotFound; 186| | // Start the iteration at the desired slot (key_hash % capacity_) 187| | // searching either for a free slot or a tombstone. In the worst case we 188| | // might end up scanning the whole array of slots. The Probe functions are 189| | // guaranteed to visit all the slots within |capacity_| steps. If we find 190| | // a free slot, we can stop the search immediately (a free slot acts as an 191| | // "end of chain for entries having the same hash". If we find a 192| | // tombstones (a deleted slot) we remember its position, but have to keep 193| | // searching until a free slot to make sure we don't insert a duplicate 194| | // key. 195| 1.24M| for (probe_len = 0; probe_len < capacity_;) { ------------------ | Branch (195:27): [True: 1.24M, False: 2.02k] ------------------ 196| 1.24M| const size_t idx = Probe::Calc(key_hash, probe_len, capacity_); 197| 1.24M| PERFETTO_DCHECK(idx < capacity_); 198| 1.24M| const uint8_t tag_idx = tags_[idx]; 199| 1.24M| ++probe_len; 200| 1.24M| if (tag_idx == kFreeSlot) { ------------------ | Branch (200:13): [True: 801k, False: 438k] ------------------ 201| | // Rationale for "insertion_slot == kSlotNotFound": if we encountered 202| | // a tombstone while iterating we should reuse that rather than 203| | // taking another slot. 204| 801k| if (AppendOnly || insertion_slot == kSlotNotFound) ------------------ | Branch (204:15): [Folded - Ignored] | Branch (204:29): [True: 801k, False: 0] ------------------ 205| 801k| insertion_slot = idx; 206| 801k| break; 207| 801k| } 208| | // We should never encounter tombstones in AppendOnly mode. 209| 438k| PERFETTO_DCHECK(!(tag_idx == kTombstone && AppendOnly)); 210| 438k| if (!AppendOnly && tag_idx == kTombstone) { ------------------ | Branch (210:13): [Folded - Ignored] | Branch (210:28): [True: 0, False: 438k] ------------------ 211| 0| insertion_slot = idx; 212| 0| continue; 213| 0| } 214| 438k| if (tag_idx == tag && keys_[idx] == key) { ------------------ | Branch (214:13): [True: 114k, False: 323k] | Branch (214:31): [True: 113k, False: 925] ------------------ 215| | // The key is already in the map. 216| 113k| return std::make_pair(&values_[idx], false); 217| 113k| } 218| 438k| } // for (idx) 219| | 220| | // If we got to this point the key does not exist (otherwise we would have 221| | // hit the return above) and we are going to insert a new entry. 222| | // Before doing so, ensure we stay under the target load limit. 223| 803k| if (PERFETTO_UNLIKELY(size_ >= load_limit_)) { ------------------ | | 24| 803k|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 2.16k, False: 801k] | | ------------------ ------------------ 224| 2.16k| MaybeGrowAndRehash(/*grow=*/true); 225| 2.16k| continue; 226| 2.16k| } 227| 801k| PERFETTO_DCHECK(insertion_slot != kSlotNotFound); 228| 801k| break; 229| 803k| } // for (attempt) 230| | 231| 801k| PERFETTO_CHECK(insertion_slot < capacity_); 232| | 233| | // We found a free slot (or a tombstone). Proceed with the insertion. 234| 801k| Value* value_idx = &values_[insertion_slot]; 235| 801k| new (&keys_[insertion_slot]) Key(std::move(key)); 236| 801k| new (value_idx) Value(std::move(value)); 237| 801k| tags_[insertion_slot] = tag; 238| 801k| PERFETTO_DCHECK(probe_len > 0 && probe_len <= capacity_); 239| 801k| max_probe_length_ = std::max(max_probe_length_, probe_len); 240| 801k| size_++; 241| | 242| 801k| return std::make_pair(value_idx, true); 243| 801k| } _ZN8perfetto4base11FlatHashMapIjNSt3__16vectorIjNS2_9allocatorIjEEEENS0_4HashIjEENS0_14QuadraticProbeELb0EE9HashToTagEm: 374| 1.88M| static inline uint8_t HashToTag(size_t full_hash) { 375| 1.88M| uint8_t tag = full_hash >> (sizeof(full_hash) * 8 - 8); 376| | // Ensure the hash is always >= 2. We use 0, 1 for kFreeSlot and kTombstone. 377| 1.88M| tag += (tag <= kTombstone) << 1; 378| 1.88M| PERFETTO_DCHECK(tag > kTombstone); 379| 1.88M| return tag; 380| 1.88M| } _ZN8perfetto4base11FlatHashMapIjNSt3__16vectorIjNS2_9allocatorIjEEEENS0_4HashIjEENS0_14QuadraticProbeELb0EE18MaybeGrowAndRehashEb: 323| 4.53k| PERFETTO_NO_INLINE void MaybeGrowAndRehash(bool grow) { 324| 4.53k| PERFETTO_DCHECK(size_ <= capacity_); 325| 4.53k| const size_t old_capacity = capacity_; 326| | 327| | // Grow quickly up to 1MB, then chill. 328| 4.53k| const size_t old_size_bytes = old_capacity * (sizeof(Key) + sizeof(Value)); 329| 4.53k| const size_t grow_factor = old_size_bytes < (1024u * 1024u) ? 8 : 2; ------------------ | Branch (329:32): [True: 4.48k, False: 46] ------------------ 330| 4.53k| const size_t new_capacity = 331| 4.53k| grow ? std::max(old_capacity * grow_factor, size_t(1024)) ------------------ | Branch (331:9): [True: 2.16k, False: 2.37k] ------------------ 332| 4.53k| : old_capacity; 333| | 334| 4.53k| auto old_tags(std::move(tags_)); 335| 4.53k| auto old_keys(std::move(keys_)); 336| 4.53k| auto old_values(std::move(values_)); 337| 4.53k| size_t old_size = size_; 338| | 339| | // This must be a CHECK (i.e. not just a DCHECK) to prevent UAF attacks on 340| | // 32-bit archs that try to double the size of the table until wrapping. 341| 4.53k| PERFETTO_CHECK(new_capacity >= old_capacity); 342| 4.53k| Reset(new_capacity); 343| | 344| 4.53k| size_t new_size = 0; // Recompute the size. 345| 6.92M| for (size_t i = 0; i < old_capacity; ++i) { ------------------ | Branch (345:24): [True: 6.91M, False: 4.53k] ------------------ 346| 6.91M| const uint8_t old_tag = old_tags[i]; 347| 6.91M| if (old_tag != kFreeSlot && old_tag != kTombstone) { ------------------ | Branch (347:11): [True: 801k, False: 6.11M] | Branch (347:35): [True: 232k, False: 569k] ------------------ 348| 232k| Insert(std::move(old_keys[i]), std::move(old_values[i])); 349| 232k| old_keys[i].~Key(); // Destroy the old objects. 350| 232k| old_values[i].~Value(); 351| 232k| new_size++; 352| 232k| } 353| 6.91M| } 354| 4.53k| PERFETTO_DCHECK(new_size == old_size); 355| 4.53k| size_ = new_size; 356| 4.53k| } _ZN8perfetto4base11FlatHashMapIjNSt3__16vectorIjNS2_9allocatorIjEEEENS0_4HashIjEENS0_14QuadraticProbeELb0EE5ResetEm: 359| 4.53k| PERFETTO_NO_INLINE void Reset(size_t n) { 360| 4.53k| PERFETTO_DCHECK((n & (n - 1)) == 0); // Must be a pow2. 361| | 362| 4.53k| capacity_ = n; 363| 4.53k| max_probe_length_ = 0; 364| 4.53k| size_ = 0; 365| 4.53k| load_limit_ = n * static_cast(load_limit_percent_) / 100; 366| 4.53k| load_limit_ = std::min(load_limit_, n); 367| | 368| 4.53k| tags_.reset(new uint8_t[n]); 369| 4.53k| memset(&tags_[0], 0, n); // Clear all tags. 370| 4.53k| keys_ = AlignedAllocTyped(n); // Deliberately not 0-initialized. 371| 4.53k| values_ = AlignedAllocTyped(n); // Deliberately not 0-initialized. 372| 4.53k| } _ZN8perfetto4base11FlatHashMapIjNSt3__110unique_ptrINS_15trace_processor19InternedMessageViewENS2_14default_deleteIS5_EEEENS0_4HashIjEENS0_14QuadraticProbeELb0EE5ResetEm: 359| 1.01k| PERFETTO_NO_INLINE void Reset(size_t n) { 360| 1.01k| PERFETTO_DCHECK((n & (n - 1)) == 0); // Must be a pow2. 361| | 362| 1.01k| capacity_ = n; 363| 1.01k| max_probe_length_ = 0; 364| 1.01k| size_ = 0; 365| 1.01k| load_limit_ = n * static_cast(load_limit_percent_) / 100; 366| 1.01k| load_limit_ = std::min(load_limit_, n); 367| | 368| 1.01k| tags_.reset(new uint8_t[n]); 369| 1.01k| memset(&tags_[0], 0, n); // Clear all tags. 370| 1.01k| keys_ = AlignedAllocTyped(n); // Deliberately not 0-initialized. 371| 1.01k| values_ = AlignedAllocTyped(n); // Deliberately not 0-initialized. 372| 1.01k| } _ZN8perfetto4base11FlatHashMapIjNSt3__110unique_ptrINS_15trace_processor19InternedMessageViewENS2_14default_deleteIS5_EEEENS0_4HashIjEENS0_14QuadraticProbeELb0EE5ClearEv: 262| 44.2k| void Clear() { 263| | // Avoid trivial heap operations on zero-capacity std::move()-d objects. 264| 44.2k| if (PERFETTO_UNLIKELY(capacity_ == 0)) ------------------ | | 24| 44.2k|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 43.7k, False: 506] | | ------------------ ------------------ 265| 43.7k| return; 266| | 267| 518k| for (size_t i = 0; i < capacity_; ++i) { ------------------ | Branch (267:24): [True: 518k, False: 506] ------------------ 268| 518k| const uint8_t tag = tags_[i]; 269| 518k| if (tag != kFreeSlot && tag != kTombstone) ------------------ | Branch (269:11): [True: 506, False: 517k] | Branch (269:31): [True: 506, False: 0] ------------------ 270| 506| EraseInternal(i); 271| 518k| } 272| | // Clear all tombstones. We really need to do this for AppendOnly. 273| 506| MaybeGrowAndRehash(/*grow=*/false); 274| 506| } _ZN8perfetto4base11FlatHashMapIjNSt3__110unique_ptrINS_15trace_processor19InternedMessageViewENS2_14default_deleteIS5_EEEENS0_4HashIjEENS0_14QuadraticProbeELb0EE13EraseInternalEm: 314| 506| void EraseInternal(size_t idx) { 315| 506| PERFETTO_DCHECK(tags_[idx] > kTombstone); 316| 506| PERFETTO_DCHECK(size_ > 0); 317| 506| tags_[idx] = kTombstone; 318| 506| keys_[idx].~Key(); 319| 506| values_[idx].~Value(); 320| 506| size_--; 321| 506| } _ZN8perfetto4base11FlatHashMapIjNSt3__110unique_ptrINS_15trace_processor19InternedMessageViewENS2_14default_deleteIS5_EEEENS0_4HashIjEENS0_14QuadraticProbeELb0EE18MaybeGrowAndRehashEb: 323| 1.01k| PERFETTO_NO_INLINE void MaybeGrowAndRehash(bool grow) { 324| 1.01k| PERFETTO_DCHECK(size_ <= capacity_); 325| 1.01k| const size_t old_capacity = capacity_; 326| | 327| | // Grow quickly up to 1MB, then chill. 328| 1.01k| const size_t old_size_bytes = old_capacity * (sizeof(Key) + sizeof(Value)); 329| 1.01k| const size_t grow_factor = old_size_bytes < (1024u * 1024u) ? 8 : 2; ------------------ | Branch (329:32): [True: 1.01k, False: 0] ------------------ 330| 1.01k| const size_t new_capacity = 331| 1.01k| grow ? std::max(old_capacity * grow_factor, size_t(1024)) ------------------ | Branch (331:9): [True: 506, False: 506] ------------------ 332| 1.01k| : old_capacity; 333| | 334| 1.01k| auto old_tags(std::move(tags_)); 335| 1.01k| auto old_keys(std::move(keys_)); 336| 1.01k| auto old_values(std::move(values_)); 337| 1.01k| size_t old_size = size_; 338| | 339| | // This must be a CHECK (i.e. not just a DCHECK) to prevent UAF attacks on 340| | // 32-bit archs that try to double the size of the table until wrapping. 341| 1.01k| PERFETTO_CHECK(new_capacity >= old_capacity); 342| 1.01k| Reset(new_capacity); 343| | 344| 1.01k| size_t new_size = 0; // Recompute the size. 345| 519k| for (size_t i = 0; i < old_capacity; ++i) { ------------------ | Branch (345:24): [True: 518k, False: 1.01k] ------------------ 346| 518k| const uint8_t old_tag = old_tags[i]; 347| 518k| if (old_tag != kFreeSlot && old_tag != kTombstone) { ------------------ | Branch (347:11): [True: 506, False: 517k] | Branch (347:35): [True: 0, False: 506] ------------------ 348| 0| Insert(std::move(old_keys[i]), std::move(old_values[i])); 349| 0| old_keys[i].~Key(); // Destroy the old objects. 350| 0| old_values[i].~Value(); 351| 0| new_size++; 352| 0| } 353| 518k| } 354| 1.01k| PERFETTO_DCHECK(new_size == old_size); 355| 1.01k| size_ = new_size; 356| 1.01k| } _ZN8perfetto4base11FlatHashMapIjNSt3__110unique_ptrINS_15trace_processor19InternedMessageViewENS2_14default_deleteIS5_EEEENS0_4HashIjEENS0_14QuadraticProbeELb0EE6InsertEjS8_: 166| 94.3k| std::pair Insert(Key key, Value value) { 167| 94.3k| const size_t key_hash = Hasher{}(key); 168| 94.3k| const uint8_t tag = HashToTag(key_hash); 169| 94.3k| static constexpr size_t kSlotNotFound = std::numeric_limits::max(); 170| | 171| | // This for loop does in reality at most two attempts: 172| | // The first iteration either: 173| | // - Early-returns, because the key exists already, 174| | // - Finds an insertion slot and proceeds because the load is < limit. 175| | // The second iteration is only hit in the unlikely case of this insertion 176| | // bringing the table beyond the target |load_limit_| (or the edge case 177| | // of the HT being full, if |load_limit_pct_| = 100). 178| | // We cannot simply pre-grow the table before insertion, because we must 179| | // guarantee that calling Insert() with a key that already exists doesn't 180| | // invalidate iterators. 181| 94.3k| size_t insertion_slot; 182| 94.3k| size_t probe_len; 183| 94.9k| for (;;) { 184| 94.9k| PERFETTO_DCHECK((capacity_ & (capacity_ - 1)) == 0); // Must be a pow2. 185| 94.9k| insertion_slot = kSlotNotFound; 186| | // Start the iteration at the desired slot (key_hash % capacity_) 187| | // searching either for a free slot or a tombstone. In the worst case we 188| | // might end up scanning the whole array of slots. The Probe functions are 189| | // guaranteed to visit all the slots within |capacity_| steps. If we find 190| | // a free slot, we can stop the search immediately (a free slot acts as an 191| | // "end of chain for entries having the same hash". If we find a 192| | // tombstones (a deleted slot) we remember its position, but have to keep 193| | // searching until a free slot to make sure we don't insert a duplicate 194| | // key. 195| 94.9k| for (probe_len = 0; probe_len < capacity_;) { ------------------ | Branch (195:27): [True: 94.3k, False: 506] ------------------ 196| 94.3k| const size_t idx = Probe::Calc(key_hash, probe_len, capacity_); 197| 94.3k| PERFETTO_DCHECK(idx < capacity_); 198| 94.3k| const uint8_t tag_idx = tags_[idx]; 199| 94.3k| ++probe_len; 200| 94.3k| if (tag_idx == kFreeSlot) { ------------------ | Branch (200:13): [True: 506, False: 93.8k] ------------------ 201| | // Rationale for "insertion_slot == kSlotNotFound": if we encountered 202| | // a tombstone while iterating we should reuse that rather than 203| | // taking another slot. 204| 506| if (AppendOnly || insertion_slot == kSlotNotFound) ------------------ | Branch (204:15): [Folded - Ignored] | Branch (204:29): [True: 506, False: 0] ------------------ 205| 506| insertion_slot = idx; 206| 506| break; 207| 506| } 208| | // We should never encounter tombstones in AppendOnly mode. 209| 93.8k| PERFETTO_DCHECK(!(tag_idx == kTombstone && AppendOnly)); 210| 93.8k| if (!AppendOnly && tag_idx == kTombstone) { ------------------ | Branch (210:13): [Folded - Ignored] | Branch (210:28): [True: 0, False: 93.8k] ------------------ 211| 0| insertion_slot = idx; 212| 0| continue; 213| 0| } 214| 93.8k| if (tag_idx == tag && keys_[idx] == key) { ------------------ | Branch (214:13): [True: 93.8k, False: 0] | Branch (214:31): [True: 93.8k, False: 0] ------------------ 215| | // The key is already in the map. 216| 93.8k| return std::make_pair(&values_[idx], false); 217| 93.8k| } 218| 93.8k| } // for (idx) 219| | 220| | // If we got to this point the key does not exist (otherwise we would have 221| | // hit the return above) and we are going to insert a new entry. 222| | // Before doing so, ensure we stay under the target load limit. 223| 1.01k| if (PERFETTO_UNLIKELY(size_ >= load_limit_)) { ------------------ | | 24| 1.01k|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 506, False: 506] | | ------------------ ------------------ 224| 506| MaybeGrowAndRehash(/*grow=*/true); 225| 506| continue; 226| 506| } 227| 506| PERFETTO_DCHECK(insertion_slot != kSlotNotFound); 228| 506| break; 229| 1.01k| } // for (attempt) 230| | 231| 506| PERFETTO_CHECK(insertion_slot < capacity_); 232| | 233| | // We found a free slot (or a tombstone). Proceed with the insertion. 234| 506| Value* value_idx = &values_[insertion_slot]; 235| 506| new (&keys_[insertion_slot]) Key(std::move(key)); 236| 506| new (value_idx) Value(std::move(value)); 237| 506| tags_[insertion_slot] = tag; 238| 506| PERFETTO_DCHECK(probe_len > 0 && probe_len <= capacity_); 239| 506| max_probe_length_ = std::max(max_probe_length_, probe_len); 240| 506| size_++; 241| | 242| 506| return std::make_pair(value_idx, true); 243| 506| } _ZN8perfetto4base11FlatHashMapIjNSt3__110unique_ptrINS_15trace_processor19InternedMessageViewENS2_14default_deleteIS5_EEEENS0_4HashIjEENS0_14QuadraticProbeELb0EE9HashToTagEm: 374| 94.3k| static inline uint8_t HashToTag(size_t full_hash) { 375| 94.3k| uint8_t tag = full_hash >> (sizeof(full_hash) * 8 - 8); 376| | // Ensure the hash is always >= 2. We use 0, 1 for kFreeSlot and kTombstone. 377| 94.3k| tag += (tag <= kTombstone) << 1; 378| 94.3k| PERFETTO_DCHECK(tag > kTombstone); 379| 94.3k| return tag; 380| 94.3k| } _ZN8perfetto4base11FlatHashMapIllNS0_4HashIlEENS0_14QuadraticProbeELb0EE5ClearEv: 262| 2.03k| void Clear() { 263| | // Avoid trivial heap operations on zero-capacity std::move()-d objects. 264| 2.03k| if (PERFETTO_UNLIKELY(capacity_ == 0)) ------------------ | | 24| 2.03k|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 2.03k, False: 0] | | ------------------ ------------------ 265| 2.03k| return; 266| | 267| 0| for (size_t i = 0; i < capacity_; ++i) { ------------------ | Branch (267:24): [True: 0, False: 0] ------------------ 268| 0| const uint8_t tag = tags_[i]; 269| 0| if (tag != kFreeSlot && tag != kTombstone) ------------------ | Branch (269:11): [True: 0, False: 0] | Branch (269:31): [True: 0, False: 0] ------------------ 270| 0| EraseInternal(i); 271| 0| } 272| | // Clear all tombstones. We really need to do this for AppendOnly. 273| 0| MaybeGrowAndRehash(/*grow=*/false); 274| 0| } _ZNK8perfetto4base11FlatHashMapIjNS_15trace_processor16ProtoTraceReader19SequenceScopedStateENS0_4HashIjEENS0_14QuadraticProbeELb0EE4FindERKj: 245| 7.87M| Value* Find(const Key& key) const { 246| 7.87M| const size_t idx = FindInternal(key); 247| 7.87M| if (idx == kNotFound) ------------------ | Branch (247:9): [True: 0, False: 7.87M] ------------------ 248| 0| return nullptr; 249| 7.87M| return &values_[idx]; 250| 7.87M| } _ZNK8perfetto4base11FlatHashMapIjNS_15trace_processor16ProtoTraceReader19SequenceScopedStateENS0_4HashIjEENS0_14QuadraticProbeELb0EE12FindInternalERKj: 293| 7.87M| size_t FindInternal(const Key& key) const { 294| 7.87M| const size_t key_hash = Hasher{}(key); 295| 7.87M| const uint8_t tag = HashToTag(key_hash); 296| 7.87M| PERFETTO_DCHECK((capacity_ & (capacity_ - 1)) == 0); // Must be a pow2. 297| 7.87M| PERFETTO_DCHECK(max_probe_length_ <= capacity_); 298| 7.95M| for (size_t i = 0; i < max_probe_length_; ++i) { ------------------ | Branch (298:24): [True: 7.95M, False: 0] ------------------ 299| 7.95M| const size_t idx = Probe::Calc(key_hash, i, capacity_); 300| 7.95M| const uint8_t tag_idx = tags_[idx]; 301| | 302| 7.95M| if (tag_idx == kFreeSlot) ------------------ | Branch (302:11): [True: 0, False: 7.95M] ------------------ 303| 0| return kNotFound; 304| | // HashToTag() never returns kTombstone, so the tag-check below cannot 305| | // possibly match. Also we just want to skip tombstones. 306| 7.95M| if (tag_idx == tag && keys_[idx] == key) { ------------------ | Branch (306:11): [True: 7.87M, False: 75.5k] | Branch (306:29): [True: 7.87M, False: 214] ------------------ 307| 7.87M| PERFETTO_DCHECK(tag_idx > kTombstone); 308| 7.87M| return idx; 309| 7.87M| } 310| 7.95M| } // for (idx) 311| 0| return kNotFound; 312| 7.87M| } _ZN8perfetto4base11FlatHashMapIjNS_15trace_processor16ProtoTraceReader19SequenceScopedStateENS0_4HashIjEENS0_14QuadraticProbeELb0EE9HashToTagEm: 374| 11.9M| static inline uint8_t HashToTag(size_t full_hash) { 375| 11.9M| uint8_t tag = full_hash >> (sizeof(full_hash) * 8 - 8); 376| | // Ensure the hash is always >= 2. We use 0, 1 for kFreeSlot and kTombstone. 377| 11.9M| tag += (tag <= kTombstone) << 1; 378| 11.9M| PERFETTO_DCHECK(tag > kTombstone); 379| 11.9M| return tag; 380| 11.9M| } _ZN8perfetto4base11FlatHashMapINS_15trace_processor9TraceTypeENSt3__18functionIFNS4_10unique_ptrINS2_18ChunkedTraceReaderENS4_14default_deleteIS7_EEEEPNS2_21TraceProcessorContextEEEENS0_4HashIS3_EENS0_14QuadraticProbeELb0EE5ResetEm: 359| 868| PERFETTO_NO_INLINE void Reset(size_t n) { 360| 868| PERFETTO_DCHECK((n & (n - 1)) == 0); // Must be a pow2. 361| | 362| 868| capacity_ = n; 363| 868| max_probe_length_ = 0; 364| 868| size_ = 0; 365| 868| load_limit_ = n * static_cast(load_limit_percent_) / 100; 366| 868| load_limit_ = std::min(load_limit_, n); 367| | 368| 868| tags_.reset(new uint8_t[n]); 369| 868| memset(&tags_[0], 0, n); // Clear all tags. 370| 868| keys_ = AlignedAllocTyped(n); // Deliberately not 0-initialized. 371| 868| values_ = AlignedAllocTyped(n); // Deliberately not 0-initialized. 372| 868| } _ZN8perfetto4base11FlatHashMapINS_15trace_processor9TraceTypeENSt3__18functionIFNS4_10unique_ptrINS2_18ChunkedTraceReaderENS4_14default_deleteIS7_EEEEPNS2_21TraceProcessorContextEEEENS0_4HashIS3_EENS0_14QuadraticProbeELb0EE5ClearEv: 262| 2.03k| void Clear() { 263| | // Avoid trivial heap operations on zero-capacity std::move()-d objects. 264| 2.03k| if (PERFETTO_UNLIKELY(capacity_ == 0)) ------------------ | | 24| 2.03k|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 1.60k, False: 434] | | ------------------ ------------------ 265| 1.60k| return; 266| | 267| 444k| for (size_t i = 0; i < capacity_; ++i) { ------------------ | Branch (267:24): [True: 444k, False: 434] ------------------ 268| 444k| const uint8_t tag = tags_[i]; 269| 444k| if (tag != kFreeSlot && tag != kTombstone) ------------------ | Branch (269:11): [True: 868, False: 443k] | Branch (269:31): [True: 868, False: 0] ------------------ 270| 868| EraseInternal(i); 271| 444k| } 272| | // Clear all tombstones. We really need to do this for AppendOnly. 273| 434| MaybeGrowAndRehash(/*grow=*/false); 274| 434| } _ZN8perfetto4base11FlatHashMapINS_15trace_processor9TraceTypeENSt3__18functionIFNS4_10unique_ptrINS2_18ChunkedTraceReaderENS4_14default_deleteIS7_EEEEPNS2_21TraceProcessorContextEEEENS0_4HashIS3_EENS0_14QuadraticProbeELb0EE13EraseInternalEm: 314| 868| void EraseInternal(size_t idx) { 315| 868| PERFETTO_DCHECK(tags_[idx] > kTombstone); 316| 868| PERFETTO_DCHECK(size_ > 0); 317| 868| tags_[idx] = kTombstone; 318| 868| keys_[idx].~Key(); 319| 868| values_[idx].~Value(); 320| 868| size_--; 321| 868| } _ZN8perfetto4base11FlatHashMapINS_15trace_processor9TraceTypeENSt3__18functionIFNS4_10unique_ptrINS2_18ChunkedTraceReaderENS4_14default_deleteIS7_EEEEPNS2_21TraceProcessorContextEEEENS0_4HashIS3_EENS0_14QuadraticProbeELb0EE18MaybeGrowAndRehashEb: 323| 868| PERFETTO_NO_INLINE void MaybeGrowAndRehash(bool grow) { 324| 868| PERFETTO_DCHECK(size_ <= capacity_); 325| 868| const size_t old_capacity = capacity_; 326| | 327| | // Grow quickly up to 1MB, then chill. 328| 868| const size_t old_size_bytes = old_capacity * (sizeof(Key) + sizeof(Value)); 329| 868| const size_t grow_factor = old_size_bytes < (1024u * 1024u) ? 8 : 2; ------------------ | Branch (329:32): [True: 868, False: 0] ------------------ 330| 868| const size_t new_capacity = 331| 868| grow ? std::max(old_capacity * grow_factor, size_t(1024)) ------------------ | Branch (331:9): [True: 434, False: 434] ------------------ 332| 868| : old_capacity; 333| | 334| 868| auto old_tags(std::move(tags_)); 335| 868| auto old_keys(std::move(keys_)); 336| 868| auto old_values(std::move(values_)); 337| 868| size_t old_size = size_; 338| | 339| | // This must be a CHECK (i.e. not just a DCHECK) to prevent UAF attacks on 340| | // 32-bit archs that try to double the size of the table until wrapping. 341| 868| PERFETTO_CHECK(new_capacity >= old_capacity); 342| 868| Reset(new_capacity); 343| | 344| 868| size_t new_size = 0; // Recompute the size. 345| 445k| for (size_t i = 0; i < old_capacity; ++i) { ------------------ | Branch (345:24): [True: 444k, False: 868] ------------------ 346| 444k| const uint8_t old_tag = old_tags[i]; 347| 444k| if (old_tag != kFreeSlot && old_tag != kTombstone) { ------------------ | Branch (347:11): [True: 868, False: 443k] | Branch (347:35): [True: 0, False: 868] ------------------ 348| 0| Insert(std::move(old_keys[i]), std::move(old_values[i])); 349| 0| old_keys[i].~Key(); // Destroy the old objects. 350| 0| old_values[i].~Value(); 351| 0| new_size++; 352| 0| } 353| 444k| } 354| 868| PERFETTO_DCHECK(new_size == old_size); 355| 868| size_ = new_size; 356| 868| } _ZN8perfetto4base11FlatHashMapINS_15trace_processor9TraceTypeENSt3__18functionIFNS4_10unique_ptrINS2_18ChunkedTraceReaderENS4_14default_deleteIS7_EEEEPNS2_21TraceProcessorContextEEEENS0_4HashIS3_EENS0_14QuadraticProbeELb0EE6InsertES3_SE_: 166| 868| std::pair Insert(Key key, Value value) { 167| 868| const size_t key_hash = Hasher{}(key); 168| 868| const uint8_t tag = HashToTag(key_hash); 169| 868| static constexpr size_t kSlotNotFound = std::numeric_limits::max(); 170| | 171| | // This for loop does in reality at most two attempts: 172| | // The first iteration either: 173| | // - Early-returns, because the key exists already, 174| | // - Finds an insertion slot and proceeds because the load is < limit. 175| | // The second iteration is only hit in the unlikely case of this insertion 176| | // bringing the table beyond the target |load_limit_| (or the edge case 177| | // of the HT being full, if |load_limit_pct_| = 100). 178| | // We cannot simply pre-grow the table before insertion, because we must 179| | // guarantee that calling Insert() with a key that already exists doesn't 180| | // invalidate iterators. 181| 868| size_t insertion_slot; 182| 868| size_t probe_len; 183| 1.30k| for (;;) { 184| 1.30k| PERFETTO_DCHECK((capacity_ & (capacity_ - 1)) == 0); // Must be a pow2. 185| 1.30k| insertion_slot = kSlotNotFound; 186| | // Start the iteration at the desired slot (key_hash % capacity_) 187| | // searching either for a free slot or a tombstone. In the worst case we 188| | // might end up scanning the whole array of slots. The Probe functions are 189| | // guaranteed to visit all the slots within |capacity_| steps. If we find 190| | // a free slot, we can stop the search immediately (a free slot acts as an 191| | // "end of chain for entries having the same hash". If we find a 192| | // tombstones (a deleted slot) we remember its position, but have to keep 193| | // searching until a free slot to make sure we don't insert a duplicate 194| | // key. 195| 1.30k| for (probe_len = 0; probe_len < capacity_;) { ------------------ | Branch (195:27): [True: 868, False: 434] ------------------ 196| 868| const size_t idx = Probe::Calc(key_hash, probe_len, capacity_); 197| 868| PERFETTO_DCHECK(idx < capacity_); 198| 868| const uint8_t tag_idx = tags_[idx]; 199| 868| ++probe_len; 200| 868| if (tag_idx == kFreeSlot) { ------------------ | Branch (200:13): [True: 868, False: 0] ------------------ 201| | // Rationale for "insertion_slot == kSlotNotFound": if we encountered 202| | // a tombstone while iterating we should reuse that rather than 203| | // taking another slot. 204| 868| if (AppendOnly || insertion_slot == kSlotNotFound) ------------------ | Branch (204:15): [Folded - Ignored] | Branch (204:29): [True: 868, False: 0] ------------------ 205| 868| insertion_slot = idx; 206| 868| break; 207| 868| } 208| | // We should never encounter tombstones in AppendOnly mode. 209| 0| PERFETTO_DCHECK(!(tag_idx == kTombstone && AppendOnly)); 210| 0| if (!AppendOnly && tag_idx == kTombstone) { ------------------ | Branch (210:13): [Folded - Ignored] | Branch (210:28): [True: 0, False: 0] ------------------ 211| 0| insertion_slot = idx; 212| 0| continue; 213| 0| } 214| 0| if (tag_idx == tag && keys_[idx] == key) { ------------------ | Branch (214:13): [True: 0, False: 0] | Branch (214:31): [True: 0, False: 0] ------------------ 215| | // The key is already in the map. 216| 0| return std::make_pair(&values_[idx], false); 217| 0| } 218| 0| } // for (idx) 219| | 220| | // If we got to this point the key does not exist (otherwise we would have 221| | // hit the return above) and we are going to insert a new entry. 222| | // Before doing so, ensure we stay under the target load limit. 223| 1.30k| if (PERFETTO_UNLIKELY(size_ >= load_limit_)) { ------------------ | | 24| 1.30k|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 434, False: 868] | | ------------------ ------------------ 224| 434| MaybeGrowAndRehash(/*grow=*/true); 225| 434| continue; 226| 434| } 227| 868| PERFETTO_DCHECK(insertion_slot != kSlotNotFound); 228| 868| break; 229| 1.30k| } // for (attempt) 230| | 231| 868| PERFETTO_CHECK(insertion_slot < capacity_); 232| | 233| | // We found a free slot (or a tombstone). Proceed with the insertion. 234| 868| Value* value_idx = &values_[insertion_slot]; 235| 868| new (&keys_[insertion_slot]) Key(std::move(key)); 236| 868| new (value_idx) Value(std::move(value)); 237| 868| tags_[insertion_slot] = tag; 238| 868| PERFETTO_DCHECK(probe_len > 0 && probe_len <= capacity_); 239| 868| max_probe_length_ = std::max(max_probe_length_, probe_len); 240| 868| size_++; 241| | 242| 868| return std::make_pair(value_idx, true); 243| 868| } _ZN8perfetto4base11FlatHashMapINS_15trace_processor9TraceTypeENSt3__18functionIFNS4_10unique_ptrINS2_18ChunkedTraceReaderENS4_14default_deleteIS7_EEEEPNS2_21TraceProcessorContextEEEENS0_4HashIS3_EENS0_14QuadraticProbeELb0EE9HashToTagEm: 374| 1.29k| static inline uint8_t HashToTag(size_t full_hash) { 375| 1.29k| uint8_t tag = full_hash >> (sizeof(full_hash) * 8 - 8); 376| | // Ensure the hash is always >= 2. We use 0, 1 for kFreeSlot and kTombstone. 377| 1.29k| tag += (tag <= kTombstone) << 1; 378| 1.29k| PERFETTO_DCHECK(tag > kTombstone); 379| 1.29k| return tag; 380| 1.29k| } _ZN8perfetto4base11FlatHashMapINS_15trace_processor9TraceTypeENSt3__18functionIFNS4_10unique_ptrINS2_18ChunkedTraceReaderENS4_14default_deleteIS7_EEEEPNS2_21TraceProcessorContextEEEENS0_4HashIS3_EENS0_14QuadraticProbeELb0EED2Ev: 142| 2.03k| ~FlatHashMap() { Clear(); } _ZN8perfetto4base11FlatHashMapINS_15trace_processor25DeobfuscationMappingTable9PackageIdENS1_INS2_10StringPool2IdENS3_16ClassTranslationENS0_4HashIS6_EENS0_14QuadraticProbeELb0EEENS3_13PackageIdHashESA_Lb0EED2Ev: 142| 2.03k| ~FlatHashMap() { Clear(); } _ZN8perfetto4base11FlatHashMapINS_15trace_processor25DeobfuscationMappingTable9PackageIdENS1_INS2_10StringPool2IdENS3_16ClassTranslationENS0_4HashIS6_EENS0_14QuadraticProbeELb0EEENS3_13PackageIdHashESA_Lb0EE5ClearEv: 262| 2.03k| void Clear() { 263| | // Avoid trivial heap operations on zero-capacity std::move()-d objects. 264| 2.03k| if (PERFETTO_UNLIKELY(capacity_ == 0)) ------------------ | | 24| 2.03k|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 2.03k, False: 0] | | ------------------ ------------------ 265| 2.03k| return; 266| | 267| 0| for (size_t i = 0; i < capacity_; ++i) { ------------------ | Branch (267:24): [True: 0, False: 0] ------------------ 268| 0| const uint8_t tag = tags_[i]; 269| 0| if (tag != kFreeSlot && tag != kTombstone) ------------------ | Branch (269:11): [True: 0, False: 0] | Branch (269:31): [True: 0, False: 0] ------------------ 270| 0| EraseInternal(i); 271| 0| } 272| | // Clear all tombstones. We really need to do this for AppendOnly. 273| 0| MaybeGrowAndRehash(/*grow=*/false); 274| 0| } _ZN8perfetto4base11FlatHashMapINS_15trace_processor10StringPool2IdES4_NS0_4HashIS4_EENS0_14QuadraticProbeELb0EED2Ev: 142| 4.07k| ~FlatHashMap() { Clear(); } _ZN8perfetto4base11FlatHashMapINS_15trace_processor10StringPool2IdES4_NS0_4HashIS4_EENS0_14QuadraticProbeELb0EE5ClearEv: 262| 4.07k| void Clear() { 263| | // Avoid trivial heap operations on zero-capacity std::move()-d objects. 264| 4.07k| if (PERFETTO_UNLIKELY(capacity_ == 0)) ------------------ | | 24| 4.07k|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 4.07k, False: 0] | | ------------------ ------------------ 265| 4.07k| return; 266| | 267| 0| for (size_t i = 0; i < capacity_; ++i) { ------------------ | Branch (267:24): [True: 0, False: 0] ------------------ 268| 0| const uint8_t tag = tags_[i]; 269| 0| if (tag != kFreeSlot && tag != kTombstone) ------------------ | Branch (269:11): [True: 0, False: 0] | Branch (269:31): [True: 0, False: 0] ------------------ 270| 0| EraseInternal(i); 271| 0| } 272| | // Clear all tombstones. We really need to do this for AppendOnly. 273| 0| MaybeGrowAndRehash(/*grow=*/false); 274| 0| } _ZN8perfetto4base11FlatHashMapINS_15trace_processor10StringPool2IdES4_NS0_4HashIS4_EENS0_14QuadraticProbeELb0EE9HashToTagEm: 374| 950k| static inline uint8_t HashToTag(size_t full_hash) { 375| 950k| uint8_t tag = full_hash >> (sizeof(full_hash) * 8 - 8); 376| | // Ensure the hash is always >= 2. We use 0, 1 for kFreeSlot and kTombstone. 377| 950k| tag += (tag <= kTombstone) << 1; 378| 950k| PERFETTO_DCHECK(tag > kTombstone); 379| 950k| return tag; 380| 950k| } _ZN8perfetto4base11FlatHashMapINS_15trace_processor10StringPool2IdES4_NS0_4HashIS4_EENS0_14QuadraticProbeELb0EEC2Emi: 135| 4.07k| : load_limit_percent_(load_limit_pct) { 136| 4.07k| if (initial_capacity > 0) ------------------ | Branch (136:9): [True: 0, False: 4.07k] ------------------ 137| 0| Reset(initial_capacity); 138| 4.07k| } _ZN8perfetto4base11FlatHashMapINSt3__14pairINS_15trace_processor6tables24StackProfileMappingTable2IdEmEENS4_20ArgsTranslationTable14SourceLocationENS0_4HashIS8_EENS0_14QuadraticProbeELb0EED2Ev: 142| 2.03k| ~FlatHashMap() { Clear(); } _ZN8perfetto4base11FlatHashMapINSt3__14pairINS_15trace_processor6tables24StackProfileMappingTable2IdEmEENS4_20ArgsTranslationTable14SourceLocationENS0_4HashIS8_EENS0_14QuadraticProbeELb0EE5ClearEv: 262| 2.03k| void Clear() { 263| | // Avoid trivial heap operations on zero-capacity std::move()-d objects. 264| 2.03k| if (PERFETTO_UNLIKELY(capacity_ == 0)) ------------------ | | 24| 2.03k|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 2.03k, False: 0] | | ------------------ ------------------ 265| 2.03k| return; 266| | 267| 0| for (size_t i = 0; i < capacity_; ++i) { ------------------ | Branch (267:24): [True: 0, False: 0] ------------------ 268| 0| const uint8_t tag = tags_[i]; 269| 0| if (tag != kFreeSlot && tag != kTombstone) ------------------ | Branch (269:11): [True: 0, False: 0] | Branch (269:31): [True: 0, False: 0] ------------------ 270| 0| EraseInternal(i); 271| 0| } 272| | // Clear all tombstones. We really need to do this for AppendOnly. 273| 0| MaybeGrowAndRehash(/*grow=*/false); 274| 0| } _ZN8perfetto4base11FlatHashMapImNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS0_4HashImEENS0_14QuadraticProbeELb0EED2Ev: 142| 10.1k| ~FlatHashMap() { Clear(); } _ZN8perfetto4base11FlatHashMapImNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS0_4HashImEENS0_14QuadraticProbeELb0EE5ClearEv: 262| 10.1k| void Clear() { 263| | // Avoid trivial heap operations on zero-capacity std::move()-d objects. 264| 10.1k| if (PERFETTO_UNLIKELY(capacity_ == 0)) ------------------ | | 24| 10.1k|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 10.1k, False: 0] | | ------------------ ------------------ 265| 10.1k| return; 266| | 267| 0| for (size_t i = 0; i < capacity_; ++i) { ------------------ | Branch (267:24): [True: 0, False: 0] ------------------ 268| 0| const uint8_t tag = tags_[i]; 269| 0| if (tag != kFreeSlot && tag != kTombstone) ------------------ | Branch (269:11): [True: 0, False: 0] | Branch (269:31): [True: 0, False: 0] ------------------ 270| 0| EraseInternal(i); 271| 0| } 272| | // Clear all tombstones. We really need to do this for AppendOnly. 273| 0| MaybeGrowAndRehash(/*grow=*/false); 274| 0| } _ZN8perfetto4base11FlatHashMapImNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS0_4HashImEENS0_14QuadraticProbeELb0EE9HashToTagEm: 374| 8.08M| static inline uint8_t HashToTag(size_t full_hash) { 375| 8.08M| uint8_t tag = full_hash >> (sizeof(full_hash) * 8 - 8); 376| | // Ensure the hash is always >= 2. We use 0, 1 for kFreeSlot and kTombstone. 377| 8.08M| tag += (tag <= kTombstone) << 1; 378| 8.08M| PERFETTO_DCHECK(tag > kTombstone); 379| 8.08M| return tag; 380| 8.08M| } _ZN8perfetto4base11FlatHashMapImNS_15trace_processor6tables10TrackTable2IdENS0_13AlreadyHashedImEENS0_14QuadraticProbeELb0EED2Ev: 142| 2.03k| ~FlatHashMap() { Clear(); } _ZN8perfetto4base11FlatHashMapImNS_15trace_processor6tables10TrackTable2IdENS0_13AlreadyHashedImEENS0_14QuadraticProbeELb0EE5ClearEv: 262| 2.03k| void Clear() { 263| | // Avoid trivial heap operations on zero-capacity std::move()-d objects. 264| 2.03k| if (PERFETTO_UNLIKELY(capacity_ == 0)) ------------------ | | 24| 2.03k|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 1.62k, False: 412] | | ------------------ ------------------ 265| 1.62k| return; 266| | 267| 1.35M| for (size_t i = 0; i < capacity_; ++i) { ------------------ | Branch (267:24): [True: 1.35M, False: 412] ------------------ 268| 1.35M| const uint8_t tag = tags_[i]; 269| 1.35M| if (tag != kFreeSlot && tag != kTombstone) ------------------ | Branch (269:11): [True: 267k, False: 1.08M] | Branch (269:31): [True: 267k, False: 0] ------------------ 270| 267k| EraseInternal(i); 271| 1.35M| } 272| | // Clear all tombstones. We really need to do this for AppendOnly. 273| 412| MaybeGrowAndRehash(/*grow=*/false); 274| 412| } _ZN8perfetto4base11FlatHashMapImNS_15trace_processor6tables10TrackTable2IdENS0_13AlreadyHashedImEENS0_14QuadraticProbeELb0EE13EraseInternalEm: 314| 267k| void EraseInternal(size_t idx) { 315| 267k| PERFETTO_DCHECK(tags_[idx] > kTombstone); 316| 267k| PERFETTO_DCHECK(size_ > 0); 317| 267k| tags_[idx] = kTombstone; 318| 267k| keys_[idx].~Key(); 319| 267k| values_[idx].~Value(); 320| 267k| size_--; 321| 267k| } _ZN8perfetto4base11FlatHashMapImNS_15trace_processor6tables10TrackTable2IdENS0_13AlreadyHashedImEENS0_14QuadraticProbeELb0EE18MaybeGrowAndRehashEb: 323| 933| PERFETTO_NO_INLINE void MaybeGrowAndRehash(bool grow) { 324| 933| PERFETTO_DCHECK(size_ <= capacity_); 325| 933| const size_t old_capacity = capacity_; 326| | 327| | // Grow quickly up to 1MB, then chill. 328| 933| const size_t old_size_bytes = old_capacity * (sizeof(Key) + sizeof(Value)); 329| 933| const size_t grow_factor = old_size_bytes < (1024u * 1024u) ? 8 : 2; ------------------ | Branch (329:32): [True: 933, False: 0] ------------------ 330| 933| const size_t new_capacity = 331| 933| grow ? std::max(old_capacity * grow_factor, size_t(1024)) ------------------ | Branch (331:9): [True: 521, False: 412] ------------------ 332| 933| : old_capacity; 333| | 334| 933| auto old_tags(std::move(tags_)); 335| 933| auto old_keys(std::move(keys_)); 336| 933| auto old_values(std::move(values_)); 337| 933| size_t old_size = size_; 338| | 339| | // This must be a CHECK (i.e. not just a DCHECK) to prevent UAF attacks on 340| | // 32-bit archs that try to double the size of the table until wrapping. 341| 933| PERFETTO_CHECK(new_capacity >= old_capacity); 342| 933| Reset(new_capacity); 343| | 344| 933| size_t new_size = 0; // Recompute the size. 345| 1.48M| for (size_t i = 0; i < old_capacity; ++i) { ------------------ | Branch (345:24): [True: 1.48M, False: 933] ------------------ 346| 1.48M| const uint8_t old_tag = old_tags[i]; 347| 1.48M| if (old_tag != kFreeSlot && old_tag != kTombstone) { ------------------ | Branch (347:11): [True: 367k, False: 1.11M] | Branch (347:35): [True: 99.8k, False: 267k] ------------------ 348| 99.8k| Insert(std::move(old_keys[i]), std::move(old_values[i])); 349| 99.8k| old_keys[i].~Key(); // Destroy the old objects. 350| 99.8k| old_values[i].~Value(); 351| 99.8k| new_size++; 352| 99.8k| } 353| 1.48M| } 354| 933| PERFETTO_DCHECK(new_size == old_size); 355| 933| size_ = new_size; 356| 933| } _ZN8perfetto4base11FlatHashMapImNS_15trace_processor6tables10TrackTable2IdENS0_13AlreadyHashedImEENS0_14QuadraticProbeELb0EE5ResetEm: 359| 933| PERFETTO_NO_INLINE void Reset(size_t n) { 360| 933| PERFETTO_DCHECK((n & (n - 1)) == 0); // Must be a pow2. 361| | 362| 933| capacity_ = n; 363| 933| max_probe_length_ = 0; 364| 933| size_ = 0; 365| 933| load_limit_ = n * static_cast(load_limit_percent_) / 100; 366| 933| load_limit_ = std::min(load_limit_, n); 367| | 368| 933| tags_.reset(new uint8_t[n]); 369| 933| memset(&tags_[0], 0, n); // Clear all tags. 370| 933| keys_ = AlignedAllocTyped(n); // Deliberately not 0-initialized. 371| 933| values_ = AlignedAllocTyped(n); // Deliberately not 0-initialized. 372| 933| } _ZN8perfetto4base11FlatHashMapImNS_15trace_processor6tables10TrackTable2IdENS0_13AlreadyHashedImEENS0_14QuadraticProbeELb0EE6InsertEmS5_: 166| 683k| std::pair Insert(Key key, Value value) { 167| 683k| const size_t key_hash = Hasher{}(key); 168| 683k| const uint8_t tag = HashToTag(key_hash); 169| 683k| static constexpr size_t kSlotNotFound = std::numeric_limits::max(); 170| | 171| | // This for loop does in reality at most two attempts: 172| | // The first iteration either: 173| | // - Early-returns, because the key exists already, 174| | // - Finds an insertion slot and proceeds because the load is < limit. 175| | // The second iteration is only hit in the unlikely case of this insertion 176| | // bringing the table beyond the target |load_limit_| (or the edge case 177| | // of the HT being full, if |load_limit_pct_| = 100). 178| | // We cannot simply pre-grow the table before insertion, because we must 179| | // guarantee that calling Insert() with a key that already exists doesn't 180| | // invalidate iterators. 181| 683k| size_t insertion_slot; 182| 683k| size_t probe_len; 183| 684k| for (;;) { 184| 684k| PERFETTO_DCHECK((capacity_ & (capacity_ - 1)) == 0); // Must be a pow2. 185| 684k| insertion_slot = kSlotNotFound; 186| | // Start the iteration at the desired slot (key_hash % capacity_) 187| | // searching either for a free slot or a tombstone. In the worst case we 188| | // might end up scanning the whole array of slots. The Probe functions are 189| | // guaranteed to visit all the slots within |capacity_| steps. If we find 190| | // a free slot, we can stop the search immediately (a free slot acts as an 191| | // "end of chain for entries having the same hash". If we find a 192| | // tombstones (a deleted slot) we remember its position, but have to keep 193| | // searching until a free slot to make sure we don't insert a duplicate 194| | // key. 195| 860k| for (probe_len = 0; probe_len < capacity_;) { ------------------ | Branch (195:27): [True: 859k, False: 412] ------------------ 196| 859k| const size_t idx = Probe::Calc(key_hash, probe_len, capacity_); 197| 859k| PERFETTO_DCHECK(idx < capacity_); 198| 859k| const uint8_t tag_idx = tags_[idx]; 199| 859k| ++probe_len; 200| 859k| if (tag_idx == kFreeSlot) { ------------------ | Branch (200:13): [True: 367k, False: 492k] ------------------ 201| | // Rationale for "insertion_slot == kSlotNotFound": if we encountered 202| | // a tombstone while iterating we should reuse that rather than 203| | // taking another slot. 204| 367k| if (AppendOnly || insertion_slot == kSlotNotFound) ------------------ | Branch (204:15): [Folded - Ignored] | Branch (204:29): [True: 367k, False: 0] ------------------ 205| 367k| insertion_slot = idx; 206| 367k| break; 207| 367k| } 208| | // We should never encounter tombstones in AppendOnly mode. 209| 492k| PERFETTO_DCHECK(!(tag_idx == kTombstone && AppendOnly)); 210| 492k| if (!AppendOnly && tag_idx == kTombstone) { ------------------ | Branch (210:13): [Folded - Ignored] | Branch (210:28): [True: 0, False: 492k] ------------------ 211| 0| insertion_slot = idx; 212| 0| continue; 213| 0| } 214| 492k| if (tag_idx == tag && keys_[idx] == key) { ------------------ | Branch (214:13): [True: 316k, False: 175k] | Branch (214:31): [True: 315k, False: 518] ------------------ 215| | // The key is already in the map. 216| 315k| return std::make_pair(&values_[idx], false); 217| 315k| } 218| 492k| } // for (idx) 219| | 220| | // If we got to this point the key does not exist (otherwise we would have 221| | // hit the return above) and we are going to insert a new entry. 222| | // Before doing so, ensure we stay under the target load limit. 223| 368k| if (PERFETTO_UNLIKELY(size_ >= load_limit_)) { ------------------ | | 24| 368k|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 521, False: 367k] | | ------------------ ------------------ 224| 521| MaybeGrowAndRehash(/*grow=*/true); 225| 521| continue; 226| 521| } 227| 367k| PERFETTO_DCHECK(insertion_slot != kSlotNotFound); 228| 367k| break; 229| 368k| } // for (attempt) 230| | 231| 367k| PERFETTO_CHECK(insertion_slot < capacity_); 232| | 233| | // We found a free slot (or a tombstone). Proceed with the insertion. 234| 367k| Value* value_idx = &values_[insertion_slot]; 235| 367k| new (&keys_[insertion_slot]) Key(std::move(key)); 236| 367k| new (value_idx) Value(std::move(value)); 237| 367k| tags_[insertion_slot] = tag; 238| 367k| PERFETTO_DCHECK(probe_len > 0 && probe_len <= capacity_); 239| 367k| max_probe_length_ = std::max(max_probe_length_, probe_len); 240| 367k| size_++; 241| | 242| 367k| return std::make_pair(value_idx, true); 243| 367k| } _ZN8perfetto4base11FlatHashMapImNS_15trace_processor6tables10TrackTable2IdENS0_13AlreadyHashedImEENS0_14QuadraticProbeELb0EE9HashToTagEm: 374| 683k| static inline uint8_t HashToTag(size_t full_hash) { 375| 683k| uint8_t tag = full_hash >> (sizeof(full_hash) * 8 - 8); 376| | // Ensure the hash is always >= 2. We use 0, 1 for kFreeSlot and kTombstone. 377| 683k| tag += (tag <= kTombstone) << 1; 378| 683k| PERFETTO_DCHECK(tag > kTombstone); 379| 683k| return tag; 380| 683k| } _ZN8perfetto4base11FlatHashMapImNS_15trace_processor15TrackCompressor11TrackSetNewENS0_13AlreadyHashedImEENS0_14QuadraticProbeELb0EED2Ev: 142| 2.03k| ~FlatHashMap() { Clear(); } _ZN8perfetto4base11FlatHashMapImNS_15trace_processor15TrackCompressor11TrackSetNewENS0_13AlreadyHashedImEENS0_14QuadraticProbeELb0EE5ClearEv: 262| 2.03k| void Clear() { 263| | // Avoid trivial heap operations on zero-capacity std::move()-d objects. 264| 2.03k| if (PERFETTO_UNLIKELY(capacity_ == 0)) ------------------ | | 24| 2.03k|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 2.03k, False: 0] | | ------------------ ------------------ 265| 2.03k| return; 266| | 267| 0| for (size_t i = 0; i < capacity_; ++i) { ------------------ | Branch (267:24): [True: 0, False: 0] ------------------ 268| 0| const uint8_t tag = tags_[i]; 269| 0| if (tag != kFreeSlot && tag != kTombstone) ------------------ | Branch (269:11): [True: 0, False: 0] | Branch (269:31): [True: 0, False: 0] ------------------ 270| 0| EraseInternal(i); 271| 0| } 272| | // Clear all tombstones. We really need to do this for AppendOnly. 273| 0| MaybeGrowAndRehash(/*grow=*/false); 274| 0| } _ZN8perfetto4base11FlatHashMapIlNSt3__13mapIllNS2_4lessIlEENS2_9allocatorINS2_4pairIKllEEEEEENS0_4HashIlEENS0_14QuadraticProbeELb0EED2Ev: 142| 2.03k| ~FlatHashMap() { Clear(); } _ZN8perfetto4base11FlatHashMapIlNSt3__13mapIllNS2_4lessIlEENS2_9allocatorINS2_4pairIKllEEEEEENS0_4HashIlEENS0_14QuadraticProbeELb0EE5ClearEv: 262| 2.03k| void Clear() { 263| | // Avoid trivial heap operations on zero-capacity std::move()-d objects. 264| 2.03k| if (PERFETTO_UNLIKELY(capacity_ == 0)) ------------------ | | 24| 2.03k|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 2.03k, False: 0] | | ------------------ ------------------ 265| 2.03k| return; 266| | 267| 0| for (size_t i = 0; i < capacity_; ++i) { ------------------ | Branch (267:24): [True: 0, False: 0] ------------------ 268| 0| const uint8_t tag = tags_[i]; 269| 0| if (tag != kFreeSlot && tag != kTombstone) ------------------ | Branch (269:11): [True: 0, False: 0] | Branch (269:31): [True: 0, False: 0] ------------------ 270| 0| EraseInternal(i); 271| 0| } 272| | // Clear all tombstones. We really need to do this for AppendOnly. 273| 0| MaybeGrowAndRehash(/*grow=*/false); 274| 0| } _ZN8perfetto4base11FlatHashMapIjNS_15trace_processor15AddressRangeMapIPNS2_8JitCacheEEENS0_4HashIjEENS0_14QuadraticProbeELb0EED2Ev: 142| 2.03k| ~FlatHashMap() { Clear(); } _ZN8perfetto4base11FlatHashMapIjNS_15trace_processor15AddressRangeMapIPNS2_8JitCacheEEENS0_4HashIjEENS0_14QuadraticProbeELb0EE5ClearEv: 262| 2.03k| void Clear() { 263| | // Avoid trivial heap operations on zero-capacity std::move()-d objects. 264| 2.03k| if (PERFETTO_UNLIKELY(capacity_ == 0)) ------------------ | | 24| 2.03k|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 2.03k, False: 0] | | ------------------ ------------------ 265| 2.03k| return; 266| | 267| 0| for (size_t i = 0; i < capacity_; ++i) { ------------------ | Branch (267:24): [True: 0, False: 0] ------------------ 268| 0| const uint8_t tag = tags_[i]; 269| 0| if (tag != kFreeSlot && tag != kTombstone) ------------------ | Branch (269:11): [True: 0, False: 0] | Branch (269:31): [True: 0, False: 0] ------------------ 270| 0| EraseInternal(i); 271| 0| } 272| | // Clear all tombstones. We really need to do this for AppendOnly. 273| 0| MaybeGrowAndRehash(/*grow=*/false); 274| 0| } _ZN8perfetto4base11FlatHashMapIjNS_15trace_processor15AddressRangeMapIPNS2_17UserMemoryMappingEEENS0_4HashIjEENS0_14QuadraticProbeELb0EED2Ev: 142| 2.03k| ~FlatHashMap() { Clear(); } _ZN8perfetto4base11FlatHashMapIjNS_15trace_processor15AddressRangeMapIPNS2_17UserMemoryMappingEEENS0_4HashIjEENS0_14QuadraticProbeELb0EE5ClearEv: 262| 2.03k| void Clear() { 263| | // Avoid trivial heap operations on zero-capacity std::move()-d objects. 264| 2.03k| if (PERFETTO_UNLIKELY(capacity_ == 0)) ------------------ | | 24| 2.03k|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 2.03k, False: 0] | | ------------------ ------------------ 265| 2.03k| return; 266| | 267| 0| for (size_t i = 0; i < capacity_; ++i) { ------------------ | Branch (267:24): [True: 0, False: 0] ------------------ 268| 0| const uint8_t tag = tags_[i]; 269| 0| if (tag != kFreeSlot && tag != kTombstone) ------------------ | Branch (269:11): [True: 0, False: 0] | Branch (269:31): [True: 0, False: 0] ------------------ 270| 0| EraseInternal(i); 271| 0| } 272| | // Clear all tombstones. We really need to do this for AppendOnly. 273| 0| MaybeGrowAndRehash(/*grow=*/false); 274| 0| } _ZN8perfetto4base11FlatHashMapINS_15trace_processor14MappingTracker14NameAndBuildIdENSt3__16vectorIPNS2_20VirtualMemoryMappingENS5_9allocatorIS8_EEEENS4_6HasherENS0_14QuadraticProbeELb0EED2Ev: 142| 2.03k| ~FlatHashMap() { Clear(); } _ZN8perfetto4base11FlatHashMapINS_15trace_processor14MappingTracker14NameAndBuildIdENSt3__16vectorIPNS2_20VirtualMemoryMappingENS5_9allocatorIS8_EEEENS4_6HasherENS0_14QuadraticProbeELb0EE5ClearEv: 262| 2.03k| void Clear() { 263| | // Avoid trivial heap operations on zero-capacity std::move()-d objects. 264| 2.03k| if (PERFETTO_UNLIKELY(capacity_ == 0)) ------------------ | | 24| 2.03k|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 2.03k, False: 0] | | ------------------ ------------------ 265| 2.03k| return; 266| | 267| 0| for (size_t i = 0; i < capacity_; ++i) { ------------------ | Branch (267:24): [True: 0, False: 0] ------------------ 268| 0| const uint8_t tag = tags_[i]; 269| 0| if (tag != kFreeSlot && tag != kTombstone) ------------------ | Branch (269:11): [True: 0, False: 0] | Branch (269:31): [True: 0, False: 0] ------------------ 270| 0| EraseInternal(i); 271| 0| } 272| | // Clear all tombstones. We really need to do this for AppendOnly. 273| 0| MaybeGrowAndRehash(/*grow=*/false); 274| 0| } _ZN8perfetto4base11FlatHashMapINS_15trace_processor19CreateMappingParamsEPNS2_20VirtualMemoryMappingENS3_6HasherENS0_14QuadraticProbeELb0EED2Ev: 142| 2.03k| ~FlatHashMap() { Clear(); } _ZN8perfetto4base11FlatHashMapINS_15trace_processor19CreateMappingParamsEPNS2_20VirtualMemoryMappingENS3_6HasherENS0_14QuadraticProbeELb0EE5ClearEv: 262| 2.03k| void Clear() { 263| | // Avoid trivial heap operations on zero-capacity std::move()-d objects. 264| 2.03k| if (PERFETTO_UNLIKELY(capacity_ == 0)) ------------------ | | 24| 2.03k|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 2.03k, False: 0] | | ------------------ ------------------ 265| 2.03k| return; 266| | 267| 0| for (size_t i = 0; i < capacity_; ++i) { ------------------ | Branch (267:24): [True: 0, False: 0] ------------------ 268| 0| const uint8_t tag = tags_[i]; 269| 0| if (tag != kFreeSlot && tag != kTombstone) ------------------ | Branch (269:11): [True: 0, False: 0] | Branch (269:31): [True: 0, False: 0] ------------------ 270| 0| EraseInternal(i); 271| 0| } 272| | // Clear all tombstones. We really need to do this for AppendOnly. 273| 0| MaybeGrowAndRehash(/*grow=*/false); 274| 0| } _ZN8perfetto4base11FlatHashMapINS_15trace_processor6tables24StackProfileMappingTable2IdENSt3__110unique_ptrINS2_20VirtualMemoryMappingENS6_14default_deleteIS8_EEEENS0_4HashIS5_EENS0_14QuadraticProbeELb0EED2Ev: 142| 2.03k| ~FlatHashMap() { Clear(); } _ZN8perfetto4base11FlatHashMapINS_15trace_processor6tables24StackProfileMappingTable2IdENSt3__110unique_ptrINS2_20VirtualMemoryMappingENS6_14default_deleteIS8_EEEENS0_4HashIS5_EENS0_14QuadraticProbeELb0EE5ClearEv: 262| 2.03k| void Clear() { 263| | // Avoid trivial heap operations on zero-capacity std::move()-d objects. 264| 2.03k| if (PERFETTO_UNLIKELY(capacity_ == 0)) ------------------ | | 24| 2.03k|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 2.03k, False: 0] | | ------------------ ------------------ 265| 2.03k| return; 266| | 267| 0| for (size_t i = 0; i < capacity_; ++i) { ------------------ | Branch (267:24): [True: 0, False: 0] ------------------ 268| 0| const uint8_t tag = tags_[i]; 269| 0| if (tag != kFreeSlot && tag != kTombstone) ------------------ | Branch (269:11): [True: 0, False: 0] | Branch (269:31): [True: 0, False: 0] ------------------ 270| 0| EraseInternal(i); 271| 0| } 272| | // Clear all tombstones. We really need to do this for AppendOnly. 273| 0| MaybeGrowAndRehash(/*grow=*/false); 274| 0| } _ZN8perfetto4base11FlatHashMapINS_15trace_processor13NameInPackageENSt3__16vectorINS2_6tables22StackProfileFrameTable2IdENS4_9allocatorIS8_EEEENS3_6HasherENS0_14QuadraticProbeELb0EED2Ev: 142| 2.03k| ~FlatHashMap() { Clear(); } _ZN8perfetto4base11FlatHashMapINS_15trace_processor13NameInPackageENSt3__16vectorINS2_6tables22StackProfileFrameTable2IdENS4_9allocatorIS8_EEEENS3_6HasherENS0_14QuadraticProbeELb0EE5ClearEv: 262| 2.03k| void Clear() { 263| | // Avoid trivial heap operations on zero-capacity std::move()-d objects. 264| 2.03k| if (PERFETTO_UNLIKELY(capacity_ == 0)) ------------------ | | 24| 2.03k|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 2.03k, False: 0] | | ------------------ ------------------ 265| 2.03k| return; 266| | 267| 0| for (size_t i = 0; i < capacity_; ++i) { ------------------ | Branch (267:24): [True: 0, False: 0] ------------------ 268| 0| const uint8_t tag = tags_[i]; 269| 0| if (tag != kFreeSlot && tag != kTombstone) ------------------ | Branch (269:11): [True: 0, False: 0] | Branch (269:31): [True: 0, False: 0] ------------------ 270| 0| EraseInternal(i); 271| 0| } 272| | // Clear all tombstones. We really need to do this for AppendOnly. 273| 0| MaybeGrowAndRehash(/*grow=*/false); 274| 0| } _ZN8perfetto4base11FlatHashMapINS_15trace_processor6tables25StackProfileCallsiteTable3RowENS4_2IdENS0_4HashIS5_EENS0_14QuadraticProbeELb0EED2Ev: 142| 2.03k| ~FlatHashMap() { Clear(); } _ZN8perfetto4base11FlatHashMapINS_15trace_processor6tables25StackProfileCallsiteTable3RowENS4_2IdENS0_4HashIS5_EENS0_14QuadraticProbeELb0EE5ClearEv: 262| 2.03k| void Clear() { 263| | // Avoid trivial heap operations on zero-capacity std::move()-d objects. 264| 2.03k| if (PERFETTO_UNLIKELY(capacity_ == 0)) ------------------ | | 24| 2.03k|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 2.03k, False: 0] | | ------------------ ------------------ 265| 2.03k| return; 266| | 267| 0| for (size_t i = 0; i < capacity_; ++i) { ------------------ | Branch (267:24): [True: 0, False: 0] ------------------ 268| 0| const uint8_t tag = tags_[i]; 269| 0| if (tag != kFreeSlot && tag != kTombstone) ------------------ | Branch (269:11): [True: 0, False: 0] | Branch (269:31): [True: 0, False: 0] ------------------ 270| 0| EraseInternal(i); 271| 0| } 272| | // Clear all tombstones. We really need to do this for AppendOnly. 273| 0| MaybeGrowAndRehash(/*grow=*/false); 274| 0| } _ZN8perfetto4base11FlatHashMapINSt3__14pairImjEENS_15trace_processor25LegacyV8CpuProfileTracker5StateENS6_6HasherENS0_14QuadraticProbeELb0EED2Ev: 142| 2.03k| ~FlatHashMap() { Clear(); } _ZN8perfetto4base11FlatHashMapINSt3__14pairImjEENS_15trace_processor25LegacyV8CpuProfileTracker5StateENS6_6HasherENS0_14QuadraticProbeELb0EE5ClearEv: 262| 2.03k| void Clear() { 263| | // Avoid trivial heap operations on zero-capacity std::move()-d objects. 264| 2.03k| if (PERFETTO_UNLIKELY(capacity_ == 0)) ------------------ | | 24| 2.03k|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 2.03k, False: 0] | | ------------------ ------------------ 265| 2.03k| return; 266| | 267| 0| for (size_t i = 0; i < capacity_; ++i) { ------------------ | Branch (267:24): [True: 0, False: 0] ------------------ 268| 0| const uint8_t tag = tags_[i]; 269| 0| if (tag != kFreeSlot && tag != kTombstone) ------------------ | Branch (269:11): [True: 0, False: 0] | Branch (269:31): [True: 0, False: 0] ------------------ 270| 0| EraseInternal(i); 271| 0| } 272| | // Clear all tombstones. We really need to do this for AppendOnly. 273| 0| MaybeGrowAndRehash(/*grow=*/false); 274| 0| } _ZN8perfetto4base11FlatHashMapINS_15trace_processor9TraceTypeENSt3__18functionIFNS4_10unique_ptrINS2_18ChunkedTraceReaderENS4_14default_deleteIS7_EEEEPNS2_21TraceProcessorContextEEEENS0_4HashIS3_EENS0_14QuadraticProbeELb0EEC2Emi: 135| 2.03k| : load_limit_percent_(load_limit_pct) { 136| 2.03k| if (initial_capacity > 0) ------------------ | Branch (136:9): [True: 0, False: 2.03k] ------------------ 137| 0| Reset(initial_capacity); 138| 2.03k| } _ZN8perfetto4base11FlatHashMapINS_15trace_processor6tables24StackProfileMappingTable2IdENSt3__110unique_ptrINS2_20VirtualMemoryMappingENS6_14default_deleteIS8_EEEENS0_4HashIS5_EENS0_14QuadraticProbeELb0EEC2Emi: 135| 2.03k| : load_limit_percent_(load_limit_pct) { 136| 2.03k| if (initial_capacity > 0) ------------------ | Branch (136:9): [True: 0, False: 2.03k] ------------------ 137| 0| Reset(initial_capacity); 138| 2.03k| } _ZN8perfetto4base11FlatHashMapINS_15trace_processor19CreateMappingParamsEPNS2_20VirtualMemoryMappingENS3_6HasherENS0_14QuadraticProbeELb0EEC2Emi: 135| 2.03k| : load_limit_percent_(load_limit_pct) { 136| 2.03k| if (initial_capacity > 0) ------------------ | Branch (136:9): [True: 0, False: 2.03k] ------------------ 137| 0| Reset(initial_capacity); 138| 2.03k| } _ZN8perfetto4base11FlatHashMapINS_15trace_processor14MappingTracker14NameAndBuildIdENSt3__16vectorIPNS2_20VirtualMemoryMappingENS5_9allocatorIS8_EEEENS4_6HasherENS0_14QuadraticProbeELb0EEC2Emi: 135| 2.03k| : load_limit_percent_(load_limit_pct) { 136| 2.03k| if (initial_capacity > 0) ------------------ | Branch (136:9): [True: 0, False: 2.03k] ------------------ 137| 0| Reset(initial_capacity); 138| 2.03k| } _ZN8perfetto4base11FlatHashMapIjNS_15trace_processor15AddressRangeMapIPNS2_17UserMemoryMappingEEENS0_4HashIjEENS0_14QuadraticProbeELb0EEC2Emi: 135| 2.03k| : load_limit_percent_(load_limit_pct) { 136| 2.03k| if (initial_capacity > 0) ------------------ | Branch (136:9): [True: 0, False: 2.03k] ------------------ 137| 0| Reset(initial_capacity); 138| 2.03k| } _ZN8perfetto4base11FlatHashMapIjNS_15trace_processor15AddressRangeMapIPNS2_8JitCacheEEENS0_4HashIjEENS0_14QuadraticProbeELb0EEC2Emi: 135| 2.03k| : load_limit_percent_(load_limit_pct) { 136| 2.03k| if (initial_capacity > 0) ------------------ | Branch (136:9): [True: 0, False: 2.03k] ------------------ 137| 0| Reset(initial_capacity); 138| 2.03k| } _ZN8perfetto4base11FlatHashMapINS_15trace_processor6tables25StackProfileCallsiteTable3RowENS4_2IdENS0_4HashIS5_EENS0_14QuadraticProbeELb0EEC2Emi: 135| 2.03k| : load_limit_percent_(load_limit_pct) { 136| 2.03k| if (initial_capacity > 0) ------------------ | Branch (136:9): [True: 0, False: 2.03k] ------------------ 137| 0| Reset(initial_capacity); 138| 2.03k| } _ZN8perfetto4base11FlatHashMapINS_15trace_processor13NameInPackageENSt3__16vectorINS2_6tables22StackProfileFrameTable2IdENS4_9allocatorIS8_EEEENS3_6HasherENS0_14QuadraticProbeELb0EEC2Emi: 135| 2.03k| : load_limit_percent_(load_limit_pct) { 136| 2.03k| if (initial_capacity > 0) ------------------ | Branch (136:9): [True: 0, False: 2.03k] ------------------ 137| 0| Reset(initial_capacity); 138| 2.03k| } _ZN8perfetto4base11FlatHashMapImjNS0_13AlreadyHashedImEENS0_14QuadraticProbeELb0EED2Ev: 142| 2.03k| ~FlatHashMap() { Clear(); } _ZN8perfetto4base11FlatHashMapImjNS0_13AlreadyHashedImEENS0_14QuadraticProbeELb0EE5ClearEv: 262| 2.03k| void Clear() { 263| | // Avoid trivial heap operations on zero-capacity std::move()-d objects. 264| 2.03k| if (PERFETTO_UNLIKELY(capacity_ == 0)) ------------------ | | 24| 2.03k|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 1.62k, False: 412] | | ------------------ ------------------ 265| 1.62k| return; 266| | 267| 5.50M| for (size_t i = 0; i < capacity_; ++i) { ------------------ | Branch (267:24): [True: 5.50M, False: 412] ------------------ 268| 5.50M| const uint8_t tag = tags_[i]; 269| 5.50M| if (tag != kFreeSlot && tag != kTombstone) ------------------ | Branch (269:11): [True: 1.03M, False: 4.46M] | Branch (269:31): [True: 1.03M, False: 0] ------------------ 270| 1.03M| EraseInternal(i); 271| 5.50M| } 272| | // Clear all tombstones. We really need to do this for AppendOnly. 273| 412| MaybeGrowAndRehash(/*grow=*/false); 274| 412| } _ZN8perfetto4base11FlatHashMapImjNS0_13AlreadyHashedImEENS0_14QuadraticProbeELb0EE13EraseInternalEm: 314| 1.03M| void EraseInternal(size_t idx) { 315| 1.03M| PERFETTO_DCHECK(tags_[idx] > kTombstone); 316| 1.03M| PERFETTO_DCHECK(size_ > 0); 317| 1.03M| tags_[idx] = kTombstone; 318| 1.03M| keys_[idx].~Key(); 319| 1.03M| values_[idx].~Value(); 320| 1.03M| size_--; 321| 1.03M| } _ZNK8perfetto4base11FlatHashMapINS_15trace_processor10StringPool2IdES4_NS0_4HashIS4_EENS0_14QuadraticProbeELb0EE4FindERKS4_: 245| 950k| Value* Find(const Key& key) const { 246| 950k| const size_t idx = FindInternal(key); 247| 950k| if (idx == kNotFound) ------------------ | Branch (247:9): [True: 950k, False: 0] ------------------ 248| 950k| return nullptr; 249| 0| return &values_[idx]; 250| 950k| } _ZNK8perfetto4base11FlatHashMapINS_15trace_processor10StringPool2IdES4_NS0_4HashIS4_EENS0_14QuadraticProbeELb0EE12FindInternalERKS4_: 293| 950k| size_t FindInternal(const Key& key) const { 294| 950k| const size_t key_hash = Hasher{}(key); 295| 950k| const uint8_t tag = HashToTag(key_hash); 296| 950k| PERFETTO_DCHECK((capacity_ & (capacity_ - 1)) == 0); // Must be a pow2. 297| 950k| PERFETTO_DCHECK(max_probe_length_ <= capacity_); 298| 950k| for (size_t i = 0; i < max_probe_length_; ++i) { ------------------ | Branch (298:24): [True: 0, False: 950k] ------------------ 299| 0| const size_t idx = Probe::Calc(key_hash, i, capacity_); 300| 0| const uint8_t tag_idx = tags_[idx]; 301| | 302| 0| if (tag_idx == kFreeSlot) ------------------ | Branch (302:11): [True: 0, False: 0] ------------------ 303| 0| return kNotFound; 304| | // HashToTag() never returns kTombstone, so the tag-check below cannot 305| | // possibly match. Also we just want to skip tombstones. 306| 0| if (tag_idx == tag && keys_[idx] == key) { ------------------ | Branch (306:11): [True: 0, False: 0] | Branch (306:29): [True: 0, False: 0] ------------------ 307| 0| PERFETTO_DCHECK(tag_idx > kTombstone); 308| 0| return idx; 309| 0| } 310| 0| } // for (idx) 311| 950k| return kNotFound; 312| 950k| } _ZNK8perfetto4base11FlatHashMapINS_15trace_processor9TraceTypeENSt3__18functionIFNS4_10unique_ptrINS2_18ChunkedTraceReaderENS4_14default_deleteIS7_EEEEPNS2_21TraceProcessorContextEEEENS0_4HashIS3_EENS0_14QuadraticProbeELb0EE4FindERKS3_: 245| 426| Value* Find(const Key& key) const { 246| 426| const size_t idx = FindInternal(key); 247| 426| if (idx == kNotFound) ------------------ | Branch (247:9): [True: 2, False: 424] ------------------ 248| 2| return nullptr; 249| 424| return &values_[idx]; 250| 426| } _ZNK8perfetto4base11FlatHashMapINS_15trace_processor9TraceTypeENSt3__18functionIFNS4_10unique_ptrINS2_18ChunkedTraceReaderENS4_14default_deleteIS7_EEEEPNS2_21TraceProcessorContextEEEENS0_4HashIS3_EENS0_14QuadraticProbeELb0EE12FindInternalERKS3_: 293| 426| size_t FindInternal(const Key& key) const { 294| 426| const size_t key_hash = Hasher{}(key); 295| 426| const uint8_t tag = HashToTag(key_hash); 296| 426| PERFETTO_DCHECK((capacity_ & (capacity_ - 1)) == 0); // Must be a pow2. 297| 426| PERFETTO_DCHECK(max_probe_length_ <= capacity_); 298| 426| for (size_t i = 0; i < max_probe_length_; ++i) { ------------------ | Branch (298:24): [True: 426, False: 0] ------------------ 299| 426| const size_t idx = Probe::Calc(key_hash, i, capacity_); 300| 426| const uint8_t tag_idx = tags_[idx]; 301| | 302| 426| if (tag_idx == kFreeSlot) ------------------ | Branch (302:11): [True: 2, False: 424] ------------------ 303| 2| return kNotFound; 304| | // HashToTag() never returns kTombstone, so the tag-check below cannot 305| | // possibly match. Also we just want to skip tombstones. 306| 424| if (tag_idx == tag && keys_[idx] == key) { ------------------ | Branch (306:11): [True: 424, False: 0] | Branch (306:29): [True: 424, False: 0] ------------------ 307| 424| PERFETTO_DCHECK(tag_idx > kTombstone); 308| 424| return idx; 309| 424| } 310| 424| } // for (idx) 311| 0| return kNotFound; 312| 426| } _ZN8perfetto4base11FlatHashMapImNS_15trace_processor10StringPool2IdENS0_13AlreadyHashedImEENS0_11LinearProbeELb1EEC2Emi: 135| 434| : load_limit_percent_(load_limit_pct) { 136| 434| if (initial_capacity > 0) ------------------ | Branch (136:9): [True: 434, False: 0] ------------------ 137| 434| Reset(initial_capacity); 138| 434| } _ZN8perfetto4base11FlatHashMapImNS_15trace_processor10StringPool2IdENS0_13AlreadyHashedImEENS0_11LinearProbeELb1EED2Ev: 142| 434| ~FlatHashMap() { Clear(); } _ZN8perfetto4base11FlatHashMapImNS_15trace_processor10StringPool2IdENS0_13AlreadyHashedImEENS0_11LinearProbeELb1EE5ClearEv: 262| 434| void Clear() { 263| | // Avoid trivial heap operations on zero-capacity std::move()-d objects. 264| 434| if (PERFETTO_UNLIKELY(capacity_ == 0)) ------------------ | | 24| 434|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 0, False: 434] | | ------------------ ------------------ 265| 0| return; 266| | 267| 1.86M| for (size_t i = 0; i < capacity_; ++i) { ------------------ | Branch (267:24): [True: 1.86M, False: 434] ------------------ 268| 1.86M| const uint8_t tag = tags_[i]; 269| 1.86M| if (tag != kFreeSlot && tag != kTombstone) ------------------ | Branch (269:11): [True: 153k, False: 1.70M] | Branch (269:31): [True: 153k, False: 0] ------------------ 270| 153k| EraseInternal(i); 271| 1.86M| } 272| | // Clear all tombstones. We really need to do this for AppendOnly. 273| 434| MaybeGrowAndRehash(/*grow=*/false); 274| 434| } _ZN8perfetto4base11FlatHashMapImNS_15trace_processor10StringPool2IdENS0_13AlreadyHashedImEENS0_11LinearProbeELb1EE13EraseInternalEm: 314| 153k| void EraseInternal(size_t idx) { 315| 153k| PERFETTO_DCHECK(tags_[idx] > kTombstone); 316| 153k| PERFETTO_DCHECK(size_ > 0); 317| 153k| tags_[idx] = kTombstone; 318| 153k| keys_[idx].~Key(); 319| 153k| values_[idx].~Value(); 320| 153k| size_--; 321| 153k| } _ZN8perfetto4base11FlatHashMapINS_15trace_processor25DeobfuscationMappingTable9PackageIdENS1_INS2_10StringPool2IdENS3_16ClassTranslationENS0_4HashIS6_EENS0_14QuadraticProbeELb0EEENS3_13PackageIdHashESA_Lb0EEC2Emi: 135| 2.03k| : load_limit_percent_(load_limit_pct) { 136| 2.03k| if (initial_capacity > 0) ------------------ | Branch (136:9): [True: 0, False: 2.03k] ------------------ 137| 0| Reset(initial_capacity); 138| 2.03k| } _ZN8perfetto4base11FlatHashMapImNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS0_4HashImEENS0_14QuadraticProbeELb0EEC2Emi: 135| 10.1k| : load_limit_percent_(load_limit_pct) { 136| 10.1k| if (initial_capacity > 0) ------------------ | Branch (136:9): [True: 0, False: 10.1k] ------------------ 137| 0| Reset(initial_capacity); 138| 10.1k| } _ZN8perfetto4base11FlatHashMapINSt3__14pairINS_15trace_processor6tables24StackProfileMappingTable2IdEmEENS4_20ArgsTranslationTable14SourceLocationENS0_4HashIS8_EENS0_14QuadraticProbeELb0EEC2Emi: 135| 2.03k| : load_limit_percent_(load_limit_pct) { 136| 2.03k| if (initial_capacity > 0) ------------------ | Branch (136:9): [True: 0, False: 2.03k] ------------------ 137| 0| Reset(initial_capacity); 138| 2.03k| } _ZNK8perfetto4base11FlatHashMapImNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS0_4HashImEENS0_14QuadraticProbeELb0EE4FindERKm: 245| 8.08M| Value* Find(const Key& key) const { 246| 8.08M| const size_t idx = FindInternal(key); 247| 8.08M| if (idx == kNotFound) ------------------ | Branch (247:9): [True: 8.08M, False: 0] ------------------ 248| 8.08M| return nullptr; 249| 0| return &values_[idx]; 250| 8.08M| } _ZNK8perfetto4base11FlatHashMapImNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS0_4HashImEENS0_14QuadraticProbeELb0EE12FindInternalERKm: 293| 8.08M| size_t FindInternal(const Key& key) const { 294| 8.08M| const size_t key_hash = Hasher{}(key); 295| 8.08M| const uint8_t tag = HashToTag(key_hash); 296| 8.08M| PERFETTO_DCHECK((capacity_ & (capacity_ - 1)) == 0); // Must be a pow2. 297| 8.08M| PERFETTO_DCHECK(max_probe_length_ <= capacity_); 298| 8.08M| for (size_t i = 0; i < max_probe_length_; ++i) { ------------------ | Branch (298:24): [True: 0, False: 8.08M] ------------------ 299| 0| const size_t idx = Probe::Calc(key_hash, i, capacity_); 300| 0| const uint8_t tag_idx = tags_[idx]; 301| | 302| 0| if (tag_idx == kFreeSlot) ------------------ | Branch (302:11): [True: 0, False: 0] ------------------ 303| 0| return kNotFound; 304| | // HashToTag() never returns kTombstone, so the tag-check below cannot 305| | // possibly match. Also we just want to skip tombstones. 306| 0| if (tag_idx == tag && keys_[idx] == key) { ------------------ | Branch (306:11): [True: 0, False: 0] | Branch (306:29): [True: 0, False: 0] ------------------ 307| 0| PERFETTO_DCHECK(tag_idx > kTombstone); 308| 0| return idx; 309| 0| } 310| 0| } // for (idx) 311| 8.08M| return kNotFound; 312| 8.08M| } _ZN8perfetto4base11FlatHashMapIlNSt3__13mapIllNS2_4lessIlEENS2_9allocatorINS2_4pairIKllEEEEEENS0_4HashIlEENS0_14QuadraticProbeELb0EEC2Emi: 135| 2.03k| : load_limit_percent_(load_limit_pct) { 136| 2.03k| if (initial_capacity > 0) ------------------ | Branch (136:9): [True: 0, False: 2.03k] ------------------ 137| 0| Reset(initial_capacity); 138| 2.03k| } _ZN8perfetto4base11FlatHashMapIllNS0_4HashIlEENS0_14QuadraticProbeELb0EEC2Emi: 135| 2.03k| : load_limit_percent_(load_limit_pct) { 136| 2.03k| if (initial_capacity > 0) ------------------ | Branch (136:9): [True: 0, False: 2.03k] ------------------ 137| 0| Reset(initial_capacity); 138| 2.03k| } _ZN8perfetto4base11FlatHashMapIllNS0_4HashIlEENS0_14QuadraticProbeELb0EED2Ev: 142| 2.03k| ~FlatHashMap() { Clear(); } _ZN8perfetto4base11FlatHashMapINS_15trace_processor6tables10TrackTable2IdENSt3__16vectorImNS6_9allocatorImEEEENS0_4HashIS5_EENS0_14QuadraticProbeELb0EEC2Emi: 135| 2.03k| : load_limit_percent_(load_limit_pct) { 136| 2.03k| if (initial_capacity > 0) ------------------ | Branch (136:9): [True: 0, False: 2.03k] ------------------ 137| 0| Reset(initial_capacity); 138| 2.03k| } _ZN8perfetto4base11FlatHashMapINS_15trace_processor6tables10TrackTable2IdENSt3__16vectorImNS6_9allocatorImEEEENS0_4HashIS5_EENS0_14QuadraticProbeELb0EE5ResetEm: 359| 70| PERFETTO_NO_INLINE void Reset(size_t n) { 360| 70| PERFETTO_DCHECK((n & (n - 1)) == 0); // Must be a pow2. 361| | 362| 70| capacity_ = n; 363| 70| max_probe_length_ = 0; 364| 70| size_ = 0; 365| 70| load_limit_ = n * static_cast(load_limit_percent_) / 100; 366| 70| load_limit_ = std::min(load_limit_, n); 367| | 368| 70| tags_.reset(new uint8_t[n]); 369| 70| memset(&tags_[0], 0, n); // Clear all tags. 370| 70| keys_ = AlignedAllocTyped(n); // Deliberately not 0-initialized. 371| 70| values_ = AlignedAllocTyped(n); // Deliberately not 0-initialized. 372| 70| } _ZN8perfetto4base11FlatHashMapImNS_15trace_processor6tables10SliceTable2IdENS0_4HashImEENS0_14QuadraticProbeELb0EEC2Emi: 135| 2.03k| : load_limit_percent_(load_limit_pct) { 136| 2.03k| if (initial_capacity > 0) ------------------ | Branch (136:9): [True: 0, False: 2.03k] ------------------ 137| 0| Reset(initial_capacity); 138| 2.03k| } _ZN8perfetto4base11FlatHashMapImNS_15trace_processor6tables10SliceTable2IdENS0_4HashImEENS0_14QuadraticProbeELb0EE5ResetEm: 359| 179| PERFETTO_NO_INLINE void Reset(size_t n) { 360| 179| PERFETTO_DCHECK((n & (n - 1)) == 0); // Must be a pow2. 361| | 362| 179| capacity_ = n; 363| 179| max_probe_length_ = 0; 364| 179| size_ = 0; 365| 179| load_limit_ = n * static_cast(load_limit_percent_) / 100; 366| 179| load_limit_ = std::min(load_limit_, n); 367| | 368| 179| tags_.reset(new uint8_t[n]); 369| 179| memset(&tags_[0], 0, n); // Clear all tags. 370| 179| keys_ = AlignedAllocTyped(n); // Deliberately not 0-initialized. 371| 179| values_ = AlignedAllocTyped(n); // Deliberately not 0-initialized. 372| 179| } _ZN8perfetto4base11FlatHashMapINS_15trace_processor11FlowTracker8V1FlowIdEmNS3_14V1FlowIdHasherENS0_14QuadraticProbeELb0EEC2Emi: 135| 2.03k| : load_limit_percent_(load_limit_pct) { 136| 2.03k| if (initial_capacity > 0) ------------------ | Branch (136:9): [True: 0, False: 2.03k] ------------------ 137| 0| Reset(initial_capacity); 138| 2.03k| } _ZN8perfetto4base11FlatHashMapINS_15trace_processor11FlowTracker8V1FlowIdEmNS3_14V1FlowIdHasherENS0_14QuadraticProbeELb0EE5ResetEm: 359| 181| PERFETTO_NO_INLINE void Reset(size_t n) { 360| 181| PERFETTO_DCHECK((n & (n - 1)) == 0); // Must be a pow2. 361| | 362| 181| capacity_ = n; 363| 181| max_probe_length_ = 0; 364| 181| size_ = 0; 365| 181| load_limit_ = n * static_cast(load_limit_percent_) / 100; 366| 181| load_limit_ = std::min(load_limit_, n); 367| | 368| 181| tags_.reset(new uint8_t[n]); 369| 181| memset(&tags_[0], 0, n); // Clear all tags. 370| 181| keys_ = AlignedAllocTyped(n); // Deliberately not 0-initialized. 371| 181| values_ = AlignedAllocTyped(n); // Deliberately not 0-initialized. 372| 181| } _ZN8perfetto4base11FlatHashMapImNS_15trace_processor11FlowTracker8V1FlowIdENS0_4HashImEENS0_14QuadraticProbeELb0EEC2Emi: 135| 2.03k| : load_limit_percent_(load_limit_pct) { 136| 2.03k| if (initial_capacity > 0) ------------------ | Branch (136:9): [True: 0, False: 2.03k] ------------------ 137| 0| Reset(initial_capacity); 138| 2.03k| } _ZN8perfetto4base11FlatHashMapImNS_15trace_processor11FlowTracker8V1FlowIdENS0_4HashImEENS0_14QuadraticProbeELb0EE5ResetEm: 359| 181| PERFETTO_NO_INLINE void Reset(size_t n) { 360| 181| PERFETTO_DCHECK((n & (n - 1)) == 0); // Must be a pow2. 361| | 362| 181| capacity_ = n; 363| 181| max_probe_length_ = 0; 364| 181| size_ = 0; 365| 181| load_limit_ = n * static_cast(load_limit_percent_) / 100; 366| 181| load_limit_ = std::min(load_limit_, n); 367| | 368| 181| tags_.reset(new uint8_t[n]); 369| 181| memset(&tags_[0], 0, n); // Clear all tags. 370| 181| keys_ = AlignedAllocTyped(n); // Deliberately not 0-initialized. 371| 181| values_ = AlignedAllocTyped(n); // Deliberately not 0-initialized. 372| 181| } _ZN8perfetto4base11FlatHashMapINS_15trace_processor6tables10TrackTable2IdENSt3__16vectorImNS6_9allocatorImEEEENS0_4HashIS5_EENS0_14QuadraticProbeELb0EED2Ev: 142| 2.03k| ~FlatHashMap() { Clear(); } _ZN8perfetto4base11FlatHashMapINS_15trace_processor6tables10TrackTable2IdENSt3__16vectorImNS6_9allocatorImEEEENS0_4HashIS5_EENS0_14QuadraticProbeELb0EE5ClearEv: 262| 2.03k| void Clear() { 263| | // Avoid trivial heap operations on zero-capacity std::move()-d objects. 264| 2.03k| if (PERFETTO_UNLIKELY(capacity_ == 0)) ------------------ | | 24| 2.03k|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 2.00k, False: 35] | | ------------------ ------------------ 265| 2.00k| return; 266| | 267| 35.8k| for (size_t i = 0; i < capacity_; ++i) { ------------------ | Branch (267:24): [True: 35.8k, False: 35] ------------------ 268| 35.8k| const uint8_t tag = tags_[i]; 269| 35.8k| if (tag != kFreeSlot && tag != kTombstone) ------------------ | Branch (269:11): [True: 40, False: 35.8k] | Branch (269:31): [True: 1, False: 39] ------------------ 270| 1| EraseInternal(i); 271| 35.8k| } 272| | // Clear all tombstones. We really need to do this for AppendOnly. 273| 35| MaybeGrowAndRehash(/*grow=*/false); 274| 35| } _ZN8perfetto4base11FlatHashMapINS_15trace_processor6tables10TrackTable2IdENSt3__16vectorImNS6_9allocatorImEEEENS0_4HashIS5_EENS0_14QuadraticProbeELb0EE13EraseInternalEm: 314| 125| void EraseInternal(size_t idx) { 315| 125| PERFETTO_DCHECK(tags_[idx] > kTombstone); 316| 125| PERFETTO_DCHECK(size_ > 0); 317| 125| tags_[idx] = kTombstone; 318| 125| keys_[idx].~Key(); 319| 125| values_[idx].~Value(); 320| 125| size_--; 321| 125| } _ZN8perfetto4base11FlatHashMapINS_15trace_processor6tables10TrackTable2IdENSt3__16vectorImNS6_9allocatorImEEEENS0_4HashIS5_EENS0_14QuadraticProbeELb0EE18MaybeGrowAndRehashEb: 323| 70| PERFETTO_NO_INLINE void MaybeGrowAndRehash(bool grow) { 324| 70| PERFETTO_DCHECK(size_ <= capacity_); 325| 70| const size_t old_capacity = capacity_; 326| | 327| | // Grow quickly up to 1MB, then chill. 328| 70| const size_t old_size_bytes = old_capacity * (sizeof(Key) + sizeof(Value)); 329| 70| const size_t grow_factor = old_size_bytes < (1024u * 1024u) ? 8 : 2; ------------------ | Branch (329:32): [True: 70, False: 0] ------------------ 330| 70| const size_t new_capacity = 331| 70| grow ? std::max(old_capacity * grow_factor, size_t(1024)) ------------------ | Branch (331:9): [True: 35, False: 35] ------------------ 332| 70| : old_capacity; 333| | 334| 70| auto old_tags(std::move(tags_)); 335| 70| auto old_keys(std::move(keys_)); 336| 70| auto old_values(std::move(values_)); 337| 70| size_t old_size = size_; 338| | 339| | // This must be a CHECK (i.e. not just a DCHECK) to prevent UAF attacks on 340| | // 32-bit archs that try to double the size of the table until wrapping. 341| 70| PERFETTO_CHECK(new_capacity >= old_capacity); 342| 70| Reset(new_capacity); 343| | 344| 70| size_t new_size = 0; // Recompute the size. 345| 35.9k| for (size_t i = 0; i < old_capacity; ++i) { ------------------ | Branch (345:24): [True: 35.8k, False: 70] ------------------ 346| 35.8k| const uint8_t old_tag = old_tags[i]; 347| 35.8k| if (old_tag != kFreeSlot && old_tag != kTombstone) { ------------------ | Branch (347:11): [True: 40, False: 35.8k] | Branch (347:35): [True: 0, False: 40] ------------------ 348| 0| Insert(std::move(old_keys[i]), std::move(old_values[i])); 349| 0| old_keys[i].~Key(); // Destroy the old objects. 350| 0| old_values[i].~Value(); 351| 0| new_size++; 352| 0| } 353| 35.8k| } 354| 70| PERFETTO_DCHECK(new_size == old_size); 355| 70| size_ = new_size; 356| 70| } _ZN8perfetto4base11FlatHashMapINS_15trace_processor6tables10TrackTable2IdENSt3__16vectorImNS6_9allocatorImEEEENS0_4HashIS5_EENS0_14QuadraticProbeELb0EE6InsertES5_SA_: 166| 137| std::pair Insert(Key key, Value value) { 167| 137| const size_t key_hash = Hasher{}(key); 168| 137| const uint8_t tag = HashToTag(key_hash); 169| 137| static constexpr size_t kSlotNotFound = std::numeric_limits::max(); 170| | 171| | // This for loop does in reality at most two attempts: 172| | // The first iteration either: 173| | // - Early-returns, because the key exists already, 174| | // - Finds an insertion slot and proceeds because the load is < limit. 175| | // The second iteration is only hit in the unlikely case of this insertion 176| | // bringing the table beyond the target |load_limit_| (or the edge case 177| | // of the HT being full, if |load_limit_pct_| = 100). 178| | // We cannot simply pre-grow the table before insertion, because we must 179| | // guarantee that calling Insert() with a key that already exists doesn't 180| | // invalidate iterators. 181| 137| size_t insertion_slot; 182| 137| size_t probe_len; 183| 172| for (;;) { 184| 172| PERFETTO_DCHECK((capacity_ & (capacity_ - 1)) == 0); // Must be a pow2. 185| 172| insertion_slot = kSlotNotFound; 186| | // Start the iteration at the desired slot (key_hash % capacity_) 187| | // searching either for a free slot or a tombstone. In the worst case we 188| | // might end up scanning the whole array of slots. The Probe functions are 189| | // guaranteed to visit all the slots within |capacity_| steps. If we find 190| | // a free slot, we can stop the search immediately (a free slot acts as an 191| | // "end of chain for entries having the same hash". If we find a 192| | // tombstones (a deleted slot) we remember its position, but have to keep 193| | // searching until a free slot to make sure we don't insert a duplicate 194| | // key. 195| 257| for (probe_len = 0; probe_len < capacity_;) { ------------------ | Branch (195:27): [True: 222, False: 35] ------------------ 196| 222| const size_t idx = Probe::Calc(key_hash, probe_len, capacity_); 197| 222| PERFETTO_DCHECK(idx < capacity_); 198| 222| const uint8_t tag_idx = tags_[idx]; 199| 222| ++probe_len; 200| 222| if (tag_idx == kFreeSlot) { ------------------ | Branch (200:13): [True: 125, False: 97] ------------------ 201| | // Rationale for "insertion_slot == kSlotNotFound": if we encountered 202| | // a tombstone while iterating we should reuse that rather than 203| | // taking another slot. 204| 125| if (AppendOnly || insertion_slot == kSlotNotFound) ------------------ | Branch (204:15): [Folded - Ignored] | Branch (204:29): [True: 40, False: 85] ------------------ 205| 40| insertion_slot = idx; 206| 125| break; 207| 125| } 208| | // We should never encounter tombstones in AppendOnly mode. 209| 97| PERFETTO_DCHECK(!(tag_idx == kTombstone && AppendOnly)); 210| 97| if (!AppendOnly && tag_idx == kTombstone) { ------------------ | Branch (210:13): [Folded - Ignored] | Branch (210:28): [True: 85, False: 12] ------------------ 211| 85| insertion_slot = idx; 212| 85| continue; 213| 85| } 214| 12| if (tag_idx == tag && keys_[idx] == key) { ------------------ | Branch (214:13): [True: 12, False: 0] | Branch (214:31): [True: 12, False: 0] ------------------ 215| | // The key is already in the map. 216| 12| return std::make_pair(&values_[idx], false); 217| 12| } 218| 12| } // for (idx) 219| | 220| | // If we got to this point the key does not exist (otherwise we would have 221| | // hit the return above) and we are going to insert a new entry. 222| | // Before doing so, ensure we stay under the target load limit. 223| 160| if (PERFETTO_UNLIKELY(size_ >= load_limit_)) { ------------------ | | 24| 160|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 35, False: 125] | | ------------------ ------------------ 224| 35| MaybeGrowAndRehash(/*grow=*/true); 225| 35| continue; 226| 35| } 227| 125| PERFETTO_DCHECK(insertion_slot != kSlotNotFound); 228| 125| break; 229| 160| } // for (attempt) 230| | 231| 125| PERFETTO_CHECK(insertion_slot < capacity_); 232| | 233| | // We found a free slot (or a tombstone). Proceed with the insertion. 234| 125| Value* value_idx = &values_[insertion_slot]; 235| 125| new (&keys_[insertion_slot]) Key(std::move(key)); 236| 125| new (value_idx) Value(std::move(value)); 237| 125| tags_[insertion_slot] = tag; 238| 125| PERFETTO_DCHECK(probe_len > 0 && probe_len <= capacity_); 239| 125| max_probe_length_ = std::max(max_probe_length_, probe_len); 240| 125| size_++; 241| | 242| 125| return std::make_pair(value_idx, true); 243| 125| } _ZN8perfetto4base11FlatHashMapINS_15trace_processor6tables10TrackTable2IdENSt3__16vectorImNS6_9allocatorImEEEENS0_4HashIS5_EENS0_14QuadraticProbeELb0EE9HashToTagEm: 374| 732k| static inline uint8_t HashToTag(size_t full_hash) { 375| 732k| uint8_t tag = full_hash >> (sizeof(full_hash) * 8 - 8); 376| | // Ensure the hash is always >= 2. We use 0, 1 for kFreeSlot and kTombstone. 377| 732k| tag += (tag <= kTombstone) << 1; 378| 732k| PERFETTO_DCHECK(tag > kTombstone); 379| 732k| return tag; 380| 732k| } _ZN8perfetto4base11FlatHashMapImNS_15trace_processor6tables10SliceTable2IdENS0_4HashImEENS0_14QuadraticProbeELb0EED2Ev: 142| 2.03k| ~FlatHashMap() { Clear(); } _ZN8perfetto4base11FlatHashMapImNS_15trace_processor6tables10SliceTable2IdENS0_4HashImEENS0_14QuadraticProbeELb0EE5ClearEv: 262| 2.03k| void Clear() { 263| | // Avoid trivial heap operations on zero-capacity std::move()-d objects. 264| 2.03k| if (PERFETTO_UNLIKELY(capacity_ == 0)) ------------------ | | 24| 2.03k|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 1.95k, False: 85] | | ------------------ ------------------ 265| 1.95k| return; 266| | 267| 151k| for (size_t i = 0; i < capacity_; ++i) { ------------------ | Branch (267:24): [True: 151k, False: 85] ------------------ 268| 151k| const uint8_t tag = tags_[i]; 269| 151k| if (tag != kFreeSlot && tag != kTombstone) ------------------ | Branch (269:11): [True: 12.7k, False: 138k] | Branch (269:31): [True: 12.7k, False: 0] ------------------ 270| 12.7k| EraseInternal(i); 271| 151k| } 272| | // Clear all tombstones. We really need to do this for AppendOnly. 273| 85| MaybeGrowAndRehash(/*grow=*/false); 274| 85| } _ZN8perfetto4base11FlatHashMapImNS_15trace_processor6tables10SliceTable2IdENS0_4HashImEENS0_14QuadraticProbeELb0EE13EraseInternalEm: 314| 12.7k| void EraseInternal(size_t idx) { 315| 12.7k| PERFETTO_DCHECK(tags_[idx] > kTombstone); 316| 12.7k| PERFETTO_DCHECK(size_ > 0); 317| 12.7k| tags_[idx] = kTombstone; 318| 12.7k| keys_[idx].~Key(); 319| 12.7k| values_[idx].~Value(); 320| 12.7k| size_--; 321| 12.7k| } _ZN8perfetto4base11FlatHashMapImNS_15trace_processor6tables10SliceTable2IdENS0_4HashImEENS0_14QuadraticProbeELb0EE18MaybeGrowAndRehashEb: 323| 179| PERFETTO_NO_INLINE void MaybeGrowAndRehash(bool grow) { 324| 179| PERFETTO_DCHECK(size_ <= capacity_); 325| 179| const size_t old_capacity = capacity_; 326| | 327| | // Grow quickly up to 1MB, then chill. 328| 179| const size_t old_size_bytes = old_capacity * (sizeof(Key) + sizeof(Value)); 329| 179| const size_t grow_factor = old_size_bytes < (1024u * 1024u) ? 8 : 2; ------------------ | Branch (329:32): [True: 179, False: 0] ------------------ 330| 179| const size_t new_capacity = 331| 179| grow ? std::max(old_capacity * grow_factor, size_t(1024)) ------------------ | Branch (331:9): [True: 94, False: 85] ------------------ 332| 179| : old_capacity; 333| | 334| 179| auto old_tags(std::move(tags_)); 335| 179| auto old_keys(std::move(keys_)); 336| 179| auto old_values(std::move(values_)); 337| 179| size_t old_size = size_; 338| | 339| | // This must be a CHECK (i.e. not just a DCHECK) to prevent UAF attacks on 340| | // 32-bit archs that try to double the size of the table until wrapping. 341| 179| PERFETTO_CHECK(new_capacity >= old_capacity); 342| 179| Reset(new_capacity); 343| | 344| 179| size_t new_size = 0; // Recompute the size. 345| 160k| for (size_t i = 0; i < old_capacity; ++i) { ------------------ | Branch (345:24): [True: 160k, False: 179] ------------------ 346| 160k| const uint8_t old_tag = old_tags[i]; 347| 160k| if (old_tag != kFreeSlot && old_tag != kTombstone) { ------------------ | Branch (347:11): [True: 19.6k, False: 141k] | Branch (347:35): [True: 6.91k, False: 12.7k] ------------------ 348| 6.91k| Insert(std::move(old_keys[i]), std::move(old_values[i])); 349| 6.91k| old_keys[i].~Key(); // Destroy the old objects. 350| 6.91k| old_values[i].~Value(); 351| 6.91k| new_size++; 352| 6.91k| } 353| 160k| } 354| 179| PERFETTO_DCHECK(new_size == old_size); 355| 179| size_ = new_size; 356| 179| } _ZN8perfetto4base11FlatHashMapINS_15trace_processor11FlowTracker8V1FlowIdEmNS3_14V1FlowIdHasherENS0_14QuadraticProbeELb0EED2Ev: 142| 2.03k| ~FlatHashMap() { Clear(); } _ZN8perfetto4base11FlatHashMapINS_15trace_processor11FlowTracker8V1FlowIdEmNS3_14V1FlowIdHasherENS0_14QuadraticProbeELb0EE5ClearEv: 262| 2.03k| void Clear() { 263| | // Avoid trivial heap operations on zero-capacity std::move()-d objects. 264| 2.03k| if (PERFETTO_UNLIKELY(capacity_ == 0)) ------------------ | | 24| 2.03k|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 1.95k, False: 86] | | ------------------ ------------------ 265| 1.95k| return; 266| | 267| 152k| for (size_t i = 0; i < capacity_; ++i) { ------------------ | Branch (267:24): [True: 152k, False: 86] ------------------ 268| 152k| const uint8_t tag = tags_[i]; 269| 152k| if (tag != kFreeSlot && tag != kTombstone) ------------------ | Branch (269:11): [True: 13.6k, False: 138k] | Branch (269:31): [True: 13.6k, False: 0] ------------------ 270| 13.6k| EraseInternal(i); 271| 152k| } 272| | // Clear all tombstones. We really need to do this for AppendOnly. 273| 86| MaybeGrowAndRehash(/*grow=*/false); 274| 86| } _ZN8perfetto4base11FlatHashMapINS_15trace_processor11FlowTracker8V1FlowIdEmNS3_14V1FlowIdHasherENS0_14QuadraticProbeELb0EE13EraseInternalEm: 314| 13.6k| void EraseInternal(size_t idx) { 315| 13.6k| PERFETTO_DCHECK(tags_[idx] > kTombstone); 316| 13.6k| PERFETTO_DCHECK(size_ > 0); 317| 13.6k| tags_[idx] = kTombstone; 318| 13.6k| keys_[idx].~Key(); 319| 13.6k| values_[idx].~Value(); 320| 13.6k| size_--; 321| 13.6k| } _ZN8perfetto4base11FlatHashMapINS_15trace_processor11FlowTracker8V1FlowIdEmNS3_14V1FlowIdHasherENS0_14QuadraticProbeELb0EE18MaybeGrowAndRehashEb: 323| 181| PERFETTO_NO_INLINE void MaybeGrowAndRehash(bool grow) { 324| 181| PERFETTO_DCHECK(size_ <= capacity_); 325| 181| const size_t old_capacity = capacity_; 326| | 327| | // Grow quickly up to 1MB, then chill. 328| 181| const size_t old_size_bytes = old_capacity * (sizeof(Key) + sizeof(Value)); 329| 181| const size_t grow_factor = old_size_bytes < (1024u * 1024u) ? 8 : 2; ------------------ | Branch (329:32): [True: 181, False: 0] ------------------ 330| 181| const size_t new_capacity = 331| 181| grow ? std::max(old_capacity * grow_factor, size_t(1024)) ------------------ | Branch (331:9): [True: 95, False: 86] ------------------ 332| 181| : old_capacity; 333| | 334| 181| auto old_tags(std::move(tags_)); 335| 181| auto old_keys(std::move(keys_)); 336| 181| auto old_values(std::move(values_)); 337| 181| size_t old_size = size_; 338| | 339| | // This must be a CHECK (i.e. not just a DCHECK) to prevent UAF attacks on 340| | // 32-bit archs that try to double the size of the table until wrapping. 341| 181| PERFETTO_CHECK(new_capacity >= old_capacity); 342| 181| Reset(new_capacity); 343| | 344| 181| size_t new_size = 0; // Recompute the size. 345| 161k| for (size_t i = 0; i < old_capacity; ++i) { ------------------ | Branch (345:24): [True: 161k, False: 181] ------------------ 346| 161k| const uint8_t old_tag = old_tags[i]; 347| 161k| if (old_tag != kFreeSlot && old_tag != kTombstone) { ------------------ | Branch (347:11): [True: 20.5k, False: 141k] | Branch (347:35): [True: 6.91k, False: 13.6k] ------------------ 348| 6.91k| Insert(std::move(old_keys[i]), std::move(old_values[i])); 349| 6.91k| old_keys[i].~Key(); // Destroy the old objects. 350| 6.91k| old_values[i].~Value(); 351| 6.91k| new_size++; 352| 6.91k| } 353| 161k| } 354| 181| PERFETTO_DCHECK(new_size == old_size); 355| 181| size_ = new_size; 356| 181| } _ZN8perfetto4base11FlatHashMapINS_15trace_processor11FlowTracker8V1FlowIdEmNS3_14V1FlowIdHasherENS0_14QuadraticProbeELb0EE6InsertES4_m: 166| 20.5k| std::pair Insert(Key key, Value value) { 167| 20.5k| const size_t key_hash = Hasher{}(key); 168| 20.5k| const uint8_t tag = HashToTag(key_hash); 169| 20.5k| static constexpr size_t kSlotNotFound = std::numeric_limits::max(); 170| | 171| | // This for loop does in reality at most two attempts: 172| | // The first iteration either: 173| | // - Early-returns, because the key exists already, 174| | // - Finds an insertion slot and proceeds because the load is < limit. 175| | // The second iteration is only hit in the unlikely case of this insertion 176| | // bringing the table beyond the target |load_limit_| (or the edge case 177| | // of the HT being full, if |load_limit_pct_| = 100). 178| | // We cannot simply pre-grow the table before insertion, because we must 179| | // guarantee that calling Insert() with a key that already exists doesn't 180| | // invalidate iterators. 181| 20.5k| size_t insertion_slot; 182| 20.5k| size_t probe_len; 183| 20.6k| for (;;) { 184| 20.6k| PERFETTO_DCHECK((capacity_ & (capacity_ - 1)) == 0); // Must be a pow2. 185| 20.6k| insertion_slot = kSlotNotFound; 186| | // Start the iteration at the desired slot (key_hash % capacity_) 187| | // searching either for a free slot or a tombstone. In the worst case we 188| | // might end up scanning the whole array of slots. The Probe functions are 189| | // guaranteed to visit all the slots within |capacity_| steps. If we find 190| | // a free slot, we can stop the search immediately (a free slot acts as an 191| | // "end of chain for entries having the same hash". If we find a 192| | // tombstones (a deleted slot) we remember its position, but have to keep 193| | // searching until a free slot to make sure we don't insert a duplicate 194| | // key. 195| 29.9k| for (probe_len = 0; probe_len < capacity_;) { ------------------ | Branch (195:27): [True: 29.8k, False: 86] ------------------ 196| 29.8k| const size_t idx = Probe::Calc(key_hash, probe_len, capacity_); 197| 29.8k| PERFETTO_DCHECK(idx < capacity_); 198| 29.8k| const uint8_t tag_idx = tags_[idx]; 199| 29.8k| ++probe_len; 200| 29.8k| if (tag_idx == kFreeSlot) { ------------------ | Branch (200:13): [True: 20.6k, False: 9.25k] ------------------ 201| | // Rationale for "insertion_slot == kSlotNotFound": if we encountered 202| | // a tombstone while iterating we should reuse that rather than 203| | // taking another slot. 204| 20.6k| if (AppendOnly || insertion_slot == kSlotNotFound) ------------------ | Branch (204:15): [Folded - Ignored] | Branch (204:29): [True: 20.6k, False: 0] ------------------ 205| 20.6k| insertion_slot = idx; 206| 20.6k| break; 207| 20.6k| } 208| | // We should never encounter tombstones in AppendOnly mode. 209| 9.25k| PERFETTO_DCHECK(!(tag_idx == kTombstone && AppendOnly)); 210| 9.25k| if (!AppendOnly && tag_idx == kTombstone) { ------------------ | Branch (210:13): [Folded - Ignored] | Branch (210:28): [True: 0, False: 9.25k] ------------------ 211| 0| insertion_slot = idx; 212| 0| continue; 213| 0| } 214| 9.25k| if (tag_idx == tag && keys_[idx] == key) { ------------------ | Branch (214:13): [True: 39, False: 9.21k] | Branch (214:31): [True: 0, False: 39] ------------------ 215| | // The key is already in the map. 216| 0| return std::make_pair(&values_[idx], false); 217| 0| } 218| 9.25k| } // for (idx) 219| | 220| | // If we got to this point the key does not exist (otherwise we would have 221| | // hit the return above) and we are going to insert a new entry. 222| | // Before doing so, ensure we stay under the target load limit. 223| 20.6k| if (PERFETTO_UNLIKELY(size_ >= load_limit_)) { ------------------ | | 24| 20.6k|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 95, False: 20.5k] | | ------------------ ------------------ 224| 95| MaybeGrowAndRehash(/*grow=*/true); 225| 95| continue; 226| 95| } 227| 20.5k| PERFETTO_DCHECK(insertion_slot != kSlotNotFound); 228| 20.5k| break; 229| 20.6k| } // for (attempt) 230| | 231| 20.5k| PERFETTO_CHECK(insertion_slot < capacity_); 232| | 233| | // We found a free slot (or a tombstone). Proceed with the insertion. 234| 20.5k| Value* value_idx = &values_[insertion_slot]; 235| 20.5k| new (&keys_[insertion_slot]) Key(std::move(key)); 236| 20.5k| new (value_idx) Value(std::move(value)); 237| 20.5k| tags_[insertion_slot] = tag; 238| 20.5k| PERFETTO_DCHECK(probe_len > 0 && probe_len <= capacity_); 239| 20.5k| max_probe_length_ = std::max(max_probe_length_, probe_len); 240| 20.5k| size_++; 241| | 242| 20.5k| return std::make_pair(value_idx, true); 243| 20.5k| } _ZN8perfetto4base11FlatHashMapINS_15trace_processor11FlowTracker8V1FlowIdEmNS3_14V1FlowIdHasherENS0_14QuadraticProbeELb0EE9HashToTagEm: 374| 74.9k| static inline uint8_t HashToTag(size_t full_hash) { 375| 74.9k| uint8_t tag = full_hash >> (sizeof(full_hash) * 8 - 8); 376| | // Ensure the hash is always >= 2. We use 0, 1 for kFreeSlot and kTombstone. 377| 74.9k| tag += (tag <= kTombstone) << 1; 378| 74.9k| PERFETTO_DCHECK(tag > kTombstone); 379| 74.9k| return tag; 380| 74.9k| } _ZN8perfetto4base11FlatHashMapImNS_15trace_processor11FlowTracker8V1FlowIdENS0_4HashImEENS0_14QuadraticProbeELb0EED2Ev: 142| 2.03k| ~FlatHashMap() { Clear(); } _ZN8perfetto4base11FlatHashMapImNS_15trace_processor11FlowTracker8V1FlowIdENS0_4HashImEENS0_14QuadraticProbeELb0EE5ClearEv: 262| 2.03k| void Clear() { 263| | // Avoid trivial heap operations on zero-capacity std::move()-d objects. 264| 2.03k| if (PERFETTO_UNLIKELY(capacity_ == 0)) ------------------ | | 24| 2.03k|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 1.95k, False: 86] | | ------------------ ------------------ 265| 1.95k| return; 266| | 267| 152k| for (size_t i = 0; i < capacity_; ++i) { ------------------ | Branch (267:24): [True: 152k, False: 86] ------------------ 268| 152k| const uint8_t tag = tags_[i]; 269| 152k| if (tag != kFreeSlot && tag != kTombstone) ------------------ | Branch (269:11): [True: 13.6k, False: 138k] | Branch (269:31): [True: 13.6k, False: 0] ------------------ 270| 13.6k| EraseInternal(i); 271| 152k| } 272| | // Clear all tombstones. We really need to do this for AppendOnly. 273| 86| MaybeGrowAndRehash(/*grow=*/false); 274| 86| } _ZN8perfetto4base11FlatHashMapImNS_15trace_processor11FlowTracker8V1FlowIdENS0_4HashImEENS0_14QuadraticProbeELb0EE13EraseInternalEm: 314| 13.6k| void EraseInternal(size_t idx) { 315| 13.6k| PERFETTO_DCHECK(tags_[idx] > kTombstone); 316| 13.6k| PERFETTO_DCHECK(size_ > 0); 317| 13.6k| tags_[idx] = kTombstone; 318| 13.6k| keys_[idx].~Key(); 319| 13.6k| values_[idx].~Value(); 320| 13.6k| size_--; 321| 13.6k| } _ZN8perfetto4base11FlatHashMapImNS_15trace_processor11FlowTracker8V1FlowIdENS0_4HashImEENS0_14QuadraticProbeELb0EE18MaybeGrowAndRehashEb: 323| 181| PERFETTO_NO_INLINE void MaybeGrowAndRehash(bool grow) { 324| 181| PERFETTO_DCHECK(size_ <= capacity_); 325| 181| const size_t old_capacity = capacity_; 326| | 327| | // Grow quickly up to 1MB, then chill. 328| 181| const size_t old_size_bytes = old_capacity * (sizeof(Key) + sizeof(Value)); 329| 181| const size_t grow_factor = old_size_bytes < (1024u * 1024u) ? 8 : 2; ------------------ | Branch (329:32): [True: 181, False: 0] ------------------ 330| 181| const size_t new_capacity = 331| 181| grow ? std::max(old_capacity * grow_factor, size_t(1024)) ------------------ | Branch (331:9): [True: 95, False: 86] ------------------ 332| 181| : old_capacity; 333| | 334| 181| auto old_tags(std::move(tags_)); 335| 181| auto old_keys(std::move(keys_)); 336| 181| auto old_values(std::move(values_)); 337| 181| size_t old_size = size_; 338| | 339| | // This must be a CHECK (i.e. not just a DCHECK) to prevent UAF attacks on 340| | // 32-bit archs that try to double the size of the table until wrapping. 341| 181| PERFETTO_CHECK(new_capacity >= old_capacity); 342| 181| Reset(new_capacity); 343| | 344| 181| size_t new_size = 0; // Recompute the size. 345| 161k| for (size_t i = 0; i < old_capacity; ++i) { ------------------ | Branch (345:24): [True: 161k, False: 181] ------------------ 346| 161k| const uint8_t old_tag = old_tags[i]; 347| 161k| if (old_tag != kFreeSlot && old_tag != kTombstone) { ------------------ | Branch (347:11): [True: 20.5k, False: 141k] | Branch (347:35): [True: 6.91k, False: 13.6k] ------------------ 348| 6.91k| Insert(std::move(old_keys[i]), std::move(old_values[i])); 349| 6.91k| old_keys[i].~Key(); // Destroy the old objects. 350| 6.91k| old_values[i].~Value(); 351| 6.91k| new_size++; 352| 6.91k| } 353| 161k| } 354| 181| PERFETTO_DCHECK(new_size == old_size); 355| 181| size_ = new_size; 356| 181| } _ZN8perfetto4base11FlatHashMapImNS_15trace_processor11FlowTracker8V1FlowIdENS0_4HashImEENS0_14QuadraticProbeELb0EE6InsertEmS4_: 166| 20.5k| std::pair Insert(Key key, Value value) { 167| 20.5k| const size_t key_hash = Hasher{}(key); 168| 20.5k| const uint8_t tag = HashToTag(key_hash); 169| 20.5k| static constexpr size_t kSlotNotFound = std::numeric_limits::max(); 170| | 171| | // This for loop does in reality at most two attempts: 172| | // The first iteration either: 173| | // - Early-returns, because the key exists already, 174| | // - Finds an insertion slot and proceeds because the load is < limit. 175| | // The second iteration is only hit in the unlikely case of this insertion 176| | // bringing the table beyond the target |load_limit_| (or the edge case 177| | // of the HT being full, if |load_limit_pct_| = 100). 178| | // We cannot simply pre-grow the table before insertion, because we must 179| | // guarantee that calling Insert() with a key that already exists doesn't 180| | // invalidate iterators. 181| 20.5k| size_t insertion_slot; 182| 20.5k| size_t probe_len; 183| 20.6k| for (;;) { 184| 20.6k| PERFETTO_DCHECK((capacity_ & (capacity_ - 1)) == 0); // Must be a pow2. 185| 20.6k| insertion_slot = kSlotNotFound; 186| | // Start the iteration at the desired slot (key_hash % capacity_) 187| | // searching either for a free slot or a tombstone. In the worst case we 188| | // might end up scanning the whole array of slots. The Probe functions are 189| | // guaranteed to visit all the slots within |capacity_| steps. If we find 190| | // a free slot, we can stop the search immediately (a free slot acts as an 191| | // "end of chain for entries having the same hash". If we find a 192| | // tombstones (a deleted slot) we remember its position, but have to keep 193| | // searching until a free slot to make sure we don't insert a duplicate 194| | // key. 195| 25.9k| for (probe_len = 0; probe_len < capacity_;) { ------------------ | Branch (195:27): [True: 25.8k, False: 86] ------------------ 196| 25.8k| const size_t idx = Probe::Calc(key_hash, probe_len, capacity_); 197| 25.8k| PERFETTO_DCHECK(idx < capacity_); 198| 25.8k| const uint8_t tag_idx = tags_[idx]; 199| 25.8k| ++probe_len; 200| 25.8k| if (tag_idx == kFreeSlot) { ------------------ | Branch (200:13): [True: 20.6k, False: 5.28k] ------------------ 201| | // Rationale for "insertion_slot == kSlotNotFound": if we encountered 202| | // a tombstone while iterating we should reuse that rather than 203| | // taking another slot. 204| 20.6k| if (AppendOnly || insertion_slot == kSlotNotFound) ------------------ | Branch (204:15): [Folded - Ignored] | Branch (204:29): [True: 20.6k, False: 0] ------------------ 205| 20.6k| insertion_slot = idx; 206| 20.6k| break; 207| 20.6k| } 208| | // We should never encounter tombstones in AppendOnly mode. 209| 5.28k| PERFETTO_DCHECK(!(tag_idx == kTombstone && AppendOnly)); 210| 5.28k| if (!AppendOnly && tag_idx == kTombstone) { ------------------ | Branch (210:13): [Folded - Ignored] | Branch (210:28): [True: 0, False: 5.28k] ------------------ 211| 0| insertion_slot = idx; 212| 0| continue; 213| 0| } 214| 5.28k| if (tag_idx == tag && keys_[idx] == key) { ------------------ | Branch (214:13): [True: 0, False: 5.28k] | Branch (214:31): [True: 0, False: 0] ------------------ 215| | // The key is already in the map. 216| 0| return std::make_pair(&values_[idx], false); 217| 0| } 218| 5.28k| } // for (idx) 219| | 220| | // If we got to this point the key does not exist (otherwise we would have 221| | // hit the return above) and we are going to insert a new entry. 222| | // Before doing so, ensure we stay under the target load limit. 223| 20.6k| if (PERFETTO_UNLIKELY(size_ >= load_limit_)) { ------------------ | | 24| 20.6k|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 95, False: 20.5k] | | ------------------ ------------------ 224| 95| MaybeGrowAndRehash(/*grow=*/true); 225| 95| continue; 226| 95| } 227| 20.5k| PERFETTO_DCHECK(insertion_slot != kSlotNotFound); 228| 20.5k| break; 229| 20.6k| } // for (attempt) 230| | 231| 20.5k| PERFETTO_CHECK(insertion_slot < capacity_); 232| | 233| | // We found a free slot (or a tombstone). Proceed with the insertion. 234| 20.5k| Value* value_idx = &values_[insertion_slot]; 235| 20.5k| new (&keys_[insertion_slot]) Key(std::move(key)); 236| 20.5k| new (value_idx) Value(std::move(value)); 237| 20.5k| tags_[insertion_slot] = tag; 238| 20.5k| PERFETTO_DCHECK(probe_len > 0 && probe_len <= capacity_); 239| 20.5k| max_probe_length_ = std::max(max_probe_length_, probe_len); 240| 20.5k| size_++; 241| | 242| 20.5k| return std::make_pair(value_idx, true); 243| 20.5k| } _ZN8perfetto4base11FlatHashMapImNS_15trace_processor11FlowTracker8V1FlowIdENS0_4HashImEENS0_14QuadraticProbeELb0EE9HashToTagEm: 374| 21.9k| static inline uint8_t HashToTag(size_t full_hash) { 375| 21.9k| uint8_t tag = full_hash >> (sizeof(full_hash) * 8 - 8); 376| | // Ensure the hash is always >= 2. We use 0, 1 for kFreeSlot and kTombstone. 377| 21.9k| tag += (tag <= kTombstone) << 1; 378| 21.9k| PERFETTO_DCHECK(tag > kTombstone); 379| 21.9k| return tag; 380| 21.9k| } _ZN8perfetto4base11FlatHashMapImNS_15trace_processor6tables10SliceTable2IdENS0_4HashImEENS0_14QuadraticProbeELb0EE6InsertEmS5_: 166| 53.7k| std::pair Insert(Key key, Value value) { 167| 53.7k| const size_t key_hash = Hasher{}(key); 168| 53.7k| const uint8_t tag = HashToTag(key_hash); 169| 53.7k| static constexpr size_t kSlotNotFound = std::numeric_limits::max(); 170| | 171| | // This for loop does in reality at most two attempts: 172| | // The first iteration either: 173| | // - Early-returns, because the key exists already, 174| | // - Finds an insertion slot and proceeds because the load is < limit. 175| | // The second iteration is only hit in the unlikely case of this insertion 176| | // bringing the table beyond the target |load_limit_| (or the edge case 177| | // of the HT being full, if |load_limit_pct_| = 100). 178| | // We cannot simply pre-grow the table before insertion, because we must 179| | // guarantee that calling Insert() with a key that already exists doesn't 180| | // invalidate iterators. 181| 53.7k| size_t insertion_slot; 182| 53.7k| size_t probe_len; 183| 53.8k| for (;;) { 184| 53.8k| PERFETTO_DCHECK((capacity_ & (capacity_ - 1)) == 0); // Must be a pow2. 185| 53.8k| insertion_slot = kSlotNotFound; 186| | // Start the iteration at the desired slot (key_hash % capacity_) 187| | // searching either for a free slot or a tombstone. In the worst case we 188| | // might end up scanning the whole array of slots. The Probe functions are 189| | // guaranteed to visit all the slots within |capacity_| steps. If we find 190| | // a free slot, we can stop the search immediately (a free slot acts as an 191| | // "end of chain for entries having the same hash". If we find a 192| | // tombstones (a deleted slot) we remember its position, but have to keep 193| | // searching until a free slot to make sure we don't insert a duplicate 194| | // key. 195| 58.5k| for (probe_len = 0; probe_len < capacity_;) { ------------------ | Branch (195:27): [True: 58.4k, False: 85] ------------------ 196| 58.4k| const size_t idx = Probe::Calc(key_hash, probe_len, capacity_); 197| 58.4k| PERFETTO_DCHECK(idx < capacity_); 198| 58.4k| const uint8_t tag_idx = tags_[idx]; 199| 58.4k| ++probe_len; 200| 58.4k| if (tag_idx == kFreeSlot) { ------------------ | Branch (200:13): [True: 19.6k, False: 38.7k] ------------------ 201| | // Rationale for "insertion_slot == kSlotNotFound": if we encountered 202| | // a tombstone while iterating we should reuse that rather than 203| | // taking another slot. 204| 19.6k| if (AppendOnly || insertion_slot == kSlotNotFound) ------------------ | Branch (204:15): [Folded - Ignored] | Branch (204:29): [True: 19.6k, False: 1] ------------------ 205| 19.6k| insertion_slot = idx; 206| 19.6k| break; 207| 19.6k| } 208| | // We should never encounter tombstones in AppendOnly mode. 209| 38.7k| PERFETTO_DCHECK(!(tag_idx == kTombstone && AppendOnly)); 210| 38.7k| if (!AppendOnly && tag_idx == kTombstone) { ------------------ | Branch (210:13): [Folded - Ignored] | Branch (210:28): [True: 1, False: 38.7k] ------------------ 211| 1| insertion_slot = idx; 212| 1| continue; 213| 1| } 214| 38.7k| if (tag_idx == tag && keys_[idx] == key) { ------------------ | Branch (214:13): [True: 34.0k, False: 4.70k] | Branch (214:31): [True: 34.0k, False: 0] ------------------ 215| | // The key is already in the map. 216| 34.0k| return std::make_pair(&values_[idx], false); 217| 34.0k| } 218| 38.7k| } // for (idx) 219| | 220| | // If we got to this point the key does not exist (otherwise we would have 221| | // hit the return above) and we are going to insert a new entry. 222| | // Before doing so, ensure we stay under the target load limit. 223| 19.7k| if (PERFETTO_UNLIKELY(size_ >= load_limit_)) { ------------------ | | 24| 19.7k|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 94, False: 19.6k] | | ------------------ ------------------ 224| 94| MaybeGrowAndRehash(/*grow=*/true); 225| 94| continue; 226| 94| } 227| 19.6k| PERFETTO_DCHECK(insertion_slot != kSlotNotFound); 228| 19.6k| break; 229| 19.7k| } // for (attempt) 230| | 231| 19.6k| PERFETTO_CHECK(insertion_slot < capacity_); 232| | 233| | // We found a free slot (or a tombstone). Proceed with the insertion. 234| 19.6k| Value* value_idx = &values_[insertion_slot]; 235| 19.6k| new (&keys_[insertion_slot]) Key(std::move(key)); 236| 19.6k| new (value_idx) Value(std::move(value)); 237| 19.6k| tags_[insertion_slot] = tag; 238| 19.6k| PERFETTO_DCHECK(probe_len > 0 && probe_len <= capacity_); 239| 19.6k| max_probe_length_ = std::max(max_probe_length_, probe_len); 240| 19.6k| size_++; 241| | 242| 19.6k| return std::make_pair(value_idx, true); 243| 19.6k| } _ZN8perfetto4base11FlatHashMapImNS_15trace_processor6tables10SliceTable2IdENS0_4HashImEENS0_14QuadraticProbeELb0EE9HashToTagEm: 374| 63.5k| static inline uint8_t HashToTag(size_t full_hash) { 375| 63.5k| uint8_t tag = full_hash >> (sizeof(full_hash) * 8 - 8); 376| | // Ensure the hash is always >= 2. We use 0, 1 for kFreeSlot and kTombstone. 377| 63.5k| tag += (tag <= kTombstone) << 1; 378| 63.5k| PERFETTO_DCHECK(tag > kTombstone); 379| 63.5k| return tag; 380| 63.5k| } _ZNK8perfetto4base11FlatHashMapImNS_15trace_processor6tables10SliceTable2IdENS0_4HashImEENS0_14QuadraticProbeELb0EE4FindERKm: 245| 9.87k| Value* Find(const Key& key) const { 246| 9.87k| const size_t idx = FindInternal(key); 247| 9.87k| if (idx == kNotFound) ------------------ | Branch (247:9): [True: 8.59k, False: 1.27k] ------------------ 248| 8.59k| return nullptr; 249| 1.27k| return &values_[idx]; 250| 9.87k| } _ZNK8perfetto4base11FlatHashMapImNS_15trace_processor6tables10SliceTable2IdENS0_4HashImEENS0_14QuadraticProbeELb0EE12FindInternalERKm: 293| 9.87k| size_t FindInternal(const Key& key) const { 294| 9.87k| const size_t key_hash = Hasher{}(key); 295| 9.87k| const uint8_t tag = HashToTag(key_hash); 296| 9.87k| PERFETTO_DCHECK((capacity_ & (capacity_ - 1)) == 0); // Must be a pow2. 297| 9.87k| PERFETTO_DCHECK(max_probe_length_ <= capacity_); 298| 9.87k| for (size_t i = 0; i < max_probe_length_; ++i) { ------------------ | Branch (298:24): [True: 1.31k, False: 8.56k] ------------------ 299| 1.31k| const size_t idx = Probe::Calc(key_hash, i, capacity_); 300| 1.31k| const uint8_t tag_idx = tags_[idx]; 301| | 302| 1.31k| if (tag_idx == kFreeSlot) ------------------ | Branch (302:11): [True: 36, False: 1.27k] ------------------ 303| 36| return kNotFound; 304| | // HashToTag() never returns kTombstone, so the tag-check below cannot 305| | // possibly match. Also we just want to skip tombstones. 306| 1.27k| if (tag_idx == tag && keys_[idx] == key) { ------------------ | Branch (306:11): [True: 1.27k, False: 2] | Branch (306:29): [True: 1.27k, False: 0] ------------------ 307| 1.27k| PERFETTO_DCHECK(tag_idx > kTombstone); 308| 1.27k| return idx; 309| 1.27k| } 310| 1.27k| } // for (idx) 311| 8.56k| return kNotFound; 312| 9.87k| } _ZN8perfetto4base11FlatHashMapINS_15trace_processor6tables10TrackTable2IdENSt3__16vectorImNS6_9allocatorImEEEENS0_4HashIS5_EENS0_14QuadraticProbeELb0EEixES5_: 276| 137| Value& operator[](Key key) { 277| 137| auto it_and_inserted = Insert(std::move(key), Value{}); 278| 137| return *it_and_inserted.first; 279| 137| } _ZN8perfetto4base11FlatHashMapImNS_15trace_processor6tables10SliceTable2IdENS0_4HashImEENS0_14QuadraticProbeELb0EE5EraseERKm: 252| 1| bool Erase(const Key& key) { 253| 1| if (AppendOnly) ------------------ | Branch (253:9): [Folded - Ignored] ------------------ 254| 0| PERFETTO_FATAL("Erase() not supported because AppendOnly=true"); 255| 1| size_t idx = FindInternal(key); 256| 1| if (idx == kNotFound) ------------------ | Branch (256:9): [True: 0, False: 1] ------------------ 257| 0| return false; 258| 1| EraseInternal(idx); 259| 1| return true; 260| 1| } _ZNK8perfetto4base11FlatHashMapINS_15trace_processor11FlowTracker8V1FlowIdEmNS3_14V1FlowIdHasherENS0_14QuadraticProbeELb0EE4FindERKS4_: 245| 54.3k| Value* Find(const Key& key) const { 246| 54.3k| const size_t idx = FindInternal(key); 247| 54.3k| if (idx == kNotFound) ------------------ | Branch (247:9): [True: 13.6k, False: 40.6k] ------------------ 248| 13.6k| return nullptr; 249| 40.6k| return &values_[idx]; 250| 54.3k| } _ZNK8perfetto4base11FlatHashMapINS_15trace_processor11FlowTracker8V1FlowIdEmNS3_14V1FlowIdHasherENS0_14QuadraticProbeELb0EE12FindInternalERKS4_: 293| 54.3k| size_t FindInternal(const Key& key) const { 294| 54.3k| const size_t key_hash = Hasher{}(key); 295| 54.3k| const uint8_t tag = HashToTag(key_hash); 296| 54.3k| PERFETTO_DCHECK((capacity_ & (capacity_ - 1)) == 0); // Must be a pow2. 297| 54.3k| PERFETTO_DCHECK(max_probe_length_ <= capacity_); 298| 64.5k| for (size_t i = 0; i < max_probe_length_; ++i) { ------------------ | Branch (298:24): [True: 64.3k, False: 211] ------------------ 299| 64.3k| const size_t idx = Probe::Calc(key_hash, i, capacity_); 300| 64.3k| const uint8_t tag_idx = tags_[idx]; 301| | 302| 64.3k| if (tag_idx == kFreeSlot) ------------------ | Branch (302:11): [True: 13.4k, False: 50.8k] ------------------ 303| 13.4k| return kNotFound; 304| | // HashToTag() never returns kTombstone, so the tag-check below cannot 305| | // possibly match. Also we just want to skip tombstones. 306| 50.8k| if (tag_idx == tag && keys_[idx] == key) { ------------------ | Branch (306:11): [True: 40.6k, False: 10.1k] | Branch (306:29): [True: 40.6k, False: 39] ------------------ 307| 40.6k| PERFETTO_DCHECK(tag_idx > kTombstone); 308| 40.6k| return idx; 309| 40.6k| } 310| 50.8k| } // for (idx) 311| 211| return kNotFound; 312| 54.3k| } _ZN8perfetto4base11FlatHashMapImNS_15trace_processor11FlowTracker8V1FlowIdENS0_4HashImEENS0_14QuadraticProbeELb0EEixEm: 276| 13.6k| Value& operator[](Key key) { 277| 13.6k| auto it_and_inserted = Insert(std::move(key), Value{}); 278| 13.6k| return *it_and_inserted.first; 279| 13.6k| } _ZN8perfetto4base11FlatHashMapINS_15trace_processor11FlowTracker8V1FlowIdEmNS3_14V1FlowIdHasherENS0_14QuadraticProbeELb0EEixES4_: 276| 13.6k| Value& operator[](Key key) { 277| 13.6k| auto it_and_inserted = Insert(std::move(key), Value{}); 278| 13.6k| return *it_and_inserted.first; 279| 13.6k| } _ZNK8perfetto4base11FlatHashMapINS_15trace_processor6tables10TrackTable2IdENSt3__16vectorImNS6_9allocatorImEEEENS0_4HashIS5_EENS0_14QuadraticProbeELb0EE4FindERKS5_: 245| 731k| Value* Find(const Key& key) const { 246| 731k| const size_t idx = FindInternal(key); 247| 731k| if (idx == kNotFound) ------------------ | Branch (247:9): [True: 731k, False: 124] ------------------ 248| 731k| return nullptr; 249| 124| return &values_[idx]; 250| 731k| } _ZNK8perfetto4base11FlatHashMapINS_15trace_processor6tables10TrackTable2IdENSt3__16vectorImNS6_9allocatorImEEEENS0_4HashIS5_EENS0_14QuadraticProbeELb0EE12FindInternalERKS5_: 293| 731k| size_t FindInternal(const Key& key) const { 294| 731k| const size_t key_hash = Hasher{}(key); 295| 731k| const uint8_t tag = HashToTag(key_hash); 296| 731k| PERFETTO_DCHECK((capacity_ & (capacity_ - 1)) == 0); // Must be a pow2. 297| 731k| PERFETTO_DCHECK(max_probe_length_ <= capacity_); 298| 735k| for (size_t i = 0; i < max_probe_length_; ++i) { ------------------ | Branch (298:24): [True: 26.3k, False: 708k] ------------------ 299| 26.3k| const size_t idx = Probe::Calc(key_hash, i, capacity_); 300| 26.3k| const uint8_t tag_idx = tags_[idx]; 301| | 302| 26.3k| if (tag_idx == kFreeSlot) ------------------ | Branch (302:11): [True: 22.6k, False: 3.64k] ------------------ 303| 22.6k| return kNotFound; 304| | // HashToTag() never returns kTombstone, so the tag-check below cannot 305| | // possibly match. Also we just want to skip tombstones. 306| 3.64k| if (tag_idx == tag && keys_[idx] == key) { ------------------ | Branch (306:11): [True: 248, False: 3.39k] | Branch (306:29): [True: 248, False: 0] ------------------ 307| 248| PERFETTO_DCHECK(tag_idx > kTombstone); 308| 248| return idx; 309| 248| } 310| 3.64k| } // for (idx) 311| 708k| return kNotFound; 312| 731k| } _ZN8perfetto4base11FlatHashMapImNS_15trace_processor6tables10SliceTable2IdENS0_4HashImEENS0_14QuadraticProbeELb0EEixEm: 276| 135| Value& operator[](Key key) { 277| 135| auto it_and_inserted = Insert(std::move(key), Value{}); 278| 135| return *it_and_inserted.first; 279| 135| } _ZN8perfetto4base11FlatHashMapINS_15trace_processor6tables10TrackTable2IdENSt3__16vectorImNS6_9allocatorImEEEENS0_4HashIS5_EENS0_14QuadraticProbeELb0EE5EraseERKS5_: 252| 124| bool Erase(const Key& key) { 253| 124| if (AppendOnly) ------------------ | Branch (253:9): [Folded - Ignored] ------------------ 254| 0| PERFETTO_FATAL("Erase() not supported because AppendOnly=true"); 255| 124| size_t idx = FindInternal(key); 256| 124| if (idx == kNotFound) ------------------ | Branch (256:9): [True: 0, False: 124] ------------------ 257| 0| return false; 258| 124| EraseInternal(idx); 259| 124| return true; 260| 124| } _ZNK8perfetto4base11FlatHashMapImNS_15trace_processor11FlowTracker8V1FlowIdENS0_4HashImEENS0_14QuadraticProbeELb0EE4FindERKm: 245| 1.40k| Value* Find(const Key& key) const { 246| 1.40k| const size_t idx = FindInternal(key); 247| 1.40k| if (idx == kNotFound) ------------------ | Branch (247:9): [True: 9, False: 1.39k] ------------------ 248| 9| return nullptr; 249| 1.39k| return &values_[idx]; 250| 1.40k| } _ZNK8perfetto4base11FlatHashMapImNS_15trace_processor11FlowTracker8V1FlowIdENS0_4HashImEENS0_14QuadraticProbeELb0EE12FindInternalERKm: 293| 1.40k| size_t FindInternal(const Key& key) const { 294| 1.40k| const size_t key_hash = Hasher{}(key); 295| 1.40k| const uint8_t tag = HashToTag(key_hash); 296| 1.40k| PERFETTO_DCHECK((capacity_ & (capacity_ - 1)) == 0); // Must be a pow2. 297| 1.40k| PERFETTO_DCHECK(max_probe_length_ <= capacity_); 298| 1.40k| for (size_t i = 0; i < max_probe_length_; ++i) { ------------------ | Branch (298:24): [True: 1.39k, False: 9] ------------------ 299| 1.39k| const size_t idx = Probe::Calc(key_hash, i, capacity_); 300| 1.39k| const uint8_t tag_idx = tags_[idx]; 301| | 302| 1.39k| if (tag_idx == kFreeSlot) ------------------ | Branch (302:11): [True: 0, False: 1.39k] ------------------ 303| 0| return kNotFound; 304| | // HashToTag() never returns kTombstone, so the tag-check below cannot 305| | // possibly match. Also we just want to skip tombstones. 306| 1.39k| if (tag_idx == tag && keys_[idx] == key) { ------------------ | Branch (306:11): [True: 1.39k, False: 2] | Branch (306:29): [True: 1.39k, False: 0] ------------------ 307| 1.39k| PERFETTO_DCHECK(tag_idx > kTombstone); 308| 1.39k| return idx; 309| 1.39k| } 310| 1.39k| } // for (idx) 311| 9| return kNotFound; 312| 1.40k| } _ZN8perfetto4base11FlatHashMapImjNS0_13AlreadyHashedImEENS0_14QuadraticProbeELb0EEC2Emi: 135| 2.03k| : load_limit_percent_(load_limit_pct) { 136| 2.03k| if (initial_capacity > 0) ------------------ | Branch (136:9): [True: 0, False: 2.03k] ------------------ 137| 0| Reset(initial_capacity); 138| 2.03k| } _ZN8perfetto4base11FlatHashMapINSt3__14pairImjEENS_15trace_processor25LegacyV8CpuProfileTracker5StateENS6_6HasherENS0_14QuadraticProbeELb0EEC2Emi: 135| 2.03k| : load_limit_percent_(load_limit_pct) { 136| 2.03k| if (initial_capacity > 0) ------------------ | Branch (136:9): [True: 0, False: 2.03k] ------------------ 137| 0| Reset(initial_capacity); 138| 2.03k| } _ZN8perfetto4base11FlatHashMapIjNSt3__16vectorIjNS2_9allocatorIjEEEENS0_4HashIjEENS0_14QuadraticProbeELb0EEC2Emi: 135| 2.03k| : load_limit_percent_(load_limit_pct) { 136| 2.03k| if (initial_capacity > 0) ------------------ | Branch (136:9): [True: 0, False: 2.03k] ------------------ 137| 0| Reset(initial_capacity); 138| 2.03k| } _ZN8perfetto4base11FlatHashMapIjjNS0_4HashIjEENS0_14QuadraticProbeELb0EEC2Emi: 135| 2.03k| : load_limit_percent_(load_limit_pct) { 136| 2.03k| if (initial_capacity > 0) ------------------ | Branch (136:9): [True: 0, False: 2.03k] ------------------ 137| 0| Reset(initial_capacity); 138| 2.03k| } _ZN8perfetto4base11FlatHashMapIjjNS0_4HashIjEENS0_14QuadraticProbeELb0EE5ResetEm: 359| 4.53k| PERFETTO_NO_INLINE void Reset(size_t n) { 360| 4.53k| PERFETTO_DCHECK((n & (n - 1)) == 0); // Must be a pow2. 361| | 362| 4.53k| capacity_ = n; 363| 4.53k| max_probe_length_ = 0; 364| 4.53k| size_ = 0; 365| 4.53k| load_limit_ = n * static_cast(load_limit_percent_) / 100; 366| 4.53k| load_limit_ = std::min(load_limit_, n); 367| | 368| 4.53k| tags_.reset(new uint8_t[n]); 369| 4.53k| memset(&tags_[0], 0, n); // Clear all tags. 370| 4.53k| keys_ = AlignedAllocTyped(n); // Deliberately not 0-initialized. 371| 4.53k| values_ = AlignedAllocTyped(n); // Deliberately not 0-initialized. 372| 4.53k| } _ZN8perfetto4base11FlatHashMapIjNSt3__16vectorIjNS2_9allocatorIjEEEENS0_4HashIjEENS0_14QuadraticProbeELb0EED2Ev: 142| 2.03k| ~FlatHashMap() { Clear(); } _ZN8perfetto4base11FlatHashMapIjjNS0_4HashIjEENS0_14QuadraticProbeELb0EED2Ev: 142| 2.03k| ~FlatHashMap() { Clear(); } _ZN8perfetto4base11FlatHashMapIjjNS0_4HashIjEENS0_14QuadraticProbeELb0EE5EraseERKj: 252| 6.44k| bool Erase(const Key& key) { 253| 6.44k| if (AppendOnly) ------------------ | Branch (253:9): [Folded - Ignored] ------------------ 254| 0| PERFETTO_FATAL("Erase() not supported because AppendOnly=true"); 255| 6.44k| size_t idx = FindInternal(key); 256| 6.44k| if (idx == kNotFound) ------------------ | Branch (256:9): [True: 0, False: 6.44k] ------------------ 257| 0| return false; 258| 6.44k| EraseInternal(idx); 259| 6.44k| return true; 260| 6.44k| } _ZN8perfetto4base11FlatHashMapIjjNS0_4HashIjEENS0_14QuadraticProbeELb0EE13EraseInternalEm: 314| 566k| void EraseInternal(size_t idx) { 315| 566k| PERFETTO_DCHECK(tags_[idx] > kTombstone); 316| 566k| PERFETTO_DCHECK(size_ > 0); 317| 566k| tags_[idx] = kTombstone; 318| 566k| keys_[idx].~Key(); 319| 566k| values_[idx].~Value(); 320| 566k| size_--; 321| 566k| } _ZNK8perfetto4base11FlatHashMapIjNSt3__16vectorIjNS2_9allocatorIjEEEENS0_4HashIjEENS0_14QuadraticProbeELb0EE4FindERKj: 245| 969k| Value* Find(const Key& key) const { 246| 969k| const size_t idx = FindInternal(key); 247| 969k| if (idx == kNotFound) ------------------ | Branch (247:9): [True: 566k, False: 402k] ------------------ 248| 566k| return nullptr; 249| 402k| return &values_[idx]; 250| 969k| } _ZNK8perfetto4base11FlatHashMapIjNSt3__16vectorIjNS2_9allocatorIjEEEENS0_4HashIjEENS0_14QuadraticProbeELb0EE12FindInternalERKj: 293| 969k| size_t FindInternal(const Key& key) const { 294| 969k| const size_t key_hash = Hasher{}(key); 295| 969k| const uint8_t tag = HashToTag(key_hash); 296| 969k| PERFETTO_DCHECK((capacity_ & (capacity_ - 1)) == 0); // Must be a pow2. 297| 969k| PERFETTO_DCHECK(max_probe_length_ <= capacity_); 298| 1.28M| for (size_t i = 0; i < max_probe_length_; ++i) { ------------------ | Branch (298:24): [True: 1.28M, False: 1.74k] ------------------ 299| 1.28M| const size_t idx = Probe::Calc(key_hash, i, capacity_); 300| 1.28M| const uint8_t tag_idx = tags_[idx]; 301| | 302| 1.28M| if (tag_idx == kFreeSlot) ------------------ | Branch (302:11): [True: 565k, False: 716k] ------------------ 303| 565k| return kNotFound; 304| | // HashToTag() never returns kTombstone, so the tag-check below cannot 305| | // possibly match. Also we just want to skip tombstones. 306| 716k| if (tag_idx == tag && keys_[idx] == key) { ------------------ | Branch (306:11): [True: 403k, False: 313k] | Branch (306:29): [True: 402k, False: 959] ------------------ 307| 402k| PERFETTO_DCHECK(tag_idx > kTombstone); 308| 402k| return idx; 309| 402k| } 310| 716k| } // for (idx) 311| 1.74k| return kNotFound; 312| 969k| } _ZN8perfetto4base11FlatHashMapIjjNS0_4HashIjEENS0_14QuadraticProbeELb0EE6InsertEjj: 166| 1.44M| std::pair Insert(Key key, Value value) { 167| 1.44M| const size_t key_hash = Hasher{}(key); 168| 1.44M| const uint8_t tag = HashToTag(key_hash); 169| 1.44M| static constexpr size_t kSlotNotFound = std::numeric_limits::max(); 170| | 171| | // This for loop does in reality at most two attempts: 172| | // The first iteration either: 173| | // - Early-returns, because the key exists already, 174| | // - Finds an insertion slot and proceeds because the load is < limit. 175| | // The second iteration is only hit in the unlikely case of this insertion 176| | // bringing the table beyond the target |load_limit_| (or the edge case 177| | // of the HT being full, if |load_limit_pct_| = 100). 178| | // We cannot simply pre-grow the table before insertion, because we must 179| | // guarantee that calling Insert() with a key that already exists doesn't 180| | // invalidate iterators. 181| 1.44M| size_t insertion_slot; 182| 1.44M| size_t probe_len; 183| 1.45M| for (;;) { 184| 1.45M| PERFETTO_DCHECK((capacity_ & (capacity_ - 1)) == 0); // Must be a pow2. 185| 1.45M| insertion_slot = kSlotNotFound; 186| | // Start the iteration at the desired slot (key_hash % capacity_) 187| | // searching either for a free slot or a tombstone. In the worst case we 188| | // might end up scanning the whole array of slots. The Probe functions are 189| | // guaranteed to visit all the slots within |capacity_| steps. If we find 190| | // a free slot, we can stop the search immediately (a free slot acts as an 191| | // "end of chain for entries having the same hash". If we find a 192| | // tombstones (a deleted slot) we remember its position, but have to keep 193| | // searching until a free slot to make sure we don't insert a duplicate 194| | // key. 195| 2.11M| for (probe_len = 0; probe_len < capacity_;) { ------------------ | Branch (195:27): [True: 2.11M, False: 2.02k] ------------------ 196| 2.11M| const size_t idx = Probe::Calc(key_hash, probe_len, capacity_); 197| 2.11M| PERFETTO_DCHECK(idx < capacity_); 198| 2.11M| const uint8_t tag_idx = tags_[idx]; 199| 2.11M| ++probe_len; 200| 2.11M| if (tag_idx == kFreeSlot) { ------------------ | Branch (200:13): [True: 797k, False: 1.31M] ------------------ 201| | // Rationale for "insertion_slot == kSlotNotFound": if we encountered 202| | // a tombstone while iterating we should reuse that rather than 203| | // taking another slot. 204| 797k| if (AppendOnly || insertion_slot == kSlotNotFound) ------------------ | Branch (204:15): [Folded - Ignored] | Branch (204:29): [True: 791k, False: 6.44k] ------------------ 205| 791k| insertion_slot = idx; 206| 797k| break; 207| 797k| } 208| | // We should never encounter tombstones in AppendOnly mode. 209| 1.31M| PERFETTO_DCHECK(!(tag_idx == kTombstone && AppendOnly)); 210| 1.31M| if (!AppendOnly && tag_idx == kTombstone) { ------------------ | Branch (210:13): [Folded - Ignored] | Branch (210:28): [True: 6.44k, False: 1.30M] ------------------ 211| 6.44k| insertion_slot = idx; 212| 6.44k| continue; 213| 6.44k| } 214| 1.30M| if (tag_idx == tag && keys_[idx] == key) { ------------------ | Branch (214:13): [True: 653k, False: 653k] | Branch (214:31): [True: 651k, False: 1.83k] ------------------ 215| | // The key is already in the map. 216| 651k| return std::make_pair(&values_[idx], false); 217| 651k| } 218| 1.30M| } // for (idx) 219| | 220| | // If we got to this point the key does not exist (otherwise we would have 221| | // hit the return above) and we are going to insert a new entry. 222| | // Before doing so, ensure we stay under the target load limit. 223| 799k| if (PERFETTO_UNLIKELY(size_ >= load_limit_)) { ------------------ | | 24| 799k|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 2.16k, False: 797k] | | ------------------ ------------------ 224| 2.16k| MaybeGrowAndRehash(/*grow=*/true); 225| 2.16k| continue; 226| 2.16k| } 227| 797k| PERFETTO_DCHECK(insertion_slot != kSlotNotFound); 228| 797k| break; 229| 799k| } // for (attempt) 230| | 231| 797k| PERFETTO_CHECK(insertion_slot < capacity_); 232| | 233| | // We found a free slot (or a tombstone). Proceed with the insertion. 234| 797k| Value* value_idx = &values_[insertion_slot]; 235| 797k| new (&keys_[insertion_slot]) Key(std::move(key)); 236| 797k| new (value_idx) Value(std::move(value)); 237| 797k| tags_[insertion_slot] = tag; 238| 797k| PERFETTO_DCHECK(probe_len > 0 && probe_len <= capacity_); 239| 797k| max_probe_length_ = std::max(max_probe_length_, probe_len); 240| 797k| size_++; 241| | 242| 797k| return std::make_pair(value_idx, true); 243| 797k| } _ZN8perfetto4base11FlatHashMapIjjNS0_4HashIjEENS0_14QuadraticProbeELb0EE18MaybeGrowAndRehashEb: 323| 4.53k| PERFETTO_NO_INLINE void MaybeGrowAndRehash(bool grow) { 324| 4.53k| PERFETTO_DCHECK(size_ <= capacity_); 325| 4.53k| const size_t old_capacity = capacity_; 326| | 327| | // Grow quickly up to 1MB, then chill. 328| 4.53k| const size_t old_size_bytes = old_capacity * (sizeof(Key) + sizeof(Value)); 329| 4.53k| const size_t grow_factor = old_size_bytes < (1024u * 1024u) ? 8 : 2; ------------------ | Branch (329:32): [True: 4.53k, False: 0] ------------------ 330| 4.53k| const size_t new_capacity = 331| 4.53k| grow ? std::max(old_capacity * grow_factor, size_t(1024)) ------------------ | Branch (331:9): [True: 2.16k, False: 2.37k] ------------------ 332| 4.53k| : old_capacity; 333| | 334| 4.53k| auto old_tags(std::move(tags_)); 335| 4.53k| auto old_keys(std::move(keys_)); 336| 4.53k| auto old_values(std::move(values_)); 337| 4.53k| size_t old_size = size_; 338| | 339| | // This must be a CHECK (i.e. not just a DCHECK) to prevent UAF attacks on 340| | // 32-bit archs that try to double the size of the table until wrapping. 341| 4.53k| PERFETTO_CHECK(new_capacity >= old_capacity); 342| 4.53k| Reset(new_capacity); 343| | 344| 4.53k| size_t new_size = 0; // Recompute the size. 345| 6.89M| for (size_t i = 0; i < old_capacity; ++i) { ------------------ | Branch (345:24): [True: 6.88M, False: 4.53k] ------------------ 346| 6.88M| const uint8_t old_tag = old_tags[i]; 347| 6.88M| if (old_tag != kFreeSlot && old_tag != kTombstone) { ------------------ | Branch (347:11): [True: 791k, False: 6.09M] | Branch (347:35): [True: 231k, False: 559k] ------------------ 348| 231k| Insert(std::move(old_keys[i]), std::move(old_values[i])); 349| 231k| old_keys[i].~Key(); // Destroy the old objects. 350| 231k| old_values[i].~Value(); 351| 231k| new_size++; 352| 231k| } 353| 6.88M| } 354| 4.53k| PERFETTO_DCHECK(new_size == old_size); 355| 4.53k| size_ = new_size; 356| 4.53k| } _ZN8perfetto4base11FlatHashMapIjNSt3__16vectorIjNS2_9allocatorIjEEEENS0_4HashIjEENS0_14QuadraticProbeELb0EE5ClearEv: 262| 2.38k| void Clear() { 263| | // Avoid trivial heap operations on zero-capacity std::move()-d objects. 264| 2.38k| if (PERFETTO_UNLIKELY(capacity_ == 0)) ------------------ | | 24| 2.38k|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 10, False: 2.37k] | | ------------------ ------------------ 265| 10| return; 266| | 267| 6.61M| for (size_t i = 0; i < capacity_; ++i) { ------------------ | Branch (267:24): [True: 6.60M, False: 2.37k] ------------------ 268| 6.60M| const uint8_t tag = tags_[i]; 269| 6.60M| if (tag != kFreeSlot && tag != kTombstone) ------------------ | Branch (269:11): [True: 569k, False: 6.03M] | Branch (269:31): [True: 569k, False: 0] ------------------ 270| 569k| EraseInternal(i); 271| 6.60M| } 272| | // Clear all tombstones. We really need to do this for AppendOnly. 273| 2.37k| MaybeGrowAndRehash(/*grow=*/false); 274| 2.37k| } _ZN8perfetto4base11FlatHashMapIjNSt3__16vectorIjNS2_9allocatorIjEEEENS0_4HashIjEENS0_14QuadraticProbeELb0EE13EraseInternalEm: 314| 569k| void EraseInternal(size_t idx) { 315| 569k| PERFETTO_DCHECK(tags_[idx] > kTombstone); 316| 569k| PERFETTO_DCHECK(size_ > 0); 317| 569k| tags_[idx] = kTombstone; 318| 569k| keys_[idx].~Key(); 319| 569k| values_[idx].~Value(); 320| 569k| size_--; 321| 569k| } _ZN8perfetto4base11FlatHashMapIjjNS0_4HashIjEENS0_14QuadraticProbeELb0EE5ClearEv: 262| 2.38k| void Clear() { 263| | // Avoid trivial heap operations on zero-capacity std::move()-d objects. 264| 2.38k| if (PERFETTO_UNLIKELY(capacity_ == 0)) ------------------ | | 24| 2.38k|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 10, False: 2.37k] | | ------------------ ------------------ 265| 10| return; 266| | 267| 6.58M| for (size_t i = 0; i < capacity_; ++i) { ------------------ | Branch (267:24): [True: 6.57M, False: 2.37k] ------------------ 268| 6.57M| const uint8_t tag = tags_[i]; 269| 6.57M| if (tag != kFreeSlot && tag != kTombstone) ------------------ | Branch (269:11): [True: 559k, False: 6.01M] | Branch (269:31): [True: 559k, False: 0] ------------------ 270| 559k| EraseInternal(i); 271| 6.57M| } 272| | // Clear all tombstones. We really need to do this for AppendOnly. 273| 2.37k| MaybeGrowAndRehash(/*grow=*/false); 274| 2.37k| } _ZN8perfetto4base11FlatHashMapINS_15trace_processor6tables10TrackTable2IdENS2_12SliceTracker9TrackInfoENS0_4HashIS5_EENS0_14QuadraticProbeELb0EEC2Emi: 135| 2.03k| : load_limit_percent_(load_limit_pct) { 136| 2.03k| if (initial_capacity > 0) ------------------ | Branch (136:9): [True: 0, False: 2.03k] ------------------ 137| 0| Reset(initial_capacity); 138| 2.03k| } _ZN8perfetto4base11FlatHashMapINS_15trace_processor6tables10TrackTable2IdENS2_12SliceTracker9TrackInfoENS0_4HashIS5_EENS0_14QuadraticProbeELb0EE5ResetEm: 359| 1.12k| PERFETTO_NO_INLINE void Reset(size_t n) { 360| 1.12k| PERFETTO_DCHECK((n & (n - 1)) == 0); // Must be a pow2. 361| | 362| 1.12k| capacity_ = n; 363| 1.12k| max_probe_length_ = 0; 364| 1.12k| size_ = 0; 365| 1.12k| load_limit_ = n * static_cast(load_limit_percent_) / 100; 366| 1.12k| load_limit_ = std::min(load_limit_, n); 367| | 368| 1.12k| tags_.reset(new uint8_t[n]); 369| 1.12k| memset(&tags_[0], 0, n); // Clear all tags. 370| 1.12k| keys_ = AlignedAllocTyped(n); // Deliberately not 0-initialized. 371| 1.12k| values_ = AlignedAllocTyped(n); // Deliberately not 0-initialized. 372| 1.12k| } _ZN8perfetto4base11FlatHashMapINS_15trace_processor6tables10TrackTable2IdENS2_12SliceTracker9TrackInfoENS0_4HashIS5_EENS0_14QuadraticProbeELb0EED2Ev: 142| 2.03k| ~FlatHashMap() { Clear(); } _ZN8perfetto4base11FlatHashMapINS_15trace_processor6tables10TrackTable2IdENS2_12SliceTracker9TrackInfoENS0_4HashIS5_EENS0_14QuadraticProbeELb0EEixES5_: 276| 2.10M| Value& operator[](Key key) { 277| 2.10M| auto it_and_inserted = Insert(std::move(key), Value{}); 278| 2.10M| return *it_and_inserted.first; 279| 2.10M| } _ZN8perfetto4base11FlatHashMapINS_15trace_processor6tables10TrackTable2IdENS2_12SliceTracker9TrackInfoENS0_4HashIS5_EENS0_14QuadraticProbeELb0EE6InsertES5_S7_: 166| 2.12M| std::pair Insert(Key key, Value value) { 167| 2.12M| const size_t key_hash = Hasher{}(key); 168| 2.12M| const uint8_t tag = HashToTag(key_hash); 169| 2.12M| static constexpr size_t kSlotNotFound = std::numeric_limits::max(); 170| | 171| | // This for loop does in reality at most two attempts: 172| | // The first iteration either: 173| | // - Early-returns, because the key exists already, 174| | // - Finds an insertion slot and proceeds because the load is < limit. 175| | // The second iteration is only hit in the unlikely case of this insertion 176| | // bringing the table beyond the target |load_limit_| (or the edge case 177| | // of the HT being full, if |load_limit_pct_| = 100). 178| | // We cannot simply pre-grow the table before insertion, because we must 179| | // guarantee that calling Insert() with a key that already exists doesn't 180| | // invalidate iterators. 181| 2.12M| size_t insertion_slot; 182| 2.12M| size_t probe_len; 183| 2.12M| for (;;) { 184| 2.12M| PERFETTO_DCHECK((capacity_ & (capacity_ - 1)) == 0); // Must be a pow2. 185| 2.12M| insertion_slot = kSlotNotFound; 186| | // Start the iteration at the desired slot (key_hash % capacity_) 187| | // searching either for a free slot or a tombstone. In the worst case we 188| | // might end up scanning the whole array of slots. The Probe functions are 189| | // guaranteed to visit all the slots within |capacity_| steps. If we find 190| | // a free slot, we can stop the search immediately (a free slot acts as an 191| | // "end of chain for entries having the same hash". If we find a 192| | // tombstones (a deleted slot) we remember its position, but have to keep 193| | // searching until a free slot to make sure we don't insert a duplicate 194| | // key. 195| 2.18M| for (probe_len = 0; probe_len < capacity_;) { ------------------ | Branch (195:27): [True: 2.18M, False: 387] ------------------ 196| 2.18M| const size_t idx = Probe::Calc(key_hash, probe_len, capacity_); 197| 2.18M| PERFETTO_DCHECK(idx < capacity_); 198| 2.18M| const uint8_t tag_idx = tags_[idx]; 199| 2.18M| ++probe_len; 200| 2.18M| if (tag_idx == kFreeSlot) { ------------------ | Branch (200:13): [True: 111k, False: 2.07M] ------------------ 201| | // Rationale for "insertion_slot == kSlotNotFound": if we encountered 202| | // a tombstone while iterating we should reuse that rather than 203| | // taking another slot. 204| 111k| if (AppendOnly || insertion_slot == kSlotNotFound) ------------------ | Branch (204:15): [Folded - Ignored] | Branch (204:29): [True: 111k, False: 0] ------------------ 205| 111k| insertion_slot = idx; 206| 111k| break; 207| 111k| } 208| | // We should never encounter tombstones in AppendOnly mode. 209| 2.07M| PERFETTO_DCHECK(!(tag_idx == kTombstone && AppendOnly)); 210| 2.07M| if (!AppendOnly && tag_idx == kTombstone) { ------------------ | Branch (210:13): [Folded - Ignored] | Branch (210:28): [True: 0, False: 2.07M] ------------------ 211| 0| insertion_slot = idx; 212| 0| continue; 213| 0| } 214| 2.07M| if (tag_idx == tag && keys_[idx] == key) { ------------------ | Branch (214:13): [True: 2.07M, False: 0] | Branch (214:31): [True: 2.01M, False: 61.3k] ------------------ 215| | // The key is already in the map. 216| 2.01M| return std::make_pair(&values_[idx], false); 217| 2.01M| } 218| 2.07M| } // for (idx) 219| | 220| | // If we got to this point the key does not exist (otherwise we would have 221| | // hit the return above) and we are going to insert a new entry. 222| | // Before doing so, ensure we stay under the target load limit. 223| 112k| if (PERFETTO_UNLIKELY(size_ >= load_limit_)) { ------------------ | | 24| 112k|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 419, False: 111k] | | ------------------ ------------------ 224| 419| MaybeGrowAndRehash(/*grow=*/true); 225| 419| continue; 226| 419| } 227| 111k| PERFETTO_DCHECK(insertion_slot != kSlotNotFound); 228| 111k| break; 229| 112k| } // for (attempt) 230| | 231| 111k| PERFETTO_CHECK(insertion_slot < capacity_); 232| | 233| | // We found a free slot (or a tombstone). Proceed with the insertion. 234| 111k| Value* value_idx = &values_[insertion_slot]; 235| 111k| new (&keys_[insertion_slot]) Key(std::move(key)); 236| 111k| new (value_idx) Value(std::move(value)); 237| 111k| tags_[insertion_slot] = tag; 238| 111k| PERFETTO_DCHECK(probe_len > 0 && probe_len <= capacity_); 239| 111k| max_probe_length_ = std::max(max_probe_length_, probe_len); 240| 111k| size_++; 241| | 242| 111k| return std::make_pair(value_idx, true); 243| 111k| } _ZN8perfetto4base11FlatHashMapINS_15trace_processor6tables10TrackTable2IdENS2_12SliceTracker9TrackInfoENS0_4HashIS5_EENS0_14QuadraticProbeELb0EE9HashToTagEm: 374| 2.18M| static inline uint8_t HashToTag(size_t full_hash) { 375| 2.18M| uint8_t tag = full_hash >> (sizeof(full_hash) * 8 - 8); 376| | // Ensure the hash is always >= 2. We use 0, 1 for kFreeSlot and kTombstone. 377| 2.18M| tag += (tag <= kTombstone) << 1; 378| 2.18M| PERFETTO_DCHECK(tag > kTombstone); 379| 2.18M| return tag; 380| 2.18M| } _ZN8perfetto4base11FlatHashMapINS_15trace_processor6tables10TrackTable2IdENS2_12SliceTracker9TrackInfoENS0_4HashIS5_EENS0_14QuadraticProbeELb0EE18MaybeGrowAndRehashEb: 323| 1.12k| PERFETTO_NO_INLINE void MaybeGrowAndRehash(bool grow) { 324| 1.12k| PERFETTO_DCHECK(size_ <= capacity_); 325| 1.12k| const size_t old_capacity = capacity_; 326| | 327| | // Grow quickly up to 1MB, then chill. 328| 1.12k| const size_t old_size_bytes = old_capacity * (sizeof(Key) + sizeof(Value)); 329| 1.12k| const size_t grow_factor = old_size_bytes < (1024u * 1024u) ? 8 : 2; ------------------ | Branch (329:32): [True: 1.12k, False: 0] ------------------ 330| 1.12k| const size_t new_capacity = 331| 1.12k| grow ? std::max(old_capacity * grow_factor, size_t(1024)) ------------------ | Branch (331:9): [True: 419, False: 705] ------------------ 332| 1.12k| : old_capacity; 333| | 334| 1.12k| auto old_tags(std::move(tags_)); 335| 1.12k| auto old_keys(std::move(keys_)); 336| 1.12k| auto old_values(std::move(values_)); 337| 1.12k| size_t old_size = size_; 338| | 339| | // This must be a CHECK (i.e. not just a DCHECK) to prevent UAF attacks on 340| | // 32-bit archs that try to double the size of the table until wrapping. 341| 1.12k| PERFETTO_CHECK(new_capacity >= old_capacity); 342| 1.12k| Reset(new_capacity); 343| | 344| 1.12k| size_t new_size = 0; // Recompute the size. 345| 1.21M| for (size_t i = 0; i < old_capacity; ++i) { ------------------ | Branch (345:24): [True: 1.21M, False: 1.12k] ------------------ 346| 1.21M| const uint8_t old_tag = old_tags[i]; 347| 1.21M| if (old_tag != kFreeSlot && old_tag != kTombstone) { ------------------ | Branch (347:11): [True: 111k, False: 1.10M] | Branch (347:35): [True: 24.5k, False: 87.0k] ------------------ 348| 24.5k| Insert(std::move(old_keys[i]), std::move(old_values[i])); 349| 24.5k| old_keys[i].~Key(); // Destroy the old objects. 350| 24.5k| old_values[i].~Value(); 351| 24.5k| new_size++; 352| 24.5k| } 353| 1.21M| } 354| 1.12k| PERFETTO_DCHECK(new_size == old_size); 355| 1.12k| size_ = new_size; 356| 1.12k| } _ZNK8perfetto4base11FlatHashMapINS_15trace_processor6tables10TrackTable2IdENS2_12SliceTracker9TrackInfoENS0_4HashIS5_EENS0_14QuadraticProbeELb0EE4FindERKS5_: 245| 57.3k| Value* Find(const Key& key) const { 246| 57.3k| const size_t idx = FindInternal(key); 247| 57.3k| if (idx == kNotFound) ------------------ | Branch (247:9): [True: 6.31k, False: 50.9k] ------------------ 248| 6.31k| return nullptr; 249| 50.9k| return &values_[idx]; 250| 57.3k| } _ZNK8perfetto4base11FlatHashMapINS_15trace_processor6tables10TrackTable2IdENS2_12SliceTracker9TrackInfoENS0_4HashIS5_EENS0_14QuadraticProbeELb0EE12FindInternalERKS5_: 293| 57.3k| size_t FindInternal(const Key& key) const { 294| 57.3k| const size_t key_hash = Hasher{}(key); 295| 57.3k| const uint8_t tag = HashToTag(key_hash); 296| 57.3k| PERFETTO_DCHECK((capacity_ & (capacity_ - 1)) == 0); // Must be a pow2. 297| 57.3k| PERFETTO_DCHECK(max_probe_length_ <= capacity_); 298| 57.6k| for (size_t i = 0; i < max_probe_length_; ++i) { ------------------ | Branch (298:24): [True: 51.5k, False: 6.08k] ------------------ 299| 51.5k| const size_t idx = Probe::Calc(key_hash, i, capacity_); 300| 51.5k| const uint8_t tag_idx = tags_[idx]; 301| | 302| 51.5k| if (tag_idx == kFreeSlot) ------------------ | Branch (302:11): [True: 224, False: 51.3k] ------------------ 303| 224| return kNotFound; 304| | // HashToTag() never returns kTombstone, so the tag-check below cannot 305| | // possibly match. Also we just want to skip tombstones. 306| 51.3k| if (tag_idx == tag && keys_[idx] == key) { ------------------ | Branch (306:11): [True: 51.3k, False: 0] | Branch (306:29): [True: 50.9k, False: 367] ------------------ 307| 50.9k| PERFETTO_DCHECK(tag_idx > kTombstone); 308| 50.9k| return idx; 309| 50.9k| } 310| 51.3k| } // for (idx) 311| 6.08k| return kNotFound; 312| 57.3k| } _ZN8perfetto4base11FlatHashMapINS_15trace_processor6tables10TrackTable2IdENS2_12SliceTracker9TrackInfoENS0_4HashIS5_EENS0_14QuadraticProbeELb0EE11GetIteratorEv: 281| 345| Iterator GetIterator() { return Iterator(this); } _ZN8perfetto4base11FlatHashMapINS_15trace_processor6tables10TrackTable2IdENS2_12SliceTracker9TrackInfoENS0_4HashIS5_EENS0_14QuadraticProbeELb0EE8IteratorC2EPKSB_: 96| 345| explicit Iterator(const FlatHashMap* map) : map_(map) { FindNextNonFree(); } _ZN8perfetto4base11FlatHashMapINS_15trace_processor6tables10TrackTable2IdENS2_12SliceTracker9TrackInfoENS0_4HashIS5_EENS0_14QuadraticProbeELb0EE8Iterator15FindNextNonFreeEv: 119| 81.9k| void FindNextNonFree() { 120| 81.9k| const auto& tags = map_->tags_; 121| 555k| for (; idx_ < map_->capacity_; idx_++) { ------------------ | Branch (121:14): [True: 555k, False: 345] ------------------ 122| 555k| if (tags[idx_] != kFreeSlot && (AppendOnly || tags[idx_] != kTombstone)) ------------------ | Branch (122:13): [True: 81.5k, False: 473k] | Branch (122:41): [Folded - Ignored] | Branch (122:55): [True: 81.5k, False: 0] ------------------ 123| 81.5k| return; 124| 555k| } 125| 345| idx_ = kEnd; 126| 345| } _ZNK8perfetto4base11FlatHashMapINS_15trace_processor6tables10TrackTable2IdENS2_12SliceTracker9TrackInfoENS0_4HashIS5_EENS0_14QuadraticProbeELb0EE8IteratorcvbEv: 108| 81.9k| explicit operator bool() const { return idx_ != kEnd; } _ZN8perfetto4base11FlatHashMapINS_15trace_processor6tables10TrackTable2IdENS2_12SliceTracker9TrackInfoENS0_4HashIS5_EENS0_14QuadraticProbeELb0EE8IteratorppEv: 109| 81.5k| Iterator& operator++() { 110| 81.5k| PERFETTO_DCHECK(idx_ < map_->capacity_); 111| 81.5k| ++idx_; 112| 81.5k| FindNextNonFree(); 113| 81.5k| return *this; 114| 81.5k| } _ZN8perfetto4base11FlatHashMapINS_15trace_processor6tables10TrackTable2IdENS2_12SliceTracker9TrackInfoENS0_4HashIS5_EENS0_14QuadraticProbeELb0EE8Iterator5valueEv: 104| 81.5k| Value& value() { return map_->values_[idx_]; } _ZN8perfetto4base11FlatHashMapINS_15trace_processor6tables10TrackTable2IdENS2_12SliceTracker9TrackInfoENS0_4HashIS5_EENS0_14QuadraticProbeELb0EE5ClearEv: 262| 2.38k| void Clear() { 263| | // Avoid trivial heap operations on zero-capacity std::move()-d objects. 264| 2.38k| if (PERFETTO_UNLIKELY(capacity_ == 0)) ------------------ | | 24| 2.38k|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 1.67k, False: 705] | | ------------------ ------------------ 265| 1.67k| return; 266| | 267| 1.18M| for (size_t i = 0; i < capacity_; ++i) { ------------------ | Branch (267:24): [True: 1.18M, False: 705] ------------------ 268| 1.18M| const uint8_t tag = tags_[i]; 269| 1.18M| if (tag != kFreeSlot && tag != kTombstone) ------------------ | Branch (269:11): [True: 87.0k, False: 1.09M] | Branch (269:31): [True: 87.0k, False: 0] ------------------ 270| 87.0k| EraseInternal(i); 271| 1.18M| } 272| | // Clear all tombstones. We really need to do this for AppendOnly. 273| 705| MaybeGrowAndRehash(/*grow=*/false); 274| 705| } _ZN8perfetto4base11FlatHashMapINS_15trace_processor6tables10TrackTable2IdENS2_12SliceTracker9TrackInfoENS0_4HashIS5_EENS0_14QuadraticProbeELb0EE13EraseInternalEm: 314| 87.0k| void EraseInternal(size_t idx) { 315| 87.0k| PERFETTO_DCHECK(tags_[idx] > kTombstone); 316| 87.0k| PERFETTO_DCHECK(size_ > 0); 317| 87.0k| tags_[idx] = kTombstone; 318| 87.0k| keys_[idx].~Key(); 319| 87.0k| values_[idx].~Value(); 320| 87.0k| size_--; 321| 87.0k| } _ZN8perfetto4base11FlatHashMapImNS_15trace_processor15TrackCompressor11TrackSetNewENS0_13AlreadyHashedImEENS0_14QuadraticProbeELb0EEC2Emi: 135| 2.03k| : load_limit_percent_(load_limit_pct) { 136| 2.03k| if (initial_capacity > 0) ------------------ | Branch (136:9): [True: 0, False: 2.03k] ------------------ 137| 0| Reset(initial_capacity); 138| 2.03k| } _ZN8perfetto4base11FlatHashMapImNS_15trace_processor6tables10TrackTable2IdENS0_13AlreadyHashedImEENS0_14QuadraticProbeELb0EEC2Emi: 135| 2.03k| : load_limit_percent_(load_limit_pct) { 136| 2.03k| if (initial_capacity > 0) ------------------ | Branch (136:9): [True: 0, False: 2.03k] ------------------ 137| 0| Reset(initial_capacity); 138| 2.03k| } _ZN8perfetto4base11FlatHashMapIjNS_15trace_processor28ActiveChromeProcessesTracker11ProcessDataENS0_4HashIjEENS0_14QuadraticProbeELb0EEixEj: 276| 459k| Value& operator[](Key key) { 277| 459k| auto it_and_inserted = Insert(std::move(key), Value{}); 278| 459k| return *it_and_inserted.first; 279| 459k| } _ZN8perfetto4base11FlatHashMapIjNS_15trace_processor28ActiveChromeProcessesTracker11ProcessDataENS0_4HashIjEENS0_14QuadraticProbeELb0EE6InsertEjS4_: 166| 635k| std::pair Insert(Key key, Value value) { 167| 635k| const size_t key_hash = Hasher{}(key); 168| 635k| const uint8_t tag = HashToTag(key_hash); 169| 635k| static constexpr size_t kSlotNotFound = std::numeric_limits::max(); 170| | 171| | // This for loop does in reality at most two attempts: 172| | // The first iteration either: 173| | // - Early-returns, because the key exists already, 174| | // - Finds an insertion slot and proceeds because the load is < limit. 175| | // The second iteration is only hit in the unlikely case of this insertion 176| | // bringing the table beyond the target |load_limit_| (or the edge case 177| | // of the HT being full, if |load_limit_pct_| = 100). 178| | // We cannot simply pre-grow the table before insertion, because we must 179| | // guarantee that calling Insert() with a key that already exists doesn't 180| | // invalidate iterators. 181| 635k| size_t insertion_slot; 182| 635k| size_t probe_len; 183| 635k| for (;;) { 184| 635k| PERFETTO_DCHECK((capacity_ & (capacity_ - 1)) == 0); // Must be a pow2. 185| 635k| insertion_slot = kSlotNotFound; 186| | // Start the iteration at the desired slot (key_hash % capacity_) 187| | // searching either for a free slot or a tombstone. In the worst case we 188| | // might end up scanning the whole array of slots. The Probe functions are 189| | // guaranteed to visit all the slots within |capacity_| steps. If we find 190| | // a free slot, we can stop the search immediately (a free slot acts as an 191| | // "end of chain for entries having the same hash". If we find a 192| | // tombstones (a deleted slot) we remember its position, but have to keep 193| | // searching until a free slot to make sure we don't insert a duplicate 194| | // key. 195| 847k| for (probe_len = 0; probe_len < capacity_;) { ------------------ | Branch (195:27): [True: 846k, False: 189] ------------------ 196| 846k| const size_t idx = Probe::Calc(key_hash, probe_len, capacity_); 197| 846k| PERFETTO_DCHECK(idx < capacity_); 198| 846k| const uint8_t tag_idx = tags_[idx]; 199| 846k| ++probe_len; 200| 846k| if (tag_idx == kFreeSlot) { ------------------ | Branch (200:13): [True: 592k, False: 254k] ------------------ 201| | // Rationale for "insertion_slot == kSlotNotFound": if we encountered 202| | // a tombstone while iterating we should reuse that rather than 203| | // taking another slot. 204| 592k| if (AppendOnly || insertion_slot == kSlotNotFound) ------------------ | Branch (204:15): [Folded - Ignored] | Branch (204:29): [True: 592k, False: 0] ------------------ 205| 592k| insertion_slot = idx; 206| 592k| break; 207| 592k| } 208| | // We should never encounter tombstones in AppendOnly mode. 209| 254k| PERFETTO_DCHECK(!(tag_idx == kTombstone && AppendOnly)); 210| 254k| if (!AppendOnly && tag_idx == kTombstone) { ------------------ | Branch (210:13): [Folded - Ignored] | Branch (210:28): [True: 0, False: 254k] ------------------ 211| 0| insertion_slot = idx; 212| 0| continue; 213| 0| } 214| 254k| if (tag_idx == tag && keys_[idx] == key) { ------------------ | Branch (214:13): [True: 42.4k, False: 211k] | Branch (214:31): [True: 42.3k, False: 80] ------------------ 215| | // The key is already in the map. 216| 42.3k| return std::make_pair(&values_[idx], false); 217| 42.3k| } 218| 254k| } // for (idx) 219| | 220| | // If we got to this point the key does not exist (otherwise we would have 221| | // hit the return above) and we are going to insert a new entry. 222| | // Before doing so, ensure we stay under the target load limit. 223| 593k| if (PERFETTO_UNLIKELY(size_ >= load_limit_)) { ------------------ | | 24| 593k|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 250, False: 592k] | | ------------------ ------------------ 224| 250| MaybeGrowAndRehash(/*grow=*/true); 225| 250| continue; 226| 250| } 227| 592k| PERFETTO_DCHECK(insertion_slot != kSlotNotFound); 228| 592k| break; 229| 593k| } // for (attempt) 230| | 231| 592k| PERFETTO_CHECK(insertion_slot < capacity_); 232| | 233| | // We found a free slot (or a tombstone). Proceed with the insertion. 234| 592k| Value* value_idx = &values_[insertion_slot]; 235| 592k| new (&keys_[insertion_slot]) Key(std::move(key)); 236| 592k| new (value_idx) Value(std::move(value)); 237| 592k| tags_[insertion_slot] = tag; 238| 592k| PERFETTO_DCHECK(probe_len > 0 && probe_len <= capacity_); 239| 592k| max_probe_length_ = std::max(max_probe_length_, probe_len); 240| 592k| size_++; 241| | 242| 592k| return std::make_pair(value_idx, true); 243| 592k| } _ZN8perfetto4base11FlatHashMapIjNS_15trace_processor28ActiveChromeProcessesTracker11ProcessDataENS0_4HashIjEENS0_14QuadraticProbeELb0EE9HashToTagEm: 374| 635k| static inline uint8_t HashToTag(size_t full_hash) { 375| 635k| uint8_t tag = full_hash >> (sizeof(full_hash) * 8 - 8); 376| | // Ensure the hash is always >= 2. We use 0, 1 for kFreeSlot and kTombstone. 377| 635k| tag += (tag <= kTombstone) << 1; 378| 635k| PERFETTO_DCHECK(tag > kTombstone); 379| 635k| return tag; 380| 635k| } _ZN8perfetto4base11FlatHashMapIjNS_15trace_processor28ActiveChromeProcessesTracker11ProcessDataENS0_4HashIjEENS0_14QuadraticProbeELb0EE18MaybeGrowAndRehashEb: 323| 439| PERFETTO_NO_INLINE void MaybeGrowAndRehash(bool grow) { 324| 439| PERFETTO_DCHECK(size_ <= capacity_); 325| 439| const size_t old_capacity = capacity_; 326| | 327| | // Grow quickly up to 1MB, then chill. 328| 439| const size_t old_size_bytes = old_capacity * (sizeof(Key) + sizeof(Value)); 329| 439| const size_t grow_factor = old_size_bytes < (1024u * 1024u) ? 8 : 2; ------------------ | Branch (329:32): [True: 415, False: 24] ------------------ 330| 439| const size_t new_capacity = 331| 439| grow ? std::max(old_capacity * grow_factor, size_t(1024)) ------------------ | Branch (331:9): [True: 250, False: 189] ------------------ 332| 439| : old_capacity; 333| | 334| 439| auto old_tags(std::move(tags_)); 335| 439| auto old_keys(std::move(keys_)); 336| 439| auto old_values(std::move(values_)); 337| 439| size_t old_size = size_; 338| | 339| | // This must be a CHECK (i.e. not just a DCHECK) to prevent UAF attacks on 340| | // 32-bit archs that try to double the size of the table until wrapping. 341| 439| PERFETTO_CHECK(new_capacity >= old_capacity); 342| 439| Reset(new_capacity); 343| | 344| 439| size_t new_size = 0; // Recompute the size. 345| 2.06M| for (size_t i = 0; i < old_capacity; ++i) { ------------------ | Branch (345:24): [True: 2.06M, False: 439] ------------------ 346| 2.06M| const uint8_t old_tag = old_tags[i]; 347| 2.06M| if (old_tag != kFreeSlot && old_tag != kTombstone) { ------------------ | Branch (347:11): [True: 592k, False: 1.47M] | Branch (347:35): [True: 175k, False: 416k] ------------------ 348| 175k| Insert(std::move(old_keys[i]), std::move(old_values[i])); 349| 175k| old_keys[i].~Key(); // Destroy the old objects. 350| 175k| old_values[i].~Value(); 351| 175k| new_size++; 352| 175k| } 353| 2.06M| } 354| 439| PERFETTO_DCHECK(new_size == old_size); 355| 439| size_ = new_size; 356| 439| } _ZN8perfetto4base11FlatHashMapIjNS_15trace_processor28ActiveChromeProcessesTracker11ProcessDataENS0_4HashIjEENS0_14QuadraticProbeELb0EE5ResetEm: 359| 439| PERFETTO_NO_INLINE void Reset(size_t n) { 360| 439| PERFETTO_DCHECK((n & (n - 1)) == 0); // Must be a pow2. 361| | 362| 439| capacity_ = n; 363| 439| max_probe_length_ = 0; 364| 439| size_ = 0; 365| 439| load_limit_ = n * static_cast(load_limit_percent_) / 100; 366| 439| load_limit_ = std::min(load_limit_, n); 367| | 368| 439| tags_.reset(new uint8_t[n]); 369| 439| memset(&tags_[0], 0, n); // Clear all tags. 370| 439| keys_ = AlignedAllocTyped(n); // Deliberately not 0-initialized. 371| 439| values_ = AlignedAllocTyped(n); // Deliberately not 0-initialized. 372| 439| } _ZNK8perfetto4base11FlatHashMapIjNS_15trace_processor28ActiveChromeProcessesTracker11ProcessDataENS0_4HashIjEENS0_14QuadraticProbeELb0EE11GetIteratorEv: 282| 345| const Iterator GetIterator() const { return Iterator(this); } _ZN8perfetto4base11FlatHashMapIjNS_15trace_processor28ActiveChromeProcessesTracker11ProcessDataENS0_4HashIjEENS0_14QuadraticProbeELb0EE8IteratorC2EPKS8_: 96| 345| explicit Iterator(const FlatHashMap* map) : map_(map) { FindNextNonFree(); } _ZN8perfetto4base11FlatHashMapIjNS_15trace_processor28ActiveChromeProcessesTracker11ProcessDataENS0_4HashIjEENS0_14QuadraticProbeELb0EE8Iterator15FindNextNonFreeEv: 119| 394k| void FindNextNonFree() { 120| 394k| const auto& tags = map_->tags_; 121| 1.65M| for (; idx_ < map_->capacity_; idx_++) { ------------------ | Branch (121:14): [True: 1.65M, False: 345] ------------------ 122| 1.65M| if (tags[idx_] != kFreeSlot && (AppendOnly || tags[idx_] != kTombstone)) ------------------ | Branch (122:13): [True: 394k, False: 1.26M] | Branch (122:41): [Folded - Ignored] | Branch (122:55): [True: 394k, False: 0] ------------------ 123| 394k| return; 124| 1.65M| } 125| 345| idx_ = kEnd; 126| 345| } _ZNK8perfetto4base11FlatHashMapIjNS_15trace_processor28ActiveChromeProcessesTracker11ProcessDataENS0_4HashIjEENS0_14QuadraticProbeELb0EE8IteratorcvbEv: 108| 394k| explicit operator bool() const { return idx_ != kEnd; } _ZN8perfetto4base11FlatHashMapIjNS_15trace_processor28ActiveChromeProcessesTracker11ProcessDataENS0_4HashIjEENS0_14QuadraticProbeELb0EE8IteratorppEv: 109| 394k| Iterator& operator++() { 110| 394k| PERFETTO_DCHECK(idx_ < map_->capacity_); 111| 394k| ++idx_; 112| 394k| FindNextNonFree(); 113| 394k| return *this; 114| 394k| } _ZN8perfetto4base11FlatHashMapIjNS_15trace_processor28ActiveChromeProcessesTracker11ProcessDataENS0_4HashIjEENS0_14QuadraticProbeELb0EE8Iterator3keyEv: 103| 394k| Key& key() { return map_->keys_[idx_]; } _ZN8perfetto4base11FlatHashMapIjNS_15trace_processor28ActiveChromeProcessesTracker11ProcessDataENS0_4HashIjEENS0_14QuadraticProbeELb0EE8Iterator5valueEv: 104| 394k| Value& value() { return map_->values_[idx_]; } _ZN8perfetto4base11FlatHashMapIjNS_15trace_processor28ActiveChromeProcessesTracker11ProcessDataENS0_4HashIjEENS0_14QuadraticProbeELb0EE5ClearEv: 262| 2.03k| void Clear() { 263| | // Avoid trivial heap operations on zero-capacity std::move()-d objects. 264| 2.03k| if (PERFETTO_UNLIKELY(capacity_ == 0)) ------------------ | | 24| 2.03k|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 1.84k, False: 189] | | ------------------ ------------------ 265| 1.84k| return; 266| | 267| 1.83M| for (size_t i = 0; i < capacity_; ++i) { ------------------ | Branch (267:24): [True: 1.83M, False: 189] ------------------ 268| 1.83M| const uint8_t tag = tags_[i]; 269| 1.83M| if (tag != kFreeSlot && tag != kTombstone) ------------------ | Branch (269:11): [True: 416k, False: 1.41M] | Branch (269:31): [True: 416k, False: 0] ------------------ 270| 416k| EraseInternal(i); 271| 1.83M| } 272| | // Clear all tombstones. We really need to do this for AppendOnly. 273| 189| MaybeGrowAndRehash(/*grow=*/false); 274| 189| } _ZN8perfetto4base11FlatHashMapIjNS_15trace_processor28ActiveChromeProcessesTracker11ProcessDataENS0_4HashIjEENS0_14QuadraticProbeELb0EE13EraseInternalEm: 314| 416k| void EraseInternal(size_t idx) { 315| 416k| PERFETTO_DCHECK(tags_[idx] > kTombstone); 316| 416k| PERFETTO_DCHECK(size_ > 0); 317| 416k| tags_[idx] = kTombstone; 318| 416k| keys_[idx].~Key(); 319| 416k| values_[idx].~Value(); 320| 416k| size_--; 321| 416k| } _ZN8perfetto4base11FlatHashMapIjNSt3__110unique_ptrINS_15trace_processor19InternedMessageViewENS2_14default_deleteIS5_EEEENS0_4HashIjEENS0_14QuadraticProbeELb0EED2Ev: 142| 44.2k| ~FlatHashMap() { Clear(); } _ZN8perfetto4base11FlatHashMapIjNS_15trace_processor24MultiMachineTraceManager20RemoteMachineContextENS0_4HashIjEENS0_14QuadraticProbeELb0EEC2Emi: 135| 434| : load_limit_percent_(load_limit_pct) { 136| 434| if (initial_capacity > 0) ------------------ | Branch (136:9): [True: 0, False: 434] ------------------ 137| 0| Reset(initial_capacity); 138| 434| } _ZN8perfetto4base11FlatHashMapIjNS_15trace_processor24MultiMachineTraceManager20RemoteMachineContextENS0_4HashIjEENS0_14QuadraticProbeELb0EE5ResetEm: 359| 24| PERFETTO_NO_INLINE void Reset(size_t n) { 360| 24| PERFETTO_DCHECK((n & (n - 1)) == 0); // Must be a pow2. 361| | 362| 24| capacity_ = n; 363| 24| max_probe_length_ = 0; 364| 24| size_ = 0; 365| 24| load_limit_ = n * static_cast(load_limit_percent_) / 100; 366| 24| load_limit_ = std::min(load_limit_, n); 367| | 368| 24| tags_.reset(new uint8_t[n]); 369| 24| memset(&tags_[0], 0, n); // Clear all tags. 370| 24| keys_ = AlignedAllocTyped(n); // Deliberately not 0-initialized. 371| 24| values_ = AlignedAllocTyped(n); // Deliberately not 0-initialized. 372| 24| } _ZN8perfetto4base11FlatHashMapIjNS_15trace_processor24MultiMachineTraceManager20RemoteMachineContextENS0_4HashIjEENS0_14QuadraticProbeELb0EED2Ev: 142| 434| ~FlatHashMap() { Clear(); } _ZN8perfetto4base11FlatHashMapIjNS_15trace_processor24MultiMachineTraceManager20RemoteMachineContextENS0_4HashIjEENS0_14QuadraticProbeELb0EE5ClearEv: 262| 434| void Clear() { 263| | // Avoid trivial heap operations on zero-capacity std::move()-d objects. 264| 434| if (PERFETTO_UNLIKELY(capacity_ == 0)) ------------------ | | 24| 434|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 422, False: 12] | | ------------------ ------------------ 265| 422| return; 266| | 267| 12.3k| for (size_t i = 0; i < capacity_; ++i) { ------------------ | Branch (267:24): [True: 12.2k, False: 12] ------------------ 268| 12.2k| const uint8_t tag = tags_[i]; 269| 12.2k| if (tag != kFreeSlot && tag != kTombstone) ------------------ | Branch (269:11): [True: 1.60k, False: 10.6k] | Branch (269:31): [True: 1.60k, False: 0] ------------------ 270| 1.60k| EraseInternal(i); 271| 12.2k| } 272| | // Clear all tombstones. We really need to do this for AppendOnly. 273| 12| MaybeGrowAndRehash(/*grow=*/false); 274| 12| } _ZN8perfetto4base11FlatHashMapIjNS_15trace_processor24MultiMachineTraceManager20RemoteMachineContextENS0_4HashIjEENS0_14QuadraticProbeELb0EE13EraseInternalEm: 314| 1.60k| void EraseInternal(size_t idx) { 315| 1.60k| PERFETTO_DCHECK(tags_[idx] > kTombstone); 316| 1.60k| PERFETTO_DCHECK(size_ > 0); 317| 1.60k| tags_[idx] = kTombstone; 318| 1.60k| keys_[idx].~Key(); 319| 1.60k| values_[idx].~Value(); 320| 1.60k| size_--; 321| 1.60k| } _ZN8perfetto4base11FlatHashMapIjNS_15trace_processor24MultiMachineTraceManager20RemoteMachineContextENS0_4HashIjEENS0_14QuadraticProbeELb0EE18MaybeGrowAndRehashEb: 323| 24| PERFETTO_NO_INLINE void MaybeGrowAndRehash(bool grow) { 324| 24| PERFETTO_DCHECK(size_ <= capacity_); 325| 24| const size_t old_capacity = capacity_; 326| | 327| | // Grow quickly up to 1MB, then chill. 328| 24| const size_t old_size_bytes = old_capacity * (sizeof(Key) + sizeof(Value)); 329| 24| const size_t grow_factor = old_size_bytes < (1024u * 1024u) ? 8 : 2; ------------------ | Branch (329:32): [True: 24, False: 0] ------------------ 330| 24| const size_t new_capacity = 331| 24| grow ? std::max(old_capacity * grow_factor, size_t(1024)) ------------------ | Branch (331:9): [True: 12, False: 12] ------------------ 332| 24| : old_capacity; 333| | 334| 24| auto old_tags(std::move(tags_)); 335| 24| auto old_keys(std::move(keys_)); 336| 24| auto old_values(std::move(values_)); 337| 24| size_t old_size = size_; 338| | 339| | // This must be a CHECK (i.e. not just a DCHECK) to prevent UAF attacks on 340| | // 32-bit archs that try to double the size of the table until wrapping. 341| 24| PERFETTO_CHECK(new_capacity >= old_capacity); 342| 24| Reset(new_capacity); 343| | 344| 24| size_t new_size = 0; // Recompute the size. 345| 12.3k| for (size_t i = 0; i < old_capacity; ++i) { ------------------ | Branch (345:24): [True: 12.2k, False: 24] ------------------ 346| 12.2k| const uint8_t old_tag = old_tags[i]; 347| 12.2k| if (old_tag != kFreeSlot && old_tag != kTombstone) { ------------------ | Branch (347:11): [True: 1.60k, False: 10.6k] | Branch (347:35): [True: 0, False: 1.60k] ------------------ 348| 0| Insert(std::move(old_keys[i]), std::move(old_values[i])); 349| 0| old_keys[i].~Key(); // Destroy the old objects. 350| 0| old_values[i].~Value(); 351| 0| new_size++; 352| 0| } 353| 12.2k| } 354| 24| PERFETTO_DCHECK(new_size == old_size); 355| 24| size_ = new_size; 356| 24| } _ZN8perfetto4base11FlatHashMapIjNS_15trace_processor24MultiMachineTraceManager20RemoteMachineContextENS0_4HashIjEENS0_14QuadraticProbeELb0EE6InsertEjS4_: 166| 3.20k| std::pair Insert(Key key, Value value) { 167| 3.20k| const size_t key_hash = Hasher{}(key); 168| 3.20k| const uint8_t tag = HashToTag(key_hash); 169| 3.20k| static constexpr size_t kSlotNotFound = std::numeric_limits::max(); 170| | 171| | // This for loop does in reality at most two attempts: 172| | // The first iteration either: 173| | // - Early-returns, because the key exists already, 174| | // - Finds an insertion slot and proceeds because the load is < limit. 175| | // The second iteration is only hit in the unlikely case of this insertion 176| | // bringing the table beyond the target |load_limit_| (or the edge case 177| | // of the HT being full, if |load_limit_pct_| = 100). 178| | // We cannot simply pre-grow the table before insertion, because we must 179| | // guarantee that calling Insert() with a key that already exists doesn't 180| | // invalidate iterators. 181| 3.20k| size_t insertion_slot; 182| 3.20k| size_t probe_len; 183| 3.21k| for (;;) { 184| 3.21k| PERFETTO_DCHECK((capacity_ & (capacity_ - 1)) == 0); // Must be a pow2. 185| 3.21k| insertion_slot = kSlotNotFound; 186| | // Start the iteration at the desired slot (key_hash % capacity_) 187| | // searching either for a free slot or a tombstone. In the worst case we 188| | // might end up scanning the whole array of slots. The Probe functions are 189| | // guaranteed to visit all the slots within |capacity_| steps. If we find 190| | // a free slot, we can stop the search immediately (a free slot acts as an 191| | // "end of chain for entries having the same hash". If we find a 192| | // tombstones (a deleted slot) we remember its position, but have to keep 193| | // searching until a free slot to make sure we don't insert a duplicate 194| | // key. 195| 4.40k| for (probe_len = 0; probe_len < capacity_;) { ------------------ | Branch (195:27): [True: 4.39k, False: 12] ------------------ 196| 4.39k| const size_t idx = Probe::Calc(key_hash, probe_len, capacity_); 197| 4.39k| PERFETTO_DCHECK(idx < capacity_); 198| 4.39k| const uint8_t tag_idx = tags_[idx]; 199| 4.39k| ++probe_len; 200| 4.39k| if (tag_idx == kFreeSlot) { ------------------ | Branch (200:13): [True: 1.60k, False: 2.78k] ------------------ 201| | // Rationale for "insertion_slot == kSlotNotFound": if we encountered 202| | // a tombstone while iterating we should reuse that rather than 203| | // taking another slot. 204| 1.60k| if (AppendOnly || insertion_slot == kSlotNotFound) ------------------ | Branch (204:15): [Folded - Ignored] | Branch (204:29): [True: 1.60k, False: 0] ------------------ 205| 1.60k| insertion_slot = idx; 206| 1.60k| break; 207| 1.60k| } 208| | // We should never encounter tombstones in AppendOnly mode. 209| 2.78k| PERFETTO_DCHECK(!(tag_idx == kTombstone && AppendOnly)); 210| 2.78k| if (!AppendOnly && tag_idx == kTombstone) { ------------------ | Branch (210:13): [Folded - Ignored] | Branch (210:28): [True: 0, False: 2.78k] ------------------ 211| 0| insertion_slot = idx; 212| 0| continue; 213| 0| } 214| 2.78k| if (tag_idx == tag && keys_[idx] == key) { ------------------ | Branch (214:13): [True: 1.61k, False: 1.17k] | Branch (214:31): [True: 1.60k, False: 12] ------------------ 215| | // The key is already in the map. 216| 1.60k| return std::make_pair(&values_[idx], false); 217| 1.60k| } 218| 2.78k| } // for (idx) 219| | 220| | // If we got to this point the key does not exist (otherwise we would have 221| | // hit the return above) and we are going to insert a new entry. 222| | // Before doing so, ensure we stay under the target load limit. 223| 1.61k| if (PERFETTO_UNLIKELY(size_ >= load_limit_)) { ------------------ | | 24| 1.61k|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 12, False: 1.60k] | | ------------------ ------------------ 224| 12| MaybeGrowAndRehash(/*grow=*/true); 225| 12| continue; 226| 12| } 227| 1.60k| PERFETTO_DCHECK(insertion_slot != kSlotNotFound); 228| 1.60k| break; 229| 1.61k| } // for (attempt) 230| | 231| 1.60k| PERFETTO_CHECK(insertion_slot < capacity_); 232| | 233| | // We found a free slot (or a tombstone). Proceed with the insertion. 234| 1.60k| Value* value_idx = &values_[insertion_slot]; 235| 1.60k| new (&keys_[insertion_slot]) Key(std::move(key)); 236| 1.60k| new (value_idx) Value(std::move(value)); 237| 1.60k| tags_[insertion_slot] = tag; 238| 1.60k| PERFETTO_DCHECK(probe_len > 0 && probe_len <= capacity_); 239| 1.60k| max_probe_length_ = std::max(max_probe_length_, probe_len); 240| 1.60k| size_++; 241| | 242| 1.60k| return std::make_pair(value_idx, true); 243| 1.60k| } _ZN8perfetto4base11FlatHashMapIjNS_15trace_processor24MultiMachineTraceManager20RemoteMachineContextENS0_4HashIjEENS0_14QuadraticProbeELb0EE9HashToTagEm: 374| 4.80k| static inline uint8_t HashToTag(size_t full_hash) { 375| 4.80k| uint8_t tag = full_hash >> (sizeof(full_hash) * 8 - 8); 376| | // Ensure the hash is always >= 2. We use 0, 1 for kFreeSlot and kTombstone. 377| 4.80k| tag += (tag <= kTombstone) << 1; 378| 4.80k| PERFETTO_DCHECK(tag > kTombstone); 379| 4.80k| return tag; 380| 4.80k| } _ZNK8perfetto4base11FlatHashMapIjNS_15trace_processor24MultiMachineTraceManager20RemoteMachineContextENS0_4HashIjEENS0_14QuadraticProbeELb0EE4FindERKj: 245| 1.60k| Value* Find(const Key& key) const { 246| 1.60k| const size_t idx = FindInternal(key); 247| 1.60k| if (idx == kNotFound) ------------------ | Branch (247:9): [True: 1.60k, False: 0] ------------------ 248| 1.60k| return nullptr; 249| 0| return &values_[idx]; 250| 1.60k| } _ZNK8perfetto4base11FlatHashMapIjNS_15trace_processor24MultiMachineTraceManager20RemoteMachineContextENS0_4HashIjEENS0_14QuadraticProbeELb0EE12FindInternalERKj: 293| 1.60k| size_t FindInternal(const Key& key) const { 294| 1.60k| const size_t key_hash = Hasher{}(key); 295| 1.60k| const uint8_t tag = HashToTag(key_hash); 296| 1.60k| PERFETTO_DCHECK((capacity_ & (capacity_ - 1)) == 0); // Must be a pow2. 297| 1.60k| PERFETTO_DCHECK(max_probe_length_ <= capacity_); 298| 2.19k| for (size_t i = 0; i < max_probe_length_; ++i) { ------------------ | Branch (298:24): [True: 2.16k, False: 26] ------------------ 299| 2.16k| const size_t idx = Probe::Calc(key_hash, i, capacity_); 300| 2.16k| const uint8_t tag_idx = tags_[idx]; 301| | 302| 2.16k| if (tag_idx == kFreeSlot) ------------------ | Branch (302:11): [True: 1.57k, False: 588] ------------------ 303| 1.57k| return kNotFound; 304| | // HashToTag() never returns kTombstone, so the tag-check below cannot 305| | // possibly match. Also we just want to skip tombstones. 306| 588| if (tag_idx == tag && keys_[idx] == key) { ------------------ | Branch (306:11): [True: 6, False: 582] | Branch (306:29): [True: 0, False: 6] ------------------ 307| 0| PERFETTO_DCHECK(tag_idx > kTombstone); 308| 0| return idx; 309| 0| } 310| 588| } // for (idx) 311| 26| return kNotFound; 312| 1.60k| } _ZN8perfetto4base11FlatHashMapIjNS_15trace_processor24MultiMachineTraceManager20RemoteMachineContextENS0_4HashIjEENS0_14QuadraticProbeELb0EEixEj: 276| 3.20k| Value& operator[](Key key) { 277| 3.20k| auto it_and_inserted = Insert(std::move(key), Value{}); 278| 3.20k| return *it_and_inserted.first; 279| 3.20k| } _ZN8perfetto4base11FlatHashMapIjNSt3__110unique_ptrINS_15trace_processor19InternedMessageViewENS2_14default_deleteIS5_EEEENS0_4HashIjEENS0_14QuadraticProbeELb0EEC2Emi: 135| 44.2k| : load_limit_percent_(load_limit_pct) { 136| 44.2k| if (initial_capacity > 0) ------------------ | Branch (136:9): [True: 0, False: 44.2k] ------------------ 137| 0| Reset(initial_capacity); 138| 44.2k| } _ZN8perfetto4base11FlatHashMapIjNSt3__110unique_ptrINS_15trace_processor19InternedMessageViewENS2_14default_deleteIS5_EEEENS0_4HashIjEENS0_14QuadraticProbeELb0EEC2EOSC_: 144| 18.5k| FlatHashMap(FlatHashMap&& other) noexcept { 145| 18.5k| tags_ = std::move(other.tags_); 146| 18.5k| keys_ = std::move(other.keys_); 147| 18.5k| values_ = std::move(other.values_); 148| 18.5k| capacity_ = other.capacity_; 149| 18.5k| size_ = other.size_; 150| 18.5k| max_probe_length_ = other.max_probe_length_; 151| 18.5k| load_limit_ = other.load_limit_; 152| 18.5k| load_limit_percent_ = other.load_limit_percent_; 153| | 154| 18.5k| new (&other) FlatHashMap(); 155| 18.5k| } _ZN8perfetto4base11FlatHashMapImNS_15trace_processor10StringPool2IdENS0_4HashImEENS0_14QuadraticProbeELb0EEC2Emi: 135| 2.03k| : load_limit_percent_(load_limit_pct) { 136| 2.03k| if (initial_capacity > 0) ------------------ | Branch (136:9): [True: 0, False: 2.03k] ------------------ 137| 0| Reset(initial_capacity); 138| 2.03k| } _ZN8perfetto4base11FlatHashMapImNS_15trace_processor10StringPool2IdENS0_4HashImEENS0_14QuadraticProbeELb0EE5ResetEm: 359| 104| PERFETTO_NO_INLINE void Reset(size_t n) { 360| 104| PERFETTO_DCHECK((n & (n - 1)) == 0); // Must be a pow2. 361| | 362| 104| capacity_ = n; 363| 104| max_probe_length_ = 0; 364| 104| size_ = 0; 365| 104| load_limit_ = n * static_cast(load_limit_percent_) / 100; 366| 104| load_limit_ = std::min(load_limit_, n); 367| | 368| 104| tags_.reset(new uint8_t[n]); 369| 104| memset(&tags_[0], 0, n); // Clear all tags. 370| 104| keys_ = AlignedAllocTyped(n); // Deliberately not 0-initialized. 371| 104| values_ = AlignedAllocTyped(n); // Deliberately not 0-initialized. 372| 104| } _ZN8perfetto4base11FlatHashMapImNS_15trace_processor10StringPool2IdENS0_4HashImEENS0_14QuadraticProbeELb0EED2Ev: 142| 2.03k| ~FlatHashMap() { Clear(); } _ZN8perfetto4base11FlatHashMapImNS_15trace_processor10StringPool2IdENS0_4HashImEENS0_14QuadraticProbeELb0EE5ClearEv: 262| 2.03k| void Clear() { 263| | // Avoid trivial heap operations on zero-capacity std::move()-d objects. 264| 2.03k| if (PERFETTO_UNLIKELY(capacity_ == 0)) ------------------ | | 24| 2.03k|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 1.98k, False: 52] | | ------------------ ------------------ 265| 1.98k| return; 266| | 267| 53.3k| for (size_t i = 0; i < capacity_; ++i) { ------------------ | Branch (267:24): [True: 53.2k, False: 52] ------------------ 268| 53.2k| const uint8_t tag = tags_[i]; 269| 53.2k| if (tag != kFreeSlot && tag != kTombstone) ------------------ | Branch (269:11): [True: 52, False: 53.1k] | Branch (269:31): [True: 52, False: 0] ------------------ 270| 52| EraseInternal(i); 271| 53.2k| } 272| | // Clear all tombstones. We really need to do this for AppendOnly. 273| 52| MaybeGrowAndRehash(/*grow=*/false); 274| 52| } _ZN8perfetto4base11FlatHashMapImNS_15trace_processor10StringPool2IdENS0_4HashImEENS0_14QuadraticProbeELb0EE13EraseInternalEm: 314| 52| void EraseInternal(size_t idx) { 315| 52| PERFETTO_DCHECK(tags_[idx] > kTombstone); 316| 52| PERFETTO_DCHECK(size_ > 0); 317| 52| tags_[idx] = kTombstone; 318| 52| keys_[idx].~Key(); 319| 52| values_[idx].~Value(); 320| 52| size_--; 321| 52| } _ZN8perfetto4base11FlatHashMapImNS_15trace_processor10StringPool2IdENS0_4HashImEENS0_14QuadraticProbeELb0EE18MaybeGrowAndRehashEb: 323| 104| PERFETTO_NO_INLINE void MaybeGrowAndRehash(bool grow) { 324| 104| PERFETTO_DCHECK(size_ <= capacity_); 325| 104| const size_t old_capacity = capacity_; 326| | 327| | // Grow quickly up to 1MB, then chill. 328| 104| const size_t old_size_bytes = old_capacity * (sizeof(Key) + sizeof(Value)); 329| 104| const size_t grow_factor = old_size_bytes < (1024u * 1024u) ? 8 : 2; ------------------ | Branch (329:32): [True: 104, False: 0] ------------------ 330| 104| const size_t new_capacity = 331| 104| grow ? std::max(old_capacity * grow_factor, size_t(1024)) ------------------ | Branch (331:9): [True: 52, False: 52] ------------------ 332| 104| : old_capacity; 333| | 334| 104| auto old_tags(std::move(tags_)); 335| 104| auto old_keys(std::move(keys_)); 336| 104| auto old_values(std::move(values_)); 337| 104| size_t old_size = size_; 338| | 339| | // This must be a CHECK (i.e. not just a DCHECK) to prevent UAF attacks on 340| | // 32-bit archs that try to double the size of the table until wrapping. 341| 104| PERFETTO_CHECK(new_capacity >= old_capacity); 342| 104| Reset(new_capacity); 343| | 344| 104| size_t new_size = 0; // Recompute the size. 345| 53.3k| for (size_t i = 0; i < old_capacity; ++i) { ------------------ | Branch (345:24): [True: 53.2k, False: 104] ------------------ 346| 53.2k| const uint8_t old_tag = old_tags[i]; 347| 53.2k| if (old_tag != kFreeSlot && old_tag != kTombstone) { ------------------ | Branch (347:11): [True: 52, False: 53.1k] | Branch (347:35): [True: 0, False: 52] ------------------ 348| 0| Insert(std::move(old_keys[i]), std::move(old_values[i])); 349| 0| old_keys[i].~Key(); // Destroy the old objects. 350| 0| old_values[i].~Value(); 351| 0| new_size++; 352| 0| } 353| 53.2k| } 354| 104| PERFETTO_DCHECK(new_size == old_size); 355| 104| size_ = new_size; 356| 104| } _ZN8perfetto4base11FlatHashMapImNS_15trace_processor10StringPool2IdENS0_4HashImEENS0_14QuadraticProbeELb0EE6InsertEmS4_: 166| 37.5k| std::pair Insert(Key key, Value value) { 167| 37.5k| const size_t key_hash = Hasher{}(key); 168| 37.5k| const uint8_t tag = HashToTag(key_hash); 169| 37.5k| static constexpr size_t kSlotNotFound = std::numeric_limits::max(); 170| | 171| | // This for loop does in reality at most two attempts: 172| | // The first iteration either: 173| | // - Early-returns, because the key exists already, 174| | // - Finds an insertion slot and proceeds because the load is < limit. 175| | // The second iteration is only hit in the unlikely case of this insertion 176| | // bringing the table beyond the target |load_limit_| (or the edge case 177| | // of the HT being full, if |load_limit_pct_| = 100). 178| | // We cannot simply pre-grow the table before insertion, because we must 179| | // guarantee that calling Insert() with a key that already exists doesn't 180| | // invalidate iterators. 181| 37.5k| size_t insertion_slot; 182| 37.5k| size_t probe_len; 183| 37.6k| for (;;) { 184| 37.6k| PERFETTO_DCHECK((capacity_ & (capacity_ - 1)) == 0); // Must be a pow2. 185| 37.6k| insertion_slot = kSlotNotFound; 186| | // Start the iteration at the desired slot (key_hash % capacity_) 187| | // searching either for a free slot or a tombstone. In the worst case we 188| | // might end up scanning the whole array of slots. The Probe functions are 189| | // guaranteed to visit all the slots within |capacity_| steps. If we find 190| | // a free slot, we can stop the search immediately (a free slot acts as an 191| | // "end of chain for entries having the same hash". If we find a 192| | // tombstones (a deleted slot) we remember its position, but have to keep 193| | // searching until a free slot to make sure we don't insert a duplicate 194| | // key. 195| 37.6k| for (probe_len = 0; probe_len < capacity_;) { ------------------ | Branch (195:27): [True: 37.5k, False: 52] ------------------ 196| 37.5k| const size_t idx = Probe::Calc(key_hash, probe_len, capacity_); 197| 37.5k| PERFETTO_DCHECK(idx < capacity_); 198| 37.5k| const uint8_t tag_idx = tags_[idx]; 199| 37.5k| ++probe_len; 200| 37.5k| if (tag_idx == kFreeSlot) { ------------------ | Branch (200:13): [True: 52, False: 37.5k] ------------------ 201| | // Rationale for "insertion_slot == kSlotNotFound": if we encountered 202| | // a tombstone while iterating we should reuse that rather than 203| | // taking another slot. 204| 52| if (AppendOnly || insertion_slot == kSlotNotFound) ------------------ | Branch (204:15): [Folded - Ignored] | Branch (204:29): [True: 52, False: 0] ------------------ 205| 52| insertion_slot = idx; 206| 52| break; 207| 52| } 208| | // We should never encounter tombstones in AppendOnly mode. 209| 37.5k| PERFETTO_DCHECK(!(tag_idx == kTombstone && AppendOnly)); 210| 37.5k| if (!AppendOnly && tag_idx == kTombstone) { ------------------ | Branch (210:13): [Folded - Ignored] | Branch (210:28): [True: 0, False: 37.5k] ------------------ 211| 0| insertion_slot = idx; 212| 0| continue; 213| 0| } 214| 37.5k| if (tag_idx == tag && keys_[idx] == key) { ------------------ | Branch (214:13): [True: 37.5k, False: 0] | Branch (214:31): [True: 37.5k, False: 0] ------------------ 215| | // The key is already in the map. 216| 37.5k| return std::make_pair(&values_[idx], false); 217| 37.5k| } 218| 37.5k| } // for (idx) 219| | 220| | // If we got to this point the key does not exist (otherwise we would have 221| | // hit the return above) and we are going to insert a new entry. 222| | // Before doing so, ensure we stay under the target load limit. 223| 104| if (PERFETTO_UNLIKELY(size_ >= load_limit_)) { ------------------ | | 24| 104|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 52, False: 52] | | ------------------ ------------------ 224| 52| MaybeGrowAndRehash(/*grow=*/true); 225| 52| continue; 226| 52| } 227| 52| PERFETTO_DCHECK(insertion_slot != kSlotNotFound); 228| 52| break; 229| 104| } // for (attempt) 230| | 231| 52| PERFETTO_CHECK(insertion_slot < capacity_); 232| | 233| | // We found a free slot (or a tombstone). Proceed with the insertion. 234| 52| Value* value_idx = &values_[insertion_slot]; 235| 52| new (&keys_[insertion_slot]) Key(std::move(key)); 236| 52| new (value_idx) Value(std::move(value)); 237| 52| tags_[insertion_slot] = tag; 238| 52| PERFETTO_DCHECK(probe_len > 0 && probe_len <= capacity_); 239| 52| max_probe_length_ = std::max(max_probe_length_, probe_len); 240| 52| size_++; 241| | 242| 52| return std::make_pair(value_idx, true); 243| 52| } _ZN8perfetto4base11FlatHashMapImNS_15trace_processor10StringPool2IdENS0_4HashImEENS0_14QuadraticProbeELb0EE9HashToTagEm: 374| 37.6k| static inline uint8_t HashToTag(size_t full_hash) { 375| 37.6k| uint8_t tag = full_hash >> (sizeof(full_hash) * 8 - 8); 376| | // Ensure the hash is always >= 2. We use 0, 1 for kFreeSlot and kTombstone. 377| 37.6k| tag += (tag <= kTombstone) << 1; 378| 37.6k| PERFETTO_DCHECK(tag > kTombstone); 379| 37.6k| return tag; 380| 37.6k| } _ZNK8perfetto4base11FlatHashMapImNS_15trace_processor10StringPool2IdENS0_4HashImEENS0_14QuadraticProbeELb0EE4FindERKm: 245| 63| Value* Find(const Key& key) const { 246| 63| const size_t idx = FindInternal(key); 247| 63| if (idx == kNotFound) ------------------ | Branch (247:9): [True: 18, False: 45] ------------------ 248| 18| return nullptr; 249| 45| return &values_[idx]; 250| 63| } _ZNK8perfetto4base11FlatHashMapImNS_15trace_processor10StringPool2IdENS0_4HashImEENS0_14QuadraticProbeELb0EE12FindInternalERKm: 293| 63| size_t FindInternal(const Key& key) const { 294| 63| const size_t key_hash = Hasher{}(key); 295| 63| const uint8_t tag = HashToTag(key_hash); 296| 63| PERFETTO_DCHECK((capacity_ & (capacity_ - 1)) == 0); // Must be a pow2. 297| 63| PERFETTO_DCHECK(max_probe_length_ <= capacity_); 298| 63| for (size_t i = 0; i < max_probe_length_; ++i) { ------------------ | Branch (298:24): [True: 45, False: 18] ------------------ 299| 45| const size_t idx = Probe::Calc(key_hash, i, capacity_); 300| 45| const uint8_t tag_idx = tags_[idx]; 301| | 302| 45| if (tag_idx == kFreeSlot) ------------------ | Branch (302:11): [True: 0, False: 45] ------------------ 303| 0| return kNotFound; 304| | // HashToTag() never returns kTombstone, so the tag-check below cannot 305| | // possibly match. Also we just want to skip tombstones. 306| 45| if (tag_idx == tag && keys_[idx] == key) { ------------------ | Branch (306:11): [True: 45, False: 0] | Branch (306:29): [True: 45, False: 0] ------------------ 307| 45| PERFETTO_DCHECK(tag_idx > kTombstone); 308| 45| return idx; 309| 45| } 310| 45| } // for (idx) 311| 18| return kNotFound; 312| 63| } _ZN8perfetto4base11FlatHashMapIjNS_15trace_processor16ProtoTraceReader19SequenceScopedStateENS0_4HashIjEENS0_14QuadraticProbeELb0EEC2Emi: 135| 2.02k| : load_limit_percent_(load_limit_pct) { 136| 2.02k| if (initial_capacity > 0) ------------------ | Branch (136:9): [True: 0, False: 2.02k] ------------------ 137| 0| Reset(initial_capacity); 138| 2.02k| } _ZN8perfetto4base11FlatHashMapIjNS_15trace_processor16ProtoTraceReader19SequenceScopedStateENS0_4HashIjEENS0_14QuadraticProbeELb0EE5ResetEm: 359| 4.07k| PERFETTO_NO_INLINE void Reset(size_t n) { 360| 4.07k| PERFETTO_DCHECK((n & (n - 1)) == 0); // Must be a pow2. 361| | 362| 4.07k| capacity_ = n; 363| 4.07k| max_probe_length_ = 0; 364| 4.07k| size_ = 0; 365| 4.07k| load_limit_ = n * static_cast(load_limit_percent_) / 100; 366| 4.07k| load_limit_ = std::min(load_limit_, n); 367| | 368| 4.07k| tags_.reset(new uint8_t[n]); 369| 4.07k| memset(&tags_[0], 0, n); // Clear all tags. 370| 4.07k| keys_ = AlignedAllocTyped(n); // Deliberately not 0-initialized. 371| 4.07k| values_ = AlignedAllocTyped(n); // Deliberately not 0-initialized. 372| 4.07k| } _ZN8perfetto4base11FlatHashMapIjNS_15trace_processor16ProtoTraceReader19SequenceScopedStateENS0_4HashIjEENS0_14QuadraticProbeELb0EED2Ev: 142| 2.02k| ~FlatHashMap() { Clear(); } _ZN8perfetto4base11FlatHashMapIjNS_15trace_processor16ProtoTraceReader19SequenceScopedStateENS0_4HashIjEENS0_14QuadraticProbeELb0EE5ClearEv: 262| 2.02k| void Clear() { 263| | // Avoid trivial heap operations on zero-capacity std::move()-d objects. 264| 2.02k| if (PERFETTO_UNLIKELY(capacity_ == 0)) ------------------ | | 24| 2.02k|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 0, False: 2.02k] | | ------------------ ------------------ 265| 0| return; 266| | 267| 2.42M| for (size_t i = 0; i < capacity_; ++i) { ------------------ | Branch (267:24): [True: 2.41M, False: 2.02k] ------------------ 268| 2.41M| const uint8_t tag = tags_[i]; 269| 2.41M| if (tag != kFreeSlot && tag != kTombstone) ------------------ | Branch (269:11): [True: 58.3k, False: 2.36M] | Branch (269:31): [True: 58.3k, False: 0] ------------------ 270| 58.3k| EraseInternal(i); 271| 2.41M| } 272| | // Clear all tombstones. We really need to do this for AppendOnly. 273| 2.02k| MaybeGrowAndRehash(/*grow=*/false); 274| 2.02k| } _ZN8perfetto4base11FlatHashMapIjNS_15trace_processor16ProtoTraceReader19SequenceScopedStateENS0_4HashIjEENS0_14QuadraticProbeELb0EE13EraseInternalEm: 314| 58.3k| void EraseInternal(size_t idx) { 315| 58.3k| PERFETTO_DCHECK(tags_[idx] > kTombstone); 316| 58.3k| PERFETTO_DCHECK(size_ > 0); 317| 58.3k| tags_[idx] = kTombstone; 318| 58.3k| keys_[idx].~Key(); 319| 58.3k| values_[idx].~Value(); 320| 58.3k| size_--; 321| 58.3k| } _ZN8perfetto4base11FlatHashMapIjNS_15trace_processor16ProtoTraceReader19SequenceScopedStateENS0_4HashIjEENS0_14QuadraticProbeELb0EE18MaybeGrowAndRehashEb: 323| 4.07k| PERFETTO_NO_INLINE void MaybeGrowAndRehash(bool grow) { 324| 4.07k| PERFETTO_DCHECK(size_ <= capacity_); 325| 4.07k| const size_t old_capacity = capacity_; 326| | 327| | // Grow quickly up to 1MB, then chill. 328| 4.07k| const size_t old_size_bytes = old_capacity * (sizeof(Key) + sizeof(Value)); 329| 4.07k| const size_t grow_factor = old_size_bytes < (1024u * 1024u) ? 8 : 2; ------------------ | Branch (329:32): [True: 4.07k, False: 4] ------------------ 330| 4.07k| const size_t new_capacity = 331| 4.07k| grow ? std::max(old_capacity * grow_factor, size_t(1024)) ------------------ | Branch (331:9): [True: 2.04k, False: 2.02k] ------------------ 332| 4.07k| : old_capacity; 333| | 334| 4.07k| auto old_tags(std::move(tags_)); 335| 4.07k| auto old_keys(std::move(keys_)); 336| 4.07k| auto old_values(std::move(values_)); 337| 4.07k| size_t old_size = size_; 338| | 339| | // This must be a CHECK (i.e. not just a DCHECK) to prevent UAF attacks on 340| | // 32-bit archs that try to double the size of the table until wrapping. 341| 4.07k| PERFETTO_CHECK(new_capacity >= old_capacity); 342| 4.07k| Reset(new_capacity); 343| | 344| 4.07k| size_t new_size = 0; // Recompute the size. 345| 2.47M| for (size_t i = 0; i < old_capacity; ++i) { ------------------ | Branch (345:24): [True: 2.46M, False: 4.07k] ------------------ 346| 2.46M| const uint8_t old_tag = old_tags[i]; 347| 2.46M| if (old_tag != kFreeSlot && old_tag != kTombstone) { ------------------ | Branch (347:11): [True: 95.2k, False: 2.37M] | Branch (347:35): [True: 36.8k, False: 58.3k] ------------------ 348| 36.8k| Insert(std::move(old_keys[i]), std::move(old_values[i])); 349| 36.8k| old_keys[i].~Key(); // Destroy the old objects. 350| 36.8k| old_values[i].~Value(); 351| 36.8k| new_size++; 352| 36.8k| } 353| 2.46M| } 354| 4.07k| PERFETTO_DCHECK(new_size == old_size); 355| 4.07k| size_ = new_size; 356| 4.07k| } _ZN8perfetto4base11FlatHashMapIjNS_15trace_processor16ProtoTraceReader19SequenceScopedStateENS0_4HashIjEENS0_14QuadraticProbeELb0EE6InsertEjS4_: 166| 4.02M| std::pair Insert(Key key, Value value) { 167| 4.02M| const size_t key_hash = Hasher{}(key); 168| 4.02M| const uint8_t tag = HashToTag(key_hash); 169| 4.02M| static constexpr size_t kSlotNotFound = std::numeric_limits::max(); 170| | 171| | // This for loop does in reality at most two attempts: 172| | // The first iteration either: 173| | // - Early-returns, because the key exists already, 174| | // - Finds an insertion slot and proceeds because the load is < limit. 175| | // The second iteration is only hit in the unlikely case of this insertion 176| | // bringing the table beyond the target |load_limit_| (or the edge case 177| | // of the HT being full, if |load_limit_pct_| = 100). 178| | // We cannot simply pre-grow the table before insertion, because we must 179| | // guarantee that calling Insert() with a key that already exists doesn't 180| | // invalidate iterators. 181| 4.02M| size_t insertion_slot; 182| 4.02M| size_t probe_len; 183| 4.02M| for (;;) { 184| 4.02M| PERFETTO_DCHECK((capacity_ & (capacity_ - 1)) == 0); // Must be a pow2. 185| 4.02M| insertion_slot = kSlotNotFound; 186| | // Start the iteration at the desired slot (key_hash % capacity_) 187| | // searching either for a free slot or a tombstone. In the worst case we 188| | // might end up scanning the whole array of slots. The Probe functions are 189| | // guaranteed to visit all the slots within |capacity_| steps. If we find 190| | // a free slot, we can stop the search immediately (a free slot acts as an 191| | // "end of chain for entries having the same hash". If we find a 192| | // tombstones (a deleted slot) we remember its position, but have to keep 193| | // searching until a free slot to make sure we don't insert a duplicate 194| | // key. 195| 4.06M| for (probe_len = 0; probe_len < capacity_;) { ------------------ | Branch (195:27): [True: 4.06M, False: 2.02k] ------------------ 196| 4.06M| const size_t idx = Probe::Calc(key_hash, probe_len, capacity_); 197| 4.06M| PERFETTO_DCHECK(idx < capacity_); 198| 4.06M| const uint8_t tag_idx = tags_[idx]; 199| 4.06M| ++probe_len; 200| 4.06M| if (tag_idx == kFreeSlot) { ------------------ | Branch (200:13): [True: 95.2k, False: 3.96M] ------------------ 201| | // Rationale for "insertion_slot == kSlotNotFound": if we encountered 202| | // a tombstone while iterating we should reuse that rather than 203| | // taking another slot. 204| 95.2k| if (AppendOnly || insertion_slot == kSlotNotFound) ------------------ | Branch (204:15): [Folded - Ignored] | Branch (204:29): [True: 95.2k, False: 0] ------------------ 205| 95.2k| insertion_slot = idx; 206| 95.2k| break; 207| 95.2k| } 208| | // We should never encounter tombstones in AppendOnly mode. 209| 3.96M| PERFETTO_DCHECK(!(tag_idx == kTombstone && AppendOnly)); 210| 3.96M| if (!AppendOnly && tag_idx == kTombstone) { ------------------ | Branch (210:13): [Folded - Ignored] | Branch (210:28): [True: 0, False: 3.96M] ------------------ 211| 0| insertion_slot = idx; 212| 0| continue; 213| 0| } 214| 3.96M| if (tag_idx == tag && keys_[idx] == key) { ------------------ | Branch (214:13): [True: 3.93M, False: 39.5k] | Branch (214:31): [True: 3.92M, False: 110] ------------------ 215| | // The key is already in the map. 216| 3.92M| return std::make_pair(&values_[idx], false); 217| 3.92M| } 218| 3.96M| } // for (idx) 219| | 220| | // If we got to this point the key does not exist (otherwise we would have 221| | // hit the return above) and we are going to insert a new entry. 222| | // Before doing so, ensure we stay under the target load limit. 223| 97.2k| if (PERFETTO_UNLIKELY(size_ >= load_limit_)) { ------------------ | | 24| 97.2k|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 2.04k, False: 95.2k] | | ------------------ ------------------ 224| 2.04k| MaybeGrowAndRehash(/*grow=*/true); 225| 2.04k| continue; 226| 2.04k| } 227| 95.2k| PERFETTO_DCHECK(insertion_slot != kSlotNotFound); 228| 95.2k| break; 229| 97.2k| } // for (attempt) 230| | 231| 95.2k| PERFETTO_CHECK(insertion_slot < capacity_); 232| | 233| | // We found a free slot (or a tombstone). Proceed with the insertion. 234| 95.2k| Value* value_idx = &values_[insertion_slot]; 235| 95.2k| new (&keys_[insertion_slot]) Key(std::move(key)); 236| 95.2k| new (value_idx) Value(std::move(value)); 237| 95.2k| tags_[insertion_slot] = tag; 238| 95.2k| PERFETTO_DCHECK(probe_len > 0 && probe_len <= capacity_); 239| 95.2k| max_probe_length_ = std::max(max_probe_length_, probe_len); 240| 95.2k| size_++; 241| | 242| 95.2k| return std::make_pair(value_idx, true); 243| 95.2k| } proto_trace_reader.cc:_ZN8perfetto4base11FlatHashMapIiZNS_15trace_processor16ProtoTraceReader15ParseTraceStatsEN9protozero10ConstBytesEE8BufStatsNS0_4HashIiEENS0_14QuadraticProbeELb0EEC2Emi: 135| 24| : load_limit_percent_(load_limit_pct) { 136| 24| if (initial_capacity > 0) ------------------ | Branch (136:9): [True: 0, False: 24] ------------------ 137| 0| Reset(initial_capacity); 138| 24| } proto_trace_reader.cc:_ZN8perfetto4base11FlatHashMapIiZNS_15trace_processor16ProtoTraceReader15ParseTraceStatsEN9protozero10ConstBytesEE8BufStatsNS0_4HashIiEENS0_14QuadraticProbeELb0EED2Ev: 142| 24| ~FlatHashMap() { Clear(); } proto_trace_reader.cc:_ZN8perfetto4base11FlatHashMapIiZNS_15trace_processor16ProtoTraceReader15ParseTraceStatsEN9protozero10ConstBytesEE8BufStatsNS0_4HashIiEENS0_14QuadraticProbeELb0EE5ClearEv: 262| 24| void Clear() { 263| | // Avoid trivial heap operations on zero-capacity std::move()-d objects. 264| 24| if (PERFETTO_UNLIKELY(capacity_ == 0)) ------------------ | | 24| 24|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 24, False: 0] | | ------------------ ------------------ 265| 24| return; 266| | 267| 0| for (size_t i = 0; i < capacity_; ++i) { ------------------ | Branch (267:24): [True: 0, False: 0] ------------------ 268| 0| const uint8_t tag = tags_[i]; 269| 0| if (tag != kFreeSlot && tag != kTombstone) ------------------ | Branch (269:11): [True: 0, False: 0] | Branch (269:31): [True: 0, False: 0] ------------------ 270| 0| EraseInternal(i); 271| 0| } 272| | // Clear all tombstones. We really need to do this for AppendOnly. 273| 0| MaybeGrowAndRehash(/*grow=*/false); 274| 0| } proto_trace_reader.cc:_ZN8perfetto4base11FlatHashMapIiZNS_15trace_processor16ProtoTraceReader15ParseTraceStatsEN9protozero10ConstBytesEE8BufStatsNS0_4HashIiEENS0_14QuadraticProbeELb0EE11GetIteratorEv: 281| 24| Iterator GetIterator() { return Iterator(this); } proto_trace_reader.cc:_ZN8perfetto4base11FlatHashMapIiZNS_15trace_processor16ProtoTraceReader15ParseTraceStatsEN9protozero10ConstBytesEE8BufStatsNS0_4HashIiEENS0_14QuadraticProbeELb0EE8IteratorC2EPKSA_: 96| 24| explicit Iterator(const FlatHashMap* map) : map_(map) { FindNextNonFree(); } proto_trace_reader.cc:_ZN8perfetto4base11FlatHashMapIiZNS_15trace_processor16ProtoTraceReader15ParseTraceStatsEN9protozero10ConstBytesEE8BufStatsNS0_4HashIiEENS0_14QuadraticProbeELb0EE8Iterator15FindNextNonFreeEv: 119| 24| void FindNextNonFree() { 120| 24| const auto& tags = map_->tags_; 121| 24| for (; idx_ < map_->capacity_; idx_++) { ------------------ | Branch (121:14): [True: 0, False: 24] ------------------ 122| 0| if (tags[idx_] != kFreeSlot && (AppendOnly || tags[idx_] != kTombstone)) ------------------ | Branch (122:13): [True: 0, False: 0] | Branch (122:41): [Folded - Ignored] | Branch (122:55): [True: 0, False: 0] ------------------ 123| 0| return; 124| 0| } 125| 24| idx_ = kEnd; 126| 24| } proto_trace_reader.cc:_ZNK8perfetto4base11FlatHashMapIiZNS_15trace_processor16ProtoTraceReader15ParseTraceStatsEN9protozero10ConstBytesEE8BufStatsNS0_4HashIiEENS0_14QuadraticProbeELb0EE8IteratorcvbEv: 108| 24| explicit operator bool() const { return idx_ != kEnd; } _ZN8perfetto4base11FlatHashMapIjNS_15trace_processor28ActiveChromeProcessesTracker11ProcessDataENS0_4HashIjEENS0_14QuadraticProbeELb0EED2Ev: 142| 2.03k| ~FlatHashMap() { Clear(); } _ZN8perfetto4base11FlatHashMapIjmNS0_4HashIjEENS0_14QuadraticProbeELb0EED2Ev: 142| 4.07k| ~FlatHashMap() { Clear(); } _ZN8perfetto4base11FlatHashMapIjmNS0_4HashIjEENS0_14QuadraticProbeELb0EE5ClearEv: 262| 4.07k| void Clear() { 263| | // Avoid trivial heap operations on zero-capacity std::move()-d objects. 264| 4.07k| if (PERFETTO_UNLIKELY(capacity_ == 0)) ------------------ | | 24| 4.07k|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 3.86k, False: 207] | | ------------------ ------------------ 265| 3.86k| return; 266| | 267| 283k| for (size_t i = 0; i < capacity_; ++i) { ------------------ | Branch (267:24): [True: 283k, False: 207] ------------------ 268| 283k| const uint8_t tag = tags_[i]; 269| 283k| if (tag != kFreeSlot && tag != kTombstone) ------------------ | Branch (269:11): [True: 30.3k, False: 253k] | Branch (269:31): [True: 30.3k, False: 0] ------------------ 270| 30.3k| EraseInternal(i); 271| 283k| } 272| | // Clear all tombstones. We really need to do this for AppendOnly. 273| 207| MaybeGrowAndRehash(/*grow=*/false); 274| 207| } _ZN8perfetto4base11FlatHashMapIjmNS0_4HashIjEENS0_14QuadraticProbeELb0EE13EraseInternalEm: 314| 30.3k| void EraseInternal(size_t idx) { 315| 30.3k| PERFETTO_DCHECK(tags_[idx] > kTombstone); 316| 30.3k| PERFETTO_DCHECK(size_ > 0); 317| 30.3k| tags_[idx] = kTombstone; 318| 30.3k| keys_[idx].~Key(); 319| 30.3k| values_[idx].~Value(); 320| 30.3k| size_--; 321| 30.3k| } _ZN8perfetto4base11FlatHashMapIjmNS0_4HashIjEENS0_14QuadraticProbeELb0EE18MaybeGrowAndRehashEb: 323| 424| PERFETTO_NO_INLINE void MaybeGrowAndRehash(bool grow) { 324| 424| PERFETTO_DCHECK(size_ <= capacity_); 325| 424| const size_t old_capacity = capacity_; 326| | 327| | // Grow quickly up to 1MB, then chill. 328| 424| const size_t old_size_bytes = old_capacity * (sizeof(Key) + sizeof(Value)); 329| 424| const size_t grow_factor = old_size_bytes < (1024u * 1024u) ? 8 : 2; ------------------ | Branch (329:32): [True: 424, False: 0] ------------------ 330| 424| const size_t new_capacity = 331| 424| grow ? std::max(old_capacity * grow_factor, size_t(1024)) ------------------ | Branch (331:9): [True: 217, False: 207] ------------------ 332| 424| : old_capacity; 333| | 334| 424| auto old_tags(std::move(tags_)); 335| 424| auto old_keys(std::move(keys_)); 336| 424| auto old_values(std::move(values_)); 337| 424| size_t old_size = size_; 338| | 339| | // This must be a CHECK (i.e. not just a DCHECK) to prevent UAF attacks on 340| | // 32-bit archs that try to double the size of the table until wrapping. 341| 424| PERFETTO_CHECK(new_capacity >= old_capacity); 342| 424| Reset(new_capacity); 343| | 344| 424| size_t new_size = 0; // Recompute the size. 345| 294k| for (size_t i = 0; i < old_capacity; ++i) { ------------------ | Branch (345:24): [True: 293k, False: 424] ------------------ 346| 293k| const uint8_t old_tag = old_tags[i]; 347| 293k| if (old_tag != kFreeSlot && old_tag != kTombstone) { ------------------ | Branch (347:11): [True: 38.0k, False: 255k] | Branch (347:35): [True: 7.68k, False: 30.3k] ------------------ 348| 7.68k| Insert(std::move(old_keys[i]), std::move(old_values[i])); 349| 7.68k| old_keys[i].~Key(); // Destroy the old objects. 350| 7.68k| old_values[i].~Value(); 351| 7.68k| new_size++; 352| 7.68k| } 353| 293k| } 354| 424| PERFETTO_DCHECK(new_size == old_size); 355| 424| size_ = new_size; 356| 424| } _ZN8perfetto4base11FlatHashMapIjmNS0_4HashIjEENS0_14QuadraticProbeELb0EE5ResetEm: 359| 424| PERFETTO_NO_INLINE void Reset(size_t n) { 360| 424| PERFETTO_DCHECK((n & (n - 1)) == 0); // Must be a pow2. 361| | 362| 424| capacity_ = n; 363| 424| max_probe_length_ = 0; 364| 424| size_ = 0; 365| 424| load_limit_ = n * static_cast(load_limit_percent_) / 100; 366| 424| load_limit_ = std::min(load_limit_, n); 367| | 368| 424| tags_.reset(new uint8_t[n]); 369| 424| memset(&tags_[0], 0, n); // Clear all tags. 370| 424| keys_ = AlignedAllocTyped(n); // Deliberately not 0-initialized. 371| 424| values_ = AlignedAllocTyped(n); // Deliberately not 0-initialized. 372| 424| } _ZN8perfetto4base11FlatHashMapIjmNS0_4HashIjEENS0_14QuadraticProbeELb0EE6InsertEjm: 166| 46.3k| std::pair Insert(Key key, Value value) { 167| 46.3k| const size_t key_hash = Hasher{}(key); 168| 46.3k| const uint8_t tag = HashToTag(key_hash); 169| 46.3k| static constexpr size_t kSlotNotFound = std::numeric_limits::max(); 170| | 171| | // This for loop does in reality at most two attempts: 172| | // The first iteration either: 173| | // - Early-returns, because the key exists already, 174| | // - Finds an insertion slot and proceeds because the load is < limit. 175| | // The second iteration is only hit in the unlikely case of this insertion 176| | // bringing the table beyond the target |load_limit_| (or the edge case 177| | // of the HT being full, if |load_limit_pct_| = 100). 178| | // We cannot simply pre-grow the table before insertion, because we must 179| | // guarantee that calling Insert() with a key that already exists doesn't 180| | // invalidate iterators. 181| 46.3k| size_t insertion_slot; 182| 46.3k| size_t probe_len; 183| 46.6k| for (;;) { 184| 46.6k| PERFETTO_DCHECK((capacity_ & (capacity_ - 1)) == 0); // Must be a pow2. 185| 46.6k| insertion_slot = kSlotNotFound; 186| | // Start the iteration at the desired slot (key_hash % capacity_) 187| | // searching either for a free slot or a tombstone. In the worst case we 188| | // might end up scanning the whole array of slots. The Probe functions are 189| | // guaranteed to visit all the slots within |capacity_| steps. If we find 190| | // a free slot, we can stop the search immediately (a free slot acts as an 191| | // "end of chain for entries having the same hash". If we find a 192| | // tombstones (a deleted slot) we remember its position, but have to keep 193| | // searching until a free slot to make sure we don't insert a duplicate 194| | // key. 195| 57.9k| for (probe_len = 0; probe_len < capacity_;) { ------------------ | Branch (195:27): [True: 57.7k, False: 207] ------------------ 196| 57.7k| const size_t idx = Probe::Calc(key_hash, probe_len, capacity_); 197| 57.7k| PERFETTO_DCHECK(idx < capacity_); 198| 57.7k| const uint8_t tag_idx = tags_[idx]; 199| 57.7k| ++probe_len; 200| 57.7k| if (tag_idx == kFreeSlot) { ------------------ | Branch (200:13): [True: 38.0k, False: 19.7k] ------------------ 201| | // Rationale for "insertion_slot == kSlotNotFound": if we encountered 202| | // a tombstone while iterating we should reuse that rather than 203| | // taking another slot. 204| 38.0k| if (AppendOnly || insertion_slot == kSlotNotFound) ------------------ | Branch (204:15): [Folded - Ignored] | Branch (204:29): [True: 38.0k, False: 0] ------------------ 205| 38.0k| insertion_slot = idx; 206| 38.0k| break; 207| 38.0k| } 208| | // We should never encounter tombstones in AppendOnly mode. 209| 19.7k| PERFETTO_DCHECK(!(tag_idx == kTombstone && AppendOnly)); 210| 19.7k| if (!AppendOnly && tag_idx == kTombstone) { ------------------ | Branch (210:13): [Folded - Ignored] | Branch (210:28): [True: 0, False: 19.7k] ------------------ 211| 0| insertion_slot = idx; 212| 0| continue; 213| 0| } 214| 19.7k| if (tag_idx == tag && keys_[idx] == key) { ------------------ | Branch (214:13): [True: 8.38k, False: 11.3k] | Branch (214:31): [True: 8.35k, False: 38] ------------------ 215| | // The key is already in the map. 216| 8.35k| return std::make_pair(&values_[idx], false); 217| 8.35k| } 218| 19.7k| } // for (idx) 219| | 220| | // If we got to this point the key does not exist (otherwise we would have 221| | // hit the return above) and we are going to insert a new entry. 222| | // Before doing so, ensure we stay under the target load limit. 223| 38.2k| if (PERFETTO_UNLIKELY(size_ >= load_limit_)) { ------------------ | | 24| 38.2k|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 217, False: 38.0k] | | ------------------ ------------------ 224| 217| MaybeGrowAndRehash(/*grow=*/true); 225| 217| continue; 226| 217| } 227| 38.0k| PERFETTO_DCHECK(insertion_slot != kSlotNotFound); 228| 38.0k| break; 229| 38.2k| } // for (attempt) 230| | 231| 38.0k| PERFETTO_CHECK(insertion_slot < capacity_); 232| | 233| | // We found a free slot (or a tombstone). Proceed with the insertion. 234| 38.0k| Value* value_idx = &values_[insertion_slot]; 235| 38.0k| new (&keys_[insertion_slot]) Key(std::move(key)); 236| 38.0k| new (value_idx) Value(std::move(value)); 237| 38.0k| tags_[insertion_slot] = tag; 238| 38.0k| PERFETTO_DCHECK(probe_len > 0 && probe_len <= capacity_); 239| 38.0k| max_probe_length_ = std::max(max_probe_length_, probe_len); 240| 38.0k| size_++; 241| | 242| 38.0k| return std::make_pair(value_idx, true); 243| 38.0k| } _ZN8perfetto4base11FlatHashMapIjmNS0_4HashIjEENS0_14QuadraticProbeELb0EE9HashToTagEm: 374| 46.3k| static inline uint8_t HashToTag(size_t full_hash) { 375| 46.3k| uint8_t tag = full_hash >> (sizeof(full_hash) * 8 - 8); 376| | // Ensure the hash is always >= 2. We use 0, 1 for kFreeSlot and kTombstone. 377| 46.3k| tag += (tag <= kTombstone) << 1; 378| 46.3k| PERFETTO_DCHECK(tag > kTombstone); 379| 46.3k| return tag; 380| 46.3k| } _ZN8perfetto4base11FlatHashMapImNS_15trace_processor17TrackEventTracker23ResolvedDescriptorTrackENS0_4HashImEENS0_14QuadraticProbeELb0EED2Ev: 142| 2.03k| ~FlatHashMap() { Clear(); } _ZN8perfetto4base11FlatHashMapImNS_15trace_processor17TrackEventTracker23ResolvedDescriptorTrackENS0_4HashImEENS0_14QuadraticProbeELb0EE5ClearEv: 262| 2.03k| void Clear() { 263| | // Avoid trivial heap operations on zero-capacity std::move()-d objects. 264| 2.03k| if (PERFETTO_UNLIKELY(capacity_ == 0)) ------------------ | | 24| 2.03k|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 1.65k, False: 382] | | ------------------ ------------------ 265| 1.65k| return; 266| | 267| 606k| for (size_t i = 0; i < capacity_; ++i) { ------------------ | Branch (267:24): [True: 606k, False: 382] ------------------ 268| 606k| const uint8_t tag = tags_[i]; 269| 606k| if (tag != kFreeSlot && tag != kTombstone) ------------------ | Branch (269:11): [True: 74.8k, False: 531k] | Branch (269:31): [True: 74.8k, False: 0] ------------------ 270| 74.8k| EraseInternal(i); 271| 606k| } 272| | // Clear all tombstones. We really need to do this for AppendOnly. 273| 382| MaybeGrowAndRehash(/*grow=*/false); 274| 382| } _ZN8perfetto4base11FlatHashMapImNS_15trace_processor17TrackEventTracker23ResolvedDescriptorTrackENS0_4HashImEENS0_14QuadraticProbeELb0EE13EraseInternalEm: 314| 74.8k| void EraseInternal(size_t idx) { 315| 74.8k| PERFETTO_DCHECK(tags_[idx] > kTombstone); 316| 74.8k| PERFETTO_DCHECK(size_ > 0); 317| 74.8k| tags_[idx] = kTombstone; 318| 74.8k| keys_[idx].~Key(); 319| 74.8k| values_[idx].~Value(); 320| 74.8k| size_--; 321| 74.8k| } _ZN8perfetto4base11FlatHashMapImNS_15trace_processor17TrackEventTracker23ResolvedDescriptorTrackENS0_4HashImEENS0_14QuadraticProbeELb0EE18MaybeGrowAndRehashEb: 323| 794| PERFETTO_NO_INLINE void MaybeGrowAndRehash(bool grow) { 324| 794| PERFETTO_DCHECK(size_ <= capacity_); 325| 794| const size_t old_capacity = capacity_; 326| | 327| | // Grow quickly up to 1MB, then chill. 328| 794| const size_t old_size_bytes = old_capacity * (sizeof(Key) + sizeof(Value)); 329| 794| const size_t grow_factor = old_size_bytes < (1024u * 1024u) ? 8 : 2; ------------------ | Branch (329:32): [True: 794, False: 0] ------------------ 330| 794| const size_t new_capacity = 331| 794| grow ? std::max(old_capacity * grow_factor, size_t(1024)) ------------------ | Branch (331:9): [True: 412, False: 382] ------------------ 332| 794| : old_capacity; 333| | 334| 794| auto old_tags(std::move(tags_)); 335| 794| auto old_keys(std::move(keys_)); 336| 794| auto old_values(std::move(values_)); 337| 794| size_t old_size = size_; 338| | 339| | // This must be a CHECK (i.e. not just a DCHECK) to prevent UAF attacks on 340| | // 32-bit archs that try to double the size of the table until wrapping. 341| 794| PERFETTO_CHECK(new_capacity >= old_capacity); 342| 794| Reset(new_capacity); 343| | 344| 794| size_t new_size = 0; // Recompute the size. 345| 637k| for (size_t i = 0; i < old_capacity; ++i) { ------------------ | Branch (345:24): [True: 636k, False: 794] ------------------ 346| 636k| const uint8_t old_tag = old_tags[i]; 347| 636k| if (old_tag != kFreeSlot && old_tag != kTombstone) { ------------------ | Branch (347:11): [True: 97.8k, False: 539k] | Branch (347:35): [True: 23.0k, False: 74.8k] ------------------ 348| 23.0k| Insert(std::move(old_keys[i]), std::move(old_values[i])); 349| 23.0k| old_keys[i].~Key(); // Destroy the old objects. 350| 23.0k| old_values[i].~Value(); 351| 23.0k| new_size++; 352| 23.0k| } 353| 636k| } 354| 794| PERFETTO_DCHECK(new_size == old_size); 355| 794| size_ = new_size; 356| 794| } _ZN8perfetto4base11FlatHashMapImNS_15trace_processor17TrackEventTracker23ResolvedDescriptorTrackENS0_4HashImEENS0_14QuadraticProbeELb0EE5ResetEm: 359| 794| PERFETTO_NO_INLINE void Reset(size_t n) { 360| 794| PERFETTO_DCHECK((n & (n - 1)) == 0); // Must be a pow2. 361| | 362| 794| capacity_ = n; 363| 794| max_probe_length_ = 0; 364| 794| size_ = 0; 365| 794| load_limit_ = n * static_cast(load_limit_percent_) / 100; 366| 794| load_limit_ = std::min(load_limit_, n); 367| | 368| 794| tags_.reset(new uint8_t[n]); 369| 794| memset(&tags_[0], 0, n); // Clear all tags. 370| 794| keys_ = AlignedAllocTyped(n); // Deliberately not 0-initialized. 371| 794| values_ = AlignedAllocTyped(n); // Deliberately not 0-initialized. 372| 794| } _ZN8perfetto4base11FlatHashMapImNS_15trace_processor17TrackEventTracker23ResolvedDescriptorTrackENS0_4HashImEENS0_14QuadraticProbeELb0EE6InsertEmS4_: 166| 97.8k| std::pair Insert(Key key, Value value) { 167| 97.8k| const size_t key_hash = Hasher{}(key); 168| 97.8k| const uint8_t tag = HashToTag(key_hash); 169| 97.8k| static constexpr size_t kSlotNotFound = std::numeric_limits::max(); 170| | 171| | // This for loop does in reality at most two attempts: 172| | // The first iteration either: 173| | // - Early-returns, because the key exists already, 174| | // - Finds an insertion slot and proceeds because the load is < limit. 175| | // The second iteration is only hit in the unlikely case of this insertion 176| | // bringing the table beyond the target |load_limit_| (or the edge case 177| | // of the HT being full, if |load_limit_pct_| = 100). 178| | // We cannot simply pre-grow the table before insertion, because we must 179| | // guarantee that calling Insert() with a key that already exists doesn't 180| | // invalidate iterators. 181| 97.8k| size_t insertion_slot; 182| 97.8k| size_t probe_len; 183| 98.2k| for (;;) { 184| 98.2k| PERFETTO_DCHECK((capacity_ & (capacity_ - 1)) == 0); // Must be a pow2. 185| 98.2k| insertion_slot = kSlotNotFound; 186| | // Start the iteration at the desired slot (key_hash % capacity_) 187| | // searching either for a free slot or a tombstone. In the worst case we 188| | // might end up scanning the whole array of slots. The Probe functions are 189| | // guaranteed to visit all the slots within |capacity_| steps. If we find 190| | // a free slot, we can stop the search immediately (a free slot acts as an 191| | // "end of chain for entries having the same hash". If we find a 192| | // tombstones (a deleted slot) we remember its position, but have to keep 193| | // searching until a free slot to make sure we don't insert a duplicate 194| | // key. 195| 137k| for (probe_len = 0; probe_len < capacity_;) { ------------------ | Branch (195:27): [True: 137k, False: 382] ------------------ 196| 137k| const size_t idx = Probe::Calc(key_hash, probe_len, capacity_); 197| 137k| PERFETTO_DCHECK(idx < capacity_); 198| 137k| const uint8_t tag_idx = tags_[idx]; 199| 137k| ++probe_len; 200| 137k| if (tag_idx == kFreeSlot) { ------------------ | Branch (200:13): [True: 97.9k, False: 39.6k] ------------------ 201| | // Rationale for "insertion_slot == kSlotNotFound": if we encountered 202| | // a tombstone while iterating we should reuse that rather than 203| | // taking another slot. 204| 97.9k| if (AppendOnly || insertion_slot == kSlotNotFound) ------------------ | Branch (204:15): [Folded - Ignored] | Branch (204:29): [True: 97.9k, False: 0] ------------------ 205| 97.9k| insertion_slot = idx; 206| 97.9k| break; 207| 97.9k| } 208| | // We should never encounter tombstones in AppendOnly mode. 209| 39.6k| PERFETTO_DCHECK(!(tag_idx == kTombstone && AppendOnly)); 210| 39.6k| if (!AppendOnly && tag_idx == kTombstone) { ------------------ | Branch (210:13): [Folded - Ignored] | Branch (210:28): [True: 0, False: 39.6k] ------------------ 211| 0| insertion_slot = idx; 212| 0| continue; 213| 0| } 214| 39.6k| if (tag_idx == tag && keys_[idx] == key) { ------------------ | Branch (214:13): [True: 166, False: 39.5k] | Branch (214:31): [True: 0, False: 166] ------------------ 215| | // The key is already in the map. 216| 0| return std::make_pair(&values_[idx], false); 217| 0| } 218| 39.6k| } // for (idx) 219| | 220| | // If we got to this point the key does not exist (otherwise we would have 221| | // hit the return above) and we are going to insert a new entry. 222| | // Before doing so, ensure we stay under the target load limit. 223| 98.2k| if (PERFETTO_UNLIKELY(size_ >= load_limit_)) { ------------------ | | 24| 98.2k|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 412, False: 97.8k] | | ------------------ ------------------ 224| 412| MaybeGrowAndRehash(/*grow=*/true); 225| 412| continue; 226| 412| } 227| 97.8k| PERFETTO_DCHECK(insertion_slot != kSlotNotFound); 228| 97.8k| break; 229| 98.2k| } // for (attempt) 230| | 231| 97.8k| PERFETTO_CHECK(insertion_slot < capacity_); 232| | 233| | // We found a free slot (or a tombstone). Proceed with the insertion. 234| 97.8k| Value* value_idx = &values_[insertion_slot]; 235| 97.8k| new (&keys_[insertion_slot]) Key(std::move(key)); 236| 97.8k| new (value_idx) Value(std::move(value)); 237| 97.8k| tags_[insertion_slot] = tag; 238| 97.8k| PERFETTO_DCHECK(probe_len > 0 && probe_len <= capacity_); 239| 97.8k| max_probe_length_ = std::max(max_probe_length_, probe_len); 240| 97.8k| size_++; 241| | 242| 97.8k| return std::make_pair(value_idx, true); 243| 97.8k| } _ZN8perfetto4base11FlatHashMapImNS_15trace_processor17TrackEventTracker23ResolvedDescriptorTrackENS0_4HashImEENS0_14QuadraticProbeELb0EE9HashToTagEm: 374| 941k| static inline uint8_t HashToTag(size_t full_hash) { 375| 941k| uint8_t tag = full_hash >> (sizeof(full_hash) * 8 - 8); 376| | // Ensure the hash is always >= 2. We use 0, 1 for kFreeSlot and kTombstone. 377| 941k| tag += (tag <= kTombstone) << 1; 378| 941k| PERFETTO_DCHECK(tag > kTombstone); 379| 941k| return tag; 380| 941k| } _ZN8perfetto4base11FlatHashMapImNS_15trace_processor17TrackEventTracker26DescriptorTrackReservationENS0_4HashImEENS0_14QuadraticProbeELb0EED2Ev: 142| 2.03k| ~FlatHashMap() { Clear(); } _ZN8perfetto4base11FlatHashMapImNS_15trace_processor17TrackEventTracker26DescriptorTrackReservationENS0_4HashImEENS0_14QuadraticProbeELb0EE5ClearEv: 262| 2.03k| void Clear() { 263| | // Avoid trivial heap operations on zero-capacity std::move()-d objects. 264| 2.03k| if (PERFETTO_UNLIKELY(capacity_ == 0)) ------------------ | | 24| 2.03k|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 1.64k, False: 391] | | ------------------ ------------------ 265| 1.64k| return; 266| | 267| 694k| for (size_t i = 0; i < capacity_; ++i) { ------------------ | Branch (267:24): [True: 694k, False: 391] ------------------ 268| 694k| const uint8_t tag = tags_[i]; 269| 694k| if (tag != kFreeSlot && tag != kTombstone) ------------------ | Branch (269:11): [True: 93.5k, False: 600k] | Branch (269:31): [True: 93.5k, False: 0] ------------------ 270| 93.5k| EraseInternal(i); 271| 694k| } 272| | // Clear all tombstones. We really need to do this for AppendOnly. 273| 391| MaybeGrowAndRehash(/*grow=*/false); 274| 391| } _ZN8perfetto4base11FlatHashMapImNS_15trace_processor17TrackEventTracker26DescriptorTrackReservationENS0_4HashImEENS0_14QuadraticProbeELb0EE13EraseInternalEm: 314| 93.5k| void EraseInternal(size_t idx) { 315| 93.5k| PERFETTO_DCHECK(tags_[idx] > kTombstone); 316| 93.5k| PERFETTO_DCHECK(size_ > 0); 317| 93.5k| tags_[idx] = kTombstone; 318| 93.5k| keys_[idx].~Key(); 319| 93.5k| values_[idx].~Value(); 320| 93.5k| size_--; 321| 93.5k| } _ZN8perfetto4base11FlatHashMapImNS_15trace_processor17TrackEventTracker26DescriptorTrackReservationENS0_4HashImEENS0_14QuadraticProbeELb0EE18MaybeGrowAndRehashEb: 323| 823| PERFETTO_NO_INLINE void MaybeGrowAndRehash(bool grow) { 324| 823| PERFETTO_DCHECK(size_ <= capacity_); 325| 823| const size_t old_capacity = capacity_; 326| | 327| | // Grow quickly up to 1MB, then chill. 328| 823| const size_t old_size_bytes = old_capacity * (sizeof(Key) + sizeof(Value)); 329| 823| const size_t grow_factor = old_size_bytes < (1024u * 1024u) ? 8 : 2; ------------------ | Branch (329:32): [True: 823, False: 0] ------------------ 330| 823| const size_t new_capacity = 331| 823| grow ? std::max(old_capacity * grow_factor, size_t(1024)) ------------------ | Branch (331:9): [True: 432, False: 391] ------------------ 332| 823| : old_capacity; 333| | 334| 823| auto old_tags(std::move(tags_)); 335| 823| auto old_keys(std::move(keys_)); 336| 823| auto old_values(std::move(values_)); 337| 823| size_t old_size = size_; 338| | 339| | // This must be a CHECK (i.e. not just a DCHECK) to prevent UAF attacks on 340| | // 32-bit archs that try to double the size of the table until wrapping. 341| 823| PERFETTO_CHECK(new_capacity >= old_capacity); 342| 823| Reset(new_capacity); 343| | 344| 823| size_t new_size = 0; // Recompute the size. 345| 737k| for (size_t i = 0; i < old_capacity; ++i) { ------------------ | Branch (345:24): [True: 736k, False: 823] ------------------ 346| 736k| const uint8_t old_tag = old_tags[i]; 347| 736k| if (old_tag != kFreeSlot && old_tag != kTombstone) { ------------------ | Branch (347:11): [True: 125k, False: 611k] | Branch (347:35): [True: 31.4k, False: 93.5k] ------------------ 348| 31.4k| Insert(std::move(old_keys[i]), std::move(old_values[i])); 349| 31.4k| old_keys[i].~Key(); // Destroy the old objects. 350| 31.4k| old_values[i].~Value(); 351| 31.4k| new_size++; 352| 31.4k| } 353| 736k| } 354| 823| PERFETTO_DCHECK(new_size == old_size); 355| 823| size_ = new_size; 356| 823| } _ZN8perfetto4base11FlatHashMapImNS_15trace_processor17TrackEventTracker26DescriptorTrackReservationENS0_4HashImEENS0_14QuadraticProbeELb0EE5ResetEm: 359| 823| PERFETTO_NO_INLINE void Reset(size_t n) { 360| 823| PERFETTO_DCHECK((n & (n - 1)) == 0); // Must be a pow2. 361| | 362| 823| capacity_ = n; 363| 823| max_probe_length_ = 0; 364| 823| size_ = 0; 365| 823| load_limit_ = n * static_cast(load_limit_percent_) / 100; 366| 823| load_limit_ = std::min(load_limit_, n); 367| | 368| 823| tags_.reset(new uint8_t[n]); 369| 823| memset(&tags_[0], 0, n); // Clear all tags. 370| 823| keys_ = AlignedAllocTyped(n); // Deliberately not 0-initialized. 371| 823| values_ = AlignedAllocTyped(n); // Deliberately not 0-initialized. 372| 823| } _ZN8perfetto4base11FlatHashMapImNS_15trace_processor17TrackEventTracker26DescriptorTrackReservationENS0_4HashImEENS0_14QuadraticProbeELb0EE6InsertEmS4_: 166| 147k| std::pair Insert(Key key, Value value) { 167| 147k| const size_t key_hash = Hasher{}(key); 168| 147k| const uint8_t tag = HashToTag(key_hash); 169| 147k| static constexpr size_t kSlotNotFound = std::numeric_limits::max(); 170| | 171| | // This for loop does in reality at most two attempts: 172| | // The first iteration either: 173| | // - Early-returns, because the key exists already, 174| | // - Finds an insertion slot and proceeds because the load is < limit. 175| | // The second iteration is only hit in the unlikely case of this insertion 176| | // bringing the table beyond the target |load_limit_| (or the edge case 177| | // of the HT being full, if |load_limit_pct_| = 100). 178| | // We cannot simply pre-grow the table before insertion, because we must 179| | // guarantee that calling Insert() with a key that already exists doesn't 180| | // invalidate iterators. 181| 147k| size_t insertion_slot; 182| 147k| size_t probe_len; 183| 148k| for (;;) { 184| 148k| PERFETTO_DCHECK((capacity_ & (capacity_ - 1)) == 0); // Must be a pow2. 185| 148k| insertion_slot = kSlotNotFound; 186| | // Start the iteration at the desired slot (key_hash % capacity_) 187| | // searching either for a free slot or a tombstone. In the worst case we 188| | // might end up scanning the whole array of slots. The Probe functions are 189| | // guaranteed to visit all the slots within |capacity_| steps. If we find 190| | // a free slot, we can stop the search immediately (a free slot acts as an 191| | // "end of chain for entries having the same hash". If we find a 192| | // tombstones (a deleted slot) we remember its position, but have to keep 193| | // searching until a free slot to make sure we don't insert a duplicate 194| | // key. 195| 198k| for (probe_len = 0; probe_len < capacity_;) { ------------------ | Branch (195:27): [True: 197k, False: 391] ------------------ 196| 197k| const size_t idx = Probe::Calc(key_hash, probe_len, capacity_); 197| 197k| PERFETTO_DCHECK(idx < capacity_); 198| 197k| const uint8_t tag_idx = tags_[idx]; 199| 197k| ++probe_len; 200| 197k| if (tag_idx == kFreeSlot) { ------------------ | Branch (200:13): [True: 125k, False: 72.5k] ------------------ 201| | // Rationale for "insertion_slot == kSlotNotFound": if we encountered 202| | // a tombstone while iterating we should reuse that rather than 203| | // taking another slot. 204| 125k| if (AppendOnly || insertion_slot == kSlotNotFound) ------------------ | Branch (204:15): [Folded - Ignored] | Branch (204:29): [True: 125k, False: 0] ------------------ 205| 125k| insertion_slot = idx; 206| 125k| break; 207| 125k| } 208| | // We should never encounter tombstones in AppendOnly mode. 209| 72.5k| PERFETTO_DCHECK(!(tag_idx == kTombstone && AppendOnly)); 210| 72.5k| if (!AppendOnly && tag_idx == kTombstone) { ------------------ | Branch (210:13): [Folded - Ignored] | Branch (210:28): [True: 0, False: 72.5k] ------------------ 211| 0| insertion_slot = idx; 212| 0| continue; 213| 0| } 214| 72.5k| if (tag_idx == tag && keys_[idx] == key) { ------------------ | Branch (214:13): [True: 23.0k, False: 49.4k] | Branch (214:31): [True: 22.9k, False: 181] ------------------ 215| | // The key is already in the map. 216| 22.9k| return std::make_pair(&values_[idx], false); 217| 22.9k| } 218| 72.5k| } // for (idx) 219| | 220| | // If we got to this point the key does not exist (otherwise we would have 221| | // hit the return above) and we are going to insert a new entry. 222| | // Before doing so, ensure we stay under the target load limit. 223| 125k| if (PERFETTO_UNLIKELY(size_ >= load_limit_)) { ------------------ | | 24| 125k|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 432, False: 125k] | | ------------------ ------------------ 224| 432| MaybeGrowAndRehash(/*grow=*/true); 225| 432| continue; 226| 432| } 227| 125k| PERFETTO_DCHECK(insertion_slot != kSlotNotFound); 228| 125k| break; 229| 125k| } // for (attempt) 230| | 231| 125k| PERFETTO_CHECK(insertion_slot < capacity_); 232| | 233| | // We found a free slot (or a tombstone). Proceed with the insertion. 234| 125k| Value* value_idx = &values_[insertion_slot]; 235| 125k| new (&keys_[insertion_slot]) Key(std::move(key)); 236| 125k| new (value_idx) Value(std::move(value)); 237| 125k| tags_[insertion_slot] = tag; 238| 125k| PERFETTO_DCHECK(probe_len > 0 && probe_len <= capacity_); 239| 125k| max_probe_length_ = std::max(max_probe_length_, probe_len); 240| 125k| size_++; 241| | 242| 125k| return std::make_pair(value_idx, true); 243| 125k| } _ZN8perfetto4base11FlatHashMapImNS_15trace_processor17TrackEventTracker26DescriptorTrackReservationENS0_4HashImEENS0_14QuadraticProbeELb0EE9HashToTagEm: 374| 373k| static inline uint8_t HashToTag(size_t full_hash) { 375| 373k| uint8_t tag = full_hash >> (sizeof(full_hash) * 8 - 8); 376| | // Ensure the hash is always >= 2. We use 0, 1 for kFreeSlot and kTombstone. 377| 373k| tag += (tag <= kTombstone) << 1; 378| 373k| PERFETTO_DCHECK(tag > kTombstone); 379| 373k| return tag; 380| 373k| } _ZN8perfetto4base11FlatHashMapIjNS_15trace_processor28ActiveChromeProcessesTracker11ProcessDataENS0_4HashIjEENS0_14QuadraticProbeELb0EEC2Emi: 135| 2.03k| : load_limit_percent_(load_limit_pct) { 136| 2.03k| if (initial_capacity > 0) ------------------ | Branch (136:9): [True: 0, False: 2.03k] ------------------ 137| 0| Reset(initial_capacity); 138| 2.03k| } _ZN8perfetto4base11FlatHashMapImNS_15trace_processor17TrackEventTracker26DescriptorTrackReservationENS0_4HashImEENS0_14QuadraticProbeELb0EEC2Emi: 135| 2.03k| : load_limit_percent_(load_limit_pct) { 136| 2.03k| if (initial_capacity > 0) ------------------ | Branch (136:9): [True: 0, False: 2.03k] ------------------ 137| 0| Reset(initial_capacity); 138| 2.03k| } _ZN8perfetto4base11FlatHashMapImNS_15trace_processor17TrackEventTracker23ResolvedDescriptorTrackENS0_4HashImEENS0_14QuadraticProbeELb0EEC2Emi: 135| 2.03k| : load_limit_percent_(load_limit_pct) { 136| 2.03k| if (initial_capacity > 0) ------------------ | Branch (136:9): [True: 0, False: 2.03k] ------------------ 137| 0| Reset(initial_capacity); 138| 2.03k| } _ZN8perfetto4base11FlatHashMapIjmNS0_4HashIjEENS0_14QuadraticProbeELb0EEC2Emi: 135| 4.07k| : load_limit_percent_(load_limit_pct) { 136| 4.07k| if (initial_capacity > 0) ------------------ | Branch (136:9): [True: 0, False: 4.07k] ------------------ 137| 0| Reset(initial_capacity); 138| 4.07k| } _ZNK8perfetto4base11FlatHashMapImNS_15trace_processor17TrackEventTracker23ResolvedDescriptorTrackENS0_4HashImEENS0_14QuadraticProbeELb0EE4FindERKm: 245| 843k| Value* Find(const Key& key) const { 246| 843k| const size_t idx = FindInternal(key); 247| 843k| if (idx == kNotFound) ------------------ | Branch (247:9): [True: 101k, False: 742k] ------------------ 248| 101k| return nullptr; 249| 742k| return &values_[idx]; 250| 843k| } _ZNK8perfetto4base11FlatHashMapImNS_15trace_processor17TrackEventTracker23ResolvedDescriptorTrackENS0_4HashImEENS0_14QuadraticProbeELb0EE12FindInternalERKm: 293| 843k| size_t FindInternal(const Key& key) const { 294| 843k| const size_t key_hash = Hasher{}(key); 295| 843k| const uint8_t tag = HashToTag(key_hash); 296| 843k| PERFETTO_DCHECK((capacity_ & (capacity_ - 1)) == 0); // Must be a pow2. 297| 843k| PERFETTO_DCHECK(max_probe_length_ <= capacity_); 298| 892k| for (size_t i = 0; i < max_probe_length_; ++i) { ------------------ | Branch (298:24): [True: 891k, False: 1.17k] ------------------ 299| 891k| const size_t idx = Probe::Calc(key_hash, i, capacity_); 300| 891k| const uint8_t tag_idx = tags_[idx]; 301| | 302| 891k| if (tag_idx == kFreeSlot) ------------------ | Branch (302:11): [True: 100k, False: 791k] ------------------ 303| 100k| return kNotFound; 304| | // HashToTag() never returns kTombstone, so the tag-check below cannot 305| | // possibly match. Also we just want to skip tombstones. 306| 791k| if (tag_idx == tag && keys_[idx] == key) { ------------------ | Branch (306:11): [True: 742k, False: 48.9k] | Branch (306:29): [True: 742k, False: 179] ------------------ 307| 742k| PERFETTO_DCHECK(tag_idx > kTombstone); 308| 742k| return idx; 309| 742k| } 310| 791k| } // for (idx) 311| 1.17k| return kNotFound; 312| 843k| } _ZNK8perfetto4base11FlatHashMapImNS_15trace_processor17TrackEventTracker26DescriptorTrackReservationENS0_4HashImEENS0_14QuadraticProbeELb0EE4FindERKm: 245| 225k| Value* Find(const Key& key) const { 246| 225k| const size_t idx = FindInternal(key); 247| 225k| if (idx == kNotFound) ------------------ | Branch (247:9): [True: 21.1k, False: 204k] ------------------ 248| 21.1k| return nullptr; 249| 204k| return &values_[idx]; 250| 225k| } _ZNK8perfetto4base11FlatHashMapImNS_15trace_processor17TrackEventTracker26DescriptorTrackReservationENS0_4HashImEENS0_14QuadraticProbeELb0EE12FindInternalERKm: 293| 225k| size_t FindInternal(const Key& key) const { 294| 225k| const size_t key_hash = Hasher{}(key); 295| 225k| const uint8_t tag = HashToTag(key_hash); 296| 225k| PERFETTO_DCHECK((capacity_ & (capacity_ - 1)) == 0); // Must be a pow2. 297| 225k| PERFETTO_DCHECK(max_probe_length_ <= capacity_); 298| 269k| for (size_t i = 0; i < max_probe_length_; ++i) { ------------------ | Branch (298:24): [True: 269k, False: 137] ------------------ 299| 269k| const size_t idx = Probe::Calc(key_hash, i, capacity_); 300| 269k| const uint8_t tag_idx = tags_[idx]; 301| | 302| 269k| if (tag_idx == kFreeSlot) ------------------ | Branch (302:11): [True: 20.9k, False: 248k] ------------------ 303| 20.9k| return kNotFound; 304| | // HashToTag() never returns kTombstone, so the tag-check below cannot 305| | // possibly match. Also we just want to skip tombstones. 306| 248k| if (tag_idx == tag && keys_[idx] == key) { ------------------ | Branch (306:11): [True: 204k, False: 44.1k] | Branch (306:29): [True: 204k, False: 298] ------------------ 307| 204k| PERFETTO_DCHECK(tag_idx > kTombstone); 308| 204k| return idx; 309| 204k| } 310| 248k| } // for (idx) 311| 137| return kNotFound; 312| 225k| } _ZN8perfetto4base11FlatHashMapImNS_15trace_processor17TrackEventTracker26DescriptorTrackReservationENS0_4HashImEENS0_14QuadraticProbeELb0EE11GetIteratorEv: 281| 10.1k| Iterator GetIterator() { return Iterator(this); } _ZN8perfetto4base11FlatHashMapImNS_15trace_processor17TrackEventTracker26DescriptorTrackReservationENS0_4HashImEENS0_14QuadraticProbeELb0EE8IteratorC2EPKS8_: 96| 10.1k| explicit Iterator(const FlatHashMap* map) : map_(map) { FindNextNonFree(); } _ZN8perfetto4base11FlatHashMapImNS_15trace_processor17TrackEventTracker26DescriptorTrackReservationENS0_4HashImEENS0_14QuadraticProbeELb0EE8Iterator15FindNextNonFreeEv: 119| 1.24M| void FindNextNonFree() { 120| 1.24M| const auto& tags = map_->tags_; 121| 10.8M| for (; idx_ < map_->capacity_; idx_++) { ------------------ | Branch (121:14): [True: 10.8M, False: 10.1k] ------------------ 122| 10.8M| if (tags[idx_] != kFreeSlot && (AppendOnly || tags[idx_] != kTombstone)) ------------------ | Branch (122:13): [True: 1.23M, False: 9.57M] | Branch (122:41): [Folded - Ignored] | Branch (122:55): [True: 1.23M, False: 0] ------------------ 123| 1.23M| return; 124| 10.8M| } 125| 10.1k| idx_ = kEnd; 126| 10.1k| } _ZNK8perfetto4base11FlatHashMapImNS_15trace_processor17TrackEventTracker26DescriptorTrackReservationENS0_4HashImEENS0_14QuadraticProbeELb0EE8IteratorcvbEv: 108| 1.24M| explicit operator bool() const { return idx_ != kEnd; } _ZN8perfetto4base11FlatHashMapImNS_15trace_processor17TrackEventTracker26DescriptorTrackReservationENS0_4HashImEENS0_14QuadraticProbeELb0EE8IteratorppEv: 109| 1.23M| Iterator& operator++() { 110| 1.23M| PERFETTO_DCHECK(idx_ < map_->capacity_); 111| 1.23M| ++idx_; 112| 1.23M| FindNextNonFree(); 113| 1.23M| return *this; 114| 1.23M| } _ZN8perfetto4base11FlatHashMapImNS_15trace_processor17TrackEventTracker26DescriptorTrackReservationENS0_4HashImEENS0_14QuadraticProbeELb0EE8Iterator5valueEv: 104| 1.23M| Value& value() { return map_->values_[idx_]; } _ZN8perfetto4base6Hasher6UpdateEPKcm: 56| 179M| constexpr void Update(const char* data, size_t size) { 57| 1.51G| for (size_t i = 0; i < size; i++) { ------------------ | Branch (57:24): [True: 1.33G, False: 179M] ------------------ 58| 1.33G| result_ ^= static_cast(data[i]); 59| | // Note: Arithmetic overflow of unsigned integers is well defined in C++ 60| | // standard unlike signed integers. 61| | // https://stackoverflow.com/a/41280273 62| 1.33G| result_ *= kFnv1a64Prime; 63| 1.33G| } 64| 179M| } _ZNK8perfetto4base6Hasher6digestEv: 79| 151M| constexpr uint64_t digest() const { return result_; } _ZN8perfetto4base6Hasher9UpdateAllEv: 103| 74.9k| constexpr void UpdateAll() {} _ZNK8perfetto4base13AlreadyHashedImEclERKm: 123| 27.6M| size_t operator()(const T& x) const { return static_cast(x); } _ZN8perfetto4base6Hasher6UpdateIjTnNSt3__19enable_ifIXsr3std13is_arithmeticIT_EE5valueEbE4typeELb1EEEvS5_: 43| 136M| void Update(T data) { 44| 136M| Update(reinterpret_cast(&data), sizeof(data)); 45| 136M| } _ZN8perfetto4base6Hasher6UpdateIlTnNSt3__19enable_ifIXsr3std13is_arithmeticIT_EE5valueEbE4typeELb1EEEvS5_: 43| 1.24M| void Update(T data) { 44| 1.24M| Update(reinterpret_cast(&data), sizeof(data)); 45| 1.24M| } _ZN8perfetto4base6Hasher6UpdateImTnNSt3__19enable_ifIXsr3std13is_arithmeticIT_EE5valueEbE4typeELb1EEEvS5_: 43| 18.0M| void Update(T data) { 44| 18.0M| Update(reinterpret_cast(&data), sizeof(data)); 45| 18.0M| } _ZN8perfetto4base6Hasher6UpdateIdTnNSt3__19enable_ifIXsr3std13is_arithmeticIT_EE5valueEbE4typeELb1EEEvS5_: 43| 457| void Update(T data) { 44| 457| Update(reinterpret_cast(&data), sizeof(data)); 45| 457| } _ZN8perfetto4base6Hasher6UpdateIbTnNSt3__19enable_ifIXsr3std13is_arithmeticIT_EE5valueEbE4typeELb1EEEvS5_: 43| 151k| void Update(T data) { 44| 151k| Update(reinterpret_cast(&data), sizeof(data)); 45| 151k| } _ZN8perfetto4base6Hasher6UpdateIiTnNSt3__19enable_ifIXsr3std13is_arithmeticIT_EE5valueEbE4typeELb1EEEvS5_: 43| 7.35k| void Update(T data) { 44| 7.35k| Update(reinterpret_cast(&data), sizeof(data)); 45| 7.35k| } _ZN8perfetto4base4HashIjEclIjEEKNSt3__19enable_ifIXsr3std13is_arithmeticIT_EE5valueEmE4typeERKS6_: 137| 106M| const { 138| 106M| Hasher hash; 139| 106M| hash.Update(x); 140| 106M| return static_cast(hash.digest()); 141| 106M| } _ZN8perfetto4base4HashImEclImEEKNSt3__19enable_ifIXsr3std13is_arithmeticIT_EE5valueEmE4typeERKS6_: 137| 9.52M| const { 138| 9.52M| Hasher hash; 139| 9.52M| hash.Update(x); 140| 9.52M| return static_cast(hash.digest()); 141| 9.52M| } _ZN8perfetto4base4HashINS_15trace_processor9TraceTypeEEclIS3_EEKNSt3__19enable_ifIXntsr3std13is_arithmeticIT_EE5valueEmE4typeERKS8_: 147| 1.29k| const { 148| 1.29k| return std::hash()(x); 149| 1.29k| } _ZN8perfetto4base4HashINS_15trace_processor10StringPool2IdEEclIS4_EEKNSt3__19enable_ifIXntsr3std13is_arithmeticIT_EE5valueEmE4typeERKS9_: 147| 950k| const { 148| 950k| return std::hash()(x); 149| 950k| } _ZN8perfetto4base6HasherC2Ev: 37| 151M| constexpr Hasher() = default; _ZN8perfetto4base6Hasher6UpdateINS0_10StringViewEvEEvRKT_: 69| 397k| constexpr void Update(const T& t) { 70| 397k| if constexpr (std::is_member_function_pointer_v) { 71| 397k| Update(t.data(), t.size()); 72| | } else { 73| | Update(t.data, t.size); 74| | } 75| 397k| } _ZN8perfetto4base6Hasher9UpdateAllIjJjEEEvOT_DpOT0_: 106| 74.9k| constexpr void UpdateAll(T&& arg, Ts&&... args) { 107| 74.9k| Update(arg); 108| 74.9k| UpdateAll(std::forward(args)...); 109| 74.9k| } _ZN8perfetto4base6Hasher9UpdateAllIjJEEEvOT_DpOT0_: 106| 74.9k| constexpr void UpdateAll(T&& arg, Ts&&... args) { 107| 74.9k| Update(arg); 108| 74.9k| UpdateAll(std::forward(args)...); 109| 74.9k| } _ZN8perfetto4base6Hasher9UpdateAllIRKmJjjEEEvOT_DpOT0_: 106| 74.9k| constexpr void UpdateAll(T&& arg, Ts&&... args) { 107| 74.9k| Update(arg); 108| 74.9k| UpdateAll(std::forward(args)...); 109| 74.9k| } _ZN8perfetto4base6Hasher7CombineIJRKmjjEEEmDpOT_: 84| 74.9k| static constexpr uint64_t Combine(Ts&&... args) { 85| 74.9k| Hasher hasher; 86| 74.9k| hasher.UpdateAll(std::forward(args)...); 87| 74.9k| return hasher.digest(); 88| 74.9k| } _ZN8perfetto4base4HashINS_15trace_processor6tables10TrackTable2IdEEclIS5_EEKNSt3__19enable_ifIXntsr3std13is_arithmeticIT_EE5valueEmE4typeERKSA_: 147| 2.91M| const { 148| 2.91M| return std::hash()(x); 149| 2.91M| } _ZN8perfetto4base11PagedMemory15EnsureCommittedEm: 76| 154k| void EnsureCommitted(size_t /*committed_size*/) {} _ZNK8perfetto4base11PagedMemory3GetEv: 79| 588k| inline void* Get() const noexcept { return p_; } _ZN8perfetto4base11SmallVectorIPKNS_15trace_processor17GlobalArgsTracker10CompactArgELm64EE20inline_storage_beginEv: 183| 5.54M| T* inline_storage_begin() { return reinterpret_cast(inline_storage_); } _ZN8perfetto4base11SmallVectorIPKNS_15trace_processor17GlobalArgsTracker10CompactArgELm64EE5clearEv: 157| 2.77M| void clear() { 158| 10.4M| while (!empty()) ------------------ | Branch (158:12): [True: 7.69M, False: 2.77M] ------------------ 159| 7.69M| pop_back(); 160| 2.77M| } _ZN8perfetto4base11SmallVectorIPKNS_15trace_processor17GlobalArgsTracker10CompactArgELm64EE13is_using_heapEv: 184| 2.77M| bool is_using_heap() { return begin_ != inline_storage_begin(); } _ZNK8perfetto4base11SmallVectorIPKNS_15trace_processor17GlobalArgsTracker10CompactArgELm64EE5emptyEv: 107| 25.7M| bool empty() const { return end_ == begin_; } _ZN8perfetto4base11SmallVectorIPKNS_15trace_processor17GlobalArgsTracker10CompactArgELm64EE4backEv: 122| 27.8M| T& back() { 123| 27.8M| PERFETTO_DCHECK(!empty()); 124| 27.8M| return end_[-1]; 125| 27.8M| } _ZN8perfetto4base11SmallVectorIPKNS_15trace_processor17GlobalArgsTracker10CompactArgELm64EE8pop_backEv: 150| 15.3M| void pop_back() { 151| 15.3M| PERFETTO_DCHECK(!empty()); 152| 15.3M| back().~T(); 153| 15.3M| --end_; 154| 15.3M| } _ZN8perfetto4base11SmallVectorIPKNS_15trace_processor17GlobalArgsTracker10CompactArgELm64EE12emplace_backIJS6_EEEvDpOT_: 142| 15.3M| void emplace_back(Args&&... args) { 143| 15.3M| T* end = end_; 144| 15.3M| if (PERFETTO_UNLIKELY(end == end_of_storage_)) ------------------ | | 24| 15.3M|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 0, False: 15.3M] | | ------------------ ------------------ 145| 0| end = Grow(); 146| 15.3M| new (end) T(std::forward(args)...); 147| 15.3M| end_ = end + 1; 148| 15.3M| } _ZN8perfetto4base11SmallVectorIPKNS_15trace_processor17GlobalArgsTracker10CompactArgELm64EE5beginEv: 99| 3.80M| T* begin() { return begin_; } _ZN8perfetto4base11SmallVectorIPKNS_15trace_processor17GlobalArgsTracker10CompactArgELm64EE3endEv: 102| 3.80M| T* end() { return end_; } _ZN8perfetto4base11SmallVectorINS_15trace_processor17GlobalArgsTracker3ArgELm16EEC2Ev: 37| 1.23M| explicit SmallVector() = default; _ZN8perfetto4base11SmallVectorINS_15trace_processor17GlobalArgsTracker3ArgELm16EE20inline_storage_beginEv: 183| 6.08M| T* inline_storage_begin() { return reinterpret_cast(inline_storage_); } args_tracker.cc:_ZN8perfetto4base11SmallVectorIZNS_15trace_processor11ArgsTracker5FlushEvE5EntryLm16EEC2Ev: 37| 389k| explicit SmallVector() = default; args_tracker.cc:_ZN8perfetto4base11SmallVectorIZNS_15trace_processor11ArgsTracker5FlushEvE5EntryLm16EE20inline_storage_beginEv: 183| 857k| T* inline_storage_begin() { return reinterpret_cast(inline_storage_); } _ZN8perfetto4base11SmallVectorIPKNS_15trace_processor17GlobalArgsTracker10CompactArgELm64EEC2Ev: 37| 2.77M| explicit SmallVector() = default; _ZN8perfetto4base11SmallVectorIPKNS_15trace_processor17GlobalArgsTracker10CompactArgELm64EED2Ev: 39| 2.77M| ~SmallVector() { 40| 2.77M| clear(); 41| 2.77M| if (PERFETTO_UNLIKELY(is_using_heap())) ------------------ | | 24| 2.77M|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 0, False: 2.77M] | | ------------------ ------------------ 42| 0| AlignedFree(begin_); 43| 2.77M| begin_ = end_ = end_of_storage_ = nullptr; 44| 2.77M| } _ZN8perfetto4base11SmallVectorINS_15trace_processor17GlobalArgsTracker10CompactArgELm16EEC2Ev: 37| 518k| explicit SmallVector() = default; _ZN8perfetto4base11SmallVectorINS_15trace_processor17GlobalArgsTracker10CompactArgELm16EE20inline_storage_beginEv: 183| 6.40M| T* inline_storage_begin() { return reinterpret_cast(inline_storage_); } _ZN8perfetto4base11SmallVectorINS_15trace_processor17GlobalArgsTracker3ArgELm16EED2Ev: 39| 2.00M| ~SmallVector() { 40| 2.00M| clear(); 41| 2.00M| if (PERFETTO_UNLIKELY(is_using_heap())) ------------------ | | 24| 2.00M|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 548k, False: 1.45M] | | ------------------ ------------------ 42| 548k| AlignedFree(begin_); 43| 2.00M| begin_ = end_ = end_of_storage_ = nullptr; 44| 2.00M| } _ZN8perfetto4base11SmallVectorINS_15trace_processor17GlobalArgsTracker3ArgELm16EE13is_using_heapEv: 184| 3.32M| bool is_using_heap() { return begin_ != inline_storage_begin(); } _ZN8perfetto4base11SmallVectorINS_15trace_processor17GlobalArgsTracker3ArgELm16EE12emplace_backIJEEEvDpOT_: 142| 23.0M| void emplace_back(Args&&... args) { 143| 23.0M| T* end = end_; 144| 23.0M| if (PERFETTO_UNLIKELY(end == end_of_storage_)) ------------------ | | 24| 23.0M|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 473k, False: 22.6M] | | ------------------ ------------------ 145| 473k| end = Grow(); 146| 23.0M| new (end) T(std::forward(args)...); 147| 23.0M| end_ = end + 1; 148| 23.0M| } _ZN8perfetto4base11SmallVectorINS_15trace_processor17GlobalArgsTracker3ArgELm16EE4GrowEm: 163| 552k| PERFETTO_NO_INLINE T* Grow(size_t desired_capacity = 0) { 164| 552k| size_t cur_size = size(); 165| 552k| size_t new_capacity = desired_capacity; 166| 552k| if (desired_capacity <= cur_size) ------------------ | Branch (166:9): [True: 552k, False: 0] ------------------ 167| 552k| new_capacity = std::max(capacity() * 2, size_t(128)); 168| 552k| T* new_storage = 169| 552k| static_cast(AlignedAlloc(alignof(T), new_capacity * sizeof(T))); 170| 44.6M| for (size_t i = 0; i < cur_size; ++i) { ------------------ | Branch (170:24): [True: 44.0M, False: 552k] ------------------ 171| | // Move the elements into the new heap buffer and destroy the old ones. 172| 44.0M| new (&new_storage[i]) T(std::move(begin_[i])); 173| 44.0M| begin_[i].~T(); 174| 44.0M| } 175| 552k| if (is_using_heap()) ------------------ | Branch (175:9): [True: 4.49k, False: 548k] ------------------ 176| 4.49k| AlignedFree(begin_); 177| 552k| begin_ = new_storage; 178| 552k| end_ = new_storage + cur_size; 179| 552k| end_of_storage_ = new_storage + new_capacity; 180| 552k| return end_; 181| 552k| } _ZNK8perfetto4base11SmallVectorINS_15trace_processor17GlobalArgsTracker3ArgELm16EE8capacityEv: 109| 552k| size_t capacity() const { 110| 552k| return static_cast(end_of_storage_ - begin_); 111| 552k| } _ZN8perfetto4base11SmallVectorINS_15trace_processor17GlobalArgsTracker3ArgELm16EE4backEv: 122| 60.9M| T& back() { 123| 60.9M| PERFETTO_DCHECK(!empty()); 124| 60.9M| return end_[-1]; 125| 60.9M| } _ZNK8perfetto4base11SmallVectorINS_15trace_processor17GlobalArgsTracker3ArgELm16EE5emptyEv: 107| 43.4M| bool empty() const { return end_ == begin_; } args_tracker.cc:_ZN8perfetto4base11SmallVectorIZNS_15trace_processor11ArgsTracker5FlushEvE5EntryLm16EED2Ev: 39| 389k| ~SmallVector() { 40| 389k| clear(); 41| 389k| if (PERFETTO_UNLIKELY(is_using_heap())) ------------------ | | 24| 389k|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 76.3k, False: 313k] | | ------------------ ------------------ 42| 76.3k| AlignedFree(begin_); 43| 389k| begin_ = end_ = end_of_storage_ = nullptr; 44| 389k| } args_tracker.cc:_ZN8perfetto4base11SmallVectorIZNS_15trace_processor11ArgsTracker5FlushEvE5EntryLm16EE5clearEv: 157| 389k| void clear() { 158| 15.2M| while (!empty()) ------------------ | Branch (158:12): [True: 14.8M, False: 389k] ------------------ 159| 14.8M| pop_back(); 160| 389k| } args_tracker.cc:_ZNK8perfetto4base11SmallVectorIZNS_15trace_processor11ArgsTracker5FlushEvE5EntryLm16EE5emptyEv: 107| 15.2M| bool empty() const { return end_ == begin_; } args_tracker.cc:_ZN8perfetto4base11SmallVectorIZNS_15trace_processor11ArgsTracker5FlushEvE5EntryLm16EE8pop_backEv: 150| 14.8M| void pop_back() { 151| 14.8M| PERFETTO_DCHECK(!empty()); 152| 14.8M| back().~T(); 153| 14.8M| --end_; 154| 14.8M| } args_tracker.cc:_ZN8perfetto4base11SmallVectorIZNS_15trace_processor11ArgsTracker5FlushEvE5EntryLm16EE4backEv: 122| 14.8M| T& back() { 123| 14.8M| PERFETTO_DCHECK(!empty()); 124| 14.8M| return end_[-1]; 125| 14.8M| } args_tracker.cc:_ZN8perfetto4base11SmallVectorIZNS_15trace_processor11ArgsTracker5FlushEvE5EntryLm16EE13is_using_heapEv: 184| 468k| bool is_using_heap() { return begin_ != inline_storage_begin(); } _ZN8perfetto4base11SmallVectorINS_15trace_processor17GlobalArgsTracker3ArgELm16EE5beginEv: 99| 907k| T* begin() { return begin_; } _ZN8perfetto4base11SmallVectorINS_15trace_processor17GlobalArgsTracker3ArgELm16EE3endEv: 102| 907k| T* end() { return end_; } args_tracker.cc:_ZNK8perfetto4base11SmallVectorIZNS_15trace_processor11ArgsTracker5FlushEvE5EntryLm16EE4sizeEv: 105| 29.7M| size_t size() const { return static_cast(end_ - begin_); } args_tracker.cc:_ZN8perfetto4base11SmallVectorIZNS_15trace_processor11ArgsTracker5FlushEvE5EntryLm16EE12emplace_backIJmRKNS2_10StringPool2IdEEEEvDpOT_: 142| 14.8M| void emplace_back(Args&&... args) { 143| 14.8M| T* end = end_; 144| 14.8M| if (PERFETTO_UNLIKELY(end == end_of_storage_)) ------------------ | | 24| 14.8M|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 78.7k, False: 14.7M] | | ------------------ ------------------ 145| 78.7k| end = Grow(); 146| 14.8M| new (end) T(std::forward(args)...); 147| 14.8M| end_ = end + 1; 148| 14.8M| } args_tracker.cc:_ZN8perfetto4base11SmallVectorIZNS_15trace_processor11ArgsTracker5FlushEvE5EntryLm16EE4GrowEm: 163| 78.7k| PERFETTO_NO_INLINE T* Grow(size_t desired_capacity = 0) { 164| 78.7k| size_t cur_size = size(); 165| 78.7k| size_t new_capacity = desired_capacity; 166| 78.7k| if (desired_capacity <= cur_size) ------------------ | Branch (166:9): [True: 78.7k, False: 0] ------------------ 167| 78.7k| new_capacity = std::max(capacity() * 2, size_t(128)); 168| 78.7k| T* new_storage = 169| 78.7k| static_cast(AlignedAlloc(alignof(T), new_capacity * sizeof(T))); 170| 19.0M| for (size_t i = 0; i < cur_size; ++i) { ------------------ | Branch (170:24): [True: 18.9M, False: 78.7k] ------------------ 171| | // Move the elements into the new heap buffer and destroy the old ones. 172| 18.9M| new (&new_storage[i]) T(std::move(begin_[i])); 173| 18.9M| begin_[i].~T(); 174| 18.9M| } 175| 78.7k| if (is_using_heap()) ------------------ | Branch (175:9): [True: 2.47k, False: 76.3k] ------------------ 176| 2.47k| AlignedFree(begin_); 177| 78.7k| begin_ = new_storage; 178| 78.7k| end_ = new_storage + cur_size; 179| 78.7k| end_of_storage_ = new_storage + new_capacity; 180| 78.7k| return end_; 181| 78.7k| } args_tracker.cc:_ZNK8perfetto4base11SmallVectorIZNS_15trace_processor11ArgsTracker5FlushEvE5EntryLm16EE8capacityEv: 109| 78.7k| size_t capacity() const { 110| 78.7k| return static_cast(end_of_storage_ - begin_); 111| 78.7k| } args_tracker.cc:_ZN8perfetto4base11SmallVectorIZNS_15trace_processor11ArgsTracker5FlushEvE5EntryLm16EE5beginEv: 99| 1.16M| T* begin() { return begin_; } args_tracker.cc:_ZN8perfetto4base11SmallVectorIZNS_15trace_processor11ArgsTracker5FlushEvE5EntryLm16EE3endEv: 102| 1.16M| T* end() { return end_; } args_tracker.cc:_ZN8perfetto4base11SmallVectorIZNS_15trace_processor11ArgsTracker5FlushEvE5EntryLm16EEixEm: 131| 58.5M| T& operator[](size_t index) { 132| 58.5M| PERFETTO_DCHECK(index < size()); 133| 58.5M| return begin_[index]; 134| 58.5M| } _ZN8perfetto4base11SmallVectorINS_15trace_processor17GlobalArgsTracker3ArgELm16EEixEm: 131| 529M| T& operator[](size_t index) { 132| 529M| PERFETTO_DCHECK(index < size()); 133| 529M| return begin_[index]; 134| 529M| } _ZN8perfetto4base11SmallVectorINS_15trace_processor17GlobalArgsTracker3ArgELm16EE12emplace_backIJRS4_EEEvDpOT_: 142| 14.8M| void emplace_back(Args&&... args) { 143| 14.8M| T* end = end_; 144| 14.8M| if (PERFETTO_UNLIKELY(end == end_of_storage_)) ------------------ | | 24| 14.8M|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 78.7k, False: 14.7M] | | ------------------ ------------------ 145| 78.7k| end = Grow(); 146| 14.8M| new (end) T(std::forward(args)...); 147| 14.8M| end_ = end + 1; 148| 14.8M| } _ZNK8perfetto4base11SmallVectorINS_15trace_processor17GlobalArgsTracker3ArgELm16EE4sizeEv: 105| 19.0M| size_t size() const { return static_cast(end_ - begin_); } _ZN8perfetto4base11SmallVectorINS_15trace_processor17GlobalArgsTracker3ArgELm16EE4dataEv: 96| 2.50M| T* data() { return begin_; } _ZN8perfetto4base11SmallVectorINS_15trace_processor17GlobalArgsTracker3ArgELm16EE5clearEv: 157| 2.91M| void clear() { 158| 40.8M| while (!empty()) ------------------ | Branch (158:12): [True: 37.9M, False: 2.91M] ------------------ 159| 37.9M| pop_back(); 160| 2.91M| } _ZN8perfetto4base11SmallVectorINS_15trace_processor17GlobalArgsTracker3ArgELm16EE8pop_backEv: 150| 37.9M| void pop_back() { 151| 37.9M| PERFETTO_DCHECK(!empty()); 152| 37.9M| back().~T(); 153| 37.9M| --end_; 154| 37.9M| } _ZN8perfetto4base11SmallVectorINS_15trace_processor17GlobalArgsTracker10CompactArgELm16EED2Ev: 39| 1.76M| ~SmallVector() { 40| 1.76M| clear(); 41| 1.76M| if (PERFETTO_UNLIKELY(is_using_heap())) ------------------ | | 24| 1.76M|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 397k, False: 1.36M] | | ------------------ ------------------ 42| 397k| AlignedFree(begin_); 43| 1.76M| begin_ = end_ = end_of_storage_ = nullptr; 44| 1.76M| } _ZN8perfetto4base11SmallVectorINS_15trace_processor17GlobalArgsTracker10CompactArgELm16EE5clearEv: 157| 1.76M| void clear() { 158| 10.0M| while (!empty()) ------------------ | Branch (158:12): [True: 8.24M, False: 1.76M] ------------------ 159| 8.24M| pop_back(); 160| 1.76M| } _ZNK8perfetto4base11SmallVectorINS_15trace_processor17GlobalArgsTracker10CompactArgELm16EE5emptyEv: 107| 10.0M| bool empty() const { return end_ == begin_; } _ZN8perfetto4base11SmallVectorINS_15trace_processor17GlobalArgsTracker10CompactArgELm16EE8pop_backEv: 150| 8.24M| void pop_back() { 151| 8.24M| PERFETTO_DCHECK(!empty()); 152| 8.24M| back().~T(); 153| 8.24M| --end_; 154| 8.24M| } _ZN8perfetto4base11SmallVectorINS_15trace_processor17GlobalArgsTracker10CompactArgELm16EE4backEv: 122| 8.24M| T& back() { 123| 8.24M| PERFETTO_DCHECK(!empty()); 124| 8.24M| return end_[-1]; 125| 8.24M| } _ZN8perfetto4base11SmallVectorINS_15trace_processor17GlobalArgsTracker10CompactArgELm16EE13is_using_heapEv: 184| 3.40M| bool is_using_heap() { return begin_ != inline_storage_begin(); } _ZN8perfetto4base11SmallVectorINS_15trace_processor17GlobalArgsTracker10CompactArgELm16EE12emplace_backIJS4_EEEvDpOT_: 142| 8.24M| void emplace_back(Args&&... args) { 143| 8.24M| T* end = end_; 144| 8.24M| if (PERFETTO_UNLIKELY(end == end_of_storage_)) ------------------ | | 24| 8.24M|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 397k, False: 7.84M] | | ------------------ ------------------ 145| 397k| end = Grow(); 146| 8.24M| new (end) T(std::forward(args)...); 147| 8.24M| end_ = end + 1; 148| 8.24M| } _ZN8perfetto4base11SmallVectorINS_15trace_processor17GlobalArgsTracker10CompactArgELm16EE4GrowEm: 163| 397k| PERFETTO_NO_INLINE T* Grow(size_t desired_capacity = 0) { 164| 397k| size_t cur_size = size(); 165| 397k| size_t new_capacity = desired_capacity; 166| 397k| if (desired_capacity <= cur_size) ------------------ | Branch (166:9): [True: 397k, False: 0] ------------------ 167| 397k| new_capacity = std::max(capacity() * 2, size_t(128)); 168| 397k| T* new_storage = 169| 397k| static_cast(AlignedAlloc(alignof(T), new_capacity * sizeof(T))); 170| 6.74M| for (size_t i = 0; i < cur_size; ++i) { ------------------ | Branch (170:24): [True: 6.35M, False: 397k] ------------------ 171| | // Move the elements into the new heap buffer and destroy the old ones. 172| 6.35M| new (&new_storage[i]) T(std::move(begin_[i])); 173| 6.35M| begin_[i].~T(); 174| 6.35M| } 175| 397k| if (is_using_heap()) ------------------ | Branch (175:9): [True: 0, False: 397k] ------------------ 176| 0| AlignedFree(begin_); 177| 397k| begin_ = new_storage; 178| 397k| end_ = new_storage + cur_size; 179| 397k| end_of_storage_ = new_storage + new_capacity; 180| 397k| return end_; 181| 397k| } _ZNK8perfetto4base11SmallVectorINS_15trace_processor17GlobalArgsTracker10CompactArgELm16EE4sizeEv: 105| 690k| size_t size() const { return static_cast(end_ - begin_); } _ZNK8perfetto4base11SmallVectorINS_15trace_processor17GlobalArgsTracker10CompactArgELm16EE8capacityEv: 109| 397k| size_t capacity() const { 110| 397k| return static_cast(end_of_storage_ - begin_); 111| 397k| } _ZNK8perfetto4base11SmallVectorINS_15trace_processor17GlobalArgsTracker3ArgELm16EE5beginEv: 100| 725k| const T* begin() const { return begin_; } _ZNK8perfetto4base11SmallVectorINS_15trace_processor17GlobalArgsTracker3ArgELm16EE3endEv: 103| 725k| const T* end() const { return end_; } _ZNK8perfetto4base11SmallVectorINS_15trace_processor17GlobalArgsTracker10CompactArgELm16EE5beginEv: 100| 512k| const T* begin() const { return begin_; } _ZNK8perfetto4base11SmallVectorINS_15trace_processor17GlobalArgsTracker10CompactArgELm16EE3endEv: 103| 512k| const T* end() const { return end_; } _ZN8perfetto4base11SmallVectorINS_15trace_processor17GlobalArgsTracker10CompactArgELm16EEC2EOS5_: 48| 1.24M| std::is_nothrow_move_constructible::value) { 49| 1.24M| if (other.is_using_heap()) { ------------------ | Branch (49:9): [True: 949k, False: 293k] ------------------ 50| | // Move the heap content, no need to move the individual objects as their 51| | // location won't change. 52| 949k| begin_ = other.begin_; 53| 949k| end_ = other.end_; 54| 949k| end_of_storage_ = other.end_of_storage_; 55| 949k| } else { 56| 293k| const size_t other_size = other.size(); 57| 293k| PERFETTO_DCHECK(other_size <= capacity()); 58| 2.96M| for (size_t i = 0; i < other_size; i++) { ------------------ | Branch (58:26): [True: 2.67M, False: 293k] ------------------ 59| | // Move the entries and destroy the ones in the moved-from object. 60| 2.67M| new (&begin_[i]) T(std::move(other.begin_[i])); 61| 2.67M| other.begin_[i].~T(); 62| 2.67M| } 63| 293k| end_ = begin_ + other_size; 64| 293k| } 65| 1.24M| auto* const other_inline_storage = other.inline_storage_begin(); 66| 1.24M| other.end_ = other.begin_ = other_inline_storage; 67| 1.24M| other.end_of_storage_ = other_inline_storage + kInlineSize; 68| 1.24M| } _ZN8perfetto4base11SmallVectorINS_15trace_processor17GlobalArgsTracker3ArgELm16EEC2EOS5_: 48| 765k| std::is_nothrow_move_constructible::value) { 49| 765k| if (other.is_using_heap()) { ------------------ | Branch (49:9): [True: 1.93k, False: 763k] ------------------ 50| | // Move the heap content, no need to move the individual objects as their 51| | // location won't change. 52| 1.93k| begin_ = other.begin_; 53| 1.93k| end_ = other.end_; 54| 1.93k| end_of_storage_ = other.end_of_storage_; 55| 763k| } else { 56| 763k| const size_t other_size = other.size(); 57| 763k| PERFETTO_DCHECK(other_size <= capacity()); 58| 774k| for (size_t i = 0; i < other_size; i++) { ------------------ | Branch (58:26): [True: 11.3k, False: 763k] ------------------ 59| | // Move the entries and destroy the ones in the moved-from object. 60| 11.3k| new (&begin_[i]) T(std::move(other.begin_[i])); 61| 11.3k| other.begin_[i].~T(); 62| 11.3k| } 63| 763k| end_ = begin_ + other_size; 64| 763k| } 65| 765k| auto* const other_inline_storage = other.inline_storage_begin(); 66| 765k| other.end_ = other.begin_ = other_inline_storage; 67| 765k| other.end_of_storage_ = other_inline_storage + kInlineSize; 68| 765k| } _ZNK8perfetto4base8StatusOrINSt3__110unique_ptrINS_15trace_processor18ChunkedTraceReaderENS2_14default_deleteIS5_EEEEE6statusEv: 52| 426| const base::Status& status() const { return status_; } _ZN8perfetto4base8StatusOrINSt3__110unique_ptrINS_15trace_processor18ChunkedTraceReaderENS2_14default_deleteIS5_EEEEE5valueEv: 54| 424| T& value() { 55| 424| PERFETTO_DCHECK(status_.ok()); 56| 424| return *value_; 57| 424| } _ZNK8perfetto4base8StatusOrIlE6statusEv: 52| 59.0k| const base::Status& status() const { return status_; } _ZN8perfetto4base8StatusOrIlE5valueEv: 54| 74.5k| T& value() { 55| 74.5k| PERFETTO_DCHECK(status_.ok()); 56| 74.5k| return *value_; 57| 74.5k| } _ZNK8perfetto4base8StatusOrIlE2okEv: 51| 44.3k| bool ok() const { return status_.ok(); } _ZN8perfetto4base8StatusOrIlEdeEv: 60| 50.2k| T& operator*() { return value(); } _ZN8perfetto4base8StatusOrINSt3__110unique_ptrINS_15trace_processor18ChunkedTraceReaderENS2_14default_deleteIS5_EEEEEC2ES8_: 49| 424| StatusOr(T value) : StatusOr(base::OkStatus(), std::move(value)) {} _ZN8perfetto4base8StatusOrINSt3__110unique_ptrINS_15trace_processor18ChunkedTraceReaderENS2_14default_deleteIS5_EEEEEC2ENS0_6StatusENS2_8optionalIS8_EE: 68| 426| : status_(std::move(status)), value_(std::move(value)) { 69| 426| PERFETTO_DCHECK(!status_.ok() || value_.has_value()); 70| 426| } _ZN8perfetto4base8StatusOrINSt3__110unique_ptrINS_15trace_processor18ChunkedTraceReaderENS2_14default_deleteIS5_EEEEEC2ENS0_6StatusE: 42| 2| StatusOr(base::Status status) : StatusOr(std::move(status), std::nullopt) { 43| 2| if (status.ok()) { ------------------ | Branch (43:9): [True: 0, False: 2] ------------------ 44| | // Matches what Abseil's approach towards OkStatus being passed to 45| | // absl::StatusOr. 46| 0| PERFETTO_FATAL("base::OkStatus passed to StatusOr: this is not allowd"); 47| 0| } 48| 2| } _ZN8perfetto4base8StatusOrIlEC2ENS0_6StatusE: 42| 37.1k| StatusOr(base::Status status) : StatusOr(std::move(status), std::nullopt) { 43| 37.1k| if (status.ok()) { ------------------ | Branch (43:9): [True: 0, False: 37.1k] ------------------ 44| | // Matches what Abseil's approach towards OkStatus being passed to 45| | // absl::StatusOr. 46| 0| PERFETTO_FATAL("base::OkStatus passed to StatusOr: this is not allowd"); 47| 0| } 48| 37.1k| } _ZN8perfetto4base8StatusOrIlEC2ENS0_6StatusENSt3__18optionalIlEE: 68| 86.5k| : status_(std::move(status)), value_(std::move(value)) { 69| 86.5k| PERFETTO_DCHECK(!status_.ok() || value_.has_value()); 70| 86.5k| } _ZN8perfetto4base8StatusOrIlEC2El: 49| 49.4k| StatusOr(T value) : StatusOr(base::OkStatus(), std::move(value)) {} _ZN8perfetto4base8StatusOrIjEC2ENS0_6StatusE: 42| 3.82k| StatusOr(base::Status status) : StatusOr(std::move(status), std::nullopt) { 43| 3.82k| if (status.ok()) { ------------------ | Branch (43:9): [True: 0, False: 3.82k] ------------------ 44| | // Matches what Abseil's approach towards OkStatus being passed to 45| | // absl::StatusOr. 46| 0| PERFETTO_FATAL("base::OkStatus passed to StatusOr: this is not allowd"); 47| 0| } 48| 3.82k| } _ZN8perfetto4base8StatusOrIjEC2ENS0_6StatusENSt3__18optionalIjEE: 68| 21.1k| : status_(std::move(status)), value_(std::move(value)) { 69| 21.1k| PERFETTO_DCHECK(!status_.ok() || value_.has_value()); 70| 21.1k| } _ZN8perfetto4base8StatusOrIjEC2Ej: 49| 17.3k| StatusOr(T value) : StatusOr(base::OkStatus(), std::move(value)) {} _ZNK8perfetto4base8StatusOrIjE2okEv: 51| 21.1k| bool ok() const { return status_.ok(); } _ZNK8perfetto4base8StatusOrIjE6statusEv: 52| 3.82k| const base::Status& status() const { return status_; } _ZN8perfetto4base8StatusOrIjEdeEv: 60| 25.1k| T& operator*() { return value(); } _ZN8perfetto4base8StatusOrIjE5valueEv: 54| 25.1k| T& value() { 55| 25.1k| PERFETTO_DCHECK(status_.ok()); 56| 25.1k| return *value_; 57| 25.1k| } _ZN8perfetto4base9LowercaseEc: 36| 27.6k|inline char Lowercase(char c) { 37| 27.6k| return ('A' <= c && c <= 'Z') ? static_cast(c - ('A' - 'a')) : c; ------------------ | Branch (37:11): [True: 3.12k, False: 24.5k] | Branch (37:23): [True: 1.53k, False: 1.58k] ------------------ 38| 27.6k|} _ZN8perfetto4base15CStringToUInt32EPKci: 44| 378|inline std::optional CStringToUInt32(const char* s, int base = 10) { 45| 378| char* endptr = nullptr; 46| 378| auto value = static_cast(strtoul(s, &endptr, base)); 47| 378| return (*s && !*endptr) ? std::make_optional(value) : std::nullopt; ------------------ | Branch (47:11): [True: 378, False: 0] | Branch (47:17): [True: 0, False: 378] ------------------ 48| 378|} _ZN8perfetto4base15CStringToDoubleEPKc: 71| 378|inline std::optional CStringToDouble(const char* s) { 72| 378| char* endptr = nullptr; 73| 378| double value = StrToD(s, &endptr); 74| 378| std::optional result(std::nullopt); 75| 378| if (*s != '\0' && *endptr == '\0') ------------------ | Branch (75:7): [True: 378, False: 0] | Branch (75:21): [True: 378, False: 0] ------------------ 76| 378| result = value; 77| 378| return result; 78| 378|} _ZN8perfetto4base14StringToUInt32ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEi: 81| 378| int base = 10) { 82| 378| return CStringToUInt32(s.c_str(), base); 83| 378|} _ZN8perfetto4base14StringToDoubleERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE: 100| 378|inline std::optional StringToDouble(const std::string& s) { 101| 378| return CStringToDouble(s.c_str()); 102| 378|} _ZN8perfetto4base11StackStringILm10EEC2EPKcz: 273| 212k| StackString(const char* fmt, ...) { 274| 212k| buf_[0] = '\0'; 275| 212k| va_list args; 276| 212k| va_start(args, fmt); 277| 212k| int res = vsnprintf(buf_, sizeof(buf_), fmt, args); 278| 212k| va_end(args); 279| 212k| buf_[sizeof(buf_) - 1] = '\0'; 280| 212k| len_ = res < 0 ? 0 : std::min(static_cast(res), sizeof(buf_) - 1); ------------------ | Branch (280:12): [True: 0, False: 212k] ------------------ 281| 212k| } _ZNK8perfetto4base11StackStringILm10EE3lenEv: 286| 212k| size_t len() const { return len_; } _ZNK8perfetto4base11StackStringILm10EE5c_strEv: 285| 212k| const char* c_str() const { return buf_; } _ZN8perfetto4base11StackStringILm24EEC2EPKcz: 273| 212k| StackString(const char* fmt, ...) { 274| 212k| buf_[0] = '\0'; 275| 212k| va_list args; 276| 212k| va_start(args, fmt); 277| 212k| int res = vsnprintf(buf_, sizeof(buf_), fmt, args); 278| 212k| va_end(args); 279| 212k| buf_[sizeof(buf_) - 1] = '\0'; 280| 212k| len_ = res < 0 ? 0 : std::min(static_cast(res), sizeof(buf_) - 1); ------------------ | Branch (280:12): [True: 0, False: 212k] ------------------ 281| 212k| } _ZN8perfetto4base11StackStringILm32EEC2EPKcz: 273| 212k| StackString(const char* fmt, ...) { 274| 212k| buf_[0] = '\0'; 275| 212k| va_list args; 276| 212k| va_start(args, fmt); 277| 212k| int res = vsnprintf(buf_, sizeof(buf_), fmt, args); 278| 212k| va_end(args); 279| 212k| buf_[sizeof(buf_) - 1] = '\0'; 280| 212k| len_ = res < 0 ? 0 : std::min(static_cast(res), sizeof(buf_) - 1); ------------------ | Branch (280:12): [True: 0, False: 212k] ------------------ 281| 212k| } _ZNK8perfetto4base11StackStringILm32EE5c_strEv: 285| 212k| const char* c_str() const { return buf_; } _ZNK8perfetto4base11StackStringILm24EE5c_strEv: 285| 212k| const char* c_str() const { return buf_; } _ZNK8perfetto4base11StackStringILm32EE11string_viewEv: 283| 212k| StringView string_view() const { return StringView(buf_, len_); } _ZNK8perfetto4base11StackStringILm24EE11string_viewEv: 283| 212k| StringView string_view() const { return StringView(buf_, len_); } _ZN8perfetto4base11StackStringILm64EEC2EPKcz: 273| 279k| StackString(const char* fmt, ...) { 274| 279k| buf_[0] = '\0'; 275| 279k| va_list args; 276| 279k| va_start(args, fmt); 277| 279k| int res = vsnprintf(buf_, sizeof(buf_), fmt, args); 278| 279k| va_end(args); 279| 279k| buf_[sizeof(buf_) - 1] = '\0'; 280| 279k| len_ = res < 0 ? 0 : std::min(static_cast(res), sizeof(buf_) - 1); ------------------ | Branch (280:12): [True: 0, False: 279k] ------------------ 281| 279k| } _ZN8perfetto4base11StackStringILm6EEC2EPKcz: 273| 7| StackString(const char* fmt, ...) { 274| 7| buf_[0] = '\0'; 275| 7| va_list args; 276| 7| va_start(args, fmt); 277| 7| int res = vsnprintf(buf_, sizeof(buf_), fmt, args); 278| 7| va_end(args); 279| 7| buf_[sizeof(buf_) - 1] = '\0'; 280| 7| len_ = res < 0 ? 0 : std::min(static_cast(res), sizeof(buf_) - 1); ------------------ | Branch (280:12): [True: 0, False: 7] ------------------ 281| 7| } _ZNK8perfetto4base11StackStringILm6EE11ToStdStringEv: 284| 14| std::string ToStdString() const { return std::string(buf_, len_); } _ZN8perfetto4base11StackStringILm45EEC2EPKcz: 273| 24| StackString(const char* fmt, ...) { 274| 24| buf_[0] = '\0'; 275| 24| va_list args; 276| 24| va_start(args, fmt); 277| 24| int res = vsnprintf(buf_, sizeof(buf_), fmt, args); 278| 24| va_end(args); 279| 24| buf_[sizeof(buf_) - 1] = '\0'; 280| 24| len_ = res < 0 ? 0 : std::min(static_cast(res), sizeof(buf_) - 1); ------------------ | Branch (280:12): [True: 0, False: 24] ------------------ 281| 24| } _ZNK8perfetto4base11StackStringILm45EE11ToStdStringEv: 284| 24| std::string ToStdString() const { return std::string(buf_, len_); } _ZNK8perfetto4base11StackStringILm64EE11string_viewEv: 283| 279k| StringView string_view() const { return StringView(buf_, len_); } _ZN8perfetto4base11StackStringILm2048EEC2EPKcz: 273| 3.97M| StackString(const char* fmt, ...) { 274| 3.97M| buf_[0] = '\0'; 275| 3.97M| va_list args; 276| 3.97M| va_start(args, fmt); 277| 3.97M| int res = vsnprintf(buf_, sizeof(buf_), fmt, args); 278| 3.97M| va_end(args); 279| 3.97M| buf_[sizeof(buf_) - 1] = '\0'; 280| 3.97M| len_ = res < 0 ? 0 : std::min(static_cast(res), sizeof(buf_) - 1); ------------------ | Branch (280:12): [True: 0, False: 3.97M] ------------------ 281| 3.97M| } _ZNK8perfetto4base11StackStringILm2048EE11string_viewEv: 283| 3.97M| StringView string_view() const { return StringView(buf_, len_); } _ZN8perfetto4base10StringViewC2Ev: 41| 4.12M| StringView() : data_(nullptr), size_(0) {} _ZN8perfetto4base10StringViewC2EPKcm: 44| 18.8M| StringView(const char* data, size_t size) : data_(data), size_(size) { 45| 18.8M| PERFETTO_DCHECK(size == 0 || data != nullptr); 46| 18.8M| } _ZN8perfetto4base10StringViewC2EPKc: 57| 1.88M| StringView(const char* cstr) : data_(cstr), size_(strlen(cstr)) { 58| 1.88M| PERFETTO_DCHECK(cstr != nullptr); 59| 1.88M| } _ZN8perfetto4base10StringViewC2ERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE: 64| 17.5M| : data_(str.data()), size_(str.size()) {} _ZNK8perfetto4base10StringView4sizeEv: 67| 8.51M| size_t size() const { return size_; } _ZNK8perfetto4base10StringView4dataEv: 68| 38.9M| const char* data() const { return data_; } _ZNK8perfetto4base10StringView10StartsWithERKS1_: 133| 428| bool StartsWith(const StringView& other) const { 134| 428| if (other.size() == 0) ------------------ | Branch (134:9): [True: 0, False: 428] ------------------ 135| 0| return true; 136| 428| if (size() == 0) ------------------ | Branch (136:9): [True: 424, False: 4] ------------------ 137| 424| return false; 138| 4| if (other.size() > size()) ------------------ | Branch (138:9): [True: 0, False: 4] ------------------ 139| 0| return false; 140| 4| return memcmp(data(), other.data(), other.size()) == 0; 141| 4| } _ZNK8perfetto4base10StringView11ToStdStringEv: 154| 2.79M| std::string ToStdString() const { 155| 2.79M| return size_ == 0 ? "" : std::string(data_, size_); ------------------ | Branch (155:12): [True: 9.61k, False: 2.78M] ------------------ 156| 2.79M| } _ZNK8perfetto4base10StringView4HashEv: 158| 23.5M| uint64_t Hash() const { 159| 23.5M| base::Hasher hasher; 160| 23.5M| hasher.Update(data_, size_); 161| 23.5M| return hasher.digest(); 162| 23.5M| } _ZN8perfetto4baseeqERKNS0_10StringViewES3_: 169| 1.29M|inline bool operator==(const StringView& x, const StringView& y) { 170| 1.29M| if (x.size() != y.size()) ------------------ | Branch (170:7): [True: 945k, False: 346k] ------------------ 171| 945k| return false; 172| 346k| if (x.size() == 0) ------------------ | Branch (172:7): [True: 0, False: 346k] ------------------ 173| 0| return true; 174| 346k| return memcmp(x.data(), y.data(), x.size()) == 0; 175| 346k|} _ZN8perfetto4base10StringViewC2IN9protozero10ConstCharsENSt3__19enable_ifILb1EvEEEERKT_: 51| 12.3M| StringView(const T& x) : StringView(x.data, x.size) { 52| 12.3M| PERFETTO_DCHECK(x.size == 0 || x.data != nullptr); 53| 12.3M| } _ZN8perfetto4base12StringWriter12AppendStringENS0_10StringViewE: 65| 53.0k| void AppendString(StringView data) { AppendString(data.data(), data.size()); } _ZN8perfetto4base12StringWriter12AppendStringEPKcm: 50| 93.2k| void AppendString(const char* in, size_t n) { 51| 93.2k| PERFETTO_DCHECK(pos_ + n <= size_); 52| 93.2k| memcpy(&buffer_[pos_], in, n); 53| 93.2k| pos_ += n; 54| 93.2k| } _ZN8perfetto4base12StringWriterC2EPcm: 40| 33.4k| StringWriter(char* buffer, size_t size) : buffer_(buffer), size_(size) {} _ZN8perfetto4base12StringWriter10AppendCharEcm: 43| 33.2k| void AppendChar(char in, size_t n = 1) { 44| 33.2k| PERFETTO_DCHECK(pos_ + n <= size_); 45| 33.2k| memset(&buffer_[pos_], in, n); 46| 33.2k| pos_ += n; 47| 33.2k| } _ZN8perfetto4base12StringWriter17AppendUnsignedIntEm: 85| 33.2k| void AppendUnsignedInt(uint64_t value) { 86| 33.2k| AppendPaddedUnsignedInt<'0', 0>(value); 87| 33.2k| } _ZN8perfetto4base12StringWriter13GetStringViewEv: 124| 33.4k| StringView GetStringView() { 125| 33.4k| PERFETTO_DCHECK(pos_ <= size_); 126| 33.4k| return StringView(buffer_, pos_); 127| 33.4k| } _ZN8perfetto4base12StringWriter15AppendPaddedIntILc48ELm0EEEvmb: 144| 33.2k| void AppendPaddedInt(uint64_t absolute_value, bool negate) { 145| | // Need to add 2 to the number of digits to account for minus sign and 146| | // rounding down of digits10. 147| 33.2k| constexpr auto kMaxDigits = std::numeric_limits::digits10 + 2; 148| 33.2k| constexpr auto kSizeNeeded = kMaxDigits > padding ? kMaxDigits : padding; ------------------ | Branch (148:34): [Folded - Ignored] ------------------ 149| 33.2k| PERFETTO_DCHECK(pos_ + kSizeNeeded <= size_); 150| | 151| 33.2k| char data[kSizeNeeded]; 152| | 153| 33.2k| size_t idx; 154| 131k| for (idx = kSizeNeeded - 1; absolute_value >= 10;) { ------------------ | Branch (154:33): [True: 98.3k, False: 33.2k] ------------------ 155| 98.3k| char digit = absolute_value % 10; 156| 98.3k| absolute_value /= 10; 157| 98.3k| data[idx--] = digit + '0'; 158| 98.3k| } 159| 33.2k| data[idx--] = static_cast(absolute_value) + '0'; 160| | 161| 33.2k| if (padding > 0) { ------------------ | Branch (161:9): [Folded - Ignored] ------------------ 162| 0| size_t num_digits = kSizeNeeded - 1 - idx; 163| | // std::max() needed to work around GCC not being able to tell that 164| | // padding > 0. 165| 0| for (size_t i = num_digits; i < std::max(uint64_t{1u}, padding); i++) { ------------------ | Branch (165:35): [True: 0, False: 0] ------------------ 166| 0| data[idx--] = padchar; 167| 0| } 168| 0| } 169| | 170| 33.2k| if (negate) ------------------ | Branch (170:9): [True: 0, False: 33.2k] ------------------ 171| 0| buffer_[pos_++] = '-'; 172| 33.2k| AppendString(&data[idx + 1], kSizeNeeded - idx - 1); 173| 33.2k| } _ZN8perfetto4base12StringWriter23AppendPaddedUnsignedIntILc48ELm0EEEvm: 92| 33.2k| void AppendPaddedUnsignedInt(uint64_t value) { 93| 33.2k| AppendPaddedInt(value, false); 94| 33.2k| } _ZN8perfetto4base12StringWriter13AppendLiteralILm9EEEvRAT__Kc: 60| 6.91k| inline void AppendLiteral(const char (&in)[N]) { 61| 6.91k| AppendString(in, N - 1); 62| 6.91k| } _ZN8perfetto4base14GetSysPageSizeEv: 63| 3.47k|inline uint32_t GetSysPageSize() { 64| 3.47k| const uint32_t page_size = 65| 3.47k| internal::g_cached_page_size.load(std::memory_order_relaxed); 66| 3.47k| return page_size != 0 ? page_size : internal::GetSysPageSizeSlowpath(); ------------------ | Branch (66:10): [True: 3.47k, False: 1] ------------------ 67| 3.47k|} _ZN8perfetto4base7AlignUpEmm: 92| 1.08M|inline constexpr size_t AlignUp(size_t size, size_t alignment) { 93| 1.08M| return (size + alignment - 1) & ~(alignment - 1); 94| 1.08M|} _ZNK8perfetto4base14AlignedDeleterImEclEPm: 149| 5.60k| inline void operator()(T* ptr) const { AlignedFree(ptr); } _ZNK8perfetto4base14AlignedDeleterINS_15trace_processor10StringPool2IdEEclEPS4_: 149| 975| inline void operator()(T* ptr) const { AlignedFree(ptr); } _ZN8perfetto4base17AlignedAllocTypedIA_mEENSt3__110unique_ptrIT_NS0_14AlignedDeleterINS3_13remove_extentIS5_E4typeEEEEEm: 160| 5.60k|AlignedUniquePtr AlignedAllocTyped(size_t n_membs) { 161| 5.60k| using TU = typename std::remove_extent::type; 162| 5.60k| return AlignedUniquePtr( 163| 5.60k| static_cast(AlignedAlloc(alignof(TU), sizeof(TU) * n_membs))); 164| 5.60k|} _ZN8perfetto4base17AlignedAllocTypedIA_NS_15trace_processor10StringPool2IdEEENSt3__110unique_ptrIT_NS0_14AlignedDeleterINS6_13remove_extentIS8_E4typeEEEEEm: 160| 975|AlignedUniquePtr AlignedAllocTyped(size_t n_membs) { 161| 975| using TU = typename std::remove_extent::type; 162| 975| return AlignedUniquePtr( 163| 975| static_cast(AlignedAlloc(alignof(TU), sizeof(TU) * n_membs))); 164| 975|} _ZNK8perfetto4base14AlignedDeleterIjEclEPj: 149| 20.6k| inline void operator()(T* ptr) const { AlignedFree(ptr); } _ZN8perfetto4base17AlignedAllocTypedIA_jEENSt3__110unique_ptrIT_NS0_14AlignedDeleterINS3_13remove_extentIS5_E4typeEEEEEm: 160| 20.6k|AlignedUniquePtr AlignedAllocTyped(size_t n_membs) { 161| 20.6k| using TU = typename std::remove_extent::type; 162| 20.6k| return AlignedUniquePtr( 163| 20.6k| static_cast(AlignedAlloc(alignof(TU), sizeof(TU) * n_membs))); 164| 20.6k|} _ZNK8perfetto4base14AlignedDeleterINSt3__16vectorIjNS2_9allocatorIjEEEEEclEPS6_: 149| 4.53k| inline void operator()(T* ptr) const { AlignedFree(ptr); } _ZN8perfetto4base17AlignedAllocTypedIA_NSt3__16vectorIjNS2_9allocatorIjEEEEEENS2_10unique_ptrIT_NS0_14AlignedDeleterINS2_13remove_extentIS9_E4typeEEEEEm: 160| 4.53k|AlignedUniquePtr AlignedAllocTyped(size_t n_membs) { 161| 4.53k| using TU = typename std::remove_extent::type; 162| 4.53k| return AlignedUniquePtr( 163| 4.53k| static_cast(AlignedAlloc(alignof(TU), sizeof(TU) * n_membs))); 164| 4.53k|} _ZNK8perfetto4base14AlignedDeleterINSt3__110unique_ptrINS_15trace_processor19InternedMessageViewENS2_14default_deleteIS5_EEEEEclEPS8_: 149| 1.01k| inline void operator()(T* ptr) const { AlignedFree(ptr); } _ZN8perfetto4base17AlignedAllocTypedIA_NSt3__110unique_ptrINS_15trace_processor19InternedMessageViewENS2_14default_deleteIS5_EEEEEENS3_IT_NS0_14AlignedDeleterINS2_13remove_extentISA_E4typeEEEEEm: 160| 1.01k|AlignedUniquePtr AlignedAllocTyped(size_t n_membs) { 161| 1.01k| using TU = typename std::remove_extent::type; 162| 1.01k| return AlignedUniquePtr( 163| 1.01k| static_cast(AlignedAlloc(alignof(TU), sizeof(TU) * n_membs))); 164| 1.01k|} _ZNK8perfetto4base14AlignedDeleterINS_15trace_processor11TraceSorter16TimestampedEventEEclEPS4_: 149| 3.41k| inline void operator()(T* ptr) const { AlignedFree(ptr); } _ZN8perfetto4base17AlignedAllocTypedIA_NS_15trace_processor11TraceSorter16TimestampedEventEEENSt3__110unique_ptrIT_NS0_14AlignedDeleterINS6_13remove_extentIS8_E4typeEEEEEm: 160| 3.41k|AlignedUniquePtr AlignedAllocTyped(size_t n_membs) { 161| 3.41k| using TU = typename std::remove_extent::type; 162| 3.41k| return AlignedUniquePtr( 163| 3.41k| static_cast(AlignedAlloc(alignof(TU), sizeof(TU) * n_membs))); 164| 3.41k|} _ZNK8perfetto4base14AlignedDeleterINS_15trace_processor9TraceTypeEEclEPS3_: 149| 868| inline void operator()(T* ptr) const { AlignedFree(ptr); } _ZNK8perfetto4base14AlignedDeleterINSt3__18functionIFNS2_10unique_ptrINS_15trace_processor18ChunkedTraceReaderENS2_14default_deleteIS6_EEEEPNS5_21TraceProcessorContextEEEEEclEPSD_: 149| 868| inline void operator()(T* ptr) const { AlignedFree(ptr); } _ZN8perfetto4base17AlignedAllocTypedIA_NS_15trace_processor9TraceTypeEEENSt3__110unique_ptrIT_NS0_14AlignedDeleterINS5_13remove_extentIS7_E4typeEEEEEm: 160| 868|AlignedUniquePtr AlignedAllocTyped(size_t n_membs) { 161| 868| using TU = typename std::remove_extent::type; 162| 868| return AlignedUniquePtr( 163| 868| static_cast(AlignedAlloc(alignof(TU), sizeof(TU) * n_membs))); 164| 868|} _ZN8perfetto4base17AlignedAllocTypedIA_NSt3__18functionIFNS2_10unique_ptrINS_15trace_processor18ChunkedTraceReaderENS2_14default_deleteIS6_EEEEPNS5_21TraceProcessorContextEEEEEENS4_IT_NS0_14AlignedDeleterINS2_13remove_extentISF_E4typeEEEEEm: 160| 868|AlignedUniquePtr AlignedAllocTyped(size_t n_membs) { 161| 868| using TU = typename std::remove_extent::type; 162| 868| return AlignedUniquePtr( 163| 868| static_cast(AlignedAlloc(alignof(TU), sizeof(TU) * n_membs))); 164| 868|} _ZN8perfetto4base7AlignUpILm8EEEmm: 99| 1.08M|constexpr size_t AlignUp(size_t size) { 100| 1.08M| static_assert((alignment & (alignment - 1)) == 0, "alignment must be a pow2"); 101| 1.08M| return AlignUp(size, alignment); 102| 1.08M|} _ZN8perfetto4base17AlignedAllocTypedIA_NS_15trace_processor6tables10TrackTable2IdEEENSt3__110unique_ptrIT_NS0_14AlignedDeleterINS7_13remove_extentIS9_E4typeEEEEEm: 160| 2.12k|AlignedUniquePtr AlignedAllocTyped(size_t n_membs) { 161| 2.12k| using TU = typename std::remove_extent::type; 162| 2.12k| return AlignedUniquePtr( 163| 2.12k| static_cast(AlignedAlloc(alignof(TU), sizeof(TU) * n_membs))); 164| 2.12k|} _ZNK8perfetto4base14AlignedDeleterINS_15trace_processor6tables10TrackTable2IdEEclEPS5_: 149| 2.12k| inline void operator()(T* ptr) const { AlignedFree(ptr); } _ZN8perfetto4base17AlignedAllocTypedIA_NSt3__16vectorImNS2_9allocatorImEEEEEENS2_10unique_ptrIT_NS0_14AlignedDeleterINS2_13remove_extentIS9_E4typeEEEEEm: 160| 70|AlignedUniquePtr AlignedAllocTyped(size_t n_membs) { 161| 70| using TU = typename std::remove_extent::type; 162| 70| return AlignedUniquePtr( 163| 70| static_cast(AlignedAlloc(alignof(TU), sizeof(TU) * n_membs))); 164| 70|} _ZNK8perfetto4base14AlignedDeleterINSt3__16vectorImNS2_9allocatorImEEEEEclEPS6_: 149| 70| inline void operator()(T* ptr) const { AlignedFree(ptr); } _ZN8perfetto4base17AlignedAllocTypedIA_NS_15trace_processor6tables10SliceTable2IdEEENSt3__110unique_ptrIT_NS0_14AlignedDeleterINS7_13remove_extentIS9_E4typeEEEEEm: 160| 179|AlignedUniquePtr AlignedAllocTyped(size_t n_membs) { 161| 179| using TU = typename std::remove_extent::type; 162| 179| return AlignedUniquePtr( 163| 179| static_cast(AlignedAlloc(alignof(TU), sizeof(TU) * n_membs))); 164| 179|} _ZNK8perfetto4base14AlignedDeleterINS_15trace_processor6tables10SliceTable2IdEEclEPS5_: 149| 179| inline void operator()(T* ptr) const { AlignedFree(ptr); } _ZN8perfetto4base17AlignedAllocTypedIA_NS_15trace_processor11FlowTracker8V1FlowIdEEENSt3__110unique_ptrIT_NS0_14AlignedDeleterINS6_13remove_extentIS8_E4typeEEEEEm: 160| 362|AlignedUniquePtr AlignedAllocTyped(size_t n_membs) { 161| 362| using TU = typename std::remove_extent::type; 162| 362| return AlignedUniquePtr( 163| 362| static_cast(AlignedAlloc(alignof(TU), sizeof(TU) * n_membs))); 164| 362|} _ZNK8perfetto4base14AlignedDeleterINS_15trace_processor11FlowTracker8V1FlowIdEEclEPS4_: 149| 362| inline void operator()(T* ptr) const { AlignedFree(ptr); } _ZN8perfetto4base17AlignedAllocTypedIA_NS_15trace_processor12SliceTracker9TrackInfoEEENSt3__110unique_ptrIT_NS0_14AlignedDeleterINS6_13remove_extentIS8_E4typeEEEEEm: 160| 1.12k|AlignedUniquePtr AlignedAllocTyped(size_t n_membs) { 161| 1.12k| using TU = typename std::remove_extent::type; 162| 1.12k| return AlignedUniquePtr( 163| 1.12k| static_cast(AlignedAlloc(alignof(TU), sizeof(TU) * n_membs))); 164| 1.12k|} _ZNK8perfetto4base14AlignedDeleterINS_15trace_processor12SliceTracker9TrackInfoEEclEPS4_: 149| 1.12k| inline void operator()(T* ptr) const { AlignedFree(ptr); } _ZN8perfetto4base17AlignedAllocTypedIA_NS_15trace_processor28ActiveChromeProcessesTracker11ProcessDataEEENSt3__110unique_ptrIT_NS0_14AlignedDeleterINS6_13remove_extentIS8_E4typeEEEEEm: 160| 439|AlignedUniquePtr AlignedAllocTyped(size_t n_membs) { 161| 439| using TU = typename std::remove_extent::type; 162| 439| return AlignedUniquePtr( 163| 439| static_cast(AlignedAlloc(alignof(TU), sizeof(TU) * n_membs))); 164| 439|} _ZNK8perfetto4base14AlignedDeleterINS_15trace_processor28ActiveChromeProcessesTracker11ProcessDataEEclEPS4_: 149| 439| inline void operator()(T* ptr) const { AlignedFree(ptr); } chrome_string_lookup.cc:_ZN8perfetto4base9ArraySizeINS_15trace_processor12_GLOBAL__N_111ProcessNameELm41EEEmRAT0__KT_: 70| 85.5k|constexpr size_t ArraySize(const T (&)[TSize]) { 71| 85.5k| return TSize; 72| 85.5k|} chrome_string_lookup.cc:_ZN8perfetto4base9ArraySizeINS_15trace_processor12_GLOBAL__N_110ThreadNameELm45EEEmRAT0__KT_: 70| 93.7k|constexpr size_t ArraySize(const T (&)[TSize]) { 71| 93.7k| return TSize; 72| 93.7k|} _ZN8perfetto4base17AlignedAllocTypedIA_NS_15trace_processor24MultiMachineTraceManager20RemoteMachineContextEEENSt3__110unique_ptrIT_NS0_14AlignedDeleterINS6_13remove_extentIS8_E4typeEEEEEm: 160| 24|AlignedUniquePtr AlignedAllocTyped(size_t n_membs) { 161| 24| using TU = typename std::remove_extent::type; 162| 24| return AlignedUniquePtr( 163| 24| static_cast(AlignedAlloc(alignof(TU), sizeof(TU) * n_membs))); 164| 24|} _ZNK8perfetto4base14AlignedDeleterINS_15trace_processor24MultiMachineTraceManager20RemoteMachineContextEEclEPS4_: 149| 24| inline void operator()(T* ptr) const { AlignedFree(ptr); } _ZNK8perfetto4base14AlignedDeleterINS_15trace_processor4util19TraceBlobViewReader5EntryEEclEPS5_: 149| 2.02k| inline void operator()(T* ptr) const { AlignedFree(ptr); } _ZN8perfetto4base17AlignedAllocTypedIA_NS_15trace_processor16ProtoTraceReader19SequenceScopedStateEEENSt3__110unique_ptrIT_NS0_14AlignedDeleterINS6_13remove_extentIS8_E4typeEEEEEm: 160| 4.07k|AlignedUniquePtr AlignedAllocTyped(size_t n_membs) { 161| 4.07k| using TU = typename std::remove_extent::type; 162| 4.07k| return AlignedUniquePtr( 163| 4.07k| static_cast(AlignedAlloc(alignof(TU), sizeof(TU) * n_membs))); 164| 4.07k|} _ZNK8perfetto4base14AlignedDeleterINS_15trace_processor16ProtoTraceReader19SequenceScopedStateEEclEPS4_: 149| 4.07k| inline void operator()(T* ptr) const { AlignedFree(ptr); } _ZN8perfetto4base17AlignedAllocTypedIA_NS_15trace_processor4util19TraceBlobViewReader5EntryEEENSt3__110unique_ptrIT_NS0_14AlignedDeleterINS7_13remove_extentIS9_E4typeEEEEEm: 160| 2.02k|AlignedUniquePtr AlignedAllocTyped(size_t n_membs) { 161| 2.02k| using TU = typename std::remove_extent::type; 162| 2.02k| return AlignedUniquePtr( 163| 2.02k| static_cast(AlignedAlloc(alignof(TU), sizeof(TU) * n_membs))); 164| 2.02k|} _ZN8perfetto4base17AlignedAllocTypedIA_NS_15trace_processor17TrackEventTracker23ResolvedDescriptorTrackEEENSt3__110unique_ptrIT_NS0_14AlignedDeleterINS6_13remove_extentIS8_E4typeEEEEEm: 160| 794|AlignedUniquePtr AlignedAllocTyped(size_t n_membs) { 161| 794| using TU = typename std::remove_extent::type; 162| 794| return AlignedUniquePtr( 163| 794| static_cast(AlignedAlloc(alignof(TU), sizeof(TU) * n_membs))); 164| 794|} _ZNK8perfetto4base14AlignedDeleterINS_15trace_processor17TrackEventTracker23ResolvedDescriptorTrackEEclEPS4_: 149| 794| inline void operator()(T* ptr) const { AlignedFree(ptr); } _ZN8perfetto4base17AlignedAllocTypedIA_NS_15trace_processor17TrackEventTracker26DescriptorTrackReservationEEENSt3__110unique_ptrIT_NS0_14AlignedDeleterINS6_13remove_extentIS8_E4typeEEEEEm: 160| 823|AlignedUniquePtr AlignedAllocTyped(size_t n_membs) { 161| 823| using TU = typename std::remove_extent::type; 162| 823| return AlignedUniquePtr( 163| 823| static_cast(AlignedAlloc(alignof(TU), sizeof(TU) * n_membs))); 164| 823|} _ZNK8perfetto4base14AlignedDeleterINS_15trace_processor17TrackEventTracker26DescriptorTrackReservationEEclEPS4_: 149| 823| inline void operator()(T* ptr) const { AlignedFree(ptr); } _ZN8perfetto4base17AlignedAllocTypedIA_NSt3__16vectorINS_15trace_processor16TraceTokenBuffer14BlobWithOffsetENS2_9allocatorIS6_EEEEEENS2_10unique_ptrIT_NS0_14AlignedDeleterINS2_13remove_extentISC_E4typeEEEEEm: 160| 424|AlignedUniquePtr AlignedAllocTyped(size_t n_membs) { 161| 424| using TU = typename std::remove_extent::type; 162| 424| return AlignedUniquePtr( 163| 424| static_cast(AlignedAlloc(alignof(TU), sizeof(TU) * n_membs))); 164| 424|} _ZNK8perfetto4base14AlignedDeleterINSt3__16vectorINS_15trace_processor16TraceTokenBuffer14BlobWithOffsetENS2_9allocatorIS6_EEEEEclEPS9_: 149| 424| inline void operator()(T* ptr) const { AlignedFree(ptr); } _ZN8perfetto4base17AlignedAllocTypedIA_NSt3__16vectorIPNS_15trace_processor29PacketSequenceStateGenerationENS2_9allocatorIS6_EEEEEENS2_10unique_ptrIT_NS0_14AlignedDeleterINS2_13remove_extentISC_E4typeEEEEEm: 160| 424|AlignedUniquePtr AlignedAllocTyped(size_t n_membs) { 161| 424| using TU = typename std::remove_extent::type; 162| 424| return AlignedUniquePtr( 163| 424| static_cast(AlignedAlloc(alignof(TU), sizeof(TU) * n_membs))); 164| 424|} _ZNK8perfetto4base14AlignedDeleterINSt3__16vectorIPNS_15trace_processor29PacketSequenceStateGenerationENS2_9allocatorIS6_EEEEEclEPS9_: 149| 424| inline void operator()(T* ptr) const { AlignedFree(ptr); } _ZNK8perfetto4base14AlignedDeleterIhEclEPh: 149| 2.18k| inline void operator()(T* ptr) const { AlignedFree(ptr); } _ZN8perfetto4base17AlignedAllocTypedIA_NS_15trace_processor13BumpAllocator5ChunkEEENSt3__110unique_ptrIT_NS0_14AlignedDeleterINS6_13remove_extentIS8_E4typeEEEEEm: 160| 424|AlignedUniquePtr AlignedAllocTyped(size_t n_membs) { 161| 424| using TU = typename std::remove_extent::type; 162| 424| return AlignedUniquePtr( 163| 424| static_cast(AlignedAlloc(alignof(TU), sizeof(TU) * n_membs))); 164| 424|} _ZNK8perfetto4base14AlignedDeleterINS_15trace_processor13BumpAllocator5ChunkEEclEPS4_: 149| 424| inline void operator()(T* ptr) const { AlignedFree(ptr); } _ZN8perfetto4base4Uuid11set_lsb_msbEll: 57| 434| void set_lsb_msb(int64_t lsb, int64_t msb) { 58| 434| set_lsb(lsb); 59| 434| set_msb(msb); 60| 434| } _ZN8perfetto4base4Uuid7set_msbEl: 61| 434| void set_msb(int64_t msb) { memcpy(data_.data() + 8, &msb, 8); } _ZN8perfetto4base4Uuid7set_lsbEl: 62| 434| void set_lsb(int64_t lsb) { memcpy(data_.data(), &lsb, 8); } _ZNK8perfetto15trace_processor15GlobalNodeGraph7Process4rootEv: 67| 259k| GlobalNodeGraph::Node* root() const { return root_; } _ZN8perfetto15trace_processor15GlobalNodeGraph4Node8set_weakEb: 142| 10.6k| void set_weak(bool weak) { weak_ = weak; } _ZN8perfetto15trace_processor15GlobalNodeGraph4Node12set_explicitEb: 144| 10.6k| void set_explicit(bool explicit_node) { explicit_ = explicit_node; } _ZN8perfetto15trace_processor15GlobalNodeGraph4Node6set_idENS0_21MemoryAllocatorNodeIdE: 175| 10.6k| void set_id(MemoryAllocatorNodeId id) { id_ = id; } _ZNK8perfetto15trace_processor15GlobalNodeGraph7Process12global_graphEv: 66| 31| GlobalNodeGraph* global_graph() const { return global_graph_; } _ZNK8perfetto15trace_processor15GlobalNodeGraph4Node6parentEv: 184| 59.5k| const Node* parent() const { return parent_; } _ZNK8perfetto15trace_processor15GlobalNodeGraph4Node9owns_edgeEv: 176| 60.1k| GlobalNodeGraph::Edge* owns_edge() const { return owns_edge_; } _ZNK8perfetto15trace_processor15GlobalNodeGraph4Edge6targetEv: 222| 1.22k| GlobalNodeGraph::Node* target() const { return target_; } _ZN8perfetto15trace_processor15GlobalNodeGraph4Node8childrenEv: 177| 608k| std::map* children() { return &children_; } _ZN8perfetto15trace_processor15GlobalNodeGraph4Node14owned_by_edgesEv: 181| 647k| std::vector* owned_by_edges() { 182| 647k| return &owned_by_edges_; 183| 647k| } _ZNK8perfetto15trace_processor15GlobalNodeGraph4Edge6sourceEv: 221| 303k| GlobalNodeGraph::Node* source() const { return source_; } _ZNK8perfetto15trace_processor15GlobalNodeGraph4Node18not_owned_sub_sizeEv: 145| 3.98k| uint64_t not_owned_sub_size() const { return not_owned_sub_size_; } _ZN8perfetto15trace_processor15GlobalNodeGraph4Node22add_not_owned_sub_sizeEm: 146| 4.06k| void add_not_owned_sub_size(uint64_t addition) { 147| 4.06k| not_owned_sub_size_ += addition; 148| 4.06k| } _ZNK8perfetto15trace_processor15GlobalNodeGraph4Node19not_owning_sub_sizeEv: 149| 92.4k| uint64_t not_owning_sub_size() const { return not_owning_sub_size_; } _ZN8perfetto15trace_processor15GlobalNodeGraph4Node23add_not_owning_sub_sizeEm: 150| 4.03k| void add_not_owning_sub_size(uint64_t addition) { 151| 4.03k| not_owning_sub_size_ += addition; 152| 4.03k| } _ZNK8perfetto15trace_processor15GlobalNodeGraph4Node17owned_coefficientEv: 153| 3.82k| double owned_coefficient() const { return owned_coefficient_; } _ZN8perfetto15trace_processor15GlobalNodeGraph4Node21set_owned_coefficientEd: 154| 242| void set_owned_coefficient(double owned_coefficient) { 155| 242| owned_coefficient_ = owned_coefficient; 156| 242| } _ZNK8perfetto15trace_processor15GlobalNodeGraph4Node18owning_coefficientEv: 157| 11| double owning_coefficient() const { return owning_coefficient_; } _ZN8perfetto15trace_processor15GlobalNodeGraph4Node22set_owning_coefficientEd: 158| 30.2k| void set_owning_coefficient(double owning_coefficient) { 159| 30.2k| owning_coefficient_ = owning_coefficient; 160| 30.2k| } _ZNK8perfetto15trace_processor15GlobalNodeGraph4Node28cumulative_owned_coefficientEv: 161| 907| double cumulative_owned_coefficient() const { 162| 907| return cumulative_owned_coefficient_; 163| 907| } _ZN8perfetto15trace_processor15GlobalNodeGraph4Node32set_cumulative_owned_coefficientEd: 164| 3.82k| void set_cumulative_owned_coefficient(double cumulative_owned_coefficient) { 165| 3.82k| cumulative_owned_coefficient_ = cumulative_owned_coefficient; 166| 3.82k| } _ZNK8perfetto15trace_processor15GlobalNodeGraph4Node29cumulative_owning_coefficientEv: 167| 907| double cumulative_owning_coefficient() const { 168| 907| return cumulative_owning_coefficient_; 169| 907| } _ZN8perfetto15trace_processor15GlobalNodeGraph4Node33set_cumulative_owning_coefficientEd: 171| 3.82k| double cumulative_owning_coefficient) { 172| 3.82k| cumulative_owning_coefficient_ = cumulative_owning_coefficient; 173| 3.82k| } _ZNK8perfetto15trace_processor15GlobalNodeGraph4Node2idEv: 174| 35.0k| MemoryAllocatorNodeId id() const { return id_; } _ZN8perfetto15trace_processor15GlobalNodeGraph4Node7entriesEv: 186| 637k| std::map* entries() { return &entries_; } _ZNK8perfetto15trace_processor15GlobalNodeGraph4Node13const_entriesEv: 187| 3.77k| const std::map& const_entries() const { 188| 3.77k| return entries_; 189| 3.77k| } _ZNK8perfetto15trace_processor15GlobalNodeGraph4Edge8priorityEv: 223| 878k| int priority() const { return priority_; } _ZNK8perfetto15trace_processor15GlobalNodeGraph11nodes_by_idEv: 289| 69.6k| const IdNodeMap& nodes_by_id() const { return nodes_by_id_; } _ZNK8perfetto15trace_processor15GlobalNodeGraph19shared_memory_graphEv: 290| 770| GlobalNodeGraph::Process* shared_memory_graph() const { 291| 770| return shared_memory_graph_.get(); 292| 770| } _ZNK8perfetto15trace_processor15GlobalNodeGraph19process_node_graphsEv: 293| 641| const ProcessNodeGraphMap& process_node_graphs() const { 294| 641| return process_node_graphs_; 295| 641| } _ZNK8perfetto15trace_processor15GlobalNodeGraph5edgesEv: 296| 641| const std::forward_list& edges() const { return all_edges_; } _ZNK8perfetto15trace_processor21MemoryAllocatorNodeId5emptyEv: 39| 10.6k| bool empty() const { return id_ == 0u; } _ZNK8perfetto15trace_processor21MemoryAllocatorNodeIdltERKS1_: 49| 258k| bool operator<(const MemoryAllocatorNodeId& other) const { 50| 258k| return id_ < other.id_; 51| 258k| } _ZN8perfetto15trace_processor15MemoryGraphEdgeC2ENS0_21MemoryAllocatorNodeIdES2_ib: 34| 54.3k| : source(s), target(t), importance(i), overridable(o) {} _ZNK8perfetto15trace_processor18RawMemoryGraphNode2idEv: 120| 24.1k| MemoryAllocatorNodeId id() const { return id_; } _ZNK8perfetto15trace_processor18RawMemoryGraphNode5flagsEv: 132| 10.6k| int flags() const { return flags_; } _ZNK8perfetto15trace_processor18RawMemoryGraphNode7entriesEv: 125| 13.5k| const std::vector& entries() const { return entries_; } _ZN8perfetto15trace_processor18RawMemoryGraphNode9set_flagsEi: 130| 38.5k| void set_flags(int flags) { flags_ |= flags; } _ZNK8perfetto15trace_processor20RawProcessMemoryNode15allocator_nodesEv: 61| 42.6k| const MemoryNodesMap& allocator_nodes() const { return allocator_nodes_; } _ZNK8perfetto15trace_processor20RawProcessMemoryNode21allocator_nodes_edgesEv: 63| 42.6k| const AllocatorNodeEdgesMap& allocator_nodes_edges() const { 64| 42.6k| return allocator_nodes_edges_; 65| 42.6k| } _ZNK9protozero10ConstChars11ToStdStringEv: 46| 2.15M| std::string ToStdString() const { return {data, size}; } _ZNK9protozero5Field5validEv: 61| 250M| bool valid() const { return id_ != 0; } _ZNK9protozero5Field2idEv: 62| 133M| uint32_t id() const { return id_; } _ZNK9protozero5FieldcvbEv: 63| 123k| explicit operator bool() const { return valid(); } _ZNK9protozero5Field7as_boolEv: 74| 16.1M| bool as_bool() const { 75| 16.1M| PERFETTO_DCHECK(!valid() || type() == proto_utils::ProtoWireType::kVarInt); 76| 16.1M| return static_cast(int_value_); 77| 16.1M| } _ZNK9protozero5Field9as_uint32Ev: 79| 19.6M| uint32_t as_uint32() const { 80| 19.6M| PERFETTO_DCHECK(!valid() || type() == proto_utils::ProtoWireType::kVarInt || 81| 19.6M| type() == proto_utils::ProtoWireType::kFixed32); 82| 19.6M| return static_cast(int_value_); 83| 19.6M| } _ZNK9protozero5Field8as_int32Ev: 85| 14.6M| int32_t as_int32() const { 86| 14.6M| PERFETTO_DCHECK(!valid() || type() == proto_utils::ProtoWireType::kVarInt || 87| 14.6M| type() == proto_utils::ProtoWireType::kFixed32); 88| 14.6M| return static_cast(int_value_); 89| 14.6M| } _ZNK9protozero5Field9as_uint64Ev: 96| 14.9M| uint64_t as_uint64() const { 97| 14.9M| PERFETTO_DCHECK(!valid() || type() == proto_utils::ProtoWireType::kVarInt || 98| 14.9M| type() == proto_utils::ProtoWireType::kFixed32 || 99| 14.9M| type() == proto_utils::ProtoWireType::kFixed64); 100| 14.9M| return int_value_; 101| 14.9M| } _ZNK9protozero5Field8as_int64Ev: 103| 1.14M| int64_t as_int64() const { 104| 1.14M| PERFETTO_DCHECK(!valid() || type() == proto_utils::ProtoWireType::kVarInt || 105| 1.14M| type() == proto_utils::ProtoWireType::kFixed32 || 106| 1.14M| type() == proto_utils::ProtoWireType::kFixed64); 107| 1.14M| return static_cast(int_value_); 108| 1.14M| } _ZNK9protozero5Field8as_floatEv: 115| 10| float as_float() const { 116| 10| PERFETTO_DCHECK(!valid() || type() == proto_utils::ProtoWireType::kFixed32); 117| 10| float res; 118| 10| uint32_t value32 = static_cast(int_value_); 119| 10| memcpy(&res, &value32, sizeof(res)); 120| 10| return res; 121| 10| } _ZNK9protozero5Field9as_doubleEv: 123| 7| double as_double() const { 124| 7| PERFETTO_DCHECK(!valid() || type() == proto_utils::ProtoWireType::kFixed64); 125| 7| double res; 126| 7| memcpy(&res, &int_value_, sizeof(res)); 127| 7| return res; 128| 7| } _ZNK9protozero5Field9as_stringEv: 130| 14.6M| ConstChars as_string() const { 131| 14.6M| PERFETTO_DCHECK(!valid() || 132| 14.6M| type() == proto_utils::ProtoWireType::kLengthDelimited); 133| 14.6M| return ConstChars{reinterpret_cast(data()), size_}; 134| 14.6M| } _ZNK9protozero5Field8as_bytesEv: 138| 21.4M| ConstBytes as_bytes() const { 139| 21.4M| PERFETTO_DCHECK(!valid() || 140| 21.4M| type() == proto_utils::ProtoWireType::kLengthDelimited); 141| 21.4M| return ConstBytes{data(), size_}; 142| 21.4M| } _ZNK9protozero5Field4dataEv: 144| 37.9M| const uint8_t* data() const { 145| 37.9M| PERFETTO_DCHECK(!valid() || 146| 37.9M| type() == proto_utils::ProtoWireType::kLengthDelimited); 147| 37.9M| return reinterpret_cast(int_value_); 148| 37.9M| } _ZNK9protozero5Field4sizeEv: 150| 1.85M| size_t size() const { 151| 1.85M| PERFETTO_DCHECK(!valid() || 152| 1.85M| type() == proto_utils::ProtoWireType::kLengthDelimited); 153| 1.85M| return size_; 154| 1.85M| } _ZN9protozero5Field10initializeEjhmj: 161| 96.9M| uint32_t size) { 162| 96.9M| id_ = id & kMaxId; 163| 96.9M| type_ = type; 164| 96.9M| int_value_ = int_value; 165| 96.9M| size_ = size; 166| 96.9M| } _ZNK9protozero5Field3getEPi: 171| 397k| void get(int32_t* val) const { *val = as_int32(); } _ZNK9protozero5Field3getEPm: 172| 36.8k| void get(uint64_t* val) const { *val = as_uint64(); } _ZNK9protozero5Field3getEPl: 173| 2.17k| void get(int64_t* val) const { *val = as_int64(); } _ZNK9protozero5Field3getEPNS_10ConstCharsE: 177| 272k| void get(ConstChars* val) const { *val = as_string(); } _ZNK9protozero5Field3getEPNS_10ConstBytesE: 178| 9.01M| void get(ConstBytes* val) const { *val = as_bytes(); } _ZN9protozero12ProtoDecoderC2EPKvm: 47| 32.8M| : begin_(reinterpret_cast(buffer)), 48| 32.8M| end_(begin_ + length), 49| 32.8M| read_ptr_(begin_) {} _ZN9protozero12ProtoDecoderC2ERKNS_10ConstBytesE: 51| 1.29M| ProtoDecoder(const ConstBytes& cb) : ProtoDecoder(cb.data, cb.size) {} _ZNK9protozero12ProtoDecoder10bytes_leftEv: 73| 3.98M| size_t bytes_left() const { 74| 3.98M| PERFETTO_DCHECK(read_ptr_ <= end_); 75| 3.98M| return static_cast(end_ - read_ptr_); 76| 3.98M| } _ZNK9protozero21TypedProtoDecoderBase3GetEj: 286| 52.1M| const Field& Get(uint32_t id) const { 287| 52.1M| if (PERFETTO_LIKELY(id < num_fields_ && id < size_)) ------------------ | | 23| 104M|#define PERFETTO_LIKELY(...) __builtin_expect(!!(__VA_ARGS__), 1) | | ------------------ | | | Branch (23:30): [True: 48.7M, False: 3.43M] | | | Branch (23:50): [True: 52.1M, False: 0] | | | Branch (23:50): [True: 48.7M, False: 3.43M] | | ------------------ ------------------ 288| 48.7M| return fields_[id]; 289| | // If id >= num_fields_, the field id is invalid (was not known in the 290| | // .proto) and we return the 0th field, which is always !valid(). 291| | // If id >= size_ and <= num_fields, the id is valid but the field has not 292| | // been seen while decoding (hence the stack storage has not been expanded) 293| | // so we return the 0th invalid field. 294| 3.43M| return fields_[0]; 295| 52.1M| } _ZN9protozero21TypedProtoDecoderBaseC2EPNS_5FieldEjjPKhm: 358| 31.4M| : ProtoDecoder(buffer, length), 359| 31.4M| fields_(storage), 360| 31.4M| num_fields_(num_fields), 361| | // The reason for "capacity -1" is to avoid hitting the expansion path 362| | // in TypedProtoDecoderBase::ParseAllFields() when we are just setting 363| | // fields < INITIAL_STACK_CAPACITY (which is the most common case). 364| 31.4M| size_(std::min(num_fields, capacity - 1)), 365| 31.4M| capacity_(capacity) { 366| | // The reason why Field needs to be trivially de/constructible is to avoid 367| | // implicit initializers on all the ~1000 entries. We need it to initialize 368| | // only on the first |max_field_id| fields, the remaining capacity doesn't 369| | // require initialization. 370| 31.4M| static_assert(std::is_trivially_constructible::value && 371| 31.4M| std::is_trivially_destructible::value && 372| 31.4M| std::is_trivial::value, 373| 31.4M| "Field must be a trivial aggregate type"); 374| 31.4M| memset(fields_, 0, sizeof(Field) * capacity_); 375| 31.4M| PERFETTO_DCHECK(capacity > 0); 376| 31.4M| } _ZNK9protozero17TypedProtoDecoderILi8ELb0EE2atILj1EEERKNS_5FieldEv: 439| 34.8k| const Field& at() const { 440| 34.8k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 34.8k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 34.8k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 34.8k| return fields_[FIELD_ID]; 447| 34.8k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 34.8k| } _ZNK9protozero17TypedProtoDecoderILi8ELb0EE2atILj2EEERKNS_5FieldEv: 439| 24.5k| const Field& at() const { 440| 24.5k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 24.5k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 24.5k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 24.5k| return fields_[FIELD_ID]; 447| 24.5k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 24.5k| } _ZNK9protozero17TypedProtoDecoderILi8ELb0EE2atILj5EEERKNS_5FieldEv: 439| 5.79k| const Field& at() const { 440| 5.79k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 5.79k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 5.79k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 5.79k| return fields_[FIELD_ID]; 447| 5.79k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 5.79k| } _ZNK9protozero17TypedProtoDecoderILi8ELb0EE2atILj4EEERKNS_5FieldEv: 439| 5.32k| const Field& at() const { 440| 5.32k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 5.32k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 5.32k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 5.32k| return fields_[FIELD_ID]; 447| 5.32k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 5.32k| } _ZNK9protozero17TypedProtoDecoderILi8ELb0EE2atILj6EEERKNS_5FieldEv: 439| 2.06k| const Field& at() const { 440| 2.06k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 2.06k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 2.06k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 2.06k| return fields_[FIELD_ID]; 447| 2.06k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 2.06k| } _ZNK9protozero17TypedProtoDecoderILi8ELb0EE2atILj7EEERKNS_5FieldEv: 439| 2.06k| const Field& at() const { 440| 2.06k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 2.06k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 2.06k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 2.06k| return fields_[FIELD_ID]; 447| 2.06k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 2.06k| } _ZNK9protozero17TypedProtoDecoderILi8ELb0EE2atILj8EEERKNS_5FieldEv: 439| 2.06k| const Field& at() const { 440| 2.06k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 2.06k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 2.06k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 2.06k| return fields_[FIELD_ID]; 447| 2.06k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 2.06k| } _ZNK9protozero17TypedProtoDecoderILi99ELb0EE2atILj58EEERKNS_5FieldEv: 439| 51.0k| const Field& at() const { 440| 51.0k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 51.0k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 51.0k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 51.0k| return fields_[FIELD_ID]; 447| 51.0k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 51.0k| } _ZNK9protozero17TypedProtoDecoderILi99ELb0EE2atILj11EEERKNS_5FieldEv: 439| 506| const Field& at() const { 440| 506| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 506| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 506|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 506| return fields_[FIELD_ID]; 447| 506| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 506| } _ZNK9protozero17TypedProtoDecoderILi2ELb0EE2atILj1EEERKNS_5FieldEv: 439| 3.17M| const Field& at() const { 440| 3.17M| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 3.17M| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 3.17M|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 3.17M| return fields_[FIELD_ID]; 447| 3.17M| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 3.17M| } _ZNK9protozero17TypedProtoDecoderILi2ELb0EE2atILj2EEERKNS_5FieldEv: 439| 3.17M| const Field& at() const { 440| 3.17M| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 3.17M| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 3.17M|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 3.17M| return fields_[FIELD_ID]; 447| 3.17M| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 3.17M| } _ZNK9protozero17TypedProtoDecoderILi45ELb1EE2atILj11EEERKNS_5FieldEv: 439| 84.9k| const Field& at() const { 440| 84.9k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 84.9k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 84.9k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 84.9k| return fields_[FIELD_ID]; 447| 84.9k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 84.9k| } _ZNK9protozero21TypedProtoDecoderBase11GetRepeatedImEENS_21RepeatedFieldIteratorIT_EEj: 301| 2.87M| RepeatedFieldIterator GetRepeated(uint32_t field_id) const { 302| 2.87M| const Field* repeated_begin; 303| | // The storage for repeated fields starts after the slot for the highest 304| | // field id (refer to the diagram in the class-level comment). However, if 305| | // a message has more than INITIAL_STACK_CAPACITY field there will be no 306| | // slots available for the repeated fields (if ExpandHeapStorage() was not 307| | // called). Imagine a message that has highest field id = 102 and that is 308| | // still using the stack: 309| | // [ F0 ] [ F1 ] ... [ F100 ] [ F101 ] [ F1012] [ repeated fields ] 310| | // ^ num_fields_ 311| | // ^ size (== capacity) 312| 2.87M| if (PERFETTO_LIKELY(num_fields_ < size_)) { ------------------ | | 23| 2.87M|#define PERFETTO_LIKELY(...) __builtin_expect(!!(__VA_ARGS__), 1) | | ------------------ | | | Branch (23:30): [True: 2.05M, False: 826k] | | ------------------ ------------------ 313| 2.05M| repeated_begin = &fields_[num_fields_]; 314| 2.05M| } else { 315| | // This is the case of not having any storage space for repeated fields. 316| | // This makes it so begin == end, so the iterator will just skip @ last. 317| 826k| repeated_begin = &fields_[size_]; 318| 826k| } 319| 2.87M| const Field* repeated_end = &fields_[size_]; 320| 2.87M| const Field* last = &Get(field_id); 321| 2.87M| return RepeatedFieldIterator(field_id, repeated_begin, repeated_end, 322| 2.87M| last); 323| 2.87M| } _ZN9protozero21RepeatedFieldIteratorImE18FindNextMatchingIdEv: 144| 2.88M| void FindNextMatchingId() { 145| 2.88M| PERFETTO_DCHECK(iter_ != last_); 146| 5.65M| for (; iter_ != end_; ++iter_) { ------------------ | Branch (146:12): [True: 2.77M, False: 2.87M] ------------------ 147| 2.77M| if (iter_->id() == field_id_) ------------------ | Branch (147:11): [True: 9.67k, False: 2.76M] ------------------ 148| 9.67k| return; 149| 2.77M| } 150| 2.87M| iter_ = last_->valid() ? last_ : end_; ------------------ | Branch (150:13): [True: 25.0k, False: 2.85M] ------------------ 151| 2.87M| } _ZNK9protozero21TypedProtoDecoderBase11GetRepeatedINS_10ConstCharsEEENS_21RepeatedFieldIteratorIT_EEj: 301| 966k| RepeatedFieldIterator GetRepeated(uint32_t field_id) const { 302| 966k| const Field* repeated_begin; 303| | // The storage for repeated fields starts after the slot for the highest 304| | // field id (refer to the diagram in the class-level comment). However, if 305| | // a message has more than INITIAL_STACK_CAPACITY field there will be no 306| | // slots available for the repeated fields (if ExpandHeapStorage() was not 307| | // called). Imagine a message that has highest field id = 102 and that is 308| | // still using the stack: 309| | // [ F0 ] [ F1 ] ... [ F100 ] [ F101 ] [ F1012] [ repeated fields ] 310| | // ^ num_fields_ 311| | // ^ size (== capacity) 312| 966k| if (PERFETTO_LIKELY(num_fields_ < size_)) { ------------------ | | 23| 966k|#define PERFETTO_LIKELY(...) __builtin_expect(!!(__VA_ARGS__), 1) | | ------------------ | | | Branch (23:30): [True: 737k, False: 228k] | | ------------------ ------------------ 313| 737k| repeated_begin = &fields_[num_fields_]; 314| 737k| } else { 315| | // This is the case of not having any storage space for repeated fields. 316| | // This makes it so begin == end, so the iterator will just skip @ last. 317| 228k| repeated_begin = &fields_[size_]; 318| 228k| } 319| 966k| const Field* repeated_end = &fields_[size_]; 320| 966k| const Field* last = &Get(field_id); 321| 966k| return RepeatedFieldIterator(field_id, repeated_begin, repeated_end, 322| 966k| last); 323| 966k| } _ZN9protozero21RepeatedFieldIteratorINS_10ConstCharsEE18FindNextMatchingIdEv: 144| 1.06M| void FindNextMatchingId() { 145| 1.06M| PERFETTO_DCHECK(iter_ != last_); 146| 2.99M| for (; iter_ != end_; ++iter_) { ------------------ | Branch (146:12): [True: 2.02M, False: 966k] ------------------ 147| 2.02M| if (iter_->id() == field_id_) ------------------ | Branch (147:11): [True: 99.9k, False: 1.92M] ------------------ 148| 99.9k| return; 149| 2.02M| } 150| 966k| iter_ = last_->valid() ? last_ : end_; ------------------ | Branch (150:13): [True: 102k, False: 863k] ------------------ 151| 966k| } _ZNK9protozero17TypedProtoDecoderILi50ELb1EE2atILj10EEERKNS_5FieldEv: 439| 840k| const Field& at() const { 440| 840k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 840k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 840k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 840k| return fields_[FIELD_ID]; 447| 840k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 840k| } _ZNK9protozero17TypedProtoDecoderILi50ELb1EE2atILj23EEERKNS_5FieldEv: 439| 826k| const Field& at() const { 440| 826k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 826k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 826k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 826k| return fields_[FIELD_ID]; 447| 826k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 826k| } _ZNK9protozero17TypedProtoDecoderILi50ELb1EE2atILj9EEERKNS_5FieldEv: 439| 3.31M| const Field& at() const { 440| 3.31M| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 3.31M| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 3.31M|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 3.31M| return fields_[FIELD_ID]; 447| 3.31M| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 3.31M| } _ZNK9protozero17TypedProtoDecoderILi50ELb1EE2atILj11EEERKNS_5FieldEv: 439| 1.63M| const Field& at() const { 440| 1.63M| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 1.63M| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 1.63M|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 1.63M| return fields_[FIELD_ID]; 447| 1.63M| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 1.63M| } _ZNK9protozero17TypedProtoDecoderILi50ELb1EE2atILj30EEERKNS_5FieldEv: 439| 1| const Field& at() const { 440| 1| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 1| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 1|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 1| return fields_[FIELD_ID]; 447| 1| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 1| } _ZNK9protozero17TypedProtoDecoderILi50ELb1EE2atILj44EEERKNS_5FieldEv: 439| 1| const Field& at() const { 440| 1| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 1| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 1|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 1| return fields_[FIELD_ID]; 447| 1| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 1| } _ZNK9protozero17TypedProtoDecoderILi50ELb1EE2atILj12EEERKNS_5FieldEv: 439| 831k| const Field& at() const { 440| 831k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 831k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 831k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 831k| return fields_[FIELD_ID]; 447| 831k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 831k| } _ZNK9protozero21TypedProtoDecoderBase11GetRepeatedIlEENS_21RepeatedFieldIteratorIT_EEj: 301| 971k| RepeatedFieldIterator GetRepeated(uint32_t field_id) const { 302| 971k| const Field* repeated_begin; 303| | // The storage for repeated fields starts after the slot for the highest 304| | // field id (refer to the diagram in the class-level comment). However, if 305| | // a message has more than INITIAL_STACK_CAPACITY field there will be no 306| | // slots available for the repeated fields (if ExpandHeapStorage() was not 307| | // called). Imagine a message that has highest field id = 102 and that is 308| | // still using the stack: 309| | // [ F0 ] [ F1 ] ... [ F100 ] [ F101 ] [ F1012] [ repeated fields ] 310| | // ^ num_fields_ 311| | // ^ size (== capacity) 312| 971k| if (PERFETTO_LIKELY(num_fields_ < size_)) { ------------------ | | 23| 971k|#define PERFETTO_LIKELY(...) __builtin_expect(!!(__VA_ARGS__), 1) | | ------------------ | | | Branch (23:30): [True: 665k, False: 306k] | | ------------------ ------------------ 313| 665k| repeated_begin = &fields_[num_fields_]; 314| 665k| } else { 315| | // This is the case of not having any storage space for repeated fields. 316| | // This makes it so begin == end, so the iterator will just skip @ last. 317| 306k| repeated_begin = &fields_[size_]; 318| 306k| } 319| 971k| const Field* repeated_end = &fields_[size_]; 320| 971k| const Field* last = &Get(field_id); 321| 971k| return RepeatedFieldIterator(field_id, repeated_begin, repeated_end, 322| 971k| last); 323| 971k| } _ZN9protozero21RepeatedFieldIteratorIlE18FindNextMatchingIdEv: 144| 971k| void FindNextMatchingId() { 145| 971k| PERFETTO_DCHECK(iter_ != last_); 146| 1.86M| for (; iter_ != end_; ++iter_) { ------------------ | Branch (146:12): [True: 900k, False: 966k] ------------------ 147| 900k| if (iter_->id() == field_id_) ------------------ | Branch (147:11): [True: 4.31k, False: 896k] ------------------ 148| 4.31k| return; 149| 900k| } 150| 966k| iter_ = last_->valid() ? last_ : end_; ------------------ | Branch (150:13): [True: 5.04k, False: 961k] ------------------ 151| 966k| } _ZNK9protozero17TypedProtoDecoderILi50ELb1EE2atILj46EEERKNS_5FieldEv: 439| 831k| const Field& at() const { 440| 831k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 831k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 831k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 831k| return fields_[FIELD_ID]; 447| 831k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 831k| } _ZNK9protozero21TypedProtoDecoderBase11GetRepeatedIdEENS_21RepeatedFieldIteratorIT_EEj: 301| 961k| RepeatedFieldIterator GetRepeated(uint32_t field_id) const { 302| 961k| const Field* repeated_begin; 303| | // The storage for repeated fields starts after the slot for the highest 304| | // field id (refer to the diagram in the class-level comment). However, if 305| | // a message has more than INITIAL_STACK_CAPACITY field there will be no 306| | // slots available for the repeated fields (if ExpandHeapStorage() was not 307| | // called). Imagine a message that has highest field id = 102 and that is 308| | // still using the stack: 309| | // [ F0 ] [ F1 ] ... [ F100 ] [ F101 ] [ F1012] [ repeated fields ] 310| | // ^ num_fields_ 311| | // ^ size (== capacity) 312| 961k| if (PERFETTO_LIKELY(num_fields_ < size_)) { ------------------ | | 23| 961k|#define PERFETTO_LIKELY(...) __builtin_expect(!!(__VA_ARGS__), 1) | | ------------------ | | | Branch (23:30): [True: 657k, False: 304k] | | ------------------ ------------------ 313| 657k| repeated_begin = &fields_[num_fields_]; 314| 657k| } else { 315| | // This is the case of not having any storage space for repeated fields. 316| | // This makes it so begin == end, so the iterator will just skip @ last. 317| 304k| repeated_begin = &fields_[size_]; 318| 304k| } 319| 961k| const Field* repeated_end = &fields_[size_]; 320| 961k| const Field* last = &Get(field_id); 321| 961k| return RepeatedFieldIterator(field_id, repeated_begin, repeated_end, 322| 961k| last); 323| 961k| } _ZN9protozero21RepeatedFieldIteratorIdE18FindNextMatchingIdEv: 144| 961k| void FindNextMatchingId() { 145| 961k| PERFETTO_DCHECK(iter_ != last_); 146| 1.84M| for (; iter_ != end_; ++iter_) { ------------------ | Branch (146:12): [True: 883k, False: 961k] ------------------ 147| 883k| if (iter_->id() == field_id_) ------------------ | Branch (147:11): [True: 188, False: 883k] ------------------ 148| 188| return; 149| 883k| } 150| 961k| iter_ = last_->valid() ? last_ : end_; ------------------ | Branch (150:13): [True: 0, False: 961k] ------------------ 151| 961k| } _ZNK9protozero17TypedProtoDecoderILi50ELb1EE2atILj36EEERKNS_5FieldEv: 439| 727k| const Field& at() const { 440| 727k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 727k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 727k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 727k| return fields_[FIELD_ID]; 447| 727k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 727k| } _ZNK9protozero17TypedProtoDecoderILi50ELb1EE2atILj47EEERKNS_5FieldEv: 439| 727k| const Field& at() const { 440| 727k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 727k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 727k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 727k| return fields_[FIELD_ID]; 447| 727k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 727k| } _ZNK9protozero17TypedProtoDecoderILi50ELb1EE2atILj42EEERKNS_5FieldEv: 439| 727k| const Field& at() const { 440| 727k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 727k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 727k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 727k| return fields_[FIELD_ID]; 447| 727k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 727k| } _ZNK9protozero17TypedProtoDecoderILi50ELb1EE2atILj48EEERKNS_5FieldEv: 439| 727k| const Field& at() const { 440| 727k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 727k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 727k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 727k| return fields_[FIELD_ID]; 447| 727k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 727k| } _ZNK9protozero21TypedProtoDecoderBase11GetRepeatedINS_10ConstBytesEEENS_21RepeatedFieldIteratorIT_EEj: 301| 3.16M| RepeatedFieldIterator GetRepeated(uint32_t field_id) const { 302| 3.16M| const Field* repeated_begin; 303| | // The storage for repeated fields starts after the slot for the highest 304| | // field id (refer to the diagram in the class-level comment). However, if 305| | // a message has more than INITIAL_STACK_CAPACITY field there will be no 306| | // slots available for the repeated fields (if ExpandHeapStorage() was not 307| | // called). Imagine a message that has highest field id = 102 and that is 308| | // still using the stack: 309| | // [ F0 ] [ F1 ] ... [ F100 ] [ F101 ] [ F1012] [ repeated fields ] 310| | // ^ num_fields_ 311| | // ^ size (== capacity) 312| 3.16M| if (PERFETTO_LIKELY(num_fields_ < size_)) { ------------------ | | 23| 3.16M|#define PERFETTO_LIKELY(...) __builtin_expect(!!(__VA_ARGS__), 1) | | ------------------ | | | Branch (23:30): [True: 2.69M, False: 475k] | | ------------------ ------------------ 313| 2.69M| repeated_begin = &fields_[num_fields_]; 314| 2.69M| } else { 315| | // This is the case of not having any storage space for repeated fields. 316| | // This makes it so begin == end, so the iterator will just skip @ last. 317| 475k| repeated_begin = &fields_[size_]; 318| 475k| } 319| 3.16M| const Field* repeated_end = &fields_[size_]; 320| 3.16M| const Field* last = &Get(field_id); 321| 3.16M| return RepeatedFieldIterator(field_id, repeated_begin, repeated_end, 322| 3.16M| last); 323| 3.16M| } _ZN9protozero21RepeatedFieldIteratorINS_10ConstBytesEE18FindNextMatchingIdEv: 144| 12.2M| void FindNextMatchingId() { 145| 12.2M| PERFETTO_DCHECK(iter_ != last_); 146| 23.0M| for (; iter_ != end_; ++iter_) { ------------------ | Branch (146:12): [True: 19.8M, False: 3.16M] ------------------ 147| 19.8M| if (iter_->id() == field_id_) ------------------ | Branch (147:11): [True: 9.11M, False: 10.7M] ------------------ 148| 9.11M| return; 149| 19.8M| } 150| 3.16M| iter_ = last_->valid() ? last_ : end_; ------------------ | Branch (150:13): [True: 1.75M, False: 1.40M] ------------------ 151| 3.16M| } _ZNK9protozero17TypedProtoDecoderILi50ELb1EE2atILj5EEERKNS_5FieldEv: 439| 761k| const Field& at() const { 440| 761k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 761k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 761k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 761k| return fields_[FIELD_ID]; 447| 761k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 761k| } _ZNK9protozero17TypedProtoDecoderILi50ELb1EE2atILj21EEERKNS_5FieldEv: 439| 739k| const Field& at() const { 440| 739k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 739k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 739k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 739k| return fields_[FIELD_ID]; 447| 739k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 739k| } _ZNK9protozero17TypedProtoDecoderILi50ELb1EE2atILj28EEERKNS_5FieldEv: 439| 1.26M| const Field& at() const { 440| 1.26M| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 1.26M| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 1.26M|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 1.26M| return fields_[FIELD_ID]; 447| 1.26M| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 1.26M| } _ZNK9protozero17TypedProtoDecoderILi50ELb1EE2atILj49EEERKNS_5FieldEv: 439| 765k| const Field& at() const { 440| 765k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 765k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 765k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 765k| return fields_[FIELD_ID]; 447| 765k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 765k| } _ZNK9protozero17TypedProtoDecoderILi50ELb1EE2atILj34EEERKNS_5FieldEv: 439| 739k| const Field& at() const { 440| 739k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 739k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 739k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 739k| return fields_[FIELD_ID]; 447| 739k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 739k| } _ZNK9protozero17TypedProtoDecoderILi50ELb1EE2atILj1EEERKNS_5FieldEv: 439| 999k| const Field& at() const { 440| 999k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 999k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 999k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 999k| return fields_[FIELD_ID]; 447| 999k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 999k| } _ZNK9protozero17TypedProtoDecoderILi50ELb1EE2atILj16EEERKNS_5FieldEv: 439| 988k| const Field& at() const { 440| 988k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 988k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 988k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 988k| return fields_[FIELD_ID]; 447| 988k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 988k| } _ZNK9protozero17TypedProtoDecoderILi50ELb1EE2atILj2EEERKNS_5FieldEv: 439| 984k| const Field& at() const { 440| 984k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 984k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 984k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 984k| return fields_[FIELD_ID]; 447| 984k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 984k| } _ZNK9protozero17TypedProtoDecoderILi50ELb1EE2atILj17EEERKNS_5FieldEv: 439| 975k| const Field& at() const { 440| 975k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 975k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 975k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 975k| return fields_[FIELD_ID]; 447| 975k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 975k| } _ZNK9protozero17TypedProtoDecoderILi50ELb1EE2atILj8EEERKNS_5FieldEv: 439| 975k| const Field& at() const { 440| 975k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 975k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 975k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 975k| return fields_[FIELD_ID]; 447| 975k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 975k| } _ZNK9protozero17TypedProtoDecoderILi50ELb1EE2atILj20EEERKNS_5FieldEv: 439| 971k| const Field& at() const { 440| 971k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 971k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 971k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 971k| return fields_[FIELD_ID]; 447| 971k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 971k| } _ZNK9protozero17TypedProtoDecoderILi50ELb1EE2atILj6EEERKNS_5FieldEv: 439| 2.22M| const Field& at() const { 440| 2.22M| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 2.22M| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 2.22M|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 2.22M| return fields_[FIELD_ID]; 447| 2.22M| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 2.22M| } _ZNK9protozero17TypedProtoDecoderILi19ELb0EE2atILj1EEERKNS_5FieldEv: 439| 829k| const Field& at() const { 440| 829k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 829k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 829k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 829k| return fields_[FIELD_ID]; 447| 829k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 829k| } _ZNK9protozero17TypedProtoDecoderILi19ELb0EE2atILj2EEERKNS_5FieldEv: 439| 2.96M| const Field& at() const { 440| 2.96M| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 2.96M| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 2.96M|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 2.96M| return fields_[FIELD_ID]; 447| 2.96M| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 2.96M| } _ZNK9protozero17TypedProtoDecoderILi19ELb0EE2atILj3EEERKNS_5FieldEv: 439| 20.9k| const Field& at() const { 440| 20.9k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 20.9k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 20.9k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 20.9k| return fields_[FIELD_ID]; 447| 20.9k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 20.9k| } _ZNK9protozero17TypedProtoDecoderILi19ELb0EE2atILj4EEERKNS_5FieldEv: 439| 82| const Field& at() const { 440| 82| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 82| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 82|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 82| return fields_[FIELD_ID]; 447| 82| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 82| } _ZNK9protozero17TypedProtoDecoderILi19ELb0EE2atILj15EEERKNS_5FieldEv: 439| 82| const Field& at() const { 440| 82| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 82| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 82|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 82| return fields_[FIELD_ID]; 447| 82| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 82| } _ZNK9protozero17TypedProtoDecoderILi19ELb0EE2atILj6EEERKNS_5FieldEv: 439| 260k| const Field& at() const { 440| 260k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 260k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 260k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 260k| return fields_[FIELD_ID]; 447| 260k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 260k| } _ZNK9protozero17TypedProtoDecoderILi19ELb0EE2atILj10EEERKNS_5FieldEv: 439| 235k| const Field& at() const { 440| 235k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 235k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 235k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 235k| return fields_[FIELD_ID]; 447| 235k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 235k| } _ZNK9protozero17TypedProtoDecoderILi19ELb0EE2atILj11EEERKNS_5FieldEv: 439| 140k| const Field& at() const { 440| 140k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 140k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 140k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 140k| return fields_[FIELD_ID]; 447| 140k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 140k| } _ZNK9protozero17TypedProtoDecoderILi19ELb0EE2atILj7EEERKNS_5FieldEv: 439| 120k| const Field& at() const { 440| 120k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 120k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 120k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 120k| return fields_[FIELD_ID]; 447| 120k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 120k| } _ZNK9protozero17TypedProtoDecoderILi19ELb0EE2atILj9EEERKNS_5FieldEv: 439| 734k| const Field& at() const { 440| 734k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 734k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 734k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 734k| return fields_[FIELD_ID]; 447| 734k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 734k| } _ZNK9protozero17TypedProtoDecoderILi19ELb0EE2atILj8EEERKNS_5FieldEv: 439| 731k| const Field& at() const { 440| 731k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 731k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 731k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 731k| return fields_[FIELD_ID]; 447| 731k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 731k| } _ZNK9protozero17TypedProtoDecoderILi19ELb0EE2atILj12EEERKNS_5FieldEv: 439| 1.51k| const Field& at() const { 440| 1.51k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 1.51k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 1.51k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 1.51k| return fields_[FIELD_ID]; 447| 1.51k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 1.51k| } _ZNK9protozero17TypedProtoDecoderILi19ELb0EE2atILj13EEERKNS_5FieldEv: 439| 6.94k| const Field& at() const { 440| 6.94k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 6.94k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 6.94k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 6.94k| return fields_[FIELD_ID]; 447| 6.94k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 6.94k| } _ZNK9protozero17TypedProtoDecoderILi19ELb0EE2atILj14EEERKNS_5FieldEv: 439| 3.72k| const Field& at() const { 440| 3.72k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 3.72k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 3.72k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 3.72k| return fields_[FIELD_ID]; 447| 3.72k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 3.72k| } _ZNK9protozero17TypedProtoDecoderILi19ELb0EE2atILj18EEERKNS_5FieldEv: 439| 1.00M| const Field& at() const { 440| 1.00M| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 1.00M| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 1.00M|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 1.00M| return fields_[FIELD_ID]; 447| 1.00M| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 1.00M| } _ZNK9protozero17TypedProtoDecoderILi19ELb0EE2atILj19EEERKNS_5FieldEv: 439| 901k| const Field& at() const { 440| 901k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 901k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 901k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 901k| return fields_[FIELD_ID]; 447| 901k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 901k| } _ZNK9protozero17TypedProtoDecoderILi900ELb0EE2atILj8EEERKNS_5FieldEv: 439| 7.83M| const Field& at() const { 440| 7.83M| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 7.83M| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 7.83M|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 7.83M| return fields_[FIELD_ID]; 447| 7.83M| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 7.83M| } _ZNK9protozero17TypedProtoDecoderILi900ELb0EE2atILj58EEERKNS_5FieldEv: 439| 2.88M| const Field& at() const { 440| 2.88M| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 2.88M| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 2.88M|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 2.88M| return fields_[FIELD_ID]; 447| 2.88M| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 2.88M| } _ZNK9protozero17TypedProtoDecoderILi900ELb0EE2atILj9EEERKNS_5FieldEv: 439| 6.75k| const Field& at() const { 440| 6.75k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 6.75k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 6.75k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 6.75k| return fields_[FIELD_ID]; 447| 6.75k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 6.75k| } _ZNK9protozero17TypedProtoDecoderILi900ELb0EE2atILj5EEERKNS_5FieldEv: 439| 4.18M| const Field& at() const { 440| 4.18M| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 4.18M| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 4.18M|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 4.18M| return fields_[FIELD_ID]; 447| 4.18M| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 4.18M| } _ZNK9protozero17TypedProtoDecoderILi900ELb0EE2atILj6EEERKNS_5FieldEv: 439| 4.00M| const Field& at() const { 440| 4.00M| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 4.00M| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 4.00M|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 4.00M| return fields_[FIELD_ID]; 447| 4.00M| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 4.00M| } _ZNK9protozero17TypedProtoDecoderILi900ELb0EE2atILj11EEERKNS_5FieldEv: 439| 1.87M| const Field& at() const { 440| 1.87M| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 1.87M| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 1.87M|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 1.87M| return fields_[FIELD_ID]; 447| 1.87M| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 1.87M| } _ZNK9protozero17TypedProtoDecoderILi900ELb0EE2atILj33EEERKNS_5FieldEv: 439| 5.10M| const Field& at() const { 440| 5.10M| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 5.10M| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 5.10M|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 5.10M| return fields_[FIELD_ID]; 447| 5.10M| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 5.10M| } _ZNK9protozero17TypedProtoDecoderILi900ELb0EE2atILj35EEERKNS_5FieldEv: 439| 3.96M| const Field& at() const { 440| 3.96M| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 3.96M| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 3.96M|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 3.96M| return fields_[FIELD_ID]; 447| 3.96M| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 3.96M| } _ZNK9protozero17TypedProtoDecoderILi900ELb0EE2atILj48EEERKNS_5FieldEv: 439| 1.29k| const Field& at() const { 440| 1.29k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 1.29k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 1.29k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 1.29k| return fields_[FIELD_ID]; 447| 1.29k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 1.29k| } _ZNK9protozero17TypedProtoDecoderILi900ELb0EE2atILj49EEERKNS_5FieldEv: 439| 1.47M| const Field& at() const { 440| 1.47M| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 1.47M| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 1.47M|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 1.47M| return fields_[FIELD_ID]; 447| 1.47M| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 1.47M| } _ZNK9protozero17TypedProtoDecoderILi900ELb0EE2atILj51EEERKNS_5FieldEv: 439| 2.88M| const Field& at() const { 440| 2.88M| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 2.88M| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 2.88M|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 2.88M| return fields_[FIELD_ID]; 447| 2.88M| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 2.88M| } _ZNK9protozero17TypedProtoDecoderILi900ELb0EE2atILj69EEERKNS_5FieldEv: 439| 4.00M| const Field& at() const { 440| 4.00M| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 4.00M| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 4.00M|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 4.00M| return fields_[FIELD_ID]; 447| 4.00M| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 4.00M| } _ZNK9protozero17TypedProtoDecoderILi900ELb0EE2atILj73EEERKNS_5FieldEv: 439| 60.7k| const Field& at() const { 440| 60.7k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 60.7k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 60.7k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 60.7k| return fields_[FIELD_ID]; 447| 60.7k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 60.7k| } _ZNK9protozero17TypedProtoDecoderILi900ELb0EE2atILj60EEERKNS_5FieldEv: 439| 248k| const Field& at() const { 440| 248k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 248k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 248k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 248k| return fields_[FIELD_ID]; 447| 248k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 248k| } _ZNK9protozero17TypedProtoDecoderILi900ELb0EE2atILj43EEERKNS_5FieldEv: 439| 20.4k| const Field& at() const { 440| 20.4k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 20.4k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 20.4k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 20.4k| return fields_[FIELD_ID]; 447| 20.4k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 20.4k| } _ZNK9protozero17TypedProtoDecoderILi900ELb0EE2atILj44EEERKNS_5FieldEv: 439| 46| const Field& at() const { 440| 46| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 46| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 46|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 46| return fields_[FIELD_ID]; 447| 46| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 46| } _ZNK9protozero17TypedProtoDecoderILi900ELb0EE2atILj50EEERKNS_5FieldEv: 439| 7.97M| const Field& at() const { 440| 7.97M| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 7.97M| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 7.97M|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 7.97M| return fields_[FIELD_ID]; 447| 7.97M| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 7.97M| } _ZNK9protozero17TypedProtoDecoderILi900ELb0EE2atILj72EEERKNS_5FieldEv: 439| 3.93M| const Field& at() const { 440| 3.93M| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 3.93M| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 3.93M|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 3.93M| return fields_[FIELD_ID]; 447| 3.93M| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 3.93M| } _ZNK9protozero17TypedProtoDecoderILi900ELb0EE2atILj107EEERKNS_5FieldEv: 439| 3.96M| const Field& at() const { 440| 3.96M| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 3.96M| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 3.96M|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 0| return fields_[FIELD_ID]; 447| 3.96M| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 3.96M| return Get(FIELD_ID); 450| 3.96M| } 451| 3.96M| } _ZNK9protozero17TypedProtoDecoderILi900ELb0EE2atILj10EEERKNS_5FieldEv: 439| 16.0M| const Field& at() const { 440| 16.0M| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 16.0M| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 16.0M|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 16.0M| return fields_[FIELD_ID]; 447| 16.0M| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 16.0M| } _ZNK9protozero17TypedProtoDecoderILi900ELb0EE2atILj79EEERKNS_5FieldEv: 439| 131k| const Field& at() const { 440| 131k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 131k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 131k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 131k| return fields_[FIELD_ID]; 447| 131k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 131k| } _ZNK9protozero17TypedProtoDecoderILi900ELb0EE2atILj12EEERKNS_5FieldEv: 439| 4.00M| const Field& at() const { 440| 4.00M| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 4.00M| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 4.00M|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 4.00M| return fields_[FIELD_ID]; 447| 4.00M| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 4.00M| } _ZNK9protozero17TypedProtoDecoderILi900ELb0EE2atILj13EEERKNS_5FieldEv: 439| 7.91M| const Field& at() const { 440| 7.91M| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 7.91M| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 7.91M|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 7.91M| return fields_[FIELD_ID]; 447| 7.91M| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 7.91M| } _ZNK9protozero17TypedProtoDecoderILi900ELb0EE2atILj41EEERKNS_5FieldEv: 439| 3.98M| const Field& at() const { 440| 3.98M| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 3.98M| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 3.98M|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 3.98M| return fields_[FIELD_ID]; 447| 3.98M| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 3.98M| } _ZNK9protozero17TypedProtoDecoderILi900ELb0EE2atILj59EEERKNS_5FieldEv: 439| 3.98M| const Field& at() const { 440| 3.98M| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 3.98M| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 3.98M|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 3.98M| return fields_[FIELD_ID]; 447| 3.98M| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 3.98M| } _ZNK9protozero17TypedProtoDecoderILi900ELb0EE2atILj42EEERKNS_5FieldEv: 439| 5.01M| const Field& at() const { 440| 5.01M| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 5.01M| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 5.01M|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 5.01M| return fields_[FIELD_ID]; 447| 5.01M| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 5.01M| } _ZNK9protozero17TypedProtoDecoderILi900ELb0EE2atILj87EEERKNS_5FieldEv: 439| 3.98M| const Field& at() const { 440| 3.98M| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 3.98M| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 3.98M|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 3.98M| return fields_[FIELD_ID]; 447| 3.98M| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 3.98M| } _ZNK9protozero17TypedProtoDecoderILi900ELb0EE2atILj98EEERKNS_5FieldEv: 439| 3.99M| const Field& at() const { 440| 3.99M| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 3.99M| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 3.99M|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 3.99M| return fields_[FIELD_ID]; 447| 3.99M| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 3.99M| } _ZNK9protozero17TypedProtoDecoderILi4ELb1EE2atILj1EEERKNS_5FieldEv: 439| 14| const Field& at() const { 440| 14| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 14| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 14|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 14| return fields_[FIELD_ID]; 447| 14| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 14| } _ZNK9protozero17TypedProtoDecoderILi4ELb1EE2atILj4EEERKNS_5FieldEv: 439| 7| const Field& at() const { 440| 7| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 7| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 7|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 7| return fields_[FIELD_ID]; 447| 7| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 7| } _ZNK9protozero17TypedProtoDecoderILi4ELb1EE2atILj2EEERKNS_5FieldEv: 439| 14| const Field& at() const { 440| 14| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 14| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 14|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 14| return fields_[FIELD_ID]; 447| 14| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 14| } _ZNK9protozero17TypedProtoDecoderILi4ELb1EE2atILj3EEERKNS_5FieldEv: 439| 7| const Field& at() const { 440| 7| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 7| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 7|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 7| return fields_[FIELD_ID]; 447| 7| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 7| } _ZNK9protozero17TypedProtoDecoderILi1ELb0EE2atILj1EEERKNS_5FieldEv: 439| 23.8k| const Field& at() const { 440| 23.8k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 23.8k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 23.8k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 23.8k| return fields_[FIELD_ID]; 447| 23.8k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 23.8k| } _ZNK9protozero17TypedProtoDecoderILi3ELb1EE2atILj1EEERKNS_5FieldEv: 439| 58.5k| const Field& at() const { 440| 58.5k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 58.5k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 58.5k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 58.5k| return fields_[FIELD_ID]; 447| 58.5k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 58.5k| } _ZNK9protozero17TypedProtoDecoderILi3ELb1EE2atILj2EEERKNS_5FieldEv: 439| 60.7k| const Field& at() const { 440| 60.7k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 60.7k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 60.7k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 60.7k| return fields_[FIELD_ID]; 447| 60.7k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 60.7k| } _ZNK9protozero17TypedProtoDecoderILi3ELb1EE2atILj3EEERKNS_5FieldEv: 439| 7| const Field& at() const { 440| 7| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 7| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 7|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 7| return fields_[FIELD_ID]; 447| 7| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 7| } _ZNK9protozero17TypedProtoDecoderILi6ELb1EE2atILj1EEERKNS_5FieldEv: 439| 49.3k| const Field& at() const { 440| 49.3k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 49.3k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 49.3k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 49.3k| return fields_[FIELD_ID]; 447| 49.3k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 49.3k| } _ZNK9protozero17TypedProtoDecoderILi6ELb1EE2atILj2EEERKNS_5FieldEv: 439| 20.3k| const Field& at() const { 440| 20.3k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 20.3k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 20.3k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 20.3k| return fields_[FIELD_ID]; 447| 20.3k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 20.3k| } _ZNK9protozero17TypedProtoDecoderILi6ELb1EE2atILj3EEERKNS_5FieldEv: 439| 20.3k| const Field& at() const { 440| 20.3k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 20.3k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 20.3k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 20.3k| return fields_[FIELD_ID]; 447| 20.3k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 20.3k| } _ZNK9protozero17TypedProtoDecoderILi6ELb1EE2atILj4EEERKNS_5FieldEv: 439| 20.3k| const Field& at() const { 440| 20.3k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 20.3k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 20.3k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 20.3k| return fields_[FIELD_ID]; 447| 20.3k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 20.3k| } _ZNK9protozero17TypedProtoDecoderILi6ELb1EE2atILj5EEERKNS_5FieldEv: 439| 40.6k| const Field& at() const { 440| 40.6k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 40.6k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 40.6k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 40.6k| return fields_[FIELD_ID]; 447| 40.6k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 40.6k| } _ZNK9protozero17TypedProtoDecoderILi6ELb1EE2atILj6EEERKNS_5FieldEv: 439| 14.8k| const Field& at() const { 440| 14.8k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 14.8k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 14.8k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 14.8k| return fields_[FIELD_ID]; 447| 14.8k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 14.8k| } _ZNK9protozero17TypedProtoDecoderILi6ELb0EE2atILj4EEERKNS_5FieldEv: 439| 534| const Field& at() const { 440| 534| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 534| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 534|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 534| return fields_[FIELD_ID]; 447| 534| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 534| } _ZNK9protozero17TypedProtoDecoderILi9ELb0EE2atILj1EEERKNS_5FieldEv: 439| 1.75M| const Field& at() const { 440| 1.75M| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 1.75M| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 1.75M|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 1.75M| return fields_[FIELD_ID]; 447| 1.75M| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 1.75M| } _ZNK9protozero17TypedProtoDecoderILi9ELb0EE2atILj2EEERKNS_5FieldEv: 439| 162k| const Field& at() const { 440| 162k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 162k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 162k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 162k| return fields_[FIELD_ID]; 447| 162k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 162k| } _ZNK9protozero17TypedProtoDecoderILi9ELb0EE2atILj3EEERKNS_5FieldEv: 439| 1.75M| const Field& at() const { 440| 1.75M| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 1.75M| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 1.75M|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 1.75M| return fields_[FIELD_ID]; 447| 1.75M| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 1.75M| } _ZNK9protozero17TypedProtoDecoderILi9ELb0EE2atILj8EEERKNS_5FieldEv: 439| 7.03M| const Field& at() const { 440| 7.03M| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 7.03M| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 7.03M|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 7.03M| return fields_[FIELD_ID]; 447| 7.03M| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 7.03M| } _ZNK9protozero17TypedProtoDecoderILi9ELb0EE2atILj4EEERKNS_5FieldEv: 439| 1.75M| const Field& at() const { 440| 1.75M| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 1.75M| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 1.75M|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 1.75M| return fields_[FIELD_ID]; 447| 1.75M| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 1.75M| } _ZNK9protozero17TypedProtoDecoderILi9ELb0EE2atILj5EEERKNS_5FieldEv: 439| 3.51M| const Field& at() const { 440| 3.51M| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 3.51M| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 3.51M|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 3.51M| return fields_[FIELD_ID]; 447| 3.51M| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 3.51M| } _ZNK9protozero17TypedProtoDecoderILi9ELb0EE2atILj6EEERKNS_5FieldEv: 439| 2.28M| const Field& at() const { 440| 2.28M| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 2.28M| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 2.28M|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 2.28M| return fields_[FIELD_ID]; 447| 2.28M| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 2.28M| } _ZNK9protozero17TypedProtoDecoderILi2ELb1EE2atILj2EEERKNS_5FieldEv: 439| 28.4k| const Field& at() const { 440| 28.4k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 28.4k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 28.4k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 28.4k| return fields_[FIELD_ID]; 447| 28.4k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 28.4k| } _ZNK9protozero17TypedProtoDecoderILi4ELb0EE2atILj1EEERKNS_5FieldEv: 439| 4.21M| const Field& at() const { 440| 4.21M| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 4.21M| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 4.21M|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 4.21M| return fields_[FIELD_ID]; 447| 4.21M| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 4.21M| } _ZNK9protozero17TypedProtoDecoderILi4ELb0EE2atILj2EEERKNS_5FieldEv: 439| 4.16M| const Field& at() const { 440| 4.16M| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 4.16M| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 4.16M|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 4.16M| return fields_[FIELD_ID]; 447| 4.16M| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 4.16M| } _ZNK9protozero17TypedProtoDecoderILi4ELb0EE2atILj3EEERKNS_5FieldEv: 439| 4.12M| const Field& at() const { 440| 4.12M| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 4.12M| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 4.12M|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 4.12M| return fields_[FIELD_ID]; 447| 4.12M| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 4.12M| } _ZNK9protozero17TypedProtoDecoderILi4ELb0EE2atILj4EEERKNS_5FieldEv: 439| 4.68M| const Field& at() const { 440| 4.68M| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 4.68M| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 4.68M|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 4.68M| return fields_[FIELD_ID]; 447| 4.68M| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 4.68M| } _ZNK9protozero17TypedProtoDecoderILi9ELb0EE2atILj7EEERKNS_5FieldEv: 439| 1.75M| const Field& at() const { 440| 1.75M| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 1.75M| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 1.75M|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 1.75M| return fields_[FIELD_ID]; 447| 1.75M| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 1.75M| } _ZNK9protozero17TypedProtoDecoderILi17ELb1EE2atILj1EEERKNS_5FieldEv: 439| 1.15M| const Field& at() const { 440| 1.15M| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 1.15M| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 1.15M|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 1.15M| return fields_[FIELD_ID]; 447| 1.15M| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 1.15M| } _ZNK9protozero17TypedProtoDecoderILi17ELb1EE2atILj10EEERKNS_5FieldEv: 439| 1.18M| const Field& at() const { 440| 1.18M| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 1.18M| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 1.18M|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 1.18M| return fields_[FIELD_ID]; 447| 1.18M| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 1.18M| } _ZNK9protozero17TypedProtoDecoderILi17ELb1EE2atILj2EEERKNS_5FieldEv: 439| 24.0k| const Field& at() const { 440| 24.0k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 24.0k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 24.0k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 24.0k| return fields_[FIELD_ID]; 447| 24.0k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 24.0k| } _ZNK9protozero17TypedProtoDecoderILi17ELb1EE2atILj3EEERKNS_5FieldEv: 439| 23.9k| const Field& at() const { 440| 23.9k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 23.9k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 23.9k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 23.9k| return fields_[FIELD_ID]; 447| 23.9k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 23.9k| } _ZNK9protozero17TypedProtoDecoderILi17ELb1EE2atILj4EEERKNS_5FieldEv: 439| 23.4k| const Field& at() const { 440| 23.4k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 23.4k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 23.4k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 23.4k| return fields_[FIELD_ID]; 447| 23.4k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 23.4k| } _ZNK9protozero17TypedProtoDecoderILi17ELb1EE2atILj5EEERKNS_5FieldEv: 439| 23.4k| const Field& at() const { 440| 23.4k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 23.4k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 23.4k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 23.4k| return fields_[FIELD_ID]; 447| 23.4k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 23.4k| } _ZNK9protozero17TypedProtoDecoderILi17ELb1EE2atILj6EEERKNS_5FieldEv: 439| 23.4k| const Field& at() const { 440| 23.4k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 23.4k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 23.4k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 23.4k| return fields_[FIELD_ID]; 447| 23.4k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 23.4k| } _ZNK9protozero17TypedProtoDecoderILi17ELb1EE2atILj17EEERKNS_5FieldEv: 439| 23.4k| const Field& at() const { 440| 23.4k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 23.4k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 23.4k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 23.4k| return fields_[FIELD_ID]; 447| 23.4k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 23.4k| } _ZNK9protozero17TypedProtoDecoderILi17ELb1EE2atILj7EEERKNS_5FieldEv: 439| 27.4k| const Field& at() const { 440| 27.4k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 27.4k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 27.4k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 27.4k| return fields_[FIELD_ID]; 447| 27.4k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 27.4k| } _ZNK9protozero17TypedProtoDecoderILi17ELb1EE2atILj11EEERKNS_5FieldEv: 439| 19.3k| const Field& at() const { 440| 19.3k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 19.3k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 19.3k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 19.3k| return fields_[FIELD_ID]; 447| 19.3k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 19.3k| } _ZN9protozero21RepeatedFieldIteratorINS_10ConstBytesEEC2EjPKNS_5FieldES5_S5_: 107| 3.16M| : field_id_(field_id), iter_(begin), end_(end), last_(last) { 108| 3.16M| FindNextMatchingId(); 109| 3.16M| } _ZN9protozero17TypedProtoDecoderILi17ELb1EEC2EPKhm: 430| 1.15M| : TypedProtoDecoderBase(on_stack_storage_, 431| 1.15M| /*num_fields=*/MAX_FIELD_ID + 1, 432| 1.15M| PROTOZERO_DECODER_INITIAL_STACK_CAPACITY, ------------------ | | 422| 1.15M|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ 433| 1.15M| buffer, 434| 1.15M| length) { 435| 1.15M| TypedProtoDecoderBase::ParseAllFields(); 436| 1.15M| } _ZNK9protozero17TypedProtoDecoderILi17ELb1EE2atILj12EEERKNS_5FieldEv: 439| 19.3k| const Field& at() const { 440| 19.3k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 19.3k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 19.3k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 19.3k| return fields_[FIELD_ID]; 447| 19.3k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 19.3k| } _ZNK9protozero17TypedProtoDecoderILi17ELb1EE2atILj9EEERKNS_5FieldEv: 439| 36.9k| const Field& at() const { 440| 36.9k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 36.9k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 36.9k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 36.9k| return fields_[FIELD_ID]; 447| 36.9k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 36.9k| } _ZNK9protozero17TypedProtoDecoderILi17ELb1EE2atILj8EEERKNS_5FieldEv: 439| 2.10k| const Field& at() const { 440| 2.10k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 2.10k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 2.10k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 2.10k| return fields_[FIELD_ID]; 447| 2.10k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 2.10k| } _ZNK9protozero17TypedProtoDecoderILi17ELb1EE2atILj14EEERKNS_5FieldEv: 439| 1.55k| const Field& at() const { 440| 1.55k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 1.55k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 1.55k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 1.55k| return fields_[FIELD_ID]; 447| 1.55k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 1.55k| } _ZNK9protozero17TypedProtoDecoderILi17ELb1EE2atILj16EEERKNS_5FieldEv: 439| 1.51k| const Field& at() const { 440| 1.51k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 1.51k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 1.51k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 1.51k| return fields_[FIELD_ID]; 447| 1.51k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 1.51k| } _ZNK9protozero17TypedProtoDecoderILi17ELb1EE2atILj13EEERKNS_5FieldEv: 439| 3.03k| const Field& at() const { 440| 3.03k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 3.03k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 3.03k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 3.03k| return fields_[FIELD_ID]; 447| 3.03k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 3.03k| } _ZN9protozero17TypedProtoDecoderILi8ELb1EEC2EPKhm: 430| 109k| : TypedProtoDecoderBase(on_stack_storage_, 431| 109k| /*num_fields=*/MAX_FIELD_ID + 1, 432| 109k| PROTOZERO_DECODER_INITIAL_STACK_CAPACITY, ------------------ | | 422| 109k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ 433| 109k| buffer, 434| 109k| length) { 435| 109k| TypedProtoDecoderBase::ParseAllFields(); 436| 109k| } _ZNK9protozero17TypedProtoDecoderILi8ELb1EE2atILj1EEERKNS_5FieldEv: 439| 157k| const Field& at() const { 440| 157k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 157k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 157k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 157k| return fields_[FIELD_ID]; 447| 157k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 157k| } _ZNK9protozero17TypedProtoDecoderILi8ELb1EE2atILj7EEERKNS_5FieldEv: 439| 124k| const Field& at() const { 440| 124k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 124k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 124k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 124k| return fields_[FIELD_ID]; 447| 124k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 124k| } _ZNK9protozero17TypedProtoDecoderILi8ELb1EE2atILj6EEERKNS_5FieldEv: 439| 57.4k| const Field& at() const { 440| 57.4k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 57.4k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 57.4k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 57.4k| return fields_[FIELD_ID]; 447| 57.4k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 57.4k| } _ZN9protozero21RepeatedFieldIteratorINS_10ConstCharsEEC2EjPKNS_5FieldES5_S5_: 107| 966k| : field_id_(field_id), iter_(begin), end_(end), last_(last) { 108| 966k| FindNextMatchingId(); 109| 966k| } _ZN9protozero17TypedProtoDecoderILi2ELb0EEC2EPKhm: 430| 3.17M| : TypedProtoDecoderBase(on_stack_storage_, 431| 3.17M| /*num_fields=*/MAX_FIELD_ID + 1, 432| 3.17M| PROTOZERO_DECODER_INITIAL_STACK_CAPACITY, ------------------ | | 422| 3.17M|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ 433| 3.17M| buffer, 434| 3.17M| length) { 435| 3.17M| TypedProtoDecoderBase::ParseAllFields(); 436| 3.17M| } _ZNK9protozero21RepeatedFieldIteratorINS_10ConstBytesEEcvbEv: 115| 14.0M| explicit operator bool() const { return iter_ != end_; } _ZN9protozero21RepeatedFieldIteratorINS_10ConstBytesEEppEv: 125| 10.8M| RepeatedFieldIterator& operator++() { 126| 10.8M| PERFETTO_DCHECK(iter_ != end_); 127| 10.8M| if (iter_ == last_) { ------------------ | Branch (127:9): [True: 1.75M, False: 9.11M] ------------------ 128| 1.75M| iter_ = end_; 129| 1.75M| return *this; 130| 1.75M| } 131| 9.11M| ++iter_; 132| 9.11M| FindNextMatchingId(); 133| 9.11M| return *this; 134| 10.8M| } _ZNK9protozero21RepeatedFieldIteratorINS_10ConstBytesEEdeEv: 118| 9.01M| T operator*() const { 119| 9.01M| T val{}; 120| 9.01M| iter_->get(&val); 121| 9.01M| return val; 122| 9.01M| } _ZNK9protozero21RepeatedFieldIteratorINS_10ConstCharsEEcvbEv: 115| 1.16M| explicit operator bool() const { return iter_ != end_; } _ZN9protozero21RepeatedFieldIteratorINS_10ConstCharsEEppEv: 125| 202k| RepeatedFieldIterator& operator++() { 126| 202k| PERFETTO_DCHECK(iter_ != end_); 127| 202k| if (iter_ == last_) { ------------------ | Branch (127:9): [True: 102k, False: 99.9k] ------------------ 128| 102k| iter_ = end_; 129| 102k| return *this; 130| 102k| } 131| 99.9k| ++iter_; 132| 99.9k| FindNextMatchingId(); 133| 99.9k| return *this; 134| 202k| } _ZNK9protozero21RepeatedFieldIteratorINS_10ConstCharsEEdeEv: 118| 272k| T operator*() const { 119| 272k| T val{}; 120| 272k| iter_->get(&val); 121| 272k| return val; 122| 272k| } _ZNK9protozero17TypedProtoDecoderILi8ELb1EE2atILj4EEERKNS_5FieldEv: 439| 77.3k| const Field& at() const { 440| 77.3k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 77.3k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 77.3k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 77.3k| return fields_[FIELD_ID]; 447| 77.3k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 77.3k| } _ZNK9protozero17TypedProtoDecoderILi5ELb1EE2atILj1EEERKNS_5FieldEv: 439| 205k| const Field& at() const { 440| 205k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 205k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 205k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 205k| return fields_[FIELD_ID]; 447| 205k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 205k| } _ZNK9protozero17TypedProtoDecoderILi5ELb1EE2atILj2EEERKNS_5FieldEv: 439| 149k| const Field& at() const { 440| 149k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 149k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 149k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 149k| return fields_[FIELD_ID]; 447| 149k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 149k| } _ZNK9protozero17TypedProtoDecoderILi5ELb1EE2atILj5EEERKNS_5FieldEv: 439| 110k| const Field& at() const { 440| 110k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 110k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 110k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 110k| return fields_[FIELD_ID]; 447| 110k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 110k| } _ZNK9protozero17TypedProtoDecoderILi999ELb1EE2atILj2EEERKNS_5FieldEv: 439| 1.75M| const Field& at() const { 440| 1.75M| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 1.75M| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 1.75M|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 1.75M| return fields_[FIELD_ID]; 447| 1.75M| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 1.75M| } _ZNK9protozero17TypedProtoDecoderILi10ELb1EE2atILj1EEERKNS_5FieldEv: 439| 291k| const Field& at() const { 440| 291k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 291k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 291k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 291k| return fields_[FIELD_ID]; 447| 291k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 291k| } _ZNK9protozero17TypedProtoDecoderILi11ELb1EE2atILj1EEERKNS_5FieldEv: 439| 343k| const Field& at() const { 440| 343k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 343k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 343k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 343k| return fields_[FIELD_ID]; 447| 343k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 343k| } _ZNK9protozero17TypedProtoDecoderILi11ELb1EE2atILj2EEERKNS_5FieldEv: 439| 886k| const Field& at() const { 440| 886k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 886k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 886k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 886k| return fields_[FIELD_ID]; 447| 886k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 886k| } _ZNK9protozero17TypedProtoDecoderILi11ELb1EE2atILj3EEERKNS_5FieldEv: 439| 5.54k| const Field& at() const { 440| 5.54k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 5.54k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 5.54k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 5.54k| return fields_[FIELD_ID]; 447| 5.54k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 5.54k| } _ZNK9protozero21TypedProtoDecoderBase11GetRepeatedIiEENS_21RepeatedFieldIteratorIT_EEj: 301| 26.3k| RepeatedFieldIterator GetRepeated(uint32_t field_id) const { 302| 26.3k| const Field* repeated_begin; 303| | // The storage for repeated fields starts after the slot for the highest 304| | // field id (refer to the diagram in the class-level comment). However, if 305| | // a message has more than INITIAL_STACK_CAPACITY field there will be no 306| | // slots available for the repeated fields (if ExpandHeapStorage() was not 307| | // called). Imagine a message that has highest field id = 102 and that is 308| | // still using the stack: 309| | // [ F0 ] [ F1 ] ... [ F100 ] [ F101 ] [ F1012] [ repeated fields ] 310| | // ^ num_fields_ 311| | // ^ size (== capacity) 312| 26.3k| if (PERFETTO_LIKELY(num_fields_ < size_)) { ------------------ | | 23| 26.3k|#define PERFETTO_LIKELY(...) __builtin_expect(!!(__VA_ARGS__), 1) | | ------------------ | | | Branch (23:30): [True: 19.7k, False: 6.64k] | | ------------------ ------------------ 313| 19.7k| repeated_begin = &fields_[num_fields_]; 314| 19.7k| } else { 315| | // This is the case of not having any storage space for repeated fields. 316| | // This makes it so begin == end, so the iterator will just skip @ last. 317| 6.64k| repeated_begin = &fields_[size_]; 318| 6.64k| } 319| 26.3k| const Field* repeated_end = &fields_[size_]; 320| 26.3k| const Field* last = &Get(field_id); 321| 26.3k| return RepeatedFieldIterator(field_id, repeated_begin, repeated_end, 322| 26.3k| last); 323| 26.3k| } _ZN9protozero21RepeatedFieldIteratorIiE18FindNextMatchingIdEv: 144| 403k| void FindNextMatchingId() { 145| 403k| PERFETTO_DCHECK(iter_ != last_); 146| 403k| for (; iter_ != end_; ++iter_) { ------------------ | Branch (146:12): [True: 377k, False: 26.3k] ------------------ 147| 377k| if (iter_->id() == field_id_) ------------------ | Branch (147:11): [True: 377k, False: 0] ------------------ 148| 377k| return; 149| 377k| } 150| 26.3k| iter_ = last_->valid() ? last_ : end_; ------------------ | Branch (150:13): [True: 19.8k, False: 6.53k] ------------------ 151| 26.3k| } _ZNK9protozero17TypedProtoDecoderILi11ELb1EE2atILj11EEERKNS_5FieldEv: 439| 282k| const Field& at() const { 440| 282k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 282k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 282k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 282k| return fields_[FIELD_ID]; 447| 282k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 282k| } _ZNK9protozero17TypedProtoDecoderILi11ELb1EE2atILj4EEERKNS_5FieldEv: 439| 279k| const Field& at() const { 440| 279k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 279k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 279k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 279k| return fields_[FIELD_ID]; 447| 279k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 279k| } _ZNK9protozero17TypedProtoDecoderILi11ELb1EE2atILj5EEERKNS_5FieldEv: 439| 287k| const Field& at() const { 440| 287k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 287k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 287k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 287k| return fields_[FIELD_ID]; 447| 287k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 287k| } _ZN9protozero17TypedProtoDecoderILi9ELb0EEC2EPKhm: 430| 1.75M| : TypedProtoDecoderBase(on_stack_storage_, 431| 1.75M| /*num_fields=*/MAX_FIELD_ID + 1, 432| 1.75M| PROTOZERO_DECODER_INITIAL_STACK_CAPACITY, ------------------ | | 422| 1.75M|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ 433| 1.75M| buffer, 434| 1.75M| length) { 435| 1.75M| TypedProtoDecoderBase::ParseAllFields(); 436| 1.75M| } _ZN9protozero17TypedProtoDecoderILi999ELb1EEC2EPKhm: 430| 1.75M| : TypedProtoDecoderBase(on_stack_storage_, 431| 1.75M| /*num_fields=*/MAX_FIELD_ID + 1, 432| 1.75M| PROTOZERO_DECODER_INITIAL_STACK_CAPACITY, ------------------ | | 422| 1.75M|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ 433| 1.75M| buffer, 434| 1.75M| length) { 435| 1.75M| TypedProtoDecoderBase::ParseAllFields(); 436| 1.75M| } _ZN9protozero17TypedProtoDecoderILi10ELb1EEC2EPKhm: 430| 291k| : TypedProtoDecoderBase(on_stack_storage_, 431| 291k| /*num_fields=*/MAX_FIELD_ID + 1, 432| 291k| PROTOZERO_DECODER_INITIAL_STACK_CAPACITY, ------------------ | | 422| 291k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ 433| 291k| buffer, 434| 291k| length) { 435| 291k| TypedProtoDecoderBase::ParseAllFields(); 436| 291k| } _ZN9protozero17TypedProtoDecoderILi5ELb1EEC2EPKhm: 430| 316k| : TypedProtoDecoderBase(on_stack_storage_, 431| 316k| /*num_fields=*/MAX_FIELD_ID + 1, 432| 316k| PROTOZERO_DECODER_INITIAL_STACK_CAPACITY, ------------------ | | 422| 316k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ 433| 316k| buffer, 434| 316k| length) { 435| 316k| TypedProtoDecoderBase::ParseAllFields(); 436| 316k| } _ZN9protozero17TypedProtoDecoderILi1ELb1EEC2EPKhm: 430| 34.2k| : TypedProtoDecoderBase(on_stack_storage_, 431| 34.2k| /*num_fields=*/MAX_FIELD_ID + 1, 432| 34.2k| PROTOZERO_DECODER_INITIAL_STACK_CAPACITY, ------------------ | | 422| 34.2k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ 433| 34.2k| buffer, 434| 34.2k| length) { 435| 34.2k| TypedProtoDecoderBase::ParseAllFields(); 436| 34.2k| } _ZN9protozero17TypedProtoDecoderILi11ELb1EEC2EPKhm: 430| 333k| : TypedProtoDecoderBase(on_stack_storage_, 431| 333k| /*num_fields=*/MAX_FIELD_ID + 1, 432| 333k| PROTOZERO_DECODER_INITIAL_STACK_CAPACITY, ------------------ | | 422| 333k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ 433| 333k| buffer, 434| 333k| length) { 435| 333k| TypedProtoDecoderBase::ParseAllFields(); 436| 333k| } _ZNK9protozero21RepeatedFieldIteratorINS_10ConstBytesEEptEv: 123| 3.71M| const Field* operator->() const { return iter_; } _ZNK9protozero17TypedProtoDecoderILi5ELb0EE2atILj1EEERKNS_5FieldEv: 439| 88.3k| const Field& at() const { 440| 88.3k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 88.3k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 88.3k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 88.3k| return fields_[FIELD_ID]; 447| 88.3k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 88.3k| } _ZNK9protozero17TypedProtoDecoderILi5ELb0EE2atILj2EEERKNS_5FieldEv: 439| 59.0k| const Field& at() const { 440| 59.0k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 59.0k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 59.0k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 59.0k| return fields_[FIELD_ID]; 447| 59.0k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 59.0k| } _ZNK9protozero17TypedProtoDecoderILi5ELb0EE2atILj3EEERKNS_5FieldEv: 439| 43.3k| const Field& at() const { 440| 43.3k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 43.3k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 43.3k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 43.3k| return fields_[FIELD_ID]; 447| 43.3k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 43.3k| } _ZNK9protozero17TypedProtoDecoderILi5ELb0EE2atILj4EEERKNS_5FieldEv: 439| 103k| const Field& at() const { 440| 103k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 103k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 103k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 103k| return fields_[FIELD_ID]; 447| 103k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 103k| } _ZNK9protozero17TypedProtoDecoderILi5ELb0EE2atILj5EEERKNS_5FieldEv: 439| 89.4k| const Field& at() const { 440| 89.4k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 89.4k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 89.4k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 89.4k| return fields_[FIELD_ID]; 447| 89.4k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 89.4k| } _ZN9protozero17TypedProtoDecoderILi4ELb0EEC2EPKhm: 430| 4.64M| : TypedProtoDecoderBase(on_stack_storage_, 431| 4.64M| /*num_fields=*/MAX_FIELD_ID + 1, 432| 4.64M| PROTOZERO_DECODER_INITIAL_STACK_CAPACITY, ------------------ | | 422| 4.64M|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ 433| 4.64M| buffer, 434| 4.64M| length) { 435| 4.64M| TypedProtoDecoderBase::ParseAllFields(); 436| 4.64M| } _ZN9protozero17TypedProtoDecoderILi6ELb0EEC2EPKhm: 430| 534| : TypedProtoDecoderBase(on_stack_storage_, 431| 534| /*num_fields=*/MAX_FIELD_ID + 1, 432| 534| PROTOZERO_DECODER_INITIAL_STACK_CAPACITY, ------------------ | | 422| 534|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ 433| 534| buffer, 434| 534| length) { 435| 534| TypedProtoDecoderBase::ParseAllFields(); 436| 534| } _ZN9protozero17TypedProtoDecoderILi2ELb1EEC2EPKhm: 430| 27.9k| : TypedProtoDecoderBase(on_stack_storage_, 431| 27.9k| /*num_fields=*/MAX_FIELD_ID + 1, 432| 27.9k| PROTOZERO_DECODER_INITIAL_STACK_CAPACITY, ------------------ | | 422| 27.9k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ 433| 27.9k| buffer, 434| 27.9k| length) { 435| 27.9k| TypedProtoDecoderBase::ParseAllFields(); 436| 27.9k| } _ZNK9protozero17TypedProtoDecoderILi5ELb1EE2atILj3EEERKNS_5FieldEv: 439| 38.5k| const Field& at() const { 440| 38.5k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 38.5k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 38.5k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 38.5k| return fields_[FIELD_ID]; 447| 38.5k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 38.5k| } _ZNK9protozero17TypedProtoDecoderILi5ELb1EE2atILj4EEERKNS_5FieldEv: 439| 153k| const Field& at() const { 440| 153k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 153k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 153k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 153k| return fields_[FIELD_ID]; 447| 153k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 153k| } _ZN9protozero17TypedProtoDecoderILi3ELb1EEC2EPKhm: 430| 119k| : TypedProtoDecoderBase(on_stack_storage_, 431| 119k| /*num_fields=*/MAX_FIELD_ID + 1, 432| 119k| PROTOZERO_DECODER_INITIAL_STACK_CAPACITY, ------------------ | | 422| 119k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ 433| 119k| buffer, 434| 119k| length) { 435| 119k| TypedProtoDecoderBase::ParseAllFields(); 436| 119k| } _ZN9protozero17TypedProtoDecoderILi9ELb1EEC2EPKhm: 430| 1.29k| : TypedProtoDecoderBase(on_stack_storage_, 431| 1.29k| /*num_fields=*/MAX_FIELD_ID + 1, 432| 1.29k| PROTOZERO_DECODER_INITIAL_STACK_CAPACITY, ------------------ | | 422| 1.29k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ 433| 1.29k| buffer, 434| 1.29k| length) { 435| 1.29k| TypedProtoDecoderBase::ParseAllFields(); 436| 1.29k| } _ZNK9protozero17TypedProtoDecoderILi9ELb1EE2atILj3EEERKNS_5FieldEv: 439| 1.36k| const Field& at() const { 440| 1.36k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 1.36k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 1.36k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 1.36k| return fields_[FIELD_ID]; 447| 1.36k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 1.36k| } _ZNK9protozero17TypedProtoDecoderILi9ELb1EE2atILj4EEERKNS_5FieldEv: 439| 1.93k| const Field& at() const { 440| 1.93k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 1.93k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 1.93k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 1.93k| return fields_[FIELD_ID]; 447| 1.93k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 1.93k| } _ZNK9protozero17TypedProtoDecoderILi9ELb1EE2atILj5EEERKNS_5FieldEv: 439| 1.29k| const Field& at() const { 440| 1.29k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 1.29k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 1.29k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 1.29k| return fields_[FIELD_ID]; 447| 1.29k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 1.29k| } _ZNK9protozero17TypedProtoDecoderILi9ELb1EE2atILj6EEERKNS_5FieldEv: 439| 1.36k| const Field& at() const { 440| 1.36k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 1.36k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 1.36k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 1.36k| return fields_[FIELD_ID]; 447| 1.36k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 1.36k| } _ZNK9protozero17TypedProtoDecoderILi9ELb1EE2atILj1EEERKNS_5FieldEv: 439| 1.43k| const Field& at() const { 440| 1.43k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 1.43k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 1.43k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 1.43k| return fields_[FIELD_ID]; 447| 1.43k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 1.43k| } _ZNK9protozero17TypedProtoDecoderILi9ELb1EE2atILj2EEERKNS_5FieldEv: 439| 1.73k| const Field& at() const { 440| 1.73k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 1.73k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 1.73k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 1.73k| return fields_[FIELD_ID]; 447| 1.73k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 1.73k| } _ZNK9protozero17TypedProtoDecoderILi9ELb1EE2atILj8EEERKNS_5FieldEv: 439| 1.67k| const Field& at() const { 440| 1.67k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 1.67k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 1.67k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 1.67k| return fields_[FIELD_ID]; 447| 1.67k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 1.67k| } _ZNK9protozero17TypedProtoDecoderILi9ELb1EE2atILj9EEERKNS_5FieldEv: 439| 1.29k| const Field& at() const { 440| 1.29k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 1.29k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 1.29k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 1.29k| return fields_[FIELD_ID]; 447| 1.29k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 1.29k| } _ZN9protozero17TypedProtoDecoderILi4ELb1EEC2EPKhm: 430| 7| : TypedProtoDecoderBase(on_stack_storage_, 431| 7| /*num_fields=*/MAX_FIELD_ID + 1, 432| 7| PROTOZERO_DECODER_INITIAL_STACK_CAPACITY, ------------------ | | 422| 7|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ 433| 7| buffer, 434| 7| length) { 435| 7| TypedProtoDecoderBase::ParseAllFields(); 436| 7| } _ZNK9protozero17TypedProtoDecoderILi11ELb0EE2atILj1EEERKNS_5FieldEv: 439| 34.7k| const Field& at() const { 440| 34.7k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 34.7k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 34.7k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 34.7k| return fields_[FIELD_ID]; 447| 34.7k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 34.7k| } _ZNK9protozero17TypedProtoDecoderILi11ELb0EE2atILj2EEERKNS_5FieldEv: 439| 34.7k| const Field& at() const { 440| 34.7k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 34.7k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 34.7k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 34.7k| return fields_[FIELD_ID]; 447| 34.7k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 34.7k| } _ZNK9protozero17TypedProtoDecoderILi11ELb0EE2atILj4EEERKNS_5FieldEv: 439| 34.7k| const Field& at() const { 440| 34.7k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 34.7k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 34.7k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 34.7k| return fields_[FIELD_ID]; 447| 34.7k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 34.7k| } _ZNK9protozero17TypedProtoDecoderILi11ELb0EE2atILj5EEERKNS_5FieldEv: 439| 34.7k| const Field& at() const { 440| 34.7k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 34.7k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 34.7k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 34.7k| return fields_[FIELD_ID]; 447| 34.7k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 34.7k| } _ZNK9protozero17TypedProtoDecoderILi11ELb0EE2atILj10EEERKNS_5FieldEv: 439| 34.7k| const Field& at() const { 440| 34.7k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 34.7k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 34.7k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 34.7k| return fields_[FIELD_ID]; 447| 34.7k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 34.7k| } _ZNK9protozero17TypedProtoDecoderILi11ELb0EE2atILj11EEERKNS_5FieldEv: 439| 34.7k| const Field& at() const { 440| 34.7k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 34.7k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 34.7k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 34.7k| return fields_[FIELD_ID]; 447| 34.7k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 34.7k| } _ZNK9protozero17TypedProtoDecoderILi11ELb0EE2atILj7EEERKNS_5FieldEv: 439| 34.7k| const Field& at() const { 440| 34.7k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 34.7k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 34.7k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 34.7k| return fields_[FIELD_ID]; 447| 34.7k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 34.7k| } _ZN9protozero17TypedProtoDecoderILi11ELb0EEC2EPKhm: 430| 34.7k| : TypedProtoDecoderBase(on_stack_storage_, 431| 34.7k| /*num_fields=*/MAX_FIELD_ID + 1, 432| 34.7k| PROTOZERO_DECODER_INITIAL_STACK_CAPACITY, ------------------ | | 422| 34.7k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ 433| 34.7k| buffer, 434| 34.7k| length) { 435| 34.7k| TypedProtoDecoderBase::ParseAllFields(); 436| 34.7k| } _ZNK9protozero17TypedProtoDecoderILi11ELb0EE2atILj3EEERKNS_5FieldEv: 439| 34.7k| const Field& at() const { 440| 34.7k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 34.7k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 34.7k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 34.7k| return fields_[FIELD_ID]; 447| 34.7k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 34.7k| } _ZNK9protozero21RepeatedFieldIteratorImEcvbEv: 115| 892k| explicit operator bool() const { return iter_ != end_; } _ZN9protozero21RepeatedFieldIteratorImEppEv: 125| 29.3k| RepeatedFieldIterator& operator++() { 126| 29.3k| PERFETTO_DCHECK(iter_ != end_); 127| 29.3k| if (iter_ == last_) { ------------------ | Branch (127:9): [True: 22.8k, False: 6.55k] ------------------ 128| 22.8k| iter_ = end_; 129| 22.8k| return *this; 130| 22.8k| } 131| 6.55k| ++iter_; 132| 6.55k| FindNextMatchingId(); 133| 6.55k| return *this; 134| 29.3k| } _ZNK9protozero21RepeatedFieldIteratorImEdeEv: 118| 36.8k| T operator*() const { 119| 36.8k| T val{}; 120| 36.8k| iter_->get(&val); 121| 36.8k| return val; 122| 36.8k| } _ZN9protozero17TypedProtoDecoderILi900ELb0EEC2EPKhm: 430| 14.1M| : TypedProtoDecoderBase(on_stack_storage_, 431| 14.1M| /*num_fields=*/MAX_FIELD_ID + 1, 432| 14.1M| PROTOZERO_DECODER_INITIAL_STACK_CAPACITY, ------------------ | | 422| 14.1M|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ 433| 14.1M| buffer, 434| 14.1M| length) { 435| 14.1M| TypedProtoDecoderBase::ParseAllFields(); 436| 14.1M| } _ZN9protozero17TypedProtoDecoderILi39ELb1EEC2EPKhm: 430| 3.28k| : TypedProtoDecoderBase(on_stack_storage_, 431| 3.28k| /*num_fields=*/MAX_FIELD_ID + 1, 432| 3.28k| PROTOZERO_DECODER_INITIAL_STACK_CAPACITY, ------------------ | | 422| 3.28k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ 433| 3.28k| buffer, 434| 3.28k| length) { 435| 3.28k| TypedProtoDecoderBase::ParseAllFields(); 436| 3.28k| } _ZN9protozero17TypedProtoDecoderILi5ELb0EEC2EPKhm: 430| 92.5k| : TypedProtoDecoderBase(on_stack_storage_, 431| 92.5k| /*num_fields=*/MAX_FIELD_ID + 1, 432| 92.5k| PROTOZERO_DECODER_INITIAL_STACK_CAPACITY, ------------------ | | 422| 92.5k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ 433| 92.5k| buffer, 434| 92.5k| length) { 435| 92.5k| TypedProtoDecoderBase::ParseAllFields(); 436| 92.5k| } _ZNK9protozero17TypedProtoDecoderILi11ELb1EE2atILj8EEERKNS_5FieldEv: 439| 282k| const Field& at() const { 440| 282k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 282k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 282k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 282k| return fields_[FIELD_ID]; 447| 282k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 282k| } _ZNK9protozero17TypedProtoDecoderILi11ELb1EE2atILj9EEERKNS_5FieldEv: 439| 2.38k| const Field& at() const { 440| 2.38k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 2.38k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 2.38k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 2.38k| return fields_[FIELD_ID]; 447| 2.38k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 2.38k| } _ZNK9protozero17TypedProtoDecoderILi11ELb1EE2atILj6EEERKNS_5FieldEv: 439| 287k| const Field& at() const { 440| 287k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 287k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 287k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 287k| return fields_[FIELD_ID]; 447| 287k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 287k| } _ZNK9protozero17TypedProtoDecoderILi39ELb1EE2atILj8EEERKNS_5FieldEv: 439| 2.18k| const Field& at() const { 440| 2.18k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 2.18k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 2.18k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 2.18k| return fields_[FIELD_ID]; 447| 2.18k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 2.18k| } _ZNK9protozero17TypedProtoDecoderILi39ELb1EE2atILj13EEERKNS_5FieldEv: 439| 475| const Field& at() const { 440| 475| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 475| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 475|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 475| return fields_[FIELD_ID]; 447| 475| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 475| } _ZN9protozero17TypedProtoDecoderILi1ELb0EEC2EPKhm: 430| 23.8k| : TypedProtoDecoderBase(on_stack_storage_, 431| 23.8k| /*num_fields=*/MAX_FIELD_ID + 1, 432| 23.8k| PROTOZERO_DECODER_INITIAL_STACK_CAPACITY, ------------------ | | 422| 23.8k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ 433| 23.8k| buffer, 434| 23.8k| length) { 435| 23.8k| TypedProtoDecoderBase::ParseAllFields(); 436| 23.8k| } _ZN9protozero17TypedProtoDecoderILi99ELb0EEC2EPKhm: 430| 814| : TypedProtoDecoderBase(on_stack_storage_, 431| 814| /*num_fields=*/MAX_FIELD_ID + 1, 432| 814| PROTOZERO_DECODER_INITIAL_STACK_CAPACITY, ------------------ | | 422| 814|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ 433| 814| buffer, 434| 814| length) { 435| 814| TypedProtoDecoderBase::ParseAllFields(); 436| 814| } _ZN9protozero17TypedProtoDecoderILi18ELb1EEC2EPKhm: 430| 24| : TypedProtoDecoderBase(on_stack_storage_, 431| 24| /*num_fields=*/MAX_FIELD_ID + 1, 432| 24| PROTOZERO_DECODER_INITIAL_STACK_CAPACITY, ------------------ | | 422| 24|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ 433| 24| buffer, 434| 24| length) { 435| 24| TypedProtoDecoderBase::ParseAllFields(); 436| 24| } _ZNK9protozero17TypedProtoDecoderILi18ELb1EE2atILj2EEERKNS_5FieldEv: 439| 24| const Field& at() const { 440| 24| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 24| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 24|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 24| return fields_[FIELD_ID]; 447| 24| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 24| } _ZNK9protozero17TypedProtoDecoderILi18ELb1EE2atILj3EEERKNS_5FieldEv: 439| 24| const Field& at() const { 440| 24| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 24| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 24|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 24| return fields_[FIELD_ID]; 447| 24| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 24| } _ZNK9protozero17TypedProtoDecoderILi18ELb1EE2atILj4EEERKNS_5FieldEv: 439| 24| const Field& at() const { 440| 24| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 24| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 24|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 24| return fields_[FIELD_ID]; 447| 24| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 24| } _ZNK9protozero17TypedProtoDecoderILi18ELb1EE2atILj5EEERKNS_5FieldEv: 439| 24| const Field& at() const { 440| 24| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 24| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 24|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 24| return fields_[FIELD_ID]; 447| 24| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 24| } _ZNK9protozero17TypedProtoDecoderILi18ELb1EE2atILj6EEERKNS_5FieldEv: 439| 24| const Field& at() const { 440| 24| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 24| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 24|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 24| return fields_[FIELD_ID]; 447| 24| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 24| } _ZNK9protozero17TypedProtoDecoderILi18ELb1EE2atILj7EEERKNS_5FieldEv: 439| 24| const Field& at() const { 440| 24| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 24| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 24|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 24| return fields_[FIELD_ID]; 447| 24| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 24| } _ZNK9protozero17TypedProtoDecoderILi18ELb1EE2atILj8EEERKNS_5FieldEv: 439| 24| const Field& at() const { 440| 24| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 24| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 24|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 24| return fields_[FIELD_ID]; 447| 24| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 24| } _ZNK9protozero17TypedProtoDecoderILi18ELb1EE2atILj9EEERKNS_5FieldEv: 439| 24| const Field& at() const { 440| 24| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 24| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 24|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 24| return fields_[FIELD_ID]; 447| 24| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 24| } _ZNK9protozero17TypedProtoDecoderILi18ELb1EE2atILj12EEERKNS_5FieldEv: 439| 24| const Field& at() const { 440| 24| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 24| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 24|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 24| return fields_[FIELD_ID]; 447| 24| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 24| } _ZNK9protozero17TypedProtoDecoderILi18ELb1EE2atILj13EEERKNS_5FieldEv: 439| 24| const Field& at() const { 440| 24| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 24| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 24|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 24| return fields_[FIELD_ID]; 447| 24| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 24| } _ZNK9protozero17TypedProtoDecoderILi18ELb1EE2atILj14EEERKNS_5FieldEv: 439| 24| const Field& at() const { 440| 24| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 24| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 24|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 24| return fields_[FIELD_ID]; 447| 24| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 24| } _ZNK9protozero17TypedProtoDecoderILi18ELb1EE2atILj11EEERKNS_5FieldEv: 439| 26| const Field& at() const { 440| 26| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 26| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 26|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 26| return fields_[FIELD_ID]; 447| 26| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 26| } _ZN9protozero17TypedProtoDecoderILi20ELb1EEC2EPKhm: 430| 2| : TypedProtoDecoderBase(on_stack_storage_, 431| 2| /*num_fields=*/MAX_FIELD_ID + 1, 432| 2| PROTOZERO_DECODER_INITIAL_STACK_CAPACITY, ------------------ | | 422| 2|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ 433| 2| buffer, 434| 2| length) { 435| 2| TypedProtoDecoderBase::ParseAllFields(); 436| 2| } _ZNK9protozero17TypedProtoDecoderILi20ELb1EE2atILj4EEERKNS_5FieldEv: 439| 2| const Field& at() const { 440| 2| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 2| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 2|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 2| return fields_[FIELD_ID]; 447| 2| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 2| } _ZNK9protozero17TypedProtoDecoderILi20ELb1EE2atILj2EEERKNS_5FieldEv: 439| 2| const Field& at() const { 440| 2| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 2| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 2|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 2| return fields_[FIELD_ID]; 447| 2| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 2| } _ZNK9protozero17TypedProtoDecoderILi20ELb1EE2atILj1EEERKNS_5FieldEv: 439| 2| const Field& at() const { 440| 2| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 2| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 2|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 2| return fields_[FIELD_ID]; 447| 2| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 2| } _ZNK9protozero17TypedProtoDecoderILi20ELb1EE2atILj3EEERKNS_5FieldEv: 439| 2| const Field& at() const { 440| 2| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 2| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 2|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 2| return fields_[FIELD_ID]; 447| 2| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 2| } _ZNK9protozero17TypedProtoDecoderILi20ELb1EE2atILj5EEERKNS_5FieldEv: 439| 2| const Field& at() const { 440| 2| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 2| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 2|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 2| return fields_[FIELD_ID]; 447| 2| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 2| } _ZN9protozero21RepeatedFieldIteratorImEC2EjPKNS_5FieldES4_S4_: 107| 2.87M| : field_id_(field_id), iter_(begin), end_(end), last_(last) { 108| 2.87M| FindNextMatchingId(); 109| 2.87M| } _ZNK9protozero17TypedProtoDecoderILi18ELb1EE2atILj15EEERKNS_5FieldEv: 439| 24| const Field& at() const { 440| 24| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 24| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 24|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 24| return fields_[FIELD_ID]; 447| 24| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 24| } _ZN9protozero17TypedProtoDecoderILi19ELb0EEC2EPKhm: 430| 1.23M| : TypedProtoDecoderBase(on_stack_storage_, 431| 1.23M| /*num_fields=*/MAX_FIELD_ID + 1, 432| 1.23M| PROTOZERO_DECODER_INITIAL_STACK_CAPACITY, ------------------ | | 422| 1.23M|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ 433| 1.23M| buffer, 434| 1.23M| length) { 435| 1.23M| TypedProtoDecoderBase::ParseAllFields(); 436| 1.23M| } _ZNK9protozero17TypedProtoDecoderILi19ELb0EE2atILj16EEERKNS_5FieldEv: 439| 59| const Field& at() const { 440| 59| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 59| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 59|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 59| return fields_[FIELD_ID]; 447| 59| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 59| } _ZNK9protozero17TypedProtoDecoderILi19ELb0EE2atILj17EEERKNS_5FieldEv: 439| 59| const Field& at() const { 440| 59| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 59| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 59|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 59| return fields_[FIELD_ID]; 447| 59| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 59| } _ZNK9protozero17TypedProtoDecoderILi19ELb0EE2atILj5EEERKNS_5FieldEv: 439| 59| const Field& at() const { 440| 59| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 59| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 59|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 59| return fields_[FIELD_ID]; 447| 59| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 59| } _ZN9protozero17TypedProtoDecoderILi13ELb0EEC2EPKhm: 430| 248k| : TypedProtoDecoderBase(on_stack_storage_, 431| 248k| /*num_fields=*/MAX_FIELD_ID + 1, 432| 248k| PROTOZERO_DECODER_INITIAL_STACK_CAPACITY, ------------------ | | 422| 248k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ 433| 248k| buffer, 434| 248k| length) { 435| 248k| TypedProtoDecoderBase::ParseAllFields(); 436| 248k| } _ZNK9protozero17TypedProtoDecoderILi13ELb0EE2atILj1EEERKNS_5FieldEv: 439| 380k| const Field& at() const { 440| 380k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 380k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 380k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 380k| return fields_[FIELD_ID]; 447| 380k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 380k| } _ZNK9protozero17TypedProtoDecoderILi13ELb0EE2atILj4EEERKNS_5FieldEv: 439| 237k| const Field& at() const { 440| 237k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 237k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 237k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 237k| return fields_[FIELD_ID]; 447| 237k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 237k| } _ZNK9protozero17TypedProtoDecoderILi13ELb0EE2atILj7EEERKNS_5FieldEv: 439| 5.25k| const Field& at() const { 440| 5.25k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 5.25k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 5.25k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 5.25k| return fields_[FIELD_ID]; 447| 5.25k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 5.25k| } _ZNK9protozero17TypedProtoDecoderILi13ELb0EE2atILj3EEERKNS_5FieldEv: 439| 277k| const Field& at() const { 440| 277k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 277k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 277k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 277k| return fields_[FIELD_ID]; 447| 277k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 277k| } _ZNK9protozero17TypedProtoDecoderILi13ELb0EE2atILj6EEERKNS_5FieldEv: 439| 71.8k| const Field& at() const { 440| 71.8k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 71.8k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 71.8k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 71.8k| return fields_[FIELD_ID]; 447| 71.8k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 71.8k| } _ZNK9protozero17TypedProtoDecoderILi13ELb0EE2atILj2EEERKNS_5FieldEv: 439| 321k| const Field& at() const { 440| 321k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 321k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 321k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 321k| return fields_[FIELD_ID]; 447| 321k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 321k| } _ZNK9protozero17TypedProtoDecoderILi13ELb0EE2atILj10EEERKNS_5FieldEv: 439| 107k| const Field& at() const { 440| 107k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 107k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 107k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 107k| return fields_[FIELD_ID]; 447| 107k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 107k| } _ZNK9protozero17TypedProtoDecoderILi13ELb0EE2atILj13EEERKNS_5FieldEv: 439| 37.6k| const Field& at() const { 440| 37.6k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 37.6k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 37.6k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 37.6k| return fields_[FIELD_ID]; 447| 37.6k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 37.6k| } _ZN9protozero17TypedProtoDecoderILi8ELb0EEC2EPKhm: 430| 24.3k| : TypedProtoDecoderBase(on_stack_storage_, 431| 24.3k| /*num_fields=*/MAX_FIELD_ID + 1, 432| 24.3k| PROTOZERO_DECODER_INITIAL_STACK_CAPACITY, ------------------ | | 422| 24.3k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ 433| 24.3k| buffer, 434| 24.3k| length) { 435| 24.3k| TypedProtoDecoderBase::ParseAllFields(); 436| 24.3k| } _ZN9protozero17TypedProtoDecoderILi50ELb1EEC2EPKhm: 430| 1.87M| : TypedProtoDecoderBase(on_stack_storage_, 431| 1.87M| /*num_fields=*/MAX_FIELD_ID + 1, 432| 1.87M| PROTOZERO_DECODER_INITIAL_STACK_CAPACITY, ------------------ | | 422| 1.87M|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ 433| 1.87M| buffer, 434| 1.87M| length) { 435| 1.87M| TypedProtoDecoderBase::ParseAllFields(); 436| 1.87M| } _ZN9protozero17TypedProtoDecoderILi45ELb1EEC2EPKhm: 430| 506| : TypedProtoDecoderBase(on_stack_storage_, 431| 506| /*num_fields=*/MAX_FIELD_ID + 1, 432| 506| PROTOZERO_DECODER_INITIAL_STACK_CAPACITY, ------------------ | | 422| 506|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ 433| 506| buffer, 434| 506| length) { 435| 506| TypedProtoDecoderBase::ParseAllFields(); 436| 506| } _ZN9protozero21RepeatedFieldIteratorImEC2Ev: 113| 980k| : field_id_(0u), iter_(nullptr), end_(nullptr), last_(nullptr) {} _ZN9protozero21RepeatedFieldIteratorIlEC2EjPKNS_5FieldES4_S4_: 107| 971k| : field_id_(field_id), iter_(begin), end_(end), last_(last) { 108| 971k| FindNextMatchingId(); 109| 971k| } _ZNK9protozero21RepeatedFieldIteratorIlEcvbEv: 115| 976k| explicit operator bool() const { return iter_ != end_; } _ZN9protozero21RepeatedFieldIteratorIdEC2EjPKNS_5FieldES4_S4_: 107| 961k| : field_id_(field_id), iter_(begin), end_(end), last_(last) { 108| 961k| FindNextMatchingId(); 109| 961k| } _ZNK9protozero21RepeatedFieldIteratorIdEcvbEv: 115| 961k| explicit operator bool() const { return iter_ != end_; } _ZN9protozero21RepeatedFieldIteratorIiEC2EjPKNS_5FieldES4_S4_: 107| 26.3k| : field_id_(field_id), iter_(begin), end_(end), last_(last) { 108| 26.3k| FindNextMatchingId(); 109| 26.3k| } _ZNK9protozero21RepeatedFieldIteratorIiEcvbEv: 115| 423k| explicit operator bool() const { return iter_ != end_; } _ZNK9protozero21RepeatedFieldIteratorIiEdeEv: 118| 397k| T operator*() const { 119| 397k| T val{}; 120| 397k| iter_->get(&val); 121| 397k| return val; 122| 397k| } _ZN9protozero21RepeatedFieldIteratorIiEppEv: 125| 397k| RepeatedFieldIterator& operator++() { 126| 397k| PERFETTO_DCHECK(iter_ != end_); 127| 397k| if (iter_ == last_) { ------------------ | Branch (127:9): [True: 19.8k, False: 377k] ------------------ 128| 19.8k| iter_ = end_; 129| 19.8k| return *this; 130| 19.8k| } 131| 377k| ++iter_; 132| 377k| FindNextMatchingId(); 133| 377k| return *this; 134| 397k| } _ZN9protozero21RepeatedFieldIteratorINS_10ConstCharsEEppEi: 136| 64.9k| RepeatedFieldIterator operator++(int) { 137| 64.9k| PERFETTO_DCHECK(iter_ != end_); 138| 64.9k| RepeatedFieldIterator it(*this); 139| 64.9k| ++(*this); 140| 64.9k| return it; 141| 64.9k| } _ZNK9protozero17TypedProtoDecoderILi13ELb0EE2atILj5EEERKNS_5FieldEv: 439| 160k| const Field& at() const { 440| 160k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 160k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 160k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 160k| return fields_[FIELD_ID]; 447| 160k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 160k| } _ZNK9protozero17TypedProtoDecoderILi13ELb0EE2atILj8EEERKNS_5FieldEv: 439| 79.4k| const Field& at() const { 440| 79.4k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 79.4k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 79.4k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 79.4k| return fields_[FIELD_ID]; 447| 79.4k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 79.4k| } _ZNK9protozero17TypedProtoDecoderILi13ELb0EE2atILj9EEERKNS_5FieldEv: 439| 8.49k| const Field& at() const { 440| 8.49k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 8.49k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 8.49k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 8.49k| return fields_[FIELD_ID]; 447| 8.49k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 8.49k| } _ZNK9protozero17TypedProtoDecoderILi13ELb0EE2atILj11EEERKNS_5FieldEv: 439| 130k| const Field& at() const { 440| 130k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 130k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 130k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 130k| return fields_[FIELD_ID]; 447| 130k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 130k| } _ZNK9protozero17TypedProtoDecoderILi13ELb0EE2atILj12EEERKNS_5FieldEv: 439| 131k| const Field& at() const { 440| 131k| static_assert(FIELD_ID <= MAX_FIELD_ID, "FIELD_ID > MAX_FIELD_ID"); 441| | // If the field id is < the on-stack capacity, it's safe to always 442| | // dereference |fields_|, whether it's still using the stack or it fell 443| | // back on the heap. Because both terms of the if () are known at compile 444| | // time, the compiler elides the branch for ids < INITIAL_STACK_CAPACITY. 445| 131k| if (FIELD_ID < PROTOZERO_DECODER_INITIAL_STACK_CAPACITY) { ------------------ | | 422| 131k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ | Branch (445:9): [Folded - Ignored] ------------------ 446| 131k| return fields_[FIELD_ID]; 447| 131k| } else { 448| | // Otherwise use the slowpath Get() which will do a runtime check. 449| 0| return Get(FIELD_ID); 450| 0| } 451| 131k| } _ZN9protozero17TypedProtoDecoderILi6ELb1EEC2EPKhm: 430| 20.3k| : TypedProtoDecoderBase(on_stack_storage_, 431| 20.3k| /*num_fields=*/MAX_FIELD_ID + 1, 432| 20.3k| PROTOZERO_DECODER_INITIAL_STACK_CAPACITY, ------------------ | | 422| 20.3k|#define PROTOZERO_DECODER_INITIAL_STACK_CAPACITY 100 ------------------ 433| 20.3k| buffer, 434| 20.3k| length) { 435| 20.3k| TypedProtoDecoderBase::ParseAllFields(); 436| 20.3k| } _ZNK9protozero21RepeatedFieldIteratorIlEdeEv: 118| 2.17k| T operator*() const { 119| 2.17k| T val{}; 120| 2.17k| iter_->get(&val); 121| 2.17k| return val; 122| 2.17k| } _ZN9protozero11proto_utils11ParseVarIntEPKhS2_Pm: 257| 140M| uint64_t* out_value) { 258| 140M| return PerfettoPbParseVarInt(start, end, out_value); 259| 140M|} _ZN9protozero11proto_utils11WriteVarIntImEEPhT_S2_: 209| 154k|inline uint8_t* WriteVarInt(T value, uint8_t* target) { 210| 154k| auto unsigned_value = ExtendValueForVarIntSerialization(value); 211| | 212| 154k| while (unsigned_value >= 0x80) { ------------------ | Branch (212:10): [True: 0, False: 154k] ------------------ 213| 0| *target++ = static_cast(unsigned_value) | 0x80; 214| 0| unsigned_value >>= 7; 215| 0| } 216| 154k| *target = static_cast(unsigned_value); 217| 154k| return target + 1; 218| 154k|} _ZN9protozero11proto_utils33ExtendValueForVarIntSerializationImEENSt3__113make_unsignedINS2_11conditionalIXsr3std11is_unsignedIT_EE5valueES5_lE4typeEE4typeES5_: 185| 154k| type { 186| | // If value is <= 0 we must first sign extend to int64_t (see [1]). 187| | // Finally we always cast to an unsigned value to to avoid arithmetic 188| | // (sign expanding) shifts in the while loop. 189| | // [1]: "If you use int32 or int64 as the type for a negative number, the 190| | // resulting varint is always ten bytes long". 191| | // - developers.google.com/protocol-buffers/docs/encoding 192| | // So for each input type we do the following casts: 193| | // uintX_t -> uintX_t -> uintX_t 194| | // int8_t -> int64_t -> uint64_t 195| | // int16_t -> int64_t -> uint64_t 196| | // int32_t -> int64_t -> uint64_t 197| | // int64_t -> int64_t -> uint64_t 198| 154k| using MaybeExtendedType = 199| 154k| typename std::conditional::value, T, int64_t>::type; 200| 154k| using UnsignedType = typename std::make_unsigned::type; 201| | 202| 154k| MaybeExtendedType extended_value = static_cast(value); 203| 154k| UnsignedType unsigned_value = static_cast(extended_value); 204| | 205| 154k| return unsigned_value; 206| 154k|} proto_decoder.cc:_ZL21PerfettoPbParseVarIntPKhS0_Pm: 99| 103M| uint64_t* out_value) { 100| 103M| const uint8_t* pos = start; 101| 103M| uint64_t value = 0; 102| 113M| for (uint32_t shift = 0; pos < end && shift < 64u; shift += 7) { ------------------ | Branch (102:28): [True: 113M, False: 347k] | Branch (102:41): [True: 113M, False: 1.39k] ------------------ 103| | // Cache *pos into |cur_byte| to prevent that the compiler dereferences the 104| | // pointer twice (here and in the if() below) due to char* aliasing rules. 105| 113M| uint8_t cur_byte = *pos++; 106| 113M| value |= PERFETTO_STATIC_CAST(uint64_t, cur_byte & 0x7f) << shift; ------------------ | | 33| 113M|#define PERFETTO_STATIC_CAST(TYPE, VAL) static_cast(VAL) ------------------ 107| 113M| if ((cur_byte & 0x80) == 0) { ------------------ | Branch (107:9): [True: 103M, False: 10.0M] ------------------ 108| | // In valid cases we get here. 109| 103M| *out_value = value; 110| 103M| return pos; 111| 103M| } 112| 113M| } 113| 348k| *out_value = 0; 114| 348k| return start; 115| 103M|} string_pool.cc:_ZL21PerfettoPbParseVarIntPKhS0_Pm: 99| 279k| uint64_t* out_value) { 100| 279k| const uint8_t* pos = start; 101| 279k| uint64_t value = 0; 102| 279k| for (uint32_t shift = 0; pos < end && shift < 64u; shift += 7) { ------------------ | Branch (102:28): [True: 279k, False: 0] | Branch (102:41): [True: 279k, False: 0] ------------------ 103| | // Cache *pos into |cur_byte| to prevent that the compiler dereferences the 104| | // pointer twice (here and in the if() below) due to char* aliasing rules. 105| 279k| uint8_t cur_byte = *pos++; 106| 279k| value |= PERFETTO_STATIC_CAST(uint64_t, cur_byte & 0x7f) << shift; ------------------ | | 33| 279k|#define PERFETTO_STATIC_CAST(TYPE, VAL) static_cast(VAL) ------------------ 107| 279k| if ((cur_byte & 0x80) == 0) { ------------------ | Branch (107:9): [True: 279k, False: 0] ------------------ 108| | // In valid cases we get here. 109| 279k| *out_value = value; 110| 279k| return pos; 111| 279k| } 112| 279k| } 113| 0| *out_value = 0; 114| 0| return start; 115| 279k|} trace_type.cc:_ZL21PerfettoPbParseVarIntPKhS0_Pm: 99| 1.24k| uint64_t* out_value) { 100| 1.24k| const uint8_t* pos = start; 101| 1.24k| uint64_t value = 0; 102| 1.51k| for (uint32_t shift = 0; pos < end && shift < 64u; shift += 7) { ------------------ | Branch (102:28): [True: 1.51k, False: 0] | Branch (102:41): [True: 1.51k, False: 1] ------------------ 103| | // Cache *pos into |cur_byte| to prevent that the compiler dereferences the 104| | // pointer twice (here and in the if() below) due to char* aliasing rules. 105| 1.51k| uint8_t cur_byte = *pos++; 106| 1.51k| value |= PERFETTO_STATIC_CAST(uint64_t, cur_byte & 0x7f) << shift; ------------------ | | 33| 1.51k|#define PERFETTO_STATIC_CAST(TYPE, VAL) static_cast(VAL) ------------------ 107| 1.51k| if ((cur_byte & 0x80) == 0) { ------------------ | Branch (107:9): [True: 1.24k, False: 263] ------------------ 108| | // In valid cases we get here. 109| 1.24k| *out_value = value; 110| 1.24k| return pos; 111| 1.24k| } 112| 1.51k| } 113| 1| *out_value = 0; 114| 1| return start; 115| 1.24k|} proto_trace_reader.cc:_ZL21PerfettoPbParseVarIntPKhS0_Pm: 99| 36.4M| uint64_t* out_value) { 100| 36.4M| const uint8_t* pos = start; 101| 36.4M| uint64_t value = 0; 102| 36.8M| for (uint32_t shift = 0; pos < end && shift < 64u; shift += 7) { ------------------ | Branch (102:28): [True: 36.8M, False: 0] | Branch (102:41): [True: 36.8M, False: 3] ------------------ 103| | // Cache *pos into |cur_byte| to prevent that the compiler dereferences the 104| | // pointer twice (here and in the if() below) due to char* aliasing rules. 105| 36.8M| uint8_t cur_byte = *pos++; 106| 36.8M| value |= PERFETTO_STATIC_CAST(uint64_t, cur_byte & 0x7f) << shift; ------------------ | | 33| 36.8M|#define PERFETTO_STATIC_CAST(TYPE, VAL) static_cast(VAL) ------------------ 107| 36.8M| if ((cur_byte & 0x80) == 0) { ------------------ | Branch (107:9): [True: 36.4M, False: 361k] ------------------ 108| | // In valid cases we get here. 109| 36.4M| *out_value = value; 110| 36.4M| return pos; 111| 36.4M| } 112| 36.8M| } 113| 3| *out_value = 0; 114| 3| return start; 115| 36.4M|} _ZNK8perfetto15trace_processor10RefCounted6AddRefEv: 54| 75.6M| void AddRef() const { 55| 75.6M| PERFETTO_DCHECK(refcount_ >= 0); 56| 75.6M| ++refcount_; 57| 75.6M| } _ZNK8perfetto15trace_processor10RefCounted7ReleaseEv: 58| 75.6M| bool Release() const { 59| 75.6M| PERFETTO_DCHECK(refcount_ > 0); 60| 75.6M| return --refcount_ == 0; 61| 75.6M| } _ZN8perfetto15trace_processor6RefPtrINS0_9TraceBlobEE5resetEv: 82| 300M| void reset() { 83| 300M| auto* old_ptr = ptr_; 84| 300M| ptr_ = nullptr; 85| 300M| if (old_ptr && old_ptr->Release()) ------------------ | Branch (85:9): [True: 65.6M, False: 234M] | Branch (85:20): [True: 593, False: 65.6M] ------------------ 86| 593| delete old_ptr; 87| 300M| } _ZN8perfetto15trace_processor6RefPtrINS0_9TraceBlobEE5resetEPS2_: 90| 593| void reset(T* new_obj) { *this = RefPtr(new_obj); } _ZNK8perfetto15trace_processor6RefPtrINS0_9TraceBlobEEptEv: 151| 11.1M| T* operator->() const { return ptr_; } _ZN8perfetto15trace_processor6RefPtrINS0_9TraceBlobEEaSEOS3_: 117| 98.0M| RefPtr& operator=(RefPtr&& move_from) noexcept { 118| 98.0M| this->~RefPtr(); 119| 98.0M| new (this) RefPtr(std::move(move_from)); 120| 98.0M| return *this; 121| 98.0M| } _ZN8perfetto15trace_processor6RefPtrINS0_9TraceBlobEEC2Ev: 74| 74.7M| RefPtr() : ptr_(nullptr) {} _ZN8perfetto15trace_processor6RefPtrINS0_9TraceBlobEED2Ev: 80| 300M| ~RefPtr() { reset(); } _ZN8perfetto15trace_processor6RefPtrINS0_9TraceBlobEEC2EOS3_: 112| 160M| RefPtr(RefPtr&& move_from) noexcept { 113| 160M| ptr_ = move_from.ptr_; 114| 160M| move_from.ptr_ = nullptr; 115| 160M| } _ZN8perfetto15trace_processor6RefPtrINS0_6column12StorageLayerEE5resetEv: 82| 667k| void reset() { 83| 667k| auto* old_ptr = ptr_; 84| 667k| ptr_ = nullptr; 85| 667k| if (old_ptr && old_ptr->Release()) ------------------ | Branch (85:9): [True: 667k, False: 0] | Branch (85:20): [True: 218k, False: 449k] ------------------ 86| 218k| delete old_ptr; 87| 667k| } _ZN8perfetto15trace_processor6RefPtrINS0_6column12OverlayLayerEE5resetEv: 82| 539k| void reset() { 83| 539k| auto* old_ptr = ptr_; 84| 539k| ptr_ = nullptr; 85| 539k| if (old_ptr && old_ptr->Release()) ------------------ | Branch (85:9): [True: 167k, False: 372k] | Branch (85:20): [True: 54.2k, False: 112k] ------------------ 86| 54.2k| delete old_ptr; 87| 539k| } _ZN8perfetto15trace_processor6RefPtrINS0_6column12OverlayLayerEE5resetEPS3_: 90| 434| void reset(T* new_obj) { *this = RefPtr(new_obj); } _ZN8perfetto15trace_processor6RefPtrINS0_6column12OverlayLayerEEaSEOS4_: 117| 434| RefPtr& operator=(RefPtr&& move_from) noexcept { 118| 434| this->~RefPtr(); 119| 434| new (this) RefPtr(std::move(move_from)); 120| 434| return *this; 121| 434| } _ZN8perfetto15trace_processor6RefPtrINS0_29PacketSequenceStateGeneration11CustomStateEE5resetEv: 82| 275k| void reset() { 83| 275k| auto* old_ptr = ptr_; 84| 275k| ptr_ = nullptr; 85| 275k| if (old_ptr && old_ptr->Release()) ------------------ | Branch (85:9): [True: 0, False: 275k] | Branch (85:20): [True: 0, False: 0] ------------------ 86| 0| delete old_ptr; 87| 275k| } _ZN8perfetto15trace_processor6RefPtrINS0_29PacketSequenceStateGenerationEE5resetEv: 82| 42.2M| void reset() { 83| 42.2M| auto* old_ptr = ptr_; 84| 42.2M| ptr_ = nullptr; 85| 42.2M| if (old_ptr && old_ptr->Release()) ------------------ | Branch (85:9): [True: 9.11M, False: 33.1M] | Branch (85:20): [True: 67.9k, False: 9.05M] ------------------ 86| 67.9k| delete old_ptr; 87| 42.2M| } _ZN8perfetto15trace_processor6RefPtrINS0_29PacketSequenceStateGenerationEEaSEOS3_: 117| 68.0k| RefPtr& operator=(RefPtr&& move_from) noexcept { 118| 68.0k| this->~RefPtr(); 119| 68.0k| new (this) RefPtr(std::move(move_from)); 120| 68.0k| return *this; 121| 68.0k| } _ZNK8perfetto15trace_processor6RefPtrINS0_29PacketSequenceStateGenerationEEptEv: 151| 5.96M| T* operator->() const { return ptr_; } _ZN8perfetto15trace_processor10RefCountedC2Ev: 44| 341k| RefCounted() = default; _ZN8perfetto15trace_processor6RefPtrINS0_9TraceBlobEEC2EPS2_: 75| 593| explicit RefPtr(T* ptr) : ptr_(ptr) { 76| 593| if (ptr_) ------------------ | Branch (76:9): [True: 593, False: 0] ------------------ 77| 593| ptr_->AddRef(); 78| 593| } _ZN8perfetto15trace_processor6RefPtrINS0_6column12StorageLayerEED2Ev: 80| 667k| ~RefPtr() { reset(); } _ZN8perfetto15trace_processor6RefPtrINS0_6column12OverlayLayerEED2Ev: 80| 539k| ~RefPtr() { reset(); } _ZN8perfetto15trace_processor6RefPtrINS0_6column12StorageLayerEEC2ERKS4_: 124| 449k| RefPtr(const RefPtr& copy_from) { 125| 449k| ptr_ = copy_from.ptr_; 126| 449k| if (ptr_) ------------------ | Branch (126:9): [True: 449k, False: 0] ------------------ 127| 449k| ptr_->AddRef(); 128| 449k| } _ZN8perfetto15trace_processor6RefPtrINS0_6column12OverlayLayerEEC2ERKS4_: 124| 281k| RefPtr(const RefPtr& copy_from) { 125| 281k| ptr_ = copy_from.ptr_; 126| 281k| if (ptr_) ------------------ | Branch (126:9): [True: 112k, False: 168k] ------------------ 127| 112k| ptr_->AddRef(); 128| 281k| } _ZN8perfetto15trace_processor6RefPtrINS0_6column12OverlayLayerEEC2Ev: 74| 203k| RefPtr() : ptr_(nullptr) {} _ZN8perfetto15trace_processor6RefPtrINS0_6column12OverlayLayerEEC2EPS3_: 75| 54.2k| explicit RefPtr(T* ptr) : ptr_(ptr) { 76| 54.2k| if (ptr_) ------------------ | Branch (76:9): [True: 54.2k, False: 0] ------------------ 77| 54.2k| ptr_->AddRef(); 78| 54.2k| } _ZN8perfetto15trace_processor6RefPtrINS0_6column12OverlayLayerEEC2EOS4_: 112| 434| RefPtr(RefPtr&& move_from) noexcept { 113| 434| ptr_ = move_from.ptr_; 114| 434| move_from.ptr_ = nullptr; 115| 434| } _ZN8perfetto15trace_processor6RefPtrINS0_6column12StorageLayerEEC2EPS3_: 75| 218k| explicit RefPtr(T* ptr) : ptr_(ptr) { 76| 218k| if (ptr_) ------------------ | Branch (76:9): [True: 218k, False: 0] ------------------ 77| 218k| ptr_->AddRef(); 78| 218k| } _ZN8perfetto15trace_processor6RefPtrINS0_29PacketSequenceStateGenerationEED2Ev: 80| 42.2M| ~RefPtr() { reset(); } _ZN8perfetto15trace_processor6RefPtrINS0_29PacketSequenceStateGeneration11CustomStateEED2Ev: 80| 275k| ~RefPtr() { reset(); } _ZN8perfetto15trace_processor6RefPtrINS0_29PacketSequenceStateGenerationEEC2EOS3_: 112| 29.3M| RefPtr(RefPtr&& move_from) noexcept { 113| 29.3M| ptr_ = move_from.ptr_; 114| 29.3M| move_from.ptr_ = nullptr; 115| 29.3M| } _ZN8perfetto15trace_processor6RefPtrINS0_29PacketSequenceStateGenerationEEC2ERKS3_: 124| 9.05M| RefPtr(const RefPtr& copy_from) { 125| 9.05M| ptr_ = copy_from.ptr_; 126| 9.05M| if (ptr_) ------------------ | Branch (126:9): [True: 9.05M, False: 0] ------------------ 127| 9.05M| ptr_->AddRef(); 128| 9.05M| } _ZN8perfetto15trace_processor6RefPtrINS0_29PacketSequenceStateGeneration11CustomStateEEC2Ev: 74| 268k| RefPtr() : ptr_(nullptr) {} _ZN8perfetto15trace_processor6RefPtrINS0_29PacketSequenceStateGeneration11CustomStateEEC2EOS4_: 112| 3.25k| RefPtr(RefPtr&& move_from) noexcept { 113| 3.25k| ptr_ = move_from.ptr_; 114| 3.25k| move_from.ptr_ = nullptr; 115| 3.25k| } _ZN8perfetto15trace_processor6RefPtrINS0_29PacketSequenceStateGeneration11CustomStateEEC2ERKS4_: 124| 3.25k| RefPtr(const RefPtr& copy_from) { 125| 3.25k| ptr_ = copy_from.ptr_; 126| 3.25k| if (ptr_) ------------------ | Branch (126:9): [True: 0, False: 3.25k] ------------------ 127| 0| ptr_->AddRef(); 128| 3.25k| } _ZN8perfetto15trace_processor6RefPtrINS0_29PacketSequenceStateGenerationEEC2EPS2_: 75| 68.0k| explicit RefPtr(T* ptr) : ptr_(ptr) { 76| 68.0k| if (ptr_) ------------------ | Branch (76:9): [True: 68.0k, False: 0] ------------------ 77| 68.0k| ptr_->AddRef(); 78| 68.0k| } _ZNK8perfetto15trace_processor6RefPtrINS0_29PacketSequenceStateGeneration11CustomStateEE3getEv: 150| 3.25k| T* get() const { return ptr_; } _ZN8perfetto15trace_processor6RefPtrINS0_9TraceBlobEEC2ERKS3_: 124| 65.6M| RefPtr(const RefPtr& copy_from) { 125| 65.6M| ptr_ = copy_from.ptr_; 126| 65.6M| if (ptr_) ------------------ | Branch (126:9): [True: 65.6M, False: 0] ------------------ 127| 65.6M| ptr_->AddRef(); 128| 65.6M| } _ZN8perfetto15trace_processor6RefPtrINS0_29PacketSequenceStateGenerationEEC2Ev: 74| 3.77M| RefPtr() : ptr_(nullptr) {} _ZNK8perfetto15trace_processor6RefPtrINS0_29PacketSequenceStateGenerationEE3getEv: 150| 19.6M| T* get() const { return ptr_; } _ZNK8perfetto15trace_processor6RefPtrINS0_29PacketSequenceStateGenerationEEdeEv: 152| 2.06k| T& operator*() const { return *ptr_; } _ZN8perfetto15trace_processor6RefPtrINS0_9TraceBlobEE18FromReleasedUnsafeEPS2_: 104| 3.71M| static RefPtr FromReleasedUnsafe(T* ptr) { 105| 3.71M| PERFETTO_DCHECK(ptr->refcount_ > 0); 106| 3.71M| RefPtr res; 107| 3.71M| res.ptr_ = ptr; 108| 3.71M| return res; 109| 3.71M| } _ZN8perfetto15trace_processor6RefPtrINS0_29PacketSequenceStateGenerationEE18FromReleasedUnsafeEPS2_: 104| 3.71M| static RefPtr FromReleasedUnsafe(T* ptr) { 105| 3.71M| PERFETTO_DCHECK(ptr->refcount_ > 0); 106| 3.71M| RefPtr res; 107| 3.71M| res.ptr_ = ptr; 108| 3.71M| return res; 109| 3.71M| } _ZNK8perfetto15trace_processor6RefPtrINS0_9TraceBlobEE3getEv: 150| 3.71M| T* get() const { return ptr_; } _ZN8perfetto15trace_processor6RefPtrINS0_9TraceBlobEE13ReleaseUnsafeEv: 95| 3.71M| T* ReleaseUnsafe() { 96| 3.71M| PERFETTO_DCHECK(ptr_->refcount_ > 0); 97| 3.71M| auto* old_ptr = ptr_; 98| 3.71M| ptr_ = nullptr; 99| 3.71M| return old_ptr; 100| 3.71M| } _ZN8perfetto15trace_processor6RefPtrINS0_29PacketSequenceStateGenerationEE13ReleaseUnsafeEv: 95| 3.71M| T* ReleaseUnsafe() { 96| 3.71M| PERFETTO_DCHECK(ptr_->refcount_ > 0); 97| 3.71M| auto* old_ptr = ptr_; 98| 3.71M| ptr_ = nullptr; 99| 3.71M| return old_ptr; 100| 3.71M| } _ZNK8perfetto15trace_processor9TraceBlob4dataEv: 71| 11.1M| uint8_t* data() const { return data_; } _ZNK8perfetto15trace_processor9TraceBlob4sizeEv: 72| 593| size_t size() const { return size_; } _ZN8perfetto15trace_processor13TraceBlobViewC2ENS0_9TraceBlobEmm: 54| 593| size_t length = kWholeBlob) { 55| 593| PERFETTO_DCHECK(offset <= std::numeric_limits::max()); 56| 593| data_ = blob.data() + offset; 57| 593| if (length == kWholeBlob) { ------------------ | Branch (57:9): [True: 593, False: 0] ------------------ 58| 593| length_ = static_cast(blob.size() - offset); 59| 593| } else { 60| 0| PERFETTO_DCHECK(length <= std::numeric_limits::max()); 61| 0| PERFETTO_DCHECK(offset + length_ <= blob.size()); 62| 0| length_ = static_cast(length); 63| 0| } 64| 593| blob_.reset(new TraceBlob(std::move(blob))); 65| 593| } _ZN8perfetto15trace_processor13TraceBlobViewC2ENS0_6RefPtrINS0_9TraceBlobEEEmj: 68| 3.71M| : blob_(std::move(blob)), data_(blob_->data() + offset), length_(length) { 69| 3.71M| PERFETTO_DCHECK(offset + length_ <= blob_->size()); 70| 3.71M| } _ZN8perfetto15trace_processor13TraceBlobViewC2Ev: 73| 159| TraceBlobView() : data_(nullptr), length_(0) {} _ZN8perfetto15trace_processor13TraceBlobViewC2EOS1_: 78| 71.0M| TraceBlobView(TraceBlobView&& other) noexcept { *this = std::move(other); } _ZN8perfetto15trace_processor13TraceBlobViewaSEOS1_: 80| 98.0M| TraceBlobView& operator=(TraceBlobView&& other) noexcept { 81| 98.0M| data_ = other.data_; 82| 98.0M| length_ = other.length_; 83| 98.0M| blob_ = std::move(other.blob_); 84| 98.0M| return *this; 85| 98.0M| } _ZNK8perfetto15trace_processor13TraceBlobView5sliceEPKhm: 92| 143k| TraceBlobView slice(const uint8_t* data, size_t length) const { 93| 143k| PERFETTO_DCHECK(data >= data_); 94| 143k| PERFETTO_DCHECK(data + length <= data_ + length_); 95| 143k| return TraceBlobView(blob_, data, static_cast(length)); 96| 143k| } _ZNK8perfetto15trace_processor13TraceBlobView9slice_offEmm: 99| 58.0M| TraceBlobView slice_off(size_t off, size_t length) const { 100| 58.0M| PERFETTO_DCHECK(off + length <= length_); 101| 58.0M| return TraceBlobView(blob_, data_ + off, static_cast(length)); 102| 58.0M| } _ZNK8perfetto15trace_processor13TraceBlobView4copyEv: 104| 528| TraceBlobView copy() const { return slice(data_, length_); } _ZNK8perfetto15trace_processor13TraceBlobView4dataEv: 112| 103M| const uint8_t* data() const { return data_; } _ZNK8perfetto15trace_processor13TraceBlobView6offsetEv: 113| 7.43M| size_t offset() const { return static_cast(data_ - blob_->data()); } _ZNK8perfetto15trace_processor13TraceBlobView6lengthEv: 114| 14.2M| size_t length() const { return length_; } _ZNK8perfetto15trace_processor13TraceBlobView4sizeEv: 115| 141M| size_t size() const { return length_; } _ZNK8perfetto15trace_processor13TraceBlobView4blobEv: 116| 7.43M| RefPtr blob() const { return blob_; } _ZN8perfetto15trace_processor13TraceBlobViewC2ENS0_6RefPtrINS0_9TraceBlobEEEPKhj: 120| 58.2M| : blob_(std::move(blob)), data_(data), length_(length) {} _ZN8perfetto15trace_processor13TraceBlobViewD2Ev: 75| 132M| ~TraceBlobView() = default; _ZN8perfetto4base12Base64EncodeEPKvmPcm: 58| 7| size_t dst_size) { 59| 7| const size_t padded_dst_size = Base64EncSize(src_size); 60| 7| if (dst_size < padded_dst_size) ------------------ | Branch (60:7): [True: 0, False: 7] ------------------ 61| 0| return -1; // Not enough space in output. 62| | 63| 7| const uint8_t* rd = static_cast(src); 64| 7| const uint8_t* const end = rd + src_size; 65| 7| size_t wr_size = 0; 66| 11| while (rd < end) { ------------------ | Branch (66:10): [True: 4, False: 7] ------------------ 67| 4| uint8_t s[3]{}; 68| 4| s[0] = *(rd++); 69| 4| dst[wr_size++] = kEncTable[s[0] >> 2]; 70| | 71| 4| uint8_t carry0 = static_cast((s[0] & 0x03) << 4); 72| 4| if (PERFETTO_LIKELY(rd < end)) { ------------------ | | 23| 4|#define PERFETTO_LIKELY(...) __builtin_expect(!!(__VA_ARGS__), 1) | | ------------------ | | | Branch (23:30): [True: 4, False: 0] | | ------------------ ------------------ 73| 4| s[1] = *(rd++); 74| 4| dst[wr_size++] = kEncTable[carry0 | (s[1] >> 4)]; 75| 4| } else { 76| 0| dst[wr_size++] = kEncTable[carry0]; 77| 0| dst[wr_size++] = kPadding; 78| 0| dst[wr_size++] = kPadding; 79| 0| break; 80| 0| } 81| | 82| 4| uint8_t carry1 = static_cast((s[1] & 0x0f) << 2); 83| 4| if (PERFETTO_LIKELY(rd < end)) { ------------------ | | 23| 4|#define PERFETTO_LIKELY(...) __builtin_expect(!!(__VA_ARGS__), 1) | | ------------------ | | | Branch (23:30): [True: 4, False: 0] | | ------------------ ------------------ 84| 4| s[2] = *(rd++); 85| 4| dst[wr_size++] = kEncTable[carry1 | (s[2] >> 6)]; 86| 4| } else { 87| 0| dst[wr_size++] = kEncTable[carry1]; 88| 0| dst[wr_size++] = kPadding; 89| 0| break; 90| 0| } 91| | 92| 4| dst[wr_size++] = kEncTable[s[2] & 0x3f]; 93| 4| } 94| 7| PERFETTO_DCHECK(wr_size == padded_dst_size); 95| 7| return static_cast(padded_dst_size); 96| 7|} _ZN8perfetto4base12Base64EncodeEPKvm: 98| 7|std::string Base64Encode(const void* src, size_t src_size) { 99| 7| std::string dst; 100| 7| dst.resize(Base64EncSize(src_size)); 101| 7| auto res = Base64Encode(src, src_size, &dst[0], dst.size()); 102| 7| PERFETTO_CHECK(res == static_cast(dst.size())); 103| 7| return dst; 104| 7|} _ZN8perfetto4base8CrashKey8RegisterEv: 37| 1|void CrashKey::Register() { 38| | // If doesn't matter if we fail below. If there are no slots left, don't 39| | // keep trying re-registering on every Set(), the outcome won't change. 40| | 41| | // If two threads raced on the Register(), avoid registering the key twice. 42| 1| if (registered_.exchange(true)) ------------------ | Branch (42:7): [True: 0, False: 1] ------------------ 43| 0| return; 44| | 45| 1| uint32_t slot = g_num_keys.fetch_add(1); 46| 1| if (slot >= kMaxKeys) { ------------------ | Branch (46:7): [True: 0, False: 1] ------------------ 47| 0| PERFETTO_LOG("Too many crash keys registered"); 48| 0| return; 49| 0| } 50| 1| g_keys[slot].store(this); 51| 1|} _ZN8perfetto4base13LogRingBuffer6AppendENS0_10StringViewES2_S2_: 67| 212k| void Append(StringView tstamp, StringView source, StringView log_msg) { 68| | // Reserve atomically a slot in the ring buffer, so any concurrent Append() 69| | // won't overlap (unless too many concurrent Append() happen together). 70| | // There is no strict synchronization here, |event_slot_| is atomic only for 71| | // the sake of avoiding colliding on the same slot but does NOT guarantee 72| | // full consistency and integrity of the log messages written in each slot. 73| | // A release-store (or acq+rel) won't be enough for full consistency. Two 74| | // threads that race on Append() and take the N+1 and N+2 slots could finish 75| | // the write in reverse order. So Read() would need to synchronize with 76| | // something else (either a per-slot atomic flag or with a second atomic 77| | // counter which is incremented after the snprintf). Both options increase 78| | // the cost of Append() with no huge benefits (90% of the perfetto services 79| | // where we use it is single thread, and the log ring buffer is disabled 80| | // on non-standalone builds like the SDK). 81| 212k| uint32_t slot = event_slot_.fetch_add(1, std::memory_order_relaxed); 82| 212k| slot = slot % kLogRingBufEntries; 83| | 84| 212k| char* const msg = events_[slot]; 85| 212k| PERFETTO_ANNOTATE_BENIGN_RACE_SIZED(msg, kLogRingBufMsgLen, 86| 212k| "see comments in log_ring_buffer.h") 87| 212k| snprintf(msg, kLogRingBufMsgLen, "%.*s%.*s %.*s", 88| 212k| static_cast(tstamp.size()), tstamp.data(), 89| 212k| static_cast(source.size()), source.data(), 90| 212k| static_cast(log_msg.size()), log_msg.data()); 91| 212k| } _ZN8perfetto4base10LogMessageENS0_6LogLevEPKciS3_z: 86| 212k| ...) { 87| 212k| char stack_buf[512]; 88| 212k| std::unique_ptr large_buf; 89| 212k| char* log_msg = &stack_buf[0]; 90| 212k| size_t log_msg_len = 0; 91| | 92| | // By default use a stack allocated buffer because most log messages are quite 93| | // short. In rare cases they can be larger (e.g. --help). In those cases we 94| | // pay the cost of allocating the buffer on the heap. 95| 212k| for (size_t max_len = sizeof(stack_buf);;) { 96| 212k| va_list args; 97| 212k| va_start(args, fmt); 98| 212k| int res = vsnprintf(log_msg, max_len, fmt, args); 99| 212k| va_end(args); 100| | 101| | // If for any reason the print fails, overwrite the message but still print 102| | // it. The code below will attach the filename and line, which is still 103| | // useful. 104| 212k| if (res < 0) { ------------------ | Branch (104:9): [True: 0, False: 212k] ------------------ 105| 0| snprintf(log_msg, max_len, "%s", "[printf format error]"); 106| 0| break; 107| 0| } 108| | 109| | // if res == max_len, vsnprintf saturated the input buffer. Retry with a 110| | // larger buffer in that case (within reasonable limits). 111| 212k| if (res < static_cast(max_len) || max_len >= 128 * 1024) { ------------------ | Branch (111:9): [True: 212k, False: 0] | Branch (111:44): [True: 0, False: 0] ------------------ 112| | // In case of truncation vsnprintf returns the len that "would have been 113| | // written if the string was longer", not the actual chars written. 114| 212k| log_msg_len = std::min(static_cast(res), max_len - 1); 115| 212k| break; 116| 212k| } 117| 0| max_len *= 4; 118| 0| large_buf.reset(new char[max_len]); 119| 0| log_msg = &large_buf[0]; 120| 0| } 121| | 122| 212k| LogMessageCallback cb = g_log_callback.load(std::memory_order_relaxed); 123| 212k| if (cb) { ------------------ | Branch (123:7): [True: 0, False: 212k] ------------------ 124| 0| cb({level, line, fname, log_msg}); 125| 0| return; 126| 0| } 127| | 128| 212k| const char* color = kDefault; 129| 212k| switch (level) { ------------------ | Branch (129:11): [True: 0, False: 212k] ------------------ 130| 0| case kLogDebug: ------------------ | Branch (130:5): [True: 0, False: 212k] ------------------ 131| 0| color = kDim; 132| 0| break; 133| 0| case kLogInfo: ------------------ | Branch (133:5): [True: 0, False: 212k] ------------------ 134| 0| color = kDefault; 135| 0| break; 136| 0| case kLogImportant: ------------------ | Branch (136:5): [True: 0, False: 212k] ------------------ 137| 0| color = kBoldGreen; 138| 0| break; 139| 212k| case kLogError: ------------------ | Branch (139:5): [True: 212k, False: 0] ------------------ 140| 212k| color = kRed; 141| 212k| break; 142| 212k| } 143| | 144| 212k|#if !PERFETTO_BUILDFLAG(PERFETTO_OS_WIN) && \ 145| 212k| !PERFETTO_BUILDFLAG(PERFETTO_OS_WASM) && \ 146| 212k| !PERFETTO_BUILDFLAG(PERFETTO_CHROMIUM_BUILD) 147| 212k| static const bool use_colors = isatty(STDERR_FILENO); 148| |#else 149| | static const bool use_colors = false; 150| |#endif 151| | 152| | // Formats file.cc:line as a space-padded fixed width string. If the file name 153| | // |fname| is too long, truncate it on the left-hand side. 154| 212k| StackString<10> line_str("%d", line); 155| | 156| | // 24 will be the width of the file.cc:line column in the log event. 157| 212k| static constexpr size_t kMaxNameAndLine = 24; 158| 212k| size_t fname_len = strlen(fname); 159| 212k| size_t fname_max = kMaxNameAndLine - line_str.len() - 2; // 2 = ':' + '\0'. 160| 212k| size_t fname_offset = fname_len <= fname_max ? 0 : fname_len - fname_max; ------------------ | Branch (160:25): [True: 6.11k, False: 206k] ------------------ 161| 212k| StackString file_and_line( 162| 212k| "%*s:%s", static_cast(fname_max), &fname[fname_offset], 163| 212k| line_str.c_str()); 164| | 165| |#if PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID) 166| | // Logcat has already timestamping, don't re-emit it. 167| | __android_log_print(int{ANDROID_LOG_DEBUG} + level, "perfetto", "%s %s", 168| | file_and_line.c_str(), log_msg); 169| |#endif 170| | 171| | // When printing on stderr, print also the timestamp. We don't really care 172| | // about the actual time. We just need some reference clock that can be used 173| | // to correlated events across differrent processses (e.g. traced and 174| | // traced_probes). The wall time % 1000 is good enough. 175| 212k| uint32_t t_ms = static_cast(GetWallTimeMs().count()); 176| 212k| uint32_t t_sec = t_ms / 1000; 177| 212k| t_ms -= t_sec * 1000; 178| 212k| t_sec = t_sec % 1000; 179| 212k| StackString<32> timestamp("[%03u.%03u] ", t_sec, t_ms); 180| | 181| 212k| if (use_colors) { ------------------ | Branch (181:7): [True: 0, False: 212k] ------------------ 182| 0| fprintf(stderr, "%s%s%s%s %s%s%s\n", kLightGray, timestamp.c_str(), 183| 0| file_and_line.c_str(), kReset, color, log_msg, kReset); 184| 212k| } else { 185| 212k| fprintf(stderr, "%s%s %s\n", timestamp.c_str(), file_and_line.c_str(), 186| 212k| log_msg); 187| 212k| } 188| | 189| 212k|#if PERFETTO_ENABLE_LOG_RING_BUFFER() 190| | // Append the message to the ring buffer for crash reporting postmortems. 191| 212k| StringView timestamp_sv = timestamp.string_view(); 192| 212k| StringView file_and_line_sv = file_and_line.string_view(); 193| 212k| StringView log_msg_sv(log_msg, static_cast(log_msg_len)); 194| 212k| g_log_ring_buffer.Append(timestamp_sv, file_and_line_sv, log_msg_sv); 195| |#else 196| | ignore_result(log_msg_len); 197| |#endif 198| 212k|} _ZN8perfetto4base11PagedMemory8AllocateEmi: 54| 434|PagedMemory PagedMemory::Allocate(size_t req_size, int flags) { 55| 434| size_t rounded_up_size = RoundUpToSysPageSize(req_size); 56| 434| PERFETTO_CHECK(rounded_up_size >= req_size); 57| 434| size_t outer_size = rounded_up_size + GuardSize() * 2; 58| |#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN) 59| | void* ptr = VirtualAlloc(nullptr, outer_size, MEM_RESERVE, PAGE_NOACCESS); 60| | if (!ptr && (flags & kMayFail)) 61| | return PagedMemory(); 62| | PERFETTO_CHECK(ptr); 63| | char* usable_region = reinterpret_cast(ptr) + GuardSize(); 64| |#else // PERFETTO_BUILDFLAG(PERFETTO_OS_WIN) 65| 434| void* ptr = mmap(nullptr, outer_size, PROT_READ | PROT_WRITE, 66| 434| MAP_PRIVATE | MAP_ANONYMOUS, -1, 0); 67| 434| if (ptr == MAP_FAILED && (flags & kMayFail)) ------------------ | Branch (67:7): [True: 0, False: 434] | Branch (67:28): [True: 0, False: 0] ------------------ 68| 0| return PagedMemory(); 69| 434| PERFETTO_CHECK(ptr && ptr != MAP_FAILED); 70| 434| char* usable_region = reinterpret_cast(ptr) + GuardSize(); 71| 434| int res = mprotect(ptr, GuardSize(), PROT_NONE); 72| 434| res |= mprotect(usable_region + rounded_up_size, GuardSize(), PROT_NONE); 73| 434| PERFETTO_CHECK(res == 0); 74| 434|#endif // PERFETTO_BUILDFLAG(PERFETTO_OS_WIN) 75| | 76| 434| auto memory = PagedMemory(usable_region, req_size); 77| |#if TRACK_COMMITTED_SIZE() 78| | size_t initial_commit = req_size; 79| | if (flags & kDontCommit) 80| | initial_commit = std::min(initial_commit, kCommitChunkSize); 81| | memory.EnsureCommitted(initial_commit); 82| |#endif // TRACK_COMMITTED_SIZE() 83| 434| return memory; 84| 434|} _ZN8perfetto4base11PagedMemoryC2EPcm: 89| 434|PagedMemory::PagedMemory(char* p, size_t size) : p_(p), size_(size) { 90| 434| ANNOTATE_NEW_BUFFER(p_, size_, committed_size_) 91| 434|} _ZN8perfetto4base11PagedMemoryD2Ev: 105| 434|PagedMemory::~PagedMemory() { 106| 434| if (!p_) ------------------ | Branch (106:7): [True: 0, False: 434] ------------------ 107| 0| return; 108| 434| PERFETTO_CHECK(size_); 109| 434| char* start = p_ - GuardSize(); 110| |#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN) 111| | BOOL res = VirtualFree(start, 0, MEM_RELEASE); 112| | PERFETTO_CHECK(res != 0); 113| |#else // PERFETTO_BUILDFLAG(PERFETTO_OS_WIN) 114| 434| const size_t outer_size = RoundUpToSysPageSize(size_) + GuardSize() * 2; 115| 434| int res = munmap(start, outer_size); 116| 434| PERFETTO_CHECK(res == 0); 117| 434|#endif // PERFETTO_BUILDFLAG(PERFETTO_OS_WIN) 118| 434| ANNOTATE_DELETE_BUFFER(p_, size_, committed_size_) 119| 434|} paged_memory.cc:_ZN8perfetto4base12_GLOBAL__N_120RoundUpToSysPageSizeEm: 42| 868|size_t RoundUpToSysPageSize(size_t req_size) { 43| 868| const size_t page_size = GetSysPageSize(); 44| 868| return (req_size + page_size - 1) & ~(page_size - 1); 45| 868|} paged_memory.cc:_ZN8perfetto4base12_GLOBAL__N_19GuardSizeEv: 47| 2.60k|size_t GuardSize() { 48| 2.60k| return GetSysPageSize(); 49| 2.60k|} _ZN8perfetto4base9ErrStatusEPKcz: 27| 1.32M|Status ErrStatus(const char* format, ...) { 28| 1.32M| std::string buf; 29| 1.32M| buf.resize(1024); 30| 1.32M| for (;;) { 31| 1.32M| va_list ap; 32| 1.32M| va_start(ap, format); 33| 1.32M| int N = vsnprintf(buf.data(), buf.size() - 1, format, ap); 34| 1.32M| va_end(ap); 35| | 36| 1.32M| if (N <= 0) { ------------------ | Branch (36:9): [True: 0, False: 1.32M] ------------------ 37| 0| buf = "[printf format error]"; 38| 0| break; 39| 0| } 40| | 41| 1.32M| auto sN = static_cast(N); 42| 1.32M| if (sN > buf.size() - 1) { ------------------ | Branch (42:9): [True: 0, False: 1.32M] ------------------ 43| | // Indicates that the string was truncated and sN is the "number of 44| | // non-null bytes which would be needed to fit the result". This is the 45| | // C99 standard behaviour in the case of truncation. In that case, resize 46| | // the buffer to match the returned value (with + 1 for the null 47| | // terminator) and try again. 48| 0| buf.resize(sN + 1); 49| 0| continue; 50| 0| } 51| 1.32M| if (sN == buf.size() - 1) { ------------------ | Branch (51:9): [True: 0, False: 1.32M] ------------------ 52| | // Indicates that the string was likely truncated and sN is just the 53| | // number of bytes written into the string. This is the behaviour of 54| | // non-standard compilers (MSVC) etc. In that case, just double the 55| | // storage and try again. 56| 0| buf.resize(sN * 2); 57| 0| continue; 58| 0| } 59| | 60| | // Otherwise, indicates the string was written successfully: we need to 61| | // resize to match the number of non-null bytes and return. 62| 1.32M| buf.resize(sN); 63| 1.32M| break; 64| 1.32M| } 65| 1.32M| return Status(std::move(buf)); 66| 1.32M|} _ZN8perfetto4base6StrToDEPKcPPc: 40| 378|double StrToD(const char* nptr, char** endptr) { 41| 378|#if PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID) || \ 42| 378| PERFETTO_BUILDFLAG(PERFETTO_OS_LINUX_BUT_NOT_QNX) || \ 43| 378| PERFETTO_BUILDFLAG(PERFETTO_OS_APPLE) 44| 378| static auto c_locale = newlocale(LC_ALL, "C", nullptr); 45| 378| return strtod_l(nptr, endptr, c_locale); 46| |#else 47| | return strtod(nptr, endptr); 48| |#endif 49| 378|} _ZN8perfetto4base10StartsWithERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_: 51| 18.6k|bool StartsWith(const std::string& str, const std::string& prefix) { 52| 18.6k| return str.compare(0, prefix.length(), prefix) == 0; 53| 18.6k|} _ZN8perfetto4base13StartsWithAnyERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERKNS1_6vectorIS7_NS5_IS7_EEEE: 56| 46.3k| const std::vector& prefixes) { 57| 46.3k| return std::any_of( 58| 46.3k| prefixes.begin(), prefixes.end(), 59| 46.3k| [&str](const std::string& prefix) { return StartsWith(str, prefix); }); 60| 46.3k|} _ZN8perfetto4base8ContainsERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_: 68| 1.29k|bool Contains(const std::string& haystack, const std::string& needle) { 69| 1.29k| return haystack.find(needle) != std::string::npos; 70| 1.29k|} _ZN8perfetto4base11SplitStringERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_: 108| 11.8k| const std::string& delimiter) { 109| 11.8k| PERFETTO_CHECK(!delimiter.empty()); 110| | 111| 11.8k| std::vector output; 112| 11.8k| size_t start = 0; 113| 11.8k| size_t next; 114| 571k| for (;;) { 115| 571k| next = std::min(text.find(delimiter, start), text.size()); 116| 571k| if (next > start) ------------------ | Branch (116:9): [True: 341k, False: 229k] ------------------ 117| 341k| output.emplace_back(&text[start], next - start); 118| 571k| start = next + delimiter.size(); 119| 571k| if (start >= text.size()) ------------------ | Branch (119:9): [True: 11.8k, False: 559k] ------------------ 120| 11.8k| break; 121| 571k| } 122| 11.8k| return output; 123| 11.8k|} _ZN8perfetto4base7ToLowerERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE: 155| 432|std::string ToLower(const std::string& str) { 156| | // Don't use tolower(), it depends on the locale. 157| 432| std::string res(str); 158| 432| auto end = res.end(); 159| 28.0k| for (auto c = res.begin(); c != end; ++c) ------------------ | Branch (159:30): [True: 27.6k, False: 432] ------------------ 160| 27.6k| *c = Lowercase(*c); 161| 432| return res; 162| 432|} _ZN8perfetto4base10ReplaceAllENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERKS7_S9_: 212| 378| const std::string& replacement) { 213| 378| PERFETTO_CHECK(!to_replace.empty()); 214| 378| size_t pos = 0; 215| 222k| while ((pos = str.find(to_replace, pos)) != std::string::npos) { ------------------ | Branch (215:10): [True: 221k, False: 378] ------------------ 216| 221k| str.replace(pos, to_replace.length(), replacement); 217| 221k| pos += replacement.length(); 218| 221k| } 219| 378| return str; 220| 378|} utils.cc:_ZN12_GLOBAL__N_121CheckCpuOptimizationsEv: 113| 2|CheckCpuOptimizations() { 114| 2| uint32_t eax = 0, ebx = 0, ecx = 0, edx = 0; 115| 2| PERFETTO_GETCPUID(eax, ebx, ecx, edx, 1, 0); ------------------ | | 98| 2| asm("mov %%rbx, %%rdi\n" \ | | 99| 2| "cpuid\n" \ | | 100| 2| "xchg %%rdi, %%rbx\n" \ | | 101| 2| : "=a"(a), "=D"(b), "=c"(c), "=d"(d) \ | | 102| 2| : "a"(a_inp), "2"(c_inp)) ------------------ 116| | 117| 2| static constexpr uint64_t xcr0_xmm_mask = 0x2; 118| 2| static constexpr uint64_t xcr0_ymm_mask = 0x4; 119| 2| static constexpr uint64_t xcr0_avx_mask = xcr0_xmm_mask | xcr0_ymm_mask; 120| | 121| 2| const bool have_popcnt = ecx & (1u << 23); 122| 2| const bool have_sse4_2 = ecx & (1u << 20); 123| 2| const bool have_avx = 124| | // Does the OS save/restore XMM and YMM state? 125| 2| (ecx & (1u << 27)) && // OS support XGETBV. ------------------ | Branch (125:7): [True: 2, False: 0] ------------------ 126| 2| (ecx & (1u << 28)) && // AVX supported in hardware ------------------ | Branch (126:7): [True: 2, False: 0] ------------------ 127| 2| ((GetXCR0EAX() & xcr0_avx_mask) == xcr0_avx_mask); ------------------ | Branch (127:7): [True: 2, False: 0] ------------------ 128| | 129| | // Get level 7 features (eax = 7 and ecx= 0), to check for AVX2 support. 130| | // (See Intel 64 and IA-32 Architectures Software Developer's Manual 131| | // Volume 2A: Instruction Set Reference, A-M CPUID). 132| 2| PERFETTO_GETCPUID(eax, ebx, ecx, edx, 7, 0); ------------------ | | 98| 2| asm("mov %%rbx, %%rdi\n" \ | | 99| 2| "cpuid\n" \ | | 100| 2| "xchg %%rdi, %%rbx\n" \ | | 101| 2| : "=a"(a), "=D"(b), "=c"(c), "=d"(d) \ | | 102| 2| : "a"(a_inp), "2"(c_inp)) ------------------ 133| 2| const bool have_avx2 = have_avx && ((ebx >> 5) & 0x1); ------------------ | Branch (133:26): [True: 2, False: 0] | Branch (133:38): [True: 2, False: 0] ------------------ 134| 2| const bool have_bmi = (ebx >> 3) & 0x1; 135| 2| const bool have_bmi2 = (ebx >> 8) & 0x1; 136| | 137| 2| if (!have_sse4_2 || !have_popcnt || !have_avx2 || !have_bmi || !have_bmi2) { ------------------ | Branch (137:7): [True: 0, False: 2] | Branch (137:23): [True: 0, False: 2] | Branch (137:39): [True: 0, False: 2] | Branch (137:53): [True: 0, False: 2] | Branch (137:66): [True: 0, False: 2] ------------------ 138| 0| fprintf( 139| 0| stderr, 140| 0| "This executable requires a x86_64 cpu that supports SSE4.2, BMI2 and " 141| 0| "AVX2.\n" 142| |#if PERFETTO_BUILDFLAG(PERFETTO_OS_APPLE) 143| | "On MacOS, this might be caused by running x86_64 binaries on arm64.\n" 144| | "See https://github.com/google/perfetto/issues/294 for more.\n" 145| |#endif 146| 0| "Rebuild with enable_perfetto_x64_cpu_opt=false.\n"); 147| 0| _exit(126); 148| 0| } 149| 2|} _ZN8perfetto4base8internal22GetSysPageSizeSlowpathEv: 161| 1|uint32_t GetSysPageSizeSlowpath() { 162| 1| uint32_t page_size = 0; 163| 1|#if PERFETTO_BUILDFLAG(PERFETTO_OS_LINUX) || \ 164| 1| PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID) 165| 1| const int page_size_int = getpagesize(); 166| | // If sysconf() fails for obscure reasons (e.g. SELinux denial) assume the 167| | // page size is 4KB. This is to avoid regressing subtle SDK usages, as old 168| | // versions of this code had a static constant baked in. 169| 1| page_size = static_cast(page_size_int > 0 ? page_size_int : 4096); ------------------ | Branch (169:37): [True: 1, False: 0] ------------------ 170| |#elif PERFETTO_BUILDFLAG(PERFETTO_OS_APPLE) 171| | page_size = static_cast(vm_page_size); 172| |#else 173| | page_size = 4096; 174| |#endif 175| | 176| 1| PERFETTO_CHECK(page_size > 0 && page_size % 4096 == 0); 177| | 178| | // Races here are fine because any thread will write the same value. 179| 1| g_cached_page_size.store(page_size, std::memory_order_relaxed); 180| 1| return page_size; 181| 1|} _ZN8perfetto4base12AlignedAllocEmm: 316| 1.08M|void* AlignedAlloc(size_t alignment, size_t size) { 317| 1.08M| void* res = nullptr; 318| 1.08M| alignment = AlignUp(alignment); // At least pointer size. 319| |#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN) 320| | // Window's _aligned_malloc() has a nearly identically signature to Unix's 321| | // aligned_alloc() but its arguments are obviously swapped. 322| | res = _aligned_malloc(size, alignment); 323| |#else 324| | // aligned_alloc() has been introduced in Android only in API 28. 325| | // Also NaCl and Fuchsia seems to have only posix_memalign(). 326| 1.08M| ignore_result(posix_memalign(&res, alignment, size)); 327| 1.08M|#endif 328| 1.08M| PERFETTO_CHECK(res); 329| 1.08M| return res; 330| 1.08M|} _ZN8perfetto4base11AlignedFreeEPv: 332| 1.08M|void AlignedFree(void* ptr) { 333| |#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN) 334| | _aligned_free(ptr); // MSDN says it is fine to pass nullptr. 335| |#else 336| 1.08M| free(ptr); 337| 1.08M|#endif 338| 1.08M|} utils.cc:_ZN12_GLOBAL__N_110GetXCR0EAXEv: 104| 2|uint32_t GetXCR0EAX() { 105| 2| uint32_t eax = 0, edx = 0; 106| 2| asm("xgetbv" : "=a"(eax), "=d"(edx) : "c"(0)); 107| 2| return eax; 108| 2|} _ZN8perfetto4base4UuidC2Ell: 81| 434|Uuid::Uuid(int64_t lsb, int64_t msb) { 82| 434| set_lsb_msb(lsb, msb); 83| 434|} _ZNK8perfetto4base4Uuid14ToPrettyStringEv: 89| 434|std::string Uuid::ToPrettyString() const { 90| 434| std::string s(data_.size() * 2 + 4, '-'); 91| | // Format is 123e4567-e89b-12d3-a456-426655443322. 92| 434| size_t j = 0; 93| 7.37k| for (size_t i = 0; i < data_.size(); ++i) { ------------------ | Branch (93:22): [True: 6.94k, False: 434] ------------------ 94| 6.94k| if (i == 4 || i == 6 || i == 8 || i == 10) ------------------ | Branch (94:9): [True: 434, False: 6.51k] | Branch (94:19): [True: 434, False: 6.07k] | Branch (94:29): [True: 434, False: 5.64k] | Branch (94:39): [True: 434, False: 5.20k] ------------------ 95| 1.73k| j++; 96| 6.94k| s[2 * i + j] = kHexmap[(data_[data_.size() - i - 1] & 0xf0) >> 4]; 97| 6.94k| s[2 * i + 1 + j] = kHexmap[(data_[data_.size() - i - 1] & 0x0f)]; 98| 6.94k| } 99| 434| return s; 100| 434|} _ZN9protozero12ProtoDecoder9FindFieldEj: 161| 123k|Field ProtoDecoder::FindField(uint32_t field_id) { 162| 123k| Field res{}; 163| 123k| auto old_position = read_ptr_; 164| 123k| read_ptr_ = begin_; 165| 126k| for (auto f = ReadField(); f.valid(); f = ReadField()) { ------------------ | Branch (165:30): [True: 27.2k, False: 99.5k] ------------------ 166| 27.2k| if (f.id() == field_id) { ------------------ | Branch (166:9): [True: 23.8k, False: 3.44k] ------------------ 167| 23.8k| res = f; 168| 23.8k| break; 169| 23.8k| } 170| 27.2k| } 171| 123k| read_ptr_ = old_position; 172| 123k| return res; 173| 123k|} _ZN9protozero12ProtoDecoder9ReadFieldEv: 175| 13.6M|Field ProtoDecoder::ReadField() { 176| 13.6M| ParseFieldResult res; 177| 13.6M| do { 178| 13.6M| res = ParseOneField(read_ptr_, end_); 179| 13.6M| read_ptr_ = res.next; 180| 13.6M| } while (PERFETTO_UNLIKELY(res.parse_res == ParseFieldResult::kSkip)); ------------------ | | 24| 13.6M|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 96, False: 13.6M] | | ------------------ ------------------ 181| 13.6M| return res.field; 182| 13.6M|} _ZN9protozero21TypedProtoDecoderBase14ParseAllFieldsEv: 184| 31.4M|void TypedProtoDecoderBase::ParseAllFields() { 185| 31.4M| const uint8_t* cur = begin_; 186| 31.4M| ParseFieldResult res; 187| 116M| for (;;) { 188| 116M| res = ParseOneField(cur, end_); 189| 116M| PERFETTO_DCHECK(res.parse_res != ParseFieldResult::kOk || res.next != cur); 190| 116M| cur = res.next; 191| 116M| if (PERFETTO_UNLIKELY(res.parse_res == ParseFieldResult::kSkip)) ------------------ | | 24| 116M|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 24.1k, False: 116M] | | ------------------ ------------------ 192| 24.1k| continue; 193| 116M| if (PERFETTO_UNLIKELY(res.parse_res == ParseFieldResult::kAbort)) ------------------ | | 24| 116M|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 31.4M, False: 84.6M] | | ------------------ ------------------ 194| 31.4M| break; 195| | 196| 84.6M| PERFETTO_DCHECK(res.parse_res == ParseFieldResult::kOk); 197| 84.6M| PERFETTO_DCHECK(res.field.valid()); 198| 84.6M| auto field_id = res.field.id(); 199| 84.6M| if (PERFETTO_UNLIKELY(field_id >= num_fields_)) ------------------ | | 24| 84.6M|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 3.16M, False: 81.5M] | | ------------------ ------------------ 200| 3.16M| continue; 201| | 202| | // There are two reasons why we might want to expand the heap capacity: 203| | // 1. We are writing a non-repeated field, which has an id > 204| | // INITIAL_STACK_CAPACITY. In this case ExpandHeapStorage() ensures to 205| | // allocate at least (num_fields_ + 1) slots. 206| | // 2. We are writing a repeated field but ran out of capacity. 207| 81.5M| if (PERFETTO_UNLIKELY(field_id >= size_ || size_ >= capacity_)) ------------------ | | 24| 163M|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 25.3k, False: 81.4M] | | | Branch (24:52): [True: 23.3k, False: 81.4M] | | | Branch (24:52): [True: 2.03k, False: 81.4M] | | ------------------ ------------------ 208| 25.3k| ExpandHeapStorage(); 209| | 210| 81.5M| PERFETTO_DCHECK(field_id < size_); 211| 81.5M| Field* fld = &fields_[field_id]; 212| 81.5M| if (PERFETTO_LIKELY(!fld->valid())) { ------------------ | | 23| 81.5M|#define PERFETTO_LIKELY(...) __builtin_expect(!!(__VA_ARGS__), 1) | | ------------------ | | | Branch (23:30): [True: 54.4M, False: 27.0M] | | ------------------ ------------------ 213| | // This is the first time we see this field. 214| 54.4M| *fld = std::move(res.field); 215| 54.4M| } else { 216| | // Repeated field case. 217| | // In this case we need to: 218| | // 1. Append the last value of the field to end of the repeated field 219| | // storage. 220| | // 2. Replace the default instance at offset |field_id| with the current 221| | // value. This is because in case of repeated field a call to Get(X) is 222| | // supposed to return the last value of X, not the first one. 223| | // This is so that the RepeatedFieldIterator will iterate in the right 224| | // order, see comments on RepeatedFieldIterator. 225| 27.0M| if (num_fields_ > size_) { ------------------ | Branch (225:11): [True: 2.08M, False: 24.9M] ------------------ 226| 2.08M| ExpandHeapStorage(); 227| 2.08M| fld = &fields_[field_id]; 228| 2.08M| } 229| | 230| 27.0M| PERFETTO_DCHECK(size_ < capacity_); 231| 27.0M| fields_[size_++] = *fld; 232| 27.0M| *fld = std::move(res.field); 233| 27.0M| } 234| 81.5M| } 235| 31.4M| read_ptr_ = res.next; 236| 31.4M|} _ZN9protozero21TypedProtoDecoderBase17ExpandHeapStorageEv: 238| 2.10M|void TypedProtoDecoderBase::ExpandHeapStorage() { 239| | // When we expand the heap we must ensure that we have at very last capacity 240| | // to deal with all known fields plus at least one repeated field. We go +2048 241| | // here based on observations on a large 4GB android trace. This is to avoid 242| | // trivial re-allocations when dealing with repeated fields of a message that 243| | // has > INITIAL_STACK_CAPACITY fields. 244| 2.10M| const uint32_t min_capacity = num_fields_ + 2048; // Any num >= +1 will do. 245| 2.10M| const uint32_t new_capacity = std::max(capacity_ * 2, min_capacity); 246| 2.10M| PERFETTO_CHECK(new_capacity > size_ && new_capacity > num_fields_); 247| 2.10M| std::unique_ptr new_storage(new Field[new_capacity]); 248| | 249| 2.10M| static_assert(std::is_trivially_constructible::value, 250| 2.10M| "Field must be trivially constructible"); 251| 2.10M| static_assert(std::is_trivially_copyable::value, 252| 2.10M| "Field must be trivially copyable"); 253| | 254| | // Zero-initialize the slots for known field IDs slots, as they can be 255| | // randomly accessed. Instead, there is no need to initialize the repeated 256| | // slots, because they are written linearly with no gaps and are always 257| | // initialized before incrementing |size_|. 258| 2.10M| const uint32_t new_size = std::max(size_, num_fields_); 259| 2.10M| memset(&new_storage[size_], 0, sizeof(Field) * (new_size - size_)); 260| | 261| 2.10M| memcpy(&new_storage[0], fields_, sizeof(Field) * size_); 262| | 263| 2.10M| heap_storage_ = std::move(new_storage); 264| 2.10M| fields_ = &heap_storage_[0]; 265| 2.10M| capacity_ = new_capacity; 266| 2.10M| size_ = new_size; 267| 2.10M|} proto_decoder.cc:_ZN9protozero12_GLOBAL__N_113ParseOneFieldEPKhS2_: 50| 129M| const uint8_t* const end) { 51| 129M| ParseFieldResult res{ParseFieldResult::kAbort, buffer, Field{}}; 52| | 53| | // The first byte of a proto field is structured as follows: 54| | // The least 3 significant bits determine the field type. 55| | // The most 5 significant bits determine the field id. If MSB == 1, the 56| | // field id continues on the next bytes following the VarInt encoding. 57| 129M| const uint8_t kFieldTypeNumBits = 3; 58| 129M| const uint64_t kFieldTypeMask = (1 << kFieldTypeNumBits) - 1; // 0000 0111; 59| 129M| const uint8_t* pos = buffer; 60| | 61| | // If we've already hit the end, just return an invalid field. 62| 129M| if (PERFETTO_UNLIKELY(pos >= end)) ------------------ | | 24| 129M|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 28.1M, False: 101M] | | ------------------ ------------------ 63| 28.1M| return res; 64| | 65| 101M| uint64_t preamble = 0; 66| 101M| if (PERFETTO_LIKELY(*pos < 0x80)) { // Fastpath for fields with ID < 16. ------------------ | | 23| 101M|#define PERFETTO_LIKELY(...) __builtin_expect(!!(__VA_ARGS__), 1) | | ------------------ | | | Branch (23:30): [True: 94.2M, False: 7.33M] | | ------------------ ------------------ 67| 94.2M| preamble = *(pos++); 68| 94.2M| } else { 69| 7.33M| const uint8_t* next = ParseVarInt(pos, end, &preamble); 70| 7.33M| if (PERFETTO_UNLIKELY(pos == next)) ------------------ | | 24| 7.33M|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 326k, False: 7.00M] | | ------------------ ------------------ 71| 326k| return res; 72| 7.00M| pos = next; 73| 7.00M| } 74| | 75| 101M| uint32_t field_id = static_cast(preamble >> kFieldTypeNumBits); 76| 101M| if (field_id == 0 || pos >= end) ------------------ | Branch (76:7): [True: 1.85M, False: 99.4M] | Branch (76:24): [True: 1.30M, False: 98.1M] ------------------ 77| 3.16M| return res; 78| | 79| 98.1M| auto field_type = static_cast(preamble & kFieldTypeMask); 80| 98.1M| const uint8_t* new_pos = pos; 81| 98.1M| uint64_t int_value = 0; 82| 98.1M| uint64_t size = 0; 83| | 84| 98.1M| switch (field_type) { 85| 38.9M| case static_cast(ProtoWireType::kVarInt): { ------------------ | Branch (85:5): [True: 38.9M, False: 59.1M] ------------------ 86| 38.9M| new_pos = ParseVarInt(pos, end, &int_value); 87| | 88| | // new_pos not being greater than pos means ParseVarInt could not fully 89| | // parse the number. This is because we are out of space in the buffer. 90| | // Set the id to zero and return but don't update the offset so a future 91| | // read can read this field. 92| 38.9M| if (PERFETTO_UNLIKELY(new_pos == pos)) ------------------ | | 24| 38.9M|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 20.6k, False: 38.9M] | | ------------------ ------------------ 93| 20.6k| return res; 94| | 95| 38.9M| break; 96| 38.9M| } 97| | 98| 41.1M| case static_cast(ProtoWireType::kLengthDelimited): { ------------------ | Branch (98:5): [True: 41.1M, False: 56.9M] ------------------ 99| 41.1M| uint64_t payload_length; 100| 41.1M| new_pos = ParseVarInt(pos, end, &payload_length); 101| 41.1M| if (PERFETTO_UNLIKELY(new_pos == pos)) ------------------ | | 24| 41.1M|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 1.30k, False: 41.1M] | | ------------------ ------------------ 102| 1.30k| return res; 103| | 104| | // ParseVarInt guarantees that |new_pos| <= |end| when it succeeds; 105| 41.1M| if (payload_length > static_cast(end - new_pos)) ------------------ | Branch (105:11): [True: 328k, False: 40.8M] ------------------ 106| 328k| return res; 107| | 108| 40.8M| const uintptr_t payload_start = reinterpret_cast(new_pos); 109| 40.8M| int_value = payload_start; 110| 40.8M| size = payload_length; 111| 40.8M| new_pos += payload_length; 112| 40.8M| break; 113| 41.1M| } 114| | 115| 12.2M| case static_cast(ProtoWireType::kFixed64): { ------------------ | Branch (115:5): [True: 12.2M, False: 85.9M] ------------------ 116| 12.2M| new_pos = pos + sizeof(uint64_t); 117| 12.2M| if (PERFETTO_UNLIKELY(new_pos > end)) ------------------ | | 24| 12.2M|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 365k, False: 11.8M] | | ------------------ ------------------ 118| 365k| return res; 119| 11.8M| memcpy(&int_value, pos, sizeof(uint64_t)); 120| 11.8M| break; 121| 12.2M| } 122| | 123| 5.32M| case static_cast(ProtoWireType::kFixed32): { ------------------ | Branch (123:5): [True: 5.32M, False: 92.8M] ------------------ 124| 5.32M| new_pos = pos + sizeof(uint32_t); 125| 5.32M| if (PERFETTO_UNLIKELY(new_pos > end)) ------------------ | | 24| 5.32M|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 50.6k, False: 5.27M] | | ------------------ ------------------ 126| 50.6k| return res; 127| 5.27M| memcpy(&int_value, pos, sizeof(uint32_t)); 128| 5.27M| break; 129| 5.32M| } 130| | 131| 423k| default: ------------------ | Branch (131:5): [True: 423k, False: 97.7M] ------------------ 132| 423k| PERFETTO_DLOG("Invalid proto field type: %u", field_type); 133| 423k| return res; 134| 98.1M| } 135| | 136| 96.9M| res.next = new_pos; 137| | 138| 96.9M| if (PERFETTO_UNLIKELY(field_id > Field::kMaxId)) { ------------------ | | 24| 96.9M|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 24.2k, False: 96.9M] | | ------------------ ------------------ 139| 24.2k| PERFETTO_DLOG("Skipping field %" PRIu32 " because its id > %" PRIu32, 140| 24.2k| field_id, Field::kMaxId); 141| 24.2k| res.parse_res = ParseFieldResult::kSkip; 142| 24.2k| return res; 143| 24.2k| } 144| | 145| 96.9M| if (PERFETTO_UNLIKELY(size > proto_utils::kMaxMessageLength)) { ------------------ | | 24| 96.9M|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 0, False: 96.9M] | | ------------------ ------------------ 146| 0| PERFETTO_DLOG("Skipping field %" PRIu32 " because it's too big (%" PRIu64 147| 0| " KB)", 148| 0| field_id, size / 1024); 149| 0| res.parse_res = ParseFieldResult::kSkip; 150| 0| return res; 151| 0| } 152| | 153| 96.9M| res.parse_res = ParseFieldResult::kOk; 154| 96.9M| res.field.initialize(field_id, field_type, int_value, 155| 96.9M| static_cast(size)); 156| 96.9M| return res; 157| 96.9M|} _ZN8perfetto15trace_processor9BitVectorC2Ev: 123| 54.2k|BitVector::BitVector() = default; _ZNK8perfetto15trace_processor9BitVector4sizeEv: 163| 9.33M| uint32_t size() const { return static_cast(size_); } _ZNK8perfetto15trace_processor9BitVector5IsSetEj: 166| 365M| bool IsSet(uint32_t idx) const { 167| 365M| PERFETTO_DCHECK(idx < size()); 168| 365M| return ConstBitWord(&words_[WordFloor(idx)]).IsSet(idx % BitWord::kBits); 169| 365M| } _ZNK8perfetto15trace_processor9BitVector12CountSetBitsEv: 172| 112k| uint32_t CountSetBits() const { return CountSetBits(size()); } _ZNK8perfetto15trace_processor9BitVector12CountSetBitsEj: 176| 185M| uint32_t CountSetBits(uint32_t end) const { 177| 185M| if (end == 0) ------------------ | Branch (177:9): [True: 527k, False: 184M] ------------------ 178| 527k| return 0; 179| | 180| | // Although the external interface we present uses an exclusive |end|, 181| | // internally it's a lot nicer to work with an inclusive |end| (mainly 182| | // because we get block rollovers on exclusive ends which means we need 183| | // to have if checks to ensure we don't overflow the number of blocks). 184| 184M| Address addr = IndexToAddress(end - 1); 185| | 186| | // Add the number of set bits until the start of the block to the number 187| | // of set bits until the end address inside the block. 188| 184M| return counts_[addr.block_idx] + 189| 184M| ConstBlockFromIndex(addr.block_idx).CountSetBits(addr.block_offset); 190| 185M| } _ZN8perfetto15trace_processor9BitVector3SetEj: 222| 2.73M| bool Set(uint32_t idx) { 223| | // Set the bit to the correct value inside the block but store the old 224| | // bit to help fix the counts. 225| 2.73M| auto addr = IndexToAddress(idx); 226| 2.73M| bool old_value = 227| 2.73M| ConstBlockFromIndex(addr.block_idx).IsSet(addr.block_offset); 228| | 229| | // If the old value was unset, set the bit and add one to the count. 230| 2.73M| if (PERFETTO_LIKELY(!old_value)) { ------------------ | | 23| 2.73M|#define PERFETTO_LIKELY(...) __builtin_expect(!!(__VA_ARGS__), 1) | | ------------------ | | | Branch (23:30): [True: 2.66M, False: 69.3k] | | ------------------ ------------------ 231| 2.66M| BlockFromIndex(addr.block_idx).Set(addr.block_offset); 232| | 233| 2.66M| auto size = static_cast(counts_.size()); 234| 7.75M| for (uint32_t i = addr.block_idx + 1; i < size; ++i) { ------------------ | Branch (234:45): [True: 5.09M, False: 2.66M] ------------------ 235| 5.09M| counts_[i]++; 236| 5.09M| } 237| 2.66M| } 238| 2.73M| return old_value; 239| 2.73M| } _ZN8perfetto15trace_processor9BitVector10AppendTrueEv: 262| 9.22M| void AppendTrue() { 263| 9.22M| AppendFalse(); 264| 9.22M| Address addr = IndexToAddress(size() - 1); 265| 9.22M| BlockFromIndex(addr.block_idx).Set(addr.block_offset); 266| 9.22M| } _ZN8perfetto15trace_processor9BitVector11AppendFalseEv: 269| 52.4M| void AppendFalse() { 270| 52.4M| Address addr = IndexToAddress(size_); 271| 52.4M| uint32_t old_blocks_size = BlockCount(); 272| 52.4M| uint32_t new_blocks_size = addr.block_idx + 1; 273| | 274| 52.4M| if (PERFETTO_UNLIKELY(new_blocks_size > old_blocks_size)) { ------------------ | | 24| 52.4M|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 112k, False: 52.3M] | | ------------------ ------------------ 275| 112k| uint32_t t = CountSetBits(); 276| 112k| words_.resize(words_.size() + Block::kWords); 277| 112k| counts_.emplace_back(t); 278| 112k| } 279| | 280| 52.4M| size_++; 281| | // We don't need to clear the bit as we ensure that anything after 282| | // size_ is always set to false. 283| 52.4M| } _ZN8perfetto15trace_processor9BitVector7BitWordC2EPm: 445| 11.8M| explicit BitWord(uint64_t* word) : word_(word) {} _ZN8perfetto15trace_processor9BitVector7BitWord2OrEm: 448| 11.8M| void Or(uint64_t mask) { *word_ |= mask; } _ZN8perfetto15trace_processor9BitVector7BitWord3SetEj: 457| 11.8M| void Set(uint32_t idx) { 458| 11.8M| PERFETTO_DCHECK(idx < kBits); 459| | 460| | // Or the value for the true shifted up to |idx| with the word. 461| 11.8M| Or(1ull << idx); 462| 11.8M| } _ZN8perfetto15trace_processor9BitVector7BitWord19MaskAllBitsSetUntilEj: 489| 184M| static uint64_t MaskAllBitsSetUntil(uint32_t idx) { 490| | // Start with 1 and shift it up (idx + 1) bits we get: 491| | // top : 00000000010000000 492| 184M| uint64_t top = 1ull << ((idx + 1ull) % kBits); 493| | 494| | // We need to handle the case where idx == 63. In this case |top| will be 495| | // zero because 1 << ((idx + 1) % 64) == 1 << (64 % 64) == 1. 496| | // In this case, we actually want top == 0. We can do this by shifting 497| | // down by (idx + 1) / kBits - this will be a noop for every index other 498| | // than idx == 63. This should also be free on x86 because of the mod 499| | // instruction above. 500| 184M| top = top >> ((idx + 1) / kBits); 501| | 502| | // Then if we take away 1, we get precisely the mask we want. 503| 184M| return top - 1u; 504| 184M| } _ZN8perfetto15trace_processor9BitVector12ConstBitWordC2EPKm: 534| 1.16G| explicit ConstBitWord(const uint64_t* word) : word_(word) {} _ZNK8perfetto15trace_processor9BitVector12ConstBitWord5IsSetEj: 537| 367M| bool IsSet(uint32_t idx) const { 538| 367M| PERFETTO_DCHECK(idx < kBits); 539| 367M| return (*word_ >> idx) & 1ull; 540| 367M| } _ZNK8perfetto15trace_processor9BitVector12ConstBitWord12CountSetBitsEv: 577| 612M| uint32_t CountSetBits() const { 578| 612M| return static_cast(PERFETTO_POPCOUNT(*word_)); ------------------ | | 81| 612M|#define PERFETTO_POPCOUNT(x) __builtin_popcountll(x) ------------------ 579| 612M| } _ZNK8perfetto15trace_processor9BitVector12ConstBitWord12CountSetBitsEj: 582| 184M| uint32_t CountSetBits(uint32_t idx) const { 583| 184M| PERFETTO_DCHECK(idx < kBits); 584| 184M| return static_cast(PERFETTO_POPCOUNT(WordUntil(idx))); ------------------ | | 81| 184M|#define PERFETTO_POPCOUNT(x) __builtin_popcountll(x) ------------------ 585| 184M| } _ZNK8perfetto15trace_processor9BitVector12ConstBitWord9WordUntilEj: 609| 184M| uint64_t WordUntil(uint32_t idx) const { 610| 184M| PERFETTO_DCHECK(idx < kBits); 611| | 612| | // To understand what is happeninng here, consider an example. 613| | // Suppose we want to all the bits up to the 7th bit in the atom 614| | // 7th 615| | // | 616| | // v 617| | // atom: 01010101011111000 618| | // 619| | // The easiest way to do this would be if we had a mask with only 620| | // the bottom 7 bits set: 621| | // mask: 00000000001111111 622| 184M| uint64_t mask = BitWord::MaskAllBitsSetUntil(idx); 623| | 624| | // Finish up by and'ing the atom with the computed mask. 625| 184M| return *word_ & mask; 626| 184M| } _ZN8perfetto15trace_processor9BitVector5BlockC2EPm: 643| 11.8M| explicit Block(uint64_t* start_word) : start_word_(start_word) {} _ZN8perfetto15trace_processor9BitVector5Block3SetERKNS1_11BlockOffsetE: 646| 11.8M| void Set(const BlockOffset& addr) { 647| 11.8M| PERFETTO_DCHECK(addr.word_idx < kWords); 648| 11.8M| BitWord(&start_word_[addr.word_idx]).Set(addr.bit_idx); 649| 11.8M| } _ZN8perfetto15trace_processor9BitVector10ConstBlockC2EPKm: 738| 187M| explicit ConstBlock(const uint64_t* start_word) : start_word_(start_word) {} _ZNK8perfetto15trace_processor9BitVector10ConstBlock5IsSetERKNS1_11BlockOffsetE: 742| 2.73M| bool IsSet(const BlockOffset& addr) const { 743| 2.73M| PERFETTO_DCHECK(addr.word_idx < kWords); 744| 2.73M| return ConstBitWord(start_word_ + addr.word_idx).IsSet(addr.bit_idx); 745| 2.73M| } _ZNK8perfetto15trace_processor9BitVector10ConstBlock12CountSetBitsERKNS1_11BlockOffsetE: 777| 184M| uint32_t CountSetBits(const BlockOffset& addr) const { 778| 184M| PERFETTO_DCHECK(addr.word_idx < kWords); 779| | 780| | // Count all the set bits in the atom until we reach the last atom 781| | // index. 782| 184M| uint32_t count = 0; 783| 797M| for (uint32_t i = 0; i < addr.word_idx; ++i) { ------------------ | Branch (783:28): [True: 612M, False: 184M] ------------------ 784| 612M| count += ConstBitWord(&start_word_[i]).CountSetBits(); 785| 612M| } 786| | 787| | // For the last atom, only count the bits upto and including the bit 788| | // index. 789| 184M| return count + ConstBitWord(&start_word_[addr.word_idx]) 790| 184M| .CountSetBits(addr.bit_idx); 791| 184M| } _ZN8perfetto15trace_processor9BitVector10BlockCountEv: 811| 52.4M| uint32_t BlockCount() { 812| 52.4M| return static_cast(words_.size()) / Block::kWords; 813| 52.4M| } _ZN8perfetto15trace_processor9BitVector14BlockFromIndexEj: 815| 11.8M| Block BlockFromIndex(uint32_t idx) { 816| 11.8M| PERFETTO_DCHECK(Block::kWords * (idx + 1) <= words_.size()); 817| | 818| 11.8M| uint64_t* start_word = &words_[Block::kWords * idx]; 819| 11.8M| return Block(start_word); 820| 11.8M| } _ZNK8perfetto15trace_processor9BitVector19ConstBlockFromIndexEj: 822| 187M| ConstBlock ConstBlockFromIndex(uint32_t idx) const { 823| 187M| PERFETTO_DCHECK(Block::kWords * (idx + 1) <= words_.size()); 824| | 825| 187M| return ConstBlock(&words_[Block::kWords * idx]); 826| 187M| } _ZN8perfetto15trace_processor9BitVector9WordFloorEj: 880| 365M| static constexpr uint32_t WordFloor(uint32_t idx) { 881| 365M| return idx / BitWord::kBits; 882| 365M| } _ZN8perfetto15trace_processor9BitVector14IndexToAddressEj: 890| 249M| static Address IndexToAddress(uint32_t idx) { 891| 249M| Address a; 892| 249M| a.block_idx = idx / Block::kBits; 893| | 894| 249M| uint16_t bit_idx_inside_block = idx % Block::kBits; 895| 249M| a.block_offset.word_idx = bit_idx_inside_block / BitWord::kBits; 896| 249M| a.block_offset.bit_idx = bit_idx_inside_block % BitWord::kBits; 897| 249M| return a; 898| 249M| } _ZN8perfetto15trace_processor9BitVectorC2EOS1_: 147| 2.17k| BitVector(BitVector&&) noexcept = default; _ZN8perfetto15trace_processor18NullTermStringViewC2Ev: 30| 4.12M| NullTermStringView() : StringView() {} _ZN8perfetto15trace_processor18NullTermStringViewC2EPKcm: 44| 279k| NullTermStringView(const char* data, size_t size) : StringView(data, size) { 45| 279k| PERFETTO_DCHECK(data[size] == '\0'); 46| 279k| } _ZNK8perfetto15trace_processor18NullTermStringView5c_strEv: 54| 4.00M| const char* c_str() const { return data(); } _ZN8perfetto15trace_processor6RowMapC2Ejj: 230| 35.1k|RowMap::RowMap(uint32_t start, uint32_t end) : data_(Range{start, end}) {} _ZN8perfetto15trace_processor6RowMapC2ENS0_9BitVectorE: 237| 434|RowMap::RowMap(BitVector bit_vector) : data_(std::move(bit_vector)) {} _ZN8perfetto15trace_processor6RowMap8IteratorC2EPKS1_: 284| 71.8k|RowMap::Iterator::Iterator(const RowMap* rm) : rm_(rm) { 285| 71.8k| if (const auto* range = std::get_if(&rm_->data_)) { ------------------ | Branch (285:19): [True: 71.8k, False: 0] ------------------ 286| 71.8k| ordinal_ = range->start; 287| 71.8k| return; 288| 71.8k| } 289| 0| if (const auto* bv = std::get_if(&rm_->data_)) { ------------------ | Branch (289:19): [True: 0, False: 0] ------------------ 290| 0| results_ = bv->GetSetBitIndices(); 291| 0| return; 292| 0| } 293| 0|} _ZN8perfetto15trace_processor6RowMap5RangeC2Ejj: 86| 35.1k| : start(start_index), end(end_index) { 87| 35.1k| PERFETTO_DCHECK(start_index <= end_index); 88| 35.1k| } _ZN8perfetto15trace_processor6RowMap8Iterator4NextEv: 117| 374k| void Next() { ++ordinal_; } _ZNK8perfetto15trace_processor6RowMap8IteratorcvbEv: 120| 446k| explicit operator bool() const { 121| 446k| if (const auto* range = std::get_if(&rm_->data_)) { ------------------ | Branch (121:23): [True: 446k, False: 0] ------------------ 122| 446k| return ordinal_ < range->end; 123| 446k| } 124| 0| if (std::get_if(&rm_->data_)) { ------------------ | Branch (124:11): [True: 0, False: 0] ------------------ 125| 0| return ordinal_ < results_.size(); 126| 0| } 127| 0| if (const auto* vec = std::get_if(&rm_->data_)) { ------------------ | Branch (127:23): [True: 0, False: 0] ------------------ 128| 0| return ordinal_ < vec->size(); 129| 0| } 130| 0| PERFETTO_FATAL("Didn't match any variant type."); 131| 0| } _ZNK8perfetto15trace_processor6RowMap8Iterator5indexEv: 134| 584k| OutputIndex index() const { 135| 584k| if (std::get_if(&rm_->data_)) { ------------------ | Branch (135:11): [True: 584k, False: 0] ------------------ 136| 584k| return ordinal_; 137| 584k| } 138| 0| if (std::get_if(&rm_->data_)) { ------------------ | Branch (138:11): [True: 0, False: 0] ------------------ 139| 0| return results_[ordinal_]; 140| 0| } 141| 0| if (const auto* vec = std::get_if(&rm_->data_)) { ------------------ | Branch (141:23): [True: 0, False: 0] ------------------ 142| 0| return (*vec)[ordinal_]; 143| 0| } 144| 0| PERFETTO_FATAL("Didn't match any variant type."); 145| 0| } _ZNK8perfetto15trace_processor6RowMap3GetEj: 219| 604M| OutputIndex Get(InputRow row) const { 220| 604M| if (const auto* range = std::get_if(&data_)) { ------------------ | Branch (220:21): [True: 604M, False: 0] ------------------ 221| 604M| return GetRange(*range, row); 222| 604M| } 223| 0| if (const auto* bv = std::get_if(&data_)) { ------------------ | Branch (223:21): [True: 0, False: 0] ------------------ 224| 0| return GetBitVector(*bv, row); 225| 0| } 226| 0| if (const auto* vec = std::get_if(&data_)) { ------------------ | Branch (226:21): [True: 0, False: 0] ------------------ 227| 0| return GetIndexVector(*vec, row); 228| 0| } 229| 0| NoVariantMatched(); 230| 0| } _ZNK8perfetto15trace_processor6RowMap5RowOfEj: 266| 3.97M| std::optional RowOf(OutputIndex index) const { 267| 3.97M| if (const auto* range = std::get_if(&data_)) { ------------------ | Branch (267:21): [True: 3.97M, False: 0] ------------------ 268| 3.97M| if (index < range->start || index >= range->end) ------------------ | Branch (268:11): [True: 0, False: 3.97M] | Branch (268:35): [True: 0, False: 3.97M] ------------------ 269| 0| return std::nullopt; 270| 3.97M| return index - range->start; 271| 3.97M| } 272| 0| if (const auto* bv = std::get_if(&data_)) { ------------------ | Branch (272:21): [True: 0, False: 0] ------------------ 273| 0| return index < bv->size() && bv->IsSet(index) ------------------ | Branch (273:14): [True: 0, False: 0] | Branch (273:36): [True: 0, False: 0] ------------------ 274| 0| ? std::make_optional(bv->CountSetBits(index)) 275| 0| : std::nullopt; 276| 0| } 277| 0| if (const auto* vec = std::get_if(&data_)) { ------------------ | Branch (277:21): [True: 0, False: 0] ------------------ 278| 0| auto it = std::find(vec->begin(), vec->end(), index); 279| 0| return it != vec->end() ? std::make_optional(static_cast( ------------------ | Branch (279:14): [True: 0, False: 0] ------------------ 280| 0| std::distance(vec->begin(), it))) 281| 0| : std::nullopt; 282| 0| } 283| 0| NoVariantMatched(); 284| 0| } _ZN8perfetto15trace_processor6RowMap6InsertEj: 300| 14.9M| void Insert(OutputIndex index) { 301| 14.9M| if (auto* range = std::get_if(&data_)) { ------------------ | Branch (301:15): [True: 14.9M, False: 0] ------------------ 302| 14.9M| if (index == range->end) { ------------------ | Branch (302:11): [True: 14.9M, False: 0] ------------------ 303| | // Fast path: if we're just appending to the end 304| | // of the range, we can stay in range mode and 305| | // just bump the end index. 306| 14.9M| range->end++; 307| 14.9M| return; 308| 14.9M| } 309| | 310| | // Slow path: the insert is somewhere else other 311| | // than the end. This means we need to switch to 312| | // using a BitVector instead. 313| 0| BitVector bv; 314| 0| bv.Resize(range->start, false); 315| 0| bv.Resize(range->end, true); 316| 0| InsertIntoBitVector(bv, index); 317| 0| data_ = std::move(bv); 318| 0| return; 319| 14.9M| } 320| 0| if (auto* bv = std::get_if(&data_)) { ------------------ | Branch (320:15): [True: 0, False: 0] ------------------ 321| 0| InsertIntoBitVector(*bv, index); 322| 0| return; 323| 0| } 324| 0| if (auto* vec = std::get_if(&data_)) { ------------------ | Branch (324:15): [True: 0, False: 0] ------------------ 325| 0| PERFETTO_DCHECK(std::is_sorted(vec->begin(), vec->end())); 326| 0| auto it = std::upper_bound(vec->begin(), vec->end(), index); 327| 0| vec->insert(it, index); 328| 0| return; 329| 0| } 330| 0| NoVariantMatched(); 331| 0| } _ZNK8perfetto15trace_processor6RowMap14GetIfBitVectorEv: 399| 434| const BitVector* GetIfBitVector() const { 400| 434| return std::get_if(&data_); 401| 434| } _ZNK8perfetto15trace_processor6RowMap11IterateRowsEv: 414| 71.8k| Iterator IterateRows() const { return Iterator(this); } _ZNK8perfetto15trace_processor6RowMap11IsBitVectorEv: 420| 434| bool IsBitVector() const { return std::holds_alternative(data_); } _ZN8perfetto15trace_processor6RowMap8GetRangeENS1_5RangeEj: 434| 604M| PERFETTO_ALWAYS_INLINE static OutputIndex GetRange(Range r, InputRow row) { 435| 604M| return r.start + row; 436| 604M| } _ZN8perfetto15trace_processor6RowMap8IteratorC2EOS2_: 113| 143k| Iterator(Iterator&&) noexcept = default; _ZN8perfetto15trace_processor6RowMapaSEOS1_: 186| 434| RowMap& operator=(RowMap&&) = default; _ZN8perfetto15trace_processor6RowMapC2EOS1_: 185| 36.0k| RowMap(RowMap&&) noexcept = default; _ZN8perfetto15trace_processor10StringPoolC2Ev: 28| 434|StringPool::StringPool() { 29| 434| static_assert( 30| 434| StringPool::kMinLargeStringSizeBytes <= StringPool::kBlockSizeBytes + 1, 31| 434| "minimum size of large strings must be small enough to support any " 32| 434| "string that doesn't fit in a Block."); 33| | 34| 434| blocks_.emplace_back(kBlockSizeBytes); 35| | 36| | // Reserve a slot for the null string. 37| 434| PERFETTO_CHECK(blocks_.back().TryInsert(NullTermStringView()).first); 38| 434|} _ZN8perfetto15trace_processor10StringPoolD2Ev: 40| 434|StringPool::~StringPool() = default; _ZN8perfetto15trace_processor10StringPool12InsertStringENS_4base10StringViewEm: 45| 153k|StringPool::Id StringPool::InsertString(base::StringView str, uint64_t hash) { 46| | // Try and find enough space in the current block for the string and the 47| | // metadata (varint-encoded size + the string data + the null terminator). 48| 153k| bool success; 49| 153k| uint32_t offset; 50| 153k| std::tie(success, offset) = blocks_.back().TryInsert(str); 51| 153k| if (PERFETTO_UNLIKELY(!success)) { ------------------ | | 24| 153k|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 0, False: 153k] | | ------------------ ------------------ 52| | // The block did not have enough space for the string. If the string is 53| | // large, add it into the |large_strings_| vector, to avoid discarding a 54| | // large portion of the current block's memory. This also enables us to 55| | // support strings that wouldn't fit into a single block. Otherwise, add a 56| | // new block to store the string. 57| 0| if (str.size() + kMaxMetadataSize >= kMinLargeStringSizeBytes) { ------------------ | Branch (57:9): [True: 0, False: 0] ------------------ 58| 0| return InsertLargeString(str, hash); 59| 0| } 60| 0| blocks_.emplace_back(kBlockSizeBytes); 61| | 62| | // Try and reserve space again - this time we should definitely succeed. 63| 0| std::tie(success, offset) = blocks_.back().TryInsert(str); 64| 0| PERFETTO_CHECK(success); 65| 0| } 66| | 67| | // Compute the id from the block index and offset and add a mapping from the 68| | // hash to the id. 69| 153k| Id string_id = Id::BlockString(blocks_.size() - 1, offset); 70| | 71| | // Deliberately not adding |string_id| to |string_index_|. The caller 72| | // (InternString()) must take care of this. 73| 153k| PERFETTO_DCHECK(string_index_.Find(hash)); 74| | 75| 153k| return string_id; 76| 153k|} _ZN8perfetto15trace_processor10StringPool5Block9TryInsertENS_4base10StringViewE: 92| 154k| base::StringView str) { 93| 154k| auto str_size = str.size(); 94| 154k| size_t max_pos = static_cast(pos_) + str_size + kMaxMetadataSize; 95| 154k| if (max_pos > size_) ------------------ | Branch (95:7): [True: 0, False: 154k] ------------------ 96| 0| return std::make_pair(false, 0u); 97| | 98| | // Ensure that we commit up until the end of the string to memory. 99| 154k| mem_.EnsureCommitted(max_pos); 100| | 101| | // Get where we should start writing this string. 102| 154k| uint32_t offset = pos_; 103| 154k| uint8_t* begin = Get(offset); 104| | 105| | // First write the size of the string using varint encoding. 106| 154k| uint8_t* end = protozero::proto_utils::WriteVarInt(str_size, begin); 107| | 108| | // Next the string itself. 109| 154k| if (PERFETTO_LIKELY(str_size > 0)) { ------------------ | | 23| 154k|#define PERFETTO_LIKELY(...) __builtin_expect(!!(__VA_ARGS__), 1) | | ------------------ | | | Branch (23:30): [True: 153k, False: 790] | | ------------------ ------------------ 110| 153k| memcpy(end, str.data(), str_size); 111| 153k| end += str_size; 112| 153k| } 113| | 114| | // Finally add a null terminator. 115| 154k| *(end++) = '\0'; 116| | 117| | // Update the end of the block and return the pointer to the string. 118| 154k| pos_ = OffsetOf(end); 119| | 120| 154k| return std::make_pair(true, offset); 121| 154k|} _ZNK8perfetto15trace_processor10StringPool2IdeqERKS2_: 47| 45.1M| constexpr bool operator==(const Id& other) const { return other.id == id; } _ZNK8perfetto15trace_processor10StringPool2IdneERKS2_: 48| 4.13M| constexpr bool operator!=(const Id& other) const { 49| 4.13M| return !(other == *this); 50| 4.13M| } _ZNK8perfetto15trace_processor10StringPool2IdltERKS2_: 51| 493M| constexpr bool operator<(const Id& other) const { return id < other.id; } _ZNK8perfetto15trace_processor10StringPool2Id7is_nullEv: 53| 21.1M| constexpr bool is_null() const { return id == 0u; } _ZNK8perfetto15trace_processor10StringPool2Id15is_large_stringEv: 55| 279k| constexpr bool is_large_string() const { 56| 279k| return id & kLargeStringFlagBitMask; 57| 279k| } _ZNK8perfetto15trace_processor10StringPool2Id12block_offsetEv: 59| 279k| constexpr uint32_t block_offset() const { return id & kBlockOffsetBitMask; } _ZNK8perfetto15trace_processor10StringPool2Id11block_indexEv: 61| 279k| constexpr uint32_t block_index() const { 62| 279k| return (id & kBlockIndexBitMask) >> kNumBlockOffsetBits; 63| 279k| } _ZNK8perfetto15trace_processor10StringPool2Id6raw_idEv: 70| 40.8M| constexpr uint32_t raw_id() const { return id; } _ZN8perfetto15trace_processor10StringPool2Id11BlockStringEmj: 78| 153k| static constexpr Id BlockString(size_t index, uint32_t offset) { 79| 153k| PERFETTO_DCHECK(index < (1u << (kNumBlockIndexBits + 1))); 80| 153k| PERFETTO_DCHECK(offset < (1u << (kNumBlockOffsetBits + 1))); 81| 153k| return Id(~kLargeStringFlagBitMask & 82| 153k| (static_cast(index << kNumBlockOffsetBits) | 83| 153k| (offset & kBlockOffsetBitMask))); 84| 153k| } _ZN8perfetto15trace_processor10StringPool2Id4NullEv: 88| 13.1M| static constexpr Id Null() { return Id(0u); } _ZN8perfetto15trace_processor10StringPool2IdC2Ej: 91| 13.3M| constexpr explicit Id(uint32_t i) : id(i) {} _ZN8perfetto15trace_processor10StringPool12InternStringENS_4base10StringViewE: 125| 32.9M| Id InternString(base::StringView str) { 126| 32.9M| if (str.data() == nullptr) ------------------ | Branch (126:9): [True: 9.42M, False: 23.5M] ------------------ 127| 9.42M| return Id::Null(); 128| | 129| 23.5M| auto hash = str.Hash(); 130| | 131| | // Perform a hashtable insertion with a null ID just to check if the string 132| | // is already inserted. If it's not, overwrite 0 with the actual Id. 133| 23.5M| auto it_and_inserted = string_index_.Insert(hash, Id()); 134| 23.5M| Id* id = it_and_inserted.first; 135| 23.5M| if (!it_and_inserted.second) { ------------------ | Branch (135:9): [True: 23.3M, False: 153k] ------------------ 136| 23.3M| PERFETTO_DCHECK(Get(*id) == str); 137| 23.3M| return *id; 138| 23.3M| } 139| 153k| *id = InsertString(str, hash); 140| 153k| return *id; 141| 23.5M| } _ZNK8perfetto15trace_processor10StringPool5GetIdENS_4base10StringViewE: 143| 71.8k| std::optional GetId(base::StringView str) const { 144| 71.8k| if (str.data() == nullptr) ------------------ | Branch (144:9): [True: 0, False: 71.8k] ------------------ 145| 0| return Id::Null(); 146| | 147| 71.8k| auto hash = str.Hash(); 148| 71.8k| Id* id = string_index_.Find(hash); 149| 71.8k| if (id) { ------------------ | Branch (149:9): [True: 71.8k, False: 0] ------------------ 150| 71.8k| PERFETTO_DCHECK(Get(*id) == str); 151| 71.8k| return *id; 152| 71.8k| } 153| 0| return std::nullopt; 154| 71.8k| } _ZNK8perfetto15trace_processor10StringPool3GetENS1_2IdE: 156| 4.40M| NullTermStringView Get(Id id) const { 157| 4.40M| if (id.is_null()) ------------------ | Branch (157:9): [True: 4.12M, False: 279k] ------------------ 158| 4.12M| return NullTermStringView(); 159| 279k| if (id.is_large_string()) ------------------ | Branch (159:9): [True: 0, False: 279k] ------------------ 160| 0| return GetLargeString(id); 161| 279k| return GetFromBlockPtr(IdToPtr(id)); 162| 279k| } _ZN8perfetto15trace_processor10StringPool5BlockC2Em: 181| 434| : mem_(base::PagedMemory::Allocate(size, 182| 434| base::PagedMemory::kDontCommit)), 183| 434| size_(size) {} _ZNK8perfetto15trace_processor10StringPool5Block3GetEj: 194| 588k| uint8_t* Get(uint32_t offset) const { 195| 588k| return static_cast(mem_.Get()) + offset; 196| 588k| } _ZNK8perfetto15trace_processor10StringPool5Block8OffsetOfEPKh: 201| 154k| uint32_t OffsetOf(const uint8_t* ptr) const { 202| 154k| PERFETTO_DCHECK(Get(0) < ptr && 203| 154k| ptr <= Get(static_cast(size_ - 1))); 204| 154k| return static_cast(ptr - Get(0)); 205| 154k| } _ZNK8perfetto15trace_processor10StringPool7IdToPtrENS1_2IdE: 257| 279k| const uint8_t* IdToPtr(Id id) const { 258| | // If the MSB is set, the ID represents an index into |large_strings_|, so 259| | // shouldn't be converted into a block pointer. 260| 279k| PERFETTO_DCHECK(!id.is_large_string()); 261| | 262| 279k| size_t block_index = id.block_index(); 263| 279k| uint32_t block_offset = id.block_offset(); 264| | 265| 279k| PERFETTO_DCHECK(block_index < blocks_.size()); 266| 279k| PERFETTO_DCHECK(block_offset < blocks_[block_index].pos()); 267| | 268| 279k| return blocks_[block_index].Get(block_offset); 269| 279k| } _ZN8perfetto15trace_processor10StringPool8ReadSizeEPKhPj: 274| 279k| static const uint8_t* ReadSize(const uint8_t* ptr, uint32_t* size) { 275| 279k| uint64_t value = 0; 276| 279k| const uint8_t* str_ptr = protozero::proto_utils::ParseVarInt( 277| 279k| ptr, ptr + kMaxMetadataSize, &value); 278| 279k| PERFETTO_DCHECK(str_ptr != ptr); 279| 279k| PERFETTO_DCHECK(value < std::numeric_limits::max()); 280| 279k| *size = static_cast(value); 281| 279k| return str_ptr; 282| 279k| } _ZN8perfetto15trace_processor10StringPool15GetFromBlockPtrEPKh: 286| 279k| static NullTermStringView GetFromBlockPtr(const uint8_t* ptr) { 287| 279k| uint32_t size = 0; 288| 279k| const uint8_t* str_ptr = ReadSize(ptr, &size); 289| 279k| return {reinterpret_cast(str_ptr), size}; 290| 279k| } _ZNKSt3__14hashIN8perfetto15trace_processor10StringPool2IdEEclERKS4_: 326| 950k| result_type operator()(const argument_type& r) const { 327| 950k| return std::hash{}(r.raw_id()); 328| 950k| } _ZN8perfetto15trace_processor10StringPool5BlockD2Ev: 184| 434| ~Block() = default; _ZN8perfetto15trace_processor6BaseIdC2Ej: 31| 16.5M| explicit constexpr BaseId(uint32_t v) : value(v) {} _ZNK8perfetto15trace_processor6BaseIdeqERKS1_: 33| 2.53M| bool operator==(const BaseId& o) const { return o.value == value; } _ZNK8perfetto15trace_processor6BaseIdltERKS1_: 35| 3.05k| bool operator<(const BaseId& o) const { return value < o.value; } _ZN8perfetto15trace_processor12ColumnLegacyC2ERKS1_jjPKc: 33| 6.51k| : ColumnLegacy(name ? name : column.name_, ------------------ | Branch (33:20): [True: 0, False: 6.51k] ------------------ 34| 6.51k| column.type_, 35| 6.51k| column.flags_ & ~kNoCrossTableInheritFlags, 36| 6.51k| col_idx, 37| 6.51k| overlay_idx, 38| 6.51k| column.storage_) {} _ZN8perfetto15trace_processor12ColumnLegacyC2EPKcNS0_10ColumnTypeEjjjPNS0_17ColumnStorageBaseE: 46| 224k| : type_(type), 47| 224k| storage_(st), 48| 224k| name_(name), 49| 224k| flags_(flags), 50| 224k| index_in_table_(index_in_table), 51| 224k| overlay_index_(overlay_index) {} _ZN8perfetto15trace_processor12ColumnLegacy8IdColumnEjjPKcj: 66| 34.2k| uint32_t flags) { 67| 34.2k| return {name, ColumnType::kId, flags, col_idx, overlay_idx, nullptr}; 68| 34.2k|} _ZNK8perfetto15trace_processor12ColumnLegacy7overlayEv: 70| 608M|const ColumnStorageOverlay& ColumnLegacy::overlay() const { 71| 608M| PERFETTO_DCHECK(type_ != ColumnType::kDummy); 72| 608M| return table_->overlays_[overlay_index()]; 73| 608M|} _ZN8perfetto15trace_processor16ColumnTypeHelperIiE12ToColumnTypeEv: 40| 16.4k| static constexpr ColumnType ToColumnType() { return ColumnType::kInt32; } _ZN8perfetto15trace_processor16ColumnTypeHelperIjE12ToColumnTypeEv: 44| 2.66M| static constexpr ColumnType ToColumnType() { return ColumnType::kUint32; } _ZN8perfetto15trace_processor16ColumnTypeHelperIlE12ToColumnTypeEv: 48| 98.0k| static constexpr ColumnType ToColumnType() { return ColumnType::kInt64; } _ZN8perfetto15trace_processor16ColumnTypeHelperIdE12ToColumnTypeEv: 52| 6.94k| static constexpr ColumnType ToColumnType() { return ColumnType::kDouble; } _ZN8perfetto15trace_processor16ColumnTypeHelperINS0_10StringPool2IdEE12ToColumnTypeEv: 56| 44.2k| static constexpr ColumnType ToColumnType() { return ColumnType::kString; } _ZNK8perfetto15trace_processor12ColumnLegacy4IsIdEv: 235| 2.50M| bool IsId() const { return type_ == ColumnType::kId; } _ZNK8perfetto15trace_processor12ColumnLegacy10IsNullableEv: 238| 5.23M| bool IsNullable() const { return IsNullable(flags_); } _ZNK8perfetto15trace_processor12ColumnLegacy7IsDummyEv: 252| 56.4k| bool IsDummy() const { return type_ == ColumnType::kDummy; } _ZNK8perfetto15trace_processor12ColumnLegacy13overlay_indexEv: 258| 609M| uint32_t overlay_index() const { return overlay_index_; } _ZNK8perfetto15trace_processor12ColumnLegacy14index_in_tableEv: 261| 521k| uint32_t index_in_table() const { return index_in_table_; } _ZN8perfetto15trace_processor12ColumnLegacy10IsNullableEj: 420| 5.23M| static constexpr bool IsNullable(uint32_t flags) { 421| 5.23M| return (flags & Flag::kNonNull) == 0; 422| 5.23M| } _ZN8perfetto15trace_processor12ColumnLegacy11BindToTableEPNS0_5TableEPNS0_10StringPoolE: 455| 224k| void BindToTable(Table* table, StringPool* string_pool) { 456| 224k| PERFETTO_DCHECK(!table_); 457| 224k| table_ = table; 458| 224k| string_pool_ = string_pool; 459| | 460| | // Check that the dense-ness of the column and the nullable vector match. 461| 224k| if (IsNullable() && !IsDummy()) { ------------------ | Branch (461:9): [True: 56.4k, False: 168k] | Branch (461:25): [True: 56.4k, False: 0] ------------------ 462| 56.4k| bool is_storage_dense; 463| 56.4k| switch (type_) { ------------------ | Branch (463:15): [True: 0, False: 56.4k] ------------------ 464| 1.30k| case ColumnType::kInt32: ------------------ | Branch (464:9): [True: 1.30k, False: 55.1k] ------------------ 465| 1.30k| is_storage_dense = storage>().IsDense(); 466| 1.30k| break; 467| 39.9k| case ColumnType::kUint32: ------------------ | Branch (467:9): [True: 39.9k, False: 16.4k] ------------------ 468| 39.9k| is_storage_dense = storage>().IsDense(); 469| 39.9k| break; 470| 12.1k| case ColumnType::kInt64: ------------------ | Branch (470:9): [True: 12.1k, False: 44.2k] ------------------ 471| 12.1k| is_storage_dense = storage>().IsDense(); 472| 12.1k| break; 473| 3.03k| case ColumnType::kDouble: ------------------ | Branch (473:9): [True: 3.03k, False: 53.3k] ------------------ 474| 3.03k| is_storage_dense = storage>().IsDense(); 475| 3.03k| break; 476| 0| case ColumnType::kString: ------------------ | Branch (476:9): [True: 0, False: 56.4k] ------------------ 477| 0| PERFETTO_FATAL("String column should not be nullable"); 478| 0| case ColumnType::kId: ------------------ | Branch (478:9): [True: 0, False: 56.4k] ------------------ 479| 0| PERFETTO_FATAL("Id column should not be nullable"); 480| 0| case ColumnType::kDummy: ------------------ | Branch (480:9): [True: 0, False: 56.4k] ------------------ 481| 0| PERFETTO_FATAL("Dummy column excluded above"); 482| 56.4k| } 483| 56.4k| PERFETTO_DCHECK(is_storage_dense == IsDense()); 484| 56.4k| } 485| 224k| PERFETTO_DCHECK(IsFlagsAndTypeValid(flags_, type_)); 486| 224k| } _ZNK8perfetto15trace_processor12ColumnLegacy7storageIjEERKNS0_13ColumnStorageINS0_11tc_internal11TypeHandlerIT_E11stored_typeEEEv: 319| 182M| const ColumnStorage>& storage() const { 320| 182M| PERFETTO_DCHECK(ColumnTypeHelper::ToColumnType() == type_); 321| 182M| PERFETTO_DCHECK(tc_internal::TypeHandler::is_optional == IsNullable()); 322| 182M| return *static_cast>*>(storage_); 323| 182M| } _ZNK8perfetto15trace_processor12ColumnLegacy7storageIlEERKNS0_13ColumnStorageINS0_11tc_internal11TypeHandlerIT_E11stored_typeEEEv: 319| 32.9M| const ColumnStorage>& storage() const { 320| 32.9M| PERFETTO_DCHECK(ColumnTypeHelper::ToColumnType() == type_); 321| 32.9M| PERFETTO_DCHECK(tc_internal::TypeHandler::is_optional == IsNullable()); 322| 32.9M| return *static_cast>*>(storage_); 323| 32.9M| } _ZNK8perfetto15trace_processor12ColumnLegacy7storageINS0_10StringPool2IdEEERKNS0_13ColumnStorageINS0_11tc_internal11TypeHandlerIT_E11stored_typeEEEv: 319| 16.1M| const ColumnStorage>& storage() const { 320| 16.1M| PERFETTO_DCHECK(ColumnTypeHelper::ToColumnType() == type_); 321| 16.1M| PERFETTO_DCHECK(tc_internal::TypeHandler::is_optional == IsNullable()); 322| 16.1M| return *static_cast>*>(storage_); 323| 16.1M| } _ZNK8perfetto15trace_processor12ColumnLegacy7storageINSt3__18optionalIiEEEERKNS0_13ColumnStorageINS0_11tc_internal11TypeHandlerIT_E11stored_typeEEEv: 319| 1.30k| const ColumnStorage>& storage() const { 320| 1.30k| PERFETTO_DCHECK(ColumnTypeHelper::ToColumnType() == type_); 321| 1.30k| PERFETTO_DCHECK(tc_internal::TypeHandler::is_optional == IsNullable()); 322| 1.30k| return *static_cast>*>(storage_); 323| 1.30k| } _ZNK8perfetto15trace_processor12ColumnLegacy7storageINSt3__18optionalIjEEEERKNS0_13ColumnStorageINS0_11tc_internal11TypeHandlerIT_E11stored_typeEEEv: 319| 183M| const ColumnStorage>& storage() const { 320| 183M| PERFETTO_DCHECK(ColumnTypeHelper::ToColumnType() == type_); 321| 183M| PERFETTO_DCHECK(tc_internal::TypeHandler::is_optional == IsNullable()); 322| 183M| return *static_cast>*>(storage_); 323| 183M| } _ZNK8perfetto15trace_processor12ColumnLegacy7storageINSt3__18optionalIlEEEERKNS0_13ColumnStorageINS0_11tc_internal11TypeHandlerIT_E11stored_typeEEEv: 319| 181M| const ColumnStorage>& storage() const { 320| 181M| PERFETTO_DCHECK(ColumnTypeHelper::ToColumnType() == type_); 321| 181M| PERFETTO_DCHECK(tc_internal::TypeHandler::is_optional == IsNullable()); 322| 181M| return *static_cast>*>(storage_); 323| 181M| } _ZNK8perfetto15trace_processor12ColumnLegacy7storageINSt3__18optionalIdEEEERKNS0_13ColumnStorageINS0_11tc_internal11TypeHandlerIT_E11stored_typeEEEv: 319| 3.03k| const ColumnStorage>& storage() const { 320| 3.03k| PERFETTO_DCHECK(ColumnTypeHelper::ToColumnType() == type_); 321| 3.03k| PERFETTO_DCHECK(tc_internal::TypeHandler::is_optional == IsNullable()); 322| 3.03k| return *static_cast>*>(storage_); 323| 3.03k| } _ZN8perfetto15trace_processor12ColumnLegacy15mutable_storageIjEEPNS0_13ColumnStorageINS0_11tc_internal11TypeHandlerIT_E11stored_typeEEEv: 348| 19.6M| ColumnStorage>* mutable_storage() { 349| 19.6M| PERFETTO_DCHECK(ColumnTypeHelper::ToColumnType() == type_); 350| 19.6M| PERFETTO_DCHECK(tc_internal::TypeHandler::is_optional == IsNullable()); 351| 19.6M| return static_cast>*>(storage_); 352| 19.6M| } _ZN8perfetto15trace_processor12ColumnLegacy15mutable_storageINS0_10StringPool2IdEEEPNS0_13ColumnStorageINS0_11tc_internal11TypeHandlerIT_E11stored_typeEEEv: 348| 23.1M| ColumnStorage>* mutable_storage() { 349| 23.1M| PERFETTO_DCHECK(ColumnTypeHelper::ToColumnType() == type_); 350| 23.1M| PERFETTO_DCHECK(tc_internal::TypeHandler::is_optional == IsNullable()); 351| 23.1M| return static_cast>*>(storage_); 352| 23.1M| } _ZN8perfetto15trace_processor12ColumnLegacy15mutable_storageINSt3__18optionalIlEEEEPNS0_13ColumnStorageINS0_11tc_internal11TypeHandlerIT_E11stored_typeEEEv: 348| 8.22M| ColumnStorage>* mutable_storage() { 349| 8.22M| PERFETTO_DCHECK(ColumnTypeHelper::ToColumnType() == type_); 350| 8.22M| PERFETTO_DCHECK(tc_internal::TypeHandler::is_optional == IsNullable()); 351| 8.22M| return static_cast>*>(storage_); 352| 8.22M| } _ZN8perfetto15trace_processor12ColumnLegacy15mutable_storageINSt3__18optionalIjEEEEPNS0_13ColumnStorageINS0_11tc_internal11TypeHandlerIT_E11stored_typeEEEv: 348| 44.8M| ColumnStorage>* mutable_storage() { 349| 44.8M| PERFETTO_DCHECK(ColumnTypeHelper::ToColumnType() == type_); 350| 44.8M| PERFETTO_DCHECK(tc_internal::TypeHandler::is_optional == IsNullable()); 351| 44.8M| return static_cast>*>(storage_); 352| 44.8M| } _ZN8perfetto15trace_processor12ColumnLegacy15mutable_storageINSt3__18optionalIdEEEEPNS0_13ColumnStorageINS0_11tc_internal11TypeHandlerIT_E11stored_typeEEEv: 348| 2.16M| ColumnStorage>* mutable_storage() { 349| 2.16M| PERFETTO_DCHECK(ColumnTypeHelper::ToColumnType() == type_); 350| 2.16M| PERFETTO_DCHECK(tc_internal::TypeHandler::is_optional == IsNullable()); 351| 2.16M| return static_cast>*>(storage_); 352| 2.16M| } _ZN8perfetto15trace_processor12ColumnLegacy15mutable_storageIlEEPNS0_13ColumnStorageINS0_11tc_internal11TypeHandlerIT_E11stored_typeEEEv: 348| 6.23M| ColumnStorage>* mutable_storage() { 349| 6.23M| PERFETTO_DCHECK(ColumnTypeHelper::ToColumnType() == type_); 350| 6.23M| PERFETTO_DCHECK(tc_internal::TypeHandler::is_optional == IsNullable()); 351| 6.23M| return static_cast>*>(storage_); 352| 6.23M| } _ZN8perfetto15trace_processor12ColumnLegacy15mutable_storageIdEEPNS0_13ColumnStorageINS0_11tc_internal11TypeHandlerIT_E11stored_typeEEEv: 348| 279k| ColumnStorage>* mutable_storage() { 349| 279k| PERFETTO_DCHECK(ColumnTypeHelper::ToColumnType() == type_); 350| 279k| PERFETTO_DCHECK(tc_internal::TypeHandler::is_optional == IsNullable()); 351| 279k| return static_cast>*>(storage_); 352| 279k| } _ZNK8perfetto15trace_processor12ColumnLegacy12IsColumnTypeINSt3__18optionalIjEEEEbv: 230| 1.09M| bool IsColumnType() const { 231| 1.09M| return ColumnTypeHelper::ToColumnType() == type_; 232| 1.09M| } _ZNK8perfetto15trace_processor12ColumnLegacy12IsColumnTypeIjEEbv: 230| 1.40M| bool IsColumnType() const { 231| 1.40M| return ColumnTypeHelper::ToColumnType() == type_; 232| 1.40M| } _ZN8perfetto15trace_processor12ColumnLegacyC2INS0_10StringPool2IdEEEPKcPNS0_13ColumnStorageIT_EEjjj: 187| 44.2k| : ColumnLegacy(name, 188| 44.2k| ColumnTypeHelper>::ToColumnType(), 189| 44.2k| flags, 190| 44.2k| col_idx_in_table, 191| 44.2k| row_map_idx, 192| 44.2k| storage) {} _ZN8perfetto15trace_processor12ColumnLegacyC2INSt3__18optionalIlEEEEPKcPNS0_13ColumnStorageIT_EEjjj: 187| 10.4k| : ColumnLegacy(name, 188| 10.4k| ColumnTypeHelper>::ToColumnType(), 189| 10.4k| flags, 190| 10.4k| col_idx_in_table, 191| 10.4k| row_map_idx, 192| 10.4k| storage) {} _ZN8perfetto15trace_processor12ColumnLegacyC2IlEEPKcPNS0_13ColumnStorageIT_EEjjj: 187| 38.6k| : ColumnLegacy(name, 188| 38.6k| ColumnTypeHelper>::ToColumnType(), 189| 38.6k| flags, 190| 38.6k| col_idx_in_table, 191| 38.6k| row_map_idx, 192| 38.6k| storage) {} _ZN8perfetto15trace_processor12ColumnLegacyC2IjEEPKcPNS0_13ColumnStorageIT_EEjjj: 187| 39.9k| : ColumnLegacy(name, 188| 39.9k| ColumnTypeHelper>::ToColumnType(), 189| 39.9k| flags, 190| 39.9k| col_idx_in_table, 191| 39.9k| row_map_idx, 192| 39.9k| storage) {} _ZN8perfetto15trace_processor12ColumnLegacyC2INSt3__18optionalIjEEEEPKcPNS0_13ColumnStorageIT_EEjjj: 187| 39.0k| : ColumnLegacy(name, 188| 39.0k| ColumnTypeHelper>::ToColumnType(), 189| 39.0k| flags, 190| 39.0k| col_idx_in_table, 191| 39.0k| row_map_idx, 192| 39.0k| storage) {} _ZN8perfetto15trace_processor12ColumnLegacyC2IiEEPKcPNS0_13ColumnStorageIT_EEjjj: 187| 6.94k| : ColumnLegacy(name, 188| 6.94k| ColumnTypeHelper>::ToColumnType(), 189| 6.94k| flags, 190| 6.94k| col_idx_in_table, 191| 6.94k| row_map_idx, 192| 6.94k| storage) {} _ZN8perfetto15trace_processor12ColumnLegacyC2INSt3__18optionalIdEEEEPKcPNS0_13ColumnStorageIT_EEjjj: 187| 3.03k| : ColumnLegacy(name, 188| 3.03k| ColumnTypeHelper>::ToColumnType(), 189| 3.03k| flags, 190| 3.03k| col_idx_in_table, 191| 3.03k| row_map_idx, 192| 3.03k| storage) {} _ZN8perfetto15trace_processor12ColumnLegacyC2IdEEPKcPNS0_13ColumnStorageIT_EEjjj: 187| 434| : ColumnLegacy(name, 188| 434| ColumnTypeHelper>::ToColumnType(), 189| 434| flags, 190| 434| col_idx_in_table, 191| 434| row_map_idx, 192| 434| storage) {} _ZN8perfetto15trace_processor12ColumnLegacyC2INSt3__18optionalIiEEEEPKcPNS0_13ColumnStorageIT_EEjjj: 187| 1.30k| : ColumnLegacy(name, 188| 1.30k| ColumnTypeHelper>::ToColumnType(), 189| 1.30k| flags, 190| 1.30k| col_idx_in_table, 191| 1.30k| row_map_idx, 192| 1.30k| storage) {} _ZN8perfetto15trace_processor6column14NumericStorageIdEC2EPKNSt3__16vectorIdNS4_9allocatorIdEEEENS0_10ColumnTypeEb: 232| 3.47k| : NumericStorageBase(type, is_sorted, GetImpl()), vector_(vec) {} _ZN8perfetto15trace_processor6column14NumericStorageIjEC2EPKNSt3__16vectorIjNS4_9allocatorIjEEEENS0_10ColumnTypeEb: 232| 76.8k| : NumericStorageBase(type, is_sorted, GetImpl()), vector_(vec) {} _ZN8perfetto15trace_processor6column14NumericStorageIiEC2EPKNSt3__16vectorIiNS4_9allocatorIiEEEENS0_10ColumnTypeEb: 232| 8.24k| : NumericStorageBase(type, is_sorted, GetImpl()), vector_(vec) {} _ZN8perfetto15trace_processor6column14NumericStorageIlEC2EPKNSt3__16vectorIlNS4_9allocatorIlEEEENS0_10ColumnTypeEb: 232| 49.0k| : NumericStorageBase(type, is_sorted, GetImpl()), vector_(vec) {} _ZN8perfetto15trace_processor6column9DataLayerD2Ev: 47| 272k|DataLayer::~DataLayer() = default; _ZN8perfetto15trace_processor6column16DenseNullOverlayC2EPKNS0_9BitVectorE: 186| 868| : OverlayLayer(Impl::kDenseNull), non_null_(non_null) {} _ZN8perfetto15trace_processor6column16DenseNullOverlayD2Ev: 187| 868|DenseNullOverlay::~DenseNullOverlay() = default; _ZN8perfetto15trace_processor6column9IdStorageC2Ev: 199| 34.2k|IdStorage::IdStorage() : StorageLayer(Impl::kId) {} _ZN8perfetto15trace_processor6column9IdStorageD2Ev: 200| 34.2k|IdStorage::~IdStorage() = default; _ZN8perfetto15trace_processor6column11NullOverlayC2EPKNS0_9BitVectorE: 207| 52.9k| : OverlayLayer(Impl::kNull), non_null_(non_null) {} _ZN8perfetto15trace_processor6column11NullOverlayD2Ev: 208| 52.9k|NullOverlay::~NullOverlay() = default; _ZN8perfetto15trace_processor6column18NumericStorageBaseC2ENS0_10ColumnTypeEbNS1_9DataLayer4ImplE: 219| 137k| : StorageLayer(impl), storage_type_(type), is_sorted_(is_sorted) {} _ZN8perfetto15trace_processor6column18NumericStorageBaseD2Ev: 221| 137k|NumericStorageBase::~NumericStorageBase() = default; _ZN8perfetto15trace_processor6column15SelectorOverlayC2EPKNS0_9BitVectorE: 252| 434| : OverlayLayer(Impl::kSelector), selector_(selector) {} _ZN8perfetto15trace_processor6column15SelectorOverlayD2Ev: 253| 434|SelectorOverlay::~SelectorOverlay() = default; _ZN8perfetto15trace_processor6column12SetIdStorageC2EPKNSt3__16vectorIjNS3_9allocatorIjEEEE: 262| 2.17k| : StorageLayer(Impl::kSetId), values_(values) {} _ZN8perfetto15trace_processor6column12SetIdStorageD2Ev: 263| 2.17k|SetIdStorage::~SetIdStorage() = default; _ZN8perfetto15trace_processor6column13StringStorageC2EPNS0_10StringPoolEPKNSt3__16vectorINS3_2IdENS5_9allocatorIS7_EEEEb: 272| 44.2k| : StorageLayer(Impl::kString), 273| 44.2k| data_(data), 274| 44.2k| string_pool_(string_pool), 275| 44.2k| is_sorted_(is_sorted) {} _ZN8perfetto15trace_processor6column13StringStorageD2Ev: 276| 44.2k|StringStorage::~StringStorage() = default; _ZN8perfetto15trace_processor6column9DataLayerC2ENS2_4ImplE: 81| 272k| explicit DataLayer(Impl impl) : impl_(impl) {} _ZN8perfetto15trace_processor6column14NumericStorageIdE7GetImplEv: 172| 3.47k| Impl GetImpl() { 173| 3.47k| if constexpr (std::is_same_v) { 174| 3.47k| return Impl::kNumericDouble; 175| | } else if constexpr (std::is_same_v) { 176| | return Impl::kNumericUint32; 177| | } else if constexpr (std::is_same_v) { 178| | return Impl::kNumericInt32; 179| | } else if constexpr (std::is_same_v) { 180| | return Impl::kNumericInt64; 181| | } else { 182| | // false doesn't work as expression has to depend on the template 183| | // parameter 184| | static_assert(sizeof(T*) == 0, "T is not supported"); 185| | } 186| 3.47k| } _ZN8perfetto15trace_processor6column14NumericStorageIjE7GetImplEv: 172| 76.8k| Impl GetImpl() { 173| | if constexpr (std::is_same_v) { 174| | return Impl::kNumericDouble; 175| 76.8k| } else if constexpr (std::is_same_v) { 176| 76.8k| return Impl::kNumericUint32; 177| | } else if constexpr (std::is_same_v) { 178| | return Impl::kNumericInt32; 179| | } else if constexpr (std::is_same_v) { 180| | return Impl::kNumericInt64; 181| | } else { 182| | // false doesn't work as expression has to depend on the template 183| | // parameter 184| | static_assert(sizeof(T*) == 0, "T is not supported"); 185| | } 186| 76.8k| } _ZN8perfetto15trace_processor6column14NumericStorageIiE7GetImplEv: 172| 8.24k| Impl GetImpl() { 173| | if constexpr (std::is_same_v) { 174| | return Impl::kNumericDouble; 175| | } else if constexpr (std::is_same_v) { 176| | return Impl::kNumericUint32; 177| 8.24k| } else if constexpr (std::is_same_v) { 178| 8.24k| return Impl::kNumericInt32; 179| | } else if constexpr (std::is_same_v) { 180| | return Impl::kNumericInt64; 181| | } else { 182| | // false doesn't work as expression has to depend on the template 183| | // parameter 184| | static_assert(sizeof(T*) == 0, "T is not supported"); 185| | } 186| 8.24k| } _ZN8perfetto15trace_processor6column14NumericStorageIlE7GetImplEv: 172| 49.0k| Impl GetImpl() { 173| | if constexpr (std::is_same_v) { 174| | return Impl::kNumericDouble; 175| | } else if constexpr (std::is_same_v) { 176| | return Impl::kNumericUint32; 177| | } else if constexpr (std::is_same_v) { 178| | return Impl::kNumericInt32; 179| 49.0k| } else if constexpr (std::is_same_v) { 180| 49.0k| return Impl::kNumericInt64; 181| | } else { 182| | // false doesn't work as expression has to depend on the template 183| | // parameter 184| | static_assert(sizeof(T*) == 0, "T is not supported"); 185| | } 186| 49.0k| } _ZN8perfetto15trace_processor6column12OverlayLayerC2ENS1_9DataLayer4ImplE: 23| 54.2k|OverlayLayer::OverlayLayer(Impl impl) : DataLayer(impl) {} _ZN8perfetto15trace_processor6column12OverlayLayerD2Ev: 25| 54.2k|OverlayLayer::~OverlayLayer() = default; _ZN8perfetto15trace_processor6column12StorageLayerC2ENS1_9DataLayer4ImplE: 23| 218k|StorageLayer::StorageLayer(Impl impl) : DataLayer(impl) {} _ZN8perfetto15trace_processor6column12StorageLayerD2Ev: 25| 218k|StorageLayer::~StorageLayer() = default; _ZN8perfetto15trace_processor17ColumnStorageBaseD2Ev: 22| 184k|ColumnStorageBase::~ColumnStorageBase() = default; _ZNK8perfetto15trace_processor13ColumnStorageINS0_10StringPool2IdEE3GetEj: 63| 16.1M| T Get(uint32_t idx) const { return vector_[idx]; } _ZNK8perfetto15trace_processor13ColumnStorageINSt3__18optionalIjEEE3GetEj: 111| 183M| std::optional Get(uint32_t idx) const { 112| 183M| bool contains = valid_.IsSet(idx); 113| 183M| if (mode_ == Mode::kDense) { ------------------ | Branch (113:9): [True: 0, False: 183M] ------------------ 114| 0| return contains ? std::make_optional(data_[idx]) : std::nullopt; ------------------ | Branch (114:14): [True: 0, False: 0] ------------------ 115| 0| } 116| 183M| return contains ? std::make_optional(data_[valid_.CountSetBits(idx)]) ------------------ | Branch (116:12): [True: 182M, False: 783k] ------------------ 117| 183M| : std::nullopt; 118| 183M| } _ZNK8perfetto15trace_processor13ColumnStorageIjE3GetEj: 63| 182M| T Get(uint32_t idx) const { return vector_[idx]; } _ZNK8perfetto15trace_processor13ColumnStorageINSt3__18optionalIlEEE3GetEj: 111| 181M| std::optional Get(uint32_t idx) const { 112| 181M| bool contains = valid_.IsSet(idx); 113| 181M| if (mode_ == Mode::kDense) { ------------------ | Branch (113:9): [True: 0, False: 181M] ------------------ 114| 0| return contains ? std::make_optional(data_[idx]) : std::nullopt; ------------------ | Branch (114:14): [True: 0, False: 0] ------------------ 115| 0| } 116| 181M| return contains ? std::make_optional(data_[valid_.CountSetBits(idx)]) ------------------ | Branch (116:12): [True: 6.14k, False: 181M] ------------------ 117| 181M| : std::nullopt; 118| 181M| } _ZNK8perfetto15trace_processor13ColumnStorageIlE3GetEj: 63| 32.9M| T Get(uint32_t idx) const { return vector_[idx]; } _ZNK8perfetto15trace_processor13ColumnStorageINSt3__18optionalIiEEE7IsDenseEv: 160| 1.30k| bool IsDense() const { return mode_ == Mode::kDense; } _ZNK8perfetto15trace_processor13ColumnStorageINSt3__18optionalIjEEE7IsDenseEv: 160| 39.9k| bool IsDense() const { return mode_ == Mode::kDense; } _ZNK8perfetto15trace_processor13ColumnStorageINSt3__18optionalIlEEE7IsDenseEv: 160| 12.1k| bool IsDense() const { return mode_ == Mode::kDense; } _ZNK8perfetto15trace_processor13ColumnStorageINSt3__18optionalIdEEE7IsDenseEv: 160| 3.03k| bool IsDense() const { return mode_ == Mode::kDense; } _ZN8perfetto15trace_processor13ColumnStorageIjE3SetEjj: 71| 2.14M| void Set(uint32_t idx, T val) { vector_[idx] = val; } _ZN8perfetto15trace_processor13ColumnStorageIjE6CreateILb0EEES2_v: 81| 39.9k| static ColumnStorage Create() { 82| 39.9k| static_assert(!IsDense, "Invalid for non-null storage to be dense."); 83| 39.9k| return ColumnStorage(); 84| 39.9k| } _ZNK8perfetto15trace_processor13ColumnStorageIjE6vectorEv: 73| 39.9k| const std::vector& vector() const { return vector_; } _ZN8perfetto15trace_processor13ColumnStorageIjE6AppendEj: 64| 17.5M| void Append(T val) { vector_.emplace_back(val); } _ZN8perfetto15trace_processor13ColumnStorageINS0_10StringPool2IdEE3SetEjS3_: 71| 137k| void Set(uint32_t idx, T val) { vector_[idx] = val; } _ZN8perfetto15trace_processor13ColumnStorageINSt3__18optionalIlEEE3SetEjl: 144| 140k| void Set(uint32_t idx, T val) { 145| 140k| if (mode_ == Mode::kDense) { ------------------ | Branch (145:9): [True: 0, False: 140k] ------------------ 146| 0| valid_.Set(idx); 147| 0| data_[idx] = val; 148| 140k| } else { 149| | // Generally, we will be setting a null row to non-null so optimize for 150| | // that path. 151| 140k| uint32_t row = valid_.CountSetBits(idx); 152| 140k| bool was_set = valid_.Set(idx); 153| 140k| if (PERFETTO_UNLIKELY(was_set)) { ------------------ | | 24| 140k|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 69.2k, False: 70.8k] | | ------------------ ------------------ 154| 69.2k| data_[row] = val; 155| 70.8k| } else { 156| 70.8k| data_.insert(data_.begin() + static_cast(row), val); 157| 70.8k| } 158| 140k| } 159| 140k| } _ZN8perfetto15trace_processor13ColumnStorageINSt3__18optionalIjEEE3SetEjj: 144| 2.59M| void Set(uint32_t idx, T val) { 145| 2.59M| if (mode_ == Mode::kDense) { ------------------ | Branch (145:9): [True: 0, False: 2.59M] ------------------ 146| 0| valid_.Set(idx); 147| 0| data_[idx] = val; 148| 2.59M| } else { 149| | // Generally, we will be setting a null row to non-null so optimize for 150| | // that path. 151| 2.59M| uint32_t row = valid_.CountSetBits(idx); 152| 2.59M| bool was_set = valid_.Set(idx); 153| 2.59M| if (PERFETTO_UNLIKELY(was_set)) { ------------------ | | 24| 2.59M|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 74, False: 2.59M] | | ------------------ ------------------ 154| 74| data_[row] = val; 155| 2.59M| } else { 156| 2.59M| data_.insert(data_.begin() + static_cast(row), val); 157| 2.59M| } 158| 2.59M| } 159| 2.59M| } _ZN8perfetto15trace_processor13ColumnStorageINS0_10StringPool2IdEE6CreateILb0EEES4_v: 81| 44.2k| static ColumnStorage Create() { 82| 44.2k| static_assert(!IsDense, "Invalid for non-null storage to be dense."); 83| 44.2k| return ColumnStorage(); 84| 44.2k| } _ZN8perfetto15trace_processor13ColumnStorageINSt3__18optionalIlEEE6CreateILb0EEES5_v: 178| 10.4k| static ColumnStorage> Create() { 179| 10.4k| return IsDense ? ColumnStorage>(Mode::kDense) ------------------ | Branch (179:12): [Folded - Ignored] ------------------ 180| 10.4k| : ColumnStorage>(Mode::kSparse); 181| 10.4k| } _ZN8perfetto15trace_processor13ColumnStorageINSt3__18optionalIjEEE6CreateILb0EEES5_v: 178| 38.1k| static ColumnStorage> Create() { 179| 38.1k| return IsDense ? ColumnStorage>(Mode::kDense) ------------------ | Branch (179:12): [Folded - Ignored] ------------------ 180| 38.1k| : ColumnStorage>(Mode::kSparse); 181| 38.1k| } _ZNK8perfetto15trace_processor13ColumnStorageINS0_10StringPool2IdEE6vectorEv: 73| 44.2k| const std::vector& vector() const { return vector_; } _ZNKR8perfetto15trace_processor13ColumnStorageINSt3__18optionalIlEEE15non_null_vectorEv: 167| 10.4k| const std::vector& non_null_vector() const& { return data_; } _ZNKR8perfetto15trace_processor13ColumnStorageINSt3__18optionalIjEEE15non_null_vectorEv: 167| 39.0k| const std::vector& non_null_vector() const& { return data_; } _ZNK8perfetto15trace_processor13ColumnStorageINSt3__18optionalIlEEE2bvEv: 171| 10.4k| const BitVector* bv() const final { return &non_null_bit_vector(); } _ZNK8perfetto15trace_processor13ColumnStorageINSt3__18optionalIlEEE19non_null_bit_vectorEv: 168| 10.4k| const BitVector& non_null_bit_vector() const { return valid_; } _ZNK8perfetto15trace_processor13ColumnStorageINSt3__18optionalIjEEE2bvEv: 171| 39.0k| const BitVector* bv() const final { return &non_null_bit_vector(); } _ZNK8perfetto15trace_processor13ColumnStorageINSt3__18optionalIjEEE19non_null_bit_vectorEv: 168| 39.0k| const BitVector& non_null_bit_vector() const { return valid_; } _ZN8perfetto15trace_processor13ColumnStorageINS0_10StringPool2IdEE6AppendES3_: 64| 23.0M| void Append(T val) { vector_.emplace_back(val); } _ZN8perfetto15trace_processor13ColumnStorageINSt3__18optionalIlEEE6AppendES4_: 123| 8.08M| void Append(std::optional val) { 124| 8.08M| if (val) { ------------------ | Branch (124:9): [True: 2.14M, False: 5.93M] ------------------ 125| 2.14M| Append(*val); 126| 5.93M| } else { 127| 5.93M| AppendNull(); 128| 5.93M| } 129| 8.08M| } _ZN8perfetto15trace_processor13ColumnStorageINSt3__18optionalIlEEE6AppendEl: 119| 2.14M| void Append(T val) { 120| 2.14M| data_.emplace_back(val); 121| 2.14M| valid_.AppendTrue(); 122| 2.14M| } _ZN8perfetto15trace_processor13ColumnStorageINSt3__18optionalIlEEE10AppendNullEv: 201| 5.93M| void AppendNull() { 202| 5.93M| if (mode_ == Mode::kDense) { ------------------ | Branch (202:9): [True: 0, False: 5.93M] ------------------ 203| 0| data_.emplace_back(); 204| 0| } 205| 5.93M| valid_.AppendFalse(); 206| 5.93M| } _ZN8perfetto15trace_processor13ColumnStorageINSt3__18optionalIjEEE6AppendES4_: 123| 42.2M| void Append(std::optional val) { 124| 42.2M| if (val) { ------------------ | Branch (124:9): [True: 7.07M, False: 35.1M] ------------------ 125| 7.07M| Append(*val); 126| 35.1M| } else { 127| 35.1M| AppendNull(); 128| 35.1M| } 129| 42.2M| } _ZN8perfetto15trace_processor13ColumnStorageINSt3__18optionalIjEEE6AppendEj: 119| 7.07M| void Append(T val) { 120| 7.07M| data_.emplace_back(val); 121| 7.07M| valid_.AppendTrue(); 122| 7.07M| } _ZN8perfetto15trace_processor13ColumnStorageINSt3__18optionalIjEEE10AppendNullEv: 201| 35.1M| void AppendNull() { 202| 35.1M| if (mode_ == Mode::kDense) { ------------------ | Branch (202:9): [True: 0, False: 35.1M] ------------------ 203| 0| data_.emplace_back(); 204| 0| } 205| 35.1M| valid_.AppendFalse(); 206| 35.1M| } _ZN8perfetto15trace_processor13ColumnStorageINSt3__18optionalIdEEE6CreateILb0EEES5_v: 178| 3.03k| static ColumnStorage> Create() { 179| 3.03k| return IsDense ? ColumnStorage>(Mode::kDense) ------------------ | Branch (179:12): [Folded - Ignored] ------------------ 180| 3.03k| : ColumnStorage>(Mode::kSparse); 181| 3.03k| } _ZNKR8perfetto15trace_processor13ColumnStorageINSt3__18optionalIdEEE15non_null_vectorEv: 167| 3.03k| const std::vector& non_null_vector() const& { return data_; } _ZNK8perfetto15trace_processor13ColumnStorageINSt3__18optionalIdEEE2bvEv: 171| 3.03k| const BitVector* bv() const final { return &non_null_bit_vector(); } _ZNK8perfetto15trace_processor13ColumnStorageINSt3__18optionalIdEEE19non_null_bit_vectorEv: 168| 3.03k| const BitVector& non_null_bit_vector() const { return valid_; } _ZN8perfetto15trace_processor13ColumnStorageINSt3__18optionalIdEEE6AppendES4_: 123| 2.16M| void Append(std::optional val) { 124| 2.16M| if (val) { ------------------ | Branch (124:9): [True: 43, False: 2.16M] ------------------ 125| 43| Append(*val); 126| 2.16M| } else { 127| 2.16M| AppendNull(); 128| 2.16M| } 129| 2.16M| } _ZN8perfetto15trace_processor13ColumnStorageINSt3__18optionalIdEEE6AppendEd: 119| 43| void Append(T val) { 120| 43| data_.emplace_back(val); 121| 43| valid_.AppendTrue(); 122| 43| } _ZN8perfetto15trace_processor13ColumnStorageINSt3__18optionalIdEEE10AppendNullEv: 201| 2.16M| void AppendNull() { 202| 2.16M| if (mode_ == Mode::kDense) { ------------------ | Branch (202:9): [True: 0, False: 2.16M] ------------------ 203| 0| data_.emplace_back(); 204| 0| } 205| 2.16M| valid_.AppendFalse(); 206| 2.16M| } _ZN8perfetto15trace_processor13ColumnStorageIlE3SetEjl: 71| 1.46M| void Set(uint32_t idx, T val) { vector_[idx] = val; } _ZN8perfetto15trace_processor13ColumnStorageIlE6CreateILb0EEES2_v: 81| 38.6k| static ColumnStorage Create() { 82| 38.6k| static_assert(!IsDense, "Invalid for non-null storage to be dense."); 83| 38.6k| return ColumnStorage(); 84| 38.6k| } _ZNK8perfetto15trace_processor13ColumnStorageIlE6vectorEv: 73| 38.6k| const std::vector& vector() const { return vector_; } _ZN8perfetto15trace_processor13ColumnStorageIlE6AppendEl: 64| 4.77M| void Append(T val) { vector_.emplace_back(val); } _ZN8perfetto15trace_processor13ColumnStorageIiE6CreateILb0EEES2_v: 81| 6.94k| static ColumnStorage Create() { 82| 6.94k| static_assert(!IsDense, "Invalid for non-null storage to be dense."); 83| 6.94k| return ColumnStorage(); 84| 6.94k| } _ZN8perfetto15trace_processor13ColumnStorageINSt3__18optionalIiEEE6CreateILb0EEES5_v: 178| 1.30k| static ColumnStorage> Create() { 179| 1.30k| return IsDense ? ColumnStorage>(Mode::kDense) ------------------ | Branch (179:12): [Folded - Ignored] ------------------ 180| 1.30k| : ColumnStorage>(Mode::kSparse); 181| 1.30k| } _ZNK8perfetto15trace_processor13ColumnStorageIiE6vectorEv: 73| 6.94k| const std::vector& vector() const { return vector_; } _ZNKR8perfetto15trace_processor13ColumnStorageINSt3__18optionalIiEEE15non_null_vectorEv: 167| 1.30k| const std::vector& non_null_vector() const& { return data_; } _ZNK8perfetto15trace_processor13ColumnStorageINSt3__18optionalIiEEE2bvEv: 171| 1.30k| const BitVector* bv() const final { return &non_null_bit_vector(); } _ZNK8perfetto15trace_processor13ColumnStorageINSt3__18optionalIiEEE19non_null_bit_vectorEv: 168| 1.30k| const BitVector& non_null_bit_vector() const { return valid_; } _ZN8perfetto15trace_processor13ColumnStorageIdE6CreateILb0EEES2_v: 81| 434| static ColumnStorage Create() { 82| 434| static_assert(!IsDense, "Invalid for non-null storage to be dense."); 83| 434| return ColumnStorage(); 84| 434| } _ZNK8perfetto15trace_processor13ColumnStorageIdE6vectorEv: 73| 434| const std::vector& vector() const { return vector_; } _ZN8perfetto15trace_processor13ColumnStorageIdE6AppendEd: 64| 279k| void Append(T val) { vector_.emplace_back(val); } _ZN8perfetto15trace_processor13ColumnStorageINSt3__18optionalIjEEE6CreateILb1EEES5_v: 178| 868| static ColumnStorage> Create() { 179| 868| return IsDense ? ColumnStorage>(Mode::kDense) ------------------ | Branch (179:12): [Folded - Ignored] ------------------ 180| 868| : ColumnStorage>(Mode::kSparse); 181| 868| } _ZN8perfetto15trace_processor13ColumnStorageINS0_10StringPool2IdEEC2Ev: 55| 44.2k| ColumnStorage() = default; _ZN8perfetto15trace_processor17ColumnStorageBaseC2Ev: 36| 184k| ColumnStorageBase() = default; _ZN8perfetto15trace_processor13ColumnStorageINSt3__18optionalIlEEEC2ENS5_4ModeE: 199| 10.4k| explicit ColumnStorage(Mode mode) : mode_(mode) {} _ZN8perfetto15trace_processor13ColumnStorageIlEC2Ev: 55| 38.6k| ColumnStorage() = default; _ZN8perfetto15trace_processor13ColumnStorageIjEC2Ev: 55| 39.9k| ColumnStorage() = default; _ZN8perfetto15trace_processor13ColumnStorageINSt3__18optionalIjEEEC2ENS5_4ModeE: 199| 39.0k| explicit ColumnStorage(Mode mode) : mode_(mode) {} _ZN8perfetto15trace_processor13ColumnStorageIiEC2Ev: 55| 6.94k| ColumnStorage() = default; _ZN8perfetto15trace_processor13ColumnStorageINSt3__18optionalIdEEEC2ENS5_4ModeE: 199| 3.03k| explicit ColumnStorage(Mode mode) : mode_(mode) {} _ZN8perfetto15trace_processor13ColumnStorageIdEC2Ev: 55| 434| ColumnStorage() = default; _ZN8perfetto15trace_processor13ColumnStorageINSt3__18optionalIiEEEC2ENS5_4ModeE: 199| 1.30k| explicit ColumnStorage(Mode mode) : mode_(mode) {} _ZN8perfetto15trace_processor20ColumnStorageOverlay8IteratorC2ENS0_6RowMap8IteratorE: 45| 71.8k| explicit Iterator(RowMap::Iterator it) : it_(std::move(it)) {} _ZN8perfetto15trace_processor20ColumnStorageOverlay8Iterator4NextEv: 51| 374k| void Next() { return it_.Next(); } _ZNK8perfetto15trace_processor20ColumnStorageOverlay8IteratorcvbEv: 54| 446k| explicit operator bool() const { return bool(it_); } _ZNK8perfetto15trace_processor20ColumnStorageOverlay8Iterator5indexEv: 57| 584k| OutputIndex index() const { return it_.index(); } _ZN8perfetto15trace_processor20ColumnStorageOverlayC2Ev: 68| 35.1k| ColumnStorageOverlay() : ColumnStorageOverlay(0) {} _ZN8perfetto15trace_processor20ColumnStorageOverlayC2Ej: 72| 35.1k| : ColumnStorageOverlay(0, size) {} _ZN8perfetto15trace_processor20ColumnStorageOverlayC2Ejj: 77| 35.1k| : ColumnStorageOverlay(RowMap(start, end)) {} _ZN8perfetto15trace_processor20ColumnStorageOverlayC2ENS0_9BitVectorE: 82| 434| : ColumnStorageOverlay(RowMap(std::move(bv))) {} _ZNK8perfetto15trace_processor20ColumnStorageOverlay3GetEj: 110| 604M| OutputIndex Get(uint32_t row) const { return row_map_.Get(row); } _ZNK8perfetto15trace_processor20ColumnStorageOverlay5RowOfEj: 113| 3.97M| std::optional RowOf(OutputIndex index) const { 114| 3.97M| return row_map_.RowOf(index); 115| 3.97M| } _ZN8perfetto15trace_processor20ColumnStorageOverlay6InsertEj: 122| 14.9M| void Insert(OutputIndex index) { return row_map_.Insert(index); } _ZNK8perfetto15trace_processor20ColumnStorageOverlay11IterateRowsEv: 137| 71.8k| Iterator IterateRows() const { return Iterator(row_map_.IterateRows()); } _ZNK8perfetto15trace_processor20ColumnStorageOverlay7row_mapEv: 139| 868| const RowMap& row_map() const { return row_map_; } _ZN8perfetto15trace_processor20ColumnStorageOverlayC2ENS0_6RowMapE: 142| 35.5k| explicit ColumnStorageOverlay(RowMap rm) : row_map_(std::move(rm)) {} _ZN8perfetto15trace_processor20ColumnStorageOverlay8IteratorC2EOS2_: 47| 71.8k| Iterator(Iterator&&) noexcept = default; _ZN8perfetto15trace_processor20ColumnStorageOverlayC2EOS1_: 91| 434| ColumnStorageOverlay(ColumnStorageOverlay&&) noexcept = default; _ZN8perfetto15trace_processor20ColumnStorageOverlayaSEOS1_: 92| 434| ColumnStorageOverlay& operator=(ColumnStorageOverlay&&) = default; _ZN8perfetto15trace_processor5TableC2EPNS0_10StringPoolEjNSt3__16vectorINS0_12ColumnLegacyENS4_9allocatorIS6_EEEENS5_INS0_20ColumnStorageOverlayENS7_ISA_EEEE: 99| 34.7k| : string_pool_(pool), 100| 34.7k| row_count_(row_count), 101| 34.7k| overlays_(std::move(overlays)), 102| 34.7k| columns_(std::move(columns)) { 103| 34.7k| PERFETTO_DCHECK(string_pool_); 104| 34.7k|} _ZN8perfetto15trace_processor5TableD2Ev: 106| 34.7k|Table::~Table() = default; _ZN8perfetto15trace_processor5Table23OnConstructionCompletedENSt3__16vectorINS0_6RefPtrINS0_6column12StorageLayerEEENS2_9allocatorIS7_EEEENS3_INS4_INS5_12OverlayLayerEEENS8_ISC_EEEESE_: 251| 34.7k| std::vector> overlay_layers) { 252| 224k| for (ColumnLegacy& col : columns_) { ------------------ | Branch (252:26): [True: 224k, False: 34.7k] ------------------ 253| 224k| col.BindToTable(this, string_pool_); 254| 224k| } 255| 34.7k| PERFETTO_CHECK(storage_layers.size() == columns_.size()); 256| 34.7k| PERFETTO_CHECK(null_layers.size() == columns_.size()); 257| 34.7k| PERFETTO_CHECK(overlay_layers.size() == overlays_.size()); 258| 34.7k| storage_layers_ = std::move(storage_layers); 259| 34.7k| null_layers_ = std::move(null_layers); 260| 34.7k| overlay_layers_ = std::move(overlay_layers); 261| 34.7k|} _ZN8perfetto15trace_processor5Table8IteratorC2EPKS1_: 62| 71.8k| explicit Iterator(const Table* table) : table_(table) { 63| 71.8k| its_.reserve(table->overlays().size()); 64| 71.8k| for (const auto& rm : table->overlays()) { ------------------ | Branch (64:27): [True: 71.8k, False: 71.8k] ------------------ 65| 71.8k| its_.emplace_back(rm.IterateRows()); 66| 71.8k| } 67| 71.8k| } _ZN8perfetto15trace_processor5Table8IteratorppEv: 88| 374k| Iterator& operator++() { 89| 374k| for (auto& it : its_) { ------------------ | Branch (89:21): [True: 374k, False: 374k] ------------------ 90| 374k| it.Next(); 91| 374k| } 92| 374k| return *this; 93| 374k| } _ZNK8perfetto15trace_processor5Table8IteratorcvbEv: 96| 446k| explicit operator bool() const { return bool(its_[0]); } _ZNK8perfetto15trace_processor5Table8Iterator21StorageIndexForColumnEj: 105| 514k| uint32_t StorageIndexForColumn(uint32_t col_idx) const { 106| 514k| const auto& col = table_->columns_[col_idx]; 107| 514k| return its_[col.overlay_index()].index(); 108| 514k| } _ZNK8perfetto15trace_processor5Table8Iterator26StorageIndexForLastOverlayEv: 111| 69.9k| uint32_t StorageIndexForLastOverlay() const { return its_.back().index(); } _ZNK8perfetto15trace_processor5Table11IterateRowsEv: 187| 71.8k| Iterator IterateRows() const { return Iterator(this); } _ZNK8perfetto15trace_processor5Table9row_countEv: 203| 17.7M| uint32_t row_count() const { return row_count_; } _ZNK8perfetto15trace_processor5Table7columnsEv: 204| 603M| const std::vector& columns() const { return columns_; } _ZNK8perfetto15trace_processor5Table11string_poolEv: 205| 44.2k| StringPool* string_pool() const { return string_pool_; } _ZNK8perfetto15trace_processor5Table14storage_layersEv: 207| 6.51k| const std::vector>& storage_layers() const { 208| 6.51k| return storage_layers_; 209| 6.51k| } _ZNK8perfetto15trace_processor5Table11null_layersEv: 210| 2.60k| const std::vector>& null_layers() const { 211| 2.60k| return null_layers_; 212| 2.60k| } _ZN8perfetto15trace_processor5Table36IncrementRowCountAndAddToLastOverlayEv: 231| 14.9M| void IncrementRowCountAndAddToLastOverlay() { 232| | // Also add the index of the new row to the identity row map and increment 233| | // the size. 234| 14.9M| overlays_.back().Insert(row_count_++); 235| 14.9M| } _ZN8perfetto15trace_processor5Table9GetColumnEj: 242| 105M| ColumnLegacy* GetColumn(uint32_t index) { return &columns_[index]; } _ZNK8perfetto15trace_processor5Table8overlaysEv: 244| 145k| const std::vector& overlays() const { 245| 145k| return overlays_; 246| 145k| } _ZN8perfetto15trace_processor5Table8IteratorC2EOS2_: 81| 287k| Iterator(Iterator&&) noexcept = default; _ZNK8perfetto15trace_processor11TypedColumnIjEixEj: 86| 182M| T operator[](uint32_t row) const { return GetAtIdx(overlay().Get(row)); } _ZN8perfetto15trace_processor11TypedColumnIjE3SetEjj: 97| 2.14M| void Set(uint32_t row, non_optional_type v) { 98| 2.14M| auto serialized = Serializer::Serialize(v); 99| 2.14M| mutable_storage()->Set(overlay().Get(row), serialized); 100| 2.14M| } _ZN8perfetto15trace_processor11TypedColumnIjE15mutable_storageEv: 165| 18.5M| ColumnStorage* mutable_storage() { 166| 18.5M| return ColumnLegacy::mutable_storage(); 167| 18.5M| } _ZNK8perfetto15trace_processor11TypedColumnIjE8GetAtIdxEj: 155| 182M| T GetAtIdx(uint32_t idx) const { 156| 182M| return Serializer::Deserialize(TH::Get(storage(), idx)); 157| 182M| } _ZNK8perfetto15trace_processor11TypedColumnIjE7storageEv: 162| 182M| const ColumnStorage& storage() const { 163| 182M| return ColumnLegacy::storage(); 164| 182M| } _ZN8perfetto15trace_processor11TypedColumnIjE6AppendEj: 103| 16.4M| void Append(T v) { mutable_storage()->Append(Serializer::Serialize(v)); } _ZNK8perfetto15trace_processor11TypedColumnINSt3__18optionalINS0_10StringPool2IdEEEEixEj: 86| 15.6M| T operator[](uint32_t row) const { return GetAtIdx(overlay().Get(row)); } _ZNK8perfetto15trace_processor11TypedColumnINSt3__18optionalIlEEEixEj: 86| 181M| T operator[](uint32_t row) const { return GetAtIdx(overlay().Get(row)); } _ZNK8perfetto15trace_processor11TypedColumnINSt3__18optionalIjEEEixEj: 86| 183M| T operator[](uint32_t row) const { return GetAtIdx(overlay().Get(row)); } _ZN8perfetto15trace_processor11TypedColumnINSt3__18optionalINS0_10StringPool2IdEEEE3SetEjS5_: 97| 88.9k| void Set(uint32_t row, non_optional_type v) { 98| 88.9k| auto serialized = Serializer::Serialize(v); 99| 88.9k| mutable_storage()->Set(overlay().Get(row), serialized); 100| 88.9k| } _ZN8perfetto15trace_processor11TypedColumnINSt3__18optionalINS0_10StringPool2IdEEEE15mutable_storageEv: 165| 5.92M| ColumnStorage* mutable_storage() { 166| 5.92M| return ColumnLegacy::mutable_storage(); 167| 5.92M| } _ZN8perfetto15trace_processor11TypedColumnINSt3__18optionalIlEEE3SetEjl: 97| 140k| void Set(uint32_t row, non_optional_type v) { 98| 140k| auto serialized = Serializer::Serialize(v); 99| 140k| mutable_storage()->Set(overlay().Get(row), serialized); 100| 140k| } _ZN8perfetto15trace_processor11TypedColumnINSt3__18optionalIlEEE15mutable_storageEv: 165| 8.22M| ColumnStorage* mutable_storage() { 166| 8.22M| return ColumnLegacy::mutable_storage(); 167| 8.22M| } _ZN8perfetto15trace_processor11TypedColumnINSt3__18optionalIjEEE3SetEjj: 97| 2.43M| void Set(uint32_t row, non_optional_type v) { 98| 2.43M| auto serialized = Serializer::Serialize(v); 99| 2.43M| mutable_storage()->Set(overlay().Get(row), serialized); 100| 2.43M| } _ZN8perfetto15trace_processor11TypedColumnINSt3__18optionalIjEEE15mutable_storageEv: 165| 33.7M| ColumnStorage* mutable_storage() { 166| 33.7M| return ColumnLegacy::mutable_storage(); 167| 33.7M| } _ZN8perfetto15trace_processor11TypedColumnINSt3__18optionalINS0_6tables12MachineTable2IdEEEE15mutable_storageEv: 165| 9.88M| ColumnStorage* mutable_storage() { 166| 9.88M| return ColumnLegacy::mutable_storage(); 167| 9.88M| } _ZNK8perfetto15trace_processor11TypedColumnINSt3__18optionalINS0_10StringPool2IdEEEE8GetAtIdxEj: 155| 15.6M| T GetAtIdx(uint32_t idx) const { 156| 15.6M| return Serializer::Deserialize(TH::Get(storage(), idx)); 157| 15.6M| } _ZNK8perfetto15trace_processor11TypedColumnINSt3__18optionalINS0_10StringPool2IdEEEE7storageEv: 162| 15.6M| const ColumnStorage& storage() const { 163| 15.6M| return ColumnLegacy::storage(); 164| 15.6M| } _ZNK8perfetto15trace_processor11TypedColumnINSt3__18optionalIlEEE8GetAtIdxEj: 155| 181M| T GetAtIdx(uint32_t idx) const { 156| 181M| return Serializer::Deserialize(TH::Get(storage(), idx)); 157| 181M| } _ZNK8perfetto15trace_processor11TypedColumnINSt3__18optionalIlEEE7storageEv: 162| 181M| const ColumnStorage& storage() const { 163| 181M| return ColumnLegacy::storage(); 164| 181M| } _ZNK8perfetto15trace_processor11TypedColumnINSt3__18optionalIjEEE8GetAtIdxEj: 155| 183M| T GetAtIdx(uint32_t idx) const { 156| 183M| return Serializer::Deserialize(TH::Get(storage(), idx)); 157| 183M| } _ZNK8perfetto15trace_processor11TypedColumnINSt3__18optionalIjEEE7storageEv: 162| 183M| const ColumnStorage& storage() const { 163| 183M| return ColumnLegacy::storage(); 164| 183M| } _ZN8perfetto15trace_processor11TypedColumnINSt3__18optionalINS0_10StringPool2IdEEEE6AppendES6_: 103| 5.83M| void Append(T v) { mutable_storage()->Append(Serializer::Serialize(v)); } _ZN8perfetto15trace_processor11TypedColumnINSt3__18optionalIlEEE6AppendES4_: 103| 8.08M| void Append(T v) { mutable_storage()->Append(Serializer::Serialize(v)); } _ZN8perfetto15trace_processor11TypedColumnINSt3__18optionalIjEEE6AppendES4_: 103| 31.3M| void Append(T v) { mutable_storage()->Append(Serializer::Serialize(v)); } _ZN8perfetto15trace_processor11TypedColumnINSt3__18optionalINS0_6tables12MachineTable2IdEEEE6AppendES7_: 103| 9.88M| void Append(T v) { mutable_storage()->Append(Serializer::Serialize(v)); } _ZNK8perfetto15trace_processor11TypedColumnINS0_10StringPool2IdEEixEj: 86| 2.27k| T operator[](uint32_t row) const { return GetAtIdx(overlay().Get(row)); } _ZN8perfetto15trace_processor11TypedColumnINS0_10StringPool2IdEE3SetEjS3_: 97| 48.1k| void Set(uint32_t row, non_optional_type v) { 98| 48.1k| auto serialized = Serializer::Serialize(v); 99| 48.1k| mutable_storage()->Set(overlay().Get(row), serialized); 100| 48.1k| } _ZN8perfetto15trace_processor11TypedColumnINS0_10StringPool2IdEE15mutable_storageEv: 165| 17.2M| ColumnStorage* mutable_storage() { 166| 17.2M| return ColumnLegacy::mutable_storage(); 167| 17.2M| } _ZN8perfetto15trace_processor11TypedColumnINSt3__18optionalIdEEE15mutable_storageEv: 165| 2.16M| ColumnStorage* mutable_storage() { 166| 2.16M| return ColumnLegacy::mutable_storage(); 167| 2.16M| } _ZNK8perfetto15trace_processor11TypedColumnINS0_10StringPool2IdEE8GetAtIdxEj: 155| 447k| T GetAtIdx(uint32_t idx) const { 156| 447k| return Serializer::Deserialize(TH::Get(storage(), idx)); 157| 447k| } _ZNK8perfetto15trace_processor11TypedColumnINS0_10StringPool2IdEE7storageEv: 162| 447k| const ColumnStorage& storage() const { 163| 447k| return ColumnLegacy::storage(); 164| 447k| } _ZN8perfetto15trace_processor11TypedColumnINS0_10StringPool2IdEE6AppendES3_: 103| 17.2M| void Append(T v) { mutable_storage()->Append(Serializer::Serialize(v)); } _ZN8perfetto15trace_processor11TypedColumnINSt3__18optionalIdEEE6AppendES4_: 103| 2.16M| void Append(T v) { mutable_storage()->Append(Serializer::Serialize(v)); } _ZNK8perfetto15trace_processor11TypedColumnIlEixEj: 86| 32.9M| T operator[](uint32_t row) const { return GetAtIdx(overlay().Get(row)); } _ZN8perfetto15trace_processor11TypedColumnIlE3SetEjl: 97| 1.46M| void Set(uint32_t row, non_optional_type v) { 98| 1.46M| auto serialized = Serializer::Serialize(v); 99| 1.46M| mutable_storage()->Set(overlay().Get(row), serialized); 100| 1.46M| } _ZN8perfetto15trace_processor11TypedColumnIlE15mutable_storageEv: 165| 6.23M| ColumnStorage* mutable_storage() { 166| 6.23M| return ColumnLegacy::mutable_storage(); 167| 6.23M| } _ZNK8perfetto15trace_processor11TypedColumnIlE8GetAtIdxEj: 155| 32.9M| T GetAtIdx(uint32_t idx) const { 156| 32.9M| return Serializer::Deserialize(TH::Get(storage(), idx)); 157| 32.9M| } _ZNK8perfetto15trace_processor11TypedColumnIlE7storageEv: 162| 32.9M| const ColumnStorage& storage() const { 163| 32.9M| return ColumnLegacy::storage(); 164| 32.9M| } _ZNK8perfetto15trace_processor8IdColumnINS0_6tables14ChromeRawTable2IdEE7IndexOfES4_: 182| 1.44M| std::optional IndexOf(Id id) const { 183| 1.44M| return overlay().RowOf(id.value); 184| 1.44M| } _ZN8perfetto15trace_processor11TypedColumnIlE6AppendEl: 103| 4.77M| void Append(T v) { mutable_storage()->Append(Serializer::Serialize(v)); } _ZNK8perfetto15trace_processor8IdColumnINS0_6tables13MetadataTable2IdEE8GetAtIdxEj: 187| 69.9k| Id GetAtIdx(uint32_t idx) const { return Id(idx); } _ZN8perfetto15trace_processor11TypedColumnINSt3__18optionalINS0_6tables14TraceFileTable2IdEEEE15mutable_storageEv: 165| 434| ColumnStorage* mutable_storage() { 166| 434| return ColumnLegacy::mutable_storage(); 167| 434| } _ZNK8perfetto15trace_processor8IdColumnINS0_6tables14TraceFileTable2IdEE7IndexOfES4_: 182| 771| std::optional IndexOf(Id id) const { 183| 771| return overlay().RowOf(id.value); 184| 771| } _ZN8perfetto15trace_processor11TypedColumnINSt3__18optionalINS0_6tables14TraceFileTable2IdEEEE6AppendES7_: 103| 434| void Append(T v) { mutable_storage()->Append(Serializer::Serialize(v)); } _ZN8perfetto15trace_processor11TypedColumnINSt3__18optionalINS0_6tables10TrackTable2IdEEEE3SetEjS6_: 97| 23| void Set(uint32_t row, non_optional_type v) { 98| 23| auto serialized = Serializer::Serialize(v); 99| 23| mutable_storage()->Set(overlay().Get(row), serialized); 100| 23| } _ZN8perfetto15trace_processor11TypedColumnINSt3__18optionalINS0_6tables10TrackTable2IdEEEE15mutable_storageEv: 165| 268k| ColumnStorage* mutable_storage() { 166| 268k| return ColumnLegacy::mutable_storage(); 167| 268k| } _ZNK8perfetto15trace_processor8IdColumnINS0_6tables10TrackTable2IdEE7IndexOfES4_: 182| 241k| std::optional IndexOf(Id id) const { 183| 241k| return overlay().RowOf(id.value); 184| 241k| } _ZN8perfetto15trace_processor11TypedColumnINSt3__18optionalINS0_6tables10TrackTable2IdEEEE6AppendES7_: 103| 267k| void Append(T v) { mutable_storage()->Append(Serializer::Serialize(v)); } _ZN8perfetto15trace_processor11TypedColumnINS0_6tables10TrackTable2IdEE15mutable_storageEv: 165| 1.02M| ColumnStorage* mutable_storage() { 166| 1.02M| return ColumnLegacy::mutable_storage(); 167| 1.02M| } _ZN8perfetto15trace_processor11TypedColumnIdE15mutable_storageEv: 165| 279k| ColumnStorage* mutable_storage() { 166| 279k| return ColumnLegacy::mutable_storage(); 167| 279k| } _ZNK8perfetto15trace_processor8IdColumnINS0_6tables12CounterTable2IdEE7IndexOfES4_: 182| 279k| std::optional IndexOf(Id id) const { 183| 279k| return overlay().RowOf(id.value); 184| 279k| } _ZN8perfetto15trace_processor11TypedColumnINS0_6tables10TrackTable2IdEE6AppendES4_: 103| 1.02M| void Append(T v) { mutable_storage()->Append(Serializer::Serialize(v)); } _ZN8perfetto15trace_processor11TypedColumnIdE6AppendEd: 103| 279k| void Append(T v) { mutable_storage()->Append(Serializer::Serialize(v)); } _ZNK8perfetto15trace_processor8IdColumnINS0_6tables10SliceTable2IdEEixEj: 180| 1.47M| Id operator[](uint32_t row) const { return Id(overlay().Get(row)); } _ZN8perfetto15trace_processor11TypedColumnINSt3__18optionalINS0_6tables10SliceTable2IdEEEE3SetEjS6_: 97| 154k| void Set(uint32_t row, non_optional_type v) { 98| 154k| auto serialized = Serializer::Serialize(v); 99| 154k| mutable_storage()->Set(overlay().Get(row), serialized); 100| 154k| } _ZN8perfetto15trace_processor11TypedColumnINSt3__18optionalINS0_6tables10SliceTable2IdEEEE15mutable_storageEv: 165| 902k| ColumnStorage* mutable_storage() { 166| 902k| return ColumnLegacy::mutable_storage(); 167| 902k| } _ZNK8perfetto15trace_processor8IdColumnINS0_6tables10SliceTable2IdEE7IndexOfES4_: 182| 1.99M| std::optional IndexOf(Id id) const { 183| 1.99M| return overlay().RowOf(id.value); 184| 1.99M| } _ZN8perfetto15trace_processor11TypedColumnINSt3__18optionalINS0_6tables10SliceTable2IdEEEE6AppendES7_: 103| 748k| void Append(T v) { mutable_storage()->Append(Serializer::Serialize(v)); } _ZN8perfetto15trace_processor11TypedColumnINS0_6tables10SliceTable2IdEE15mutable_storageEv: 165| 2.80k| ColumnStorage* mutable_storage() { 166| 2.80k| return ColumnLegacy::mutable_storage(); 167| 2.80k| } _ZNK8perfetto15trace_processor8IdColumnINS0_6tables9FlowTable2IdEE7IndexOfES4_: 182| 1.39k| std::optional IndexOf(Id id) const { 183| 1.39k| return overlay().RowOf(id.value); 184| 1.39k| } _ZN8perfetto15trace_processor11TypedColumnINS0_6tables10SliceTable2IdEE6AppendES4_: 103| 2.80k| void Append(T v) { mutable_storage()->Append(Serializer::Serialize(v)); } _ZN8perfetto15trace_processor11TypedColumnINS0_6tables19MemorySnapshotTable2IdEE15mutable_storageEv: 165| 43.2k| ColumnStorage* mutable_storage() { 166| 43.2k| return ColumnLegacy::mutable_storage(); 167| 43.2k| } _ZN8perfetto15trace_processor11TypedColumnINS0_6tables19MemorySnapshotTable2IdEE6AppendES4_: 103| 43.2k| void Append(T v) { mutable_storage()->Append(Serializer::Serialize(v)); } _ZN8perfetto15trace_processor11TypedColumnINS0_6tables26ProcessMemorySnapshotTable2IdEE15mutable_storageEv: 165| 3.77k| ColumnStorage* mutable_storage() { 166| 3.77k| return ColumnLegacy::mutable_storage(); 167| 3.77k| } _ZN8perfetto15trace_processor11TypedColumnINSt3__18optionalINS0_6tables23MemorySnapshotNodeTable2IdEEEE15mutable_storageEv: 165| 3.77k| ColumnStorage* mutable_storage() { 166| 3.77k| return ColumnLegacy::mutable_storage(); 167| 3.77k| } _ZNK8perfetto15trace_processor8IdColumnINS0_6tables23MemorySnapshotNodeTable2IdEE7IndexOfES4_: 182| 7.54k| std::optional IndexOf(Id id) const { 183| 7.54k| return overlay().RowOf(id.value); 184| 7.54k| } _ZN8perfetto15trace_processor11TypedColumnINS0_6tables26ProcessMemorySnapshotTable2IdEE6AppendES4_: 103| 3.77k| void Append(T v) { mutable_storage()->Append(Serializer::Serialize(v)); } _ZN8perfetto15trace_processor11TypedColumnINSt3__18optionalINS0_6tables23MemorySnapshotNodeTable2IdEEEE6AppendES7_: 103| 3.77k| void Append(T v) { mutable_storage()->Append(Serializer::Serialize(v)); } _ZN8perfetto15trace_processor11TypedColumnINS0_6tables23MemorySnapshotNodeTable2IdEE15mutable_storageEv: 165| 728| ColumnStorage* mutable_storage() { 166| 728| return ColumnLegacy::mutable_storage(); 167| 728| } _ZN8perfetto15trace_processor11TypedColumnINS0_6tables23MemorySnapshotNodeTable2IdEE6AppendES4_: 103| 728| void Append(T v) { mutable_storage()->Append(Serializer::Serialize(v)); } _ZN8perfetto15trace_processor11TypedColumnINSt3__18optionalIjEEE10FromColumnEPNS0_12ColumnLegacyE: 138| 1.09M| static TypedColumn* FromColumn(ColumnLegacy* column) { 139| | // While casting from a base to derived without constructing as a derived is 140| | // technically UB, in practice, this is at the heart of protozero (see 141| | // Message::BeginNestedMessage) so we use it here. 142| 1.09M| static_assert(sizeof(TypedColumn) == sizeof(ColumnLegacy), 143| 1.09M| "TypedColumn cannot introduce extra state."); 144| | 145| 1.09M| if (column->template IsColumnType() && ------------------ | Branch (145:9): [True: 1.09M, False: 0] ------------------ 146| 1.09M| (column->IsNullable() == TH::is_optional) && !column->IsId()) { ------------------ | Branch (146:9): [True: 1.09M, False: 0] | Branch (146:54): [True: 1.09M, False: 0] ------------------ 147| 1.09M| return static_cast*>(column); 148| 1.09M| } else { 149| 0| PERFETTO_FATAL("Unsafe to convert Column TypedColumn (%s)", 150| 0| column->name()); 151| 0| } 152| 1.09M| } _ZN8perfetto15trace_processor11TypedColumnIjE10FromColumnEPNS0_12ColumnLegacyE: 138| 1.40M| static TypedColumn* FromColumn(ColumnLegacy* column) { 139| | // While casting from a base to derived without constructing as a derived is 140| | // technically UB, in practice, this is at the heart of protozero (see 141| | // Message::BeginNestedMessage) so we use it here. 142| 1.40M| static_assert(sizeof(TypedColumn) == sizeof(ColumnLegacy), 143| 1.40M| "TypedColumn cannot introduce extra state."); 144| | 145| 1.40M| if (column->template IsColumnType() && ------------------ | Branch (145:9): [True: 1.40M, False: 0] ------------------ 146| 1.40M| (column->IsNullable() == TH::is_optional) && !column->IsId()) { ------------------ | Branch (146:9): [True: 1.40M, False: 0] | Branch (146:54): [True: 1.40M, False: 0] ------------------ 147| 1.40M| return static_cast*>(column); 148| 1.40M| } else { 149| 0| PERFETTO_FATAL("Unsafe to convert Column TypedColumn (%s)", 150| 0| column->name()); 151| 0| } 152| 1.40M| } _ZN8perfetto15trace_processor11tc_internal10SerializerINS0_10StringPool2IdEvE9SerializeES4_: 69| 19.4M| static serialized_type Serialize(StringPool::Id value) { return value; } _ZN8perfetto15trace_processor11tc_internal10SerializerINS0_10StringPool2IdEvE11DeserializeES4_: 70| 447k| static StringPool::Id Deserialize(serialized_type value) { return value; } _ZN8perfetto15trace_processor11tc_internal10SerializerINS0_10StringPool2IdEvE9SerializeENSt3__18optionalIS4_EE: 72| 5.83M| static serialized_type Serialize(std::optional value) { 73| | // Since StringPool::Id == 0 is always treated as null, rewrite 74| | // std::nullopt -> 0 to remove an extra check at filter time for 75| | // std::nullopt. Instead, that code can assume that the ColumnStorage 76| | // layer always returns a valid id and can handle the nullability at the 77| | // stringpool level. 78| | // TODO(lalitm): remove this special casing if we migrate all tables over 79| | // to macro tables and find that we can remove support for null stringids 80| | // in the stringpool. 81| 5.83M| return value ? Serialize(*value) : StringPool::Id::Null(); ------------------ | Branch (81:12): [True: 2.10M, False: 3.73M] ------------------ 82| 5.83M| } _ZN8perfetto15trace_processor11tc_internal10SerializerINS0_10StringPool2IdEvE11DeserializeENSt3__18optionalIS4_EE: 84| 15.6M| std::optional value) { 85| 15.6M| return value; 86| 15.6M| } _ZN8perfetto15trace_processor11tc_internal11TypeHandlerINS0_10StringPool2IdEE3GetERKNS0_13ColumnStorageIS4_EEj: 152| 447k| uint32_t idx) { 153| 447k| return nv.Get(idx); 154| 447k| } _ZN8perfetto15trace_processor11tc_internal11TypeHandlerINSt3__18optionalINS0_10StringPool2IdEEEE3GetERKNS0_13ColumnStorageIS6_EEj: 174| 15.6M| uint32_t idx) { 175| 15.6M| StringPool::Id id = nv.Get(idx); 176| 15.6M| return id.is_null() ? std::nullopt : std::make_optional(id); ------------------ | Branch (176:12): [True: 15.3M, False: 289k] ------------------ 177| 15.6M| } _ZN8perfetto15trace_processor11tc_internal10SerializerIjvE9SerializeEj: 34| 21.0M| static serialized_type Serialize(T value) { return value; } _ZN8perfetto15trace_processor11tc_internal11TypeHandlerIjE3GetERKNS0_13ColumnStorageIjEEj: 102| 182M| static stored_type Get(const ColumnStorage& nv, uint32_t idx) { 103| 182M| return nv.Get(idx); 104| 182M| } _ZN8perfetto15trace_processor11tc_internal10SerializerIjvE11DeserializeEj: 35| 182M| static T Deserialize(serialized_type value) { return value; } _ZN8perfetto15trace_processor11tc_internal10SerializerIlvE9SerializeEl: 34| 6.37M| static serialized_type Serialize(T value) { return value; } _ZN8perfetto15trace_processor11tc_internal10SerializerINS0_6tables12MachineTable2IdEvE9SerializeES5_: 53| 6.56M| static serialized_type Serialize(T value) { return value.value; } _ZN8perfetto15trace_processor11tc_internal11TypeHandlerINSt3__18optionalIlEEE3GetERKNS0_13ColumnStorageIS5_EEj: 126| 181M| static stored_type Get(const ColumnStorage& nv, uint32_t idx) { 127| 181M| return nv.Get(idx); 128| 181M| } _ZN8perfetto15trace_processor11tc_internal10SerializerIlvE11DeserializeENSt3__18optionalIlEE: 40| 181M| static std::optional Deserialize(std::optional value) { 41| 181M| return value; 42| 181M| } _ZN8perfetto15trace_processor11tc_internal11TypeHandlerINSt3__18optionalIjEEE3GetERKNS0_13ColumnStorageIS5_EEj: 126| 183M| static stored_type Get(const ColumnStorage& nv, uint32_t idx) { 127| 183M| return nv.Get(idx); 128| 183M| } _ZN8perfetto15trace_processor11tc_internal10SerializerIjvE11DeserializeENSt3__18optionalIjEE: 40| 183M| static std::optional Deserialize(std::optional value) { 41| 183M| return value; 42| 183M| } _ZN8perfetto15trace_processor11tc_internal10SerializerIlvE9SerializeENSt3__18optionalIlEE: 37| 8.08M| static std::optional Serialize(std::optional value) { 38| 8.08M| return value; 39| 8.08M| } _ZN8perfetto15trace_processor11tc_internal10SerializerIjvE9SerializeENSt3__18optionalIjEE: 37| 31.3M| static std::optional Serialize(std::optional value) { 38| 31.3M| return value; 39| 31.3M| } _ZN8perfetto15trace_processor11tc_internal10SerializerINS0_6tables12MachineTable2IdEvE9SerializeENSt3__18optionalIS5_EE: 56| 9.88M| static std::optional Serialize(std::optional value) { 57| 9.88M| return value ? std::make_optional(Serialize(*value)) : std::nullopt; ------------------ | Branch (57:12): [True: 6.56M, False: 3.31M] ------------------ 58| 9.88M| } _ZN8perfetto15trace_processor11tc_internal10SerializerIdvE9SerializeEd: 34| 279k| static serialized_type Serialize(T value) { return value; } _ZN8perfetto15trace_processor11tc_internal10SerializerIdvE9SerializeENSt3__18optionalIdEE: 37| 2.16M| static std::optional Serialize(std::optional value) { 38| 2.16M| return value; 39| 2.16M| } _ZN8perfetto15trace_processor11tc_internal11TypeHandlerIlE3GetERKNS0_13ColumnStorageIlEEj: 102| 32.9M| static stored_type Get(const ColumnStorage& nv, uint32_t idx) { 103| 32.9M| return nv.Get(idx); 104| 32.9M| } _ZN8perfetto15trace_processor11tc_internal10SerializerIlvE11DeserializeEl: 35| 32.9M| static T Deserialize(serialized_type value) { return value; } _ZN8perfetto15trace_processor11tc_internal10SerializerINS0_6tables14TraceFileTable2IdEvE9SerializeENSt3__18optionalIS5_EE: 56| 434| static std::optional Serialize(std::optional value) { 57| 434| return value ? std::make_optional(Serialize(*value)) : std::nullopt; ------------------ | Branch (57:12): [True: 0, False: 434] ------------------ 58| 434| } _ZN8perfetto15trace_processor11tc_internal10SerializerINS0_6tables10TrackTable2IdEvE9SerializeES5_: 53| 1.02M| static serialized_type Serialize(T value) { return value.value; } _ZN8perfetto15trace_processor11tc_internal10SerializerINS0_6tables10TrackTable2IdEvE9SerializeENSt3__18optionalIS5_EE: 56| 267k| static std::optional Serialize(std::optional value) { 57| 267k| return value ? std::make_optional(Serialize(*value)) : std::nullopt; ------------------ | Branch (57:12): [True: 0, False: 267k] ------------------ 58| 267k| } _ZN8perfetto15trace_processor11tc_internal10SerializerINS0_6tables10SliceTable2IdEvE9SerializeES5_: 53| 157k| static serialized_type Serialize(T value) { return value.value; } _ZN8perfetto15trace_processor11tc_internal10SerializerINS0_6tables10SliceTable2IdEvE9SerializeENSt3__18optionalIS5_EE: 56| 748k| static std::optional Serialize(std::optional value) { 57| 748k| return value ? std::make_optional(Serialize(*value)) : std::nullopt; ------------------ | Branch (57:12): [True: 0, False: 748k] ------------------ 58| 748k| } _ZN8perfetto15trace_processor11tc_internal10SerializerINS0_6tables19MemorySnapshotTable2IdEvE9SerializeES5_: 53| 43.2k| static serialized_type Serialize(T value) { return value.value; } _ZN8perfetto15trace_processor11tc_internal10SerializerINS0_6tables26ProcessMemorySnapshotTable2IdEvE9SerializeES5_: 53| 3.77k| static serialized_type Serialize(T value) { return value.value; } _ZN8perfetto15trace_processor11tc_internal10SerializerINS0_6tables23MemorySnapshotNodeTable2IdEvE9SerializeES5_: 53| 1.29k| static serialized_type Serialize(T value) { return value.value; } _ZN8perfetto15trace_processor11tc_internal10SerializerINS0_6tables23MemorySnapshotNodeTable2IdEvE9SerializeENSt3__18optionalIS5_EE: 56| 3.77k| static std::optional Serialize(std::optional value) { 57| 3.77k| return value ? std::make_optional(Serialize(*value)) : std::nullopt; ------------------ | Branch (57:12): [True: 563, False: 3.21k] ------------------ 58| 3.77k| } _ZN8perfetto15trace_processor21ForwardingTraceParserC2EPNS0_21TraceProcessorContextENS0_6tables14TraceFileTable2IdE: 93| 434| : context_(context), file_id_(id) {} _ZN8perfetto15trace_processor21ForwardingTraceParserD2Ev: 95| 434|ForwardingTraceParser::~ForwardingTraceParser() = default; _ZN8perfetto15trace_processor21ForwardingTraceParser4InitERKNS0_13TraceBlobViewE: 97| 434|base::Status ForwardingTraceParser::Init(const TraceBlobView& blob) { 98| 434| PERFETTO_CHECK(!reader_); 99| | 100| 434| { 101| 434| auto scoped_trace = context_->storage->TraceExecutionTimeIntoStats( 102| 434| stats::guess_trace_type_duration_ns); 103| 434| trace_type_ = GuessTraceType(blob.data(), blob.size()); 104| 434| } 105| 434| if (trace_type_ == kUnknownTraceType) { ------------------ | Branch (105:7): [True: 8, False: 426] ------------------ 106| | // If renaming this error message don't remove the "(ERR:fmt)" part. 107| | // The UI's error_dialog.ts uses it to make the dialog more graceful. 108| 8| return base::ErrStatus("Unknown trace type provided (ERR:fmt)"); 109| 8| } 110| 426| context_->trace_file_tracker->StartParsing(file_id_, trace_type_); 111| 426| ASSIGN_OR_RETURN(reader_, ------------------ | | 38| 426| PERFETTO_INTERNAL_MACRO_CONCAT(auto status_or, __LINE__) = rhs; \ | | ------------------ | | | | 32| 426|#define PERFETTO_INTERNAL_MACRO_CONCAT(x, y) PERFETTO_INTERNAL_CONCAT_IMPL(x, y) | | | | ------------------ | | | | | | 31| 426|#define PERFETTO_INTERNAL_CONCAT_IMPL(x, y) x##y | | | | ------------------ | | ------------------ | | 39| 426| RETURN_IF_ERROR( \ | | ------------------ | | | | 25| 426| do { \ | | | | 26| 426| base::Status status_macro_internal_status = (expr); \ | | | | 27| 426| if (!status_macro_internal_status.ok()) \ | | | | ------------------ | | | | | Branch (27:9): [True: 2, False: 424] | | | | ------------------ | | | | 28| 426| return status_macro_internal_status; \ | | | | 29| 426| } while (0) | | | | ------------------ | | | | | Branch (29:12): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 40| 426| PERFETTO_INTERNAL_MACRO_CONCAT(status_or, __LINE__).status()); \ | | 41| 426| lhs = std::move(PERFETTO_INTERNAL_MACRO_CONCAT(status_or, __LINE__).value()) | | ------------------ | | | | 32| 424|#define PERFETTO_INTERNAL_MACRO_CONCAT(x, y) PERFETTO_INTERNAL_CONCAT_IMPL(x, y) | | | | ------------------ | | | | | | 31| 424|#define PERFETTO_INTERNAL_CONCAT_IMPL(x, y) x##y | | | | ------------------ | | ------------------ ------------------ 112| 424| context_->reader_registry->CreateTraceReader(trace_type_)); 113| | 114| 424| PERFETTO_DLOG("%s trace detected", TraceTypeToString(trace_type_)); 115| 424| UpdateSorterForTraceType(trace_type_); 116| | 117| | // TODO(b/334978369) Make sure kProtoTraceType and kSystraceTraceType are 118| | // parsed first so that we do not get issues with 119| | // SetPidZeroIsUpidZeroIdleProcess() 120| 424| if (trace_type_ == kProtoTraceType || trace_type_ == kSystraceTraceType) { ------------------ | Branch (120:7): [True: 424, False: 0] | Branch (120:41): [True: 0, False: 0] ------------------ 121| 424| context_->process_tracker->SetPidZeroIsUpidZeroIdleProcess(); 122| 424| } 123| 424| return base::OkStatus(); 124| 426|} _ZN8perfetto15trace_processor21ForwardingTraceParser24UpdateSorterForTraceTypeENS0_9TraceTypeE: 126| 424|void ForwardingTraceParser::UpdateSorterForTraceType(TraceType trace_type) { 127| 424| std::optional minimum_sorting_mode = 128| 424| GetMinimumSortingMode(trace_type, *context_); 129| 424| if (!minimum_sorting_mode.has_value()) { ------------------ | Branch (129:7): [True: 0, False: 424] ------------------ 130| 0| return; 131| 0| } 132| | 133| 424| if (!context_->sorter) { ------------------ | Branch (133:7): [True: 424, False: 0] ------------------ 134| 424| TraceSorter::EventHandling event_handling; 135| 424| switch (context_->config.parsing_mode) { ------------------ | Branch (135:13): [True: 0, False: 424] ------------------ 136| 424| case ParsingMode::kDefault: ------------------ | Branch (136:7): [True: 424, False: 0] ------------------ 137| 424| event_handling = TraceSorter::EventHandling::kSortAndPush; 138| 424| break; 139| 0| case ParsingMode::kTokenizeOnly: ------------------ | Branch (139:7): [True: 0, False: 424] ------------------ 140| 0| event_handling = TraceSorter::EventHandling::kDrop; 141| 0| break; 142| 0| case ParsingMode::kTokenizeAndSort: ------------------ | Branch (142:7): [True: 0, False: 424] ------------------ 143| 0| event_handling = TraceSorter::EventHandling::kSortAndDrop; 144| 0| break; 145| 424| } 146| 424| if (context_->config.enable_dev_features) { ------------------ | Branch (146:9): [True: 0, False: 424] ------------------ 147| 0| auto it = context_->config.dev_flags.find("drop-after-sort"); 148| 0| if (it != context_->config.dev_flags.end() && it->second == "true") { ------------------ | Branch (148:11): [True: 0, False: 0] | Branch (148:11): [True: 0, False: 0] | Branch (148:53): [True: 0, False: 0] ------------------ 149| 0| event_handling = TraceSorter::EventHandling::kSortAndDrop; 150| 0| } 151| 0| } 152| 424| context_->sorter = std::make_shared( 153| 424| context_, *minimum_sorting_mode, event_handling); 154| 424| } 155| | 156| 424| switch (context_->sorter->sorting_mode()) { ------------------ | Branch (156:11): [True: 0, False: 424] ------------------ 157| 424| case TraceSorter::SortingMode::kDefault: ------------------ | Branch (157:5): [True: 424, False: 0] ------------------ 158| 424| PERFETTO_CHECK(minimum_sorting_mode == 159| 424| TraceSorter::SortingMode::kDefault); 160| 424| break; 161| 424| case TraceSorter::SortingMode::kFullSort: ------------------ | Branch (161:5): [True: 0, False: 424] ------------------ 162| 0| break; 163| 424| } 164| 424|} _ZN8perfetto15trace_processor21ForwardingTraceParser5ParseENS0_13TraceBlobViewE: 166| 434|base::Status ForwardingTraceParser::Parse(TraceBlobView blob) { 167| | // If this is the first Parse() call, guess the trace type and create the 168| | // appropriate parser. 169| 434| if (!reader_) { ------------------ | Branch (169:7): [True: 434, False: 0] ------------------ 170| 434| RETURN_IF_ERROR(Init(blob)); ------------------ | | 25| 434| do { \ | | 26| 434| base::Status status_macro_internal_status = (expr); \ | | 27| 434| if (!status_macro_internal_status.ok()) \ | | ------------------ | | | Branch (27:9): [True: 10, False: 424] | | ------------------ | | 28| 434| return status_macro_internal_status; \ | | 29| 434| } while (0) | | ------------------ | | | Branch (29:12): [Folded - Ignored] | | ------------------ ------------------ 171| 434| } 172| 424| trace_size_ += blob.size(); 173| 424| return reader_->Parse(std::move(blob)); 174| 434|} _ZN8perfetto15trace_processor21ForwardingTraceParser15NotifyEndOfFileEv: 176| 345|base::Status ForwardingTraceParser::NotifyEndOfFile() { 177| 345| if (reader_) { ------------------ | Branch (177:7): [True: 345, False: 0] ------------------ 178| 345| RETURN_IF_ERROR(reader_->NotifyEndOfFile()); ------------------ | | 25| 345| do { \ | | 26| 345| base::Status status_macro_internal_status = (expr); \ | | 27| 345| if (!status_macro_internal_status.ok()) \ | | ------------------ | | | Branch (27:9): [True: 0, False: 345] | | ------------------ | | 28| 345| return status_macro_internal_status; \ | | 29| 345| } while (0) | | ------------------ | | | Branch (29:12): [Folded - Ignored] | | ------------------ ------------------ 179| 345| } 180| 345| if (trace_type_ != kUnknownTraceType) { ------------------ | Branch (180:7): [True: 345, False: 0] ------------------ 181| 345| context_->trace_file_tracker->DoneParsing(file_id_, trace_size_); 182| 345| } 183| 345| return base::OkStatus(); 184| 345|} forwarding_trace_parser.cc:_ZN8perfetto15trace_processor12_GLOBAL__N_121GetMinimumSortingModeENS0_9TraceTypeERKNS0_21TraceProcessorContextE: 54| 424| const TraceProcessorContext& context) { 55| 424| switch (trace_type) { ------------------ | Branch (55:11): [True: 0, False: 424] ------------------ 56| 0| case kNinjaLogTraceType: ------------------ | Branch (56:5): [True: 0, False: 424] ------------------ 57| 0| case kSystraceTraceType: ------------------ | Branch (57:5): [True: 0, False: 424] ------------------ 58| 0| case kGzipTraceType: ------------------ | Branch (58:5): [True: 0, False: 424] ------------------ 59| 0| case kCtraceTraceType: ------------------ | Branch (59:5): [True: 0, False: 424] ------------------ 60| 0| return std::nullopt; 61| | 62| 0| case kPerfDataTraceType: ------------------ | Branch (62:5): [True: 0, False: 424] ------------------ 63| 0| case kInstrumentsXmlTraceType: ------------------ | Branch (63:5): [True: 0, False: 424] ------------------ 64| 0| return TraceSorter::SortingMode::kDefault; 65| | 66| 0| case kUnknownTraceType: ------------------ | Branch (66:5): [True: 0, False: 424] ------------------ 67| 0| case kJsonTraceType: ------------------ | Branch (67:5): [True: 0, False: 424] ------------------ 68| 0| case kFuchsiaTraceType: ------------------ | Branch (68:5): [True: 0, False: 424] ------------------ 69| 0| case kZipFile: ------------------ | Branch (69:5): [True: 0, False: 424] ------------------ 70| 0| case kTarTraceType: ------------------ | Branch (70:5): [True: 0, False: 424] ------------------ 71| 0| case kAndroidDumpstateTraceType: ------------------ | Branch (71:5): [True: 0, False: 424] ------------------ 72| 0| case kAndroidLogcatTraceType: ------------------ | Branch (72:5): [True: 0, False: 424] ------------------ 73| 0| case kGeckoTraceType: ------------------ | Branch (73:5): [True: 0, False: 424] ------------------ 74| 0| case kArtMethodTraceType: ------------------ | Branch (74:5): [True: 0, False: 424] ------------------ 75| 0| case kPerfTextTraceType: ------------------ | Branch (75:5): [True: 0, False: 424] ------------------ 76| 0| return TraceSorter::SortingMode::kFullSort; 77| | 78| 424| case kProtoTraceType: ------------------ | Branch (78:5): [True: 424, False: 0] ------------------ 79| 424| case kSymbolsTraceType: ------------------ | Branch (79:5): [True: 0, False: 424] ------------------ 80| 424| return ConvertSortingMode(context.config.sorting_mode); 81| | 82| 0| case kAndroidBugreportTraceType: ------------------ | Branch (82:5): [True: 0, False: 424] ------------------ 83| 0| PERFETTO_FATAL( 84| 424| "This trace type should be handled at the ZipParser level"); 85| 424| } 86| 0| PERFETTO_FATAL("For GCC"); 87| 0|} forwarding_trace_parser.cc:_ZN8perfetto15trace_processor12_GLOBAL__N_118ConvertSortingModeENS0_11SortingModeE: 42| 424|TraceSorter::SortingMode ConvertSortingMode(SortingMode sorting_mode) { 43| 424| switch (sorting_mode) { ------------------ | Branch (43:11): [True: 0, False: 424] ------------------ 44| 424| case SortingMode::kDefaultHeuristics: ------------------ | Branch (44:5): [True: 424, False: 0] ------------------ 45| 424| return TraceSorter::SortingMode::kDefault; 46| 0| case SortingMode::kForceFullSort: ------------------ | Branch (46:5): [True: 0, False: 424] ------------------ 47| 0| return TraceSorter::SortingMode::kFullSort; 48| 424| } 49| 0| PERFETTO_FATAL("For GCC"); 50| 0|} _ZN8perfetto15trace_processor15AndroidLogEvent12DetectFormatENS_4base10StringViewE: 49| 428| base::StringView line) { 50| 428| auto p = base::SplitString(line.ToStdString(), " "); 51| 428| if (p.size() < 5) ------------------ | Branch (51:7): [True: 427, False: 1] ------------------ 52| 427| return std::nullopt; 53| | 54| 1| if (p[0].size() != 5 || p[0][2] != '-') ------------------ | Branch (54:7): [True: 1, False: 0] | Branch (54:27): [True: 0, False: 0] ------------------ 55| 1| return std::nullopt; 56| | 57| 0| if (p[1].size() < 10 || p[1][2] != ':' || p[1][5] != ':' || p[1][8] != '.') ------------------ | Branch (57:7): [True: 0, False: 0] | Branch (57:27): [True: 0, False: 0] | Branch (57:45): [True: 0, False: 0] | Branch (57:63): [True: 0, False: 0] ------------------ 58| 0| return std::nullopt; 59| | 60| 0| if (p[4].size() == 1 && p[4][0] >= 'A' && p[4][0] <= 'Z') ------------------ | Branch (60:7): [True: 0, False: 0] | Branch (60:27): [True: 0, False: 0] | Branch (60:45): [True: 0, False: 0] ------------------ 61| 0| return Format::kPersistentLog; 62| | 63| 0| if (p[5].size() == 1 && p[5][0] >= 'A' && p[5][0] <= 'Z') ------------------ | Branch (63:7): [True: 0, False: 0] | Branch (63:27): [True: 0, False: 0] | Branch (63:45): [True: 0, False: 0] ------------------ 64| 0| return Format::kBugreport; 65| | 66| 0| return std::nullopt; 67| 0|} _ZN8perfetto15trace_processor15AndroidLogEvent15IsAndroidLogcatEPKhm: 70| 432|bool AndroidLogEvent::IsAndroidLogcat(const uint8_t* data, size_t size) { 71| | // Make sure we don't split an entire file into lines. 72| 432| constexpr size_t kMaxGuessAndroidLogEventLookAhead = 4096; 73| 432| std::vector lines = 74| 432| FindLines(data, std::min(size, kMaxGuessAndroidLogEventLookAhead)); 75| | 76| 432| auto is_marker = [](base::StringView line) { 77| 432| return line.StartsWith("--------"); 78| 432| }; 79| 432| auto it = std::find_if_not(lines.begin(), lines.end(), is_marker); 80| | 81| 432| return it != lines.end() && DetectFormat(*it).has_value(); ------------------ | Branch (81:10): [True: 428, False: 4] | Branch (81:31): [True: 0, False: 428] ------------------ 82| 432|} android_log_event.cc:_ZN8perfetto15trace_processor12_GLOBAL__N_19FindLinesEPKhm: 31| 432|std::vector FindLines(const uint8_t* data, size_t size) { 32| 432| std::vector lines; 33| 432| const char* line_start = reinterpret_cast(data); 34| 432| const char* ptr = line_start; 35| 432| const char* const end = ptr + size; 36| | 37| 1.76M| for (; ptr != end; ++ptr) { ------------------ | Branch (37:10): [True: 1.76M, False: 432] ------------------ 38| 1.76M| if (*ptr == '\n') { ------------------ | Branch (38:9): [True: 200k, False: 1.56M] ------------------ 39| 200k| lines.emplace_back(line_start, static_cast(ptr - line_start)); 40| 200k| line_start = ptr + 1; 41| 200k| } 42| 1.76M| } 43| 432| return lines; 44| 432|} android_log_event.cc:_ZZN8perfetto15trace_processor15AndroidLogEvent15IsAndroidLogcatEPKhmENK3$_0clENS_4base10StringViewE: 76| 428| auto is_marker = [](base::StringView line) { 77| 428| return line.StartsWith("--------"); 78| 428| }; _ZN8perfetto15trace_processor11ArgsTrackerC2EPNS0_21TraceProcessorContextE: 36| 848k|ArgsTracker::ArgsTracker(TraceProcessorContext* context) : context_(context) {} _ZN8perfetto15trace_processor11ArgsTrackerD2Ev: 38| 1.61M|ArgsTracker::~ArgsTracker() { 39| 1.61M| Flush(); 40| 1.61M|} _ZN8perfetto15trace_processor11ArgsTracker6AddArgEPNS0_12ColumnLegacyEjNS0_10StringPool2IdES5_NS0_8VariadicENS0_17GlobalArgsTracker12UpdatePolicyE: 47| 23.0M| UpdatePolicy update_policy) { 48| 23.0M| args_.emplace_back(); 49| | 50| 23.0M| auto* rid_arg = &args_.back(); 51| 23.0M| rid_arg->column = arg_set_id; 52| 23.0M| rid_arg->row = row; 53| 23.0M| rid_arg->flat_key = flat_key; 54| 23.0M| rid_arg->key = key; 55| 23.0M| rid_arg->value = value; 56| 23.0M| rid_arg->update_policy = update_policy; 57| 23.0M|} _ZN8perfetto15trace_processor11ArgsTracker5FlushEv: 59| 2.64M|void ArgsTracker::Flush() { 60| 2.64M| using Arg = GlobalArgsTracker::Arg; 61| | 62| 2.64M| if (args_.empty()) ------------------ | Branch (62:7): [True: 2.25M, False: 389k] ------------------ 63| 2.25M| return; 64| | 65| | // We need to ensure that the args with the same arg set (arg_set_id + row) 66| | // and key are grouped together. This is important for joining the args from 67| | // different events (e.g. trace event begin and trace event end might both 68| | // have arguments). 69| | // 70| | // To achieve that (and do it quickly) we do two steps: 71| | // - First, group all of the values within the same key together and compute 72| | // the smallest index for each key. 73| | // - Then we sort the args by column, row, smallest_index_for_key (to group 74| | // keys) and index (to preserve the original ordering). 75| | 76| 389k| struct Entry { 77| 389k| size_t index; 78| 389k| StringId key; 79| 389k| size_t smallest_index_for_key = 0; 80| | 81| 389k| Entry(size_t i, StringId k) : index(i), key(k) {} 82| 389k| }; 83| | 84| 389k| base::SmallVector entries; 85| 14.8M| for (const auto& arg : args_) { ------------------ | Branch (85:24): [True: 14.8M, False: 389k] ------------------ 86| 14.8M| entries.emplace_back(entries.size(), arg.key); 87| 14.8M| } 88| | 89| | // Step 1: Compute the `smallest_index_for_key`. 90| 389k| std::sort(entries.begin(), entries.end(), [](const Entry& a, const Entry& b) { 91| 389k| return std::tie(a.key, a.index) < std::tie(b.key, b.index); 92| 389k| }); 93| | 94| | // As the data is sorted by (`key`, `index`) now, then the objects with the 95| | // same key will be contiguous and within this block it will be sorted by 96| | // index. That means that `smallest_index_for_key` for the entire block should 97| | // be the value of the first index in the block. 98| 389k| entries[0].smallest_index_for_key = entries[0].index; 99| 14.8M| for (size_t i = 1; i < entries.size(); ++i) { ------------------ | Branch (99:22): [True: 14.4M, False: 389k] ------------------ 100| 14.4M| entries[i].smallest_index_for_key = 101| 14.4M| entries[i].key == entries[i - 1].key ------------------ | Branch (101:9): [True: 13.4M, False: 955k] ------------------ 102| 14.4M| ? entries[i - 1].smallest_index_for_key 103| 14.4M| : entries[i].index; 104| 14.4M| } 105| | 106| | // Step 2: sort in the desired order: grouping by arg set first (column, row), 107| | // then ensuring that the args with the same key are grouped together 108| | // (smallest_index_for_key) and then preserving the original order within 109| | // these group (index). 110| 389k| std::sort( 111| 389k| entries.begin(), entries.end(), [&](const Entry& a, const Entry& b) { 112| 389k| const Arg& first_arg = args_[a.index]; 113| 389k| const Arg& second_arg = args_[b.index]; 114| 389k| return std::tie(first_arg.column, first_arg.row, 115| 389k| a.smallest_index_for_key, 116| 389k| a.index) < std::tie(second_arg.column, second_arg.row, 117| 389k| b.smallest_index_for_key, b.index); 118| 389k| }); 119| | 120| | // Apply permutation of entries[].index to args. 121| 389k| base::SmallVector sorted_args; 122| 14.8M| for (auto& entry : entries) { ------------------ | Branch (122:20): [True: 14.8M, False: 389k] ------------------ 123| 14.8M| sorted_args.emplace_back(args_[entry.index]); 124| 14.8M| } 125| | 126| | // Insert args. 127| 2.89M| for (uint32_t i = 0; i < args_.size();) { ------------------ | Branch (127:24): [True: 2.50M, False: 389k] ------------------ 128| 2.50M| const GlobalArgsTracker::Arg& arg = sorted_args[i]; 129| 2.50M| auto* col = arg.column; 130| 2.50M| uint32_t row = arg.row; 131| | 132| 2.50M| uint32_t next_rid_idx = i + 1; 133| 14.8M| while (next_rid_idx < sorted_args.size() && ------------------ | Branch (133:12): [True: 14.4M, False: 389k] ------------------ 134| 14.8M| col == sorted_args[next_rid_idx].column && ------------------ | Branch (134:12): [True: 14.4M, False: 244] ------------------ 135| 14.8M| row == sorted_args[next_rid_idx].row) { ------------------ | Branch (135:12): [True: 12.3M, False: 2.11M] ------------------ 136| 12.3M| next_rid_idx++; 137| 12.3M| } 138| | 139| 2.50M| ArgSetId set_id = context_->global_args_tracker->AddArgSet( 140| 2.50M| sorted_args.data(), i, next_rid_idx); 141| 2.50M| if (col->IsNullable()) { ------------------ | Branch (141:9): [True: 1.09M, False: 1.40M] ------------------ 142| 1.09M| TypedColumn>::FromColumn(col)->Set(row, set_id); 143| 1.40M| } else { 144| 1.40M| TypedColumn::FromColumn(col)->Set(row, set_id); 145| 1.40M| } 146| | 147| 2.50M| i = next_rid_idx; 148| 2.50M| } 149| 389k| args_.clear(); 150| 389k|} _ZNO8perfetto15trace_processor11ArgsTracker15ToCompactArgSetERKNS0_12ColumnLegacyEj: 154| 518k| uint32_t row_number) && { 155| 518k| CompactArgSet compact_args; 156| 8.24M| for (const auto& arg : args_) { ------------------ | Branch (156:24): [True: 8.24M, False: 518k] ------------------ 157| 8.24M| PERFETTO_DCHECK(arg.column == &column); 158| 8.24M| PERFETTO_DCHECK(arg.row == row_number); 159| 8.24M| compact_args.emplace_back(arg.ToCompactArg()); 160| 8.24M| } 161| 518k| args_.clear(); 162| 518k| return compact_args; 163| 518k|} _ZNK8perfetto15trace_processor11ArgsTracker16NeedsTranslationERKNS0_20ArgsTranslationTableE: 165| 725k|bool ArgsTracker::NeedsTranslation(const ArgsTranslationTable& table) const { 166| 725k| return std::any_of( 167| 725k| args_.begin(), args_.end(), [&table](const GlobalArgsTracker::Arg& arg) { 168| 725k| return table.NeedsTranslation(arg.flat_key, arg.key, arg.value.type); 169| 725k| }); 170| 725k|} _ZN8perfetto15trace_processor11ArgsTracker13BoundInserterC2EPS1_PNS0_12ColumnLegacyEj: 175| 3.22M| : args_tracker_(args_tracker), 176| 3.22M| arg_set_id_column_(arg_set_id_column), 177| 3.22M| row_(row) {} _ZN8perfetto15trace_processor11ArgsTracker13BoundInserterD2Ev: 179| 3.22M|ArgsTracker::BoundInserter::~BoundInserter() = default; args_tracker.cc:_ZZN8perfetto15trace_processor11ArgsTracker5FlushEvEN5EntryC2EmNS0_10StringPool2IdE: 81| 14.8M| Entry(size_t i, StringId k) : index(i), key(k) {} args_tracker.cc:_ZZN8perfetto15trace_processor11ArgsTracker5FlushEvENK3$_0clERKZNS1_5FlushEvE5EntryS5_: 90| 251M| std::sort(entries.begin(), entries.end(), [](const Entry& a, const Entry& b) { 91| 251M| return std::tie(a.key, a.index) < std::tie(b.key, b.index); 92| 251M| }); args_tracker.cc:_ZZN8perfetto15trace_processor11ArgsTracker5FlushEvENK3$_1clERKZNS1_5FlushEvE5EntryS5_: 111| 241M| entries.begin(), entries.end(), [&](const Entry& a, const Entry& b) { 112| 241M| const Arg& first_arg = args_[a.index]; 113| 241M| const Arg& second_arg = args_[b.index]; 114| 241M| return std::tie(first_arg.column, first_arg.row, 115| 241M| a.smallest_index_for_key, 116| 241M| a.index) < std::tie(second_arg.column, second_arg.row, 117| 241M| b.smallest_index_for_key, b.index); 118| 241M| }); args_tracker.cc:_ZZNK8perfetto15trace_processor11ArgsTracker16NeedsTranslationERKNS0_20ArgsTranslationTableEENK3$_0clERKNS0_17GlobalArgsTracker3ArgE: 167| 1.04M| args_.begin(), args_.end(), [&table](const GlobalArgsTracker::Arg& arg) { 168| 1.04M| return table.NeedsTranslation(arg.flat_key, arg.key, arg.value.type); 169| 1.04M| }); _ZN8perfetto15trace_processor11ArgsTracker13BoundInserter6AddArgENS0_10StringPool2IdENS0_8VariadicENS0_17GlobalArgsTracker12UpdatePolicyE: 56| 10.2M| UpdatePolicy update_policy = UpdatePolicy::kAddOrUpdate) { 57| 10.2M| return AddArg(key, key, v, update_policy); 58| 10.2M| } _ZN8perfetto15trace_processor11ArgsTracker13BoundInserter6AddArgENS0_10StringPool2IdES4_NS0_8VariadicENS0_17GlobalArgsTracker12UpdatePolicyE: 64| 23.0M| UpdatePolicy update_policy = UpdatePolicy::kAddOrUpdate) { 65| 23.0M| args_tracker_->AddArg(arg_set_id_column_, row_, flat_key, key, v, 66| 23.0M| update_policy); 67| 23.0M| return *this; 68| 23.0M| } _ZN8perfetto15trace_processor11ArgsTracker13BoundInserter22GetNextArrayEntryIndexENS0_10StringPool2IdE: 72| 2.79k| size_t GetNextArrayEntryIndex(StringId key) { 73| | // Zero-initializes |key| in the map if it doesn't exist yet. 74| 2.79k| return args_tracker_ 75| 2.79k| ->array_indexes_[std::make_tuple(arg_set_id_column_, row_, key)]; 76| 2.79k| } _ZN8perfetto15trace_processor11ArgsTracker13BoundInserter24IncrementArrayEntryIndexENS0_10StringPool2IdE: 79| 2.79k| size_t IncrementArrayEntryIndex(StringId key) { 80| | // Zero-initializes |key| in the map if it doesn't exist yet. 81| 2.79k| return ++args_tracker_->array_indexes_[std::make_tuple(arg_set_id_column_, 82| 2.79k| row_, key)]; 83| 2.79k| } _ZN8perfetto15trace_processor11ArgsTracker9AddArgsToENS0_6tables14ChromeRawTable2IdE: 108| 1.44M| BoundInserter AddArgsTo(tables::ChromeRawTable::Id id) { 109| 1.44M| return AddArgsTo(context_->storage->mutable_chrome_raw_table(), id); 110| 1.44M| } _ZN8perfetto15trace_processor11ArgsTracker9AddArgsToENS0_6tables12CounterTable2IdE: 116| 279k| BoundInserter AddArgsTo(CounterId id) { 117| 279k| return AddArgsTo(context_->storage->mutable_counter_table(), id); 118| 279k| } _ZN8perfetto15trace_processor11ArgsTracker9AddArgsToENS0_6tables10SliceTable2IdE: 120| 1.24M| BoundInserter AddArgsTo(SliceId id) { 121| 1.24M| return AddArgsTo(context_->storage->mutable_slice_table(), id); 122| 1.24M| } _ZN8perfetto15trace_processor11ArgsTracker9AddArgsToENS0_6tables9FlowTable2IdE: 124| 1.39k| BoundInserter AddArgsTo(tables::FlowTable::Id id) { 125| 1.39k| return AddArgsTo(context_->storage->mutable_flow_table(), id); 126| 1.39k| } _ZN8perfetto15trace_processor11ArgsTracker9AddArgsToENS0_6tables23MemorySnapshotNodeTable2IdE: 143| 3.77k| BoundInserter AddArgsTo(tables::MemorySnapshotNodeTable::Id id) { 144| 3.77k| return AddArgsTo(context_->storage->mutable_memory_snapshot_node_table(), 145| 3.77k| id); 146| 3.77k| } _ZN8perfetto15trace_processor11ArgsTracker9AddArgsToENS0_6tables10TrackTable2IdE: 201| 151k| BoundInserter AddArgsTo(TrackId id) { 202| 151k| auto* table = context_->storage->mutable_track_table(); 203| 151k| uint32_t row = table->FindById(id)->ToRowNumber().row_number(); 204| 151k| return BoundInserter(this, table->mutable_source_arg_set_id(), row); 205| 151k| } _ZN8perfetto15trace_processor11ArgsTracker9AddArgsToEj: 212| 100k| BoundInserter AddArgsTo(UniquePid id) { 213| 100k| return BoundInserter( 214| 100k| this, context_->storage->mutable_process_table()->mutable_arg_set_id(), 215| 100k| id); 216| 100k| } _ZN8perfetto15trace_processor11ArgsTracker9AddArgsToINS0_6tables14ChromeRawTableEEENS1_13BoundInserterEPT_NS6_2IdE: 247| 1.44M| BoundInserter AddArgsTo(Table* table, typename Table::Id id) { 248| 1.44M| uint32_t row = table->FindById(id)->ToRowNumber().row_number(); 249| 1.44M| return BoundInserter(this, table->mutable_arg_set_id(), row); 250| 1.44M| } _ZN8perfetto15trace_processor11ArgsTracker9AddArgsToINS0_6tables12CounterTableEEENS1_13BoundInserterEPT_NS6_2IdE: 247| 279k| BoundInserter AddArgsTo(Table* table, typename Table::Id id) { 248| 279k| uint32_t row = table->FindById(id)->ToRowNumber().row_number(); 249| 279k| return BoundInserter(this, table->mutable_arg_set_id(), row); 250| 279k| } _ZN8perfetto15trace_processor11ArgsTracker9AddArgsToINS0_6tables10SliceTableEEENS1_13BoundInserterEPT_NS6_2IdE: 247| 1.24M| BoundInserter AddArgsTo(Table* table, typename Table::Id id) { 248| 1.24M| uint32_t row = table->FindById(id)->ToRowNumber().row_number(); 249| 1.24M| return BoundInserter(this, table->mutable_arg_set_id(), row); 250| 1.24M| } _ZN8perfetto15trace_processor11ArgsTracker9AddArgsToINS0_6tables9FlowTableEEENS1_13BoundInserterEPT_NS6_2IdE: 247| 1.39k| BoundInserter AddArgsTo(Table* table, typename Table::Id id) { 248| 1.39k| uint32_t row = table->FindById(id)->ToRowNumber().row_number(); 249| 1.39k| return BoundInserter(this, table->mutable_arg_set_id(), row); 250| 1.39k| } _ZN8perfetto15trace_processor11ArgsTracker9AddArgsToINS0_6tables23MemorySnapshotNodeTableEEENS1_13BoundInserterEPT_NS6_2IdE: 247| 3.77k| BoundInserter AddArgsTo(Table* table, typename Table::Id id) { 248| 3.77k| uint32_t row = table->FindById(id)->ToRowNumber().row_number(); 249| 3.77k| return BoundInserter(this, table->mutable_arg_set_id(), row); 250| 3.77k| } _ZN8perfetto15trace_processor11ArgsTrackerC2EOS1_: 103| 765k| ArgsTracker(ArgsTracker&&) = default; _ZN8perfetto15trace_processor20ArgsTranslationTableC2EPNS0_12TraceStorageE: 56| 2.03k| : storage_(storage), 57| | interned_chrome_histogram_hash_key_( 58| 2.03k| storage->InternString(kChromeHistogramHashKey)), 59| | interned_chrome_histogram_name_key_( 60| 2.03k| storage->InternString(kChromeHistogramNameKey)), 61| | interned_chrome_user_event_hash_key_( 62| 2.03k| storage->InternString(kChromeUserEventHashKey)), 63| | interned_chrome_user_event_action_key_( 64| 2.03k| storage->InternString(kChromeUserEventActionKey)), 65| | interned_chrome_performance_mark_site_hash_key_( 66| 2.03k| storage->InternString(kChromePerformanceMarkSiteHashKey)), 67| | interned_chrome_performance_mark_site_key_( 68| 2.03k| storage->InternString(kChromePerformanceMarkSiteKey)), 69| | interned_chrome_performance_mark_mark_hash_key_( 70| 2.03k| storage->InternString(kChromePerformanceMarkMarkHashKey)), 71| | interned_chrome_performance_mark_mark_key_( 72| 2.03k| storage->InternString(kChromePerformanceMarkMarkKey)), 73| | interned_chrome_trigger_hash_key_( 74| 2.03k| storage->InternString(kChromeTriggerHashKey)), 75| | interned_chrome_trigger_name_key_( 76| 2.03k| storage->InternString(kChromeTriggerNameKey)), 77| | interned_mojo_method_mapping_id_( 78| 2.03k| storage->InternString(kMojoMethodMappingIdKey)), 79| 2.03k| interned_mojo_method_rel_pc_(storage->InternString(kMojoMethodRelPcKey)), 80| 2.03k| interned_mojo_method_name_(storage->InternString(kMojoMethodNameKey)), 81| 2.03k| interned_mojo_interface_tag_(storage->InternString(kMojoIntefaceTagKey)), 82| | interned_obfuscated_view_dump_class_name_flat_key_( 83| 2.03k| storage->InternString(kObfuscatedViewDumpClassNameFlatKey)) {} _ZNK8perfetto15trace_processor20ArgsTranslationTable16NeedsTranslationENS0_10StringPool2IdES3_NS0_8Variadic4TypeE: 87| 1.04M| Variadic::Type type) const { 88| 1.04M| return KeyIdAndTypeToEnum(flat_key_id, key_id, type).has_value(); 89| 1.04M|} _ZNK8perfetto15trace_processor20ArgsTranslationTable13TranslateArgsERKNS_4base11SmallVectorINS0_17GlobalArgsTracker10CompactArgELm16EEERNS0_11ArgsTracker13BoundInserterE: 93| 512k| ArgsTracker::BoundInserter& inserter) const { 94| 512k| std::optional mapping_id; 95| 512k| std::optional rel_pc; 96| | 97| 8.16M| for (const auto& arg : arg_set) { ------------------ | Branch (97:24): [True: 8.16M, False: 512k] ------------------ 98| 8.16M| const auto key_type = 99| 8.16M| KeyIdAndTypeToEnum(arg.flat_key, arg.key, arg.value.type); 100| 8.16M| if (!key_type.has_value()) { ------------------ | Branch (100:9): [True: 80.9k, False: 8.08M] ------------------ 101| 80.9k| inserter.AddArg(arg.flat_key, arg.key, arg.value, arg.update_policy); 102| 80.9k| continue; 103| 80.9k| } 104| | 105| 8.08M| switch (*key_type) { ------------------ | Branch (105:13): [True: 0, False: 8.08M] ------------------ 106| 8.08M| case KeyType::kChromeHistogramHash: { ------------------ | Branch (106:7): [True: 8.08M, False: 0] ------------------ 107| 8.08M| inserter.AddArg(interned_chrome_histogram_hash_key_, arg.value); 108| 8.08M| const std::optional translated_value = 109| 8.08M| TranslateChromeHistogramHash(arg.value.uint_value); 110| 8.08M| if (translated_value) { ------------------ | Branch (110:13): [True: 0, False: 8.08M] ------------------ 111| 0| inserter.AddArg( 112| 0| interned_chrome_histogram_name_key_, 113| 0| Variadic::String(storage_->InternString(*translated_value))); 114| 0| } 115| 8.08M| break; 116| 0| } 117| 0| case KeyType::kChromeUserEventHash: { ------------------ | Branch (117:7): [True: 0, False: 8.08M] ------------------ 118| 0| inserter.AddArg(interned_chrome_user_event_hash_key_, arg.value); 119| 0| const std::optional translated_value = 120| 0| TranslateChromeUserEventHash(arg.value.uint_value); 121| 0| if (translated_value) { ------------------ | Branch (121:13): [True: 0, False: 0] ------------------ 122| 0| inserter.AddArg( 123| 0| interned_chrome_user_event_action_key_, 124| 0| Variadic::String(storage_->InternString(*translated_value))); 125| 0| } 126| 0| break; 127| 0| } 128| 0| case KeyType::kChromePerformanceMarkMarkHash: { ------------------ | Branch (128:7): [True: 0, False: 8.08M] ------------------ 129| 0| inserter.AddArg(interned_chrome_performance_mark_mark_hash_key_, 130| 0| arg.value); 131| 0| const std::optional translated_value = 132| 0| TranslateChromePerformanceMarkMarkHash(arg.value.uint_value); 133| 0| if (translated_value) { ------------------ | Branch (133:13): [True: 0, False: 0] ------------------ 134| 0| inserter.AddArg( 135| 0| interned_chrome_performance_mark_mark_key_, 136| 0| Variadic::String(storage_->InternString(*translated_value))); 137| 0| } 138| 0| break; 139| 0| } 140| 0| case KeyType::kChromePerformanceMarkSiteHash: { ------------------ | Branch (140:7): [True: 0, False: 8.08M] ------------------ 141| 0| inserter.AddArg(interned_chrome_performance_mark_site_hash_key_, 142| 0| arg.value); 143| 0| const std::optional translated_value = 144| 0| TranslateChromePerformanceMarkSiteHash(arg.value.uint_value); 145| 0| if (translated_value) { ------------------ | Branch (145:13): [True: 0, False: 0] ------------------ 146| 0| inserter.AddArg( 147| 0| interned_chrome_performance_mark_site_key_, 148| 0| Variadic::String(storage_->InternString(*translated_value))); 149| 0| } 150| 0| break; 151| 0| } 152| 0| case KeyType::kClassName: { ------------------ | Branch (152:7): [True: 0, False: 8.08M] ------------------ 153| 0| const std::optional translated_class_name = 154| 0| TranslateClassName(arg.value.string_value); 155| 0| if (translated_class_name) { ------------------ | Branch (155:13): [True: 0, False: 0] ------------------ 156| 0| inserter.AddArg(arg.flat_key, arg.key, 157| 0| Variadic::String(*translated_class_name)); 158| 0| } else { 159| 0| inserter.AddArg(arg.flat_key, arg.key, arg.value); 160| 0| } 161| 0| break; 162| 0| } 163| 0| case KeyType::kChromeTriggerHash: { ------------------ | Branch (163:7): [True: 0, False: 8.08M] ------------------ 164| 0| inserter.AddArg(interned_chrome_trigger_hash_key_, arg.value); 165| 0| const std::optional translated_value = 166| 0| TranslateChromeStudyHash(arg.value.uint_value); 167| 0| if (translated_value) { ------------------ | Branch (167:13): [True: 0, False: 0] ------------------ 168| 0| inserter.AddArg( 169| 0| interned_chrome_trigger_name_key_, 170| 0| Variadic::String(storage_->InternString(*translated_value))); 171| 0| } 172| 0| break; 173| 0| } 174| 0| case KeyType::kMojoMethodMappingId: { ------------------ | Branch (174:7): [True: 0, False: 8.08M] ------------------ 175| 0| mapping_id = arg.value.uint_value; 176| 0| break; 177| 0| } 178| 0| case KeyType::kMojoMethodRelPc: { ------------------ | Branch (178:7): [True: 0, False: 8.08M] ------------------ 179| 0| rel_pc = arg.value.uint_value; 180| 0| break; 181| 0| } 182| 8.08M| } 183| 8.08M| } 184| 512k| EmitMojoMethodLocation(mapping_id, rel_pc, inserter); 185| 512k|} _ZNK8perfetto15trace_processor20ArgsTranslationTable18KeyIdAndTypeToEnumENS0_10StringPool2IdES3_NS0_8Variadic4TypeE: 190| 9.21M| Variadic::Type type) const { 191| 9.21M| if (type == Variadic::Type::kUint) { ------------------ | Branch (191:7): [True: 8.72M, False: 488k] ------------------ 192| 8.72M| if (key_id == interned_chrome_histogram_hash_key_) { ------------------ | Branch (192:9): [True: 8.60M, False: 123k] ------------------ 193| 8.60M| return KeyType::kChromeHistogramHash; 194| 8.60M| } 195| 123k| if (key_id == interned_chrome_user_event_hash_key_) { ------------------ | Branch (195:9): [True: 0, False: 123k] ------------------ 196| 0| return KeyType::kChromeUserEventHash; 197| 0| } 198| 123k| if (key_id == interned_chrome_performance_mark_mark_hash_key_) { ------------------ | Branch (198:9): [True: 0, False: 123k] ------------------ 199| 0| return KeyType::kChromePerformanceMarkMarkHash; 200| 0| } 201| 123k| if (key_id == interned_chrome_performance_mark_site_hash_key_) { ------------------ | Branch (201:9): [True: 0, False: 123k] ------------------ 202| 0| return KeyType::kChromePerformanceMarkSiteHash; 203| 0| } 204| 123k| if (key_id == interned_mojo_method_mapping_id_) { ------------------ | Branch (204:9): [True: 0, False: 123k] ------------------ 205| 0| return KeyType::kMojoMethodMappingId; 206| 0| } 207| 123k| if (key_id == interned_mojo_method_rel_pc_) { ------------------ | Branch (207:9): [True: 0, False: 123k] ------------------ 208| 0| return KeyType::kMojoMethodRelPc; 209| 0| } 210| 123k| if (key_id == interned_chrome_trigger_hash_key_) { ------------------ | Branch (210:9): [True: 0, False: 123k] ------------------ 211| 0| return KeyType::kChromeTriggerHash; 212| 0| } 213| 488k| } else if (type == Variadic::Type::kString) { ------------------ | Branch (213:14): [True: 35.1k, False: 453k] ------------------ 214| 35.1k| if (flat_key_id == interned_obfuscated_view_dump_class_name_flat_key_) { ------------------ | Branch (214:9): [True: 0, False: 35.1k] ------------------ 215| 0| return KeyType::kClassName; 216| 0| } 217| 35.1k| } 218| 611k| return std::nullopt; 219| 9.21M|} _ZNK8perfetto15trace_processor20ArgsTranslationTable28TranslateChromeHistogramHashEm: 222| 8.08M|ArgsTranslationTable::TranslateChromeHistogramHash(uint64_t hash) const { 223| 8.08M| auto* value = chrome_histogram_hash_to_name_.Find(hash); 224| 8.08M| if (!value) { ------------------ | Branch (224:7): [True: 8.08M, False: 0] ------------------ 225| 8.08M| return std::nullopt; 226| 8.08M| } 227| 0| return base::StringView(*value); 228| 8.08M|} _ZNK8perfetto15trace_processor20ArgsTranslationTable22EmitMojoMethodLocationENSt3__18optionalImEES4_RNS0_11ArgsTracker13BoundInserterE: 287| 512k| ArgsTracker::BoundInserter& inserter) const { 288| 512k| if (!mapping_id || !rel_pc) { ------------------ | Branch (288:7): [True: 512k, False: 0] | Branch (288:22): [True: 0, False: 0] ------------------ 289| 512k| return; 290| 512k| } 291| 0| const MappingId row_id(static_cast(*mapping_id)); 292| 0| const auto loc = TranslateNativeSymbol(row_id, *rel_pc); 293| 0| if (loc) { ------------------ | Branch (293:7): [True: 0, False: 0] ------------------ 294| 0| inserter.AddArg(interned_mojo_method_name_, 295| 0| Variadic::String(storage_->InternString(base::StringView( 296| 0| ExtractMojoMethod((loc->function_name)))))); 297| 0| inserter.AddArg(interned_mojo_interface_tag_, 298| 0| Variadic::String(storage_->InternString(base::StringView( 299| 0| ExtractMojoInterfaceTag(loc->function_name)))), 300| | // If the trace already has interface tag as a raw string 301| | // (older Chromium versions, local traces, and so on), use 302| | // the raw string. 303| 0| GlobalArgsTracker::UpdatePolicy::kSkipIfExists); 304| 0| } else { 305| | // Could not find the corresponding source location. Let's emit raw arg 306| | // values so that the data doesn't silently go missing. 307| 0| inserter.AddArg(interned_mojo_method_mapping_id_, 308| 0| Variadic::UnsignedInteger(*mapping_id)); 309| 0| inserter.AddArg(interned_mojo_method_rel_pc_, 310| 0| Variadic::UnsignedInteger(*rel_pc)); 311| 0| } 312| 0|} _ZN8perfetto15trace_processor14ClockConverterC2EPNS0_21TraceProcessorContextE: 38| 2.03k| : context_(context) {} _ZN8perfetto15trace_processor12ClockTrackerC2EPNS0_21TraceProcessorContextE: 40| 2.03k| : context_(context), 41| 2.03k| trace_time_clock_id_(protos::pbzero::BUILTIN_CLOCK_BOOTTIME) {} _ZN8perfetto15trace_processor12ClockTrackerD2Ev: 43| 2.03k|ClockTracker::~ClockTracker() = default; _ZN8perfetto15trace_processor12ClockTracker11AddSnapshotERKNSt3__16vectorINS1_14ClockTimestampENS2_9allocatorIS4_EEEE: 46| 21.1k| const std::vector& clock_timestamps) { 47| 21.1k| const auto snapshot_id = cur_snapshot_id_++; 48| | 49| | // Clear the cache 50| 21.1k| cache_.fill({}); 51| | 52| | // Compute the fingerprint of the snapshot by hashing all clock ids. This is 53| | // used by the clock pathfinding logic. 54| 21.1k| base::Hasher hasher; 55| 21.1k| for (const auto& clock_ts : clock_timestamps) ------------------ | Branch (55:29): [True: 60.9k, False: 21.1k] ------------------ 56| 60.9k| hasher.Update(clock_ts.clock.id); 57| 21.1k| const auto snapshot_hash = static_cast(hasher.digest()); 58| | 59| | // Add a new entry in each clock's snapshot vector. 60| 51.8k| for (const auto& clock_ts : clock_timestamps) { ------------------ | Branch (60:29): [True: 51.8k, False: 17.3k] ------------------ 61| 51.8k| ClockId clock_id = clock_ts.clock.id; 62| 51.8k| ClockDomain& domain = clocks_[clock_id]; 63| | 64| 51.8k| if (domain.snapshots.empty()) { ------------------ | Branch (64:9): [True: 8.11k, False: 43.7k] ------------------ 65| 8.11k| if (clock_ts.clock.is_incremental && ------------------ | Branch (65:11): [True: 1.93k, False: 6.17k] ------------------ 66| 8.11k| !IsConvertedSequenceClock(clock_id)) { ------------------ | Branch (66:11): [True: 707, False: 1.22k] ------------------ 67| 707| context_->storage->IncrementStats(stats::invalid_clock_snapshots); 68| 707| return base::ErrStatus( 69| 707| "Clock sync error: the global clock with id=%" PRId64 70| 707| " cannot use incremental encoding; this is only " 71| 707| "supported for sequence-scoped clocks.", 72| 707| clock_id); 73| 707| } 74| 7.40k| domain.unit_multiplier_ns = clock_ts.clock.unit_multiplier_ns; 75| 7.40k| domain.is_incremental = clock_ts.clock.is_incremental; 76| 43.7k| } else if (PERFETTO_UNLIKELY(domain.unit_multiplier_ns != ------------------ | | 24| 87.4k|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 3, False: 43.7k] | | | Branch (24:52): [True: 3, False: 43.7k] | | | Branch (24:52): [True: 0, False: 43.7k] | | ------------------ ------------------ 77| 43.7k| clock_ts.clock.unit_multiplier_ns || 78| 43.7k| domain.is_incremental != 79| 43.7k| clock_ts.clock.is_incremental)) { 80| 3| context_->storage->IncrementStats(stats::invalid_clock_snapshots); 81| 3| return base::ErrStatus( 82| 3| "Clock sync error: the clock domain with id=%" PRId64 83| 3| " (unit=%" PRId64 84| 3| ", incremental=%d), was previously registered with " 85| 3| "different properties (unit=%" PRId64 ", incremental=%d).", 86| 3| clock_id, clock_ts.clock.unit_multiplier_ns, 87| 3| clock_ts.clock.is_incremental, domain.unit_multiplier_ns, 88| 3| domain.is_incremental); 89| 3| } 90| 51.1k| const int64_t timestamp_ns = clock_ts.timestamp * domain.unit_multiplier_ns; 91| 51.1k| domain.last_timestamp_ns = timestamp_ns; 92| | 93| 51.1k| ClockSnapshots& vect = domain.snapshots[snapshot_hash]; 94| 51.1k| if (!vect.snapshot_ids.empty() && ------------------ | Branch (94:9): [True: 33.0k, False: 18.1k] ------------------ 95| 51.1k| PERFETTO_UNLIKELY(vect.snapshot_ids.back() == snapshot_id)) { ------------------ | | 24| 33.0k|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 3.11k, False: 29.8k] | | ------------------ ------------------ 96| 3.11k| context_->storage->IncrementStats(stats::invalid_clock_snapshots); 97| 3.11k| return base::ErrStatus( 98| 3.11k| "Clock sync error: duplicate clock domain with id=%" PRId64 99| 3.11k| " at snapshot %" PRIu32 ".", 100| 3.11k| clock_id, snapshot_id); 101| 3.11k| } 102| | 103| | // Clock ids in the range [64, 128) are sequence-scoped and must be 104| | // translated to global ids via SeqScopedClockIdToGlobal() before calling 105| | // this function. 106| 48.0k| PERFETTO_DCHECK(!IsSequenceClock(clock_id)); 107| | 108| | // Snapshot IDs must be always monotonic. 109| 48.0k| PERFETTO_DCHECK(vect.snapshot_ids.empty() || 110| 48.0k| vect.snapshot_ids.back() < snapshot_id); 111| | 112| 48.0k| if (!vect.timestamps_ns.empty() && ------------------ | Branch (112:9): [True: 29.8k, False: 18.1k] ------------------ 113| 48.0k| timestamp_ns < vect.timestamps_ns.back()) { ------------------ | Branch (113:9): [True: 845, False: 29.0k] ------------------ 114| | // Clock is not monotonic. 115| | 116| 845| if (clock_id == trace_time_clock_id_) { ------------------ | Branch (116:11): [True: 0, False: 845] ------------------ 117| 0| context_->storage->IncrementStats(stats::invalid_clock_snapshots); 118| | // The trace clock cannot be non-monotonic. 119| 0| return base::ErrStatus("Clock sync error: the trace clock (id=%" PRId64 120| 0| ") is not monotonic at snapshot %" PRIu32 121| 0| ". %" PRId64 " not >= %" PRId64 ".", 122| 0| clock_id, snapshot_id, timestamp_ns, 123| 0| vect.timestamps_ns.back()); 124| 0| } 125| | 126| 845| PERFETTO_DLOG("Detected non-monotonic clock with ID %" PRId64, clock_id); 127| | 128| | // For the other clocks the best thing we can do is mark it as 129| | // non-monotonic and refuse to use it as a source clock in the resolution 130| | // graph. We can still use it as a target clock, but not viceversa. 131| | // The concrete example is the CLOCK_REALTIME going 1h backwards during 132| | // daylight saving. We can still answer the question "what was the 133| | // REALTIME timestamp when BOOTTIME was X?" but we can't answer the 134| | // opposite question because there can be two valid BOOTTIME(s) for the 135| | // same REALTIME instant because of the 1:many relationship. 136| 845| non_monotonic_clocks_.insert(clock_id); 137| | 138| | // Erase all edges from the graph that start from this clock (but keep the 139| | // ones that end on this clock). 140| 845| auto begin = graph_.lower_bound(ClockGraphEdge{clock_id, 0, 0}); 141| 845| auto end = graph_.lower_bound(ClockGraphEdge{clock_id + 1, 0, 0}); 142| 845| graph_.erase(begin, end); 143| 845| } 144| 48.0k| vect.snapshot_ids.emplace_back(snapshot_id); 145| 48.0k| vect.timestamps_ns.emplace_back(timestamp_ns); 146| 48.0k| } 147| | 148| | // Create graph edges for all the possible tuples of clocks in this snapshot. 149| | // If the snapshot contains clock a, b, c, d create edges [ab, ac, ad, bc, bd, 150| | // cd] and the symmetrical ones [ba, ca, da, bc, db, dc]. 151| | // This is to store the information: Clock A is syncable to Clock B via the 152| | // snapshots of type (hash). 153| | // Clocks that were previously marked as non-monotonic won't be added as 154| | // valid sources. 155| 59.2k| for (auto it1 = clock_timestamps.begin(); it1 != clock_timestamps.end(); ------------------ | Branch (155:45): [True: 41.9k, False: 17.3k] ------------------ 156| 41.9k| ++it1) { 157| 41.9k| auto it2 = it1; 158| 41.9k| ++it2; 159| 91.5k| for (; it2 != clock_timestamps.end(); ++it2) { ------------------ | Branch (159:12): [True: 49.6k, False: 41.9k] ------------------ 160| 49.6k| if (!non_monotonic_clocks_.count(it1->clock.id)) ------------------ | Branch (160:11): [True: 41.2k, False: 8.37k] ------------------ 161| 41.2k| graph_.emplace(it1->clock.id, it2->clock.id, snapshot_hash); 162| | 163| 49.6k| if (!non_monotonic_clocks_.count(it2->clock.id)) ------------------ | Branch (163:11): [True: 39.7k, False: 9.87k] ------------------ 164| 39.7k| graph_.emplace(it2->clock.id, it1->clock.id, snapshot_hash); 165| 49.6k| } 166| 41.9k| } 167| | 168| 17.3k| return snapshot_id; 169| 21.1k|} _ZN8perfetto15trace_processor12ClockTracker8FindPathEll: 176| 42.1k|ClockTracker::ClockPath ClockTracker::FindPath(ClockId src, ClockId target) { 177| 42.1k| PERFETTO_CHECK(src != target); 178| | 179| | // If we've never heard of the clock before there is no hope: 180| 42.1k| if (clocks_.find(target) == clocks_.end()) { ------------------ | Branch (180:7): [True: 15.6k, False: 26.5k] ------------------ 181| 15.6k| return ClockPath(); 182| 15.6k| } 183| 26.5k| if (clocks_.find(src) == clocks_.end()) { ------------------ | Branch (183:7): [True: 362, False: 26.1k] ------------------ 184| 362| return ClockPath(); 185| 362| } 186| | 187| | // This is a classic breadth-first search. Each node in the queue holds also 188| | // the full path to reach that node. 189| | // We assume the graph is acyclic, if it isn't the ClockPath::kMaxLen will 190| | // stop the search anyways. 191| 26.1k| std::queue queue; 192| 26.1k| queue.emplace(src); 193| | 194| 2.73M| while (!queue.empty()) { ------------------ | Branch (194:10): [True: 2.73M, False: 2.55k] ------------------ 195| 2.73M| ClockPath cur_path = queue.front(); 196| 2.73M| queue.pop(); 197| | 198| 2.73M| const ClockId cur_clock_id = cur_path.last; 199| 2.73M| if (cur_clock_id == target) ------------------ | Branch (199:9): [True: 23.6k, False: 2.70M] ------------------ 200| 23.6k| return cur_path; 201| | 202| 2.70M| if (cur_path.len >= ClockPath::kMaxLen) ------------------ | Branch (202:9): [True: 787k, False: 1.91M] ------------------ 203| 787k| continue; 204| | 205| | // Expore all the adjacent clocks. 206| | // The lower_bound() below returns an iterator to the first edge that starts 207| | // on |cur_clock_id|. The edges are sorted by (src, target, hash). 208| 1.91M| for (auto it = graph_.lower_bound(ClockGraphEdge(cur_clock_id, 0, 0)); 209| 67.6M| it != graph_.end() && std::get<0>(*it) == cur_clock_id; ++it) { ------------------ | Branch (209:10): [True: 67.6M, False: 24.3k] | Branch (209:10): [True: 65.7M, False: 1.91M] | Branch (209:32): [True: 65.7M, False: 1.89M] ------------------ 210| 65.7M| ClockId next_clock_id = std::get<1>(*it); 211| 65.7M| SnapshotHash hash = std::get<2>(*it); 212| 65.7M| queue.push(ClockPath(cur_path, next_clock_id, hash)); 213| 65.7M| } 214| 1.91M| } 215| 2.55k| return ClockPath(); // invalid path. 216| 26.1k|} _ZN8perfetto15trace_processor12ClockTracker23ToTraceTimeFromSnapshotERKNSt3__16vectorINS1_14ClockTimestampENS2_9allocatorIS4_EEEE: 219| 17.3k| const std::vector& snapshot) { 220| 17.3k| auto maybe_found_trace_time_clock = std::find_if( 221| 17.3k| snapshot.begin(), snapshot.end(), 222| 17.3k| [this](const ClockTimestamp& clock_timestamp) { 223| 17.3k| return clock_timestamp.clock.id == this->trace_time_clock_id_; 224| 17.3k| }); 225| | 226| 17.3k| if (maybe_found_trace_time_clock == snapshot.end()) ------------------ | Branch (226:7): [True: 15.1k, False: 2.17k] ------------------ 227| 15.1k| return std::nullopt; 228| | 229| 2.17k| return maybe_found_trace_time_clock->timestamp; 230| 17.3k|} _ZN8perfetto15trace_processor12ClockTracker15ConvertSlowpathElll: 234| 42.1k| ClockId target_clock_id) { 235| 42.1k| PERFETTO_DCHECK(!IsSequenceClock(src_clock_id)); 236| 42.1k| PERFETTO_DCHECK(!IsSequenceClock(target_clock_id)); 237| | 238| 42.1k| context_->storage->IncrementStats(stats::clock_sync_cache_miss); 239| | 240| 42.1k| ClockPath path = FindPath(src_clock_id, target_clock_id); 241| | 242| 42.1k| if (!path.valid()) { ------------------ | Branch (242:7): [True: 18.5k, False: 23.6k] ------------------ 243| | // Too many logs maybe emitted when path is invalid. 244| 18.5k| context_->storage->IncrementStats(stats::clock_sync_failure); 245| 18.5k| return base::ErrStatus("No path from clock %" PRId64 " to %" PRId64 246| 18.5k| " at timestamp %" PRId64, 247| 18.5k| src_clock_id, target_clock_id, src_timestamp); 248| 18.5k| } 249| | 250| | // We can cache only single-path resolutions between two clocks. 251| | // Caching multi-path resolutions is harder because the (src,target) tuple 252| | // is not enough as a cache key: at any step the |ns| value can yield to a 253| | // different choice of the next snapshot. Multi-path resolutions don't seem 254| | // too frequent these days, so we focus only on caching the more frequent 255| | // one-step resolutions (typically from any clock to the trace clock). 256| 23.6k| const bool cacheable = path.len == 1; 257| 23.6k| CachedClockPath cache_entry{}; 258| | 259| | // Iterate trough the path found and translate timestamps onto the new clock 260| | // domain on each step, until the target domain is reached. 261| 23.6k| ClockDomain* src_domain = GetClock(src_clock_id); 262| 23.6k| int64_t ns = src_domain->ToNs(src_timestamp); 263| 60.8k| for (uint32_t i = 0; i < path.len; ++i) { ------------------ | Branch (263:24): [True: 37.2k, False: 23.6k] ------------------ 264| 37.2k| const ClockGraphEdge edge = path.at(i); 265| 37.2k| ClockDomain* cur_clock = GetClock(std::get<0>(edge)); 266| 37.2k| ClockDomain* next_clock = GetClock(std::get<1>(edge)); 267| 37.2k| const SnapshotHash hash = std::get<2>(edge); 268| | 269| | // Find the closest timestamp within the snapshots of the source clock. 270| 37.2k| const ClockSnapshots& cur_snap = cur_clock->GetSnapshot(hash); 271| 37.2k| const auto& ts_vec = cur_snap.timestamps_ns; 272| 37.2k| auto it = std::upper_bound(ts_vec.begin(), ts_vec.end(), ns); 273| 37.2k| if (it != ts_vec.begin()) ------------------ | Branch (273:9): [True: 37.0k, False: 261] ------------------ 274| 37.0k| --it; 275| | 276| | // Now lookup the snapshot id that matches the closest timestamp. 277| 37.2k| size_t index = static_cast(std::distance(ts_vec.begin(), it)); 278| 37.2k| PERFETTO_DCHECK(index < ts_vec.size()); 279| 37.2k| PERFETTO_DCHECK(cur_snap.snapshot_ids.size() == ts_vec.size()); 280| 37.2k| uint32_t snapshot_id = cur_snap.snapshot_ids[index]; 281| | 282| | // And use that to retrieve the corresponding time in the next clock domain. 283| | // The snapshot id must exist in the target clock domain. If it doesn't 284| | // either the hash logic or the pathfinding logic are bugged. 285| | // This can also happen if the checks in AddSnapshot fail and we skip part 286| | // of the snapshot. 287| 37.2k| const ClockSnapshots& next_snap = next_clock->GetSnapshot(hash); 288| | 289| | // Using std::lower_bound because snapshot_ids is sorted, so we can do 290| | // a binary search. std::find would do a linear scan. 291| 37.2k| auto next_it = std::lower_bound(next_snap.snapshot_ids.begin(), 292| 37.2k| next_snap.snapshot_ids.end(), snapshot_id); 293| 37.2k| if (next_it == next_snap.snapshot_ids.end() || *next_it != snapshot_id) { ------------------ | Branch (293:9): [True: 0, False: 37.2k] | Branch (293:9): [True: 0, False: 37.2k] | Branch (293:52): [True: 0, False: 37.2k] ------------------ 294| 0| PERFETTO_DFATAL("Snapshot does not exist in clock domain."); 295| 0| continue; 296| 0| } 297| 37.2k| size_t next_index = static_cast( 298| 37.2k| std::distance(next_snap.snapshot_ids.begin(), next_it)); 299| 37.2k| PERFETTO_DCHECK(next_index < next_snap.snapshot_ids.size()); 300| 37.2k| int64_t next_timestamp_ns = next_snap.timestamps_ns[next_index]; 301| | 302| | // The translated timestamp is the relative delta of the source timestamp 303| | // from the closest snapshot found (ns - *it), plus the timestamp in 304| | // the new clock domain for the same snapshot id. 305| 37.2k| const int64_t adj = next_timestamp_ns - *it; 306| 37.2k| ns += adj; 307| | 308| | // On the first iteration, keep track of the bounds for the cache entry. 309| | // This will allow future Convert() calls to skip the pathfinder logic 310| | // as long as the query stays within the bound. 311| 37.2k| if (cacheable) { ------------------ | Branch (311:9): [True: 11.5k, False: 25.7k] ------------------ 312| 11.5k| PERFETTO_DCHECK(i == 0); 313| 11.5k| const int64_t kInt64Min = std::numeric_limits::min(); 314| 11.5k| const int64_t kInt64Max = std::numeric_limits::max(); 315| 11.5k| cache_entry.min_ts_ns = it == ts_vec.begin() ? kInt64Min : *it; ------------------ | Branch (315:31): [True: 840, False: 10.7k] ------------------ 316| 11.5k| auto ubound = it + 1; 317| 11.5k| cache_entry.max_ts_ns = ubound == ts_vec.end() ? kInt64Max : *ubound; ------------------ | Branch (317:31): [True: 11.5k, False: 0] ------------------ 318| 11.5k| cache_entry.translation_ns = adj; 319| 11.5k| } 320| | 321| | // The last clock in the path must be the target clock. 322| 37.2k| PERFETTO_DCHECK(i < path.len - 1 || std::get<1>(edge) == target_clock_id); 323| 37.2k| } 324| | 325| 23.6k| if (cacheable) { ------------------ | Branch (325:7): [True: 11.5k, False: 12.0k] ------------------ 326| 11.5k| cache_entry.src = src_clock_id; 327| 11.5k| cache_entry.src_domain = src_domain; 328| 11.5k| cache_entry.target = target_clock_id; 329| 11.5k| cache_[rnd_() % cache_.size()] = cache_entry; 330| 11.5k| } 331| | 332| 23.6k| return ns; 333| 42.1k|} clock_tracker.cc:_ZZN8perfetto15trace_processor12ClockTracker23ToTraceTimeFromSnapshotERKNSt3__16vectorINS1_14ClockTimestampENS2_9allocatorIS4_EEEEENK3$_0clERKS4_: 222| 39.9k| [this](const ClockTimestamp& clock_timestamp) { 223| 39.9k| return clock_timestamp.clock.id == this->trace_time_clock_id_; 224| 39.9k| }); _ZN8perfetto15trace_processor12ClockTracker5ClockC2Ellb: 130| 60.9k| : id(clock_id), unit_multiplier_ns(unit), is_incremental(incremental) {} _ZN8perfetto15trace_processor12ClockTracker14ClockTimestampC2Elllb: 141| 60.9k| : clock(id, unit, incremental), timestamp(ts) {} _ZN8perfetto15trace_processor12ClockTracker15IsSequenceClockEl: 150| 60.9k| static bool IsSequenceClock(ClockId clock_id) { 151| 60.9k| return clock_id >= 64 && clock_id < 128; ------------------ | Branch (151:12): [True: 11.6k, False: 49.3k] | Branch (151:30): [True: 2.95k, False: 8.66k] ------------------ 152| 60.9k| } _ZN8perfetto15trace_processor12ClockTracker21SequenceToGlobalClockEjj: 156| 2.95k| static ClockId SequenceToGlobalClock(uint32_t seq_id, uint32_t clock_id) { 157| 2.95k| PERFETTO_DCHECK(IsSequenceClock(clock_id)); 158| 2.95k| return (static_cast(seq_id) << 32) | clock_id; 159| 2.95k| } _ZN8perfetto15trace_processor12ClockTracker15ToHostTraceTimeEl: 179| 25.8k| PERFETTO_ALWAYS_INLINE int64_t ToHostTraceTime(int64_t timestamp) { 180| 25.8k| if (PERFETTO_LIKELY(!context_->machine_id())) { ------------------ | | 23| 25.8k|#define PERFETTO_LIKELY(...) __builtin_expect(!!(__VA_ARGS__), 1) | | ------------------ | | | Branch (23:30): [True: 25.8k, False: 0] | | ------------------ ------------------ 181| | // No need to convert host timestamps. 182| 25.8k| return timestamp; 183| 25.8k| } 184| | 185| | // Find the offset for |trace_time_clock_id_| and apply the offset, or 186| | // default offset 0 if not offset is found for |trace_time_clock_id_|. 187| 0| int64_t clock_offset = clock_offsets_[trace_time_clock_id_]; 188| 0| return timestamp - clock_offset; 189| 25.8k| } _ZN8perfetto15trace_processor12ClockTracker11ToTraceTimeEll: 193| 44.3k| int64_t timestamp) { 194| 44.3k| if (PERFETTO_UNLIKELY(!trace_time_clock_id_used_for_conversion_)) { ------------------ | | 24| 44.3k|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 205, False: 44.1k] | | ------------------ ------------------ 195| 205| context_->metadata_tracker->SetMetadata( 196| 205| metadata::trace_time_clock_id, 197| 205| Variadic::Integer(trace_time_clock_id_)); 198| 205| trace_time_clock_id_used_for_conversion_ = true; 199| 205| } 200| 44.3k| trace_time_clock_id_used_for_conversion_ = true; 201| | 202| 44.3k| if (clock_id == trace_time_clock_id_) { ------------------ | Branch (202:9): [True: 2.18k, False: 42.1k] ------------------ 203| 2.18k| return ToHostTraceTime(timestamp); 204| 2.18k| } 205| | 206| 44.3k| ASSIGN_OR_RETURN(int64_t ts, ------------------ | | 38| 42.1k| PERFETTO_INTERNAL_MACRO_CONCAT(auto status_or, __LINE__) = rhs; \ | | ------------------ | | | | 32| 42.1k|#define PERFETTO_INTERNAL_MACRO_CONCAT(x, y) PERFETTO_INTERNAL_CONCAT_IMPL(x, y) | | | | ------------------ | | | | | | 31| 42.1k|#define PERFETTO_INTERNAL_CONCAT_IMPL(x, y) x##y | | | | ------------------ | | ------------------ | | 39| 42.1k| RETURN_IF_ERROR( \ | | ------------------ | | | | 25| 42.1k| do { \ | | | | 26| 42.1k| base::Status status_macro_internal_status = (expr); \ | | | | 27| 42.1k| if (!status_macro_internal_status.ok()) \ | | | | ------------------ | | | | | Branch (27:9): [True: 18.5k, False: 23.6k] | | | | ------------------ | | | | 28| 42.1k| return status_macro_internal_status; \ | | | | 29| 42.1k| } while (0) | | | | ------------------ | | | | | Branch (29:12): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 40| 42.1k| PERFETTO_INTERNAL_MACRO_CONCAT(status_or, __LINE__).status()); \ | | 41| 42.1k| lhs = std::move(PERFETTO_INTERNAL_MACRO_CONCAT(status_or, __LINE__).value()) | | ------------------ | | | | 32| 23.6k|#define PERFETTO_INTERNAL_MACRO_CONCAT(x, y) PERFETTO_INTERNAL_CONCAT_IMPL(x, y) | | | | ------------------ | | | | | | 31| 23.6k|#define PERFETTO_INTERNAL_CONCAT_IMPL(x, y) x##y | | | | ------------------ | | ------------------ ------------------ 207| 23.6k| Convert(clock_id, timestamp, trace_time_clock_id_)); 208| 23.6k| return ToHostTraceTime(ts); 209| 42.1k| } _ZN8perfetto15trace_processor12ClockTracker17SetTraceTimeClockEl: 216| 7.31k| void SetTraceTimeClock(ClockId clock_id) { 217| 7.31k| PERFETTO_DCHECK(!IsSequenceClock(clock_id)); 218| 7.31k| if (trace_time_clock_id_used_for_conversion_ && ------------------ | Branch (218:9): [True: 7.24k, False: 70] ------------------ 219| 7.31k| trace_time_clock_id_ != clock_id) { ------------------ | Branch (219:9): [True: 6.11k, False: 1.13k] ------------------ 220| 6.11k| PERFETTO_ELOG("Not updating trace time clock from %" PRId64 " to %" PRId64 221| 6.11k| " because the old clock was already used for timestamp " 222| 6.11k| "conversion - ClockSnapshot too late in trace?", 223| 6.11k| trace_time_clock_id_, clock_id); 224| 6.11k| return; 225| 6.11k| } 226| 1.20k| trace_time_clock_id_ = clock_id; 227| 1.20k| context_->metadata_tracker->SetMetadata( 228| 1.20k| metadata::trace_time_clock_id, Variadic::Integer(trace_time_clock_id_)); 229| 1.20k| } _ZN8perfetto15trace_processor12ClockTracker18HasPathToTraceTimeEl: 231| 2| bool HasPathToTraceTime(ClockId clock_id) { 232| 2| if (clock_id == trace_time_clock_id_) { ------------------ | Branch (232:9): [True: 0, False: 2] ------------------ 233| 0| return true; 234| 0| } 235| 2| return FindPath(clock_id, trace_time_clock_id_).valid(); 236| 2| } _ZN8perfetto15trace_processor12ClockTracker9ClockPathC2El: 263| 26.1k| explicit ClockPath(ClockId clock_id) : last(clock_id) {} _ZN8perfetto15trace_processor12ClockTracker9ClockPathC2ERKS2_lj: 267| 65.7M| ClockPath(const ClockPath& prefix, ClockId clock_id, SnapshotHash hash) { 268| 65.7M| PERFETTO_DCHECK(prefix.len < kMaxLen); 269| 65.7M| len = prefix.len + 1; 270| 65.7M| path = prefix.path; 271| 65.7M| path[prefix.len] = ClockGraphEdge{prefix.last, clock_id, hash}; 272| 65.7M| last = clock_id; 273| 65.7M| } _ZNK8perfetto15trace_processor12ClockTracker9ClockPath5validEv: 275| 42.1k| bool valid() const { return len > 0; } _ZNK8perfetto15trace_processor12ClockTracker9ClockPath2atEj: 276| 37.2k| const ClockGraphEdge& at(uint32_t i) const { 277| 37.2k| PERFETTO_DCHECK(i < len); 278| 37.2k| return path[i]; 279| 37.2k| } _ZN8perfetto15trace_processor12ClockTracker11ClockDomain4ToNsEl: 309| 23.6k| int64_t ToNs(int64_t timestamp) { 310| 23.6k| if (!is_incremental) ------------------ | Branch (310:11): [True: 23.0k, False: 574] ------------------ 311| 23.0k| return timestamp * unit_multiplier_ns; 312| | 313| 574| int64_t delta_ns = timestamp * unit_multiplier_ns; 314| 574| last_timestamp_ns += delta_ns; 315| 574| return last_timestamp_ns; 316| 23.6k| } _ZNK8perfetto15trace_processor12ClockTracker11ClockDomain11GetSnapshotEj: 318| 74.5k| const ClockSnapshots& GetSnapshot(uint32_t hash) const { 319| 74.5k| auto it = snapshots.find(hash); 320| 74.5k| PERFETTO_DCHECK(it != snapshots.end()); 321| 74.5k| return it->second; 322| 74.5k| } _ZN8perfetto15trace_processor12ClockTracker7ConvertElll: 348| 42.1k| ClockId target_clock_id) { 349| 42.1k| if (PERFETTO_LIKELY(!cache_lookups_disabled_for_testing_)) { ------------------ | | 23| 42.1k|#define PERFETTO_LIKELY(...) __builtin_expect(!!(__VA_ARGS__), 1) | | ------------------ | | | Branch (23:30): [True: 42.1k, False: 0] | | ------------------ ------------------ 350| 84.3k| for (const auto& cached_clock_path : cache_) { ------------------ | Branch (350:42): [True: 84.3k, False: 42.1k] ------------------ 351| 84.3k| if (cached_clock_path.src != src_clock_id || ------------------ | Branch (351:13): [True: 67.1k, False: 17.2k] ------------------ 352| 84.3k| cached_clock_path.target != target_clock_id) ------------------ | Branch (352:13): [True: 17.2k, False: 5] ------------------ 353| 84.3k| continue; 354| 5| int64_t ns = cached_clock_path.src_domain->ToNs(src_timestamp); 355| 5| if (ns >= cached_clock_path.min_ts_ns && ------------------ | Branch (355:13): [True: 5, False: 0] ------------------ 356| 5| ns < cached_clock_path.max_ts_ns) ------------------ | Branch (356:13): [True: 5, False: 0] ------------------ 357| 5| return ns + cached_clock_path.translation_ns; 358| 5| } 359| 42.1k| } 360| 42.1k| return ConvertSlowpath(src_clock_id, src_timestamp, target_clock_id); 361| 42.1k| } _ZN8perfetto15trace_processor12ClockTracker24IsConvertedSequenceClockEl: 365| 1.93k| static bool IsConvertedSequenceClock(ClockId global_clock_id) { 366| | // If the id is > 2**32, this is a sequence-scoped clock id translated into 367| | // the global namespace. 368| 1.93k| return (global_clock_id >> 32) > 0; 369| 1.93k| } _ZN8perfetto15trace_processor12ClockTracker8GetClockEl: 373| 98.1k| ClockDomain* GetClock(ClockId clock_id) { 374| 98.1k| auto it = clocks_.find(clock_id); 375| 98.1k| PERFETTO_DCHECK(it != clocks_.end()); 376| 98.1k| return &it->second; 377| 98.1k| } _ZN8perfetto15trace_processor12ClockTracker9ClockPathC2Ev: 259| 18.5k| ClockPath() = default; _ZN8perfetto15trace_processor10CpuTrackerC2EPNS0_21TraceProcessorContextE: 29| 2.03k|CpuTracker::CpuTracker(TraceProcessorContext* context) : context_(context) { 30| | // Preallocate ucpu of this machine for maintaining the relative order between 31| | // ucpu and cpu. 32| 2.03k| auto machine_id = context_->machine_tracker->machine_id(); 33| 2.03k| if (machine_id.has_value()) ------------------ | Branch (33:7): [True: 1.60k, False: 434] ------------------ 34| 1.60k| ucpu_offset_ = machine_id->value * kMaxCpusPerMachine; 35| | 36| 8.34M| for (auto id = 0u; id < kMaxCpusPerMachine; id++) { ------------------ | Branch (36:22): [True: 8.34M, False: 2.03k] ------------------ 37| | // Only populate the |machine_id| column. The |cpu| column is update only 38| | // when the CPU is present. 39| 8.34M| tables::CpuTable::Row cpu_row; 40| 8.34M| cpu_row.machine_id = machine_id; 41| 8.34M| context_->storage->mutable_cpu_table()->Insert(cpu_row); 42| 8.34M| } 43| 2.03k|} _ZN8perfetto15trace_processor12EventTrackerC2EPNS0_21TraceProcessorContextE: 33| 2.03k| : context_(context) {} _ZN8perfetto15trace_processor12EventTrackerD2Ev: 35| 2.03k|EventTracker::~EventTracker() = default; _ZN8perfetto15trace_processor12EventTracker11PushCounterEldNS0_6tables10TrackTable2IdE: 54| 279k| TrackId track_id) { 55| 279k| auto* counters = context_->storage->mutable_counter_table(); 56| 279k| return counters->Insert({timestamp, track_id, value, {}}).id; 57| 279k|} _ZN8perfetto15trace_processor12EventTracker18FlushPendingEventsEv: 72| 345|void EventTracker::FlushPendingEvents() { 73| 345| const auto& thread_table = context_->storage->thread_table(); 74| 345| for (const auto& pending_counter : pending_upid_resolution_counter_) { ------------------ | Branch (74:36): [True: 0, False: 345] ------------------ 75| 0| UniqueTid utid = pending_counter.utid; 76| 0| std::optional upid = thread_table[utid].upid(); 77| | 78| | // If we still don't know which process this thread belongs to, fall back 79| | // onto creating a thread counter track. It's too late to drop data 80| | // because the counter values have already been inserted. 81| 0| TrackId track_id; 82| 0| switch (pending_counter.counter.index()) { ------------------ | Branch (82:13): [True: 0, False: 0] ------------------ 83| 0| case base::variant_index(): ------------------ | Branch (83:7): [True: 0, False: 0] ------------------ 84| 0| if (upid.has_value()) { ------------------ | Branch (84:13): [True: 0, False: 0] ------------------ 85| 0| track_id = context_->track_tracker->InternTrack( 86| 0| tracks::kOomScoreAdjBlueprint, tracks::Dimensions(*upid)); 87| 0| } else { 88| 0| track_id = context_->track_tracker->InternTrack( 89| 0| tracks::kOomScoreAdjThreadFallbackBlueprint, 90| 0| tracks::Dimensions(utid)); 91| 0| } 92| 0| break; 93| 0| case base::variant_index(): { ------------------ | Branch (93:7): [True: 0, False: 0] ------------------ 94| 0| const auto& mm_event = std::get(pending_counter.counter); 95| 0| if (upid.has_value()) { ------------------ | Branch (95:13): [True: 0, False: 0] ------------------ 96| 0| track_id = context_->track_tracker->InternTrack( 97| 0| tracks::kMmEventBlueprint, 98| 0| tracks::Dimensions(*upid, mm_event.type, mm_event.metric)); 99| 0| } else { 100| 0| track_id = context_->track_tracker->InternTrack( 101| 0| tracks::kMmEventThreadFallbackBlueprint, 102| 0| tracks::Dimensions(utid, mm_event.type, mm_event.metric)); 103| 0| } 104| 0| break; 105| 0| } 106| 0| case base::variant_index(): { ------------------ | Branch (106:7): [True: 0, False: 0] ------------------ 107| 0| const auto& rss_stat = std::get(pending_counter.counter); 108| 0| if (upid.has_value()) { ------------------ | Branch (108:13): [True: 0, False: 0] ------------------ 109| 0| track_id = context_->track_tracker->InternTrack( 110| 0| tracks::kProcessMemoryBlueprint, 111| 0| tracks::Dimensions(*upid, rss_stat.process_memory_key)); 112| 0| } else { 113| 0| track_id = context_->track_tracker->InternTrack( 114| 0| tracks::kProcessMemoryThreadFallbackBlueprint, 115| 0| tracks::Dimensions(utid, rss_stat.process_memory_key)); 116| 0| } 117| 0| break; 118| 0| } 119| 0| case base::variant_index(): { ------------------ | Branch (119:7): [True: 0, False: 0] ------------------ 120| 0| const auto& json = std::get(pending_counter.counter); 121| 0| if (upid.has_value()) { ------------------ | Branch (121:13): [True: 0, False: 0] ------------------ 122| 0| track_id = context_->track_tracker->InternTrack( 123| 0| tracks::kJsonCounterBlueprint, 124| 0| tracks::Dimensions( 125| 0| *upid, context_->storage->GetString(json.counter_name_id)), 126| 0| tracks::DynamicName(json.counter_name_id)); 127| 0| } else { 128| 0| track_id = context_->track_tracker->InternTrack( 129| 0| tracks::kJsonCounterThreadFallbackBlueprint, 130| 0| tracks::Dimensions( 131| 0| utid, context_->storage->GetString(json.counter_name_id)), 132| 0| tracks::DynamicName(json.counter_name_id)); 133| 0| } 134| 0| break; 135| 0| } 136| 0| } 137| 0| auto& counter = *context_->storage->mutable_counter_table(); 138| 0| counter[pending_counter.row].set_track_id(track_id); 139| 0| } 140| 345| pending_upid_resolution_counter_.clear(); 141| 345|} _ZN8perfetto15trace_processor11FlowTrackerC2EPNS0_21TraceProcessorContextE: 30| 2.03k|FlowTracker::FlowTracker(TraceProcessorContext* context) : context_(context) { 31| 2.03k| name_key_id_ = context_->storage->InternString("name"); 32| 2.03k| cat_key_id_ = context_->storage->InternString("cat"); 33| 2.03k|} _ZN8perfetto15trace_processor11FlowTrackerD2Ev: 35| 2.03k|FlowTracker::~FlowTracker() = default; _ZN8perfetto15trace_processor11FlowTracker5BeginENS0_6tables10TrackTable2IdEm: 43| 52.8k|void FlowTracker::Begin(TrackId track_id, FlowId flow_id) { 44| 52.8k| std::optional open_slice_id = 45| 52.8k| context_->slice_tracker->GetTopmostSliceOnTrack(track_id); 46| 52.8k| if (!open_slice_id) { ------------------ | Branch (46:7): [True: 6.21k, False: 46.6k] ------------------ 47| 6.21k| context_->storage->IncrementStats(stats::flow_no_enclosing_slice); 48| 6.21k| return; 49| 6.21k| } 50| 46.6k| Begin(open_slice_id.value(), flow_id); 51| 46.6k|} _ZN8perfetto15trace_processor11FlowTracker5BeginENS0_6tables10SliceTable2IdEm: 53| 46.6k|void FlowTracker::Begin(SliceId slice_id, FlowId flow_id) { 54| 46.6k| auto it_and_ins = flow_to_slice_map_.Insert(flow_id, slice_id); 55| 46.6k| if (!it_and_ins.second) { ------------------ | Branch (55:7): [True: 33.9k, False: 12.6k] ------------------ 56| 33.9k| context_->storage->IncrementStats(stats::flow_duplicate_id); 57| 33.9k| return; 58| 33.9k| } 59| 46.6k|} _ZN8perfetto15trace_processor11FlowTracker4StepENS0_6tables10SliceTable2IdEm: 71| 8|void FlowTracker::Step(SliceId slice_id, FlowId flow_id) { 72| 8| auto* it = flow_to_slice_map_.Find(flow_id); 73| 8| if (!it) { ------------------ | Branch (73:7): [True: 0, False: 8] ------------------ 74| 0| context_->storage->IncrementStats(stats::flow_step_without_start); 75| 0| return; 76| 0| } 77| 8| SliceId slice_out_id = *it; 78| 8| InsertFlow(flow_id, slice_out_id, slice_id); 79| 8| *it = slice_id; 80| 8|} _ZN8perfetto15trace_processor11FlowTracker3EndENS0_6tables10TrackTable2IdEmbb: 85| 1.45k| bool close_flow) { 86| 1.45k| if (!bind_enclosing_slice) { ------------------ | Branch (86:7): [True: 137, False: 1.31k] ------------------ 87| 137| pending_flow_ids_map_[track_id].push_back(flow_id); 88| 137| return; 89| 137| } 90| 1.31k| std::optional open_slice_id = 91| 1.31k| context_->slice_tracker->GetTopmostSliceOnTrack(track_id); 92| 1.31k| if (!open_slice_id) { ------------------ | Branch (92:7): [True: 60, False: 1.25k] ------------------ 93| 60| context_->storage->IncrementStats(stats::flow_no_enclosing_slice); 94| 60| return; 95| 60| } 96| 1.25k| End(open_slice_id.value(), flow_id, close_flow); 97| 1.25k|} _ZN8perfetto15trace_processor11FlowTracker3EndENS0_6tables10SliceTable2IdEmb: 99| 1.25k|void FlowTracker::End(SliceId slice_id, FlowId flow_id, bool close_flow) { 100| 1.25k| auto* it = flow_to_slice_map_.Find(flow_id); 101| 1.25k| if (!it) { ------------------ | Branch (101:7): [True: 0, False: 1.25k] ------------------ 102| 0| context_->storage->IncrementStats(stats::flow_end_without_start); 103| 0| return; 104| 0| } 105| 1.25k| SliceId slice_out_id = *it; 106| 1.25k| if (close_flow) ------------------ | Branch (106:7): [True: 1, False: 1.25k] ------------------ 107| 1| flow_to_slice_map_.Erase(flow_id); 108| 1.25k| InsertFlow(flow_id, slice_out_id, slice_id); 109| 1.25k|} _ZNK8perfetto15trace_processor11FlowTracker8IsActiveEm: 111| 8.60k|bool FlowTracker::IsActive(FlowId flow_id) const { 112| 8.60k| return flow_to_slice_map_.Find(flow_id) != nullptr; 113| 8.60k|} _ZN8perfetto15trace_processor11FlowTracker19GetFlowIdForV1EventEmNS0_10StringPool2IdES3_: 117| 54.3k| StringId name) { 118| 54.3k| V1FlowId v1_flow_id = {source_id, cat, name}; 119| 54.3k| auto* iter = v1_flow_id_to_flow_id_map_.Find(v1_flow_id); 120| 54.3k| if (iter) ------------------ | Branch (120:7): [True: 40.6k, False: 13.6k] ------------------ 121| 40.6k| return *iter; 122| 13.6k| FlowId new_id = v1_id_counter_++; 123| 13.6k| flow_id_to_v1_flow_id_map_[new_id] = v1_flow_id; 124| 13.6k| v1_flow_id_to_flow_id_map_[v1_flow_id] = new_id; 125| 13.6k| return new_id; 126| 54.3k|} _ZN8perfetto15trace_processor11FlowTracker25ClosePendingEventsOnTrackENS0_6tables10TrackTable2IdENS2_10SliceTable2IdE: 129| 731k| SliceId slice_id) { 130| 731k| auto* iter = pending_flow_ids_map_.Find(track_id); 131| 731k| if (!iter) ------------------ | Branch (131:7): [True: 731k, False: 124] ------------------ 132| 731k| return; 133| | 134| 135| for (FlowId flow_id : *iter) { ------------------ | Branch (134:23): [True: 135, False: 124] ------------------ 135| 135| SliceId slice_out_id = flow_to_slice_map_[flow_id]; 136| 135| InsertFlow(flow_id, slice_out_id, slice_id); 137| 135| } 138| | 139| 124| pending_flow_ids_map_.Erase(track_id); 140| 124|} _ZN8perfetto15trace_processor11FlowTracker10InsertFlowEmNS0_6tables10SliceTable2IdES4_: 144| 1.40k| SliceId slice_in_id) { 145| 1.40k| tables::FlowTable::Row row(slice_out_id, slice_in_id, flow_id, std::nullopt); 146| 1.40k| auto id = context_->storage->mutable_flow_table()->Insert(row).id; 147| | 148| 1.40k| auto* it = flow_id_to_v1_flow_id_map_.Find(flow_id); 149| 1.40k| if (it) { ------------------ | Branch (149:7): [True: 1.39k, False: 9] ------------------ 150| | // TODO(b/168007725): Add any args from v1 flow events and also export them. 151| 1.39k| auto inserter = context_->args_tracker->AddArgsTo(id); 152| 1.39k| inserter.AddArg(name_key_id_, Variadic::String(it->name)); 153| 1.39k| inserter.AddArg(cat_key_id_, Variadic::String(it->cat)); 154| 1.39k| context_->args_tracker->Flush(); 155| 1.39k| } 156| 1.40k|} _ZNK8perfetto15trace_processor11FlowTracker8V1FlowIdeqERKS2_: 76| 40.7k| bool operator==(const V1FlowId& o) const { 77| 40.7k| return o.source_id == source_id && o.cat == cat && o.name == name; ------------------ | Branch (77:14): [True: 40.6k, False: 78] | Branch (77:42): [True: 40.6k, False: 0] | Branch (77:58): [True: 40.6k, False: 0] ------------------ 78| 40.7k| } _ZNK8perfetto15trace_processor11FlowTracker14V1FlowIdHasherclERKNS1_8V1FlowIdE: 82| 74.9k| size_t operator()(const V1FlowId& c) const { 83| 74.9k| return std::hash{}( 84| 74.9k| base::Hasher::Combine(c.source_id, c.cat.raw_id(), c.name.raw_id())); 85| 74.9k| } _ZN8perfetto15trace_processor17GlobalArgsTrackerC2EPNS0_12TraceStorageE: 23| 2.03k| : storage_(storage) {} _ZNK8perfetto15trace_processor17GlobalArgsTracker3Arg12ToCompactArgEv: 61| 8.24M| CompactArg ToCompactArg() const { return CompactArg(*this); } _ZNK8perfetto15trace_processor17GlobalArgsTracker9ArgHasherclERKNS1_10CompactArgE: 67| 7.69M| uint64_t operator()(const CompactArg& arg) const noexcept { 68| 7.69M| base::Hasher hash; 69| 7.69M| hash.Update(arg.key.raw_id()); 70| | // We don't hash arg.flat_key because it's a subsequence of arg.key. 71| 7.69M| switch (arg.value.type) { ------------------ | Branch (71:15): [True: 0, False: 7.69M] ------------------ 72| 999k| case Variadic::Type::kInt: ------------------ | Branch (72:9): [True: 999k, False: 6.69M] ------------------ 73| 999k| hash.Update(arg.value.int_value); 74| 999k| break; 75| 722k| case Variadic::Type::kUint: ------------------ | Branch (75:9): [True: 722k, False: 6.97M] ------------------ 76| 722k| hash.Update(arg.value.uint_value); 77| 722k| break; 78| 5.80M| case Variadic::Type::kString: ------------------ | Branch (78:9): [True: 5.80M, False: 1.89M] ------------------ 79| 5.80M| hash.Update(arg.value.string_value.raw_id()); 80| 5.80M| break; 81| 457| case Variadic::Type::kReal: ------------------ | Branch (81:9): [True: 457, False: 7.69M] ------------------ 82| 457| hash.Update(arg.value.real_value); 83| 457| break; 84| 4.04k| case Variadic::Type::kPointer: ------------------ | Branch (84:9): [True: 4.04k, False: 7.69M] ------------------ 85| 4.04k| hash.Update(arg.value.pointer_value); 86| 4.04k| break; 87| 151k| case Variadic::Type::kBool: ------------------ | Branch (87:9): [True: 151k, False: 7.54M] ------------------ 88| 151k| hash.Update(arg.value.bool_value); 89| 151k| break; 90| 11.6k| case Variadic::Type::kJson: ------------------ | Branch (90:9): [True: 11.6k, False: 7.68M] ------------------ 91| 11.6k| hash.Update(arg.value.json_value.raw_id()); 92| 11.6k| break; 93| 7.35k| case Variadic::Type::kNull: ------------------ | Branch (93:9): [True: 7.35k, False: 7.69M] ------------------ 94| 7.35k| hash.Update(0); 95| 7.35k| break; 96| 7.69M| } 97| 7.69M| return hash.digest(); 98| 7.69M| } _ZN8perfetto15trace_processor17GlobalArgsTracker9AddArgSetEPNS1_3ArgEjj: 108| 2.50M| ArgSetId AddArgSet(Arg* args, uint32_t begin, uint32_t end) { 109| 2.50M| return AddArgSet(args + begin, args + end, sizeof(Arg)); 110| 2.50M| } _ZN8perfetto15trace_processor17GlobalArgsTracker9AddArgSetEPNS1_10CompactArgEjj: 111| 267k| ArgSetId AddArgSet(CompactArg* args, uint32_t begin, uint32_t end) { 112| 267k| return AddArgSet(args + begin, args + end, sizeof(CompactArg)); 113| 267k| } _ZN8perfetto15trace_processor17GlobalArgsTracker9AddArgSetEPKvS3_j: 120| 2.77M| ArgSetId AddArgSet(const void* start, const void* end, uint32_t stride) { 121| 2.77M| base::SmallVector valid; 122| | 123| | // TODO(eseckler): Also detect "invalid" key combinations in args sets (e.g. 124| | // "foo" and "foo.bar" in the same arg set)? 125| 18.0M| for (const void* ptr = start; ptr != end; ------------------ | Branch (125:35): [True: 15.3M, False: 2.77M] ------------------ 126| 15.3M| ptr = reinterpret_cast(ptr) + stride) { 127| 15.3M| const auto& arg = *reinterpret_cast(ptr); 128| 15.3M| if (!valid.empty() && valid.back()->key == arg.key) { ------------------ | Branch (128:11): [True: 12.5M, False: 2.77M] | Branch (128:29): [True: 7.60M, False: 4.92M] ------------------ 129| | // Last arg had the same key as this one. In case of kSkipIfExists, skip 130| | // this arg. In case of kAddOrUpdate, remove the last arg and add this 131| | // arg instead. 132| 7.60M| if (arg.update_policy == UpdatePolicy::kSkipIfExists) { ------------------ | Branch (132:13): [True: 0, False: 7.60M] ------------------ 133| 0| continue; 134| 0| } 135| 7.60M| PERFETTO_DCHECK(arg.update_policy == UpdatePolicy::kAddOrUpdate); 136| 7.60M| valid.pop_back(); 137| 7.60M| } 138| 15.3M| valid.emplace_back(&arg); 139| 15.3M| } 140| | 141| 2.77M| base::Hasher hash; 142| 7.69M| for (const auto* it : valid) { ------------------ | Branch (142:25): [True: 7.69M, False: 2.77M] ------------------ 143| 7.69M| hash.Update(ArgHasher()(*it)); 144| 7.69M| } 145| | 146| 2.77M| auto& arg_table = *storage_->mutable_arg_table(); 147| | 148| 2.77M| uint32_t arg_set_id = arg_table.row_count(); 149| 2.77M| ArgSetHash digest = hash.digest(); 150| 2.77M| auto [it, inserted] = arg_row_for_hash_.Insert(digest, arg_set_id); 151| 2.77M| if (!inserted) { ------------------ | Branch (151:9): [True: 1.73M, False: 1.03M] ------------------ 152| | // Already inserted. 153| 1.73M| return *it; 154| 1.73M| } 155| | 156| 2.16M| for (const CompactArg* ptr : valid) { ------------------ | Branch (156:32): [True: 2.16M, False: 1.03M] ------------------ 157| 2.16M| const auto& arg = *ptr; 158| 2.16M| tables::ArgTable::Row row; 159| 2.16M| row.arg_set_id = arg_set_id; 160| 2.16M| row.flat_key = arg.flat_key; 161| 2.16M| row.key = arg.key; 162| 2.16M| switch (arg.value.type) { ------------------ | Branch (162:15): [True: 0, False: 2.16M] ------------------ 163| 961k| case Variadic::Type::kInt: ------------------ | Branch (163:9): [True: 961k, False: 1.20M] ------------------ 164| 961k| row.int_value = arg.value.int_value; 165| 961k| break; 166| 717k| case Variadic::Type::kUint: ------------------ | Branch (166:9): [True: 717k, False: 1.45M] ------------------ 167| 717k| row.int_value = static_cast(arg.value.uint_value); 168| 717k| break; 169| 337k| case Variadic::Type::kString: ------------------ | Branch (169:9): [True: 337k, False: 1.82M] ------------------ 170| 337k| row.string_value = arg.value.string_value; 171| 337k| break; 172| 43| case Variadic::Type::kReal: ------------------ | Branch (172:9): [True: 43, False: 2.16M] ------------------ 173| 43| row.real_value = arg.value.real_value; 174| 43| break; 175| 178| case Variadic::Type::kPointer: ------------------ | Branch (175:9): [True: 178, False: 2.16M] ------------------ 176| 178| row.int_value = static_cast(arg.value.pointer_value); 177| 178| break; 178| 151k| case Variadic::Type::kBool: ------------------ | Branch (178:9): [True: 151k, False: 2.01M] ------------------ 179| 151k| row.int_value = arg.value.bool_value; 180| 151k| break; 181| 184| case Variadic::Type::kJson: ------------------ | Branch (181:9): [True: 184, False: 2.16M] ------------------ 182| 184| row.string_value = arg.value.json_value; 183| 184| break; 184| 204| case Variadic::Type::kNull: ------------------ | Branch (184:9): [True: 204, False: 2.16M] ------------------ 185| 204| break; 186| 2.16M| } 187| 2.16M| row.value_type = storage_->GetIdForVariadicType(arg.value.type); 188| 2.16M| arg_table.Insert(row); 189| 2.16M| } 190| 1.03M| return arg_set_id; 191| 1.03M| } _ZN8perfetto15trace_processor25LegacyV8CpuProfileTrackerC2EPNS0_21TraceProcessorContextE: 38| 2.03k| : context_(context) {} _ZN8perfetto15trace_processor14MachineTrackerC2EPNS0_21TraceProcessorContextEj: 24| 2.03k| : context_(context) { 25| 2.03k| auto id = 26| 2.03k| context_->storage->mutable_machine_table()->Insert({raw_machine_id}).id; 27| | 28| 2.03k| if (raw_machine_id) ------------------ | Branch (28:7): [True: 1.60k, False: 434] ------------------ 29| 1.60k| machine_id_ = id; 30| 2.03k|} _ZN8perfetto15trace_processor14MachineTrackerD2Ev: 31| 2.03k|MachineTracker::~MachineTracker() = default; _ZNK8perfetto15trace_processor14MachineTracker10machine_idEv: 32| 5.29M| std::optional machine_id() const { return machine_id_; } _ZN8perfetto15trace_processor14MappingTrackerC2EPNS0_21TraceProcessorContextE: 60| 2.03k| explicit MappingTracker(TraceProcessorContext* context) : context_(context) {} _ZN8perfetto15trace_processor15MetadataTrackerC2EPNS0_12TraceStorageE: 37| 2.03k|MetadataTracker::MetadataTracker(TraceStorage* storage) : storage_(storage) { 38| 85.5k| for (uint32_t i = 0; i < kNumKeys; ++i) { ------------------ | Branch (38:24): [True: 83.5k, False: 2.03k] ------------------ 39| 83.5k| key_ids_[i] = storage->InternString(metadata::kNames[i]); 40| 83.5k| } 41| 6.11k| for (uint32_t i = 0; i < kNumKeyTypes; ++i) { ------------------ | Branch (41:24): [True: 4.07k, False: 2.03k] ------------------ 42| 4.07k| key_type_ids_[i] = storage->InternString(metadata::kKeyTypeNames[i]); 43| 4.07k| } 44| 2.03k|} _ZN8perfetto15trace_processor15MetadataTracker11SetMetadataENS0_8metadata5KeyIdENS0_8VariadicE: 46| 71.8k|MetadataId MetadataTracker::SetMetadata(metadata::KeyId key, Variadic value) { 47| 71.8k| PERFETTO_DCHECK(metadata::kKeyTypes[key] == metadata::KeyType::kSingle); 48| 71.8k| PERFETTO_DCHECK(value.type == metadata::kValueTypes[key]); 49| | 50| | // When the trace_uuid is set, store a copy in a crash key, so in case of 51| | // a crash in the pipelines we can tell which trace caused the crash. 52| 71.8k| if (key == metadata::trace_uuid && value.type == Variadic::kString) { ------------------ | Branch (52:7): [True: 434, False: 71.3k] | Branch (52:38): [True: 434, False: 0] ------------------ 53| 434| auto uuid_string_view = storage_->GetString(value.string_value); 54| 434| g_crash_key_uuid.Set(uuid_string_view); 55| 434| } 56| | 57| 71.8k| auto& metadata_table = *storage_->mutable_metadata_table(); 58| 71.8k| auto key_idx = static_cast(key); 59| 71.8k| auto name_id = storage_->string_pool().GetId(metadata::kNames[key_idx]); 60| 71.8k| if (name_id) { ------------------ | Branch (60:7): [True: 71.8k, False: 0] ------------------ 61| 446k| for (auto it = metadata_table.IterateRows(); it; ++it) { ------------------ | Branch (61:50): [True: 444k, False: 1.84k] ------------------ 62| 444k| if (it.name() == *name_id) { ------------------ | Branch (62:11): [True: 69.9k, False: 374k] ------------------ 63| 69.9k| WriteValue(it.row_number().row_number(), value); 64| 69.9k| return it.id(); 65| 69.9k| } 66| 444k| } 67| 71.8k| } 68| | 69| 1.84k| tables::MetadataTable::Row row; 70| 1.84k| row.name = key_ids_[key_idx]; 71| 1.84k| row.key_type = key_type_ids_[static_cast(metadata::KeyType::kSingle)]; 72| | 73| 1.84k| auto id_and_row = metadata_table.Insert(row); 74| 1.84k| WriteValue(id_and_row.row, value); 75| 1.84k| return id_and_row.id; 76| 71.8k|} _ZN8perfetto15trace_processor15MetadataTracker14AppendMetadataENS0_8metadata5KeyIdENS0_8VariadicE: 121| 38.5k| Variadic value) { 122| 38.5k| PERFETTO_DCHECK(key < metadata::kNumKeys); 123| 38.5k| PERFETTO_DCHECK(metadata::kKeyTypes[key] == metadata::KeyType::kMulti); 124| 38.5k| PERFETTO_DCHECK(value.type == metadata::kValueTypes[key]); 125| | 126| 38.5k| uint32_t key_idx = static_cast(key); 127| 38.5k| tables::MetadataTable::Row row; 128| 38.5k| row.name = key_ids_[key_idx]; 129| 38.5k| row.key_type = key_type_ids_[static_cast(metadata::KeyType::kMulti)]; 130| | 131| 38.5k| auto* metadata_table = storage_->mutable_metadata_table(); 132| 38.5k| auto id_and_row = metadata_table->Insert(row); 133| 38.5k| WriteValue(id_and_row.row, value); 134| 38.5k| return id_and_row.id; 135| 38.5k|} _ZN8perfetto15trace_processor15MetadataTracker18SetDynamicMetadataENS0_10StringPool2IdENS0_8VariadicE: 137| 26.5k|MetadataId MetadataTracker::SetDynamicMetadata(StringId key, Variadic value) { 138| 26.5k| tables::MetadataTable::Row row; 139| 26.5k| row.name = key; 140| 26.5k| row.key_type = key_type_ids_[static_cast(metadata::KeyType::kSingle)]; 141| | 142| 26.5k| auto* metadata_table = storage_->mutable_metadata_table(); 143| 26.5k| auto id_and_row = metadata_table->Insert(row); 144| 26.5k| WriteValue(id_and_row.row, value); 145| 26.5k| return id_and_row.id; 146| 26.5k|} _ZN8perfetto15trace_processor15MetadataTracker10WriteValueEjNS0_8VariadicE: 148| 136k|void MetadataTracker::WriteValue(uint32_t row, Variadic value) { 149| 136k| auto& metadata_table = *storage_->mutable_metadata_table(); 150| 136k| auto rr = metadata_table[row]; 151| 136k| switch (value.type) { ------------------ | Branch (151:11): [True: 0, False: 136k] ------------------ 152| 112k| case Variadic::Type::kInt: ------------------ | Branch (152:5): [True: 112k, False: 24.6k] ------------------ 153| 112k| rr.set_int_value(value.int_value); 154| 112k| break; 155| 12.9k| case Variadic::Type::kString: ------------------ | Branch (155:5): [True: 12.9k, False: 123k] ------------------ 156| 12.9k| rr.set_str_value(value.string_value); 157| 12.9k| break; 158| 11.6k| case Variadic::Type::kJson: ------------------ | Branch (158:5): [True: 11.6k, False: 125k] ------------------ 159| 11.6k| rr.set_str_value(value.json_value); 160| 11.6k| break; 161| 0| case Variadic::Type::kBool: ------------------ | Branch (161:5): [True: 0, False: 136k] ------------------ 162| 0| case Variadic::Type::kPointer: ------------------ | Branch (162:5): [True: 0, False: 136k] ------------------ 163| 0| case Variadic::Type::kUint: ------------------ | Branch (163:5): [True: 0, False: 136k] ------------------ 164| 0| case Variadic::Type::kReal: ------------------ | Branch (164:5): [True: 0, False: 136k] ------------------ 165| 0| case Variadic::Type::kNull: ------------------ | Branch (165:5): [True: 0, False: 136k] ------------------ 166| 0| PERFETTO_FATAL("Unsupported value type"); 167| 136k| } 168| 136k|} _ZN8perfetto15trace_processor15MetadataTracker34IncrementChromeMetadataBundleCountEv: 57| 31.2k| uint32_t IncrementChromeMetadataBundleCount() { 58| 31.2k| return ++chrome_metadata_bundle_count_; 59| 31.2k| } _ZN8perfetto15trace_processor14TrackEventDataC2ENS0_13TraceBlobViewENS0_6RefPtrINS0_29PacketSequenceStateGenerationEEE: 82| 4.71M| : trace_packet_data{std::move(pv), std::move(generation)} {} _ZN8perfetto15trace_processor14TrackEventDataC2ENS0_15TracePacketDataE: 85| 2.75M| : trace_packet_data(std::move(tpd)) {} _ZNK8perfetto15trace_processor14TrackEventData23CountExtraCounterValuesEv: 89| 3.71M| uint8_t CountExtraCounterValues() const { 90| 3.71M| for (uint8_t i = 0; i < TrackEventData::kMaxNumExtraCounters; ++i) { ------------------ | Branch (90:25): [True: 3.71M, False: 0] ------------------ 91| 3.71M| if (std::equal_to()(extra_counter_values[i], 0)) ------------------ | Branch (91:11): [True: 3.71M, False: 0] ------------------ 92| 3.71M| return i; 93| 3.71M| } 94| 0| return TrackEventData::kMaxNumExtraCounters; 95| 3.71M| } _ZN8perfetto15trace_processor28ProcessTrackTranslationTableC2EPNS0_12TraceStorageE: 23| 2.03k| : storage_(storage) {} _ZNK8perfetto15trace_processor28ProcessTrackTranslationTable13TranslateNameENS0_10StringPool2IdE: 36| 199k| StringId TranslateName(StringId raw_name) const { 37| 199k| const auto* mapped_name = raw_to_deobfuscated_name_.Find(raw_name); 38| 199k| return mapped_name ? *mapped_name : raw_name; ------------------ | Branch (38:12): [True: 0, False: 199k] ------------------ 39| 199k| } _ZN8perfetto15trace_processor14ProcessTrackerC2EPNS0_21TraceProcessorContextE: 36| 2.03k| : context_(context), args_tracker_(context) { 37| | // Reserve utid/upid 0. These are special as embedders (e.g. Perfetto UI) 38| | // exclude them from certain views (e.g. thread state) under the assumption 39| | // that they correspond to the idle (swapper) process. When parsing Linux 40| | // system traces, SetPidZeroIsUpidZeroIdleProcess will be called to associate 41| | // tid0/pid0 to utid0/upid0. If other types of traces refer to tid0/pid0, 42| | // then they will get their own non-zero utid/upid, so that those threads are 43| | // still surfaced in embedder UIs. 44| | // 45| | // Note on multi-machine tracing: utid/upid of the swapper process of 46| | // secondary machine will not be 0. The ProcessTracker needs to insert to the 47| | // thread and process tables to reserve utid and upid. 48| 2.03k| tables::ProcessTable::Row process_row; 49| 2.03k| process_row.pid = 0u; 50| 2.03k| process_row.machine_id = context_->machine_id(); 51| 2.03k| auto upid = 52| 2.03k| context_->storage->mutable_process_table()->Insert(process_row).row; 53| | 54| 2.03k| tables::ThreadTable::Row thread_row; 55| 2.03k| thread_row.tid = 0u; 56| 2.03k| thread_row.upid = upid; // The swapper upid may be != 0 for remote machines. 57| 2.03k| thread_row.is_main_thread = true; 58| 2.03k| thread_row.is_idle = true; 59| 2.03k| thread_row.machine_id = context_->machine_id(); 60| 2.03k| auto utid = context_->storage->mutable_thread_table()->Insert(thread_row).row; 61| | 62| 2.03k| swapper_upid_ = upid; 63| 2.03k| swapper_utid_ = utid; 64| | 65| | // An element to match the reserved tid = 0. 66| 2.03k| thread_name_priorities_.push_back(ThreadNamePriority::kOther); 67| 2.03k|} _ZN8perfetto15trace_processor14ProcessTrackerD2Ev: 69| 2.03k|ProcessTracker::~ProcessTracker() = default; _ZN8perfetto15trace_processor14ProcessTracker14StartNewThreadENSt3__18optionalIlEEj: 72| 680k| uint32_t tid) { 73| 680k| tables::ThreadTable::Row row; 74| 680k| row.tid = tid; 75| 680k| row.start_ts = timestamp; 76| 680k| row.machine_id = context_->machine_id(); 77| | 78| 680k| auto* thread_table = context_->storage->mutable_thread_table(); 79| 680k| UniqueTid new_utid = thread_table->Insert(row).row; 80| 680k| tids_[tid].emplace_back(new_utid); 81| | 82| 680k| if (PERFETTO_UNLIKELY(thread_name_priorities_.size() <= new_utid)) { ------------------ | | 24| 680k|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 680k, False: 0] | | ------------------ ------------------ 83| | // This condition can happen in a multi-machine tracing session: 84| | // Machine 1 gets utid 0, 1 85| | // Machine 2 gets utid 2, 3 86| | // Machine 1 gets utid 4: where thread_name_priorities_.size() == 2. 87| 680k| thread_name_priorities_.resize(new_utid + 1); 88| 680k| } 89| 680k| thread_name_priorities_[new_utid] = ThreadNamePriority::kOther; 90| 680k| return new_utid; 91| 680k|} _ZN8perfetto15trace_processor14ProcessTracker15GetThreadOrNullEj: 135| 289k|std::optional ProcessTracker::GetThreadOrNull(uint32_t tid) { 136| 289k| auto opt_utid = GetThreadOrNull(tid, std::nullopt); 137| 289k| if (!opt_utid) ------------------ | Branch (137:7): [True: 8.84k, False: 280k] ------------------ 138| 8.84k| return std::nullopt; 139| | 140| 280k| auto& threads = *context_->storage->mutable_thread_table(); 141| 280k| UniqueTid utid = *opt_utid; 142| 280k| auto rr = threads[utid]; 143| | 144| | // Ensure that the tid matches the tid we were looking for. 145| 280k| PERFETTO_DCHECK(rr.tid() == tid); 146| | // Ensure that the thread's machine ID matches the context's machine ID. 147| 280k| PERFETTO_DCHECK(rr.machine_id() == context_->machine_id()); 148| | // If the thread is being tracked by the process tracker, it should not be 149| | // known to have ended. 150| 280k| PERFETTO_DCHECK(!rr.end_ts().has_value()); 151| | 152| 280k| return utid; 153| 289k|} _ZN8perfetto15trace_processor14ProcessTracker17GetOrCreateThreadEj: 155| 289k|UniqueTid ProcessTracker::GetOrCreateThread(uint32_t tid) { 156| 289k| auto utid = GetThreadOrNull(tid); 157| 289k| return utid ? *utid : StartNewThread(std::nullopt, tid); ------------------ | Branch (157:10): [True: 280k, False: 8.84k] ------------------ 158| 289k|} _ZN8perfetto15trace_processor14ProcessTracker16UpdateThreadNameEjNS0_10StringPool2IdENS0_18ThreadNamePriorityE: 162| 2.02k| ThreadNamePriority priority) { 163| 2.02k| auto utid = GetOrCreateThread(tid); 164| 2.02k| UpdateThreadNameByUtid(utid, thread_name_id, priority); 165| 2.02k| return utid; 166| 2.02k|} _ZN8perfetto15trace_processor14ProcessTracker22UpdateThreadNameByUtidEjNS0_10StringPool2IdENS0_18ThreadNamePriorityE: 170| 13.7k| ThreadNamePriority priority) { 171| 13.7k| if (thread_name_id.is_null()) ------------------ | Branch (171:7): [True: 11.5k, False: 2.18k] ------------------ 172| 11.5k| return; 173| | 174| 2.18k| auto& thread_table = *context_->storage->mutable_thread_table(); 175| 2.18k| if (PERFETTO_UNLIKELY(thread_name_priorities_.size() <= utid)) { ------------------ | | 24| 2.18k|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 1.60k, False: 585] | | ------------------ ------------------ 176| | // This condition can happen in a multi-machine tracing session: 177| | // Machine 1 gets utid 0, 1 178| | // Machine 2 gets utid 2, 3 179| | // Machine 1 gets utid 4: where thread_name_priorities_.size() == 2. 180| 1.60k| thread_name_priorities_.resize(utid + 1); 181| 1.60k| } 182| 2.18k| if (priority >= thread_name_priorities_[utid]) { ------------------ | Branch (182:7): [True: 2.18k, False: 0] ------------------ 183| 2.18k| thread_table[utid].set_name(thread_name_id); 184| 2.18k| thread_name_priorities_[utid] = priority; 185| 2.18k| } 186| 2.18k|} _ZN8perfetto15trace_processor14ProcessTracker13IsThreadAliveEj: 188| 90.8M|bool ProcessTracker::IsThreadAlive(UniqueTid utid) { 189| 90.8M| auto& threads = *context_->storage->mutable_thread_table(); 190| 90.8M| auto& processes = *context_->storage->mutable_process_table(); 191| | 192| | // If the thread has an end ts, it's certainly dead. 193| 90.8M| auto rr = threads[utid]; 194| 90.8M| if (rr.end_ts().has_value()) ------------------ | Branch (194:7): [True: 0, False: 90.8M] ------------------ 195| 0| return false; 196| | 197| | // If we don't know the parent process, we have to consider this thread alive. 198| 90.8M| auto opt_current_upid = rr.upid(); 199| 90.8M| if (!opt_current_upid) ------------------ | Branch (199:7): [True: 33.1k, False: 90.8M] ------------------ 200| 33.1k| return true; 201| | 202| | // If the process is already dead, the thread can't be alive. 203| 90.8M| UniquePid current_upid = *opt_current_upid; 204| 90.8M| auto prr = processes[current_upid]; 205| 90.8M| if (prr.end_ts().has_value()) ------------------ | Branch (205:7): [True: 0, False: 90.8M] ------------------ 206| 0| return false; 207| | 208| | // If the process has been replaced in |pids_|, this thread is dead. 209| 90.8M| uint32_t current_pid = prr.pid(); 210| 90.8M| auto* pid_it = pids_.Find(current_pid); 211| 90.8M| return !pid_it || *pid_it == current_upid; ------------------ | Branch (211:10): [True: 0, False: 90.8M] | Branch (211:21): [True: 90.8M, False: 191] ------------------ 212| 90.8M|} _ZN8perfetto15trace_processor14ProcessTracker15GetThreadOrNullEjNSt3__18optionalIjEE: 216| 969k| std::optional pid) { 217| 969k| auto& threads = *context_->storage->mutable_thread_table(); 218| 969k| auto& processes = *context_->storage->mutable_process_table(); 219| | 220| 969k| auto* vector_it = tids_.Find(tid); 221| 969k| if (!vector_it) ------------------ | Branch (221:7): [True: 566k, False: 402k] ------------------ 222| 566k| return std::nullopt; 223| | 224| | // Iterate backwards through the threads so ones later in the trace are more 225| | // likely to be picked. 226| 402k| const auto& vector = *vector_it; 227| 90.9M| for (auto it = vector.rbegin(); it != vector.rend(); it++) { ------------------ | Branch (227:35): [True: 90.8M, False: 105k] ------------------ 228| 90.8M| UniqueTid current_utid = *it; 229| 90.8M| auto rr = threads[current_utid]; 230| | 231| | // If we finished this thread, we should have removed it from the vector 232| | // entirely. 233| 90.8M| PERFETTO_DCHECK(!rr.end_ts().has_value()); 234| | 235| | // If the thread is dead, ignore it. 236| 90.8M| if (!IsThreadAlive(current_utid)) ------------------ | Branch (236:9): [True: 191, False: 90.8M] ------------------ 237| 191| continue; 238| | 239| | // If we don't know the parent process, we have to choose this thread. 240| 90.8M| auto opt_current_upid = rr.upid(); 241| 90.8M| if (!opt_current_upid) ------------------ | Branch (241:9): [True: 33.1k, False: 90.8M] ------------------ 242| 33.1k| return current_utid; 243| | 244| | // We found a thread that matches both the tid and its parent pid. 245| 90.8M| auto prr = processes[*opt_current_upid]; 246| 90.8M| uint32_t current_pid = prr.pid(); 247| 90.8M| if (!pid || current_pid == *pid) ------------------ | Branch (247:9): [True: 255k, False: 90.5M] | Branch (247:17): [True: 9.00k, False: 90.5M] ------------------ 248| 264k| return current_utid; 249| 90.8M| } 250| 105k| return std::nullopt; 251| 402k|} _ZN8perfetto15trace_processor14ProcessTracker12UpdateThreadEjj: 253| 680k|UniqueTid ProcessTracker::UpdateThread(uint32_t tid, uint32_t pid) { 254| 680k| auto& thread_table = *context_->storage->mutable_thread_table(); 255| | 256| | // Try looking for a thread that matches both tid and thread group id (pid). 257| 680k| std::optional opt_utid = GetThreadOrNull(tid, pid); 258| | 259| | // If no matching thread was found, create a new one. 260| 680k| UniqueTid utid = opt_utid ? *opt_utid : StartNewThread(std::nullopt, tid); ------------------ | Branch (260:20): [True: 17.3k, False: 663k] ------------------ 261| 680k| auto rr = thread_table[utid]; 262| 680k| PERFETTO_DCHECK(rr.tid() == tid); 263| | // Ensure that the thread's machine ID matches the context's machine ID. 264| 680k| PERFETTO_DCHECK(rr.machine_id() == context_->machine_id()); 265| | 266| | // Find matching process or create new one. 267| 680k| if (!rr.upid().has_value()) { ------------------ | Branch (267:7): [True: 671k, False: 9.00k] ------------------ 268| 671k| AssociateThreadToProcess(utid, GetOrCreateProcess(pid)); 269| 671k| } 270| 680k| ResolvePendingAssociations(utid, *rr.upid()); 271| 680k| return utid; 272| 680k|} _ZN8perfetto15trace_processor14ProcessTracker16UpdateTrustedPidEjm: 274| 1.04k|void ProcessTracker::UpdateTrustedPid(uint32_t trusted_pid, uint64_t uuid) { 275| 1.04k| trusted_pids_[uuid] = trusted_pid; 276| 1.04k|} _ZN8perfetto15trace_processor14ProcessTracker13GetTrustedPidEm: 278| 74.8k|std::optional ProcessTracker::GetTrustedPid(uint64_t uuid) { 279| 74.8k| if (trusted_pids_.find(uuid) == trusted_pids_.end()) ------------------ | Branch (279:7): [True: 73.9k, False: 842] ------------------ 280| 73.9k| return std::nullopt; 281| 842| return trusted_pids_[uuid]; 282| 74.8k|} _ZN8perfetto15trace_processor14ProcessTracker15StartNewProcessENSt3__18optionalIlEENS3_IjEEjNS0_10StringPool2IdENS0_18ThreadNamePriorityE: 320| 6.44k| ThreadNamePriority priority) { 321| 6.44k| pids_.Erase(pid); 322| | // TODO(eseckler): Consider erasing all old entries in |tids_| that match the 323| | // |pid| (those would be for an older process with the same pid). Right now, 324| | // we keep them in |tids_| (if they weren't erased by EndThread()), but ignore 325| | // them in GetThreadOrNull(). 326| | 327| | // Create a new UTID for the main thread, so we don't end up reusing an old 328| | // entry in case of TID recycling. 329| 6.44k| UniqueTid utid = StartNewThread(timestamp, /*tid=*/pid); 330| 6.44k| UpdateThreadNameByUtid(utid, main_thread_name, priority); 331| | 332| | // Note that we erased the pid above so this should always return a new 333| | // process. 334| 6.44k| UniquePid upid = GetOrCreateProcess(pid); 335| | 336| 6.44k| auto& process_table = *context_->storage->mutable_process_table(); 337| 6.44k| auto& thread_table = *context_->storage->mutable_thread_table(); 338| | 339| 6.44k| auto prr = process_table[upid]; 340| 6.44k| PERFETTO_DCHECK(!prr.name().has_value()); 341| 6.44k| PERFETTO_DCHECK(!prr.start_ts().has_value()); 342| | 343| 6.44k| if (timestamp) { ------------------ | Branch (343:7): [True: 0, False: 6.44k] ------------------ 344| 0| prr.set_start_ts(*timestamp); 345| 0| } 346| 6.44k| prr.set_name(main_thread_name); 347| | 348| 6.44k| if (parent_tid) { ------------------ | Branch (348:7): [True: 0, False: 6.44k] ------------------ 349| 0| UniqueTid parent_utid = GetOrCreateThread(*parent_tid); 350| 0| auto opt_parent_upid = thread_table[parent_utid].upid(); 351| 0| if (opt_parent_upid.has_value()) { ------------------ | Branch (351:9): [True: 0, False: 0] ------------------ 352| 0| prr.set_parent_upid(*opt_parent_upid); 353| 0| } else { 354| 0| pending_parent_assocs_.emplace_back(parent_utid, upid); 355| 0| } 356| 0| } 357| 6.44k| return upid; 358| 6.44k|} _ZN8perfetto15trace_processor14ProcessTracker21SetProcessNameIfUnsetEjNS0_10StringPool2IdE: 404| 55.7k| StringId process_name_id) { 405| 55.7k| auto& pt = *context_->storage->mutable_process_table(); 406| 55.7k| if (auto rr = pt[upid]; !rr.name().has_value()) { ------------------ | Branch (406:27): [True: 55.6k, False: 24] ------------------ 407| 55.6k| rr.set_name(process_name_id); 408| 55.6k| } 409| 55.7k|} _ZN8perfetto15trace_processor14ProcessTracker17SetStartTsIfUnsetEjl: 412| 33.4k| int64_t start_ts_nanoseconds) { 413| 33.4k| auto& pt = *context_->storage->mutable_process_table(); 414| 33.4k| if (auto rr = pt[upid]; !rr.start_ts().has_value()) { ------------------ | Branch (414:27): [True: 27.3k, False: 6.14k] ------------------ 415| 27.3k| rr.set_start_ts(start_ts_nanoseconds); 416| 27.3k| } 417| 33.4k|} _ZN8perfetto15trace_processor14ProcessTracker18GetOrCreateProcessEj: 439| 1.21M|UniquePid ProcessTracker::GetOrCreateProcess(uint32_t pid) { 440| 1.21M| auto& process_table = *context_->storage->mutable_process_table(); 441| | 442| | // If the insertion succeeds, we'll fill the upid below. 443| 1.21M| auto it_and_ins = pids_.Insert(pid, UniquePid{0}); 444| 1.21M| if (!it_and_ins.second) { ------------------ | Branch (444:7): [True: 651k, False: 564k] ------------------ 445| | // Ensure that the process has not ended. 446| 651k| PERFETTO_DCHECK(!process_table[*it_and_ins.first].end_ts().has_value()); 447| 651k| return *it_and_ins.first; 448| 651k| } 449| | 450| 564k| tables::ProcessTable::Row row; 451| 564k| row.pid = pid; 452| 564k| row.machine_id = context_->machine_id(); 453| | 454| 564k| UniquePid upid = process_table.Insert(row).row; 455| 564k| *it_and_ins.first = upid; // Update the newly inserted hashmap entry. 456| | 457| | // Create an entry for the main thread. 458| | // We cannot call StartNewThread() here, because threads for this process 459| | // (including the main thread) might have been seen already prior to this 460| | // call. This call usually comes from the ProcessTree dump which is delayed. 461| 564k| UpdateThread(/*tid=*/pid, pid); 462| 564k| return upid; 463| 1.21M|} _ZN8perfetto15trace_processor14ProcessTracker26ResolvePendingAssociationsEjj: 501| 680k| UniquePid upid) { 502| 680k| auto& tt = *context_->storage->mutable_thread_table(); 503| 680k| auto& pt = *context_->storage->mutable_process_table(); 504| | 505| 680k| auto trr = tt[utid_arg]; 506| 680k| PERFETTO_DCHECK(trr.upid() == upid); 507| | 508| 680k| std::vector resolved_utids; 509| 680k| resolved_utids.emplace_back(utid_arg); 510| | 511| 1.36M| while (!resolved_utids.empty()) { ------------------ | Branch (511:10): [True: 680k, False: 680k] ------------------ 512| 680k| UniqueTid utid = resolved_utids.back(); 513| 680k| resolved_utids.pop_back(); 514| 680k| for (auto it = pending_parent_assocs_.begin(); 515| 680k| it != pending_parent_assocs_.end();) { ------------------ | Branch (515:10): [True: 0, False: 680k] ------------------ 516| 0| UniqueTid parent_utid = it->first; 517| 0| UniquePid child_upid = it->second; 518| | 519| 0| if (parent_utid != utid) { ------------------ | Branch (519:11): [True: 0, False: 0] ------------------ 520| 0| ++it; 521| 0| continue; 522| 0| } 523| 0| PERFETTO_DCHECK(child_upid != upid); 524| | 525| | // Set the parent pid of the other process 526| 0| auto crr = pt[child_upid]; 527| 0| PERFETTO_DCHECK(!crr.parent_upid() || crr.parent_upid() == upid); 528| 0| crr.set_parent_upid(upid); 529| | 530| | // Erase the pair. The |pending_parent_assocs_| vector is not sorted and 531| | // swapping a std::pair is cheap. 532| 0| std::swap(*it, pending_parent_assocs_.back()); 533| 0| pending_parent_assocs_.pop_back(); 534| 0| } 535| | 536| 680k| auto end = pending_assocs_.end(); 537| 680k| for (auto it = pending_assocs_.begin(); it != end;) { ------------------ | Branch (537:45): [True: 0, False: 680k] ------------------ 538| 0| UniqueTid other_utid; 539| 0| if (it->first == utid) { ------------------ | Branch (539:11): [True: 0, False: 0] ------------------ 540| 0| other_utid = it->second; 541| 0| } else if (it->second == utid) { ------------------ | Branch (541:18): [True: 0, False: 0] ------------------ 542| 0| other_utid = it->first; 543| 0| } else { 544| 0| ++it; 545| 0| continue; 546| 0| } 547| | 548| 0| PERFETTO_DCHECK(other_utid != utid); 549| | 550| | // Update the other thread and associated it to the same process. 551| 0| auto orr = tt[other_utid]; 552| 0| PERFETTO_DCHECK(!orr.upid() || orr.upid() == upid); 553| 0| AssociateThreadToProcess(other_utid, upid); 554| | 555| | // Swap the current element to the end of the list and move the end 556| | // iterator back. This works because |pending_assocs_| is not sorted. We 557| | // do it this way rather than modifying |pending_assocs_| directly to 558| | // prevent undefined behaviour caused by modifying a vector while 559| | // iterating through it. 560| 0| std::swap(*it, *(--end)); 561| | 562| | // Recurse into the newly resolved thread. Some other threads might have 563| | // been bound to that. 564| 0| resolved_utids.emplace_back(other_utid); 565| 0| } 566| | 567| | // Make sure to actually erase the utids which have been resolved. 568| 680k| pending_assocs_.erase(end, pending_assocs_.end()); 569| 680k| } // while (!resolved_utids.empty()) 570| 680k|} _ZN8perfetto15trace_processor14ProcessTracker24AssociateThreadToProcessEjj: 572| 671k|void ProcessTracker::AssociateThreadToProcess(UniqueTid utid, UniquePid upid) { 573| 671k| auto& thread_table = *context_->storage->mutable_thread_table(); 574| 671k| auto& process_table = *context_->storage->mutable_process_table(); 575| | 576| 671k| auto trr = thread_table[utid]; 577| 671k| auto prr = process_table[upid]; 578| 671k| trr.set_upid(upid); 579| 671k| trr.set_is_main_thread(trr.tid() == prr.pid()); 580| 671k|} _ZN8perfetto15trace_processor14ProcessTracker31SetPidZeroIsUpidZeroIdleProcessEv: 582| 2.02k|void ProcessTracker::SetPidZeroIsUpidZeroIdleProcess() { 583| | // Create a mapping from (t|p)id 0 -> u(t|p)id for the idle process. 584| 2.02k| tids_.Insert(0, std::vector{swapper_utid_}); 585| 2.02k| pids_.Insert(0, swapper_upid_); 586| | 587| 2.02k| auto swapper_id = context_->storage->InternString("swapper"); 588| 2.02k| UpdateThreadName(0, swapper_id, ThreadNamePriority::kTraceProcessorConstant); 589| 2.02k|} _ZN8perfetto15trace_processor14ProcessTracker9AddArgsToEj: 591| 100k|ArgsTracker::BoundInserter ProcessTracker::AddArgsTo(UniquePid upid) { 592| 100k| return args_tracker_.AddArgsTo(upid); 593| 100k|} _ZN8perfetto15trace_processor14ProcessTracker15NotifyEndOfFileEv: 595| 345|void ProcessTracker::NotifyEndOfFile() { 596| 345| args_tracker_.Flush(); 597| 345| tids_.Clear(); 598| 345| pids_.Clear(); 599| 345| pending_assocs_.clear(); 600| 345| pending_parent_assocs_.clear(); 601| 345| thread_name_priorities_.clear(); 602| 345| trusted_pids_.clear(); 603| 345| namespaced_threads_.clear(); 604| 345| namespaced_processes_.clear(); 605| 345|} _ZN8perfetto15trace_processor17SchedEventTrackerD2Ev: 22| 2.03k|SchedEventTracker::~SchedEventTracker() = default; _ZN8perfetto15trace_processor17SchedEventTrackerC2EPNS0_21TraceProcessorContextE: 37| 2.03k| : context_(context) {} _ZN8perfetto15trace_processor12SliceTrackerC2EPNS0_21TraceProcessorContextE: 42| 2.03k| context->storage->InternString("legacy_unnestable_begin_count")), 43| | legacy_unnestable_last_begin_ts_string_id_( 44| 2.03k| context->storage->InternString("legacy_unnestable_last_begin_ts")), 45| 2.03k| context_(context) {} _ZN8perfetto15trace_processor12SliceTrackerD2Ev: 47| 2.03k|SliceTracker::~SliceTracker() = default; _ZN8perfetto15trace_processor12SliceTracker5BeginElNS0_6tables10TrackTable2IdENS0_10StringPool2IdES6_NSt3__18functionIFvPNS0_11ArgsTracker13BoundInserterEEEE: 53| 121k| SetArgsCallback args_callback) { 54| 121k| const StringId name = 55| 121k| context_->slice_translation_table->TranslateName(raw_name); 56| 121k| tables::SliceTable::Row row(timestamp, kPendingDuration, track_id, category, 57| 121k| name); 58| 121k| return StartSlice(timestamp, track_id, args_callback, [this, &row]() { 59| 121k| return context_->storage->mutable_slice_table()->Insert(row).id; 60| 121k| }); 61| 121k|} _ZN8perfetto15trace_processor12SliceTracker6ScopedElNS0_6tables10TrackTable2IdENS0_10StringPool2IdES6_lNSt3__18functionIFvPNS0_11ArgsTracker13BoundInserterEEEE: 93| 626k| SetArgsCallback args_callback) { 94| 626k| PERFETTO_DCHECK(duration >= 0); 95| | 96| 626k| const StringId name = 97| 626k| context_->slice_translation_table->TranslateName(raw_name); 98| 626k| tables::SliceTable::Row row(timestamp, duration, track_id, category, name); 99| 626k| return StartSlice(timestamp, track_id, args_callback, [this, &row]() { 100| 626k| return context_->storage->mutable_slice_table()->Insert(row).id; 101| 626k| }); 102| 626k|} _ZN8perfetto15trace_processor12SliceTracker3EndElNS0_6tables10TrackTable2IdENS0_10StringPool2IdES6_NSt3__18functionIFvPNS0_11ArgsTracker13BoundInserterEEEE: 108| 3.10k| SetArgsCallback args_callback) { 109| 3.10k| const StringId name = 110| 3.10k| context_->slice_translation_table->TranslateName(raw_name); 111| 3.10k| auto finder = [this, category, name](const SlicesStack& stack) { 112| 3.10k| return MatchingIncompleteSliceIndex(stack, name, category); 113| 3.10k| }; 114| 3.10k| return CompleteSlice(timestamp, track_id, args_callback, finder); 115| 3.10k|} _ZN8perfetto15trace_processor12SliceTracker10StartSliceElNS0_6tables10TrackTable2IdENSt3__18functionIFvPNS0_11ArgsTracker13BoundInserterEEEENS6_IFNS2_10SliceTable2IdEvEEE: 150| 748k| std::function inserter) { 151| 748k| auto& track_info = stacks_[track_id]; 152| 748k| auto& stack = track_info.slice_stack; 153| | 154| 748k| if (track_info.is_legacy_unnestable) { ------------------ | Branch (154:7): [True: 0, False: 748k] ------------------ 155| 0| PERFETTO_DCHECK(stack.size() <= 1); 156| | 157| 0| track_info.legacy_unnestable_begin_count++; 158| 0| track_info.legacy_unnestable_last_begin_ts = timestamp; 159| | 160| | // If this is an unnestable track, don't start a new slice if one already 161| | // exists. 162| 0| if (!stack.empty()) { ------------------ | Branch (162:9): [True: 0, False: 0] ------------------ 163| 0| return std::nullopt; 164| 0| } 165| 0| } 166| | 167| 748k| auto* slices = context_->storage->mutable_slice_table(); 168| 748k| MaybeCloseStack(timestamp, stack, track_id); 169| | 170| 748k| size_t depth = stack.size(); 171| | 172| 748k| std::optional parent_ref = 173| 748k| depth == 0 ? std::nullopt ------------------ | Branch (173:7): [True: 577k, False: 170k] ------------------ 174| 748k| : std::make_optional(stack.back().row.ToRowReference(slices)); 175| 748k| int64_t parent_stack_id = parent_ref ? parent_ref->stack_id() : 0; ------------------ | Branch (175:29): [True: 170k, False: 577k] ------------------ 176| 748k| std::optional parent_id = 177| 748k| parent_ref ? std::make_optional(parent_ref->id()) : std::nullopt; ------------------ | Branch (177:7): [True: 170k, False: 577k] ------------------ 178| | 179| 748k| SliceId id = inserter(); 180| 748k| tables::SliceTable::RowReference ref = *slices->FindById(id); 181| 748k| if (depth >= kMaxDepth) { ------------------ | Branch (181:7): [True: 16.3k, False: 731k] ------------------ 182| 16.3k| auto parent_name = context_->storage->GetString( 183| 16.3k| parent_ref->name().value_or(kNullStringId)); 184| 16.3k| auto name = 185| 16.3k| context_->storage->GetString(ref.name().value_or(kNullStringId)); 186| 16.3k| PERFETTO_DLOG("Last slice: %s", parent_name.c_str()); 187| 16.3k| PERFETTO_DLOG("Current slice: %s", name.c_str()); 188| 16.3k| PERFETTO_DFATAL("Slices with too large depth found."); 189| 16.3k| return std::nullopt; 190| 16.3k| } 191| 731k| StackPush(track_id, ref); 192| | 193| | // Post fill all the relevant columns. All the other columns should have 194| | // been filled by the inserter. 195| 731k| ref.set_depth(static_cast(depth)); 196| 731k| ref.set_parent_stack_id(parent_stack_id); 197| 731k| ref.set_stack_id(GetStackHash(stack)); 198| 731k| if (parent_id) ------------------ | Branch (198:7): [True: 154k, False: 577k] ------------------ 199| 154k| ref.set_parent_id(*parent_id); 200| | 201| 731k| if (args_callback) { ------------------ | Branch (201:7): [True: 731k, False: 0] ------------------ 202| 731k| auto bound_inserter = stack.back().args_tracker.AddArgsTo(id); 203| 731k| args_callback(&bound_inserter); 204| 731k| } 205| 731k| return id; 206| 748k|} _ZN8perfetto15trace_processor12SliceTracker13CompleteSliceElNS0_6tables10TrackTable2IdENSt3__18functionIFvPNS0_11ArgsTracker13BoundInserterEEEENS6_IFNS5_8optionalIjEERKNS5_6vectorINS1_9SliceInfoENS5_9allocatorISF_EEEEEEE: 212| 3.10k| std::function(const SlicesStack&)> finder) { 213| 3.10k| auto* it = stacks_.Find(track_id); 214| 3.10k| if (!it) ------------------ | Branch (214:7): [True: 56, False: 3.04k] ------------------ 215| 56| return std::nullopt; 216| | 217| 3.04k| TrackInfo& track_info = *it; 218| 3.04k| SlicesStack& stack = track_info.slice_stack; 219| 3.04k| MaybeCloseStack(timestamp, stack, track_id); 220| 3.04k| if (stack.empty()) ------------------ | Branch (220:7): [True: 329, False: 2.72k] ------------------ 221| 329| return std::nullopt; 222| | 223| 2.72k| auto* slices = context_->storage->mutable_slice_table(); 224| 2.72k| std::optional stack_idx = finder(stack); 225| | 226| | // If we are trying to close slices that are not open on the stack (e.g., 227| | // slices that began before tracing started), bail out. 228| 2.72k| if (!stack_idx) ------------------ | Branch (228:7): [True: 1.15k, False: 1.57k] ------------------ 229| 1.15k| return std::nullopt; 230| | 231| 1.57k| const auto& slice_info = stack[stack_idx.value()]; 232| | 233| 1.57k| tables::SliceTable::RowReference ref = slice_info.row.ToRowReference(slices); 234| 1.57k| PERFETTO_DCHECK(ref.dur() == kPendingDuration); 235| 1.57k| ref.set_dur(timestamp - ref.ts()); 236| | 237| 1.57k| ArgsTracker& tracker = stack[stack_idx.value()].args_tracker; 238| 1.57k| if (args_callback) { ------------------ | Branch (238:7): [True: 1.57k, False: 0] ------------------ 239| 1.57k| auto bound_inserter = tracker.AddArgsTo(ref.id()); 240| 1.57k| args_callback(&bound_inserter); 241| 1.57k| } 242| | 243| | // Add the legacy unnestable args if they exist. 244| 1.57k| if (track_info.is_legacy_unnestable) { ------------------ | Branch (244:7): [True: 0, False: 1.57k] ------------------ 245| 0| auto bound_inserter = tracker.AddArgsTo(ref.id()); 246| 0| bound_inserter.AddArg( 247| 0| legacy_unnestable_begin_count_string_id_, 248| 0| Variadic::Integer(track_info.legacy_unnestable_begin_count)); 249| 0| bound_inserter.AddArg( 250| 0| legacy_unnestable_last_begin_ts_string_id_, 251| 0| Variadic::Integer(track_info.legacy_unnestable_last_begin_ts)); 252| 0| } 253| | 254| | // If this slice is the top slice on the stack, pop it off. 255| 1.57k| if (*stack_idx == stack.size() - 1) { ------------------ | Branch (255:7): [True: 1.51k, False: 59] ------------------ 256| 1.51k| StackPop(track_id); 257| 1.51k| } 258| 1.57k| return ref.id(); 259| 2.72k|} _ZN8perfetto15trace_processor12SliceTracker28MatchingIncompleteSliceIndexERKNSt3__16vectorINS1_9SliceInfoENS2_9allocatorIS4_EEEENS0_10StringPool2IdESB_: 267| 2.72k| StringId category) { 268| 2.72k| auto* slices = context_->storage->mutable_slice_table(); 269| 171k| for (int i = static_cast(stack.size()) - 1; i >= 0; i--) { ------------------ | Branch (269:52): [True: 170k, False: 1.15k] ------------------ 270| 170k| tables::SliceTable::RowReference ref = 271| 170k| stack[static_cast(i)].row.ToRowReference(slices); 272| 170k| if (ref.dur() != kPendingDuration) ------------------ | Branch (272:9): [True: 6.07k, False: 163k] ------------------ 273| 6.07k| continue; 274| 163k| std::optional other_category = ref.category(); 275| 163k| if (!category.is_null() && (!other_category || other_category->is_null() || ------------------ | Branch (275:9): [True: 162k, False: 1.51k] | Branch (275:33): [True: 87.8k, False: 74.5k] | Branch (275:52): [True: 0, False: 74.5k] ------------------ 276| 162k| category != other_category)) { ------------------ | Branch (276:33): [True: 74.5k, False: 59] ------------------ 277| 162k| continue; 278| 162k| } 279| 1.57k| std::optional other_name = ref.name(); 280| 1.57k| if (!name.is_null() && other_name && !other_name->is_null() && ------------------ | Branch (280:9): [True: 0, False: 1.57k] | Branch (280:28): [True: 0, False: 0] | Branch (280:42): [True: 0, False: 0] ------------------ 281| 1.57k| name != other_name) { ------------------ | Branch (281:9): [True: 0, False: 0] ------------------ 282| 0| continue; 283| 0| } 284| 1.57k| return static_cast(i); 285| 1.57k| } 286| 1.15k| return std::nullopt; 287| 2.72k|} _ZN8perfetto15trace_processor12SliceTracker24MaybeAddTranslatableArgsERNS1_9SliceInfoE: 289| 725k|void SliceTracker::MaybeAddTranslatableArgs(SliceInfo& slice_info) { 290| 725k| if (!slice_info.args_tracker.NeedsTranslation( ------------------ | Branch (290:7): [True: 207k, False: 518k] ------------------ 291| 725k| *context_->args_translation_table)) { 292| 207k| return; 293| 207k| } 294| 518k| const auto& table = context_->storage->slice_table(); 295| 518k| tables::SliceTable::ConstRowReference ref = 296| 518k| slice_info.row.ToRowReference(table); 297| 518k| translatable_args_.emplace_back(TranslatableArgs{ 298| 518k| ref.id(), 299| 518k| std::move(slice_info.args_tracker) 300| 518k| .ToCompactArgSet(table.arg_set_id(), slice_info.row.row_number())}); 301| 518k|} _ZN8perfetto15trace_processor12SliceTracker18FlushPendingSlicesEv: 303| 345|void SliceTracker::FlushPendingSlices() { 304| | // Clear the remaining stack entries. This ensures that any pending args are 305| | // written to the storage. We don't close any slices with kPendingDuration so 306| | // that the UI can still distinguish such "incomplete" slices. 307| | // 308| | // TODO(eseckler): Reconsider whether we want to close pending slices by 309| | // setting their duration to |trace_end - event_start|. Might still want some 310| | // additional way of flagging these events as "incomplete" to the UI. 311| | 312| | // Make sure that args for all incomplete slice are translated. 313| 81.9k| for (auto it = stacks_.GetIterator(); it; ++it) { ------------------ | Branch (313:41): [True: 81.5k, False: 345] ------------------ 314| 81.5k| auto& track_info = it.value(); 315| 104k| for (auto& slice_info : track_info.slice_stack) { ------------------ | Branch (315:27): [True: 104k, False: 81.5k] ------------------ 316| 104k| MaybeAddTranslatableArgs(slice_info); 317| 104k| } 318| 81.5k| } 319| | 320| | // Translate and flush all pending args. 321| 512k| for (const auto& translatable_arg : translatable_args_) { ------------------ | Branch (321:37): [True: 512k, False: 345] ------------------ 322| 512k| auto bound_inserter = 323| 512k| context_->args_tracker->AddArgsTo(translatable_arg.slice_id); 324| 512k| context_->args_translation_table->TranslateArgs( 325| 512k| translatable_arg.compact_arg_set, bound_inserter); 326| 512k| } 327| 345| translatable_args_.clear(); 328| | 329| 345| stacks_.Clear(); 330| 345|} _ZN8perfetto15trace_processor12SliceTracker23SetOnSliceBeginCallbackENSt3__18functionIFvNS0_6tables10TrackTable2IdENS4_10SliceTable2IdEEEE: 332| 2.03k|void SliceTracker::SetOnSliceBeginCallback(OnSliceBeginCallback callback) { 333| 2.03k| on_slice_begin_callback_ = callback; 334| 2.03k|} _ZNK8perfetto15trace_processor12SliceTracker22GetTopmostSliceOnTrackENS0_6tables10TrackTable2IdE: 337| 54.1k| TrackId track_id) const { 338| 54.1k| const auto* iter = stacks_.Find(track_id); 339| 54.1k| if (!iter) ------------------ | Branch (339:7): [True: 6.25k, False: 47.9k] ------------------ 340| 6.25k| return std::nullopt; 341| 47.9k| const auto& stack = iter->slice_stack; 342| 47.9k| if (stack.empty()) ------------------ | Branch (342:7): [True: 20, False: 47.9k] ------------------ 343| 20| return std::nullopt; 344| 47.9k| const auto& slice = context_->storage->slice_table(); 345| 47.9k| return stack.back().row.ToRowReference(slice).id(); 346| 47.9k|} _ZN8perfetto15trace_processor12SliceTracker15MaybeCloseStackElRKNSt3__16vectorINS1_9SliceInfoENS2_9allocatorIS4_EEEENS0_6tables10TrackTable2IdE: 350| 751k| TrackId track_id) { 351| 751k| auto* slices = context_->storage->mutable_slice_table(); 352| 751k| bool incomplete_descendent = false; 353| 17.0M| for (int i = static_cast(stack.size()) - 1; i >= 0; i--) { ------------------ | Branch (353:52): [True: 16.3M, False: 751k] ------------------ 354| 16.3M| tables::SliceTable::RowReference ref = 355| 16.3M| stack[static_cast(i)].row.ToRowReference(slices); 356| | 357| 16.3M| int64_t start_ts = ref.ts(); 358| 16.3M| int64_t dur = ref.dur(); 359| 16.3M| int64_t end_ts = start_ts + dur; 360| 16.3M| if (dur == kPendingDuration) { ------------------ | Branch (360:9): [True: 15.6M, False: 674k] ------------------ 361| 15.6M| incomplete_descendent = true; 362| 15.6M| continue; 363| 15.6M| } 364| | 365| 674k| if (incomplete_descendent) { ------------------ | Branch (365:9): [True: 11.5k, False: 662k] ------------------ 366| 11.5k| PERFETTO_DCHECK(ts >= start_ts); 367| | 368| | // Only process slices if the ts is past the end of the slice. 369| 11.5k| if (ts <= end_ts) ------------------ | Branch (369:11): [True: 11.4k, False: 46] ------------------ 370| 11.4k| continue; 371| | 372| | // This usually happens because we have two slices that are partially 373| | // overlapping. 374| | // [ slice 1 ] 375| | // [ slice 2 ] 376| | // This is invalid in chrome and should be fixed. Duration events should 377| | // either be nested or disjoint, never partially intersecting. 378| | // KI: if tracing both binder and system calls on android, "binder reply" 379| | // slices will try to escape the enclosing sys_ioctl. 380| 46| PERFETTO_DLOG( 381| 46| "Incorrect ordering of begin/end slice events. " 382| 46| "Truncating incomplete descendants to the end of slice " 383| 46| "%s[%" PRId64 ", %" PRId64 "] due to an event at ts=%" PRId64 ".", 384| 46| context_->storage->GetString(ref.name().value_or(kNullStringId)) 385| 46| .c_str(), 386| 46| start_ts, end_ts, ts); 387| 46| context_->storage->IncrementStats(stats::misplaced_end_event); 388| | 389| | // Every slice below this one should have a pending duration. Update 390| | // of them to have the end ts of the current slice and pop them 391| | // all off. 392| 515| for (int j = static_cast(stack.size()) - 1; j > i; --j) { ------------------ | Branch (392:56): [True: 469, False: 46] ------------------ 393| 469| tables::SliceTable::RowReference child_ref = 394| 469| stack[static_cast(j)].row.ToRowReference(slices); 395| 469| PERFETTO_DCHECK(child_ref.dur() == kPendingDuration); 396| 469| child_ref.set_dur(end_ts - child_ref.ts()); 397| 469| StackPop(track_id); 398| 469| } 399| | 400| | // Also pop the current row itself and reset the incomplete flag. 401| 46| StackPop(track_id); 402| 46| incomplete_descendent = false; 403| | 404| 46| continue; 405| 11.5k| } 406| | 407| 662k| if (end_ts <= ts) { ------------------ | Branch (407:9): [True: 618k, False: 44.2k] ------------------ 408| 618k| StackPop(track_id); 409| 618k| } 410| 662k| } 411| 751k|} _ZN8perfetto15trace_processor12SliceTracker12GetStackHashERKNSt3__16vectorINS1_9SliceInfoENS2_9allocatorIS4_EEEE: 413| 731k|int64_t SliceTracker::GetStackHash(const SlicesStack& stack) { 414| 731k| PERFETTO_DCHECK(!stack.empty()); 415| | 416| 731k| const auto& slices = context_->storage->slice_table(); 417| | 418| 731k| base::Hasher hash; 419| 7.71M| for (const auto& i : stack) { ------------------ | Branch (419:22): [True: 7.71M, False: 731k] ------------------ 420| 7.71M| auto ref = i.row.ToRowReference(slices); 421| 7.71M| hash.Update(ref.category().value_or(kNullStringId).raw_id()); 422| 7.71M| hash.Update(ref.name().value_or(kNullStringId).raw_id()); 423| 7.71M| } 424| | 425| | // For clients which don't have an integer type (i.e. Javascript), returning 426| | // hashes which have the top 11 bits set leads to numbers which are 427| | // unrepresenatble. This means that clients cannot filter using this number as 428| | // it will be meaningless when passed back to us. For this reason, make sure 429| | // that the hash is always less than 2^53 - 1. 430| 731k| constexpr uint64_t kSafeBitmask = (1ull << 53) - 1; 431| 731k| return static_cast(hash.digest() & kSafeBitmask); 432| 731k|} _ZN8perfetto15trace_processor12SliceTracker8StackPopENS0_6tables10TrackTable2IdE: 434| 620k|void SliceTracker::StackPop(TrackId track_id) { 435| 620k| auto& stack = stacks_[track_id].slice_stack; 436| 620k| MaybeAddTranslatableArgs(stack.back()); 437| 620k| stack.pop_back(); 438| 620k|} _ZN8perfetto15trace_processor12SliceTracker9StackPushENS0_6tables10TrackTable2IdENS2_10SliceTable12RowReferenceE: 441| 731k| tables::SliceTable::RowReference ref) { 442| 731k| stacks_[track_id].slice_stack.push_back( 443| 731k| SliceInfo{ref.ToRowNumber(), ArgsTracker(context_)}); 444| 731k| if (on_slice_begin_callback_) { ------------------ | Branch (444:7): [True: 731k, False: 0] ------------------ 445| 731k| on_slice_begin_callback_(track_id, ref.id()); 446| 731k| } 447| 731k|} slice_tracker.cc:_ZZN8perfetto15trace_processor12SliceTracker5BeginElNS0_6tables10TrackTable2IdENS0_10StringPool2IdES6_NSt3__18functionIFvPNS0_11ArgsTracker13BoundInserterEEEEENK3$_0clEv: 58| 121k| return StartSlice(timestamp, track_id, args_callback, [this, &row]() { 59| 121k| return context_->storage->mutable_slice_table()->Insert(row).id; 60| 121k| }); slice_tracker.cc:_ZZN8perfetto15trace_processor12SliceTracker6ScopedElNS0_6tables10TrackTable2IdENS0_10StringPool2IdES6_lNSt3__18functionIFvPNS0_11ArgsTracker13BoundInserterEEEEENK3$_0clEv: 99| 626k| return StartSlice(timestamp, track_id, args_callback, [this, &row]() { 100| 626k| return context_->storage->mutable_slice_table()->Insert(row).id; 101| 626k| }); slice_tracker.cc:_ZZN8perfetto15trace_processor12SliceTracker3EndElNS0_6tables10TrackTable2IdENS0_10StringPool2IdES6_NSt3__18functionIFvPNS0_11ArgsTracker13BoundInserterEEEEENK3$_0clERKNS7_6vectorINS1_9SliceInfoENS7_9allocatorISG_EEEE: 111| 2.72k| auto finder = [this, category, name](const SlicesStack& stack) { 112| 2.72k| return MatchingIncompleteSliceIndex(stack, name, category); 113| 2.72k| }; _ZN8perfetto15trace_processor21SliceTranslationTableC2EPNS0_12TraceStorageE: 23| 2.03k| : storage_(storage) {} _ZNK8perfetto15trace_processor21SliceTranslationTable13TranslateNameENS0_10StringPool2IdE: 37| 751k| StringId TranslateName(StringId raw_name) const { 38| 751k| const auto* mapped_name = raw_to_deobfuscated_name_.Find(raw_name); 39| 751k| return mapped_name ? *mapped_name : raw_name; ------------------ | Branch (39:12): [True: 0, False: 751k] ------------------ 40| 751k| } _ZN8perfetto15trace_processor19StackProfileTrackerC2EPNS0_21TraceProcessorContextE: 55| 2.03k| : context_(context) {} _ZN8perfetto15trace_processor16TraceFileTracker11AddFileImplENS0_10StringPool2IdE: 39| 434|tables::TraceFileTable::Id TraceFileTracker::AddFileImpl(StringId name) { 40| 434| std::optional parent = 41| 434| parsing_stack_.empty() ? std::nullopt ------------------ | Branch (41:7): [True: 434, False: 0] ------------------ 42| 434| : std::make_optional(parsing_stack_.back()); 43| 434| return context_->storage->mutable_trace_file_table() 44| 434| ->Insert({parent, name, 0, 45| 434| context_->storage->InternString( 46| 434| TraceTypeToString(kUnknownTraceType)), 47| 434| std::nullopt}) 48| 434| .id; 49| 434|} _ZN8perfetto15trace_processor16TraceFileTracker12StartParsingENS0_6tables14TraceFileTable2IdENS0_9TraceTypeE: 57| 426| TraceType trace_type) { 58| 426| parsing_stack_.push_back(id); 59| 426| auto row = *context_->storage->mutable_trace_file_table()->FindById(id); 60| 426| row.set_trace_type( 61| 426| context_->storage->InternString(TraceTypeToString(trace_type))); 62| 426| row.set_processing_order(static_cast(processing_order_++)); 63| 426|} _ZN8perfetto15trace_processor16TraceFileTracker11DoneParsingENS0_6tables14TraceFileTable2IdEm: 65| 345|void TraceFileTracker::DoneParsing(tables::TraceFileTable::Id id, size_t size) { 66| 345| PERFETTO_CHECK(!parsing_stack_.empty() && parsing_stack_.back() == id); 67| 345| parsing_stack_.pop_back(); 68| 345| auto row = *context_->storage->mutable_trace_file_table()->FindById(id); 69| 345| row.set_size(static_cast(size)); 70| | 71| | // First file (root) 72| 345| if (id.value == 0) { ------------------ | Branch (72:7): [True: 345, False: 0] ------------------ 73| 345| context_->metadata_tracker->SetMetadata(metadata::trace_size_bytes, 74| 345| Variadic::Integer(row.size())); 75| 345| context_->metadata_tracker->SetMetadata(metadata::trace_type, 76| 345| Variadic::String(row.trace_type())); 77| 345| } 78| 345|} _ZN8perfetto15trace_processor16TraceFileTrackerC2EPNS0_21TraceProcessorContextE: 37| 2.03k| : context_(context) {} _ZN8perfetto15trace_processor16TraceFileTracker7AddFileEv: 40| 434| tables::TraceFileTable::Id AddFile() { return AddFileImpl(kNullStringId); } _ZN8perfetto15trace_processor16ProtoTraceParserD2Ev: 27| 2.03k|ProtoTraceParser::~ProtoTraceParser() = default; _ZN8perfetto15trace_processor15TrackCompressorC2EPNS0_21TraceProcessorContextE: 30| 2.03k| : context_(context) {} _ZN8perfetto15trace_processor15TrackCompressorD2Ev: 81| 2.03k| ~TrackCompressor() = default; _ZN8perfetto15trace_processor12TrackTrackerC2EPNS0_21TraceProcessorContextE: 39| 2.03k| : source_key_(context->storage->InternString("source")), 40| 2.03k| trace_id_key_(context->storage->InternString("trace_id")), 41| | trace_id_is_process_scoped_key_( 42| 2.03k| context->storage->InternString("trace_id_is_process_scoped")), 43| 2.03k| upid_(context->storage->InternString("upid")), 44| 2.03k| source_scope_key_(context->storage->InternString("source_scope")), 45| 2.03k| chrome_source_(context->storage->InternString("chrome")), 46| 2.03k| context_(context), 47| 2.03k| args_tracker_(context) {} _ZN8perfetto15trace_processor12TrackTracker22InternLegacyAsyncTrackENS0_10StringPool2IdEjlbS3_: 53| 118k| StringId source_scope) { 54| 118k| const StringId name = 55| 118k| context_->process_track_translation_table->TranslateName(raw_name); 56| | 57| 118k| auto args_fn = [&](ArgsTracker::BoundInserter& inserter) { 58| 118k| inserter.AddArg(source_key_, Variadic::String(chrome_source_)) 59| 118k| .AddArg(trace_id_key_, Variadic::Integer(trace_id)) 60| 118k| .AddArg(trace_id_is_process_scoped_key_, 61| 118k| Variadic::Boolean(trace_id_is_process_scoped)) 62| 118k| .AddArg(upid_, Variadic::UnsignedInteger(upid)) 63| 118k| .AddArg(source_scope_key_, Variadic::String(source_scope)); 64| 118k| }; 65| 118k| TrackId track_id; 66| 118k| bool inserted; 67| 118k| if (trace_id_is_process_scoped) { ------------------ | Branch (67:7): [True: 107k, False: 10.4k] ------------------ 68| 107k| static constexpr auto kBlueprint = tracks::SliceBlueprint( 69| 107k| "legacy_async_process_slice", 70| 107k| tracks::DimensionBlueprints(tracks::kProcessDimensionBlueprint, 71| 107k| tracks::StringDimensionBlueprint("scope"), 72| 107k| tracks::LongDimensionBlueprint("cookie")), 73| 107k| tracks::DynamicNameBlueprint()); 74| 107k| std::tie(track_id, inserted) = InternTrackInner( 75| 107k| kBlueprint, 76| 107k| tracks::Dimensions(upid, context_->storage->GetString(source_scope), 77| 107k| trace_id), 78| 107k| tracks::DynamicName(name), args_fn); 79| 107k| } else { 80| 10.4k| static constexpr auto kBlueprint = tracks::SliceBlueprint( 81| 10.4k| "legacy_async_global_slice", 82| 10.4k| tracks::DimensionBlueprints(tracks::StringDimensionBlueprint("scope"), 83| 10.4k| tracks::LongDimensionBlueprint("cookie")), 84| 10.4k| tracks::DynamicNameBlueprint()); 85| 10.4k| std::tie(track_id, inserted) = InternTrackInner( 86| 10.4k| kBlueprint, 87| 10.4k| tracks::Dimensions(context_->storage->GetString(source_scope), 88| 10.4k| trace_id), 89| 10.4k| tracks::DynamicName(name), args_fn); 90| 10.4k| } 91| | // The track may have been created for an end event without name. In 92| | // that case, update it with this event's name. 93| 118k| if (inserted && name != kNullStringId) { ------------------ | Branch (93:7): [True: 79.9k, False: 38.3k] | Branch (93:19): [True: 0, False: 79.9k] ------------------ 94| 0| auto& tracks = *context_->storage->mutable_track_table(); 95| 0| auto rr = *tracks.FindById(track_id); 96| 0| if (rr.name() == kNullStringId) { ------------------ | Branch (96:9): [True: 0, False: 0] ------------------ 97| 0| rr.set_name(name); 98| 0| } 99| 0| } 100| 118k| return track_id; 101| 118k|} _ZN8perfetto15trace_processor12TrackTracker8AddTrackERKNS0_6tracks13BlueprintBaseENS0_10StringPool2IdES7_PNS0_17GlobalArgsTracker10CompactArgEjRKNSt3__18functionIFvRNS0_11ArgsTracker13BoundInserterEEEE: 108| 267k| const SetArgsCallback& args) { 109| 267k| tables::TrackTable::Row row(name); 110| 267k| const auto* dims = blueprint.dimension_blueprints.data(); 111| 737k| for (uint32_t i = 0; i < d_size; ++i) { ------------------ | Branch (111:24): [True: 469k, False: 267k] ------------------ 112| 469k| base::StringView str(dims[i].name.data(), dims[i].name.size()); 113| 469k| if (str == "cpu" && d_args[i].value.type == Variadic::kInt) { ------------------ | Branch (113:9): [True: 0, False: 469k] | Branch (113:9): [True: 0, False: 469k] | Branch (113:25): [True: 0, False: 0] ------------------ 114| 0| context_->cpu_tracker->MarkCpuValid( 115| 0| static_cast(d_args[i].value.int_value)); 116| 469k| } else if (str == "utid" && d_args[i].value.type == Variadic::kInt) { ------------------ | Branch (116:16): [True: 116k, False: 352k] | Branch (116:16): [True: 116k, False: 352k] | Branch (116:33): [True: 116k, False: 0] ------------------ 117| 116k| row.utid = static_cast(d_args[i].value.int_value); 118| 352k| } else if (str == "upid" && d_args[i].value.type == Variadic::kInt) { ------------------ | Branch (118:16): [True: 114k, False: 238k] | Branch (118:16): [True: 114k, False: 238k] | Branch (118:33): [True: 114k, False: 0] ------------------ 119| 114k| row.upid = static_cast(d_args[i].value.int_value); 120| 114k| } 121| 469k| StringId key = context_->storage->InternString(str); 122| 469k| d_args[i].key = key; 123| 469k| d_args[i].flat_key = key; 124| 469k| } 125| | 126| 267k| row.machine_id = context_->machine_id(); 127| 267k| row.type = context_->storage->InternString( 128| 267k| base::StringView(blueprint.type.data(), blueprint.type.size())); 129| 267k| if (d_size > 0) { ------------------ | Branch (129:7): [True: 267k, False: 244] ------------------ 130| 267k| row.dimension_arg_set_id = 131| 267k| context_->global_args_tracker->AddArgSet(d_args, 0, d_size); 132| 267k| } 133| 267k| row.event_type = context_->storage->InternString(blueprint.event_type); 134| 267k| row.counter_unit = counter_unit; 135| 267k| TrackId id = context_->storage->mutable_track_table()->Insert(row).id; 136| 267k| if (args) { ------------------ | Branch (136:7): [True: 151k, False: 116k] ------------------ 137| 151k| auto inserter = args_tracker_.AddArgsTo(id); 138| 151k| args(inserter); 139| 151k| args_tracker_.Flush(); 140| 151k| } 141| 267k| return id; 142| 267k|} track_tracker.cc:_ZZN8perfetto15trace_processor12TrackTracker22InternLegacyAsyncTrackENS0_10StringPool2IdEjlbS3_ENK3$_0clERNS0_11ArgsTracker13BoundInserterE: 57| 79.9k| auto args_fn = [&](ArgsTracker::BoundInserter& inserter) { 58| 79.9k| inserter.AddArg(source_key_, Variadic::String(chrome_source_)) 59| 79.9k| .AddArg(trace_id_key_, Variadic::Integer(trace_id)) 60| 79.9k| .AddArg(trace_id_is_process_scoped_key_, 61| 79.9k| Variadic::Boolean(trace_id_is_process_scoped)) 62| 79.9k| .AddArg(upid_, Variadic::UnsignedInteger(upid)) 63| 79.9k| .AddArg(source_scope_key_, Variadic::String(source_scope)); 64| 79.9k| }; _ZN8perfetto15trace_processor12TrackTracker17InternThreadTrackEj: 115| 114k| TrackId InternThreadTrack(UniqueTid utid) { 116| 114k| static constexpr auto kBlueprint = tracks::SliceBlueprint( 117| 114k| "thread_execution", 118| 114k| tracks::DimensionBlueprints(tracks::kThreadDimensionBlueprint)); 119| 114k| return InternTrack(kBlueprint, tracks::Dimensions(utid)); 120| 114k| } _ZN8perfetto15trace_processor12TrackTracker11InternTrackINS0_6tracks10BlueprintTINS3_14NameBlueprintT4AutoENS3_14UnitBlueprintT7UnknownEJNS3_19DimensionBlueprintTIjEEEEEEENS0_6tables10TrackTable2IdERKT_RKNSF_12dimensions_tERKNSF_6name_tERKNSt3__18functionIFvRNS0_11ArgsTracker13BoundInserterEEEERKNSF_6unit_tE: 104| 114k| const typename BlueprintT::unit_t& unit = tracks::BlueprintUnit()) { 105| 114k| return InternTrackInner(bp, dims, name, args, unit).first; 106| 114k| } _ZN8perfetto15trace_processor12TrackTracker16InternTrackInnerINS0_6tracks10BlueprintTINS3_14NameBlueprintT4AutoENS3_14UnitBlueprintT7UnknownEJNS3_19DimensionBlueprintTIjEEEEEEENSt3__14pairINS0_6tables10TrackTable2IdEbEERKT_RKNSI_12dimensions_tERKNSI_6name_tERKNSC_8functionIFvRNS0_11ArgsTracker13BoundInserterEEEERKNSI_6unit_tE: 151| 114k| const typename BlueprintT::unit_t& unit = tracks::BlueprintUnit()) { 152| 114k| uint64_t hash = tracks::HashFromBlueprintAndDimensions(bp, dims); 153| 114k| auto [it, inserted] = tracks_.Insert(hash, {}); 154| 114k| if (inserted) { ------------------ | Branch (154:9): [True: 109k, False: 5.17k] ------------------ 155| 109k| std::array a; 156| 109k| DimensionsToArgs<0>(dims, bp.dimension_blueprints.data(), a.data()); 157| 109k| StringId n; 158| 109k| using NBT = tracks::NameBlueprintT; 159| 109k| using name_blueprint_t = typename BlueprintT::name_blueprint_t; 160| 109k| if constexpr (std::is_same_v) { 161| 109k| n = kNullStringId; 162| | } else if constexpr (std::is_same_v) { 163| | n = context_->storage->InternString(bp.name_blueprint.name); 164| | } else if constexpr (std::is_base_of_v) { 165| | n = context_->storage->InternString( 166| | std::apply(bp.name_blueprint.fn, dims).string_view()); 167| | } else { 168| | static_assert(std::is_same_v); 169| | n = name; 170| | } 171| 109k| using UBT = tracks::UnitBlueprintT; 172| 109k| using unit_blueprint_t = typename BlueprintT::unit_blueprint_t; 173| 109k| StringId u; 174| 109k| if constexpr (std::is_same_v) { 175| 109k| u = kNullStringId; 176| | } else if constexpr (std::is_same_v) { 177| | u = context_->storage->InternString(bp.unit_blueprint.name); 178| | } else { 179| | static_assert(std::is_same_v); 180| | u = unit; 181| | } 182| | // GCC warns about the variables being unused even they are in certain 183| | // constexpr branches above. Just use them here to suppress the warning. 184| 109k| base::ignore_result(name, unit); 185| 109k| static constexpr uint32_t kDimensionCount = 186| 109k| std::tuple_size_v; 187| 109k| *it = AddTrack(bp, n, u, a.data(), kDimensionCount, args); 188| 109k| } 189| 114k| return std::make_pair(*it, inserted); 190| 114k| } _ZN8perfetto15trace_processor12TrackTracker16DimensionsToArgsILm0ENSt3__15tupleIJjEEEEEvRKT0_PKNS0_6tracks22DimensionBlueprintBaseEPNS0_17GlobalArgsTracker10CompactArgE: 195| 109k| GlobalArgsTracker::CompactArg* a) { 196| 109k| static constexpr size_t kTupleSize = std::tuple_size_v; 197| 109k| if constexpr (i < kTupleSize) { 198| 109k| using elem_t = std::tuple_element_t; 199| 109k| if constexpr (std::is_same_v) { 200| 109k| a[i].value = Variadic::Integer(std::get(dimensions)); 201| | } else if constexpr (std::is_integral_v) { 202| | a[i].value = Variadic::Integer(std::get(dimensions)); 203| | } else { 204| | static_assert(std::is_same_v, 205| | "Unknown type for dimension"); 206| | a[i].value = Variadic::String( 207| | context_->storage->InternString(std::get(dimensions))); 208| | } 209| 109k| DimensionsToArgs(dimensions, dimensions_schema, a); 210| 109k| } 211| | // Required for GCC to not complain. 212| 109k| base::ignore_result(dimensions_schema); 213| 109k| } _ZN8perfetto15trace_processor12TrackTracker16DimensionsToArgsILm1ENSt3__15tupleIJjEEEEEvRKT0_PKNS0_6tracks22DimensionBlueprintBaseEPNS0_17GlobalArgsTracker10CompactArgE: 195| 109k| GlobalArgsTracker::CompactArg* a) { 196| 109k| static constexpr size_t kTupleSize = std::tuple_size_v; 197| | if constexpr (i < kTupleSize) { 198| | using elem_t = std::tuple_element_t; 199| | if constexpr (std::is_same_v) { 200| | a[i].value = Variadic::Integer(std::get(dimensions)); 201| | } else if constexpr (std::is_integral_v) { 202| | a[i].value = Variadic::Integer(std::get(dimensions)); 203| | } else { 204| | static_assert(std::is_same_v, 205| | "Unknown type for dimension"); 206| | a[i].value = Variadic::String( 207| | context_->storage->InternString(std::get(dimensions))); 208| | } 209| | DimensionsToArgs(dimensions, dimensions_schema, a); 210| | } 211| | // Required for GCC to not complain. 212| 109k| base::ignore_result(dimensions_schema); 213| 109k| } _ZN8perfetto15trace_processor12TrackTracker16DimensionsToArgsILm0ENSt3__15tupleIJjNS_4base10StringViewEEEEEEvRKT0_PKNS0_6tracks22DimensionBlueprintBaseEPNS0_17GlobalArgsTracker10CompactArgE: 195| 7.13k| GlobalArgsTracker::CompactArg* a) { 196| 7.13k| static constexpr size_t kTupleSize = std::tuple_size_v; 197| 7.13k| if constexpr (i < kTupleSize) { 198| 7.13k| using elem_t = std::tuple_element_t; 199| 7.13k| if constexpr (std::is_same_v) { 200| 7.13k| a[i].value = Variadic::Integer(std::get(dimensions)); 201| | } else if constexpr (std::is_integral_v) { 202| | a[i].value = Variadic::Integer(std::get(dimensions)); 203| | } else { 204| | static_assert(std::is_same_v, 205| | "Unknown type for dimension"); 206| | a[i].value = Variadic::String( 207| | context_->storage->InternString(std::get(dimensions))); 208| | } 209| 7.13k| DimensionsToArgs(dimensions, dimensions_schema, a); 210| 7.13k| } 211| | // Required for GCC to not complain. 212| 7.13k| base::ignore_result(dimensions_schema); 213| 7.13k| } _ZN8perfetto15trace_processor12TrackTracker16DimensionsToArgsILm1ENSt3__15tupleIJjNS_4base10StringViewEEEEEEvRKT0_PKNS0_6tracks22DimensionBlueprintBaseEPNS0_17GlobalArgsTracker10CompactArgE: 195| 7.13k| GlobalArgsTracker::CompactArg* a) { 196| 7.13k| static constexpr size_t kTupleSize = std::tuple_size_v; 197| 7.13k| if constexpr (i < kTupleSize) { 198| 7.13k| using elem_t = std::tuple_element_t; 199| | if constexpr (std::is_same_v) { 200| | a[i].value = Variadic::Integer(std::get(dimensions)); 201| | } else if constexpr (std::is_integral_v) { 202| | a[i].value = Variadic::Integer(std::get(dimensions)); 203| 7.13k| } else { 204| 7.13k| static_assert(std::is_same_v, 205| 7.13k| "Unknown type for dimension"); 206| 7.13k| a[i].value = Variadic::String( 207| 7.13k| context_->storage->InternString(std::get(dimensions))); 208| 7.13k| } 209| 7.13k| DimensionsToArgs(dimensions, dimensions_schema, a); 210| 7.13k| } 211| | // Required for GCC to not complain. 212| 7.13k| base::ignore_result(dimensions_schema); 213| 7.13k| } _ZN8perfetto15trace_processor12TrackTracker16DimensionsToArgsILm2ENSt3__15tupleIJjNS_4base10StringViewEEEEEEvRKT0_PKNS0_6tracks22DimensionBlueprintBaseEPNS0_17GlobalArgsTracker10CompactArgE: 195| 7.13k| GlobalArgsTracker::CompactArg* a) { 196| 7.13k| static constexpr size_t kTupleSize = std::tuple_size_v; 197| | if constexpr (i < kTupleSize) { 198| | using elem_t = std::tuple_element_t; 199| | if constexpr (std::is_same_v) { 200| | a[i].value = Variadic::Integer(std::get(dimensions)); 201| | } else if constexpr (std::is_integral_v) { 202| | a[i].value = Variadic::Integer(std::get(dimensions)); 203| | } else { 204| | static_assert(std::is_same_v, 205| | "Unknown type for dimension"); 206| | a[i].value = Variadic::String( 207| | context_->storage->InternString(std::get(dimensions))); 208| | } 209| | DimensionsToArgs(dimensions, dimensions_schema, a); 210| | } 211| | // Required for GCC to not complain. 212| 7.13k| base::ignore_result(dimensions_schema); 213| 7.13k| } _ZN8perfetto15trace_processor12TrackTracker11InternTrackINS0_6tracks10BlueprintTINS3_14NameBlueprintT7DynamicENS3_14UnitBlueprintT7UnknownEJNS3_19DimensionBlueprintTIjEENS9_INS_4base10StringViewEEEEEEEENS0_6tables10TrackTable2IdERKT_RKNSI_12dimensions_tERKNSI_6name_tERKNSt3__18functionIFvRNS0_11ArgsTracker13BoundInserterEEEERKNSI_6unit_tE: 104| 279k| const typename BlueprintT::unit_t& unit = tracks::BlueprintUnit()) { 105| 279k| return InternTrackInner(bp, dims, name, args, unit).first; 106| 279k| } _ZN8perfetto15trace_processor12TrackTracker16InternTrackInnerINS0_6tracks10BlueprintTINS3_14NameBlueprintT7DynamicENS3_14UnitBlueprintT7UnknownEJNS3_19DimensionBlueprintTIjEENS9_INS_4base10StringViewEEEEEEEENSt3__14pairINS0_6tables10TrackTable2IdEbEERKT_RKNSL_12dimensions_tERKNSL_6name_tERKNSF_8functionIFvRNS0_11ArgsTracker13BoundInserterEEEERKNSL_6unit_tE: 151| 279k| const typename BlueprintT::unit_t& unit = tracks::BlueprintUnit()) { 152| 279k| uint64_t hash = tracks::HashFromBlueprintAndDimensions(bp, dims); 153| 279k| auto [it, inserted] = tracks_.Insert(hash, {}); 154| 279k| if (inserted) { ------------------ | Branch (154:9): [True: 7.13k, False: 272k] ------------------ 155| 7.13k| std::array a; 156| 7.13k| DimensionsToArgs<0>(dims, bp.dimension_blueprints.data(), a.data()); 157| 7.13k| StringId n; 158| 7.13k| using NBT = tracks::NameBlueprintT; 159| 7.13k| using name_blueprint_t = typename BlueprintT::name_blueprint_t; 160| | if constexpr (std::is_same_v) { 161| | n = kNullStringId; 162| | } else if constexpr (std::is_same_v) { 163| | n = context_->storage->InternString(bp.name_blueprint.name); 164| | } else if constexpr (std::is_base_of_v) { 165| | n = context_->storage->InternString( 166| | std::apply(bp.name_blueprint.fn, dims).string_view()); 167| 7.13k| } else { 168| 7.13k| static_assert(std::is_same_v); 169| 7.13k| n = name; 170| 7.13k| } 171| 7.13k| using UBT = tracks::UnitBlueprintT; 172| 7.13k| using unit_blueprint_t = typename BlueprintT::unit_blueprint_t; 173| 7.13k| StringId u; 174| 7.13k| if constexpr (std::is_same_v) { 175| 7.13k| u = kNullStringId; 176| | } else if constexpr (std::is_same_v) { 177| | u = context_->storage->InternString(bp.unit_blueprint.name); 178| | } else { 179| | static_assert(std::is_same_v); 180| | u = unit; 181| | } 182| | // GCC warns about the variables being unused even they are in certain 183| | // constexpr branches above. Just use them here to suppress the warning. 184| 7.13k| base::ignore_result(name, unit); 185| 7.13k| static constexpr uint32_t kDimensionCount = 186| 7.13k| std::tuple_size_v; 187| 7.13k| *it = AddTrack(bp, n, u, a.data(), kDimensionCount, args); 188| 7.13k| } 189| 279k| return std::make_pair(*it, inserted); 190| 279k| } _ZN8perfetto15trace_processor12TrackTracker16InternTrackInnerINS0_6tracks10BlueprintTINS3_14NameBlueprintT7DynamicENS3_14UnitBlueprintT7UnknownEJNS3_19DimensionBlueprintTIjEENS9_INS_4base10StringViewEEENS9_IlEEEEEEENSt3__14pairINS0_6tables10TrackTable2IdEbEERKT_RKNSM_12dimensions_tERKNSM_6name_tERKNSG_8functionIFvRNS0_11ArgsTracker13BoundInserterEEEERKNSM_6unit_tE: 151| 107k| const typename BlueprintT::unit_t& unit = tracks::BlueprintUnit()) { 152| 107k| uint64_t hash = tracks::HashFromBlueprintAndDimensions(bp, dims); 153| 107k| auto [it, inserted] = tracks_.Insert(hash, {}); 154| 107k| if (inserted) { ------------------ | Branch (154:9): [True: 79.7k, False: 28.0k] ------------------ 155| 79.7k| std::array a; 156| 79.7k| DimensionsToArgs<0>(dims, bp.dimension_blueprints.data(), a.data()); 157| 79.7k| StringId n; 158| 79.7k| using NBT = tracks::NameBlueprintT; 159| 79.7k| using name_blueprint_t = typename BlueprintT::name_blueprint_t; 160| | if constexpr (std::is_same_v) { 161| | n = kNullStringId; 162| | } else if constexpr (std::is_same_v) { 163| | n = context_->storage->InternString(bp.name_blueprint.name); 164| | } else if constexpr (std::is_base_of_v) { 165| | n = context_->storage->InternString( 166| | std::apply(bp.name_blueprint.fn, dims).string_view()); 167| 79.7k| } else { 168| 79.7k| static_assert(std::is_same_v); 169| 79.7k| n = name; 170| 79.7k| } 171| 79.7k| using UBT = tracks::UnitBlueprintT; 172| 79.7k| using unit_blueprint_t = typename BlueprintT::unit_blueprint_t; 173| 79.7k| StringId u; 174| 79.7k| if constexpr (std::is_same_v) { 175| 79.7k| u = kNullStringId; 176| | } else if constexpr (std::is_same_v) { 177| | u = context_->storage->InternString(bp.unit_blueprint.name); 178| | } else { 179| | static_assert(std::is_same_v); 180| | u = unit; 181| | } 182| | // GCC warns about the variables being unused even they are in certain 183| | // constexpr branches above. Just use them here to suppress the warning. 184| 79.7k| base::ignore_result(name, unit); 185| 79.7k| static constexpr uint32_t kDimensionCount = 186| 79.7k| std::tuple_size_v; 187| 79.7k| *it = AddTrack(bp, n, u, a.data(), kDimensionCount, args); 188| 79.7k| } 189| 107k| return std::make_pair(*it, inserted); 190| 107k| } _ZN8perfetto15trace_processor12TrackTracker16DimensionsToArgsILm0ENSt3__15tupleIJjNS_4base10StringViewElEEEEEvRKT0_PKNS0_6tracks22DimensionBlueprintBaseEPNS0_17GlobalArgsTracker10CompactArgE: 195| 79.7k| GlobalArgsTracker::CompactArg* a) { 196| 79.7k| static constexpr size_t kTupleSize = std::tuple_size_v; 197| 79.7k| if constexpr (i < kTupleSize) { 198| 79.7k| using elem_t = std::tuple_element_t; 199| 79.7k| if constexpr (std::is_same_v) { 200| 79.7k| a[i].value = Variadic::Integer(std::get(dimensions)); 201| | } else if constexpr (std::is_integral_v) { 202| | a[i].value = Variadic::Integer(std::get(dimensions)); 203| | } else { 204| | static_assert(std::is_same_v, 205| | "Unknown type for dimension"); 206| | a[i].value = Variadic::String( 207| | context_->storage->InternString(std::get(dimensions))); 208| | } 209| 79.7k| DimensionsToArgs(dimensions, dimensions_schema, a); 210| 79.7k| } 211| | // Required for GCC to not complain. 212| 79.7k| base::ignore_result(dimensions_schema); 213| 79.7k| } _ZN8perfetto15trace_processor12TrackTracker16DimensionsToArgsILm1ENSt3__15tupleIJjNS_4base10StringViewElEEEEEvRKT0_PKNS0_6tracks22DimensionBlueprintBaseEPNS0_17GlobalArgsTracker10CompactArgE: 195| 79.7k| GlobalArgsTracker::CompactArg* a) { 196| 79.7k| static constexpr size_t kTupleSize = std::tuple_size_v; 197| 79.7k| if constexpr (i < kTupleSize) { 198| 79.7k| using elem_t = std::tuple_element_t; 199| | if constexpr (std::is_same_v) { 200| | a[i].value = Variadic::Integer(std::get(dimensions)); 201| | } else if constexpr (std::is_integral_v) { 202| | a[i].value = Variadic::Integer(std::get(dimensions)); 203| 79.7k| } else { 204| 79.7k| static_assert(std::is_same_v, 205| 79.7k| "Unknown type for dimension"); 206| 79.7k| a[i].value = Variadic::String( 207| 79.7k| context_->storage->InternString(std::get(dimensions))); 208| 79.7k| } 209| 79.7k| DimensionsToArgs(dimensions, dimensions_schema, a); 210| 79.7k| } 211| | // Required for GCC to not complain. 212| 79.7k| base::ignore_result(dimensions_schema); 213| 79.7k| } _ZN8perfetto15trace_processor12TrackTracker16DimensionsToArgsILm2ENSt3__15tupleIJjNS_4base10StringViewElEEEEEvRKT0_PKNS0_6tracks22DimensionBlueprintBaseEPNS0_17GlobalArgsTracker10CompactArgE: 195| 79.7k| GlobalArgsTracker::CompactArg* a) { 196| 79.7k| static constexpr size_t kTupleSize = std::tuple_size_v; 197| 79.7k| if constexpr (i < kTupleSize) { 198| 79.7k| using elem_t = std::tuple_element_t; 199| | if constexpr (std::is_same_v) { 200| | a[i].value = Variadic::Integer(std::get(dimensions)); 201| 79.7k| } else if constexpr (std::is_integral_v) { 202| 79.7k| a[i].value = Variadic::Integer(std::get(dimensions)); 203| | } else { 204| | static_assert(std::is_same_v, 205| | "Unknown type for dimension"); 206| | a[i].value = Variadic::String( 207| | context_->storage->InternString(std::get(dimensions))); 208| | } 209| 79.7k| DimensionsToArgs(dimensions, dimensions_schema, a); 210| 79.7k| } 211| | // Required for GCC to not complain. 212| 79.7k| base::ignore_result(dimensions_schema); 213| 79.7k| } _ZN8perfetto15trace_processor12TrackTracker16DimensionsToArgsILm3ENSt3__15tupleIJjNS_4base10StringViewElEEEEEvRKT0_PKNS0_6tracks22DimensionBlueprintBaseEPNS0_17GlobalArgsTracker10CompactArgE: 195| 79.7k| GlobalArgsTracker::CompactArg* a) { 196| 79.7k| static constexpr size_t kTupleSize = std::tuple_size_v; 197| | if constexpr (i < kTupleSize) { 198| | using elem_t = std::tuple_element_t; 199| | if constexpr (std::is_same_v) { 200| | a[i].value = Variadic::Integer(std::get(dimensions)); 201| | } else if constexpr (std::is_integral_v) { 202| | a[i].value = Variadic::Integer(std::get(dimensions)); 203| | } else { 204| | static_assert(std::is_same_v, 205| | "Unknown type for dimension"); 206| | a[i].value = Variadic::String( 207| | context_->storage->InternString(std::get(dimensions))); 208| | } 209| | DimensionsToArgs(dimensions, dimensions_schema, a); 210| | } 211| | // Required for GCC to not complain. 212| 79.7k| base::ignore_result(dimensions_schema); 213| 79.7k| } _ZN8perfetto15trace_processor12TrackTracker16InternTrackInnerINS0_6tracks10BlueprintTINS3_14NameBlueprintT7DynamicENS3_14UnitBlueprintT7UnknownEJNS3_19DimensionBlueprintTINS_4base10StringViewEEENS9_IlEEEEEEENSt3__14pairINS0_6tables10TrackTable2IdEbEERKT_RKNSL_12dimensions_tERKNSL_6name_tERKNSF_8functionIFvRNS0_11ArgsTracker13BoundInserterEEEERKNSL_6unit_tE: 151| 10.4k| const typename BlueprintT::unit_t& unit = tracks::BlueprintUnit()) { 152| 10.4k| uint64_t hash = tracks::HashFromBlueprintAndDimensions(bp, dims); 153| 10.4k| auto [it, inserted] = tracks_.Insert(hash, {}); 154| 10.4k| if (inserted) { ------------------ | Branch (154:9): [True: 153, False: 10.2k] ------------------ 155| 153| std::array a; 156| 153| DimensionsToArgs<0>(dims, bp.dimension_blueprints.data(), a.data()); 157| 153| StringId n; 158| 153| using NBT = tracks::NameBlueprintT; 159| 153| using name_blueprint_t = typename BlueprintT::name_blueprint_t; 160| | if constexpr (std::is_same_v) { 161| | n = kNullStringId; 162| | } else if constexpr (std::is_same_v) { 163| | n = context_->storage->InternString(bp.name_blueprint.name); 164| | } else if constexpr (std::is_base_of_v) { 165| | n = context_->storage->InternString( 166| | std::apply(bp.name_blueprint.fn, dims).string_view()); 167| 153| } else { 168| 153| static_assert(std::is_same_v); 169| 153| n = name; 170| 153| } 171| 153| using UBT = tracks::UnitBlueprintT; 172| 153| using unit_blueprint_t = typename BlueprintT::unit_blueprint_t; 173| 153| StringId u; 174| 153| if constexpr (std::is_same_v) { 175| 153| u = kNullStringId; 176| | } else if constexpr (std::is_same_v) { 177| | u = context_->storage->InternString(bp.unit_blueprint.name); 178| | } else { 179| | static_assert(std::is_same_v); 180| | u = unit; 181| | } 182| | // GCC warns about the variables being unused even they are in certain 183| | // constexpr branches above. Just use them here to suppress the warning. 184| 153| base::ignore_result(name, unit); 185| 153| static constexpr uint32_t kDimensionCount = 186| 153| std::tuple_size_v; 187| 153| *it = AddTrack(bp, n, u, a.data(), kDimensionCount, args); 188| 153| } 189| 10.4k| return std::make_pair(*it, inserted); 190| 10.4k| } _ZN8perfetto15trace_processor12TrackTracker16DimensionsToArgsILm0ENSt3__15tupleIJNS_4base10StringViewElEEEEEvRKT0_PKNS0_6tracks22DimensionBlueprintBaseEPNS0_17GlobalArgsTracker10CompactArgE: 195| 153| GlobalArgsTracker::CompactArg* a) { 196| 153| static constexpr size_t kTupleSize = std::tuple_size_v; 197| 153| if constexpr (i < kTupleSize) { 198| 153| using elem_t = std::tuple_element_t; 199| | if constexpr (std::is_same_v) { 200| | a[i].value = Variadic::Integer(std::get(dimensions)); 201| | } else if constexpr (std::is_integral_v) { 202| | a[i].value = Variadic::Integer(std::get(dimensions)); 203| 153| } else { 204| 153| static_assert(std::is_same_v, 205| 153| "Unknown type for dimension"); 206| 153| a[i].value = Variadic::String( 207| 153| context_->storage->InternString(std::get(dimensions))); 208| 153| } 209| 153| DimensionsToArgs(dimensions, dimensions_schema, a); 210| 153| } 211| | // Required for GCC to not complain. 212| 153| base::ignore_result(dimensions_schema); 213| 153| } _ZN8perfetto15trace_processor12TrackTracker16DimensionsToArgsILm1ENSt3__15tupleIJNS_4base10StringViewElEEEEEvRKT0_PKNS0_6tracks22DimensionBlueprintBaseEPNS0_17GlobalArgsTracker10CompactArgE: 195| 153| GlobalArgsTracker::CompactArg* a) { 196| 153| static constexpr size_t kTupleSize = std::tuple_size_v; 197| 153| if constexpr (i < kTupleSize) { 198| 153| using elem_t = std::tuple_element_t; 199| | if constexpr (std::is_same_v) { 200| | a[i].value = Variadic::Integer(std::get(dimensions)); 201| 153| } else if constexpr (std::is_integral_v) { 202| 153| a[i].value = Variadic::Integer(std::get(dimensions)); 203| | } else { 204| | static_assert(std::is_same_v, 205| | "Unknown type for dimension"); 206| | a[i].value = Variadic::String( 207| | context_->storage->InternString(std::get(dimensions))); 208| | } 209| 153| DimensionsToArgs(dimensions, dimensions_schema, a); 210| 153| } 211| | // Required for GCC to not complain. 212| 153| base::ignore_result(dimensions_schema); 213| 153| } _ZN8perfetto15trace_processor12TrackTracker16DimensionsToArgsILm2ENSt3__15tupleIJNS_4base10StringViewElEEEEEvRKT0_PKNS0_6tracks22DimensionBlueprintBaseEPNS0_17GlobalArgsTracker10CompactArgE: 195| 153| GlobalArgsTracker::CompactArg* a) { 196| 153| static constexpr size_t kTupleSize = std::tuple_size_v; 197| | if constexpr (i < kTupleSize) { 198| | using elem_t = std::tuple_element_t; 199| | if constexpr (std::is_same_v) { 200| | a[i].value = Variadic::Integer(std::get(dimensions)); 201| | } else if constexpr (std::is_integral_v) { 202| | a[i].value = Variadic::Integer(std::get(dimensions)); 203| | } else { 204| | static_assert(std::is_same_v, 205| | "Unknown type for dimension"); 206| | a[i].value = Variadic::String( 207| | context_->storage->InternString(std::get(dimensions))); 208| | } 209| | DimensionsToArgs(dimensions, dimensions_schema, a); 210| | } 211| | // Required for GCC to not complain. 212| 153| base::ignore_result(dimensions_schema); 213| 153| } _ZN8perfetto15trace_processor12TrackTracker11InternTrackINS0_6tracks10BlueprintTINS3_14NameBlueprintT4AutoENS3_14UnitBlueprintT7UnknownEJEEEEENS0_6tables10TrackTable2IdERKT_RKNSD_12dimensions_tERKNSD_6name_tERKNSt3__18functionIFvRNS0_11ArgsTracker13BoundInserterEEEERKNSD_6unit_tE: 104| 641| const typename BlueprintT::unit_t& unit = tracks::BlueprintUnit()) { 105| 641| return InternTrackInner(bp, dims, name, args, unit).first; 106| 641| } _ZN8perfetto15trace_processor12TrackTracker16InternTrackInnerINS0_6tracks10BlueprintTINS3_14NameBlueprintT4AutoENS3_14UnitBlueprintT7UnknownEJEEEEENSt3__14pairINS0_6tables10TrackTable2IdEbEERKT_RKNSG_12dimensions_tERKNSG_6name_tERKNSA_8functionIFvRNS0_11ArgsTracker13BoundInserterEEEERKNSG_6unit_tE: 151| 641| const typename BlueprintT::unit_t& unit = tracks::BlueprintUnit()) { 152| 641| uint64_t hash = tracks::HashFromBlueprintAndDimensions(bp, dims); 153| 641| auto [it, inserted] = tracks_.Insert(hash, {}); 154| 641| if (inserted) { ------------------ | Branch (154:9): [True: 244, False: 397] ------------------ 155| 244| std::array a; 156| 244| DimensionsToArgs<0>(dims, bp.dimension_blueprints.data(), a.data()); 157| 244| StringId n; 158| 244| using NBT = tracks::NameBlueprintT; 159| 244| using name_blueprint_t = typename BlueprintT::name_blueprint_t; 160| 244| if constexpr (std::is_same_v) { 161| 244| n = kNullStringId; 162| | } else if constexpr (std::is_same_v) { 163| | n = context_->storage->InternString(bp.name_blueprint.name); 164| | } else if constexpr (std::is_base_of_v) { 165| | n = context_->storage->InternString( 166| | std::apply(bp.name_blueprint.fn, dims).string_view()); 167| | } else { 168| | static_assert(std::is_same_v); 169| | n = name; 170| | } 171| 244| using UBT = tracks::UnitBlueprintT; 172| 244| using unit_blueprint_t = typename BlueprintT::unit_blueprint_t; 173| 244| StringId u; 174| 244| if constexpr (std::is_same_v) { 175| 244| u = kNullStringId; 176| | } else if constexpr (std::is_same_v) { 177| | u = context_->storage->InternString(bp.unit_blueprint.name); 178| | } else { 179| | static_assert(std::is_same_v); 180| | u = unit; 181| | } 182| | // GCC warns about the variables being unused even they are in certain 183| | // constexpr branches above. Just use them here to suppress the warning. 184| 244| base::ignore_result(name, unit); 185| 244| static constexpr uint32_t kDimensionCount = 186| 244| std::tuple_size_v; 187| 244| *it = AddTrack(bp, n, u, a.data(), kDimensionCount, args); 188| 244| } 189| 641| return std::make_pair(*it, inserted); 190| 641| } _ZN8perfetto15trace_processor12TrackTracker16DimensionsToArgsILm0ENSt3__15tupleIJEEEEEvRKT0_PKNS0_6tracks22DimensionBlueprintBaseEPNS0_17GlobalArgsTracker10CompactArgE: 195| 244| GlobalArgsTracker::CompactArg* a) { 196| 244| static constexpr size_t kTupleSize = std::tuple_size_v; 197| | if constexpr (i < kTupleSize) { 198| | using elem_t = std::tuple_element_t; 199| | if constexpr (std::is_same_v) { 200| | a[i].value = Variadic::Integer(std::get(dimensions)); 201| | } else if constexpr (std::is_integral_v) { 202| | a[i].value = Variadic::Integer(std::get(dimensions)); 203| | } else { 204| | static_assert(std::is_same_v, 205| | "Unknown type for dimension"); 206| | a[i].value = Variadic::String( 207| | context_->storage->InternString(std::get(dimensions))); 208| | } 209| | DimensionsToArgs(dimensions, dimensions_schema, a); 210| | } 211| | // Required for GCC to not complain. 212| 244| base::ignore_result(dimensions_schema); 213| 244| } _ZN8perfetto15trace_processor12TrackTracker11InternTrackINS0_6tracks10BlueprintTINS3_14NameBlueprintT7DynamicENS3_14UnitBlueprintT7UnknownEJNS3_19DimensionBlueprintTIjEEEEEEENS0_6tables10TrackTable2IdERKT_RKNSF_12dimensions_tERKNSF_6name_tERKNSt3__18functionIFvRNS0_11ArgsTracker13BoundInserterEEEERKNSF_6unit_tE: 104| 48| const typename BlueprintT::unit_t& unit = tracks::BlueprintUnit()) { 105| 48| return InternTrackInner(bp, dims, name, args, unit).first; 106| 48| } _ZN8perfetto15trace_processor12TrackTracker16InternTrackInnerINS0_6tracks10BlueprintTINS3_14NameBlueprintT7DynamicENS3_14UnitBlueprintT7UnknownEJNS3_19DimensionBlueprintTIjEEEEEEENSt3__14pairINS0_6tables10TrackTable2IdEbEERKT_RKNSI_12dimensions_tERKNSI_6name_tERKNSC_8functionIFvRNS0_11ArgsTracker13BoundInserterEEEERKNSI_6unit_tE: 151| 48| const typename BlueprintT::unit_t& unit = tracks::BlueprintUnit()) { 152| 48| uint64_t hash = tracks::HashFromBlueprintAndDimensions(bp, dims); 153| 48| auto [it, inserted] = tracks_.Insert(hash, {}); 154| 48| if (inserted) { ------------------ | Branch (154:9): [True: 6, False: 42] ------------------ 155| 6| std::array a; 156| 6| DimensionsToArgs<0>(dims, bp.dimension_blueprints.data(), a.data()); 157| 6| StringId n; 158| 6| using NBT = tracks::NameBlueprintT; 159| 6| using name_blueprint_t = typename BlueprintT::name_blueprint_t; 160| | if constexpr (std::is_same_v) { 161| | n = kNullStringId; 162| | } else if constexpr (std::is_same_v) { 163| | n = context_->storage->InternString(bp.name_blueprint.name); 164| | } else if constexpr (std::is_base_of_v) { 165| | n = context_->storage->InternString( 166| | std::apply(bp.name_blueprint.fn, dims).string_view()); 167| 6| } else { 168| 6| static_assert(std::is_same_v); 169| 6| n = name; 170| 6| } 171| 6| using UBT = tracks::UnitBlueprintT; 172| 6| using unit_blueprint_t = typename BlueprintT::unit_blueprint_t; 173| 6| StringId u; 174| 6| if constexpr (std::is_same_v) { 175| 6| u = kNullStringId; 176| | } else if constexpr (std::is_same_v) { 177| | u = context_->storage->InternString(bp.unit_blueprint.name); 178| | } else { 179| | static_assert(std::is_same_v); 180| | u = unit; 181| | } 182| | // GCC warns about the variables being unused even they are in certain 183| | // constexpr branches above. Just use them here to suppress the warning. 184| 6| base::ignore_result(name, unit); 185| 6| static constexpr uint32_t kDimensionCount = 186| 6| std::tuple_size_v; 187| 6| *it = AddTrack(bp, n, u, a.data(), kDimensionCount, args); 188| 6| } 189| 48| return std::make_pair(*it, inserted); 190| 48| } _ZN8perfetto15trace_processor12TrackTracker11InternTrackINS0_6tracks10BlueprintTINS3_14NameBlueprintT7DynamicENS3_14UnitBlueprintT7DynamicEJNS3_19DimensionBlueprintTIjEENS9_IlEEEEEEENS0_6tables10TrackTable2IdERKT_RKNSG_12dimensions_tERKNSG_6name_tERKNSt3__18functionIFvRNS0_11ArgsTracker13BoundInserterEEEERKNSG_6unit_tE: 104| 160| const typename BlueprintT::unit_t& unit = tracks::BlueprintUnit()) { 105| 160| return InternTrackInner(bp, dims, name, args, unit).first; 106| 160| } _ZN8perfetto15trace_processor12TrackTracker16InternTrackInnerINS0_6tracks10BlueprintTINS3_14NameBlueprintT7DynamicENS3_14UnitBlueprintT7DynamicEJNS3_19DimensionBlueprintTIjEENS9_IlEEEEEEENSt3__14pairINS0_6tables10TrackTable2IdEbEERKT_RKNSJ_12dimensions_tERKNSJ_6name_tERKNSD_8functionIFvRNS0_11ArgsTracker13BoundInserterEEEERKNSJ_6unit_tE: 151| 160| const typename BlueprintT::unit_t& unit = tracks::BlueprintUnit()) { 152| 160| uint64_t hash = tracks::HashFromBlueprintAndDimensions(bp, dims); 153| 160| auto [it, inserted] = tracks_.Insert(hash, {}); 154| 160| if (inserted) { ------------------ | Branch (154:9): [True: 160, False: 0] ------------------ 155| 160| std::array a; 156| 160| DimensionsToArgs<0>(dims, bp.dimension_blueprints.data(), a.data()); 157| 160| StringId n; 158| 160| using NBT = tracks::NameBlueprintT; 159| 160| using name_blueprint_t = typename BlueprintT::name_blueprint_t; 160| | if constexpr (std::is_same_v) { 161| | n = kNullStringId; 162| | } else if constexpr (std::is_same_v) { 163| | n = context_->storage->InternString(bp.name_blueprint.name); 164| | } else if constexpr (std::is_base_of_v) { 165| | n = context_->storage->InternString( 166| | std::apply(bp.name_blueprint.fn, dims).string_view()); 167| 160| } else { 168| 160| static_assert(std::is_same_v); 169| 160| n = name; 170| 160| } 171| 160| using UBT = tracks::UnitBlueprintT; 172| 160| using unit_blueprint_t = typename BlueprintT::unit_blueprint_t; 173| 160| StringId u; 174| | if constexpr (std::is_same_v) { 175| | u = kNullStringId; 176| | } else if constexpr (std::is_same_v) { 177| | u = context_->storage->InternString(bp.unit_blueprint.name); 178| 160| } else { 179| 160| static_assert(std::is_same_v); 180| 160| u = unit; 181| 160| } 182| | // GCC warns about the variables being unused even they are in certain 183| | // constexpr branches above. Just use them here to suppress the warning. 184| 160| base::ignore_result(name, unit); 185| 160| static constexpr uint32_t kDimensionCount = 186| 160| std::tuple_size_v; 187| 160| *it = AddTrack(bp, n, u, a.data(), kDimensionCount, args); 188| 160| } 189| 160| return std::make_pair(*it, inserted); 190| 160| } _ZN8perfetto15trace_processor12TrackTracker16DimensionsToArgsILm0ENSt3__15tupleIJjlEEEEEvRKT0_PKNS0_6tracks22DimensionBlueprintBaseEPNS0_17GlobalArgsTracker10CompactArgE: 195| 35.1k| GlobalArgsTracker::CompactArg* a) { 196| 35.1k| static constexpr size_t kTupleSize = std::tuple_size_v; 197| 35.1k| if constexpr (i < kTupleSize) { 198| 35.1k| using elem_t = std::tuple_element_t; 199| 35.1k| if constexpr (std::is_same_v) { 200| 35.1k| a[i].value = Variadic::Integer(std::get(dimensions)); 201| | } else if constexpr (std::is_integral_v) { 202| | a[i].value = Variadic::Integer(std::get(dimensions)); 203| | } else { 204| | static_assert(std::is_same_v, 205| | "Unknown type for dimension"); 206| | a[i].value = Variadic::String( 207| | context_->storage->InternString(std::get(dimensions))); 208| | } 209| 35.1k| DimensionsToArgs(dimensions, dimensions_schema, a); 210| 35.1k| } 211| | // Required for GCC to not complain. 212| 35.1k| base::ignore_result(dimensions_schema); 213| 35.1k| } _ZN8perfetto15trace_processor12TrackTracker16DimensionsToArgsILm1ENSt3__15tupleIJjlEEEEEvRKT0_PKNS0_6tracks22DimensionBlueprintBaseEPNS0_17GlobalArgsTracker10CompactArgE: 195| 35.1k| GlobalArgsTracker::CompactArg* a) { 196| 35.1k| static constexpr size_t kTupleSize = std::tuple_size_v; 197| 35.1k| if constexpr (i < kTupleSize) { 198| 35.1k| using elem_t = std::tuple_element_t; 199| | if constexpr (std::is_same_v) { 200| | a[i].value = Variadic::Integer(std::get(dimensions)); 201| 35.1k| } else if constexpr (std::is_integral_v) { 202| 35.1k| a[i].value = Variadic::Integer(std::get(dimensions)); 203| | } else { 204| | static_assert(std::is_same_v, 205| | "Unknown type for dimension"); 206| | a[i].value = Variadic::String( 207| | context_->storage->InternString(std::get(dimensions))); 208| | } 209| 35.1k| DimensionsToArgs(dimensions, dimensions_schema, a); 210| 35.1k| } 211| | // Required for GCC to not complain. 212| 35.1k| base::ignore_result(dimensions_schema); 213| 35.1k| } _ZN8perfetto15trace_processor12TrackTracker16DimensionsToArgsILm2ENSt3__15tupleIJjlEEEEEvRKT0_PKNS0_6tracks22DimensionBlueprintBaseEPNS0_17GlobalArgsTracker10CompactArgE: 195| 35.1k| GlobalArgsTracker::CompactArg* a) { 196| 35.1k| static constexpr size_t kTupleSize = std::tuple_size_v; 197| | if constexpr (i < kTupleSize) { 198| | using elem_t = std::tuple_element_t; 199| | if constexpr (std::is_same_v) { 200| | a[i].value = Variadic::Integer(std::get(dimensions)); 201| | } else if constexpr (std::is_integral_v) { 202| | a[i].value = Variadic::Integer(std::get(dimensions)); 203| | } else { 204| | static_assert(std::is_same_v, 205| | "Unknown type for dimension"); 206| | a[i].value = Variadic::String( 207| | context_->storage->InternString(std::get(dimensions))); 208| | } 209| | DimensionsToArgs(dimensions, dimensions_schema, a); 210| | } 211| | // Required for GCC to not complain. 212| 35.1k| base::ignore_result(dimensions_schema); 213| 35.1k| } _ZN8perfetto15trace_processor12TrackTracker11InternTrackINS0_6tracks10BlueprintTINS3_14NameBlueprintT7DynamicENS3_14UnitBlueprintT7UnknownEJNS3_19DimensionBlueprintTIjEENS9_IlEEEEEEENS0_6tables10TrackTable2IdERKT_RKNSG_12dimensions_tERKNSG_6name_tERKNSt3__18functionIFvRNS0_11ArgsTracker13BoundInserterEEEERKNSG_6unit_tE: 104| 34.9k| const typename BlueprintT::unit_t& unit = tracks::BlueprintUnit()) { 105| 34.9k| return InternTrackInner(bp, dims, name, args, unit).first; 106| 34.9k| } _ZN8perfetto15trace_processor12TrackTracker16InternTrackInnerINS0_6tracks10BlueprintTINS3_14NameBlueprintT7DynamicENS3_14UnitBlueprintT7UnknownEJNS3_19DimensionBlueprintTIjEENS9_IlEEEEEEENSt3__14pairINS0_6tables10TrackTable2IdEbEERKT_RKNSJ_12dimensions_tERKNSJ_6name_tERKNSD_8functionIFvRNS0_11ArgsTracker13BoundInserterEEEERKNSJ_6unit_tE: 151| 34.9k| const typename BlueprintT::unit_t& unit = tracks::BlueprintUnit()) { 152| 34.9k| uint64_t hash = tracks::HashFromBlueprintAndDimensions(bp, dims); 153| 34.9k| auto [it, inserted] = tracks_.Insert(hash, {}); 154| 34.9k| if (inserted) { ------------------ | Branch (154:9): [True: 34.9k, False: 0] ------------------ 155| 34.9k| std::array a; 156| 34.9k| DimensionsToArgs<0>(dims, bp.dimension_blueprints.data(), a.data()); 157| 34.9k| StringId n; 158| 34.9k| using NBT = tracks::NameBlueprintT; 159| 34.9k| using name_blueprint_t = typename BlueprintT::name_blueprint_t; 160| | if constexpr (std::is_same_v) { 161| | n = kNullStringId; 162| | } else if constexpr (std::is_same_v) { 163| | n = context_->storage->InternString(bp.name_blueprint.name); 164| | } else if constexpr (std::is_base_of_v) { 165| | n = context_->storage->InternString( 166| | std::apply(bp.name_blueprint.fn, dims).string_view()); 167| 34.9k| } else { 168| 34.9k| static_assert(std::is_same_v); 169| 34.9k| n = name; 170| 34.9k| } 171| 34.9k| using UBT = tracks::UnitBlueprintT; 172| 34.9k| using unit_blueprint_t = typename BlueprintT::unit_blueprint_t; 173| 34.9k| StringId u; 174| 34.9k| if constexpr (std::is_same_v) { 175| 34.9k| u = kNullStringId; 176| | } else if constexpr (std::is_same_v) { 177| | u = context_->storage->InternString(bp.unit_blueprint.name); 178| | } else { 179| | static_assert(std::is_same_v); 180| | u = unit; 181| | } 182| | // GCC warns about the variables being unused even they are in certain 183| | // constexpr branches above. Just use them here to suppress the warning. 184| 34.9k| base::ignore_result(name, unit); 185| 34.9k| static constexpr uint32_t kDimensionCount = 186| 34.9k| std::tuple_size_v; 187| 34.9k| *it = AddTrack(bp, n, u, a.data(), kDimensionCount, args); 188| 34.9k| } 189| 34.9k| return std::make_pair(*it, inserted); 190| 34.9k| } _ZN8perfetto15trace_processor12TrackTracker11InternTrackINS0_6tracks10BlueprintTINS3_14NameBlueprintT7DynamicENS3_14UnitBlueprintT7DynamicEJNS3_19DimensionBlueprintTIlEEEEEEENS0_6tables10TrackTable2IdERKT_RKNSF_12dimensions_tERKNSF_6name_tERKNSt3__18functionIFvRNS0_11ArgsTracker13BoundInserterEEEERKNSF_6unit_tE: 104| 10.3k| const typename BlueprintT::unit_t& unit = tracks::BlueprintUnit()) { 105| 10.3k| return InternTrackInner(bp, dims, name, args, unit).first; 106| 10.3k| } _ZN8perfetto15trace_processor12TrackTracker16InternTrackInnerINS0_6tracks10BlueprintTINS3_14NameBlueprintT7DynamicENS3_14UnitBlueprintT7DynamicEJNS3_19DimensionBlueprintTIlEEEEEEENSt3__14pairINS0_6tables10TrackTable2IdEbEERKT_RKNSI_12dimensions_tERKNSI_6name_tERKNSC_8functionIFvRNS0_11ArgsTracker13BoundInserterEEEERKNSI_6unit_tE: 151| 10.3k| const typename BlueprintT::unit_t& unit = tracks::BlueprintUnit()) { 152| 10.3k| uint64_t hash = tracks::HashFromBlueprintAndDimensions(bp, dims); 153| 10.3k| auto [it, inserted] = tracks_.Insert(hash, {}); 154| 10.3k| if (inserted) { ------------------ | Branch (154:9): [True: 10.3k, False: 0] ------------------ 155| 10.3k| std::array a; 156| 10.3k| DimensionsToArgs<0>(dims, bp.dimension_blueprints.data(), a.data()); 157| 10.3k| StringId n; 158| 10.3k| using NBT = tracks::NameBlueprintT; 159| 10.3k| using name_blueprint_t = typename BlueprintT::name_blueprint_t; 160| | if constexpr (std::is_same_v) { 161| | n = kNullStringId; 162| | } else if constexpr (std::is_same_v) { 163| | n = context_->storage->InternString(bp.name_blueprint.name); 164| | } else if constexpr (std::is_base_of_v) { 165| | n = context_->storage->InternString( 166| | std::apply(bp.name_blueprint.fn, dims).string_view()); 167| 10.3k| } else { 168| 10.3k| static_assert(std::is_same_v); 169| 10.3k| n = name; 170| 10.3k| } 171| 10.3k| using UBT = tracks::UnitBlueprintT; 172| 10.3k| using unit_blueprint_t = typename BlueprintT::unit_blueprint_t; 173| 10.3k| StringId u; 174| | if constexpr (std::is_same_v) { 175| | u = kNullStringId; 176| | } else if constexpr (std::is_same_v) { 177| | u = context_->storage->InternString(bp.unit_blueprint.name); 178| 10.3k| } else { 179| 10.3k| static_assert(std::is_same_v); 180| 10.3k| u = unit; 181| 10.3k| } 182| | // GCC warns about the variables being unused even they are in certain 183| | // constexpr branches above. Just use them here to suppress the warning. 184| 10.3k| base::ignore_result(name, unit); 185| 10.3k| static constexpr uint32_t kDimensionCount = 186| 10.3k| std::tuple_size_v; 187| 10.3k| *it = AddTrack(bp, n, u, a.data(), kDimensionCount, args); 188| 10.3k| } 189| 10.3k| return std::make_pair(*it, inserted); 190| 10.3k| } _ZN8perfetto15trace_processor12TrackTracker16DimensionsToArgsILm0ENSt3__15tupleIJlEEEEEvRKT0_PKNS0_6tracks22DimensionBlueprintBaseEPNS0_17GlobalArgsTracker10CompactArgE: 195| 35.8k| GlobalArgsTracker::CompactArg* a) { 196| 35.8k| static constexpr size_t kTupleSize = std::tuple_size_v; 197| 35.8k| if constexpr (i < kTupleSize) { 198| 35.8k| using elem_t = std::tuple_element_t; 199| | if constexpr (std::is_same_v) { 200| | a[i].value = Variadic::Integer(std::get(dimensions)); 201| 35.8k| } else if constexpr (std::is_integral_v) { 202| 35.8k| a[i].value = Variadic::Integer(std::get(dimensions)); 203| | } else { 204| | static_assert(std::is_same_v, 205| | "Unknown type for dimension"); 206| | a[i].value = Variadic::String( 207| | context_->storage->InternString(std::get(dimensions))); 208| | } 209| 35.8k| DimensionsToArgs(dimensions, dimensions_schema, a); 210| 35.8k| } 211| | // Required for GCC to not complain. 212| 35.8k| base::ignore_result(dimensions_schema); 213| 35.8k| } _ZN8perfetto15trace_processor12TrackTracker16DimensionsToArgsILm1ENSt3__15tupleIJlEEEEEvRKT0_PKNS0_6tracks22DimensionBlueprintBaseEPNS0_17GlobalArgsTracker10CompactArgE: 195| 35.8k| GlobalArgsTracker::CompactArg* a) { 196| 35.8k| static constexpr size_t kTupleSize = std::tuple_size_v; 197| | if constexpr (i < kTupleSize) { 198| | using elem_t = std::tuple_element_t; 199| | if constexpr (std::is_same_v) { 200| | a[i].value = Variadic::Integer(std::get(dimensions)); 201| | } else if constexpr (std::is_integral_v) { 202| | a[i].value = Variadic::Integer(std::get(dimensions)); 203| | } else { 204| | static_assert(std::is_same_v, 205| | "Unknown type for dimension"); 206| | a[i].value = Variadic::String( 207| | context_->storage->InternString(std::get(dimensions))); 208| | } 209| | DimensionsToArgs(dimensions, dimensions_schema, a); 210| | } 211| | // Required for GCC to not complain. 212| 35.8k| base::ignore_result(dimensions_schema); 213| 35.8k| } _ZN8perfetto15trace_processor12TrackTracker11InternTrackINS0_6tracks10BlueprintTINS3_14NameBlueprintT7DynamicENS3_14UnitBlueprintT7UnknownEJNS3_19DimensionBlueprintTIlEEEEEEENS0_6tables10TrackTable2IdERKT_RKNSF_12dimensions_tERKNSF_6name_tERKNSt3__18functionIFvRNS0_11ArgsTracker13BoundInserterEEEERKNSF_6unit_tE: 104| 25.4k| const typename BlueprintT::unit_t& unit = tracks::BlueprintUnit()) { 105| 25.4k| return InternTrackInner(bp, dims, name, args, unit).first; 106| 25.4k| } _ZN8perfetto15trace_processor12TrackTracker16InternTrackInnerINS0_6tracks10BlueprintTINS3_14NameBlueprintT7DynamicENS3_14UnitBlueprintT7UnknownEJNS3_19DimensionBlueprintTIlEEEEEEENSt3__14pairINS0_6tables10TrackTable2IdEbEERKT_RKNSI_12dimensions_tERKNSI_6name_tERKNSC_8functionIFvRNS0_11ArgsTracker13BoundInserterEEEERKNSI_6unit_tE: 151| 25.4k| const typename BlueprintT::unit_t& unit = tracks::BlueprintUnit()) { 152| 25.4k| uint64_t hash = tracks::HashFromBlueprintAndDimensions(bp, dims); 153| 25.4k| auto [it, inserted] = tracks_.Insert(hash, {}); 154| 25.4k| if (inserted) { ------------------ | Branch (154:9): [True: 25.4k, False: 0] ------------------ 155| 25.4k| std::array a; 156| 25.4k| DimensionsToArgs<0>(dims, bp.dimension_blueprints.data(), a.data()); 157| 25.4k| StringId n; 158| 25.4k| using NBT = tracks::NameBlueprintT; 159| 25.4k| using name_blueprint_t = typename BlueprintT::name_blueprint_t; 160| | if constexpr (std::is_same_v) { 161| | n = kNullStringId; 162| | } else if constexpr (std::is_same_v) { 163| | n = context_->storage->InternString(bp.name_blueprint.name); 164| | } else if constexpr (std::is_base_of_v) { 165| | n = context_->storage->InternString( 166| | std::apply(bp.name_blueprint.fn, dims).string_view()); 167| 25.4k| } else { 168| 25.4k| static_assert(std::is_same_v); 169| 25.4k| n = name; 170| 25.4k| } 171| 25.4k| using UBT = tracks::UnitBlueprintT; 172| 25.4k| using unit_blueprint_t = typename BlueprintT::unit_blueprint_t; 173| 25.4k| StringId u; 174| 25.4k| if constexpr (std::is_same_v) { 175| 25.4k| u = kNullStringId; 176| | } else if constexpr (std::is_same_v) { 177| | u = context_->storage->InternString(bp.unit_blueprint.name); 178| | } else { 179| | static_assert(std::is_same_v); 180| | u = unit; 181| | } 182| | // GCC warns about the variables being unused even they are in certain 183| | // constexpr branches above. Just use them here to suppress the warning. 184| 25.4k| base::ignore_result(name, unit); 185| 25.4k| static constexpr uint32_t kDimensionCount = 186| 25.4k| std::tuple_size_v; 187| 25.4k| *it = AddTrack(bp, n, u, a.data(), kDimensionCount, args); 188| 25.4k| } 189| 25.4k| return std::make_pair(*it, inserted); 190| 25.4k| } _ZN8perfetto15trace_processor6tracks13BlueprintNameEv: 161| 115k|constexpr std::nullptr_t BlueprintName() { 162| 115k| return nullptr; 163| 115k|} _ZN8perfetto15trace_processor6tracks11DynamicNameENS0_10StringPool2IdE: 167| 468k|constexpr StringPool::Id DynamicName(StringPool::Id id) { 168| 468k| return id; 169| 468k|} _ZN8perfetto15trace_processor6tracks13BlueprintUnitEv: 172| 573k|constexpr std::nullptr_t BlueprintUnit() { 173| 573k| return nullptr; 174| 573k|} _ZN8perfetto15trace_processor6tracks11DynamicUnitENS0_10StringPool2IdE: 178| 10.5k|constexpr StringPool::Id DynamicUnit(StringPool::Id id) { 179| 10.5k| return id; 180| 10.5k|} _ZN8perfetto15trace_processor6tracks10DimensionsIJjEEEDaDpT_: 156| 114k|constexpr auto Dimensions(D... dimensions) { 157| 114k| return DimensionsT{dimensions...}; 158| 114k|} _ZN8perfetto15trace_processor6tracks10DimensionsIJjNS0_18NullTermStringViewEEEEDaDpT_: 156| 279k|constexpr auto Dimensions(D... dimensions) { 157| 279k| return DimensionsT{dimensions...}; 158| 279k|} _ZN8perfetto15trace_processor6tracks10DimensionsIJjNS0_18NullTermStringViewElEEEDaDpT_: 156| 107k|constexpr auto Dimensions(D... dimensions) { 157| 107k| return DimensionsT{dimensions...}; 158| 107k|} _ZN8perfetto15trace_processor6tracks10DimensionsIJNS0_18NullTermStringViewElEEEDaDpT_: 156| 10.4k|constexpr auto Dimensions(D... dimensions) { 157| 10.4k| return DimensionsT{dimensions...}; 158| 10.4k|} _ZN8perfetto15trace_processor6tracks10DimensionsIJEEEDaDpT_: 156| 641|constexpr auto Dimensions(D... dimensions) { 157| 641| return DimensionsT{dimensions...}; 158| 641|} _ZN8perfetto15trace_processor6tracks10DimensionsIJjN9protozero10ConstCharsEEEEDaDpT_: 156| 17|constexpr auto Dimensions(D... dimensions) { 157| 17| return DimensionsT{dimensions...}; 158| 17|} _ZN8perfetto15trace_processor6tracks10DimensionsIJjlEEEDaDpT_: 156| 35.1k|constexpr auto Dimensions(D... dimensions) { 157| 35.1k| return DimensionsT{dimensions...}; 158| 35.1k|} _ZN8perfetto15trace_processor6tracks10DimensionsIJlEEEDaDpT_: 156| 35.8k|constexpr auto Dimensions(D... dimensions) { 157| 35.8k| return DimensionsT{dimensions...}; 158| 35.8k|} _ZZN8perfetto15trace_processor6tracks30HashFromBlueprintAndDimensionsINS1_10BlueprintTINS1_14NameBlueprintT4AutoENS1_14UnitBlueprintT7UnknownEJNS1_19DimensionBlueprintTIjEEEEENSt3__15tupleIJjEEEEEmRKT_RKT0_ENKUlDpOT_E_clIJRKjEEEDaSM_: 102| 114k| std::apply([&](auto&&... args) { ((hasher.Update(args)), ...); }, dims); _ZN8perfetto15trace_processor6tracks30HashFromBlueprintAndDimensionsINS1_10BlueprintTINS1_14NameBlueprintT4AutoENS1_14UnitBlueprintT7UnknownEJNS1_19DimensionBlueprintTIjEEEEENSt3__15tupleIJjEEEEEmRKT_RKT0_: 100| 114k| const Dims& dims) { 101| 114k| base::Hasher hasher(bp.hasher); 102| 114k| std::apply([&](auto&&... args) { ((hasher.Update(args)), ...); }, dims); 103| 114k| return hasher.digest(); 104| 114k|} _ZN8perfetto15trace_processor6tracks30HashFromBlueprintAndDimensionsINS1_10BlueprintTINS1_14NameBlueprintT7DynamicENS1_14UnitBlueprintT7UnknownEJNS1_19DimensionBlueprintTIjEENS8_INS_4base10StringViewEEEEEENSt3__15tupleIJjSB_EEEEEmRKT_RKT0_: 100| 279k| const Dims& dims) { 101| 279k| base::Hasher hasher(bp.hasher); 102| 279k| std::apply([&](auto&&... args) { ((hasher.Update(args)), ...); }, dims); 103| 279k| return hasher.digest(); 104| 279k|} _ZZN8perfetto15trace_processor6tracks30HashFromBlueprintAndDimensionsINS1_10BlueprintTINS1_14NameBlueprintT7DynamicENS1_14UnitBlueprintT7UnknownEJNS1_19DimensionBlueprintTIjEENS8_INS_4base10StringViewEEEEEENSt3__15tupleIJjSB_EEEEEmRKT_RKT0_ENKUlDpOT_E_clIJRKjRKSB_EEEDaSP_: 102| 279k| std::apply([&](auto&&... args) { ((hasher.Update(args)), ...); }, dims); _ZN8perfetto15trace_processor6tracks30HashFromBlueprintAndDimensionsINS1_10BlueprintTINS1_14NameBlueprintT7DynamicENS1_14UnitBlueprintT7UnknownEJNS1_19DimensionBlueprintTIjEENS8_INS_4base10StringViewEEENS8_IlEEEEENSt3__15tupleIJjSB_lEEEEEmRKT_RKT0_: 100| 107k| const Dims& dims) { 101| 107k| base::Hasher hasher(bp.hasher); 102| 107k| std::apply([&](auto&&... args) { ((hasher.Update(args)), ...); }, dims); 103| 107k| return hasher.digest(); 104| 107k|} _ZZN8perfetto15trace_processor6tracks30HashFromBlueprintAndDimensionsINS1_10BlueprintTINS1_14NameBlueprintT7DynamicENS1_14UnitBlueprintT7UnknownEJNS1_19DimensionBlueprintTIjEENS8_INS_4base10StringViewEEENS8_IlEEEEENSt3__15tupleIJjSB_lEEEEEmRKT_RKT0_ENKUlDpOT_E_clIJRKjRKSB_RKlEEEDaSQ_: 102| 107k| std::apply([&](auto&&... args) { ((hasher.Update(args)), ...); }, dims); _ZN8perfetto15trace_processor6tracks30HashFromBlueprintAndDimensionsINS1_10BlueprintTINS1_14NameBlueprintT7DynamicENS1_14UnitBlueprintT7UnknownEJNS1_19DimensionBlueprintTINS_4base10StringViewEEENS8_IlEEEEENSt3__15tupleIJSA_lEEEEEmRKT_RKT0_: 100| 10.4k| const Dims& dims) { 101| 10.4k| base::Hasher hasher(bp.hasher); 102| 10.4k| std::apply([&](auto&&... args) { ((hasher.Update(args)), ...); }, dims); 103| 10.4k| return hasher.digest(); 104| 10.4k|} _ZZN8perfetto15trace_processor6tracks30HashFromBlueprintAndDimensionsINS1_10BlueprintTINS1_14NameBlueprintT7DynamicENS1_14UnitBlueprintT7UnknownEJNS1_19DimensionBlueprintTINS_4base10StringViewEEENS8_IlEEEEENSt3__15tupleIJSA_lEEEEEmRKT_RKT0_ENKUlDpOT_E_clIJRKSA_RKlEEEDaSP_: 102| 10.4k| std::apply([&](auto&&... args) { ((hasher.Update(args)), ...); }, dims); _ZN8perfetto15trace_processor6tracks30HashFromBlueprintAndDimensionsINS1_10BlueprintTINS1_14NameBlueprintT4AutoENS1_14UnitBlueprintT7UnknownEJEEENSt3__15tupleIJEEEEEmRKT_RKT0_: 100| 641| const Dims& dims) { 101| 641| base::Hasher hasher(bp.hasher); 102| 641| std::apply([&](auto&&... args) { ((hasher.Update(args)), ...); }, dims); 103| 641| return hasher.digest(); 104| 641|} _ZZN8perfetto15trace_processor6tracks30HashFromBlueprintAndDimensionsINS1_10BlueprintTINS1_14NameBlueprintT4AutoENS1_14UnitBlueprintT7UnknownEJEEENSt3__15tupleIJEEEEEmRKT_RKT0_ENKUlDpOT_E_clIJEEEDaSK_: 102| 641| std::apply([&](auto&&... args) { ((hasher.Update(args)), ...); }, dims); _ZN8perfetto15trace_processor6tracks30HashFromBlueprintAndDimensionsINS1_10BlueprintTINS1_14NameBlueprintT7DynamicENS1_14UnitBlueprintT7UnknownEJNS1_19DimensionBlueprintTIjEEEEENSt3__15tupleIJjEEEEEmRKT_RKT0_: 100| 48| const Dims& dims) { 101| 48| base::Hasher hasher(bp.hasher); 102| 48| std::apply([&](auto&&... args) { ((hasher.Update(args)), ...); }, dims); 103| 48| return hasher.digest(); 104| 48|} _ZZN8perfetto15trace_processor6tracks30HashFromBlueprintAndDimensionsINS1_10BlueprintTINS1_14NameBlueprintT7DynamicENS1_14UnitBlueprintT7UnknownEJNS1_19DimensionBlueprintTIjEEEEENSt3__15tupleIJjEEEEEmRKT_RKT0_ENKUlDpOT_E_clIJRKjEEEDaSM_: 102| 48| std::apply([&](auto&&... args) { ((hasher.Update(args)), ...); }, dims); _ZN8perfetto15trace_processor6tracks30HashFromBlueprintAndDimensionsINS1_10BlueprintTINS1_14NameBlueprintT7DynamicENS1_14UnitBlueprintT7DynamicEJNS1_19DimensionBlueprintTIjEENS8_IlEEEEENSt3__15tupleIJjlEEEEEmRKT_RKT0_: 100| 160| const Dims& dims) { 101| 160| base::Hasher hasher(bp.hasher); 102| 160| std::apply([&](auto&&... args) { ((hasher.Update(args)), ...); }, dims); 103| 160| return hasher.digest(); 104| 160|} _ZZN8perfetto15trace_processor6tracks30HashFromBlueprintAndDimensionsINS1_10BlueprintTINS1_14NameBlueprintT7DynamicENS1_14UnitBlueprintT7DynamicEJNS1_19DimensionBlueprintTIjEENS8_IlEEEEENSt3__15tupleIJjlEEEEEmRKT_RKT0_ENKUlDpOT_E_clIJRKjRKlEEEDaSN_: 102| 160| std::apply([&](auto&&... args) { ((hasher.Update(args)), ...); }, dims); _ZN8perfetto15trace_processor6tracks30HashFromBlueprintAndDimensionsINS1_10BlueprintTINS1_14NameBlueprintT7DynamicENS1_14UnitBlueprintT7UnknownEJNS1_19DimensionBlueprintTIjEENS8_IlEEEEENSt3__15tupleIJjlEEEEEmRKT_RKT0_: 100| 34.9k| const Dims& dims) { 101| 34.9k| base::Hasher hasher(bp.hasher); 102| 34.9k| std::apply([&](auto&&... args) { ((hasher.Update(args)), ...); }, dims); 103| 34.9k| return hasher.digest(); 104| 34.9k|} _ZZN8perfetto15trace_processor6tracks30HashFromBlueprintAndDimensionsINS1_10BlueprintTINS1_14NameBlueprintT7DynamicENS1_14UnitBlueprintT7UnknownEJNS1_19DimensionBlueprintTIjEENS8_IlEEEEENSt3__15tupleIJjlEEEEEmRKT_RKT0_ENKUlDpOT_E_clIJRKjRKlEEEDaSN_: 102| 34.9k| std::apply([&](auto&&... args) { ((hasher.Update(args)), ...); }, dims); _ZN8perfetto15trace_processor6tracks30HashFromBlueprintAndDimensionsINS1_10BlueprintTINS1_14NameBlueprintT7DynamicENS1_14UnitBlueprintT7DynamicEJNS1_19DimensionBlueprintTIlEEEEENSt3__15tupleIJlEEEEEmRKT_RKT0_: 100| 10.3k| const Dims& dims) { 101| 10.3k| base::Hasher hasher(bp.hasher); 102| 10.3k| std::apply([&](auto&&... args) { ((hasher.Update(args)), ...); }, dims); 103| 10.3k| return hasher.digest(); 104| 10.3k|} _ZZN8perfetto15trace_processor6tracks30HashFromBlueprintAndDimensionsINS1_10BlueprintTINS1_14NameBlueprintT7DynamicENS1_14UnitBlueprintT7DynamicEJNS1_19DimensionBlueprintTIlEEEEENSt3__15tupleIJlEEEEEmRKT_RKT0_ENKUlDpOT_E_clIJRKlEEEDaSM_: 102| 10.3k| std::apply([&](auto&&... args) { ((hasher.Update(args)), ...); }, dims); _ZN8perfetto15trace_processor6tracks30HashFromBlueprintAndDimensionsINS1_10BlueprintTINS1_14NameBlueprintT7DynamicENS1_14UnitBlueprintT7UnknownEJNS1_19DimensionBlueprintTIlEEEEENSt3__15tupleIJlEEEEEmRKT_RKT0_: 100| 25.4k| const Dims& dims) { 101| 25.4k| base::Hasher hasher(bp.hasher); 102| 25.4k| std::apply([&](auto&&... args) { ((hasher.Update(args)), ...); }, dims); 103| 25.4k| return hasher.digest(); 104| 25.4k|} _ZZN8perfetto15trace_processor6tracks30HashFromBlueprintAndDimensionsINS1_10BlueprintTINS1_14NameBlueprintT7DynamicENS1_14UnitBlueprintT7UnknownEJNS1_19DimensionBlueprintTIlEEEEENSt3__15tupleIJlEEEEEmRKT_RKT0_ENKUlDpOT_E_clIJRKlEEEDaSM_: 102| 25.4k| std::apply([&](auto&&... args) { ((hasher.Update(args)), ...); }, dims); _ZN8perfetto15trace_processor4json15ParseJsonStringENS_4base10StringViewE: 138| 17.5k|std::optional ParseJsonString(base::StringView raw_string) { 139| 17.5k| PERFETTO_DCHECK(IsJsonSupported()); 140| | 141| 17.5k|#if PERFETTO_BUILDFLAG(PERFETTO_TP_JSON) 142| 17.5k| Json::CharReaderBuilder b; 143| 17.5k| auto reader = std::unique_ptr(b.newCharReader()); 144| | 145| 17.5k| Json::Value value; 146| 17.5k| const char* begin = raw_string.data(); 147| 17.5k| return reader->parse(begin, begin + raw_string.size(), &value, nullptr) ------------------ | Branch (147:10): [True: 1.17k, False: 16.3k] ------------------ 148| 17.5k| ? std::make_optional(std::move(value)) 149| 17.5k| : std::nullopt; 150| |#else 151| | perfetto::base::ignore_result(raw_string); 152| | return std::nullopt; 153| |#endif 154| 17.5k|} _ZN8perfetto15trace_processor4json18AddJsonValueToArgsERKN4Json5ValueENS_4base10StringViewES7_PNS0_12TraceStorageEPNS0_11ArgsTracker13BoundInserterE: 160| 3.97k| ArgsTracker::BoundInserter* inserter) { 161| 3.97k| PERFETTO_DCHECK(IsJsonSupported()); 162| | 163| 3.97k|#if PERFETTO_BUILDFLAG(PERFETTO_TP_JSON) 164| 3.97k| if (value.isObject()) { ------------------ | Branch (164:7): [True: 0, False: 3.97k] ------------------ 165| 0| auto it = value.begin(); 166| 0| bool inserted = false; 167| 0| for (; it != value.end(); ++it) { ------------------ | Branch (167:12): [True: 0, False: 0] ------------------ 168| 0| std::string child_name = it.name(); 169| 0| std::string child_flat_key = flat_key.ToStdString() + "." + child_name; 170| 0| std::string child_key = key.ToStdString() + "." + child_name; 171| 0| inserted |= 172| 0| AddJsonValueToArgs(*it, base::StringView(child_flat_key), 173| 0| base::StringView(child_key), storage, inserter); 174| 0| } 175| 0| return inserted; 176| 0| } 177| | 178| 3.97k| if (value.isArray()) { ------------------ | Branch (178:7): [True: 1.41k, False: 2.55k] ------------------ 179| 1.41k| auto it = value.begin(); 180| 1.41k| bool inserted_any = false; 181| 1.41k| std::string array_key = key.ToStdString(); 182| 1.41k| StringId array_key_id = storage->InternString(key); 183| 4.20k| for (; it != value.end(); ++it) { ------------------ | Branch (183:12): [True: 2.79k, False: 1.41k] ------------------ 184| 2.79k| size_t array_index = inserter->GetNextArrayEntryIndex(array_key_id); 185| 2.79k| std::string child_key = 186| 2.79k| array_key + "[" + std::to_string(array_index) + "]"; 187| 2.79k| bool inserted = AddJsonValueToArgs( 188| 2.79k| *it, flat_key, base::StringView(child_key), storage, inserter); 189| 2.79k| if (inserted) ------------------ | Branch (189:11): [True: 2.79k, False: 0] ------------------ 190| 2.79k| inserter->IncrementArrayEntryIndex(array_key_id); 191| 2.79k| inserted_any |= inserted; 192| 2.79k| } 193| 1.41k| return inserted_any; 194| 1.41k| } 195| | 196| | // Leaf value. 197| 2.55k| auto flat_key_id = storage->InternString(flat_key); 198| 2.55k| auto key_id = storage->InternString(key); 199| | 200| 2.55k| switch (value.type()) { ------------------ | Branch (200:11): [True: 0, False: 2.55k] ------------------ 201| 0| case Json::ValueType::nullValue: ------------------ | Branch (201:5): [True: 0, False: 2.55k] ------------------ 202| 0| break; 203| 1.65k| case Json::ValueType::intValue: ------------------ | Branch (203:5): [True: 1.65k, False: 909] ------------------ 204| 1.65k| inserter->AddArg(flat_key_id, key_id, Variadic::Integer(value.asInt64())); 205| 1.65k| return true; 206| 0| case Json::ValueType::uintValue: ------------------ | Branch (206:5): [True: 0, False: 2.55k] ------------------ 207| 0| inserter->AddArg(flat_key_id, key_id, 208| 0| Variadic::UnsignedInteger(value.asUInt64())); 209| 0| return true; 210| 440| case Json::ValueType::realValue: ------------------ | Branch (210:5): [True: 440, False: 2.11k] ------------------ 211| 440| inserter->AddArg(flat_key_id, key_id, Variadic::Real(value.asDouble())); 212| 440| return true; 213| 469| case Json::ValueType::stringValue: ------------------ | Branch (213:5): [True: 469, False: 2.09k] ------------------ 214| 469| inserter->AddArg(flat_key_id, key_id, 215| 469| Variadic::String(storage->InternString( 216| 469| base::StringView(value.asString())))); 217| 469| return true; 218| 0| case Json::ValueType::booleanValue: ------------------ | Branch (218:5): [True: 0, False: 2.55k] ------------------ 219| 0| inserter->AddArg(flat_key_id, key_id, Variadic::Boolean(value.asBool())); 220| 0| return true; 221| 0| case Json::ValueType::objectValue: ------------------ | Branch (221:5): [True: 0, False: 2.55k] ------------------ 222| 0| case Json::ValueType::arrayValue: ------------------ | Branch (222:5): [True: 0, False: 2.55k] ------------------ 223| 0| PERFETTO_FATAL("Non-leaf types handled above"); 224| 0| break; 225| 2.55k| } 226| 0| return false; 227| |#else 228| | perfetto::base::ignore_result(value); 229| | perfetto::base::ignore_result(flat_key); 230| | perfetto::base::ignore_result(key); 231| | perfetto::base::ignore_result(storage); 232| | perfetto::base::ignore_result(inserter); 233| | return false; 234| |#endif 235| 2.55k|} _ZN8perfetto15trace_processor15GlobalNodeGraphC2Ev: 35| 641| std::unique_ptr(new Process(kNullProcessId, this))) {} _ZN8perfetto15trace_processor15GlobalNodeGraphD2Ev: 36| 641|GlobalNodeGraph::~GlobalNodeGraph() {} _ZN8perfetto15trace_processor15GlobalNodeGraph21CreateGraphForProcessEi: 39| 42.6k| base::PlatformProcessId process_id) { 40| 42.6k| auto id_to_node_iterator = process_node_graphs_.emplace( 41| 42.6k| process_id, std::unique_ptr(new Process(process_id, this))); 42| 42.6k| return id_to_node_iterator.first->second.get(); 43| 42.6k|} _ZN8perfetto15trace_processor15GlobalNodeGraph20AddNodeOwnershipEdgeEPNS1_4NodeES3_i: 47| 30.5k| int importance) { 48| 30.5k| all_edges_.emplace_front(owner, owned, importance); 49| 30.5k| Edge* edge = &*all_edges_.begin(); 50| 30.5k| owner->SetOwnsEdge(edge); 51| 30.5k| owned->AddOwnedByEdge(edge); 52| 30.5k|} _ZN8perfetto15trace_processor15GlobalNodeGraph10CreateNodeEPNS1_7ProcessEPNS1_4NodeE: 54| 47.0k|Node* GlobalNodeGraph::CreateNode(Process* process_graph, Node* parent) { 55| 47.0k| all_nodes_.emplace_front(process_graph, parent); 56| 47.0k| return &*all_nodes_.begin(); 57| 47.0k|} _ZN8perfetto15trace_processor15GlobalNodeGraph25VisitInDepthFirstPreOrderEv: 59| 641|PreOrderIterator GlobalNodeGraph::VisitInDepthFirstPreOrder() { 60| 641| std::vector roots; 61| 641| for (auto it = process_node_graphs_.rbegin(); 62| 43.2k| it != process_node_graphs_.rend(); it++) { ------------------ | Branch (62:8): [True: 42.6k, False: 641] ------------------ 63| 42.6k| roots.push_back(it->second->root()); 64| 42.6k| } 65| 641| roots.push_back(shared_memory_graph_->root()); 66| 641| return PreOrderIterator{std::move(roots)}; 67| 641|} _ZN8perfetto15trace_processor15GlobalNodeGraph26VisitInDepthFirstPostOrderEv: 69| 2.56k|PostOrderIterator GlobalNodeGraph::VisitInDepthFirstPostOrder() { 70| 2.56k| std::vector roots; 71| 2.56k| for (auto it = process_node_graphs_.rbegin(); 72| 173k| it != process_node_graphs_.rend(); it++) { ------------------ | Branch (72:8): [True: 170k, False: 2.56k] ------------------ 73| 170k| roots.push_back(it->second->root()); 74| 170k| } 75| 2.56k| roots.push_back(shared_memory_graph_->root()); 76| 2.56k| return PostOrderIterator(std::move(roots)); 77| 2.56k|} _ZN8perfetto15trace_processor15GlobalNodeGraph7ProcessC2EiPS1_: 80| 43.2k| : pid_(pid), 81| 43.2k| global_graph_(global_graph), 82| 43.2k| root_(global_graph->CreateNode(this, nullptr)) {} _ZN8perfetto15trace_processor15GlobalNodeGraph7ProcessD2Ev: 83| 43.2k|Process::~Process() {} _ZN8perfetto15trace_processor15GlobalNodeGraph7Process10CreateNodeENS0_21MemoryAllocatorNodeIdERKNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEb: 87| 10.6k| bool weak) { 88| 10.6k| auto tokens = base::SplitString(path, "/"); 89| | 90| | // Perform a tree traversal, creating the nodes if they do not 91| | // already exist on the path to the child. 92| 10.6k| Node* current = root_; 93| 10.6k| for (const auto& key : tokens) { ------------------ | Branch (93:24): [True: 3.98k, False: 10.6k] ------------------ 94| 3.98k| Node* parent = current; 95| 3.98k| current = current->GetChild(key); 96| 3.98k| if (!current) { ------------------ | Branch (96:9): [True: 3.74k, False: 238] ------------------ 97| 3.74k| current = global_graph_->CreateNode(this, parent); 98| 3.74k| parent->InsertChild(key, current); 99| 3.74k| } 100| 3.98k| } 101| | 102| | // The final node should have the weakness specified by the 103| | // argument and also be considered explicit. 104| 10.6k| current->set_weak(weak); 105| 10.6k| current->set_explicit(true); 106| | 107| | // The final node should also have the associated |id|. 108| 10.6k| current->set_id(id); 109| | 110| | // Add to the global id map as well if it exists. 111| 10.6k| if (!id.empty()) ------------------ | Branch (111:7): [True: 535, False: 10.1k] ------------------ 112| 535| global_graph_->nodes_by_id_.emplace(id, current); 113| | 114| 10.6k| return current; 115| 10.6k|} _ZN8perfetto15trace_processor15GlobalNodeGraph4NodeC2EPNS1_7ProcessEPS2_: 130| 47.0k| : node_graph_(node_graph), parent_(parent), owns_edge_(nullptr) {} _ZN8perfetto15trace_processor15GlobalNodeGraph4NodeD2Ev: 131| 47.0k|Node::~Node() {} _ZNK8perfetto15trace_processor15GlobalNodeGraph4Node8GetChildERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE: 133| 3.98k|Node* Node::GetChild(const std::string& name) const { 134| 3.98k| auto child = children_.find(name); 135| 3.98k| return child == children_.end() ? nullptr : child->second; ------------------ | Branch (135:10): [True: 3.74k, False: 238] ------------------ 136| 3.98k|} _ZN8perfetto15trace_processor15GlobalNodeGraph4Node11InsertChildERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEPS2_: 138| 3.77k|void Node::InsertChild(const std::string& name, Node* node) { 139| 3.77k| PERFETTO_DCHECK(node); 140| 3.77k| children_.emplace(name, node); 141| 3.77k|} _ZN8perfetto15trace_processor15GlobalNodeGraph4Node11CreateChildERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE: 143| 31|Node* Node::CreateChild(const std::string& name) { 144| 31| Node* new_child = node_graph_->global_graph()->CreateNode(node_graph_, this); 145| 31| InsertChild(name, new_child); 146| 31| return new_child; 147| 31|} _ZNK8perfetto15trace_processor15GlobalNodeGraph4Node14IsDescendentOfERKS2_: 149| 56|bool Node::IsDescendentOf(const Node& possible_parent) const { 150| 56| const Node* current = this; 151| 128| while (current != nullptr) { ------------------ | Branch (151:10): [True: 104, False: 24] ------------------ 152| 104| if (current == &possible_parent) ------------------ | Branch (152:9): [True: 32, False: 72] ------------------ 153| 32| return true; 154| 72| current = current->parent(); 155| 72| } 156| 24| return false; 157| 56|} _ZN8perfetto15trace_processor15GlobalNodeGraph4Node14AddOwnedByEdgeEPNS1_4EdgeE: 159| 30.5k|void Node::AddOwnedByEdge(Edge* edge) { 160| 30.5k| owned_by_edges_.push_back(edge); 161| 30.5k|} _ZN8perfetto15trace_processor15GlobalNodeGraph4Node11SetOwnsEdgeEPNS1_4EdgeE: 163| 30.5k|void Node::SetOwnsEdge(Edge* owns_edge) { 164| 30.5k| owns_edge_ = owns_edge; 165| 30.5k|} _ZN8perfetto15trace_processor15GlobalNodeGraph4Node8AddEntryERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS2_5Entry11ScalarUnitsEm: 169| 13.1k| uint64_t value) { 170| 13.1k| entries_.emplace(name, Node::Entry(units, value)); 171| 13.1k|} _ZN8perfetto15trace_processor15GlobalNodeGraph4Node5EntryC2ENS3_11ScalarUnitsEm: 178| 13.1k| : type(Node::Entry::Type::kUInt64), units(units2), value_uint64(value) {} _ZN8perfetto15trace_processor15GlobalNodeGraph4EdgeC2EPNS1_4NodeES4_i: 187| 30.5k| : source_(source), target_(target), priority_(priority) {} _ZN8perfetto15trace_processor15GlobalNodeGraph16PreOrderIteratorC2EONSt3__16vectorIPNS1_4NodeENS3_9allocatorIS6_EEEE: 190| 641| : to_visit_(std::move(roots)) {} _ZN8perfetto15trace_processor15GlobalNodeGraph16PreOrderIteratorD2Ev: 192| 641|PreOrderIterator::~PreOrderIterator() {} _ZN8perfetto15trace_processor15GlobalNodeGraph16PreOrderIterator4nextEv: 195| 47.4k|Node* PreOrderIterator::next() { 196| 48.1k| while (!to_visit_.empty()) { ------------------ | Branch (196:10): [True: 47.5k, False: 641] ------------------ 197| | // Retain a pointer to the node at the top and remove it from stack. 198| 47.5k| Node* node = to_visit_.back(); 199| 47.5k| to_visit_.pop_back(); 200| | 201| | // If the node has already been visited, don't visit it again. 202| 47.5k| if (visited_.count(node) != 0) ------------------ | Branch (202:9): [True: 210, False: 47.3k] ------------------ 203| 210| continue; 204| | 205| | // If we haven't visited the node which this node owns then wait for that. 206| 47.3k| if (node->owns_edge() && visited_.count(node->owns_edge()->target()) == 0) ------------------ | Branch (206:9): [True: 483, False: 46.8k] | Branch (206:9): [True: 466, False: 46.8k] | Branch (206:30): [True: 466, False: 17] ------------------ 207| 466| continue; 208| | 209| | // If we haven't visited the node's parent then wait for that. 210| 46.8k| if (node->parent() && visited_.count(node->parent()) == 0) ------------------ | Branch (210:9): [True: 3.75k, False: 43.0k] | Branch (210:9): [True: 0, False: 46.8k] | Branch (210:27): [True: 0, False: 3.75k] ------------------ 211| 0| continue; 212| | 213| | // Visit all children of this node. 214| 50.6k| for (auto it = node->children()->rbegin(); it != node->children()->rend(); ------------------ | Branch (214:48): [True: 3.77k, False: 46.8k] ------------------ 215| 46.8k| it++) { 216| 3.77k| to_visit_.push_back(it->second); 217| 3.77k| } 218| | 219| | // Visit all owners of this node. 220| 46.8k| for (auto it = node->owned_by_edges()->rbegin(); 221| 47.3k| it != node->owned_by_edges()->rend(); it++) { ------------------ | Branch (221:10): [True: 470, False: 46.8k] ------------------ 222| 470| to_visit_.push_back((*it)->source()); 223| 470| } 224| | 225| | // Add this node to the visited set. 226| 46.8k| visited_.insert(node); 227| 46.8k| return node; 228| 46.8k| } 229| 641| return nullptr; 230| 47.4k|} _ZN8perfetto15trace_processor15GlobalNodeGraph17PostOrderIteratorC2EONSt3__16vectorIPNS1_4NodeENS3_9allocatorIS6_EEEE: 233| 2.56k| : to_visit_(std::move(roots)) {} _ZN8perfetto15trace_processor15GlobalNodeGraph17PostOrderIteratorD2Ev: 235| 2.56k|PostOrderIterator::~PostOrderIterator() = default; _ZN8perfetto15trace_processor15GlobalNodeGraph17PostOrderIterator4nextEv: 238| 190k|Node* PostOrderIterator::next() { 239| 501k| while (!to_visit_.empty()) { ------------------ | Branch (239:10): [True: 498k, False: 2.56k] ------------------ 240| | // Retain a pointer to the node at the top and remove it from stack. 241| 498k| Node* node = to_visit_.back(); 242| 498k| to_visit_.pop_back(); 243| | 244| | // If the node has already been visited, don't visit it again. 245| 498k| if (visited_.count(node) != 0) ------------------ | Branch (245:9): [True: 122k, False: 376k] ------------------ 246| 122k| continue; 247| | 248| | // If the node is at the top of the path, we have already looked 249| | // at its children and owners. 250| 376k| if (!path_.empty() && path_.back() == node) { ------------------ | Branch (250:9): [True: 203k, False: 173k] | Branch (250:27): [True: 188k, False: 15.0k] ------------------ 251| | // Mark the current node as visited so we don't visit again. 252| 188k| visited_.insert(node); 253| | 254| | // The current node is no longer on the path. 255| 188k| path_.pop_back(); 256| | 257| 188k| return node; 258| 188k| } 259| | 260| | // If the node is not at the front, it should also certainly not be 261| | // anywhere else in the path. If it is, there is a cycle in the graph. 262| 188k| path_.push_back(node); 263| | 264| | // Add this node back to the queue of nodes to visit. 265| 188k| to_visit_.push_back(node); 266| | 267| | // Visit all children of this node. 268| 203k| for (auto it = node->children()->rbegin(); it != node->children()->rend(); ------------------ | Branch (268:48): [True: 15.0k, False: 188k] ------------------ 269| 188k| it++) { 270| 15.0k| to_visit_.push_back(it->second); 271| 15.0k| } 272| | 273| | // Visit all owners of this node. 274| 188k| for (auto it = node->owned_by_edges()->rbegin(); 275| 310k| it != node->owned_by_edges()->rend(); it++) { ------------------ | Branch (275:10): [True: 122k, False: 188k] ------------------ 276| 122k| to_visit_.push_back((*it)->source()); 277| 122k| } 278| 188k| } 279| 2.56k| return nullptr; 280| 190k|} _ZN8perfetto15trace_processor14GraphProcessor17CreateMemoryGraphERKNSt3__13mapIiNS2_10unique_ptrINS0_20RawProcessMemoryNodeENS2_14default_deleteIS5_EEEENS2_4lessIiEENS2_9allocatorINS2_4pairIKiS8_EEEEEE: 59| 641| const GraphProcessor::RawMemoryNodeMap& process_nodes) { 60| 641| auto global_graph = std::unique_ptr(new GlobalNodeGraph()); 61| | 62| | // First pass: collects allocator nodes into a graph and populate 63| | // with entries. 64| 42.6k| for (const auto& pid_to_node : process_nodes) { ------------------ | Branch (64:32): [True: 42.6k, False: 641] ------------------ 65| | // There can be null entries in the map; simply filter these out. 66| 42.6k| if (!pid_to_node.second) ------------------ | Branch (66:9): [True: 0, False: 42.6k] ------------------ 67| 0| continue; 68| | 69| 42.6k| auto* graph = global_graph->CreateGraphForProcess(pid_to_node.first); 70| 42.6k| CollectAllocatorNodes(*pid_to_node.second, global_graph.get(), graph); 71| 42.6k| } 72| | 73| | // Second pass: generate the graph of edges between the nodes. 74| 42.6k| for (const auto& pid_to_node : process_nodes) { ------------------ | Branch (74:32): [True: 42.6k, False: 641] ------------------ 75| | // There can be null entries in the map; simply filter these out. 76| 42.6k| if (!pid_to_node.second) ------------------ | Branch (76:9): [True: 0, False: 42.6k] ------------------ 77| 0| continue; 78| | 79| 42.6k| AddEdges(*pid_to_node.second, global_graph.get()); 80| 42.6k| } 81| | 82| 641| return global_graph; 83| 641|} _ZN8perfetto15trace_processor14GraphProcessor22CalculateSizesForGraphEPNS0_15GlobalNodeGraphE: 141| 641|void GraphProcessor::CalculateSizesForGraph(GlobalNodeGraph* global_graph) { 142| | // Eighth pass: calculate the size field for nodes by considering the sizes 143| | // of their children and owners. 144| 641| { 145| 641| auto it = global_graph->VisitInDepthFirstPostOrder(); 146| 47.6k| while (Node* node = it.next()) { ------------------ | Branch (146:18): [True: 47.0k, False: 641] ------------------ 147| 47.0k| CalculateSizeForNode(node); 148| 47.0k| } 149| 641| } 150| | 151| | // Ninth pass: Calculate not-owned and not-owning sub-sizes of all nodes. 152| 641| { 153| 641| auto it = global_graph->VisitInDepthFirstPostOrder(); 154| 47.6k| while (Node* node = it.next()) { ------------------ | Branch (154:18): [True: 47.0k, False: 641] ------------------ 155| 47.0k| CalculateNodeSubSizes(node); 156| 47.0k| } 157| 641| } 158| | 159| | // Tenth pass: Calculate owned and owning coefficients of owned and owner 160| | // nodes. 161| 641| { 162| 641| auto it = global_graph->VisitInDepthFirstPostOrder(); 163| 47.6k| while (Node* node = it.next()) { ------------------ | Branch (163:18): [True: 47.0k, False: 641] ------------------ 164| 47.0k| CalculateNodeOwnershipCoefficient(node); 165| 47.0k| } 166| 641| } 167| | 168| | // Eleventh pass: Calculate cumulative owned and owning coefficients of all 169| | // nodes. 170| 641| { 171| 641| auto it = global_graph->VisitInDepthFirstPreOrder(); 172| 47.4k| while (Node* node = it.next()) { ------------------ | Branch (172:18): [True: 46.8k, False: 641] ------------------ 173| 46.8k| CalculateNodeCumulativeOwnershipCoefficient(node); 174| 46.8k| } 175| 641| } 176| | 177| | // Twelfth pass: Calculate the effective sizes of all nodes. 178| 641| { 179| 641| auto it = global_graph->VisitInDepthFirstPostOrder(); 180| 47.6k| while (Node* node = it.next()) { ------------------ | Branch (180:18): [True: 47.0k, False: 641] ------------------ 181| 47.0k| CalculateNodeEffectiveSize(node); 182| 47.0k| } 183| 641| } 184| 641|} _ZN8perfetto15trace_processor14GraphProcessor21CollectAllocatorNodesERKNS0_20RawProcessMemoryNodeEPNS0_15GlobalNodeGraphEPNS5_7ProcessE: 267| 42.6k| Process* process_graph) { 268| | // Turn each node into a node in the graph of nodes in the appropriate 269| | // process node or global node. 270| 42.6k| for (const auto& path_to_node : source.allocator_nodes()) { ------------------ | Branch (270:33): [True: 13.5k, False: 42.6k] ------------------ 271| 13.5k| const std::string& path = path_to_node.first; 272| 13.5k| const RawMemoryGraphNode& raw_node = *path_to_node.second; 273| | 274| | // All global nodes (i.e. those starting with global/) should be redirected 275| | // to the shared graph. 276| 13.5k| bool is_global = base::StartsWith(path, "global/"); 277| 13.5k| Process* process = 278| 13.5k| is_global ? global_graph->shared_memory_graph() : process_graph; ------------------ | Branch (278:9): [True: 129, False: 13.3k] ------------------ 279| | 280| 13.5k| Node* node; 281| 13.5k| auto node_iterator = global_graph->nodes_by_id().find(raw_node.id()); 282| 13.5k| if (node_iterator == global_graph->nodes_by_id().end()) { ------------------ | Branch (282:9): [True: 10.6k, False: 2.86k] ------------------ 283| | // Storing whether the process is weak here will allow for later 284| | // computations on whether or not the node should be removed. 285| 10.6k| bool is_weak = raw_node.flags() & RawMemoryGraphNode::Flags::kWeak; 286| 10.6k| node = process->CreateNode(raw_node.id(), path, is_weak); 287| 10.6k| } else { 288| 2.86k| node = node_iterator->second; 289| | 290| 2.86k| PERFETTO_DCHECK(node == process->FindNode(path)); 291| | 292| 2.86k| PERFETTO_DCHECK(is_global); 293| 2.86k| } 294| | 295| | // Copy any entries not already present into the node. 296| 13.5k| for (auto& entry : raw_node.entries()) { ------------------ | Branch (296:22): [True: 5.07k, False: 13.5k] ------------------ 297| 5.07k| switch (entry.entry_type) { ------------------ | Branch (297:15): [True: 0, False: 5.07k] ------------------ 298| 5.07k| case RawMemoryGraphNode::MemoryNodeEntry::EntryType::kUint64: ------------------ | Branch (298:9): [True: 5.07k, False: 0] ------------------ 299| 5.07k| node->AddEntry(entry.name, EntryUnitsFromString(entry.units), 300| 5.07k| entry.value_uint64); 301| 5.07k| break; 302| 0| case RawMemoryGraphNode::MemoryNodeEntry::EntryType::kString: ------------------ | Branch (302:9): [True: 0, False: 5.07k] ------------------ 303| 0| node->AddEntry(entry.name, entry.value_string); 304| 0| break; 305| 5.07k| } 306| 5.07k| } 307| 13.5k| } 308| 42.6k|} _ZN8perfetto15trace_processor14GraphProcessor8AddEdgesERKNS0_20RawProcessMemoryNodeEPNS0_15GlobalNodeGraphE: 312| 42.6k| GlobalNodeGraph* global_graph) { 313| 42.6k| const auto& nodes_by_id = global_graph->nodes_by_id(); 314| 42.6k| for (const auto& id_to_edge : source.allocator_nodes_edges()) { ------------------ | Branch (314:31): [True: 37.1k, False: 42.6k] ------------------ 315| 37.1k| auto& edge = id_to_edge.second; 316| | 317| | // Find the source and target nodes in the global map by id. 318| 37.1k| auto source_it = nodes_by_id.find(edge->source); 319| 37.1k| auto target_it = nodes_by_id.find(edge->target); 320| | 321| 37.1k| if (source_it == nodes_by_id.end()) { ------------------ | Branch (321:9): [True: 6.56k, False: 30.5k] ------------------ 322| | // If the source is missing then simply pretend the edge never existed 323| | // leading to the memory being allocated to the target (if it exists). 324| 6.56k| continue; 325| 30.5k| } else if (target_it == nodes_by_id.end()) { ------------------ | Branch (325:16): [True: 0, False: 30.5k] ------------------ 326| | // If the target is lost but the source is present, then also ignore 327| | // this edge for now. 328| | // TODO(lalitm): see crbug.com/770712 for the permanent fix for this 329| | // issue. 330| 0| continue; 331| 30.5k| } else { 332| | // Add an edge indicating the source node owns the memory of the 333| | // target node with the given importance of the edge. 334| 30.5k| global_graph->AddNodeOwnershipEdge(source_it->second, target_it->second, 335| 30.5k| edge->importance); 336| 30.5k| } 337| 37.1k| } 338| 42.6k|} _ZN8perfetto15trace_processor14GraphProcessor30AggregateSizeForDescendantNodeEPNS0_15GlobalNodeGraph4NodeES4_: 535| 4.73k| Node* descendant) { 536| 4.73k| Edge* owns_edge = descendant->owns_edge(); 537| 4.73k| if (owns_edge && owns_edge->target()->IsDescendentOf(*root)) ------------------ | Branch (537:7): [True: 56, False: 4.68k] | Branch (537:20): [True: 32, False: 24] ------------------ 538| 32| return std::make_optional(0UL); 539| | 540| 4.70k| if (descendant->children()->empty()) ------------------ | Branch (540:7): [True: 3.71k, False: 989] ------------------ 541| 3.71k| return GetSizeEntryOfNode(descendant).value_or(0ul); 542| | 543| 989| std::optional size; 544| 993| for (const auto& path_to_child : *descendant->children()) { ------------------ | Branch (544:34): [True: 993, False: 989] ------------------ 545| 993| auto c_size = AggregateSizeForDescendantNode(root, path_to_child.second); 546| 993| if (size) { ------------------ | Branch (546:9): [True: 4, False: 989] ------------------ 547| 4| *size += c_size.value_or(0); 548| 989| } else { 549| 989| size = std::move(c_size); 550| 989| } 551| 993| } 552| 989| return size; 553| 4.70k|} _ZN8perfetto15trace_processor14GraphProcessor20CalculateSizeForNodeEPNS0_15GlobalNodeGraph4NodeE: 557| 47.0k|void GraphProcessor::CalculateSizeForNode(Node* node) { 558| | // Get the size at the root node if it exists. 559| 47.0k| std::optional node_size = GetSizeEntryOfNode(node); 560| | 561| | // Aggregate the size of all the child nodes. 562| 47.0k| std::optional aggregated_size; 563| 47.0k| for (const auto& path_to_child : *node->children()) { ------------------ | Branch (563:34): [True: 3.74k, False: 47.0k] ------------------ 564| 3.74k| auto c_size = AggregateSizeForDescendantNode(node, path_to_child.second); 565| 3.74k| if (aggregated_size) { ------------------ | Branch (565:9): [True: 4, False: 3.73k] ------------------ 566| 4| *aggregated_size += c_size.value_or(0ul); 567| 3.73k| } else { 568| 3.73k| aggregated_size = std::move(c_size); 569| 3.73k| } 570| 3.74k| } 571| | 572| | // Check that if both aggregated and node sizes exist that the node size 573| | // is bigger than the aggregated. 574| | // TODO(lalitm): the following condition is triggered very often even though 575| | // it is a warning in JS code. Find a way to add the warning to display in UI 576| | // or to fix all instances where this is violated and then enable this check. 577| | // PERFETTO_DCHECK(!node_size || !aggregated_size || *node_size >= 578| | // *aggregated_size); 579| | 580| | // Calculate the maximal size of an owner node. 581| 47.0k| std::optional max_owner_size; 582| 47.0k| for (auto* edge : *node->owned_by_edges()) { ------------------ | Branch (582:19): [True: 30.5k, False: 47.0k] ------------------ 583| 30.5k| auto o_size = GetSizeEntryOfNode(edge->source()); 584| 30.5k| if (max_owner_size) { ------------------ | Branch (584:9): [True: 30.0k, False: 463] ------------------ 585| 30.0k| *max_owner_size = std::max(o_size.value_or(0ul), *max_owner_size); 586| 30.0k| } else { 587| 463| max_owner_size = std::move(o_size); 588| 463| } 589| 30.5k| } 590| | 591| | // Check that if both owner and node sizes exist that the node size 592| | // is bigger than the owner. 593| | // TODO(lalitm): the following condition is triggered very often even though 594| | // it is a warning in JS code. Find a way to add the warning to display in UI 595| | // or to fix all instances where this is violated and then enable this check. 596| | // PERFETTO_DCHECK(!node_size || !max_owner_size || *node_size >= 597| | // *max_owner_size); 598| | 599| | // Clear out any existing size entry which may exist. 600| 47.0k| node->entries()->erase(kSizeEntryName); 601| | 602| | // If no inference about size can be made then simply return. 603| 47.0k| if (!node_size && !aggregated_size && !max_owner_size) ------------------ | Branch (603:7): [True: 46.7k, False: 264] | Branch (603:21): [True: 43.0k, False: 3.70k] | Branch (603:41): [True: 43.0k, False: 23] ------------------ 604| 43.0k| return; 605| | 606| | // Update the node with the new size entry. 607| 3.99k| uint64_t aggregated_size_value = aggregated_size.value_or(0ul); 608| 3.99k| uint64_t process_size = 609| 3.99k| std::max({node_size.value_or(0ul), aggregated_size_value, 610| 3.99k| max_owner_size.value_or(0ul)}); 611| 3.99k| node->AddEntry(kSizeEntryName, Node::Entry::ScalarUnits::kBytes, 612| 3.99k| process_size); 613| | 614| | // If this is an intermediate node then add a ghost node which stores 615| | // all sizes not accounted for by the children. 616| 3.99k| uint64_t unaccounted = process_size - aggregated_size_value; 617| 3.99k| if (unaccounted > 0 && !node->children()->empty()) { ------------------ | Branch (617:7): [True: 287, False: 3.70k] | Branch (617:26): [True: 31, False: 256] ------------------ 618| 31| Node* unspecified = node->CreateChild(""); 619| 31| unspecified->AddEntry(kSizeEntryName, Node::Entry::ScalarUnits::kBytes, 620| 31| unaccounted); 621| 31| } 622| 3.99k|} _ZN8perfetto15trace_processor14GraphProcessor21CalculateNodeSubSizesEPNS0_15GlobalNodeGraph4NodeE: 626| 47.0k|void GraphProcessor::CalculateNodeSubSizes(Node* node) { 627| | // Completely skip nodes with undefined size. 628| 47.0k| std::optional size_opt = GetSizeEntryOfNode(node); 629| 47.0k| if (!size_opt) ------------------ | Branch (629:7): [True: 43.0k, False: 4.02k] ------------------ 630| 43.0k| return; 631| | 632| | // If the node is a leaf node, then both sub-sizes are equal to the size. 633| 4.02k| if (node->children()->empty()) { ------------------ | Branch (633:7): [True: 287, False: 3.73k] ------------------ 634| 287| node->add_not_owning_sub_size(*size_opt); 635| 287| node->add_not_owned_sub_size(*size_opt); 636| 287| return; 637| 287| } 638| | 639| | // Calculate this node's not-owning sub-size by summing up the not-owning 640| | // sub-sizes of children which do not own another node. 641| 3.77k| for (const auto& path_to_child : *node->children()) { ------------------ | Branch (641:34): [True: 3.77k, False: 3.73k] ------------------ 642| 3.77k| if (path_to_child.second->owns_edge()) ------------------ | Branch (642:9): [True: 28, False: 3.74k] ------------------ 643| 28| continue; 644| 3.74k| node->add_not_owning_sub_size(path_to_child.second->not_owning_sub_size()); 645| 3.74k| } 646| | 647| | // Calculate this node's not-owned sub-size. 648| 3.77k| for (const auto& path_to_child : *node->children()) { ------------------ | Branch (648:34): [True: 3.77k, False: 3.73k] ------------------ 649| 3.77k| Node* child = path_to_child.second; 650| | 651| | // If the child node is not owned, then add its not-owned sub-size. 652| 3.77k| if (child->owned_by_edges()->empty()) { ------------------ | Branch (652:9): [True: 3.74k, False: 34] ------------------ 653| 3.74k| node->add_not_owned_sub_size(child->not_owned_sub_size()); 654| 3.74k| continue; 655| 3.74k| } 656| | 657| | // If the child node is owned, then add the difference between its size 658| | // and the largest owner. 659| 34| uint64_t largest_owner_size = 0; 660| 504| for (Edge* edge : *child->owned_by_edges()) { ------------------ | Branch (660:21): [True: 504, False: 34] ------------------ 661| 504| uint64_t source_size = GetSizeEntryOfNode(edge->source()).value_or(0); 662| 504| largest_owner_size = std::max(largest_owner_size, source_size); 663| 504| } 664| 34| uint64_t child_size = GetSizeEntryOfNode(child).value_or(0); 665| 34| node->add_not_owned_sub_size(child_size - largest_owner_size); 666| 34| } 667| 3.73k|} _ZN8perfetto15trace_processor14GraphProcessor33CalculateNodeOwnershipCoefficientEPNS0_15GlobalNodeGraph4NodeE: 670| 47.0k|void GraphProcessor::CalculateNodeOwnershipCoefficient(Node* node) { 671| | // Completely skip nodes with undefined size. 672| 47.0k| std::optional size_opt = GetSizeEntryOfNode(node); 673| 47.0k| if (!size_opt) ------------------ | Branch (673:7): [True: 43.0k, False: 4.02k] ------------------ 674| 43.0k| return; 675| | 676| | // We only need to consider owned nodes. 677| 4.02k| if (node->owned_by_edges()->empty()) ------------------ | Branch (677:7): [True: 3.78k, False: 242] ------------------ 678| 3.78k| return; 679| | 680| | // Sort the owners in decreasing order of ownership priority and 681| | // increasing order of not-owning sub-size (in case of equal priority). 682| 242| std::vector owners = *node->owned_by_edges(); 683| 242| std::sort(owners.begin(), owners.end(), [](Edge* a, Edge* b) { 684| 242| if (a->priority() == b->priority()) { 685| 242| return a->source()->not_owning_sub_size() < 686| 242| b->source()->not_owning_sub_size(); 687| 242| } 688| 242| return b->priority() < a->priority(); 689| 242| }); 690| | 691| | // Loop over the list of owners and distribute the owned node's not-owned 692| | // sub-size among them according to their ownership priority and 693| | // not-owning sub-size. 694| 242| uint64_t already_attributed_sub_size = 0; 695| 17.2k| for (auto current_it = owners.begin(); current_it != owners.end();) { ------------------ | Branch (695:42): [True: 17.0k, False: 242] ------------------ 696| | // Find the position of the first owner with lower priority. 697| 17.0k| int current_priority = (*current_it)->priority(); 698| 17.0k| auto next_it = 699| 17.0k| std::find_if(current_it, owners.end(), [current_priority](Edge* edge) { 700| 17.0k| return edge->priority() < current_priority; 701| 17.0k| }); 702| | 703| | // Compute the number of nodes which have the same priority as current. 704| 17.0k| size_t difference = static_cast(std::distance(current_it, next_it)); 705| | 706| | // Visit the owners with the same priority in increasing order of 707| | // not-owned sub-size, split the owned memory among them appropriately, 708| | // and calculate their owning coefficients. 709| 17.0k| double attributed_not_owning_sub_size = 0; 710| 47.5k| for (; current_it != next_it; current_it++) { ------------------ | Branch (710:12): [True: 30.4k, False: 17.0k] ------------------ 711| 30.4k| uint64_t not_owning_sub_size = 712| 30.4k| (*current_it)->source()->not_owning_sub_size(); 713| 30.4k| if (not_owning_sub_size > already_attributed_sub_size) { ------------------ | Branch (713:11): [True: 236, False: 30.2k] ------------------ 714| 236| attributed_not_owning_sub_size += 715| 236| static_cast(not_owning_sub_size - 716| 236| already_attributed_sub_size) / 717| 236| static_cast(difference); 718| 236| already_attributed_sub_size = not_owning_sub_size; 719| 236| } 720| | 721| 30.4k| if (not_owning_sub_size != 0) { ------------------ | Branch (721:11): [True: 30.2k, False: 215] ------------------ 722| 30.2k| double coeff = attributed_not_owning_sub_size / 723| 30.2k| static_cast(not_owning_sub_size); 724| 30.2k| (*current_it)->source()->set_owning_coefficient(coeff); 725| 30.2k| } 726| 30.4k| difference--; 727| 30.4k| } 728| | 729| | // At the end of this loop, we should move to a node with a lower priority. 730| 17.0k| PERFETTO_DCHECK(current_it == next_it); 731| 17.0k| } 732| | 733| | // Attribute the remainder of the owned node's not-owned sub-size to 734| | // the node itself and calculate its owned coefficient. 735| 242| uint64_t not_owned_sub_size = node->not_owned_sub_size(); 736| 242| if (not_owned_sub_size != 0) { ------------------ | Branch (736:7): [True: 242, False: 0] ------------------ 737| 242| double remainder_sub_size = 738| 242| static_cast(not_owned_sub_size - already_attributed_sub_size); 739| 242| node->set_owned_coefficient(remainder_sub_size / 740| 242| static_cast(not_owned_sub_size)); 741| 242| } 742| 242|} _ZN8perfetto15trace_processor14GraphProcessor43CalculateNodeCumulativeOwnershipCoefficientEPNS0_15GlobalNodeGraph4NodeE: 745| 46.8k|void GraphProcessor::CalculateNodeCumulativeOwnershipCoefficient(Node* node) { 746| | // Completely skip nodes with undefined size. 747| 46.8k| std::optional size_opt = GetSizeEntryOfNode(node); 748| 46.8k| if (!size_opt) ------------------ | Branch (748:7): [True: 43.0k, False: 3.82k] ------------------ 749| 43.0k| return; 750| | 751| 3.82k| double cumulative_owned_coefficient = node->owned_coefficient(); 752| 3.82k| if (node->parent()) { ------------------ | Branch (752:7): [True: 620, False: 3.20k] ------------------ 753| 620| cumulative_owned_coefficient *= 754| 620| node->parent()->cumulative_owned_coefficient(); 755| 620| } 756| 3.82k| node->set_cumulative_owned_coefficient(cumulative_owned_coefficient); 757| | 758| 3.82k| if (node->owns_edge()) { ------------------ | Branch (758:7): [True: 11, False: 3.81k] ------------------ 759| 11| node->set_cumulative_owning_coefficient( 760| 11| node->owning_coefficient() * 761| 11| node->owns_edge()->target()->cumulative_owning_coefficient()); 762| 3.81k| } else if (node->parent()) { ------------------ | Branch (762:14): [True: 609, False: 3.20k] ------------------ 763| 609| node->set_cumulative_owning_coefficient( 764| 609| node->parent()->cumulative_owning_coefficient()); 765| 3.20k| } else { 766| 3.20k| node->set_cumulative_owning_coefficient(1); 767| 3.20k| } 768| 3.82k|} _ZN8perfetto15trace_processor14GraphProcessor26CalculateNodeEffectiveSizeEPNS0_15GlobalNodeGraph4NodeE: 771| 47.0k|void GraphProcessor::CalculateNodeEffectiveSize(Node* node) { 772| | // Completely skip nodes with undefined size. As a result, each node will 773| | // have defined effective size if and only if it has defined size. 774| 47.0k| std::optional size_opt = GetSizeEntryOfNode(node); 775| 47.0k| if (!size_opt) { ------------------ | Branch (775:7): [True: 43.0k, False: 4.02k] ------------------ 776| 43.0k| node->entries()->erase(kEffectiveSizeEntryName); 777| 43.0k| return; 778| 43.0k| } 779| | 780| 4.02k| uint64_t effective_size = 0; 781| 4.02k| if (node->children()->empty()) { ------------------ | Branch (781:7): [True: 287, False: 3.73k] ------------------ 782| | // Leaf node. 783| 287| effective_size = static_cast( 784| 287| static_cast(*size_opt) * node->cumulative_owning_coefficient() * 785| 287| node->cumulative_owned_coefficient()); 786| 3.73k| } else { 787| | // Non-leaf node. 788| 3.77k| for (const auto& path_to_child : *node->children()) { ------------------ | Branch (788:36): [True: 3.77k, False: 3.73k] ------------------ 789| 3.77k| Node* child = path_to_child.second; 790| 3.77k| if (!GetSizeEntryOfNode(child)) ------------------ | Branch (790:11): [True: 3.13k, False: 637] ------------------ 791| 3.13k| continue; 792| 637| effective_size += 793| 637| child->entries()->find(kEffectiveSizeEntryName)->second.value_uint64; 794| 637| } 795| 3.73k| } 796| 4.02k| node->AddEntry(kEffectiveSizeEntryName, Node::Entry::ScalarUnits::kBytes, 797| 4.02k| effective_size); 798| 4.02k|} graph_processor.cc:_ZN8perfetto15trace_processor12_GLOBAL__N_120EntryUnitsFromStringERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE: 34| 5.07k|Node::Entry::ScalarUnits EntryUnitsFromString(const std::string& units) { 35| 5.07k| if (units == RawMemoryGraphNode::kUnitsBytes) { ------------------ | Branch (35:7): [True: 2.29k, False: 2.78k] ------------------ 36| 2.29k| return Node::Entry::ScalarUnits::kBytes; 37| 2.78k| } else if (units == RawMemoryGraphNode::kUnitsObjects) { ------------------ | Branch (37:14): [True: 0, False: 2.78k] ------------------ 38| 0| return Node::Entry::ScalarUnits::kObjects; 39| 2.78k| } else { 40| | // Invalid units so we just return a value of the correct type. 41| 2.78k| return Node::Entry::ScalarUnits::kObjects; 42| 2.78k| } 43| 5.07k|} graph_processor.cc:_ZN8perfetto15trace_processor12_GLOBAL__N_118GetSizeEntryOfNodeEPNS0_15GlobalNodeGraph4NodeE: 45| 273k|std::optional GetSizeEntryOfNode(Node* node) { 46| 273k| auto size_it = node->entries()->find(kSizeEntryName); 47| 273k| if (size_it == node->entries()->end()) ------------------ | Branch (47:7): [True: 226k, False: 47.4k] ------------------ 48| 226k| return std::nullopt; 49| | 50| 47.4k| PERFETTO_DCHECK(size_it->second.type == Node::Entry::Type::kUInt64); 51| 47.4k| PERFETTO_DCHECK(size_it->second.units == Node::Entry::ScalarUnits::kBytes); 52| 47.4k| return std::optional(size_it->second.value_uint64); 53| 273k|} graph_processor.cc:_ZZN8perfetto15trace_processor14GraphProcessor33CalculateNodeOwnershipCoefficientEPNS0_15GlobalNodeGraph4NodeEENK3$_0clEPNS2_4EdgeES7_: 683| 217k| std::sort(owners.begin(), owners.end(), [](Edge* a, Edge* b) { 684| 217k| if (a->priority() == b->priority()) { ------------------ | Branch (684:9): [True: 29.1k, False: 188k] ------------------ 685| 29.1k| return a->source()->not_owning_sub_size() < 686| 29.1k| b->source()->not_owning_sub_size(); 687| 29.1k| } 688| 188k| return b->priority() < a->priority(); 689| 217k| }); graph_processor.cc:_ZZN8perfetto15trace_processor14GraphProcessor33CalculateNodeOwnershipCoefficientEPNS0_15GlobalNodeGraph4NodeEENK3$_1clEPNS2_4EdgeE: 699| 47.2k| std::find_if(current_it, owners.end(), [current_priority](Edge* edge) { 700| 47.2k| return edge->priority() < current_priority; 701| 47.2k| }); _ZN8perfetto15trace_processor21MemoryAllocatorNodeIdC2Em: 29| 248k|MemoryAllocatorNodeId::MemoryAllocatorNodeId(uint64_t id) : id_(id) {} _ZN8perfetto15trace_processor21MemoryAllocatorNodeIdC2Ev: 31| 47.0k|MemoryAllocatorNodeId::MemoryAllocatorNodeId() : MemoryAllocatorNodeId(0u) {} _ZN8perfetto15trace_processor18RawMemoryGraphNode15MemoryNodeEntryC2ERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEESB_m: 32| 8.73k| : name(n), units(u), entry_type(kUint64), value_uint64(v) {} _ZN8perfetto15trace_processor18RawMemoryGraphNodeC2ERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS0_13LevelOfDetailENS0_21MemoryAllocatorNodeIdEONS2_6vectorINS1_15MemoryNodeEntryENS6_ISE_EEEE: 65| 38.5k| : absolute_name_(absolute_name), 66| 38.5k| level_of_detail_(level), 67| 38.5k| entries_(std::move(entries)), 68| 38.5k| id_(id), 69| 38.5k| flags_(Flags::kDefault) {} _ZN8perfetto15trace_processor20RawProcessMemoryNodeC2ENS0_13LevelOfDetailEONSt3__13mapINS0_21MemoryAllocatorNodeIdENS3_10unique_ptrINS0_15MemoryGraphEdgeENS3_14default_deleteIS7_EEEENS3_4lessIS5_EENS3_9allocatorINS3_4pairIKS5_SA_EEEEEEONS4_INS3_12basic_stringIcNS3_11char_traitsIcEENSD_IcEEEENS6_INS0_18RawMemoryGraphNodeENS8_ISP_EEEENSB_ISO_EENSD_INSE_IKSO_SR_EEEEEE: 34| 58.5k| : level_of_detail_(level_of_detail), 35| 58.5k| allocator_nodes_edges_(std::move(edges_map)), 36| 58.5k| allocator_nodes_(std::move(nodes_map)) {} _ZN8perfetto15trace_processor20RawProcessMemoryNodeD2Ev: 39| 58.5k|RawProcessMemoryNode::~RawProcessMemoryNode() = default; _ZN8perfetto15trace_processor18perf_text_importer15ParseSampleLineENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEE: 69| 431|std::optional ParseSampleLine(std::string_view line) { 70| | // Example of what we're parsing here: 71| | // trace_processor 3962131 303057.417513: 1 cpu_atom/cycles/Pu: 72| | // 73| | // Find colons and look backwards to find something which looks like a 74| | // timestamp. Anything before that is metadata of the sample we may be able 75| | // to parse out. 76| 59.2k| for (size_t s = 0, cln = line.find(':', s); cln != std::string_view::npos; ------------------ | Branch (76:47): [True: 58.7k, False: 431] ------------------ 77| 58.7k| s = cln + 1, cln = line.find(':', s)) { 78| 58.7k| std::string_view raw_ts = FindTsAtEnd(line.substr(0, cln)); 79| 58.7k| if (raw_ts.empty()) { ------------------ | Branch (79:9): [True: 58.4k, False: 378] ------------------ 80| 58.4k| continue; 81| 58.4k| } 82| 378| std::optional ts = base::StringToDouble(std::string(raw_ts)); 83| 378| if (!ts) { ------------------ | Branch (83:9): [True: 0, False: 378] ------------------ 84| 0| continue; 85| 0| } 86| 378| std::string before_ts(line.data(), 87| 378| static_cast(raw_ts.data() - line.data())); 88| | 89| | // simpleperf puts tabs after the comm while perf puts spaces. Make it 90| | // consistent and just use spaces. 91| 378| before_ts = base::ReplaceAll(before_ts, "\t", " "); 92| | 93| 378| std::vector pieces = base::SplitString(before_ts, " "); 94| 378| if (pieces.empty()) { ------------------ | Branch (94:9): [True: 0, False: 378] ------------------ 95| 0| continue; 96| 0| } 97| | 98| 378| size_t pos = pieces.size() - 1; 99| | 100| | // Try to parse out the CPU in the form: '[cpu]' (e.g. '[3]'). 101| 378| std::optional cpu; 102| 378| if (base::StartsWith(pieces[pos], "[") && ------------------ | Branch (102:9): [True: 0, False: 378] | Branch (102:9): [True: 0, False: 378] ------------------ 103| 378| base::EndsWith(pieces[pos], "]")) { ------------------ | Branch (103:9): [True: 0, False: 0] ------------------ 104| 0| cpu = base::StringToUInt32(pieces[pos].substr(1, pieces[pos].size() - 2)); 105| 0| if (!cpu) { ------------------ | Branch (105:11): [True: 0, False: 0] ------------------ 106| 0| continue; 107| 0| } 108| 0| --pos; 109| 0| } 110| | 111| | // Try to parse out the tid and pid in the form 'pid/tid' (e.g. 112| | // '1024/1025'). If there's no '/' then just try to parse it as a tid. 113| 378| std::vector pid_and_tid = base::SplitString(pieces[pos], "/"); 114| 378| if (pid_and_tid.size() == 0 || pid_and_tid.size() > 2) { ------------------ | Branch (114:9): [True: 0, False: 378] | Branch (114:36): [True: 0, False: 378] ------------------ 115| 0| continue; 116| 0| } 117| | 118| 378| uint32_t tid_idx = pid_and_tid.size() == 1 ? 0 : 1; ------------------ | Branch (118:24): [True: 201, False: 177] ------------------ 119| 378| auto opt_tid = base::StringToUInt32(pid_and_tid[tid_idx]); 120| 378| if (!opt_tid) { ------------------ | Branch (120:9): [True: 378, False: 0] ------------------ 121| 378| continue; 122| 378| } 123| 0| uint32_t tid = *opt_tid; 124| | 125| 0| std::optional pid; 126| 0| if (pid_and_tid.size() == 2) { ------------------ | Branch (126:9): [True: 0, False: 0] ------------------ 127| 0| pid = base::StringToUInt32(pid_and_tid[0]); 128| 0| if (!pid) { ------------------ | Branch (128:11): [True: 0, False: 0] ------------------ 129| 0| continue; 130| 0| } 131| 0| } 132| | 133| | // All the remaining pieces are the comm which needs to be joined together 134| | // with ' '. 135| 0| pieces.resize(pos); 136| 0| std::string comm = base::Join(pieces, " "); 137| 0| return SampleLine{ 138| 0| comm, pid, tid, cpu, static_cast(*ts * 1000 * 1000 * 1000), 139| 0| }; 140| 0| } 141| 431| return std::nullopt; 142| 431|} _ZN8perfetto15trace_processor18perf_text_importer21IsPerfTextFormatTraceEPKhm: 144| 432|bool IsPerfTextFormatTrace(const uint8_t* ptr, size_t size) { 145| 432| std::string_view str(reinterpret_cast(ptr), size); 146| 432| size_t nl = str.find('\n'); 147| 432| if (nl == std::string_view::npos) { ------------------ | Branch (147:7): [True: 1, False: 431] ------------------ 148| 1| return false; 149| 1| } 150| 431| return ParseSampleLine(str.substr(0, nl)).has_value(); 151| 432|} perf_text_sample_line_parser.cc:_ZN8perfetto15trace_processor18perf_text_importer12_GLOBAL__N_111FindTsAtEndENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEE: 33| 58.7k|std::string_view FindTsAtEnd(std::string_view line) { 34| | // We need to have 8 characters to have a valid timestamp with decimal 35| | // and 6 trailing digits. 36| 58.7k| if (line.size() < 8) { ------------------ | Branch (36:7): [True: 5, False: 58.7k] ------------------ 37| 5| return {}; 38| 5| } 39| | // All of the 6 trailing digits should be digits. 40| 90.0k| for (char c : line.substr(line.size() - 6)) { ------------------ | Branch (40:15): [True: 90.0k, False: 1.55k] ------------------ 41| 90.0k| if (!isdigit(c)) { ------------------ | Branch (41:9): [True: 57.2k, False: 32.7k] ------------------ 42| 57.2k| return {}; 43| 57.2k| } 44| 90.0k| } 45| | // 7 digits from the end should be a '.'. 46| 1.55k| if (line[line.size() - 7] != '.') { ------------------ | Branch (46:7): [True: 760, False: 799] ------------------ 47| 760| return {}; 48| 760| } 49| | 50| | // A space before the timestamp dot should exist. 51| 799| std::string_view until_dot = line.substr(0, line.size() - 7); 52| 799| size_t c = until_dot.rfind(' '); 53| 799| if (c == std::string_view::npos) { ------------------ | Branch (53:7): [True: 0, False: 799] ------------------ 54| 0| return {}; 55| 0| } 56| | 57| | // All the characters between the last space and the colon should also 58| | // be the digits. 59| 799| for (char x : until_dot.substr(c + 1, until_dot.size() - c - 1)) { ------------------ | Branch (59:15): [True: 421, False: 378] ------------------ 60| 421| if (!isdigit(x)) { ------------------ | Branch (60:9): [True: 421, False: 0] ------------------ 61| 421| return {}; 62| 421| } 63| 421| } 64| 378| return line.substr(c + 1); 65| 799|} _ZN8perfetto15trace_processor28ActiveChromeProcessesTracker24AddActiveProcessMetadataElj: 23| 402k| UniquePid upid) { 24| 402k| process_data_[upid].metadata_timestamps.insert(timestamp); 25| 402k| global_metadata_timestamps_.insert(timestamp); 26| 402k|} _ZNK8perfetto15trace_processor28ActiveChromeProcessesTracker24GetProcessesWithDataLossEv: 29| 345|ActiveChromeProcessesTracker::GetProcessesWithDataLoss() const { 30| 345| std::vector processes_with_data_loss; 31| 394k| for (auto it = process_data_.GetIterator(); it; ++it) { ------------------ | Branch (31:47): [True: 394k, False: 345] ------------------ 32| 394k| UniquePid upid = it.key(); 33| 394k| const auto& process_data = it.value(); 34| 394k| std::optional last_loss_moment; 35| 394k| std::optional next_no_loss_moment; 36| 394k| for (int64_t metadata_ts : process_data.metadata_timestamps) { ------------------ | Branch (36:30): [True: 361k, False: 394k] ------------------ 37| | // Looks for a matching process descriptor in the [t - 0.2s, t + 0.2s] 38| | // window. The window size is somewhat arbitrary, and can be changed in 39| | // the future. It should be smaller than the incremental state reset 40| | // interval, which is 5s for Chromium traces. 41| 361k| constexpr int64_t kMaxTimestampDiff = 200 * 1000 * 1000; 42| 361k| auto descriptor_it = process_data.descriptor_timestamps.lower_bound( 43| 361k| metadata_ts - kMaxTimestampDiff); 44| 361k| if (descriptor_it != process_data.descriptor_timestamps.end()) { ------------------ | Branch (44:11): [True: 72, False: 361k] ------------------ 45| 72| if (*descriptor_it > metadata_ts + kMaxTimestampDiff) { ------------------ | Branch (45:13): [True: 58, False: 14] ------------------ 46| | // There's no matching descriptor, but there's a descriptor at some 47| | // point in the future. 48| 58| last_loss_moment = metadata_ts; 49| 58| next_no_loss_moment = *descriptor_it; 50| 58| } 51| 361k| } else { 52| | // There's no matching descriptor, and there're no descriptors in the 53| | // future. 54| 361k| last_loss_moment = metadata_ts; 55| 361k| auto global_metadata_it = 56| 361k| global_metadata_timestamps_.upper_bound(metadata_ts); 57| 361k| if (global_metadata_it != global_metadata_timestamps_.end()) { ------------------ | Branch (57:13): [True: 318k, False: 43.1k] ------------------ 58| | // The process terminated before the next incremental state reset. 59| | // So it has no data loss from the next reset until the end of the 60| | // trace. 61| 318k| next_no_loss_moment = *global_metadata_it; 62| 318k| } else { 63| 43.1k| next_no_loss_moment = std::nullopt; 64| 43.1k| } 65| 361k| } 66| 361k| } 67| 394k| if (last_loss_moment) { ------------------ | Branch (67:9): [True: 361k, False: 32.9k] ------------------ 68| 361k| processes_with_data_loss.push_back({upid, next_no_loss_moment}); 69| 361k| } 70| 394k| } 71| 345| return processes_with_data_loss; 72| 345|} _ZN8perfetto15trace_processor28ActiveChromeProcessesTracker15NotifyEndOfFileEv: 74| 345|void ActiveChromeProcessesTracker::NotifyEndOfFile() { 75| 345| const auto processes = GetProcessesWithDataLoss(); 76| 361k| for (const auto& p : processes) { ------------------ | Branch (76:22): [True: 361k, False: 345] ------------------ 77| 361k| tables::ExpMissingChromeProcTable::Row row; 78| 361k| row.upid = p.upid; 79| 361k| row.reliable_from = p.reliable_from; 80| 361k| context_->storage->mutable_experimental_missing_chrome_processes_table() 81| 361k| ->Insert(row); 82| 361k| } 83| 345|} _ZN8perfetto15trace_processor28ActiveChromeProcessesTrackerC2EPNS0_21TraceProcessorContextE: 44| 2.03k| : context_(context) {} _ZN8perfetto15trace_processor28ActiveChromeProcessesTracker20AddProcessDescriptorElj: 47| 56.9k| void AddProcessDescriptor(int64_t timestamp, UniquePid upid) { 48| 56.9k| process_data_[upid].descriptor_timestamps.insert(timestamp); 49| 56.9k| } _ZN8perfetto15trace_processor10ArgsParserC2ElRNS0_11ArgsTracker13BoundInserterERNS0_12TraceStorageEPNS0_29PacketSequenceStateGenerationEb: 31| 739k| : support_json_(support_json), 32| 739k| packet_timestamp_(packet_timestamp), 33| 739k| sequence_state_(sequence_state), 34| 739k| inserter_(inserter), 35| 739k| storage_(storage) {} _ZN8perfetto15trace_processor10ArgsParserD2Ev: 37| 739k|ArgsParser::~ArgsParser() = default; _ZN8perfetto15trace_processor10ArgsParser10AddIntegerERKNS0_4util17ProtoToArgsParser3KeyEl: 39| 439k|void ArgsParser::AddInteger(const Key& key, int64_t value) { 40| 439k| inserter_.AddArg(storage_.InternString(base::StringView(key.flat_key)), 41| 439k| storage_.InternString(base::StringView(key.key)), 42| 439k| Variadic::Integer(value)); 43| 439k|} _ZN8perfetto15trace_processor10ArgsParser18AddUnsignedIntegerERKNS0_4util17ProtoToArgsParser3KeyEm: 45| 8.21M|void ArgsParser::AddUnsignedInteger(const Key& key, uint64_t value) { 46| 8.21M| inserter_.AddArg(storage_.InternString(base::StringView(key.flat_key)), 47| 8.21M| storage_.InternString(base::StringView(key.key)), 48| 8.21M| Variadic::UnsignedInteger(value)); 49| 8.21M|} _ZN8perfetto15trace_processor10ArgsParser9AddStringERKNS0_4util17ProtoToArgsParser3KeyERKN9protozero10ConstCharsE: 51| 1.08k|void ArgsParser::AddString(const Key& key, const protozero::ConstChars& value) { 52| 1.08k| inserter_.AddArg(storage_.InternString(base::StringView(key.flat_key)), 53| 1.08k| storage_.InternString(base::StringView(key.key)), 54| 1.08k| Variadic::String(storage_.InternString(value))); 55| 1.08k|} _ZN8perfetto15trace_processor10ArgsParser9AddStringERKNS0_4util17ProtoToArgsParser3KeyERKNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEE: 57| 12.9k|void ArgsParser::AddString(const Key& key, const std::string& value) { 58| 12.9k| inserter_.AddArg( 59| 12.9k| storage_.InternString(base::StringView(key.flat_key)), 60| 12.9k| storage_.InternString(base::StringView(key.key)), 61| 12.9k| Variadic::String(storage_.InternString(base::StringView(value)))); 62| 12.9k|} _ZN8perfetto15trace_processor10ArgsParser9AddDoubleERKNS0_4util17ProtoToArgsParser3KeyEd: 64| 17|void ArgsParser::AddDouble(const Key& key, double value) { 65| 17| inserter_.AddArg(storage_.InternString(base::StringView(key.flat_key)), 66| 17| storage_.InternString(base::StringView(key.key)), 67| 17| Variadic::Real(value)); 68| 17|} _ZN8perfetto15trace_processor10ArgsParser10AddPointerERKNS0_4util17ProtoToArgsParser3KeyEm: 70| 4.04k|void ArgsParser::AddPointer(const Key& key, uint64_t value) { 71| 4.04k| inserter_.AddArg(storage_.InternString(base::StringView(key.flat_key)), 72| 4.04k| storage_.InternString(base::StringView(key.key)), 73| 4.04k| Variadic::Pointer(value)); 74| 4.04k|} _ZN8perfetto15trace_processor10ArgsParser10AddBooleanERKNS0_4util17ProtoToArgsParser3KeyEb: 76| 198|void ArgsParser::AddBoolean(const Key& key, bool value) { 77| 198| inserter_.AddArg(storage_.InternString(base::StringView(key.flat_key)), 78| 198| storage_.InternString(base::StringView(key.key)), 79| 198| Variadic::Boolean(value)); 80| 198|} _ZN8perfetto15trace_processor10ArgsParser7AddJsonERKNS0_4util17ProtoToArgsParser3KeyERKN9protozero10ConstCharsE: 87| 17.5k|bool ArgsParser::AddJson(const Key& key, const protozero::ConstChars& value) { 88| 17.5k| if (!support_json_) ------------------ | Branch (88:7): [True: 0, False: 17.5k] ------------------ 89| 0| PERFETTO_FATAL("Unexpected JSON value when parsing data"); 90| | 91| 17.5k| auto json_value = json::ParseJsonString(value); 92| 17.5k| if (!json_value) ------------------ | Branch (92:7): [True: 16.3k, False: 1.17k] ------------------ 93| 16.3k| return false; 94| 1.17k| return json::AddJsonValueToArgs(*json_value, base::StringView(key.flat_key), 95| 1.17k| base::StringView(key.key), &storage_, 96| 1.17k| &inserter_); 97| 17.5k|} _ZN8perfetto15trace_processor10ArgsParser7AddNullERKNS0_4util17ProtoToArgsParser3KeyE: 99| 7.36k|void ArgsParser::AddNull(const Key& key) { 100| 7.36k| inserter_.AddArg(storage_.InternString(base::StringView(key.flat_key)), 101| 7.36k| storage_.InternString(base::StringView(key.key)), 102| 7.36k| Variadic::Null()); 103| 7.36k|} _ZN8perfetto15trace_processor10ArgsParser16packet_timestampEv: 115| 5.36k|int64_t ArgsParser::packet_timestamp() { 116| 5.36k| return packet_timestamp_; 117| 5.36k|} _ZN8perfetto15trace_processor10ArgsParser22GetInternedMessageViewEjm: 124| 1.53k| uint64_t iid) { 125| 1.53k| if (!sequence_state_) ------------------ | Branch (125:7): [True: 0, False: 1.53k] ------------------ 126| 0| return nullptr; 127| 1.53k| return sequence_state_->GetInternedMessageView(field_id, iid); 128| 1.53k|} _ZN8perfetto15trace_processor18ChromeStringLookupC2EPNS0_12TraceStorageE: 178| 2.03k|ChromeStringLookup::ChromeStringLookup(TraceStorage* storage) { 179| 85.5k| for (uint32_t i = 0; i < base::ArraySize(kProcessNames); i++) { ------------------ | Branch (179:24): [True: 83.5k, False: 2.03k] ------------------ 180| 83.5k| chrome_process_name_ids_[kProcessNames[i].type] = 181| 83.5k| kProcessNames[i].name ? storage->InternString(kProcessNames[i].name) ------------------ | Branch (181:9): [True: 81.4k, False: 2.03k] ------------------ 182| 83.5k| : kNullStringId; 183| 83.5k| } 184| | 185| 93.7k| for (uint32_t i = 0; i < base::ArraySize(kThreadNames); i++) { ------------------ | Branch (185:24): [True: 91.6k, False: 2.03k] ------------------ 186| 91.6k| chrome_thread_name_ids_[kThreadNames[i].type] = 187| 91.6k| kThreadNames[i].name ? storage->InternString(kThreadNames[i].name) ------------------ | Branch (187:9): [True: 89.6k, False: 2.03k] ------------------ 188| 91.6k| : kNullStringId; 189| 91.6k| } 190| 2.03k|} _ZNK8perfetto15trace_processor18ChromeStringLookup14GetProcessNameEi: 192| 55.7k|StringId ChromeStringLookup::GetProcessName(int32_t process_type) const { 193| 55.7k| auto process_name_it = chrome_process_name_ids_.find(process_type); 194| 55.7k| if (process_name_it != chrome_process_name_ids_.end()) ------------------ | Branch (194:7): [True: 35.3k, False: 20.4k] ------------------ 195| 35.3k| return process_name_it->second; 196| | 197| 20.4k| PERFETTO_DLOG("GetProcessName error: Unknown Chrome process type %u", 198| 20.4k| process_type); 199| 20.4k| return kNullStringId; 200| 55.7k|} _ZNK8perfetto15trace_processor18ChromeStringLookup13GetThreadNameEi: 202| 126|StringId ChromeStringLookup::GetThreadName(int32_t thread_type) const { 203| 126| auto thread_name_it = chrome_thread_name_ids_.find(thread_type); 204| 126| if (thread_name_it != chrome_thread_name_ids_.end()) ------------------ | Branch (204:7): [True: 126, False: 0] ------------------ 205| 126| return thread_name_it->second; 206| | 207| 0| PERFETTO_DLOG("GetThreadName error: Unknown Chrome thread type %u", 208| 0| thread_type); 209| 0| return kNullStringId; 210| 126|} _ZN8perfetto15trace_processor24ChromeSystemProbesModuleC2EPNS0_21TraceProcessorContextE: 30| 2.03k| : parser_(context) { 31| 2.03k| RegisterForField(TracePacket::kProcessStatsFieldNumber, context); 32| 2.03k|} _ZN8perfetto15trace_processor24ChromeSystemProbesModule20ParseTracePacketDataERKNS_6protos6pbzero19TracePacket_DecoderElRKNS0_15TracePacketDataEj: 38| 6.75k| uint32_t field_id) { 39| 6.75k| switch (field_id) { ------------------ | Branch (39:11): [True: 0, False: 6.75k] ------------------ 40| 6.75k| case TracePacket::kProcessStatsFieldNumber: ------------------ | Branch (40:5): [True: 6.75k, False: 0] ------------------ 41| 6.75k| parser_.ParseProcessStats(ts, decoder.process_stats()); 42| 6.75k| return; 43| 6.75k| } 44| 6.75k|} _ZN8perfetto15trace_processor24ChromeSystemProbesParserC2EPNS0_21TraceProcessorContextE: 37| 2.03k| : context_(context), 38| | is_peak_rss_resettable_id_( 39| 2.03k| context->storage->InternString("is_peak_rss_resettable")) {} _ZN8perfetto15trace_processor24ChromeSystemProbesParser17ParseProcessStatsElN9protozero10ConstBytesE: 41| 6.75k|void ChromeSystemProbesParser::ParseProcessStats(int64_t ts, ConstBytes blob) { 42| 6.75k| protos::pbzero::ProcessStats::Decoder stats(blob); 43| 6.83k| for (auto it = stats.processes(); it; ++it) { ------------------ | Branch (43:37): [True: 84, False: 6.75k] ------------------ 44| 84| protozero::ProtoDecoder proc(*it); 45| 84| auto pid_field = 46| 84| proc.FindField(protos::pbzero::ProcessStats::Process::kPidFieldNumber); 47| 84| uint32_t pid = pid_field.as_uint32(); 48| | 49| 354| for (auto fld = proc.ReadField(); fld.valid(); fld = proc.ReadField()) { ------------------ | Branch (49:39): [True: 270, False: 84] ------------------ 50| 270| using ProcessStats = protos::pbzero::ProcessStats; 51| 270| if (fld.id() == ProcessStats::Process::kIsPeakRssResettableFieldNumber) { ------------------ | Branch (51:11): [True: 0, False: 270] ------------------ 52| 0| UniquePid upid = context_->process_tracker->GetOrCreateProcess(pid); 53| 0| context_->process_tracker->AddArgsTo(upid).AddArg( 54| 0| is_peak_rss_resettable_id_, Variadic::Boolean(fld.as_bool())); 55| 0| continue; 56| 0| } 57| 270| if (fld.id() == ------------------ | Branch (57:11): [True: 0, False: 270] ------------------ 58| 270| ProcessStats::Process::kChromePrivateFootprintKbFieldNumber) { 59| 0| UniquePid upid = context_->process_tracker->GetOrCreateProcess(pid); 60| 0| TrackId track = context_->track_tracker->InternTrack( 61| 0| tracks::kChromeProcessStatsBlueprint, 62| 0| tracks::Dimensions(upid, "private_footprint_kb")); 63| 0| int64_t value = fld.as_int64() * 1024; 64| 0| context_->event_tracker->PushCounter(ts, static_cast(value), 65| 0| track); 66| 0| continue; 67| 0| } 68| 270| if (fld.id() == ------------------ | Branch (68:11): [True: 0, False: 270] ------------------ 69| 270| ProcessStats::Process::kChromePeakResidentSetKbFieldNumber) { 70| 0| UniquePid upid = context_->process_tracker->GetOrCreateProcess(pid); 71| 0| TrackId track = context_->track_tracker->InternTrack( 72| 0| tracks::kChromeProcessStatsBlueprint, 73| 0| tracks::Dimensions(upid, "peak_resident_set_kb")); 74| 0| int64_t value = fld.as_int64() * 1024; 75| 0| context_->event_tracker->PushCounter(ts, static_cast(value), 76| 0| track); 77| 0| continue; 78| 0| } 79| 270| } 80| 84| } 81| 6.75k|} _ZN8perfetto15trace_processor22RegisterDefaultModulesEPNS0_21TraceProcessorContextE: 29| 2.03k|void RegisterDefaultModules(TraceProcessorContext* context) { 30| | // Ftrace and Etw modules are special, because they have an extra method for 31| | // parsing the ftrace/etw packets. So we need to store a pointer to it 32| | // separately. 33| 2.03k| context->modules.emplace_back(new FtraceModule()); 34| 2.03k| context->ftrace_module = 35| 2.03k| static_cast(context->modules.back().get()); 36| 2.03k| context->modules.emplace_back(new EtwModule()); 37| 2.03k| context->etw_module = static_cast(context->modules.back().get()); 38| | 39| 2.03k| context->modules.emplace_back(new TrackEventModule(context)); 40| 2.03k| context->track_module = 41| 2.03k| static_cast(context->modules.back().get()); 42| | 43| 2.03k| context->modules.emplace_back(new MemoryTrackerSnapshotModule(context)); 44| 2.03k| context->modules.emplace_back(new ChromeSystemProbesModule(context)); 45| 2.03k| context->modules.emplace_back(new MetadataMinimalModule(context)); 46| 2.03k|} _ZN8perfetto15trace_processor27MemoryTrackerSnapshotModuleC2EPNS0_21TraceProcessorContextE: 27| 2.03k| : parser_(context) { 28| 2.03k| RegisterForField(TracePacket::kMemoryTrackerSnapshotFieldNumber, context); 29| 2.03k|} _ZN8perfetto15trace_processor27MemoryTrackerSnapshotModuleD2Ev: 31| 2.03k|MemoryTrackerSnapshotModule::~MemoryTrackerSnapshotModule() = default; _ZN8perfetto15trace_processor27MemoryTrackerSnapshotModule20ParseTracePacketDataERKNS_6protos6pbzero19TracePacket_DecoderElRKNS0_15TracePacketDataEj: 37| 60.7k| uint32_t field_id) { 38| 60.7k| switch (field_id) { ------------------ | Branch (38:11): [True: 0, False: 60.7k] ------------------ 39| 60.7k| case TracePacket::kMemoryTrackerSnapshotFieldNumber: ------------------ | Branch (39:5): [True: 60.7k, False: 0] ------------------ 40| 60.7k| parser_.ParseMemoryTrackerSnapshot(ts, decoder.memory_tracker_snapshot()); 41| 60.7k| return; 42| 60.7k| } 43| 60.7k|} _ZN8perfetto15trace_processor27MemoryTrackerSnapshotModule15NotifyEndOfFileEv: 45| 345|void MemoryTrackerSnapshotModule::NotifyEndOfFile() { 46| 345| parser_.NotifyEndOfFile(); 47| 345|} _ZN8perfetto15trace_processor27MemoryTrackerSnapshotParserC2EPNS0_21TraceProcessorContextE: 51| 2.03k| : context_(context), 52| 2.03k| level_of_detail_ids_{{context_->storage->InternString("background"), 53| 2.03k| context_->storage->InternString("light"), 54| 2.03k| context_->storage->InternString("detailed")}}, 55| 2.03k| unit_ids_{{context_->storage->InternString("objects"), 56| 2.03k| context_->storage->InternString("bytes")}}, 57| 2.03k| aggregate_raw_nodes_(), 58| 2.03k| last_snapshot_timestamp_(-1), 59| 2.03k| last_snapshot_level_of_detail_(LevelOfDetail::kFirst) {} _ZN8perfetto15trace_processor27MemoryTrackerSnapshotParser26ParseMemoryTrackerSnapshotElN9protozero10ConstBytesE: 62| 60.7k| ConstBytes blob) { 63| 60.7k| PERFETTO_DCHECK(last_snapshot_timestamp_ <= ts); 64| 60.7k| if (!aggregate_raw_nodes_.empty() && ts != last_snapshot_timestamp_) { ------------------ | Branch (64:7): [True: 60.1k, False: 613] | Branch (64:40): [True: 419, False: 59.6k] ------------------ 65| 419| GenerateGraphFromRawNodesAndEmitRows(); 66| 419| } 67| 60.7k| ReadProtoSnapshot(blob, aggregate_raw_nodes_, last_snapshot_level_of_detail_); 68| 60.7k| last_snapshot_timestamp_ = ts; 69| 60.7k|} _ZN8perfetto15trace_processor27MemoryTrackerSnapshotParser15NotifyEndOfFileEv: 71| 345|void MemoryTrackerSnapshotParser::NotifyEndOfFile() { 72| 345| if (!aggregate_raw_nodes_.empty()) { ------------------ | Branch (72:7): [True: 222, False: 123] ------------------ 73| 222| GenerateGraphFromRawNodesAndEmitRows(); 74| 222| } 75| 345|} _ZN8perfetto15trace_processor27MemoryTrackerSnapshotParser17ReadProtoSnapshotEN9protozero10ConstBytesERNSt3__13mapIiNS4_10unique_ptrINS0_20RawProcessMemoryNodeENS4_14default_deleteIS7_EEEENS4_4lessIiEENS4_9allocatorINS4_4pairIKiSA_EEEEEERNS0_13LevelOfDetailE: 80| 60.7k| LevelOfDetail& level_of_detail) { 81| 60.7k| protos::pbzero::MemoryTrackerSnapshot::Decoder snapshot(blob); 82| 60.7k| level_of_detail = LevelOfDetail::kDetailed; 83| | 84| 60.7k| switch (snapshot.level_of_detail()) { ------------------ | Branch (84:11): [True: 51.7k, False: 8.99k] ------------------ 85| 8.99k| case 0: // FULL ------------------ | Branch (85:5): [True: 8.99k, False: 51.7k] ------------------ 86| 8.99k| level_of_detail = LevelOfDetail::kDetailed; 87| 8.99k| break; 88| 3| case 1: // LIGHT ------------------ | Branch (88:5): [True: 3, False: 60.7k] ------------------ 89| 3| level_of_detail = LevelOfDetail::kLight; 90| 3| break; 91| 0| case 2: // BACKGROUND ------------------ | Branch (91:5): [True: 0, False: 60.7k] ------------------ 92| 0| level_of_detail = LevelOfDetail::kBackground; 93| 0| break; 94| 60.7k| } 95| | 96| 119k| for (auto process_it = snapshot.process_memory_dumps(); process_it; ------------------ | Branch (96:59): [True: 58.5k, False: 60.7k] ------------------ 97| 60.7k| ++process_it) { 98| 58.5k| protos::pbzero::MemoryTrackerSnapshot::ProcessSnapshot::Decoder 99| 58.5k| process_memory_dump(*process_it); 100| | 101| 58.5k| auto pid = static_cast(process_memory_dump.pid()); 102| | 103| 58.5k| RawProcessMemoryNode::MemoryNodesMap nodes_map; 104| 58.5k| RawProcessMemoryNode::AllocatorNodeEdgesMap edges_map; 105| | 106| 97.0k| for (auto node_it = process_memory_dump.allocator_dumps(); node_it; ------------------ | Branch (106:64): [True: 38.5k, False: 58.5k] ------------------ 107| 58.5k| ++node_it) { 108| 38.5k| protos::pbzero::MemoryTrackerSnapshot::ProcessSnapshot::MemoryNode:: 109| 38.5k| Decoder node(*node_it); 110| | 111| 38.5k| MemoryAllocatorNodeId node_id(node.id()); 112| 38.5k| const std::string absolute_name = node.absolute_name().ToStdString(); 113| 38.5k| int flags; 114| 38.5k| if (node.weak()) { ------------------ | Branch (114:11): [True: 3.87k, False: 34.6k] ------------------ 115| 3.87k| flags = RawMemoryGraphNode::kWeak; 116| 34.6k| } else { 117| 34.6k| flags = RawMemoryGraphNode::kDefault; 118| 34.6k| } 119| | 120| 38.5k| std::vector entries; 121| | 122| 38.5k| if (node.has_size_bytes()) { ------------------ | Branch (122:11): [True: 4.20k, False: 34.3k] ------------------ 123| 4.20k| entries.emplace_back("size", RawMemoryGraphNode::kUnitsBytes, 124| 4.20k| node.size_bytes()); 125| 4.20k| } 126| | 127| 64.3k| for (auto entry_it = node.entries(); entry_it; ++entry_it) { ------------------ | Branch (127:44): [True: 25.8k, False: 38.5k] ------------------ 128| 25.8k| protos::pbzero::MemoryTrackerSnapshot::ProcessSnapshot::MemoryNode:: 129| 25.8k| MemoryNodeEntry::Decoder entry(*entry_it); 130| | 131| 25.8k| std::string unit; 132| | 133| 25.8k| switch (entry.units()) { ------------------ | Branch (133:17): [True: 25.8k, False: 0] ------------------ 134| 0| case 1: // BYTES ------------------ | Branch (134:11): [True: 0, False: 25.8k] ------------------ 135| 0| unit = RawMemoryGraphNode::kUnitsBytes; 136| 0| break; 137| 0| case 2: // COUNT ------------------ | Branch (137:11): [True: 0, False: 25.8k] ------------------ 138| 0| unit = RawMemoryGraphNode::kUnitsObjects; 139| 0| break; 140| 25.8k| } 141| 25.8k| if (entry.has_value_uint64()) { ------------------ | Branch (141:13): [True: 4.52k, False: 21.3k] ------------------ 142| 4.52k| entries.emplace_back(entry.name().ToStdString(), unit, 143| 4.52k| entry.value_uint64()); 144| 21.3k| } else if (entry.has_value_string()) { ------------------ | Branch (144:20): [True: 0, False: 21.3k] ------------------ 145| 0| entries.emplace_back(entry.name().ToStdString(), unit, 146| 0| entry.value_string().ToStdString()); 147| 21.3k| } else { 148| 21.3k| context_->storage->IncrementStats( 149| 21.3k| stats::memory_snapshot_parser_failure); 150| 21.3k| } 151| 25.8k| } 152| 38.5k| std::unique_ptr raw_graph_node(new RawMemoryGraphNode( 153| 38.5k| absolute_name, level_of_detail, node_id, std::move(entries))); 154| 38.5k| raw_graph_node->set_flags(flags); 155| 38.5k| nodes_map.insert( 156| 38.5k| std::make_pair(absolute_name, std::move(raw_graph_node))); 157| 38.5k| } 158| | 159| 112k| for (auto edge_it = process_memory_dump.memory_edges(); edge_it; ------------------ | Branch (159:61): [True: 54.3k, False: 58.5k] ------------------ 160| 58.5k| ++edge_it) { 161| 54.3k| protos::pbzero::MemoryTrackerSnapshot::ProcessSnapshot::MemoryEdge:: 162| 54.3k| Decoder edge(*edge_it); 163| | 164| 54.3k| std::unique_ptr graph_edge(new MemoryGraphEdge( 165| 54.3k| MemoryAllocatorNodeId(edge.source_id()), 166| 54.3k| MemoryAllocatorNodeId(edge.target_id()), 167| 54.3k| static_cast(edge.importance()), edge.overridable())); 168| | 169| 54.3k| edges_map.insert(std::make_pair(MemoryAllocatorNodeId(edge.source_id()), 170| 54.3k| std::move(graph_edge))); 171| 54.3k| } 172| 58.5k| std::unique_ptr raw_node(new RawProcessMemoryNode( 173| 58.5k| level_of_detail, std::move(edges_map), std::move(nodes_map))); 174| 58.5k| raw_nodes.insert(std::make_pair(pid, std::move(raw_node))); 175| 58.5k| } 176| 60.7k|} _ZN8perfetto15trace_processor27MemoryTrackerSnapshotParser13GenerateGraphERNSt3__13mapIiNS2_10unique_ptrINS0_20RawProcessMemoryNodeENS2_14default_deleteIS5_EEEENS2_4lessIiEENS2_9allocatorINS2_4pairIKiS8_EEEEEE: 179| 641| RawMemoryNodeMap& raw_nodes) { 180| 641| auto graph = GraphProcessor::CreateMemoryGraph(raw_nodes); 181| 641| GraphProcessor::CalculateSizesForGraph(graph.get()); 182| 641| return graph; 183| 641|} _ZN8perfetto15trace_processor27MemoryTrackerSnapshotParser8EmitRowsElRNS0_15GlobalNodeGraphENS0_13LevelOfDetailE: 187| 641| LevelOfDetail level_of_detail) { 188| 641| IdNodeMap id_node_map; 189| | 190| | // For now, we use the existing global instant event track for chrome events, 191| | // since memory dumps are global. 192| 641| TrackId track_id = context_->track_tracker->InternTrack( 193| 641| tracks::kLegacyGlobalInstantsBlueprint, tracks::Dimensions(), 194| 641| tracks::BlueprintName(), [this](ArgsTracker::BoundInserter& inserter) { 195| 641| inserter.AddArg( 196| 641| context_->storage->InternString("source"), 197| 641| Variadic::String(context_->storage->InternString("chrome"))); 198| 641| }); 199| | 200| 641| tables::MemorySnapshotTable::Row snapshot_row( 201| 641| ts, track_id, level_of_detail_ids_[static_cast(level_of_detail)]); 202| 641| tables::MemorySnapshotTable::Id snapshot_row_id = 203| 641| context_->storage->mutable_memory_snapshot_table() 204| 641| ->Insert(snapshot_row) 205| 641| .id; 206| | 207| 42.6k| for (auto const& it_process : graph.process_node_graphs()) { ------------------ | Branch (207:31): [True: 42.6k, False: 641] ------------------ 208| 42.6k| tables::ProcessMemorySnapshotTable::Row process_row; 209| 42.6k| process_row.upid = context_->process_tracker->GetOrCreateProcess( 210| 42.6k| static_cast(it_process.first)); 211| 42.6k| process_row.snapshot_id = snapshot_row_id; 212| 42.6k| tables::ProcessMemorySnapshotTable::Id proc_snapshot_row_id = 213| 42.6k| context_->storage->mutable_process_memory_snapshot_table() 214| 42.6k| ->Insert(process_row) 215| 42.6k| .id; 216| 42.6k| EmitMemorySnapshotNodeRows(*(it_process.second->root()), 217| 42.6k| proc_snapshot_row_id, id_node_map); 218| 42.6k| } 219| | 220| | // For each snapshot nodes from shared_memory_graph will be associated 221| | // with a fabricated process_memory_snapshot entry whose pid == 0. 222| | // TODO(mobica-google-contributors@mobica.com): Track the shared memory graph 223| | // in a separate table. 224| 641| tables::ProcessMemorySnapshotTable::Row fake_process_row; 225| 641| fake_process_row.upid = context_->process_tracker->GetOrCreateProcess(0u); 226| 641| fake_process_row.snapshot_id = snapshot_row_id; 227| 641| tables::ProcessMemorySnapshotTable::Id fake_proc_snapshot_row_id = 228| 641| context_->storage->mutable_process_memory_snapshot_table() 229| 641| ->Insert(fake_process_row) 230| 641| .id; 231| 641| EmitMemorySnapshotNodeRows(*(graph.shared_memory_graph()->root()), 232| 641| fake_proc_snapshot_row_id, id_node_map); 233| | 234| 30.5k| for (const auto& edge : graph.edges()) { ------------------ | Branch (234:25): [True: 30.5k, False: 641] ------------------ 235| 30.5k| tables::MemorySnapshotEdgeTable::Row edge_row; 236| 30.5k| auto source_it = id_node_map.find(edge.source()->id()); 237| 30.5k| if (source_it == id_node_map.end()) ------------------ | Branch (237:9): [True: 29.8k, False: 678] ------------------ 238| 29.8k| continue; 239| 678| edge_row.source_node_id = 240| 678| static_cast(source_it->second); 241| 678| auto target_it = id_node_map.find(edge.target()->id()); 242| 678| if (target_it == id_node_map.end()) ------------------ | Branch (242:9): [True: 314, False: 364] ------------------ 243| 314| continue; 244| 364| edge_row.target_node_id = 245| 364| static_cast(target_it->second); 246| 364| edge_row.importance = static_cast(edge.priority()); 247| 364| context_->storage->mutable_memory_snapshot_edge_table()->Insert(edge_row); 248| 364| } 249| 641|} _ZN8perfetto15trace_processor27MemoryTrackerSnapshotParser26EmitMemorySnapshotNodeRowsERNS0_15GlobalNodeGraph4NodeERNS0_6tables26ProcessMemorySnapshotTable2IdERNSt3__13mapINS0_21MemoryAllocatorNodeIdENS5_23MemorySnapshotNodeTable2IdENS9_4lessISB_EENS9_9allocatorINS9_4pairIKSB_SD_EEEEEE: 254| 43.2k| IdNodeMap& id_node_map) { 255| 43.2k| EmitMemorySnapshotNodeRowsRecursively(root_node_graph, std::string(), 256| 43.2k| std::nullopt, proc_snapshot_row_id, 257| 43.2k| id_node_map); 258| 43.2k|} _ZN8perfetto15trace_processor27MemoryTrackerSnapshotParser37EmitMemorySnapshotNodeRowsRecursivelyERNS0_15GlobalNodeGraph4NodeERKNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEENS5_8optionalINS0_6tables23MemorySnapshotNodeTable2IdEEERNSF_26ProcessMemorySnapshotTable2IdERNS5_3mapINS0_21MemoryAllocatorNodeIdESH_NS5_4lessISN_EENS9_INS5_4pairIKSN_SH_EEEEEE: 265| 47.0k| IdNodeMap& id_node_map) { 266| 47.0k| std::optional node_id; 267| | // Skip emitting the root node into the tables - it is not a real node. 268| 47.0k| if (!path.empty()) { ------------------ | Branch (268:7): [True: 3.77k, False: 43.2k] ------------------ 269| 3.77k| node_id = EmitNode(node, path, parent_node_row_id, proc_snapshot_row_id, 270| 3.77k| id_node_map); 271| 3.77k| } 272| | 273| 47.0k| for (const auto& name_and_child : *node.children()) { ------------------ | Branch (273:35): [True: 3.77k, False: 47.0k] ------------------ 274| 3.77k| std::string child_path = path; 275| 3.77k| if (!child_path.empty()) ------------------ | Branch (275:9): [True: 563, False: 3.21k] ------------------ 276| 563| child_path += "/"; 277| 3.77k| child_path += name_and_child.first; 278| | 279| 3.77k| EmitMemorySnapshotNodeRowsRecursively(*(name_and_child.second), child_path, 280| 3.77k| /*parent_node_row_id=*/node_id, 281| 3.77k| proc_snapshot_row_id, id_node_map); 282| 3.77k| } 283| 47.0k|} _ZN8perfetto15trace_processor27MemoryTrackerSnapshotParser8EmitNodeERKNS0_15GlobalNodeGraph4NodeERKNSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEENS6_8optionalINS0_6tables23MemorySnapshotNodeTable2IdEEERNSG_26ProcessMemorySnapshotTable2IdERNS6_3mapINS0_21MemoryAllocatorNodeIdESI_NS6_4lessISO_EENSA_INS6_4pairIKSO_SI_EEEEEE: 291| 3.77k| IdNodeMap& id_node_map) { 292| 3.77k| tables::MemorySnapshotNodeTable::Row node_row; 293| 3.77k| node_row.process_snapshot_id = proc_snapshot_row_id; 294| 3.77k| node_row.parent_node_id = parent_node_row_id; 295| 3.77k| node_row.path = context_->storage->InternString(base::StringView(path)); 296| | 297| 3.77k| tables::MemorySnapshotNodeTable::Id node_row_id = 298| 3.77k| context_->storage->mutable_memory_snapshot_node_table() 299| 3.77k| ->Insert(node_row) 300| 3.77k| .id; 301| | 302| 3.77k| auto* node_table = context_->storage->mutable_memory_snapshot_node_table(); 303| 3.77k| auto rr = *node_table->FindById(node_row_id); 304| 3.77k| ArgsTracker::BoundInserter args = 305| 3.77k| context_->args_tracker->AddArgsTo(node_row_id); 306| | 307| 4.05k| for (const auto& entry : node.const_entries()) { ------------------ | Branch (307:26): [True: 4.05k, False: 3.77k] ------------------ 308| 4.05k| switch (entry.second.type) { ------------------ | Branch (308:13): [True: 0, False: 4.05k] ------------------ 309| 4.05k| case GlobalNodeGraph::Node::Entry::Type::kUInt64: { ------------------ | Branch (309:7): [True: 4.05k, False: 0] ------------------ 310| 4.05k| int64_t value_int = static_cast(entry.second.value_uint64); 311| | 312| 4.05k| if (entry.first == "size") { ------------------ | Branch (312:13): [True: 637, False: 3.41k] ------------------ 313| 637| rr.set_size(value_int); 314| 3.41k| } else if (entry.first == "effective_size") { ------------------ | Branch (314:20): [True: 637, False: 2.78k] ------------------ 315| 637| rr.set_effective_size(value_int); 316| 2.78k| } else { 317| 2.78k| args.AddArg(context_->storage->InternString( 318| 2.78k| base::StringView(entry.first + ".value")), 319| 2.78k| Variadic::Integer(value_int)); 320| 2.78k| if (entry.second.units < unit_ids_.size()) { ------------------ | Branch (320:15): [True: 2.78k, False: 0] ------------------ 321| 2.78k| args.AddArg(context_->storage->InternString( 322| 2.78k| base::StringView(entry.first + ".unit")), 323| 2.78k| Variadic::String(unit_ids_[entry.second.units])); 324| 2.78k| } 325| 2.78k| } 326| 4.05k| break; 327| 0| } 328| 0| case GlobalNodeGraph::Node::Entry::Type::kString: { ------------------ | Branch (328:7): [True: 0, False: 4.05k] ------------------ 329| 0| args.AddArg(context_->storage->InternString( 330| 0| base::StringView(entry.first + ".value")), 331| 0| Variadic::String(context_->storage->InternString( 332| 0| base::StringView(entry.second.value_string)))); 333| 0| break; 334| 0| } 335| 4.05k| } 336| 4.05k| } 337| 3.77k| id_node_map.emplace(std::make_pair(node.id(), node_row_id)); 338| 3.77k| return node_row_id; 339| 3.77k|} _ZN8perfetto15trace_processor27MemoryTrackerSnapshotParser36GenerateGraphFromRawNodesAndEmitRowsEv: 341| 641|void MemoryTrackerSnapshotParser::GenerateGraphFromRawNodesAndEmitRows() { 342| 641| std::unique_ptr graph = GenerateGraph(aggregate_raw_nodes_); 343| 641| EmitRows(last_snapshot_timestamp_, *graph, last_snapshot_level_of_detail_); 344| 641| aggregate_raw_nodes_.clear(); 345| 641|} memory_tracker_snapshot_parser.cc:_ZZN8perfetto15trace_processor27MemoryTrackerSnapshotParser8EmitRowsElRNS0_15GlobalNodeGraphENS0_13LevelOfDetailEENK3$_0clERNS0_11ArgsTracker13BoundInserterE: 194| 244| tracks::BlueprintName(), [this](ArgsTracker::BoundInserter& inserter) { 195| 244| inserter.AddArg( 196| 244| context_->storage->InternString("source"), 197| 244| Variadic::String(context_->storage->InternString("chrome"))); 198| 244| }); _ZN8perfetto15trace_processor21MetadataMinimalModuleC2EPNS0_21TraceProcessorContextE: 34| 2.03k| : context_(context) { 35| 2.03k| RegisterForField(TracePacket::kChromeMetadataFieldNumber, context); 36| 2.03k| RegisterForField(TracePacket::kChromeBenchmarkMetadataFieldNumber, context); 37| 2.03k|} _ZN8perfetto15trace_processor21MetadataMinimalModule14TokenizePacketERKNS_6protos6pbzero19TracePacket_DecoderEPNS0_13TraceBlobViewElNS0_6RefPtrINS0_29PacketSequenceStateGenerationEEEj: 44| 1.30k| uint32_t field_id) { 45| 1.30k| switch (field_id) { ------------------ | Branch (45:11): [True: 0, False: 1.30k] ------------------ 46| 7| case TracePacket::kChromeMetadataFieldNumber: { ------------------ | Branch (46:5): [True: 7, False: 1.29k] ------------------ 47| 7| ParseChromeMetadataPacket(decoder.chrome_metadata()); 48| 7| return ModuleResult::Handled(); 49| 0| } 50| 1.29k| case TracePacket::kChromeBenchmarkMetadataFieldNumber: { ------------------ | Branch (50:5): [True: 1.29k, False: 7] ------------------ 51| 1.29k| ParseChromeBenchmarkMetadata(decoder.chrome_benchmark_metadata()); 52| 1.29k| return ModuleResult::Handled(); 53| 0| } 54| 1.30k| } 55| 0| return ModuleResult::Ignored(); 56| 1.30k|} _ZN8perfetto15trace_processor21MetadataMinimalModule28ParseChromeBenchmarkMetadataEN9protozero10ConstBytesE: 58| 1.29k|void MetadataMinimalModule::ParseChromeBenchmarkMetadata(ConstBytes blob) { 59| 1.29k| TraceStorage* storage = context_->storage.get(); 60| 1.29k| MetadataTracker* metadata = context_->metadata_tracker.get(); 61| | 62| 1.29k| protos::pbzero::ChromeBenchmarkMetadata::Decoder packet(blob.data, blob.size); 63| 1.29k| if (packet.has_benchmark_name()) { ------------------ | Branch (63:7): [True: 66, False: 1.23k] ------------------ 64| 66| auto benchmark_name_id = storage->InternString(packet.benchmark_name()); 65| 66| metadata->SetMetadata(metadata::benchmark_name, 66| 66| Variadic::String(benchmark_name_id)); 67| 66| } 68| 1.29k| if (packet.has_benchmark_description()) { ------------------ | Branch (68:7): [True: 640, False: 656] ------------------ 69| 640| auto benchmark_description_id = 70| 640| storage->InternString(packet.benchmark_description()); 71| 640| metadata->SetMetadata(metadata::benchmark_description, 72| 640| Variadic::String(benchmark_description_id)); 73| 640| } 74| 1.29k| if (packet.has_label()) { ------------------ | Branch (74:7): [True: 0, False: 1.29k] ------------------ 75| 0| auto label_id = storage->InternString(packet.label()); 76| 0| metadata->SetMetadata(metadata::benchmark_label, 77| 0| Variadic::String(label_id)); 78| 0| } 79| 1.29k| if (packet.has_story_name()) { ------------------ | Branch (79:7): [True: 64, False: 1.23k] ------------------ 80| 64| auto story_name_id = storage->InternString(packet.story_name()); 81| 64| metadata->SetMetadata(metadata::benchmark_story_name, 82| 64| Variadic::String(story_name_id)); 83| 64| } 84| 10.9k| for (auto it = packet.story_tags(); it; ++it) { ------------------ | Branch (84:39): [True: 9.62k, False: 1.29k] ------------------ 85| 9.62k| auto story_tag_id = storage->InternString(*it); 86| 9.62k| metadata->AppendMetadata(metadata::benchmark_story_tags, 87| 9.62k| Variadic::String(story_tag_id)); 88| 9.62k| } 89| 1.29k| if (packet.has_benchmark_start_time_us()) { ------------------ | Branch (89:7): [True: 136, False: 1.16k] ------------------ 90| 136| metadata->SetMetadata(metadata::benchmark_start_time_us, 91| 136| Variadic::Integer(packet.benchmark_start_time_us())); 92| 136| } 93| 1.29k| if (packet.has_story_run_time_us()) { ------------------ | Branch (93:7): [True: 441, False: 855] ------------------ 94| 441| metadata->SetMetadata(metadata::benchmark_story_run_time_us, 95| 441| Variadic::Integer(packet.story_run_time_us())); 96| 441| } 97| 1.29k| if (packet.has_story_run_index()) { ------------------ | Branch (97:7): [True: 375, False: 921] ------------------ 98| 375| metadata->SetMetadata(metadata::benchmark_story_run_index, 99| 375| Variadic::Integer(packet.story_run_index())); 100| 375| } 101| 1.29k| if (packet.has_had_failures()) { ------------------ | Branch (101:7): [True: 0, False: 1.29k] ------------------ 102| 0| metadata->SetMetadata(metadata::benchmark_had_failures, 103| 0| Variadic::Integer(packet.had_failures())); 104| 0| } 105| 1.29k|} _ZN8perfetto15trace_processor21MetadataMinimalModule25ParseChromeMetadataPacketEN9protozero10ConstBytesE: 107| 7|void MetadataMinimalModule::ParseChromeMetadataPacket(ConstBytes blob) { 108| 7| TraceStorage* storage = context_->storage.get(); 109| 7| MetadataTracker* metadata = context_->metadata_tracker.get(); 110| | 111| | // TODO(b/322298334): There is no easy way to associate ChromeMetadataPacket 112| | // with ChromeMetadata for the same instance, so we have opted for letters to 113| | // differentiate Chrome instances for ChromeMetadataPacket. When a unifying 114| | // Chrome instance ID is in place, update this code to use the same counter 115| | // as ChromeMetadata values. 116| 7| base::StackString<6> metadata_prefix( 117| 7| "cr-%c-", static_cast('a' + (chrome_metadata_count_ % 26))); 118| 7| chrome_metadata_count_++; 119| | 120| | // Typed chrome metadata proto. The untyped metadata is parsed below in 121| | // ParseChromeEvents(). 122| 7| protos::pbzero::ChromeMetadataPacket::Decoder packet_decoder(blob.data, 123| 7| blob.size); 124| | 125| 7| if (packet_decoder.has_chrome_version_code()) { ------------------ | Branch (125:7): [True: 7, False: 0] ------------------ 126| 7| metadata->SetDynamicMetadata( 127| 7| storage->InternString(base::StringView(metadata_prefix.ToStdString() + 128| 7| "playstore_version_code")), 129| 7| Variadic::Integer(packet_decoder.chrome_version_code())); 130| 7| } 131| 7| if (packet_decoder.has_enabled_categories()) { ------------------ | Branch (131:7): [True: 0, False: 7] ------------------ 132| 0| auto categories_id = 133| 0| storage->InternString(packet_decoder.enabled_categories()); 134| 0| metadata->SetDynamicMetadata( 135| 0| storage->InternString(base::StringView(metadata_prefix.ToStdString() + 136| 0| "enabled_categories")), 137| 0| Variadic::String(categories_id)); 138| 0| } 139| | 140| 7| if (packet_decoder.has_field_trial_hashes()) { ------------------ | Branch (140:7): [True: 7, False: 0] ------------------ 141| 7| std::string field_trials; 142| | 143| | // Add a line break after every 2 field trial hashes to better utilize the 144| | // UI space. 145| 7| int line_size = 0; 146| 31| for (auto it = packet_decoder.field_trial_hashes(); it; ++it) { ------------------ | Branch (146:57): [True: 24, False: 7] ------------------ 147| 24| if (line_size == 2) { ------------------ | Branch (147:11): [True: 5, False: 19] ------------------ 148| 5| field_trials.append("\n"); 149| 5| line_size = 1; 150| 19| } else { 151| 19| line_size++; 152| 19| } 153| | 154| 24| perfetto::protos::pbzero::ChromeMetadataPacket::FinchHash::Decoder 155| 24| field_trial(*it); 156| | 157| 24| base::StackString<45> field_trial_string( 158| 24| "{ name: %u, group: %u } ", field_trial.name(), field_trial.group()); 159| | 160| 24| field_trials.append(field_trial_string.ToStdString()); 161| 24| } 162| | 163| 7| StringId field_trials_string = 164| 7| context_->storage->InternString(base::StringView(field_trials)); 165| 7| metadata->SetDynamicMetadata( 166| 7| storage->InternString(base::StringView(metadata_prefix.ToStdString() + 167| 7| "field_trial_hashes")), 168| 7| Variadic::String(field_trials_string)); 169| 7| } 170| | 171| 7| if (packet_decoder.has_background_tracing_metadata()) { ------------------ | Branch (171:7): [True: 7, False: 0] ------------------ 172| 7| auto background_tracing_metadata = 173| 7| packet_decoder.background_tracing_metadata(); 174| | 175| 7| std::string base64 = base::Base64Encode(background_tracing_metadata.data, 176| 7| background_tracing_metadata.size); 177| 7| metadata->SetDynamicMetadata( 178| 7| storage->InternString("cr-background_tracing_metadata"), 179| 7| Variadic::String(storage->InternString(base::StringView(base64)))); 180| | 181| 7| protos::pbzero::BackgroundTracingMetadata::Decoder metadata_decoder( 182| 7| background_tracing_metadata.data, background_tracing_metadata.size); 183| 7| if (metadata_decoder.has_scenario_name_hash()) { ------------------ | Branch (183:9): [True: 0, False: 7] ------------------ 184| 0| metadata->SetDynamicMetadata( 185| 0| storage->InternString("cr-scenario_name_hash"), 186| 0| Variadic::Integer(metadata_decoder.scenario_name_hash())); 187| 0| } 188| 7| auto triggered_rule = metadata_decoder.triggered_rule(); 189| 7| if (!metadata_decoder.has_triggered_rule()) ------------------ | Branch (189:9): [True: 5, False: 2] ------------------ 190| 5| return; 191| 2| protos::pbzero::BackgroundTracingMetadata::TriggerRule::Decoder 192| 2| triggered_rule_decoder(triggered_rule.data, triggered_rule.size); 193| 2| } 194| 7|} _ZN8perfetto15trace_processor24MultiMachineTraceManagerC2EPNS0_21TraceProcessorContextE: 34| 434| : default_context_(default_context) { 35| 434| PERFETTO_DCHECK(default_context && !default_context_->machine_id()); 36| 434|} _ZN8perfetto15trace_processor24MultiMachineTraceManagerD2Ev: 37| 434|MultiMachineTraceManager::~MultiMachineTraceManager() = default; _ZN8perfetto15trace_processor24MultiMachineTraceManager13CreateContextEj: 40| 1.60k| RawMachineId raw_machine_id) { 41| 1.60k| TraceProcessorContext::InitArgs args{ 42| 1.60k| default_context_->config, default_context_->storage, raw_machine_id}; 43| 1.60k| auto new_context = std::make_unique(args); 44| | 45| | // Register default and additional modules (if enabled). 46| 1.60k| RegisterDefaultModules(new_context.get()); 47| | // Register addtional modules through the registered function pointer. 48| 1.60k| if (additional_modules_factory_) ------------------ | Branch (48:7): [True: 0, False: 1.60k] ------------------ 49| 0| additional_modules_factory_(new_context.get()); 50| | 51| | // Set up shared member fields: 52| | // arg_set_id is a monotonically increasing ID. 53| | // Share |global_args_tracker| between contexts. 54| 1.60k| new_context->global_args_tracker = default_context_->global_args_tracker; 55| | // Share the sorter, but enable for the parser. 56| 1.60k| new_context->sorter = default_context_->sorter; 57| 1.60k| new_context->sorter->AddMachineContext(new_context.get()); 58| 1.60k| new_context->process_tracker->SetPidZeroIsUpidZeroIdleProcess(); 59| 1.60k| new_context->proto_trace_parser.reset( 60| 1.60k| new ProtoTraceParserImpl(new_context.get())); 61| | 62| 1.60k| return new_context; 63| 1.60k|} _ZN8perfetto15trace_processor24MultiMachineTraceManager17GetOrCreateReaderEj: 71| 1.60k| RawMachineId raw_machine_id) { 72| 1.60k| auto* remote_ctx = remote_machine_contexts_.Find(raw_machine_id); 73| 1.60k| if (remote_ctx) ------------------ | Branch (73:7): [True: 0, False: 1.60k] ------------------ 74| 0| return remote_ctx->reader.get(); 75| | 76| 1.60k| auto new_context = CreateContext(raw_machine_id); 77| | 78| 1.60k| auto new_reader = std::make_unique(new_context.get()); 79| 1.60k| remote_machine_contexts_[raw_machine_id] = 80| 1.60k| RemoteMachineContext{std::move(new_context), std::move(new_reader)}; 81| 1.60k| return remote_machine_contexts_[raw_machine_id].reader.get(); 82| 1.60k|} _ZN8perfetto15trace_processor26PacketSequenceStateBuilderC2EPNS0_21TraceProcessorContextE: 36| 56.9k| explicit PacketSequenceStateBuilder(TraceProcessorContext* context) { 37| 56.9k| generation_ = PacketSequenceStateGeneration::CreateFirst(context); 38| 56.9k| } _ZN8perfetto15trace_processor26PacketSequenceStateBuilder13InternMessageEjNS0_13TraceBlobViewE: 41| 123k| void InternMessage(uint32_t field_id, TraceBlobView message) { 42| 123k| generation_->InternMessage(field_id, std::move(message)); 43| 123k| } _ZN8perfetto15trace_processor26PacketSequenceStateBuilder25UpdateTracePacketDefaultsENS0_13TraceBlobViewE: 48| 814| void UpdateTracePacketDefaults(TraceBlobView defaults) { 49| 814| generation_ = generation_->OnNewTracePacketDefaults(std::move(defaults)); 50| 814| } _ZN8perfetto15trace_processor26PacketSequenceStateBuilder12OnPacketLossEv: 52| 47| void OnPacketLoss() { 53| 47| generation_ = generation_->OnPacketLoss(); 54| 47| packet_loss_ = true; 55| 47| } _ZN8perfetto15trace_processor26PacketSequenceStateBuilder25OnIncrementalStateClearedEv: 58| 10.1k| void OnIncrementalStateCleared() { 59| 10.1k| packet_loss_ = false; 60| 10.1k| generation_ = generation_->OnIncrementalStateCleared(); 61| 10.1k| } _ZNK8perfetto15trace_processor26PacketSequenceStateBuilder23IsIncrementalStateValidEv: 63| 31.7k| bool IsIncrementalStateValid() const { return !packet_loss_; } _ZNK8perfetto15trace_processor26PacketSequenceStateBuilder18current_generationEv: 66| 8.05M| RefPtr current_generation() const { 67| 8.05M| return generation_; 68| 8.05M| } _ZN8perfetto15trace_processor29PacketSequenceStateGeneration11CreateFirstEPNS0_21TraceProcessorContextE: 31| 56.9k|PacketSequenceStateGeneration::CreateFirst(TraceProcessorContext* context) { 32| 56.9k| return RefPtr( 33| 56.9k| new PacketSequenceStateGeneration( 34| 56.9k| context, TrackEventSequenceState::CreateFirst(), false)); 35| 56.9k|} _ZN8perfetto15trace_processor29PacketSequenceStateGenerationC2EPNS0_21TraceProcessorContextENSt3__113unordered_mapIjNS5_ImNS0_19InternedMessageViewENS4_4hashImEENS4_8equal_toImEENS4_9allocatorINS4_4pairIKmS6_EEEEEENS7_IjEENS9_IjEENSB_INSC_IKjSG_EEEEEENS0_23TrackEventSequenceStateENS4_5arrayINS0_6RefPtrINS1_11CustomStateEEELm4EEENS0_13TraceBlobViewEb: 44| 814| : context_(context), 45| 814| interned_data_(std::move(interned_data)), 46| 814| track_event_sequence_state_(std::move(track_event_sequence_state)), 47| 814| custom_state_(std::move(custom_state)), 48| 814| trace_packet_defaults_(std::move(trace_packet_defaults)), 49| 814| is_incremental_state_valid_(is_incremental_state_valid) { 50| 3.25k| for (auto& s : custom_state_) { ------------------ | Branch (50:16): [True: 3.25k, False: 814] ------------------ 51| 3.25k| if (s.get() != nullptr) { ------------------ | Branch (51:9): [True: 0, False: 3.25k] ------------------ 52| 0| s->set_generation(this); 53| 0| } 54| 3.25k| } 55| 814|} _ZN8perfetto15trace_processor29PacketSequenceStateGeneration12OnPacketLossEv: 58| 47|PacketSequenceStateGeneration::OnPacketLoss() { 59| | // No need to increment the generation. If any future packet depends on 60| | // previous messages to update the incremental state its packet (if the 61| | // DataSource is behaving correctly) would have the 62| | // SEQ_NEEDS_INCREMENTAL_STATE bit set and such a packet will be dropped by 63| | // the ProtoTraceReader and never make it far enough to update any incremental 64| | // state. 65| 47| track_event_sequence_state_.OnPacketLoss(); 66| 47| is_incremental_state_valid_ = false; 67| 47| return RefPtr(this); 68| 47|} _ZN8perfetto15trace_processor29PacketSequenceStateGeneration25OnIncrementalStateClearedEv: 71| 10.1k|PacketSequenceStateGeneration::OnIncrementalStateCleared() { 72| 10.1k| return RefPtr( 73| 10.1k| new PacketSequenceStateGeneration( 74| 10.1k| context_, track_event_sequence_state_.OnIncrementalStateCleared(), 75| 10.1k| true)); 76| 10.1k|} _ZN8perfetto15trace_processor29PacketSequenceStateGeneration24OnNewTracePacketDefaultsENS0_13TraceBlobViewE: 80| 814| TraceBlobView trace_packet_defaults) { 81| 814| return RefPtr( 82| 814| new PacketSequenceStateGeneration( 83| 814| context_, interned_data_, 84| 814| track_event_sequence_state_.OnIncrementalStateCleared(), 85| 814| custom_state_, std::move(trace_packet_defaults), 86| 814| is_incremental_state_valid_)); 87| 814|} _ZN8perfetto15trace_processor29PacketSequenceStateGeneration22GetInternedMessageViewEjm: 91| 79.0k| uint64_t iid) { 92| 79.0k| auto field_it = interned_data_.find(field_id); 93| 79.0k| if (field_it != interned_data_.end()) { ------------------ | Branch (93:7): [True: 7.37k, False: 71.6k] ------------------ 94| 7.37k| auto* message_map = &field_it->second; 95| 7.37k| auto it = message_map->find(iid); 96| 7.37k| if (it != message_map->end()) { ------------------ | Branch (96:9): [True: 4.03k, False: 3.33k] ------------------ 97| 4.03k| return &it->second; 98| 4.03k| } 99| 7.37k| } 100| | 101| 74.9k| context_->storage->IncrementStats(stats::interned_data_tokenizer_errors); 102| 74.9k| return nullptr; 103| 79.0k|} _ZN8perfetto15trace_processor29PacketSequenceStateGeneration13InternMessageEjNS0_13TraceBlobViewE: 106| 123k| TraceBlobView message) { 107| 123k| constexpr auto kIidFieldNumber = 1; 108| | 109| 123k| uint64_t iid = 0; 110| 123k| auto message_start = message.data(); 111| 123k| auto message_size = message.length(); 112| 123k| protozero::ProtoDecoder decoder(message_start, message_size); 113| | 114| 123k| auto field = decoder.FindField(kIidFieldNumber); 115| 123k| if (PERFETTO_UNLIKELY(!field)) { ------------------ | | 24| 123k|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 99.5k, False: 23.8k] | | ------------------ ------------------ 116| 99.5k| PERFETTO_DLOG("Interned message without interning_id"); 117| 99.5k| context_->storage->IncrementStats(stats::interned_data_tokenizer_errors); 118| 99.5k| return; 119| 99.5k| } 120| 23.8k| iid = field.as_uint64(); 121| | 122| 23.8k| auto res = interned_data_[field_id].emplace( 123| 23.8k| iid, InternedMessageView(std::move(message))); 124| | 125| | // If a message with this ID is already interned in the same generation, 126| | // its data should not have changed (this is forbidden by the InternedData 127| | // proto). 128| | // TODO(eseckler): This DCHECK assumes that the message is encoded the 129| | // same way if it is re-emitted. 130| 23.8k| PERFETTO_DCHECK(res.second || 131| 23.8k| (res.first->second.message().length() == message_size && 132| 23.8k| memcmp(res.first->second.message().data(), message_start, 133| 23.8k| message_size) == 0)); 134| 23.8k|} _ZNK8perfetto15trace_processor29PacketSequenceStateGeneration17pid_and_tid_validEv: 130| 839k| bool pid_and_tid_valid() const { 131| 839k| return track_event_sequence_state_.pid_and_tid_valid(); 132| 839k| } _ZNK8perfetto15trace_processor29PacketSequenceStateGeneration3pidEv: 133| 105k| int32_t pid() const { return track_event_sequence_state_.pid(); } _ZNK8perfetto15trace_processor29PacketSequenceStateGeneration3tidEv: 134| 105k| int32_t tid() const { return track_event_sequence_state_.tid(); } _ZN8perfetto15trace_processor29PacketSequenceStateGeneration26GetTracePacketDefaultsViewEv: 149| 1.87M| InternedMessageView* GetTracePacketDefaultsView() { 150| 1.87M| if (!trace_packet_defaults_.has_value()) { ------------------ | Branch (150:9): [True: 1.78M, False: 94.3k] ------------------ 151| 1.78M| return nullptr; 152| 1.78M| } 153| | 154| 94.3k| return &*trace_packet_defaults_; 155| 1.87M| } _ZN8perfetto15trace_processor29PacketSequenceStateGeneration22GetTracePacketDefaultsEv: 158| 3.92M| protos::pbzero::TracePacketDefaults::Decoder* GetTracePacketDefaults() { 159| 3.92M| if (!trace_packet_defaults_.has_value()) { ------------------ | Branch (159:9): [True: 3.84M, False: 74.7k] ------------------ 160| 3.84M| return nullptr; 161| 3.84M| } 162| 74.7k| return trace_packet_defaults_ 163| 74.7k| ->GetOrCreateDecoder(); 164| 3.92M| } _ZN8perfetto15trace_processor29PacketSequenceStateGeneration21GetTrackEventDefaultsEv: 167| 1.87M| protos::pbzero::TrackEventDefaults::Decoder* GetTrackEventDefaults() { 168| 1.87M| auto* packet_defaults_view = GetTracePacketDefaultsView(); 169| 1.87M| if (packet_defaults_view) { ------------------ | Branch (169:9): [True: 94.3k, False: 1.78M] ------------------ 170| 94.3k| auto* track_event_defaults_view = 171| 94.3k| packet_defaults_view 172| 94.3k| ->GetOrCreateSubmessageView(); 175| 94.3k| if (track_event_defaults_view) { ------------------ | Branch (175:11): [True: 94.3k, False: 0] ------------------ 176| 94.3k| return track_event_defaults_view 177| 94.3k| ->GetOrCreateDecoder(); 178| 94.3k| } 179| 94.3k| } 180| 1.78M| return nullptr; 181| 1.87M| } _ZN8perfetto15trace_processor29PacketSequenceStateGeneration31IncrementAndGetTrackEventTimeNsEl: 201| 22| int64_t IncrementAndGetTrackEventTimeNs(int64_t delta_ns) { 202| 22| return track_event_sequence_state_.IncrementAndGetTrackEventTimeNs( 203| 22| delta_ns); 204| 22| } _ZN8perfetto15trace_processor29PacketSequenceStateGeneration37IncrementAndGetTrackEventThreadTimeNsEl: 206| 24| int64_t IncrementAndGetTrackEventThreadTimeNs(int64_t delta_ns) { 207| 24| return track_event_sequence_state_.IncrementAndGetTrackEventThreadTimeNs( 208| 24| delta_ns); 209| 24| } _ZN8perfetto15trace_processor29PacketSequenceStateGeneration47IncrementAndGetTrackEventThreadInstructionCountEl: 211| 24| int64_t IncrementAndGetTrackEventThreadInstructionCount(int64_t delta) { 212| 24| return track_event_sequence_state_ 213| 24| .IncrementAndGetTrackEventThreadInstructionCount(delta); 214| 24| } _ZNK8perfetto15trace_processor29PacketSequenceStateGeneration28track_event_timestamps_validEv: 216| 23.6k| bool track_event_timestamps_valid() const { 217| 23.6k| return track_event_sequence_state_.timestamps_valid(); 218| 23.6k| } _ZN8perfetto15trace_processor29PacketSequenceStateGeneration19SetThreadDescriptorERKNS_6protos6pbzero24ThreadDescriptor_DecoderE: 221| 2.06k| const protos::pbzero::ThreadDescriptor::Decoder& descriptor) { 222| 2.06k| track_event_sequence_state_.SetThreadDescriptor(descriptor); 223| 2.06k| } _ZNK8perfetto15trace_processor29PacketSequenceStateGeneration23IsIncrementalStateValidEv: 227| 8.51k| bool IsIncrementalStateValid() const { return is_incremental_state_valid_; } _ZN8perfetto15trace_processor29PacketSequenceStateGenerationC2EPNS0_21TraceProcessorContextENS0_23TrackEventSequenceStateEb: 260| 67.1k| : context_(context), 261| 67.1k| track_event_sequence_state_(std::move(track_state)), 262| 67.1k| is_incremental_state_valid_(is_incremental_state_valid) {} _ZN8perfetto15trace_processor29PacketSequenceStateGeneration21LookupInternedMessageILj1ENS_6protos6pbzero13EventCategoryEEEPNT0_7DecoderEm: 139| 20.7k| typename MessageType::Decoder* LookupInternedMessage(uint64_t iid) { 140| 20.7k| auto* interned_message_view = GetInternedMessageView(FieldId, iid); 141| 20.7k| if (!interned_message_view) ------------------ | Branch (141:9): [True: 16.7k, False: 4.03k] ------------------ 142| 16.7k| return nullptr; 143| | 144| 4.03k| return interned_message_view->template GetOrCreateDecoder(); 145| 20.7k| } _ZN8perfetto15trace_processor29PacketSequenceStateGeneration21LookupInternedMessageILj2ENS_6protos6pbzero9EventNameEEEPNT0_7DecoderEm: 139| 13.4k| typename MessageType::Decoder* LookupInternedMessage(uint64_t iid) { 140| 13.4k| auto* interned_message_view = GetInternedMessageView(FieldId, iid); 141| 13.4k| if (!interned_message_view) ------------------ | Branch (141:9): [True: 13.4k, False: 0] ------------------ 142| 13.4k| return nullptr; 143| | 144| 0| return interned_message_view->template GetOrCreateDecoder(); 145| 13.4k| } _ZN8perfetto15trace_processor29PacketSequenceStateGeneration21LookupInternedMessageILj4ENS_6protos6pbzero14SourceLocationEEEPNT0_7DecoderEm: 139| 146| typename MessageType::Decoder* LookupInternedMessage(uint64_t iid) { 140| 146| auto* interned_message_view = GetInternedMessageView(FieldId, iid); 141| 146| if (!interned_message_view) ------------------ | Branch (141:9): [True: 146, False: 0] ------------------ 142| 146| return nullptr; 143| | 144| 0| return interned_message_view->template GetOrCreateDecoder(); 145| 146| } _ZN8perfetto15trace_processor29PacketSequenceStateGeneration21LookupInternedMessageILj25ENS_6protos6pbzero13HistogramNameEEEPNT0_7DecoderEm: 139| 43.1k| typename MessageType::Decoder* LookupInternedMessage(uint64_t iid) { 140| 43.1k| auto* interned_message_view = GetInternedMessageView(FieldId, iid); 141| 43.1k| if (!interned_message_view) ------------------ | Branch (141:9): [True: 43.1k, False: 0] ------------------ 142| 43.1k| return nullptr; 143| | 144| 0| return interned_message_view->template GetOrCreateDecoder(); 145| 43.1k| } _ZN8perfetto15trace_processor17PerfSampleTrackerC2EPNS0_21TraceProcessorContextE: 156| 2.03k| : is_timebase_id_(context->storage->InternString("is_timebase")), 157| 2.03k| context_(context) {} _ZN8perfetto15trace_processor19ProtoImporterModuleC2Ev: 26| 12.2k|ProtoImporterModule::ProtoImporterModule() {} _ZN8perfetto15trace_processor19ProtoImporterModuleD2Ev: 28| 12.2k|ProtoImporterModule::~ProtoImporterModule() {} _ZN8perfetto15trace_processor19ProtoImporterModule14TokenizePacketERKNS_6protos6pbzero19TracePacket_DecoderEPNS0_13TraceBlobViewElNS0_6RefPtrINS0_29PacketSequenceStateGenerationEEEj: 35| 74.6k| uint32_t /*field_id*/) { 36| 74.6k| return ModuleResult::Ignored(); 37| 74.6k|} _ZN8perfetto15trace_processor19ProtoImporterModule16ParseTraceConfigERKNS_6protos6pbzero19TraceConfig_DecoderE: 46| 6.55k| const protos::pbzero::TraceConfig_Decoder&) {} _ZN8perfetto15trace_processor19ProtoImporterModule16RegisterForFieldEjPNS0_21TraceProcessorContextE: 49| 18.3k| TraceProcessorContext* context) { 50| 18.3k| if (context->modules_by_field.size() <= field_id) { ------------------ | Branch (50:7): [True: 2.03k, False: 16.2k] ------------------ 51| 2.03k| context->modules_by_field.resize(field_id + 1); 52| 2.03k| } 53| 18.3k| context->modules_by_field[field_id].push_back(this); 54| 18.3k|} _ZN8perfetto15trace_processor12ModuleResult7IgnoredEv: 65| 211k| static ModuleResult Ignored() { return ModuleResult(true); } _ZN8perfetto15trace_processor12ModuleResult7HandledEv: 69| 1.16M| static ModuleResult Handled() { return ModuleResult(false); } _ZNK8perfetto15trace_processor12ModuleResult7ignoredEv: 77| 1.37M| bool ignored() const { return ignored_; } _ZNK8perfetto15trace_processor12ModuleResult8ToStatusEv: 81| 1.16M| base::Status ToStatus() const { 82| 1.16M| PERFETTO_DCHECK(!ignored_); 83| 1.16M| if (error_) ------------------ | Branch (83:9): [True: 0, False: 1.16M] ------------------ 84| 0| return base::Status(*error_); 85| 1.16M| return base::OkStatus(); 86| 1.16M| } _ZN8perfetto15trace_processor12ModuleResultC2Eb: 89| 1.37M| explicit ModuleResult(bool ignored) : ignored_(ignored) {} _ZN8perfetto15trace_processor19ProtoImporterModule25OnIncrementalStateClearedEj: 121| 50.8k| virtual void OnIncrementalStateCleared(uint32_t /* packet_sequence_id */) {} _ZN8perfetto15trace_processor19ProtoImporterModule23OnFirstPacketOnSequenceEj: 127| 5| virtual void OnFirstPacketOnSequence(uint32_t /* packet_sequence_id */) {} _ZN8perfetto15trace_processor19ProtoImporterModule15NotifyEndOfFileEv: 141| 1.38k| virtual void NotifyEndOfFile() {} _ZN8perfetto15trace_processor20ProtoTraceParserImplC2EPNS0_21TraceProcessorContextE: 60| 2.03k| : context_(context), 61| 2.03k| metatrace_id_(context->storage->InternString("metatrace")), 62| 2.03k| data_name_id_(context->storage->InternString("data")), 63| | raw_chrome_metadata_event_id_( 64| 2.03k| context->storage->InternString("chrome_event.metadata")), 65| | raw_chrome_legacy_system_trace_event_id_( 66| 2.03k| context->storage->InternString("chrome_event.legacy_system_trace")), 67| | raw_chrome_legacy_user_trace_event_id_( 68| 2.03k| context->storage->InternString("chrome_event.legacy_user_trace")), 69| | missing_metatrace_interned_string_id_( 70| 2.03k| context->storage->InternString("MISSING STRING")) {} _ZN8perfetto15trace_processor20ProtoTraceParserImplD2Ev: 72| 2.03k|ProtoTraceParserImpl::~ProtoTraceParserImpl() = default; _ZN8perfetto15trace_processor20ProtoTraceParserImpl16ParseTracePacketElNS0_15TracePacketDataE: 74| 1.37M|void ProtoTraceParserImpl::ParseTracePacket(int64_t ts, TracePacketData data) { 75| 1.37M| const TraceBlobView& blob = data.packet; 76| 1.37M| protos::pbzero::TracePacket::Decoder packet(blob.data(), blob.length()); 77| | // TODO(eseckler): Propagate statuses from modules. 78| 1.37M| auto& modules = context_->modules_by_field; 79| 119M| for (uint32_t field_id = 1; field_id < modules.size(); ++field_id) { ------------------ | Branch (79:31): [True: 118M, False: 1.18M] ------------------ 80| 118M| if (!modules[field_id].empty() && packet.Get(field_id).valid()) { ------------------ | Branch (80:9): [True: 11.9M, False: 106M] | Branch (80:39): [True: 195k, False: 11.7M] ------------------ 81| 195k| for (ProtoImporterModule* global_module : ------------------ | Branch (81:47): [True: 0, False: 195k] ------------------ 82| 195k| context_->modules_for_all_fields) { 83| 0| global_module->ParseTracePacketData(packet, ts, data, field_id); 84| 0| } 85| 195k| for (ProtoImporterModule* module : modules[field_id]) ------------------ | Branch (85:40): [True: 195k, False: 195k] ------------------ 86| 195k| module->ParseTracePacketData(packet, ts, data, field_id); 87| 195k| return; 88| 195k| } 89| 118M| } 90| | 91| 1.18M| if (packet.has_chrome_events()) { ------------------ | Branch (91:7): [True: 110k, False: 1.07M] ------------------ 92| 110k| ParseChromeEvents(ts, packet.chrome_events()); 93| 110k| } 94| | 95| 1.18M| if (packet.has_perfetto_metatrace()) { ------------------ | Branch (95:7): [True: 287k, False: 896k] ------------------ 96| 287k| ParseMetatraceEvent(ts, packet.perfetto_metatrace()); 97| 287k| } 98| | 99| 1.18M| if (packet.has_trace_config()) { ------------------ | Branch (99:7): [True: 1.09k, False: 1.18M] ------------------ 100| | // TODO(eseckler): Propagate statuses from modules. 101| 1.09k| protos::pbzero::TraceConfig::Decoder config(packet.trace_config()); 102| 6.55k| for (auto& module : context_->modules) { ------------------ | Branch (102:23): [True: 6.55k, False: 1.09k] ------------------ 103| 6.55k| module->ParseTraceConfig(config); 104| 6.55k| } 105| 1.09k| } 106| 1.18M|} _ZN8perfetto15trace_processor20ProtoTraceParserImpl15ParseTrackEventElNS0_14TrackEventDataE: 108| 877k|void ProtoTraceParserImpl::ParseTrackEvent(int64_t ts, TrackEventData data) { 109| 877k| const TraceBlobView& blob = data.trace_packet_data.packet; 110| 877k| protos::pbzero::TracePacket::Decoder packet(blob.data(), blob.length()); 111| 877k| context_->track_module->ParseTrackEventData(packet, ts, data); 112| 877k| context_->args_tracker->Flush(); 113| 877k|} _ZN8perfetto15trace_processor20ProtoTraceParserImpl17ParseChromeEventsElN9protozero10ConstBytesE: 163| 110k|void ProtoTraceParserImpl::ParseChromeEvents(int64_t ts, ConstBytes blob) { 164| 110k| TraceStorage* storage = context_->storage.get(); 165| 110k| protos::pbzero::ChromeEventBundle::Decoder bundle(blob); 166| 110k| ArgsTracker args(context_); 167| 110k| if (bundle.has_metadata()) { ------------------ | Branch (167:7): [True: 31.2k, False: 79.2k] ------------------ 168| 31.2k| tables::ChromeRawTable::Id id = 169| 31.2k| storage->mutable_chrome_raw_table() 170| 31.2k| ->Insert({ts, raw_chrome_metadata_event_id_, 0, 0}) 171| 31.2k| .id; 172| 31.2k| auto inserter = args.AddArgsTo(id); 173| | 174| 31.2k| uint32_t bundle_index = 175| 31.2k| context_->metadata_tracker->IncrementChromeMetadataBundleCount(); 176| | 177| | // The legacy untyped metadata is proxied via a special event in the raw 178| | // table to JSON export. 179| 88.5k| for (auto it = bundle.metadata(); it; ++it) { ------------------ | Branch (179:39): [True: 57.2k, False: 31.2k] ------------------ 180| 57.2k| protos::pbzero::ChromeMetadata::Decoder metadata(*it); 181| 57.2k| Variadic value = Variadic::Null(); 182| 57.2k| if (metadata.has_string_value()) { ------------------ | Branch (182:11): [True: 1.75k, False: 55.5k] ------------------ 183| 1.75k| value = 184| 1.75k| Variadic::String(storage->InternString(metadata.string_value())); 185| 55.5k| } else if (metadata.has_int_value()) { ------------------ | Branch (185:18): [True: 12.6k, False: 42.9k] ------------------ 186| 12.6k| value = Variadic::Integer(metadata.int_value()); 187| 42.9k| } else if (metadata.has_bool_value()) { ------------------ | Branch (187:18): [True: 464, False: 42.4k] ------------------ 188| 464| value = Variadic::Integer(metadata.bool_value()); 189| 42.4k| } else if (metadata.has_json_value()) { ------------------ | Branch (189:18): [True: 11.6k, False: 30.7k] ------------------ 190| 11.6k| value = Variadic::Json(storage->InternString(metadata.json_value())); 191| 30.7k| } else { 192| 30.7k| context_->storage->IncrementStats(stats::empty_chrome_metadata); 193| 30.7k| continue; 194| 30.7k| } 195| | 196| 26.5k| StringId name_id = storage->InternString(metadata.name()); 197| 26.5k| args.AddArgsTo(id).AddArg(name_id, value); 198| | 199| 26.5k| char buffer[2048]; 200| 26.5k| base::StringWriter writer(buffer, sizeof(buffer)); 201| 26.5k| writer.AppendString("cr-"); 202| | // If we have data from multiple Chrome instances, append a suffix 203| | // to differentiate them. 204| 26.5k| if (bundle_index > 1) { ------------------ | Branch (204:11): [True: 26.3k, False: 143] ------------------ 205| 26.3k| writer.AppendUnsignedInt(bundle_index); 206| 26.3k| writer.AppendChar('-'); 207| 26.3k| } 208| 26.5k| writer.AppendString(metadata.name()); 209| | 210| 26.5k| auto metadata_id = storage->InternString(writer.GetStringView()); 211| 26.5k| context_->metadata_tracker->SetDynamicMetadata(metadata_id, value); 212| 26.5k| } 213| 31.2k| } 214| | 215| 110k| if (bundle.has_legacy_ftrace_output()) { ------------------ | Branch (215:7): [True: 53.7k, False: 56.7k] ------------------ 216| 53.7k| tables::ChromeRawTable::Id id = 217| 53.7k| storage->mutable_chrome_raw_table() 218| 53.7k| ->Insert({ts, raw_chrome_legacy_system_trace_event_id_, 0, 0}) 219| 53.7k| .id; 220| | 221| 53.7k| std::string data; 222| 109k| for (auto it = bundle.legacy_ftrace_output(); it; ++it) { ------------------ | Branch (222:51): [True: 55.8k, False: 53.7k] ------------------ 223| 55.8k| data += (*it).ToStdString(); 224| 55.8k| } 225| 53.7k| Variadic value = 226| 53.7k| Variadic::String(storage->InternString(base::StringView(data))); 227| 53.7k| args.AddArgsTo(id).AddArg(data_name_id_, value); 228| 53.7k| } 229| | 230| 110k| if (bundle.has_legacy_json_trace()) { ------------------ | Branch (230:7): [True: 100k, False: 9.55k] ------------------ 231| 1.41M| for (auto it = bundle.legacy_json_trace(); it; ++it) { ------------------ | Branch (231:48): [True: 1.31M, False: 100k] ------------------ 232| 1.31M| protos::pbzero::ChromeLegacyJsonTrace::Decoder legacy_trace(*it); 233| 1.31M| if (legacy_trace.type() != ------------------ | Branch (233:11): [True: 11, False: 1.31M] ------------------ 234| 1.31M| protos::pbzero::ChromeLegacyJsonTrace::USER_TRACE) { 235| 11| continue; 236| 11| } 237| 1.31M| tables::ChromeRawTable::Id id = 238| 1.31M| storage->mutable_chrome_raw_table() 239| 1.31M| ->Insert({ts, raw_chrome_legacy_user_trace_event_id_, 0, 0}) 240| 1.31M| .id; 241| 1.31M| Variadic value = 242| 1.31M| Variadic::String(storage->InternString(legacy_trace.data())); 243| 1.31M| args.AddArgsTo(id).AddArg(data_name_id_, value); 244| 1.31M| } 245| 100k| } 246| 110k|} _ZN8perfetto15trace_processor20ProtoTraceParserImpl19ParseMetatraceEventElN9protozero10ConstBytesE: 248| 287k|void ProtoTraceParserImpl::ParseMetatraceEvent(int64_t ts, ConstBytes blob) { 249| 287k| protos::pbzero::PerfettoMetatrace::Decoder event(blob); 250| 287k| auto utid = context_->process_tracker->GetOrCreateThread(event.thread_id()); 251| | 252| 287k| StringId cat_id = metatrace_id_; 253| 324k| for (auto it = event.interned_strings(); it; ++it) { ------------------ | Branch (253:44): [True: 37.5k, False: 287k] ------------------ 254| 37.5k| protos::pbzero::PerfettoMetatrace::InternedString::Decoder interned_string( 255| 37.5k| it->data(), it->size()); 256| 37.5k| metatrace_interned_strings_.Insert( 257| 37.5k| interned_string.iid(), 258| 37.5k| context_->storage->InternString(interned_string.value())); 259| 37.5k| } 260| | 261| | // This function inserts the args from the proto into the args table. 262| | // Args inserted with the same key multiple times are treated as an array: 263| | // this function correctly creates the key and flat key for each arg array. 264| 287k| auto args_fn = [this, &event](ArgsTracker::BoundInserter* inserter) { 265| 287k| using Arg = std::pair; 266| | 267| | // First, get a list of all the args so we can group them by key. 268| 287k| std::vector interned; 269| 287k| for (auto it = event.args(); it; ++it) { 270| 287k| protos::pbzero::PerfettoMetatrace::Arg::Decoder arg_proto(*it); 271| 287k| StringId key; 272| 287k| if (arg_proto.has_key_iid()) { 273| 287k| key = GetMetatraceInternedString(arg_proto.key_iid()); 274| 287k| } else { 275| 287k| key = context_->storage->InternString(arg_proto.key()); 276| 287k| } 277| 287k| StringId value; 278| 287k| if (arg_proto.has_value_iid()) { 279| 287k| value = GetMetatraceInternedString(arg_proto.value_iid()); 280| 287k| } else { 281| 287k| value = context_->storage->InternString(arg_proto.value()); 282| 287k| } 283| 287k| interned.emplace_back(key, value); 284| 287k| } 285| | 286| | // We stable sort insted of sorting here to avoid changing the order of the 287| | // args in arrays. 288| 287k| std::stable_sort(interned.begin(), interned.end(), 289| 287k| [](const Arg& a, const Arg& b) { 290| 287k| return a.first.raw_id() < b.first.raw_id(); 291| 287k| }); 292| | 293| | // Compute the correct key for each arg, possibly adding an index to 294| | // the end of the key if needed. 295| 287k| char buffer[2048]; 296| 287k| uint32_t current_idx = 0; 297| 287k| for (auto it = interned.begin(); it != interned.end(); ++it) { 298| 287k| auto next = it + 1; 299| 287k| StringId key = it->first; 300| 287k| StringId next_key = next == interned.end() ? kNullStringId : next->first; 301| | 302| 287k| if (key != next_key && current_idx == 0) { 303| 287k| inserter->AddArg(key, Variadic::String(it->second)); 304| 287k| } else { 305| 287k| constexpr size_t kMaxIndexSize = 20; 306| 287k| NullTermStringView key_str = context_->storage->GetString(key); 307| 287k| if (key_str.size() >= sizeof(buffer) - kMaxIndexSize) { 308| 287k| PERFETTO_DLOG("Ignoring arg with unreasonbly large size"); 309| 287k| continue; 310| 287k| } 311| | 312| 287k| base::StackString<2048> array_key("%s[%u]", key_str.c_str(), 313| 287k| current_idx); 314| 287k| StringId new_key = 315| 287k| context_->storage->InternString(array_key.string_view()); 316| 287k| inserter->AddArg(key, new_key, Variadic::String(it->second)); 317| | 318| 287k| current_idx = key == next_key ? current_idx + 1 : 0; 319| 287k| } 320| 287k| } 321| 287k| }; 322| | 323| 287k| if (event.has_event_id() || event.has_event_name() || ------------------ | Branch (323:7): [True: 4.92k, False: 282k] | Branch (323:31): [True: 614, False: 281k] ------------------ 324| 287k| event.has_event_name_iid()) { ------------------ | Branch (324:7): [True: 3, False: 281k] ------------------ 325| 5.54k| StringId name_id; 326| 5.54k| if (event.has_event_id()) { ------------------ | Branch (326:9): [True: 4.92k, False: 617] ------------------ 327| 4.92k| auto eid = event.event_id(); 328| 4.92k| if (eid < metatrace::EVENTS_MAX) { ------------------ | Branch (328:11): [True: 3.99k, False: 935] ------------------ 329| 3.99k| name_id = context_->storage->InternString(metatrace::kEventNames[eid]); 330| 3.99k| } else { 331| 935| base::StackString<64> fallback("Event %u", eid); 332| 935| name_id = context_->storage->InternString(fallback.string_view()); 333| 935| } 334| 4.92k| } else if (event.has_event_name_iid()) { ------------------ | Branch (334:16): [True: 3, False: 614] ------------------ 335| 3| name_id = GetMetatraceInternedString(event.event_name_iid()); 336| 614| } else { 337| 614| name_id = context_->storage->InternString(event.event_name()); 338| 614| } 339| 5.54k| TrackId track_id = context_->track_tracker->InternThreadTrack(utid); 340| 5.54k| context_->slice_tracker->Scoped( 341| 5.54k| ts, track_id, cat_id, name_id, 342| 5.54k| static_cast(event.event_duration_ns()), args_fn); 343| 281k| } else if (event.has_counter_id() || event.has_counter_name()) { ------------------ | Branch (343:14): [True: 279k, False: 2.34k] | Branch (343:40): [True: 17, False: 2.33k] ------------------ 344| 279k| static constexpr auto kBlueprint = tracks::CounterBlueprint( 345| 279k| "metatrace_counter", tracks::UnknownUnitBlueprint(), 346| 279k| tracks::DimensionBlueprints( 347| 279k| tracks::kThreadDimensionBlueprint, 348| 279k| tracks::StringDimensionBlueprint("counter_name")), 349| 279k| tracks::DynamicNameBlueprint()); 350| 279k| TrackId track; 351| 279k| if (event.has_counter_id()) { ------------------ | Branch (351:9): [True: 279k, False: 17] ------------------ 352| 279k| auto cid = event.counter_id(); 353| 279k| StringId name_id; 354| 279k| if (cid < metatrace::COUNTERS_MAX) { ------------------ | Branch (354:11): [True: 206, False: 278k] ------------------ 355| 206| name_id = 356| 206| context_->storage->InternString(metatrace::kCounterNames[cid]); 357| 278k| } else { 358| 278k| base::StackString<64> fallback("Counter %u", cid); 359| 278k| name_id = context_->storage->InternString(fallback.string_view()); 360| 278k| } 361| 279k| track = context_->track_tracker->InternTrack( 362| 279k| kBlueprint, 363| 279k| tracks::Dimensions(utid, context_->storage->GetString(name_id)), 364| 279k| tracks::DynamicName(name_id)); 365| 279k| } else { 366| 17| track = context_->track_tracker->InternTrack( 367| 17| kBlueprint, tracks::Dimensions(utid, event.counter_name()), 368| 17| tracks::DynamicName( 369| 17| context_->storage->InternString(event.counter_name()))); 370| 17| } 371| 279k| auto opt_id = 372| 279k| context_->event_tracker->PushCounter(ts, event.counter_value(), track); 373| 279k| if (opt_id) { ------------------ | Branch (373:9): [True: 279k, False: 0] ------------------ 374| 279k| auto inserter = context_->args_tracker->AddArgsTo(*opt_id); 375| 279k| args_fn(&inserter); 376| 279k| } 377| 279k| } 378| | 379| 287k| if (event.has_overruns()) ------------------ | Branch (379:7): [True: 272k, False: 14.3k] ------------------ 380| 272k| context_->storage->IncrementStats(stats::metatrace_overruns); 381| 287k|} _ZN8perfetto15trace_processor20ProtoTraceParserImpl26GetMetatraceInternedStringEm: 383| 63|StringId ProtoTraceParserImpl::GetMetatraceInternedString(uint64_t iid) { 384| 63| StringId* maybe_id = metatrace_interned_strings_.Find(iid); 385| 63| if (!maybe_id) ------------------ | Branch (385:7): [True: 18, False: 45] ------------------ 386| 18| return missing_metatrace_interned_string_id_; 387| 45| return *maybe_id; 388| 63|} proto_trace_parser_impl.cc:_ZZN8perfetto15trace_processor20ProtoTraceParserImpl19ParseMetatraceEventElN9protozero10ConstBytesEENK3$_0clEPNS0_11ArgsTracker13BoundInserterE: 264| 284k| auto args_fn = [this, &event](ArgsTracker::BoundInserter* inserter) { 265| 284k| using Arg = std::pair; 266| | 267| | // First, get a list of all the args so we can group them by key. 268| 284k| std::vector interned; 269| 4.26M| for (auto it = event.args(); it; ++it) { ------------------ | Branch (269:34): [True: 3.97M, False: 284k] ------------------ 270| 3.97M| protos::pbzero::PerfettoMetatrace::Arg::Decoder arg_proto(*it); 271| 3.97M| StringId key; 272| 3.97M| if (arg_proto.has_key_iid()) { ------------------ | Branch (272:11): [True: 15, False: 3.97M] ------------------ 273| 15| key = GetMetatraceInternedString(arg_proto.key_iid()); 274| 3.97M| } else { 275| 3.97M| key = context_->storage->InternString(arg_proto.key()); 276| 3.97M| } 277| 3.97M| StringId value; 278| 3.97M| if (arg_proto.has_value_iid()) { ------------------ | Branch (278:11): [True: 45, False: 3.97M] ------------------ 279| 45| value = GetMetatraceInternedString(arg_proto.value_iid()); 280| 3.97M| } else { 281| 3.97M| value = context_->storage->InternString(arg_proto.value()); 282| 3.97M| } 283| 3.97M| interned.emplace_back(key, value); 284| 3.97M| } 285| | 286| | // We stable sort insted of sorting here to avoid changing the order of the 287| | // args in arrays. 288| 284k| std::stable_sort(interned.begin(), interned.end(), 289| 284k| [](const Arg& a, const Arg& b) { 290| 284k| return a.first.raw_id() < b.first.raw_id(); 291| 284k| }); 292| | 293| | // Compute the correct key for each arg, possibly adding an index to 294| | // the end of the key if needed. 295| 284k| char buffer[2048]; 296| 284k| uint32_t current_idx = 0; 297| 4.26M| for (auto it = interned.begin(); it != interned.end(); ++it) { ------------------ | Branch (297:38): [True: 3.97M, False: 284k] ------------------ 298| 3.97M| auto next = it + 1; 299| 3.97M| StringId key = it->first; 300| 3.97M| StringId next_key = next == interned.end() ? kNullStringId : next->first; ------------------ | Branch (300:27): [True: 278k, False: 3.69M] ------------------ 301| | 302| 3.97M| if (key != next_key && current_idx == 0) { ------------------ | Branch (302:11): [True: 2.59k, False: 3.97M] | Branch (302:30): [True: 1.59k, False: 1.00k] ------------------ 303| 1.59k| inserter->AddArg(key, Variadic::String(it->second)); 304| 3.97M| } else { 305| 3.97M| constexpr size_t kMaxIndexSize = 20; 306| 3.97M| NullTermStringView key_str = context_->storage->GetString(key); 307| 3.97M| if (key_str.size() >= sizeof(buffer) - kMaxIndexSize) { ------------------ | Branch (307:13): [True: 0, False: 3.97M] ------------------ 308| 0| PERFETTO_DLOG("Ignoring arg with unreasonbly large size"); 309| 0| continue; 310| 0| } 311| | 312| 3.97M| base::StackString<2048> array_key("%s[%u]", key_str.c_str(), 313| 3.97M| current_idx); 314| 3.97M| StringId new_key = 315| 3.97M| context_->storage->InternString(array_key.string_view()); 316| 3.97M| inserter->AddArg(key, new_key, Variadic::String(it->second)); 317| | 318| 3.97M| current_idx = key == next_key ? current_idx + 1 : 0; ------------------ | Branch (318:23): [True: 3.97M, False: 1.00k] ------------------ 319| 3.97M| } 320| 3.97M| } 321| 284k| }; proto_trace_parser_impl.cc:_ZZZN8perfetto15trace_processor20ProtoTraceParserImpl19ParseMetatraceEventElN9protozero10ConstBytesEENK3$_0clEPNS0_11ArgsTracker13BoundInserterEENKUlRKNSt3__14pairINS0_10StringPool2IdESB_EESE_E_clESE_SE_: 289| 5.41M| [](const Arg& a, const Arg& b) { 290| 5.41M| return a.first.raw_id() < b.first.raw_id(); 291| 5.41M| }); _ZN8perfetto15trace_processor16ProtoTraceReaderC2EPNS0_21TraceProcessorContextE: 65| 2.02k| : context_(ctx), 66| 2.02k| skipped_packet_key_id_(ctx->storage->InternString("skipped_packet")), 67| | invalid_incremental_state_key_id_( 68| 2.02k| ctx->storage->InternString("invalid_incremental_state")) {} _ZN8perfetto15trace_processor16ProtoTraceReaderD2Ev: 69| 2.02k|ProtoTraceReader::~ProtoTraceReader() = default; _ZN8perfetto15trace_processor16ProtoTraceReader5ParseENS0_13TraceBlobViewE: 71| 424|base::Status ProtoTraceReader::Parse(TraceBlobView blob) { 72| 424| return tokenizer_.Tokenize(std::move(blob), [this](TraceBlobView packet) { 73| 424| return ParsePacket(std::move(packet)); 74| 424| }); 75| 424|} _ZN8perfetto15trace_processor16ProtoTraceReader24ParseExtensionDescriptorEN9protozero10ConstBytesE: 77| 1.78k|base::Status ProtoTraceReader::ParseExtensionDescriptor(ConstBytes descriptor) { 78| 1.78k| protos::pbzero::ExtensionDescriptor::Decoder decoder(descriptor.data, 79| 1.78k| descriptor.size); 80| | 81| 1.78k| auto extension = decoder.extension_set(); 82| 1.78k| return context_->descriptor_pool_->AddFromFileDescriptorSet( 83| 1.78k| extension.data, extension.size, 84| 1.78k| /*skip_prefixes*/ {}, 85| 1.78k| /*merge_existing_messages=*/true); 86| 1.78k|} _ZN8perfetto15trace_processor16ProtoTraceReader11ParsePacketENS0_13TraceBlobViewE: 88| 3.98M|base::Status ProtoTraceReader::ParsePacket(TraceBlobView packet) { 89| 3.98M| protos::pbzero::TracePacket::Decoder decoder(packet.data(), packet.length()); 90| 3.98M| if (PERFETTO_UNLIKELY(decoder.bytes_left())) { ------------------ | | 24| 3.98M|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 23, False: 3.98M] | | ------------------ ------------------ 91| 23| return base::ErrStatus( 92| 23| "Failed to parse proto packet fully; the trace is probably corrupt."); 93| 23| } 94| | 95| | // Any compressed packets should have been handled by the tokenizer. 96| 3.98M| PERFETTO_CHECK(!decoder.has_compressed_packets()); 97| | 98| | // When the trace packet is emitted from a remote machine: parse the packet 99| | // using a different ProtoTraceReader instance. The packet will be parsed 100| | // in the context of the remote machine. 101| 3.98M| if (PERFETTO_UNLIKELY(decoder.has_machine_id())) { ------------------ | | 24| 3.98M|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 3.20k, False: 3.98M] | | ------------------ ------------------ 102| 3.20k| if (!context_->machine_id()) { ------------------ | Branch (102:9): [True: 1.60k, False: 1.60k] ------------------ 103| | // Default context: switch to another reader instance to parse the packet. 104| 1.60k| PERFETTO_DCHECK(context_->multi_machine_trace_manager); 105| 1.60k| auto* reader = context_->multi_machine_trace_manager->GetOrCreateReader( 106| 1.60k| decoder.machine_id()); 107| 1.60k| return reader->ParsePacket(std::move(packet)); 108| 1.60k| } 109| 3.20k| } 110| | // Assert that the packet is parsed using the right instance of reader. 111| 3.98M| PERFETTO_DCHECK(decoder.has_machine_id() == !!context_->machine_id()); 112| | 113| 3.98M| uint32_t seq_id = decoder.trusted_packet_sequence_id(); 114| 3.98M| auto [scoped_state, inserted] = sequence_state_.Insert(seq_id, {}); 115| 3.98M| if (decoder.has_trusted_packet_sequence_id()) { ------------------ | Branch (115:7): [True: 1.09M, False: 2.89M] ------------------ 116| 1.09M| if (!inserted && decoder.previous_packet_dropped()) { ------------------ | Branch (116:9): [True: 1.03M, False: 56.3k] | Branch (116:22): [True: 41, False: 1.03M] ------------------ 117| 41| ++scoped_state->previous_packet_dropped_count; 118| 41| } 119| 1.09M| } 120| | 121| 3.98M| if (decoder.first_packet_on_sequence()) { ------------------ | Branch (121:7): [True: 1, False: 3.98M] ------------------ 122| 1| HandleFirstPacketOnSequence(seq_id); 123| 1| } 124| | 125| 3.98M| uint32_t sequence_flags = decoder.sequence_flags(); 126| 3.98M| if (decoder.incremental_state_cleared() || ------------------ | Branch (126:7): [True: 2, False: 3.98M] ------------------ 127| 3.98M| sequence_flags & ------------------ | Branch (127:7): [True: 10.2k, False: 3.97M] ------------------ 128| 3.98M| protos::pbzero::TracePacket::SEQ_INCREMENTAL_STATE_CLEARED) { 129| 10.2k| HandleIncrementalStateCleared(decoder); 130| 3.97M| } else if (decoder.previous_packet_dropped()) { ------------------ | Branch (130:14): [True: 78, False: 3.97M] ------------------ 131| 78| HandlePreviousPacketDropped(decoder); 132| 78| } 133| | 134| | // It is important that we parse defaults before parsing other fields such as 135| | // the timestamp, since the defaults could affect them. 136| 3.98M| if (decoder.has_trace_packet_defaults()) { ------------------ | Branch (136:7): [True: 815, False: 3.98M] ------------------ 137| 815| auto field = decoder.trace_packet_defaults(); 138| 815| ParseTracePacketDefaults(decoder, packet.slice(field.data, field.size)); 139| 815| } 140| | 141| 3.98M| if (decoder.has_interned_data()) { ------------------ | Branch (141:7): [True: 18.3k, False: 3.96M] ------------------ 142| 18.3k| auto field = decoder.interned_data(); 143| 18.3k| ParseInternedData(decoder, packet.slice(field.data, field.size)); 144| 18.3k| } 145| | 146| 3.98M| if (decoder.has_clock_snapshot()) { ------------------ | Branch (146:7): [True: 21.1k, False: 3.96M] ------------------ 147| 21.1k| return ParseClockSnapshot(decoder.clock_snapshot(), seq_id); 148| 21.1k| } 149| | 150| 3.96M| if (decoder.has_trace_stats()) { ------------------ | Branch (150:7): [True: 24, False: 3.96M] ------------------ 151| 24| ParseTraceStats(decoder.trace_stats()); 152| 24| } 153| | 154| 3.96M| if (decoder.has_remote_clock_sync()) { ------------------ | Branch (154:7): [True: 0, False: 3.96M] ------------------ 155| 0| PERFETTO_DCHECK(context_->machine_id()); 156| 0| return ParseRemoteClockSync(decoder.remote_clock_sync()); 157| 0| } 158| | 159| 3.96M| if (decoder.has_service_event()) { ------------------ | Branch (159:7): [True: 34.7k, False: 3.93M] ------------------ 160| 34.7k| PERFETTO_DCHECK(decoder.has_timestamp()); 161| 34.7k| int64_t ts = static_cast(decoder.timestamp()); 162| 34.7k| return ParseServiceEvent(ts, decoder.service_event()); 163| 34.7k| } 164| | 165| 3.93M| if (decoder.has_extension_descriptor()) { ------------------ | Branch (165:7): [True: 1.78k, False: 3.93M] ------------------ 166| 1.78k| return ParseExtensionDescriptor(decoder.extension_descriptor()); 167| 1.78k| } 168| | 169| 3.93M| auto* state = GetIncrementalStateForPacketSequence(seq_id); 170| 3.93M| if (decoder.sequence_flags() & ------------------ | Branch (170:7): [True: 14.3k, False: 3.91M] ------------------ 171| 3.93M| protos::pbzero::TracePacket::SEQ_NEEDS_INCREMENTAL_STATE) { 172| 14.3k| if (!seq_id) { ------------------ | Branch (172:9): [True: 0, False: 14.3k] ------------------ 173| 0| return base::ErrStatus( 174| 0| "TracePacket specified SEQ_NEEDS_INCREMENTAL_STATE but the " 175| 0| "TraceWriter's sequence_id is zero (the service is " 176| 0| "probably too old)"); 177| 0| } 178| 14.3k| scoped_state->needs_incremental_state_total++; 179| | 180| 14.3k| if (!state->IsIncrementalStateValid()) { ------------------ | Branch (180:9): [True: 10.1k, False: 4.17k] ------------------ 181| 10.1k| if (context_->content_analyzer) { ------------------ | Branch (181:11): [True: 0, False: 10.1k] ------------------ 182| | // Account for the skipped packet for trace proto content analysis, 183| | // with a special annotation. 184| 0| PacketAnalyzer::SampleAnnotation annotation; 185| 0| annotation.emplace_back(skipped_packet_key_id_, 186| 0| invalid_incremental_state_key_id_); 187| 0| PacketAnalyzer::Get(context_)->ProcessPacket(packet, annotation); 188| 0| } 189| 10.1k| scoped_state->needs_incremental_state_skipped++; 190| 10.1k| context_->storage->IncrementStats(stats::tokenizer_skipped_packets); 191| 10.1k| return base::OkStatus(); 192| 10.1k| } 193| 14.3k| } 194| | 195| 3.92M| if (context_->content_analyzer && !decoder.has_track_event()) { ------------------ | Branch (195:7): [True: 0, False: 3.92M] | Branch (195:37): [True: 0, False: 0] ------------------ 196| 0| PacketAnalyzer::Get(context_)->ProcessPacket(packet, {}); 197| 0| } 198| | 199| 3.92M| if (decoder.has_trace_config()) { ------------------ | Branch (199:7): [True: 2.18k, False: 3.91M] ------------------ 200| 2.18k| ParseTraceConfig(decoder.trace_config()); 201| 2.18k| } 202| | 203| 3.92M| return TimestampTokenizeAndPushToSorter(std::move(packet)); 204| 3.93M|} _ZN8perfetto15trace_processor16ProtoTraceReader32TimestampTokenizeAndPushToSorterENS0_13TraceBlobViewE: 207| 3.92M| TraceBlobView packet) { 208| 3.92M| protos::pbzero::TracePacket::Decoder decoder(packet.data(), packet.length()); 209| | 210| 3.92M| uint32_t seq_id = decoder.trusted_packet_sequence_id(); 211| 3.92M| auto* state = GetIncrementalStateForPacketSequence(seq_id); 212| | 213| 3.92M| protos::pbzero::TracePacketDefaults::Decoder* defaults = 214| 3.92M| state->current_generation()->GetTracePacketDefaults(); 215| | 216| 3.92M| int64_t timestamp; 217| 3.92M| if (decoder.has_timestamp()) { ------------------ | Branch (217:7): [True: 2.88M, False: 1.03M] ------------------ 218| 2.88M| timestamp = static_cast(decoder.timestamp()); 219| | 220| 2.88M| uint32_t timestamp_clock_id = 221| 2.88M| decoder.has_timestamp_clock_id() ------------------ | Branch (221:9): [True: 2, False: 2.88M] ------------------ 222| 2.88M| ? decoder.timestamp_clock_id() 223| 2.88M| : (defaults ? defaults->timestamp_clock_id() : 0); ------------------ | Branch (223:16): [True: 51.0k, False: 2.83M] ------------------ 224| | 225| 2.88M| if ((decoder.has_chrome_events() || decoder.has_chrome_metadata()) && ------------------ | Branch (225:10): [True: 1.65k, False: 2.88M] | Branch (225:41): [True: 0, False: 2.88M] ------------------ 226| 2.88M| (!timestamp_clock_id || ------------------ | Branch (226:10): [True: 1.65k, False: 0] ------------------ 227| 1.65k| timestamp_clock_id == protos::pbzero::BUILTIN_CLOCK_MONOTONIC)) { ------------------ | Branch (227:10): [True: 0, False: 0] ------------------ 228| | // Chrome event timestamps are in MONOTONIC domain, but may occur in 229| | // traces where (a) no clock snapshots exist or (b) no clock_id is 230| | // specified for their timestamps. Adjust to trace time if we have a clock 231| | // snapshot. 232| | // TODO(eseckler): Set timestamp_clock_id and emit ClockSnapshots in 233| | // chrome and then remove this. 234| 1.65k| auto trace_ts = context_->clock_tracker->ToTraceTime( 235| 1.65k| protos::pbzero::BUILTIN_CLOCK_MONOTONIC, timestamp); 236| 1.65k| if (trace_ts.ok()) ------------------ | Branch (236:11): [True: 669, False: 982] ------------------ 237| 669| timestamp = trace_ts.value(); 238| 2.88M| } else if (timestamp_clock_id) { ------------------ | Branch (238:16): [True: 2, False: 2.88M] ------------------ 239| | // If the TracePacket specifies a non-zero clock-id, translate the 240| | // timestamp into the trace-time clock domain. 241| 2| ClockTracker::ClockId converted_clock_id = timestamp_clock_id; 242| 2| if (ClockTracker::IsSequenceClock(converted_clock_id)) { ------------------ | Branch (242:11): [True: 0, False: 2] ------------------ 243| 0| if (!seq_id) { ------------------ | Branch (243:13): [True: 0, False: 0] ------------------ 244| 0| return base::ErrStatus( 245| 0| "TracePacket specified a sequence-local clock id (%" PRIu32 246| 0| ") but the TraceWriter's sequence_id is zero (the service is " 247| 0| "probably too old)", 248| 0| timestamp_clock_id); 249| 0| } 250| 0| converted_clock_id = 251| 0| ClockTracker::SequenceToGlobalClock(seq_id, timestamp_clock_id); 252| 0| } 253| | // If the clock tracker is missing a path to trace time for this clock 254| | // then try to save this packet for processing later when a path exists. 255| 2| if (!context_->clock_tracker->HasPathToTraceTime(converted_clock_id)) { ------------------ | Branch (255:11): [True: 2, False: 0] ------------------ 256| | // We need to switch to full sorting mode to ensure that packets with 257| | // missing timestamp are handled correctly. Don't save the packet unless 258| | // switching to full sorting mode succeeded. 259| 2| if (!received_eof_ && context_->sorter->SetSortingMode( ------------------ | Branch (259:13): [True: 1, False: 1] | Branch (259:31): [True: 1, False: 0] ------------------ 260| 1| TraceSorter::SortingMode::kFullSort)) { 261| 1| eof_deferred_packets_.push_back(std::move(packet)); 262| 1| return base::OkStatus(); 263| 1| } 264| | // Fall-through and let ToTraceTime fail below. 265| 2| } 266| 1| auto trace_ts = 267| 1| context_->clock_tracker->ToTraceTime(converted_clock_id, timestamp); 268| 1| if (!trace_ts.ok()) { ------------------ | Branch (268:11): [True: 1, False: 0] ------------------ 269| | // ToTraceTime() will increase the |clock_sync_failure| stat on failure. 270| | // We don't return an error here as it will cause the trace to stop 271| | // parsing. Instead, we rely on the stat increment in ToTraceTime() to 272| | // inform the user about the error. 273| 1| return base::OkStatus(); 274| 1| } 275| 0| timestamp = trace_ts.value(); 276| 0| } 277| 2.88M| } else { 278| 1.03M| timestamp = std::max(latest_timestamp_, context_->sorter->max_timestamp()); 279| 1.03M| } 280| 3.92M| latest_timestamp_ = std::max(timestamp, latest_timestamp_); 281| | 282| 3.92M| auto& modules = context_->modules_by_field; 283| 264M| for (uint32_t field_id = 1; field_id < modules.size(); ++field_id) { ------------------ | Branch (283:31): [True: 262M, False: 2.75M] ------------------ 284| 262M| if (!modules[field_id].empty() && decoder.Get(field_id).valid()) { ------------------ | Branch (284:9): [True: 27.2M, False: 234M] | Branch (284:39): [True: 1.37M, False: 25.8M] ------------------ 285| 1.37M| for (ProtoImporterModule* global_module : ------------------ | Branch (285:47): [True: 0, False: 1.37M] ------------------ 286| 1.37M| context_->modules_for_all_fields) { 287| 0| ModuleResult res = global_module->TokenizePacket( 288| 0| decoder, &packet, timestamp, state->current_generation(), field_id); 289| 0| if (!res.ignored()) ------------------ | Branch (289:13): [True: 0, False: 0] ------------------ 290| 0| return res.ToStatus(); 291| 0| } 292| 1.37M| for (ProtoImporterModule* module : modules[field_id]) { ------------------ | Branch (292:40): [True: 1.37M, False: 211k] ------------------ 293| 1.37M| ModuleResult res = module->TokenizePacket( 294| 1.37M| decoder, &packet, timestamp, state->current_generation(), field_id); 295| 1.37M| if (!res.ignored()) ------------------ | Branch (295:13): [True: 1.16M, False: 211k] ------------------ 296| 1.16M| return res.ToStatus(); 297| 1.37M| } 298| 1.37M| } 299| 262M| } 300| | 301| | // Use parent data and length because we want to parse this again 302| | // later to get the exact type of the packet. 303| 2.75M| context_->sorter->PushTracePacket(timestamp, state->current_generation(), 304| 2.75M| std::move(packet), context_->machine_id()); 305| | 306| 2.75M| return base::OkStatus(); 307| 3.92M|} _ZN8perfetto15trace_processor16ProtoTraceReader16ParseTraceConfigEN9protozero10ConstBytesE: 309| 2.18k|void ProtoTraceReader::ParseTraceConfig(protozero::ConstBytes blob) { 310| 2.18k| using Config = protos::pbzero::TraceConfig; 311| 2.18k| Config::Decoder trace_config(blob); 312| 2.18k| if (trace_config.write_into_file()) { ------------------ | Branch (312:7): [True: 475, False: 1.71k] ------------------ 313| 475| if (!trace_config.flush_period_ms()) { ------------------ | Branch (313:9): [True: 317, False: 158] ------------------ 314| 317| context_->storage->IncrementStats(stats::config_write_into_file_no_flush); 315| 317| } 316| 475| int i = 0; 317| 1.00k| for (auto it = trace_config.buffers(); it; ++it, ++i) { ------------------ | Branch (317:44): [True: 534, False: 475] ------------------ 318| 534| Config::BufferConfig::Decoder buf(*it); 319| 534| if (buf.fill_policy() == Config::BufferConfig::FillPolicy::DISCARD) { ------------------ | Branch (319:11): [True: 0, False: 534] ------------------ 320| 0| context_->storage->IncrementIndexedStats( 321| 0| stats::config_write_into_file_discard, i); 322| 0| } 323| 534| } 324| 475| } 325| 2.18k|} _ZN8perfetto15trace_processor16ProtoTraceReader29HandleIncrementalStateClearedERKNS_6protos6pbzero19TracePacket_DecoderE: 328| 10.2k| const protos::pbzero::TracePacket::Decoder& packet_decoder) { 329| 10.2k| if (PERFETTO_UNLIKELY(!packet_decoder.has_trusted_packet_sequence_id())) { ------------------ | | 24| 10.2k|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 121, False: 10.1k] | | ------------------ ------------------ 330| 121| PERFETTO_ELOG( 331| 121| "incremental_state_cleared without trusted_packet_sequence_id"); 332| 121| context_->storage->IncrementStats(stats::interned_data_tokenizer_errors); 333| 121| return; 334| 121| } 335| 10.1k| GetIncrementalStateForPacketSequence( 336| 10.1k| packet_decoder.trusted_packet_sequence_id()) 337| 10.1k| ->OnIncrementalStateCleared(); 338| 61.0k| for (auto& module : context_->modules) { ------------------ | Branch (338:21): [True: 61.0k, False: 10.1k] ------------------ 339| 61.0k| module->OnIncrementalStateCleared( 340| 61.0k| packet_decoder.trusted_packet_sequence_id()); 341| 61.0k| } 342| 10.1k|} _ZN8perfetto15trace_processor16ProtoTraceReader27HandleFirstPacketOnSequenceEj: 345| 1| uint32_t packet_sequence_id) { 346| 6| for (auto& module : context_->modules) { ------------------ | Branch (346:21): [True: 6, False: 1] ------------------ 347| 6| module->OnFirstPacketOnSequence(packet_sequence_id); 348| 6| } 349| 1|} _ZN8perfetto15trace_processor16ProtoTraceReader27HandlePreviousPacketDroppedERKNS_6protos6pbzero19TracePacket_DecoderE: 352| 78| const protos::pbzero::TracePacket::Decoder& packet_decoder) { 353| 78| if (PERFETTO_UNLIKELY(!packet_decoder.has_trusted_packet_sequence_id())) { ------------------ | | 24| 78|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 31, False: 47] | | ------------------ ------------------ 354| 31| PERFETTO_ELOG("previous_packet_dropped without trusted_packet_sequence_id"); 355| 31| context_->storage->IncrementStats(stats::interned_data_tokenizer_errors); 356| 31| return; 357| 31| } 358| 47| GetIncrementalStateForPacketSequence( 359| 47| packet_decoder.trusted_packet_sequence_id()) 360| 47| ->OnPacketLoss(); 361| 47|} _ZN8perfetto15trace_processor16ProtoTraceReader24ParseTracePacketDefaultsERKNS_6protos6pbzero19TracePacket_DecoderENS0_13TraceBlobViewE: 365| 815| TraceBlobView trace_packet_defaults) { 366| 815| if (PERFETTO_UNLIKELY(!packet_decoder.has_trusted_packet_sequence_id())) { ------------------ | | 24| 815|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 1, False: 814] | | ------------------ ------------------ 367| 1| PERFETTO_ELOG( 368| 1| "TracePacketDefaults packet without trusted_packet_sequence_id"); 369| 1| context_->storage->IncrementStats(stats::interned_data_tokenizer_errors); 370| 1| return; 371| 1| } 372| | 373| 814| auto* state = GetIncrementalStateForPacketSequence( 374| 814| packet_decoder.trusted_packet_sequence_id()); 375| 814| state->UpdateTracePacketDefaults(std::move(trace_packet_defaults)); 376| 814|} _ZN8perfetto15trace_processor16ProtoTraceReader17ParseInternedDataERKNS_6protos6pbzero19TracePacket_DecoderENS0_13TraceBlobViewE: 380| 18.3k| TraceBlobView interned_data) { 381| 18.3k| if (PERFETTO_UNLIKELY(!packet_decoder.has_trusted_packet_sequence_id())) { ------------------ | | 24| 18.3k|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 955, False: 17.3k] | | ------------------ ------------------ 382| 955| PERFETTO_ELOG("InternedData packet without trusted_packet_sequence_id"); 383| 955| context_->storage->IncrementStats(stats::interned_data_tokenizer_errors); 384| 955| return; 385| 955| } 386| | 387| 17.3k| auto* state = GetIncrementalStateForPacketSequence( 388| 17.3k| packet_decoder.trusted_packet_sequence_id()); 389| | 390| | // Don't parse interned data entries until incremental state is valid, because 391| | // they could otherwise be associated with the wrong generation in the state. 392| 17.3k| if (!state->IsIncrementalStateValid()) { ------------------ | Branch (392:7): [True: 3.48k, False: 13.9k] ------------------ 393| 3.48k| context_->storage->IncrementStats(stats::tokenizer_skipped_packets); 394| 3.48k| return; 395| 3.48k| } 396| | 397| | // Store references to interned data submessages into the sequence's state. 398| 13.9k| protozero::ProtoDecoder decoder(interned_data.data(), interned_data.length()); 399| 137k| for (protozero::Field f = decoder.ReadField(); f.valid(); ------------------ | Branch (399:50): [True: 123k, False: 13.9k] ------------------ 400| 123k| f = decoder.ReadField()) { 401| 123k| auto bytes = f.as_bytes(); 402| 123k| state->InternMessage(f.id(), interned_data.slice(bytes.data, bytes.size)); 403| 123k| } 404| 13.9k|} _ZN8perfetto15trace_processor16ProtoTraceReader18ParseClockSnapshotEN9protozero10ConstBytesEj: 407| 21.1k| uint32_t seq_id) { 408| 21.1k| std::vector clock_timestamps; 409| 21.1k| protos::pbzero::ClockSnapshot::Decoder evt(blob.data, blob.size); 410| 21.1k| if (evt.primary_trace_clock()) { ------------------ | Branch (410:7): [True: 7.31k, False: 13.8k] ------------------ 411| 7.31k| context_->clock_tracker->SetTraceTimeClock( 412| 7.31k| static_cast(evt.primary_trace_clock())); 413| 7.31k| } 414| 82.1k| for (auto it = evt.clocks(); it; ++it) { ------------------ | Branch (414:32): [True: 60.9k, False: 21.1k] ------------------ 415| 60.9k| protos::pbzero::ClockSnapshot::Clock::Decoder clk(*it); 416| 60.9k| ClockTracker::ClockId clock_id = clk.clock_id(); 417| 60.9k| if (ClockTracker::IsSequenceClock(clk.clock_id())) { ------------------ | Branch (417:9): [True: 2.95k, False: 58.0k] ------------------ 418| 2.95k| if (!seq_id) { ------------------ | Branch (418:11): [True: 0, False: 2.95k] ------------------ 419| 0| return base::ErrStatus( 420| 0| "ClockSnapshot packet is specifying a sequence-scoped clock id " 421| 0| "(%" PRId64 ") but the TracePacket sequence_id is zero", 422| 0| clock_id); 423| 0| } 424| 2.95k| clock_id = ClockTracker::SequenceToGlobalClock(seq_id, clk.clock_id()); 425| 2.95k| } 426| 60.9k| int64_t unit_multiplier_ns = 427| 60.9k| clk.unit_multiplier_ns() ------------------ | Branch (427:9): [True: 3, False: 60.9k] ------------------ 428| 60.9k| ? static_cast(clk.unit_multiplier_ns()) 429| 60.9k| : 1; 430| 60.9k| clock_timestamps.emplace_back(clock_id, clk.timestamp(), unit_multiplier_ns, 431| 60.9k| clk.is_incremental()); 432| 60.9k| } 433| | 434| 21.1k| base::StatusOr snapshot_id = 435| 21.1k| context_->clock_tracker->AddSnapshot(clock_timestamps); 436| 21.1k| if (!snapshot_id.ok()) { ------------------ | Branch (436:7): [True: 3.82k, False: 17.3k] ------------------ 437| 3.82k| PERFETTO_ELOG("%s", snapshot_id.status().c_message()); 438| 3.82k| return base::OkStatus(); 439| 3.82k| } 440| | 441| 17.3k| std::optional trace_time_from_snapshot = 442| 17.3k| context_->clock_tracker->ToTraceTimeFromSnapshot(clock_timestamps); 443| | 444| | // Add the all the clock snapshots to the clock snapshot table. 445| 17.3k| std::optional trace_ts_for_check; 446| 41.9k| for (const auto& clock_timestamp : clock_timestamps) { ------------------ | Branch (446:36): [True: 41.9k, False: 17.3k] ------------------ 447| | // If the clock is incremental, we need to use 0 to map correctly to 448| | // |absolute_timestamp|. 449| 41.9k| int64_t ts_to_convert = 450| 41.9k| clock_timestamp.clock.is_incremental ? 0 : clock_timestamp.timestamp; ------------------ | Branch (450:9): [True: 1.22k, False: 40.6k] ------------------ 451| | // Even if we have trace time from snapshot, we still run ToTraceTime to 452| | // optimise future conversions. 453| 41.9k| base::StatusOr opt_trace_ts = context_->clock_tracker->ToTraceTime( 454| 41.9k| clock_timestamp.clock.id, ts_to_convert); 455| | 456| 41.9k| if (!opt_trace_ts.ok()) { ------------------ | Branch (456:9): [True: 16.8k, False: 25.1k] ------------------ 457| | // This can happen if |AddSnapshot| failed to resolve this clock, e.g. if 458| | // clock is not monotonic. Try to fetch trace time from snapshot. 459| 16.8k| if (!trace_time_from_snapshot) { ------------------ | Branch (459:11): [True: 16.8k, False: 0] ------------------ 460| 16.8k| PERFETTO_DLOG("%s", opt_trace_ts.status().c_message()); 461| 16.8k| continue; 462| 16.8k| } 463| 0| opt_trace_ts = *trace_time_from_snapshot; 464| 0| } 465| | 466| | // Double check that all the clocks in this snapshot resolve to the same 467| | // trace timestamp value. 468| 25.1k| PERFETTO_DCHECK(!trace_ts_for_check || 469| 25.1k| opt_trace_ts.value() == trace_ts_for_check.value()); 470| 25.1k| trace_ts_for_check = *opt_trace_ts; 471| | 472| 25.1k| tables::ClockSnapshotTable::Row row; 473| 25.1k| row.ts = *opt_trace_ts; 474| 25.1k| row.clock_id = static_cast(clock_timestamp.clock.id); 475| 25.1k| row.clock_value = 476| 25.1k| clock_timestamp.timestamp * clock_timestamp.clock.unit_multiplier_ns; 477| 25.1k| row.clock_name = GetBuiltinClockNameOrNull(clock_timestamp.clock.id); 478| 25.1k| row.snapshot_id = *snapshot_id; 479| 25.1k| row.machine_id = context_->machine_id(); 480| | 481| 25.1k| context_->storage->mutable_clock_snapshot_table()->Insert(row); 482| 25.1k| } 483| 17.3k| return base::OkStatus(); 484| 21.1k|} _ZN8perfetto15trace_processor16ProtoTraceReader25GetBuiltinClockNameOrNullEl: 607| 25.1k| int64_t clock_id) { 608| 25.1k| switch (clock_id) { 609| 89| case protos::pbzero::ClockSnapshot::Clock::REALTIME: ------------------ | Branch (609:5): [True: 89, False: 25.0k] ------------------ 610| 89| return context_->storage->InternString("REALTIME"); 611| 189| case protos::pbzero::ClockSnapshot::Clock::REALTIME_COARSE: ------------------ | Branch (611:5): [True: 189, False: 24.9k] ------------------ 612| 189| return context_->storage->InternString("REALTIME_COARSE"); 613| 438| case protos::pbzero::ClockSnapshot::Clock::MONOTONIC: ------------------ | Branch (613:5): [True: 438, False: 24.6k] ------------------ 614| 438| return context_->storage->InternString("MONOTONIC"); 615| 1.67k| case protos::pbzero::ClockSnapshot::Clock::MONOTONIC_COARSE: ------------------ | Branch (615:5): [True: 1.67k, False: 23.4k] ------------------ 616| 1.67k| return context_->storage->InternString("MONOTONIC_COARSE"); 617| 0| case protos::pbzero::ClockSnapshot::Clock::MONOTONIC_RAW: ------------------ | Branch (617:5): [True: 0, False: 25.1k] ------------------ 618| 0| return context_->storage->InternString("MONOTONIC_RAW"); 619| 2.28k| case protos::pbzero::ClockSnapshot::Clock::BOOTTIME: ------------------ | Branch (619:5): [True: 2.28k, False: 22.8k] ------------------ 620| 2.28k| return context_->storage->InternString("BOOTTIME"); 621| 20.4k| default: ------------------ | Branch (621:5): [True: 20.4k, False: 4.67k] ------------------ 622| 20.4k| return std::nullopt; 623| 25.1k| } 624| 25.1k|} _ZN8perfetto15trace_processor16ProtoTraceReader17ParseServiceEventElN9protozero10ConstBytesE: 626| 34.7k|base::Status ProtoTraceReader::ParseServiceEvent(int64_t ts, ConstBytes blob) { 627| 34.7k| protos::pbzero::TracingServiceEvent::Decoder tse(blob); 628| 34.7k| if (tse.tracing_started()) { ------------------ | Branch (628:7): [True: 30.1k, False: 4.57k] ------------------ 629| 30.1k| context_->metadata_tracker->SetMetadata(metadata::tracing_started_ns, 630| 30.1k| Variadic::Integer(ts)); 631| 30.1k| } 632| 34.7k| if (tse.tracing_disabled()) { ------------------ | Branch (632:7): [True: 6.63k, False: 28.1k] ------------------ 633| 6.63k| context_->metadata_tracker->SetMetadata(metadata::tracing_disabled_ns, 634| 6.63k| Variadic::Integer(ts)); 635| 6.63k| } 636| 34.7k| if (tse.all_data_sources_started()) { ------------------ | Branch (636:7): [True: 30.7k, False: 3.98k] ------------------ 637| 30.7k| context_->metadata_tracker->SetMetadata( 638| 30.7k| metadata::all_data_source_started_ns, Variadic::Integer(ts)); 639| 30.7k| } 640| 34.7k| if (tse.all_data_sources_flushed()) { ------------------ | Branch (640:7): [True: 28.9k, False: 5.82k] ------------------ 641| 28.9k| context_->metadata_tracker->AppendMetadata( 642| 28.9k| metadata::all_data_source_flushed_ns, Variadic::Integer(ts)); 643| 28.9k| context_->sorter->NotifyFlushEvent(); 644| 28.9k| } 645| 34.7k| if (tse.read_tracing_buffers_completed()) { ------------------ | Branch (645:7): [True: 34.4k, False: 308] ------------------ 646| 34.4k| context_->sorter->NotifyReadBufferEvent(); 647| 34.4k| } 648| 34.7k| if (tse.has_slow_starting_data_sources()) { ------------------ | Branch (648:7): [True: 11, False: 34.7k] ------------------ 649| 11| protos::pbzero::TracingServiceEvent::DataSources::Decoder msg( 650| 11| tse.slow_starting_data_sources()); 651| 11| for (auto it = msg.data_source(); it; it++) { ------------------ | Branch (651:39): [True: 0, False: 11] ------------------ 652| 0| protos::pbzero::TracingServiceEvent::DataSources::DataSource::Decoder 653| 0| data_source(*it); 654| 0| std::string formatted = data_source.producer_name().ToStdString() + " " + 655| 0| data_source.data_source_name().ToStdString(); 656| 0| context_->metadata_tracker->AppendMetadata( 657| 0| metadata::slow_start_data_source, 658| 0| Variadic::String( 659| 0| context_->storage->InternString(base::StringView(formatted)))); 660| 0| } 661| 11| } 662| 34.7k| if (tse.has_clone_started()) { ------------------ | Branch (662:7): [True: 3.14k, False: 31.6k] ------------------ 663| 3.14k| context_->storage->SetStats(stats::traced_clone_started_timestamp_ns, ts); 664| 3.14k| } 665| 34.7k| if (tse.has_buffer_cloned()) { ------------------ | Branch (665:7): [True: 29, False: 34.7k] ------------------ 666| 29| context_->storage->SetIndexedStats( 667| 29| stats::traced_buf_clone_done_timestamp_ns, 668| 29| static_cast(tse.buffer_cloned()), ts); 669| 29| } 670| 34.7k| return base::OkStatus(); 671| 34.7k|} _ZN8perfetto15trace_processor16ProtoTraceReader15ParseTraceStatsEN9protozero10ConstBytesE: 673| 24|void ProtoTraceReader::ParseTraceStats(ConstBytes blob) { 674| 24| protos::pbzero::TraceStats::Decoder evt(blob.data, blob.size); 675| 24| auto* storage = context_->storage.get(); 676| 24| storage->SetStats(stats::traced_producers_connected, 677| 24| static_cast(evt.producers_connected())); 678| 24| storage->SetStats(stats::traced_producers_seen, 679| 24| static_cast(evt.producers_seen())); 680| 24| storage->SetStats(stats::traced_data_sources_registered, 681| 24| static_cast(evt.data_sources_registered())); 682| 24| storage->SetStats(stats::traced_data_sources_seen, 683| 24| static_cast(evt.data_sources_seen())); 684| 24| storage->SetStats(stats::traced_tracing_sessions, 685| 24| static_cast(evt.tracing_sessions())); 686| 24| storage->SetStats(stats::traced_total_buffers, 687| 24| static_cast(evt.total_buffers())); 688| 24| storage->SetStats(stats::traced_chunks_discarded, 689| 24| static_cast(evt.chunks_discarded())); 690| 24| storage->SetStats(stats::traced_patches_discarded, 691| 24| static_cast(evt.patches_discarded())); 692| 24| storage->SetStats(stats::traced_flushes_requested, 693| 24| static_cast(evt.flushes_requested())); 694| 24| storage->SetStats(stats::traced_flushes_succeeded, 695| 24| static_cast(evt.flushes_succeeded())); 696| 24| storage->SetStats(stats::traced_flushes_failed, 697| 24| static_cast(evt.flushes_failed())); 698| | 699| 24| if (evt.has_filter_stats()) { ------------------ | Branch (699:7): [True: 2, False: 22] ------------------ 700| 2| protos::pbzero::TraceStats::FilterStats::Decoder fstat(evt.filter_stats()); 701| 2| storage->SetStats(stats::filter_errors, 702| 2| static_cast(fstat.errors())); 703| 2| storage->SetStats(stats::filter_input_bytes, 704| 2| static_cast(fstat.input_bytes())); 705| 2| storage->SetStats(stats::filter_input_packets, 706| 2| static_cast(fstat.input_packets())); 707| 2| storage->SetStats(stats::filter_output_bytes, 708| 2| static_cast(fstat.output_bytes())); 709| 2| storage->SetStats(stats::filter_time_taken_ns, 710| 2| static_cast(fstat.time_taken_ns())); 711| 2| for (auto [i, it] = std::tuple{0, fstat.bytes_discarded_per_buffer()}; it; ------------------ | Branch (711:76): [True: 0, False: 2] ------------------ 712| 2| ++it, ++i) { 713| 0| storage->SetIndexedStats(stats::traced_buf_bytes_filtered_out, i, 714| 0| static_cast(*it)); 715| 0| } 716| 2| } 717| | 718| 24| switch (evt.final_flush_outcome()) { ------------------ | Branch (718:11): [True: 0, False: 24] ------------------ 719| 0| case protos::pbzero::TraceStats::FINAL_FLUSH_SUCCEEDED: ------------------ | Branch (719:5): [True: 0, False: 24] ------------------ 720| 0| storage->IncrementStats(stats::traced_final_flush_succeeded, 1); 721| 0| break; 722| 0| case protos::pbzero::TraceStats::FINAL_FLUSH_FAILED: ------------------ | Branch (722:5): [True: 0, False: 24] ------------------ 723| 0| storage->IncrementStats(stats::traced_final_flush_failed, 1); 724| 0| break; 725| 24| case protos::pbzero::TraceStats::FINAL_FLUSH_UNSPECIFIED: ------------------ | Branch (725:5): [True: 24, False: 0] ------------------ 726| 24| break; 727| 24| } 728| | 729| 24| int buf_num = 0; 730| 83| for (auto it = evt.buffer_stats(); it; ++it, ++buf_num) { ------------------ | Branch (730:38): [True: 59, False: 24] ------------------ 731| 59| protos::pbzero::TraceStats::BufferStats::Decoder buf(*it); 732| 59| storage->SetIndexedStats(stats::traced_buf_buffer_size, buf_num, 733| 59| static_cast(buf.buffer_size())); 734| 59| storage->SetIndexedStats(stats::traced_buf_bytes_written, buf_num, 735| 59| static_cast(buf.bytes_written())); 736| 59| storage->SetIndexedStats(stats::traced_buf_bytes_overwritten, buf_num, 737| 59| static_cast(buf.bytes_overwritten())); 738| 59| storage->SetIndexedStats(stats::traced_buf_bytes_read, buf_num, 739| 59| static_cast(buf.bytes_read())); 740| 59| storage->SetIndexedStats(stats::traced_buf_padding_bytes_written, buf_num, 741| 59| static_cast(buf.padding_bytes_written())); 742| 59| storage->SetIndexedStats(stats::traced_buf_padding_bytes_cleared, buf_num, 743| 59| static_cast(buf.padding_bytes_cleared())); 744| 59| storage->SetIndexedStats(stats::traced_buf_chunks_written, buf_num, 745| 59| static_cast(buf.chunks_written())); 746| 59| storage->SetIndexedStats(stats::traced_buf_chunks_rewritten, buf_num, 747| 59| static_cast(buf.chunks_rewritten())); 748| 59| storage->SetIndexedStats(stats::traced_buf_chunks_overwritten, buf_num, 749| 59| static_cast(buf.chunks_overwritten())); 750| 59| storage->SetIndexedStats(stats::traced_buf_chunks_discarded, buf_num, 751| 59| static_cast(buf.chunks_discarded())); 752| 59| storage->SetIndexedStats(stats::traced_buf_chunks_read, buf_num, 753| 59| static_cast(buf.chunks_read())); 754| 59| storage->SetIndexedStats( 755| 59| stats::traced_buf_chunks_committed_out_of_order, buf_num, 756| 59| static_cast(buf.chunks_committed_out_of_order())); 757| 59| storage->SetIndexedStats(stats::traced_buf_write_wrap_count, buf_num, 758| 59| static_cast(buf.write_wrap_count())); 759| 59| storage->SetIndexedStats(stats::traced_buf_patches_succeeded, buf_num, 760| 59| static_cast(buf.patches_succeeded())); 761| 59| storage->SetIndexedStats(stats::traced_buf_patches_failed, buf_num, 762| 59| static_cast(buf.patches_failed())); 763| 59| storage->SetIndexedStats(stats::traced_buf_readaheads_succeeded, buf_num, 764| 59| static_cast(buf.readaheads_succeeded())); 765| 59| storage->SetIndexedStats(stats::traced_buf_readaheads_failed, buf_num, 766| 59| static_cast(buf.readaheads_failed())); 767| 59| storage->SetIndexedStats(stats::traced_buf_abi_violations, buf_num, 768| 59| static_cast(buf.abi_violations())); 769| 59| storage->SetIndexedStats( 770| 59| stats::traced_buf_trace_writer_packet_loss, buf_num, 771| 59| static_cast(buf.trace_writer_packet_loss())); 772| 59| } 773| | 774| 24| struct BufStats { 775| 24| uint32_t packet_loss = 0; 776| 24| uint32_t incremental_sequences_dropped = 0; 777| 24| }; 778| 24| base::FlatHashMap stats_per_buffer; 779| 24| for (auto it = evt.writer_stats(); it; ++it) { ------------------ | Branch (779:38): [True: 0, False: 24] ------------------ 780| 0| protos::pbzero::TraceStats::WriterStats::Decoder w(*it); 781| 0| auto seq_id = static_cast(w.sequence_id()); 782| 0| if (auto* s = sequence_state_.Find(seq_id)) { ------------------ | Branch (782:15): [True: 0, False: 0] ------------------ 783| 0| auto& stats = stats_per_buffer[static_cast(w.buffer())]; 784| 0| stats.packet_loss += s->previous_packet_dropped_count; 785| 0| stats.incremental_sequences_dropped += 786| 0| s->needs_incremental_state_skipped > 0 && ------------------ | Branch (786:11): [True: 0, False: 0] ------------------ 787| 0| s->needs_incremental_state_skipped == ------------------ | Branch (787:11): [True: 0, False: 0] ------------------ 788| 0| s->needs_incremental_state_total; 789| 0| } 790| 0| } 791| | 792| 24| for (auto it = stats_per_buffer.GetIterator(); it; ++it) { ------------------ | Branch (792:50): [True: 0, False: 24] ------------------ 793| 0| auto& v = it.value(); 794| 0| storage->SetIndexedStats(stats::traced_buf_sequence_packet_loss, it.key(), 795| 0| v.packet_loss); 796| 0| storage->SetIndexedStats(stats::traced_buf_incremental_sequences_dropped, 797| 0| it.key(), v.incremental_sequences_dropped); 798| 0| } 799| 24|} _ZN8perfetto15trace_processor16ProtoTraceReader15NotifyEndOfFileEv: 801| 345|base::Status ProtoTraceReader::NotifyEndOfFile() { 802| 345| received_eof_ = true; 803| 345| for (auto& packet : eof_deferred_packets_) { ------------------ | Branch (803:21): [True: 1, False: 345] ------------------ 804| 1| RETURN_IF_ERROR(TimestampTokenizeAndPushToSorter(std::move(packet))); ------------------ | | 25| 1| do { \ | | 26| 1| base::Status status_macro_internal_status = (expr); \ | | 27| 1| if (!status_macro_internal_status.ok()) \ | | ------------------ | | | Branch (27:9): [True: 0, False: 1] | | ------------------ | | 28| 1| return status_macro_internal_status; \ | | 29| 1| } while (0) | | ------------------ | | | Branch (29:12): [Folded - Ignored] | | ------------------ ------------------ 805| 1| } 806| 345| return base::OkStatus(); 807| 345|} proto_trace_reader.cc:_ZZN8perfetto15trace_processor16ProtoTraceReader5ParseENS0_13TraceBlobViewEENK3$_0clES2_: 72| 3.98M| return tokenizer_.Tokenize(std::move(blob), [this](TraceBlobView packet) { 73| 3.98M| return ParsePacket(std::move(packet)); 74| 3.98M| }); _ZN8perfetto15trace_processor16ProtoTraceReader36GetIncrementalStateForPacketSequenceEj: 107| 7.87M| uint32_t sequence_id) { 108| 7.87M| auto& builder = sequence_state_.Find(sequence_id)->sequence_state_builder; 109| 7.87M| if (!builder) { ------------------ | Branch (109:9): [True: 56.9k, False: 7.82M] ------------------ 110| 56.9k| builder = PacketSequenceStateBuilder(context_); 111| 56.9k| } 112| 7.87M| return &*builder; 113| 7.87M| } _ZN8perfetto15trace_processor19ProtoTraceTokenizerC2Ev: 25| 2.02k|ProtoTraceTokenizer::ProtoTraceTokenizer() = default; _ZN8perfetto15trace_processor19ProtoTraceTokenizer10DecompressENS0_13TraceBlobViewEPS2_: 28| 159| TraceBlobView* output) { 29| 159| PERFETTO_DCHECK(util::IsGzipSupported()); 30| | 31| 159| std::vector data; 32| 159| data.reserve(input.length()); 33| | 34| | // Ensure that the decompressor is able to cope with a new stream of data. 35| 159| decompressor_.Reset(); 36| 159| using ResultCode = util::GzipDecompressor::ResultCode; 37| 159| ResultCode ret = decompressor_.FeedAndExtract( 38| 159| input.data(), input.length(), 39| 159| [&data](const uint8_t* buffer, size_t buffer_len) { 40| 159| data.insert(data.end(), buffer, buffer + buffer_len); 41| 159| }); 42| | 43| 159| if (ret == ResultCode::kError || ret == ResultCode::kNeedsMoreInput) { ------------------ | Branch (43:7): [True: 0, False: 159] | Branch (43:36): [True: 0, False: 159] ------------------ 44| 0| return base::ErrStatus("Failed to decompress (error code: %d)", 45| 0| static_cast(ret)); 46| 0| } 47| | 48| 159| TraceBlob out_blob = TraceBlob::CopyFrom(data.data(), data.size()); 49| 159| *output = TraceBlobView(std::move(out_blob)); 50| 159| return base::OkStatus(); 51| 159|} proto_trace_tokenizer.cc:_ZZN8perfetto15trace_processor19ProtoTraceTokenizer10DecompressENS0_13TraceBlobViewEPS2_ENK3$_0clEPKhm: 39| 159| [&data](const uint8_t* buffer, size_t buffer_len) { 40| 159| data.insert(data.end(), buffer, buffer + buffer_len); 41| 159| }); proto_trace_reader.cc:_ZN8perfetto15trace_processor19ProtoTraceTokenizer8TokenizeIZNS0_16ProtoTraceReader5ParseENS0_13TraceBlobViewEE3$_0EENS_4base6StatusES4_T_: 48| 424| base::Status Tokenize(TraceBlobView tbv, Callback callback) { 49| 424| reader_.PushBack(std::move(tbv)); 50| | 51| 27.0M| for (;;) { 52| 27.0M| size_t start_offset = reader_.start_offset(); 53| 27.0M| size_t avail = reader_.avail(); 54| | 55| | // The header must be at least 2 bytes (1 byte for tag, 1 byte for 56| | // size/varint) and can be at most 20 bytes (10 bytes for tag + 10 bytes 57| | // for size/varint). 58| 27.0M| const size_t kMinHeaderBytes = 2; 59| 27.0M| const size_t kMaxHeaderBytes = 20; 60| 27.0M| std::optional header = reader_.SliceOff( 61| 27.0M| start_offset, 62| 27.0M| std::min(std::max(avail, kMinHeaderBytes), kMaxHeaderBytes)); 63| | 64| | // This means that kMinHeaderBytes was not available. Just wait for the 65| | // next round. 66| 27.0M| if (PERFETTO_UNLIKELY(!header)) { ------------------ | | 24| 27.0M|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 119, False: 27.0M] | | ------------------ ------------------ 67| 119| return base::OkStatus(); 68| 119| } 69| | 70| 27.0M| uint64_t tag; 71| 27.0M| const uint8_t* tag_start = header->data(); 72| 27.0M| const uint8_t* tag_end = protozero::proto_utils::ParseVarInt( 73| 27.0M| tag_start, header->data() + header->size(), &tag); 74| | 75| 27.0M| if (PERFETTO_UNLIKELY(tag_end == tag_start)) { ------------------ | | 24| 27.0M|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 2, False: 27.0M] | | ------------------ ------------------ 76| 2| return header->size() < kMaxHeaderBytes ------------------ | Branch (76:16): [True: 0, False: 2] ------------------ 77| 2| ? base::OkStatus() 78| 2| : base::ErrStatus("Failed to parse tag"); 79| 2| } 80| | 81| 27.0M| if (PERFETTO_UNLIKELY(tag != kTracePacketTag)) { ------------------ | | 24| 27.0M|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 17.6M, False: 9.39M] | | ------------------ ------------------ 82| | // Other field. Skip. 83| 17.6M| auto field_type = static_cast(tag & 0b111); 84| 17.6M| switch (field_type) { 85| 15.9M| case static_cast( ------------------ | Branch (85:11): [True: 15.9M, False: 1.68M] ------------------ 86| 15.9M| protozero::proto_utils::ProtoWireType::kVarInt): { 87| 15.9M| uint64_t varint; 88| 15.9M| const uint8_t* varint_start = tag_end; 89| 15.9M| const uint8_t* varint_end = protozero::proto_utils::ParseVarInt( 90| 15.9M| tag_end, header->data() + header->size(), &varint); 91| 15.9M| if (PERFETTO_UNLIKELY(varint_end == varint_start)) { ------------------ | | 24| 15.9M|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 5, False: 15.9M] | | ------------------ ------------------ 92| 5| return header->size() < kMaxHeaderBytes ------------------ | Branch (92:22): [True: 4, False: 1] ------------------ 93| 5| ? base::OkStatus() 94| 5| : base::ErrStatus("Failed to skip varint"); 95| 5| } 96| 15.9M| PERFETTO_CHECK(reader_.PopFrontBytes( 97| 15.9M| static_cast(varint_end - tag_start))); 98| 15.9M| continue; 99| 15.9M| } 100| 15.9M| case static_cast( ------------------ | Branch (100:11): [True: 398k, False: 17.2M] ------------------ 101| 398k| protozero::proto_utils::ProtoWireType::kLengthDelimited): { 102| 398k| uint64_t varint; 103| 398k| const uint8_t* varint_start = tag_end; 104| 398k| const uint8_t* varint_end = protozero::proto_utils::ParseVarInt( 105| 398k| tag_end, header->data() + header->size(), &varint); 106| 398k| if (PERFETTO_UNLIKELY(varint_end == varint_start)) { ------------------ | | 24| 398k|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 0, False: 398k] | | ------------------ ------------------ 107| 0| return header->size() < kMaxHeaderBytes ------------------ | Branch (107:22): [True: 0, False: 0] ------------------ 108| 0| ? base::OkStatus() 109| 0| : base::ErrStatus("Failed to skip delimited"); 110| 0| } 111| | 112| 398k| size_t size_incl_header = 113| 398k| static_cast(varint_end - tag_start) + varint; 114| 398k| if (size_incl_header > avail) { ------------------ | Branch (114:17): [True: 50, False: 398k] ------------------ 115| 50| return base::OkStatus(); 116| 50| } 117| 398k| PERFETTO_CHECK(reader_.PopFrontBytes(size_incl_header)); 118| 398k| continue; 119| 398k| } 120| 830k| case static_cast( ------------------ | Branch (120:11): [True: 830k, False: 16.8M] ------------------ 121| 830k| protozero::proto_utils::ProtoWireType::kFixed64): { 122| 830k| size_t size_incl_header = 123| 830k| static_cast(tag_end - tag_start) + 8; 124| 830k| if (size_incl_header > avail) { ------------------ | Branch (124:17): [True: 6, False: 830k] ------------------ 125| 6| return base::OkStatus(); 126| 6| } 127| 830k| PERFETTO_CHECK(reader_.PopFrontBytes(size_incl_header)); 128| 830k| continue; 129| 830k| } 130| 830k| case static_cast( ------------------ | Branch (130:11): [True: 458k, False: 17.2M] ------------------ 131| 458k| protozero::proto_utils::ProtoWireType::kFixed32): { 132| 458k| size_t size_incl_header = 133| 458k| static_cast(tag_end - tag_start) + 4; 134| 458k| if (size_incl_header > avail) { ------------------ | Branch (134:17): [True: 0, False: 458k] ------------------ 135| 0| return base::OkStatus(); 136| 0| } 137| 458k| PERFETTO_CHECK(reader_.PopFrontBytes(size_incl_header)); 138| 458k| continue; 139| 458k| } 140| 458k| default: ------------------ | Branch (140:11): [True: 52, False: 17.6M] ------------------ 141| 52| return base::ErrStatus("Unknown field type"); 142| 17.6M| } 143| 17.6M| } 144| | 145| 9.39M| uint64_t field_size; 146| 9.39M| const uint8_t* size_start = tag_end; 147| 9.39M| const uint8_t* size_end = protozero::proto_utils::ParseVarInt( 148| 9.39M| size_start, header->data() + header->size(), &field_size); 149| | 150| | // If we had less than the maximum number of header bytes, it's possible 151| | // that we just need more to actually parse. Otherwise, this is an error. 152| 9.39M| if (PERFETTO_UNLIKELY(size_start == size_end)) { ------------------ | | 24| 9.39M|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 1, False: 9.39M] | | ------------------ ------------------ 153| 1| return header->size() < kMaxHeaderBytes ------------------ | Branch (153:16): [True: 0, False: 1] ------------------ 154| 1| ? base::OkStatus() 155| 1| : base::ErrStatus("Failed to parse TracePacket size"); 156| 1| } 157| | 158| | // Empty packets can legitimately happen if the producer ends up emitting 159| | // no data: just ignore them. 160| 9.39M| auto hdr_size = static_cast(size_end - header->data()); 161| 9.39M| if (PERFETTO_UNLIKELY(field_size == 0)) { ------------------ | | 24| 9.39M|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 5.40M, False: 3.98M] | | ------------------ ------------------ 162| 5.40M| PERFETTO_CHECK(reader_.PopFrontBytes(hdr_size)); 163| 5.40M| continue; 164| 5.40M| } 165| | 166| | // If there's not enough bytes in the reader, then we cannot do anymore. 167| 3.98M| size_t size_incl_header = hdr_size + field_size; 168| 3.98M| if (size_incl_header > avail) { ------------------ | Branch (168:11): [True: 166, False: 3.98M] ------------------ 169| 166| return base::OkStatus(); 170| 166| } 171| | 172| 3.98M| auto packet = reader_.SliceOff(start_offset + hdr_size, field_size); 173| 3.98M| PERFETTO_CHECK(packet); 174| 3.98M| PERFETTO_CHECK(reader_.PopFrontBytes(hdr_size + field_size)); 175| 3.98M| protos::pbzero::TracePacket::Decoder decoder(packet->data(), 176| 3.98M| packet->length()); 177| 3.98M| if (!decoder.has_compressed_packets()) { ------------------ | Branch (177:11): [True: 3.98M, False: 159] ------------------ 178| 3.98M| RETURN_IF_ERROR(callback(std::move(*packet))); ------------------ | | 25| 3.98M| do { \ | | 26| 3.98M| base::Status status_macro_internal_status = (expr); \ | | 27| 3.98M| if (!status_macro_internal_status.ok()) \ | | ------------------ | | | Branch (27:9): [True: 23, False: 3.98M] | | ------------------ | | 28| 3.98M| return status_macro_internal_status; \ | | 29| 3.98M| } while (0) | | ------------------ | | | Branch (29:12): [Folded - Ignored] | | ------------------ ------------------ 179| 3.98M| continue; 180| 3.98M| } 181| | 182| 159| if (!util::IsGzipSupported()) { ------------------ | Branch (182:11): [Folded - Ignored] ------------------ 183| 0| return base::ErrStatus( 184| 0| "Cannot decode compressed packets. Zlib not enabled"); 185| 0| } 186| | 187| 159| protozero::ConstBytes field = decoder.compressed_packets(); 188| 159| TraceBlobView compressed_packets = packet->slice(field.data, field.size); 189| 159| TraceBlobView packets; 190| 159| RETURN_IF_ERROR(Decompress(std::move(compressed_packets), &packets)); ------------------ | | 25| 159| do { \ | | 26| 159| base::Status status_macro_internal_status = (expr); \ | | 27| 159| if (!status_macro_internal_status.ok()) \ | | ------------------ | | | Branch (27:9): [True: 0, False: 159] | | ------------------ | | 28| 159| return status_macro_internal_status; \ | | 29| 159| } while (0) | | ------------------ | | | Branch (29:12): [Folded - Ignored] | | ------------------ ------------------ 191| | 192| 159| const uint8_t* start = packets.data(); 193| 159| const uint8_t* end = packets.data() + packets.length(); 194| 159| const uint8_t* ptr = start; 195| 159| while ((end - ptr) > 2) { ------------------ | Branch (195:14): [True: 0, False: 159] ------------------ 196| 0| const uint8_t* packet_outer = ptr; 197| 0| if (PERFETTO_UNLIKELY(*ptr != kTracePacketTag)) { ------------------ | | 24| 0|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 0, False: 0] | | ------------------ ------------------ 198| 0| return base::ErrStatus("Expected TracePacket tag"); 199| 0| } 200| 0| uint64_t packet_size = 0; 201| 0| ptr = protozero::proto_utils::ParseVarInt(++ptr, end, &packet_size); 202| 0| const uint8_t* packet_start = ptr; 203| 0| ptr += packet_size; 204| 0| if (PERFETTO_UNLIKELY((ptr - packet_outer) < 2 || ptr > end)) { ------------------ | | 24| 0|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 0, False: 0] | | | Branch (24:52): [True: 0, False: 0] | | | Branch (24:52): [True: 0, False: 0] | | ------------------ ------------------ 205| 0| return base::ErrStatus("Invalid packet size"); 206| 0| } 207| 0| TraceBlobView sliced = 208| 0| packets.slice(packet_start, static_cast(packet_size)); 209| 0| RETURN_IF_ERROR(callback(std::move(sliced))); ------------------ | | 25| 0| do { \ | | 26| 0| base::Status status_macro_internal_status = (expr); \ | | 27| 0| if (!status_macro_internal_status.ok()) \ | | ------------------ | | | Branch (27:9): [True: 0, False: 0] | | ------------------ | | 28| 0| return status_macro_internal_status; \ | | 29| 0| } while (0) | | ------------------ | | | Branch (29:12): [Folded - Ignored] | | ------------------ ------------------ 210| 0| } 211| 159| } 212| 424| } _ZN8perfetto15trace_processor16TrackEventModuleC2EPNS0_21TraceProcessorContextE: 40| 2.03k| : track_event_tracker_(new TrackEventTracker(context)), 41| 2.03k| tokenizer_(context, track_event_tracker_.get()), 42| 2.03k| parser_(context, track_event_tracker_.get()) { 43| 2.03k| RegisterForField(TracePacket::kTrackEventRangeOfInterestFieldNumber, context); 44| 2.03k| RegisterForField(TracePacket::kTrackEventFieldNumber, context); 45| 2.03k| RegisterForField(TracePacket::kTrackDescriptorFieldNumber, context); 46| 2.03k| RegisterForField(TracePacket::kThreadDescriptorFieldNumber, context); 47| 2.03k| RegisterForField(TracePacket::kProcessDescriptorFieldNumber, context); 48| | 49| 2.03k| context->descriptor_pool_->AddFromFileDescriptorSet( 50| 2.03k| kTrackEventDescriptor.data(), kTrackEventDescriptor.size()); 51| 2.03k| context->descriptor_pool_->AddFromFileDescriptorSet( 52| 2.03k| kChromeTrackEventDescriptor.data(), kChromeTrackEventDescriptor.size()); 53| 2.03k| context->descriptor_pool_->AddFromFileDescriptorSet( 54| 2.03k| kAndroidTrackEventDescriptor.data(), kAndroidTrackEventDescriptor.size()); 55| 2.03k|} _ZN8perfetto15trace_processor16TrackEventModuleD2Ev: 57| 2.03k|TrackEventModule::~TrackEventModule() = default; _ZN8perfetto15trace_processor16TrackEventModule14TokenizePacketERKNS_6protos6pbzero19TracePacket_DecoderEPNS0_13TraceBlobViewElNS0_6RefPtrINS0_29PacketSequenceStateGenerationEEEj: 64| 1.29M| uint32_t field_id) { 65| 1.29M| switch (field_id) { ------------------ | Branch (65:11): [True: 21.4k, False: 1.27M] ------------------ 66| 0| case TracePacket::kTrackEventRangeOfInterestFieldNumber: ------------------ | Branch (66:5): [True: 0, False: 1.29M] ------------------ 67| 0| return tokenizer_.TokenizeRangeOfInterestPacket(std::move(state), decoder, 68| 0| packet_timestamp); 69| 140k| case TracePacket::kTrackDescriptorFieldNumber: ------------------ | Branch (69:5): [True: 140k, False: 1.15M] ------------------ 70| 140k| return tokenizer_.TokenizeTrackDescriptorPacket(std::move(state), decoder, 71| 140k| packet_timestamp); 72| 1.13M| case TracePacket::kTrackEventFieldNumber: ------------------ | Branch (72:5): [True: 1.13M, False: 162k] ------------------ 73| 1.13M| return tokenizer_.TokenizeTrackEventPacket(std::move(state), decoder, 74| 1.13M| packet, packet_timestamp); 75| 649| case TracePacket::kThreadDescriptorFieldNumber: ------------------ | Branch (75:5): [True: 649, False: 1.29M] ------------------ 76| | // TODO(eseckler): Remove once Chrome has switched to TrackDescriptors. 77| 649| return tokenizer_.TokenizeThreadDescriptorPacket(std::move(state), 78| 649| decoder); 79| 1.29M| } 80| 21.4k| return ModuleResult::Ignored(); 81| 1.29M|} _ZN8perfetto15trace_processor16TrackEventModule20ParseTracePacketDataERKNS_6protos6pbzero19TracePacket_DecoderElRKNS0_15TracePacketDataEj: 86| 128k| uint32_t field_id) { 87| 128k| switch (field_id) { ------------------ | Branch (87:11): [True: 0, False: 128k] ------------------ 88| 107k| case TracePacket::kTrackDescriptorFieldNumber: ------------------ | Branch (88:5): [True: 107k, False: 20.4k] ------------------ 89| 107k| parser_.ParseTrackDescriptor(ts, decoder.track_descriptor(), 90| 107k| decoder.trusted_packet_sequence_id()); 91| 107k| break; 92| 20.4k| case TracePacket::kProcessDescriptorFieldNumber: ------------------ | Branch (92:5): [True: 20.4k, False: 107k] ------------------ 93| | // TODO(eseckler): Remove once Chrome has switched to TrackDescriptors. 94| 20.4k| parser_.ParseProcessDescriptor(ts, decoder.process_descriptor()); 95| 20.4k| break; 96| 23| case TracePacket::kThreadDescriptorFieldNumber: ------------------ | Branch (96:5): [True: 23, False: 128k] ------------------ 97| | // TODO(eseckler): Remove once Chrome has switched to TrackDescriptors. 98| 23| parser_.ParseThreadDescriptor(decoder.thread_descriptor()); 99| 23| break; 100| 0| case TracePacket::kTrackEventFieldNumber: ------------------ | Branch (100:5): [True: 0, False: 128k] ------------------ 101| 0| PERFETTO_DFATAL("Wrong TracePacket number"); 102| 128k| } 103| 128k|} _ZN8perfetto15trace_processor16TrackEventModule25OnIncrementalStateClearedEj: 105| 10.1k|void TrackEventModule::OnIncrementalStateCleared(uint32_t packet_sequence_id) { 106| 10.1k| track_event_tracker_->OnIncrementalStateCleared(packet_sequence_id); 107| 10.1k|} _ZN8perfetto15trace_processor16TrackEventModule23OnFirstPacketOnSequenceEj: 109| 1|void TrackEventModule::OnFirstPacketOnSequence(uint32_t packet_sequence_id) { 110| 1| track_event_tracker_->OnFirstPacketOnSequence(packet_sequence_id); 111| 1|} _ZN8perfetto15trace_processor16TrackEventModule19ParseTrackEventDataERKNS_6protos6pbzero19TracePacket_DecoderElRKNS0_14TrackEventDataE: 115| 877k| const TrackEventData& data) { 116| 877k| parser_.ParseTrackEvent(ts, &data, decoder.track_event(), 117| 877k| decoder.trusted_packet_sequence_id()); 118| 877k|} _ZN8perfetto15trace_processor16TrackEventModule15NotifyEndOfFileEv: 120| 345|void TrackEventModule::NotifyEndOfFile() { 121| 345| parser_.NotifyEndOfFile(); 122| 345|} _ZN8perfetto15trace_processor16TrackEventParserC2EPNS0_21TraceProcessorContextEPNS0_17TrackEventTrackerE: 1379| 2.03k| : args_parser_(*context->descriptor_pool_), 1380| 2.03k| context_(context), 1381| 2.03k| track_event_tracker_(track_event_tracker), 1382| | counter_name_thread_time_id_( 1383| 2.03k| context->storage->InternString("thread_time")), 1384| | counter_name_thread_instruction_count_id_( 1385| 2.03k| context->storage->InternString("thread_instruction_count")), 1386| | task_file_name_args_key_id_( 1387| 2.03k| context->storage->InternString("task.posted_from.file_name")), 1388| | task_function_name_args_key_id_( 1389| 2.03k| context->storage->InternString("task.posted_from.function_name")), 1390| | task_line_number_args_key_id_( 1391| 2.03k| context->storage->InternString("task.posted_from.line_number")), 1392| | log_message_body_key_id_( 1393| 2.03k| context->storage->InternString("track_event.log_message")), 1394| | log_message_source_location_function_name_key_id_( 1395| 2.03k| context->storage->InternString( 1396| 2.03k| "track_event.log_message.function_name")), 1397| | log_message_source_location_file_name_key_id_( 1398| 2.03k| context->storage->InternString("track_event.log_message.file_name")), 1399| | log_message_source_location_line_number_key_id_( 1400| 2.03k| context->storage->InternString( 1401| 2.03k| "track_event.log_message.line_number")), 1402| | log_message_priority_id_( 1403| 2.03k| context->storage->InternString("track_event.priority")), 1404| | source_location_function_name_key_id_( 1405| 2.03k| context->storage->InternString("source.function_name")), 1406| | source_location_file_name_key_id_( 1407| 2.03k| context->storage->InternString("source.file_name")), 1408| | source_location_line_number_key_id_( 1409| 2.03k| context->storage->InternString("source.line_number")), 1410| | raw_legacy_event_id_( 1411| 2.03k| context->storage->InternString("track_event.legacy_event")), 1412| | legacy_event_passthrough_utid_id_( 1413| 2.03k| context->storage->InternString("legacy_event.passthrough_utid")), 1414| | legacy_event_category_key_id_( 1415| 2.03k| context->storage->InternString("legacy_event.category")), 1416| | legacy_event_name_key_id_( 1417| 2.03k| context->storage->InternString("legacy_event.name")), 1418| | legacy_event_phase_key_id_( 1419| 2.03k| context->storage->InternString("legacy_event.phase")), 1420| | legacy_event_duration_ns_key_id_( 1421| 2.03k| context->storage->InternString("legacy_event.duration_ns")), 1422| | legacy_event_thread_timestamp_ns_key_id_( 1423| 2.03k| context->storage->InternString("legacy_event.thread_timestamp_ns")), 1424| | legacy_event_thread_duration_ns_key_id_( 1425| 2.03k| context->storage->InternString("legacy_event.thread_duration_ns")), 1426| | legacy_event_thread_instruction_count_key_id_( 1427| 2.03k| context->storage->InternString( 1428| 2.03k| "legacy_event.thread_instruction_count")), 1429| | legacy_event_thread_instruction_delta_key_id_( 1430| 2.03k| context->storage->InternString( 1431| 2.03k| "legacy_event.thread_instruction_delta")), 1432| | legacy_event_use_async_tts_key_id_( 1433| 2.03k| context->storage->InternString("legacy_event.use_async_tts")), 1434| | legacy_event_unscoped_id_key_id_( 1435| 2.03k| context->storage->InternString("legacy_event.unscoped_id")), 1436| | legacy_event_global_id_key_id_( 1437| 2.03k| context->storage->InternString("legacy_event.global_id")), 1438| | legacy_event_local_id_key_id_( 1439| 2.03k| context->storage->InternString("legacy_event.local_id")), 1440| | legacy_event_id_scope_key_id_( 1441| 2.03k| context->storage->InternString("legacy_event.id_scope")), 1442| | legacy_event_bind_id_key_id_( 1443| 2.03k| context->storage->InternString("legacy_event.bind_id")), 1444| | legacy_event_bind_to_enclosing_key_id_( 1445| 2.03k| context->storage->InternString("legacy_event.bind_to_enclosing")), 1446| | legacy_event_flow_direction_key_id_( 1447| 2.03k| context->storage->InternString("legacy_event.flow_direction")), 1448| | histogram_name_key_id_( 1449| 2.03k| context->storage->InternString("chrome_histogram_sample.name")), 1450| 2.03k| flow_direction_value_in_id_(context->storage->InternString("in")), 1451| 2.03k| flow_direction_value_out_id_(context->storage->InternString("out")), 1452| 2.03k| flow_direction_value_inout_id_(context->storage->InternString("inout")), 1453| | chrome_legacy_ipc_class_args_key_id_( 1454| 2.03k| context->storage->InternString("legacy_ipc.class")), 1455| | chrome_legacy_ipc_line_args_key_id_( 1456| 2.03k| context->storage->InternString("legacy_ipc.line")), 1457| | chrome_host_app_package_name_id_( 1458| 2.03k| context->storage->InternString("chrome.host_app_package_name")), 1459| | chrome_crash_trace_id_name_id_( 1460| 2.03k| context->storage->InternString("chrome.crash_trace_id")), 1461| | chrome_process_label_flat_key_id_( 1462| 2.03k| context->storage->InternString("chrome.process_label")), 1463| | chrome_process_type_id_( 1464| 2.03k| context_->storage->InternString("chrome.process_type")), 1465| 2.03k| event_category_key_id_(context_->storage->InternString("event.category")), 1466| 2.03k| event_name_key_id_(context_->storage->InternString("event.name")), 1467| 2.03k| chrome_string_lookup_(context->storage.get()), 1468| 2.03k| active_chrome_processes_tracker_(context) { 1469| 2.03k| args_parser_.AddParsingOverrideForField( 1470| 2.03k| "chrome_mojo_event_info.mojo_interface_method_iid", 1471| 2.03k| [](const protozero::Field& field, 1472| 2.03k| util::ProtoToArgsParser::Delegate& delegate) { 1473| 2.03k| return MaybeParseUnsymbolizedSourceLocation( 1474| 2.03k| "chrome_mojo_event_info.mojo_interface_method.native_symbol", field, 1475| 2.03k| delegate); 1476| 2.03k| }); 1477| | // Switch |source_location_iid| into its interned data variant. 1478| 2.03k| args_parser_.AddParsingOverrideForField( 1479| 2.03k| "begin_impl_frame_args.current_args.source_location_iid", 1480| 2.03k| [](const protozero::Field& field, 1481| 2.03k| util::ProtoToArgsParser::Delegate& delegate) { 1482| 2.03k| return MaybeParseSourceLocation("begin_impl_frame_args.current_args", 1483| 2.03k| field, delegate); 1484| 2.03k| }); 1485| 2.03k| args_parser_.AddParsingOverrideForField( 1486| 2.03k| "begin_impl_frame_args.last_args.source_location_iid", 1487| 2.03k| [](const protozero::Field& field, 1488| 2.03k| util::ProtoToArgsParser::Delegate& delegate) { 1489| 2.03k| return MaybeParseSourceLocation("begin_impl_frame_args.last_args", 1490| 2.03k| field, delegate); 1491| 2.03k| }); 1492| 2.03k| args_parser_.AddParsingOverrideForField( 1493| 2.03k| "begin_frame_observer_state.last_begin_frame_args.source_location_iid", 1494| 2.03k| [](const protozero::Field& field, 1495| 2.03k| util::ProtoToArgsParser::Delegate& delegate) { 1496| 2.03k| return MaybeParseSourceLocation( 1497| 2.03k| "begin_frame_observer_state.last_begin_frame_args", field, 1498| 2.03k| delegate); 1499| 2.03k| }); 1500| 2.03k| args_parser_.AddParsingOverrideForField( 1501| 2.03k| "chrome_memory_pressure_notification.creation_location_iid", 1502| 2.03k| [](const protozero::Field& field, 1503| 2.03k| util::ProtoToArgsParser::Delegate& delegate) { 1504| 2.03k| return MaybeParseSourceLocation("chrome_memory_pressure_notification", 1505| 2.03k| field, delegate); 1506| 2.03k| }); 1507| | 1508| | // Parse DebugAnnotations. 1509| 2.03k| args_parser_.AddParsingOverrideForType( 1510| 2.03k| ".perfetto.protos.DebugAnnotation", 1511| 2.03k| [&](util::ProtoToArgsParser::ScopedNestedKeyContext& key, 1512| 2.03k| const protozero::ConstBytes& data, 1513| 2.03k| util::ProtoToArgsParser::Delegate& delegate) { 1514| | // Do not add "debug_annotations" to the final key. 1515| 2.03k| key.RemoveFieldSuffix(); 1516| 2.03k| util::DebugAnnotationParser annotation_parser(args_parser_); 1517| 2.03k| return annotation_parser.Parse(data, delegate); 1518| 2.03k| }); 1519| | 1520| 2.03k| args_parser_.AddParsingOverrideForField( 1521| 2.03k| "active_processes.pid", [&](const protozero::Field& field, 1522| 2.03k| util::ProtoToArgsParser::Delegate& delegate) { 1523| 2.03k| AddActiveProcess(delegate.packet_timestamp(), field.as_int32()); 1524| | // Fallthrough so that the parser adds pid as a regular arg. 1525| 2.03k| return std::nullopt; 1526| 2.03k| }); 1527| | 1528| 34.6k| for (uint16_t index : kReflectFields) { ------------------ | Branch (1528:23): [True: 34.6k, False: 2.03k] ------------------ 1529| 34.6k| reflect_fields_.push_back(index); 1530| 34.6k| } 1531| 2.03k|} _ZN8perfetto15trace_processor16TrackEventParser20ParseTrackDescriptorElN9protozero10ConstBytesEj: 1536| 107k| uint32_t packet_sequence_id) { 1537| 107k| protos::pbzero::TrackDescriptor::Decoder decoder(track_descriptor); 1538| | 1539| | // Ensure that the track and its parents are resolved. This may start a new 1540| | // process and/or thread (i.e. new upid/utid). 1541| 107k| std::optional track_id = track_event_tracker_->GetDescriptorTrack( 1542| 107k| decoder.uuid(), kNullStringId, packet_sequence_id); 1543| 107k| if (!track_id) { ------------------ | Branch (1543:7): [True: 25.6k, False: 82.3k] ------------------ 1544| 25.6k| context_->storage->IncrementStats(stats::track_event_parser_errors); 1545| 25.6k| return; 1546| 25.6k| } 1547| | 1548| 82.3k| if (decoder.has_thread()) { ------------------ | Branch (1548:7): [True: 5.20k, False: 77.1k] ------------------ 1549| 5.20k| UniqueTid utid = ParseThreadDescriptor(decoder.thread()); 1550| 5.20k| if (decoder.has_chrome_thread()) { ------------------ | Branch (1550:9): [True: 48, False: 5.16k] ------------------ 1551| 48| ParseChromeThreadDescriptor(utid, decoder.chrome_thread()); 1552| 48| } 1553| 77.1k| } else if (decoder.has_process()) { ------------------ | Branch (1553:14): [True: 36.5k, False: 40.6k] ------------------ 1554| 36.5k| UniquePid upid = 1555| 36.5k| ParseProcessDescriptor(packet_timestamp, decoder.process()); 1556| 36.5k| if (decoder.has_chrome_process()) { ------------------ | Branch (1556:9): [True: 35.2k, False: 1.22k] ------------------ 1557| 35.2k| ParseChromeProcessDescriptor(upid, decoder.chrome_process()); 1558| 35.2k| } 1559| 36.5k| } 1560| | 1561| | // Override the name with the most recent name seen (after sorting by ts). 1562| 82.3k| ::protozero::ConstChars name = {nullptr, 0}; 1563| 82.3k| if (decoder.has_name()) { ------------------ | Branch (1563:7): [True: 45.2k, False: 37.1k] ------------------ 1564| 45.2k| name = decoder.name(); 1565| 45.2k| } else if (decoder.has_static_name()) { ------------------ | Branch (1565:14): [True: 112, False: 36.9k] ------------------ 1566| 112| name = decoder.static_name(); 1567| 36.9k| } else if (decoder.has_atrace_name()) { ------------------ | Branch (1567:14): [True: 633, False: 36.3k] ------------------ 1568| 633| name = decoder.atrace_name(); 1569| 633| } 1570| 82.3k| if (name.data) { ------------------ | Branch (1570:7): [True: 45.9k, False: 36.3k] ------------------ 1571| 45.9k| auto* tracks = context_->storage->mutable_track_table(); 1572| 45.9k| const StringId raw_name_id = context_->storage->InternString(name); 1573| 45.9k| const StringId name_id = 1574| 45.9k| context_->process_track_translation_table->TranslateName(raw_name_id); 1575| 45.9k| tracks->FindById(*track_id)->set_name(name_id); 1576| 45.9k| } 1577| 82.3k|} _ZN8perfetto15trace_processor16TrackEventParser22ParseProcessDescriptorElN9protozero10ConstBytesE: 1581| 56.9k| protozero::ConstBytes process_descriptor) { 1582| 56.9k| protos::pbzero::ProcessDescriptor::Decoder decoder(process_descriptor); 1583| 56.9k| UniquePid upid = context_->process_tracker->GetOrCreateProcess( 1584| 56.9k| static_cast(decoder.pid())); 1585| 56.9k| active_chrome_processes_tracker_.AddProcessDescriptor(packet_timestamp, upid); 1586| 56.9k| if (decoder.has_process_name() && decoder.process_name().size) { ------------------ | Branch (1586:7): [True: 496, False: 56.4k] | Branch (1586:7): [True: 0, False: 56.9k] | Branch (1586:37): [True: 0, False: 496] ------------------ 1587| | // Don't override system-provided names. 1588| 0| context_->process_tracker->SetProcessNameIfUnset( 1589| 0| upid, context_->storage->InternString(decoder.process_name())); 1590| 0| } 1591| 56.9k| if (decoder.has_start_timestamp_ns() && decoder.start_timestamp_ns() > 0) { ------------------ | Branch (1591:7): [True: 33.8k, False: 23.0k] | Branch (1591:43): [True: 33.4k, False: 361] ------------------ 1592| 33.4k| context_->process_tracker->SetStartTsIfUnset(upid, 1593| 33.4k| decoder.start_timestamp_ns()); 1594| 33.4k| } 1595| | // TODO(skyostil): Remove parsing for legacy chrome_process_type field. 1596| 56.9k| if (decoder.has_chrome_process_type()) { ------------------ | Branch (1596:7): [True: 20.4k, False: 36.5k] ------------------ 1597| 20.4k| StringId name_id = 1598| 20.4k| chrome_string_lookup_.GetProcessName(decoder.chrome_process_type()); 1599| | // Don't override system-provided names. 1600| 20.4k| context_->process_tracker->SetProcessNameIfUnset(upid, name_id); 1601| 20.4k| } 1602| 56.9k| int label_index = 0; 1603| 121k| for (auto it = decoder.process_labels(); it; it++) { ------------------ | Branch (1603:44): [True: 64.9k, False: 56.9k] ------------------ 1604| 64.9k| StringId label_id = context_->storage->InternString(*it); 1605| 64.9k| std::string key = "chrome.process_label["; 1606| 64.9k| key.append(std::to_string(label_index++)); 1607| 64.9k| key.append("]"); 1608| 64.9k| context_->process_tracker->AddArgsTo(upid).AddArg( 1609| 64.9k| chrome_process_label_flat_key_id_, 1610| 64.9k| context_->storage->InternString(base::StringView(key)), 1611| 64.9k| Variadic::String(label_id)); 1612| 64.9k| } 1613| 56.9k| return upid; 1614| 56.9k|} _ZN8perfetto15trace_processor16TrackEventParser28ParseChromeProcessDescriptorEjN9protozero10ConstBytesE: 1618| 35.2k| protozero::ConstBytes chrome_process_descriptor) { 1619| 35.2k| protos::pbzero::ChromeProcessDescriptor::Decoder decoder( 1620| 35.2k| chrome_process_descriptor); 1621| | 1622| 35.2k| StringId name_id = 1623| 35.2k| chrome_string_lookup_.GetProcessName(decoder.process_type()); 1624| | // Don't override system-provided names. 1625| 35.2k| context_->process_tracker->SetProcessNameIfUnset(upid, name_id); 1626| | 1627| 35.2k| ArgsTracker::BoundInserter process_args = 1628| 35.2k| context_->process_tracker->AddArgsTo(upid); 1629| | // For identifying Chrome processes in system traces. 1630| 35.2k| process_args.AddArg(chrome_process_type_id_, Variadic::String(name_id)); 1631| 35.2k| if (decoder.has_host_app_package_name()) { ------------------ | Branch (1631:7): [True: 0, False: 35.2k] ------------------ 1632| 0| process_args.AddArg(chrome_host_app_package_name_id_, 1633| 0| Variadic::String(context_->storage->InternString( 1634| 0| decoder.host_app_package_name()))); 1635| 0| } 1636| 35.2k| if (decoder.has_crash_trace_id()) { ------------------ | Branch (1636:7): [True: 0, False: 35.2k] ------------------ 1637| 0| process_args.AddArg(chrome_crash_trace_id_name_id_, 1638| 0| Variadic::UnsignedInteger(decoder.crash_trace_id())); 1639| 0| } 1640| 35.2k|} _ZN8perfetto15trace_processor16TrackEventParser21ParseThreadDescriptorEN9protozero10ConstBytesE: 1643| 5.23k| protozero::ConstBytes thread_descriptor) { 1644| 5.23k| protos::pbzero::ThreadDescriptor::Decoder decoder(thread_descriptor); 1645| 5.23k| UniqueTid utid = context_->process_tracker->UpdateThread( 1646| 5.23k| static_cast(decoder.tid()), 1647| 5.23k| static_cast(decoder.pid())); 1648| 5.23k| StringId name_id = kNullStringId; 1649| 5.23k| if (decoder.has_thread_name() && decoder.thread_name().size) { ------------------ | Branch (1649:7): [True: 526, False: 4.70k] | Branch (1649:7): [True: 35, False: 5.19k] | Branch (1649:36): [True: 35, False: 491] ------------------ 1650| 35| name_id = context_->storage->InternString(decoder.thread_name()); 1651| 5.19k| } else if (decoder.has_chrome_thread_type()) { ------------------ | Branch (1651:14): [True: 126, False: 5.07k] ------------------ 1652| | // TODO(skyostil): Remove parsing for legacy chrome_thread_type field. 1653| 126| name_id = chrome_string_lookup_.GetThreadName(decoder.chrome_thread_type()); 1654| 126| } 1655| 5.23k| context_->process_tracker->UpdateThreadNameByUtid( 1656| 5.23k| utid, name_id, ThreadNamePriority::kTrackDescriptor); 1657| 5.23k| return utid; 1658| 5.23k|} _ZN8perfetto15trace_processor16TrackEventParser27ParseChromeThreadDescriptorEjN9protozero10ConstBytesE: 1662| 48| protozero::ConstBytes chrome_thread_descriptor) { 1663| 48| protos::pbzero::ChromeThreadDescriptor::Decoder decoder( 1664| 48| chrome_thread_descriptor); 1665| 48| if (!decoder.has_thread_type()) ------------------ | Branch (1665:7): [True: 48, False: 0] ------------------ 1666| 48| return; 1667| | 1668| 0| StringId name_id = chrome_string_lookup_.GetThreadName(decoder.thread_type()); 1669| 0| context_->process_tracker->UpdateThreadNameByUtid( 1670| 0| utid, name_id, ThreadNamePriority::kTrackDescriptorThreadType); 1671| 0|} _ZN8perfetto15trace_processor16TrackEventParser15ParseTrackEventElPKNS0_14TrackEventDataEN9protozero10ConstBytesEj: 1676| 877k| uint32_t packet_sequence_id) { 1677| 877k| const auto range_of_interest_start_us = 1678| 877k| track_event_tracker_->range_of_interest_start_us(); 1679| 877k| if (context_->config.drop_track_event_data_before == ------------------ | Branch (1679:7): [True: 0, False: 877k] ------------------ 1680| 877k| DropTrackEventDataBefore::kTrackEventRangeOfInterest && 1681| 877k| range_of_interest_start_us && ts < *range_of_interest_start_us * 1000) { ------------------ | Branch (1681:7): [True: 0, False: 0] | Branch (1681:37): [True: 0, False: 0] ------------------ 1682| | // The event is outside of the range of interest, and dropping is enabled. 1683| | // So we drop the event. 1684| 0| context_->storage->IncrementStats( 1685| 0| stats::track_event_dropped_packets_outside_of_range_of_interest); 1686| 0| return; 1687| 0| } 1688| 877k| base::Status status = 1689| 877k| EventImporter(this, ts, event_data, blob, packet_sequence_id).Import(); 1690| 877k| if (!status.ok()) { ------------------ | Branch (1690:7): [True: 65.6k, False: 811k] ------------------ 1691| 65.6k| context_->storage->IncrementStats(stats::track_event_parser_errors); 1692| 65.6k| PERFETTO_DLOG("ParseTrackEvent error: %s", status.c_message()); 1693| 65.6k| } 1694| 877k|} _ZN8perfetto15trace_processor16TrackEventParser16AddActiveProcessEli: 1696| 402k|void TrackEventParser::AddActiveProcess(int64_t packet_timestamp, int32_t pid) { 1697| 402k| UniquePid upid = 1698| 402k| context_->process_tracker->GetOrCreateProcess(static_cast(pid)); 1699| 402k| active_chrome_processes_tracker_.AddActiveProcessMetadata(packet_timestamp, 1700| 402k| upid); 1701| 402k|} _ZN8perfetto15trace_processor16TrackEventParser15NotifyEndOfFileEv: 1703| 345|void TrackEventParser::NotifyEndOfFile() { 1704| 345| active_chrome_processes_tracker_.NotifyEndOfFile(); 1705| 345|} _ZN8perfetto15trace_processor16TrackEventParser13EventImporterC2EPS1_lPKNS0_14TrackEventDataEN9protozero10ConstBytesEj: 187| 877k| : context_(parser->context_), 188| 877k| track_event_tracker_(parser->track_event_tracker_), 189| 877k| storage_(context_->storage.get()), 190| 877k| parser_(parser), 191| 877k| args_translation_table_(context_->args_translation_table.get()), 192| 877k| ts_(ts), 193| 877k| event_data_(event_data), 194| 877k| sequence_state_(event_data->trace_packet_data.sequence_state.get()), 195| 877k| blob_(blob), 196| 877k| event_(blob_), 197| 877k| legacy_event_(event_.legacy_event()), 198| 877k| defaults_(event_data->trace_packet_data.sequence_state 199| 877k| ->GetTrackEventDefaults()), 200| 877k| thread_timestamp_(event_data->thread_timestamp), 201| 877k| thread_instruction_count_(event_data->thread_instruction_count), 202| 877k| packet_sequence_id_(packet_sequence_id) {} _ZN8perfetto15trace_processor16TrackEventParser13EventImporter6ImportEv: 204| 877k| base::Status Import() { 205| | // TODO(eseckler): This legacy event field will eventually be replaced by 206| | // fields in TrackEvent itself. 207| 877k| if (PERFETTO_UNLIKELY(!event_.type() && !legacy_event_.has_phase())) ------------------ | | 24| 914k|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 36.9k, False: 840k] | | | Branch (24:52): [True: 36.9k, False: 840k] | | | Branch (24:52): [True: 36.9k, False: 0] | | ------------------ ------------------ 208| 36.9k| return base::ErrStatus("TrackEvent without type or phase"); 209| | 210| 840k| category_id_ = ParseTrackEventCategory(); 211| 840k| name_id_ = ParseTrackEventName(); 212| | 213| 840k| if (context_->content_analyzer) { ------------------ | Branch (213:9): [True: 0, False: 840k] ------------------ 214| 0| PacketAnalyzer::SampleAnnotation annotation; 215| 0| annotation.emplace_back(parser_->event_category_key_id_, category_id_); 216| 0| annotation.emplace_back(parser_->event_name_key_id_, name_id_); 217| 0| PacketAnalyzer::Get(context_)->ProcessPacket( 218| 0| event_data_->trace_packet_data.packet, annotation); 219| 0| } 220| | 221| 840k| RETURN_IF_ERROR(ParseTrackAssociation()); ------------------ | | 25| 840k| do { \ | | 26| 840k| base::Status status_macro_internal_status = (expr); \ | | 27| 840k| if (!status_macro_internal_status.ok()) \ | | ------------------ | | | Branch (27:9): [True: 8.44k, False: 831k] | | ------------------ | | 28| 840k| return status_macro_internal_status; \ | | 29| 840k| } while (0) | | ------------------ | | | Branch (29:12): [Folded - Ignored] | | ------------------ ------------------ 222| | 223| | // If we have legacy thread time / instruction count fields, also parse them 224| | // into the counters tables. 225| 831k| ParseLegacyThreadTimeAndInstructionsAsCounters(); 226| | 227| | // Parse extra counter values before parsing the actual event. This way, we 228| | // can update the slice's thread time / instruction count fields based on 229| | // these counter values and also parse them as slice attributes / arguments. 230| 831k| ParseExtraCounterValues(); 231| | 232| | // Non-legacy counters are treated differently. Legacy counters do not have 233| | // a track_id_ and should instead go through the switch below. 234| 831k| if (event_.type() == TrackEvent::TYPE_COUNTER) { ------------------ | Branch (234:9): [True: 0, False: 831k] ------------------ 235| 0| return ParseCounterEvent(); 236| 0| } 237| | 238| | // TODO(eseckler): Replace phase with type and remove handling of 239| | // legacy_event_.phase() once it is no longer used by producers. 240| 831k| char phase = static_cast(ParsePhaseOrType()); 241| | 242| 831k| switch (phase) { 243| 6| case 'B': // TRACE_EVENT_PHASE_BEGIN. ------------------ | Branch (243:7): [True: 6, False: 831k] ------------------ 244| 6| return ParseThreadBeginEvent(); 245| 10| case 'E': // TRACE_EVENT_PHASE_END. ------------------ | Branch (245:7): [True: 10, False: 831k] ------------------ 246| 10| return ParseThreadEndEvent(); 247| 1.02k| case 'X': // TRACE_EVENT_PHASE_COMPLETE. ------------------ | Branch (247:7): [True: 1.02k, False: 830k] ------------------ 248| 1.02k| return ParseThreadCompleteEvent(); 249| 64.8k| case 's': // TRACE_EVENT_PHASE_FLOW_BEGIN. ------------------ | Branch (249:7): [True: 64.8k, False: 767k] ------------------ 250| 64.8k| case 't': // TRACE_EVENT_PHASE_FLOW_STEP. ------------------ | Branch (250:7): [True: 1, False: 831k] ------------------ 251| 66.3k| case 'f': // TRACE_EVENT_PHASE_FLOW_END. ------------------ | Branch (251:7): [True: 1.45k, False: 830k] ------------------ 252| 66.3k| return ParseFlowEventV1(phase); 253| 4.15k| case 'i': ------------------ | Branch (253:7): [True: 4.15k, False: 827k] ------------------ 254| 4.32k| case 'I': // TRACE_EVENT_PHASE_INSTANT. ------------------ | Branch (254:7): [True: 161, False: 831k] ------------------ 255| 4.32k| case 'R': // TRACE_EVENT_PHASE_MARK. ------------------ | Branch (255:7): [True: 4, False: 831k] ------------------ 256| 4.32k| return ParseThreadInstantEvent(phase); 257| 121k| case 'b': // TRACE_EVENT_PHASE_NESTABLE_ASYNC_BEGIN ------------------ | Branch (257:7): [True: 121k, False: 710k] ------------------ 258| 121k| case 'S': ------------------ | Branch (258:7): [True: 2, False: 831k] ------------------ 259| 121k| return ParseAsyncBeginEvent(phase); 260| 3.08k| case 'e': // TRACE_EVENT_PHASE_NESTABLE_ASYNC_END ------------------ | Branch (260:7): [True: 3.08k, False: 828k] ------------------ 261| 3.10k| case 'F': ------------------ | Branch (261:7): [True: 18, False: 831k] ------------------ 262| 3.10k| return ParseAsyncEndEvent(); 263| 616k| case 'n': // TRACE_EVENT_PHASE_NESTABLE_ASYNC_INSTANT ------------------ | Branch (263:7): [True: 616k, False: 215k] ------------------ 264| 616k| return ParseAsyncInstantEvent(); 265| 1| case 'T': ------------------ | Branch (265:7): [True: 1, False: 831k] ------------------ 266| 4| case 'p': ------------------ | Branch (266:7): [True: 3, False: 831k] ------------------ 267| 4| return ParseAsyncStepEvent(phase); 268| 1| case 'M': // TRACE_EVENT_PHASE_METADATA (process and thread names). ------------------ | Branch (268:7): [True: 1, False: 831k] ------------------ 269| 1| return ParseMetadataEvent(); 270| 19.6k| default: ------------------ | Branch (270:7): [True: 19.6k, False: 812k] ------------------ 271| | // Other events are proxied via the raw table for JSON export. 272| 19.6k| return ParseLegacyEventAsRawEvent(); 273| 831k| } 274| 831k| } _ZN8perfetto15trace_processor16TrackEventParser13EventImporter23ParseTrackEventCategoryEv: 277| 840k| StringId ParseTrackEventCategory() { 278| 840k| StringId category_id = kNullStringId; 279| | 280| 840k| std::vector category_iids; 281| 861k| for (auto it = event_.category_iids(); it; ++it) { ------------------ | Branch (281:44): [True: 20.7k, False: 840k] ------------------ 282| 20.7k| category_iids.push_back(*it); 283| 20.7k| } 284| 840k| std::vector category_strings; 285| 842k| for (auto it = event_.categories(); it; ++it) { ------------------ | Branch (285:41): [True: 1.96k, False: 840k] ------------------ 286| 1.96k| category_strings.push_back(*it); 287| 1.96k| } 288| | 289| | // If there's a single category, we can avoid building a concatenated 290| | // string. 291| 840k| if (PERFETTO_LIKELY(category_iids.size() == 1 && ------------------ | | 23| 849k|#define PERFETTO_LIKELY(...) __builtin_expect(!!(__VA_ARGS__), 1) | | ------------------ | | | Branch (23:30): [True: 7.61k, False: 832k] | | | Branch (23:50): [True: 9.13k, False: 831k] | | | Branch (23:50): [True: 7.61k, False: 1.52k] | | ------------------ ------------------ 292| 840k| category_strings.empty())) { 293| 7.61k| auto* decoder = sequence_state_->LookupInternedMessage< 294| 7.61k| protos::pbzero::InternedData::kEventCategoriesFieldNumber, 295| 7.61k| protos::pbzero::EventCategory>(category_iids[0]); 296| 7.61k| if (decoder) { ------------------ | Branch (296:11): [True: 693, False: 6.91k] ------------------ 297| 693| category_id = storage_->InternString(decoder->name()); 298| 6.91k| } else { 299| 6.91k| char buffer[32]; 300| 6.91k| base::StringWriter writer(buffer, sizeof(buffer)); 301| 6.91k| writer.AppendLiteral("unknown("); 302| 6.91k| writer.AppendUnsignedInt(category_iids[0]); 303| 6.91k| writer.AppendChar(')'); 304| 6.91k| category_id = storage_->InternString(writer.GetStringView()); 305| 6.91k| } 306| 832k| } else if (category_iids.empty() && category_strings.size() == 1) { ------------------ | Branch (306:16): [True: 826k, False: 6.65k] | Branch (306:41): [True: 158, False: 825k] ------------------ 307| 158| category_id = storage_->InternString(category_strings[0]); 308| 832k| } else if (category_iids.size() + category_strings.size() > 1) { ------------------ | Branch (308:16): [True: 6.75k, False: 825k] ------------------ 309| | // We concatenate the category strings together since we currently only 310| | // support a single "cat" column. 311| | // TODO(eseckler): Support multi-category events in the table schema. 312| 6.75k| std::string categories; 313| 13.1k| for (uint64_t iid : category_iids) { ------------------ | Branch (313:25): [True: 13.1k, False: 6.75k] ------------------ 314| 13.1k| auto* decoder = sequence_state_->LookupInternedMessage< 315| 13.1k| protos::pbzero::InternedData::kEventCategoriesFieldNumber, 316| 13.1k| protos::pbzero::EventCategory>(iid); 317| 13.1k| if (!decoder) ------------------ | Branch (317:13): [True: 9.81k, False: 3.34k] ------------------ 318| 9.81k| continue; 319| 3.34k| base::StringView name = decoder->name(); 320| 3.34k| if (!categories.empty()) ------------------ | Branch (320:13): [True: 0, False: 3.34k] ------------------ 321| 0| categories.append(","); 322| 3.34k| categories.append(name.data(), name.size()); 323| 3.34k| } 324| 6.75k| for (const protozero::ConstChars& cat : category_strings) { ------------------ | Branch (324:45): [True: 1.80k, False: 6.75k] ------------------ 325| 1.80k| if (!categories.empty()) ------------------ | Branch (325:13): [True: 0, False: 1.80k] ------------------ 326| 0| categories.append(","); 327| 1.80k| categories.append(cat.data, cat.size); 328| 1.80k| } 329| 6.75k| if (!categories.empty()) ------------------ | Branch (329:11): [True: 0, False: 6.75k] ------------------ 330| 0| category_id = storage_->InternString(base::StringView(categories)); 331| 6.75k| } 332| | 333| 840k| return category_id; 334| 840k| } _ZN8perfetto15trace_processor16TrackEventParser13EventImporter19ParseTrackEventNameEv: 336| 840k| StringId ParseTrackEventName() { 337| 840k| uint64_t name_iid = event_.name_iid(); 338| 840k| if (!name_iid) ------------------ | Branch (338:9): [True: 829k, False: 11.1k] ------------------ 339| 829k| name_iid = legacy_event_.name_iid(); 340| | 341| 840k| if (PERFETTO_LIKELY(name_iid)) { ------------------ | | 23| 840k|#define PERFETTO_LIKELY(...) __builtin_expect(!!(__VA_ARGS__), 1) | | ------------------ | | | Branch (23:30): [True: 13.4k, False: 826k] | | ------------------ ------------------ 342| 13.4k| auto* decoder = sequence_state_->LookupInternedMessage< 343| 13.4k| protos::pbzero::InternedData::kEventNamesFieldNumber, 344| 13.4k| protos::pbzero::EventName>(name_iid); 345| 13.4k| if (decoder) ------------------ | Branch (345:11): [True: 0, False: 13.4k] ------------------ 346| 0| return storage_->InternString(decoder->name()); 347| 826k| } else if (event_.has_name()) { ------------------ | Branch (347:16): [True: 0, False: 826k] ------------------ 348| 0| return storage_->InternString(event_.name()); 349| 0| } 350| | 351| 840k| return kNullStringId; 352| 840k| } _ZN8perfetto15trace_processor16TrackEventParser13EventImporter21ParseTrackAssociationEv: 354| 840k| base::Status ParseTrackAssociation() { 355| 840k| TrackTracker* track_tracker = context_->track_tracker.get(); 356| 840k| ProcessTracker* procs = context_->process_tracker.get(); 357| | 358| | // Consider track_uuid from the packet and TrackEventDefaults, fall back to 359| | // the default descriptor track (uuid 0). 360| 840k| track_uuid_ = event_.has_track_uuid() ------------------ | Branch (360:19): [True: 1.94k, False: 838k] ------------------ 361| 840k| ? event_.track_uuid() 362| 840k| : (defaults_ && defaults_->has_track_uuid() ------------------ | Branch (362:26): [True: 42.4k, False: 795k] | Branch (362:39): [True: 42.4k, False: 0] ------------------ 363| 838k| ? defaults_->track_uuid() 364| 838k| : 0u); 365| | 366| | // Determine track from track_uuid specified in either TrackEvent or 367| | // TrackEventDefaults. If a non-default track is not set, we either: 368| | // a) fall back to the track specified by the sequence's (or event's) pid 369| | // + tid (only in case of legacy tracks/events, i.e. events that don't 370| | // specify an explicit track uuid or use legacy event phases instead of 371| | // TrackEvent types), or 372| | // b) a default track. 373| 840k| if (track_uuid_) { ------------------ | Branch (373:9): [True: 44.4k, False: 795k] ------------------ 374| 44.4k| std::optional opt_track_id = 375| 44.4k| track_event_tracker_->GetDescriptorTrack(track_uuid_, name_id_, 376| 44.4k| packet_sequence_id_); 377| 44.4k| if (!opt_track_id) { ------------------ | Branch (377:11): [True: 499, False: 43.9k] ------------------ 378| 499| TrackEventTracker::DescriptorTrackReservation r; 379| 499| r.parent_uuid = 0; 380| 499| r.name = name_id_; 381| 499| track_event_tracker_->ReserveDescriptorTrack(track_uuid_, r); 382| 499| opt_track_id = track_event_tracker_->GetDescriptorTrack( 383| 499| track_uuid_, name_id_, packet_sequence_id_); 384| | 385| 499| if (!opt_track_id) { ------------------ | Branch (385:13): [True: 410, False: 89] ------------------ 386| 410| return base::ErrStatus( 387| 410| "track_event_parser: unable to find track matching UUID %" PRIu64, 388| 410| track_uuid_); 389| 410| } 390| 499| } 391| 44.0k| track_id_ = *opt_track_id; 392| | 393| 44.0k| auto rr = storage_->mutable_track_table()->FindById(track_id_); 394| 44.0k| if (rr && rr->utid()) { ------------------ | Branch (394:11): [True: 44.0k, False: 0] | Branch (394:11): [True: 817, False: 43.1k] | Branch (394:17): [True: 817, False: 43.1k] ------------------ 395| 817| utid_ = rr->utid(); 396| 817| upid_ = storage_->thread_table()[*utid_].upid(); 397| 43.1k| } else if (rr && rr->upid()) { ------------------ | Branch (397:18): [True: 43.1k, False: 0] | Branch (397:18): [True: 41.2k, False: 1.93k] | Branch (397:24): [True: 41.2k, False: 1.93k] ------------------ 398| 41.2k| upid_ = rr->upid(); 399| 41.2k| if (sequence_state_->pid_and_tid_valid()) { ------------------ | Branch (399:13): [True: 0, False: 41.2k] ------------------ 400| 0| auto pid = static_cast(sequence_state_->pid()); 401| 0| auto tid = static_cast(sequence_state_->tid()); 402| 0| UniqueTid utid_candidate = procs->UpdateThread(tid, pid); 403| 0| if (storage_->thread_table()[utid_candidate].upid() == upid_) { ------------------ | Branch (403:15): [True: 0, False: 0] ------------------ 404| 0| legacy_passthrough_utid_ = utid_candidate; 405| 0| } 406| 0| } 407| 41.2k| } else { 408| 1.93k| if (rr) { ------------------ | Branch (408:13): [True: 1.93k, False: 0] ------------------ 409| 1.93k| StringPool::Id id = rr->name(); 410| 1.93k| if (id.is_null()) { ------------------ | Branch (410:15): [True: 1.78k, False: 149] ------------------ 411| 1.78k| rr->set_name(name_id_); 412| 1.78k| } 413| 1.93k| } 414| 1.93k| if (sequence_state_->pid_and_tid_valid()) { ------------------ | Branch (414:13): [True: 0, False: 1.93k] ------------------ 415| 0| auto pid = static_cast(sequence_state_->pid()); 416| 0| auto tid = static_cast(sequence_state_->tid()); 417| 0| legacy_passthrough_utid_ = procs->UpdateThread(tid, pid); 418| 0| } 419| 1.93k| } 420| 795k| } else { 421| 795k| bool pid_tid_state_valid = sequence_state_->pid_and_tid_valid(); 422| | 423| | // We have a 0-value |track_uuid|. Nevertheless, we should only fall back 424| | // if we have either no |track_uuid| specified at all or |track_uuid| was 425| | // set explicitly to 0 (e.g. to override a default track_uuid) and we have 426| | // a legacy phase. Events with real phases should use |track_uuid| to 427| | // specify a different track (or use the pid/tid_override fields). 428| 795k| bool fallback_to_legacy_pid_tid_tracks = 429| 795k| (!event_.has_track_uuid() || !event_.has_type()) && ------------------ | Branch (429:12): [True: 795k, False: 0] | Branch (429:40): [True: 0, False: 0] ------------------ 430| 795k| pid_tid_state_valid; ------------------ | Branch (430:11): [True: 24, False: 795k] ------------------ 431| | 432| | // Always allow fallback if we have a process override. 433| 795k| fallback_to_legacy_pid_tid_tracks |= legacy_event_.has_pid_override(); 434| | 435| | // A thread override requires a valid pid. 436| 795k| fallback_to_legacy_pid_tid_tracks |= 437| 795k| legacy_event_.has_tid_override() && pid_tid_state_valid; ------------------ | Branch (437:11): [True: 0, False: 795k] | Branch (437:47): [True: 0, False: 0] ------------------ 438| | 439| 795k| if (fallback_to_legacy_pid_tid_tracks) { ------------------ | Branch (439:11): [True: 105k, False: 690k] ------------------ 440| 105k| auto pid = static_cast(sequence_state_->pid()); 441| 105k| auto tid = static_cast(sequence_state_->tid()); 442| 105k| if (legacy_event_.has_pid_override()) { ------------------ | Branch (442:13): [True: 105k, False: 24] ------------------ 443| 105k| pid = static_cast(legacy_event_.pid_override()); 444| 105k| tid = static_cast(-1); 445| 105k| } 446| 105k| if (legacy_event_.has_tid_override()) ------------------ | Branch (446:13): [True: 0, False: 105k] ------------------ 447| 0| tid = static_cast(legacy_event_.tid_override()); 448| | 449| 105k| utid_ = procs->UpdateThread(tid, pid); 450| 105k| upid_ = storage_->thread_table()[*utid_].upid(); 451| 105k| track_id_ = track_tracker->InternThreadTrack(*utid_); 452| 690k| } else { 453| 690k| track_id_ = *track_event_tracker_->GetDescriptorTrack( 454| 690k| TrackEventTracker::kDefaultDescriptorTrackUuid); 455| 690k| } 456| 795k| } 457| | 458| 839k| if (!legacy_event_.has_phase()) ------------------ | Branch (458:9): [True: 631k, False: 208k] ------------------ 459| 631k| return base::OkStatus(); 460| | 461| | // Legacy phases may imply a different track than the one specified by 462| | // the fallback (or default track uuid) above. 463| 208k| switch (legacy_event_.phase()) { 464| 124k| case 'b': ------------------ | Branch (464:7): [True: 124k, False: 84.0k] ------------------ 465| 124k| case 'e': ------------------ | Branch (465:7): [True: 621, False: 207k] ------------------ 466| 124k| case 'n': ------------------ | Branch (466:7): [True: 0, False: 208k] ------------------ 467| 124k| case 'S': ------------------ | Branch (467:7): [True: 58, False: 208k] ------------------ 468| 124k| case 'T': ------------------ | Branch (468:7): [True: 0, False: 208k] ------------------ 469| 124k| case 'p': ------------------ | Branch (469:7): [True: 119, False: 208k] ------------------ 470| 124k| case 'F': { ------------------ | Branch (470:7): [True: 16, False: 208k] ------------------ 471| | // Intern tracks for legacy async events based on legacy event ids. 472| 124k| int64_t source_id = 0; 473| 124k| bool source_id_is_process_scoped = false; 474| 124k| if (legacy_event_.has_unscoped_id()) { ------------------ | Branch (474:13): [True: 3.49k, False: 121k] ------------------ 475| 3.49k| source_id = static_cast(legacy_event_.unscoped_id()); 476| 121k| } else if (legacy_event_.has_global_id()) { ------------------ | Branch (476:20): [True: 6.94k, False: 114k] ------------------ 477| 6.94k| source_id = static_cast(legacy_event_.global_id()); 478| 114k| } else if (legacy_event_.has_local_id()) { ------------------ | Branch (478:20): [True: 108k, False: 6.19k] ------------------ 479| 108k| if (!upid_) { ------------------ | Branch (479:15): [True: 492, False: 107k] ------------------ 480| 492| return base::ErrStatus( 481| 492| "TrackEvent with local_id without process association"); 482| 492| } 483| | 484| 107k| source_id = static_cast(legacy_event_.local_id()); 485| 107k| source_id_is_process_scoped = true; 486| 107k| } else { 487| 6.19k| return base::ErrStatus("Async LegacyEvent without ID"); 488| 6.19k| } 489| | 490| | // Catapult treats nestable async events of different categories with 491| | // the same ID as separate tracks. We replicate the same behavior 492| | // here. For legacy async events, it uses different tracks based on 493| | // event names. 494| 118k| const bool legacy_async = 495| 118k| legacy_event_.phase() == 'S' || legacy_event_.phase() == 'T' || ------------------ | Branch (495:13): [True: 0, False: 118k] | Branch (495:45): [True: 0, False: 118k] ------------------ 496| 118k| legacy_event_.phase() == 'p' || legacy_event_.phase() == 'F'; ------------------ | Branch (496:13): [True: 0, False: 118k] | Branch (496:45): [True: 16, False: 118k] ------------------ 497| 118k| StringId id_scope = legacy_async ? name_id_ : category_id_; ------------------ | Branch (497:29): [True: 16, False: 118k] ------------------ 498| 118k| if (legacy_event_.has_id_scope()) { ------------------ | Branch (498:13): [True: 0, False: 118k] ------------------ 499| 0| std::string concat = storage_->GetString(category_id_).ToStdString() + 500| 0| ":" + legacy_event_.id_scope().ToStdString(); 501| 0| id_scope = storage_->InternString(base::StringView(concat)); 502| 0| } 503| | 504| 118k| track_id_ = context_->track_tracker->InternLegacyAsyncTrack( 505| 118k| name_id_, upid_.value_or(0), source_id, source_id_is_process_scoped, 506| 118k| id_scope); 507| 118k| legacy_passthrough_utid_ = utid_; 508| 118k| break; 509| 124k| } 510| 3.12k| case 'i': ------------------ | Branch (510:7): [True: 3.12k, False: 205k] ------------------ 511| 3.66k| case 'I': { ------------------ | Branch (511:7): [True: 534, False: 207k] ------------------ 512| | // Intern tracks for global or process-scoped legacy instant events. 513| 3.66k| switch (legacy_event_.instant_event_scope()) { ------------------ | Branch (513:17): [True: 33, False: 3.63k] ------------------ 514| 822| case LegacyEvent::SCOPE_UNSPECIFIED: ------------------ | Branch (514:11): [True: 822, False: 2.84k] ------------------ 515| 3.63k| case LegacyEvent::SCOPE_THREAD: ------------------ | Branch (515:11): [True: 2.80k, False: 855] ------------------ 516| | // Thread-scoped legacy instant events already have the right 517| | // track based on the tid/pid of the sequence. 518| 3.63k| if (!utid_) { ------------------ | Branch (518:17): [True: 1.35k, False: 2.27k] ------------------ 519| 1.35k| return base::ErrStatus( 520| 1.35k| "Thread-scoped instant event without thread association"); 521| 1.35k| } 522| 2.27k| break; 523| 2.27k| case LegacyEvent::SCOPE_GLOBAL: ------------------ | Branch (523:11): [True: 0, False: 3.66k] ------------------ 524| 0| track_id_ = context_->track_tracker->InternTrack( 525| 0| tracks::kLegacyGlobalInstantsBlueprint, tracks::Dimensions(), 526| 0| tracks::BlueprintName(), 527| 0| [this](ArgsTracker::BoundInserter& inserter) { 528| 0| inserter.AddArg( 529| 0| context_->storage->InternString("source"), 530| 0| Variadic::String( 531| 0| context_->storage->InternString("chrome"))); 532| 0| }); 533| 0| legacy_passthrough_utid_ = utid_; 534| 0| utid_ = std::nullopt; 535| 0| break; 536| 0| case LegacyEvent::SCOPE_PROCESS: ------------------ | Branch (536:11): [True: 0, False: 3.66k] ------------------ 537| 0| if (!upid_) { ------------------ | Branch (537:17): [True: 0, False: 0] ------------------ 538| 0| return base::ErrStatus( 539| 0| "Process-scoped instant event without process association"); 540| 0| } 541| | 542| 0| track_id_ = context_->track_tracker->InternTrack( 543| 0| tracks::kChromeProcessInstantBlueprint, 544| 0| tracks::Dimensions(*upid_), tracks::BlueprintName(), 545| 0| [this](ArgsTracker::BoundInserter& inserter) { 546| 0| inserter.AddArg( 547| 0| context_->storage->InternString("source"), 548| 0| Variadic::String( 549| 0| context_->storage->InternString("chrome"))); 550| 0| }); 551| 0| legacy_passthrough_utid_ = utid_; 552| 0| utid_ = std::nullopt; 553| 0| break; 554| 3.66k| } 555| 2.31k| break; 556| 3.66k| } 557| 79.5k| default: ------------------ | Branch (557:7): [True: 79.5k, False: 128k] ------------------ 558| 79.5k| break; 559| 208k| } 560| | 561| 200k| return base::OkStatus(); 562| 208k| } _ZN8perfetto15trace_processor16TrackEventParser13EventImporter46ParseLegacyThreadTimeAndInstructionsAsCountersEv: 594| 831k| void ParseLegacyThreadTimeAndInstructionsAsCounters() { 595| 831k| if (!utid_) ------------------ | Branch (595:9): [True: 730k, False: 101k] ------------------ 596| 730k| return; 597| | // When these fields are set, we don't expect TrackDescriptor-based counters 598| | // for thread time or instruction count for this thread in the trace, so we 599| | // intern separate counter tracks based on name + utid. Note that we cannot 600| | // import the counter values from the end of a complete event, because the 601| | // EventTracker expects counters to be pushed in order of their timestamps. 602| | // One more reason to switch to split begin/end events. 603| 101k| if (thread_timestamp_) { ------------------ | Branch (603:9): [True: 24, False: 101k] ------------------ 604| 24| static constexpr auto kBlueprint = tracks::CounterBlueprint( 605| 24| "thread_time", tracks::UnknownUnitBlueprint(), 606| 24| tracks::DimensionBlueprints(tracks::kThreadDimensionBlueprint), 607| 24| tracks::DynamicNameBlueprint()); 608| 24| TrackId track_id = context_->track_tracker->InternTrack( 609| 24| kBlueprint, tracks::Dimensions(*utid_), 610| 24| tracks::DynamicName(parser_->counter_name_thread_time_id_)); 611| 24| context_->event_tracker->PushCounter( 612| 24| ts_, static_cast(*thread_timestamp_), track_id); 613| 24| } 614| 101k| if (thread_instruction_count_) { ------------------ | Branch (614:9): [True: 24, False: 101k] ------------------ 615| 24| static constexpr auto kBlueprint = tracks::CounterBlueprint( 616| 24| "thread_instructions", tracks::UnknownUnitBlueprint(), 617| 24| tracks::DimensionBlueprints(tracks::kThreadDimensionBlueprint), 618| 24| tracks::DynamicNameBlueprint()); 619| 24| TrackId track_id = context_->track_tracker->InternTrack( 620| 24| kBlueprint, tracks::Dimensions(*utid_), 621| 24| tracks::DynamicName( 622| 24| parser_->counter_name_thread_instruction_count_id_)); 623| 24| context_->event_tracker->PushCounter( 624| 24| ts_, static_cast(*thread_instruction_count_), track_id); 625| 24| } 626| 101k| } _ZN8perfetto15trace_processor16TrackEventParser13EventImporter23ParseExtraCounterValuesEv: 628| 831k| void ParseExtraCounterValues() { 629| 831k| if (!event_.has_extra_counter_values() && ------------------ | Branch (629:9): [True: 831k, False: 0] ------------------ 630| 831k| !event_.has_extra_double_counter_values()) { ------------------ | Branch (630:9): [True: 831k, False: 0] ------------------ 631| 831k| return; 632| 831k| } 633| | 634| | // Add integer extra counter values. 635| 0| size_t index = 0; 636| 0| protozero::RepeatedFieldIterator track_uuid_it; 637| 0| if (event_.has_extra_counter_track_uuids()) { ------------------ | Branch (637:9): [True: 0, False: 0] ------------------ 638| 0| track_uuid_it = event_.extra_counter_track_uuids(); 639| 0| } else if (defaults_ && defaults_->has_extra_counter_track_uuids()) { ------------------ | Branch (639:16): [True: 0, False: 0] | Branch (639:29): [True: 0, False: 0] ------------------ 640| 0| track_uuid_it = defaults_->extra_counter_track_uuids(); 641| 0| } 642| 0| for (auto value_it = event_.extra_counter_values(); value_it; ------------------ | Branch (642:57): [True: 0, False: 0] ------------------ 643| 0| ++value_it, ++track_uuid_it, ++index) { 644| 0| AddExtraCounterValue(track_uuid_it, index); 645| 0| } 646| | 647| | // Add double extra counter values. 648| 0| track_uuid_it = protozero::RepeatedFieldIterator(); 649| 0| if (event_.has_extra_double_counter_track_uuids()) { ------------------ | Branch (649:9): [True: 0, False: 0] ------------------ 650| 0| track_uuid_it = event_.extra_double_counter_track_uuids(); 651| 0| } else if (defaults_ && defaults_->has_extra_double_counter_track_uuids()) { ------------------ | Branch (651:16): [True: 0, False: 0] | Branch (651:29): [True: 0, False: 0] ------------------ 652| 0| track_uuid_it = defaults_->extra_double_counter_track_uuids(); 653| 0| } 654| 0| for (auto value_it = event_.extra_double_counter_values(); value_it; ------------------ | Branch (654:64): [True: 0, False: 0] ------------------ 655| 0| ++value_it, ++track_uuid_it, ++index) { 656| 0| AddExtraCounterValue(track_uuid_it, index); 657| 0| } 658| 0| } _ZN8perfetto15trace_processor16TrackEventParser13EventImporter19ParseTrackEventArgsEPNS0_11ArgsTracker13BoundInserterE: 1146| 739k| void ParseTrackEventArgs(BoundInserter* inserter) { 1147| 739k| auto log_errors = [this](const base::Status& status) { 1148| 739k| if (status.ok()) 1149| 739k| return; 1150| | // Log error but continue parsing the other args. 1151| 739k| storage_->IncrementStats(stats::track_event_parser_errors); 1152| 739k| PERFETTO_DLOG("ParseTrackEventArgs error: %s", status.c_message()); 1153| 739k| }; 1154| | 1155| 739k| if (event_.has_source_location_iid()) { ------------------ | Branch (1155:9): [True: 146, False: 739k] ------------------ 1156| 146| log_errors(AddSourceLocationArgs(event_.source_location_iid(), inserter)); 1157| 146| } 1158| | 1159| 739k| if (event_.has_task_execution()) { ------------------ | Branch (1159:9): [True: 22.0k, False: 717k] ------------------ 1160| 22.0k| log_errors(ParseTaskExecutionArgs(event_.task_execution(), inserter)); 1161| 22.0k| } 1162| 739k| if (event_.has_log_message()) { ------------------ | Branch (1162:9): [True: 0, False: 739k] ------------------ 1163| 0| log_errors(ParseLogMessage(event_.log_message(), inserter)); 1164| 0| } 1165| 739k| if (event_.has_chrome_histogram_sample()) { ------------------ | Branch (1165:9): [True: 526k, False: 213k] ------------------ 1166| 526k| log_errors( 1167| 526k| ParseHistogramName(event_.chrome_histogram_sample(), inserter)); 1168| 526k| } 1169| 739k| if (event_.has_chrome_active_processes()) { ------------------ | Branch (1169:9): [True: 26.3k, False: 713k] ------------------ 1170| 26.3k| protos::pbzero::ChromeActiveProcesses::Decoder message( 1171| 26.3k| event_.chrome_active_processes()); 1172| 423k| for (auto it = message.pid(); it; ++it) { ------------------ | Branch (1172:37): [True: 397k, False: 26.3k] ------------------ 1173| 397k| parser_->AddActiveProcess(ts_, *it); 1174| 397k| } 1175| 26.3k| } 1176| | 1177| 739k| ArgsParser args_writer(ts_, *inserter, *storage_, sequence_state_, 1178| 739k| /*support_json=*/true); 1179| 739k| int unknown_extensions = 0; 1180| 739k| log_errors(parser_->args_parser_.ParseMessage( 1181| 739k| blob_, ".perfetto.protos.TrackEvent", &parser_->reflect_fields_, 1182| 739k| args_writer, &unknown_extensions)); 1183| 739k| if (unknown_extensions > 0) { ------------------ | Branch (1183:9): [True: 635k, False: 103k] ------------------ 1184| 635k| context_->storage->IncrementStats(stats::unknown_extension_fields, 1185| 635k| unknown_extensions); 1186| 635k| } 1187| | 1188| 739k| { 1189| 739k| auto key = parser_->args_parser_.EnterDictionary("debug"); 1190| 739k| util::DebugAnnotationParser parser(parser_->args_parser_); 1191| 1.89M| for (auto it = event_.debug_annotations(); it; ++it) { ------------------ | Branch (1191:50): [True: 1.15M, False: 739k] ------------------ 1192| 1.15M| log_errors(parser.Parse(*it, args_writer)); 1193| 1.15M| } 1194| 739k| } 1195| | 1196| 739k| if (legacy_passthrough_utid_) { ------------------ | Branch (1196:9): [True: 84.3k, False: 655k] ------------------ 1197| 84.3k| inserter->AddArg(parser_->legacy_event_passthrough_utid_id_, 1198| 84.3k| Variadic::UnsignedInteger(*legacy_passthrough_utid_), 1199| 84.3k| ArgsTracker::UpdatePolicy::kSkipIfExists); 1200| 84.3k| } 1201| 739k| } _ZZN8perfetto15trace_processor16TrackEventParser13EventImporter19ParseTrackEventArgsEPNS0_11ArgsTracker13BoundInserterEENKUlRKNS_4base6StatusEE_clES9_: 1147| 2.44M| auto log_errors = [this](const base::Status& status) { 1148| 2.44M| if (status.ok()) ------------------ | Branch (1148:11): [True: 1.24M, False: 1.20M] ------------------ 1149| 1.24M| return; 1150| | // Log error but continue parsing the other args. 1151| 1.20M| storage_->IncrementStats(stats::track_event_parser_errors); 1152| 1.20M| PERFETTO_DLOG("ParseTrackEventArgs error: %s", status.c_message()); 1153| 1.20M| }; _ZN8perfetto15trace_processor16TrackEventParser13EventImporter21AddSourceLocationArgsEmPNS0_11ArgsTracker13BoundInserterE: 1234| 146| base::Status AddSourceLocationArgs(uint64_t iid, BoundInserter* inserter) { 1235| 146| if (!iid) ------------------ | Branch (1235:9): [True: 0, False: 146] ------------------ 1236| 0| return base::ErrStatus("SourceLocation with invalid iid"); 1237| | 1238| 146| auto* decoder = sequence_state_->LookupInternedMessage< 1239| 146| protos::pbzero::InternedData::kSourceLocationsFieldNumber, 1240| 146| protos::pbzero::SourceLocation>(iid); 1241| 146| if (!decoder) ------------------ | Branch (1241:9): [True: 146, False: 0] ------------------ 1242| 146| return base::ErrStatus("SourceLocation with invalid iid"); 1243| | 1244| 0| StringId file_name_id = kNullStringId; 1245| 0| StringId function_name_id = kNullStringId; 1246| 0| uint32_t line_number = 0; 1247| | 1248| 0| std::string file_name = NormalizePathSeparators(decoder->file_name()); 1249| 0| file_name_id = storage_->InternString(base::StringView(file_name)); 1250| 0| function_name_id = storage_->InternString(decoder->function_name()); 1251| 0| line_number = decoder->line_number(); 1252| | 1253| 0| inserter->AddArg(parser_->source_location_file_name_key_id_, 1254| 0| Variadic::String(file_name_id)); 1255| 0| inserter->AddArg(parser_->source_location_function_name_key_id_, 1256| 0| Variadic::String(function_name_id)); 1257| 0| inserter->AddArg(parser_->source_location_line_number_key_id_, 1258| 0| Variadic::UnsignedInteger(line_number)); 1259| 0| return base::OkStatus(); 1260| 146| } _ZN8perfetto15trace_processor16TrackEventParser13EventImporter22ParseTaskExecutionArgsEN9protozero10ConstBytesEPNS0_11ArgsTracker13BoundInserterE: 1204| 22.0k| BoundInserter* inserter) { 1205| 22.0k| protos::pbzero::TaskExecution::Decoder task(task_execution); 1206| 22.0k| uint64_t iid = task.posted_from_iid(); 1207| 22.0k| if (!iid) ------------------ | Branch (1207:9): [True: 22.0k, False: 0] ------------------ 1208| 22.0k| return base::ErrStatus("TaskExecution with invalid posted_from_iid"); 1209| | 1210| 0| auto* decoder = sequence_state_->LookupInternedMessage< 1211| 0| protos::pbzero::InternedData::kSourceLocationsFieldNumber, 1212| 0| protos::pbzero::SourceLocation>(iid); 1213| 0| if (!decoder) ------------------ | Branch (1213:9): [True: 0, False: 0] ------------------ 1214| 0| return base::ErrStatus("TaskExecution with invalid posted_from_iid"); 1215| | 1216| 0| StringId file_name_id = kNullStringId; 1217| 0| StringId function_name_id = kNullStringId; 1218| 0| uint32_t line_number = 0; 1219| | 1220| 0| std::string file_name = NormalizePathSeparators(decoder->file_name()); 1221| 0| file_name_id = storage_->InternString(base::StringView(file_name)); 1222| 0| function_name_id = storage_->InternString(decoder->function_name()); 1223| 0| line_number = decoder->line_number(); 1224| | 1225| 0| inserter->AddArg(parser_->task_file_name_args_key_id_, 1226| 0| Variadic::String(file_name_id)); 1227| 0| inserter->AddArg(parser_->task_function_name_args_key_id_, 1228| 0| Variadic::String(function_name_id)); 1229| 0| inserter->AddArg(parser_->task_line_number_args_key_id_, 1230| 0| Variadic::UnsignedInteger(line_number)); 1231| 0| return base::OkStatus(); 1232| 0| } _ZN8perfetto15trace_processor16TrackEventParser13EventImporter18ParseHistogramNameEN9protozero10ConstBytesEPNS0_11ArgsTracker13BoundInserterE: 1323| 526k| base::Status ParseHistogramName(ConstBytes blob, BoundInserter* inserter) { 1324| 526k| protos::pbzero::ChromeHistogramSample::Decoder sample(blob); 1325| 526k| if (!sample.has_name_iid()) ------------------ | Branch (1325:9): [True: 482k, False: 43.5k] ------------------ 1326| 482k| return base::OkStatus(); 1327| | 1328| 43.5k| if (sample.has_name()) { ------------------ | Branch (1328:9): [True: 438, False: 43.1k] ------------------ 1329| 438| return base::ErrStatus( 1330| 438| "name is already set for ChromeHistogramSample: only one of name and " 1331| 438| "name_iid can be set."); 1332| 438| } 1333| | 1334| 43.1k| auto* decoder = sequence_state_->LookupInternedMessage< 1335| 43.1k| protos::pbzero::InternedData::kHistogramNamesFieldNumber, 1336| 43.1k| protos::pbzero::HistogramName>(sample.name_iid()); 1337| 43.1k| if (!decoder) ------------------ | Branch (1337:9): [True: 43.1k, False: 0] ------------------ 1338| 43.1k| return base::ErrStatus("HistogramName with invalid name_iid"); 1339| | 1340| 0| inserter->AddArg(parser_->histogram_name_key_id_, 1341| 0| Variadic::String(storage_->InternString(decoder->name()))); 1342| 0| return base::OkStatus(); 1343| 43.1k| } _ZN8perfetto15trace_processor16TrackEventParser13EventImporter16ParsePhaseOrTypeEv: 564| 831k| int32_t ParsePhaseOrType() { 565| 831k| if (legacy_event_.has_phase()) ------------------ | Branch (565:9): [True: 200k, False: 631k] ------------------ 566| 200k| return legacy_event_.phase(); 567| | 568| 631k| switch (event_.type()) { 569| 3.57k| case TrackEvent::TYPE_SLICE_BEGIN: ------------------ | Branch (569:7): [True: 3.57k, False: 628k] ------------------ 570| 3.57k| return utid_ ? 'B' : 'b'; ------------------ | Branch (570:16): [True: 0, False: 3.57k] ------------------ 571| 2.46k| case TrackEvent::TYPE_SLICE_END: ------------------ | Branch (571:7): [True: 2.46k, False: 629k] ------------------ 572| 2.46k| return utid_ ? 'E' : 'e'; ------------------ | Branch (572:16): [True: 0, False: 2.46k] ------------------ 573| 618k| case TrackEvent::TYPE_INSTANT: ------------------ | Branch (573:7): [True: 618k, False: 13.5k] ------------------ 574| 618k| return utid_ ? 'i' : 'n'; ------------------ | Branch (574:16): [True: 2.00k, False: 616k] ------------------ 575| 7.53k| default: ------------------ | Branch (575:7): [True: 7.53k, False: 624k] ------------------ 576| 7.53k| PERFETTO_ELOG("unexpected event type %d", event_.type()); 577| 7.53k| return 0; 578| 631k| } 579| 631k| } _ZN8perfetto15trace_processor16TrackEventParser13EventImporter21ParseThreadBeginEventEv: 687| 6| base::Status ParseThreadBeginEvent() { 688| 6| if (!utid_) { ------------------ | Branch (688:9): [True: 5, False: 1] ------------------ 689| 5| return base::ErrStatus( 690| 5| "TrackEvent with phase B without thread association"); 691| 5| } 692| | 693| 1| auto opt_slice_id = context_->slice_tracker->Begin( 694| 1| ts_, track_id_, category_id_, name_id_, 695| 1| [this](BoundInserter* inserter) { ParseTrackEventArgs(inserter); }); 696| 1| if (opt_slice_id.has_value()) { ------------------ | Branch (696:9): [True: 1, False: 0] ------------------ 697| 1| auto rr = 698| 1| context_->storage->mutable_slice_table()->FindById(*opt_slice_id); 699| 1| if (thread_timestamp_) { ------------------ | Branch (699:11): [True: 0, False: 1] ------------------ 700| 0| rr->set_thread_ts(*thread_timestamp_); 701| 0| } 702| 1| if (thread_instruction_count_) { ------------------ | Branch (702:11): [True: 0, False: 1] ------------------ 703| 0| rr->set_thread_instruction_count(*thread_instruction_count_); 704| 0| } 705| 1| MaybeParseFlowEvents(opt_slice_id.value()); 706| 1| } 707| 1| return base::OkStatus(); 708| 6| } _ZZN8perfetto15trace_processor16TrackEventParser13EventImporter21ParseThreadBeginEventEvENKUlPNS0_11ArgsTracker13BoundInserterEE_clES5_: 695| 1| [this](BoundInserter* inserter) { ParseTrackEventArgs(inserter); }); _ZN8perfetto15trace_processor16TrackEventParser13EventImporter20MaybeParseFlowEventsENS0_6tables10SliceTable2IdE: 870| 727k| void MaybeParseFlowEvents(SliceId slice_id) { 871| 727k| MaybeParseFlowEventV2(slice_id); 872| 727k| MaybeParseTrackEventFlows(slice_id); 873| 727k| } _ZN8perfetto15trace_processor16TrackEventParser13EventImporter21MaybeParseFlowEventV2ENS0_6tables10SliceTable2IdE: 844| 727k| void MaybeParseFlowEventV2(SliceId slice_id) { 845| 727k| if (!legacy_event_.has_bind_id()) { ------------------ | Branch (845:9): [True: 724k, False: 3.44k] ------------------ 846| 724k| return; 847| 724k| } 848| 3.44k| if (!legacy_event_.has_flow_direction()) { ------------------ | Branch (848:9): [True: 1, False: 3.44k] ------------------ 849| 1| storage_->IncrementStats(stats::flow_without_direction); 850| 1| return; 851| 1| } 852| | 853| 3.44k| auto bind_id = legacy_event_.bind_id(); 854| 3.44k| switch (legacy_event_.flow_direction()) { 855| 0| case LegacyEvent::FLOW_OUT: ------------------ | Branch (855:7): [True: 0, False: 3.44k] ------------------ 856| 0| context_->flow_tracker->Begin(slice_id, bind_id); 857| 0| break; 858| 0| case LegacyEvent::FLOW_INOUT: ------------------ | Branch (858:7): [True: 0, False: 3.44k] ------------------ 859| 0| context_->flow_tracker->Step(slice_id, bind_id); 860| 0| break; 861| 0| case LegacyEvent::FLOW_IN: ------------------ | Branch (861:7): [True: 0, False: 3.44k] ------------------ 862| 0| context_->flow_tracker->End(slice_id, bind_id, 863| 0| /* close_flow = */ false); 864| 0| break; 865| 3.44k| default: ------------------ | Branch (865:7): [True: 3.44k, False: 0] ------------------ 866| 3.44k| storage_->IncrementStats(stats::flow_without_direction); 867| 3.44k| } 868| 3.44k| } _ZN8perfetto15trace_processor16TrackEventParser13EventImporter25MaybeParseTrackEventFlowsENS0_6tables10SliceTable2IdE: 813| 727k| void MaybeParseTrackEventFlows(SliceId slice_id) { 814| 727k| if (event_.has_flow_ids_old() || event_.has_flow_ids()) { ------------------ | Branch (814:9): [True: 9, False: 727k] | Branch (814:38): [True: 8, False: 727k] ------------------ 815| 17| auto it = 816| 17| event_.has_flow_ids() ? event_.flow_ids() : event_.flow_ids_old(); ------------------ | Branch (816:11): [True: 8, False: 9] ------------------ 817| 34| for (; it; ++it) { ------------------ | Branch (817:14): [True: 17, False: 17] ------------------ 818| 17| FlowId flow_id = *it; 819| 17| if (!context_->flow_tracker->IsActive(flow_id)) { ------------------ | Branch (819:13): [True: 9, False: 8] ------------------ 820| 9| context_->flow_tracker->Begin(slice_id, flow_id); 821| 9| continue; 822| 9| } 823| 8| context_->flow_tracker->Step(slice_id, flow_id); 824| 8| } 825| 17| } 826| 727k| if (event_.has_terminating_flow_ids_old() || ------------------ | Branch (826:9): [True: 8.41k, False: 719k] ------------------ 827| 727k| event_.has_terminating_flow_ids()) { ------------------ | Branch (827:9): [True: 128, False: 719k] ------------------ 828| 8.54k| auto it = event_.has_terminating_flow_ids() ------------------ | Branch (828:17): [True: 4.19k, False: 4.34k] ------------------ 829| 8.54k| ? event_.terminating_flow_ids() 830| 8.54k| : event_.terminating_flow_ids_old(); 831| 17.1k| for (; it; ++it) { ------------------ | Branch (831:14): [True: 8.59k, False: 8.54k] ------------------ 832| 8.59k| FlowId flow_id = *it; 833| 8.59k| if (!context_->flow_tracker->IsActive(flow_id)) { ------------------ | Branch (833:13): [True: 8.59k, False: 1] ------------------ 834| | // If we should terminate a flow, do not begin a new one if it's not 835| | // active already. 836| 8.59k| continue; 837| 8.59k| } 838| 1| context_->flow_tracker->End(slice_id, flow_id, 839| 1| /* close_flow = */ true); 840| 1| } 841| 8.54k| } 842| 727k| } _ZN8perfetto15trace_processor16TrackEventParser13EventImporter19ParseThreadEndEventEv: 710| 10| base::Status ParseThreadEndEvent() { 711| 10| if (!utid_) { ------------------ | Branch (711:9): [True: 5, False: 5] ------------------ 712| 5| return base::ErrStatus( 713| 5| "TrackEvent with phase E without thread association"); 714| 5| } 715| 5| auto opt_slice_id = context_->slice_tracker->End( 716| 5| ts_, track_id_, category_id_, name_id_, 717| 5| [this](BoundInserter* inserter) { ParseTrackEventArgs(inserter); }); 718| 5| if (!opt_slice_id) ------------------ | Branch (718:9): [True: 5, False: 0] ------------------ 719| 5| return base::OkStatus(); 720| | 721| 0| MaybeParseFlowEvents(*opt_slice_id); 722| 0| auto* thread_slices = storage_->mutable_slice_table(); 723| 0| auto opt_thread_slice_ref = thread_slices->FindById(*opt_slice_id); 724| 0| if (!opt_thread_slice_ref) { ------------------ | Branch (724:9): [True: 0, False: 0] ------------------ 725| | // This means that the end event did not match a corresponding track event 726| | // begin packet so we likely closed the wrong slice. There's not much we 727| | // can do about this beyond flag it as a stat. 728| 0| context_->storage->IncrementStats(stats::track_event_thread_invalid_end); 729| 0| return base::OkStatus(); 730| 0| } 731| | 732| 0| tables::SliceTable::RowReference slice_ref = *opt_thread_slice_ref; 733| 0| std::optional tts = slice_ref.thread_ts(); 734| 0| if (tts) { ------------------ | Branch (734:9): [True: 0, False: 0] ------------------ 735| 0| PERFETTO_DCHECK(thread_timestamp_); 736| 0| slice_ref.set_thread_dur(*thread_timestamp_ - *tts); 737| 0| } 738| 0| std::optional tic = slice_ref.thread_instruction_count(); 739| 0| if (tic) { ------------------ | Branch (739:9): [True: 0, False: 0] ------------------ 740| 0| PERFETTO_DCHECK(event_data_->thread_instruction_count); 741| 0| slice_ref.set_thread_instruction_delta( 742| 0| *event_data_->thread_instruction_count - *tic); 743| 0| } 744| 0| return base::OkStatus(); 745| 0| } _ZN8perfetto15trace_processor16TrackEventParser13EventImporter24ParseThreadCompleteEventEv: 747| 1.02k| base::Status ParseThreadCompleteEvent() { 748| 1.02k| if (!utid_) { ------------------ | Branch (748:9): [True: 133, False: 896] ------------------ 749| 133| return base::ErrStatus( 750| 133| "TrackEvent with phase X without thread association"); 751| 133| } 752| | 753| 896| auto duration_ns = legacy_event_.duration_us() * 1000; 754| 896| if (duration_ns < 0) ------------------ | Branch (754:9): [True: 0, False: 896] ------------------ 755| 0| return base::ErrStatus("TrackEvent with phase X with negative duration"); 756| | 757| 896| auto opt_slice_id = context_->slice_tracker->Scoped( 758| 896| ts_, track_id_, category_id_, name_id_, duration_ns, 759| 896| [this](BoundInserter* inserter) { ParseTrackEventArgs(inserter); }); 760| 896| if (opt_slice_id.has_value()) { ------------------ | Branch (760:9): [True: 896, False: 0] ------------------ 761| 896| auto rr = 762| 896| context_->storage->mutable_slice_table()->FindById(*opt_slice_id); 763| 896| PERFETTO_CHECK(rr); 764| 896| if (thread_timestamp_) { ------------------ | Branch (764:11): [True: 0, False: 896] ------------------ 765| 0| rr->set_thread_ts(*thread_timestamp_); 766| 0| rr->set_thread_dur(legacy_event_.thread_duration_us() * 1000); 767| 0| } 768| 896| if (thread_instruction_count_) { ------------------ | Branch (768:11): [True: 0, False: 896] ------------------ 769| 0| rr->set_thread_instruction_count(*thread_instruction_count_); 770| 0| rr->set_thread_instruction_delta( 771| 0| legacy_event_.thread_instruction_delta()); 772| 0| } 773| 896| MaybeParseFlowEvents(opt_slice_id.value()); 774| 896| } 775| 896| return base::OkStatus(); 776| 896| } _ZZN8perfetto15trace_processor16TrackEventParser13EventImporter24ParseThreadCompleteEventEvENKUlPNS0_11ArgsTracker13BoundInserterEE_clES5_: 759| 896| [this](BoundInserter* inserter) { ParseTrackEventArgs(inserter); }); _ZN8perfetto15trace_processor16TrackEventParser13EventImporter16ParseFlowEventV1Ec: 789| 66.3k| base::Status ParseFlowEventV1(char phase) { 790| 66.3k| auto opt_source_id = GetLegacyEventId(); 791| 66.3k| if (!opt_source_id) { ------------------ | Branch (791:9): [True: 12.0k, False: 54.3k] ------------------ 792| 12.0k| storage_->IncrementStats(stats::flow_invalid_id); 793| 12.0k| return base::ErrStatus("Invalid id for flow event v1"); 794| 12.0k| } 795| 54.3k| FlowId flow_id = context_->flow_tracker->GetFlowIdForV1Event( 796| 54.3k| opt_source_id.value(), category_id_, name_id_); 797| 54.3k| switch (phase) { ------------------ | Branch (797:13): [True: 0, False: 54.3k] ------------------ 798| 52.8k| case 's': ------------------ | Branch (798:7): [True: 52.8k, False: 1.45k] ------------------ 799| 52.8k| context_->flow_tracker->Begin(track_id_, flow_id); 800| 52.8k| break; 801| 0| case 't': ------------------ | Branch (801:7): [True: 0, False: 54.3k] ------------------ 802| 0| context_->flow_tracker->Step(track_id_, flow_id); 803| 0| break; 804| 1.45k| case 'f': ------------------ | Branch (804:7): [True: 1.45k, False: 52.8k] ------------------ 805| 1.45k| context_->flow_tracker->End(track_id_, flow_id, 806| 1.45k| legacy_event_.bind_to_enclosing(), 807| 1.45k| /* close_flow = */ false); 808| 1.45k| break; 809| 54.3k| } 810| 54.3k| return base::OkStatus(); 811| 54.3k| } _ZN8perfetto15trace_processor16TrackEventParser13EventImporter16GetLegacyEventIdEv: 778| 66.3k| std::optional GetLegacyEventId() { 779| 66.3k| if (legacy_event_.has_unscoped_id()) ------------------ | Branch (779:9): [True: 54.3k, False: 12.0k] ------------------ 780| 54.3k| return legacy_event_.unscoped_id(); 781| | // TODO(andrewbb): Catapult doesn't support global_id and local_id on flow 782| | // events. We could add support in trace processor (e.g. because there seem 783| | // to be some callsites supplying local_id in chromium), but we would have 784| | // to consider the process ID for local IDs and use a separate ID scope for 785| | // global_id and unscoped_id. 786| 12.0k| return std::nullopt; 787| 66.3k| } _ZN8perfetto15trace_processor16TrackEventParser13EventImporter23ParseThreadInstantEventEc: 875| 4.32k| base::Status ParseThreadInstantEvent(char phase) { 876| | // Handle instant events as slices with zero duration, so that they end 877| | // up nested underneath their parent slices. 878| 4.32k| int64_t duration_ns = 0; 879| 4.32k| int64_t tidelta = 0; 880| 4.32k| std::optional opt_slice_id; 881| 4.32k| auto args_inserter = [this, phase](BoundInserter* inserter) { 882| 4.32k| ParseTrackEventArgs(inserter); 883| | // For legacy MARK event, add phase for JSON exporter. 884| 4.32k| if (phase == 'R') { 885| 4.32k| std::string phase_string(1, static_cast(phase)); 886| 4.32k| StringId phase_id = storage_->InternString(phase_string.c_str()); 887| 4.32k| inserter->AddArg(parser_->legacy_event_phase_key_id_, 888| 4.32k| Variadic::String(phase_id)); 889| 4.32k| } 890| 4.32k| }; 891| 4.32k| opt_slice_id = 892| 4.32k| context_->slice_tracker->Scoped(ts_, track_id_, category_id_, name_id_, 893| 4.32k| duration_ns, std::move(args_inserter)); 894| 4.32k| if (!opt_slice_id) { ------------------ | Branch (894:9): [True: 0, False: 4.32k] ------------------ 895| 0| return base::OkStatus(); 896| 0| } 897| 4.32k| if (utid_) { ------------------ | Branch (897:9): [True: 4.28k, False: 39] ------------------ 898| 4.28k| auto rr = 899| 4.28k| context_->storage->mutable_slice_table()->FindById(*opt_slice_id); 900| 4.28k| if (thread_timestamp_) { ------------------ | Branch (900:11): [True: 1, False: 4.28k] ------------------ 901| 1| rr->set_thread_ts(*thread_timestamp_); 902| 1| rr->set_thread_dur(duration_ns); 903| 1| } 904| 4.28k| if (thread_instruction_count_) { ------------------ | Branch (904:11): [True: 1, False: 4.28k] ------------------ 905| 1| rr->set_thread_instruction_count(*thread_instruction_count_); 906| 1| rr->set_thread_instruction_delta(tidelta); 907| 1| } 908| 4.28k| } 909| 4.32k| MaybeParseFlowEvents(opt_slice_id.value()); 910| 4.32k| return base::OkStatus(); 911| 4.32k| } _ZZN8perfetto15trace_processor16TrackEventParser13EventImporter23ParseThreadInstantEventEcENKUlPNS0_11ArgsTracker13BoundInserterEE_clES5_: 881| 4.32k| auto args_inserter = [this, phase](BoundInserter* inserter) { 882| 4.32k| ParseTrackEventArgs(inserter); 883| | // For legacy MARK event, add phase for JSON exporter. 884| 4.32k| if (phase == 'R') { ------------------ | Branch (884:11): [True: 4, False: 4.32k] ------------------ 885| 4| std::string phase_string(1, static_cast(phase)); 886| 4| StringId phase_id = storage_->InternString(phase_string.c_str()); 887| 4| inserter->AddArg(parser_->legacy_event_phase_key_id_, 888| 4| Variadic::String(phase_id)); 889| 4| } 890| 4.32k| }; _ZN8perfetto15trace_processor16TrackEventParser13EventImporter20ParseAsyncBeginEventEc: 913| 121k| base::Status ParseAsyncBeginEvent(char phase) { 914| 121k| auto args_inserter = [this, phase](BoundInserter* inserter) { 915| 121k| ParseTrackEventArgs(inserter); 916| | 917| 121k| if (phase == 'b') 918| 121k| return; 919| 121k| PERFETTO_DCHECK(phase == 'S'); 920| | // For legacy ASYNC_BEGIN, add phase for JSON exporter. 921| 121k| std::string phase_string(1, static_cast(phase)); 922| 121k| StringId phase_id = storage_->InternString(phase_string.c_str()); 923| 121k| inserter->AddArg(parser_->legacy_event_phase_key_id_, 924| 121k| Variadic::String(phase_id)); 925| 121k| }; 926| 121k| auto opt_slice_id = context_->slice_tracker->Begin( 927| 121k| ts_, track_id_, category_id_, name_id_, args_inserter); 928| 121k| if (!opt_slice_id.has_value()) { ------------------ | Branch (928:9): [True: 16.3k, False: 104k] ------------------ 929| 16.3k| return base::OkStatus(); 930| 16.3k| } 931| 104k| MaybeParseFlowEvents(opt_slice_id.value()); 932| | // For the time being, we only create vtrack slice rows if we need to 933| | // store thread timestamps/counters. 934| 104k| if (legacy_event_.use_async_tts()) { ------------------ | Branch (934:9): [True: 2.86k, False: 102k] ------------------ 935| 2.86k| auto* vtrack_slices = storage_->mutable_virtual_track_slices(); 936| 2.86k| PERFETTO_DCHECK(!vtrack_slices->slice_count() || 937| 2.86k| vtrack_slices->slice_ids().back() < opt_slice_id.value()); 938| 2.86k| int64_t tts = thread_timestamp_.value_or(0); 939| 2.86k| int64_t tic = thread_instruction_count_.value_or(0); 940| 2.86k| vtrack_slices->AddVirtualTrackSlice(opt_slice_id.value(), tts, 941| 2.86k| kPendingThreadDuration, tic, 942| 2.86k| kPendingThreadInstructionDelta); 943| 2.86k| } 944| 104k| return base::OkStatus(); 945| 121k| } _ZZN8perfetto15trace_processor16TrackEventParser13EventImporter20ParseAsyncBeginEventEcENKUlPNS0_11ArgsTracker13BoundInserterEE_clES5_: 914| 104k| auto args_inserter = [this, phase](BoundInserter* inserter) { 915| 104k| ParseTrackEventArgs(inserter); 916| | 917| 104k| if (phase == 'b') ------------------ | Branch (917:11): [True: 104k, False: 2] ------------------ 918| 104k| return; 919| 2| PERFETTO_DCHECK(phase == 'S'); 920| | // For legacy ASYNC_BEGIN, add phase for JSON exporter. 921| 2| std::string phase_string(1, static_cast(phase)); 922| 2| StringId phase_id = storage_->InternString(phase_string.c_str()); 923| 2| inserter->AddArg(parser_->legacy_event_phase_key_id_, 924| 2| Variadic::String(phase_id)); 925| 2| }; _ZN8perfetto15trace_processor16TrackEventParser13EventImporter18ParseAsyncEndEventEv: 947| 3.10k| base::Status ParseAsyncEndEvent() { 948| 3.10k| auto opt_slice_id = context_->slice_tracker->End( 949| 3.10k| ts_, track_id_, category_id_, name_id_, 950| 3.10k| [this](BoundInserter* inserter) { ParseTrackEventArgs(inserter); }); 951| 3.10k| if (!opt_slice_id) ------------------ | Branch (951:9): [True: 1.53k, False: 1.57k] ------------------ 952| 1.53k| return base::OkStatus(); 953| | 954| 1.57k| MaybeParseFlowEvents(*opt_slice_id); 955| 1.57k| if (legacy_event_.use_async_tts()) { ------------------ | Branch (955:9): [True: 559, False: 1.01k] ------------------ 956| 559| auto* vtrack_slices = storage_->mutable_virtual_track_slices(); 957| 559| int64_t tts = event_data_->thread_timestamp.value_or(0); 958| 559| int64_t tic = event_data_->thread_instruction_count.value_or(0); 959| 559| vtrack_slices->UpdateThreadDeltasForSliceId(*opt_slice_id, tts, tic); 960| 559| } 961| 1.57k| return base::OkStatus(); 962| 3.10k| } _ZZN8perfetto15trace_processor16TrackEventParser13EventImporter18ParseAsyncEndEventEvENKUlPNS0_11ArgsTracker13BoundInserterEE_clES5_: 950| 1.57k| [this](BoundInserter* inserter) { ParseTrackEventArgs(inserter); }); _ZN8perfetto15trace_processor16TrackEventParser13EventImporter22ParseAsyncInstantEventEv: 985| 616k| base::Status ParseAsyncInstantEvent() { 986| | // Handle instant events as slices with zero duration, so that they end 987| | // up nested underneath their parent slices. 988| 616k| int64_t duration_ns = 0; 989| 616k| int64_t tidelta = 0; 990| 616k| auto opt_slice_id = context_->slice_tracker->Scoped( 991| 616k| ts_, track_id_, category_id_, name_id_, duration_ns, 992| 616k| [this](BoundInserter* inserter) { ParseTrackEventArgs(inserter); }); 993| 616k| if (!opt_slice_id.has_value()) { ------------------ | Branch (993:9): [True: 0, False: 616k] ------------------ 994| 0| return base::OkStatus(); 995| 0| } 996| 616k| MaybeParseFlowEvents(opt_slice_id.value()); 997| 616k| if (legacy_event_.use_async_tts()) { ------------------ | Branch (997:9): [True: 1, False: 616k] ------------------ 998| 1| auto* vtrack_slices = storage_->mutable_virtual_track_slices(); 999| 1| PERFETTO_DCHECK(!vtrack_slices->slice_count() || 1000| 1| vtrack_slices->slice_ids().back() < opt_slice_id.value()); 1001| 1| int64_t tts = thread_timestamp_.value_or(0); 1002| 1| int64_t tic = thread_instruction_count_.value_or(0); 1003| 1| vtrack_slices->AddVirtualTrackSlice(opt_slice_id.value(), tts, 1004| 1| duration_ns, tic, tidelta); 1005| 1| } 1006| 616k| return base::OkStatus(); 1007| 616k| } _ZZN8perfetto15trace_processor16TrackEventParser13EventImporter22ParseAsyncInstantEventEvENKUlPNS0_11ArgsTracker13BoundInserterEE_clES5_: 992| 616k| [this](BoundInserter* inserter) { ParseTrackEventArgs(inserter); }); _ZN8perfetto15trace_processor16TrackEventParser13EventImporter19ParseAsyncStepEventEc: 964| 4| base::Status ParseAsyncStepEvent(char phase) { 965| | // Parse step events as instant events. Reconstructing the begin/end times 966| | // of the child slice would be too complicated, see b/178540838. For JSON 967| | // export, we still record the original step's phase in an arg. 968| 4| int64_t duration_ns = 0; 969| 4| context_->slice_tracker->Scoped( 970| 4| ts_, track_id_, category_id_, name_id_, duration_ns, 971| 4| [this, phase](BoundInserter* inserter) { 972| 4| ParseTrackEventArgs(inserter); 973| | 974| 4| PERFETTO_DCHECK(phase == 'T' || phase == 'p'); 975| 4| std::string phase_string(1, static_cast(phase)); 976| 4| StringId phase_id = storage_->InternString(phase_string.c_str()); 977| 4| inserter->AddArg(parser_->legacy_event_phase_key_id_, 978| 4| Variadic::String(phase_id)); 979| 4| }); 980| | // Step events don't support thread timestamps, so no need to add a row to 981| | // virtual_track_slices. 982| 4| return base::OkStatus(); 983| 4| } _ZZN8perfetto15trace_processor16TrackEventParser13EventImporter19ParseAsyncStepEventEcENKUlPNS0_11ArgsTracker13BoundInserterEE_clES5_: 971| 4| [this, phase](BoundInserter* inserter) { 972| 4| ParseTrackEventArgs(inserter); 973| | 974| 4| PERFETTO_DCHECK(phase == 'T' || phase == 'p'); 975| 4| std::string phase_string(1, static_cast(phase)); 976| 4| StringId phase_id = storage_->InternString(phase_string.c_str()); 977| 4| inserter->AddArg(parser_->legacy_event_phase_key_id_, 978| 4| Variadic::String(phase_id)); 979| 4| }); _ZN8perfetto15trace_processor16TrackEventParser13EventImporter18ParseMetadataEventEv: 1009| 1| base::Status ParseMetadataEvent() { 1010| 1| ProcessTracker* procs = context_->process_tracker.get(); 1011| | 1012| 1| if (name_id_ == kNullStringId) ------------------ | Branch (1012:9): [True: 1, False: 0] ------------------ 1013| 1| return base::ErrStatus("Metadata event without name"); 1014| | 1015| | // Parse process and thread names from correspondingly named events. 1016| 0| NullTermStringView event_name = storage_->GetString(name_id_); 1017| 0| PERFETTO_DCHECK(event_name.data()); 1018| 0| if (event_name == "thread_name") { ------------------ | Branch (1018:9): [True: 0, False: 0] ------------------ 1019| 0| if (!utid_) { ------------------ | Branch (1019:11): [True: 0, False: 0] ------------------ 1020| 0| return base::ErrStatus( 1021| 0| "thread_name metadata event without thread association"); 1022| 0| } 1023| | 1024| 0| auto it = event_.debug_annotations(); 1025| 0| if (!it) { ------------------ | Branch (1025:11): [True: 0, False: 0] ------------------ 1026| 0| return base::ErrStatus( 1027| 0| "thread_name metadata event without debug annotations"); 1028| 0| } 1029| 0| protos::pbzero::DebugAnnotation::Decoder annotation(*it); 1030| 0| auto thread_name = annotation.string_value(); 1031| 0| if (!thread_name.size) ------------------ | Branch (1031:11): [True: 0, False: 0] ------------------ 1032| 0| return base::OkStatus(); 1033| 0| auto thread_name_id = storage_->InternString(thread_name); 1034| 0| procs->UpdateThreadNameByUtid( 1035| 0| *utid_, thread_name_id, 1036| 0| ThreadNamePriority::kTrackDescriptorThreadType); 1037| 0| return base::OkStatus(); 1038| 0| } 1039| 0| if (event_name == "process_name") { ------------------ | Branch (1039:9): [True: 0, False: 0] ------------------ 1040| 0| if (!upid_) { ------------------ | Branch (1040:11): [True: 0, False: 0] ------------------ 1041| 0| return base::ErrStatus( 1042| 0| "process_name metadata event without process association"); 1043| 0| } 1044| | 1045| 0| auto it = event_.debug_annotations(); 1046| 0| if (!it) { ------------------ | Branch (1046:11): [True: 0, False: 0] ------------------ 1047| 0| return base::ErrStatus( 1048| 0| "process_name metadata event without debug annotations"); 1049| 0| } 1050| 0| protos::pbzero::DebugAnnotation::Decoder annotation(*it); 1051| 0| auto process_name = annotation.string_value(); 1052| 0| if (!process_name.size) ------------------ | Branch (1052:11): [True: 0, False: 0] ------------------ 1053| 0| return base::OkStatus(); 1054| 0| auto process_name_id = 1055| 0| storage_->InternString(base::StringView(process_name)); 1056| | // Don't override system-provided names. 1057| 0| procs->SetProcessNameIfUnset(*upid_, process_name_id); 1058| 0| return base::OkStatus(); 1059| 0| } 1060| | // Other metadata events are proxied via the raw table for JSON export. 1061| 0| ParseLegacyEventAsRawEvent(); 1062| 0| return base::OkStatus(); 1063| 0| } _ZN8perfetto15trace_processor16TrackEventParser13EventImporter26ParseLegacyEventAsRawEventEv: 1065| 19.6k| base::Status ParseLegacyEventAsRawEvent() { 1066| 19.6k| if (!utid_) ------------------ | Branch (1066:9): [True: 8.09k, False: 11.5k] ------------------ 1067| 8.09k| return base::ErrStatus("raw legacy event without thread association"); 1068| | 1069| 11.5k| tables::ChromeRawTable::Id id = 1070| 11.5k| storage_->mutable_chrome_raw_table() 1071| 11.5k| ->Insert({ts_, parser_->raw_legacy_event_id_, *utid_, 0}) 1072| 11.5k| .id; 1073| | 1074| 11.5k| auto inserter = context_->args_tracker->AddArgsTo(id); 1075| 11.5k| inserter 1076| 11.5k| .AddArg(parser_->legacy_event_category_key_id_, 1077| 11.5k| Variadic::String(category_id_)) 1078| 11.5k| .AddArg(parser_->legacy_event_name_key_id_, Variadic::String(name_id_)); 1079| | 1080| 11.5k| std::string phase_string(1, static_cast(legacy_event_.phase())); 1081| 11.5k| StringId phase_id = storage_->InternString(phase_string.c_str()); 1082| 11.5k| inserter.AddArg(parser_->legacy_event_phase_key_id_, 1083| 11.5k| Variadic::String(phase_id)); 1084| | 1085| 11.5k| if (legacy_event_.has_duration_us()) { ------------------ | Branch (1085:9): [True: 8.42k, False: 3.15k] ------------------ 1086| 8.42k| inserter.AddArg(parser_->legacy_event_duration_ns_key_id_, 1087| 8.42k| Variadic::Integer(legacy_event_.duration_us() * 1000)); 1088| 8.42k| } 1089| | 1090| 11.5k| if (thread_timestamp_) { ------------------ | Branch (1090:9): [True: 23, False: 11.5k] ------------------ 1091| 23| inserter.AddArg(parser_->legacy_event_thread_timestamp_ns_key_id_, 1092| 23| Variadic::Integer(*thread_timestamp_)); 1093| 23| if (legacy_event_.has_thread_duration_us()) { ------------------ | Branch (1093:11): [True: 0, False: 23] ------------------ 1094| 0| inserter.AddArg( 1095| 0| parser_->legacy_event_thread_duration_ns_key_id_, 1096| 0| Variadic::Integer(legacy_event_.thread_duration_us() * 1000)); 1097| 0| } 1098| 23| } 1099| | 1100| 11.5k| if (thread_instruction_count_) { ------------------ | Branch (1100:9): [True: 23, False: 11.5k] ------------------ 1101| 23| inserter.AddArg(parser_->legacy_event_thread_instruction_count_key_id_, 1102| 23| Variadic::Integer(*thread_instruction_count_)); 1103| 23| if (legacy_event_.has_thread_instruction_delta()) { ------------------ | Branch (1103:11): [True: 0, False: 23] ------------------ 1104| 0| inserter.AddArg( 1105| 0| parser_->legacy_event_thread_instruction_delta_key_id_, 1106| 0| Variadic::Integer(legacy_event_.thread_instruction_delta())); 1107| 0| } 1108| 23| } 1109| | 1110| 11.5k| if (legacy_event_.use_async_tts()) { ------------------ | Branch (1110:9): [True: 613, False: 10.9k] ------------------ 1111| 613| inserter.AddArg(parser_->legacy_event_use_async_tts_key_id_, 1112| 613| Variadic::Boolean(true)); 1113| 613| } 1114| | 1115| 11.5k| bool has_id = false; 1116| 11.5k| if (legacy_event_.has_unscoped_id()) { ------------------ | Branch (1116:9): [True: 20, False: 11.5k] ------------------ 1117| | // Unscoped ids are either global or local depending on the phase. Pass 1118| | // them through as unscoped IDs to JSON export to preserve this behavior. 1119| 20| inserter.AddArg(parser_->legacy_event_unscoped_id_key_id_, 1120| 20| Variadic::UnsignedInteger(legacy_event_.unscoped_id())); 1121| 20| has_id = true; 1122| 11.5k| } else if (legacy_event_.has_global_id()) { ------------------ | Branch (1122:16): [True: 79, False: 11.4k] ------------------ 1123| 79| inserter.AddArg(parser_->legacy_event_global_id_key_id_, 1124| 79| Variadic::UnsignedInteger(legacy_event_.global_id())); 1125| 79| has_id = true; 1126| 11.4k| } else if (legacy_event_.has_local_id()) { ------------------ | Branch (1126:16): [True: 1.73k, False: 9.74k] ------------------ 1127| 1.73k| inserter.AddArg(parser_->legacy_event_local_id_key_id_, 1128| 1.73k| Variadic::UnsignedInteger(legacy_event_.local_id())); 1129| 1.73k| has_id = true; 1130| 1.73k| } 1131| | 1132| 11.5k| if (has_id && legacy_event_.has_id_scope() && ------------------ | Branch (1132:9): [True: 1.83k, False: 9.74k] | Branch (1132:9): [True: 0, False: 11.5k] | Branch (1132:19): [True: 0, False: 1.83k] ------------------ 1133| 11.5k| legacy_event_.id_scope().size) { ------------------ | Branch (1133:9): [True: 0, False: 0] ------------------ 1134| 0| inserter.AddArg( 1135| 0| parser_->legacy_event_id_scope_key_id_, 1136| 0| Variadic::String(storage_->InternString(legacy_event_.id_scope()))); 1137| 0| } 1138| | 1139| | // No need to parse legacy_event.instant_event_scope() because we import 1140| | // instant events into the slice table. 1141| | 1142| 11.5k| ParseTrackEventArgs(&inserter); 1143| 11.5k| return base::OkStatus(); 1144| 19.6k| } track_event_parser.cc:_ZZN8perfetto15trace_processor16TrackEventParserC1EPNS0_21TraceProcessorContextEPNS0_17TrackEventTrackerEENK3$_6clERKN9protozero5FieldERNS0_4util17ProtoToArgsParser8DelegateE: 1522| 5.36k| util::ProtoToArgsParser::Delegate& delegate) { 1523| 5.36k| AddActiveProcess(delegate.packet_timestamp(), field.as_int32()); 1524| | // Fallthrough so that the parser adds pid as a regular arg. 1525| 5.36k| return std::nullopt; 1526| 5.36k| }); _ZN8perfetto15trace_processor23TrackEventSequenceState19SetThreadDescriptorERKNS_6protos6pbzero24ThreadDescriptor_DecoderE: 24| 2.06k| const protos::pbzero::ThreadDescriptor::Decoder& decoder) { 25| 2.06k| persistent_state_.pid_and_tid_valid = true; 26| 2.06k| persistent_state_.pid = decoder.pid(); 27| 2.06k| persistent_state_.tid = decoder.tid(); 28| | 29| 2.06k| timestamps_valid_ = true; 30| 2.06k| timestamp_ns_ = decoder.reference_timestamp_us() * 1000; 31| 2.06k| thread_timestamp_ns_ = decoder.reference_thread_time_us() * 1000; 32| 2.06k| thread_instruction_count_ = decoder.reference_thread_instruction_count(); 33| 2.06k|} _ZN8perfetto15trace_processor23TrackEventSequenceState11CreateFirstEv: 29| 56.9k| static TrackEventSequenceState CreateFirst() { 30| 56.9k| return TrackEventSequenceState(PersistentState()); 31| 56.9k| } _ZN8perfetto15trace_processor23TrackEventSequenceState25OnIncrementalStateClearedEv: 33| 10.9k| TrackEventSequenceState OnIncrementalStateCleared() { 34| 10.9k| return TrackEventSequenceState(persistent_state_); 35| 10.9k| } _ZN8perfetto15trace_processor23TrackEventSequenceState12OnPacketLossEv: 37| 47| void OnPacketLoss() { timestamps_valid_ = false; } _ZNK8perfetto15trace_processor23TrackEventSequenceState17pid_and_tid_validEv: 39| 839k| bool pid_and_tid_valid() const { return persistent_state_.pid_and_tid_valid; } _ZNK8perfetto15trace_processor23TrackEventSequenceState3pidEv: 41| 105k| int32_t pid() const { return persistent_state_.pid; } _ZNK8perfetto15trace_processor23TrackEventSequenceState3tidEv: 42| 105k| int32_t tid() const { return persistent_state_.tid; } _ZNK8perfetto15trace_processor23TrackEventSequenceState16timestamps_validEv: 44| 23.6k| bool timestamps_valid() const { return timestamps_valid_; } _ZN8perfetto15trace_processor23TrackEventSequenceState31IncrementAndGetTrackEventTimeNsEl: 46| 22| int64_t IncrementAndGetTrackEventTimeNs(int64_t delta_ns) { 47| 22| PERFETTO_DCHECK(timestamps_valid()); 48| 22| timestamp_ns_ += delta_ns; 49| 22| return timestamp_ns_; 50| 22| } _ZN8perfetto15trace_processor23TrackEventSequenceState37IncrementAndGetTrackEventThreadTimeNsEl: 52| 24| int64_t IncrementAndGetTrackEventThreadTimeNs(int64_t delta_ns) { 53| 24| PERFETTO_DCHECK(timestamps_valid()); 54| 24| thread_timestamp_ns_ += delta_ns; 55| 24| return thread_timestamp_ns_; 56| 24| } _ZN8perfetto15trace_processor23TrackEventSequenceState47IncrementAndGetTrackEventThreadInstructionCountEl: 58| 24| int64_t IncrementAndGetTrackEventThreadInstructionCount(int64_t delta) { 59| 24| PERFETTO_DCHECK(timestamps_valid()); 60| 24| thread_instruction_count_ += delta; 61| 24| return thread_instruction_count_; 62| 24| } _ZN8perfetto15trace_processor23TrackEventSequenceStateC2ENS1_15PersistentStateE: 81| 67.9k| : persistent_state_(std::move(persistent_state)) {} _ZN8perfetto15trace_processor19TrackEventTokenizerC2EPNS0_21TraceProcessorContextEPNS0_17TrackEventTrackerE: 71| 2.03k| : context_(context), 72| 2.03k| track_event_tracker_(track_event_tracker), 73| | counter_name_thread_time_id_( 74| 2.03k| context_->storage->InternString("thread_time")), 75| | counter_name_thread_instruction_count_id_( 76| 2.03k| context_->storage->InternString("thread_instruction_count")), 77| 2.03k| counter_unit_ids_{{kNullStringId, context_->storage->InternString("ns"), 78| 2.03k| context_->storage->InternString("count"), 79| 2.03k| context_->storage->InternString("bytes")}} {} _ZN8perfetto15trace_processor19TrackEventTokenizer29TokenizeTrackDescriptorPacketENS0_6RefPtrINS0_29PacketSequenceStateGenerationEEERKNS_6protos6pbzero19TracePacket_DecoderEl: 101| 140k| int64_t packet_timestamp) { 102| 140k| using TrackDescriptorProto = protos::pbzero::TrackDescriptor; 103| 140k| using Reservation = TrackEventTracker::DescriptorTrackReservation; 104| 140k| auto track_descriptor_field = packet.track_descriptor(); 105| 140k| TrackDescriptorProto::Decoder track(track_descriptor_field.data, 106| 140k| track_descriptor_field.size); 107| | 108| 140k| Reservation reservation; 109| | 110| 140k| if (!track.has_uuid()) { ------------------ | Branch (110:7): [True: 9.85k, False: 130k] ------------------ 111| 9.85k| PERFETTO_ELOG("TrackDescriptor packet without uuid"); 112| 9.85k| context_->storage->IncrementStats(stats::track_event_tokenizer_errors); 113| 9.85k| return ModuleResult::Handled(); 114| 9.85k| } 115| | 116| 130k| if (track.has_parent_uuid()) { ------------------ | Branch (116:7): [True: 30.2k, False: 100k] ------------------ 117| 30.2k| reservation.parent_uuid = track.parent_uuid(); 118| 30.2k| } 119| | 120| 130k| if (track.has_child_ordering()) { ------------------ | Branch (120:7): [True: 3, False: 130k] ------------------ 121| 3| switch (track.child_ordering()) { 122| 3| case TrackDescriptorProto::ChildTracksOrdering::UNKNOWN: ------------------ | Branch (122:7): [True: 3, False: 0] ------------------ 123| 3| reservation.ordering = Reservation::ChildTracksOrdering::kUnknown; 124| 3| break; 125| 0| case TrackDescriptorProto::ChildTracksOrdering::CHRONOLOGICAL: ------------------ | Branch (125:7): [True: 0, False: 3] ------------------ 126| 0| reservation.ordering = Reservation::ChildTracksOrdering::kChronological; 127| 0| break; 128| 0| case TrackDescriptorProto::ChildTracksOrdering::LEXICOGRAPHIC: ------------------ | Branch (128:7): [True: 0, False: 3] ------------------ 129| 0| reservation.ordering = Reservation::ChildTracksOrdering::kLexicographic; 130| 0| break; 131| 0| case TrackDescriptorProto::ChildTracksOrdering::EXPLICIT: ------------------ | Branch (131:7): [True: 0, False: 3] ------------------ 132| 0| reservation.ordering = Reservation::ChildTracksOrdering::kExplicit; 133| 0| break; 134| 0| default: ------------------ | Branch (134:7): [True: 0, False: 3] ------------------ 135| 0| PERFETTO_FATAL("Unsupported ChildTracksOrdering"); 136| 3| } 137| 3| } 138| | 139| 130k| if (track.has_sibling_order_rank()) { ------------------ | Branch (139:7): [True: 594, False: 130k] ------------------ 140| 594| reservation.sibling_order_rank = track.sibling_order_rank(); 141| 594| } 142| | 143| 130k| if (track.has_name()) ------------------ | Branch (143:7): [True: 63.5k, False: 67.1k] ------------------ 144| 63.5k| reservation.name = context_->storage->InternString(track.name()); 145| 67.1k| else if (track.has_static_name()) ------------------ | Branch (145:12): [True: 3.38k, False: 63.7k] ------------------ 146| 3.38k| reservation.name = context_->storage->InternString(track.static_name()); 147| | 148| 130k| if (packet.has_trusted_pid()) { ------------------ | Branch (148:7): [True: 1.04k, False: 129k] ------------------ 149| 1.04k| context_->process_tracker->UpdateTrustedPid( 150| 1.04k| static_cast(packet.trusted_pid()), track.uuid()); 151| 1.04k| } 152| | 153| 130k| if (track.has_thread()) { ------------------ | Branch (153:7): [True: 19.0k, False: 111k] ------------------ 154| 19.0k| protos::pbzero::ThreadDescriptor::Decoder thread(track.thread()); 155| | 156| 19.0k| if (!thread.has_pid() || !thread.has_tid()) { ------------------ | Branch (156:9): [True: 10.3k, False: 8.75k] | Branch (156:30): [True: 267, False: 8.49k] ------------------ 157| 10.5k| PERFETTO_ELOG( 158| 10.5k| "No pid or tid in ThreadDescriptor for track with uuid %" PRIu64, 159| 10.5k| track.uuid()); 160| 10.5k| context_->storage->IncrementStats(stats::track_event_tokenizer_errors); 161| 10.5k| return ModuleResult::Handled(); 162| 10.5k| } 163| | 164| 8.49k| if (state->IsIncrementalStateValid()) { ------------------ | Branch (164:9): [True: 2.04k, False: 6.45k] ------------------ 165| 2.04k| TokenizeThreadDescriptor(*state, thread); 166| 2.04k| } 167| | 168| 8.49k| reservation.min_timestamp = packet_timestamp; 169| 8.49k| reservation.pid = static_cast(thread.pid()); 170| 8.49k| reservation.tid = static_cast(thread.tid()); 171| 8.49k| reservation.use_separate_track = 172| 8.49k| track.disallow_merging_with_system_tracks(); 173| | 174| 8.49k| track_event_tracker_->ReserveDescriptorTrack(track.uuid(), reservation); 175| | 176| 8.49k| return ModuleResult::Ignored(); 177| 19.0k| } 178| | 179| 111k| if (track.has_process()) { ------------------ | Branch (179:7): [True: 52.4k, False: 59.1k] ------------------ 180| 52.4k| protos::pbzero::ProcessDescriptor::Decoder process(track.process()); 181| | 182| 52.4k| if (!process.has_pid()) { ------------------ | Branch (182:9): [True: 4.45k, False: 47.9k] ------------------ 183| 4.45k| PERFETTO_ELOG("No pid in ProcessDescriptor for track with uuid %" PRIu64, 184| 4.45k| track.uuid()); 185| 4.45k| context_->storage->IncrementStats(stats::track_event_tokenizer_errors); 186| 4.45k| return ModuleResult::Handled(); 187| 4.45k| } 188| | 189| 47.9k| reservation.pid = static_cast(process.pid()); 190| 47.9k| reservation.min_timestamp = packet_timestamp; 191| 47.9k| track_event_tracker_->ReserveDescriptorTrack(track.uuid(), reservation); 192| | 193| 47.9k| return ModuleResult::Ignored(); 194| 52.4k| } 195| 59.1k| if (track.has_counter()) { ------------------ | Branch (195:7): [True: 20.3k, False: 38.8k] ------------------ 196| 20.3k| protos::pbzero::CounterDescriptor::Decoder counter(track.counter()); 197| | 198| 20.3k| StringId category_id = kNullStringId; 199| 20.3k| if (counter.has_categories()) { ------------------ | Branch (199:9): [True: 14.1k, False: 6.23k] ------------------ 200| | // TODO(eseckler): Support multi-category events in the table schema. 201| 14.1k| std::string categories; 202| 84.3k| for (auto it = counter.categories(); it; ++it) { ------------------ | Branch (202:44): [True: 70.2k, False: 14.1k] ------------------ 203| 70.2k| if (!categories.empty()) ------------------ | Branch (203:13): [True: 21.2k, False: 49.0k] ------------------ 204| 21.2k| categories += ","; 205| 70.2k| categories.append((*it).data, (*it).size); 206| 70.2k| } 207| 14.1k| if (!categories.empty()) { ------------------ | Branch (207:11): [True: 5.49k, False: 8.60k] ------------------ 208| 5.49k| category_id = 209| 5.49k| context_->storage->InternString(base::StringView(categories)); 210| 5.49k| } 211| 14.1k| } 212| | 213| | // TODO(eseckler): Intern counter tracks for specific counter types like 214| | // thread time, so that the same counter can be referred to from tracks with 215| | // different uuids. (Chrome may emit thread time values on behalf of other 216| | // threads, in which case it has to use absolute values on a different 217| | // track_uuid. Right now these absolute values are imported onto a separate 218| | // counter track than the other thread's regular thread time values.) 219| 20.3k| if (reservation.name.is_null()) { ------------------ | Branch (219:9): [True: 9.58k, False: 10.7k] ------------------ 220| 9.58k| switch (counter.type()) { ------------------ | Branch (220:15): [True: 917, False: 8.67k] ------------------ 221| 3.87k| case CounterDescriptor::COUNTER_UNSPECIFIED: ------------------ | Branch (221:9): [True: 3.87k, False: 5.71k] ------------------ 222| 3.87k| break; 223| 928| case CounterDescriptor::COUNTER_THREAD_TIME_NS: ------------------ | Branch (223:9): [True: 928, False: 8.66k] ------------------ 224| 928| reservation.name = counter_name_thread_time_id_; 225| 928| break; 226| 3.86k| case CounterDescriptor::COUNTER_THREAD_INSTRUCTION_COUNT: ------------------ | Branch (226:9): [True: 3.86k, False: 5.72k] ------------------ 227| 3.86k| reservation.name = counter_name_thread_instruction_count_id_; 228| 3.86k| break; 229| 9.58k| } 230| 9.58k| } 231| | 232| 20.3k| reservation.is_counter = true; 233| 20.3k| reservation.counter_details = 234| 20.3k| TrackEventTracker::DescriptorTrackReservation::CounterDetails{}; 235| | 236| 20.3k| auto& counter_details = *reservation.counter_details; 237| 20.3k| counter_details.category = category_id; 238| 20.3k| counter_details.is_incremental = counter.is_incremental(); 239| 20.3k| counter_details.unit_multiplier = counter.unit_multiplier(); 240| | 241| 20.3k| auto unit = static_cast(counter.unit()); 242| 20.3k| if (counter.type() == CounterDescriptor::COUNTER_THREAD_TIME_NS) { ------------------ | Branch (242:9): [True: 930, False: 19.4k] ------------------ 243| 930| counter_details.unit = counter_unit_ids_[CounterDescriptor::UNIT_TIME_NS]; 244| 930| counter_details.builtin_type_str = counter_name_thread_time_id_; 245| 19.4k| } else if (counter.type() == ------------------ | Branch (245:16): [True: 4.58k, False: 14.8k] ------------------ 246| 19.4k| CounterDescriptor::COUNTER_THREAD_INSTRUCTION_COUNT) { 247| 4.58k| counter_details.unit = counter_unit_ids_[CounterDescriptor::UNIT_COUNT]; 248| 4.58k| counter_details.builtin_type_str = 249| 4.58k| counter_name_thread_instruction_count_id_; 250| 14.8k| } else if (unit < counter_unit_ids_.size() && ------------------ | Branch (250:16): [True: 13.3k, False: 1.44k] ------------------ 251| 14.8k| unit != CounterDescriptor::COUNTER_UNSPECIFIED) { ------------------ | Branch (251:16): [True: 0, False: 13.3k] ------------------ 252| 0| counter_details.unit = counter_unit_ids_[unit]; 253| 14.8k| } else { 254| 14.8k| counter_details.unit = 255| 14.8k| context_->storage->InternString(counter.unit_name()); 256| 14.8k| } 257| | 258| | // Incrementally encoded counters are only valid on a single sequence. 259| 20.3k| if (counter.is_incremental()) { ------------------ | Branch (259:9): [True: 5.80k, False: 14.5k] ------------------ 260| 5.80k| counter_details.packet_sequence_id = packet.trusted_packet_sequence_id(); 261| 5.80k| } 262| 20.3k| track_event_tracker_->ReserveDescriptorTrack(track.uuid(), reservation); 263| | 264| 20.3k| return ModuleResult::Ignored(); 265| 20.3k| } 266| | 267| 38.8k| track_event_tracker_->ReserveDescriptorTrack(track.uuid(), reservation); 268| | 269| | // Let ProtoTraceReader forward the packet to the parser. 270| 38.8k| return ModuleResult::Ignored(); 271| 59.1k|} // namespace perfetto::trace_processor _ZN8perfetto15trace_processor19TrackEventTokenizer30TokenizeThreadDescriptorPacketENS0_6RefPtrINS0_29PacketSequenceStateGenerationEEERKNS_6protos6pbzero19TracePacket_DecoderE: 275| 649| const protos::pbzero::TracePacket::Decoder& packet) { 276| 649| if (PERFETTO_UNLIKELY(!packet.has_trusted_packet_sequence_id())) { ------------------ | | 24| 649|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 626, False: 23] | | ------------------ ------------------ 277| 626| PERFETTO_ELOG("ThreadDescriptor packet without trusted_packet_sequence_id"); 278| 626| context_->storage->IncrementStats(stats::track_event_tokenizer_errors); 279| 626| return ModuleResult::Handled(); 280| 626| } 281| | 282| | // TrackEvents will be ignored while incremental state is invalid. As a 283| | // consequence, we should also ignore any ThreadDescriptors received in this 284| | // state. Otherwise, any delta-encoded timestamps would be calculated 285| | // incorrectly once we move out of the packet loss state. Instead, wait until 286| | // the first subsequent descriptor after incremental state is cleared. 287| 23| if (!state->IsIncrementalStateValid()) { ------------------ | Branch (287:7): [True: 0, False: 23] ------------------ 288| 0| context_->storage->IncrementStats(stats::tokenizer_skipped_packets); 289| 0| return ModuleResult::Handled(); 290| 0| } 291| | 292| 23| protos::pbzero::ThreadDescriptor::Decoder thread(packet.thread_descriptor()); 293| 23| TokenizeThreadDescriptor(*state, thread); 294| | 295| | // Let ProtoTraceReader forward the packet to the parser. 296| 23| return ModuleResult::Ignored(); 297| 23|} _ZN8perfetto15trace_processor19TrackEventTokenizer24TokenizeThreadDescriptorERNS0_29PacketSequenceStateGenerationERKNS_6protos6pbzero24ThreadDescriptor_DecoderE: 301| 2.06k| const protos::pbzero::ThreadDescriptor::Decoder& thread) { 302| | // TODO(eseckler): Remove support for legacy thread descriptor-based default 303| | // tracks and delta timestamps. 304| 2.06k| state.SetThreadDescriptor(thread); 305| 2.06k|} _ZN8perfetto15trace_processor19TrackEventTokenizer24TokenizeTrackEventPacketENS0_6RefPtrINS0_29PacketSequenceStateGenerationEEERKNS_6protos6pbzero19TracePacket_DecoderEPNS0_13TraceBlobViewEl: 311| 1.13M| int64_t packet_timestamp) { 312| 1.13M| if (PERFETTO_UNLIKELY(!packet.has_trusted_packet_sequence_id())) { ------------------ | | 24| 1.13M|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 137k, False: 999k] | | ------------------ ------------------ 313| 137k| PERFETTO_ELOG("TrackEvent packet without trusted_packet_sequence_id"); 314| 137k| context_->storage->IncrementStats(stats::track_event_tokenizer_errors); 315| 137k| return ModuleResult::Handled(); 316| 137k| } 317| | 318| 999k| protos::pbzero::TrackEvent::Decoder event(packet.track_event()); 319| 999k| protos::pbzero::TrackEventDefaults::Decoder* defaults = 320| 999k| state->GetTrackEventDefaults(); 321| | 322| 999k| int64_t timestamp; 323| 999k| TrackEventData data(std::move(*packet_blob), state); 324| | 325| | // TODO(eseckler): Remove handling of timestamps relative to ThreadDescriptors 326| | // once all producers have switched to clock-domain timestamps (e.g. 327| | // TracePacket's timestamp). 328| | 329| 999k| if (event.has_timestamp_delta_us()) { ------------------ | Branch (329:7): [True: 10.9k, False: 988k] ------------------ 330| | // Delta timestamps require a valid ThreadDescriptor packet since the last 331| | // packet loss. 332| 10.9k| if (!state->track_event_timestamps_valid()) { ------------------ | Branch (332:9): [True: 10.8k, False: 22] ------------------ 333| 10.8k| context_->storage->IncrementStats(stats::tokenizer_skipped_packets); 334| 10.8k| return ModuleResult::Handled(); 335| 10.8k| } 336| 22| timestamp = state->IncrementAndGetTrackEventTimeNs( 337| 22| event.timestamp_delta_us() * 1000); 338| | 339| | // Legacy TrackEvent timestamp fields are in MONOTONIC domain. Adjust to 340| | // trace time if we have a clock snapshot. 341| 22| base::StatusOr trace_ts = context_->clock_tracker->ToTraceTime( 342| 22| protos::pbzero::BUILTIN_CLOCK_MONOTONIC, timestamp); 343| 22| if (trace_ts.ok()) ------------------ | Branch (343:9): [True: 0, False: 22] ------------------ 344| 0| timestamp = trace_ts.value(); 345| 988k| } else if (int64_t ts_absolute_us = event.timestamp_absolute_us()) { ------------------ | Branch (345:22): [True: 780, False: 987k] ------------------ 346| | // One-off absolute timestamps don't affect delta computation. 347| 780| timestamp = ts_absolute_us * 1000; 348| | 349| | // Legacy TrackEvent timestamp fields are in MONOTONIC domain. Adjust to 350| | // trace time if we have a clock snapshot. 351| 780| base::StatusOr trace_ts = context_->clock_tracker->ToTraceTime( 352| 780| protos::pbzero::BUILTIN_CLOCK_MONOTONIC, timestamp); 353| 780| if (trace_ts.ok()) ------------------ | Branch (353:9): [True: 34, False: 746] ------------------ 354| 34| timestamp = trace_ts.value(); 355| 987k| } else if (packet.has_timestamp()) { ------------------ | Branch (355:14): [True: 983k, False: 4.16k] ------------------ 356| 983k| timestamp = packet_timestamp; 357| 983k| } else { 358| 4.16k| PERFETTO_ELOG("TrackEvent without valid timestamp"); 359| 4.16k| context_->storage->IncrementStats(stats::track_event_tokenizer_errors); 360| 4.16k| return ModuleResult::Handled(); 361| 4.16k| } 362| | 363| | // Handle legacy sample events which might have timestamps embedded inside. 364| 984k| if (PERFETTO_UNLIKELY(event.has_legacy_event())) { ------------------ | | 24| 984k|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 359k, False: 624k] | | ------------------ ------------------ 365| 359k| protos::pbzero::TrackEvent::LegacyEvent::Decoder leg(event.legacy_event()); 366| 359k| if (PERFETTO_UNLIKELY(leg.phase() == 'P')) { ------------------ | | 24| 359k|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 1, False: 359k] | | ------------------ ------------------ 367| 1| RETURN_IF_ERROR(TokenizeLegacySampleEvent( ------------------ | | 25| 1| do { \ | | 26| 1| base::Status status_macro_internal_status = (expr); \ | | 27| 1| if (!status_macro_internal_status.ok()) \ | | ------------------ | | | Branch (27:9): [True: 0, False: 1] | | ------------------ | | 28| 1| return status_macro_internal_status; \ | | 29| 1| } while (0) | | ------------------ | | | Branch (29:12): [Folded - Ignored] | | ------------------ ------------------ 368| 1| event, leg, *data.trace_packet_data.sequence_state)); 369| 1| } 370| 359k| } 371| | 372| 984k| if (event.has_thread_time_delta_us()) { ------------------ | Branch (372:7): [True: 8.63k, False: 975k] ------------------ 373| | // Delta timestamps require a valid ThreadDescriptor packet since the last 374| | // packet loss. 375| 8.63k| if (!state->track_event_timestamps_valid()) { ------------------ | Branch (375:9): [True: 8.61k, False: 24] ------------------ 376| 8.61k| context_->storage->IncrementStats(stats::tokenizer_skipped_packets); 377| 8.61k| return ModuleResult::Handled(); 378| 8.61k| } 379| 24| data.thread_timestamp = state->IncrementAndGetTrackEventThreadTimeNs( 380| 24| event.thread_time_delta_us() * 1000); 381| 975k| } else if (event.has_thread_time_absolute_us()) { ------------------ | Branch (381:14): [True: 0, False: 975k] ------------------ 382| | // One-off absolute timestamps don't affect delta computation. 383| 0| data.thread_timestamp = event.thread_time_absolute_us() * 1000; 384| 0| } 385| | 386| 975k| if (event.has_thread_instruction_count_delta()) { ------------------ | Branch (386:7): [True: 4.12k, False: 971k] ------------------ 387| | // Delta timestamps require a valid ThreadDescriptor packet since the last 388| | // packet loss. 389| 4.12k| if (!state->track_event_timestamps_valid()) { ------------------ | Branch (389:9): [True: 4.10k, False: 24] ------------------ 390| 4.10k| context_->storage->IncrementStats(stats::tokenizer_skipped_packets); 391| 4.10k| return ModuleResult::Handled(); 392| 4.10k| } 393| 24| data.thread_instruction_count = 394| 24| state->IncrementAndGetTrackEventThreadInstructionCount( 395| 24| event.thread_instruction_count_delta()); 396| 971k| } else if (event.has_thread_instruction_count_absolute()) { ------------------ | Branch (396:14): [True: 43, False: 971k] ------------------ 397| | // One-off absolute timestamps don't affect delta computation. 398| 43| data.thread_instruction_count = event.thread_instruction_count_absolute(); 399| 43| } 400| | 401| 971k| if (event.type() == protos::pbzero::TrackEvent::TYPE_COUNTER) { ------------------ | Branch (401:7): [True: 213, False: 971k] ------------------ 402| | // Consider track_uuid from the packet and TrackEventDefaults. 403| 213| uint64_t track_uuid; 404| 213| if (event.has_track_uuid()) { ------------------ | Branch (404:9): [True: 0, False: 213] ------------------ 405| 0| track_uuid = event.track_uuid(); 406| 213| } else if (defaults && defaults->has_track_uuid()) { ------------------ | Branch (406:16): [True: 1, False: 212] | Branch (406:28): [True: 1, False: 0] ------------------ 407| 1| track_uuid = defaults->track_uuid(); 408| 212| } else { 409| 212| PERFETTO_DLOG( 410| 212| "Ignoring TrackEvent with counter_value but without track_uuid"); 411| 212| context_->storage->IncrementStats(stats::track_event_tokenizer_errors); 412| 212| return ModuleResult::Handled(); 413| 212| } 414| | 415| 1| if (!event.has_counter_value() && !event.has_double_counter_value()) { ------------------ | Branch (415:9): [True: 1, False: 0] | Branch (415:39): [True: 1, False: 0] ------------------ 416| 1| PERFETTO_DLOG( 417| 1| "Ignoring TrackEvent with TYPE_COUNTER but without counter_value or " 418| 1| "double_counter_value for " 419| 1| "track_uuid %" PRIu64, 420| 1| track_uuid); 421| 1| context_->storage->IncrementStats(stats::track_event_tokenizer_errors); 422| 1| return ModuleResult::Handled(); 423| 1| } 424| | 425| 0| std::optional value; 426| 0| if (event.has_counter_value()) { ------------------ | Branch (426:9): [True: 0, False: 0] ------------------ 427| 0| value = track_event_tracker_->ConvertToAbsoluteCounterValue( 428| 0| track_uuid, packet.trusted_packet_sequence_id(), 429| 0| static_cast(event.counter_value())); 430| 0| } else { 431| 0| value = track_event_tracker_->ConvertToAbsoluteCounterValue( 432| 0| track_uuid, packet.trusted_packet_sequence_id(), 433| 0| event.double_counter_value()); 434| 0| } 435| | 436| 0| if (!value) { ------------------ | Branch (436:9): [True: 0, False: 0] ------------------ 437| 0| PERFETTO_DLOG("Ignoring TrackEvent with invalid track_uuid %" PRIu64, 438| 0| track_uuid); 439| 0| context_->storage->IncrementStats(stats::track_event_tokenizer_errors); 440| 0| return ModuleResult::Handled(); 441| 0| } 442| | 443| 0| data.counter_value = *value; 444| 0| } 445| | 446| 971k| size_t index = 0; 447| 971k| const protozero::RepeatedFieldIterator kEmptyIterator; 448| 971k| auto result = AddExtraCounterValues( 449| 971k| data, index, packet.trusted_packet_sequence_id(), 450| 971k| event.extra_counter_values(), event.extra_counter_track_uuids(), 451| 971k| defaults ? defaults->extra_counter_track_uuids() : kEmptyIterator); ------------------ | Branch (451:7): [True: 48.9k, False: 922k] ------------------ 452| 971k| if (!result.ok()) { ------------------ | Branch (452:7): [True: 9.36k, False: 961k] ------------------ 453| 9.36k| PERFETTO_DLOG("%s", result.c_message()); 454| 9.36k| context_->storage->IncrementStats(stats::track_event_tokenizer_errors); 455| 9.36k| return ModuleResult::Handled(); 456| 9.36k| } 457| 961k| result = AddExtraCounterValues( 458| 961k| data, index, packet.trusted_packet_sequence_id(), 459| 961k| event.extra_double_counter_values(), 460| 961k| event.extra_double_counter_track_uuids(), 461| 961k| defaults ? defaults->extra_double_counter_track_uuids() : kEmptyIterator); ------------------ | Branch (461:7): [True: 48.9k, False: 912k] ------------------ 462| 961k| if (!result.ok()) { ------------------ | Branch (462:7): [True: 188, False: 961k] ------------------ 463| 188| PERFETTO_DLOG("%s", result.c_message()); 464| 188| context_->storage->IncrementStats(stats::track_event_tokenizer_errors); 465| 188| return ModuleResult::Handled(); 466| 188| } 467| | 468| 961k| context_->sorter->PushTrackEventPacket(timestamp, std::move(data), 469| 961k| context_->machine_id()); 470| 961k| return ModuleResult::Handled(); 471| 961k|} _ZN8perfetto15trace_processor19TrackEventTokenizer25TokenizeLegacySampleEventERKNS_6protos6pbzero18TrackEvent_DecoderERKNS3_30TrackEvent_LegacyEvent_DecoderERNS0_29PacketSequenceStateGenerationE: 524| 1| PacketSequenceStateGeneration& state) { 525| | // We are just trying to parse out the V8 profiling events into the cpu 526| | // sampling tables: if we don't have JSON enabled, just don't do this. 527| 1| if (!context_->json_trace_parser) { ------------------ | Branch (527:7): [True: 1, False: 0] ------------------ 528| 1| return base::OkStatus(); 529| 1| } 530| 0|#if PERFETTO_BUILDFLAG(PERFETTO_TP_JSON) 531| 0| for (auto it = event.debug_annotations(); it; ++it) { ------------------ | Branch (531:45): [True: 0, False: 0] ------------------ 532| 0| protos::pbzero::DebugAnnotation::Decoder da(*it); 533| 0| auto* interned_name = state.LookupInternedMessage< 534| 0| protos::pbzero::InternedData::kDebugAnnotationNamesFieldNumber, 535| 0| protos::pbzero::DebugAnnotationName>(da.name_iid()); 536| 0| base::StringView name(interned_name->name()); 537| 0| if (name != "data" || !da.has_legacy_json_value()) { ------------------ | Branch (537:9): [True: 0, False: 0] | Branch (537:9): [True: 0, False: 0] | Branch (537:27): [True: 0, False: 0] ------------------ 538| 0| continue; 539| 0| } 540| 0| auto opt_val = json::ParseJsonString(da.legacy_json_value()); 541| 0| if (!opt_val) { ------------------ | Branch (541:9): [True: 0, False: 0] ------------------ 542| 0| continue; 543| 0| } 544| 0| const auto& val = *opt_val; 545| 0| if (val.isMember("startTime")) { ------------------ | Branch (545:9): [True: 0, False: 0] ------------------ 546| 0| ASSIGN_OR_RETURN(int64_t ts, context_->clock_tracker->ToTraceTime( ------------------ | | 38| 0| PERFETTO_INTERNAL_MACRO_CONCAT(auto status_or, __LINE__) = rhs; \ | | ------------------ | | | | 32| 0|#define PERFETTO_INTERNAL_MACRO_CONCAT(x, y) PERFETTO_INTERNAL_CONCAT_IMPL(x, y) | | | | ------------------ | | | | | | 31| 0|#define PERFETTO_INTERNAL_CONCAT_IMPL(x, y) x##y | | | | ------------------ | | ------------------ | | 39| 0| RETURN_IF_ERROR( \ | | ------------------ | | | | 25| 0| do { \ | | | | 26| 0| base::Status status_macro_internal_status = (expr); \ | | | | 27| 0| if (!status_macro_internal_status.ok()) \ | | | | ------------------ | | | | | Branch (27:9): [True: 0, False: 0] | | | | ------------------ | | | | 28| 0| return status_macro_internal_status; \ | | | | 29| 0| } while (0) | | | | ------------------ | | | | | Branch (29:12): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 40| 0| PERFETTO_INTERNAL_MACRO_CONCAT(status_or, __LINE__).status()); \ | | 41| 0| lhs = std::move(PERFETTO_INTERNAL_MACRO_CONCAT(status_or, __LINE__).value()) | | ------------------ | | | | 32| 0|#define PERFETTO_INTERNAL_MACRO_CONCAT(x, y) PERFETTO_INTERNAL_CONCAT_IMPL(x, y) | | | | ------------------ | | | | | | 31| 0|#define PERFETTO_INTERNAL_CONCAT_IMPL(x, y) x##y | | | | ------------------ | | ------------------ ------------------ 547| 0| protos::pbzero::BUILTIN_CLOCK_MONOTONIC, 548| 0| val["startTime"].asInt64() * 1000)); 549| 0| context_->legacy_v8_cpu_profile_tracker->SetStartTsForSessionAndPid( 550| 0| legacy.unscoped_id(), static_cast(state.pid()), ts); 551| 0| continue; 552| 0| } 553| 0| const auto& profile = val["cpuProfile"]; 554| 0| for (const auto& n : profile["nodes"]) { ------------------ | Branch (554:24): [True: 0, False: 0] ------------------ 555| 0| uint32_t node_id = n["id"].asUInt(); 556| 0| std::optional parent_node_id = 557| 0| n.isMember("parent") ? std::make_optional(n["parent"].asUInt()) ------------------ | Branch (557:11): [True: 0, False: 0] ------------------ 558| 0| : std::nullopt; 559| 0| const auto& frame = n["callFrame"]; 560| 0| base::StringView url = 561| 0| frame.isMember("url") ? frame["url"].asCString() : base::StringView(); ------------------ | Branch (561:11): [True: 0, False: 0] ------------------ 562| 0| base::StringView function_name = frame["functionName"].asCString(); 563| 0| base::Status status = 564| 0| context_->legacy_v8_cpu_profile_tracker->AddCallsite( 565| 0| legacy.unscoped_id(), static_cast(state.pid()), node_id, 566| 0| parent_node_id, url, function_name); 567| 0| if (!status.ok()) { ------------------ | Branch (567:11): [True: 0, False: 0] ------------------ 568| 0| context_->storage->IncrementStats( 569| 0| stats::legacy_v8_cpu_profile_invalid_callsite); 570| 0| continue; 571| 0| } 572| 0| } 573| 0| const auto& samples = profile["samples"]; 574| 0| const auto& deltas = val["timeDeltas"]; 575| 0| if (samples.size() != deltas.size()) { ------------------ | Branch (575:9): [True: 0, False: 0] ------------------ 576| 0| return base::ErrStatus( 577| 0| "v8 legacy profile: samples and timestamps do not have same size"); 578| 0| } 579| 0| for (uint32_t i = 0; i < samples.size(); ++i) { ------------------ | Branch (579:26): [True: 0, False: 0] ------------------ 580| 0| ASSIGN_OR_RETURN( ------------------ | | 38| 0| PERFETTO_INTERNAL_MACRO_CONCAT(auto status_or, __LINE__) = rhs; \ | | ------------------ | | | | 32| 0|#define PERFETTO_INTERNAL_MACRO_CONCAT(x, y) PERFETTO_INTERNAL_CONCAT_IMPL(x, y) | | | | ------------------ | | | | | | 31| 0|#define PERFETTO_INTERNAL_CONCAT_IMPL(x, y) x##y | | | | ------------------ | | ------------------ | | 39| 0| RETURN_IF_ERROR( \ | | ------------------ | | | | 25| 0| do { \ | | | | 26| 0| base::Status status_macro_internal_status = (expr); \ | | | | 27| 0| if (!status_macro_internal_status.ok()) \ | | | | ------------------ | | | | | Branch (27:9): [True: 0, False: 0] | | | | ------------------ | | | | 28| 0| return status_macro_internal_status; \ | | | | 29| 0| } while (0) | | | | ------------------ | | | | | Branch (29:12): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 40| 0| PERFETTO_INTERNAL_MACRO_CONCAT(status_or, __LINE__).status()); \ | | 41| 0| lhs = std::move(PERFETTO_INTERNAL_MACRO_CONCAT(status_or, __LINE__).value()) | | ------------------ | | | | 32| 0|#define PERFETTO_INTERNAL_MACRO_CONCAT(x, y) PERFETTO_INTERNAL_CONCAT_IMPL(x, y) | | | | ------------------ | | | | | | 31| 0|#define PERFETTO_INTERNAL_CONCAT_IMPL(x, y) x##y | | | | ------------------ | | ------------------ ------------------ 581| 0| int64_t ts, 582| 0| context_->legacy_v8_cpu_profile_tracker->AddDeltaAndGetTs( 583| 0| legacy.unscoped_id(), static_cast(state.pid()), 584| 0| deltas[i].asInt64() * 1000)); 585| 0| context_->sorter->PushLegacyV8CpuProfileEvent( 586| 0| ts, legacy.unscoped_id(), static_cast(state.pid()), 587| 0| static_cast(state.tid()), samples[i].asUInt()); 588| 0| } 589| 0| } 590| |#else 591| | base::ignore_result(event, legacy, state); 592| |#endif 593| 0| return base::OkStatus(); 594| 0|} _ZN8perfetto15trace_processor19TrackEventTokenizer21AddExtraCounterValuesIlEENS_4base6StatusERNS0_14TrackEventDataERmjN9protozero21RepeatedFieldIteratorIT_EENS9_ImEESC_: 480| 971k| protozero::RepeatedFieldIterator default_track_uuid_it) { 481| 971k| if (!value_it) ------------------ | Branch (481:7): [True: 961k, False: 9.36k] ------------------ 482| 961k| return base::OkStatus(); 483| | 484| | // Consider extra_{double_,}counter_track_uuids from the packet and 485| | // TrackEventDefaults. 486| 9.36k| protozero::RepeatedFieldIterator track_uuid_it; 487| 9.36k| if (packet_track_uuid_it) { ------------------ | Branch (487:7): [True: 5.29k, False: 4.06k] ------------------ 488| 5.29k| track_uuid_it = packet_track_uuid_it; 489| 5.29k| } else if (default_track_uuid_it) { ------------------ | Branch (489:14): [True: 0, False: 4.06k] ------------------ 490| 0| track_uuid_it = default_track_uuid_it; 491| 4.06k| } else { 492| 4.06k| return base::ErrStatus( 493| 4.06k| "Ignoring TrackEvent with extra_{double_,}counter_values but without " 494| 4.06k| "extra_{double_,}counter_track_uuids"); 495| 4.06k| } 496| | 497| 5.29k| for (; value_it; ++value_it, ++track_uuid_it, ++index) { ------------------ | Branch (497:10): [True: 5.29k, False: 0] ------------------ 498| 5.29k| if (!*track_uuid_it) { ------------------ | Branch (498:9): [True: 3.11k, False: 2.17k] ------------------ 499| 3.11k| return base::ErrStatus( 500| 3.11k| "Ignoring TrackEvent with more extra_{double_,}counter_values than " 501| 3.11k| "extra_{double_,}counter_track_uuids"); 502| 3.11k| } 503| 2.17k| if (index >= TrackEventData::kMaxNumExtraCounters) { ------------------ | Branch (503:9): [True: 0, False: 2.17k] ------------------ 504| 0| return base::ErrStatus( 505| 0| "Ignoring TrackEvent with more extra_{double_,}counter_values than " 506| 0| "TrackEventData::kMaxNumExtraCounters"); 507| 0| } 508| 2.17k| std::optional abs_value = 509| 2.17k| track_event_tracker_->ConvertToAbsoluteCounterValue( 510| 2.17k| *track_uuid_it, trusted_packet_sequence_id, 511| 2.17k| static_cast(*value_it)); 512| 2.17k| if (!abs_value) { ------------------ | Branch (512:9): [True: 2.17k, False: 0] ------------------ 513| 2.17k| return base::ErrStatus( 514| 2.17k| "Ignoring TrackEvent with invalid extra counter track"); 515| 2.17k| } 516| 0| data.extra_counter_values[index] = *abs_value; 517| 0| } 518| 0| return base::OkStatus(); 519| 5.29k|} _ZN8perfetto15trace_processor19TrackEventTokenizer21AddExtraCounterValuesIdEENS_4base6StatusERNS0_14TrackEventDataERmjN9protozero21RepeatedFieldIteratorIT_EENS9_ImEESC_: 480| 961k| protozero::RepeatedFieldIterator default_track_uuid_it) { 481| 961k| if (!value_it) ------------------ | Branch (481:7): [True: 961k, False: 188] ------------------ 482| 961k| return base::OkStatus(); 483| | 484| | // Consider extra_{double_,}counter_track_uuids from the packet and 485| | // TrackEventDefaults. 486| 188| protozero::RepeatedFieldIterator track_uuid_it; 487| 188| if (packet_track_uuid_it) { ------------------ | Branch (487:7): [True: 0, False: 188] ------------------ 488| 0| track_uuid_it = packet_track_uuid_it; 489| 188| } else if (default_track_uuid_it) { ------------------ | Branch (489:14): [True: 0, False: 188] ------------------ 490| 0| track_uuid_it = default_track_uuid_it; 491| 188| } else { 492| 188| return base::ErrStatus( 493| 188| "Ignoring TrackEvent with extra_{double_,}counter_values but without " 494| 188| "extra_{double_,}counter_track_uuids"); 495| 188| } 496| | 497| 0| for (; value_it; ++value_it, ++track_uuid_it, ++index) { ------------------ | Branch (497:10): [True: 0, False: 0] ------------------ 498| 0| if (!*track_uuid_it) { ------------------ | Branch (498:9): [True: 0, False: 0] ------------------ 499| 0| return base::ErrStatus( 500| 0| "Ignoring TrackEvent with more extra_{double_,}counter_values than " 501| 0| "extra_{double_,}counter_track_uuids"); 502| 0| } 503| 0| if (index >= TrackEventData::kMaxNumExtraCounters) { ------------------ | Branch (503:9): [True: 0, False: 0] ------------------ 504| 0| return base::ErrStatus( 505| 0| "Ignoring TrackEvent with more extra_{double_,}counter_values than " 506| 0| "TrackEventData::kMaxNumExtraCounters"); 507| 0| } 508| 0| std::optional abs_value = 509| 0| track_event_tracker_->ConvertToAbsoluteCounterValue( 510| 0| *track_uuid_it, trusted_packet_sequence_id, 511| 0| static_cast(*value_it)); 512| 0| if (!abs_value) { ------------------ | Branch (512:9): [True: 0, False: 0] ------------------ 513| 0| return base::ErrStatus( 514| 0| "Ignoring TrackEvent with invalid extra counter track"); 515| 0| } 516| 0| data.extra_counter_values[index] = *abs_value; 517| 0| } 518| 0| return base::OkStatus(); 519| 0|} _ZN8perfetto15trace_processor17TrackEventTrackerC2EPNS0_21TraceProcessorContextE: 85| 2.03k| : source_key_(context->storage->InternString("source")), 86| 2.03k| source_id_key_(context->storage->InternString("trace_id")), 87| 2.03k| is_root_in_scope_key_(context->storage->InternString("is_root_in_scope")), 88| 2.03k| category_key_(context->storage->InternString("category")), 89| | builtin_counter_type_key_( 90| 2.03k| context->storage->InternString("builtin_counter_type")), 91| | has_first_packet_on_sequence_key_id_( 92| 2.03k| context->storage->InternString("has_first_packet_on_sequence")), 93| 2.03k| child_ordering_key_(context->storage->InternString("child_ordering")), 94| 2.03k| explicit_id_(context->storage->InternString("explicit")), 95| 2.03k| lexicographic_id_(context->storage->InternString("lexicographic")), 96| 2.03k| chronological_id_(context->storage->InternString("chronological")), 97| | sibling_order_rank_key_( 98| 2.03k| context->storage->InternString("sibling_order_rank")), 99| 2.03k| descriptor_source_(context->storage->InternString("descriptor")), 100| | default_descriptor_track_name_( 101| 2.03k| context->storage->InternString("Default Track")), 102| 2.03k| context_(context) {} _ZN8perfetto15trace_processor17TrackEventTracker22ReserveDescriptorTrackEmRKNS1_26DescriptorTrackReservationE: 106| 116k| const DescriptorTrackReservation& reservation) { 107| 116k| if (uuid == kDefaultDescriptorTrackUuid && reservation.parent_uuid) { ------------------ | Branch (107:7): [True: 557, False: 115k] | Branch (107:46): [True: 16, False: 541] ------------------ 108| 16| PERFETTO_DLOG( 109| 16| "Default track (uuid 0) cannot have a parent uui specified. Ignoring " 110| 16| "the descriptor."); 111| 16| context_->storage->IncrementStats(stats::track_event_tokenizer_errors); 112| 16| return; 113| 16| } 114| | 115| 116k| auto [it, inserted] = reserved_descriptor_tracks_.Insert(uuid, reservation); 116| 116k| if (inserted) { ------------------ | Branch (116:7): [True: 93.5k, False: 22.9k] ------------------ 117| 93.5k| return; 118| 93.5k| } 119| | 120| 22.9k| if (!it->IsForSameTrack(reservation)) { ------------------ | Branch (120:7): [True: 15.2k, False: 7.68k] ------------------ 121| 15.2k| PERFETTO_DLOG("New track reservation for track with uuid %" PRIu64 122| 15.2k| " doesn't match earlier one", 123| 15.2k| uuid); 124| 15.2k| context_->storage->IncrementStats(stats::track_event_tokenizer_errors); 125| 15.2k| return; 126| 15.2k| } 127| 7.68k| it->min_timestamp = std::min(it->min_timestamp, reservation.min_timestamp); 128| 7.68k|} _ZN8perfetto15trace_processor17TrackEventTracker22GetDescriptorTrackImplEmNS0_10StringPool2IdENSt3__18optionalIjEE: 134| 843k| std::optional packet_sequence_id) { 135| 843k| auto* resolved_ptr = resolved_descriptor_tracks_.Find(uuid); 136| 843k| if (resolved_ptr) { ------------------ | Branch (136:7): [True: 742k, False: 101k] ------------------ 137| 742k| if (event_name.is_null()) { ------------------ | Branch (137:9): [True: 742k, False: 0] ------------------ 138| 742k| return *resolved_ptr; 139| 742k| } 140| | 141| | // Update the name to match the first non-null and valid event name. We need 142| | // this because TrackEventParser calls |GetDescriptorTrack| with 143| | // kNullStringId which means we cannot just have the code below for updating 144| | // the name 145| 0| DescriptorTrackReservation* reservation_ptr = 146| 0| reserved_descriptor_tracks_.Find(uuid); 147| 0| PERFETTO_CHECK(reservation_ptr); 148| 0| auto* tracks = context_->storage->mutable_track_table(); 149| 0| auto rr = *tracks->FindById(resolved_ptr->track_id()); 150| 0| bool is_root_thread_process_or_counter = reservation_ptr->pid || ------------------ | Branch (150:46): [True: 0, False: 0] ------------------ 151| 0| reservation_ptr->tid || ------------------ | Branch (151:46): [True: 0, False: 0] ------------------ 152| 0| reservation_ptr->is_counter; ------------------ | Branch (152:46): [True: 0, False: 0] ------------------ 153| 0| if (rr.name().is_null() && !is_root_thread_process_or_counter) { ------------------ | Branch (153:9): [True: 0, False: 0] | Branch (153:9): [True: 0, False: 0] | Branch (153:32): [True: 0, False: 0] ------------------ 154| 0| if (resolved_ptr->scope() == ResolvedDescriptorTrack::Scope::kProcess) { ------------------ | Branch (154:11): [True: 0, False: 0] ------------------ 155| 0| rr.set_name(context_->process_track_translation_table->TranslateName( 156| 0| event_name)); 157| 0| } else { 158| 0| rr.set_name(event_name); 159| 0| } 160| 0| } 161| 0| return *resolved_ptr; 162| 0| } 163| | 164| 101k| DescriptorTrackReservation* reservation_ptr = 165| 101k| reserved_descriptor_tracks_.Find(uuid); 166| 101k| if (!reservation_ptr) { ------------------ | Branch (166:7): [True: 468, False: 100k] ------------------ 167| 468| if (uuid != kDefaultDescriptorTrackUuid) { ------------------ | Branch (167:9): [True: 89, False: 379] ------------------ 168| 89| return std::nullopt; 169| 89| } 170| | 171| | // For the default track, if there's no reservation, forcefully create it 172| | // as it's always allowed to emit events on it, even without emitting a 173| | // descriptor. 174| 379| DescriptorTrackReservation r; 175| 379| r.parent_uuid = 0; 176| 379| r.name = default_descriptor_track_name_; 177| 379| ReserveDescriptorTrack(kDefaultDescriptorTrackUuid, r); 178| | 179| 379| reservation_ptr = reserved_descriptor_tracks_.Find(uuid); 180| 379| PERFETTO_CHECK(reservation_ptr); 181| 379| } 182| | 183| | // Before trying to resolve anything, ensure that the hierarchy of tracks is 184| | // well defined. 185| 101k| if (!IsTrackHierarchyValid(uuid)) { ------------------ | Branch (185:7): [True: 26.4k, False: 74.8k] ------------------ 186| 26.4k| return std::nullopt; 187| 26.4k| } 188| | 189| | // Resolve process and thread id for tracks produced from within a pid 190| | // namespace. 191| | // 192| | // Get the root-level trusted_pid for the process that produces the track 193| | // event. 194| 74.8k| std::optional trusted_pid = 195| 74.8k| context_->process_tracker->GetTrustedPid(uuid); 196| 74.8k| DescriptorTrackReservation& reservation = *reservation_ptr; 197| | 198| | // Try to resolve to root-level pid and tid if the process is pid-namespaced. 199| 74.8k| if (trusted_pid && reservation.tid) { ------------------ | Branch (199:7): [True: 842, False: 73.9k] | Branch (199:22): [True: 0, False: 842] ------------------ 200| 0| std::optional resolved_tid = 201| 0| context_->process_tracker->ResolveNamespacedTid(*trusted_pid, 202| 0| *reservation.tid); 203| 0| if (resolved_tid) { ------------------ | Branch (203:9): [True: 0, False: 0] ------------------ 204| 0| reservation.tid = *resolved_tid; 205| 0| } 206| 0| } 207| 74.8k| if (trusted_pid && reservation.pid) { ------------------ | Branch (207:7): [True: 842, False: 73.9k] | Branch (207:22): [True: 0, False: 842] ------------------ 208| 0| std::optional resolved_pid = 209| 0| context_->process_tracker->ResolveNamespacedTid(*trusted_pid, 210| 0| *reservation.pid); 211| 0| if (resolved_pid) { ------------------ | Branch (211:9): [True: 0, False: 0] ------------------ 212| 0| reservation.pid = *resolved_pid; 213| 0| } 214| 0| } 215| | 216| 74.8k| bool is_root_thread_process_or_counter = reservation_ptr->pid || ------------------ | Branch (216:44): [True: 38.7k, False: 36.1k] ------------------ 217| 74.8k| reservation_ptr->tid || ------------------ | Branch (217:44): [True: 0, False: 36.1k] ------------------ 218| 74.8k| reservation_ptr->is_counter; ------------------ | Branch (218:44): [True: 10.5k, False: 25.5k] ------------------ 219| 74.8k| if (reservation.name.is_null() && !is_root_thread_process_or_counter) { ------------------ | Branch (219:7): [True: 30.5k, False: 44.3k] | Branch (219:37): [True: 24.9k, False: 5.50k] ------------------ 220| 24.9k| reservation.name = event_name; 221| 24.9k| } 222| | 223| | // If the reservation does not have a name specified, name it the same 224| | // as the first event on the track. Note this only applies for non-root and 225| | // non-counter tracks. 226| 74.8k| auto [it, inserted] = resolved_descriptor_tracks_.Insert( 227| 74.8k| uuid, ResolveDescriptorTrack(uuid, reservation, packet_sequence_id)); 228| 74.8k| PERFETTO_CHECK(inserted); 229| 74.8k| return *it; 230| 74.8k|} _ZN8perfetto15trace_processor17TrackEventTracker22ResolveDescriptorTrackEmRKNS1_26DescriptorTrackReservationENSt3__18optionalIjEE: 236| 74.8k| std::optional packet_sequence_id) { 237| 74.8k| TrackTracker::SetArgsCallback args_fn_root = 238| 74.8k| [&, this](ArgsTracker::BoundInserter& inserter) { 239| 74.8k| AddTrackArgs(uuid, packet_sequence_id, reservation, true /* is_root*/, 240| 74.8k| inserter); 241| 74.8k| }; 242| 74.8k| TrackTracker::SetArgsCallback args_fn_non_root = 243| 74.8k| [&, this](ArgsTracker::BoundInserter& inserter) { 244| 74.8k| AddTrackArgs(uuid, packet_sequence_id, reservation, false /* is_root*/, 245| 74.8k| inserter); 246| 74.8k| }; 247| | 248| | // Try to resolve any parent tracks recursively, too. 249| 74.8k| std::optional parent_resolved_track; 250| 74.8k| if (reservation.parent_uuid != kDefaultDescriptorTrackUuid) { ------------------ | Branch (250:7): [True: 317, False: 74.5k] ------------------ 251| 317| parent_resolved_track = GetDescriptorTrackImpl( 252| 317| reservation.parent_uuid, kNullStringId, packet_sequence_id); 253| 317| } 254| | 255| 74.8k| if (reservation.tid) { ------------------ | Branch (255:7): [True: 3.84k, False: 70.9k] ------------------ 256| 3.84k| UniqueTid utid = context_->process_tracker->UpdateThread(*reservation.tid, 257| 3.84k| *reservation.pid); 258| 3.84k| auto [it, inserted] = descriptor_uuids_by_utid_.Insert(utid, uuid); 259| 3.84k| if (!inserted) { ------------------ | Branch (259:9): [True: 1.90k, False: 1.94k] ------------------ 260| | // We already saw a another track with a different uuid for this thread. 261| | // Since there should only be one descriptor track for each thread, we 262| | // assume that its tid was reused. So, start a new thread. 263| 1.90k| uint64_t old_uuid = *it; 264| 1.90k| PERFETTO_DCHECK(old_uuid != uuid); // Every track is only resolved once. 265| 1.90k| *it = uuid; 266| | 267| 1.90k| PERFETTO_DLOG("Detected tid reuse (pid: %" PRIu32 " tid: %" PRIu32 268| 1.90k| ") from track descriptors (old uuid: %" PRIu64 269| 1.90k| " new uuid: %" PRIu64 " timestamp: %" PRId64 ")", 270| 1.90k| *reservation.pid, *reservation.tid, old_uuid, uuid, 271| 1.90k| reservation.min_timestamp); 272| | 273| | // Associate the new thread with its process. 274| 1.90k| utid = context_->process_tracker->StartNewThread(std::nullopt, 275| 1.90k| *reservation.tid); 276| 1.90k| UniqueTid updated_utid = context_->process_tracker->UpdateThread( 277| 1.90k| *reservation.tid, *reservation.pid); 278| 1.90k| PERFETTO_CHECK(updated_utid == utid); 279| 1.90k| } 280| | 281| 3.84k| TrackId id; 282| 3.84k| if (reservation.is_counter) { ------------------ | Branch (282:9): [True: 0, False: 3.84k] ------------------ 283| 0| id = context_->track_tracker->InternTrack( 284| 0| kThreadCounterTrackBlueprint, 285| 0| tracks::Dimensions(utid, static_cast(uuid)), 286| 0| tracks::DynamicName(reservation.name), args_fn_root, 287| 0| tracks::DynamicUnit(reservation.counter_details->unit)); 288| 3.84k| } else if (reservation.use_separate_track) { ------------------ | Branch (288:16): [True: 6, False: 3.84k] ------------------ 289| 6| id = context_->track_tracker->InternTrack( 290| 6| kThreadTrackBlueprint, 291| 6| tracks::Dimensions(utid, static_cast(uuid)), 292| 6| tracks::DynamicName(reservation.name), args_fn_root); 293| 3.84k| } else { 294| 3.84k| id = context_->track_tracker->InternThreadTrack(utid); 295| 3.84k| } 296| 3.84k| return ResolvedDescriptorTrack::Thread(id, utid, reservation.is_counter, 297| 3.84k| true /* is_root*/); 298| 3.84k| } 299| | 300| 70.9k| if (reservation.pid) { ------------------ | Branch (300:7): [True: 34.8k, False: 36.1k] ------------------ 301| 34.8k| UniquePid upid = 302| 34.8k| context_->process_tracker->GetOrCreateProcess(*reservation.pid); 303| 34.8k| auto [it, inserted] = descriptor_uuids_by_upid_.Insert(upid, uuid); 304| 34.8k| if (!inserted) { ------------------ | Branch (304:9): [True: 6.44k, False: 28.4k] ------------------ 305| | // We already saw a another track with a different uuid for this process. 306| | // Since there should only be one descriptor track for each process, 307| | // we assume that its pid was reused. So, start a new process. 308| 6.44k| uint64_t old_uuid = *it; 309| 6.44k| PERFETTO_DCHECK(old_uuid != uuid); // Every track is only resolved once. 310| 6.44k| *it = uuid; 311| | 312| 6.44k| PERFETTO_DLOG("Detected pid reuse (pid: %" PRIu32 313| 6.44k| ") from track descriptors (old uuid: %" PRIu64 314| 6.44k| " new uuid: %" PRIu64 " timestamp: %" PRId64 ")", 315| 6.44k| *reservation.pid, old_uuid, uuid, 316| 6.44k| reservation.min_timestamp); 317| | 318| 6.44k| upid = context_->process_tracker->StartNewProcess( 319| 6.44k| std::nullopt, std::nullopt, *reservation.pid, kNullStringId, 320| 6.44k| ThreadNamePriority::kTrackDescriptor); 321| 6.44k| } 322| 34.8k| StringId translated_name = 323| 34.8k| context_->process_track_translation_table->TranslateName( 324| 34.8k| reservation.name); 325| 34.8k| TrackId id; 326| 34.8k| if (reservation.is_counter) { ------------------ | Branch (326:9): [True: 0, False: 34.8k] ------------------ 327| 0| id = context_->track_tracker->InternTrack( 328| 0| kProcessCounterTrackBlueprint, 329| 0| tracks::Dimensions(upid, static_cast(uuid)), 330| 0| tracks::DynamicName(translated_name), args_fn_root, 331| 0| tracks::DynamicUnit(reservation.counter_details->unit)); 332| 34.8k| } else { 333| 34.8k| id = context_->track_tracker->InternTrack( 334| 34.8k| kProcessTrackBlueprint, 335| 34.8k| tracks::Dimensions(upid, static_cast(uuid)), 336| 34.8k| tracks::DynamicName(translated_name), args_fn_root); 337| 34.8k| } 338| 34.8k| return ResolvedDescriptorTrack::Process(id, upid, reservation.is_counter, 339| 34.8k| true /* is_root*/); 340| 34.8k| } 341| | 342| 36.1k| auto set_parent_id = [&](TrackId id) { 343| 36.1k| if (parent_resolved_track) { 344| 36.1k| auto rr = context_->storage->mutable_track_table()->FindById(id); 345| 36.1k| PERFETTO_CHECK(rr); 346| 36.1k| rr->set_parent_id(parent_resolved_track->track_id()); 347| 36.1k| } 348| 36.1k| }; 349| | 350| 36.1k| if (parent_resolved_track) { ------------------ | Branch (350:7): [True: 301, False: 35.8k] ------------------ 351| 301| switch (parent_resolved_track->scope()) { ------------------ | Branch (351:13): [True: 0, False: 301] ------------------ 352| 101| case ResolvedDescriptorTrack::Scope::kThread: { ------------------ | Branch (352:7): [True: 101, False: 200] ------------------ 353| | // If parent is a thread track, create another thread-associated track. 354| 101| TrackId id; 355| 101| if (reservation.is_counter) { ------------------ | Branch (355:13): [True: 24, False: 77] ------------------ 356| 24| id = context_->track_tracker->InternTrack( 357| 24| kThreadCounterTrackBlueprint, 358| 24| tracks::Dimensions(parent_resolved_track->utid(), 359| 24| static_cast(uuid)), 360| 24| tracks::DynamicName(reservation.name), args_fn_non_root, 361| 24| tracks::DynamicUnit(reservation.counter_details->unit)); 362| 77| } else { 363| 77| id = context_->track_tracker->InternTrack( 364| 77| kThreadTrackBlueprint, 365| 77| tracks::Dimensions(parent_resolved_track->utid(), 366| 77| static_cast(uuid)), 367| 77| tracks::DynamicName(reservation.name), args_fn_non_root); 368| 77| } 369| | // If the parent has a process descriptor set, promote this track 370| | // to also be a root thread level track. This is necessary for 371| | // backcompat reasons: see the comment on parent_uuid in 372| | // TrackDescriptor. 373| 101| if (!parent_resolved_track->is_root()) { ------------------ | Branch (373:13): [True: 0, False: 101] ------------------ 374| 0| set_parent_id(id); 375| 0| } 376| 101| return ResolvedDescriptorTrack::Thread( 377| 101| id, parent_resolved_track->utid(), reservation.is_counter, 378| 101| false /* is_root*/); 379| 0| } 380| 177| case ResolvedDescriptorTrack::Scope::kProcess: { ------------------ | Branch (380:7): [True: 177, False: 124] ------------------ 381| | // If parent is a process track, create another process-associated 382| | // track. 383| 177| StringId translated_name = 384| 177| context_->process_track_translation_table->TranslateName( 385| 177| reservation.name); 386| 177| TrackId id; 387| 177| if (reservation.is_counter) { ------------------ | Branch (387:13): [True: 136, False: 41] ------------------ 388| 136| id = context_->track_tracker->InternTrack( 389| 136| kProcessCounterTrackBlueprint, 390| 136| tracks::Dimensions(parent_resolved_track->upid(), 391| 136| static_cast(uuid)), 392| 136| tracks::DynamicName(translated_name), args_fn_non_root, 393| 136| tracks::DynamicUnit(reservation.counter_details->unit)); 394| 136| } else { 395| 41| id = context_->track_tracker->InternTrack( 396| 41| kProcessTrackBlueprint, 397| 41| tracks::Dimensions(parent_resolved_track->upid(), 398| 41| static_cast(uuid)), 399| 41| tracks::DynamicName(translated_name), args_fn_non_root); 400| 41| } 401| | // If the parent has a thread descriptor set, promote this track 402| | // to also be a root thread level track. This is necessary for 403| | // backcompat reasons: see the comment on parent_uuid in 404| | // TrackDescriptor. 405| 177| if (!parent_resolved_track->is_root()) { ------------------ | Branch (405:13): [True: 0, False: 177] ------------------ 406| 0| set_parent_id(id); 407| 0| } 408| 177| return ResolvedDescriptorTrack::Process( 409| 177| id, parent_resolved_track->upid(), reservation.is_counter, 410| 177| false /* is_root*/); 411| 0| } 412| 23| case ResolvedDescriptorTrack::Scope::kGlobal: ------------------ | Branch (412:7): [True: 23, False: 278] ------------------ 413| 23| break; 414| 301| } 415| 301| } 416| | 417| | // root_in_scope only matters for legacy JSON export. This is somewhat related 418| | // but intentionally distinct from our handling of parent_id relationships. 419| 35.8k| bool is_root_in_scope = uuid == kDefaultDescriptorTrackUuid; 420| 35.8k| TrackId id; 421| 35.8k| if (reservation.is_counter) { ------------------ | Branch (421:7): [True: 10.3k, False: 25.4k] ------------------ 422| 10.3k| id = context_->track_tracker->InternTrack( 423| 10.3k| kGlobalCounterTrackBlueprint, 424| 10.3k| tracks::Dimensions(static_cast(uuid)), 425| 10.3k| tracks::DynamicName(reservation.name), 426| 10.3k| is_root_in_scope ? args_fn_root : args_fn_non_root, ------------------ | Branch (426:9): [True: 0, False: 10.3k] ------------------ 427| 10.3k| tracks::DynamicUnit(reservation.counter_details->unit)); 428| 25.4k| } else { 429| 25.4k| id = context_->track_tracker->InternTrack( 430| 25.4k| kGlobalTrackBlueprint, tracks::Dimensions(static_cast(uuid)), 431| 25.4k| tracks::DynamicName(reservation.name), 432| 25.4k| is_root_in_scope ? args_fn_root : args_fn_non_root); ------------------ | Branch (432:9): [True: 380, False: 25.0k] ------------------ 433| 25.4k| } 434| 35.8k| set_parent_id(id); 435| 35.8k| return ResolvedDescriptorTrack::Global(id, reservation.is_counter); 436| 36.1k|} _ZN8perfetto15trace_processor17TrackEventTracker29ConvertToAbsoluteCounterValueEmjd: 441| 2.17k| double value) { 442| 2.17k| auto* reservation_ptr = reserved_descriptor_tracks_.Find(counter_track_uuid); 443| 2.17k| if (!reservation_ptr) { ------------------ | Branch (443:7): [True: 2.17k, False: 0] ------------------ 444| 2.17k| PERFETTO_DLOG("Unknown counter track with uuid %" PRIu64, 445| 2.17k| counter_track_uuid); 446| 2.17k| return std::nullopt; 447| 2.17k| } 448| | 449| 0| DescriptorTrackReservation& reservation = *reservation_ptr; 450| 0| if (!reservation.is_counter) { ------------------ | Branch (450:7): [True: 0, False: 0] ------------------ 451| 0| PERFETTO_DLOG("Track with uuid %" PRIu64 " is not a counter track", 452| 0| counter_track_uuid); 453| 0| return std::nullopt; 454| 0| } 455| 0| if (!reservation.counter_details) { ------------------ | Branch (455:7): [True: 0, False: 0] ------------------ 456| 0| PERFETTO_FATAL("Counter tracks require `counter_details`."); 457| 0| } 458| 0| DescriptorTrackReservation::CounterDetails& c_details = 459| 0| *reservation.counter_details; 460| | 461| 0| if (c_details.unit_multiplier > 0) ------------------ | Branch (461:7): [True: 0, False: 0] ------------------ 462| 0| value *= static_cast(c_details.unit_multiplier); 463| | 464| 0| if (c_details.is_incremental) { ------------------ | Branch (464:7): [True: 0, False: 0] ------------------ 465| 0| if (c_details.packet_sequence_id != packet_sequence_id) { ------------------ | Branch (465:9): [True: 0, False: 0] ------------------ 466| 0| PERFETTO_DLOG( 467| 0| "Incremental counter track with uuid %" PRIu64 468| 0| " was updated from the wrong packet sequence (expected: %" PRIu32 469| 0| " got:%" PRIu32 ")", 470| 0| counter_track_uuid, c_details.packet_sequence_id, packet_sequence_id); 471| 0| return std::nullopt; 472| 0| } 473| | 474| 0| c_details.latest_value += value; 475| 0| value = c_details.latest_value; 476| 0| } 477| 0| return value; 478| 0|} _ZN8perfetto15trace_processor17TrackEventTracker25OnIncrementalStateClearedEj: 480| 10.1k|void TrackEventTracker::OnIncrementalStateCleared(uint32_t packet_sequence_id) { 481| | // TODO(eseckler): Improve on the runtime complexity of this. At O(hundreds) 482| | // of packet sequences, incremental state clearing at O(trace second), and 483| | // total number of tracks in O(thousands), a linear scan through all tracks 484| | // here might not be fast enough. 485| 1.24M| for (auto it = reserved_descriptor_tracks_.GetIterator(); it; ++it) { ------------------ | Branch (485:61): [True: 1.23M, False: 10.1k] ------------------ 486| 1.23M| DescriptorTrackReservation& reservation = it.value(); 487| | // Only consider incremental counter tracks for current sequence. 488| 1.23M| if (!reservation.is_counter || !reservation.counter_details || ------------------ | Branch (488:9): [True: 1.09M, False: 143k] | Branch (488:36): [True: 0, False: 143k] ------------------ 489| 1.23M| !reservation.counter_details->is_incremental || ------------------ | Branch (489:9): [True: 120k, False: 22.8k] ------------------ 490| 1.23M| reservation.counter_details->packet_sequence_id != packet_sequence_id) { ------------------ | Branch (490:9): [True: 12.3k, False: 10.5k] ------------------ 491| 1.22M| continue; 492| 1.22M| } 493| | // Reset their value to 0, see CounterDescriptor's |is_incremental|. 494| 10.5k| reservation.counter_details->latest_value = 0; 495| 10.5k| } 496| 10.1k|} _ZN8perfetto15trace_processor17TrackEventTracker23OnFirstPacketOnSequenceEj: 498| 1|void TrackEventTracker::OnFirstPacketOnSequence(uint32_t packet_sequence_id) { 499| 1| sequences_with_first_packet_.insert(packet_sequence_id); 500| 1|} _ZN8perfetto15trace_processor17TrackEventTracker12AddTrackArgsEmNSt3__18optionalIjEERKNS1_26DescriptorTrackReservationEbRNS0_11ArgsTracker13BoundInserterE: 507| 70.9k| ArgsTracker::BoundInserter& args) { 508| 70.9k| args.AddArg(source_key_, Variadic::String(descriptor_source_)) 509| 70.9k| .AddArg(source_id_key_, Variadic::Integer(static_cast(uuid))) 510| 70.9k| .AddArg(is_root_in_scope_key_, Variadic::Boolean(is_root_in_scope)); 511| 70.9k| if (reservation.counter_details) { ------------------ | Branch (511:7): [True: 10.5k, False: 60.4k] ------------------ 512| 10.5k| if (!reservation.counter_details->category.is_null()) { ------------------ | Branch (512:9): [True: 4.68k, False: 5.86k] ------------------ 513| 4.68k| args.AddArg(category_key_, 514| 4.68k| Variadic::String(reservation.counter_details->category)); 515| 4.68k| } 516| 10.5k| if (!reservation.counter_details->builtin_type_str.is_null()) { ------------------ | Branch (516:9): [True: 118, False: 10.4k] ------------------ 517| 118| args.AddArg( 518| 118| builtin_counter_type_key_, 519| 118| Variadic::String(reservation.counter_details->builtin_type_str)); 520| 118| } 521| 10.5k| } 522| 70.9k| if (packet_sequence_id && ------------------ | Branch (522:7): [True: 70.6k, False: 380] | Branch (522:7): [True: 0, False: 70.9k] ------------------ 523| 70.9k| sequences_with_first_packet_.find(*packet_sequence_id) != ------------------ | Branch (523:7): [True: 0, False: 70.6k] ------------------ 524| 70.6k| sequences_with_first_packet_.end()) { 525| 0| args.AddArg(has_first_packet_on_sequence_key_id_, Variadic::Boolean(true)); 526| 0| } 527| | 528| 70.9k| switch (reservation.ordering) { ------------------ | Branch (528:11): [True: 0, False: 70.9k] ------------------ 529| 0| case DescriptorTrackReservation::ChildTracksOrdering::kLexicographic: ------------------ | Branch (529:5): [True: 0, False: 70.9k] ------------------ 530| 0| args.AddArg(child_ordering_key_, Variadic::String(lexicographic_id_)); 531| 0| break; 532| 0| case DescriptorTrackReservation::ChildTracksOrdering::kChronological: ------------------ | Branch (532:5): [True: 0, False: 70.9k] ------------------ 533| 0| args.AddArg(child_ordering_key_, Variadic::String(chronological_id_)); 534| 0| break; 535| 0| case DescriptorTrackReservation::ChildTracksOrdering::kExplicit: ------------------ | Branch (535:5): [True: 0, False: 70.9k] ------------------ 536| 0| args.AddArg(child_ordering_key_, Variadic::String(explicit_id_)); 537| 0| break; 538| 70.9k| case DescriptorTrackReservation::ChildTracksOrdering::kUnknown: ------------------ | Branch (538:5): [True: 70.9k, False: 0] ------------------ 539| 70.9k| break; 540| 70.9k| } 541| | 542| 70.9k| if (reservation.sibling_order_rank) { ------------------ | Branch (542:7): [True: 24, False: 70.9k] ------------------ 543| 24| args.AddArg(sibling_order_rank_key_, 544| 24| Variadic::Integer(*reservation.sibling_order_rank)); 545| 24| } 546| 70.9k|} _ZN8perfetto15trace_processor17TrackEventTracker21IsTrackHierarchyValidEm: 548| 101k|bool TrackEventTracker::IsTrackHierarchyValid(uint64_t uuid) { 549| | // Do a basic tree walking algorithm to find if there are duplicate ids or 550| | // the path to the root is longer than kMaxAncestors. 551| 101k| static constexpr size_t kMaxAncestors = 100; 552| 101k| std::array seen; 553| 101k| uint64_t current_uuid = uuid; 554| 204k| for (uint32_t i = 0; i < kMaxAncestors; ++i) { ------------------ | Branch (554:24): [True: 204k, False: 0] ------------------ 555| 204k| if (current_uuid == 0) { ------------------ | Branch (555:9): [True: 74.8k, False: 129k] ------------------ 556| 74.8k| return true; 557| 74.8k| } 558| 152k| for (uint32_t j = 0; j < i; ++j) { ------------------ | Branch (558:26): [True: 30.5k, False: 121k] ------------------ 559| 30.5k| if (current_uuid == seen[j]) { ------------------ | Branch (559:11): [True: 7.95k, False: 22.5k] ------------------ 560| 7.95k| PERFETTO_ELOG("Loop detected in hierarchy for track %" PRIu64, uuid); 561| 7.95k| return false; 562| 7.95k| } 563| 30.5k| } 564| 121k| auto* reservation_ptr = reserved_descriptor_tracks_.Find(current_uuid); 565| 121k| if (!reservation_ptr) { ------------------ | Branch (565:9): [True: 18.4k, False: 103k] ------------------ 566| 18.4k| PERFETTO_ELOG("Missing uuid in hierarchy for track %" PRIu64, uuid); 567| 18.4k| return false; 568| 18.4k| } 569| 103k| seen[i] = current_uuid; 570| 103k| current_uuid = reservation_ptr->parent_uuid; 571| 103k| } 572| 0| PERFETTO_ELOG("Too many ancestors in hierarchy for track %" PRIu64, uuid); 573| 0| return false; 574| 101k|} _ZN8perfetto15trace_processor17TrackEventTracker23ResolvedDescriptorTrack7ProcessENS0_6tables10TrackTable2IdEjbb: 580| 35.0k| bool is_root) { 581| 35.0k| ResolvedDescriptorTrack track; 582| 35.0k| track.track_id_ = track_id; 583| 35.0k| track.scope_ = Scope::kProcess; 584| 35.0k| track.is_counter_ = is_counter; 585| 35.0k| track.upid_ = upid; 586| 35.0k| track.is_root_ = is_root; 587| 35.0k| return track; 588| 35.0k|} _ZN8perfetto15trace_processor17TrackEventTracker23ResolvedDescriptorTrack6ThreadENS0_6tables10TrackTable2IdEjbb: 594| 3.94k| bool is_root) { 595| 3.94k| ResolvedDescriptorTrack track; 596| 3.94k| track.track_id_ = track_id; 597| 3.94k| track.scope_ = Scope::kThread; 598| 3.94k| track.is_counter_ = is_counter; 599| 3.94k| track.utid_ = utid; 600| 3.94k| track.is_root_ = is_root; 601| 3.94k| return track; 602| 3.94k|} _ZN8perfetto15trace_processor17TrackEventTracker23ResolvedDescriptorTrack6GlobalENS0_6tables10TrackTable2IdEb: 606| 35.8k| bool is_counter) { 607| 35.8k| ResolvedDescriptorTrack track; 608| 35.8k| track.track_id_ = track_id; 609| 35.8k| track.scope_ = Scope::kGlobal; 610| 35.8k| track.is_counter_ = is_counter; 611| 35.8k| track.is_root_ = false; 612| 35.8k| return track; 613| 35.8k|} track_event_tracker.cc:_ZZN8perfetto15trace_processor17TrackEventTracker22ResolveDescriptorTrackEmRKNS1_26DescriptorTrackReservationENSt3__18optionalIjEEENK3$_2clENS0_6tables10TrackTable2IdE: 342| 35.8k| auto set_parent_id = [&](TrackId id) { 343| 35.8k| if (parent_resolved_track) { ------------------ | Branch (343:9): [True: 23, False: 35.8k] ------------------ 344| 23| auto rr = context_->storage->mutable_track_table()->FindById(id); 345| 23| PERFETTO_CHECK(rr); 346| 23| rr->set_parent_id(parent_resolved_track->track_id()); 347| 23| } 348| 35.8k| }; track_event_tracker.cc:_ZZN8perfetto15trace_processor17TrackEventTracker22ResolveDescriptorTrackEmRKNS1_26DescriptorTrackReservationENSt3__18optionalIjEEENK3$_0clERNS0_11ArgsTracker13BoundInserterE: 238| 35.2k| [&, this](ArgsTracker::BoundInserter& inserter) { 239| 35.2k| AddTrackArgs(uuid, packet_sequence_id, reservation, true /* is_root*/, 240| 35.2k| inserter); 241| 35.2k| }; track_event_tracker.cc:_ZZN8perfetto15trace_processor17TrackEventTracker22ResolveDescriptorTrackEmRKNS1_26DescriptorTrackReservationENSt3__18optionalIjEEENK3$_1clERNS0_11ArgsTracker13BoundInserterE: 243| 35.7k| [&, this](ArgsTracker::BoundInserter& inserter) { 244| 35.7k| AddTrackArgs(uuid, packet_sequence_id, reservation, false /* is_root*/, 245| 35.7k| inserter); 246| 35.7k| }; _ZNK8perfetto15trace_processor17TrackEventTracker26DescriptorTrackReservation14CounterDetails14IsForSameTrackERKS3_: 58| 5.45k| bool IsForSameTrack(const CounterDetails& o) const { 59| 5.45k| return std::tie(category, unit_multiplier, is_incremental, 60| 5.45k| packet_sequence_id, builtin_type_str) == 61| 5.45k| std::tie(o.category, o.unit_multiplier, o.is_incremental, 62| 5.45k| o.packet_sequence_id, o.builtin_type_str); 63| 5.45k| } _ZN8perfetto15trace_processor17TrackEventTracker26DescriptorTrackReservation14IsForSameTrackERKS2_: 83| 22.9k| bool IsForSameTrack(const DescriptorTrackReservation& other) { 84| 22.9k| if (counter_details.has_value() != other.counter_details.has_value()) { ------------------ | Branch (84:11): [True: 3.75k, False: 19.1k] ------------------ 85| 3.75k| return false; 86| 3.75k| } 87| 19.1k| if (counter_details && ------------------ | Branch (87:11): [True: 5.45k, False: 13.7k] ------------------ 88| 19.1k| !counter_details->IsForSameTrack(*other.counter_details)) { ------------------ | Branch (88:11): [True: 3.99k, False: 1.46k] ------------------ 89| 3.99k| return false; 90| 3.99k| } 91| 15.1k| return std::tie(parent_uuid, pid, tid, is_counter) == 92| 15.1k| std::tie(other.parent_uuid, other.pid, other.tid, 93| 15.1k| other.is_counter); 94| 19.1k| } _ZN8perfetto15trace_processor17TrackEventTracker18GetDescriptorTrackEmNS0_10StringPool2IdENSt3__18optionalIjEE: 118| 843k| std::optional packet_sequence_id = std::nullopt) { 119| 843k| auto res = GetDescriptorTrackImpl(uuid, event_name, packet_sequence_id); 120| 843k| if (!res) { ------------------ | Branch (120:9): [True: 26.5k, False: 816k] ------------------ 121| 26.5k| return std::nullopt; 122| 26.5k| } 123| 816k| return res->track_id(); 124| 843k| } _ZNK8perfetto15trace_processor17TrackEventTracker26range_of_interest_start_usEv: 143| 877k| std::optional range_of_interest_start_us() const { 144| 877k| return range_of_interest_start_us_; 145| 877k| } _ZNK8perfetto15trace_processor17TrackEventTracker23ResolvedDescriptorTrack8track_idEv: 170| 816k| TrackId track_id() const { return track_id_; } _ZNK8perfetto15trace_processor17TrackEventTracker23ResolvedDescriptorTrack5scopeEv: 171| 301| Scope scope() const { return scope_; } _ZNK8perfetto15trace_processor17TrackEventTracker23ResolvedDescriptorTrack4utidEv: 173| 202| UniqueTid utid() const { 174| 202| PERFETTO_DCHECK(scope() == Scope::kThread); 175| 202| return utid_; 176| 202| } _ZNK8perfetto15trace_processor17TrackEventTracker23ResolvedDescriptorTrack4upidEv: 177| 354| UniquePid upid() const { 178| 354| PERFETTO_DCHECK(scope() == Scope::kProcess); 179| 354| return upid_; 180| 354| } _ZNK8perfetto15trace_processor17TrackEventTracker23ResolvedDescriptorTrack7is_rootEv: 181| 278| bool is_root() const { return is_root_; } _ZN8perfetto15trace_processor11TraceSorterC2EPNS0_21TraceProcessorContextENS1_11SortingModeENS1_13EventHandlingE: 51| 424| : sorting_mode_(sorting_mode), 52| 424| storage_(context->storage), 53| 424| event_handling_(event_handling) { 54| 424| AddMachineContext(context); 55| 424|} _ZN8perfetto15trace_processor11TraceSorterD2Ev: 57| 424|TraceSorter::~TraceSorter() { 58| | // If trace processor encountered a fatal error, it's possible for some events 59| | // to have been pushed without evicting them by pushing to the next stage. Do 60| | // that now. 61| 2.02k| for (auto& sorter_data : sorter_data_by_machine_) { ------------------ | Branch (61:26): [True: 2.02k, False: 424] ------------------ 62| 2.02k| for (auto& queue : sorter_data.queues) { ------------------ | Branch (62:22): [True: 649, False: 2.02k] ------------------ 63| 1.02M| for (const auto& event : queue.events_) { ------------------ | Branch (63:30): [True: 1.02M, False: 649] ------------------ 64| 1.02M| ExtractAndDiscardTokenizedObject(event); 65| 1.02M| } 66| 649| } 67| 2.02k| } 68| 424|} _ZN8perfetto15trace_processor11TraceSorter14SetSortingModeENS1_11SortingModeE: 70| 1|bool TraceSorter::SetSortingMode(SortingMode sorting_mode) { 71| | // Early out if the new sorting mode matches the old. 72| 1| if (sorting_mode == sorting_mode_) { ------------------ | Branch (72:7): [True: 0, False: 1] ------------------ 73| 0| return true; 74| 0| } 75| | // We cannot transition back to a more relaxed mode after having left that 76| | // mode. 77| 1| if (sorting_mode_ != SortingMode::kDefault) { ------------------ | Branch (77:7): [True: 0, False: 1] ------------------ 78| 0| return false; 79| 0| } 80| | // We cannot change sorting mode after having extracted one or more events. 81| 1| if (latest_pushed_event_ts_ != std::numeric_limits::min()) { ------------------ | Branch (81:7): [True: 0, False: 1] ------------------ 82| 0| return false; 83| 0| } 84| 1| sorting_mode_ = sorting_mode; 85| 1| return true; 86| 1|} _ZN8perfetto15trace_processor11TraceSorter5Queue4SortERNS0_16TraceTokenBufferEb: 88| 12.8k|void TraceSorter::Queue::Sort(TraceTokenBuffer& buffer, bool use_slow_sorting) { 89| 12.8k| PERFETTO_DCHECK(needs_sorting()); 90| 12.8k| PERFETTO_DCHECK(sort_start_idx_ < events_.size()); 91| | 92| | // If sort_min_ts_ has been set, it will no long be max_int, and so will be 93| | // smaller than max_ts_. 94| 12.8k| PERFETTO_DCHECK(sort_min_ts_ < std::numeric_limits::max()); 95| | 96| | // We know that all events between [0, sort_start_idx_] are sorted. Within 97| | // this range, perform a bound search and find the iterator for the min 98| | // timestamp that broke the monotonicity. Re-sort from there to the end. 99| 12.8k| auto sort_end = events_.begin() + static_cast(sort_start_idx_); 100| 12.8k| if (use_slow_sorting) { ------------------ | Branch (100:7): [True: 0, False: 12.8k] ------------------ 101| 0| PERFETTO_DCHECK(sort_min_ts_ <= max_ts_); 102| 0| PERFETTO_DCHECK(std::is_sorted(events_.begin(), sort_end, 103| 0| TimestampedEvent::SlowOperatorLess{buffer})); 104| 12.8k| } else { 105| 12.8k| PERFETTO_DCHECK(sort_min_ts_ < max_ts_); 106| 12.8k| PERFETTO_DCHECK(std::is_sorted(events_.begin(), sort_end)); 107| 12.8k| } 108| 12.8k| auto sort_begin = std::lower_bound(events_.begin(), sort_end, sort_min_ts_, 109| 12.8k| &TimestampedEvent::Compare); 110| 12.8k| if (use_slow_sorting) { ------------------ | Branch (110:7): [True: 0, False: 12.8k] ------------------ 111| 0| std::sort(sort_begin, events_.end(), 112| 0| TimestampedEvent::SlowOperatorLess{buffer}); 113| 12.8k| } else { 114| 12.8k| std::sort(sort_begin, events_.end()); 115| 12.8k| } 116| 12.8k| sort_start_idx_ = 0; 117| 12.8k| sort_min_ts_ = 0; 118| | 119| | // At this point |events_| must be fully sorted 120| 12.8k| if (use_slow_sorting) { ------------------ | Branch (120:7): [True: 0, False: 12.8k] ------------------ 121| 0| PERFETTO_DCHECK(std::is_sorted(events_.begin(), events_.end(), 122| 0| TimestampedEvent::SlowOperatorLess{buffer})); 123| 12.8k| } else { 124| 12.8k| PERFETTO_DCHECK(std::is_sorted(events_.begin(), events_.end())); 125| 12.8k| } 126| 12.8k|} _ZN8perfetto15trace_processor11TraceSorter32SortAndExtractEventsUntilAllocIdENS0_13BumpAllocator7AllocIdE: 149| 15.0k| BumpAllocator::AllocId limit_alloc_id) { 150| 15.0k| constexpr int64_t kTsMax = std::numeric_limits::max(); 151| 28.3k| for (;;) { 152| 28.3k| size_t min_machine_idx = 0; 153| 28.3k| size_t min_queue_idx = 0; // The index of the queue with the min(ts). 154| | 155| | // The top-2 min(ts) among all queues. 156| | // queues_[min_queue_idx].events.timestamp == min_queue_ts[0]. 157| 28.3k| int64_t min_queue_ts[2]{kTsMax, kTsMax}; 158| | 159| | // This loop identifies the queue which starts with the earliest event and 160| | // also remembers the earliest event of the 2nd queue (in min_queue_ts[1]). 161| 28.3k| bool all_queues_empty = true; 162| 981k| for (size_t m = 0; m < sorter_data_by_machine_.size(); m++) { ------------------ | Branch (162:24): [True: 952k, False: 28.3k] ------------------ 163| 952k| TraceSorterData& sorter_data = sorter_data_by_machine_[m]; 164| 1.90M| for (size_t i = 0; i < sorter_data.queues.size(); i++) { ------------------ | Branch (164:26): [True: 951k, False: 952k] ------------------ 165| 951k| auto& queue = sorter_data.queues[i]; 166| 951k| if (queue.events_.empty()) ------------------ | Branch (166:13): [True: 270k, False: 681k] ------------------ 167| 270k| continue; 168| 681k| PERFETTO_DCHECK(queue.max_ts_ <= append_max_ts_); 169| | 170| | // Checking for |all_queues_empty| is necessary here as in fuzzer cases 171| | // we can end up with |int64::max()| as the value here. 172| | // See https://crbug.com/oss-fuzz/69164 for an example. 173| 681k| if (all_queues_empty || queue.min_ts_ < min_queue_ts[0]) { ------------------ | Branch (173:13): [True: 26.0k, False: 655k] | Branch (173:33): [True: 21, False: 655k] ------------------ 174| 26.1k| min_queue_ts[1] = min_queue_ts[0]; 175| 26.1k| min_queue_ts[0] = queue.min_ts_; 176| 26.1k| min_queue_idx = i; 177| 26.1k| min_machine_idx = m; 178| 655k| } else if (queue.min_ts_ < min_queue_ts[1]) { ------------------ | Branch (178:20): [True: 2.86k, False: 652k] ------------------ 179| 2.86k| min_queue_ts[1] = queue.min_ts_; 180| 2.86k| } 181| 681k| all_queues_empty = false; 182| 681k| } 183| 952k| } 184| 28.3k| if (all_queues_empty) ------------------ | Branch (184:9): [True: 2.22k, False: 26.0k] ------------------ 185| 2.22k| break; 186| | 187| 26.0k| auto& sorter_data = sorter_data_by_machine_[min_machine_idx]; 188| 26.0k| auto& queue = sorter_data.queues[min_queue_idx]; 189| 26.0k| auto& events = queue.events_; 190| 26.0k| if (queue.needs_sorting()) ------------------ | Branch (190:9): [True: 12.8k, False: 13.2k] ------------------ 191| 12.8k| queue.Sort(token_buffer_, use_slow_sorting_); 192| 26.0k| PERFETTO_DCHECK(queue.min_ts_ == events.front().ts); 193| | 194| | // Now that we identified the min-queue, extract all events from it until 195| | // we hit either: (1) the min-ts of the 2nd queue or (2) the packet index 196| | // limit, whichever comes first. 197| 26.0k| size_t num_extracted = 0; 198| 2.71M| for (auto& event : events) { ------------------ | Branch (198:22): [True: 2.71M, False: 2.47k] ------------------ 199| 2.71M| if (event.alloc_id() >= limit_alloc_id) { ------------------ | Branch (199:11): [True: 23.6k, False: 2.69M] ------------------ 200| 23.6k| break; 201| 23.6k| } 202| | 203| 2.69M| if (event.ts > min_queue_ts[1]) { ------------------ | Branch (203:11): [True: 5, False: 2.69M] ------------------ 204| | // We should never hit this condition on the first extraction as by 205| | // the algorithm above (event.ts =) min_queue_ts[0] <= min_queue[1]. 206| 5| PERFETTO_DCHECK(num_extracted > 0); 207| 5| break; 208| 5| } 209| | 210| 2.69M| ++num_extracted; 211| 2.69M| MaybeExtractEvent(min_machine_idx, min_queue_idx, event); 212| 2.69M| } // for (event: events) 213| | 214| | // The earliest event cannot be extracted without going past the limit. 215| 26.0k| if (!num_extracted) ------------------ | Branch (215:9): [True: 12.8k, False: 13.2k] ------------------ 216| 12.8k| break; 217| | 218| | // Now remove the entries from the event buffer and update the queue-local 219| | // and global time bounds. 220| 13.2k| events.erase_front(num_extracted); 221| 13.2k| events.shrink_to_fit(); 222| | 223| | // Since we likely just removed a bunch of items try to reduce the memory 224| | // usage of the token buffer. 225| 13.2k| token_buffer_.FreeMemory(); 226| | 227| | // Update the queue timestamps to reflect the bounds after extraction. 228| 13.2k| if (events.empty()) { ------------------ | Branch (228:9): [True: 2.47k, False: 10.7k] ------------------ 229| 2.47k| queue.min_ts_ = kTsMax; 230| 2.47k| queue.max_ts_ = 0; 231| 10.7k| } else { 232| 10.7k| queue.min_ts_ = queue.events_.front().ts; 233| 10.7k| } 234| 13.2k| } // for(;;) 235| 15.0k|} _ZN8perfetto15trace_processor11TraceSorter16ParseTracePacketERNS0_21TraceProcessorContextERKNS1_16TimestampedEventE: 238| 2.25M| const TimestampedEvent& event) { 239| 2.25M| TraceTokenBuffer::Id id = GetTokenBufferId(event); 240| 2.25M| switch (event.type()) { ------------------ | Branch (240:11): [True: 0, False: 2.25M] ------------------ 241| 0| case TimestampedEvent::Type::kPerfRecord: ------------------ | Branch (241:5): [True: 0, False: 2.25M] ------------------ 242| 0| context.perf_record_parser->ParsePerfRecord( 243| 0| event.ts, token_buffer_.Extract(id)); 244| 0| return; 245| 0| case TimestampedEvent::Type::kInstrumentsRow: ------------------ | Branch (245:5): [True: 0, False: 2.25M] ------------------ 246| 0| context.instruments_row_parser->ParseInstrumentsRow( 247| 0| event.ts, token_buffer_.Extract(id)); 248| 0| return; 249| 1.37M| case TimestampedEvent::Type::kTracePacket: ------------------ | Branch (249:5): [True: 1.37M, False: 877k] ------------------ 250| 1.37M| context.proto_trace_parser->ParseTracePacket( 251| 1.37M| event.ts, token_buffer_.Extract(id)); 252| 1.37M| return; 253| 877k| case TimestampedEvent::Type::kTrackEvent: ------------------ | Branch (253:5): [True: 877k, False: 1.37M] ------------------ 254| 877k| context.proto_trace_parser->ParseTrackEvent( 255| 877k| event.ts, token_buffer_.Extract(id)); 256| 877k| return; 257| 0| case TimestampedEvent::Type::kFuchsiaRecord: ------------------ | Branch (257:5): [True: 0, False: 2.25M] ------------------ 258| 0| context.fuchsia_record_parser->ParseFuchsiaRecord( 259| 0| event.ts, token_buffer_.Extract(id)); 260| 0| return; 261| 0| case TimestampedEvent::Type::kJsonValue: ------------------ | Branch (261:5): [True: 0, False: 2.25M] ------------------ 262| 0| context.json_trace_parser->ParseJsonPacket( 263| 0| event.ts, std::move(token_buffer_.Extract(id).value)); 264| 0| return; 265| 0| case TimestampedEvent::Type::kSpeRecord: ------------------ | Branch (265:5): [True: 0, False: 2.25M] ------------------ 266| 0| context.spe_record_parser->ParseSpeRecord( 267| 0| event.ts, token_buffer_.Extract(id)); 268| 0| return; 269| 0| case TimestampedEvent::Type::kSystraceLine: ------------------ | Branch (269:5): [True: 0, False: 2.25M] ------------------ 270| 0| context.json_trace_parser->ParseSystraceLine( 271| 0| event.ts, token_buffer_.Extract(id)); 272| 0| return; 273| 0| case TimestampedEvent::Type::kAndroidDumpstateEvent: ------------------ | Branch (273:5): [True: 0, False: 2.25M] ------------------ 274| 0| context.android_dumpstate_event_parser->ParseAndroidDumpstateEvent( 275| 0| event.ts, token_buffer_.Extract(id)); 276| 0| return; 277| 0| case TimestampedEvent::Type::kAndroidLogEvent: ------------------ | Branch (277:5): [True: 0, False: 2.25M] ------------------ 278| 0| context.android_log_event_parser->ParseAndroidLogEvent( 279| 0| event.ts, token_buffer_.Extract(id)); 280| 0| return; 281| 0| case TimestampedEvent::Type::kLegacyV8CpuProfileEvent: ------------------ | Branch (281:5): [True: 0, False: 2.25M] ------------------ 282| 0| context.json_trace_parser->ParseLegacyV8ProfileEvent( 283| 0| event.ts, token_buffer_.Extract(id)); 284| 0| return; 285| 0| case TimestampedEvent::Type::kGeckoEvent: ------------------ | Branch (285:5): [True: 0, False: 2.25M] ------------------ 286| 0| context.gecko_trace_parser->ParseGeckoEvent( 287| 0| event.ts, token_buffer_.Extract(id)); 288| 0| return; 289| 0| case TimestampedEvent::Type::kArtMethodEvent: ------------------ | Branch (289:5): [True: 0, False: 2.25M] ------------------ 290| 0| context.art_method_parser->ParseArtMethodEvent( 291| 0| event.ts, token_buffer_.Extract(id)); 292| 0| return; 293| 0| case TimestampedEvent::Type::kPerfTextEvent: ------------------ | Branch (293:5): [True: 0, False: 2.25M] ------------------ 294| 0| context.perf_text_parser->ParsePerfTextEvent( 295| 0| event.ts, 296| 0| token_buffer_.Extract(id)); 297| 0| return; 298| 0| case TimestampedEvent::Type::kInlineSchedSwitch: ------------------ | Branch (298:5): [True: 0, False: 2.25M] ------------------ 299| 0| case TimestampedEvent::Type::kInlineSchedWaking: ------------------ | Branch (299:5): [True: 0, False: 2.25M] ------------------ 300| 0| case TimestampedEvent::Type::kEtwEvent: ------------------ | Branch (300:5): [True: 0, False: 2.25M] ------------------ 301| 0| case TimestampedEvent::Type::kFtraceEvent: ------------------ | Branch (301:5): [True: 0, False: 2.25M] ------------------ 302| 0| PERFETTO_FATAL("Invalid event type"); 303| 2.25M| } 304| 0| PERFETTO_FATAL("For GCC"); 305| 0|} _ZN8perfetto15trace_processor11TraceSorter32ExtractAndDiscardTokenizedObjectERKNS1_16TimestampedEventE: 376| 1.46M| const TimestampedEvent& event) { 377| 1.46M| TraceTokenBuffer::Id id = GetTokenBufferId(event); 378| 1.46M| switch (static_cast(event.event_type)) { ------------------ | Branch (378:11): [True: 0, False: 1.46M] ------------------ 379| 1.37M| case TimestampedEvent::Type::kTracePacket: ------------------ | Branch (379:5): [True: 1.37M, False: 84.3k] ------------------ 380| 1.37M| case TimestampedEvent::Type::kFtraceEvent: ------------------ | Branch (380:5): [True: 0, False: 1.46M] ------------------ 381| 1.37M| case TimestampedEvent::Type::kEtwEvent: ------------------ | Branch (381:5): [True: 0, False: 1.46M] ------------------ 382| 1.37M| base::ignore_result(token_buffer_.Extract(id)); 383| 1.37M| return; 384| 84.3k| case TimestampedEvent::Type::kTrackEvent: ------------------ | Branch (384:5): [True: 84.3k, False: 1.37M] ------------------ 385| 84.3k| base::ignore_result(token_buffer_.Extract(id)); 386| 84.3k| return; 387| 0| case TimestampedEvent::Type::kFuchsiaRecord: ------------------ | Branch (387:5): [True: 0, False: 1.46M] ------------------ 388| 0| base::ignore_result(token_buffer_.Extract(id)); 389| 0| return; 390| 0| case TimestampedEvent::Type::kJsonValue: ------------------ | Branch (390:5): [True: 0, False: 1.46M] ------------------ 391| 0| base::ignore_result(token_buffer_.Extract(id)); 392| 0| return; 393| 0| case TimestampedEvent::Type::kSpeRecord: ------------------ | Branch (393:5): [True: 0, False: 1.46M] ------------------ 394| 0| base::ignore_result(token_buffer_.Extract(id)); 395| 0| return; 396| 0| case TimestampedEvent::Type::kSystraceLine: ------------------ | Branch (396:5): [True: 0, False: 1.46M] ------------------ 397| 0| base::ignore_result(token_buffer_.Extract(id)); 398| 0| return; 399| 0| case TimestampedEvent::Type::kInlineSchedSwitch: ------------------ | Branch (399:5): [True: 0, False: 1.46M] ------------------ 400| 0| base::ignore_result(token_buffer_.Extract(id)); 401| 0| return; 402| 0| case TimestampedEvent::Type::kInlineSchedWaking: ------------------ | Branch (402:5): [True: 0, False: 1.46M] ------------------ 403| 0| base::ignore_result(token_buffer_.Extract(id)); 404| 0| return; 405| 0| case TimestampedEvent::Type::kPerfRecord: ------------------ | Branch (405:5): [True: 0, False: 1.46M] ------------------ 406| 0| base::ignore_result(token_buffer_.Extract(id)); 407| 0| return; 408| 0| case TimestampedEvent::Type::kInstrumentsRow: ------------------ | Branch (408:5): [True: 0, False: 1.46M] ------------------ 409| 0| base::ignore_result(token_buffer_.Extract(id)); 410| 0| return; 411| 0| case TimestampedEvent::Type::kAndroidDumpstateEvent: ------------------ | Branch (411:5): [True: 0, False: 1.46M] ------------------ 412| 0| base::ignore_result(token_buffer_.Extract(id)); 413| 0| return; 414| 0| case TimestampedEvent::Type::kAndroidLogEvent: ------------------ | Branch (414:5): [True: 0, False: 1.46M] ------------------ 415| 0| base::ignore_result(token_buffer_.Extract(id)); 416| 0| return; 417| 0| case TimestampedEvent::Type::kLegacyV8CpuProfileEvent: ------------------ | Branch (417:5): [True: 0, False: 1.46M] ------------------ 418| 0| base::ignore_result(token_buffer_.Extract(id)); 419| 0| return; 420| 0| case TimestampedEvent::Type::kGeckoEvent: ------------------ | Branch (420:5): [True: 0, False: 1.46M] ------------------ 421| 0| base::ignore_result( 422| 0| token_buffer_.Extract(id)); 423| 0| return; 424| 0| case TimestampedEvent::Type::kArtMethodEvent: ------------------ | Branch (424:5): [True: 0, False: 1.46M] ------------------ 425| 0| base::ignore_result( 426| 0| token_buffer_.Extract(id)); 427| 0| return; 428| 0| case TimestampedEvent::Type::kPerfTextEvent: ------------------ | Branch (428:5): [True: 0, False: 1.46M] ------------------ 429| 0| base::ignore_result( 430| 0| token_buffer_.Extract(id)); 431| 0| return; 432| 1.46M| } 433| 0| PERFETTO_FATAL("For GCC"); 434| 0|} _ZN8perfetto15trace_processor11TraceSorter17MaybeExtractEventEmmRKNS1_16TimestampedEventE: 438| 2.69M| const TimestampedEvent& event) { 439| 2.69M| auto* machine_context = 440| 2.69M| sorter_data_by_machine_[min_machine_idx].machine_context; 441| 2.69M| int64_t timestamp = event.ts; 442| 2.69M| if (timestamp < latest_pushed_event_ts_) { ------------------ | Branch (442:7): [True: 439k, False: 2.25M] ------------------ 443| 439k| storage_->IncrementStats(stats::sorter_push_event_out_of_order); 444| 439k| ExtractAndDiscardTokenizedObject(event); 445| 439k| return; 446| 439k| } 447| | 448| 2.25M| latest_pushed_event_ts_ = std::max(latest_pushed_event_ts_, timestamp); 449| | 450| 2.25M| if (PERFETTO_UNLIKELY(event_handling_ == EventHandling::kSortAndDrop)) { ------------------ | | 24| 2.25M|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 0, False: 2.25M] | | ------------------ ------------------ 451| | // Parse* would extract this event and push it to the next stage. Since we 452| | // are skipping that, just extract and discard it. 453| 0| ExtractAndDiscardTokenizedObject(event); 454| 0| return; 455| 0| } 456| 2.25M| PERFETTO_DCHECK(event_handling_ == EventHandling::kSortAndPush); 457| | 458| 2.25M| if (queue_idx == 0) { ------------------ | Branch (458:7): [True: 2.25M, False: 0] ------------------ 459| 2.25M| ParseTracePacket(*machine_context, event); 460| 2.25M| } else { 461| | // Ftrace queues start at offset 1. So queues_[1] = cpu[0] and so on. 462| 0| uint32_t cpu = static_cast(queue_idx - 1); 463| 0| auto event_type = static_cast(event.event_type); 464| | 465| 0| if (event_type == TimestampedEvent::Type::kEtwEvent) { ------------------ | Branch (465:9): [True: 0, False: 0] ------------------ 466| 0| ParseEtwPacket(*machine_context, static_cast(cpu), event); 467| 0| } else { 468| 0| ParseFtracePacket(*machine_context, cpu, event); 469| 0| } 470| 0| } 471| 2.25M|} _ZNK8perfetto15trace_processor11TraceSorter12sorting_modeEv: 132| 424| SortingMode sorting_mode() const { return sorting_mode_; } _ZN8perfetto15trace_processor11TraceSorter17AddMachineContextEPNS0_21TraceProcessorContextE: 135| 2.02k| void AddMachineContext(TraceProcessorContext* context) { 136| 2.02k| sorter_data_by_machine_.emplace_back(context); 137| 2.02k| } _ZN8perfetto15trace_processor11TraceSorter15PushTracePacketElNS0_15TracePacketDataENSt3__18optionalINS0_6tables12MachineTable2IdEEE: 178| 2.75M| std::optional machine_id = std::nullopt) { 179| 2.75M| AppendNonFtraceEvent(timestamp, TimestampedEvent::Type::kTracePacket, 180| 2.75M| std::move(data), machine_id); 181| 2.75M| } _ZN8perfetto15trace_processor11TraceSorter15PushTracePacketElNS0_6RefPtrINS0_29PacketSequenceStateGenerationEEENS0_13TraceBlobViewENSt3__18optionalINS0_6tables12MachineTable2IdEEE: 186| 2.75M| std::optional machine_id = std::nullopt) { 187| 2.75M| PushTracePacket(timestamp, 188| 2.75M| TracePacketData{std::move(tbv), std::move(state)}, 189| 2.75M| machine_id); 190| 2.75M| } _ZN8perfetto15trace_processor11TraceSorter20PushTrackEventPacketElNS0_14TrackEventDataENSt3__18optionalINS0_6tables12MachineTable2IdEEE: 219| 961k| std::optional machine_id = std::nullopt) { 220| 961k| AppendNonFtraceEvent(timestamp, TimestampedEvent::Type::kTrackEvent, 221| 961k| std::move(track_event), machine_id); 222| 961k| } _ZN8perfetto15trace_processor11TraceSorter19ExtractEventsForcedEv: 320| 690| void ExtractEventsForced() { 321| 690| BumpAllocator::AllocId end_id = token_buffer_.PastTheEndAllocId(); 322| 690| SortAndExtractEventsUntilAllocId(end_id); 323| 2.75k| for (auto& sorter_data : sorter_data_by_machine_) { ------------------ | Branch (323:28): [True: 2.75k, False: 690] ------------------ 324| 2.75k| for (const auto& queue : sorter_data.queues) { ------------------ | Branch (324:30): [True: 1.37k, False: 2.75k] ------------------ 325| 1.37k| PERFETTO_CHECK(queue.events_.empty()); 326| 1.37k| } 327| 2.75k| sorter_data.queues.clear(); 328| 2.75k| } 329| | 330| 690| alloc_id_for_extraction_ = end_id; 331| 690| flushes_since_extraction_ = 0; 332| 690| } _ZN8perfetto15trace_processor11TraceSorter16NotifyFlushEventEv: 334| 28.9k| void NotifyFlushEvent() { flushes_since_extraction_++; } _ZN8perfetto15trace_processor11TraceSorter21NotifyReadBufferEventEv: 336| 34.4k| void NotifyReadBufferEvent() { 337| 34.4k| if (sorting_mode_ == SortingMode::kFullSort || ------------------ | Branch (337:9): [True: 38, False: 34.4k] ------------------ 338| 34.4k| flushes_since_extraction_ < 2) { ------------------ | Branch (338:9): [True: 20.0k, False: 14.3k] ------------------ 339| 20.0k| return; 340| 20.0k| } 341| | 342| 14.3k| SortAndExtractEventsUntilAllocId(alloc_id_for_extraction_); 343| 14.3k| alloc_id_for_extraction_ = token_buffer_.PastTheEndAllocId(); 344| 14.3k| flushes_since_extraction_ = 0; 345| 14.3k| } _ZNK8perfetto15trace_processor11TraceSorter13max_timestampEv: 347| 1.03M| int64_t max_timestamp() const { return append_max_ts_; } _ZNK8perfetto15trace_processor11TraceSorter16TimestampedEvent8alloc_idEv: 391| 6.43M| BumpAllocator::AllocId alloc_id() const { 392| 6.43M| return BumpAllocator::AllocId{chunk_index, chunk_offset}; 393| 6.43M| } _ZNK8perfetto15trace_processor11TraceSorter16TimestampedEvent4typeEv: 395| 2.25M| Type type() const { return static_cast(event_type); } _ZN8perfetto15trace_processor11TraceSorter16TimestampedEvent7CompareERKS2_l: 398| 144k| static bool Compare(const TimestampedEvent& x, int64_t ts) { 399| 144k| return x.ts < ts; 400| 144k| } _ZNK8perfetto15trace_processor11TraceSorter16TimestampedEventltERKS2_: 403| 2.51G| bool operator<(const TimestampedEvent& evt) const { 404| 2.51G| return std::tie(ts, chunk_index, chunk_offset) < 405| 2.51G| std::tie(evt.ts, evt.chunk_index, evt.chunk_offset); 406| 2.51G| } _ZN8perfetto15trace_processor11TraceSorter5Queue6AppendElNS1_16TimestampedEvent4TypeENS0_16TraceTokenBuffer2IdEb: 452| 3.71M| bool use_slow_sorting) { 453| 3.71M| { 454| 3.71M| TimestampedEvent event; 455| 3.71M| event.ts = ts; 456| 3.71M| event.chunk_index = id.alloc_id.chunk_index; 457| 3.71M| event.chunk_offset = id.alloc_id.chunk_offset; 458| 3.71M| event.event_type = static_cast(type); 459| 3.71M| events_.emplace_back(std::move(event)); 460| 3.71M| } 461| | 462| | // Events are often seen in order. 463| 3.71M| if (PERFETTO_LIKELY(ts > max_ts_ || ------------------ | | 23| 14.8M|#define PERFETTO_LIKELY(...) __builtin_expect(!!(__VA_ARGS__), 1) | | ------------------ | | | Branch (23:30): [True: 899k, False: 2.81M] | | | Branch (23:50): [True: 3.69M, False: 0] | | | Branch (23:50): [True: 880k, False: 2.81M] | | | Branch (23:50): [True: 19.1k, False: 3.69M] | | ------------------ ------------------ 464| 3.71M| (!use_slow_sorting && ts == max_ts_))) { 465| 899k| max_ts_ = ts; 466| 2.81M| } else { 467| | // The event is breaking ordering. The first time it happens, keep 468| | // track of which index we are at. We know that everything before that 469| | // is sorted (because events were pushed monotonically). Everything 470| | // after that index, instead, will need a sorting pass before moving 471| | // events to the next pipeline stage. 472| 2.81M| if (sort_start_idx_ == 0) { ------------------ | Branch (472:13): [True: 12.9k, False: 2.80M] ------------------ 473| 12.9k| sort_start_idx_ = events_.size() - 1; 474| 12.9k| sort_min_ts_ = ts; 475| 2.80M| } else { 476| 2.80M| sort_min_ts_ = std::min(sort_min_ts_, ts); 477| 2.80M| } 478| 2.81M| } 479| | 480| 3.71M| min_ts_ = std::min(min_ts_, ts); 481| 3.71M| PERFETTO_DCHECK(min_ts_ <= max_ts_); 482| 3.71M| } _ZNK8perfetto15trace_processor11TraceSorter5Queue13needs_sortingEv: 484| 26.0k| bool needs_sorting() const { return sort_start_idx_ != 0; } _ZN8perfetto15trace_processor11TraceSorter8GetQueueEmNSt3__18optionalINS0_6tables12MachineTable2IdEEE: 497| 3.71M| std::optional machine_id = std::nullopt) { 498| | // sorter_data_by_machine_[0] corresponds to the default machine. 499| 3.71M| PERFETTO_DCHECK(sorter_data_by_machine_[0].machine_id == std::nullopt); 500| 3.71M| auto* queues = &sorter_data_by_machine_[0].queues; 501| | 502| | // Find the TraceSorterData instance when |machine_id| is not nullopt. 503| 3.71M| if (PERFETTO_UNLIKELY(machine_id.has_value())) { ------------------ | | 24| 3.71M|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 1.60k, False: 3.71M] | | ------------------ ------------------ 504| 1.60k| auto it = std::find_if(sorter_data_by_machine_.begin() + 1, 505| 1.60k| sorter_data_by_machine_.end(), 506| 1.60k| [machine_id](const TraceSorterData& item) { 507| 1.60k| return item.machine_id == machine_id; 508| 1.60k| }); 509| 1.60k| PERFETTO_DCHECK(it != sorter_data_by_machine_.end()); 510| 1.60k| queues = &it->queues; 511| 1.60k| } 512| | 513| 3.71M| if (PERFETTO_UNLIKELY(index >= queues->size())) ------------------ | | 24| 3.71M|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 2.02k, False: 3.71M] | | ------------------ ------------------ 514| 2.02k| queues->resize(index + 1); 515| 3.71M| return &queues->at(index); 516| 3.71M| } _ZN8perfetto15trace_processor11TraceSorter26AppendNonFtraceEventWithIdElNS1_16TimestampedEvent4TypeENS0_16TraceTokenBuffer2IdENSt3__18optionalINS0_6tables12MachineTable2IdEEE: 534| 3.71M| std::optional machine_id) { 535| 3.71M| Queue* queue = GetQueue(0, machine_id); 536| 3.71M| queue->Append(ts, event_type, id, use_slow_sorting_); 537| 3.71M| UpdateAppendMaxTs(queue); 538| 3.71M| } _ZN8perfetto15trace_processor11TraceSorter17UpdateAppendMaxTsEPNS1_5QueueE: 540| 3.71M| void UpdateAppendMaxTs(Queue* queue) { 541| 3.71M| append_max_ts_ = std::max(append_max_ts_, queue->max_ts_); 542| 3.71M| } _ZN8perfetto15trace_processor11TraceSorter16GetTokenBufferIdERKNS1_16TimestampedEventE: 558| 3.71M| static TraceTokenBuffer::Id GetTokenBufferId(const TimestampedEvent& event) { 559| 3.71M| return TraceTokenBuffer::Id{event.alloc_id()}; 560| 3.71M| } _ZN8perfetto15trace_processor11TraceSorter15TraceSorterDataC2EPNS0_21TraceProcessorContextE: 564| 2.02k| : machine_id(_machine_context->machine_id()), 565| 2.02k| machine_context(_machine_context) {} _ZN8perfetto15trace_processor11TraceSorter20AppendNonFtraceEventINS0_15TracePacketDataEEEvlNS1_16TimestampedEvent4TypeEOT_NSt3__18optionalINS0_6tables12MachineTable2IdEEE: 523| 2.75M| std::optional machine_id = std::nullopt) { 524| 2.75M| if (PERFETTO_UNLIKELY(event_handling_ == EventHandling::kDrop)) { ------------------ | | 24| 2.75M|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 0, False: 2.75M] | | ------------------ ------------------ 525| 0| return; 526| 0| } 527| 2.75M| TraceTokenBuffer::Id id = token_buffer_.Append(std::forward(evt)); 528| 2.75M| AppendNonFtraceEventWithId(ts, event_type, id, machine_id); 529| 2.75M| } _ZN8perfetto15trace_processor11TraceSorter20AppendNonFtraceEventINS0_14TrackEventDataEEEvlNS1_16TimestampedEvent4TypeEOT_NSt3__18optionalINS0_6tables12MachineTable2IdEEE: 523| 961k| std::optional machine_id = std::nullopt) { 524| 961k| if (PERFETTO_UNLIKELY(event_handling_ == EventHandling::kDrop)) { ------------------ | | 24| 961k|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 0, False: 961k] | | ------------------ ------------------ 525| 0| return; 526| 0| } 527| 961k| TraceTokenBuffer::Id id = token_buffer_.Append(std::forward(evt)); 528| 961k| AppendNonFtraceEventWithId(ts, event_type, id, machine_id); 529| 961k| } _ZZN8perfetto15trace_processor11TraceSorter8GetQueueEmNSt3__18optionalINS0_6tables12MachineTable2IdEEEENKUlRKNS1_15TraceSorterDataEE_clESA_: 506| 406k| [machine_id](const TraceSorterData& item) { 507| 406k| return item.machine_id == machine_id; 508| 406k| }); _ZN8perfetto15trace_processor16TraceTokenBuffer6AppendENS0_14TrackEventDataE: 89| 3.71M|TraceTokenBuffer::Id TraceTokenBuffer::Append(TrackEventData ted) { 90| | // TrackEventData (and TracePacketData) are two big contributors to the size 91| | // of the peak memory usage by sorted. The main reasons for this are a) object 92| | // padding and b) using more bits than necessary to store their contents. 93| | // 94| | // The purpose of this function is to "compress" the contents of 95| | // TrackEventData by utilising techniques like bitpacking, interning and 96| | // variable length encoding to ensure only the amount of data which really 97| | // needs to be stored is done so. 98| | 99| | // Compress all the booleans indicating the presence of a value into 4 bits 100| | // instead of 4 bytes as they would take inside base::Optional. 101| 3.71M| TrackEventDataDescriptor desc; 102| 3.71M| desc.has_thread_instruction_count = ted.thread_instruction_count.has_value(); 103| 3.71M| desc.has_thread_timestamp = ted.thread_timestamp.has_value(); 104| 3.71M| desc.has_counter_value = std::not_equal_to()(ted.counter_value, 0); 105| 3.71M| desc.extra_counter_count = ted.CountExtraCounterValues(); 106| | 107| | // Allocate enough memory using the BumpAllocator to store the data in |ted|. 108| | // Also figure out the interned index. 109| 3.71M| BumpAllocator::AllocId alloc_id = 110| 3.71M| AllocAndResizeInternedVectors(GetAllocSize(desc)); 111| 3.71M| InternedIndex interned_index = GetInternedIndex(alloc_id); 112| | 113| | // Compute the interning information for the TrackBlob and the SequenceState. 114| 3.71M| TracePacketData& tpd = ted.trace_packet_data; 115| 3.71M| desc.intern_blob_offset = InternTraceBlob(interned_index, tpd.packet); 116| 3.71M| desc.intern_blob_index = 117| 3.71M| static_cast(interned_blobs_.at(interned_index).size() - 1); 118| 3.71M| desc.intern_seq_index = 119| 3.71M| InternSeqState(interned_index, std::move(tpd.sequence_state)); 120| | 121| | // Store the descriptor 122| 3.71M| uint8_t* ptr = static_cast(allocator_.GetPointer(alloc_id)); 123| 3.71M| ptr = AppendToPtr(ptr, desc); 124| | 125| | // Store the packet sizes. 126| 3.71M| uint64_t packet_size = static_cast(tpd.packet.size()); 127| 3.71M| ptr = AppendToPtr(ptr, packet_size); 128| | 129| | // Add the "optional" fields of TrackEventData based on whether or not they 130| | // are non-null. 131| 3.71M| if (desc.has_thread_instruction_count) { ------------------ | Branch (131:7): [True: 67, False: 3.71M] ------------------ 132| 67| ptr = AppendToPtr(ptr, ted.thread_instruction_count.value()); 133| 67| } 134| 3.71M| if (desc.has_thread_timestamp) { ------------------ | Branch (134:7): [True: 24, False: 3.71M] ------------------ 135| 24| ptr = AppendToPtr(ptr, ted.thread_timestamp.value()); 136| 24| } 137| 3.71M| if (desc.has_counter_value) { ------------------ | Branch (137:7): [True: 0, False: 3.71M] ------------------ 138| 0| ptr = AppendToPtr(ptr, ted.counter_value); 139| 0| } 140| 3.71M| for (uint32_t i = 0; i < desc.extra_counter_count; ++i) { ------------------ | Branch (140:24): [True: 0, False: 3.71M] ------------------ 141| 0| ptr = AppendToPtr(ptr, ted.extra_counter_values[i]); 142| 0| } 143| 3.71M| return Id{alloc_id}; 144| 3.71M|} _ZN8perfetto15trace_processor16TraceTokenBuffer7ExtractINS0_14TrackEventDataEEET_NS1_2IdE: 147| 3.71M|TrackEventData TraceTokenBuffer::Extract(Id id) { 148| 3.71M| uint8_t* ptr = static_cast(allocator_.GetPointer(id.alloc_id)); 149| 3.71M| TrackEventDataDescriptor desc = 150| 3.71M| ExtractFromPtr(&ptr); 151| 3.71M| uint64_t packet_size = ExtractFromPtr(&ptr); 152| | 153| 3.71M| InternedIndex interned_index = GetInternedIndex(id.alloc_id); 154| 3.71M| BlobWithOffset& bwo = 155| 3.71M| interned_blobs_.at(interned_index)[desc.intern_blob_index]; 156| 3.71M| TraceBlobView tbv(RefPtr::FromReleasedUnsafe(bwo.blob), 157| 3.71M| bwo.offset_in_blob + desc.intern_blob_offset, 158| 3.71M| static_cast(packet_size)); 159| 3.71M| auto seq = RefPtr::FromReleasedUnsafe( 160| 3.71M| interned_seqs_.at(interned_index)[desc.intern_seq_index]); 161| | 162| 3.71M| TrackEventData ted{std::move(tbv), std::move(seq)}; 163| 3.71M| if (desc.has_thread_instruction_count) { ------------------ | Branch (163:7): [True: 67, False: 3.71M] ------------------ 164| 67| ted.thread_instruction_count = ExtractFromPtr(&ptr); 165| 67| } 166| 3.71M| if (desc.has_thread_timestamp) { ------------------ | Branch (166:7): [True: 24, False: 3.71M] ------------------ 167| 24| ted.thread_timestamp = ExtractFromPtr(&ptr); 168| 24| } 169| 3.71M| if (desc.has_counter_value) { ------------------ | Branch (169:7): [True: 0, False: 3.71M] ------------------ 170| 0| ted.counter_value = ExtractFromPtr(&ptr); 171| 0| } 172| 3.71M| for (uint32_t i = 0; i < desc.extra_counter_count; ++i) { ------------------ | Branch (172:24): [True: 0, False: 3.71M] ------------------ 173| 0| ted.extra_counter_values[i] = ExtractFromPtr(&ptr); 174| 0| } 175| 3.71M| allocator_.Free(id.alloc_id); 176| 3.71M| return ted; 177| 3.71M|} _ZN8perfetto15trace_processor16TraceTokenBuffer15InternTraceBlobEmRKNS0_13TraceBlobViewE: 180| 3.71M| const TraceBlobView& tbv) { 181| 3.71M| BlobWithOffsets& blobs = interned_blobs_.at(interned_index); 182| 3.71M| if (blobs.empty()) { ------------------ | Branch (182:7): [True: 2.18k, False: 3.71M] ------------------ 183| 2.18k| return AddTraceBlob(interned_index, tbv); 184| 2.18k| } 185| | 186| 3.71M| BlobWithOffset& last_blob = blobs.back(); 187| 3.71M| if (last_blob.blob != tbv.blob().get()) { ------------------ | Branch (187:7): [True: 0, False: 3.71M] ------------------ 188| 0| return AddTraceBlob(interned_index, tbv); 189| 0| } 190| 3.71M| PERFETTO_CHECK(last_blob.offset_in_blob <= tbv.offset()); 191| | 192| | // To allow our offsets in the store to be 16 bits, we intern not only the 193| | // TraceBlob pointer but also the offset. By having this double indirection, 194| | // we can store offset always as uint16 at the cost of storing blobs here more 195| | // often: this more than pays for itself as in the majority of cases the 196| | // offsets are small anyway. 197| 3.71M| size_t rel_offset = tbv.offset() - last_blob.offset_in_blob; 198| 3.71M| if (rel_offset > TrackEventDataDescriptor::kMaxOffsetFromInternedBlob) { ------------------ | Branch (198:7): [True: 0, False: 3.71M] ------------------ 199| 0| return AddTraceBlob(interned_index, tbv); 200| 0| } 201| | 202| | // Intentionally "leak" this pointer. This essentially keeps the refcount 203| | // of this TraceBlob one higher than the number of RefPtrs pointing to it. 204| | // This allows avoid storing the same RefPtr n times. 205| | // 206| | // Calls to this function are paired to Extract which picks 207| | // up this "leaked" pointer. 208| 3.71M| TraceBlob* leaked = tbv.blob().ReleaseUnsafe(); 209| 3.71M| base::ignore_result(leaked); 210| 3.71M| return static_cast(rel_offset); 211| 3.71M|} _ZN8perfetto15trace_processor16TraceTokenBuffer14InternSeqStateEmNS0_6RefPtrINS0_29PacketSequenceStateGenerationEEE: 215| 3.71M| RefPtr ptr) { 216| | // Look back at most 32 elements. This should be far enough in most cases 217| | // unless either: a) we are essentially round-robining between >32 sequences 218| | // b) we are churning through generations. Either case seems pathalogical. 219| 3.71M| SequenceStates& states = interned_seqs_.at(interned_index); 220| 3.71M| size_t lookback = std::min(32u, states.size()); 221| 18.8M| for (uint32_t i = 0; i < lookback; ++i) { ------------------ | Branch (221:24): [True: 18.7M, False: 73.1k] ------------------ 222| 18.7M| uint16_t idx = static_cast(states.size() - 1 - i); 223| 18.7M| if (states[idx] == ptr.get()) { ------------------ | Branch (223:9): [True: 3.64M, False: 15.1M] ------------------ 224| | // Intentionally "leak" this pointer. See |InternTraceBlob| for an 225| | // explanation. 226| 3.64M| PacketSequenceStateGeneration* leaked = ptr.ReleaseUnsafe(); 227| 3.64M| base::ignore_result(leaked); 228| 3.64M| return idx; 229| 3.64M| } 230| 18.7M| } 231| 73.1k| states.emplace_back(ptr.ReleaseUnsafe()); 232| 73.1k| PERFETTO_CHECK(states.size() <= std::numeric_limits::max()); 233| 73.1k| return static_cast(states.size() - 1); 234| 73.1k|} _ZN8perfetto15trace_processor16TraceTokenBuffer12AddTraceBlobEmRKNS0_13TraceBlobViewE: 237| 2.18k| const TraceBlobView& tbv) { 238| 2.18k| BlobWithOffsets& blobs = interned_blobs_.at(interned_index); 239| 2.18k| blobs.emplace_back(BlobWithOffset{tbv.blob().ReleaseUnsafe(), tbv.offset()}); 240| 2.18k| PERFETTO_CHECK(blobs.size() <= std::numeric_limits::max()); 241| 2.18k| return 0u; 242| 2.18k|} _ZN8perfetto15trace_processor16TraceTokenBuffer10FreeMemoryEv: 244| 13.2k|void TraceTokenBuffer::FreeMemory() { 245| 13.2k| uint64_t erased = allocator_.EraseFrontFreeChunks(); 246| 13.2k| PERFETTO_CHECK(erased <= std::numeric_limits::max()); 247| 13.2k| interned_blobs_.erase_front(static_cast(erased)); 248| 13.2k| interned_seqs_.erase_front(static_cast(erased)); 249| 13.2k| PERFETTO_CHECK(interned_blobs_.size() == interned_seqs_.size()); 250| 13.2k|} _ZN8perfetto15trace_processor16TraceTokenBuffer29AllocAndResizeInternedVectorsEj: 253| 3.71M| uint32_t size) { 254| 3.71M| uint64_t erased = allocator_.erased_front_chunks_count(); 255| 3.71M| BumpAllocator::AllocId alloc_id = allocator_.Alloc(size); 256| 3.71M| uint64_t allocator_chunks_size = alloc_id.chunk_index - erased + 1; 257| | 258| | // The allocator should never "remove" chunks from being tracked. 259| 3.71M| PERFETTO_DCHECK(allocator_chunks_size >= interned_blobs_.size()); 260| | 261| | // We should add at most one chunk in the allocator. 262| 3.71M| uint64_t chunks_added = allocator_chunks_size - interned_blobs_.size(); 263| 3.71M| PERFETTO_DCHECK(chunks_added <= 1); 264| 3.71M| PERFETTO_DCHECK(interned_blobs_.size() == interned_seqs_.size()); 265| 3.72M| for (uint64_t i = 0; i < chunks_added; ++i) { ------------------ | Branch (265:24): [True: 2.18k, False: 3.71M] ------------------ 266| 2.18k| interned_blobs_.emplace_back(); 267| 2.18k| interned_seqs_.emplace_back(); 268| 2.18k| } 269| 3.71M| return alloc_id; 270| 3.71M|} _ZN8perfetto15trace_processor16TraceTokenBuffer16GetInternedIndexENS0_13BumpAllocator7AllocIdE: 273| 7.43M| BumpAllocator::AllocId alloc_id) { 274| 7.43M| uint64_t interned_index = 275| 7.43M| alloc_id.chunk_index - allocator_.erased_front_chunks_count(); 276| 7.43M| PERFETTO_DCHECK(interned_index <= std::numeric_limits::max()); 277| 7.43M| PERFETTO_DCHECK(interned_index < interned_blobs_.size()); 278| 7.43M| PERFETTO_DCHECK(interned_index < interned_seqs_.size()); 279| 7.43M| PERFETTO_DCHECK(interned_blobs_.size() == interned_seqs_.size()); 280| 7.43M| return static_cast(interned_index); 281| 7.43M|} trace_token_buffer.cc:_ZN8perfetto15trace_processor12_GLOBAL__N_112GetAllocSizeERKNS1_24TrackEventDataDescriptorE: 77| 3.71M|uint32_t GetAllocSize(const TrackEventDataDescriptor& desc) { 78| 3.71M| uint32_t alloc_size = sizeof(TrackEventDataDescriptor); 79| 3.71M| alloc_size += sizeof(uint64_t); 80| 3.71M| alloc_size += desc.has_thread_instruction_count * sizeof(int64_t); 81| 3.71M| alloc_size += desc.has_thread_timestamp * sizeof(int64_t); 82| 3.71M| alloc_size += desc.has_counter_value * sizeof(double); 83| 3.71M| alloc_size += desc.extra_counter_count * sizeof(double); 84| 3.71M| return alloc_size; 85| 3.71M|} trace_token_buffer.cc:_ZN8perfetto15trace_processor12_GLOBAL__N_111AppendToPtrINS1_24TrackEventDataDescriptorEEEPhS4_T_: 72| 3.71M|uint8_t* AppendToPtr(uint8_t* ptr, T value) { 73| 3.71M| new (ptr) T(std::move(value)); 74| 3.71M| return ptr + sizeof(T); 75| 3.71M|} trace_token_buffer.cc:_ZN8perfetto15trace_processor12_GLOBAL__N_111AppendToPtrImEEPhS3_T_: 72| 3.71M|uint8_t* AppendToPtr(uint8_t* ptr, T value) { 73| 3.71M| new (ptr) T(std::move(value)); 74| 3.71M| return ptr + sizeof(T); 75| 3.71M|} trace_token_buffer.cc:_ZN8perfetto15trace_processor12_GLOBAL__N_111AppendToPtrIlEEPhS3_T_: 72| 91|uint8_t* AppendToPtr(uint8_t* ptr, T value) { 73| 91| new (ptr) T(std::move(value)); 74| 91| return ptr + sizeof(T); 75| 91|} trace_token_buffer.cc:_ZN8perfetto15trace_processor12_GLOBAL__N_114ExtractFromPtrINS1_24TrackEventDataDescriptorEEET_PPh: 63| 3.71M|T ExtractFromPtr(uint8_t** ptr) { 64| 3.71M| T* typed_ptr = reinterpret_cast(*ptr); 65| 3.71M| T value(std::move(*typed_ptr)); 66| 3.71M| typed_ptr->~T(); 67| 3.71M| *ptr += sizeof(T); 68| 3.71M| return value; 69| 3.71M|} trace_token_buffer.cc:_ZN8perfetto15trace_processor12_GLOBAL__N_114ExtractFromPtrImEET_PPh: 63| 3.71M|T ExtractFromPtr(uint8_t** ptr) { 64| 3.71M| T* typed_ptr = reinterpret_cast(*ptr); 65| 3.71M| T value(std::move(*typed_ptr)); 66| 3.71M| typed_ptr->~T(); 67| 3.71M| *ptr += sizeof(T); 68| 3.71M| return value; 69| 3.71M|} trace_token_buffer.cc:_ZN8perfetto15trace_processor12_GLOBAL__N_114ExtractFromPtrIlEET_PPh: 63| 91|T ExtractFromPtr(uint8_t** ptr) { 64| 91| T* typed_ptr = reinterpret_cast(*ptr); 65| 91| T value(std::move(*typed_ptr)); 66| 91| typed_ptr->~T(); 67| 91| *ptr += sizeof(T); 68| 91| return value; 69| 91|} _ZN8perfetto15trace_processor16TraceTokenBuffer6AppendENS0_15TracePacketDataE: 67| 2.75M| PERFETTO_WARN_UNUSED_RESULT Id Append(TracePacketData data) { 68| | // While in theory we could add a special case for TracePacketData, the 69| | // judgement call we make is that the code complexity does not justify the 70| | // micro-performance gain you might hope to see by avoiding the few if 71| | // conditions in the |TracePacketData| path. 72| 2.75M| return Append(TrackEventData(std::move(data))); 73| 2.75M| } _ZN8perfetto15trace_processor16TraceTokenBuffer17PastTheEndAllocIdEv: 100| 15.5k| BumpAllocator::AllocId PastTheEndAllocId() { 101| 15.5k| return allocator_.PastTheEndId(); 102| 15.5k| } _ZN8perfetto15trace_processor16TraceTokenBuffer7ExtractINS0_15TracePacketDataEEET_NS1_2IdE: 139| 2.75M|TraceTokenBuffer::Extract(Id id) { 140| | // See the comment in Append(TracePacketData) for why we do this. 141| 2.75M| return Extract(id).trace_packet_data; 142| 2.75M|} _ZN8perfetto15trace_processor12TraceStorageC2ERKNS0_6ConfigE: 55| 434|TraceStorage::TraceStorage(const Config&) { 56| 3.90k| for (uint32_t i = 0; i < variadic_type_ids_.size(); ++i) { ------------------ | Branch (56:24): [True: 3.47k, False: 434] ------------------ 57| 3.47k| variadic_type_ids_[i] = InternString(Variadic::kTypeNames[i]); 58| 3.47k| } 59| 434|} _ZN8perfetto15trace_processor12TraceStorageD2Ev: 61| 434|TraceStorage::~TraceStorage() {} _ZN8perfetto15trace_processor12TraceStorage27TraceExecutionTimeIntoStatsEm: 327| 868| ScopedStatsTracer TraceExecutionTimeIntoStats(size_t key) { 328| 868| return ScopedStatsTracer(this, key); 329| 868| } _ZN8perfetto15trace_processor12TraceStorage17ScopedStatsTracerC2EPS1_m: 295| 868| : storage_(storage), key_(key), start_ns_(base::GetWallTimeNs()) {} _ZN8perfetto15trace_processor12TraceStorage17ScopedStatsTracerD2Ev: 297| 868| ~ScopedStatsTracer() { 298| 868| if (!storage_) ------------------ | Branch (298:11): [True: 0, False: 868] ------------------ 299| 0| return; 300| 868| auto delta_ns = base::GetWallTimeNs() - start_ns_; 301| 868| storage_->IncrementStats(key_, delta_ns.count()); 302| 868| } _ZN8perfetto15trace_processor12TraceStorage14IncrementStatsEml: 255| 3.22M| void IncrementStats(size_t key, int64_t increment = 1) { 256| 3.22M| PERFETTO_DCHECK(key < stats::kNumKeys); 257| 3.22M| PERFETTO_DCHECK(stats::kTypes[key] == stats::kSingle); 258| 3.22M| stats_[key].value += increment; 259| 3.22M| } _ZN8perfetto15trace_processor12TraceStorage18VirtualTrackSlices20AddVirtualTrackSliceENS0_6tables10SliceTable2IdEllll: 143| 2.86k| int64_t thread_instruction_delta) { 144| 2.86k| slice_ids_.emplace_back(slice_id); 145| 2.86k| thread_timestamp_ns_.emplace_back(thread_timestamp_ns); 146| 2.86k| thread_duration_ns_.emplace_back(thread_duration_ns); 147| 2.86k| thread_instruction_counts_.emplace_back(thread_instruction_count); 148| 2.86k| thread_instruction_deltas_.emplace_back(thread_instruction_delta); 149| 2.86k| return slice_count() - 1; 150| 2.86k| } _ZNK8perfetto15trace_processor12TraceStorage18VirtualTrackSlices11slice_countEv: 152| 2.86k| uint32_t slice_count() const { 153| 2.86k| return static_cast(slice_ids_.size()); 154| 2.86k| } _ZNK8perfetto15trace_processor12TraceStorage18VirtualTrackSlices9slice_idsEv: 156| 2.23k| const std::deque& slice_ids() const { return slice_ids_; } _ZNK8perfetto15trace_processor12TraceStorage18VirtualTrackSlices17FindRowForSliceIdENS0_6tables10SliceTable2IdE: 170| 559| std::optional FindRowForSliceId(SliceId slice_id) const { 171| 559| auto it = 172| 559| std::lower_bound(slice_ids().begin(), slice_ids().end(), slice_id); 173| 559| if (it != slice_ids().end() && *it == slice_id) { ------------------ | Branch (173:11): [True: 559, False: 0] | Branch (173:11): [True: 559, False: 0] | Branch (173:38): [True: 559, False: 0] ------------------ 174| 559| return static_cast(std::distance(slice_ids().begin(), it)); 175| 559| } 176| 0| return std::nullopt; 177| 559| } _ZN8perfetto15trace_processor12TraceStorage18VirtualTrackSlices28UpdateThreadDeltasForSliceIdENS0_6tables10SliceTable2IdEll: 181| 559| int64_t end_thread_instruction_count) { 182| 559| auto opt_row = FindRowForSliceId(slice_id); 183| 559| if (!opt_row) ------------------ | Branch (183:11): [True: 0, False: 559] ------------------ 184| 0| return; 185| 559| uint32_t row = *opt_row; 186| 559| int64_t begin_ns = thread_timestamp_ns_[row]; 187| 559| thread_duration_ns_[row] = end_thread_timestamp_ns - begin_ns; 188| 559| int64_t begin_ticount = thread_instruction_counts_[row]; 189| 559| thread_instruction_deltas_[row] = 190| 559| end_thread_instruction_count - begin_ticount; 191| 559| } _ZN8perfetto15trace_processor12TraceStorage12InternStringENS_4base10StringViewE: 234| 32.9M| virtual StringId InternString(base::StringView str) { 235| 32.9M| return string_pool_.InternString(str); 236| 32.9M| } _ZN8perfetto15trace_processor12TraceStorage12InternStringEPKc: 237| 491k| virtual StringId InternString(const char* str) { 238| 491k| return InternString(base::StringView(str)); 239| 491k| } _ZN8perfetto15trace_processor12TraceStorage12InternStringENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEE: 243| 267k| virtual StringId InternString(std::string_view str) { 244| 267k| return InternString(base::StringView(str.data(), str.size())); 245| 267k| } _ZN8perfetto15trace_processor12TraceStorage8SetStatsEml: 248| 3.41k| void SetStats(size_t key, int64_t value) { 249| 3.41k| PERFETTO_DCHECK(key < stats::kNumKeys); 250| 3.41k| PERFETTO_DCHECK(stats::kTypes[key] == stats::kSingle); 251| 3.41k| stats_[key].value = value; 252| 3.41k| } _ZN8perfetto15trace_processor12TraceStorage15SetIndexedStatsEmil: 269| 1.15k| void SetIndexedStats(size_t key, int index, int64_t value) { 270| 1.15k| PERFETTO_DCHECK(key < stats::kNumKeys); 271| 1.15k| PERFETTO_DCHECK(stats::kTypes[key] == stats::kIndexed); 272| 1.15k| stats_[key].indexed_values[index] = value; 273| 1.15k| } _ZNK8perfetto15trace_processor12TraceStorage9GetStringENS0_10StringPool2IdE: 333| 4.40M| virtual NullTermStringView GetString(StringId id) const { 334| 4.40M| return string_pool_.Get(id); 335| 4.40M| } _ZNK8perfetto15trace_processor12TraceStorage12thread_tableEv: 357| 106k| const tables::ThreadTable& thread_table() const { return thread_table_; } _ZN8perfetto15trace_processor12TraceStorage20mutable_thread_tableEv: 358| 94.8M| tables::ThreadTable* mutable_thread_table() { return &thread_table_; } _ZN8perfetto15trace_processor12TraceStorage21mutable_process_tableEv: 361| 94.5M| tables::ProcessTable* mutable_process_table() { return &process_table_; } _ZN8perfetto15trace_processor12TraceStorage19mutable_track_tableEv: 371| 509k| tables::TrackTable* mutable_track_table() { return &track_table_; } _ZNK8perfetto15trace_processor12TraceStorage11slice_tableEv: 394| 1.29M| const tables::SliceTable& slice_table() const { return slice_table_; } _ZN8perfetto15trace_processor12TraceStorage19mutable_slice_tableEv: 395| 3.50M| tables::SliceTable* mutable_slice_table() { return &slice_table_; } _ZN8perfetto15trace_processor12TraceStorage18mutable_flow_tableEv: 405| 2.79k| tables::FlowTable* mutable_flow_table() { return &flow_table_; } _ZN8perfetto15trace_processor12TraceStorage28mutable_virtual_track_slicesEv: 410| 3.42k| VirtualTrackSlices* mutable_virtual_track_slices() { 411| 3.42k| return &virtual_track_slices_; 412| 3.42k| } _ZN8perfetto15trace_processor12TraceStorage21mutable_counter_tableEv: 415| 558k| tables::CounterTable* mutable_counter_table() { return &counter_table_; } _ZN8perfetto15trace_processor12TraceStorage22mutable_metadata_tableEv: 463| 273k| tables::MetadataTable* mutable_metadata_table() { return &metadata_table_; } _ZN8perfetto15trace_processor12TraceStorage28mutable_clock_snapshot_tableEv: 468| 25.1k| tables::ClockSnapshotTable* mutable_clock_snapshot_table() { 469| 25.1k| return &clock_snapshot_table_; 470| 25.1k| } _ZN8perfetto15trace_processor12TraceStorage17mutable_arg_tableEv: 473| 2.77M| tables::ArgTable* mutable_arg_table() { return &arg_table_; } _ZN8perfetto15trace_processor12TraceStorage24mutable_chrome_raw_tableEv: 478| 2.85M| tables::ChromeRawTable* mutable_chrome_raw_table() { 479| 2.85M| return &chrome_raw_table_; 480| 2.85M| } _ZN8perfetto15trace_processor12TraceStorage21mutable_machine_tableEv: 490| 2.03k| tables::MachineTable* mutable_machine_table() { return &machine_table_; } _ZN8perfetto15trace_processor12TraceStorage17mutable_cpu_tableEv: 493| 8.34M| tables::CpuTable* mutable_cpu_table() { return &cpu_table_; } _ZN8perfetto15trace_processor12TraceStorage24mutable_trace_file_tableEv: 554| 1.20k| tables::TraceFileTable* mutable_trace_file_table() { 555| 1.20k| return &trace_file_table_; 556| 1.20k| } _ZN8perfetto15trace_processor12TraceStorage29mutable_memory_snapshot_tableEv: 627| 641| tables::MemorySnapshotTable* mutable_memory_snapshot_table() { 628| 641| return &memory_snapshot_table_; 629| 641| } _ZN8perfetto15trace_processor12TraceStorage37mutable_process_memory_snapshot_tableEv: 635| 43.2k| tables::ProcessMemorySnapshotTable* mutable_process_memory_snapshot_table() { 636| 43.2k| return &process_memory_snapshot_table_; 637| 43.2k| } _ZN8perfetto15trace_processor12TraceStorage34mutable_memory_snapshot_node_tableEv: 642| 11.3k| tables::MemorySnapshotNodeTable* mutable_memory_snapshot_node_table() { 643| 11.3k| return &memory_snapshot_node_table_; 644| 11.3k| } _ZN8perfetto15trace_processor12TraceStorage34mutable_memory_snapshot_edge_tableEv: 649| 364| tables::MemorySnapshotEdgeTable* mutable_memory_snapshot_edge_table() { 650| 364| return &memory_snapshot_edge_table_; 651| 364| } _ZN8perfetto15trace_processor12TraceStorage51mutable_experimental_missing_chrome_processes_tableEv: 900| 361k| mutable_experimental_missing_chrome_processes_table() { 901| 361k| return &experimental_missing_chrome_processes_table_; 902| 361k| } _ZNK8perfetto15trace_processor12TraceStorage11string_poolEv: 904| 71.8k| const StringPool& string_pool() const { return string_pool_; } _ZNK8perfetto15trace_processor12TraceStorage20GetIdForVariadicTypeENS0_8Variadic4TypeE: 966| 2.16M| StringId GetIdForVariadicType(Variadic::Type type) const { 967| 2.16M| return variadic_type_ids_[type]; 968| 2.16M| } _ZNKSt3__14hashIN8perfetto15trace_processor6BaseIdEEclERKS3_: 1174| 2.91M| result_type operator()(const argument_type& r) const { 1175| 2.91M| return std::hash{}(r.value); 1176| 2.91M| } _ZN8perfetto15trace_processor15macros_internal10MacroTableC2EPNS0_10StringPoolENSt3__16vectorINS0_12ColumnLegacyENS5_9allocatorIS7_EEEEPKS2_: 42| 34.7k| : Table(pool, 0u, std::move(columns), EmptyOverlaysFromParent(parent)), 43| 34.7k| allow_inserts_(true), 44| 34.7k| parent_(parent) {} _ZN8perfetto15trace_processor15macros_internal10MacroTable28UpdateSelfOverlayAfterInsertEv: 61| 14.9M|PERFETTO_NO_INLINE void MacroTable::UpdateSelfOverlayAfterInsert() { 62| 14.9M| IncrementRowCountAndAddToLastOverlay(); 63| 14.9M|} _ZN8perfetto15trace_processor15macros_internal10MacroTable37CopyColumnsFromParentOrAddRootColumnsEPKS2_: 66| 34.7k|MacroTable::CopyColumnsFromParentOrAddRootColumns(const MacroTable* parent) { 67| 34.7k| std::vector columns; 68| 34.7k| if (parent) { ------------------ | Branch (68:7): [True: 434, False: 34.2k] ------------------ 69| 6.51k| for (const ColumnLegacy& col : parent->columns()) { ------------------ | Branch (69:34): [True: 6.51k, False: 434] ------------------ 70| 6.51k| columns.emplace_back(col, col.index_in_table(), col.overlay_index()); 71| 6.51k| } 72| 34.2k| } else { 73| 34.2k| columns.emplace_back(ColumnLegacy::IdColumn(0, 0)); 74| 34.2k| } 75| 34.7k| return columns; 76| 34.7k|} _ZN8perfetto15trace_processor15macros_internal10MacroTable41OnConstructionCompletedRegularConstructorESt16initializer_listINS0_6RefPtrINS0_6column12StorageLayerEEEES3_INS4_INS5_12OverlayLayerEEEE: 80| 34.7k| std::initializer_list> null_layers) { 81| 34.7k| std::vector> overlay_layers( 82| 34.7k| OverlayCount(parent_) + 1); 83| 35.1k| for (uint32_t i = 0; i < overlay_layers.size() - 1; ++i) { ------------------ | Branch (83:24): [True: 434, False: 34.7k] ------------------ 84| 434| PERFETTO_CHECK(overlays()[i].row_map().IsBitVector()); 85| 434| overlay_layers[i].reset( 86| 434| new column::SelectorOverlay(overlays()[i].row_map().GetIfBitVector())); 87| 434| } 88| 34.7k| Table::OnConstructionCompleted(storage_layers, null_layers, 89| 34.7k| std::move(overlay_layers)); 90| 34.7k|} _ZN8perfetto15trace_processor15macros_internal10MacroTable23EmptyOverlaysFromParentEPKS2_: 93| 34.7k|MacroTable::EmptyOverlaysFromParent(const MacroTable* parent) { 94| 34.7k| std::vector overlays(parent ? parent->overlays().size() ------------------ | Branch (94:46): [True: 434, False: 34.2k] ------------------ 95| 34.7k| : 0); 96| 34.7k| for (auto& overlay : overlays) { ------------------ | Branch (96:22): [True: 434, False: 34.7k] ------------------ 97| 434| overlay = ColumnStorageOverlay(BitVector()); 98| 434| } 99| 34.7k| overlays.emplace_back(); 100| 34.7k| return overlays; 101| 34.7k|} _ZN8perfetto15trace_processor15macros_internal17BaseConstIteratorC2EPKNS1_10MacroTableENS0_5Table8IteratorE: 118| 71.8k| : iterator_(std::move(iterator)), table_(table) { 119| 71.8k| static_assert(std::is_base_of::value, 120| 71.8k| "Template param should be a subclass of Table."); 121| 71.8k|} _ZNK8perfetto15trace_processor15macros_internal17BaseConstIteratorcvbEv: 123| 446k|BaseConstIterator::operator bool() const { 124| 446k| return bool(iterator_); 125| 446k|} _ZN8perfetto15trace_processor15macros_internal17BaseConstIteratorppEv: 127| 374k|BaseConstIterator& BaseConstIterator::operator++() { 128| 374k| ++iterator_; 129| 374k| return *this; 130| 374k|} _ZN8perfetto15trace_processor15macros_internal16BaseRowReferenceC2EPKNS1_10MacroTableEj: 133| 410M| : table_(table), row_number_(row_number) {} _ZN8perfetto15trace_processor15macros_internal15RootParentTable3RowC2EDn: 48| 15.0M| explicit Row(std::nullptr_t = nullptr) {} _ZN8perfetto15trace_processor15macros_internal10MacroTable12OverlayCountEPKS2_: 115| 69.4k| static uint32_t OverlayCount(const MacroTable* parent) { 116| 69.4k| return parent ? static_cast(parent->overlays().size()) : 0; ------------------ | Branch (116:12): [True: 868, False: 68.5k] ------------------ 117| 69.4k| } _ZNK8perfetto15trace_processor15macros_internal13BaseRowNumber10row_numberEv: 187| 3.71M| uint32_t row_number() const { return row_number_; } _ZN8perfetto15trace_processor15macros_internal13BaseRowNumberC2Ej: 195| 18.8M| explicit BaseRowNumber(uint32_t row_number) : row_number_(row_number) {} _ZN8perfetto15trace_processor15macros_internal10MacroTable17AddColumnToVectorIjEEvRNSt3__16vectorINS0_12ColumnLegacyENS4_9allocatorIS6_EEEEPKcPNS0_13ColumnStorageIT_EEjjj: 111| 39.9k| uint32_t overlay_index) { 112| 39.9k| columns.emplace_back(name, storage, flags, column_index, overlay_index); 113| 39.9k| } _ZNK8perfetto15trace_processor15macros_internal25AbstractConstRowReferenceINS0_6tables12ProcessTableENS4_9RowNumberEE5tableEv: 241| 273M| const MacroTable* table() const { 242| 273M| return static_cast(table_); 243| 273M| } _ZN8perfetto15trace_processor15macros_internal10MacroTable17AddColumnToVectorINS0_10StringPool2IdEEEvRNSt3__16vectorINS0_12ColumnLegacyENS6_9allocatorIS8_EEEEPKcPNS0_13ColumnStorageIT_EEjjj: 111| 44.2k| uint32_t overlay_index) { 112| 44.2k| columns.emplace_back(name, storage, flags, column_index, overlay_index); 113| 44.2k| } _ZN8perfetto15trace_processor15macros_internal10MacroTable17AddColumnToVectorINSt3__18optionalIlEEEEvRNS4_6vectorINS0_12ColumnLegacyENS4_9allocatorIS8_EEEEPKcPNS0_13ColumnStorageIT_EEjjj: 111| 10.4k| uint32_t overlay_index) { 112| 10.4k| columns.emplace_back(name, storage, flags, column_index, overlay_index); 113| 10.4k| } _ZN8perfetto15trace_processor15macros_internal10MacroTable17AddColumnToVectorINSt3__18optionalIjEEEEvRNS4_6vectorINS0_12ColumnLegacyENS4_9allocatorIS8_EEEEPKcPNS0_13ColumnStorageIT_EEjjj: 111| 39.0k| uint32_t overlay_index) { 112| 39.0k| columns.emplace_back(name, storage, flags, column_index, overlay_index); 113| 39.0k| } _ZNK8perfetto15trace_processor15macros_internal25AbstractConstRowReferenceINS0_6tables11ThreadTableENS4_9RowNumberEE5tableEv: 241| 276M| const MacroTable* table() const { 242| 276M| return static_cast(table_); 243| 276M| } _ZN8perfetto15trace_processor15macros_internal10MacroTable17AddColumnToVectorINSt3__18optionalIdEEEEvRNS4_6vectorINS0_12ColumnLegacyENS4_9allocatorIS8_EEEEPKcPNS0_13ColumnStorageIT_EEjjj: 111| 3.03k| uint32_t overlay_index) { 112| 3.03k| columns.emplace_back(name, storage, flags, column_index, overlay_index); 113| 3.03k| } _ZN8perfetto15trace_processor15macros_internal10MacroTable17AddColumnToVectorIlEEvRNSt3__16vectorINS0_12ColumnLegacyENS4_9allocatorIS6_EEEEPKcPNS0_13ColumnStorageIT_EEjjj: 111| 38.6k| uint32_t overlay_index) { 112| 38.6k| columns.emplace_back(name, storage, flags, column_index, overlay_index); 113| 38.6k| } _ZNK8perfetto15trace_processor15macros_internal25AbstractConstRowReferenceINS0_6tables13MetadataTableENS4_9RowNumberEE5tableEv: 241| 136k| const MacroTable* table() const { 242| 136k| return static_cast(table_); 243| 136k| } _ZNK8perfetto15trace_processor15macros_internal21AbstractConstIteratorINS0_6tables13MetadataTable13ConstIteratorES4_NS4_9RowNumberENS4_17ConstRowReferenceEE5tableEv: 175| 514k| const MacroTable* table() const { 176| 514k| return static_cast(table_); 177| 514k| } _ZNK8perfetto15trace_processor15macros_internal25AbstractConstRowReferenceINS0_6tables14TraceFileTableENS4_9RowNumberEE5tableEv: 241| 1.88k| const MacroTable* table() const { 242| 1.88k| return static_cast(table_); 243| 1.88k| } _ZN8perfetto15trace_processor15macros_internal10MacroTable17AddColumnToVectorIiEEvRNSt3__16vectorINS0_12ColumnLegacyENS4_9allocatorIS6_EEEEPKcPNS0_13ColumnStorageIT_EEjjj: 111| 6.94k| uint32_t overlay_index) { 112| 6.94k| columns.emplace_back(name, storage, flags, column_index, overlay_index); 113| 6.94k| } _ZN8perfetto15trace_processor15macros_internal10MacroTable17AddColumnToVectorINSt3__18optionalIiEEEEvRNS4_6vectorINS0_12ColumnLegacyENS4_9allocatorIS8_EEEEPKcPNS0_13ColumnStorageIT_EEjjj: 111| 1.30k| uint32_t overlay_index) { 112| 1.30k| columns.emplace_back(name, storage, flags, column_index, overlay_index); 113| 1.30k| } _ZNK8perfetto15trace_processor15macros_internal25AbstractConstRowReferenceINS0_6tables10TrackTableENS4_9RowNumberEE5tableEv: 241| 179k| const MacroTable* table() const { 242| 179k| return static_cast(table_); 243| 179k| } _ZN8perfetto15trace_processor15macros_internal10MacroTable17AddColumnToVectorIdEEvRNSt3__16vectorINS0_12ColumnLegacyENS4_9allocatorIS6_EEEEPKcPNS0_13ColumnStorageIT_EEjjj: 111| 434| uint32_t overlay_index) { 112| 434| columns.emplace_back(name, storage, flags, column_index, overlay_index); 113| 434| } _ZNK8perfetto15trace_processor15macros_internal25AbstractConstRowReferenceINS0_6tables10SliceTableENS4_9RowNumberEE5tableEv: 241| 52.4M| const MacroTable* table() const { 242| 52.4M| return static_cast(table_); 243| 52.4M| } _ZNK8perfetto15trace_processor15macros_internal25AbstractConstRowReferenceINS0_6tables23MemorySnapshotNodeTableENS4_9RowNumberEE5tableEv: 241| 1.27k| const MacroTable* table() const { 242| 1.27k| return static_cast(table_); 243| 1.27k| } _ZN8perfetto15trace_processor15macros_internal25AbstractConstRowReferenceINS0_6tables14ChromeRawTableENS4_9RowNumberEE11ToRowNumberEv: 238| 1.44M| RowNumber ToRowNumber() { return RowNumber(row_number_); } _ZN8perfetto15trace_processor15macros_internal25AbstractConstRowReferenceINS0_6tables12CounterTableENS4_9RowNumberEE11ToRowNumberEv: 238| 279k| RowNumber ToRowNumber() { return RowNumber(row_number_); } _ZN8perfetto15trace_processor15macros_internal25AbstractConstRowReferenceINS0_6tables10SliceTableENS4_9RowNumberEE11ToRowNumberEv: 238| 1.97M| RowNumber ToRowNumber() { return RowNumber(row_number_); } _ZN8perfetto15trace_processor15macros_internal25AbstractConstRowReferenceINS0_6tables9FlowTableENS4_9RowNumberEE11ToRowNumberEv: 238| 1.39k| RowNumber ToRowNumber() { return RowNumber(row_number_); } _ZN8perfetto15trace_processor15macros_internal25AbstractConstRowReferenceINS0_6tables23MemorySnapshotNodeTableENS4_9RowNumberEE11ToRowNumberEv: 238| 3.77k| RowNumber ToRowNumber() { return RowNumber(row_number_); } _ZN8perfetto15trace_processor15macros_internal25AbstractConstRowReferenceINS0_6tables10TrackTableENS4_9RowNumberEE11ToRowNumberEv: 238| 151k| RowNumber ToRowNumber() { return RowNumber(row_number_); } _ZN8perfetto15trace_processor15macros_internal25AbstractConstRowReferenceINS0_6tables8ArgTableENS4_9RowNumberEEC2EPKS4_j: 246| 2.16M| : BaseRowReference(table, row_number) {} _ZN8perfetto15trace_processor15macros_internal17AbstractRowNumberINS0_6tables8ArgTableENS4_17ConstRowReferenceENS4_12RowReferenceEEC2Ej: 220| 2.16M| explicit AbstractRowNumber(uint32_t row_number) : BaseRowNumber(row_number) {} _ZN8perfetto15trace_processor15macros_internal25AbstractConstRowReferenceINS0_6tables8CpuTableENS4_9RowNumberEEC2EPKS4_j: 246| 8.34M| : BaseRowReference(table, row_number) {} _ZN8perfetto15trace_processor15macros_internal17AbstractRowNumberINS0_6tables8CpuTableENS4_17ConstRowReferenceENS4_12RowReferenceEEC2Ej: 220| 8.34M| explicit AbstractRowNumber(uint32_t row_number) : BaseRowNumber(row_number) {} _ZN8perfetto15trace_processor15macros_internal25AbstractConstRowReferenceINS0_6tables12CounterTableENS4_9RowNumberEEC2EPKS4_j: 246| 558k| : BaseRowReference(table, row_number) {} _ZN8perfetto15trace_processor15macros_internal17AbstractRowNumberINS0_6tables12CounterTableENS4_17ConstRowReferenceENS4_12RowReferenceEEC2Ej: 220| 558k| explicit AbstractRowNumber(uint32_t row_number) : BaseRowNumber(row_number) {} _ZN8perfetto15trace_processor15macros_internal25AbstractConstRowReferenceINS0_6tables11ThreadTableENS4_9RowNumberEEC2EPKS4_j: 246| 184M| : BaseRowReference(table, row_number) {} _ZN8perfetto15trace_processor15macros_internal25AbstractConstRowReferenceINS0_6tables9FlowTableENS4_9RowNumberEEC2EPKS4_j: 246| 2.79k| : BaseRowReference(table, row_number) {} _ZN8perfetto15trace_processor15macros_internal17AbstractRowNumberINS0_6tables9FlowTableENS4_17ConstRowReferenceENS4_12RowReferenceEEC2Ej: 220| 2.79k| explicit AbstractRowNumber(uint32_t row_number) : BaseRowNumber(row_number) {} _ZN8perfetto15trace_processor15macros_internal25AbstractConstRowReferenceINS0_6tables12MachineTableENS4_9RowNumberEEC2EPKS4_j: 246| 2.03k| : BaseRowReference(table, row_number) {} _ZN8perfetto15trace_processor15macros_internal17AbstractRowNumberINS0_6tables12MachineTableENS4_17ConstRowReferenceENS4_12RowReferenceEEC2Ej: 220| 2.03k| explicit AbstractRowNumber(uint32_t row_number) : BaseRowNumber(row_number) {} _ZN8perfetto15trace_processor15macros_internal21AbstractConstIteratorINS0_6tables13MetadataTable13ConstIteratorES4_NS4_9RowNumberENS4_17ConstRowReferenceEEC2EPKS4_NS0_5Table8IteratorE: 173| 71.8k| : BaseConstIterator(table, std::move(iterator)) {} _ZN8perfetto15trace_processor15macros_internal25AbstractConstRowReferenceINS0_6tables13MetadataTableENS4_9RowNumberEEC2EPKS4_j: 246| 203k| : BaseRowReference(table, row_number) {} _ZN8perfetto15trace_processor15macros_internal17AbstractRowNumberINS0_6tables13MetadataTableENS4_17ConstRowReferenceENS4_12RowReferenceEEC2Ej: 220| 136k| explicit AbstractRowNumber(uint32_t row_number) : BaseRowNumber(row_number) {} _ZN8perfetto15trace_processor15macros_internal21AbstractConstIteratorINS0_6tables13MetadataTable13ConstIteratorES4_NS4_9RowNumberENS4_17ConstRowReferenceEEppEv: 156| 374k| Iterator& operator++() { 157| 374k| return static_cast(BaseConstIterator::operator++()); 158| 374k| } _ZNK8perfetto15trace_processor15macros_internal21AbstractConstIteratorINS0_6tables13MetadataTable13ConstIteratorES4_NS4_9RowNumberENS4_17ConstRowReferenceEE10row_numberEv: 161| 69.9k| RowNumber row_number() const { 162| 69.9k| return RowNumber(this_it()->CurrentRowNumber()); 163| 69.9k| } _ZNK8perfetto15trace_processor15macros_internal21AbstractConstIteratorINS0_6tables13MetadataTable13ConstIteratorES4_NS4_9RowNumberENS4_17ConstRowReferenceEE7this_itEv: 181| 69.9k| const Iterator* this_it() const { return static_cast(this); } _ZN8perfetto15trace_processor15macros_internal25AbstractConstRowReferenceINS0_6tables12ProcessTableENS4_9RowNumberEEC2EPKS4_j: 246| 182M| : BaseRowReference(table, row_number) {} _ZN8perfetto15trace_processor15macros_internal17AbstractRowNumberINS0_6tables12ProcessTableENS4_17ConstRowReferenceENS4_12RowReferenceEEC2Ej: 220| 566k| explicit AbstractRowNumber(uint32_t row_number) : BaseRowNumber(row_number) {} _ZN8perfetto15trace_processor15macros_internal17AbstractRowNumberINS0_6tables11ThreadTableENS4_17ConstRowReferenceENS4_12RowReferenceEEC2Ej: 220| 682k| explicit AbstractRowNumber(uint32_t row_number) : BaseRowNumber(row_number) {} _ZN8perfetto15trace_processor15macros_internal25AbstractConstRowReferenceINS0_6tables10SliceTableENS4_9RowNumberEEC2EPKS4_j: 246| 27.6M| : BaseRowReference(table, row_number) {} _ZN8perfetto15trace_processor15macros_internal17AbstractRowNumberINS0_6tables10SliceTableENS4_17ConstRowReferenceENS4_12RowReferenceEEC2Ej: 220| 2.72M| explicit AbstractRowNumber(uint32_t row_number) : BaseRowNumber(row_number) {} _ZNK8perfetto15trace_processor15macros_internal17AbstractRowNumberINS0_6tables10SliceTableENS4_17ConstRowReferenceENS4_12RowReferenceEE14ToRowReferenceIS6_EET_PS4_: 209| 16.6M| RR ToRowReference(MacroTable* table) const { 210| 16.6M| static_assert(!std::is_same_v); 211| 16.6M| return RR(table, row_number_); 212| 16.6M| } _ZNK8perfetto15trace_processor15macros_internal17AbstractRowNumberINS0_6tables10SliceTableENS4_17ConstRowReferenceENS4_12RowReferenceEE14ToRowReferenceERKS4_: 215| 8.27M| ConstRowReference ToRowReference(const MacroTable& table) const { 216| 8.27M| return ConstRowReference(&table, row_number_); 217| 8.27M| } _ZN8perfetto15trace_processor15macros_internal25AbstractConstRowReferenceINS0_6tables14TraceFileTableENS4_9RowNumberEEC2EPKS4_j: 246| 1.20k| : BaseRowReference(table, row_number) {} _ZN8perfetto15trace_processor15macros_internal17AbstractRowNumberINS0_6tables14TraceFileTableENS4_17ConstRowReferenceENS4_12RowReferenceEEC2Ej: 220| 434| explicit AbstractRowNumber(uint32_t row_number) : BaseRowNumber(row_number) {} _ZN8perfetto15trace_processor15macros_internal25AbstractConstRowReferenceINS0_6tables10TrackTableENS4_9RowNumberEEC2EPKS4_j: 246| 509k| : BaseRowReference(table, row_number) {} _ZN8perfetto15trace_processor15macros_internal17AbstractRowNumberINS0_6tables10TrackTableENS4_17ConstRowReferenceENS4_12RowReferenceEEC2Ej: 220| 419k| explicit AbstractRowNumber(uint32_t row_number) : BaseRowNumber(row_number) {} _ZN8perfetto15trace_processor15macros_internal25AbstractConstRowReferenceINS0_6tables25ExpMissingChromeProcTableENS4_9RowNumberEEC2EPKS4_j: 246| 361k| : BaseRowReference(table, row_number) {} _ZN8perfetto15trace_processor15macros_internal17AbstractRowNumberINS0_6tables25ExpMissingChromeProcTableENS4_17ConstRowReferenceENS4_12RowReferenceEEC2Ej: 220| 361k| explicit AbstractRowNumber(uint32_t row_number) : BaseRowNumber(row_number) {} _ZN8perfetto15trace_processor15macros_internal25AbstractConstRowReferenceINS0_6tables19MemorySnapshotTableENS4_9RowNumberEEC2EPKS4_j: 246| 641| : BaseRowReference(table, row_number) {} _ZN8perfetto15trace_processor15macros_internal17AbstractRowNumberINS0_6tables19MemorySnapshotTableENS4_17ConstRowReferenceENS4_12RowReferenceEEC2Ej: 220| 641| explicit AbstractRowNumber(uint32_t row_number) : BaseRowNumber(row_number) {} _ZN8perfetto15trace_processor15macros_internal25AbstractConstRowReferenceINS0_6tables26ProcessMemorySnapshotTableENS4_9RowNumberEEC2EPKS4_j: 246| 43.2k| : BaseRowReference(table, row_number) {} _ZN8perfetto15trace_processor15macros_internal17AbstractRowNumberINS0_6tables26ProcessMemorySnapshotTableENS4_17ConstRowReferenceENS4_12RowReferenceEEC2Ej: 220| 43.2k| explicit AbstractRowNumber(uint32_t row_number) : BaseRowNumber(row_number) {} _ZN8perfetto15trace_processor15macros_internal25AbstractConstRowReferenceINS0_6tables23MemorySnapshotEdgeTableENS4_9RowNumberEEC2EPKS4_j: 246| 364| : BaseRowReference(table, row_number) {} _ZN8perfetto15trace_processor15macros_internal17AbstractRowNumberINS0_6tables23MemorySnapshotEdgeTableENS4_17ConstRowReferenceENS4_12RowReferenceEEC2Ej: 220| 364| explicit AbstractRowNumber(uint32_t row_number) : BaseRowNumber(row_number) {} _ZN8perfetto15trace_processor15macros_internal25AbstractConstRowReferenceINS0_6tables23MemorySnapshotNodeTableENS4_9RowNumberEEC2EPKS4_j: 246| 11.3k| : BaseRowReference(table, row_number) {} _ZN8perfetto15trace_processor15macros_internal17AbstractRowNumberINS0_6tables23MemorySnapshotNodeTableENS4_17ConstRowReferenceENS4_12RowReferenceEEC2Ej: 220| 7.54k| explicit AbstractRowNumber(uint32_t row_number) : BaseRowNumber(row_number) {} _ZN8perfetto15trace_processor15macros_internal25AbstractConstRowReferenceINS0_6tables14ChromeRawTableENS4_9RowNumberEEC2EPKS4_j: 246| 2.85M| : BaseRowReference(table, row_number) {} _ZN8perfetto15trace_processor15macros_internal17AbstractRowNumberINS0_6tables14ChromeRawTableENS4_17ConstRowReferenceENS4_12RowReferenceEEC2Ej: 220| 2.85M| explicit AbstractRowNumber(uint32_t row_number) : BaseRowNumber(row_number) {} _ZN8perfetto15trace_processor15macros_internal25AbstractConstRowReferenceINS0_6tables18ClockSnapshotTableENS4_9RowNumberEEC2EPKS4_j: 246| 25.1k| : BaseRowReference(table, row_number) {} _ZN8perfetto15trace_processor15macros_internal17AbstractRowNumberINS0_6tables18ClockSnapshotTableENS4_17ConstRowReferenceENS4_12RowReferenceEEC2Ej: 220| 25.1k| explicit AbstractRowNumber(uint32_t row_number) : BaseRowNumber(row_number) {} _ZN8perfetto15trace_processor15macros_internal10MacroTableD2Ev: 37| 34.7k|MacroTable::~MacroTable() = default; _ZN8perfetto15trace_processor6tables21AndroidDumpstateTableD2Ev: 42| 434|AndroidDumpstateTable::~AndroidDumpstateTable() = default; _ZN8perfetto15trace_processor6tables32AndroidGameInterventionListTableD2Ev: 43| 434|AndroidGameInterventionListTable::~AndroidGameInterventionListTable() = default; _ZN8perfetto15trace_processor6tables15AndroidLogTableD2Ev: 44| 434|AndroidLogTable::~AndroidLogTable() = default; _ZN8perfetto15trace_processor6tables21AndroidKeyEventsTableD2Ev: 45| 434|AndroidKeyEventsTable::~AndroidKeyEventsTable() = default; _ZN8perfetto15trace_processor6tables24AndroidMotionEventsTableD2Ev: 46| 434|AndroidMotionEventsTable::~AndroidMotionEventsTable() = default; _ZN8perfetto15trace_processor6tables30AndroidInputEventDispatchTableD2Ev: 47| 434|AndroidInputEventDispatchTable::~AndroidInputEventDispatchTable() = default; _ZN8perfetto15trace_processor6tables12CounterTableD2Ev: 50| 434|CounterTable::~CounterTable() = default; _ZN8perfetto15trace_processor6tables12ElfFileTableD2Ev: 53| 434|ElfFileTable::~ElfFileTable() = default; _ZN8perfetto15trace_processor6tables23EtmV4ConfigurationTableD2Ev: 54| 434|EtmV4ConfigurationTable::~EtmV4ConfigurationTable() = default; _ZN8perfetto15trace_processor6tables17EtmV4SessionTableD2Ev: 55| 434|EtmV4SessionTable::~EtmV4SessionTable() = default; _ZN8perfetto15trace_processor6tables15EtmV4TraceTableD2Ev: 56| 434|EtmV4TraceTable::~EtmV4TraceTable() = default; _ZN8perfetto15trace_processor6tables9FileTableD2Ev: 57| 434|FileTable::~FileTable() = default; _ZN8perfetto15trace_processor6tables12JitCodeTableD2Ev: 60| 434|JitCodeTable::~JitCodeTable() = default; _ZN8perfetto15trace_processor6tables13JitFrameTableD2Ev: 61| 434|JitFrameTable::~JitFrameTable() = default; _ZN8perfetto15trace_processor6tables14ChromeRawTableD2Ev: 64| 434|ChromeRawTable::~ChromeRawTable() = default; _ZN8perfetto15trace_processor6tables16FtraceEventTableD2Ev: 65| 434|FtraceEventTable::~FtraceEventTable() = default; _ZN8perfetto15trace_processor6tables8ArgTableD2Ev: 66| 434|ArgTable::~ArgTable() = default; _ZN8perfetto15trace_processor6tables25ExpMissingChromeProcTableD2Ev: 67| 434|ExpMissingChromeProcTable::~ExpMissingChromeProcTable() = default; _ZN8perfetto15trace_processor6tables13MetadataTableD2Ev: 68| 434|MetadataTable::~MetadataTable() = default; _ZN8perfetto15trace_processor6tables8CpuTableD2Ev: 69| 434|CpuTable::~CpuTable() = default; _ZN8perfetto15trace_processor6tables12CpuFreqTableD2Ev: 70| 434|CpuFreqTable::~CpuFreqTable() = default; _ZN8perfetto15trace_processor6tables11ThreadTableD2Ev: 71| 434|ThreadTable::~ThreadTable() = default; _ZN8perfetto15trace_processor6tables12ProcessTableD2Ev: 72| 434|ProcessTable::~ProcessTable() = default; _ZN8perfetto15trace_processor6tables19FiledescriptorTableD2Ev: 73| 434|FiledescriptorTable::~FiledescriptorTable() = default; _ZN8perfetto15trace_processor6tables18ClockSnapshotTableD2Ev: 74| 434|ClockSnapshotTable::~ClockSnapshotTable() = default; _ZN8perfetto15trace_processor6tables12MachineTableD2Ev: 75| 434|MachineTable::~MachineTable() = default; _ZN8perfetto15trace_processor6tables14TraceFileTableD2Ev: 76| 434|TraceFileTable::~TraceFileTable() = default; _ZN8perfetto15trace_processor6tables15MmapRecordTableD2Ev: 79| 434|MmapRecordTable::~MmapRecordTable() = default; _ZN8perfetto15trace_processor6tables14SpeRecordTableD2Ev: 80| 434|SpeRecordTable::~SpeRecordTable() = default; _ZN8perfetto15trace_processor6tables24StackProfileMappingTableD2Ev: 83| 434|StackProfileMappingTable::~StackProfileMappingTable() = default; _ZN8perfetto15trace_processor6tables22StackProfileFrameTableD2Ev: 84| 434|StackProfileFrameTable::~StackProfileFrameTable() = default; _ZN8perfetto15trace_processor6tables25StackProfileCallsiteTableD2Ev: 85| 434|StackProfileCallsiteTable::~StackProfileCallsiteTable() = default; _ZN8perfetto15trace_processor6tables26CpuProfileStackSampleTableD2Ev: 86| 434|CpuProfileStackSampleTable::~CpuProfileStackSampleTable() = default; _ZN8perfetto15trace_processor6tables16PerfSessionTableD2Ev: 87| 434|PerfSessionTable::~PerfSessionTable() = default; _ZN8perfetto15trace_processor6tables15PerfSampleTableD2Ev: 88| 434|PerfSampleTable::~PerfSampleTable() = default; _ZN8perfetto15trace_processor6tables22InstrumentsSampleTableD2Ev: 89| 434|InstrumentsSampleTable::~InstrumentsSampleTable() = default; _ZN8perfetto15trace_processor6tables11SymbolTableD2Ev: 90| 434|SymbolTable::~SymbolTable() = default; _ZN8perfetto15trace_processor6tables26HeapProfileAllocationTableD2Ev: 91| 434|HeapProfileAllocationTable::~HeapProfileAllocationTable() = default; _ZN8perfetto15trace_processor6tables20HeapGraphObjectTableD2Ev: 93| 434|HeapGraphObjectTable::~HeapGraphObjectTable() = default; _ZN8perfetto15trace_processor6tables19HeapGraphClassTableD2Ev: 94| 434|HeapGraphClassTable::~HeapGraphClassTable() = default; _ZN8perfetto15trace_processor6tables23HeapGraphReferenceTableD2Ev: 95| 434|HeapGraphReferenceTable::~HeapGraphReferenceTable() = default; _ZN8perfetto15trace_processor6tables28VulkanMemoryAllocationsTableD2Ev: 96| 434|VulkanMemoryAllocationsTable::~VulkanMemoryAllocationsTable() = default; _ZN8perfetto15trace_processor6tables16PackageListTableD2Ev: 97| 434|PackageListTable::~PackageListTable() = default; _ZN8perfetto15trace_processor6tables18ProfilerSmapsTableD2Ev: 98| 434|ProfilerSmapsTable::~ProfilerSmapsTable() = default; _ZN8perfetto15trace_processor6tables20GpuCounterGroupTableD2Ev: 99| 434|GpuCounterGroupTable::~GpuCounterGroupTable() = default; _ZN8perfetto15trace_processor6tables15SchedSliceTableD2Ev: 102| 434|SchedSliceTable::~SchedSliceTable() = default; _ZN8perfetto15trace_processor6tables24SpuriousSchedWakeupTableD2Ev: 103| 434|SpuriousSchedWakeupTable::~SpuriousSchedWakeupTable() = default; _ZN8perfetto15trace_processor6tables16ThreadStateTableD2Ev: 104| 434|ThreadStateTable::~ThreadStateTable() = default; _ZN8perfetto15trace_processor6tables10SliceTableD2Ev: 107| 434|SliceTable::~SliceTable() = default; _ZN8perfetto15trace_processor6tables9FlowTableD2Ev: 108| 434|FlowTable::~FlowTable() = default; _ZN8perfetto15trace_processor6tables26AndroidNetworkPacketsTableD2Ev: 110| 434|AndroidNetworkPacketsTable::~AndroidNetworkPacketsTable() = default; _ZN8perfetto15trace_processor6tables10TrackTableD2Ev: 113| 434|TrackTable::~TrackTable() = default; _ZN8perfetto15trace_processor6tables26ExperimentalProtoPathTableD2Ev: 116| 434|ExperimentalProtoPathTable::~ExperimentalProtoPathTable() = default; _ZN8perfetto15trace_processor6tables29ExperimentalProtoContentTableD2Ev: 117| 434|ExperimentalProtoContentTable::~ExperimentalProtoContentTable() = default; _ZN8perfetto15trace_processor6tables19MemorySnapshotTableD2Ev: 120| 434|MemorySnapshotTable::~MemorySnapshotTable() = default; _ZN8perfetto15trace_processor6tables26ProcessMemorySnapshotTableD2Ev: 121| 434|ProcessMemorySnapshotTable::~ProcessMemorySnapshotTable() = default; _ZN8perfetto15trace_processor6tables23MemorySnapshotNodeTableD2Ev: 122| 434|MemorySnapshotNodeTable::~MemorySnapshotNodeTable() = default; _ZN8perfetto15trace_processor6tables23MemorySnapshotEdgeTableD2Ev: 123| 434|MemorySnapshotEdgeTable::~MemorySnapshotEdgeTable() = default; _ZN8perfetto15trace_processor6tables14V8IsolateTableD2Ev: 126| 434|V8IsolateTable::~V8IsolateTable() = default; _ZN8perfetto15trace_processor6tables15V8JsScriptTableD2Ev: 127| 434|V8JsScriptTable::~V8JsScriptTable() = default; _ZN8perfetto15trace_processor6tables17V8WasmScriptTableD2Ev: 128| 434|V8WasmScriptTable::~V8WasmScriptTable() = default; _ZN8perfetto15trace_processor6tables17V8JsFunctionTableD2Ev: 129| 434|V8JsFunctionTable::~V8JsFunctionTable() = default; _ZN8perfetto15trace_processor6tables13V8JsCodeTableD2Ev: 130| 434|V8JsCodeTable::~V8JsCodeTable() = default; _ZN8perfetto15trace_processor6tables19V8InternalCodeTableD2Ev: 131| 434|V8InternalCodeTable::~V8InternalCodeTable() = default; _ZN8perfetto15trace_processor6tables15V8WasmCodeTableD2Ev: 132| 434|V8WasmCodeTable::~V8WasmCodeTable() = default; _ZN8perfetto15trace_processor6tables17V8RegexpCodeTableD2Ev: 133| 434|V8RegexpCodeTable::~V8RegexpCodeTable() = default; _ZN8perfetto15trace_processor6tables23InputMethodClientsTableD2Ev: 136| 434|InputMethodClientsTable::~InputMethodClientsTable() = default; _ZN8perfetto15trace_processor6tables30InputMethodManagerServiceTableD2Ev: 137| 434|InputMethodManagerServiceTable::~InputMethodManagerServiceTable() = default; _ZN8perfetto15trace_processor6tables23InputMethodServiceTableD2Ev: 138| 434|InputMethodServiceTable::~InputMethodServiceTable() = default; _ZN8perfetto15trace_processor6tables13ProtoLogTableD2Ev: 139| 434|ProtoLogTable::~ProtoLogTable() = default; _ZN8perfetto15trace_processor6tables33SurfaceFlingerLayersSnapshotTableD2Ev: 140| 434|SurfaceFlingerLayersSnapshotTable::~SurfaceFlingerLayersSnapshotTable() = _ZN8perfetto15trace_processor6tables24SurfaceFlingerLayerTableD2Ev: 142| 434|SurfaceFlingerLayerTable::~SurfaceFlingerLayerTable() = default; _ZN8perfetto15trace_processor6tables31SurfaceFlingerTransactionsTableD2Ev: 143| 434|SurfaceFlingerTransactionsTable::~SurfaceFlingerTransactionsTable() = default; _ZN8perfetto15trace_processor6tables16ViewCaptureTableD2Ev: 144| 434|ViewCaptureTable::~ViewCaptureTable() = default; _ZN8perfetto15trace_processor6tables20ViewCaptureViewTableD2Ev: 145| 434|ViewCaptureViewTable::~ViewCaptureViewTable() = default; _ZN8perfetto15trace_processor6tables28ViewCaptureInternedDataTableD2Ev: 146| 434|ViewCaptureInternedDataTable::~ViewCaptureInternedDataTable() = default; _ZN8perfetto15trace_processor6tables18WindowManagerTableD2Ev: 147| 434|WindowManagerTable::~WindowManagerTable() = default; _ZN8perfetto15trace_processor6tables34WindowManagerShellTransitionsTableD2Ev: 148| 434|WindowManagerShellTransitionsTable::~WindowManagerShellTransitionsTable() = _ZN8perfetto15trace_processor6tables41WindowManagerShellTransitionHandlersTableD2Ev: 151| 434| ~WindowManagerShellTransitionHandlersTable() = default; _ZN8perfetto15trace_processor6tables39WindowManagerShellTransitionProtosTableD2Ev: 153| 434| ~WindowManagerShellTransitionProtosTable() = default; _ZN8perfetto15trace_processor9TraceBlob8AllocateEm: 41| 159|TraceBlob TraceBlob::Allocate(size_t size) { 42| 159| TraceBlob blob(Ownership::kHeapBuf, new uint8_t[size], size); 43| 159| PERFETTO_CHECK(blob.data_); 44| 159| return blob; 45| 159|} _ZN8perfetto15trace_processor9TraceBlob8CopyFromEPKvm: 48| 159|TraceBlob TraceBlob::CopyFrom(const void* src, size_t size) { 49| 159| TraceBlob blob = Allocate(size); 50| 159| const uint8_t* src_u8 = static_cast(src); 51| 159| std::copy(src_u8, src_u8 + size, blob.data_); 52| 159| return blob; 53| 159|} _ZN8perfetto15trace_processor9TraceBlob13TakeOwnershipENSt3__110unique_ptrIA_hNS2_14default_deleteIS4_EEEEm: 57| 434| size_t size) { 58| 434| PERFETTO_CHECK(buf); 59| 434| return TraceBlob(Ownership::kHeapBuf, buf.release(), size); 60| 434|} _ZN8perfetto15trace_processor9TraceBlobC2ENS1_9OwnershipEPhm: 89| 593| : ownership_(ownership), data_(data), size_(size) {} _ZN8perfetto15trace_processor9TraceBlobD2Ev: 91| 1.34k|TraceBlob::~TraceBlob() { 92| 1.34k| switch (ownership_) { ------------------ | Branch (92:11): [True: 0, False: 1.34k] ------------------ 93| 593| case Ownership::kHeapBuf: ------------------ | Branch (93:5): [True: 593, False: 752] ------------------ 94| 593| delete[] data_; 95| 593| break; 96| | 97| 752| case Ownership::kNullOrMmaped: ------------------ | Branch (97:5): [True: 752, False: 593] ------------------ 98| 752| if (mapping_) { ------------------ | Branch (98:11): [True: 0, False: 752] ------------------ 99| 0| PERFETTO_CHECK(mapping_->reset()); 100| 0| } 101| 752| break; 102| 1.34k| } 103| 1.34k| data_ = nullptr; 104| 1.34k| size_ = 0; 105| 1.34k|} _ZN8perfetto15trace_processor9TraceBlobC2EOS1_: 108| 752| : RefCounted(std::move(other)) { 109| 752| static_assert( 110| 752| sizeof(*this) == base::AlignUp( 111| 752| sizeof(data_) + sizeof(size_) + sizeof(ownership_) + 112| 752| sizeof(mapping_) + sizeof(RefCounted)), 113| 752| "TraceBlob move constructor needs updating"); 114| 752| data_ = other.data_; 115| 752| size_ = other.size_; 116| 752| ownership_ = other.ownership_; 117| 752| mapping_ = std::move(other.mapping_); 118| 752| other.data_ = nullptr; 119| 752| other.size_ = 0; 120| 752| other.ownership_ = Ownership::kNullOrMmaped; 121| 752| other.mapping_ = nullptr; 122| 752|} _ZN8perfetto15trace_processor18FuzzTraceProcessorEPKhm: 25| 434|void FuzzTraceProcessor(const uint8_t* data, size_t size) { 26| 434| std::unique_ptr processor = 27| 434| TraceProcessorStorage::CreateInstance(Config()); 28| 434| std::unique_ptr buf(new uint8_t[size]); 29| 434| memcpy(buf.get(), data, size); 30| 434| base::Status status = processor->Parse(std::move(buf), size); 31| 434| if (!status.ok()) ------------------ | Branch (31:7): [True: 89, False: 345] ------------------ 32| 89| return; 33| 345| if (auto s = processor->NotifyEndOfFile(); !s.ok()) { ------------------ | Branch (33:46): [True: 0, False: 345] ------------------ 34| 0| return; 35| 0| } 36| 345|} LLVMFuzzerTestOneInput: 43| 434|extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) { 44| 434| perfetto::trace_processor::FuzzTraceProcessor(data, size); 45| 434| return 0; 46| 434|} _ZN8perfetto15trace_processor21TraceProcessorContextC2ERKNS1_8InitArgsE: 53| 2.03k| : config(args.config), storage(args.storage) { 54| 2.03k| reader_registry = std::make_unique(this); 55| | // Init the trackers. 56| 2.03k| machine_tracker = std::make_unique(this, args.raw_machine_id); 57| 2.03k| if (!machine_id()) { ------------------ | Branch (57:7): [True: 434, False: 1.60k] ------------------ 58| 434| multi_machine_trace_manager = 59| 434| std::make_unique(this); 60| 434| } 61| 2.03k| track_tracker = std::make_unique(this); 62| 2.03k| track_compressor = std::make_unique(this); 63| 2.03k| args_tracker = std::make_unique(this); 64| 2.03k| args_translation_table = 65| 2.03k| std::make_unique(storage.get()); 66| 2.03k| slice_tracker = std::make_unique(this); 67| 2.03k| slice_translation_table = 68| 2.03k| std::make_unique(storage.get()); 69| 2.03k| flow_tracker = std::make_unique(this); 70| 2.03k| event_tracker = std::make_unique(this); 71| 2.03k| sched_event_tracker = std::make_unique(this); 72| 2.03k| process_tracker = std::make_unique(this); 73| 2.03k| process_track_translation_table = 74| 2.03k| std::make_unique(storage.get()); 75| 2.03k| clock_tracker = std::make_unique(this); 76| 2.03k| clock_converter = std::make_unique(this); 77| 2.03k| mapping_tracker = std::make_unique(this); 78| 2.03k| perf_sample_tracker = std::make_unique(this); 79| 2.03k| stack_profile_tracker = std::make_unique(this); 80| 2.03k| metadata_tracker = std::make_unique(storage.get()); 81| 2.03k| cpu_tracker = std::make_unique(this); 82| 2.03k| global_args_tracker = std::make_shared(storage.get()); 83| 2.03k| descriptor_pool_ = std::make_unique(); 84| | 85| 2.03k| slice_tracker->SetOnSliceBeginCallback( 86| 2.03k| [this](TrackId track_id, SliceId slice_id) { 87| 2.03k| flow_tracker->ClosePendingEventsOnTrack(track_id, slice_id); 88| 2.03k| }); 89| | 90| 2.03k| trace_file_tracker = std::make_unique(this); 91| 2.03k| legacy_v8_cpu_profile_tracker = 92| 2.03k| std::make_unique(this); 93| 2.03k|} _ZN8perfetto15trace_processor21TraceProcessorContextD2Ev: 96| 2.03k|TraceProcessorContext::~TraceProcessorContext() = default; _ZNK8perfetto15trace_processor21TraceProcessorContext10machine_idEv: 102| 5.29M|std::optional TraceProcessorContext::machine_id() const { 103| 5.29M| if (!machine_tracker) { ------------------ | Branch (103:7): [True: 0, False: 5.29M] ------------------ 104| | // Doesn't require that |machine_tracker| is initialzed, e.g. in unit tests. 105| 0| return std::nullopt; 106| 0| } 107| 5.29M| return machine_tracker->machine_id(); 108| 5.29M|} trace_processor_context.cc:_ZZN8perfetto15trace_processor21TraceProcessorContextC1ERKNS1_8InitArgsEENK3$_0clENS0_6tables10TrackTable2IdENS6_10SliceTable2IdE: 86| 731k| [this](TrackId track_id, SliceId slice_id) { 87| 731k| flow_tracker->ClosePendingEventsOnTrack(track_id, slice_id); 88| 731k| }); _ZN8perfetto15trace_processor21TraceProcessorStorage14CreateInstanceERKNS0_6ConfigE: 27| 434| const Config& config) { 28| 434| return std::unique_ptr( 29| 434| new TraceProcessorStorageImpl(config)); 30| 434|} _ZN8perfetto15trace_processor21TraceProcessorStorageD2Ev: 32| 434|TraceProcessorStorage::~TraceProcessorStorage() = default; _ZN8perfetto15trace_processor21TraceProcessorStorage5ParseENSt3__110unique_ptrIA_hNS2_14default_deleteIS4_EEEEm: 35| 434| size_t size) { 36| 434| return Parse(TraceBlobView(TraceBlob::TakeOwnership(std::move(buf), size))); 37| 434|} _ZN8perfetto15trace_processor25TraceProcessorStorageImplC2ERKNS0_6ConfigE: 57| 434| : context_({cfg, std::make_shared(cfg)}) { 58| 434| context_.reader_registry->RegisterTraceReader( 59| 434| kProtoTraceType); 60| 434| context_.reader_registry->RegisterTraceReader( 61| 434| kSymbolsTraceType); 62| 434| context_.proto_trace_parser = 63| 434| std::make_unique(&context_); 64| 434| RegisterDefaultModules(&context_); 65| 434|} _ZN8perfetto15trace_processor25TraceProcessorStorageImplD2Ev: 67| 434|TraceProcessorStorageImpl::~TraceProcessorStorageImpl() {} _ZN8perfetto15trace_processor25TraceProcessorStorageImpl5ParseENS0_13TraceBlobViewE: 69| 434|base::Status TraceProcessorStorageImpl::Parse(TraceBlobView blob) { 70| 434| if (blob.size() == 0) ------------------ | Branch (70:7): [True: 0, False: 434] ------------------ 71| 0| return base::OkStatus(); 72| 434| if (unrecoverable_parse_error_) ------------------ | Branch (72:7): [True: 0, False: 434] ------------------ 73| 0| return base::ErrStatus( 74| 0| "Failed unrecoverably while parsing in a previous Parse call"); 75| 434| if (!parser_) { ------------------ | Branch (75:7): [True: 434, False: 0] ------------------ 76| 434| auto parser = std::make_unique( 77| 434| &context_, context_.trace_file_tracker->AddFile()); 78| 434| parser_ = parser.get(); 79| 434| context_.chunk_readers.push_back(std::move(parser)); 80| 434| } 81| | 82| 434| auto scoped_trace = context_.storage->TraceExecutionTimeIntoStats( 83| 434| stats::parse_trace_duration_ns); 84| | 85| 434| if (hash_input_size_remaining_ > 0 && !context_.uuid_found_in_trace) { ------------------ | Branch (85:7): [True: 434, False: 0] | Branch (85:41): [True: 434, False: 0] ------------------ 86| 434| const size_t hash_size = std::min(hash_input_size_remaining_, blob.size()); 87| 434| hash_input_size_remaining_ -= hash_size; 88| | 89| 434| trace_hash_.Update(reinterpret_cast(blob.data()), hash_size); 90| 434| base::Uuid uuid(static_cast(trace_hash_.digest()), 0); 91| 434| const StringId id_for_uuid = 92| 434| context_.storage->InternString(base::StringView(uuid.ToPrettyString())); 93| 434| context_.metadata_tracker->SetMetadata(metadata::trace_uuid, 94| 434| Variadic::String(id_for_uuid)); 95| 434| } 96| | 97| 434| base::Status status = parser_->Parse(std::move(blob)); 98| 434| unrecoverable_parse_error_ |= !status.ok(); 99| 434| return status; 100| 434|} _ZN8perfetto15trace_processor25TraceProcessorStorageImpl5FlushEv: 102| 690|void TraceProcessorStorageImpl::Flush() { 103| 690| if (unrecoverable_parse_error_) ------------------ | Branch (103:7): [True: 0, False: 690] ------------------ 104| 0| return; 105| | 106| 690| if (context_.sorter) ------------------ | Branch (106:7): [True: 690, False: 0] ------------------ 107| 690| context_.sorter->ExtractEventsForced(); 108| 690| context_.args_tracker->Flush(); 109| 690|} _ZN8perfetto15trace_processor25TraceProcessorStorageImpl15NotifyEndOfFileEv: 111| 345|base::Status TraceProcessorStorageImpl::NotifyEndOfFile() { 112| 345| if (!parser_) { ------------------ | Branch (112:7): [True: 0, False: 345] ------------------ 113| 0| return base::OkStatus(); 114| 0| } 115| 345| if (unrecoverable_parse_error_) { ------------------ | Branch (115:7): [True: 0, False: 345] ------------------ 116| 0| return base::ErrStatus("Unrecoverable parsing error already occurred"); 117| 0| } 118| 345| Flush(); 119| 345| RETURN_IF_ERROR(parser_->NotifyEndOfFile()); ------------------ | | 25| 345| do { \ | | 26| 345| base::Status status_macro_internal_status = (expr); \ | | 27| 345| if (!status_macro_internal_status.ok()) \ | | ------------------ | | | Branch (27:9): [True: 0, False: 345] | | ------------------ | | 28| 345| return status_macro_internal_status; \ | | 29| 345| } while (0) | | ------------------ | | | Branch (29:12): [Folded - Ignored] | | ------------------ ------------------ 120| | // NotifyEndOfFile might have pushed packets to the sorter. 121| 345| Flush(); 122| 2.07k| for (std::unique_ptr& module : context_.modules) { ------------------ | Branch (122:53): [True: 2.07k, False: 345] ------------------ 123| 2.07k| module->NotifyEndOfFile(); 124| 2.07k| } 125| 345| if (context_.content_analyzer) { ------------------ | Branch (125:7): [True: 0, False: 345] ------------------ 126| 0| PacketAnalyzer::Get(&context_)->NotifyEndOfFile(); 127| 0| } 128| | 129| 345| context_.event_tracker->FlushPendingEvents(); 130| 345| context_.slice_tracker->FlushPendingSlices(); 131| 345| context_.args_tracker->Flush(); 132| 345| context_.process_tracker->NotifyEndOfFile(); 133| 345| return base::OkStatus(); 134| 345|} _ZN8perfetto15trace_processor19TraceReaderRegistry15RegisterFactoryENS0_9TraceTypeENSt3__18functionIFNS3_10unique_ptrINS0_18ChunkedTraceReaderENS3_14default_deleteIS6_EEEEPNS0_21TraceProcessorContextEEEE: 65| 868| Factory factory) { 66| 868| PERFETTO_CHECK(factories_.Insert(trace_type, std::move(factory)).second); 67| 868|} _ZN8perfetto15trace_processor19TraceReaderRegistry17CreateTraceReaderENS0_9TraceTypeE: 70| 426|TraceReaderRegistry::CreateTraceReader(TraceType type) { 71| 426| if (auto* it = factories_.Find(type); it) { ------------------ | Branch (71:41): [True: 424, False: 2] ------------------ 72| 424| return (*it)(context_); 73| 424| } 74| | 75| 2| if (RequiresZlibSupport(type) && !util::IsGzipSupported()) { ------------------ | Branch (75:7): [True: 2, False: 0] | Branch (75:36): [Folded - Ignored] ------------------ 76| 0| return base::ErrStatus("%s support is disabled. %s", 77| 0| TraceTypeToString(type), kNoZlibErr); 78| 0| } 79| | 80| 2| return base::ErrStatus("%s support is disabled", TraceTypeToString(type)); 81| 2|} trace_reader_registry.cc:_ZN8perfetto15trace_processor12_GLOBAL__N_119RequiresZlibSupportENS0_9TraceTypeE: 35| 2|bool RequiresZlibSupport(TraceType type) { 36| 2| switch (type) { ------------------ | Branch (36:11): [True: 0, False: 2] ------------------ 37| 0| case kGzipTraceType: ------------------ | Branch (37:5): [True: 0, False: 2] ------------------ 38| 0| case kAndroidBugreportTraceType: ------------------ | Branch (38:5): [True: 0, False: 2] ------------------ 39| 0| case kCtraceTraceType: ------------------ | Branch (39:5): [True: 0, False: 2] ------------------ 40| 2| case kZipFile: ------------------ | Branch (40:5): [True: 2, False: 0] ------------------ 41| 2| return true; 42| | 43| 0| case kNinjaLogTraceType: ------------------ | Branch (43:5): [True: 0, False: 2] ------------------ 44| 0| case kSystraceTraceType: ------------------ | Branch (44:5): [True: 0, False: 2] ------------------ 45| 0| case kPerfDataTraceType: ------------------ | Branch (45:5): [True: 0, False: 2] ------------------ 46| 0| case kInstrumentsXmlTraceType: ------------------ | Branch (46:5): [True: 0, False: 2] ------------------ 47| 0| case kUnknownTraceType: ------------------ | Branch (47:5): [True: 0, False: 2] ------------------ 48| 0| case kJsonTraceType: ------------------ | Branch (48:5): [True: 0, False: 2] ------------------ 49| 0| case kFuchsiaTraceType: ------------------ | Branch (49:5): [True: 0, False: 2] ------------------ 50| 0| case kProtoTraceType: ------------------ | Branch (50:5): [True: 0, False: 2] ------------------ 51| 0| case kSymbolsTraceType: ------------------ | Branch (51:5): [True: 0, False: 2] ------------------ 52| 0| case kAndroidLogcatTraceType: ------------------ | Branch (52:5): [True: 0, False: 2] ------------------ 53| 0| case kAndroidDumpstateTraceType: ------------------ | Branch (53:5): [True: 0, False: 2] ------------------ 54| 0| case kGeckoTraceType: ------------------ | Branch (54:5): [True: 0, False: 2] ------------------ 55| 0| case kArtMethodTraceType: ------------------ | Branch (55:5): [True: 0, False: 2] ------------------ 56| 0| case kPerfTextTraceType: ------------------ | Branch (56:5): [True: 0, False: 2] ------------------ 57| 0| case kTarTraceType: ------------------ | Branch (57:5): [True: 0, False: 2] ------------------ 58| 0| return false; 59| 2| } 60| 0| PERFETTO_FATAL("For GCC"); 61| 0|} _ZN8perfetto15trace_processor19TraceReaderRegistryC2EPNS0_21TraceProcessorContextE: 39| 2.03k| : context_(context) {} _ZN8perfetto15trace_processor19TraceReaderRegistry19RegisterTraceReaderINS0_16ProtoTraceReaderEEEvNS0_9TraceTypeE: 44| 868| void RegisterTraceReader(TraceType trace_type) { 45| 868| RegisterFactory(trace_type, [](TraceProcessorContext* ctxt) { 46| 868| return std::make_unique(ctxt); 47| 868| }); 48| 868| } _ZZN8perfetto15trace_processor19TraceReaderRegistry19RegisterTraceReaderINS0_16ProtoTraceReaderEEEvNS0_9TraceTypeEENKUlPNS0_21TraceProcessorContextEE_clES6_: 45| 424| RegisterFactory(trace_type, [](TraceProcessorContext* ctxt) { 46| 424| return std::make_unique(ctxt); 47| 424| }); _ZN8perfetto15trace_processor12DestructibleD2Ev: 21| 2.03k|Destructible::~Destructible() = default; _ZN8perfetto15trace_processor8Variadic7IntegerEl: 46| 26.3M| static constexpr Variadic Integer(int64_t int_value) { 47| 26.3M| Variadic variadic(Type::kInt); 48| 26.3M| variadic.int_value = int_value; 49| 26.3M| return variadic; 50| 26.3M| } _ZN8perfetto15trace_processor8Variadic15UnsignedIntegerEm: 56| 8.37M| static constexpr Variadic UnsignedInteger(uint64_t uint_value) { 57| 8.37M| Variadic variadic(Type::kUint); 58| 8.37M| variadic.uint_value = uint_value; 59| 8.37M| return variadic; 60| 8.37M| } _ZN8perfetto15trace_processor8Variadic6StringENS0_10StringPool2IdE: 62| 5.84M| static constexpr Variadic String(StringPool::Id string_id) { 63| 5.84M| Variadic variadic(Type::kString); 64| 5.84M| variadic.string_value = string_id; 65| 5.84M| return variadic; 66| 5.84M| } _ZN8perfetto15trace_processor8Variadic4RealEd: 68| 457| static constexpr Variadic Real(double real_value) { 69| 457| Variadic variadic(Type::kReal); 70| 457| variadic.real_value = real_value; 71| 457| return variadic; 72| 457| } _ZN8perfetto15trace_processor8Variadic7PointerEm: 76| 4.04k| static constexpr Variadic Pointer(uint64_t pointer_value) { 77| 4.04k| Variadic variadic(Type::kPointer); 78| 4.04k| variadic.pointer_value = pointer_value; 79| 4.04k| return variadic; 80| 4.04k| } _ZN8perfetto15trace_processor8Variadic7BooleanEb: 82| 151k| static constexpr Variadic Boolean(bool bool_value) { 83| 151k| Variadic variadic(Type::kBool); 84| 151k| variadic.bool_value = bool_value; 85| 151k| return variadic; 86| 151k| } _ZN8perfetto15trace_processor8Variadic4JsonENS0_10StringPool2IdE: 90| 11.6k| static constexpr Variadic Json(StringPool::Id json_value) { 91| 11.6k| Variadic variadic(Type::kJson); 92| 11.6k| variadic.json_value = json_value; 93| 11.6k| return variadic; 94| 11.6k| } _ZN8perfetto15trace_processor8Variadic4NullEv: 96| 64.6k| static constexpr Variadic Null() { return Variadic(Type::kNull); } _ZN8perfetto15trace_processor8VariadicC2ENS1_4TypeE: 135| 40.7M| constexpr explicit Variadic(Type t) : type(t), int_value(0) {} _ZN8perfetto15trace_processor13BumpAllocatorC2Ev: 44| 424|BumpAllocator::BumpAllocator() = default; _ZN8perfetto15trace_processor13BumpAllocatorD2Ev: 46| 424|BumpAllocator::~BumpAllocator() { 47| 424| for (const auto& chunk : chunks_) { ------------------ | Branch (47:26): [True: 309, False: 424] ------------------ 48| 309| PERFETTO_CHECK(chunk.unfreed_allocations == 0); 49| 309| } 50| 424|} _ZN8perfetto15trace_processor13BumpAllocator5AllocEj: 52| 3.71M|BumpAllocator::AllocId BumpAllocator::Alloc(uint32_t size) { 53| | // Size is required to be a multiple of 8 to avoid needing to deal with 54| | // alignment. It must also be at most kChunkSize as we do not support cross 55| | // chunk spanning allocations. 56| 3.71M| PERFETTO_DCHECK(size % 8 == 0); 57| 3.71M| PERFETTO_DCHECK(size <= kChunkSize); 58| | 59| | // Fast path: check if we have space to service this allocation in the current 60| | // chunk. 61| 3.71M| std::optional alloc_id = TryAllocInLastChunk(size); 62| 3.71M| if (alloc_id) { ------------------ | Branch (62:7): [True: 3.71M, False: 2.18k] ------------------ 63| 3.71M| return *alloc_id; 64| 3.71M| } 65| | 66| | // Slow path: we don't have enough space in the last chunk so we create one. 67| 2.18k| Chunk chunk; 68| 2.18k| chunk.allocation = Allocate(kChunkSize); 69| 2.18k| chunks_.emplace_back(std::move(chunk)); 70| | 71| | // Ensure that we haven't exceeded the maximum number of chunks. 72| 2.18k| PERFETTO_CHECK(LastChunkIndex() < kMaxChunkCount); 73| | 74| | // This time the allocation should definitely succeed in the last chunk (which 75| | // we just added). 76| 2.18k| alloc_id = TryAllocInLastChunk(size); 77| 2.18k| PERFETTO_CHECK(alloc_id); 78| 2.18k| return *alloc_id; 79| 2.18k|} _ZN8perfetto15trace_processor13BumpAllocator4FreeENS1_7AllocIdE: 81| 3.71M|void BumpAllocator::Free(AllocId id) { 82| 3.71M| uint64_t queue_index = ChunkIndexToQueueIndex(id.chunk_index); 83| 3.71M| PERFETTO_DCHECK(queue_index <= std::numeric_limits::max()); 84| 3.71M| Chunk& chunk = chunks_.at(static_cast(queue_index)); 85| 3.71M| PERFETTO_DCHECK(chunk.unfreed_allocations > 0); 86| 3.71M| chunk.unfreed_allocations--; 87| 3.71M|} _ZN8perfetto15trace_processor13BumpAllocator10GetPointerENS1_7AllocIdE: 89| 7.43M|void* BumpAllocator::GetPointer(AllocId id) { 90| 7.43M| uint64_t queue_index = ChunkIndexToQueueIndex(id.chunk_index); 91| 7.43M| PERFETTO_CHECK(queue_index <= std::numeric_limits::max()); 92| 7.43M| return chunks_.at(static_cast(queue_index)).allocation.get() + 93| 7.43M| id.chunk_offset; 94| 7.43M|} _ZN8perfetto15trace_processor13BumpAllocator20EraseFrontFreeChunksEv: 96| 13.2k|uint64_t BumpAllocator::EraseFrontFreeChunks() { 97| 13.2k| size_t to_erase_chunks = 0; 98| 15.0k| for (; to_erase_chunks < chunks_.size(); ++to_erase_chunks) { ------------------ | Branch (98:10): [True: 13.6k, False: 1.43k] ------------------ 99| | // Break on the first chunk which still has unfreed allocations. 100| 13.6k| if (chunks_.at(to_erase_chunks).unfreed_allocations > 0) { ------------------ | Branch (100:9): [True: 11.7k, False: 1.87k] ------------------ 101| 11.7k| break; 102| 11.7k| } 103| 13.6k| } 104| 13.2k| chunks_.erase_front(to_erase_chunks); 105| 13.2k| erased_front_chunks_count_ += to_erase_chunks; 106| 13.2k| return to_erase_chunks; 107| 13.2k|} _ZN8perfetto15trace_processor13BumpAllocator12PastTheEndIdEv: 109| 15.5k|BumpAllocator::AllocId BumpAllocator::PastTheEndId() { 110| 15.5k| if (chunks_.empty()) { ------------------ | Branch (110:7): [True: 2.30k, False: 13.2k] ------------------ 111| 2.30k| return AllocId{erased_front_chunks_count_, 0}; 112| 2.30k| } 113| 13.2k| if (chunks_.back().bump_offset == kChunkSize) { ------------------ | Branch (113:7): [True: 8, False: 13.1k] ------------------ 114| 8| return AllocId{LastChunkIndex() + 1, 0}; 115| 8| } 116| 13.1k| return AllocId{LastChunkIndex(), chunks_.back().bump_offset}; 117| 13.2k|} _ZN8perfetto15trace_processor13BumpAllocator19TryAllocInLastChunkEj: 120| 3.72M| uint32_t size) { 121| 3.72M| if (chunks_.empty()) { ------------------ | Branch (121:7): [True: 1.51k, False: 3.71M] ------------------ 122| 1.51k| return std::nullopt; 123| 1.51k| } 124| | 125| | // TODO(266983484): consider switching this to bump downwards instead of 126| | // upwards for more efficient code generation. 127| 3.71M| Chunk& chunk = chunks_.back(); 128| | 129| | // Verify some invariants: 130| | // 1) The allocation must exist 131| | // 2) The bump must be in the bounds of the chunk. 132| 3.71M| PERFETTO_DCHECK(chunk.allocation); 133| 3.71M| PERFETTO_DCHECK(chunk.bump_offset <= kChunkSize); 134| | 135| | // If the end of the allocation ends up after this chunk, we cannot service it 136| | // in this chunk. 137| 3.71M| uint32_t alloc_offset = chunk.bump_offset; 138| 3.71M| uint32_t new_bump_offset = chunk.bump_offset + size; 139| 3.71M| if (new_bump_offset > kChunkSize) { ------------------ | Branch (139:7): [True: 667, False: 3.71M] ------------------ 140| 667| return std::nullopt; 141| 667| } 142| | 143| | // Set the new offset equal to the end of this allocation and increment the 144| | // unfreed allocation counter. 145| 3.71M| chunk.bump_offset = new_bump_offset; 146| 3.71M| chunk.unfreed_allocations++; 147| | 148| | // Unpoison the allocation range to allow access to it on ASAN builds. 149| 3.71M| PERFETTO_ASAN_UNPOISON(chunk.allocation.get() + alloc_offset, size); 150| | 151| 3.71M| return AllocId{LastChunkIndex(), alloc_offset}; 152| 3.71M|} bump_allocator.cc:_ZN8perfetto15trace_processor12_GLOBAL__N_18AllocateEj: 35| 2.18k|base::AlignedUniquePtr Allocate(uint32_t size) { 36| 2.18k| uint8_t* ptr = static_cast(base::AlignedAlloc(8, size)); 37| | // Poison the region to try and catch out of bound accesses. 38| 2.18k| PERFETTO_ASAN_POISON(ptr, size); 39| 2.18k| return base::AlignedUniquePtr(ptr); 40| 2.18k|} _ZNK8perfetto15trace_processor13BumpAllocator7AllocIdltERKS2_: 86| 2.71M| bool operator<(const AllocId& other) const { 87| 2.71M| return std::tie(chunk_index, chunk_offset) < 88| 2.71M| std::tie(other.chunk_index, other.chunk_offset); 89| 2.71M| } _ZNK8perfetto15trace_processor13BumpAllocator7AllocIdgeERKS2_: 90| 2.71M| bool operator>=(const AllocId& other) const { return !(*this < other); } _ZNK8perfetto15trace_processor13BumpAllocator25erased_front_chunks_countEv: 146| 11.1M| uint64_t erased_front_chunks_count() const { 147| 11.1M| return erased_front_chunks_count_; 148| 11.1M| } _ZNK8perfetto15trace_processor13BumpAllocator22ChunkIndexToQueueIndexEm: 169| 11.1M| uint64_t ChunkIndexToQueueIndex(uint64_t chunk_index) const { 170| 11.1M| return chunk_index - erased_front_chunks_count_; 171| 11.1M| } _ZNK8perfetto15trace_processor13BumpAllocator22QueueIndexToChunkIndexEm: 172| 3.73M| uint64_t QueueIndexToChunkIndex(uint64_t index_in_chunks_vec) const { 173| 3.73M| return erased_front_chunks_count_ + index_in_chunks_vec; 174| 3.73M| } _ZNK8perfetto15trace_processor13BumpAllocator14LastChunkIndexEv: 175| 3.73M| uint64_t LastChunkIndex() const { 176| 3.73M| PERFETTO_DCHECK(!chunks_.empty()); 177| 3.73M| return QueueIndexToChunkIndex(static_cast(chunks_.size() - 1)); 178| 3.73M| } _ZN8perfetto15trace_processor4util21DebugAnnotationParserC2ERNS1_17ProtoToArgsParserE: 57| 739k| : proto_to_args_parser_(parser) {} _ZN8perfetto15trace_processor4util21DebugAnnotationParser24ParseDebugAnnotationNameERNS_6protos6pbzero23DebugAnnotation_DecoderERNS1_17ProtoToArgsParser8DelegateERNSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEE: 62| 1.15M| std::string& result) { 63| 1.15M| uint64_t name_iid = annotation.name_iid(); 64| 1.15M| if (PERFETTO_LIKELY(name_iid)) { ------------------ | | 23| 1.15M|#define PERFETTO_LIKELY(...) __builtin_expect(!!(__VA_ARGS__), 1) | | ------------------ | | | Branch (23:30): [True: 16, False: 1.15M] | | ------------------ ------------------ 65| 16| auto* decoder = delegate.GetInternedMessage( 66| 16| protos::pbzero::InternedData::kDebugAnnotationNames, name_iid); 67| 16| if (!decoder) ------------------ | Branch (67:9): [True: 16, False: 0] ------------------ 68| 16| return base::ErrStatus("Debug annotation with invalid name_iid"); 69| | 70| 0| result = SanitizeDebugAnnotationName(decoder->name().ToStdString()); 71| 1.15M| } else if (annotation.has_name()) { ------------------ | Branch (71:14): [True: 23.8k, False: 1.13M] ------------------ 72| 23.8k| result = SanitizeDebugAnnotationName(annotation.name().ToStdString()); 73| 1.13M| } else { 74| 1.13M| return base::ErrStatus("Debug annotation without name"); 75| 1.13M| } 76| 23.8k| return base::OkStatus(); 77| 1.15M|} _ZN8perfetto15trace_processor4util21DebugAnnotationParser25ParseDebugAnnotationValueERNS_6protos6pbzero23DebugAnnotation_DecoderERNS1_17ProtoToArgsParser8DelegateERKNS7_3KeyE: 83| 23.8k| const ProtoToArgsParser::Key& context_name) { 84| 23.8k| if (annotation.has_bool_value()) { ------------------ | Branch (84:7): [True: 196, False: 23.6k] ------------------ 85| 196| delegate.AddBoolean(context_name, annotation.bool_value()); 86| 23.6k| } else if (annotation.has_uint_value()) { ------------------ | Branch (86:14): [True: 218, False: 23.4k] ------------------ 87| 218| delegate.AddUnsignedInteger(context_name, annotation.uint_value()); 88| 23.4k| } else if (annotation.has_int_value()) { ------------------ | Branch (88:14): [True: 13, False: 23.4k] ------------------ 89| 13| delegate.AddInteger(context_name, annotation.int_value()); 90| 23.4k| } else if (annotation.has_double_value()) { ------------------ | Branch (90:14): [True: 7, False: 23.4k] ------------------ 91| 7| delegate.AddDouble(context_name, annotation.double_value()); 92| 23.4k| } else if (annotation.has_string_value()) { ------------------ | Branch (92:14): [True: 14, False: 23.4k] ------------------ 93| 14| delegate.AddString(context_name, annotation.string_value()); 94| 23.4k| } else if (annotation.has_string_value_iid()) { ------------------ | Branch (94:14): [True: 0, False: 23.4k] ------------------ 95| 0| auto* decoder = delegate.GetInternedMessage( 96| 0| protos::pbzero::InternedData::kDebugAnnotationStringValues, 97| 0| annotation.string_value_iid()); 98| 0| if (!decoder) { ------------------ | Branch (98:9): [True: 0, False: 0] ------------------ 99| 0| return {base::ErrStatus("Debug annotation with invalid string_value_iid"), 100| 0| false}; 101| 0| } 102| 0| delegate.AddString(context_name, decoder->str().ToStdString()); 103| 23.4k| } else if (annotation.has_pointer_value()) { ------------------ | Branch (103:14): [True: 4.04k, False: 19.3k] ------------------ 104| 4.04k| delegate.AddPointer(context_name, annotation.pointer_value()); 105| 19.3k| } else if (annotation.has_dict_entries()) { ------------------ | Branch (105:14): [True: 7, False: 19.3k] ------------------ 106| 7| bool added_entry = false; 107| 7| for (auto it = annotation.dict_entries(); it; ++it) { ------------------ | Branch (107:47): [True: 7, False: 0] ------------------ 108| 7| protos::pbzero::DebugAnnotation::Decoder key_value(*it); 109| 7| std::string key; 110| 7| base::Status key_parse_result = 111| 7| ParseDebugAnnotationName(key_value, delegate, key); 112| 7| if (!key_parse_result.ok()) ------------------ | Branch (112:11): [True: 7, False: 0] ------------------ 113| 7| return {key_parse_result, added_entry}; 114| | 115| 0| auto nested_key = proto_to_args_parser_.EnterDictionary(key); 116| 0| ParseResult value_parse_result = 117| 0| ParseDebugAnnotationValue(key_value, delegate, nested_key.key()); 118| 0| added_entry |= value_parse_result.added_entry; 119| 0| if (!value_parse_result.status.ok()) ------------------ | Branch (119:11): [True: 0, False: 0] ------------------ 120| 0| return {value_parse_result.status, added_entry}; 121| 0| } 122| 19.3k| } else if (annotation.has_array_values()) { ------------------ | Branch (122:14): [True: 0, False: 19.3k] ------------------ 123| 0| size_t index = delegate.GetArrayEntryIndex(context_name.key); 124| 0| bool added_entry = false; 125| 0| for (auto it = annotation.array_values(); it; ++it) { ------------------ | Branch (125:47): [True: 0, False: 0] ------------------ 126| 0| std::string array_key = context_name.key; 127| 0| protos::pbzero::DebugAnnotation::Decoder value(*it); 128| | 129| 0| auto nested_key = proto_to_args_parser_.EnterArray(index); 130| 0| ParseResult value_parse_result = 131| 0| ParseDebugAnnotationValue(value, delegate, nested_key.key()); 132| | 133| 0| if (value_parse_result.added_entry) { ------------------ | Branch (133:11): [True: 0, False: 0] ------------------ 134| 0| index = delegate.IncrementArrayEntryIndex(array_key); 135| 0| added_entry = true; 136| 0| } 137| 0| if (!value_parse_result.status.ok()) ------------------ | Branch (137:11): [True: 0, False: 0] ------------------ 138| 0| return {value_parse_result.status, added_entry}; 139| 0| } 140| 19.3k| } else if (annotation.has_legacy_json_value()) { ------------------ | Branch (140:14): [True: 17.5k, False: 1.82k] ------------------ 141| 17.5k| if (!IsJsonSupported()) ------------------ | Branch (141:9): [Folded - Ignored] ------------------ 142| 0| return {base::ErrStatus("Ignoring legacy_json_value (no json support)"), 143| 0| false}; 144| | 145| 17.5k| bool added_entry = 146| 17.5k| delegate.AddJson(context_name, annotation.legacy_json_value()); 147| 17.5k| return {base::OkStatus(), added_entry}; 148| 17.5k| } else if (annotation.has_nested_value()) { ------------------ | Branch (148:14): [True: 274, False: 1.55k] ------------------ 149| 274| return ParseNestedValueArgs(annotation.nested_value(), context_name, 150| 274| delegate); 151| 1.55k| } else if (annotation.has_proto_value()) { ------------------ | Branch (151:14): [True: 1.51k, False: 39] ------------------ 152| 1.51k| std::string type_name; 153| 1.51k| if (annotation.has_proto_type_name()) { ------------------ | Branch (153:9): [True: 0, False: 1.51k] ------------------ 154| 0| type_name = annotation.proto_type_name().ToStdString(); 155| 1.51k| } else if (annotation.has_proto_type_name_iid()) { ------------------ | Branch (155:16): [True: 1.51k, False: 0] ------------------ 156| 1.51k| auto* interned_name = delegate.GetInternedMessage( 157| 1.51k| protos::pbzero::InternedData::kDebugAnnotationValueTypeNames, 158| 1.51k| annotation.proto_type_name_iid()); 159| 1.51k| if (!interned_name) ------------------ | Branch (159:11): [True: 1.51k, False: 0] ------------------ 160| 1.51k| return {base::ErrStatus("Interned proto type name not found"), false}; 161| 0| type_name = interned_name->name().ToStdString(); 162| 0| } else { 163| 0| return {base::ErrStatus("DebugAnnotation has proto_value, but doesn't " 164| 0| "have proto type name"), 165| 0| false}; 166| 0| } 167| 0| return {proto_to_args_parser_.ParseMessage(annotation.proto_value(), 168| 0| type_name, nullptr, delegate), 169| 0| true}; 170| 1.51k| } else { 171| 39| return {base::OkStatus(), /*added_entry=*/false}; 172| 39| } 173| | 174| 4.49k| return {base::OkStatus(), /*added_entry=*/true}; 175| 23.8k|} _ZN8perfetto15trace_processor4util21DebugAnnotationParser5ParseEN9protozero10ConstBytesERNS1_17ProtoToArgsParser8DelegateE: 180| 1.15M| ProtoToArgsParser::Delegate& delegate) { 181| 1.15M| protos::pbzero::DebugAnnotation::Decoder annotation(data); 182| | 183| 1.15M| std::string name; 184| 1.15M| base::Status name_parse_result = 185| 1.15M| ParseDebugAnnotationName(annotation, delegate, name); 186| 1.15M| if (!name_parse_result.ok()) ------------------ | Branch (186:7): [True: 1.13M, False: 23.8k] ------------------ 187| 1.13M| return name_parse_result; 188| | 189| 23.8k| auto context = proto_to_args_parser_.EnterDictionary(name); 190| | 191| 23.8k| return ParseDebugAnnotationValue(annotation, delegate, context.key()).status; 192| 1.15M|} _ZN8perfetto15trace_processor4util21DebugAnnotationParser20ParseNestedValueArgsEN9protozero10ConstBytesERKNS1_17ProtoToArgsParser3KeyERNS5_8DelegateE: 197| 274| ProtoToArgsParser::Delegate& delegate) { 198| 274| protos::pbzero::DebugAnnotation::NestedValue::Decoder value(nested_value); 199| 274| switch (value.nested_type()) { ------------------ | Branch (199:11): [True: 274, False: 0] ------------------ 200| 0| case protos::pbzero::DebugAnnotation::NestedValue::UNSPECIFIED: { ------------------ | Branch (200:5): [True: 0, False: 274] ------------------ 201| | // Leaf value. 202| 0| if (value.has_bool_value()) { ------------------ | Branch (202:11): [True: 0, False: 0] ------------------ 203| 0| delegate.AddBoolean(context_name, value.bool_value()); 204| 0| return {base::OkStatus(), true}; 205| 0| } 206| 0| if (value.has_int_value()) { ------------------ | Branch (206:11): [True: 0, False: 0] ------------------ 207| 0| delegate.AddInteger(context_name, value.int_value()); 208| 0| return {base::OkStatus(), true}; 209| 0| } 210| 0| if (value.has_double_value()) { ------------------ | Branch (210:11): [True: 0, False: 0] ------------------ 211| 0| delegate.AddDouble(context_name, value.double_value()); 212| 0| return {base::OkStatus(), true}; 213| 0| } 214| 0| if (value.has_string_value()) { ------------------ | Branch (214:11): [True: 0, False: 0] ------------------ 215| 0| delegate.AddString(context_name, value.string_value()); 216| 0| return {base::OkStatus(), true}; 217| 0| } 218| 0| return {base::OkStatus(), false}; 219| 0| } 220| 0| case protos::pbzero::DebugAnnotation::NestedValue::DICT: { ------------------ | Branch (220:5): [True: 0, False: 274] ------------------ 221| 0| bool added_entry = false; 222| 0| auto key_it = value.dict_keys(); 223| 0| auto value_it = value.dict_values(); 224| 0| for (; key_it && value_it; ++key_it, ++value_it) { ------------------ | Branch (224:14): [True: 0, False: 0] | Branch (224:24): [True: 0, False: 0] ------------------ 225| 0| std::string child_name = 226| 0| SanitizeDebugAnnotationName((*key_it).ToStdString()); 227| 0| auto nested_key = proto_to_args_parser_.EnterDictionary(child_name); 228| 0| ParseResult result = 229| 0| ParseNestedValueArgs(*value_it, nested_key.key(), delegate); 230| 0| added_entry |= result.added_entry; 231| 0| if (!result.status.ok()) ------------------ | Branch (231:13): [True: 0, False: 0] ------------------ 232| 0| return {result.status, added_entry}; 233| 0| } 234| 0| return {base::OkStatus(), true}; 235| 0| } 236| | 237| 0| case protos::pbzero::DebugAnnotation::NestedValue::ARRAY: { ------------------ | Branch (237:5): [True: 0, False: 274] ------------------ 238| 0| std::string array_key = context_name.key; 239| 0| size_t array_index = delegate.GetArrayEntryIndex(context_name.key); 240| 0| bool added_entry = false; 241| | 242| 0| for (auto value_it = value.array_values(); value_it; ++value_it) { ------------------ | Branch (242:50): [True: 0, False: 0] ------------------ 243| 0| auto nested_key = proto_to_args_parser_.EnterArray(array_index); 244| 0| ParseResult result = 245| 0| ParseNestedValueArgs(*value_it, nested_key.key(), delegate); 246| | 247| 0| if (result.added_entry) { ------------------ | Branch (247:13): [True: 0, False: 0] ------------------ 248| 0| ++array_index; 249| 0| delegate.IncrementArrayEntryIndex(array_key); 250| 0| added_entry = true; 251| 0| } 252| 0| if (!result.status.ok()) ------------------ | Branch (252:13): [True: 0, False: 0] ------------------ 253| 0| return {result.status, added_entry}; 254| 0| } 255| 0| return {base::OkStatus(), added_entry}; 256| 0| } 257| 274| } 258| 274| return {base::OkStatus(), false}; 259| 274|} debug_annotation_parser.cc:_ZN8perfetto15trace_processor4util12_GLOBAL__N_127SanitizeDebugAnnotationNameERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE: 38| 23.8k|std::string SanitizeDebugAnnotationName(const std::string& raw_name) { 39| 23.8k| std::string result = raw_name; 40| 23.8k| std::replace(result.begin(), result.end(), '.', '_'); 41| 23.8k| std::replace(result.begin(), result.end(), '[', '_'); 42| 23.8k| std::replace(result.begin(), result.end(), ']', '_'); 43| 23.8k| return result; 44| 23.8k|} _ZN8perfetto15trace_processor14DescriptorPool16ResolveShortTypeERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEESA_: 97| 2.15M| const std::string& short_type) { 98| 2.15M| PERFETTO_DCHECK(!short_type.empty()); 99| | 100| 2.15M| std::string search_path = short_type[0] == '.' ------------------ | Branch (100:29): [True: 2.15M, False: 9] ------------------ 101| 2.15M| ? parent_path + short_type 102| 2.15M| : parent_path + '.' + short_type; 103| 2.15M| auto opt_idx = FindDescriptorIdx(search_path); 104| 2.15M| if (opt_idx) ------------------ | Branch (104:7): [True: 525k, False: 1.62M] ------------------ 105| 525k| return opt_idx; 106| | 107| 1.62M| if (parent_path.empty()) ------------------ | Branch (107:7): [True: 0, False: 1.62M] ------------------ 108| 0| return std::nullopt; 109| | 110| 1.62M| auto parent_dot_idx = parent_path.rfind('.'); 111| 1.62M| auto parent_substr = parent_dot_idx == std::string::npos ------------------ | Branch (111:24): [True: 0, False: 1.62M] ------------------ 112| 1.62M| ? "" 113| 1.62M| : parent_path.substr(0, parent_dot_idx); 114| 1.62M| return ResolveShortType(parent_substr, short_type); 115| 1.62M|} _ZN8perfetto15trace_processor14DescriptorPool17AddExtensionFieldERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEN9protozero10ConstBytesE: 119| 162k| protozero::ConstBytes field_desc_proto) { 120| 162k| using FieldDescriptorProto = protos::pbzero::FieldDescriptorProto; 121| 162k| FieldDescriptorProto::Decoder f_decoder(field_desc_proto); 122| 162k| auto field = CreateFieldFromDecoder(f_decoder, true); 123| | 124| 162k| std::string extendee_name = f_decoder.extendee().ToStdString(); 125| 162k| if (extendee_name.empty()) { ------------------ | Branch (125:7): [True: 0, False: 162k] ------------------ 126| 0| return base::ErrStatus("Extendee name is empty"); 127| 0| } 128| | 129| 162k| if (extendee_name[0] != '.') { ------------------ | Branch (129:7): [True: 0, False: 162k] ------------------ 130| | // Only prepend if the extendee is not fully qualified 131| 0| extendee_name = package_name + "." + extendee_name; 132| 0| } 133| 162k| std::optional extendee = FindDescriptorIdx(extendee_name); 134| 162k| if (!extendee.has_value()) { ------------------ | Branch (134:7): [True: 0, False: 162k] ------------------ 135| 0| return base::ErrStatus("Extendee does not exist %s", extendee_name.c_str()); 136| 0| } 137| 162k| ProtoDescriptor& extendee_desc = descriptors_[extendee.value()]; 138| 162k| RETURN_IF_ERROR(CheckExtensionField(extendee_desc, field)); ------------------ | | 25| 162k| do { \ | | 26| 162k| base::Status status_macro_internal_status = (expr); \ | | 27| 162k| if (!status_macro_internal_status.ok()) \ | | ------------------ | | | Branch (27:9): [True: 0, False: 162k] | | ------------------ | | 28| 162k| return status_macro_internal_status; \ | | 29| 162k| } while (0) | | ------------------ | | | Branch (29:12): [Folded - Ignored] | | ------------------ ------------------ 139| 162k| extendee_desc.AddField(field); 140| 162k| return base::OkStatus(); 141| 162k|} _ZN8perfetto15trace_processor14DescriptorPool25AddNestedProtoDescriptorsERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEESA_NS2_8optionalIjEEN9protozero10ConstBytesEPNS2_6vectorINS2_4pairIS8_SE_EENS6_ISH_EEEEb: 149| 291k| bool merge_existing_messages) { 150| 291k| protos::pbzero::DescriptorProto::Decoder decoder(descriptor_proto); 151| | 152| 291k| auto parent_name = 153| 291k| parent_idx ? descriptors_[*parent_idx].full_name() : package_name; ------------------ | Branch (153:7): [True: 36.2k, False: 255k] ------------------ 154| 291k| auto full_name = 155| 291k| parent_name + "." + base::StringView(decoder.name()).ToStdString(); 156| | 157| 291k| auto idx = FindDescriptorIdx(full_name); 158| 291k| if (idx.has_value() && !merge_existing_messages) { ------------------ | Branch (158:7): [True: 4.22k, False: 287k] | Branch (158:26): [True: 0, False: 4.22k] ------------------ 159| 0| const auto& existing_descriptor = descriptors_[*idx]; 160| 0| return base::ErrStatus("%s: %s was already defined in file %s", 161| 0| file_name.c_str(), full_name.c_str(), 162| 0| existing_descriptor.file_name().c_str()); 163| 0| } 164| 291k| if (!idx.has_value()) { ------------------ | Branch (164:7): [True: 287k, False: 4.22k] ------------------ 165| 287k| ProtoDescriptor proto_descriptor(file_name, package_name, full_name, 166| 287k| ProtoDescriptor::Type::kMessage, 167| 287k| parent_idx); 168| 287k| idx = AddProtoDescriptor(std::move(proto_descriptor)); 169| 287k| } 170| 291k| ProtoDescriptor& proto_descriptor = descriptors_[*idx]; 171| 291k| if (proto_descriptor.type() != ProtoDescriptor::Type::kMessage) { ------------------ | Branch (171:7): [True: 0, False: 291k] ------------------ 172| 0| return base::ErrStatus("%s was enum, redefined as message", 173| 0| full_name.c_str()); 174| 0| } 175| | 176| 291k| using FieldDescriptorProto = protos::pbzero::FieldDescriptorProto; 177| 1.88M| for (auto it = decoder.field(); it; ++it) { ------------------ | Branch (177:35): [True: 1.59M, False: 291k] ------------------ 178| 1.59M| FieldDescriptorProto::Decoder f_decoder(*it); 179| 1.59M| auto field = CreateFieldFromDecoder(f_decoder, /*is_extension=*/false); 180| 1.59M| RETURN_IF_ERROR(CheckExtensionField(proto_descriptor, field)); ------------------ | | 25| 1.59M| do { \ | | 26| 1.59M| base::Status status_macro_internal_status = (expr); \ | | 27| 1.59M| if (!status_macro_internal_status.ok()) \ | | ------------------ | | | Branch (27:9): [True: 0, False: 1.59M] | | ------------------ | | 28| 1.59M| return status_macro_internal_status; \ | | 29| 1.59M| } while (0) | | ------------------ | | | Branch (29:12): [Folded - Ignored] | | ------------------ ------------------ 181| 1.59M| proto_descriptor.AddField(std::move(field)); 182| 1.59M| } 183| | 184| 440k| for (auto it = decoder.enum_type(); it; ++it) { ------------------ | Branch (184:39): [True: 148k, False: 291k] ------------------ 185| 148k| RETURN_IF_ERROR(AddEnumProtoDescriptors(file_name, package_name, idx, *it, ------------------ | | 25| 148k| do { \ | | 26| 148k| base::Status status_macro_internal_status = (expr); \ | | 27| 148k| if (!status_macro_internal_status.ok()) \ | | ------------------ | | | Branch (27:9): [True: 0, False: 148k] | | ------------------ | | 28| 148k| return status_macro_internal_status; \ | | 29| 148k| } while (0) | | ------------------ | | | Branch (29:12): [Folded - Ignored] | | ------------------ ------------------ 186| 148k| merge_existing_messages)); 187| 148k| } 188| 327k| for (auto it = decoder.nested_type(); it; ++it) { ------------------ | Branch (188:41): [True: 36.2k, False: 291k] ------------------ 189| 36.2k| RETURN_IF_ERROR(AddNestedProtoDescriptors(file_name, package_name, idx, *it, ------------------ | | 25| 36.2k| do { \ | | 26| 36.2k| base::Status status_macro_internal_status = (expr); \ | | 27| 36.2k| if (!status_macro_internal_status.ok()) \ | | ------------------ | | | Branch (27:9): [True: 0, False: 36.2k] | | ------------------ | | 28| 36.2k| return status_macro_internal_status; \ | | 29| 36.2k| } while (0) | | ------------------ | | | Branch (29:12): [Folded - Ignored] | | ------------------ ------------------ 190| 36.2k| extensions, 191| 36.2k| merge_existing_messages)); 192| 36.2k| } 193| 454k| for (auto ext_it = decoder.extension(); ext_it; ++ext_it) { ------------------ | Branch (193:43): [True: 162k, False: 291k] ------------------ 194| 162k| extensions->emplace_back(package_name, *ext_it); 195| 162k| } 196| 291k| return base::OkStatus(); 197| 291k|} _ZN8perfetto15trace_processor14DescriptorPool23AddEnumProtoDescriptorsERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEESA_NS2_8optionalIjEEN9protozero10ConstBytesEb: 204| 167k| bool merge_existing_messages) { 205| 167k| protos::pbzero::EnumDescriptorProto::Decoder decoder(descriptor_proto); 206| | 207| 167k| auto parent_name = 208| 167k| parent_idx ? descriptors_[*parent_idx].full_name() : package_name; ------------------ | Branch (208:7): [True: 148k, False: 18.4k] ------------------ 209| 167k| auto full_name = 210| 167k| parent_name + "." + base::StringView(decoder.name()).ToStdString(); 211| | 212| 167k| auto prev_idx = FindDescriptorIdx(full_name); 213| 167k| if (prev_idx.has_value() && !merge_existing_messages) { ------------------ | Branch (213:7): [True: 2.10k, False: 165k] | Branch (213:31): [True: 0, False: 2.10k] ------------------ 214| 0| const auto& existing_descriptor = descriptors_[*prev_idx]; 215| 0| return base::ErrStatus("%s: %s was already defined in file %s", 216| 0| file_name.c_str(), full_name.c_str(), 217| 0| existing_descriptor.file_name().c_str()); 218| 0| } 219| 167k| if (!prev_idx.has_value()) { ------------------ | Branch (219:7): [True: 165k, False: 2.10k] ------------------ 220| 165k| ProtoDescriptor proto_descriptor(file_name, package_name, full_name, 221| 165k| ProtoDescriptor::Type::kEnum, 222| 165k| std::nullopt); 223| 165k| prev_idx = AddProtoDescriptor(std::move(proto_descriptor)); 224| 165k| } 225| 167k| ProtoDescriptor& proto_descriptor = descriptors_[*prev_idx]; 226| 167k| if (proto_descriptor.type() != ProtoDescriptor::Type::kEnum) { ------------------ | Branch (226:7): [True: 0, False: 167k] ------------------ 227| 0| return base::ErrStatus("%s was message, redefined as enum", 228| 0| full_name.c_str()); 229| 0| } 230| | 231| 1.98M| for (auto it = decoder.value(); it; ++it) { ------------------ | Branch (231:35): [True: 1.81M, False: 167k] ------------------ 232| 1.81M| protos::pbzero::EnumValueDescriptorProto::Decoder enum_value(it->data(), 233| 1.81M| it->size()); 234| 1.81M| proto_descriptor.AddEnumValue(enum_value.number(), 235| 1.81M| enum_value.name().ToStdString()); 236| 1.81M| } 237| | 238| 167k| return base::OkStatus(); 239| 167k|} _ZN8perfetto15trace_processor14DescriptorPool24AddFromFileDescriptorSetEPKhmRKNSt3__16vectorINS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS9_ISB_EEEEb: 245| 7.89k| bool merge_existing_messages) { 246| 7.89k| protos::pbzero::FileDescriptorSet::Decoder proto(file_descriptor_set_proto, 247| 7.89k| size); 248| 7.89k| std::vector extensions; 249| 54.2k| for (auto it = proto.file(); it; ++it) { ------------------ | Branch (249:32): [True: 46.3k, False: 7.89k] ------------------ 250| 46.3k| protos::pbzero::FileDescriptorProto::Decoder file(*it); 251| 46.3k| const std::string file_name = file.name().ToStdString(); 252| 46.3k| if (base::StartsWithAny(file_name, skip_prefixes)) ------------------ | Branch (252:9): [True: 0, False: 46.3k] ------------------ 253| 0| continue; 254| 46.3k| if (!merge_existing_messages && ------------------ | Branch (254:9): [True: 44.8k, False: 1.56k] | Branch (254:9): [True: 0, False: 46.3k] ------------------ 255| 46.3k| processed_files_.find(file_name) != processed_files_.end()) { ------------------ | Branch (255:9): [True: 0, False: 44.8k] ------------------ 256| | // This file has been loaded once already. Skip. 257| 0| continue; 258| 0| } 259| 46.3k| processed_files_.insert(file_name); 260| 46.3k| std::string package = "." + base::StringView(file.package()).ToStdString(); 261| 301k| for (auto message_it = file.message_type(); message_it; ++message_it) { ------------------ | Branch (261:49): [True: 255k, False: 46.3k] ------------------ 262| 255k| RETURN_IF_ERROR(AddNestedProtoDescriptors( ------------------ | | 25| 255k| do { \ | | 26| 255k| base::Status status_macro_internal_status = (expr); \ | | 27| 255k| if (!status_macro_internal_status.ok()) \ | | ------------------ | | | Branch (27:9): [True: 0, False: 255k] | | ------------------ | | 28| 255k| return status_macro_internal_status; \ | | 29| 255k| } while (0) | | ------------------ | | | Branch (29:12): [Folded - Ignored] | | ------------------ ------------------ 263| 255k| file_name, package, std::nullopt, *message_it, &extensions, 264| 255k| merge_existing_messages)); 265| 255k| } 266| 64.7k| for (auto enum_it = file.enum_type(); enum_it; ++enum_it) { ------------------ | Branch (266:43): [True: 18.4k, False: 46.3k] ------------------ 267| 18.4k| RETURN_IF_ERROR(AddEnumProtoDescriptors( ------------------ | | 25| 18.4k| do { \ | | 26| 18.4k| base::Status status_macro_internal_status = (expr); \ | | 27| 18.4k| if (!status_macro_internal_status.ok()) \ | | ------------------ | | | Branch (27:9): [True: 0, False: 18.4k] | | ------------------ | | 28| 18.4k| return status_macro_internal_status; \ | | 29| 18.4k| } while (0) | | ------------------ | | | Branch (29:12): [Folded - Ignored] | | ------------------ ------------------ 268| 18.4k| file_name, package, std::nullopt, *enum_it, merge_existing_messages)); 269| 18.4k| } 270| 46.3k| for (auto ext_it = file.extension(); ext_it; ++ext_it) { ------------------ | Branch (270:42): [True: 0, False: 46.3k] ------------------ 271| 0| extensions.emplace_back(package, *ext_it); 272| 0| } 273| 46.3k| } 274| | 275| | // Second pass: Add extension fields to the real protos. 276| 162k| for (const auto& extension : extensions) { ------------------ | Branch (276:30): [True: 162k, False: 7.89k] ------------------ 277| 162k| RETURN_IF_ERROR(AddExtensionField(extension.first, extension.second)); ------------------ | | 25| 162k| do { \ | | 26| 162k| base::Status status_macro_internal_status = (expr); \ | | 27| 162k| if (!status_macro_internal_status.ok()) \ | | ------------------ | | | Branch (27:9): [True: 0, False: 162k] | | ------------------ | | 28| 162k| return status_macro_internal_status; \ | | 29| 162k| } while (0) | | ------------------ | | | Branch (29:12): [Folded - Ignored] | | ------------------ ------------------ 278| 162k| } 279| | 280| | // Third pass: resolve the types of all the fields. 281| 7.89k| using FieldDescriptorProto = protos::pbzero::FieldDescriptorProto; 282| 1.42M| for (ProtoDescriptor& descriptor : descriptors_) { ------------------ | Branch (282:36): [True: 1.42M, False: 7.89k] ------------------ 283| 5.57M| for (auto& entry : *descriptor.mutable_fields()) { ------------------ | Branch (283:22): [True: 5.57M, False: 1.42M] ------------------ 284| 5.57M| FieldDescriptor& field = entry.second; 285| 5.57M| bool needs_resolution = 286| 5.57M| field.resolved_type_name().empty() && ------------------ | Branch (286:11): [True: 4.45M, False: 1.11M] ------------------ 287| 5.57M| (field.type() == FieldDescriptorProto::TYPE_MESSAGE || ------------------ | Branch (287:12): [True: 354k, False: 4.10M] ------------------ 288| 4.45M| field.type() == FieldDescriptorProto::TYPE_ENUM); ------------------ | Branch (288:12): [True: 171k, False: 3.93M] ------------------ 289| 5.57M| if (needs_resolution) { ------------------ | Branch (289:11): [True: 525k, False: 5.04M] ------------------ 290| 525k| auto opt_desc = 291| 525k| ResolveShortType(descriptor.full_name(), field.raw_type_name()); 292| 525k| if (!opt_desc.has_value()) { ------------------ | Branch (292:13): [True: 0, False: 525k] ------------------ 293| 0| return base::ErrStatus( 294| 0| "Unable to find short type %s in field inside message %s", 295| 0| field.raw_type_name().c_str(), descriptor.full_name().c_str()); 296| 0| } 297| 525k| field.set_resolved_type_name( 298| 525k| descriptors_[opt_desc.value()].full_name()); 299| 525k| } 300| 5.57M| } 301| 1.42M| } 302| | 303| | // Fourth pass: resolve all "uninterpreted" options to real options. 304| 1.42M| for (ProtoDescriptor& descriptor : descriptors_) { ------------------ | Branch (304:36): [True: 1.42M, False: 7.89k] ------------------ 305| 5.57M| for (auto& entry : *descriptor.mutable_fields()) { ------------------ | Branch (305:22): [True: 5.57M, False: 1.42M] ------------------ 306| 5.57M| FieldDescriptor& field = entry.second; 307| 5.57M| if (field.options().empty()) { ------------------ | Branch (307:11): [True: 5.54M, False: 27.5k] ------------------ 308| 5.54M| continue; 309| 5.54M| } 310| 27.5k| ResolveUninterpretedOption(descriptor, field, *field.mutable_options()); 311| 27.5k| } 312| 1.42M| } 313| 7.89k| return base::OkStatus(); 314| 7.89k|} _ZN8perfetto15trace_processor14DescriptorPool26ResolveUninterpretedOptionERKNS0_15ProtoDescriptorERKNS0_15FieldDescriptorERNSt3__16vectorIhNS8_9allocatorIhEEEE: 319| 27.5k| std::vector& options) { 320| 27.5k| auto opt_idx = FindDescriptorIdx(".google.protobuf.FieldOptions"); 321| 27.5k| if (!opt_idx) { ------------------ | Branch (321:7): [True: 27.5k, False: 0] ------------------ 322| 27.5k| return base::ErrStatus("Unable to find field options for field %s in %s", 323| 27.5k| field_desc.name().c_str(), 324| 27.5k| proto_desc.full_name().c_str()); 325| 27.5k| } 326| 0| ProtoDescriptor& field_options_desc = descriptors_[*opt_idx]; 327| | 328| 0| protozero::ProtoDecoder decoder(field_desc.options().data(), 329| 0| field_desc.options().size()); 330| 0| protozero::HeapBuffered field_options; 331| 0| for (;;) { 332| 0| const uint8_t* start = decoder.begin() + decoder.read_offset(); 333| 0| auto field = decoder.ReadField(); 334| 0| if (!field.valid()) { ------------------ | Branch (334:9): [True: 0, False: 0] ------------------ 335| 0| break; 336| 0| } 337| 0| const uint8_t* end = decoder.begin() + decoder.read_offset(); 338| | 339| 0| if (field.id() != ------------------ | Branch (339:9): [True: 0, False: 0] ------------------ 340| 0| protos::pbzero::FieldOptions::kUninterpretedOptionFieldNumber) { 341| 0| field_options->AppendRawProtoBytes(start, 342| 0| static_cast(end - start)); 343| 0| continue; 344| 0| } 345| | 346| 0| protos::pbzero::UninterpretedOption::Decoder unint(field.as_bytes()); 347| 0| auto it = unint.name(); 348| 0| if (!it) { ------------------ | Branch (348:9): [True: 0, False: 0] ------------------ 349| 0| return base::ErrStatus( 350| 0| "Option for field %s in message %s does not have a name", 351| 0| field_desc.name().c_str(), proto_desc.full_name().c_str()); 352| 0| } 353| 0| protos::pbzero::UninterpretedOption::NamePart::Decoder name_part(*it); 354| 0| const auto* option_field_desc = 355| 0| field_options_desc.FindFieldByName(name_part.name_part().ToStdString()); 356| | 357| | // It's not immediately clear how options with multiple names should 358| | // be parsed. This likely requires digging into protobuf compiler 359| | // source; given we don't have any examples of this in the codebase 360| | // today, defer handling of this to when we may need it. 361| 0| if (++it) { ------------------ | Branch (361:9): [True: 0, False: 0] ------------------ 362| 0| return base::ErrStatus( 363| 0| "Option for field %s in message %s has multiple name segments", 364| 0| field_desc.name().c_str(), proto_desc.full_name().c_str()); 365| 0| } 366| 0| if (unint.has_identifier_value()) { ------------------ | Branch (366:9): [True: 0, False: 0] ------------------ 367| 0| field_options->AppendString(option_field_desc->number(), 368| 0| unint.identifier_value().ToStdString()); 369| 0| } else if (unint.has_positive_int_value()) { ------------------ | Branch (369:16): [True: 0, False: 0] ------------------ 370| 0| field_options->AppendVarInt(option_field_desc->number(), 371| 0| unint.positive_int_value()); 372| 0| } else if (unint.has_negative_int_value()) { ------------------ | Branch (372:16): [True: 0, False: 0] ------------------ 373| 0| field_options->AppendVarInt(option_field_desc->number(), 374| 0| unint.negative_int_value()); 375| 0| } else if (unint.has_double_value()) { ------------------ | Branch (375:16): [True: 0, False: 0] ------------------ 376| 0| field_options->AppendFixed(option_field_desc->number(), 377| 0| unint.double_value()); 378| 0| } else if (unint.has_string_value()) { ------------------ | Branch (378:16): [True: 0, False: 0] ------------------ 379| 0| field_options->AppendString(option_field_desc->number(), 380| 0| unint.string_value().ToStdString()); 381| 0| } else if (unint.has_aggregate_value()) { ------------------ | Branch (381:16): [True: 0, False: 0] ------------------ 382| 0| field_options->AppendString(option_field_desc->number(), 383| 0| unint.aggregate_value().ToStdString()); 384| 0| } else { 385| 0| return base::ErrStatus( 386| 0| "Unknown field set in UninterpretedOption %s for field %s in message " 387| 0| "%s", 388| 0| option_field_desc->name().c_str(), field_desc.name().c_str(), 389| 0| proto_desc.full_name().c_str()); 390| 0| } 391| 0| } 392| 0| if (decoder.bytes_left() > 0) { ------------------ | Branch (392:7): [True: 0, False: 0] ------------------ 393| 0| return base::ErrStatus("Unexpected extra bytes when parsing option %zu", 394| 0| decoder.bytes_left()); 395| 0| } 396| 0| options = field_options.SerializeAsArray(); 397| 0| return base::OkStatus(); 398| 0|} _ZNK8perfetto15trace_processor14DescriptorPool17FindDescriptorIdxERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE: 401| 4.10M| const std::string& full_name) const { 402| 4.10M| auto it = full_name_to_descriptor_index_.find(full_name); 403| 4.10M| if (it == full_name_to_descriptor_index_.end()) { ------------------ | Branch (403:7): [True: 2.10M, False: 2.00M] ------------------ 404| 2.10M| return std::nullopt; 405| 2.10M| } 406| 2.00M| return it->second; 407| 4.10M|} _ZN8perfetto15trace_processor14DescriptorPool18AddProtoDescriptorENS0_15ProtoDescriptorE: 435| 452k|uint32_t DescriptorPool::AddProtoDescriptor(ProtoDescriptor descriptor) { 436| 452k| uint32_t idx = static_cast(descriptors_.size()); 437| 452k| full_name_to_descriptor_index_[descriptor.full_name()] = idx; 438| 452k| descriptors_.emplace_back(std::move(descriptor)); 439| 452k| return idx; 440| 452k|} _ZN8perfetto15trace_processor15ProtoDescriptorC2ENSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEES8_S8_NS1_4TypeENS2_8optionalIjEE: 447| 452k| : file_name_(std::move(file_name)), 448| 452k| package_name_(std::move(package_name)), 449| 452k| full_name_(std::move(full_name)), 450| 452k| type_(type), 451| 452k| parent_id_(parent_id) {} _ZN8perfetto15trace_processor15FieldDescriptorC2ENSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEjjS8_NS2_6vectorIhNS6_IhEEEENS2_8optionalIS8_EEbbb: 462| 1.75M| : name_(std::move(name)), 463| 1.75M| number_(number), 464| 1.75M| type_(type), 465| 1.75M| raw_type_name_(std::move(raw_type_name)), 466| 1.75M| options_(std::move(options)), 467| 1.75M| default_value_(std::move(default_value)), 468| 1.75M| is_repeated_(is_repeated), 469| 1.75M| is_packed_(is_packed), 470| 1.75M| is_extension_(is_extension) {} descriptors.cc:_ZN8perfetto15trace_processor12_GLOBAL__N_122CreateFieldFromDecoderERKNS_6protos6pbzero28FieldDescriptorProto_DecoderEb: 42| 1.75M| bool is_extension) { 43| 1.75M| using FieldDescriptorProto = protos::pbzero::FieldDescriptorProto; 44| 1.75M| std::string type_name = 45| 1.75M| f_decoder.has_type_name() ------------------ | Branch (45:7): [True: 525k, False: 1.23M] ------------------ 46| 1.75M| ? base::StringView(f_decoder.type_name()).ToStdString() 47| 1.75M| : ""; 48| | // TODO(lalitm): add support for enums here. 49| 1.75M| uint32_t type = 50| 1.75M| f_decoder.has_type() ------------------ | Branch (50:7): [True: 1.75M, False: 1.27k] ------------------ 51| 1.75M| ? static_cast(f_decoder.type()) 52| 1.75M| : static_cast(FieldDescriptorProto::TYPE_MESSAGE); 53| 1.75M| protos::pbzero::FieldOptions::Decoder opt(f_decoder.options()); 54| 1.75M| std::optional default_value; 55| 1.75M| if (f_decoder.has_default_value()) { ------------------ | Branch (55:7): [True: 0, False: 1.75M] ------------------ 56| 0| default_value = f_decoder.default_value().ToStdString(); 57| 0| } 58| 1.75M| return { 59| 1.75M| base::StringView(f_decoder.name()).ToStdString(), 60| 1.75M| static_cast(f_decoder.number()), 61| 1.75M| type, 62| 1.75M| std::move(type_name), 63| 1.75M| std::vector(f_decoder.options().data, 64| 1.75M| f_decoder.options().data + f_decoder.options().size), 65| 1.75M| default_value, 66| 1.75M| f_decoder.label() == FieldDescriptorProto::LABEL_REPEATED, 67| 1.75M| opt.packed(), 68| 1.75M| is_extension, 69| 1.75M| }; 70| 1.75M|} descriptors.cc:_ZN8perfetto15trace_processor12_GLOBAL__N_119CheckExtensionFieldERKNS0_15ProtoDescriptorERKNS0_15FieldDescriptorE: 73| 1.75M| const FieldDescriptor& field) { 74| 1.75M| using FieldDescriptorProto = protos::pbzero::FieldDescriptorProto; 75| 1.75M| const auto* existing_field = proto_descriptor.FindFieldByTag(field.number()); 76| 1.75M| if (existing_field) { ------------------ | Branch (76:7): [True: 1.26k, False: 1.75M] ------------------ 77| 1.26k| if (field.type() != existing_field->type()) { ------------------ | Branch (77:9): [True: 0, False: 1.26k] ------------------ 78| 0| return base::ErrStatus("Field %s is re-introduced with different type", 79| 0| field.name().c_str()); 80| 0| } 81| 1.26k| if ((field.type() == FieldDescriptorProto::TYPE_MESSAGE || ------------------ | Branch (81:10): [True: 1.26k, False: 3] ------------------ 82| 1.26k| field.type() == FieldDescriptorProto::TYPE_ENUM) && ------------------ | Branch (82:10): [True: 0, False: 3] ------------------ 83| 1.26k| field.raw_type_name() != existing_field->raw_type_name()) { ------------------ | Branch (83:9): [True: 0, False: 1.26k] ------------------ 84| 0| return base::ErrStatus( 85| 0| "Field %s is re-introduced with different type %s (was %s)", 86| 0| field.name().c_str(), field.raw_type_name().c_str(), 87| 0| existing_field->raw_type_name().c_str()); 88| 0| } 89| 1.26k| } 90| 1.75M| return base::OkStatus(); 91| 1.75M|} _ZNK8perfetto15trace_processor15FieldDescriptor4nameEv: 51| 18.4M| const std::string& name() const { return name_; } _ZNK8perfetto15trace_processor15FieldDescriptor6numberEv: 52| 6.26M| uint32_t number() const { return number_; } _ZNK8perfetto15trace_processor15FieldDescriptor4typeEv: 53| 26.4M| uint32_t type() const { return type_; } _ZNK8perfetto15trace_processor15FieldDescriptor13raw_type_nameEv: 54| 528k| const std::string& raw_type_name() const { return raw_type_name_; } _ZNK8perfetto15trace_processor15FieldDescriptor18resolved_type_nameEv: 55| 6.13M| const std::string& resolved_type_name() const { return resolved_type_name_; } _ZNK8perfetto15trace_processor15FieldDescriptor11is_repeatedEv: 56| 18.4M| bool is_repeated() const { return is_repeated_; } _ZNK8perfetto15trace_processor15FieldDescriptor9is_packedEv: 57| 9.22M| bool is_packed() const { return is_packed_; } _ZNK8perfetto15trace_processor15FieldDescriptor12is_extensionEv: 58| 11.4M| bool is_extension() const { return is_extension_; } _ZNK8perfetto15trace_processor15FieldDescriptor7optionsEv: 60| 5.57M| const std::vector& options() const { return options_; } _ZN8perfetto15trace_processor15FieldDescriptor15mutable_optionsEv: 61| 27.5k| std::vector* mutable_options() { return &options_; } _ZN8perfetto15trace_processor15FieldDescriptor22set_resolved_type_nameERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE: 66| 525k| void set_resolved_type_name(const std::string& resolved_type_name) { 67| 525k| resolved_type_name_ = resolved_type_name; 68| 525k| } _ZN8perfetto15trace_processor15ProtoDescriptor8AddFieldENS0_15FieldDescriptorE: 93| 1.75M| void AddField(FieldDescriptor descriptor) { 94| 1.75M| PERFETTO_DCHECK(type_ == Type::kMessage); 95| 1.75M| fields_.emplace(descriptor.number(), std::move(descriptor)); 96| 1.75M| } _ZN8perfetto15trace_processor15ProtoDescriptor12AddEnumValueEiNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE: 99| 1.81M| std::string string_representation) { 100| 1.81M| PERFETTO_DCHECK(type_ == Type::kEnum); 101| 1.81M| enum_values_by_name_[string_representation] = integer_representation; 102| 1.81M| enum_names_by_value_[integer_representation] = 103| 1.81M| std::move(string_representation); 104| 1.81M| } _ZNK8perfetto15trace_processor15ProtoDescriptor14FindFieldByTagEj: 119| 13.8M| const FieldDescriptor* FindFieldByTag(const uint32_t tag_number) const { 120| 13.8M| PERFETTO_DCHECK(type_ == Type::kMessage); 121| 13.8M| auto it = fields_.find(tag_number); 122| 13.8M| if (it == fields_.end()) { ------------------ | Branch (122:9): [True: 2.41M, False: 11.4M] ------------------ 123| 2.41M| return nullptr; 124| 2.41M| } 125| 11.4M| return &it->second; 126| 13.8M| } _ZNK8perfetto15trace_processor15ProtoDescriptor14FindEnumStringEi: 128| 12.9k| std::optional FindEnumString(const int32_t value) const { 129| 12.9k| PERFETTO_DCHECK(type_ == Type::kEnum); 130| 12.9k| auto it = enum_names_by_value_.find(value); 131| 12.9k| return it == enum_names_by_value_.end() ? std::nullopt ------------------ | Branch (131:12): [True: 12.9k, False: 0] ------------------ 132| 12.9k| : std::make_optional(it->second); 133| 12.9k| } _ZNK8perfetto15trace_processor15ProtoDescriptor9full_nameEv: 146| 1.71M| const std::string& full_name() const { return full_name_; } _ZNK8perfetto15trace_processor15ProtoDescriptor4typeEv: 148| 458k| Type type() const { return type_; } _ZN8perfetto15trace_processor15ProtoDescriptor14mutable_fieldsEv: 153| 2.85M| std::unordered_map* mutable_fields() { 154| 2.85M| return &fields_; 155| 2.85M| } _ZNK8perfetto15trace_processor14DescriptorPool11descriptorsEv: 188| 1.30M| const std::vector& descriptors() const { 189| 1.30M| return descriptors_; 190| 1.30M| } _ZN8perfetto15trace_processor4util16GzipDecompressorC2ENS2_9InputModeE: 38| 2.02k| : z_stream_(new z_stream_s()) { 39| 2.02k| z_stream_->zalloc = nullptr; 40| 2.02k| z_stream_->zfree = nullptr; 41| 2.02k| z_stream_->opaque = nullptr; 42| | // zlib uses a window size of -15..-8 to indicate it's a raw inflate stream 43| | // (i.e. there's no zlib or gzip header). 44| 2.02k| int wbits = (mode == InputMode::kRawDeflate) ? -15 : 32 + MAX_WBITS; ------------------ | Branch (44:15): [True: 0, False: 2.02k] ------------------ 45| 2.02k| inflateInit2(z_stream_.get(), wbits); 46| 2.02k|} _ZN8perfetto15trace_processor4util16GzipDecompressor5ResetEv: 48| 159|void GzipDecompressor::Reset() { 49| 159| inflateReset(z_stream_.get()); 50| 159|} _ZN8perfetto15trace_processor4util16GzipDecompressor4FeedEPKhm: 52| 159|void GzipDecompressor::Feed(const uint8_t* data, size_t size) { 53| | // This const_cast is not harmfull as zlib will not modify the data in this 54| | // pointer. This is only necessary because of the build flags we use to be 55| | // compatible with other embedders. 56| 159| z_stream_->next_in = const_cast(data); 57| 159| z_stream_->avail_in = static_cast(size); 58| 159|} _ZN8perfetto15trace_processor4util16GzipDecompressor13ExtractOutputEPhm: 61| 159| size_t out_size) { 62| 159| if (z_stream_->avail_in == 0) ------------------ | Branch (62:7): [True: 0, False: 159] ------------------ 63| 0| return Result{ResultCode::kNeedsMoreInput, 0}; 64| | 65| 159| z_stream_->next_out = out; 66| 159| z_stream_->avail_out = static_cast(out_size); 67| | 68| 159| int ret = inflate(z_stream_.get(), Z_NO_FLUSH); 69| 159| switch (ret) { 70| 0| case Z_NEED_DICT: ------------------ | Branch (70:5): [True: 0, False: 159] ------------------ 71| 0| case Z_DATA_ERROR: ------------------ | Branch (71:5): [True: 0, False: 159] ------------------ 72| 0| case Z_MEM_ERROR: ------------------ | Branch (72:5): [True: 0, False: 159] ------------------ 73| | // Ignore inflateEnd error as we will error out anyway. 74| 0| inflateEnd(z_stream_.get()); 75| 0| return Result{ResultCode::kError, 0}; 76| 159| case Z_STREAM_END: ------------------ | Branch (76:5): [True: 159, False: 0] ------------------ 77| 159| return Result{ResultCode::kEof, out_size - z_stream_->avail_out}; 78| 0| case Z_BUF_ERROR: ------------------ | Branch (78:5): [True: 0, False: 159] ------------------ 79| 0| return Result{ResultCode::kNeedsMoreInput, 0}; 80| 0| default: ------------------ | Branch (80:5): [True: 0, False: 159] ------------------ 81| 0| return Result{ResultCode::kOk, out_size - z_stream_->avail_out}; 82| 159| } 83| 159|} _ZNK8perfetto15trace_processor4util16GzipDecompressor7DeleterclEP10z_stream_s: 89| 2.02k|void GzipDecompressor::Deleter::operator()(z_stream_s* stream) const { 90| 2.02k| inflateEnd(stream); 91| 2.02k| delete stream; 92| 2.02k|} _ZN8perfetto15trace_processor4util15IsGzipSupportedEv: 33| 2|constexpr bool IsGzipSupported() { 34| 2|#if PERFETTO_BUILDFLAG(PERFETTO_ZLIB) 35| 2| return true; 36| |#else 37| | return false; 38| |#endif 39| 2|} proto_trace_tokenizer.cc:_ZN8perfetto15trace_processor4util16GzipDecompressor14FeedAndExtractIZNS0_19ProtoTraceTokenizer10DecompressENS0_13TraceBlobViewEPS5_E3$_0EENS2_10ResultCodeEPKhmRKT_: 101| 159| const Callback& output_consumer) { 102| 159| Feed(data, size); 103| 159| uint8_t buffer[4096]; 104| 159| Result result; 105| 159| do { 106| 159| result = ExtractOutput(buffer, sizeof(buffer)); 107| 159| if (result.ret != ResultCode::kError && result.bytes_written > 0) { ------------------ | Branch (107:11): [True: 159, False: 0] | Branch (107:47): [True: 159, False: 0] ------------------ 108| 159| output_consumer(buffer, result.bytes_written); 109| 159| } 110| 159| } while (result.ret == ResultCode::kOk); ------------------ | Branch (110:14): [True: 0, False: 159] ------------------ 111| 159| return result.ret; 112| 159| } _ZN8perfetto15trace_processor19InternedMessageViewC2ENS0_13TraceBlobViewE: 43| 25.1k| explicit InternedMessageView(TraceBlobView msg) : message_(std::move(msg)) {} _ZN8perfetto15trace_processor19InternedMessageViewC2ERKS1_: 51| 528| : message_(view.message_.copy()) {} _ZN8perfetto15trace_processor19InternedMessageView18GetOrCreateDecoderINS_6protos6pbzero19TracePacketDefaultsEEEPNT_7DecoderEv: 65| 75.2k| typename MessageType::Decoder* GetOrCreateDecoder() { 66| 75.2k| if (!decoder_) { ------------------ | Branch (66:9): [True: 814, False: 74.4k] ------------------ 67| | // Lazy init the decoder and save it away, so that we don't have to 68| | // reparse the message every time we access the interning entry. 69| 814| decoder_ = std::unique_ptr>( 70| 814| new typename MessageType::Decoder(message_.data(), message_.length()), 71| 814| [](void* obj) { 72| 814| delete reinterpret_cast(obj); 73| 814| }); 74| 814| decoder_type_ = PERFETTO_TYPE_IDENTIFIER; ------------------ | | 37| 814|#define PERFETTO_TYPE_IDENTIFIER nullptr ------------------ 75| 814| } 76| | // Verify that the type of the decoder didn't change. 77| 75.2k| if (PERFETTO_TYPE_IDENTIFIER && ------------------ | | 37| 150k|#define PERFETTO_TYPE_IDENTIFIER nullptr | | ------------------ | | | Branch (37:34): [Folded - Ignored] | | ------------------ ------------------ 78| 75.2k| strcmp(decoder_type_, ------------------ | Branch (78:9): [True: 0, False: 0] ------------------ 79| | // GCC complains if this arg can be null. 80| 0| static_cast(PERFETTO_TYPE_IDENTIFIER) ------------------ | | 37| 0|#define PERFETTO_TYPE_IDENTIFIER nullptr ------------------ | Branch (80:16): [Folded - Ignored] ------------------ 81| 0| ? PERFETTO_TYPE_IDENTIFIER ------------------ | | 37| 0|#define PERFETTO_TYPE_IDENTIFIER nullptr ------------------ 82| 0| : "") != 0) { 83| 0| PERFETTO_FATAL( 84| 0| "Interning entry accessed under different types! previous type: " 85| 0| "%s. new type: %s.", 86| 0| decoder_type_, PERFETTO_DEBUG_FUNCTION_IDENTIFIER()); 87| 0| } 88| 75.2k| return reinterpret_cast(decoder_.get()); 89| 75.2k| } _ZN8perfetto15trace_processor19InternedMessageView25GetOrCreateSubmessageViewINS_6protos6pbzero19TracePacketDefaultsELj11EEEPS1_v: 96| 94.3k| InternedMessageView* GetOrCreateSubmessageView() { 97| 94.3k| auto it_and_ins = submessages_.Insert(FieldId, nullptr); 98| 94.3k| if (!it_and_ins.second) ------------------ | Branch (98:9): [True: 93.8k, False: 506] ------------------ 99| 93.8k| return it_and_ins.first->get(); 100| 506| auto* decoder = GetOrCreateDecoder(); 101| | // Calls the at() template method on the decoder. 102| 506| auto field = decoder->template at().as_bytes(); 103| 506| if (!field.data) ------------------ | Branch (103:9): [True: 0, False: 506] ------------------ 104| 0| return nullptr; 105| 506| TraceBlobView submessage = message_.slice(field.data, field.size); 106| 506| auto* submessage_view = new InternedMessageView(std::move(submessage)); 107| 506| it_and_ins.first->reset(submessage_view); 108| 506| return submessage_view; 109| 506| } _ZN8perfetto15trace_processor19InternedMessageView18GetOrCreateDecoderINS_6protos6pbzero18TrackEventDefaultsEEEPNT_7DecoderEv: 65| 94.3k| typename MessageType::Decoder* GetOrCreateDecoder() { 66| 94.3k| if (!decoder_) { ------------------ | Branch (66:9): [True: 506, False: 93.8k] ------------------ 67| | // Lazy init the decoder and save it away, so that we don't have to 68| | // reparse the message every time we access the interning entry. 69| 506| decoder_ = std::unique_ptr>( 70| 506| new typename MessageType::Decoder(message_.data(), message_.length()), 71| 506| [](void* obj) { 72| 506| delete reinterpret_cast(obj); 73| 506| }); 74| 506| decoder_type_ = PERFETTO_TYPE_IDENTIFIER; ------------------ | | 37| 506|#define PERFETTO_TYPE_IDENTIFIER nullptr ------------------ 75| 506| } 76| | // Verify that the type of the decoder didn't change. 77| 94.3k| if (PERFETTO_TYPE_IDENTIFIER && ------------------ | | 37| 188k|#define PERFETTO_TYPE_IDENTIFIER nullptr | | ------------------ | | | Branch (37:34): [Folded - Ignored] | | ------------------ ------------------ 78| 94.3k| strcmp(decoder_type_, ------------------ | Branch (78:9): [True: 0, False: 0] ------------------ 79| | // GCC complains if this arg can be null. 80| 0| static_cast(PERFETTO_TYPE_IDENTIFIER) ------------------ | | 37| 0|#define PERFETTO_TYPE_IDENTIFIER nullptr ------------------ | Branch (80:16): [Folded - Ignored] ------------------ 81| 0| ? PERFETTO_TYPE_IDENTIFIER ------------------ | | 37| 0|#define PERFETTO_TYPE_IDENTIFIER nullptr ------------------ 82| 0| : "") != 0) { 83| 0| PERFETTO_FATAL( 84| 0| "Interning entry accessed under different types! previous type: " 85| 0| "%s. new type: %s.", 86| 0| decoder_type_, PERFETTO_DEBUG_FUNCTION_IDENTIFIER()); 87| 0| } 88| 94.3k| return reinterpret_cast(decoder_.get()); 89| 94.3k| } _ZN8perfetto15trace_processor19InternedMessageViewC2EOS1_: 45| 18.5k| InternedMessageView(InternedMessageView&&) = default; _ZZN8perfetto15trace_processor19InternedMessageView18GetOrCreateDecoderINS_6protos6pbzero19TracePacketDefaultsEEEPNT_7DecoderEvENKUlPvE_clES9_: 71| 814| [](void* obj) { 72| 814| delete reinterpret_cast(obj); 73| 814| }); _ZZN8perfetto15trace_processor19InternedMessageView18GetOrCreateDecoderINS_6protos6pbzero18TrackEventDefaultsEEEPNT_7DecoderEvENKUlPvE_clES9_: 71| 506| [](void* obj) { 72| 506| delete reinterpret_cast(obj); 73| 506| }); _ZN8perfetto15trace_processor19InternedMessageView18GetOrCreateDecoderINS_6protos6pbzero13EventCategoryEEEPNT_7DecoderEv: 65| 4.03k| typename MessageType::Decoder* GetOrCreateDecoder() { 66| 4.03k| if (!decoder_) { ------------------ | Branch (66:9): [True: 778, False: 3.26k] ------------------ 67| | // Lazy init the decoder and save it away, so that we don't have to 68| | // reparse the message every time we access the interning entry. 69| 778| decoder_ = std::unique_ptr>( 70| 778| new typename MessageType::Decoder(message_.data(), message_.length()), 71| 778| [](void* obj) { 72| 778| delete reinterpret_cast(obj); 73| 778| }); 74| 778| decoder_type_ = PERFETTO_TYPE_IDENTIFIER; ------------------ | | 37| 778|#define PERFETTO_TYPE_IDENTIFIER nullptr ------------------ 75| 778| } 76| | // Verify that the type of the decoder didn't change. 77| 4.03k| if (PERFETTO_TYPE_IDENTIFIER && ------------------ | | 37| 8.07k|#define PERFETTO_TYPE_IDENTIFIER nullptr | | ------------------ | | | Branch (37:34): [Folded - Ignored] | | ------------------ ------------------ 78| 4.03k| strcmp(decoder_type_, ------------------ | Branch (78:9): [True: 0, False: 0] ------------------ 79| | // GCC complains if this arg can be null. 80| 0| static_cast(PERFETTO_TYPE_IDENTIFIER) ------------------ | | 37| 0|#define PERFETTO_TYPE_IDENTIFIER nullptr ------------------ | Branch (80:16): [Folded - Ignored] ------------------ 81| 0| ? PERFETTO_TYPE_IDENTIFIER ------------------ | | 37| 0|#define PERFETTO_TYPE_IDENTIFIER nullptr ------------------ 82| 0| : "") != 0) { 83| 0| PERFETTO_FATAL( 84| 0| "Interning entry accessed under different types! previous type: " 85| 0| "%s. new type: %s.", 86| 0| decoder_type_, PERFETTO_DEBUG_FUNCTION_IDENTIFIER()); 87| 0| } 88| 4.03k| return reinterpret_cast(decoder_.get()); 89| 4.03k| } _ZZN8perfetto15trace_processor19InternedMessageView18GetOrCreateDecoderINS_6protos6pbzero13EventCategoryEEEPNT_7DecoderEvENKUlPvE_clES9_: 71| 778| [](void* obj) { 72| 778| delete reinterpret_cast(obj); 73| 778| }); _ZN8perfetto15trace_processor4util17ProtoToArgsParser3KeyC2Ev: 64| 2.03k|ProtoToArgsParser::Key::Key() = default; _ZN8perfetto15trace_processor4util17ProtoToArgsParser3KeyD2Ev: 68| 2.03k|ProtoToArgsParser::Key::~Key() = default; _ZN8perfetto15trace_processor4util17ProtoToArgsParser22ScopedNestedKeyContextC2ERNS2_3KeyE: 71| 10.7M| : key_(key), 72| 10.7M| old_flat_key_length_(key.flat_key.length()), 73| 10.7M| old_key_length_(key.key.length()) {} _ZN8perfetto15trace_processor4util17ProtoToArgsParser22ScopedNestedKeyContextD2Ev: 84| 10.7M|ProtoToArgsParser::ScopedNestedKeyContext::~ScopedNestedKeyContext() { 85| 10.7M| RemoveFieldSuffix(); 86| 10.7M|} _ZN8perfetto15trace_processor4util17ProtoToArgsParser22ScopedNestedKeyContext17RemoveFieldSuffixEv: 88| 10.7M|void ProtoToArgsParser::ScopedNestedKeyContext::RemoveFieldSuffix() { 89| 10.7M| if (old_flat_key_length_) ------------------ | Branch (89:7): [True: 10.7M, False: 0] ------------------ 90| 10.7M| key_.flat_key.resize(old_flat_key_length_.value()); 91| 10.7M| if (old_key_length_) ------------------ | Branch (91:7): [True: 10.7M, False: 0] ------------------ 92| 10.7M| key_.key.resize(old_key_length_.value()); 93| 10.7M| old_flat_key_length_ = std::nullopt; 94| 10.7M| old_key_length_ = std::nullopt; 95| 10.7M|} _ZN8perfetto15trace_processor4util17ProtoToArgsParser8DelegateD2Ev: 97| 739k|ProtoToArgsParser::Delegate::~Delegate() = default; _ZN8perfetto15trace_processor4util17ProtoToArgsParserC2ERKNS0_14DescriptorPoolE: 99| 2.03k|ProtoToArgsParser::ProtoToArgsParser(const DescriptorPool& pool) : pool_(pool) { 100| 2.03k| constexpr int kDefaultSize = 64; 101| 2.03k| key_prefix_.key.reserve(kDefaultSize); 102| 2.03k| key_prefix_.flat_key.reserve(kDefaultSize); 103| 2.03k|} _ZN8perfetto15trace_processor4util17ProtoToArgsParser12ParseMessageERKN9protozero10ConstBytesERKNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEEPKNS7_6vectorIjNSB_IjEEEERNS2_8DelegateEPib: 111| 739k| bool add_defaults) { 112| 739k| ScopedNestedKeyContext key_context(key_prefix_); 113| 739k| return ParseMessageInternal(key_context, cb, type, allowed_fields, delegate, 114| 739k| unknown_extensions, add_defaults); 115| 739k|} _ZN8perfetto15trace_processor4util17ProtoToArgsParser20ParseMessageInternalERNS2_22ScopedNestedKeyContextERKN9protozero10ConstBytesERKNSt3__112basic_stringIcNS9_11char_traitsIcEENS9_9allocatorIcEEEEPKNS9_6vectorIjNSD_IjEEEERNS2_8DelegateEPib: 124| 1.29M| bool add_defaults) { 125| 1.29M| if (auto override_result = ------------------ | Branch (125:12): [True: 0, False: 1.29M] ------------------ 126| 1.29M| MaybeApplyOverrideForType(type, key_context, cb, delegate)) { 127| 0| return override_result.value(); 128| 0| } 129| | 130| 1.29M| auto idx = pool_.FindDescriptorIdx(type); 131| 1.29M| if (!idx) { ------------------ | Branch (131:7): [True: 0, False: 1.29M] ------------------ 132| 0| return base::Status("Failed to find proto descriptor"); 133| 0| } 134| | 135| 1.29M| const auto& descriptor = pool_.descriptors()[*idx]; 136| | 137| 1.29M| std::unordered_map repeated_field_index; 138| 1.29M| bool empty_message = true; 139| 1.29M| protozero::ProtoDecoder decoder(cb); 140| 1.29M| std::unordered_set existing_fields; 141| 13.3M| for (protozero::Field f = decoder.ReadField(); f.valid(); ------------------ | Branch (141:50): [True: 12.0M, False: 1.29M] ------------------ 142| 12.0M| f = decoder.ReadField()) { 143| 12.0M| empty_message = false; 144| 12.0M| const auto* field = descriptor.FindFieldByTag(f.id()); 145| 12.0M| if (!field) { ------------------ | Branch (145:9): [True: 660k, False: 11.4M] ------------------ 146| 660k| if (unknown_extensions != nullptr) { ------------------ | Branch (146:11): [True: 660k, False: 0] ------------------ 147| 660k| (*unknown_extensions)++; 148| 660k| } 149| | // Unknown field, possibly an unknown extension. 150| 660k| continue; 151| 660k| } 152| | 153| 11.4M| if (add_defaults) { ------------------ | Branch (153:9): [True: 0, False: 11.4M] ------------------ 154| 0| existing_fields.insert(field->name()); 155| 0| } 156| | 157| 11.4M| if (!IsFieldAllowed(*field, allowed_fields)) { ------------------ | Branch (157:9): [True: 2.19M, False: 9.22M] ------------------ 158| | // Field is neither an extension, nor is allowed to be 159| | // reflected. 160| 2.19M| continue; 161| 2.19M| } 162| | 163| | // Packed fields need to be handled specially because 164| 9.22M| if (field->is_packed()) { ------------------ | Branch (164:9): [True: 0, False: 9.22M] ------------------ 165| 0| RETURN_IF_ERROR(ParsePackedField(*field, repeated_field_index, f, ------------------ | | 25| 0| do { \ | | 26| 0| base::Status status_macro_internal_status = (expr); \ | | 27| 0| if (!status_macro_internal_status.ok()) \ | | ------------------ | | | Branch (27:9): [True: 0, False: 0] | | ------------------ | | 28| 0| return status_macro_internal_status; \ | | 29| 0| } while (0) | | ------------------ | | | Branch (29:12): [Folded - Ignored] | | ------------------ ------------------ 166| 0| delegate, unknown_extensions, 167| 0| add_defaults)); 168| 0| continue; 169| 0| } 170| | 171| 9.22M| RETURN_IF_ERROR(ParseField(*field, repeated_field_index[f.id()], f, ------------------ | | 25| 9.22M| do { \ | | 26| 9.22M| base::Status status_macro_internal_status = (expr); \ | | 27| 9.22M| if (!status_macro_internal_status.ok()) \ | | ------------------ | | | Branch (27:9): [True: 0, False: 9.22M] | | ------------------ | | 28| 9.22M| return status_macro_internal_status; \ | | 29| 9.22M| } while (0) | | ------------------ | | | Branch (29:12): [Folded - Ignored] | | ------------------ ------------------ 172| 9.22M| delegate, unknown_extensions, add_defaults)); 173| 9.22M| if (field->is_repeated()) { ------------------ | Branch (173:9): [True: 403k, False: 8.81M] ------------------ 174| 403k| repeated_field_index[f.id()]++; 175| 403k| } 176| 9.22M| } 177| | 178| 1.29M| if (empty_message) { ------------------ | Branch (178:7): [True: 7.36k, False: 1.28M] ------------------ 179| 7.36k| delegate.AddNull(key_prefix_); 180| 1.28M| } else if (add_defaults) { ------------------ | Branch (180:14): [True: 0, False: 1.28M] ------------------ 181| 0| for (const auto& [id, field] : descriptor.fields()) { ------------------ | Branch (181:34): [True: 0, False: 0] ------------------ 182| 0| if (!IsFieldAllowed(field, allowed_fields)) { ------------------ | Branch (182:11): [True: 0, False: 0] ------------------ 183| 0| continue; 184| 0| } 185| 0| const std::string& field_name = field.name(); 186| 0| bool field_exists = 187| 0| existing_fields.find(field_name) != existing_fields.cend(); 188| 0| if (field_exists) { ------------------ | Branch (188:11): [True: 0, False: 0] ------------------ 189| 0| continue; 190| 0| } 191| 0| ScopedNestedKeyContext key_context_default(key_prefix_); 192| 0| AppendProtoType(key_prefix_.flat_key, field_name); 193| 0| AppendProtoType(key_prefix_.key, field_name); 194| 0| RETURN_IF_ERROR(AddDefault(field, delegate)); ------------------ | | 25| 0| do { \ | | 26| 0| base::Status status_macro_internal_status = (expr); \ | | 27| 0| if (!status_macro_internal_status.ok()) \ | | ------------------ | | | Branch (27:9): [True: 0, False: 0] | | ------------------ | | 28| 0| return status_macro_internal_status; \ | | 29| 0| } while (0) | | ------------------ | | | Branch (29:12): [Folded - Ignored] | | ------------------ ------------------ 195| 0| } 196| 0| } 197| | 198| 1.29M| return base::OkStatus(); 199| 1.29M|} _ZN8perfetto15trace_processor4util17ProtoToArgsParser10ParseFieldERKNS0_15FieldDescriptorEiN9protozero5FieldERNS2_8DelegateEPib: 207| 9.22M| bool add_defaults) { 208| 9.22M| std::string prefix_part = field_descriptor.name(); 209| 9.22M| if (field_descriptor.is_repeated()) { ------------------ | Branch (209:7): [True: 403k, False: 8.81M] ------------------ 210| 403k| std::string number = std::to_string(repeated_field_number); 211| 403k| prefix_part.reserve(prefix_part.length() + number.length() + 2); 212| 403k| prefix_part.append("["); 213| 403k| prefix_part.append(number); 214| 403k| prefix_part.append("]"); 215| 403k| } 216| | 217| | // In the args table we build up message1.message2.field1 as the column 218| | // name. This will append the ".field1" suffix to |key_prefix| and then 219| | // remove it when it goes out of scope. 220| 9.22M| ScopedNestedKeyContext key_context(key_prefix_); 221| 9.22M| AppendProtoType(key_prefix_.flat_key, field_descriptor.name()); 222| 9.22M| AppendProtoType(key_prefix_.key, prefix_part); 223| | 224| | // If we have an override parser then use that instead and move onto the 225| | // next loop. 226| 9.22M| if (std::optional status = ------------------ | Branch (226:35): [True: 0, False: 9.22M] ------------------ 227| 9.22M| MaybeApplyOverrideForField(field, delegate)) { 228| 0| return *status; 229| 0| } 230| | 231| | // If this is not a message we can just immediately add the column name and 232| | // get the value out of |field|. However if it is a message we need to 233| | // recurse into it. 234| 9.22M| if (field_descriptor.type() == ------------------ | Branch (234:7): [True: 553k, False: 8.66M] ------------------ 235| 9.22M| protos::pbzero::FieldDescriptorProto::TYPE_MESSAGE) { 236| 553k| return ParseMessageInternal(key_context, field.as_bytes(), 237| 553k| field_descriptor.resolved_type_name(), nullptr, 238| 553k| delegate, unknown_extensions, add_defaults); 239| 553k| } 240| 8.66M| return ParseSimpleField(field_descriptor, field, delegate); 241| 9.22M|} _ZN8perfetto15trace_processor4util17ProtoToArgsParser26AddParsingOverrideForFieldERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS3_8functionIFNS3_8optionalINS_4base6StatusEEERKN9protozero5FieldERNS2_8DelegateEEEE: 305| 12.2k| ParsingOverrideForField func) { 306| 12.2k| field_overrides_[field] = std::move(func); 307| 12.2k|} _ZN8perfetto15trace_processor4util17ProtoToArgsParser25AddParsingOverrideForTypeERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS3_8functionIFNS3_8optionalINS_4base6StatusEEERNS2_22ScopedNestedKeyContextERKN9protozero10ConstBytesERNS2_8DelegateEEEE: 310| 2.03k| ParsingOverrideForType func) { 311| 2.03k| type_overrides_[type] = std::move(func); 312| 2.03k|} _ZN8perfetto15trace_processor4util17ProtoToArgsParser26MaybeApplyOverrideForFieldERKN9protozero5FieldERNS2_8DelegateE: 316| 9.22M| Delegate& delegate) { 317| 9.22M| auto it = field_overrides_.find(key_prefix_.flat_key); 318| 9.22M| if (it == field_overrides_.end()) ------------------ | Branch (318:7): [True: 9.21M, False: 5.36k] ------------------ 319| 9.21M| return std::nullopt; 320| 5.36k| return it->second(field, delegate); 321| 9.22M|} _ZN8perfetto15trace_processor4util17ProtoToArgsParser25MaybeApplyOverrideForTypeERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEERNS2_22ScopedNestedKeyContextERKN9protozero10ConstBytesERNS2_8DelegateE: 327| 1.29M| Delegate& delegate) { 328| 1.29M| auto it = type_overrides_.find(message_type); 329| 1.29M| if (it == type_overrides_.end()) ------------------ | Branch (329:7): [True: 1.29M, False: 0] ------------------ 330| 1.29M| return std::nullopt; 331| 0| return it->second(key, data, delegate); 332| 1.29M|} _ZN8perfetto15trace_processor4util17ProtoToArgsParser16ParseSimpleFieldERKNS0_15FieldDescriptorERKN9protozero5FieldERNS2_8DelegateE: 337| 8.66M| Delegate& delegate) { 338| 8.66M| using FieldDescriptorProto = protos::pbzero::FieldDescriptorProto; 339| 8.66M| switch (descriptor.type()) { 340| 402k| case FieldDescriptorProto::TYPE_INT32: ------------------ | Branch (340:5): [True: 402k, False: 8.26M] ------------------ 341| 402k| case FieldDescriptorProto::TYPE_SFIXED32: ------------------ | Branch (341:5): [True: 0, False: 8.66M] ------------------ 342| 402k| delegate.AddInteger(key_prefix_, field.as_int32()); 343| 402k| return base::OkStatus(); 344| 0| case FieldDescriptorProto::TYPE_SINT32: ------------------ | Branch (344:5): [True: 0, False: 8.66M] ------------------ 345| 0| delegate.AddInteger(key_prefix_, field.as_sint32()); 346| 0| return base::OkStatus(); 347| 37.6k| case FieldDescriptorProto::TYPE_INT64: ------------------ | Branch (347:5): [True: 37.6k, False: 8.62M] ------------------ 348| 37.6k| case FieldDescriptorProto::TYPE_SFIXED64: ------------------ | Branch (348:5): [True: 0, False: 8.66M] ------------------ 349| 37.6k| delegate.AddInteger(key_prefix_, field.as_int64()); 350| 37.6k| return base::OkStatus(); 351| 0| case FieldDescriptorProto::TYPE_SINT64: ------------------ | Branch (351:5): [True: 0, False: 8.66M] ------------------ 352| 0| delegate.AddInteger(key_prefix_, field.as_sint64()); 353| 0| return base::OkStatus(); 354| 0| case FieldDescriptorProto::TYPE_UINT32: ------------------ | Branch (354:5): [True: 0, False: 8.66M] ------------------ 355| 0| case FieldDescriptorProto::TYPE_FIXED32: ------------------ | Branch (355:5): [True: 0, False: 8.66M] ------------------ 356| 0| delegate.AddUnsignedInteger(key_prefix_, field.as_uint32()); 357| 0| return base::OkStatus(); 358| 8.21M| case FieldDescriptorProto::TYPE_UINT64: ------------------ | Branch (358:5): [True: 8.21M, False: 454k] ------------------ 359| 8.21M| case FieldDescriptorProto::TYPE_FIXED64: ------------------ | Branch (359:5): [True: 0, False: 8.66M] ------------------ 360| 8.21M| delegate.AddUnsignedInteger(key_prefix_, field.as_uint64()); 361| 8.21M| return base::OkStatus(); 362| 2| case FieldDescriptorProto::TYPE_BOOL: ------------------ | Branch (362:5): [True: 2, False: 8.66M] ------------------ 363| 2| delegate.AddBoolean(key_prefix_, field.as_bool()); 364| 2| return base::OkStatus(); 365| 0| case FieldDescriptorProto::TYPE_DOUBLE: ------------------ | Branch (365:5): [True: 0, False: 8.66M] ------------------ 366| 0| delegate.AddDouble(key_prefix_, field.as_double()); 367| 0| return base::OkStatus(); 368| 10| case FieldDescriptorProto::TYPE_FLOAT: ------------------ | Branch (368:5): [True: 10, False: 8.66M] ------------------ 369| 10| delegate.AddDouble(key_prefix_, static_cast(field.as_float())); 370| 10| return base::OkStatus(); 371| 0| case FieldDescriptorProto::TYPE_BYTES: ------------------ | Branch (371:5): [True: 0, False: 8.66M] ------------------ 372| 0| delegate.AddBytes(key_prefix_, field.as_bytes()); 373| 0| return base::OkStatus(); 374| 1.07k| case FieldDescriptorProto::TYPE_STRING: ------------------ | Branch (374:5): [True: 1.07k, False: 8.66M] ------------------ 375| 1.07k| delegate.AddString(key_prefix_, field.as_string()); 376| 1.07k| return base::OkStatus(); 377| 12.9k| case FieldDescriptorProto::TYPE_ENUM: ------------------ | Branch (377:5): [True: 12.9k, False: 8.65M] ------------------ 378| 12.9k| return AddEnum(descriptor, field.as_int32(), delegate); 379| 0| default: ------------------ | Branch (379:5): [True: 0, False: 8.66M] ------------------ 380| 0| return base::ErrStatus( 381| 0| "Tried to write value of type field %s (in proto type " 382| 0| "%s) which has type enum %u", 383| 0| descriptor.name().c_str(), descriptor.resolved_type_name().c_str(), 384| 0| descriptor.type()); 385| 8.66M| } 386| 8.66M|} _ZN8perfetto15trace_processor4util17ProtoToArgsParser15EnterDictionaryERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE: 396| 763k| const std::string& name) { 397| 763k| ScopedNestedKeyContext context(key_prefix_); 398| 763k| AppendProtoType(key_prefix_.key, name); 399| 763k| AppendProtoType(key_prefix_.flat_key, name); 400| 763k| return context; 401| 763k|} _ZN8perfetto15trace_processor4util17ProtoToArgsParser7AddEnumERKNS0_15FieldDescriptorEiRNS2_8DelegateE: 485| 12.9k| Delegate& delegate) { 486| 12.9k| auto opt_enum_descriptor_idx = 487| 12.9k| pool_.FindDescriptorIdx(descriptor.resolved_type_name()); 488| 12.9k| if (!opt_enum_descriptor_idx) { ------------------ | Branch (488:7): [True: 0, False: 12.9k] ------------------ 489| | // Fall back to the integer representation of the field. 490| | // We add the string representation of the int value here in order that 491| | // EXTRACT_ARG() should return consistent types under error conditions and 492| | // that CREATE PERFETTO TABLE AS EXTRACT_ARG(...) should be generally safe 493| | // to use. 494| 0| delegate.AddString(key_prefix_, std::to_string(value)); 495| 0| return base::OkStatus(); 496| 0| } 497| 12.9k| auto opt_enum_string = 498| 12.9k| pool_.descriptors()[*opt_enum_descriptor_idx].FindEnumString(value); 499| 12.9k| if (!opt_enum_string) { ------------------ | Branch (499:7): [True: 12.9k, False: 0] ------------------ 500| | // Fall back to the integer representation of the field. See above for 501| | // motivation. 502| 12.9k| delegate.AddString(key_prefix_, std::to_string(value)); 503| 12.9k| return base::OkStatus(); 504| 12.9k| } 505| 0| delegate.AddString( 506| 0| key_prefix_, 507| 0| protozero::ConstChars{opt_enum_string->data(), opt_enum_string->size()}); 508| 0| return base::OkStatus(); 509| 12.9k|} proto_to_args_parser.cc:_ZN8perfetto15trace_processor4util12_GLOBAL__N_114IsFieldAllowedERKNS0_15FieldDescriptorEPKNSt3__16vectorIjNS6_9allocatorIjEEEE: 54| 11.4M| const std::vector* allowed_fields) { 55| | // If allowlist is not provided, reflect all fields. Otherwise, check if the 56| | // current field either an extension or is in allowlist. 57| 11.4M| return field.is_extension() || !allowed_fields || ------------------ | Branch (57:10): [True: 1.00k, False: 11.4M] | Branch (57:34): [True: 8.66M, False: 2.75M] ------------------ 58| 11.4M| std::find(allowed_fields->begin(), allowed_fields->end(), ------------------ | Branch (58:10): [True: 552k, False: 2.19M] ------------------ 59| 2.75M| field.number()) != allowed_fields->end(); 60| 11.4M|} proto_to_args_parser.cc:_ZN8perfetto15trace_processor4util12_GLOBAL__N_115AppendProtoTypeERNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEERKS9_: 47| 19.9M|void AppendProtoType(std::string& target, const std::string& value) { 48| 19.9M| if (!target.empty()) ------------------ | Branch (48:7): [True: 17.3M, False: 2.58M] ------------------ 49| 17.3M| target += '.'; 50| 19.9M| target += value; 51| 19.9M|} _ZNK8perfetto15trace_processor4util17ProtoToArgsParser22ScopedNestedKeyContext3keyEv: 173| 23.8k| const Key& key() const { return key_; } _ZN8perfetto15trace_processor4util17ProtoToArgsParser8Delegate18GetInternedMessageIN9protozero11proto_utils13FieldMetadataILj3ELNS6_14RepetitionTypeE2ELNS6_15ProtoSchemaTypeE11ENS_6protos6pbzero19DebugAnnotationNameENSB_12InternedDataEEEEEPNT_14cpp_field_type7DecoderESF_m: 120| 16| uint64_t iid) { 121| 16| static_assert(std::is_base_of::value, 123| 16| "Field metadata should be a subclass of FieldMetadataBase"); 124| 16| static_assert(std::is_same::value, 126| 16| "Field should belong to InternedData proto"); 127| 16| auto* interned_message_view = 128| 16| GetInternedMessageView(FieldMetadata::kFieldId, iid); 129| 16| if (!interned_message_view) ------------------ | Branch (129:11): [True: 16, False: 0] ------------------ 130| 16| return nullptr; 131| 0| return interned_message_view->template GetOrCreateDecoder< 132| 0| typename FieldMetadata::cpp_field_type>(); 133| 16| } _ZN8perfetto15trace_processor4util17ProtoToArgsParser8Delegate18GetInternedMessageIN9protozero11proto_utils13FieldMetadataILj27ELNS6_14RepetitionTypeE2ELNS6_15ProtoSchemaTypeE11ENS_6protos6pbzero28DebugAnnotationValueTypeNameENSB_12InternedDataEEEEEPNT_14cpp_field_type7DecoderESF_m: 120| 1.51k| uint64_t iid) { 121| 1.51k| static_assert(std::is_base_of::value, 123| 1.51k| "Field metadata should be a subclass of FieldMetadataBase"); 124| 1.51k| static_assert(std::is_same::value, 126| 1.51k| "Field should belong to InternedData proto"); 127| 1.51k| auto* interned_message_view = 128| 1.51k| GetInternedMessageView(FieldMetadata::kFieldId, iid); 129| 1.51k| if (!interned_message_view) ------------------ | Branch (129:11): [True: 1.51k, False: 0] ------------------ 130| 1.51k| return nullptr; 131| 0| return interned_message_view->template GetOrCreateDecoder< 132| 0| typename FieldMetadata::cpp_field_type>(); 133| 1.51k| } _ZN8perfetto15trace_processor4util19TraceBlobViewReader8PushBackENS0_13TraceBlobViewE: 34| 424|void TraceBlobViewReader::PushBack(TraceBlobView data) { 35| 424| if (data.size() == 0) { ------------------ | Branch (35:7): [True: 0, False: 424] ------------------ 36| 0| return; 37| 0| } 38| 424| const size_t size = data.size(); 39| 424| data_.emplace_back(Entry{end_offset_, std::move(data)}); 40| 424| end_offset_ += size; 41| 424|} _ZN8perfetto15trace_processor4util19TraceBlobViewReader13PopFrontUntilEm: 43| 27.0M|bool TraceBlobViewReader::PopFrontUntil(const size_t target_offset) { 44| 27.0M| PERFETTO_CHECK(start_offset() <= target_offset); 45| 27.0M| while (!data_.empty()) { ------------------ | Branch (45:10): [True: 27.0M, False: 104] ------------------ 46| 27.0M| Entry& entry = data_.front(); 47| 27.0M| if (target_offset == entry.start_offset) { ------------------ | Branch (47:9): [True: 0, False: 27.0M] ------------------ 48| 0| return true; 49| 0| } 50| 27.0M| const size_t bytes_to_pop = target_offset - entry.start_offset; 51| 27.0M| if (entry.data.size() > bytes_to_pop) { ------------------ | Branch (51:9): [True: 27.0M, False: 104] ------------------ 52| 27.0M| entry.data = 53| 27.0M| entry.data.slice_off(bytes_to_pop, entry.data.size() - bytes_to_pop); 54| 27.0M| entry.start_offset += bytes_to_pop; 55| 27.0M| return true; 56| 27.0M| } 57| 104| data_.pop_front(); 58| 104| } 59| 104| return target_offset == end_offset_; 60| 27.0M|} _ZNK8perfetto15trace_processor4util19TraceBlobViewReader8SliceOffEmm: 128| 31.0M| size_t length) const { 129| 31.0M| struct Visitor { 130| 31.0M| static std::optional NoData() { return std::nullopt; } 131| | 132| 31.0M| static std::optional OneSlice(TraceBlobView tbv) { 133| 31.0M| return std::move(tbv); 134| 31.0M| } 135| | 136| 31.0M| static TraceBlob StartMultiSlice(size_t length) { 137| 31.0M| return TraceBlob::Allocate(length); 138| 31.0M| } 139| | 140| 31.0M| static void AddSlice(TraceBlob& blob, size_t offset, TraceBlobView tbv) { 141| 31.0M| memcpy(blob.data() + offset, tbv.data(), tbv.size()); 142| 31.0M| } 143| | 144| 31.0M| static std::optional Finalize(TraceBlob blob) { 145| 31.0M| return TraceBlobView(std::move(blob)); 146| 31.0M| } 147| | 148| 31.0M| } visitor; 149| | 150| 31.0M| return SliceOffImpl(offset, length, visitor); 151| 31.0M|} trace_blob_view_reader.cc:_ZNK8perfetto15trace_processor4util19TraceBlobViewReader12SliceOffImplIZNKS2_8SliceOffEmmE7VisitorEEDammRT_: 65| 31.0M| Visitor& visitor) const { 66| | // If the length is zero, then a zero-sized blob view is always appropiate. 67| 31.0M| if (PERFETTO_UNLIKELY(length == 0)) { ------------------ | | 24| 31.0M|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 0, False: 31.0M] | | ------------------ ------------------ 68| 0| return visitor.OneSlice(TraceBlobView()); 69| 0| } 70| | 71| 31.0M| PERFETTO_DCHECK(offset >= start_offset()); 72| | 73| | // Fast path: the slice fits entirely inside the first TBV, we can just slice 74| | // that directly without doing any searching. This will happen most of the 75| | // time when this class is used so optimize for it. 76| 31.0M| bool is_fast_path = 77| 31.0M| !data_.empty() && ------------------ | Branch (77:7): [True: 31.0M, False: 104] ------------------ 78| 31.0M| offset + length <= data_.front().start_offset + data_.front().data.size(); ------------------ | Branch (78:7): [True: 31.0M, False: 15] ------------------ 79| 31.0M| if (PERFETTO_LIKELY(is_fast_path)) { ------------------ | | 23| 31.0M|#define PERFETTO_LIKELY(...) __builtin_expect(!!(__VA_ARGS__), 1) | | ------------------ | | | Branch (23:30): [True: 31.0M, False: 119] | | ------------------ ------------------ 80| 31.0M| return visitor.OneSlice(data_.front().data.slice_off( 81| 31.0M| offset - data_.front().start_offset, length)); 82| 31.0M| } 83| | 84| | // If we don't have any TBVs or the end of the slice does not fit, then we 85| | // cannot possibly return a full slice. 86| 119| if (PERFETTO_UNLIKELY(data_.empty() || offset + length > end_offset_)) { ------------------ | | 24| 134|#define PERFETTO_UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0) | | ------------------ | | | Branch (24:32): [True: 119, False: 0] | | | Branch (24:52): [True: 104, False: 15] | | | Branch (24:52): [True: 15, False: 0] | | ------------------ ------------------ 87| 119| return visitor.NoData(); 88| 119| } 89| | 90| | // Find the first block finishes *after* start_offset i.e. there is at least 91| | // one byte in that block which will end up in the slice. We know this *must* 92| | // exist because of the above check. 93| 0| auto it = std::upper_bound( 94| 0| data_.begin(), data_.end(), offset, [](size_t offset, const Entry& rhs) { 95| 0| return offset < rhs.start_offset + rhs.data.size(); 96| 0| }); 97| 0| PERFETTO_CHECK(it != data_.end()); 98| | 99| | // If the slice fits entirely in the block we found, then just slice that 100| | // block avoiding any copies. 101| 0| size_t rel_off = offset - it->start_offset; 102| 0| if (rel_off + length <= it->data.size()) { ------------------ | Branch (102:7): [True: 0, False: 0] ------------------ 103| 0| return visitor.OneSlice(it->data.slice_off(rel_off, length)); 104| 0| } 105| | 106| 0| auto res = visitor.StartMultiSlice(length); 107| | 108| 0| size_t res_offset = 0; 109| 0| size_t left = length; 110| | 111| 0| size_t size = it->data.length() - rel_off; 112| 0| visitor.AddSlice(res, res_offset, it->data.slice_off(rel_off, size)); 113| 0| left -= size; 114| 0| res_offset += size; 115| | 116| 0| for (++it; left != 0; ++it) { ------------------ | Branch (116:14): [True: 0, False: 0] ------------------ 117| 0| size = std::min(left, it->data.size()); 118| 0| visitor.AddSlice(res, res_offset, it->data.slice_off(0, size)); 119| 0| left -= size; 120| 0| res_offset += size; 121| 0| } 122| | 123| 0| return visitor.Finalize(std::move(res)); 124| 0|} trace_blob_view_reader.cc:_ZZNK8perfetto15trace_processor4util19TraceBlobViewReader8SliceOffEmmEN7Visitor8OneSliceENS0_13TraceBlobViewE: 132| 31.0M| static std::optional OneSlice(TraceBlobView tbv) { 133| 31.0M| return std::move(tbv); 134| 31.0M| } trace_blob_view_reader.cc:_ZZNK8perfetto15trace_processor4util19TraceBlobViewReader8SliceOffEmmEN7Visitor6NoDataEv: 130| 119| static std::optional NoData() { return std::nullopt; } _ZN8perfetto15trace_processor4util19TraceBlobViewReader13PopFrontBytesEm: 182| 27.0M| bool PopFrontBytes(size_t bytes) { 183| 27.0M| return PopFrontUntil(start_offset() + bytes); 184| 27.0M| } _ZNK8perfetto15trace_processor4util19TraceBlobViewReader12start_offsetEv: 202| 108M| size_t start_offset() const { 203| 108M| return data_.empty() ? end_offset_ : data_.front().start_offset; ------------------ | Branch (203:12): [True: 208, False: 108M] ------------------ 204| 108M| } _ZNK8perfetto15trace_processor4util19TraceBlobViewReader10end_offsetEv: 207| 27.0M| size_t end_offset() const { return end_offset_; } _ZNK8perfetto15trace_processor4util19TraceBlobViewReader5availEv: 210| 27.0M| size_t avail() const { return end_offset() - start_offset(); } _ZN8perfetto15trace_processor17TraceTypeToStringENS0_9TraceTypeE: 108| 1.28k|const char* TraceTypeToString(TraceType trace_type) { 109| 1.28k| switch (trace_type) { ------------------ | Branch (109:11): [True: 0, False: 1.28k] ------------------ 110| 0| case kJsonTraceType: ------------------ | Branch (110:5): [True: 0, False: 1.28k] ------------------ 111| 0| return "json"; 112| 848| case kProtoTraceType: ------------------ | Branch (112:5): [True: 848, False: 438] ------------------ 113| 848| return "proto"; 114| 0| case kSymbolsTraceType: ------------------ | Branch (114:5): [True: 0, False: 1.28k] ------------------ 115| 0| return "symbols"; 116| 0| case kNinjaLogTraceType: ------------------ | Branch (116:5): [True: 0, False: 1.28k] ------------------ 117| 0| return "ninja_log"; 118| 0| case kFuchsiaTraceType: ------------------ | Branch (118:5): [True: 0, False: 1.28k] ------------------ 119| 0| return "fuchsia"; 120| 0| case kSystraceTraceType: ------------------ | Branch (120:5): [True: 0, False: 1.28k] ------------------ 121| 0| return "systrace"; 122| 0| case kGzipTraceType: ------------------ | Branch (122:5): [True: 0, False: 1.28k] ------------------ 123| 0| return "gzip"; 124| 0| case kCtraceTraceType: ------------------ | Branch (124:5): [True: 0, False: 1.28k] ------------------ 125| 0| return "ctrace"; 126| 4| case kZipFile: ------------------ | Branch (126:5): [True: 4, False: 1.28k] ------------------ 127| 4| return "zip"; 128| 0| case kPerfDataTraceType: ------------------ | Branch (128:5): [True: 0, False: 1.28k] ------------------ 129| 0| return "perf"; 130| 0| case kInstrumentsXmlTraceType: ------------------ | Branch (130:5): [True: 0, False: 1.28k] ------------------ 131| 0| return "instruments_xml"; 132| 0| case kAndroidLogcatTraceType: ------------------ | Branch (132:5): [True: 0, False: 1.28k] ------------------ 133| 0| return "android_logcat"; 134| 0| case kAndroidDumpstateTraceType: ------------------ | Branch (134:5): [True: 0, False: 1.28k] ------------------ 135| 0| return "android_dumpstate"; 136| 0| case kAndroidBugreportTraceType: ------------------ | Branch (136:5): [True: 0, False: 1.28k] ------------------ 137| 0| return "android_bugreport"; 138| 0| case kGeckoTraceType: ------------------ | Branch (138:5): [True: 0, False: 1.28k] ------------------ 139| 0| return "gecko"; 140| 0| case kArtMethodTraceType: ------------------ | Branch (140:5): [True: 0, False: 1.28k] ------------------ 141| 0| return "art_method"; 142| 0| case kPerfTextTraceType: ------------------ | Branch (142:5): [True: 0, False: 1.28k] ------------------ 143| 0| return "perf_text"; 144| 434| case kUnknownTraceType: ------------------ | Branch (144:5): [True: 434, False: 852] ------------------ 145| 434| return "unknown"; 146| 0| case kTarTraceType: ------------------ | Branch (146:5): [True: 0, False: 1.28k] ------------------ 147| 0| return "tar"; 148| 1.28k| } 149| 0| PERFETTO_FATAL("For GCC"); 150| 0|} _ZN8perfetto15trace_processor14GuessTraceTypeEPKhm: 152| 434|TraceType GuessTraceType(const uint8_t* data, size_t size) { 153| 434| if (size == 0) { ------------------ | Branch (153:7): [True: 0, False: 434] ------------------ 154| 0| return kUnknownTraceType; 155| 0| } 156| | 157| 434| if (MatchesMagic(data, size, kTarPosixMagic, kTarMagicOffset)) { ------------------ | Branch (157:7): [True: 0, False: 434] ------------------ 158| 0| return kTarTraceType; 159| 0| } 160| | 161| 434| if (MatchesMagic(data, size, kTarGnuMagic, kTarMagicOffset)) { ------------------ | Branch (161:7): [True: 0, False: 434] ------------------ 162| 0| return kTarTraceType; 163| 0| } 164| | 165| 434| if (MatchesMagic(data, size, kFuchsiaMagic)) { ------------------ | Branch (165:7): [True: 0, False: 434] ------------------ 166| 0| return kFuchsiaTraceType; 167| 0| } 168| | 169| 434| if (MatchesMagic(data, size, kPerfMagic)) { ------------------ | Branch (169:7): [True: 0, False: 434] ------------------ 170| 0| return kPerfDataTraceType; 171| 0| } 172| | 173| 434| if (MatchesMagic(data, size, kZipMagic)) { ------------------ | Branch (173:7): [True: 2, False: 432] ------------------ 174| 2| return kZipFile; 175| 2| } 176| | 177| 432| if (MatchesMagic(data, size, kGzipMagic)) { ------------------ | Branch (177:7): [True: 0, False: 432] ------------------ 178| 0| return kGzipTraceType; 179| 0| } 180| | 181| 432| if (MatchesMagic(data, size, kArtMethodStreamingMagic)) { ------------------ | Branch (181:7): [True: 0, False: 432] ------------------ 182| 0| return kArtMethodTraceType; 183| 0| } 184| | 185| 432| std::string start(reinterpret_cast(data), 186| 432| std::min(size, kGuessTraceMaxLookahead)); 187| | 188| 432| std::string start_minus_white_space = RemoveWhitespace(start); 189| | // Generated by the Gecko conversion script built into perf. 190| 432| if (base::StartsWith(start_minus_white_space, "{\"meta\"")) ------------------ | Branch (190:7): [True: 0, False: 432] ------------------ 191| 0| return kGeckoTraceType; 192| | // Generated by the simpleperf conversion script. 193| 432| if (base::StartsWith(start_minus_white_space, "{\"libs\"")) ------------------ | Branch (193:7): [True: 0, False: 432] ------------------ 194| 0| return kGeckoTraceType; 195| 432| if (base::StartsWith(start_minus_white_space, "{\"")) ------------------ | Branch (195:7): [True: 0, False: 432] ------------------ 196| 0| return kJsonTraceType; 197| 432| if (base::StartsWith(start_minus_white_space, "[{\"")) ------------------ | Branch (197:7): [True: 0, False: 432] ------------------ 198| 0| return kJsonTraceType; 199| | 200| | // ART method traces (non-streaming). 201| 432| if (base::StartsWith(start, "*version\n")) ------------------ | Branch (201:7): [True: 0, False: 432] ------------------ 202| 0| return kArtMethodTraceType; 203| | 204| | // Systrace with header but no leading HTML. 205| 432| if (base::Contains(start, "# tracer")) ------------------ | Branch (205:7): [True: 0, False: 432] ------------------ 206| 0| return kSystraceTraceType; 207| | 208| | // Systrace with leading HTML. 209| | // Both: and have been observed. 210| 432| std::string lower_start = base::ToLower(start); 211| 432| if (base::StartsWith(lower_start, "") || ------------------ | Branch (211:7): [True: 0, False: 432] | Branch (211:7): [True: 0, False: 432] ------------------ 212| 432| base::StartsWith(lower_start, "")) ------------------ | Branch (212:7): [True: 0, False: 432] ------------------ 213| 0| return kSystraceTraceType; 214| | 215| | // MacOS Instruments XML export. 216| 432| if (base::StartsWith(start, "\n")) ------------------ | Branch (216:7): [True: 0, False: 432] ------------------ 217| 0| return kInstrumentsXmlTraceType; 218| | 219| | // Traces obtained from atrace -z (compress). 220| | // They all have the string "TRACE:" followed by 78 9C which is a zlib header 221| | // for "deflate, default compression, window size=32K" (see b/208691037) 222| 432| if (base::Contains(start, "TRACE:\n\x78\x9c")) ------------------ | Branch (222:7): [True: 0, False: 432] ------------------ 223| 0| return kCtraceTraceType; 224| | 225| | // Traces obtained from atrace without -z (no compression). 226| 432| if (base::Contains(start, "TRACE:\n")) ------------------ | Branch (226:7): [True: 0, False: 432] ------------------ 227| 0| return kSystraceTraceType; 228| | 229| | // Ninja's build log (.ninja_log). 230| 432| if (base::StartsWith(start, "# ninja log")) ------------------ | Branch (230:7): [True: 0, False: 432] ------------------ 231| 0| return kNinjaLogTraceType; 232| | 233| 432| if (AndroidLogEvent::IsAndroidLogcat(data, size)) { ------------------ | Branch (233:7): [True: 0, False: 432] ------------------ 234| 0| return kAndroidLogcatTraceType; 235| 0| } 236| | 237| | // Perf text format. 238| 432| if (perf_text_importer::IsPerfTextFormatTrace(data, size)) ------------------ | Branch (238:7): [True: 0, False: 432] ------------------ 239| 0| return kPerfTextTraceType; 240| | 241| | // Systrace with no header or leading HTML. 242| 432| if (base::StartsWith(start, " ")) ------------------ | Branch (242:7): [True: 0, False: 432] ------------------ 243| 0| return kSystraceTraceType; 244| | 245| 432| if (IsProtoTraceWithSymbols(data, size)) ------------------ | Branch (245:7): [True: 0, False: 432] ------------------ 246| 0| return kSymbolsTraceType; 247| | 248| 432| if (base::StartsWith(start, "\x0a")) ------------------ | Branch (248:7): [True: 424, False: 8] ------------------ 249| 424| return kProtoTraceType; 250| | 251| 8| if (base::StartsWith(start, "9,0,i,vers,")) { ------------------ | Branch (251:7): [True: 0, False: 8] ------------------ 252| 0| return kAndroidDumpstateTraceType; 253| 0| } 254| | 255| 8| return kUnknownTraceType; 256| 8|} trace_type.cc:_ZN8perfetto15trace_processor12_GLOBAL__N_116RemoveWhitespaceENSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE: 59| 432|std::string RemoveWhitespace(std::string str) { 60| 432| str.erase(std::remove_if(str.begin(), str.end(), isspace), str.end()); 61| 432| return str; 62| 432|} trace_type.cc:_ZN8perfetto15trace_processor12_GLOBAL__N_17isspaceEh: 55| 27.6k|inline bool isspace(unsigned char c) { 56| 27.6k| return ::isspace(c); 57| 27.6k|} trace_type.cc:_ZN8perfetto15trace_processor12_GLOBAL__N_123IsProtoTraceWithSymbolsEPKhm: 76| 432|bool IsProtoTraceWithSymbols(const uint8_t* ptr, size_t size) { 77| 432| const uint8_t* const end = ptr + size; 78| | 79| 432| uint64_t tag; 80| 432| const uint8_t* next = protozero::proto_utils::ParseVarInt(ptr, end, &tag); 81| | 82| 432| if (next == ptr || tag != kTracePacketTag) { ------------------ | Branch (82:7): [True: 1, False: 431] | Branch (82:22): [True: 7, False: 424] ------------------ 83| 8| return false; 84| 8| } 85| | 86| 424| ptr = next; 87| 424| uint64_t field_length; 88| 424| next = protozero::proto_utils::ParseVarInt(ptr, end, &field_length); 89| 424| if (next == ptr) { ------------------ | Branch (89:7): [True: 0, False: 424] ------------------ 90| 0| return false; 91| 0| } 92| 424| ptr = next; 93| | 94| 424| if (field_length == 0) { ------------------ | Branch (94:7): [True: 32, False: 392] ------------------ 95| 32| return false; 96| 32| } 97| | 98| 392| next = protozero::proto_utils::ParseVarInt(ptr, end, &tag); 99| 392| if (next == ptr) { ------------------ | Branch (99:7): [True: 0, False: 392] ------------------ 100| 0| return false; 101| 0| } 102| | 103| 392| return tag == kModuleSymbolsTag; 104| 392|} trace_type.cc:_ZN8perfetto15trace_processor12_GLOBAL__N_112MatchesMagicILm6EEEbPKhmRAT__Kcm: 68| 434| size_t offset = 0) { 69| 434| if (size < N + offset) { ------------------ | Branch (69:7): [True: 0, False: 434] ------------------ 70| 0| return false; 71| 0| } 72| | 73| 434| return memcmp(data + offset, magic, N) == 0; 74| 434|} trace_type.cc:_ZN8perfetto15trace_processor12_GLOBAL__N_112MatchesMagicILm8EEEbPKhmRAT__Kcm: 68| 1.30k| size_t offset = 0) { 69| 1.30k| if (size < N + offset) { ------------------ | Branch (69:7): [True: 0, False: 1.30k] ------------------ 70| 0| return false; 71| 0| } 72| | 73| 1.30k| return memcmp(data + offset, magic, N) == 0; 74| 1.30k|} trace_type.cc:_ZN8perfetto15trace_processor12_GLOBAL__N_112MatchesMagicILm4EEEbPKhmRAT__Kcm: 68| 866| size_t offset = 0) { 69| 866| if (size < N + offset) { ------------------ | Branch (69:7): [True: 0, False: 866] ------------------ 70| 0| return false; 71| 0| } 72| | 73| 866| return memcmp(data + offset, magic, N) == 0; 74| 866|} trace_type.cc:_ZN8perfetto15trace_processor12_GLOBAL__N_112MatchesMagicILm2EEEbPKhmRAT__Kcm: 68| 432| size_t offset = 0) { 69| 432| if (size < N + offset) { ------------------ | Branch (69:7): [True: 0, False: 432] ------------------ 70| 0| return false; 71| 0| } 72| | 73| 432| return memcmp(data + offset, magic, N) == 0; 74| 432|} _ZN8perfetto15trace_processor18ChunkedTraceReaderD2Ev: 22| 2.46k|ChunkedTraceReader::~ChunkedTraceReader() {} _ZN8perfetto6protos6pbzero32EnumValueDescriptorProto_DecoderC2EPKhm: 179| 1.81M| EnumValueDescriptorProto_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} _ZNK8perfetto6protos6pbzero32EnumValueDescriptorProto_Decoder4nameEv: 183| 1.81M| ::protozero::ConstChars name() const { return at<1>().as_string(); } _ZNK8perfetto6protos6pbzero32EnumValueDescriptorProto_Decoder6numberEv: 185| 1.81M| int32_t number() const { return at<2>().as_int32(); } _ZN8perfetto6protos6pbzero27EnumDescriptorProto_DecoderC2ERKN9protozero10ConstBytesE: 245| 167k| explicit EnumDescriptorProto_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} _ZNK8perfetto6protos6pbzero27EnumDescriptorProto_Decoder4nameEv: 247| 167k| ::protozero::ConstChars name() const { return at<1>().as_string(); } _ZNK8perfetto6protos6pbzero27EnumDescriptorProto_Decoder5valueEv: 249| 167k| ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> value() const { return GetRepeated<::protozero::ConstBytes>(2); } _ZN8perfetto6protos6pbzero28FieldDescriptorProto_DecoderC2ERKN9protozero10ConstBytesE: 392| 1.75M| explicit FieldDescriptorProto_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} _ZNK8perfetto6protos6pbzero28FieldDescriptorProto_Decoder4nameEv: 394| 1.75M| ::protozero::ConstChars name() const { return at<1>().as_string(); } _ZNK8perfetto6protos6pbzero28FieldDescriptorProto_Decoder6numberEv: 396| 1.75M| int32_t number() const { return at<3>().as_int32(); } _ZNK8perfetto6protos6pbzero28FieldDescriptorProto_Decoder5labelEv: 398| 1.75M| int32_t label() const { return at<4>().as_int32(); } _ZNK8perfetto6protos6pbzero28FieldDescriptorProto_Decoder8has_typeEv: 399| 1.75M| bool has_type() const { return at<5>().valid(); } _ZNK8perfetto6protos6pbzero28FieldDescriptorProto_Decoder4typeEv: 400| 1.75M| int32_t type() const { return at<5>().as_int32(); } _ZNK8perfetto6protos6pbzero28FieldDescriptorProto_Decoder13has_type_nameEv: 401| 1.75M| bool has_type_name() const { return at<6>().valid(); } _ZNK8perfetto6protos6pbzero28FieldDescriptorProto_Decoder9type_nameEv: 402| 525k| ::protozero::ConstChars type_name() const { return at<6>().as_string(); } _ZNK8perfetto6protos6pbzero28FieldDescriptorProto_Decoder8extendeeEv: 404| 162k| ::protozero::ConstChars extendee() const { return at<2>().as_string(); } _ZNK8perfetto6protos6pbzero28FieldDescriptorProto_Decoder17has_default_valueEv: 405| 1.75M| bool has_default_value() const { return at<7>().valid(); } _ZNK8perfetto6protos6pbzero28FieldDescriptorProto_Decoder7optionsEv: 408| 7.03M| ::protozero::ConstBytes options() const { return at<8>().as_bytes(); } _ZN8perfetto6protos6pbzero20FieldOptions_DecoderC2ERKN9protozero10ConstBytesE: 648| 1.75M| explicit FieldOptions_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} _ZNK8perfetto6protos6pbzero20FieldOptions_Decoder6packedEv: 650| 1.75M| bool packed() const { return at<2>().as_bool(); } _ZN8perfetto6protos6pbzero23DescriptorProto_DecoderC2ERKN9protozero10ConstBytesE: 944| 291k| explicit DescriptorProto_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} _ZNK8perfetto6protos6pbzero23DescriptorProto_Decoder4nameEv: 946| 291k| ::protozero::ConstChars name() const { return at<1>().as_string(); } _ZNK8perfetto6protos6pbzero23DescriptorProto_Decoder5fieldEv: 948| 291k| ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> field() const { return GetRepeated<::protozero::ConstBytes>(2); } _ZNK8perfetto6protos6pbzero23DescriptorProto_Decoder9extensionEv: 950| 291k| ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> extension() const { return GetRepeated<::protozero::ConstBytes>(6); } _ZNK8perfetto6protos6pbzero23DescriptorProto_Decoder11nested_typeEv: 952| 291k| ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> nested_type() const { return GetRepeated<::protozero::ConstBytes>(3); } _ZNK8perfetto6protos6pbzero23DescriptorProto_Decoder9enum_typeEv: 954| 291k| ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> enum_type() const { return GetRepeated<::protozero::ConstBytes>(4); } _ZN8perfetto6protos6pbzero27FileDescriptorProto_DecoderC2ERKN9protozero10ConstBytesE: 1175| 46.3k| explicit FileDescriptorProto_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} _ZNK8perfetto6protos6pbzero27FileDescriptorProto_Decoder4nameEv: 1177| 46.3k| ::protozero::ConstChars name() const { return at<1>().as_string(); } _ZNK8perfetto6protos6pbzero27FileDescriptorProto_Decoder7packageEv: 1179| 46.3k| ::protozero::ConstChars package() const { return at<2>().as_string(); } _ZNK8perfetto6protos6pbzero27FileDescriptorProto_Decoder12message_typeEv: 1187| 46.3k| ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> message_type() const { return GetRepeated<::protozero::ConstBytes>(4); } _ZNK8perfetto6protos6pbzero27FileDescriptorProto_Decoder9enum_typeEv: 1189| 46.3k| ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> enum_type() const { return GetRepeated<::protozero::ConstBytes>(5); } _ZNK8perfetto6protos6pbzero27FileDescriptorProto_Decoder9extensionEv: 1191| 46.3k| ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> extension() const { return GetRepeated<::protozero::ConstBytes>(7); } _ZN8perfetto6protos6pbzero25FileDescriptorSet_DecoderC2EPKhm: 1363| 7.89k| FileDescriptorSet_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} _ZNK8perfetto6protos6pbzero25FileDescriptorSet_Decoder4fileEv: 1367| 7.89k| ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> file() const { return GetRepeated<::protozero::ConstBytes>(1); } _ZN8perfetto6protos6pbzero18TraceStats_DecoderC2EPKhm: 64| 24| TraceStats_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} _ZNK8perfetto6protos6pbzero18TraceStats_Decoder19producers_connectedEv: 74| 24| uint32_t producers_connected() const { return at<2>().as_uint32(); } _ZNK8perfetto6protos6pbzero18TraceStats_Decoder14producers_seenEv: 76| 24| uint64_t producers_seen() const { return at<3>().as_uint64(); } _ZNK8perfetto6protos6pbzero18TraceStats_Decoder23data_sources_registeredEv: 78| 24| uint32_t data_sources_registered() const { return at<4>().as_uint32(); } _ZNK8perfetto6protos6pbzero18TraceStats_Decoder17data_sources_seenEv: 80| 24| uint64_t data_sources_seen() const { return at<5>().as_uint64(); } _ZNK8perfetto6protos6pbzero18TraceStats_Decoder16tracing_sessionsEv: 82| 24| uint32_t tracing_sessions() const { return at<6>().as_uint32(); } _ZNK8perfetto6protos6pbzero18TraceStats_Decoder13total_buffersEv: 84| 24| uint32_t total_buffers() const { return at<7>().as_uint32(); } _ZNK8perfetto6protos6pbzero18TraceStats_Decoder16chunks_discardedEv: 86| 24| uint64_t chunks_discarded() const { return at<8>().as_uint64(); } _ZNK8perfetto6protos6pbzero18TraceStats_Decoder17patches_discardedEv: 88| 24| uint64_t patches_discarded() const { return at<9>().as_uint64(); } _ZNK8perfetto6protos6pbzero18TraceStats_Decoder17flushes_requestedEv: 94| 24| uint64_t flushes_requested() const { return at<12>().as_uint64(); } _ZNK8perfetto6protos6pbzero18TraceStats_Decoder17flushes_succeededEv: 96| 24| uint64_t flushes_succeeded() const { return at<13>().as_uint64(); } _ZNK8perfetto6protos6pbzero18TraceStats_Decoder14flushes_failedEv: 98| 24| uint64_t flushes_failed() const { return at<14>().as_uint64(); } _ZNK8perfetto6protos6pbzero18TraceStats_Decoder16has_filter_statsEv: 91| 24| bool has_filter_stats() const { return at<11>().valid(); } _ZNK8perfetto6protos6pbzero18TraceStats_Decoder12filter_statsEv: 92| 2| ::protozero::ConstBytes filter_stats() const { return at<11>().as_bytes(); } _ZN8perfetto6protos6pbzero30TraceStats_FilterStats_DecoderC2ERKN9protozero10ConstBytesE: 438| 2| explicit TraceStats_FilterStats_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} _ZNK8perfetto6protos6pbzero30TraceStats_FilterStats_Decoder6errorsEv: 446| 2| uint64_t errors() const { return at<4>().as_uint64(); } _ZNK8perfetto6protos6pbzero30TraceStats_FilterStats_Decoder11input_bytesEv: 442| 2| uint64_t input_bytes() const { return at<2>().as_uint64(); } _ZNK8perfetto6protos6pbzero30TraceStats_FilterStats_Decoder13input_packetsEv: 440| 2| uint64_t input_packets() const { return at<1>().as_uint64(); } _ZNK8perfetto6protos6pbzero30TraceStats_FilterStats_Decoder12output_bytesEv: 444| 2| uint64_t output_bytes() const { return at<3>().as_uint64(); } _ZNK8perfetto6protos6pbzero30TraceStats_FilterStats_Decoder13time_taken_nsEv: 448| 2| uint64_t time_taken_ns() const { return at<5>().as_uint64(); } _ZNK8perfetto6protos6pbzero30TraceStats_FilterStats_Decoder26bytes_discarded_per_bufferEv: 450| 2| ::protozero::RepeatedFieldIterator bytes_discarded_per_buffer() const { return GetRepeated(20); } _ZNK8perfetto6protos6pbzero18TraceStats_Decoder19final_flush_outcomeEv: 100| 24| int32_t final_flush_outcome() const { return at<15>().as_int32(); } _ZNK8perfetto6protos6pbzero18TraceStats_Decoder12buffer_statsEv: 68| 24| ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> buffer_stats() const { return GetRepeated<::protozero::ConstBytes>(1); } _ZN8perfetto6protos6pbzero30TraceStats_BufferStats_DecoderC2ERKN9protozero10ConstBytesE: 672| 59| explicit TraceStats_BufferStats_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} _ZNK8perfetto6protos6pbzero30TraceStats_BufferStats_Decoder11buffer_sizeEv: 674| 59| uint64_t buffer_size() const { return at<12>().as_uint64(); } _ZNK8perfetto6protos6pbzero30TraceStats_BufferStats_Decoder13bytes_writtenEv: 676| 59| uint64_t bytes_written() const { return at<1>().as_uint64(); } _ZNK8perfetto6protos6pbzero30TraceStats_BufferStats_Decoder17bytes_overwrittenEv: 678| 59| uint64_t bytes_overwritten() const { return at<13>().as_uint64(); } _ZNK8perfetto6protos6pbzero30TraceStats_BufferStats_Decoder10bytes_readEv: 680| 59| uint64_t bytes_read() const { return at<14>().as_uint64(); } _ZNK8perfetto6protos6pbzero30TraceStats_BufferStats_Decoder21padding_bytes_writtenEv: 682| 59| uint64_t padding_bytes_written() const { return at<15>().as_uint64(); } _ZNK8perfetto6protos6pbzero30TraceStats_BufferStats_Decoder21padding_bytes_clearedEv: 684| 59| uint64_t padding_bytes_cleared() const { return at<16>().as_uint64(); } _ZNK8perfetto6protos6pbzero30TraceStats_BufferStats_Decoder14chunks_writtenEv: 686| 59| uint64_t chunks_written() const { return at<2>().as_uint64(); } _ZNK8perfetto6protos6pbzero30TraceStats_BufferStats_Decoder16chunks_rewrittenEv: 688| 59| uint64_t chunks_rewritten() const { return at<10>().as_uint64(); } _ZNK8perfetto6protos6pbzero30TraceStats_BufferStats_Decoder18chunks_overwrittenEv: 690| 59| uint64_t chunks_overwritten() const { return at<3>().as_uint64(); } _ZNK8perfetto6protos6pbzero30TraceStats_BufferStats_Decoder16chunks_discardedEv: 692| 59| uint64_t chunks_discarded() const { return at<18>().as_uint64(); } _ZNK8perfetto6protos6pbzero30TraceStats_BufferStats_Decoder11chunks_readEv: 694| 59| uint64_t chunks_read() const { return at<17>().as_uint64(); } _ZNK8perfetto6protos6pbzero30TraceStats_BufferStats_Decoder29chunks_committed_out_of_orderEv: 696| 59| uint64_t chunks_committed_out_of_order() const { return at<11>().as_uint64(); } _ZNK8perfetto6protos6pbzero30TraceStats_BufferStats_Decoder16write_wrap_countEv: 698| 59| uint64_t write_wrap_count() const { return at<4>().as_uint64(); } _ZNK8perfetto6protos6pbzero30TraceStats_BufferStats_Decoder17patches_succeededEv: 700| 59| uint64_t patches_succeeded() const { return at<5>().as_uint64(); } _ZNK8perfetto6protos6pbzero30TraceStats_BufferStats_Decoder14patches_failedEv: 702| 59| uint64_t patches_failed() const { return at<6>().as_uint64(); } _ZNK8perfetto6protos6pbzero30TraceStats_BufferStats_Decoder20readaheads_succeededEv: 704| 59| uint64_t readaheads_succeeded() const { return at<7>().as_uint64(); } _ZNK8perfetto6protos6pbzero30TraceStats_BufferStats_Decoder17readaheads_failedEv: 706| 59| uint64_t readaheads_failed() const { return at<8>().as_uint64(); } _ZNK8perfetto6protos6pbzero30TraceStats_BufferStats_Decoder14abi_violationsEv: 708| 59| uint64_t abi_violations() const { return at<9>().as_uint64(); } _ZNK8perfetto6protos6pbzero30TraceStats_BufferStats_Decoder24trace_writer_packet_lossEv: 710| 59| uint64_t trace_writer_packet_loss() const { return at<19>().as_uint64(); } _ZNK8perfetto6protos6pbzero18TraceStats_Decoder12writer_statsEv: 72| 24| ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> writer_stats() const { return GetRepeated<::protozero::ConstBytes>(18); } _ZN8perfetto6protos6pbzero19TraceConfig_DecoderC2ERKN9protozero10ConstBytesE: 258| 3.28k| explicit TraceConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} _ZNK8perfetto6protos6pbzero19TraceConfig_Decoder7buffersEv: 260| 475| ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> buffers() const { return GetRepeated<::protozero::ConstBytes>(1); } _ZNK8perfetto6protos6pbzero19TraceConfig_Decoder15write_into_fileEv: 278| 2.18k| bool write_into_file() const { return at<8>().as_bool(); } _ZNK8perfetto6protos6pbzero19TraceConfig_Decoder15flush_period_msEv: 290| 475| uint32_t flush_period_ms() const { return at<13>().as_uint32(); } _ZN8perfetto6protos6pbzero32TraceConfig_BufferConfig_DecoderC2ERKN9protozero10ConstBytesE: 2398| 534| explicit TraceConfig_BufferConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} _ZNK8perfetto6protos6pbzero32TraceConfig_BufferConfig_Decoder11fill_policyEv: 2402| 534| int32_t fill_policy() const { return at<4>().as_int32(); } _ZN8perfetto6protos6pbzero31ChromeBenchmarkMetadata_DecoderC2EPKhm: 22| 1.29k| ChromeBenchmarkMetadata_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} _ZNK8perfetto6protos6pbzero31ChromeBenchmarkMetadata_Decoder18has_benchmark_nameEv: 29| 1.29k| bool has_benchmark_name() const { return at<3>().valid(); } _ZNK8perfetto6protos6pbzero31ChromeBenchmarkMetadata_Decoder14benchmark_nameEv: 30| 66| ::protozero::ConstChars benchmark_name() const { return at<3>().as_string(); } _ZNK8perfetto6protos6pbzero31ChromeBenchmarkMetadata_Decoder25has_benchmark_descriptionEv: 31| 1.29k| bool has_benchmark_description() const { return at<4>().valid(); } _ZNK8perfetto6protos6pbzero31ChromeBenchmarkMetadata_Decoder21benchmark_descriptionEv: 32| 640| ::protozero::ConstChars benchmark_description() const { return at<4>().as_string(); } _ZNK8perfetto6protos6pbzero31ChromeBenchmarkMetadata_Decoder9has_labelEv: 33| 1.29k| bool has_label() const { return at<5>().valid(); } _ZNK8perfetto6protos6pbzero31ChromeBenchmarkMetadata_Decoder14has_story_nameEv: 35| 1.29k| bool has_story_name() const { return at<6>().valid(); } _ZNK8perfetto6protos6pbzero31ChromeBenchmarkMetadata_Decoder10story_nameEv: 36| 64| ::protozero::ConstChars story_name() const { return at<6>().as_string(); } _ZNK8perfetto6protos6pbzero31ChromeBenchmarkMetadata_Decoder10story_tagsEv: 38| 1.29k| ::protozero::RepeatedFieldIterator<::protozero::ConstChars> story_tags() const { return GetRepeated<::protozero::ConstChars>(7); } _ZNK8perfetto6protos6pbzero31ChromeBenchmarkMetadata_Decoder27has_benchmark_start_time_usEv: 25| 1.29k| bool has_benchmark_start_time_us() const { return at<1>().valid(); } _ZNK8perfetto6protos6pbzero31ChromeBenchmarkMetadata_Decoder23benchmark_start_time_usEv: 26| 136| int64_t benchmark_start_time_us() const { return at<1>().as_int64(); } _ZNK8perfetto6protos6pbzero31ChromeBenchmarkMetadata_Decoder21has_story_run_time_usEv: 27| 1.29k| bool has_story_run_time_us() const { return at<2>().valid(); } _ZNK8perfetto6protos6pbzero31ChromeBenchmarkMetadata_Decoder17story_run_time_usEv: 28| 441| int64_t story_run_time_us() const { return at<2>().as_int64(); } _ZNK8perfetto6protos6pbzero31ChromeBenchmarkMetadata_Decoder19has_story_run_indexEv: 39| 1.29k| bool has_story_run_index() const { return at<8>().valid(); } _ZNK8perfetto6protos6pbzero31ChromeBenchmarkMetadata_Decoder15story_run_indexEv: 40| 375| int32_t story_run_index() const { return at<8>().as_int32(); } _ZNK8perfetto6protos6pbzero31ChromeBenchmarkMetadata_Decoder16has_had_failuresEv: 41| 1.29k| bool has_had_failures() const { return at<9>().valid(); } _ZN8perfetto6protos6pbzero28ChromeMetadataPacket_DecoderC2EPKhm: 438| 7| ChromeMetadataPacket_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} _ZNK8perfetto6protos6pbzero28ChromeMetadataPacket_Decoder23has_chrome_version_codeEv: 443| 7| bool has_chrome_version_code() const { return at<2>().valid(); } _ZNK8perfetto6protos6pbzero28ChromeMetadataPacket_Decoder19chrome_version_codeEv: 444| 7| int32_t chrome_version_code() const { return at<2>().as_int32(); } _ZNK8perfetto6protos6pbzero28ChromeMetadataPacket_Decoder22has_enabled_categoriesEv: 445| 7| bool has_enabled_categories() const { return at<3>().valid(); } _ZNK8perfetto6protos6pbzero28ChromeMetadataPacket_Decoder22has_field_trial_hashesEv: 447| 7| bool has_field_trial_hashes() const { return at<4>().valid(); } _ZNK8perfetto6protos6pbzero28ChromeMetadataPacket_Decoder18field_trial_hashesEv: 448| 7| ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> field_trial_hashes() const { return GetRepeated<::protozero::ConstBytes>(4); } _ZN8perfetto6protos6pbzero38ChromeMetadataPacket_FinchHash_DecoderC2ERKN9protozero10ConstBytesE: 539| 24| explicit ChromeMetadataPacket_FinchHash_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} _ZNK8perfetto6protos6pbzero38ChromeMetadataPacket_FinchHash_Decoder4nameEv: 541| 24| uint32_t name() const { return at<1>().as_uint32(); } _ZNK8perfetto6protos6pbzero38ChromeMetadataPacket_FinchHash_Decoder5groupEv: 543| 24| uint32_t group() const { return at<2>().as_uint32(); } _ZNK8perfetto6protos6pbzero28ChromeMetadataPacket_Decoder31has_background_tracing_metadataEv: 441| 7| bool has_background_tracing_metadata() const { return at<1>().valid(); } _ZNK8perfetto6protos6pbzero28ChromeMetadataPacket_Decoder27background_tracing_metadataEv: 442| 7| ::protozero::ConstBytes background_tracing_metadata() const { return at<1>().as_bytes(); } _ZN8perfetto6protos6pbzero33BackgroundTracingMetadata_DecoderC2EPKhm: 115| 7| BackgroundTracingMetadata_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} _ZNK8perfetto6protos6pbzero33BackgroundTracingMetadata_Decoder22has_scenario_name_hashEv: 122| 7| bool has_scenario_name_hash() const { return at<3>().valid(); } _ZNK8perfetto6protos6pbzero33BackgroundTracingMetadata_Decoder14triggered_ruleEv: 119| 7| ::protozero::ConstBytes triggered_rule() const { return at<1>().as_bytes(); } _ZNK8perfetto6protos6pbzero33BackgroundTracingMetadata_Decoder18has_triggered_ruleEv: 118| 7| bool has_triggered_rule() const { return at<1>().valid(); } _ZN8perfetto6protos6pbzero45BackgroundTracingMetadata_TriggerRule_DecoderC2EPKhm: 187| 2| BackgroundTracingMetadata_TriggerRule_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} _ZN8perfetto6protos6pbzero25ChromeEventBundle_DecoderC2ERKN9protozero10ConstBytesE: 94| 110k| explicit ChromeEventBundle_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} _ZNK8perfetto6protos6pbzero25ChromeEventBundle_Decoder12has_metadataEv: 97| 110k| bool has_metadata() const { return at<2>().valid(); } _ZNK8perfetto6protos6pbzero25ChromeEventBundle_Decoder8metadataEv: 98| 31.2k| ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> metadata() const { return GetRepeated<::protozero::ConstBytes>(2); } _ZN8perfetto6protos6pbzero22ChromeMetadata_DecoderC2ERKN9protozero10ConstBytesE: 276| 57.2k| explicit ChromeMetadata_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} _ZNK8perfetto6protos6pbzero22ChromeMetadata_Decoder16has_string_valueEv: 279| 57.2k| bool has_string_value() const { return at<2>().valid(); } _ZNK8perfetto6protos6pbzero22ChromeMetadata_Decoder12string_valueEv: 280| 1.75k| ::protozero::ConstChars string_value() const { return at<2>().as_string(); } _ZNK8perfetto6protos6pbzero22ChromeMetadata_Decoder13has_int_valueEv: 283| 55.5k| bool has_int_value() const { return at<4>().valid(); } _ZNK8perfetto6protos6pbzero22ChromeMetadata_Decoder9int_valueEv: 284| 12.6k| int64_t int_value() const { return at<4>().as_int64(); } _ZNK8perfetto6protos6pbzero22ChromeMetadata_Decoder14has_bool_valueEv: 281| 42.9k| bool has_bool_value() const { return at<3>().valid(); } _ZNK8perfetto6protos6pbzero22ChromeMetadata_Decoder10bool_valueEv: 282| 464| bool bool_value() const { return at<3>().as_bool(); } _ZNK8perfetto6protos6pbzero22ChromeMetadata_Decoder14has_json_valueEv: 285| 42.4k| bool has_json_value() const { return at<5>().valid(); } _ZNK8perfetto6protos6pbzero22ChromeMetadata_Decoder10json_valueEv: 286| 11.6k| ::protozero::ConstChars json_value() const { return at<5>().as_string(); } _ZNK8perfetto6protos6pbzero22ChromeMetadata_Decoder4nameEv: 278| 53.0k| ::protozero::ConstChars name() const { return at<1>().as_string(); } _ZNK8perfetto6protos6pbzero25ChromeEventBundle_Decoder24has_legacy_ftrace_outputEv: 99| 110k| bool has_legacy_ftrace_output() const { return at<4>().valid(); } _ZNK8perfetto6protos6pbzero25ChromeEventBundle_Decoder20legacy_ftrace_outputEv: 100| 53.7k| ::protozero::RepeatedFieldIterator<::protozero::ConstChars> legacy_ftrace_output() const { return GetRepeated<::protozero::ConstChars>(4); } _ZNK8perfetto6protos6pbzero25ChromeEventBundle_Decoder21has_legacy_json_traceEv: 101| 110k| bool has_legacy_json_trace() const { return at<5>().valid(); } _ZNK8perfetto6protos6pbzero25ChromeEventBundle_Decoder17legacy_json_traceEv: 102| 100k| ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> legacy_json_trace() const { return GetRepeated<::protozero::ConstBytes>(5); } _ZN8perfetto6protos6pbzero29ChromeLegacyJsonTrace_DecoderC2ERKN9protozero10ConstBytesE: 205| 1.31M| explicit ChromeLegacyJsonTrace_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} _ZNK8perfetto6protos6pbzero29ChromeLegacyJsonTrace_Decoder4typeEv: 207| 1.31M| int32_t type() const { return at<1>().as_int32(); } _ZNK8perfetto6protos6pbzero29ChromeLegacyJsonTrace_Decoder4dataEv: 209| 1.31M| ::protozero::ConstChars data() const { return at<2>().as_string(); } _ZN8perfetto6protos6pbzero21ClockSnapshot_DecoderC2EPKhm: 79| 21.1k| ClockSnapshot_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} _ZNK8perfetto6protos6pbzero21ClockSnapshot_Decoder6clocksEv: 83| 21.1k| ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> clocks() const { return GetRepeated<::protozero::ConstBytes>(1); } _ZNK8perfetto6protos6pbzero21ClockSnapshot_Decoder19primary_trace_clockEv: 85| 28.4k| int32_t primary_trace_clock() const { return at<2>().as_int32(); } _ZN8perfetto6protos6pbzero27ClockSnapshot_Clock_DecoderC2ERKN9protozero10ConstBytesE: 136| 60.9k| explicit ClockSnapshot_Clock_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} _ZNK8perfetto6protos6pbzero27ClockSnapshot_Clock_Decoder8clock_idEv: 138| 124k| uint32_t clock_id() const { return at<1>().as_uint32(); } _ZNK8perfetto6protos6pbzero27ClockSnapshot_Clock_Decoder9timestampEv: 140| 60.9k| uint64_t timestamp() const { return at<2>().as_uint64(); } _ZNK8perfetto6protos6pbzero27ClockSnapshot_Clock_Decoder14is_incrementalEv: 142| 60.9k| bool is_incremental() const { return at<3>().as_bool(); } _ZNK8perfetto6protos6pbzero27ClockSnapshot_Clock_Decoder18unit_multiplier_nsEv: 144| 60.9k| uint64_t unit_multiplier_ns() const { return at<4>().as_uint64(); } _ZN8perfetto6protos6pbzero27ExtensionDescriptor_DecoderC2EPKhm: 29| 1.78k| ExtensionDescriptor_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} _ZNK8perfetto6protos6pbzero27ExtensionDescriptor_Decoder13extension_setEv: 33| 1.78k| ::protozero::ConstBytes extension_set() const { return at<1>().as_bytes(); } _ZN8perfetto6protos6pbzero29MemoryTrackerSnapshot_DecoderC2ERKN9protozero10ConstBytesE: 100| 60.7k| explicit MemoryTrackerSnapshot_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} _ZNK8perfetto6protos6pbzero29MemoryTrackerSnapshot_Decoder15level_of_detailEv: 104| 60.7k| int32_t level_of_detail() const { return at<2>().as_int32(); } _ZNK8perfetto6protos6pbzero29MemoryTrackerSnapshot_Decoder20process_memory_dumpsEv: 106| 60.7k| ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> process_memory_dumps() const { return GetRepeated<::protozero::ConstBytes>(3); } _ZN8perfetto6protos6pbzero45MemoryTrackerSnapshot_ProcessSnapshot_DecoderC2ERKN9protozero10ConstBytesE: 184| 58.5k| explicit MemoryTrackerSnapshot_ProcessSnapshot_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} _ZNK8perfetto6protos6pbzero45MemoryTrackerSnapshot_ProcessSnapshot_Decoder3pidEv: 186| 58.5k| int32_t pid() const { return at<1>().as_int32(); } _ZNK8perfetto6protos6pbzero45MemoryTrackerSnapshot_ProcessSnapshot_Decoder15allocator_dumpsEv: 188| 58.5k| ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> allocator_dumps() const { return GetRepeated<::protozero::ConstBytes>(2); } _ZNK8perfetto6protos6pbzero45MemoryTrackerSnapshot_ProcessSnapshot_Decoder12memory_edgesEv: 190| 58.5k| ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> memory_edges() const { return GetRepeated<::protozero::ConstBytes>(3); } _ZN8perfetto6protos6pbzero56MemoryTrackerSnapshot_ProcessSnapshot_MemoryEdge_DecoderC2ERKN9protozero10ConstBytesE: 257| 54.3k| explicit MemoryTrackerSnapshot_ProcessSnapshot_MemoryEdge_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} _ZNK8perfetto6protos6pbzero56MemoryTrackerSnapshot_ProcessSnapshot_MemoryEdge_Decoder9source_idEv: 259| 108k| uint64_t source_id() const { return at<1>().as_uint64(); } _ZNK8perfetto6protos6pbzero56MemoryTrackerSnapshot_ProcessSnapshot_MemoryEdge_Decoder9target_idEv: 261| 54.3k| uint64_t target_id() const { return at<2>().as_uint64(); } _ZNK8perfetto6protos6pbzero56MemoryTrackerSnapshot_ProcessSnapshot_MemoryEdge_Decoder10importanceEv: 263| 54.3k| uint32_t importance() const { return at<3>().as_uint32(); } _ZNK8perfetto6protos6pbzero56MemoryTrackerSnapshot_ProcessSnapshot_MemoryEdge_Decoder11overridableEv: 265| 54.3k| bool overridable() const { return at<4>().as_bool(); } _ZN8perfetto6protos6pbzero56MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_DecoderC2ERKN9protozero10ConstBytesE: 357| 38.5k| explicit MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} _ZNK8perfetto6protos6pbzero56MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_Decoder2idEv: 359| 38.5k| uint64_t id() const { return at<1>().as_uint64(); } _ZNK8perfetto6protos6pbzero56MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_Decoder13absolute_nameEv: 361| 38.5k| ::protozero::ConstChars absolute_name() const { return at<2>().as_string(); } _ZNK8perfetto6protos6pbzero56MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_Decoder4weakEv: 363| 38.5k| bool weak() const { return at<3>().as_bool(); } _ZNK8perfetto6protos6pbzero56MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_Decoder14has_size_bytesEv: 364| 38.5k| bool has_size_bytes() const { return at<4>().valid(); } _ZNK8perfetto6protos6pbzero56MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_Decoder10size_bytesEv: 365| 4.20k| uint64_t size_bytes() const { return at<4>().as_uint64(); } _ZNK8perfetto6protos6pbzero56MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_Decoder7entriesEv: 367| 38.5k| ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> entries() const { return GetRepeated<::protozero::ConstBytes>(5); } _ZN8perfetto6protos6pbzero72MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry_DecoderC2ERKN9protozero10ConstBytesE: 481| 25.8k| explicit MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} _ZNK8perfetto6protos6pbzero72MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry_Decoder4nameEv: 483| 4.52k| ::protozero::ConstChars name() const { return at<1>().as_string(); } _ZNK8perfetto6protos6pbzero72MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry_Decoder5unitsEv: 485| 25.8k| int32_t units() const { return at<2>().as_int32(); } _ZNK8perfetto6protos6pbzero72MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry_Decoder16has_value_uint64Ev: 486| 25.8k| bool has_value_uint64() const { return at<3>().valid(); } _ZNK8perfetto6protos6pbzero72MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry_Decoder12value_uint64Ev: 487| 4.52k| uint64_t value_uint64() const { return at<3>().as_uint64(); } _ZNK8perfetto6protos6pbzero72MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry_Decoder16has_value_stringEv: 488| 21.3k| bool has_value_string() const { return at<4>().valid(); } _ZN8perfetto6protos6pbzero25PerfettoMetatrace_DecoderC2ERKN9protozero10ConstBytesE: 32| 287k| explicit PerfettoMetatrace_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} _ZNK8perfetto6protos6pbzero25PerfettoMetatrace_Decoder9thread_idEv: 48| 287k| uint32_t thread_id() const { return at<5>().as_uint32(); } _ZNK8perfetto6protos6pbzero25PerfettoMetatrace_Decoder16interned_stringsEv: 54| 287k| ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> interned_strings() const { return GetRepeated<::protozero::ConstBytes>(10); } _ZN8perfetto6protos6pbzero40PerfettoMetatrace_InternedString_DecoderC2EPKhm: 283| 37.5k| PerfettoMetatrace_InternedString_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} _ZNK8perfetto6protos6pbzero40PerfettoMetatrace_InternedString_Decoder3iidEv: 287| 37.5k| uint64_t iid() const { return at<1>().as_uint64(); } _ZNK8perfetto6protos6pbzero40PerfettoMetatrace_InternedString_Decoder5valueEv: 289| 37.5k| ::protozero::ConstChars value() const { return at<2>().as_string(); } _ZNK8perfetto6protos6pbzero25PerfettoMetatrace_Decoder12has_event_idEv: 33| 292k| bool has_event_id() const { return at<1>().valid(); } _ZNK8perfetto6protos6pbzero25PerfettoMetatrace_Decoder14has_event_nameEv: 37| 282k| bool has_event_name() const { return at<8>().valid(); } _ZNK8perfetto6protos6pbzero25PerfettoMetatrace_Decoder18has_event_name_iidEv: 39| 282k| bool has_event_name_iid() const { return at<11>().valid(); } _ZNK8perfetto6protos6pbzero25PerfettoMetatrace_Decoder8event_idEv: 34| 4.92k| uint32_t event_id() const { return at<1>().as_uint32(); } _ZNK8perfetto6protos6pbzero25PerfettoMetatrace_Decoder14event_name_iidEv: 40| 3| uint64_t event_name_iid() const { return at<11>().as_uint64(); } _ZNK8perfetto6protos6pbzero25PerfettoMetatrace_Decoder10event_nameEv: 38| 614| ::protozero::ConstChars event_name() const { return at<8>().as_string(); } _ZNK8perfetto6protos6pbzero25PerfettoMetatrace_Decoder17event_duration_nsEv: 44| 5.54k| uint64_t event_duration_ns() const { return at<3>().as_uint64(); } _ZNK8perfetto6protos6pbzero25PerfettoMetatrace_Decoder14has_counter_idEv: 35| 560k| bool has_counter_id() const { return at<2>().valid(); } _ZNK8perfetto6protos6pbzero25PerfettoMetatrace_Decoder16has_counter_nameEv: 41| 2.34k| bool has_counter_name() const { return at<9>().valid(); } _ZNK8perfetto6protos6pbzero25PerfettoMetatrace_Decoder10counter_idEv: 36| 279k| uint32_t counter_id() const { return at<2>().as_uint32(); } _ZNK8perfetto6protos6pbzero25PerfettoMetatrace_Decoder12counter_nameEv: 42| 34| ::protozero::ConstChars counter_name() const { return at<9>().as_string(); } _ZNK8perfetto6protos6pbzero25PerfettoMetatrace_Decoder13counter_valueEv: 46| 279k| int32_t counter_value() const { return at<4>().as_int32(); } _ZNK8perfetto6protos6pbzero25PerfettoMetatrace_Decoder4argsEv: 52| 284k| ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> args() const { return GetRepeated<::protozero::ConstBytes>(7); } _ZN8perfetto6protos6pbzero29PerfettoMetatrace_Arg_DecoderC2ERKN9protozero10ConstBytesE: 349| 3.97M| explicit PerfettoMetatrace_Arg_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} _ZNK8perfetto6protos6pbzero29PerfettoMetatrace_Arg_Decoder11has_key_iidEv: 352| 3.97M| bool has_key_iid() const { return at<3>().valid(); } _ZNK8perfetto6protos6pbzero29PerfettoMetatrace_Arg_Decoder7key_iidEv: 353| 15| uint64_t key_iid() const { return at<3>().as_uint64(); } _ZNK8perfetto6protos6pbzero29PerfettoMetatrace_Arg_Decoder3keyEv: 351| 3.97M| ::protozero::ConstChars key() const { return at<1>().as_string(); } _ZNK8perfetto6protos6pbzero29PerfettoMetatrace_Arg_Decoder13has_value_iidEv: 356| 3.97M| bool has_value_iid() const { return at<4>().valid(); } _ZNK8perfetto6protos6pbzero29PerfettoMetatrace_Arg_Decoder9value_iidEv: 357| 45| uint64_t value_iid() const { return at<4>().as_uint64(); } _ZNK8perfetto6protos6pbzero29PerfettoMetatrace_Arg_Decoder5valueEv: 355| 3.97M| ::protozero::ConstChars value() const { return at<2>().as_string(); } _ZNK8perfetto6protos6pbzero25PerfettoMetatrace_Decoder12has_overrunsEv: 50| 287k| bool has_overruns() const { return at<6>().as_bool(); } _ZN8perfetto6protos6pbzero27TracingServiceEvent_DecoderC2ERKN9protozero10ConstBytesE: 32| 34.7k| explicit TracingServiceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} _ZNK8perfetto6protos6pbzero27TracingServiceEvent_Decoder15tracing_startedEv: 34| 34.7k| bool tracing_started() const { return at<2>().as_bool(); } _ZNK8perfetto6protos6pbzero27TracingServiceEvent_Decoder16tracing_disabledEv: 44| 34.7k| bool tracing_disabled() const { return at<5>().as_bool(); } _ZNK8perfetto6protos6pbzero27TracingServiceEvent_Decoder24all_data_sources_startedEv: 36| 34.7k| bool all_data_sources_started() const { return at<1>().as_bool(); } _ZNK8perfetto6protos6pbzero27TracingServiceEvent_Decoder24all_data_sources_flushedEv: 40| 34.7k| bool all_data_sources_flushed() const { return at<3>().as_bool(); } _ZNK8perfetto6protos6pbzero27TracingServiceEvent_Decoder30read_tracing_buffers_completedEv: 42| 34.7k| bool read_tracing_buffers_completed() const { return at<4>().as_bool(); } _ZNK8perfetto6protos6pbzero27TracingServiceEvent_Decoder30has_slow_starting_data_sourcesEv: 47| 34.7k| bool has_slow_starting_data_sources() const { return at<7>().valid(); } _ZNK8perfetto6protos6pbzero27TracingServiceEvent_Decoder26slow_starting_data_sourcesEv: 48| 11| ::protozero::ConstBytes slow_starting_data_sources() const { return at<7>().as_bytes(); } _ZN8perfetto6protos6pbzero39TracingServiceEvent_DataSources_DecoderC2ERKN9protozero10ConstBytesE: 272| 11| explicit TracingServiceEvent_DataSources_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} _ZNK8perfetto6protos6pbzero39TracingServiceEvent_DataSources_Decoder11data_sourceEv: 274| 11| ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> data_source() const { return GetRepeated<::protozero::ConstBytes>(1); } _ZNK8perfetto6protos6pbzero27TracingServiceEvent_Decoder17has_clone_startedEv: 51| 34.7k| bool has_clone_started() const { return at<10>().valid(); } _ZNK8perfetto6protos6pbzero27TracingServiceEvent_Decoder17has_buffer_clonedEv: 53| 34.7k| bool has_buffer_cloned() const { return at<11>().valid(); } _ZNK8perfetto6protos6pbzero27TracingServiceEvent_Decoder13buffer_clonedEv: 54| 29| uint32_t buffer_cloned() const { return at<11>().as_uint32(); } _ZN8perfetto6protos6pbzero20ProcessStats_DecoderC2ERKN9protozero10ConstBytesE: 33| 6.75k| explicit ProcessStats_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} _ZNK8perfetto6protos6pbzero20ProcessStats_Decoder9processesEv: 35| 6.75k| ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> processes() const { return GetRepeated<::protozero::ConstBytes>(1); } _ZN8perfetto6protos6pbzero19TracePacket_DecoderC2EPKhm: 138| 14.1M| TracePacket_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} _ZNK8perfetto6protos6pbzero19TracePacket_Decoder13has_timestampEv: 141| 4.90M| bool has_timestamp() const { return at<8>().valid(); } _ZNK8perfetto6protos6pbzero19TracePacket_Decoder9timestampEv: 142| 2.92M| uint64_t timestamp() const { return at<8>().as_uint64(); } _ZNK8perfetto6protos6pbzero19TracePacket_Decoder22has_timestamp_clock_idEv: 143| 2.88M| bool has_timestamp_clock_id() const { return at<58>().valid(); } _ZNK8perfetto6protos6pbzero19TracePacket_Decoder18timestamp_clock_idEv: 144| 2| uint32_t timestamp_clock_id() const { return at<58>().as_uint32(); } _ZNK8perfetto6protos6pbzero19TracePacket_Decoder13process_statsEv: 148| 6.75k| ::protozero::ConstBytes process_stats() const { return at<9>().as_bytes(); } _ZNK8perfetto6protos6pbzero19TracePacket_Decoder17has_chrome_eventsEv: 151| 4.07M| bool has_chrome_events() const { return at<5>().valid(); } _ZNK8perfetto6protos6pbzero19TracePacket_Decoder13chrome_eventsEv: 152| 110k| ::protozero::ConstBytes chrome_events() const { return at<5>().as_bytes(); } _ZNK8perfetto6protos6pbzero19TracePacket_Decoder18has_clock_snapshotEv: 153| 3.98M| bool has_clock_snapshot() const { return at<6>().valid(); } _ZNK8perfetto6protos6pbzero19TracePacket_Decoder14clock_snapshotEv: 154| 21.1k| ::protozero::ConstBytes clock_snapshot() const { return at<6>().as_bytes(); } _ZNK8perfetto6protos6pbzero19TracePacket_Decoder11track_eventEv: 158| 1.87M| ::protozero::ConstBytes track_event() const { return at<11>().as_bytes(); } _ZNK8perfetto6protos6pbzero19TracePacket_Decoder16has_trace_configEv: 161| 5.10M| bool has_trace_config() const { return at<33>().valid(); } _ZNK8perfetto6protos6pbzero19TracePacket_Decoder12trace_configEv: 162| 3.28k| ::protozero::ConstBytes trace_config() const { return at<33>().as_bytes(); } _ZNK8perfetto6protos6pbzero19TracePacket_Decoder15has_trace_statsEv: 165| 3.96M| bool has_trace_stats() const { return at<35>().valid(); } _ZNK8perfetto6protos6pbzero19TracePacket_Decoder11trace_statsEv: 166| 24| ::protozero::ConstBytes trace_stats() const { return at<35>().as_bytes(); } _ZNK8perfetto6protos6pbzero19TracePacket_Decoder25chrome_benchmark_metadataEv: 188| 1.29k| ::protozero::ConstBytes chrome_benchmark_metadata() const { return at<48>().as_bytes(); } _ZNK8perfetto6protos6pbzero19TracePacket_Decoder22has_perfetto_metatraceEv: 189| 1.18M| bool has_perfetto_metatrace() const { return at<49>().valid(); } _ZNK8perfetto6protos6pbzero19TracePacket_Decoder18perfetto_metatraceEv: 190| 287k| ::protozero::ConstBytes perfetto_metatrace() const { return at<49>().as_bytes(); } _ZNK8perfetto6protos6pbzero19TracePacket_Decoder19has_chrome_metadataEv: 191| 2.88M| bool has_chrome_metadata() const { return at<51>().valid(); } _ZNK8perfetto6protos6pbzero19TracePacket_Decoder15chrome_metadataEv: 192| 7| ::protozero::ConstBytes chrome_metadata() const { return at<51>().as_bytes(); } _ZNK8perfetto6protos6pbzero19TracePacket_Decoder17has_service_eventEv: 215| 3.96M| bool has_service_event() const { return at<69>().valid(); } _ZNK8perfetto6protos6pbzero19TracePacket_Decoder13service_eventEv: 216| 34.7k| ::protozero::ConstBytes service_event() const { return at<69>().as_bytes(); } _ZNK8perfetto6protos6pbzero19TracePacket_Decoder23memory_tracker_snapshotEv: 222| 60.7k| ::protozero::ConstBytes memory_tracker_snapshot() const { return at<73>().as_bytes(); } _ZNK8perfetto6protos6pbzero19TracePacket_Decoder16track_descriptorEv: 248| 248k| ::protozero::ConstBytes track_descriptor() const { return at<60>().as_bytes(); } _ZNK8perfetto6protos6pbzero19TracePacket_Decoder18process_descriptorEv: 250| 20.4k| ::protozero::ConstBytes process_descriptor() const { return at<43>().as_bytes(); } _ZNK8perfetto6protos6pbzero19TracePacket_Decoder17thread_descriptorEv: 252| 46| ::protozero::ConstBytes thread_descriptor() const { return at<44>().as_bytes(); } _ZNK8perfetto6protos6pbzero19TracePacket_Decoder22has_compressed_packetsEv: 257| 7.97M| bool has_compressed_packets() const { return at<50>().valid(); } _ZNK8perfetto6protos6pbzero19TracePacket_Decoder18compressed_packetsEv: 258| 159| ::protozero::ConstBytes compressed_packets() const { return at<50>().as_bytes(); } _ZNK8perfetto6protos6pbzero19TracePacket_Decoder24has_extension_descriptorEv: 259| 3.93M| bool has_extension_descriptor() const { return at<72>().valid(); } _ZNK8perfetto6protos6pbzero19TracePacket_Decoder20extension_descriptorEv: 260| 1.78k| ::protozero::ConstBytes extension_descriptor() const { return at<72>().as_bytes(); } _ZNK8perfetto6protos6pbzero19TracePacket_Decoder21has_remote_clock_syncEv: 293| 3.96M| bool has_remote_clock_sync() const { return at<107>().valid(); } _ZNK8perfetto6protos6pbzero19TracePacket_Decoder30has_trusted_packet_sequence_idEv: 311| 5.15M| bool has_trusted_packet_sequence_id() const { return at<10>().valid(); } _ZNK8perfetto6protos6pbzero19TracePacket_Decoder26trusted_packet_sequence_idEv: 312| 10.9M| uint32_t trusted_packet_sequence_id() const { return at<10>().as_uint32(); } _ZNK8perfetto6protos6pbzero19TracePacket_Decoder15has_trusted_pidEv: 313| 130k| bool has_trusted_pid() const { return at<79>().valid(); } _ZNK8perfetto6protos6pbzero19TracePacket_Decoder11trusted_pidEv: 314| 1.04k| int32_t trusted_pid() const { return at<79>().as_int32(); } _ZNK8perfetto6protos6pbzero19TracePacket_Decoder17has_interned_dataEv: 315| 3.98M| bool has_interned_data() const { return at<12>().valid(); } _ZNK8perfetto6protos6pbzero19TracePacket_Decoder13interned_dataEv: 316| 18.3k| ::protozero::ConstBytes interned_data() const { return at<12>().as_bytes(); } _ZNK8perfetto6protos6pbzero19TracePacket_Decoder14sequence_flagsEv: 318| 7.91M| uint32_t sequence_flags() const { return at<13>().as_uint32(); } _ZNK8perfetto6protos6pbzero19TracePacket_Decoder25incremental_state_clearedEv: 320| 3.98M| bool incremental_state_cleared() const { return at<41>().as_bool(); } _ZNK8perfetto6protos6pbzero19TracePacket_Decoder25has_trace_packet_defaultsEv: 321| 3.98M| bool has_trace_packet_defaults() const { return at<59>().valid(); } _ZNK8perfetto6protos6pbzero19TracePacket_Decoder21trace_packet_defaultsEv: 322| 815| ::protozero::ConstBytes trace_packet_defaults() const { return at<59>().as_bytes(); } _ZNK8perfetto6protos6pbzero19TracePacket_Decoder23previous_packet_droppedEv: 324| 5.01M| bool previous_packet_dropped() const { return at<42>().as_bool(); } _ZNK8perfetto6protos6pbzero19TracePacket_Decoder24first_packet_on_sequenceEv: 326| 3.98M| bool first_packet_on_sequence() const { return at<87>().as_bool(); } _ZNK8perfetto6protos6pbzero19TracePacket_Decoder14has_machine_idEv: 327| 3.98M| bool has_machine_id() const { return at<98>().valid(); } _ZNK8perfetto6protos6pbzero19TracePacket_Decoder10machine_idEv: 328| 1.60k| uint32_t machine_id() const { return at<98>().as_uint32(); } _ZN8perfetto6protos6pbzero27TracePacketDefaults_DecoderC2EPKhm: 31| 814| TracePacketDefaults_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} _ZNK8perfetto6protos6pbzero27TracePacketDefaults_Decoder18timestamp_clock_idEv: 35| 51.0k| uint32_t timestamp_clock_id() const { return at<58>().as_uint32(); } _ZN8perfetto6protos6pbzero29ChromeActiveProcesses_DecoderC2ERKN9protozero10ConstBytesE: 24| 26.3k| explicit ChromeActiveProcesses_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} _ZNK8perfetto6protos6pbzero29ChromeActiveProcesses_Decoder3pidEv: 26| 26.3k| ::protozero::RepeatedFieldIterator pid() const { return GetRepeated(1); } _ZN8perfetto6protos6pbzero29ChromeHistogramSample_DecoderC2ERKN9protozero10ConstBytesE: 24| 526k| explicit ChromeHistogramSample_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} _ZNK8perfetto6protos6pbzero29ChromeHistogramSample_Decoder12has_name_iidEv: 31| 526k| bool has_name_iid() const { return at<4>().valid(); } _ZNK8perfetto6protos6pbzero29ChromeHistogramSample_Decoder8has_nameEv: 27| 43.5k| bool has_name() const { return at<2>().valid(); } _ZNK8perfetto6protos6pbzero29ChromeHistogramSample_Decoder8name_iidEv: 32| 43.1k| uint64_t name_iid() const { return at<4>().as_uint64(); } _ZN8perfetto6protos6pbzero31ChromeProcessDescriptor_DecoderC2ERKN9protozero10ConstBytesE: 219| 35.2k| explicit ChromeProcessDescriptor_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} _ZNK8perfetto6protos6pbzero31ChromeProcessDescriptor_Decoder12process_typeEv: 221| 35.2k| int32_t process_type() const { return at<1>().as_int32(); } _ZNK8perfetto6protos6pbzero31ChromeProcessDescriptor_Decoder25has_host_app_package_nameEv: 226| 35.2k| bool has_host_app_package_name() const { return at<4>().valid(); } _ZNK8perfetto6protos6pbzero31ChromeProcessDescriptor_Decoder18has_crash_trace_idEv: 228| 35.2k| bool has_crash_trace_id() const { return at<5>().valid(); } _ZN8perfetto6protos6pbzero30ChromeThreadDescriptor_DecoderC2ERKN9protozero10ConstBytesE: 231| 48| explicit ChromeThreadDescriptor_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} _ZNK8perfetto6protos6pbzero30ChromeThreadDescriptor_Decoder15has_thread_typeEv: 232| 48| bool has_thread_type() const { return at<1>().valid(); } _ZN8perfetto6protos6pbzero25CounterDescriptor_DecoderC2ERKN9protozero10ConstBytesE: 100| 20.3k| explicit CounterDescriptor_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} _ZNK8perfetto6protos6pbzero25CounterDescriptor_Decoder4typeEv: 102| 49.3k| int32_t type() const { return at<1>().as_int32(); } _ZNK8perfetto6protos6pbzero25CounterDescriptor_Decoder14has_categoriesEv: 103| 20.3k| bool has_categories() const { return at<2>().valid(); } _ZNK8perfetto6protos6pbzero25CounterDescriptor_Decoder10categoriesEv: 104| 14.1k| ::protozero::RepeatedFieldIterator<::protozero::ConstChars> categories() const { return GetRepeated<::protozero::ConstChars>(2); } _ZNK8perfetto6protos6pbzero25CounterDescriptor_Decoder4unitEv: 106| 20.3k| int32_t unit() const { return at<3>().as_int32(); } _ZNK8perfetto6protos6pbzero25CounterDescriptor_Decoder9unit_nameEv: 108| 14.8k| ::protozero::ConstChars unit_name() const { return at<6>().as_string(); } _ZNK8perfetto6protos6pbzero25CounterDescriptor_Decoder15unit_multiplierEv: 110| 20.3k| int64_t unit_multiplier() const { return at<4>().as_int64(); } _ZNK8perfetto6protos6pbzero25CounterDescriptor_Decoder14is_incrementalEv: 112| 40.6k| bool is_incremental() const { return at<5>().as_bool(); } _ZNK8perfetto6protos6pbzero23DebugAnnotation_Decoder8name_iidEv: 195| 1.15M| uint64_t name_iid() const { return at<1>().as_uint64(); } _ZNK8perfetto6protos6pbzero23DebugAnnotation_Decoder8has_nameEv: 196| 1.15M| bool has_name() const { return at<10>().valid(); } _ZNK8perfetto6protos6pbzero23DebugAnnotation_Decoder4nameEv: 197| 23.8k| ::protozero::ConstChars name() const { return at<10>().as_string(); } _ZNK8perfetto6protos6pbzero23DebugAnnotation_Decoder14has_bool_valueEv: 198| 23.8k| bool has_bool_value() const { return at<2>().valid(); } _ZNK8perfetto6protos6pbzero23DebugAnnotation_Decoder10bool_valueEv: 199| 196| bool bool_value() const { return at<2>().as_bool(); } _ZNK8perfetto6protos6pbzero23DebugAnnotation_Decoder14has_uint_valueEv: 200| 23.6k| bool has_uint_value() const { return at<3>().valid(); } _ZNK8perfetto6protos6pbzero23DebugAnnotation_Decoder10uint_valueEv: 201| 218| uint64_t uint_value() const { return at<3>().as_uint64(); } _ZNK8perfetto6protos6pbzero23DebugAnnotation_Decoder13has_int_valueEv: 202| 23.4k| bool has_int_value() const { return at<4>().valid(); } _ZNK8perfetto6protos6pbzero23DebugAnnotation_Decoder9int_valueEv: 203| 13| int64_t int_value() const { return at<4>().as_int64(); } _ZNK8perfetto6protos6pbzero23DebugAnnotation_Decoder16has_double_valueEv: 204| 23.4k| bool has_double_value() const { return at<5>().valid(); } _ZNK8perfetto6protos6pbzero23DebugAnnotation_Decoder12double_valueEv: 205| 7| double double_value() const { return at<5>().as_double(); } _ZNK8perfetto6protos6pbzero23DebugAnnotation_Decoder16has_string_valueEv: 212| 23.4k| bool has_string_value() const { return at<6>().valid(); } _ZNK8perfetto6protos6pbzero23DebugAnnotation_Decoder12string_valueEv: 213| 14| ::protozero::ConstChars string_value() const { return at<6>().as_string(); } _ZNK8perfetto6protos6pbzero23DebugAnnotation_Decoder20has_string_value_iidEv: 214| 23.4k| bool has_string_value_iid() const { return at<17>().valid(); } _ZNK8perfetto6protos6pbzero23DebugAnnotation_Decoder17has_pointer_valueEv: 206| 23.4k| bool has_pointer_value() const { return at<7>().valid(); } _ZNK8perfetto6protos6pbzero23DebugAnnotation_Decoder13pointer_valueEv: 207| 4.04k| uint64_t pointer_value() const { return at<7>().as_uint64(); } _ZNK8perfetto6protos6pbzero23DebugAnnotation_Decoder16has_dict_entriesEv: 222| 19.3k| bool has_dict_entries() const { return at<11>().valid(); } _ZNK8perfetto6protos6pbzero23DebugAnnotation_Decoder12dict_entriesEv: 223| 7| ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> dict_entries() const { return GetRepeated<::protozero::ConstBytes>(11); } _ZN8perfetto6protos6pbzero23DebugAnnotation_DecoderC2ERKN9protozero10ConstBytesE: 193| 1.15M| explicit DebugAnnotation_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} _ZNK8perfetto6protos6pbzero23DebugAnnotation_Decoder16has_array_valuesEv: 224| 19.3k| bool has_array_values() const { return at<12>().valid(); } _ZNK8perfetto6protos6pbzero23DebugAnnotation_Decoder21has_legacy_json_valueEv: 210| 19.3k| bool has_legacy_json_value() const { return at<9>().valid(); } _ZNK8perfetto6protos6pbzero23DebugAnnotation_Decoder17legacy_json_valueEv: 211| 17.5k| ::protozero::ConstChars legacy_json_value() const { return at<9>().as_string(); } _ZNK8perfetto6protos6pbzero23DebugAnnotation_Decoder16has_nested_valueEv: 208| 1.82k| bool has_nested_value() const { return at<8>().valid(); } _ZNK8perfetto6protos6pbzero23DebugAnnotation_Decoder12nested_valueEv: 209| 274| ::protozero::ConstBytes nested_value() const { return at<8>().as_bytes(); } _ZNK8perfetto6protos6pbzero23DebugAnnotation_Decoder15has_proto_valueEv: 220| 1.55k| bool has_proto_value() const { return at<14>().valid(); } _ZNK8perfetto6protos6pbzero23DebugAnnotation_Decoder19has_proto_type_nameEv: 216| 1.51k| bool has_proto_type_name() const { return at<16>().valid(); } _ZNK8perfetto6protos6pbzero23DebugAnnotation_Decoder23has_proto_type_name_iidEv: 218| 1.51k| bool has_proto_type_name_iid() const { return at<13>().valid(); } _ZNK8perfetto6protos6pbzero23DebugAnnotation_Decoder19proto_type_name_iidEv: 219| 1.51k| uint64_t proto_type_name_iid() const { return at<13>().as_uint64(); } _ZN8perfetto6protos6pbzero35DebugAnnotation_NestedValue_DecoderC2ERKN9protozero10ConstBytesE: 564| 274| explicit DebugAnnotation_NestedValue_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} _ZNK8perfetto6protos6pbzero35DebugAnnotation_NestedValue_Decoder11nested_typeEv: 566| 274| int32_t nested_type() const { return at<1>().as_int32(); } _ZN8perfetto6protos6pbzero25ProcessDescriptor_DecoderC2ERKN9protozero10ConstBytesE: 87| 109k| explicit ProcessDescriptor_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} _ZNK8perfetto6protos6pbzero25ProcessDescriptor_Decoder3pidEv: 89| 104k| int32_t pid() const { return at<1>().as_int32(); } _ZNK8perfetto6protos6pbzero25ProcessDescriptor_Decoder16has_process_nameEv: 92| 56.9k| bool has_process_name() const { return at<6>().valid(); } _ZNK8perfetto6protos6pbzero25ProcessDescriptor_Decoder12process_nameEv: 93| 496| ::protozero::ConstChars process_name() const { return at<6>().as_string(); } _ZNK8perfetto6protos6pbzero25ProcessDescriptor_Decoder22has_start_timestamp_nsEv: 96| 56.9k| bool has_start_timestamp_ns() const { return at<7>().valid(); } _ZNK8perfetto6protos6pbzero25ProcessDescriptor_Decoder18start_timestamp_nsEv: 97| 67.2k| int64_t start_timestamp_ns() const { return at<7>().as_int64(); } _ZNK8perfetto6protos6pbzero25ProcessDescriptor_Decoder23has_chrome_process_typeEv: 98| 56.9k| bool has_chrome_process_type() const { return at<4>().valid(); } _ZNK8perfetto6protos6pbzero25ProcessDescriptor_Decoder19chrome_process_typeEv: 99| 20.4k| int32_t chrome_process_type() const { return at<4>().as_int32(); } _ZNK8perfetto6protos6pbzero25ProcessDescriptor_Decoder14process_labelsEv: 103| 56.9k| ::protozero::RepeatedFieldIterator<::protozero::ConstChars> process_labels() const { return GetRepeated<::protozero::ConstChars>(8); } _ZNK8perfetto6protos6pbzero25ProcessDescriptor_Decoder7has_pidEv: 88| 52.4k| bool has_pid() const { return at<1>().valid(); } _ZN8perfetto6protos6pbzero21TaskExecution_DecoderC2ERKN9protozero10ConstBytesE: 24| 22.0k| explicit TaskExecution_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} _ZNK8perfetto6protos6pbzero21TaskExecution_Decoder15posted_from_iidEv: 26| 22.0k| uint64_t posted_from_iid() const { return at<1>().as_uint64(); } _ZN8perfetto6protos6pbzero24ThreadDescriptor_DecoderC2ERKN9protozero10ConstBytesE: 107| 24.3k| explicit ThreadDescriptor_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} _ZNK8perfetto6protos6pbzero24ThreadDescriptor_Decoder7has_pidEv: 108| 19.0k| bool has_pid() const { return at<1>().valid(); } _ZNK8perfetto6protos6pbzero24ThreadDescriptor_Decoder3pidEv: 109| 15.7k| int32_t pid() const { return at<1>().as_int32(); } _ZNK8perfetto6protos6pbzero24ThreadDescriptor_Decoder7has_tidEv: 110| 8.75k| bool has_tid() const { return at<2>().valid(); } _ZNK8perfetto6protos6pbzero24ThreadDescriptor_Decoder3tidEv: 111| 15.7k| int32_t tid() const { return at<2>().as_int32(); } _ZNK8perfetto6protos6pbzero24ThreadDescriptor_Decoder15has_thread_nameEv: 112| 5.23k| bool has_thread_name() const { return at<5>().valid(); } _ZNK8perfetto6protos6pbzero24ThreadDescriptor_Decoder11thread_nameEv: 113| 561| ::protozero::ConstChars thread_name() const { return at<5>().as_string(); } _ZNK8perfetto6protos6pbzero24ThreadDescriptor_Decoder22has_chrome_thread_typeEv: 114| 5.19k| bool has_chrome_thread_type() const { return at<4>().valid(); } _ZNK8perfetto6protos6pbzero24ThreadDescriptor_Decoder18chrome_thread_typeEv: 115| 126| int32_t chrome_thread_type() const { return at<4>().as_int32(); } _ZNK8perfetto6protos6pbzero24ThreadDescriptor_Decoder22reference_timestamp_usEv: 117| 2.06k| int64_t reference_timestamp_us() const { return at<6>().as_int64(); } _ZNK8perfetto6protos6pbzero24ThreadDescriptor_Decoder24reference_thread_time_usEv: 119| 2.06k| int64_t reference_thread_time_us() const { return at<7>().as_int64(); } _ZNK8perfetto6protos6pbzero24ThreadDescriptor_Decoder34reference_thread_instruction_countEv: 121| 2.06k| int64_t reference_thread_instruction_count() const { return at<8>().as_int64(); } _ZN8perfetto6protos6pbzero23TrackDescriptor_DecoderC2ERKN9protozero10ConstBytesE: 72| 107k| explicit TrackDescriptor_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} _ZNK8perfetto6protos6pbzero23TrackDescriptor_Decoder4uuidEv: 74| 239k| uint64_t uuid() const { return at<1>().as_uint64(); } _ZNK8perfetto6protos6pbzero23TrackDescriptor_Decoder10has_threadEv: 87| 213k| bool has_thread() const { return at<4>().valid(); } _ZNK8perfetto6protos6pbzero23TrackDescriptor_Decoder6threadEv: 88| 24.2k| ::protozero::ConstBytes thread() const { return at<4>().as_bytes(); } _ZNK8perfetto6protos6pbzero23TrackDescriptor_Decoder17has_chrome_threadEv: 89| 5.20k| bool has_chrome_thread() const { return at<7>().valid(); } _ZNK8perfetto6protos6pbzero23TrackDescriptor_Decoder13chrome_threadEv: 90| 48| ::protozero::ConstBytes chrome_thread() const { return at<7>().as_bytes(); } _ZNK8perfetto6protos6pbzero23TrackDescriptor_Decoder11has_processEv: 83| 188k| bool has_process() const { return at<3>().valid(); } _ZNK8perfetto6protos6pbzero23TrackDescriptor_Decoder7processEv: 84| 88.9k| ::protozero::ConstBytes process() const { return at<3>().as_bytes(); } _ZNK8perfetto6protos6pbzero23TrackDescriptor_Decoder18has_chrome_processEv: 85| 36.5k| bool has_chrome_process() const { return at<6>().valid(); } _ZNK8perfetto6protos6pbzero23TrackDescriptor_Decoder14chrome_processEv: 86| 35.2k| ::protozero::ConstBytes chrome_process() const { return at<6>().as_bytes(); } _ZNK8perfetto6protos6pbzero23TrackDescriptor_Decoder8has_nameEv: 77| 213k| bool has_name() const { return at<2>().valid(); } _ZNK8perfetto6protos6pbzero23TrackDescriptor_Decoder4nameEv: 78| 108k| ::protozero::ConstChars name() const { return at<2>().as_string(); } _ZNK8perfetto6protos6pbzero23TrackDescriptor_Decoder15has_static_nameEv: 79| 104k| bool has_static_name() const { return at<10>().valid(); } _ZNK8perfetto6protos6pbzero23TrackDescriptor_Decoder11static_nameEv: 80| 3.49k| ::protozero::ConstChars static_name() const { return at<10>().as_string(); } _ZNK8perfetto6protos6pbzero23TrackDescriptor_Decoder15has_atrace_nameEv: 81| 36.9k| bool has_atrace_name() const { return at<13>().valid(); } _ZNK8perfetto6protos6pbzero23TrackDescriptor_Decoder11atrace_nameEv: 82| 633| ::protozero::ConstChars atrace_name() const { return at<13>().as_string(); } _ZN8perfetto6protos6pbzero23TrackDescriptor_DecoderC2EPKhm: 70| 140k| TrackDescriptor_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} _ZNK8perfetto6protos6pbzero23TrackDescriptor_Decoder8has_uuidEv: 73| 140k| bool has_uuid() const { return at<1>().valid(); } _ZNK8perfetto6protos6pbzero23TrackDescriptor_Decoder15has_parent_uuidEv: 75| 130k| bool has_parent_uuid() const { return at<5>().valid(); } _ZNK8perfetto6protos6pbzero23TrackDescriptor_Decoder11parent_uuidEv: 76| 30.2k| uint64_t parent_uuid() const { return at<5>().as_uint64(); } _ZNK8perfetto6protos6pbzero23TrackDescriptor_Decoder11has_counterEv: 91| 59.1k| bool has_counter() const { return at<8>().valid(); } _ZNK8perfetto6protos6pbzero23TrackDescriptor_Decoder7counterEv: 92| 20.3k| ::protozero::ConstBytes counter() const { return at<8>().as_bytes(); } _ZNK8perfetto6protos6pbzero23TrackDescriptor_Decoder35disallow_merging_with_system_tracksEv: 94| 8.49k| bool disallow_merging_with_system_tracks() const { return at<9>().as_bool(); } _ZNK8perfetto6protos6pbzero23TrackDescriptor_Decoder18has_child_orderingEv: 95| 130k| bool has_child_ordering() const { return at<11>().valid(); } _ZNK8perfetto6protos6pbzero23TrackDescriptor_Decoder14child_orderingEv: 96| 3| int32_t child_ordering() const { return at<11>().as_int32(); } _ZNK8perfetto6protos6pbzero23TrackDescriptor_Decoder22has_sibling_order_rankEv: 97| 130k| bool has_sibling_order_rank() const { return at<12>().valid(); } _ZNK8perfetto6protos6pbzero23TrackDescriptor_Decoder18sibling_order_rankEv: 98| 594| int32_t sibling_order_rank() const { return at<12>().as_int32(); } _ZN8perfetto6protos6pbzero21EventCategory_DecoderC2EPKhm: 227| 778| EventCategory_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} _ZNK8perfetto6protos6pbzero21EventCategory_Decoder4nameEv: 233| 4.03k| ::protozero::ConstChars name() const { return at<2>().as_string(); } _ZN8perfetto6protos6pbzero26TrackEventDefaults_DecoderC2EPKhm: 291| 506| TrackEventDefaults_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} _ZNK8perfetto6protos6pbzero26TrackEventDefaults_Decoder14has_track_uuidEv: 294| 42.4k| bool has_track_uuid() const { return at<11>().valid(); } _ZNK8perfetto6protos6pbzero26TrackEventDefaults_Decoder10track_uuidEv: 295| 42.4k| uint64_t track_uuid() const { return at<11>().as_uint64(); } _ZNK8perfetto6protos6pbzero26TrackEventDefaults_Decoder25extra_counter_track_uuidsEv: 297| 48.9k| ::protozero::RepeatedFieldIterator extra_counter_track_uuids() const { return GetRepeated(31); } _ZNK8perfetto6protos6pbzero26TrackEventDefaults_Decoder32extra_double_counter_track_uuidsEv: 299| 48.9k| ::protozero::RepeatedFieldIterator extra_double_counter_track_uuids() const { return GetRepeated(45); } _ZN8perfetto6protos6pbzero18TrackEvent_DecoderC2ERKN9protozero10ConstBytesE: 372| 1.87M| explicit TrackEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} _ZNK8perfetto6protos6pbzero18TrackEvent_Decoder13category_iidsEv: 374| 840k| ::protozero::RepeatedFieldIterator category_iids() const { return GetRepeated(3); } _ZNK8perfetto6protos6pbzero18TrackEvent_Decoder10categoriesEv: 376| 840k| ::protozero::RepeatedFieldIterator<::protozero::ConstChars> categories() const { return GetRepeated<::protozero::ConstChars>(22); } _ZNK8perfetto6protos6pbzero18TrackEvent_Decoder8name_iidEv: 378| 840k| uint64_t name_iid() const { return at<10>().as_uint64(); } _ZNK8perfetto6protos6pbzero18TrackEvent_Decoder8has_nameEv: 379| 826k| bool has_name() const { return at<23>().valid(); } _ZNK8perfetto6protos6pbzero18TrackEvent_Decoder4typeEv: 382| 3.31M| int32_t type() const { return at<9>().as_int32(); } _ZNK8perfetto6protos6pbzero18TrackEvent_Decoder14has_track_uuidEv: 383| 1.63M| bool has_track_uuid() const { return at<11>().valid(); } _ZNK8perfetto6protos6pbzero18TrackEvent_Decoder10track_uuidEv: 384| 1.94k| uint64_t track_uuid() const { return at<11>().as_uint64(); } _ZNK8perfetto6protos6pbzero18TrackEvent_Decoder17has_counter_valueEv: 385| 1| bool has_counter_value() const { return at<30>().valid(); } _ZNK8perfetto6protos6pbzero18TrackEvent_Decoder24has_double_counter_valueEv: 387| 1| bool has_double_counter_value() const { return at<44>().valid(); } _ZNK8perfetto6protos6pbzero18TrackEvent_Decoder25extra_counter_track_uuidsEv: 390| 971k| ::protozero::RepeatedFieldIterator extra_counter_track_uuids() const { return GetRepeated(31); } _ZNK8perfetto6protos6pbzero18TrackEvent_Decoder24has_extra_counter_valuesEv: 391| 831k| bool has_extra_counter_values() const { return at<12>().valid(); } _ZNK8perfetto6protos6pbzero18TrackEvent_Decoder20extra_counter_valuesEv: 392| 971k| ::protozero::RepeatedFieldIterator extra_counter_values() const { return GetRepeated(12); } _ZNK8perfetto6protos6pbzero18TrackEvent_Decoder32extra_double_counter_track_uuidsEv: 394| 961k| ::protozero::RepeatedFieldIterator extra_double_counter_track_uuids() const { return GetRepeated(45); } _ZNK8perfetto6protos6pbzero18TrackEvent_Decoder31has_extra_double_counter_valuesEv: 395| 831k| bool has_extra_double_counter_values() const { return at<46>().valid(); } _ZNK8perfetto6protos6pbzero18TrackEvent_Decoder27extra_double_counter_valuesEv: 396| 961k| ::protozero::RepeatedFieldIterator extra_double_counter_values() const { return GetRepeated(46); } _ZNK8perfetto6protos6pbzero18TrackEvent_Decoder16has_flow_ids_oldEv: 397| 727k| bool has_flow_ids_old() const { return at<36>().valid(); } _ZNK8perfetto6protos6pbzero18TrackEvent_Decoder12flow_ids_oldEv: 398| 9| ::protozero::RepeatedFieldIterator flow_ids_old() const { return GetRepeated(36); } _ZNK8perfetto6protos6pbzero18TrackEvent_Decoder12has_flow_idsEv: 399| 727k| bool has_flow_ids() const { return at<47>().valid(); } _ZNK8perfetto6protos6pbzero18TrackEvent_Decoder8flow_idsEv: 400| 8| ::protozero::RepeatedFieldIterator flow_ids() const { return GetRepeated(47); } _ZNK8perfetto6protos6pbzero18TrackEvent_Decoder28has_terminating_flow_ids_oldEv: 401| 727k| bool has_terminating_flow_ids_old() const { return at<42>().valid(); } _ZNK8perfetto6protos6pbzero18TrackEvent_Decoder24terminating_flow_ids_oldEv: 402| 4.34k| ::protozero::RepeatedFieldIterator terminating_flow_ids_old() const { return GetRepeated(42); } _ZNK8perfetto6protos6pbzero18TrackEvent_Decoder24has_terminating_flow_idsEv: 403| 727k| bool has_terminating_flow_ids() const { return at<48>().valid(); } _ZNK8perfetto6protos6pbzero18TrackEvent_Decoder20terminating_flow_idsEv: 404| 4.19k| ::protozero::RepeatedFieldIterator terminating_flow_ids() const { return GetRepeated(48); } _ZNK8perfetto6protos6pbzero18TrackEvent_Decoder17debug_annotationsEv: 406| 739k| ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> debug_annotations() const { return GetRepeated<::protozero::ConstBytes>(4); } _ZNK8perfetto6protos6pbzero18TrackEvent_Decoder18has_task_executionEv: 407| 739k| bool has_task_execution() const { return at<5>().valid(); } _ZNK8perfetto6protos6pbzero18TrackEvent_Decoder14task_executionEv: 408| 22.0k| ::protozero::ConstBytes task_execution() const { return at<5>().as_bytes(); } _ZNK8perfetto6protos6pbzero18TrackEvent_Decoder15has_log_messageEv: 409| 739k| bool has_log_message() const { return at<21>().valid(); } _ZNK8perfetto6protos6pbzero18TrackEvent_Decoder27has_chrome_histogram_sampleEv: 419| 739k| bool has_chrome_histogram_sample() const { return at<28>().valid(); } _ZNK8perfetto6protos6pbzero18TrackEvent_Decoder23chrome_histogram_sampleEv: 420| 526k| ::protozero::ConstBytes chrome_histogram_sample() const { return at<28>().as_bytes(); } _ZNK8perfetto6protos6pbzero18TrackEvent_Decoder27has_chrome_active_processesEv: 433| 739k| bool has_chrome_active_processes() const { return at<49>().valid(); } _ZNK8perfetto6protos6pbzero18TrackEvent_Decoder23chrome_active_processesEv: 434| 26.3k| ::protozero::ConstBytes chrome_active_processes() const { return at<49>().as_bytes(); } _ZNK8perfetto6protos6pbzero18TrackEvent_Decoder23has_source_location_iidEv: 439| 739k| bool has_source_location_iid() const { return at<34>().valid(); } _ZNK8perfetto6protos6pbzero18TrackEvent_Decoder19source_location_iidEv: 440| 146| uint64_t source_location_iid() const { return at<34>().as_uint64(); } _ZNK8perfetto6protos6pbzero18TrackEvent_Decoder22has_timestamp_delta_usEv: 445| 999k| bool has_timestamp_delta_us() const { return at<1>().valid(); } _ZNK8perfetto6protos6pbzero18TrackEvent_Decoder18timestamp_delta_usEv: 446| 22| int64_t timestamp_delta_us() const { return at<1>().as_int64(); } _ZNK8perfetto6protos6pbzero18TrackEvent_Decoder21timestamp_absolute_usEv: 448| 988k| int64_t timestamp_absolute_us() const { return at<16>().as_int64(); } _ZNK8perfetto6protos6pbzero18TrackEvent_Decoder24has_thread_time_delta_usEv: 449| 984k| bool has_thread_time_delta_us() const { return at<2>().valid(); } _ZNK8perfetto6protos6pbzero18TrackEvent_Decoder20thread_time_delta_usEv: 450| 24| int64_t thread_time_delta_us() const { return at<2>().as_int64(); } _ZNK8perfetto6protos6pbzero18TrackEvent_Decoder27has_thread_time_absolute_usEv: 451| 975k| bool has_thread_time_absolute_us() const { return at<17>().valid(); } _ZNK8perfetto6protos6pbzero18TrackEvent_Decoder34has_thread_instruction_count_deltaEv: 453| 975k| bool has_thread_instruction_count_delta() const { return at<8>().valid(); } _ZNK8perfetto6protos6pbzero18TrackEvent_Decoder30thread_instruction_count_deltaEv: 454| 24| int64_t thread_instruction_count_delta() const { return at<8>().as_int64(); } _ZNK8perfetto6protos6pbzero18TrackEvent_Decoder37has_thread_instruction_count_absoluteEv: 455| 971k| bool has_thread_instruction_count_absolute() const { return at<20>().valid(); } _ZNK8perfetto6protos6pbzero18TrackEvent_Decoder33thread_instruction_count_absoluteEv: 456| 43| int64_t thread_instruction_count_absolute() const { return at<20>().as_int64(); } _ZNK8perfetto6protos6pbzero18TrackEvent_Decoder16has_legacy_eventEv: 457| 984k| bool has_legacy_event() const { return at<6>().valid(); } _ZNK8perfetto6protos6pbzero18TrackEvent_Decoder12legacy_eventEv: 458| 1.23M| ::protozero::ConstBytes legacy_event() const { return at<6>().as_bytes(); } _ZN8perfetto6protos6pbzero30TrackEvent_LegacyEvent_DecoderC2ERKN9protozero10ConstBytesE: 1234| 1.23M| explicit TrackEvent_LegacyEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} _ZNK8perfetto6protos6pbzero30TrackEvent_LegacyEvent_Decoder8name_iidEv: 1236| 829k| uint64_t name_iid() const { return at<1>().as_uint64(); } _ZNK8perfetto6protos6pbzero30TrackEvent_LegacyEvent_Decoder9has_phaseEv: 1237| 1.70M| bool has_phase() const { return at<2>().valid(); } _ZNK8perfetto6protos6pbzero30TrackEvent_LegacyEvent_Decoder5phaseEv: 1238| 1.25M| int32_t phase() const { return at<2>().as_int32(); } _ZNK8perfetto6protos6pbzero30TrackEvent_LegacyEvent_Decoder15has_duration_usEv: 1239| 11.5k| bool has_duration_us() const { return at<3>().valid(); } _ZNK8perfetto6protos6pbzero30TrackEvent_LegacyEvent_Decoder11duration_usEv: 1240| 9.32k| int64_t duration_us() const { return at<3>().as_int64(); } _ZNK8perfetto6protos6pbzero30TrackEvent_LegacyEvent_Decoder22has_thread_duration_usEv: 1241| 23| bool has_thread_duration_us() const { return at<4>().valid(); } _ZNK8perfetto6protos6pbzero30TrackEvent_LegacyEvent_Decoder28has_thread_instruction_deltaEv: 1243| 23| bool has_thread_instruction_delta() const { return at<15>().valid(); } _ZNK8perfetto6protos6pbzero30TrackEvent_LegacyEvent_Decoder15has_unscoped_idEv: 1245| 202k| bool has_unscoped_id() const { return at<6>().valid(); } _ZNK8perfetto6protos6pbzero30TrackEvent_LegacyEvent_Decoder11unscoped_idEv: 1246| 57.8k| uint64_t unscoped_id() const { return at<6>().as_uint64(); } _ZNK8perfetto6protos6pbzero30TrackEvent_LegacyEvent_Decoder12has_local_idEv: 1247| 126k| bool has_local_id() const { return at<10>().valid(); } _ZNK8perfetto6protos6pbzero30TrackEvent_LegacyEvent_Decoder8local_idEv: 1248| 109k| uint64_t local_id() const { return at<10>().as_uint64(); } _ZNK8perfetto6protos6pbzero30TrackEvent_LegacyEvent_Decoder13has_global_idEv: 1249| 133k| bool has_global_id() const { return at<11>().valid(); } _ZNK8perfetto6protos6pbzero30TrackEvent_LegacyEvent_Decoder9global_idEv: 1250| 7.02k| uint64_t global_id() const { return at<11>().as_uint64(); } _ZNK8perfetto6protos6pbzero30TrackEvent_LegacyEvent_Decoder12has_id_scopeEv: 1251| 120k| bool has_id_scope() const { return at<7>().valid(); } _ZNK8perfetto6protos6pbzero30TrackEvent_LegacyEvent_Decoder13use_async_ttsEv: 1254| 734k| bool use_async_tts() const { return at<9>().as_bool(); } _ZNK8perfetto6protos6pbzero30TrackEvent_LegacyEvent_Decoder11has_bind_idEv: 1255| 727k| bool has_bind_id() const { return at<8>().valid(); } _ZNK8perfetto6protos6pbzero30TrackEvent_LegacyEvent_Decoder7bind_idEv: 1256| 3.44k| uint64_t bind_id() const { return at<8>().as_uint64(); } _ZNK8perfetto6protos6pbzero30TrackEvent_LegacyEvent_Decoder17bind_to_enclosingEv: 1258| 1.45k| bool bind_to_enclosing() const { return at<12>().as_bool(); } _ZNK8perfetto6protos6pbzero30TrackEvent_LegacyEvent_Decoder18has_flow_directionEv: 1259| 3.44k| bool has_flow_direction() const { return at<13>().valid(); } _ZNK8perfetto6protos6pbzero30TrackEvent_LegacyEvent_Decoder14flow_directionEv: 1260| 3.44k| int32_t flow_direction() const { return at<13>().as_int32(); } _ZNK8perfetto6protos6pbzero30TrackEvent_LegacyEvent_Decoder19instant_event_scopeEv: 1262| 3.66k| int32_t instant_event_scope() const { return at<14>().as_int32(); } _ZNK8perfetto6protos6pbzero30TrackEvent_LegacyEvent_Decoder16has_pid_overrideEv: 1263| 901k| bool has_pid_override() const { return at<18>().valid(); } _ZNK8perfetto6protos6pbzero30TrackEvent_LegacyEvent_Decoder12pid_overrideEv: 1264| 105k| int32_t pid_override() const { return at<18>().as_int32(); } _ZNK8perfetto6protos6pbzero30TrackEvent_LegacyEvent_Decoder16has_tid_overrideEv: 1265| 901k| bool has_tid_override() const { return at<19>().valid(); } _ZN8perfetto15trace_processor6tables15AndroidLogTable10GetColumnsEPS2_PKNS0_15macros_internal10MacroTableE: 248| 434| const macros_internal::MacroTable* parent) { 249| 434| std::vector columns = 250| 434| CopyColumnsFromParentOrAddRootColumns(parent); 251| 434| uint32_t olay_idx = OverlayCount(parent); 252| 434| AddColumnToVector(columns, "ts", &self->ts_, ColumnFlag::ts, 253| 434| static_cast(columns.size()), olay_idx); 254| 434| AddColumnToVector(columns, "utid", &self->utid_, ColumnFlag::utid, 255| 434| static_cast(columns.size()), olay_idx); 256| 434| AddColumnToVector(columns, "prio", &self->prio_, ColumnFlag::prio, 257| 434| static_cast(columns.size()), olay_idx); 258| 434| AddColumnToVector(columns, "tag", &self->tag_, ColumnFlag::tag, 259| 434| static_cast(columns.size()), olay_idx); 260| 434| AddColumnToVector(columns, "msg", &self->msg_, ColumnFlag::msg, 261| 434| static_cast(columns.size()), olay_idx); 262| 434| base::ignore_result(self); 263| 434| return columns; 264| 434| } _ZN8perfetto15trace_processor6tables15AndroidLogTableC2EPNS0_10StringPoolE: 267| 434| : macros_internal::MacroTable( 268| 434| pool, 269| 434| GetColumns(this, nullptr), 270| 434| nullptr), 271| 434| ts_(ColumnStorage::Create()), 272| 434| utid_(ColumnStorage::Create()), 273| 434| prio_(ColumnStorage::Create()), 274| 434| tag_(ColumnStorage::Create()), 275| 434| msg_(ColumnStorage::Create()) 276| |, 277| 434| id_storage_layer_(new column::IdStorage()), 278| 434| ts_storage_layer_( 279| 434| new column::NumericStorage( 280| 434| &ts_.vector(), 281| 434| ColumnTypeHelper::ToColumnType(), 282| 434| false)), 283| 434| utid_storage_layer_( 284| 434| new column::NumericStorage( 285| 434| &utid_.vector(), 286| 434| ColumnTypeHelper::ToColumnType(), 287| 434| false)), 288| 434| prio_storage_layer_( 289| 434| new column::NumericStorage( 290| 434| &prio_.vector(), 291| 434| ColumnTypeHelper::ToColumnType(), 292| 434| false)), 293| 434| tag_storage_layer_( 294| 434| new column::StringStorage(string_pool(), &tag_.vector())), 295| 434| msg_storage_layer_( 296| 434| new column::StringStorage(string_pool(), &msg_.vector())) 297| 434| { 298| 434| static_assert( 299| 434| ColumnLegacy::IsFlagsAndTypeValid( 300| 434| ColumnFlag::ts), 301| 434| "Column type and flag combination is not valid"); 302| 434| static_assert( 303| 434| ColumnLegacy::IsFlagsAndTypeValid( 304| 434| ColumnFlag::utid), 305| 434| "Column type and flag combination is not valid"); 306| 434| static_assert( 307| 434| ColumnLegacy::IsFlagsAndTypeValid( 308| 434| ColumnFlag::prio), 309| 434| "Column type and flag combination is not valid"); 310| 434| static_assert( 311| 434| ColumnLegacy::IsFlagsAndTypeValid( 312| 434| ColumnFlag::tag), 313| 434| "Column type and flag combination is not valid"); 314| 434| static_assert( 315| 434| ColumnLegacy::IsFlagsAndTypeValid( 316| 434| ColumnFlag::msg), 317| 434| "Column type and flag combination is not valid"); 318| 434| OnConstructionCompletedRegularConstructor( 319| 434| {id_storage_layer_,ts_storage_layer_,utid_storage_layer_,prio_storage_layer_,tag_storage_layer_,msg_storage_layer_}, 320| 434| {{},{},{},{},{},{}}); 321| 434| } _ZN8perfetto15trace_processor6tables21AndroidDumpstateTable10GetColumnsEPS2_PKNS0_15macros_internal10MacroTableE: 646| 434| const macros_internal::MacroTable* parent) { 647| 434| std::vector columns = 648| 434| CopyColumnsFromParentOrAddRootColumns(parent); 649| 434| uint32_t olay_idx = OverlayCount(parent); 650| 434| AddColumnToVector(columns, "section", &self->section_, ColumnFlag::section, 651| 434| static_cast(columns.size()), olay_idx); 652| 434| AddColumnToVector(columns, "service", &self->service_, ColumnFlag::service, 653| 434| static_cast(columns.size()), olay_idx); 654| 434| AddColumnToVector(columns, "line", &self->line_, ColumnFlag::line, 655| 434| static_cast(columns.size()), olay_idx); 656| 434| base::ignore_result(self); 657| 434| return columns; 658| 434| } _ZN8perfetto15trace_processor6tables21AndroidDumpstateTableC2EPNS0_10StringPoolE: 661| 434| : macros_internal::MacroTable( 662| 434| pool, 663| 434| GetColumns(this, nullptr), 664| 434| nullptr), 665| 434| section_(ColumnStorage::Create()), 666| 434| service_(ColumnStorage::Create()), 667| 434| line_(ColumnStorage::Create()) 668| |, 669| 434| id_storage_layer_(new column::IdStorage()), 670| 434| section_storage_layer_( 671| 434| new column::StringStorage(string_pool(), §ion_.vector())), 672| 434| service_storage_layer_( 673| 434| new column::StringStorage(string_pool(), &service_.vector())), 674| 434| line_storage_layer_( 675| 434| new column::StringStorage(string_pool(), &line_.vector())) 676| 434| { 677| 434| static_assert( 678| 434| ColumnLegacy::IsFlagsAndTypeValid( 679| 434| ColumnFlag::section), 680| 434| "Column type and flag combination is not valid"); 681| 434| static_assert( 682| 434| ColumnLegacy::IsFlagsAndTypeValid( 683| 434| ColumnFlag::service), 684| 434| "Column type and flag combination is not valid"); 685| 434| static_assert( 686| 434| ColumnLegacy::IsFlagsAndTypeValid( 687| 434| ColumnFlag::line), 688| 434| "Column type and flag combination is not valid"); 689| 434| OnConstructionCompletedRegularConstructor( 690| 434| {id_storage_layer_,section_storage_layer_,service_storage_layer_,line_storage_layer_}, 691| 434| {{},{},{},{}}); 692| 434| } _ZN8perfetto15trace_processor6tables32AndroidGameInterventionListTable10GetColumnsEPS2_PKNS0_15macros_internal10MacroTableE: 1213| 434| const macros_internal::MacroTable* parent) { 1214| 434| std::vector columns = 1215| 434| CopyColumnsFromParentOrAddRootColumns(parent); 1216| 434| uint32_t olay_idx = OverlayCount(parent); 1217| 434| AddColumnToVector(columns, "package_name", &self->package_name_, ColumnFlag::package_name, 1218| 434| static_cast(columns.size()), olay_idx); 1219| 434| AddColumnToVector(columns, "uid", &self->uid_, ColumnFlag::uid, 1220| 434| static_cast(columns.size()), olay_idx); 1221| 434| AddColumnToVector(columns, "current_mode", &self->current_mode_, ColumnFlag::current_mode, 1222| 434| static_cast(columns.size()), olay_idx); 1223| 434| AddColumnToVector(columns, "standard_mode_supported", &self->standard_mode_supported_, ColumnFlag::standard_mode_supported, 1224| 434| static_cast(columns.size()), olay_idx); 1225| 434| AddColumnToVector(columns, "standard_mode_downscale", &self->standard_mode_downscale_, ColumnFlag::standard_mode_downscale, 1226| 434| static_cast(columns.size()), olay_idx); 1227| 434| AddColumnToVector(columns, "standard_mode_use_angle", &self->standard_mode_use_angle_, ColumnFlag::standard_mode_use_angle, 1228| 434| static_cast(columns.size()), olay_idx); 1229| 434| AddColumnToVector(columns, "standard_mode_fps", &self->standard_mode_fps_, ColumnFlag::standard_mode_fps, 1230| 434| static_cast(columns.size()), olay_idx); 1231| 434| AddColumnToVector(columns, "perf_mode_supported", &self->perf_mode_supported_, ColumnFlag::perf_mode_supported, 1232| 434| static_cast(columns.size()), olay_idx); 1233| 434| AddColumnToVector(columns, "perf_mode_downscale", &self->perf_mode_downscale_, ColumnFlag::perf_mode_downscale, 1234| 434| static_cast(columns.size()), olay_idx); 1235| 434| AddColumnToVector(columns, "perf_mode_use_angle", &self->perf_mode_use_angle_, ColumnFlag::perf_mode_use_angle, 1236| 434| static_cast(columns.size()), olay_idx); 1237| 434| AddColumnToVector(columns, "perf_mode_fps", &self->perf_mode_fps_, ColumnFlag::perf_mode_fps, 1238| 434| static_cast(columns.size()), olay_idx); 1239| 434| AddColumnToVector(columns, "battery_mode_supported", &self->battery_mode_supported_, ColumnFlag::battery_mode_supported, 1240| 434| static_cast(columns.size()), olay_idx); 1241| 434| AddColumnToVector(columns, "battery_mode_downscale", &self->battery_mode_downscale_, ColumnFlag::battery_mode_downscale, 1242| 434| static_cast(columns.size()), olay_idx); 1243| 434| AddColumnToVector(columns, "battery_mode_use_angle", &self->battery_mode_use_angle_, ColumnFlag::battery_mode_use_angle, 1244| 434| static_cast(columns.size()), olay_idx); 1245| 434| AddColumnToVector(columns, "battery_mode_fps", &self->battery_mode_fps_, ColumnFlag::battery_mode_fps, 1246| 434| static_cast(columns.size()), olay_idx); 1247| 434| base::ignore_result(self); 1248| 434| return columns; 1249| 434| } _ZN8perfetto15trace_processor6tables32AndroidGameInterventionListTableC2EPNS0_10StringPoolE: 1252| 434| : macros_internal::MacroTable( 1253| 434| pool, 1254| 434| GetColumns(this, nullptr), 1255| 434| nullptr), 1256| 434| package_name_(ColumnStorage::Create()), 1257| 434| uid_(ColumnStorage::Create()), 1258| 434| current_mode_(ColumnStorage::Create()), 1259| 434| standard_mode_supported_(ColumnStorage::Create()), 1260| 434| standard_mode_downscale_(ColumnStorage::Create()), 1261| 434| standard_mode_use_angle_(ColumnStorage::Create()), 1262| 434| standard_mode_fps_(ColumnStorage::Create()), 1263| 434| perf_mode_supported_(ColumnStorage::Create()), 1264| 434| perf_mode_downscale_(ColumnStorage::Create()), 1265| 434| perf_mode_use_angle_(ColumnStorage::Create()), 1266| 434| perf_mode_fps_(ColumnStorage::Create()), 1267| 434| battery_mode_supported_(ColumnStorage::Create()), 1268| 434| battery_mode_downscale_(ColumnStorage::Create()), 1269| 434| battery_mode_use_angle_(ColumnStorage::Create()), 1270| 434| battery_mode_fps_(ColumnStorage::Create()) 1271| |, 1272| 434| id_storage_layer_(new column::IdStorage()), 1273| 434| package_name_storage_layer_( 1274| 434| new column::StringStorage(string_pool(), &package_name_.vector())), 1275| 434| uid_storage_layer_( 1276| 434| new column::NumericStorage( 1277| 434| &uid_.vector(), 1278| 434| ColumnTypeHelper::ToColumnType(), 1279| 434| false)), 1280| 434| current_mode_storage_layer_( 1281| 434| new column::NumericStorage( 1282| 434| ¤t_mode_.vector(), 1283| 434| ColumnTypeHelper::ToColumnType(), 1284| 434| false)), 1285| 434| standard_mode_supported_storage_layer_( 1286| 434| new column::NumericStorage( 1287| 434| &standard_mode_supported_.vector(), 1288| 434| ColumnTypeHelper::ToColumnType(), 1289| 434| false)), 1290| 434| standard_mode_downscale_storage_layer_( 1291| 434| new column::NumericStorage( 1292| 434| &standard_mode_downscale_.non_null_vector(), 1293| 434| ColumnTypeHelper::ToColumnType(), 1294| 434| false)), 1295| 434| standard_mode_use_angle_storage_layer_( 1296| 434| new column::NumericStorage( 1297| 434| &standard_mode_use_angle_.non_null_vector(), 1298| 434| ColumnTypeHelper::ToColumnType(), 1299| 434| false)), 1300| 434| standard_mode_fps_storage_layer_( 1301| 434| new column::NumericStorage( 1302| 434| &standard_mode_fps_.non_null_vector(), 1303| 434| ColumnTypeHelper::ToColumnType(), 1304| 434| false)), 1305| 434| perf_mode_supported_storage_layer_( 1306| 434| new column::NumericStorage( 1307| 434| &perf_mode_supported_.vector(), 1308| 434| ColumnTypeHelper::ToColumnType(), 1309| 434| false)), 1310| 434| perf_mode_downscale_storage_layer_( 1311| 434| new column::NumericStorage( 1312| 434| &perf_mode_downscale_.non_null_vector(), 1313| 434| ColumnTypeHelper::ToColumnType(), 1314| 434| false)), 1315| 434| perf_mode_use_angle_storage_layer_( 1316| 434| new column::NumericStorage( 1317| 434| &perf_mode_use_angle_.non_null_vector(), 1318| 434| ColumnTypeHelper::ToColumnType(), 1319| 434| false)), 1320| 434| perf_mode_fps_storage_layer_( 1321| 434| new column::NumericStorage( 1322| 434| &perf_mode_fps_.non_null_vector(), 1323| 434| ColumnTypeHelper::ToColumnType(), 1324| 434| false)), 1325| 434| battery_mode_supported_storage_layer_( 1326| 434| new column::NumericStorage( 1327| 434| &battery_mode_supported_.vector(), 1328| 434| ColumnTypeHelper::ToColumnType(), 1329| 434| false)), 1330| 434| battery_mode_downscale_storage_layer_( 1331| 434| new column::NumericStorage( 1332| 434| &battery_mode_downscale_.non_null_vector(), 1333| 434| ColumnTypeHelper::ToColumnType(), 1334| 434| false)), 1335| 434| battery_mode_use_angle_storage_layer_( 1336| 434| new column::NumericStorage( 1337| 434| &battery_mode_use_angle_.non_null_vector(), 1338| 434| ColumnTypeHelper::ToColumnType(), 1339| 434| false)), 1340| 434| battery_mode_fps_storage_layer_( 1341| 434| new column::NumericStorage( 1342| 434| &battery_mode_fps_.non_null_vector(), 1343| 434| ColumnTypeHelper::ToColumnType(), 1344| 434| false)) 1345| |, 1346| 434| standard_mode_downscale_null_layer_(new column::NullOverlay(standard_mode_downscale_.bv())), 1347| 434| standard_mode_use_angle_null_layer_(new column::NullOverlay(standard_mode_use_angle_.bv())), 1348| 434| standard_mode_fps_null_layer_(new column::NullOverlay(standard_mode_fps_.bv())), 1349| 434| perf_mode_downscale_null_layer_(new column::NullOverlay(perf_mode_downscale_.bv())), 1350| 434| perf_mode_use_angle_null_layer_(new column::NullOverlay(perf_mode_use_angle_.bv())), 1351| 434| perf_mode_fps_null_layer_(new column::NullOverlay(perf_mode_fps_.bv())), 1352| 434| battery_mode_downscale_null_layer_(new column::NullOverlay(battery_mode_downscale_.bv())), 1353| 434| battery_mode_use_angle_null_layer_(new column::NullOverlay(battery_mode_use_angle_.bv())), 1354| 434| battery_mode_fps_null_layer_(new column::NullOverlay(battery_mode_fps_.bv())) { 1355| 434| static_assert( 1356| 434| ColumnLegacy::IsFlagsAndTypeValid( 1357| 434| ColumnFlag::package_name), 1358| 434| "Column type and flag combination is not valid"); 1359| 434| static_assert( 1360| 434| ColumnLegacy::IsFlagsAndTypeValid( 1361| 434| ColumnFlag::uid), 1362| 434| "Column type and flag combination is not valid"); 1363| 434| static_assert( 1364| 434| ColumnLegacy::IsFlagsAndTypeValid( 1365| 434| ColumnFlag::current_mode), 1366| 434| "Column type and flag combination is not valid"); 1367| 434| static_assert( 1368| 434| ColumnLegacy::IsFlagsAndTypeValid( 1369| 434| ColumnFlag::standard_mode_supported), 1370| 434| "Column type and flag combination is not valid"); 1371| 434| static_assert( 1372| 434| ColumnLegacy::IsFlagsAndTypeValid( 1373| 434| ColumnFlag::standard_mode_downscale), 1374| 434| "Column type and flag combination is not valid"); 1375| 434| static_assert( 1376| 434| ColumnLegacy::IsFlagsAndTypeValid( 1377| 434| ColumnFlag::standard_mode_use_angle), 1378| 434| "Column type and flag combination is not valid"); 1379| 434| static_assert( 1380| 434| ColumnLegacy::IsFlagsAndTypeValid( 1381| 434| ColumnFlag::standard_mode_fps), 1382| 434| "Column type and flag combination is not valid"); 1383| 434| static_assert( 1384| 434| ColumnLegacy::IsFlagsAndTypeValid( 1385| 434| ColumnFlag::perf_mode_supported), 1386| 434| "Column type and flag combination is not valid"); 1387| 434| static_assert( 1388| 434| ColumnLegacy::IsFlagsAndTypeValid( 1389| 434| ColumnFlag::perf_mode_downscale), 1390| 434| "Column type and flag combination is not valid"); 1391| 434| static_assert( 1392| 434| ColumnLegacy::IsFlagsAndTypeValid( 1393| 434| ColumnFlag::perf_mode_use_angle), 1394| 434| "Column type and flag combination is not valid"); 1395| 434| static_assert( 1396| 434| ColumnLegacy::IsFlagsAndTypeValid( 1397| 434| ColumnFlag::perf_mode_fps), 1398| 434| "Column type and flag combination is not valid"); 1399| 434| static_assert( 1400| 434| ColumnLegacy::IsFlagsAndTypeValid( 1401| 434| ColumnFlag::battery_mode_supported), 1402| 434| "Column type and flag combination is not valid"); 1403| 434| static_assert( 1404| 434| ColumnLegacy::IsFlagsAndTypeValid( 1405| 434| ColumnFlag::battery_mode_downscale), 1406| 434| "Column type and flag combination is not valid"); 1407| 434| static_assert( 1408| 434| ColumnLegacy::IsFlagsAndTypeValid( 1409| 434| ColumnFlag::battery_mode_use_angle), 1410| 434| "Column type and flag combination is not valid"); 1411| 434| static_assert( 1412| 434| ColumnLegacy::IsFlagsAndTypeValid( 1413| 434| ColumnFlag::battery_mode_fps), 1414| 434| "Column type and flag combination is not valid"); 1415| 434| OnConstructionCompletedRegularConstructor( 1416| 434| {id_storage_layer_,package_name_storage_layer_,uid_storage_layer_,current_mode_storage_layer_,standard_mode_supported_storage_layer_,standard_mode_downscale_storage_layer_,standard_mode_use_angle_storage_layer_,standard_mode_fps_storage_layer_,perf_mode_supported_storage_layer_,perf_mode_downscale_storage_layer_,perf_mode_use_angle_storage_layer_,perf_mode_fps_storage_layer_,battery_mode_supported_storage_layer_,battery_mode_downscale_storage_layer_,battery_mode_use_angle_storage_layer_,battery_mode_fps_storage_layer_}, 1417| 434| {{},{},{},{},{},standard_mode_downscale_null_layer_,standard_mode_use_angle_null_layer_,standard_mode_fps_null_layer_,{},perf_mode_downscale_null_layer_,perf_mode_use_angle_null_layer_,perf_mode_fps_null_layer_,{},battery_mode_downscale_null_layer_,battery_mode_use_angle_null_layer_,battery_mode_fps_null_layer_}); 1418| 434| } _ZN8perfetto15trace_processor6tables21AndroidKeyEventsTable10GetColumnsEPS2_PKNS0_15macros_internal10MacroTableE: 1930| 434| const macros_internal::MacroTable* parent) { 1931| 434| std::vector columns = 1932| 434| CopyColumnsFromParentOrAddRootColumns(parent); 1933| 434| uint32_t olay_idx = OverlayCount(parent); 1934| 434| AddColumnToVector(columns, "event_id", &self->event_id_, ColumnFlag::event_id, 1935| 434| static_cast(columns.size()), olay_idx); 1936| 434| AddColumnToVector(columns, "ts", &self->ts_, ColumnFlag::ts, 1937| 434| static_cast(columns.size()), olay_idx); 1938| 434| AddColumnToVector(columns, "arg_set_id", &self->arg_set_id_, ColumnFlag::arg_set_id, 1939| 434| static_cast(columns.size()), olay_idx); 1940| 434| AddColumnToVector(columns, "base64_proto_id", &self->base64_proto_id_, ColumnFlag::base64_proto_id, 1941| 434| static_cast(columns.size()), olay_idx); 1942| 434| base::ignore_result(self); 1943| 434| return columns; 1944| 434| } _ZN8perfetto15trace_processor6tables21AndroidKeyEventsTableC2EPNS0_10StringPoolE: 1947| 434| : macros_internal::MacroTable( 1948| 434| pool, 1949| 434| GetColumns(this, nullptr), 1950| 434| nullptr), 1951| 434| event_id_(ColumnStorage::Create()), 1952| 434| ts_(ColumnStorage::Create()), 1953| 434| arg_set_id_(ColumnStorage::Create()), 1954| 434| base64_proto_id_(ColumnStorage::Create()) 1955| |, 1956| 434| id_storage_layer_(new column::IdStorage()), 1957| 434| event_id_storage_layer_( 1958| 434| new column::NumericStorage( 1959| 434| &event_id_.vector(), 1960| 434| ColumnTypeHelper::ToColumnType(), 1961| 434| false)), 1962| 434| ts_storage_layer_( 1963| 434| new column::NumericStorage( 1964| 434| &ts_.vector(), 1965| 434| ColumnTypeHelper::ToColumnType(), 1966| 434| false)), 1967| 434| arg_set_id_storage_layer_( 1968| 434| new column::NumericStorage( 1969| 434| &arg_set_id_.non_null_vector(), 1970| 434| ColumnTypeHelper::ToColumnType(), 1971| 434| false)), 1972| 434| base64_proto_id_storage_layer_( 1973| 434| new column::NumericStorage( 1974| 434| &base64_proto_id_.non_null_vector(), 1975| 434| ColumnTypeHelper::ToColumnType(), 1976| 434| false)) 1977| |, 1978| 434| arg_set_id_null_layer_(new column::NullOverlay(arg_set_id_.bv())), 1979| 434| base64_proto_id_null_layer_(new column::NullOverlay(base64_proto_id_.bv())) { 1980| 434| static_assert( 1981| 434| ColumnLegacy::IsFlagsAndTypeValid( 1982| 434| ColumnFlag::event_id), 1983| 434| "Column type and flag combination is not valid"); 1984| 434| static_assert( 1985| 434| ColumnLegacy::IsFlagsAndTypeValid( 1986| 434| ColumnFlag::ts), 1987| 434| "Column type and flag combination is not valid"); 1988| 434| static_assert( 1989| 434| ColumnLegacy::IsFlagsAndTypeValid( 1990| 434| ColumnFlag::arg_set_id), 1991| 434| "Column type and flag combination is not valid"); 1992| 434| static_assert( 1993| 434| ColumnLegacy::IsFlagsAndTypeValid( 1994| 434| ColumnFlag::base64_proto_id), 1995| 434| "Column type and flag combination is not valid"); 1996| 434| OnConstructionCompletedRegularConstructor( 1997| 434| {id_storage_layer_,event_id_storage_layer_,ts_storage_layer_,arg_set_id_storage_layer_,base64_proto_id_storage_layer_}, 1998| 434| {{},{},{},arg_set_id_null_layer_,base64_proto_id_null_layer_}); 1999| 434| } _ZN8perfetto15trace_processor6tables24AndroidMotionEventsTable10GetColumnsEPS2_PKNS0_15macros_internal10MacroTableE: 2328| 434| const macros_internal::MacroTable* parent) { 2329| 434| std::vector columns = 2330| 434| CopyColumnsFromParentOrAddRootColumns(parent); 2331| 434| uint32_t olay_idx = OverlayCount(parent); 2332| 434| AddColumnToVector(columns, "event_id", &self->event_id_, ColumnFlag::event_id, 2333| 434| static_cast(columns.size()), olay_idx); 2334| 434| AddColumnToVector(columns, "ts", &self->ts_, ColumnFlag::ts, 2335| 434| static_cast(columns.size()), olay_idx); 2336| 434| AddColumnToVector(columns, "arg_set_id", &self->arg_set_id_, ColumnFlag::arg_set_id, 2337| 434| static_cast(columns.size()), olay_idx); 2338| 434| AddColumnToVector(columns, "base64_proto_id", &self->base64_proto_id_, ColumnFlag::base64_proto_id, 2339| 434| static_cast(columns.size()), olay_idx); 2340| 434| base::ignore_result(self); 2341| 434| return columns; 2342| 434| } _ZN8perfetto15trace_processor6tables24AndroidMotionEventsTableC2EPNS0_10StringPoolE: 2345| 434| : macros_internal::MacroTable( 2346| 434| pool, 2347| 434| GetColumns(this, nullptr), 2348| 434| nullptr), 2349| 434| event_id_(ColumnStorage::Create()), 2350| 434| ts_(ColumnStorage::Create()), 2351| 434| arg_set_id_(ColumnStorage::Create()), 2352| 434| base64_proto_id_(ColumnStorage::Create()) 2353| |, 2354| 434| id_storage_layer_(new column::IdStorage()), 2355| 434| event_id_storage_layer_( 2356| 434| new column::NumericStorage( 2357| 434| &event_id_.vector(), 2358| 434| ColumnTypeHelper::ToColumnType(), 2359| 434| false)), 2360| 434| ts_storage_layer_( 2361| 434| new column::NumericStorage( 2362| 434| &ts_.vector(), 2363| 434| ColumnTypeHelper::ToColumnType(), 2364| 434| false)), 2365| 434| arg_set_id_storage_layer_( 2366| 434| new column::NumericStorage( 2367| 434| &arg_set_id_.non_null_vector(), 2368| 434| ColumnTypeHelper::ToColumnType(), 2369| 434| false)), 2370| 434| base64_proto_id_storage_layer_( 2371| 434| new column::NumericStorage( 2372| 434| &base64_proto_id_.non_null_vector(), 2373| 434| ColumnTypeHelper::ToColumnType(), 2374| 434| false)) 2375| |, 2376| 434| arg_set_id_null_layer_(new column::NullOverlay(arg_set_id_.bv())), 2377| 434| base64_proto_id_null_layer_(new column::NullOverlay(base64_proto_id_.bv())) { 2378| 434| static_assert( 2379| 434| ColumnLegacy::IsFlagsAndTypeValid( 2380| 434| ColumnFlag::event_id), 2381| 434| "Column type and flag combination is not valid"); 2382| 434| static_assert( 2383| 434| ColumnLegacy::IsFlagsAndTypeValid( 2384| 434| ColumnFlag::ts), 2385| 434| "Column type and flag combination is not valid"); 2386| 434| static_assert( 2387| 434| ColumnLegacy::IsFlagsAndTypeValid( 2388| 434| ColumnFlag::arg_set_id), 2389| 434| "Column type and flag combination is not valid"); 2390| 434| static_assert( 2391| 434| ColumnLegacy::IsFlagsAndTypeValid( 2392| 434| ColumnFlag::base64_proto_id), 2393| 434| "Column type and flag combination is not valid"); 2394| 434| OnConstructionCompletedRegularConstructor( 2395| 434| {id_storage_layer_,event_id_storage_layer_,ts_storage_layer_,arg_set_id_storage_layer_,base64_proto_id_storage_layer_}, 2396| 434| {{},{},{},arg_set_id_null_layer_,base64_proto_id_null_layer_}); 2397| 434| } _ZN8perfetto15trace_processor6tables30AndroidInputEventDispatchTable10GetColumnsEPS2_PKNS0_15macros_internal10MacroTableE: 2745| 434| const macros_internal::MacroTable* parent) { 2746| 434| std::vector columns = 2747| 434| CopyColumnsFromParentOrAddRootColumns(parent); 2748| 434| uint32_t olay_idx = OverlayCount(parent); 2749| 434| AddColumnToVector(columns, "event_id", &self->event_id_, ColumnFlag::event_id, 2750| 434| static_cast(columns.size()), olay_idx); 2751| 434| AddColumnToVector(columns, "arg_set_id", &self->arg_set_id_, ColumnFlag::arg_set_id, 2752| 434| static_cast(columns.size()), olay_idx); 2753| 434| AddColumnToVector(columns, "vsync_id", &self->vsync_id_, ColumnFlag::vsync_id, 2754| 434| static_cast(columns.size()), olay_idx); 2755| 434| AddColumnToVector(columns, "window_id", &self->window_id_, ColumnFlag::window_id, 2756| 434| static_cast(columns.size()), olay_idx); 2757| 434| AddColumnToVector(columns, "base64_proto_id", &self->base64_proto_id_, ColumnFlag::base64_proto_id, 2758| 434| static_cast(columns.size()), olay_idx); 2759| 434| base::ignore_result(self); 2760| 434| return columns; 2761| 434| } _ZN8perfetto15trace_processor6tables30AndroidInputEventDispatchTableC2EPNS0_10StringPoolE: 2764| 434| : macros_internal::MacroTable( 2765| 434| pool, 2766| 434| GetColumns(this, nullptr), 2767| 434| nullptr), 2768| 434| event_id_(ColumnStorage::Create()), 2769| 434| arg_set_id_(ColumnStorage::Create()), 2770| 434| vsync_id_(ColumnStorage::Create()), 2771| 434| window_id_(ColumnStorage::Create()), 2772| 434| base64_proto_id_(ColumnStorage::Create()) 2773| |, 2774| 434| id_storage_layer_(new column::IdStorage()), 2775| 434| event_id_storage_layer_( 2776| 434| new column::NumericStorage( 2777| 434| &event_id_.vector(), 2778| 434| ColumnTypeHelper::ToColumnType(), 2779| 434| false)), 2780| 434| arg_set_id_storage_layer_( 2781| 434| new column::NumericStorage( 2782| 434| &arg_set_id_.non_null_vector(), 2783| 434| ColumnTypeHelper::ToColumnType(), 2784| 434| false)), 2785| 434| vsync_id_storage_layer_( 2786| 434| new column::NumericStorage( 2787| 434| &vsync_id_.vector(), 2788| 434| ColumnTypeHelper::ToColumnType(), 2789| 434| false)), 2790| 434| window_id_storage_layer_( 2791| 434| new column::NumericStorage( 2792| 434| &window_id_.vector(), 2793| 434| ColumnTypeHelper::ToColumnType(), 2794| 434| false)), 2795| 434| base64_proto_id_storage_layer_( 2796| 434| new column::NumericStorage( 2797| 434| &base64_proto_id_.non_null_vector(), 2798| 434| ColumnTypeHelper::ToColumnType(), 2799| 434| false)) 2800| |, 2801| 434| arg_set_id_null_layer_(new column::NullOverlay(arg_set_id_.bv())), 2802| 434| base64_proto_id_null_layer_(new column::NullOverlay(base64_proto_id_.bv())) { 2803| 434| static_assert( 2804| 434| ColumnLegacy::IsFlagsAndTypeValid( 2805| 434| ColumnFlag::event_id), 2806| 434| "Column type and flag combination is not valid"); 2807| 434| static_assert( 2808| 434| ColumnLegacy::IsFlagsAndTypeValid( 2809| 434| ColumnFlag::arg_set_id), 2810| 434| "Column type and flag combination is not valid"); 2811| 434| static_assert( 2812| 434| ColumnLegacy::IsFlagsAndTypeValid( 2813| 434| ColumnFlag::vsync_id), 2814| 434| "Column type and flag combination is not valid"); 2815| 434| static_assert( 2816| 434| ColumnLegacy::IsFlagsAndTypeValid( 2817| 434| ColumnFlag::window_id), 2818| 434| "Column type and flag combination is not valid"); 2819| 434| static_assert( 2820| 434| ColumnLegacy::IsFlagsAndTypeValid( 2821| 434| ColumnFlag::base64_proto_id), 2822| 434| "Column type and flag combination is not valid"); 2823| 434| OnConstructionCompletedRegularConstructor( 2824| 434| {id_storage_layer_,event_id_storage_layer_,arg_set_id_storage_layer_,vsync_id_storage_layer_,window_id_storage_layer_,base64_proto_id_storage_layer_}, 2825| 434| {{},{},arg_set_id_null_layer_,{},{},base64_proto_id_null_layer_}); 2826| 434| } _ZN8perfetto15trace_processor6tables12CounterTable2IdC2Ej: 47| 279k| explicit constexpr Id(uint32_t v) : BaseId(v) {} _ZN8perfetto15trace_processor6tables12CounterTable3RowC2ElNS1_10TrackTable2IdEdNSt3__18optionalIjEEDn: 72| 279k| : macros_internal::RootParentTable::Row(), 73| 279k| ts(in_ts), 74| 279k| track_id(in_track_id), 75| 279k| value(in_value), 76| 279k| arg_set_id(in_arg_set_id) {} _ZN8perfetto15trace_processor6tables12CounterTable9RowNumberC2Ej: 104| 558k| : AbstractRowNumber(row_number) {} _ZN8perfetto15trace_processor6tables12CounterTable17ConstRowReferenceC2EPKS2_j: 113| 558k| : AbstractConstRowReference(table, row_number) {} _ZN8perfetto15trace_processor6tables12CounterTable12RowReferenceC2EPKS2_j: 136| 558k| : ConstRowReference(table, row_number) {} _ZN8perfetto15trace_processor6tables12CounterTable10GetColumnsEPS2_PKNS0_15macros_internal10MacroTableE: 229| 434| const macros_internal::MacroTable* parent) { 230| 434| std::vector columns = 231| 434| CopyColumnsFromParentOrAddRootColumns(parent); 232| 434| uint32_t olay_idx = OverlayCount(parent); 233| 434| AddColumnToVector(columns, "ts", &self->ts_, ColumnFlag::ts, 234| 434| static_cast(columns.size()), olay_idx); 235| 434| AddColumnToVector(columns, "track_id", &self->track_id_, ColumnFlag::track_id, 236| 434| static_cast(columns.size()), olay_idx); 237| 434| AddColumnToVector(columns, "value", &self->value_, ColumnFlag::value, 238| 434| static_cast(columns.size()), olay_idx); 239| 434| AddColumnToVector(columns, "arg_set_id", &self->arg_set_id_, ColumnFlag::arg_set_id, 240| 434| static_cast(columns.size()), olay_idx); 241| 434| base::ignore_result(self); 242| 434| return columns; 243| 434| } _ZN8perfetto15trace_processor6tables12CounterTableC2EPNS0_10StringPoolE: 246| 434| : macros_internal::MacroTable( 247| 434| pool, 248| 434| GetColumns(this, nullptr), 249| 434| nullptr), 250| 434| ts_(ColumnStorage::Create()), 251| 434| track_id_(ColumnStorage::Create()), 252| 434| value_(ColumnStorage::Create()), 253| 434| arg_set_id_(ColumnStorage::Create()) 254| |, 255| 434| id_storage_layer_(new column::IdStorage()), 256| 434| ts_storage_layer_( 257| 434| new column::NumericStorage( 258| 434| &ts_.vector(), 259| 434| ColumnTypeHelper::ToColumnType(), 260| 434| true)), 261| 434| track_id_storage_layer_( 262| 434| new column::NumericStorage( 263| 434| &track_id_.vector(), 264| 434| ColumnTypeHelper::ToColumnType(), 265| 434| false)), 266| 434| value_storage_layer_( 267| 434| new column::NumericStorage( 268| 434| &value_.vector(), 269| 434| ColumnTypeHelper::ToColumnType(), 270| 434| false)), 271| 434| arg_set_id_storage_layer_( 272| 434| new column::NumericStorage( 273| 434| &arg_set_id_.non_null_vector(), 274| 434| ColumnTypeHelper::ToColumnType(), 275| 434| false)) 276| |, 277| 434| arg_set_id_null_layer_(new column::NullOverlay(arg_set_id_.bv())) { 278| 434| static_assert( 279| 434| ColumnLegacy::IsFlagsAndTypeValid( 280| 434| ColumnFlag::ts), 281| 434| "Column type and flag combination is not valid"); 282| 434| static_assert( 283| 434| ColumnLegacy::IsFlagsAndTypeValid( 284| 434| ColumnFlag::track_id), 285| 434| "Column type and flag combination is not valid"); 286| 434| static_assert( 287| 434| ColumnLegacy::IsFlagsAndTypeValid( 288| 434| ColumnFlag::value), 289| 434| "Column type and flag combination is not valid"); 290| 434| static_assert( 291| 434| ColumnLegacy::IsFlagsAndTypeValid( 292| 434| ColumnFlag::arg_set_id), 293| 434| "Column type and flag combination is not valid"); 294| 434| OnConstructionCompletedRegularConstructor( 295| 434| {id_storage_layer_,ts_storage_layer_,track_id_storage_layer_,value_storage_layer_,arg_set_id_storage_layer_}, 296| 434| {{},{},{},{},arg_set_id_null_layer_}); 297| 434| } _ZN8perfetto15trace_processor6tables12CounterTable8FindByIdENS2_2IdE: 367| 279k| std::optional FindById(Id find_id) { 368| 279k| std::optional row = id().IndexOf(find_id); 369| 279k| return row ? std::make_optional(RowReference(this, *row)) : std::nullopt; ------------------ | Branch (369:12): [True: 279k, False: 0] ------------------ 370| 279k| } _ZN8perfetto15trace_processor6tables12CounterTable6InsertERKNS2_3RowE: 372| 279k| IdAndRow Insert(const Row& row) { 373| 279k| uint32_t row_number = row_count(); 374| 279k| Id id = Id{row_number}; 375| 279k| mutable_ts()->Append(row.ts); 376| 279k| mutable_track_id()->Append(row.track_id); 377| 279k| mutable_value()->Append(row.value); 378| 279k| mutable_arg_set_id()->Append(row.arg_set_id); 379| 279k| UpdateSelfOverlayAfterInsert(); 380| 279k| return IdAndRow{id, row_number, RowReference(this, row_number), 381| 279k| RowNumber(row_number)}; 382| 279k| } _ZNK8perfetto15trace_processor6tables12CounterTable2idEv: 386| 279k| const IdColumn& id() const { 387| 279k| return static_cast(columns()[ColumnIndex::id]); 388| 279k| } _ZN8perfetto15trace_processor6tables12CounterTable10mutable_tsEv: 402| 279k| TypedColumn* mutable_ts() { 403| 279k| return static_cast( 404| 279k| GetColumn(ColumnIndex::ts)); 405| 279k| } _ZN8perfetto15trace_processor6tables12CounterTable16mutable_track_idEv: 406| 279k| TypedColumn* mutable_track_id() { 407| 279k| return static_cast( 408| 279k| GetColumn(ColumnIndex::track_id)); 409| 279k| } _ZN8perfetto15trace_processor6tables12CounterTable13mutable_valueEv: 410| 279k| TypedColumn* mutable_value() { 411| 279k| return static_cast( 412| 279k| GetColumn(ColumnIndex::value)); 413| 279k| } _ZN8perfetto15trace_processor6tables12CounterTable18mutable_arg_set_idEv: 414| 558k| TypedColumn>* mutable_arg_set_id() { 415| 558k| return static_cast( 416| 558k| GetColumn(ColumnIndex::arg_set_id)); 417| 558k| } _ZN8perfetto15trace_processor6tables23EtmV4ConfigurationTable10GetColumnsEPS2_PKNS0_15macros_internal10MacroTableE: 324| 434| const macros_internal::MacroTable* parent) { 325| 434| std::vector columns = 326| 434| CopyColumnsFromParentOrAddRootColumns(parent); 327| 434| uint32_t olay_idx = OverlayCount(parent); 328| 434| AddColumnToVector(columns, "set_id", &self->set_id_, ColumnFlag::set_id, 329| 434| static_cast(columns.size()), olay_idx); 330| 434| AddColumnToVector(columns, "cpu", &self->cpu_, ColumnFlag::cpu, 331| 434| static_cast(columns.size()), olay_idx); 332| 434| AddColumnToVector(columns, "cs_trace_id", &self->cs_trace_id_, ColumnFlag::cs_trace_id, 333| 434| static_cast(columns.size()), olay_idx); 334| 434| AddColumnToVector(columns, "core_profile", &self->core_profile_, ColumnFlag::core_profile, 335| 434| static_cast(columns.size()), olay_idx); 336| 434| AddColumnToVector(columns, "arch_version", &self->arch_version_, ColumnFlag::arch_version, 337| 434| static_cast(columns.size()), olay_idx); 338| 434| AddColumnToVector(columns, "major_version", &self->major_version_, ColumnFlag::major_version, 339| 434| static_cast(columns.size()), olay_idx); 340| 434| AddColumnToVector(columns, "minor_version", &self->minor_version_, ColumnFlag::minor_version, 341| 434| static_cast(columns.size()), olay_idx); 342| 434| AddColumnToVector(columns, "max_speculation_depth", &self->max_speculation_depth_, ColumnFlag::max_speculation_depth, 343| 434| static_cast(columns.size()), olay_idx); 344| 434| AddColumnToVector(columns, "bool_flags", &self->bool_flags_, ColumnFlag::bool_flags, 345| 434| static_cast(columns.size()), olay_idx); 346| 434| base::ignore_result(self); 347| 434| return columns; 348| 434| } _ZN8perfetto15trace_processor6tables23EtmV4ConfigurationTableC2EPNS0_10StringPoolE: 351| 434| : macros_internal::MacroTable( 352| 434| pool, 353| 434| GetColumns(this, nullptr), 354| 434| nullptr), 355| 434| set_id_(ColumnStorage::Create()), 356| 434| cpu_(ColumnStorage::Create()), 357| 434| cs_trace_id_(ColumnStorage::Create()), 358| 434| core_profile_(ColumnStorage::Create()), 359| 434| arch_version_(ColumnStorage::Create()), 360| 434| major_version_(ColumnStorage::Create()), 361| 434| minor_version_(ColumnStorage::Create()), 362| 434| max_speculation_depth_(ColumnStorage::Create()), 363| 434| bool_flags_(ColumnStorage::Create()) 364| |, 365| 434| id_storage_layer_(new column::IdStorage()), 366| 434| set_id_storage_layer_( 367| 434| new column::SetIdStorage(&set_id_.vector())), 368| 434| cpu_storage_layer_( 369| 434| new column::NumericStorage( 370| 434| &cpu_.vector(), 371| 434| ColumnTypeHelper::ToColumnType(), 372| 434| false)), 373| 434| cs_trace_id_storage_layer_( 374| 434| new column::NumericStorage( 375| 434| &cs_trace_id_.vector(), 376| 434| ColumnTypeHelper::ToColumnType(), 377| 434| false)), 378| 434| core_profile_storage_layer_( 379| 434| new column::StringStorage(string_pool(), &core_profile_.vector())), 380| 434| arch_version_storage_layer_( 381| 434| new column::StringStorage(string_pool(), &arch_version_.vector())), 382| 434| major_version_storage_layer_( 383| 434| new column::NumericStorage( 384| 434| &major_version_.vector(), 385| 434| ColumnTypeHelper::ToColumnType(), 386| 434| false)), 387| 434| minor_version_storage_layer_( 388| 434| new column::NumericStorage( 389| 434| &minor_version_.vector(), 390| 434| ColumnTypeHelper::ToColumnType(), 391| 434| false)), 392| 434| max_speculation_depth_storage_layer_( 393| 434| new column::NumericStorage( 394| 434| &max_speculation_depth_.vector(), 395| 434| ColumnTypeHelper::ToColumnType(), 396| 434| false)), 397| 434| bool_flags_storage_layer_( 398| 434| new column::NumericStorage( 399| 434| &bool_flags_.vector(), 400| 434| ColumnTypeHelper::ToColumnType(), 401| 434| false)) 402| 434| { 403| 434| static_assert( 404| 434| ColumnLegacy::IsFlagsAndTypeValid( 405| 434| ColumnFlag::set_id), 406| 434| "Column type and flag combination is not valid"); 407| 434| static_assert( 408| 434| ColumnLegacy::IsFlagsAndTypeValid( 409| 434| ColumnFlag::cpu), 410| 434| "Column type and flag combination is not valid"); 411| 434| static_assert( 412| 434| ColumnLegacy::IsFlagsAndTypeValid( 413| 434| ColumnFlag::cs_trace_id), 414| 434| "Column type and flag combination is not valid"); 415| 434| static_assert( 416| 434| ColumnLegacy::IsFlagsAndTypeValid( 417| 434| ColumnFlag::core_profile), 418| 434| "Column type and flag combination is not valid"); 419| 434| static_assert( 420| 434| ColumnLegacy::IsFlagsAndTypeValid( 421| 434| ColumnFlag::arch_version), 422| 434| "Column type and flag combination is not valid"); 423| 434| static_assert( 424| 434| ColumnLegacy::IsFlagsAndTypeValid( 425| 434| ColumnFlag::major_version), 426| 434| "Column type and flag combination is not valid"); 427| 434| static_assert( 428| 434| ColumnLegacy::IsFlagsAndTypeValid( 429| 434| ColumnFlag::minor_version), 430| 434| "Column type and flag combination is not valid"); 431| 434| static_assert( 432| 434| ColumnLegacy::IsFlagsAndTypeValid( 433| 434| ColumnFlag::max_speculation_depth), 434| 434| "Column type and flag combination is not valid"); 435| 434| static_assert( 436| 434| ColumnLegacy::IsFlagsAndTypeValid( 437| 434| ColumnFlag::bool_flags), 438| 434| "Column type and flag combination is not valid"); 439| 434| OnConstructionCompletedRegularConstructor( 440| 434| {id_storage_layer_,set_id_storage_layer_,cpu_storage_layer_,cs_trace_id_storage_layer_,core_profile_storage_layer_,arch_version_storage_layer_,major_version_storage_layer_,minor_version_storage_layer_,max_speculation_depth_storage_layer_,bool_flags_storage_layer_}, 441| 434| {{},{},{},{},{},{},{},{},{},{}}); 442| 434| } _ZN8perfetto15trace_processor6tables17EtmV4SessionTable10GetColumnsEPS2_PKNS0_15macros_internal10MacroTableE: 812| 434| const macros_internal::MacroTable* parent) { 813| 434| std::vector columns = 814| 434| CopyColumnsFromParentOrAddRootColumns(parent); 815| 434| uint32_t olay_idx = OverlayCount(parent); 816| 434| AddColumnToVector(columns, "configuration_id", &self->configuration_id_, ColumnFlag::configuration_id, 817| 434| static_cast(columns.size()), olay_idx); 818| 434| AddColumnToVector(columns, "start_ts", &self->start_ts_, ColumnFlag::start_ts, 819| 434| static_cast(columns.size()), olay_idx); 820| 434| base::ignore_result(self); 821| 434| return columns; 822| 434| } _ZN8perfetto15trace_processor6tables17EtmV4SessionTableC2EPNS0_10StringPoolE: 825| 434| : macros_internal::MacroTable( 826| 434| pool, 827| 434| GetColumns(this, nullptr), 828| 434| nullptr), 829| 434| configuration_id_(ColumnStorage::Create()), 830| 434| start_ts_(ColumnStorage::Create()) 831| |, 832| 434| id_storage_layer_(new column::IdStorage()), 833| 434| configuration_id_storage_layer_( 834| 434| new column::NumericStorage( 835| 434| &configuration_id_.vector(), 836| 434| ColumnTypeHelper::ToColumnType(), 837| 434| false)), 838| 434| start_ts_storage_layer_( 839| 434| new column::NumericStorage( 840| 434| &start_ts_.non_null_vector(), 841| 434| ColumnTypeHelper::ToColumnType(), 842| 434| false)) 843| |, 844| 434| start_ts_null_layer_(new column::NullOverlay(start_ts_.bv())) { 845| 434| static_assert( 846| 434| ColumnLegacy::IsFlagsAndTypeValid( 847| 434| ColumnFlag::configuration_id), 848| 434| "Column type and flag combination is not valid"); 849| 434| static_assert( 850| 434| ColumnLegacy::IsFlagsAndTypeValid( 851| 434| ColumnFlag::start_ts), 852| 434| "Column type and flag combination is not valid"); 853| 434| OnConstructionCompletedRegularConstructor( 854| 434| {id_storage_layer_,configuration_id_storage_layer_,start_ts_storage_layer_}, 855| 434| {{},{},start_ts_null_layer_}); 856| 434| } _ZN8perfetto15trace_processor6tables15EtmV4TraceTable10GetColumnsEPS2_PKNS0_15macros_internal10MacroTableE: 1133| 434| const macros_internal::MacroTable* parent) { 1134| 434| std::vector columns = 1135| 434| CopyColumnsFromParentOrAddRootColumns(parent); 1136| 434| uint32_t olay_idx = OverlayCount(parent); 1137| 434| AddColumnToVector(columns, "session_id", &self->session_id_, ColumnFlag::session_id, 1138| 434| static_cast(columns.size()), olay_idx); 1139| 434| AddColumnToVector(columns, "trace_set_id", &self->trace_set_id_, ColumnFlag::trace_set_id, 1140| 434| static_cast(columns.size()), olay_idx); 1141| 434| AddColumnToVector(columns, "size", &self->size_, ColumnFlag::size, 1142| 434| static_cast(columns.size()), olay_idx); 1143| 434| base::ignore_result(self); 1144| 434| return columns; 1145| 434| } _ZN8perfetto15trace_processor6tables15EtmV4TraceTableC2EPNS0_10StringPoolE: 1148| 434| : macros_internal::MacroTable( 1149| 434| pool, 1150| 434| GetColumns(this, nullptr), 1151| 434| nullptr), 1152| 434| session_id_(ColumnStorage::Create()), 1153| 434| trace_set_id_(ColumnStorage::Create()), 1154| 434| size_(ColumnStorage::Create()) 1155| |, 1156| 434| id_storage_layer_(new column::IdStorage()), 1157| 434| session_id_storage_layer_( 1158| 434| new column::NumericStorage( 1159| 434| &session_id_.vector(), 1160| 434| ColumnTypeHelper::ToColumnType(), 1161| 434| false)), 1162| 434| trace_set_id_storage_layer_( 1163| 434| new column::SetIdStorage(&trace_set_id_.vector())), 1164| 434| size_storage_layer_( 1165| 434| new column::NumericStorage( 1166| 434| &size_.vector(), 1167| 434| ColumnTypeHelper::ToColumnType(), 1168| 434| false)) 1169| 434| { 1170| 434| static_assert( 1171| 434| ColumnLegacy::IsFlagsAndTypeValid( 1172| 434| ColumnFlag::session_id), 1173| 434| "Column type and flag combination is not valid"); 1174| 434| static_assert( 1175| 434| ColumnLegacy::IsFlagsAndTypeValid( 1176| 434| ColumnFlag::trace_set_id), 1177| 434| "Column type and flag combination is not valid"); 1178| 434| static_assert( 1179| 434| ColumnLegacy::IsFlagsAndTypeValid( 1180| 434| ColumnFlag::size), 1181| 434| "Column type and flag combination is not valid"); 1182| 434| OnConstructionCompletedRegularConstructor( 1183| 434| {id_storage_layer_,session_id_storage_layer_,trace_set_id_storage_layer_,size_storage_layer_}, 1184| 434| {{},{},{},{}}); 1185| 434| } _ZN8perfetto15trace_processor6tables9FileTable10GetColumnsEPS2_PKNS0_15macros_internal10MacroTableE: 1459| 434| const macros_internal::MacroTable* parent) { 1460| 434| std::vector columns = 1461| 434| CopyColumnsFromParentOrAddRootColumns(parent); 1462| 434| uint32_t olay_idx = OverlayCount(parent); 1463| 434| AddColumnToVector(columns, "name", &self->name_, ColumnFlag::name, 1464| 434| static_cast(columns.size()), olay_idx); 1465| 434| AddColumnToVector(columns, "size", &self->size_, ColumnFlag::size, 1466| 434| static_cast(columns.size()), olay_idx); 1467| 434| base::ignore_result(self); 1468| 434| return columns; 1469| 434| } _ZN8perfetto15trace_processor6tables9FileTableC2EPNS0_10StringPoolE: 1472| 434| : macros_internal::MacroTable( 1473| 434| pool, 1474| 434| GetColumns(this, nullptr), 1475| 434| nullptr), 1476| 434| name_(ColumnStorage::Create()), 1477| 434| size_(ColumnStorage::Create()) 1478| |, 1479| 434| id_storage_layer_(new column::IdStorage()), 1480| 434| name_storage_layer_( 1481| 434| new column::StringStorage(string_pool(), &name_.vector())), 1482| 434| size_storage_layer_( 1483| 434| new column::NumericStorage( 1484| 434| &size_.vector(), 1485| 434| ColumnTypeHelper::ToColumnType(), 1486| 434| false)) 1487| 434| { 1488| 434| static_assert( 1489| 434| ColumnLegacy::IsFlagsAndTypeValid( 1490| 434| ColumnFlag::name), 1491| 434| "Column type and flag combination is not valid"); 1492| 434| static_assert( 1493| 434| ColumnLegacy::IsFlagsAndTypeValid( 1494| 434| ColumnFlag::size), 1495| 434| "Column type and flag combination is not valid"); 1496| 434| OnConstructionCompletedRegularConstructor( 1497| 434| {id_storage_layer_,name_storage_layer_,size_storage_layer_}, 1498| 434| {{},{},{}}); 1499| 434| } _ZN8perfetto15trace_processor6tables12ElfFileTable10GetColumnsEPS2_PKNS0_15macros_internal10MacroTableE: 1776| 434| const macros_internal::MacroTable* parent) { 1777| 434| std::vector columns = 1778| 434| CopyColumnsFromParentOrAddRootColumns(parent); 1779| 434| uint32_t olay_idx = OverlayCount(parent); 1780| 434| AddColumnToVector(columns, "file_id", &self->file_id_, ColumnFlag::file_id, 1781| 434| static_cast(columns.size()), olay_idx); 1782| 434| AddColumnToVector(columns, "load_bias", &self->load_bias_, ColumnFlag::load_bias, 1783| 434| static_cast(columns.size()), olay_idx); 1784| 434| AddColumnToVector(columns, "build_id", &self->build_id_, ColumnFlag::build_id, 1785| 434| static_cast(columns.size()), olay_idx); 1786| 434| base::ignore_result(self); 1787| 434| return columns; 1788| 434| } _ZN8perfetto15trace_processor6tables12ElfFileTableC2EPNS0_10StringPoolE: 1791| 434| : macros_internal::MacroTable( 1792| 434| pool, 1793| 434| GetColumns(this, nullptr), 1794| 434| nullptr), 1795| 434| file_id_(ColumnStorage::Create()), 1796| 434| load_bias_(ColumnStorage::Create()), 1797| 434| build_id_(ColumnStorage::Create()) 1798| |, 1799| 434| id_storage_layer_(new column::IdStorage()), 1800| 434| file_id_storage_layer_( 1801| 434| new column::NumericStorage( 1802| 434| &file_id_.vector(), 1803| 434| ColumnTypeHelper::ToColumnType(), 1804| 434| false)), 1805| 434| load_bias_storage_layer_( 1806| 434| new column::NumericStorage( 1807| 434| &load_bias_.vector(), 1808| 434| ColumnTypeHelper::ToColumnType(), 1809| 434| false)), 1810| 434| build_id_storage_layer_( 1811| 434| new column::StringStorage(string_pool(), &build_id_.vector())) 1812| 434| { 1813| 434| static_assert( 1814| 434| ColumnLegacy::IsFlagsAndTypeValid( 1815| 434| ColumnFlag::file_id), 1816| 434| "Column type and flag combination is not valid"); 1817| 434| static_assert( 1818| 434| ColumnLegacy::IsFlagsAndTypeValid( 1819| 434| ColumnFlag::load_bias), 1820| 434| "Column type and flag combination is not valid"); 1821| 434| static_assert( 1822| 434| ColumnLegacy::IsFlagsAndTypeValid( 1823| 434| ColumnFlag::build_id), 1824| 434| "Column type and flag combination is not valid"); 1825| 434| OnConstructionCompletedRegularConstructor( 1826| 434| {id_storage_layer_,file_id_storage_layer_,load_bias_storage_layer_,build_id_storage_layer_}, 1827| 434| {{},{},{},{}}); 1828| 434| } _ZN8perfetto15trace_processor6tables9FlowTable2IdC2Ej: 47| 1.40k| explicit constexpr Id(uint32_t v) : BaseId(v) {} _ZN8perfetto15trace_processor6tables9FlowTable3RowC2ENS1_10SliceTable2IdES5_NSt3__18optionalIlEENS7_IjEEDn: 72| 1.40k| : macros_internal::RootParentTable::Row(), 73| 1.40k| slice_out(in_slice_out), 74| 1.40k| slice_in(in_slice_in), 75| 1.40k| trace_id(in_trace_id), 76| 1.40k| arg_set_id(in_arg_set_id) {} _ZN8perfetto15trace_processor6tables9FlowTable9RowNumberC2Ej: 104| 2.79k| : AbstractRowNumber(row_number) {} _ZN8perfetto15trace_processor6tables9FlowTable17ConstRowReferenceC2EPKS2_j: 113| 2.79k| : AbstractConstRowReference(table, row_number) {} _ZN8perfetto15trace_processor6tables9FlowTable12RowReferenceC2EPKS2_j: 136| 2.79k| : ConstRowReference(table, row_number) {} _ZN8perfetto15trace_processor6tables9FlowTable10GetColumnsEPS2_PKNS0_15macros_internal10MacroTableE: 229| 434| const macros_internal::MacroTable* parent) { 230| 434| std::vector columns = 231| 434| CopyColumnsFromParentOrAddRootColumns(parent); 232| 434| uint32_t olay_idx = OverlayCount(parent); 233| 434| AddColumnToVector(columns, "slice_out", &self->slice_out_, ColumnFlag::slice_out, 234| 434| static_cast(columns.size()), olay_idx); 235| 434| AddColumnToVector(columns, "slice_in", &self->slice_in_, ColumnFlag::slice_in, 236| 434| static_cast(columns.size()), olay_idx); 237| 434| AddColumnToVector(columns, "trace_id", &self->trace_id_, ColumnFlag::trace_id, 238| 434| static_cast(columns.size()), olay_idx); 239| 434| AddColumnToVector(columns, "arg_set_id", &self->arg_set_id_, ColumnFlag::arg_set_id, 240| 434| static_cast(columns.size()), olay_idx); 241| 434| base::ignore_result(self); 242| 434| return columns; 243| 434| } _ZN8perfetto15trace_processor6tables9FlowTableC2EPNS0_10StringPoolE: 246| 434| : macros_internal::MacroTable( 247| 434| pool, 248| 434| GetColumns(this, nullptr), 249| 434| nullptr), 250| 434| slice_out_(ColumnStorage::Create()), 251| 434| slice_in_(ColumnStorage::Create()), 252| 434| trace_id_(ColumnStorage::Create()), 253| 434| arg_set_id_(ColumnStorage::Create()) 254| |, 255| 434| id_storage_layer_(new column::IdStorage()), 256| 434| slice_out_storage_layer_( 257| 434| new column::NumericStorage( 258| 434| &slice_out_.vector(), 259| 434| ColumnTypeHelper::ToColumnType(), 260| 434| false)), 261| 434| slice_in_storage_layer_( 262| 434| new column::NumericStorage( 263| 434| &slice_in_.vector(), 264| 434| ColumnTypeHelper::ToColumnType(), 265| 434| false)), 266| 434| trace_id_storage_layer_( 267| 434| new column::NumericStorage( 268| 434| &trace_id_.non_null_vector(), 269| 434| ColumnTypeHelper::ToColumnType(), 270| 434| false)), 271| 434| arg_set_id_storage_layer_( 272| 434| new column::NumericStorage( 273| 434| &arg_set_id_.non_null_vector(), 274| 434| ColumnTypeHelper::ToColumnType(), 275| 434| false)) 276| |, 277| 434| trace_id_null_layer_(new column::NullOverlay(trace_id_.bv())), 278| 434| arg_set_id_null_layer_(new column::NullOverlay(arg_set_id_.bv())) { 279| 434| static_assert( 280| 434| ColumnLegacy::IsFlagsAndTypeValid( 281| 434| ColumnFlag::slice_out), 282| 434| "Column type and flag combination is not valid"); 283| 434| static_assert( 284| 434| ColumnLegacy::IsFlagsAndTypeValid( 285| 434| ColumnFlag::slice_in), 286| 434| "Column type and flag combination is not valid"); 287| 434| static_assert( 288| 434| ColumnLegacy::IsFlagsAndTypeValid( 289| 434| ColumnFlag::trace_id), 290| 434| "Column type and flag combination is not valid"); 291| 434| static_assert( 292| 434| ColumnLegacy::IsFlagsAndTypeValid( 293| 434| ColumnFlag::arg_set_id), 294| 434| "Column type and flag combination is not valid"); 295| 434| OnConstructionCompletedRegularConstructor( 296| 434| {id_storage_layer_,slice_out_storage_layer_,slice_in_storage_layer_,trace_id_storage_layer_,arg_set_id_storage_layer_}, 297| 434| {{},{},{},trace_id_null_layer_,arg_set_id_null_layer_}); 298| 434| } _ZN8perfetto15trace_processor6tables9FlowTable8FindByIdENS2_2IdE: 368| 1.39k| std::optional FindById(Id find_id) { 369| 1.39k| std::optional row = id().IndexOf(find_id); 370| 1.39k| return row ? std::make_optional(RowReference(this, *row)) : std::nullopt; ------------------ | Branch (370:12): [True: 1.39k, False: 0] ------------------ 371| 1.39k| } _ZN8perfetto15trace_processor6tables9FlowTable6InsertERKNS2_3RowE: 373| 1.40k| IdAndRow Insert(const Row& row) { 374| 1.40k| uint32_t row_number = row_count(); 375| 1.40k| Id id = Id{row_number}; 376| 1.40k| mutable_slice_out()->Append(row.slice_out); 377| 1.40k| mutable_slice_in()->Append(row.slice_in); 378| 1.40k| mutable_trace_id()->Append(row.trace_id); 379| 1.40k| mutable_arg_set_id()->Append(row.arg_set_id); 380| 1.40k| UpdateSelfOverlayAfterInsert(); 381| 1.40k| return IdAndRow{id, row_number, RowReference(this, row_number), 382| 1.40k| RowNumber(row_number)}; 383| 1.40k| } _ZNK8perfetto15trace_processor6tables9FlowTable2idEv: 387| 1.39k| const IdColumn& id() const { 388| 1.39k| return static_cast(columns()[ColumnIndex::id]); 389| 1.39k| } _ZN8perfetto15trace_processor6tables9FlowTable17mutable_slice_outEv: 403| 1.40k| TypedColumn* mutable_slice_out() { 404| 1.40k| return static_cast( 405| 1.40k| GetColumn(ColumnIndex::slice_out)); 406| 1.40k| } _ZN8perfetto15trace_processor6tables9FlowTable16mutable_slice_inEv: 407| 1.40k| TypedColumn* mutable_slice_in() { 408| 1.40k| return static_cast( 409| 1.40k| GetColumn(ColumnIndex::slice_in)); 410| 1.40k| } _ZN8perfetto15trace_processor6tables9FlowTable16mutable_trace_idEv: 411| 1.40k| TypedColumn>* mutable_trace_id() { 412| 1.40k| return static_cast( 413| 1.40k| GetColumn(ColumnIndex::trace_id)); 414| 1.40k| } _ZN8perfetto15trace_processor6tables9FlowTable18mutable_arg_set_idEv: 415| 2.79k| TypedColumn>* mutable_arg_set_id() { 416| 2.79k| return static_cast( 417| 2.79k| GetColumn(ColumnIndex::arg_set_id)); 418| 2.79k| } _ZN8perfetto15trace_processor6tables12JitCodeTable10GetColumnsEPS2_PKNS0_15macros_internal10MacroTableE: 286| 434| const macros_internal::MacroTable* parent) { 287| 434| std::vector columns = 288| 434| CopyColumnsFromParentOrAddRootColumns(parent); 289| 434| uint32_t olay_idx = OverlayCount(parent); 290| 434| AddColumnToVector(columns, "create_ts", &self->create_ts_, ColumnFlag::create_ts, 291| 434| static_cast(columns.size()), olay_idx); 292| 434| AddColumnToVector(columns, "estimated_delete_ts", &self->estimated_delete_ts_, ColumnFlag::estimated_delete_ts, 293| 434| static_cast(columns.size()), olay_idx); 294| 434| AddColumnToVector(columns, "utid", &self->utid_, ColumnFlag::utid, 295| 434| static_cast(columns.size()), olay_idx); 296| 434| AddColumnToVector(columns, "start_address", &self->start_address_, ColumnFlag::start_address, 297| 434| static_cast(columns.size()), olay_idx); 298| 434| AddColumnToVector(columns, "size", &self->size_, ColumnFlag::size, 299| 434| static_cast(columns.size()), olay_idx); 300| 434| AddColumnToVector(columns, "function_name", &self->function_name_, ColumnFlag::function_name, 301| 434| static_cast(columns.size()), olay_idx); 302| 434| AddColumnToVector(columns, "native_code_base64", &self->native_code_base64_, ColumnFlag::native_code_base64, 303| 434| static_cast(columns.size()), olay_idx); 304| 434| base::ignore_result(self); 305| 434| return columns; 306| 434| } _ZN8perfetto15trace_processor6tables12JitCodeTableC2EPNS0_10StringPoolE: 309| 434| : macros_internal::MacroTable( 310| 434| pool, 311| 434| GetColumns(this, nullptr), 312| 434| nullptr), 313| 434| create_ts_(ColumnStorage::Create()), 314| 434| estimated_delete_ts_(ColumnStorage::Create()), 315| 434| utid_(ColumnStorage::Create()), 316| 434| start_address_(ColumnStorage::Create()), 317| 434| size_(ColumnStorage::Create()), 318| 434| function_name_(ColumnStorage::Create()), 319| 434| native_code_base64_(ColumnStorage::Create()) 320| |, 321| 434| id_storage_layer_(new column::IdStorage()), 322| 434| create_ts_storage_layer_( 323| 434| new column::NumericStorage( 324| 434| &create_ts_.vector(), 325| 434| ColumnTypeHelper::ToColumnType(), 326| 434| true)), 327| 434| estimated_delete_ts_storage_layer_( 328| 434| new column::NumericStorage( 329| 434| &estimated_delete_ts_.non_null_vector(), 330| 434| ColumnTypeHelper::ToColumnType(), 331| 434| false)), 332| 434| utid_storage_layer_( 333| 434| new column::NumericStorage( 334| 434| &utid_.vector(), 335| 434| ColumnTypeHelper::ToColumnType(), 336| 434| false)), 337| 434| start_address_storage_layer_( 338| 434| new column::NumericStorage( 339| 434| &start_address_.vector(), 340| 434| ColumnTypeHelper::ToColumnType(), 341| 434| false)), 342| 434| size_storage_layer_( 343| 434| new column::NumericStorage( 344| 434| &size_.vector(), 345| 434| ColumnTypeHelper::ToColumnType(), 346| 434| false)), 347| 434| function_name_storage_layer_( 348| 434| new column::StringStorage(string_pool(), &function_name_.vector())), 349| 434| native_code_base64_storage_layer_( 350| 434| new column::StringStorage(string_pool(), &native_code_base64_.vector())) 351| |, 352| 434| estimated_delete_ts_null_layer_(new column::NullOverlay(estimated_delete_ts_.bv())) { 353| 434| static_assert( 354| 434| ColumnLegacy::IsFlagsAndTypeValid( 355| 434| ColumnFlag::create_ts), 356| 434| "Column type and flag combination is not valid"); 357| 434| static_assert( 358| 434| ColumnLegacy::IsFlagsAndTypeValid( 359| 434| ColumnFlag::estimated_delete_ts), 360| 434| "Column type and flag combination is not valid"); 361| 434| static_assert( 362| 434| ColumnLegacy::IsFlagsAndTypeValid( 363| 434| ColumnFlag::utid), 364| 434| "Column type and flag combination is not valid"); 365| 434| static_assert( 366| 434| ColumnLegacy::IsFlagsAndTypeValid( 367| 434| ColumnFlag::start_address), 368| 434| "Column type and flag combination is not valid"); 369| 434| static_assert( 370| 434| ColumnLegacy::IsFlagsAndTypeValid( 371| 434| ColumnFlag::size), 372| 434| "Column type and flag combination is not valid"); 373| 434| static_assert( 374| 434| ColumnLegacy::IsFlagsAndTypeValid( 375| 434| ColumnFlag::function_name), 376| 434| "Column type and flag combination is not valid"); 377| 434| static_assert( 378| 434| ColumnLegacy::IsFlagsAndTypeValid( 379| 434| ColumnFlag::native_code_base64), 380| 434| "Column type and flag combination is not valid"); 381| 434| OnConstructionCompletedRegularConstructor( 382| 434| {id_storage_layer_,create_ts_storage_layer_,estimated_delete_ts_storage_layer_,utid_storage_layer_,start_address_storage_layer_,size_storage_layer_,function_name_storage_layer_,native_code_base64_storage_layer_}, 383| 434| {{},{},estimated_delete_ts_null_layer_,{},{},{},{},{}}); 384| 434| } _ZN8perfetto15trace_processor6tables13JitFrameTable10GetColumnsEPS2_PKNS0_15macros_internal10MacroTableE: 722| 434| const macros_internal::MacroTable* parent) { 723| 434| std::vector columns = 724| 434| CopyColumnsFromParentOrAddRootColumns(parent); 725| 434| uint32_t olay_idx = OverlayCount(parent); 726| 434| AddColumnToVector(columns, "jit_code_id", &self->jit_code_id_, ColumnFlag::jit_code_id, 727| 434| static_cast(columns.size()), olay_idx); 728| 434| AddColumnToVector(columns, "frame_id", &self->frame_id_, ColumnFlag::frame_id, 729| 434| static_cast(columns.size()), olay_idx); 730| 434| base::ignore_result(self); 731| 434| return columns; 732| 434| } _ZN8perfetto15trace_processor6tables13JitFrameTableC2EPNS0_10StringPoolE: 735| 434| : macros_internal::MacroTable( 736| 434| pool, 737| 434| GetColumns(this, nullptr), 738| 434| nullptr), 739| 434| jit_code_id_(ColumnStorage::Create()), 740| 434| frame_id_(ColumnStorage::Create()) 741| |, 742| 434| id_storage_layer_(new column::IdStorage()), 743| 434| jit_code_id_storage_layer_( 744| 434| new column::NumericStorage( 745| 434| &jit_code_id_.vector(), 746| 434| ColumnTypeHelper::ToColumnType(), 747| 434| false)), 748| 434| frame_id_storage_layer_( 749| 434| new column::NumericStorage( 750| 434| &frame_id_.vector(), 751| 434| ColumnTypeHelper::ToColumnType(), 752| 434| false)) 753| 434| { 754| 434| static_assert( 755| 434| ColumnLegacy::IsFlagsAndTypeValid( 756| 434| ColumnFlag::jit_code_id), 757| 434| "Column type and flag combination is not valid"); 758| 434| static_assert( 759| 434| ColumnLegacy::IsFlagsAndTypeValid( 760| 434| ColumnFlag::frame_id), 761| 434| "Column type and flag combination is not valid"); 762| 434| OnConstructionCompletedRegularConstructor( 763| 434| {id_storage_layer_,jit_code_id_storage_layer_,frame_id_storage_layer_}, 764| 434| {{},{},{}}); 765| 434| } _ZN8perfetto15trace_processor6tables19MemorySnapshotTable2IdC2Ej: 47| 641| explicit constexpr Id(uint32_t v) : BaseId(v) {} _ZN8perfetto15trace_processor6tables19MemorySnapshotTable3RowC2ElNS1_10TrackTable2IdENS0_10StringPool2IdEDn: 69| 641| : macros_internal::RootParentTable::Row(), 70| 641| timestamp(in_timestamp), 71| 641| track_id(in_track_id), 72| 641| detail_level(in_detail_level) {} _ZN8perfetto15trace_processor6tables19MemorySnapshotTable9RowNumberC2Ej: 97| 641| : AbstractRowNumber(row_number) {} _ZN8perfetto15trace_processor6tables19MemorySnapshotTable17ConstRowReferenceC2EPKS2_j: 106| 641| : AbstractConstRowReference(table, row_number) {} _ZN8perfetto15trace_processor6tables19MemorySnapshotTable12RowReferenceC2EPKS2_j: 126| 641| : ConstRowReference(table, row_number) {} _ZN8perfetto15trace_processor6tables19MemorySnapshotTable10GetColumnsEPS2_PKNS0_15macros_internal10MacroTableE: 210| 434| const macros_internal::MacroTable* parent) { 211| 434| std::vector columns = 212| 434| CopyColumnsFromParentOrAddRootColumns(parent); 213| 434| uint32_t olay_idx = OverlayCount(parent); 214| 434| AddColumnToVector(columns, "timestamp", &self->timestamp_, ColumnFlag::timestamp, 215| 434| static_cast(columns.size()), olay_idx); 216| 434| AddColumnToVector(columns, "track_id", &self->track_id_, ColumnFlag::track_id, 217| 434| static_cast(columns.size()), olay_idx); 218| 434| AddColumnToVector(columns, "detail_level", &self->detail_level_, ColumnFlag::detail_level, 219| 434| static_cast(columns.size()), olay_idx); 220| 434| base::ignore_result(self); 221| 434| return columns; 222| 434| } _ZN8perfetto15trace_processor6tables19MemorySnapshotTableC2EPNS0_10StringPoolE: 225| 434| : macros_internal::MacroTable( 226| 434| pool, 227| 434| GetColumns(this, nullptr), 228| 434| nullptr), 229| 434| timestamp_(ColumnStorage::Create()), 230| 434| track_id_(ColumnStorage::Create()), 231| 434| detail_level_(ColumnStorage::Create()) 232| |, 233| 434| id_storage_layer_(new column::IdStorage()), 234| 434| timestamp_storage_layer_( 235| 434| new column::NumericStorage( 236| 434| ×tamp_.vector(), 237| 434| ColumnTypeHelper::ToColumnType(), 238| 434| false)), 239| 434| track_id_storage_layer_( 240| 434| new column::NumericStorage( 241| 434| &track_id_.vector(), 242| 434| ColumnTypeHelper::ToColumnType(), 243| 434| false)), 244| 434| detail_level_storage_layer_( 245| 434| new column::StringStorage(string_pool(), &detail_level_.vector())) 246| 434| { 247| 434| static_assert( 248| 434| ColumnLegacy::IsFlagsAndTypeValid( 249| 434| ColumnFlag::timestamp), 250| 434| "Column type and flag combination is not valid"); 251| 434| static_assert( 252| 434| ColumnLegacy::IsFlagsAndTypeValid( 253| 434| ColumnFlag::track_id), 254| 434| "Column type and flag combination is not valid"); 255| 434| static_assert( 256| 434| ColumnLegacy::IsFlagsAndTypeValid( 257| 434| ColumnFlag::detail_level), 258| 434| "Column type and flag combination is not valid"); 259| 434| OnConstructionCompletedRegularConstructor( 260| 434| {id_storage_layer_,timestamp_storage_layer_,track_id_storage_layer_,detail_level_storage_layer_}, 261| 434| {{},{},{},{}}); 262| 434| } _ZN8perfetto15trace_processor6tables19MemorySnapshotTable6InsertERKNS2_3RowE: 331| 641| IdAndRow Insert(const Row& row) { 332| 641| uint32_t row_number = row_count(); 333| 641| Id id = Id{row_number}; 334| 641| mutable_timestamp()->Append(row.timestamp); 335| 641| mutable_track_id()->Append(row.track_id); 336| 641| mutable_detail_level()->Append(row.detail_level); 337| 641| UpdateSelfOverlayAfterInsert(); 338| 641| return IdAndRow{id, row_number, RowReference(this, row_number), 339| 641| RowNumber(row_number)}; 340| 641| } _ZN8perfetto15trace_processor6tables19MemorySnapshotTable17mutable_timestampEv: 357| 641| TypedColumn* mutable_timestamp() { 358| 641| return static_cast( 359| 641| GetColumn(ColumnIndex::timestamp)); 360| 641| } _ZN8perfetto15trace_processor6tables19MemorySnapshotTable16mutable_track_idEv: 361| 641| TypedColumn* mutable_track_id() { 362| 641| return static_cast( 363| 641| GetColumn(ColumnIndex::track_id)); 364| 641| } _ZN8perfetto15trace_processor6tables19MemorySnapshotTable20mutable_detail_levelEv: 365| 641| TypedColumn* mutable_detail_level() { 366| 641| return static_cast( 367| 641| GetColumn(ColumnIndex::detail_level)); 368| 641| } _ZN8perfetto15trace_processor6tables26ProcessMemorySnapshotTable2IdC2Ej: 392| 43.2k| explicit constexpr Id(uint32_t v) : BaseId(v) {} _ZN8perfetto15trace_processor6tables26ProcessMemorySnapshotTable3RowC2ENS1_19MemorySnapshotTable2IdEjDn: 411| 43.2k| : macros_internal::RootParentTable::Row(), 412| 43.2k| snapshot_id(in_snapshot_id), 413| 43.2k| upid(in_upid) {} _ZN8perfetto15trace_processor6tables26ProcessMemorySnapshotTable9RowNumberC2Ej: 435| 43.2k| : AbstractRowNumber(row_number) {} _ZN8perfetto15trace_processor6tables26ProcessMemorySnapshotTable17ConstRowReferenceC2EPKS2_j: 444| 43.2k| : AbstractConstRowReference(table, row_number) {} _ZN8perfetto15trace_processor6tables26ProcessMemorySnapshotTable12RowReferenceC2EPKS2_j: 461| 43.2k| : ConstRowReference(table, row_number) {} _ZN8perfetto15trace_processor6tables26ProcessMemorySnapshotTable10GetColumnsEPS2_PKNS0_15macros_internal10MacroTableE: 536| 434| const macros_internal::MacroTable* parent) { 537| 434| std::vector columns = 538| 434| CopyColumnsFromParentOrAddRootColumns(parent); 539| 434| uint32_t olay_idx = OverlayCount(parent); 540| 434| AddColumnToVector(columns, "snapshot_id", &self->snapshot_id_, ColumnFlag::snapshot_id, 541| 434| static_cast(columns.size()), olay_idx); 542| 434| AddColumnToVector(columns, "upid", &self->upid_, ColumnFlag::upid, 543| 434| static_cast(columns.size()), olay_idx); 544| 434| base::ignore_result(self); 545| 434| return columns; 546| 434| } _ZN8perfetto15trace_processor6tables26ProcessMemorySnapshotTableC2EPNS0_10StringPoolE: 549| 434| : macros_internal::MacroTable( 550| 434| pool, 551| 434| GetColumns(this, nullptr), 552| 434| nullptr), 553| 434| snapshot_id_(ColumnStorage::Create()), 554| 434| upid_(ColumnStorage::Create()) 555| |, 556| 434| id_storage_layer_(new column::IdStorage()), 557| 434| snapshot_id_storage_layer_( 558| 434| new column::NumericStorage( 559| 434| &snapshot_id_.vector(), 560| 434| ColumnTypeHelper::ToColumnType(), 561| 434| false)), 562| 434| upid_storage_layer_( 563| 434| new column::NumericStorage( 564| 434| &upid_.vector(), 565| 434| ColumnTypeHelper::ToColumnType(), 566| 434| false)) 567| 434| { 568| 434| static_assert( 569| 434| ColumnLegacy::IsFlagsAndTypeValid( 570| 434| ColumnFlag::snapshot_id), 571| 434| "Column type and flag combination is not valid"); 572| 434| static_assert( 573| 434| ColumnLegacy::IsFlagsAndTypeValid( 574| 434| ColumnFlag::upid), 575| 434| "Column type and flag combination is not valid"); 576| 434| OnConstructionCompletedRegularConstructor( 577| 434| {id_storage_layer_,snapshot_id_storage_layer_,upid_storage_layer_}, 578| 434| {{},{},{}}); 579| 434| } _ZN8perfetto15trace_processor6tables26ProcessMemorySnapshotTable6InsertERKNS2_3RowE: 642| 43.2k| IdAndRow Insert(const Row& row) { 643| 43.2k| uint32_t row_number = row_count(); 644| 43.2k| Id id = Id{row_number}; 645| 43.2k| mutable_snapshot_id()->Append(row.snapshot_id); 646| 43.2k| mutable_upid()->Append(row.upid); 647| 43.2k| UpdateSelfOverlayAfterInsert(); 648| 43.2k| return IdAndRow{id, row_number, RowReference(this, row_number), 649| 43.2k| RowNumber(row_number)}; 650| 43.2k| } _ZN8perfetto15trace_processor6tables26ProcessMemorySnapshotTable19mutable_snapshot_idEv: 664| 43.2k| TypedColumn* mutable_snapshot_id() { 665| 43.2k| return static_cast( 666| 43.2k| GetColumn(ColumnIndex::snapshot_id)); 667| 43.2k| } _ZN8perfetto15trace_processor6tables26ProcessMemorySnapshotTable12mutable_upidEv: 668| 43.2k| TypedColumn* mutable_upid() { 669| 43.2k| return static_cast( 670| 43.2k| GetColumn(ColumnIndex::upid)); 671| 43.2k| } _ZN8perfetto15trace_processor6tables23MemorySnapshotNodeTable2IdC2Ej: 693| 3.77k| explicit constexpr Id(uint32_t v) : BaseId(v) {} _ZN8perfetto15trace_processor6tables23MemorySnapshotNodeTable3RowC2ENS1_26ProcessMemorySnapshotTable2IdENSt3__18optionalINS2_2IdEEENS0_10StringPool2IdEllNS7_IjEEDn: 724| 3.77k| : macros_internal::RootParentTable::Row(), 725| 3.77k| process_snapshot_id(in_process_snapshot_id), 726| 3.77k| parent_node_id(in_parent_node_id), 727| 3.77k| path(in_path), 728| 3.77k| size(in_size), 729| 3.77k| effective_size(in_effective_size), 730| 3.77k| arg_set_id(in_arg_set_id) {} _ZN8perfetto15trace_processor6tables23MemorySnapshotNodeTable9RowNumberC2Ej: 764| 7.54k| : AbstractRowNumber(row_number) {} _ZN8perfetto15trace_processor6tables23MemorySnapshotNodeTable17ConstRowReferenceC2EPKS2_j: 773| 11.3k| : AbstractConstRowReference(table, row_number) {} _ZN8perfetto15trace_processor6tables23MemorySnapshotNodeTable12RowReferenceC2EPKS2_j: 802| 11.3k| : ConstRowReference(table, row_number) {} _ZN8perfetto15trace_processor6tables23MemorySnapshotNodeTable12RowReference8set_sizeEl: 817| 637| ColumnType::size::non_optional_type v) { 818| 637| return mutable_table()->mutable_size()->Set(row_number_, v); 819| 637| } _ZN8perfetto15trace_processor6tables23MemorySnapshotNodeTable12RowReference18set_effective_sizeEl: 821| 637| ColumnType::effective_size::non_optional_type v) { 822| 637| return mutable_table()->mutable_effective_size()->Set(row_number_, v); 823| 637| } _ZNK8perfetto15trace_processor6tables23MemorySnapshotNodeTable12RowReference13mutable_tableEv: 830| 1.27k| MemorySnapshotNodeTable* mutable_table() const { 831| 1.27k| return const_cast(table()); 832| 1.27k| } _ZN8perfetto15trace_processor6tables23MemorySnapshotNodeTable10GetColumnsEPS2_PKNS0_15macros_internal10MacroTableE: 913| 434| const macros_internal::MacroTable* parent) { 914| 434| std::vector columns = 915| 434| CopyColumnsFromParentOrAddRootColumns(parent); 916| 434| uint32_t olay_idx = OverlayCount(parent); 917| 434| AddColumnToVector(columns, "process_snapshot_id", &self->process_snapshot_id_, ColumnFlag::process_snapshot_id, 918| 434| static_cast(columns.size()), olay_idx); 919| 434| AddColumnToVector(columns, "parent_node_id", &self->parent_node_id_, ColumnFlag::parent_node_id, 920| 434| static_cast(columns.size()), olay_idx); 921| 434| AddColumnToVector(columns, "path", &self->path_, ColumnFlag::path, 922| 434| static_cast(columns.size()), olay_idx); 923| 434| AddColumnToVector(columns, "size", &self->size_, ColumnFlag::size, 924| 434| static_cast(columns.size()), olay_idx); 925| 434| AddColumnToVector(columns, "effective_size", &self->effective_size_, ColumnFlag::effective_size, 926| 434| static_cast(columns.size()), olay_idx); 927| 434| AddColumnToVector(columns, "arg_set_id", &self->arg_set_id_, ColumnFlag::arg_set_id, 928| 434| static_cast(columns.size()), olay_idx); 929| 434| base::ignore_result(self); 930| 434| return columns; 931| 434| } _ZN8perfetto15trace_processor6tables23MemorySnapshotNodeTableC2EPNS0_10StringPoolE: 934| 434| : macros_internal::MacroTable( 935| 434| pool, 936| 434| GetColumns(this, nullptr), 937| 434| nullptr), 938| 434| process_snapshot_id_(ColumnStorage::Create()), 939| 434| parent_node_id_(ColumnStorage::Create()), 940| 434| path_(ColumnStorage::Create()), 941| 434| size_(ColumnStorage::Create()), 942| 434| effective_size_(ColumnStorage::Create()), 943| 434| arg_set_id_(ColumnStorage::Create()) 944| |, 945| 434| id_storage_layer_(new column::IdStorage()), 946| 434| process_snapshot_id_storage_layer_( 947| 434| new column::NumericStorage( 948| 434| &process_snapshot_id_.vector(), 949| 434| ColumnTypeHelper::ToColumnType(), 950| 434| false)), 951| 434| parent_node_id_storage_layer_( 952| 434| new column::NumericStorage( 953| 434| &parent_node_id_.non_null_vector(), 954| 434| ColumnTypeHelper::ToColumnType(), 955| 434| false)), 956| 434| path_storage_layer_( 957| 434| new column::StringStorage(string_pool(), &path_.vector())), 958| 434| size_storage_layer_( 959| 434| new column::NumericStorage( 960| 434| &size_.vector(), 961| 434| ColumnTypeHelper::ToColumnType(), 962| 434| false)), 963| 434| effective_size_storage_layer_( 964| 434| new column::NumericStorage( 965| 434| &effective_size_.vector(), 966| 434| ColumnTypeHelper::ToColumnType(), 967| 434| false)), 968| 434| arg_set_id_storage_layer_( 969| 434| new column::NumericStorage( 970| 434| &arg_set_id_.non_null_vector(), 971| 434| ColumnTypeHelper::ToColumnType(), 972| 434| false)) 973| |, 974| 434| parent_node_id_null_layer_(new column::NullOverlay(parent_node_id_.bv())), 975| 434| arg_set_id_null_layer_(new column::NullOverlay(arg_set_id_.bv())) { 976| 434| static_assert( 977| 434| ColumnLegacy::IsFlagsAndTypeValid( 978| 434| ColumnFlag::process_snapshot_id), 979| 434| "Column type and flag combination is not valid"); 980| 434| static_assert( 981| 434| ColumnLegacy::IsFlagsAndTypeValid( 982| 434| ColumnFlag::parent_node_id), 983| 434| "Column type and flag combination is not valid"); 984| 434| static_assert( 985| 434| ColumnLegacy::IsFlagsAndTypeValid( 986| 434| ColumnFlag::path), 987| 434| "Column type and flag combination is not valid"); 988| 434| static_assert( 989| 434| ColumnLegacy::IsFlagsAndTypeValid( 990| 434| ColumnFlag::size), 991| 434| "Column type and flag combination is not valid"); 992| 434| static_assert( 993| 434| ColumnLegacy::IsFlagsAndTypeValid( 994| 434| ColumnFlag::effective_size), 995| 434| "Column type and flag combination is not valid"); 996| 434| static_assert( 997| 434| ColumnLegacy::IsFlagsAndTypeValid( 998| 434| ColumnFlag::arg_set_id), 999| 434| "Column type and flag combination is not valid"); 1000| 434| OnConstructionCompletedRegularConstructor( 1001| 434| {id_storage_layer_,process_snapshot_id_storage_layer_,parent_node_id_storage_layer_,path_storage_layer_,size_storage_layer_,effective_size_storage_layer_,arg_set_id_storage_layer_}, 1002| 434| {{},{},parent_node_id_null_layer_,{},{},{},arg_set_id_null_layer_}); 1003| 434| } _ZN8perfetto15trace_processor6tables23MemorySnapshotNodeTable8FindByIdENS2_2IdE: 1085| 7.54k| std::optional FindById(Id find_id) { 1086| 7.54k| std::optional row = id().IndexOf(find_id); 1087| 7.54k| return row ? std::make_optional(RowReference(this, *row)) : std::nullopt; ------------------ | Branch (1087:12): [True: 7.54k, False: 0] ------------------ 1088| 7.54k| } _ZN8perfetto15trace_processor6tables23MemorySnapshotNodeTable6InsertERKNS2_3RowE: 1090| 3.77k| IdAndRow Insert(const Row& row) { 1091| 3.77k| uint32_t row_number = row_count(); 1092| 3.77k| Id id = Id{row_number}; 1093| 3.77k| mutable_process_snapshot_id()->Append(row.process_snapshot_id); 1094| 3.77k| mutable_parent_node_id()->Append(row.parent_node_id); 1095| 3.77k| mutable_path()->Append(row.path); 1096| 3.77k| mutable_size()->Append(row.size); 1097| 3.77k| mutable_effective_size()->Append(row.effective_size); 1098| 3.77k| mutable_arg_set_id()->Append(row.arg_set_id); 1099| 3.77k| UpdateSelfOverlayAfterInsert(); 1100| 3.77k| return IdAndRow{id, row_number, RowReference(this, row_number), 1101| 3.77k| RowNumber(row_number)}; 1102| 3.77k| } _ZNK8perfetto15trace_processor6tables23MemorySnapshotNodeTable2idEv: 1106| 7.54k| const IdColumn& id() const { 1107| 7.54k| return static_cast(columns()[ColumnIndex::id]); 1108| 7.54k| } _ZN8perfetto15trace_processor6tables23MemorySnapshotNodeTable27mutable_process_snapshot_idEv: 1128| 3.77k| TypedColumn* mutable_process_snapshot_id() { 1129| 3.77k| return static_cast( 1130| 3.77k| GetColumn(ColumnIndex::process_snapshot_id)); 1131| 3.77k| } _ZN8perfetto15trace_processor6tables23MemorySnapshotNodeTable22mutable_parent_node_idEv: 1132| 3.77k| TypedColumn>* mutable_parent_node_id() { 1133| 3.77k| return static_cast( 1134| 3.77k| GetColumn(ColumnIndex::parent_node_id)); 1135| 3.77k| } _ZN8perfetto15trace_processor6tables23MemorySnapshotNodeTable12mutable_pathEv: 1136| 3.77k| TypedColumn* mutable_path() { 1137| 3.77k| return static_cast( 1138| 3.77k| GetColumn(ColumnIndex::path)); 1139| 3.77k| } _ZN8perfetto15trace_processor6tables23MemorySnapshotNodeTable12mutable_sizeEv: 1140| 4.41k| TypedColumn* mutable_size() { 1141| 4.41k| return static_cast( 1142| 4.41k| GetColumn(ColumnIndex::size)); 1143| 4.41k| } _ZN8perfetto15trace_processor6tables23MemorySnapshotNodeTable22mutable_effective_sizeEv: 1144| 4.41k| TypedColumn* mutable_effective_size() { 1145| 4.41k| return static_cast( 1146| 4.41k| GetColumn(ColumnIndex::effective_size)); 1147| 4.41k| } _ZN8perfetto15trace_processor6tables23MemorySnapshotNodeTable18mutable_arg_set_idEv: 1148| 7.54k| TypedColumn>* mutable_arg_set_id() { 1149| 7.54k| return static_cast( 1150| 7.54k| GetColumn(ColumnIndex::arg_set_id)); 1151| 7.54k| } _ZN8perfetto15trace_processor6tables23MemorySnapshotEdgeTable2IdC2Ej: 1182| 364| explicit constexpr Id(uint32_t v) : BaseId(v) {} _ZN8perfetto15trace_processor6tables23MemorySnapshotEdgeTable3RowC2ENS1_23MemorySnapshotNodeTable2IdES5_jDn: 1204| 30.5k| : macros_internal::RootParentTable::Row(), 1205| 30.5k| source_node_id(in_source_node_id), 1206| 30.5k| target_node_id(in_target_node_id), 1207| 30.5k| importance(in_importance) {} _ZN8perfetto15trace_processor6tables23MemorySnapshotEdgeTable9RowNumberC2Ej: 1232| 364| : AbstractRowNumber(row_number) {} _ZN8perfetto15trace_processor6tables23MemorySnapshotEdgeTable17ConstRowReferenceC2EPKS2_j: 1241| 364| : AbstractConstRowReference(table, row_number) {} _ZN8perfetto15trace_processor6tables23MemorySnapshotEdgeTable12RowReferenceC2EPKS2_j: 1261| 364| : ConstRowReference(table, row_number) {} _ZN8perfetto15trace_processor6tables23MemorySnapshotEdgeTable10GetColumnsEPS2_PKNS0_15macros_internal10MacroTableE: 1345| 434| const macros_internal::MacroTable* parent) { 1346| 434| std::vector columns = 1347| 434| CopyColumnsFromParentOrAddRootColumns(parent); 1348| 434| uint32_t olay_idx = OverlayCount(parent); 1349| 434| AddColumnToVector(columns, "source_node_id", &self->source_node_id_, ColumnFlag::source_node_id, 1350| 434| static_cast(columns.size()), olay_idx); 1351| 434| AddColumnToVector(columns, "target_node_id", &self->target_node_id_, ColumnFlag::target_node_id, 1352| 434| static_cast(columns.size()), olay_idx); 1353| 434| AddColumnToVector(columns, "importance", &self->importance_, ColumnFlag::importance, 1354| 434| static_cast(columns.size()), olay_idx); 1355| 434| base::ignore_result(self); 1356| 434| return columns; 1357| 434| } _ZN8perfetto15trace_processor6tables23MemorySnapshotEdgeTableC2EPNS0_10StringPoolE: 1360| 434| : macros_internal::MacroTable( 1361| 434| pool, 1362| 434| GetColumns(this, nullptr), 1363| 434| nullptr), 1364| 434| source_node_id_(ColumnStorage::Create()), 1365| 434| target_node_id_(ColumnStorage::Create()), 1366| 434| importance_(ColumnStorage::Create()) 1367| |, 1368| 434| id_storage_layer_(new column::IdStorage()), 1369| 434| source_node_id_storage_layer_( 1370| 434| new column::NumericStorage( 1371| 434| &source_node_id_.vector(), 1372| 434| ColumnTypeHelper::ToColumnType(), 1373| 434| false)), 1374| 434| target_node_id_storage_layer_( 1375| 434| new column::NumericStorage( 1376| 434| &target_node_id_.vector(), 1377| 434| ColumnTypeHelper::ToColumnType(), 1378| 434| false)), 1379| 434| importance_storage_layer_( 1380| 434| new column::NumericStorage( 1381| 434| &importance_.vector(), 1382| 434| ColumnTypeHelper::ToColumnType(), 1383| 434| false)) 1384| 434| { 1385| 434| static_assert( 1386| 434| ColumnLegacy::IsFlagsAndTypeValid( 1387| 434| ColumnFlag::source_node_id), 1388| 434| "Column type and flag combination is not valid"); 1389| 434| static_assert( 1390| 434| ColumnLegacy::IsFlagsAndTypeValid( 1391| 434| ColumnFlag::target_node_id), 1392| 434| "Column type and flag combination is not valid"); 1393| 434| static_assert( 1394| 434| ColumnLegacy::IsFlagsAndTypeValid( 1395| 434| ColumnFlag::importance), 1396| 434| "Column type and flag combination is not valid"); 1397| 434| OnConstructionCompletedRegularConstructor( 1398| 434| {id_storage_layer_,source_node_id_storage_layer_,target_node_id_storage_layer_,importance_storage_layer_}, 1399| 434| {{},{},{},{}}); 1400| 434| } _ZN8perfetto15trace_processor6tables23MemorySnapshotEdgeTable6InsertERKNS2_3RowE: 1469| 364| IdAndRow Insert(const Row& row) { 1470| 364| uint32_t row_number = row_count(); 1471| 364| Id id = Id{row_number}; 1472| 364| mutable_source_node_id()->Append(row.source_node_id); 1473| 364| mutable_target_node_id()->Append(row.target_node_id); 1474| 364| mutable_importance()->Append(row.importance); 1475| 364| UpdateSelfOverlayAfterInsert(); 1476| 364| return IdAndRow{id, row_number, RowReference(this, row_number), 1477| 364| RowNumber(row_number)}; 1478| 364| } _ZN8perfetto15trace_processor6tables23MemorySnapshotEdgeTable22mutable_source_node_idEv: 1495| 364| TypedColumn* mutable_source_node_id() { 1496| 364| return static_cast( 1497| 364| GetColumn(ColumnIndex::source_node_id)); 1498| 364| } _ZN8perfetto15trace_processor6tables23MemorySnapshotEdgeTable22mutable_target_node_idEv: 1499| 364| TypedColumn* mutable_target_node_id() { 1500| 364| return static_cast( 1501| 364| GetColumn(ColumnIndex::target_node_id)); 1502| 364| } _ZN8perfetto15trace_processor6tables23MemorySnapshotEdgeTable18mutable_importanceEv: 1503| 364| TypedColumn* mutable_importance() { 1504| 364| return static_cast( 1505| 364| GetColumn(ColumnIndex::importance)); 1506| 364| } _ZN8perfetto15trace_processor6tables12MachineTable2IdC2Ej: 47| 2.03k| explicit constexpr Id(uint32_t v) : BaseId(v) {} _ZN8perfetto15trace_processor6tables12MachineTable3RowC2EjDn: 63| 2.03k| : macros_internal::RootParentTable::Row(), 64| 2.03k| raw_id(in_raw_id) {} _ZN8perfetto15trace_processor6tables12MachineTable9RowNumberC2Ej: 83| 2.03k| : AbstractRowNumber(row_number) {} _ZN8perfetto15trace_processor6tables12MachineTable17ConstRowReferenceC2EPKS2_j: 92| 2.03k| : AbstractConstRowReference(table, row_number) {} _ZN8perfetto15trace_processor6tables12MachineTable12RowReferenceC2EPKS2_j: 106| 2.03k| : ConstRowReference(table, row_number) {} _ZN8perfetto15trace_processor6tables12MachineTable10GetColumnsEPS2_PKNS0_15macros_internal10MacroTableE: 172| 434| const macros_internal::MacroTable* parent) { 173| 434| std::vector columns = 174| 434| CopyColumnsFromParentOrAddRootColumns(parent); 175| 434| uint32_t olay_idx = OverlayCount(parent); 176| 434| AddColumnToVector(columns, "raw_id", &self->raw_id_, ColumnFlag::raw_id, 177| 434| static_cast(columns.size()), olay_idx); 178| 434| base::ignore_result(self); 179| 434| return columns; 180| 434| } _ZN8perfetto15trace_processor6tables12MachineTableC2EPNS0_10StringPoolE: 183| 434| : macros_internal::MacroTable( 184| 434| pool, 185| 434| GetColumns(this, nullptr), 186| 434| nullptr), 187| 434| raw_id_(ColumnStorage::Create()) 188| |, 189| 434| id_storage_layer_(new column::IdStorage()), 190| 434| raw_id_storage_layer_( 191| 434| new column::NumericStorage( 192| 434| &raw_id_.vector(), 193| 434| ColumnTypeHelper::ToColumnType(), 194| 434| false)) 195| 434| { 196| 434| static_assert( 197| 434| ColumnLegacy::IsFlagsAndTypeValid( 198| 434| ColumnFlag::raw_id), 199| 434| "Column type and flag combination is not valid"); 200| 434| OnConstructionCompletedRegularConstructor( 201| 434| {id_storage_layer_,raw_id_storage_layer_}, 202| 434| {{},{}}); 203| 434| } _ZN8perfetto15trace_processor6tables12MachineTable6InsertERKNS2_3RowE: 260| 2.03k| IdAndRow Insert(const Row& row) { 261| 2.03k| uint32_t row_number = row_count(); 262| 2.03k| Id id = Id{row_number}; 263| 2.03k| mutable_raw_id()->Append(row.raw_id); 264| 2.03k| UpdateSelfOverlayAfterInsert(); 265| 2.03k| return IdAndRow{id, row_number, RowReference(this, row_number), 266| 2.03k| RowNumber(row_number)}; 267| 2.03k| } _ZN8perfetto15trace_processor6tables12MachineTable14mutable_raw_idEv: 278| 2.03k| TypedColumn* mutable_raw_id() { 279| 2.03k| return static_cast( 280| 2.03k| GetColumn(ColumnIndex::raw_id)); 281| 2.03k| } _ZN8perfetto15trace_processor6tables12ProcessTable2IdC2Ej: 301| 566k| explicit constexpr Id(uint32_t v) : BaseId(v) {} _ZN8perfetto15trace_processor6tables12ProcessTable3RowC2EjNSt3__18optionalINS0_10StringPool2IdEEENS5_IlEES9_NS5_IjEESA_SA_SA_S8_SA_NS5_INS1_12MachineTable2IdEEEDn: 347| 566k| : macros_internal::RootParentTable::Row(), 348| 566k| pid(in_pid), 349| 566k| name(in_name), 350| 566k| start_ts(in_start_ts), 351| 566k| end_ts(in_end_ts), 352| 566k| parent_upid(in_parent_upid), 353| 566k| uid(in_uid), 354| 566k| android_appid(in_android_appid), 355| 566k| android_user_id(in_android_user_id), 356| 566k| cmdline(in_cmdline), 357| 566k| arg_set_id(in_arg_set_id), 358| 566k| machine_id(in_machine_id) {} _ZN8perfetto15trace_processor6tables12ProcessTable9RowNumberC2Ej: 407| 566k| : AbstractRowNumber(row_number) {} _ZN8perfetto15trace_processor6tables12ProcessTable17ConstRowReferenceC2EPKS2_j: 416| 182M| : AbstractConstRowReference(table, row_number) {} _ZNK8perfetto15trace_processor6tables12ProcessTable17ConstRowReference3pidEv: 421| 182M| ColumnType::pid::type pid() const { 422| 182M| return table()->pid()[row_number_]; 423| 182M| } _ZNK8perfetto15trace_processor6tables12ProcessTable17ConstRowReference4nameEv: 424| 55.7k| ColumnType::name::type name() const { 425| 55.7k| return table()->name()[row_number_]; 426| 55.7k| } _ZNK8perfetto15trace_processor6tables12ProcessTable17ConstRowReference8start_tsEv: 427| 33.4k| ColumnType::start_ts::type start_ts() const { 428| 33.4k| return table()->start_ts()[row_number_]; 429| 33.4k| } _ZNK8perfetto15trace_processor6tables12ProcessTable17ConstRowReference6end_tsEv: 430| 90.8M| ColumnType::end_ts::type end_ts() const { 431| 90.8M| return table()->end_ts()[row_number_]; 432| 90.8M| } _ZN8perfetto15trace_processor6tables12ProcessTable12RowReferenceC2EPKS2_j: 460| 182M| : ConstRowReference(table, row_number) {} _ZN8perfetto15trace_processor6tables12ProcessTable12RowReference8set_nameENS0_10StringPool2IdE: 467| 62.1k| ColumnType::name::non_optional_type v) { 468| 62.1k| return mutable_table()->mutable_name()->Set(row_number_, v); 469| 62.1k| } _ZN8perfetto15trace_processor6tables12ProcessTable12RowReference12set_start_tsEl: 471| 27.3k| ColumnType::start_ts::non_optional_type v) { 472| 27.3k| return mutable_table()->mutable_start_ts()->Set(row_number_, v); 473| 27.3k| } _ZNK8perfetto15trace_processor6tables12ProcessTable12RowReference13mutable_tableEv: 508| 89.4k| ProcessTable* mutable_table() const { 509| 89.4k| return const_cast(table()); 510| 89.4k| } _ZN8perfetto15trace_processor6tables12ProcessTable10GetColumnsEPS2_PKNS0_15macros_internal10MacroTableE: 616| 434| const macros_internal::MacroTable* parent) { 617| 434| std::vector columns = 618| 434| CopyColumnsFromParentOrAddRootColumns(parent); 619| 434| uint32_t olay_idx = OverlayCount(parent); 620| 434| AddColumnToVector(columns, "pid", &self->pid_, ColumnFlag::pid, 621| 434| static_cast(columns.size()), olay_idx); 622| 434| AddColumnToVector(columns, "name", &self->name_, ColumnFlag::name, 623| 434| static_cast(columns.size()), olay_idx); 624| 434| AddColumnToVector(columns, "start_ts", &self->start_ts_, ColumnFlag::start_ts, 625| 434| static_cast(columns.size()), olay_idx); 626| 434| AddColumnToVector(columns, "end_ts", &self->end_ts_, ColumnFlag::end_ts, 627| 434| static_cast(columns.size()), olay_idx); 628| 434| AddColumnToVector(columns, "parent_upid", &self->parent_upid_, ColumnFlag::parent_upid, 629| 434| static_cast(columns.size()), olay_idx); 630| 434| AddColumnToVector(columns, "uid", &self->uid_, ColumnFlag::uid, 631| 434| static_cast(columns.size()), olay_idx); 632| 434| AddColumnToVector(columns, "android_appid", &self->android_appid_, ColumnFlag::android_appid, 633| 434| static_cast(columns.size()), olay_idx); 634| 434| AddColumnToVector(columns, "android_user_id", &self->android_user_id_, ColumnFlag::android_user_id, 635| 434| static_cast(columns.size()), olay_idx); 636| 434| AddColumnToVector(columns, "cmdline", &self->cmdline_, ColumnFlag::cmdline, 637| 434| static_cast(columns.size()), olay_idx); 638| 434| AddColumnToVector(columns, "arg_set_id", &self->arg_set_id_, ColumnFlag::arg_set_id, 639| 434| static_cast(columns.size()), olay_idx); 640| 434| AddColumnToVector(columns, "machine_id", &self->machine_id_, ColumnFlag::machine_id, 641| 434| static_cast(columns.size()), olay_idx); 642| 434| base::ignore_result(self); 643| 434| return columns; 644| 434| } _ZN8perfetto15trace_processor6tables12ProcessTableC2EPNS0_10StringPoolE: 647| 434| : macros_internal::MacroTable( 648| 434| pool, 649| 434| GetColumns(this, nullptr), 650| 434| nullptr), 651| 434| pid_(ColumnStorage::Create()), 652| 434| name_(ColumnStorage::Create()), 653| 434| start_ts_(ColumnStorage::Create()), 654| 434| end_ts_(ColumnStorage::Create()), 655| 434| parent_upid_(ColumnStorage::Create()), 656| 434| uid_(ColumnStorage::Create()), 657| 434| android_appid_(ColumnStorage::Create()), 658| 434| android_user_id_(ColumnStorage::Create()), 659| 434| cmdline_(ColumnStorage::Create()), 660| 434| arg_set_id_(ColumnStorage::Create()), 661| 434| machine_id_(ColumnStorage::Create()) 662| |, 663| 434| id_storage_layer_(new column::IdStorage()), 664| 434| pid_storage_layer_( 665| 434| new column::NumericStorage( 666| 434| &pid_.vector(), 667| 434| ColumnTypeHelper::ToColumnType(), 668| 434| false)), 669| 434| name_storage_layer_( 670| 434| new column::StringStorage(string_pool(), &name_.vector())), 671| 434| start_ts_storage_layer_( 672| 434| new column::NumericStorage( 673| 434| &start_ts_.non_null_vector(), 674| 434| ColumnTypeHelper::ToColumnType(), 675| 434| false)), 676| 434| end_ts_storage_layer_( 677| 434| new column::NumericStorage( 678| 434| &end_ts_.non_null_vector(), 679| 434| ColumnTypeHelper::ToColumnType(), 680| 434| false)), 681| 434| parent_upid_storage_layer_( 682| 434| new column::NumericStorage( 683| 434| &parent_upid_.non_null_vector(), 684| 434| ColumnTypeHelper::ToColumnType(), 685| 434| false)), 686| 434| uid_storage_layer_( 687| 434| new column::NumericStorage( 688| 434| &uid_.non_null_vector(), 689| 434| ColumnTypeHelper::ToColumnType(), 690| 434| false)), 691| 434| android_appid_storage_layer_( 692| 434| new column::NumericStorage( 693| 434| &android_appid_.non_null_vector(), 694| 434| ColumnTypeHelper::ToColumnType(), 695| 434| false)), 696| 434| android_user_id_storage_layer_( 697| 434| new column::NumericStorage( 698| 434| &android_user_id_.non_null_vector(), 699| 434| ColumnTypeHelper::ToColumnType(), 700| 434| false)), 701| 434| cmdline_storage_layer_( 702| 434| new column::StringStorage(string_pool(), &cmdline_.vector())), 703| 434| arg_set_id_storage_layer_( 704| 434| new column::NumericStorage( 705| 434| &arg_set_id_.non_null_vector(), 706| 434| ColumnTypeHelper::ToColumnType(), 707| 434| false)), 708| 434| machine_id_storage_layer_( 709| 434| new column::NumericStorage( 710| 434| &machine_id_.non_null_vector(), 711| 434| ColumnTypeHelper::ToColumnType(), 712| 434| false)) 713| |, 714| 434| start_ts_null_layer_(new column::NullOverlay(start_ts_.bv())), 715| 434| end_ts_null_layer_(new column::NullOverlay(end_ts_.bv())), 716| 434| parent_upid_null_layer_(new column::NullOverlay(parent_upid_.bv())), 717| 434| uid_null_layer_(new column::NullOverlay(uid_.bv())), 718| 434| android_appid_null_layer_(new column::NullOverlay(android_appid_.bv())), 719| 434| android_user_id_null_layer_(new column::NullOverlay(android_user_id_.bv())), 720| 434| arg_set_id_null_layer_(new column::NullOverlay(arg_set_id_.bv())), 721| 434| machine_id_null_layer_(new column::NullOverlay(machine_id_.bv())) { 722| 434| static_assert( 723| 434| ColumnLegacy::IsFlagsAndTypeValid( 724| 434| ColumnFlag::pid), 725| 434| "Column type and flag combination is not valid"); 726| 434| static_assert( 727| 434| ColumnLegacy::IsFlagsAndTypeValid( 728| 434| ColumnFlag::name), 729| 434| "Column type and flag combination is not valid"); 730| 434| static_assert( 731| 434| ColumnLegacy::IsFlagsAndTypeValid( 732| 434| ColumnFlag::start_ts), 733| 434| "Column type and flag combination is not valid"); 734| 434| static_assert( 735| 434| ColumnLegacy::IsFlagsAndTypeValid( 736| 434| ColumnFlag::end_ts), 737| 434| "Column type and flag combination is not valid"); 738| 434| static_assert( 739| 434| ColumnLegacy::IsFlagsAndTypeValid( 740| 434| ColumnFlag::parent_upid), 741| 434| "Column type and flag combination is not valid"); 742| 434| static_assert( 743| 434| ColumnLegacy::IsFlagsAndTypeValid( 744| 434| ColumnFlag::uid), 745| 434| "Column type and flag combination is not valid"); 746| 434| static_assert( 747| 434| ColumnLegacy::IsFlagsAndTypeValid( 748| 434| ColumnFlag::android_appid), 749| 434| "Column type and flag combination is not valid"); 750| 434| static_assert( 751| 434| ColumnLegacy::IsFlagsAndTypeValid( 752| 434| ColumnFlag::android_user_id), 753| 434| "Column type and flag combination is not valid"); 754| 434| static_assert( 755| 434| ColumnLegacy::IsFlagsAndTypeValid( 756| 434| ColumnFlag::cmdline), 757| 434| "Column type and flag combination is not valid"); 758| 434| static_assert( 759| 434| ColumnLegacy::IsFlagsAndTypeValid( 760| 434| ColumnFlag::arg_set_id), 761| 434| "Column type and flag combination is not valid"); 762| 434| static_assert( 763| 434| ColumnLegacy::IsFlagsAndTypeValid( 764| 434| ColumnFlag::machine_id), 765| 434| "Column type and flag combination is not valid"); 766| 434| OnConstructionCompletedRegularConstructor( 767| 434| {id_storage_layer_,pid_storage_layer_,name_storage_layer_,start_ts_storage_layer_,end_ts_storage_layer_,parent_upid_storage_layer_,uid_storage_layer_,android_appid_storage_layer_,android_user_id_storage_layer_,cmdline_storage_layer_,arg_set_id_storage_layer_,machine_id_storage_layer_}, 768| 434| {{},{},{},start_ts_null_layer_,end_ts_null_layer_,parent_upid_null_layer_,uid_null_layer_,android_appid_null_layer_,android_user_id_null_layer_,{},arg_set_id_null_layer_,machine_id_null_layer_}); 769| 434| } _ZN8perfetto15trace_processor6tables12ProcessTableixEj: 867| 182M| RowReference operator[](uint32_t r) { return RowReference(this, r); } _ZN8perfetto15trace_processor6tables12ProcessTable6InsertERKNS2_3RowE: 886| 566k| IdAndRow Insert(const Row& row) { 887| 566k| uint32_t row_number = row_count(); 888| 566k| Id id = Id{row_number}; 889| 566k| mutable_pid()->Append(row.pid); 890| 566k| mutable_name()->Append(row.name); 891| 566k| mutable_start_ts()->Append(row.start_ts); 892| 566k| mutable_end_ts()->Append(row.end_ts); 893| 566k| mutable_parent_upid()->Append(row.parent_upid); 894| 566k| mutable_uid()->Append(row.uid); 895| 566k| mutable_android_appid()->Append(row.android_appid); 896| 566k| mutable_android_user_id()->Append(row.android_user_id); 897| 566k| mutable_cmdline()->Append(row.cmdline); 898| 566k| mutable_arg_set_id()->Append(row.arg_set_id); 899| 566k| mutable_machine_id()->Append(row.machine_id); 900| 566k| UpdateSelfOverlayAfterInsert(); 901| 566k| return IdAndRow{id, row_number, RowReference(this, row_number), 902| 566k| RowNumber(row_number)}; 903| 566k| } _ZNK8perfetto15trace_processor6tables12ProcessTable3pidEv: 910| 182M| const TypedColumn& pid() const { 911| 182M| return static_cast(columns()[ColumnIndex::pid]); 912| 182M| } _ZNK8perfetto15trace_processor6tables12ProcessTable4nameEv: 913| 55.7k| const TypedColumn>& name() const { 914| 55.7k| return static_cast(columns()[ColumnIndex::name]); 915| 55.7k| } _ZNK8perfetto15trace_processor6tables12ProcessTable8start_tsEv: 916| 33.4k| const TypedColumn>& start_ts() const { 917| 33.4k| return static_cast(columns()[ColumnIndex::start_ts]); 918| 33.4k| } _ZNK8perfetto15trace_processor6tables12ProcessTable6end_tsEv: 919| 90.8M| const TypedColumn>& end_ts() const { 920| 90.8M| return static_cast(columns()[ColumnIndex::end_ts]); 921| 90.8M| } _ZN8perfetto15trace_processor6tables12ProcessTable11mutable_pidEv: 944| 566k| TypedColumn* mutable_pid() { 945| 566k| return static_cast( 946| 566k| GetColumn(ColumnIndex::pid)); 947| 566k| } _ZN8perfetto15trace_processor6tables12ProcessTable12mutable_nameEv: 948| 628k| TypedColumn>* mutable_name() { 949| 628k| return static_cast( 950| 628k| GetColumn(ColumnIndex::name)); 951| 628k| } _ZN8perfetto15trace_processor6tables12ProcessTable16mutable_start_tsEv: 952| 593k| TypedColumn>* mutable_start_ts() { 953| 593k| return static_cast( 954| 593k| GetColumn(ColumnIndex::start_ts)); 955| 593k| } _ZN8perfetto15trace_processor6tables12ProcessTable14mutable_end_tsEv: 956| 566k| TypedColumn>* mutable_end_ts() { 957| 566k| return static_cast( 958| 566k| GetColumn(ColumnIndex::end_ts)); 959| 566k| } _ZN8perfetto15trace_processor6tables12ProcessTable19mutable_parent_upidEv: 960| 566k| TypedColumn>* mutable_parent_upid() { 961| 566k| return static_cast( 962| 566k| GetColumn(ColumnIndex::parent_upid)); 963| 566k| } _ZN8perfetto15trace_processor6tables12ProcessTable11mutable_uidEv: 964| 566k| TypedColumn>* mutable_uid() { 965| 566k| return static_cast( 966| 566k| GetColumn(ColumnIndex::uid)); 967| 566k| } _ZN8perfetto15trace_processor6tables12ProcessTable21mutable_android_appidEv: 968| 566k| TypedColumn>* mutable_android_appid() { 969| 566k| return static_cast( 970| 566k| GetColumn(ColumnIndex::android_appid)); 971| 566k| } _ZN8perfetto15trace_processor6tables12ProcessTable23mutable_android_user_idEv: 972| 566k| TypedColumn>* mutable_android_user_id() { 973| 566k| return static_cast( 974| 566k| GetColumn(ColumnIndex::android_user_id)); 975| 566k| } _ZN8perfetto15trace_processor6tables12ProcessTable15mutable_cmdlineEv: 976| 566k| TypedColumn>* mutable_cmdline() { 977| 566k| return static_cast( 978| 566k| GetColumn(ColumnIndex::cmdline)); 979| 566k| } _ZN8perfetto15trace_processor6tables12ProcessTable18mutable_arg_set_idEv: 980| 666k| TypedColumn>* mutable_arg_set_id() { 981| 666k| return static_cast( 982| 666k| GetColumn(ColumnIndex::arg_set_id)); 983| 666k| } _ZN8perfetto15trace_processor6tables12ProcessTable18mutable_machine_idEv: 984| 566k| TypedColumn>* mutable_machine_id() { 985| 566k| return static_cast( 986| 566k| GetColumn(ColumnIndex::machine_id)); 987| 566k| } _ZN8perfetto15trace_processor6tables11ThreadTable2IdC2Ej: 1034| 682k| explicit constexpr Id(uint32_t v) : BaseId(v) {} _ZN8perfetto15trace_processor6tables11ThreadTable3RowC2EjNSt3__18optionalINS0_10StringPool2IdEEENS5_IlEES9_NS5_IjEESA_jNS5_INS1_12MachineTable2IdEEEDn: 1071| 682k| : macros_internal::RootParentTable::Row(), 1072| 682k| tid(in_tid), 1073| 682k| name(in_name), 1074| 682k| start_ts(in_start_ts), 1075| 682k| end_ts(in_end_ts), 1076| 682k| upid(in_upid), 1077| 682k| is_main_thread(in_is_main_thread), 1078| 682k| is_idle(in_is_idle), 1079| 682k| machine_id(in_machine_id) {} _ZN8perfetto15trace_processor6tables11ThreadTable9RowNumberC2Ej: 1119| 682k| : AbstractRowNumber(row_number) {} _ZN8perfetto15trace_processor6tables11ThreadTable17ConstRowReferenceC2EPKS2_j: 1128| 184M| : AbstractConstRowReference(table, row_number) {} _ZNK8perfetto15trace_processor6tables11ThreadTable17ConstRowReference3tidEv: 1133| 671k| ColumnType::tid::type tid() const { 1134| 671k| return table()->tid()[row_number_]; 1135| 671k| } _ZNK8perfetto15trace_processor6tables11ThreadTable17ConstRowReference6end_tsEv: 1142| 90.8M| ColumnType::end_ts::type end_ts() const { 1143| 90.8M| return table()->end_ts()[row_number_]; 1144| 90.8M| } _ZNK8perfetto15trace_processor6tables11ThreadTable17ConstRowReference4upidEv: 1145| 183M| ColumnType::upid::type upid() const { 1146| 183M| return table()->upid()[row_number_]; 1147| 183M| } _ZN8perfetto15trace_processor6tables11ThreadTable12RowReferenceC2EPKS2_j: 1163| 184M| : ConstRowReference(table, row_number) {} _ZN8perfetto15trace_processor6tables11ThreadTable12RowReference8set_nameENS0_10StringPool2IdE: 1170| 2.18k| ColumnType::name::non_optional_type v) { 1171| 2.18k| return mutable_table()->mutable_name()->Set(row_number_, v); 1172| 2.18k| } _ZN8perfetto15trace_processor6tables11ThreadTable12RowReference8set_upidEj: 1182| 671k| ColumnType::upid::non_optional_type v) { 1183| 671k| return mutable_table()->mutable_upid()->Set(row_number_, v); 1184| 671k| } _ZN8perfetto15trace_processor6tables11ThreadTable12RowReference18set_is_main_threadEj: 1186| 671k| ColumnType::is_main_thread::non_optional_type v) { 1187| 671k| return mutable_table()->mutable_is_main_thread()->Set(row_number_, v); 1188| 671k| } _ZNK8perfetto15trace_processor6tables11ThreadTable12RowReference13mutable_tableEv: 1199| 1.34M| ThreadTable* mutable_table() const { 1200| 1.34M| return const_cast(table()); 1201| 1.34M| } _ZN8perfetto15trace_processor6tables11ThreadTable10GetColumnsEPS2_PKNS0_15macros_internal10MacroTableE: 1292| 434| const macros_internal::MacroTable* parent) { 1293| 434| std::vector columns = 1294| 434| CopyColumnsFromParentOrAddRootColumns(parent); 1295| 434| uint32_t olay_idx = OverlayCount(parent); 1296| 434| AddColumnToVector(columns, "tid", &self->tid_, ColumnFlag::tid, 1297| 434| static_cast(columns.size()), olay_idx); 1298| 434| AddColumnToVector(columns, "name", &self->name_, ColumnFlag::name, 1299| 434| static_cast(columns.size()), olay_idx); 1300| 434| AddColumnToVector(columns, "start_ts", &self->start_ts_, ColumnFlag::start_ts, 1301| 434| static_cast(columns.size()), olay_idx); 1302| 434| AddColumnToVector(columns, "end_ts", &self->end_ts_, ColumnFlag::end_ts, 1303| 434| static_cast(columns.size()), olay_idx); 1304| 434| AddColumnToVector(columns, "upid", &self->upid_, ColumnFlag::upid, 1305| 434| static_cast(columns.size()), olay_idx); 1306| 434| AddColumnToVector(columns, "is_main_thread", &self->is_main_thread_, ColumnFlag::is_main_thread, 1307| 434| static_cast(columns.size()), olay_idx); 1308| 434| AddColumnToVector(columns, "is_idle", &self->is_idle_, ColumnFlag::is_idle, 1309| 434| static_cast(columns.size()), olay_idx); 1310| 434| AddColumnToVector(columns, "machine_id", &self->machine_id_, ColumnFlag::machine_id, 1311| 434| static_cast(columns.size()), olay_idx); 1312| 434| base::ignore_result(self); 1313| 434| return columns; 1314| 434| } _ZN8perfetto15trace_processor6tables11ThreadTableC2EPNS0_10StringPoolE: 1317| 434| : macros_internal::MacroTable( 1318| 434| pool, 1319| 434| GetColumns(this, nullptr), 1320| 434| nullptr), 1321| 434| tid_(ColumnStorage::Create()), 1322| 434| name_(ColumnStorage::Create()), 1323| 434| start_ts_(ColumnStorage::Create()), 1324| 434| end_ts_(ColumnStorage::Create()), 1325| 434| upid_(ColumnStorage::Create()), 1326| 434| is_main_thread_(ColumnStorage::Create()), 1327| 434| is_idle_(ColumnStorage::Create()), 1328| 434| machine_id_(ColumnStorage::Create()) 1329| |, 1330| 434| id_storage_layer_(new column::IdStorage()), 1331| 434| tid_storage_layer_( 1332| 434| new column::NumericStorage( 1333| 434| &tid_.vector(), 1334| 434| ColumnTypeHelper::ToColumnType(), 1335| 434| false)), 1336| 434| name_storage_layer_( 1337| 434| new column::StringStorage(string_pool(), &name_.vector())), 1338| 434| start_ts_storage_layer_( 1339| 434| new column::NumericStorage( 1340| 434| &start_ts_.non_null_vector(), 1341| 434| ColumnTypeHelper::ToColumnType(), 1342| 434| false)), 1343| 434| end_ts_storage_layer_( 1344| 434| new column::NumericStorage( 1345| 434| &end_ts_.non_null_vector(), 1346| 434| ColumnTypeHelper::ToColumnType(), 1347| 434| false)), 1348| 434| upid_storage_layer_( 1349| 434| new column::NumericStorage( 1350| 434| &upid_.non_null_vector(), 1351| 434| ColumnTypeHelper::ToColumnType(), 1352| 434| false)), 1353| 434| is_main_thread_storage_layer_( 1354| 434| new column::NumericStorage( 1355| 434| &is_main_thread_.non_null_vector(), 1356| 434| ColumnTypeHelper::ToColumnType(), 1357| 434| false)), 1358| 434| is_idle_storage_layer_( 1359| 434| new column::NumericStorage( 1360| 434| &is_idle_.vector(), 1361| 434| ColumnTypeHelper::ToColumnType(), 1362| 434| false)), 1363| 434| machine_id_storage_layer_( 1364| 434| new column::NumericStorage( 1365| 434| &machine_id_.non_null_vector(), 1366| 434| ColumnTypeHelper::ToColumnType(), 1367| 434| false)) 1368| |, 1369| 434| start_ts_null_layer_(new column::NullOverlay(start_ts_.bv())), 1370| 434| end_ts_null_layer_(new column::NullOverlay(end_ts_.bv())), 1371| 434| upid_null_layer_(new column::NullOverlay(upid_.bv())), 1372| 434| is_main_thread_null_layer_(new column::NullOverlay(is_main_thread_.bv())), 1373| 434| machine_id_null_layer_(new column::NullOverlay(machine_id_.bv())) { 1374| 434| static_assert( 1375| 434| ColumnLegacy::IsFlagsAndTypeValid( 1376| 434| ColumnFlag::tid), 1377| 434| "Column type and flag combination is not valid"); 1378| 434| static_assert( 1379| 434| ColumnLegacy::IsFlagsAndTypeValid( 1380| 434| ColumnFlag::name), 1381| 434| "Column type and flag combination is not valid"); 1382| 434| static_assert( 1383| 434| ColumnLegacy::IsFlagsAndTypeValid( 1384| 434| ColumnFlag::start_ts), 1385| 434| "Column type and flag combination is not valid"); 1386| 434| static_assert( 1387| 434| ColumnLegacy::IsFlagsAndTypeValid( 1388| 434| ColumnFlag::end_ts), 1389| 434| "Column type and flag combination is not valid"); 1390| 434| static_assert( 1391| 434| ColumnLegacy::IsFlagsAndTypeValid( 1392| 434| ColumnFlag::upid), 1393| 434| "Column type and flag combination is not valid"); 1394| 434| static_assert( 1395| 434| ColumnLegacy::IsFlagsAndTypeValid( 1396| 434| ColumnFlag::is_main_thread), 1397| 434| "Column type and flag combination is not valid"); 1398| 434| static_assert( 1399| 434| ColumnLegacy::IsFlagsAndTypeValid( 1400| 434| ColumnFlag::is_idle), 1401| 434| "Column type and flag combination is not valid"); 1402| 434| static_assert( 1403| 434| ColumnLegacy::IsFlagsAndTypeValid( 1404| 434| ColumnFlag::machine_id), 1405| 434| "Column type and flag combination is not valid"); 1406| 434| OnConstructionCompletedRegularConstructor( 1407| 434| {id_storage_layer_,tid_storage_layer_,name_storage_layer_,start_ts_storage_layer_,end_ts_storage_layer_,upid_storage_layer_,is_main_thread_storage_layer_,is_idle_storage_layer_,machine_id_storage_layer_}, 1408| 434| {{},{},{},start_ts_null_layer_,end_ts_null_layer_,upid_null_layer_,is_main_thread_null_layer_,{},machine_id_null_layer_}); 1409| 434| } _ZNK8perfetto15trace_processor6tables11ThreadTableixEj: 1486| 106k| ConstRowReference operator[](uint32_t r) const { 1487| 106k| return ConstRowReference(this, r); 1488| 106k| } _ZN8perfetto15trace_processor6tables11ThreadTableixEj: 1489| 184M| RowReference operator[](uint32_t r) { return RowReference(this, r); } _ZN8perfetto15trace_processor6tables11ThreadTable6InsertERKNS2_3RowE: 1508| 682k| IdAndRow Insert(const Row& row) { 1509| 682k| uint32_t row_number = row_count(); 1510| 682k| Id id = Id{row_number}; 1511| 682k| mutable_tid()->Append(row.tid); 1512| 682k| mutable_name()->Append(row.name); 1513| 682k| mutable_start_ts()->Append(row.start_ts); 1514| 682k| mutable_end_ts()->Append(row.end_ts); 1515| 682k| mutable_upid()->Append(row.upid); 1516| 682k| mutable_is_main_thread()->Append(row.is_main_thread); 1517| 682k| mutable_is_idle()->Append(row.is_idle); 1518| 682k| mutable_machine_id()->Append(row.machine_id); 1519| 682k| UpdateSelfOverlayAfterInsert(); 1520| 682k| return IdAndRow{id, row_number, RowReference(this, row_number), 1521| 682k| RowNumber(row_number)}; 1522| 682k| } _ZNK8perfetto15trace_processor6tables11ThreadTable3tidEv: 1529| 671k| const TypedColumn& tid() const { 1530| 671k| return static_cast(columns()[ColumnIndex::tid]); 1531| 671k| } _ZNK8perfetto15trace_processor6tables11ThreadTable6end_tsEv: 1538| 90.8M| const TypedColumn>& end_ts() const { 1539| 90.8M| return static_cast(columns()[ColumnIndex::end_ts]); 1540| 90.8M| } _ZNK8perfetto15trace_processor6tables11ThreadTable4upidEv: 1541| 183M| const TypedColumn>& upid() const { 1542| 183M| return static_cast(columns()[ColumnIndex::upid]); 1543| 183M| } _ZN8perfetto15trace_processor6tables11ThreadTable11mutable_tidEv: 1554| 682k| TypedColumn* mutable_tid() { 1555| 682k| return static_cast( 1556| 682k| GetColumn(ColumnIndex::tid)); 1557| 682k| } _ZN8perfetto15trace_processor6tables11ThreadTable12mutable_nameEv: 1558| 684k| TypedColumn>* mutable_name() { 1559| 684k| return static_cast( 1560| 684k| GetColumn(ColumnIndex::name)); 1561| 684k| } _ZN8perfetto15trace_processor6tables11ThreadTable16mutable_start_tsEv: 1562| 682k| TypedColumn>* mutable_start_ts() { 1563| 682k| return static_cast( 1564| 682k| GetColumn(ColumnIndex::start_ts)); 1565| 682k| } _ZN8perfetto15trace_processor6tables11ThreadTable14mutable_end_tsEv: 1566| 682k| TypedColumn>* mutable_end_ts() { 1567| 682k| return static_cast( 1568| 682k| GetColumn(ColumnIndex::end_ts)); 1569| 682k| } _ZN8perfetto15trace_processor6tables11ThreadTable12mutable_upidEv: 1570| 1.35M| TypedColumn>* mutable_upid() { 1571| 1.35M| return static_cast( 1572| 1.35M| GetColumn(ColumnIndex::upid)); 1573| 1.35M| } _ZN8perfetto15trace_processor6tables11ThreadTable22mutable_is_main_threadEv: 1574| 1.35M| TypedColumn>* mutable_is_main_thread() { 1575| 1.35M| return static_cast( 1576| 1.35M| GetColumn(ColumnIndex::is_main_thread)); 1577| 1.35M| } _ZN8perfetto15trace_processor6tables11ThreadTable15mutable_is_idleEv: 1578| 682k| TypedColumn* mutable_is_idle() { 1579| 682k| return static_cast( 1580| 682k| GetColumn(ColumnIndex::is_idle)); 1581| 682k| } _ZN8perfetto15trace_processor6tables11ThreadTable18mutable_machine_idEv: 1582| 682k| TypedColumn>* mutable_machine_id() { 1583| 682k| return static_cast( 1584| 682k| GetColumn(ColumnIndex::machine_id)); 1585| 682k| } _ZN8perfetto15trace_processor6tables8ArgTable2IdC2Ej: 1623| 2.16M| explicit constexpr Id(uint32_t v) : BaseId(v) {} _ZN8perfetto15trace_processor6tables8ArgTable3RowC2EjNS0_10StringPool2IdES5_NSt3__18optionalIlEENS7_IS5_EENS7_IdEES5_Dn: 1657| 2.16M| : macros_internal::RootParentTable::Row(), 1658| 2.16M| arg_set_id(in_arg_set_id), 1659| 2.16M| flat_key(in_flat_key), 1660| 2.16M| key(in_key), 1661| 2.16M| int_value(in_int_value), 1662| 2.16M| string_value(in_string_value), 1663| 2.16M| real_value(in_real_value), 1664| 2.16M| value_type(in_value_type) {} _ZN8perfetto15trace_processor6tables8ArgTable9RowNumberC2Ej: 1701| 2.16M| : AbstractRowNumber(row_number) {} _ZN8perfetto15trace_processor6tables8ArgTable17ConstRowReferenceC2EPKS2_j: 1710| 2.16M| : AbstractConstRowReference(table, row_number) {} _ZN8perfetto15trace_processor6tables8ArgTable12RowReferenceC2EPKS2_j: 1742| 2.16M| : ConstRowReference(table, row_number) {} _ZN8perfetto15trace_processor6tables8ArgTable10GetColumnsEPS2_PKNS0_15macros_internal10MacroTableE: 1862| 434| const macros_internal::MacroTable* parent) { 1863| 434| std::vector columns = 1864| 434| CopyColumnsFromParentOrAddRootColumns(parent); 1865| 434| uint32_t olay_idx = OverlayCount(parent); 1866| 434| AddColumnToVector(columns, "arg_set_id", &self->arg_set_id_, ColumnFlag::arg_set_id, 1867| 434| static_cast(columns.size()), olay_idx); 1868| 434| AddColumnToVector(columns, "flat_key", &self->flat_key_, ColumnFlag::flat_key, 1869| 434| static_cast(columns.size()), olay_idx); 1870| 434| AddColumnToVector(columns, "key", &self->key_, ColumnFlag::key, 1871| 434| static_cast(columns.size()), olay_idx); 1872| 434| AddColumnToVector(columns, "int_value", &self->int_value_, ColumnFlag::int_value, 1873| 434| static_cast(columns.size()), olay_idx); 1874| 434| AddColumnToVector(columns, "string_value", &self->string_value_, ColumnFlag::string_value, 1875| 434| static_cast(columns.size()), olay_idx); 1876| 434| AddColumnToVector(columns, "real_value", &self->real_value_, ColumnFlag::real_value, 1877| 434| static_cast(columns.size()), olay_idx); 1878| 434| AddColumnToVector(columns, "value_type", &self->value_type_, ColumnFlag::value_type, 1879| 434| static_cast(columns.size()), olay_idx); 1880| 434| base::ignore_result(self); 1881| 434| return columns; 1882| 434| } _ZN8perfetto15trace_processor6tables8ArgTableC2EPNS0_10StringPoolE: 1885| 434| : macros_internal::MacroTable( 1886| 434| pool, 1887| 434| GetColumns(this, nullptr), 1888| 434| nullptr), 1889| 434| arg_set_id_(ColumnStorage::Create()), 1890| 434| flat_key_(ColumnStorage::Create()), 1891| 434| key_(ColumnStorage::Create()), 1892| 434| int_value_(ColumnStorage::Create()), 1893| 434| string_value_(ColumnStorage::Create()), 1894| 434| real_value_(ColumnStorage::Create()), 1895| 434| value_type_(ColumnStorage::Create()) 1896| |, 1897| 434| id_storage_layer_(new column::IdStorage()), 1898| 434| arg_set_id_storage_layer_( 1899| 434| new column::SetIdStorage(&arg_set_id_.vector())), 1900| 434| flat_key_storage_layer_( 1901| 434| new column::StringStorage(string_pool(), &flat_key_.vector())), 1902| 434| key_storage_layer_( 1903| 434| new column::StringStorage(string_pool(), &key_.vector())), 1904| 434| int_value_storage_layer_( 1905| 434| new column::NumericStorage( 1906| 434| &int_value_.non_null_vector(), 1907| 434| ColumnTypeHelper::ToColumnType(), 1908| 434| false)), 1909| 434| string_value_storage_layer_( 1910| 434| new column::StringStorage(string_pool(), &string_value_.vector())), 1911| 434| real_value_storage_layer_( 1912| 434| new column::NumericStorage( 1913| 434| &real_value_.non_null_vector(), 1914| 434| ColumnTypeHelper::ToColumnType(), 1915| 434| false)), 1916| 434| value_type_storage_layer_( 1917| 434| new column::StringStorage(string_pool(), &value_type_.vector())) 1918| |, 1919| 434| int_value_null_layer_(new column::NullOverlay(int_value_.bv())), 1920| 434| real_value_null_layer_(new column::NullOverlay(real_value_.bv())) { 1921| 434| static_assert( 1922| 434| ColumnLegacy::IsFlagsAndTypeValid( 1923| 434| ColumnFlag::arg_set_id), 1924| 434| "Column type and flag combination is not valid"); 1925| 434| static_assert( 1926| 434| ColumnLegacy::IsFlagsAndTypeValid( 1927| 434| ColumnFlag::flat_key), 1928| 434| "Column type and flag combination is not valid"); 1929| 434| static_assert( 1930| 434| ColumnLegacy::IsFlagsAndTypeValid( 1931| 434| ColumnFlag::key), 1932| 434| "Column type and flag combination is not valid"); 1933| 434| static_assert( 1934| 434| ColumnLegacy::IsFlagsAndTypeValid( 1935| 434| ColumnFlag::int_value), 1936| 434| "Column type and flag combination is not valid"); 1937| 434| static_assert( 1938| 434| ColumnLegacy::IsFlagsAndTypeValid( 1939| 434| ColumnFlag::string_value), 1940| 434| "Column type and flag combination is not valid"); 1941| 434| static_assert( 1942| 434| ColumnLegacy::IsFlagsAndTypeValid( 1943| 434| ColumnFlag::real_value), 1944| 434| "Column type and flag combination is not valid"); 1945| 434| static_assert( 1946| 434| ColumnLegacy::IsFlagsAndTypeValid( 1947| 434| ColumnFlag::value_type), 1948| 434| "Column type and flag combination is not valid"); 1949| 434| OnConstructionCompletedRegularConstructor( 1950| 434| {id_storage_layer_,arg_set_id_storage_layer_,flat_key_storage_layer_,key_storage_layer_,int_value_storage_layer_,string_value_storage_layer_,real_value_storage_layer_,value_type_storage_layer_}, 1951| 434| {{},{},{},{},int_value_null_layer_,{},real_value_null_layer_,{}}); 1952| 434| } _ZN8perfetto15trace_processor6tables8ArgTable6InsertERKNS2_3RowE: 2045| 2.16M| IdAndRow Insert(const Row& row) { 2046| 2.16M| uint32_t row_number = row_count(); 2047| 2.16M| Id id = Id{row_number}; 2048| 2.16M| mutable_arg_set_id()->Append(row.arg_set_id); 2049| 2.16M| mutable_flat_key()->Append(row.flat_key); 2050| 2.16M| mutable_key()->Append(row.key); 2051| 2.16M| mutable_int_value()->Append(row.int_value); 2052| 2.16M| mutable_string_value()->Append(row.string_value); 2053| 2.16M| mutable_real_value()->Append(row.real_value); 2054| 2.16M| mutable_value_type()->Append(row.value_type); 2055| 2.16M| UpdateSelfOverlayAfterInsert(); 2056| 2.16M| return IdAndRow{id, row_number, RowReference(this, row_number), 2057| 2.16M| RowNumber(row_number)}; 2058| 2.16M| } _ZN8perfetto15trace_processor6tables8ArgTable18mutable_arg_set_idEv: 2087| 2.16M| TypedColumn* mutable_arg_set_id() { 2088| 2.16M| return static_cast( 2089| 2.16M| GetColumn(ColumnIndex::arg_set_id)); 2090| 2.16M| } _ZN8perfetto15trace_processor6tables8ArgTable16mutable_flat_keyEv: 2091| 2.16M| TypedColumn* mutable_flat_key() { 2092| 2.16M| return static_cast( 2093| 2.16M| GetColumn(ColumnIndex::flat_key)); 2094| 2.16M| } _ZN8perfetto15trace_processor6tables8ArgTable11mutable_keyEv: 2095| 2.16M| TypedColumn* mutable_key() { 2096| 2.16M| return static_cast( 2097| 2.16M| GetColumn(ColumnIndex::key)); 2098| 2.16M| } _ZN8perfetto15trace_processor6tables8ArgTable17mutable_int_valueEv: 2099| 2.16M| TypedColumn>* mutable_int_value() { 2100| 2.16M| return static_cast( 2101| 2.16M| GetColumn(ColumnIndex::int_value)); 2102| 2.16M| } _ZN8perfetto15trace_processor6tables8ArgTable20mutable_string_valueEv: 2103| 2.16M| TypedColumn>* mutable_string_value() { 2104| 2.16M| return static_cast( 2105| 2.16M| GetColumn(ColumnIndex::string_value)); 2106| 2.16M| } _ZN8perfetto15trace_processor6tables8ArgTable18mutable_real_valueEv: 2107| 2.16M| TypedColumn>* mutable_real_value() { 2108| 2.16M| return static_cast( 2109| 2.16M| GetColumn(ColumnIndex::real_value)); 2110| 2.16M| } _ZN8perfetto15trace_processor6tables8ArgTable18mutable_value_typeEv: 2111| 2.16M| TypedColumn* mutable_value_type() { 2112| 2.16M| return static_cast( 2113| 2.16M| GetColumn(ColumnIndex::value_type)); 2114| 2.16M| } _ZN8perfetto15trace_processor6tables14ChromeRawTable2IdC2Ej: 2147| 1.41M| explicit constexpr Id(uint32_t v) : BaseId(v) {} _ZN8perfetto15trace_processor6tables14ChromeRawTable3RowC2ElNS0_10StringPool2IdEjjDn: 2172| 1.41M| : macros_internal::RootParentTable::Row(), 2173| 1.41M| ts(in_ts), 2174| 1.41M| name(in_name), 2175| 1.41M| utid(in_utid), 2176| 1.41M| arg_set_id(in_arg_set_id) {} _ZN8perfetto15trace_processor6tables14ChromeRawTable9RowNumberC2Ej: 2204| 2.85M| : AbstractRowNumber(row_number) {} _ZN8perfetto15trace_processor6tables14ChromeRawTable17ConstRowReferenceC2EPKS2_j: 2213| 2.85M| : AbstractConstRowReference(table, row_number) {} _ZN8perfetto15trace_processor6tables14ChromeRawTable12RowReferenceC2EPKS2_j: 2236| 2.85M| : ConstRowReference(table, row_number) {} _ZN8perfetto15trace_processor6tables14ChromeRawTable10GetColumnsEPS2_PKNS0_15macros_internal10MacroTableE: 2329| 434| const macros_internal::MacroTable* parent) { 2330| 434| std::vector columns = 2331| 434| CopyColumnsFromParentOrAddRootColumns(parent); 2332| 434| uint32_t olay_idx = OverlayCount(parent); 2333| 434| AddColumnToVector(columns, "ts", &self->ts_, ColumnFlag::ts, 2334| 434| static_cast(columns.size()), olay_idx); 2335| 434| AddColumnToVector(columns, "name", &self->name_, ColumnFlag::name, 2336| 434| static_cast(columns.size()), olay_idx); 2337| 434| AddColumnToVector(columns, "utid", &self->utid_, ColumnFlag::utid, 2338| 434| static_cast(columns.size()), olay_idx); 2339| 434| AddColumnToVector(columns, "arg_set_id", &self->arg_set_id_, ColumnFlag::arg_set_id, 2340| 434| static_cast(columns.size()), olay_idx); 2341| 434| base::ignore_result(self); 2342| 434| return columns; 2343| 434| } _ZN8perfetto15trace_processor6tables14ChromeRawTableC2EPNS0_10StringPoolE: 2346| 434| : macros_internal::MacroTable( 2347| 434| pool, 2348| 434| GetColumns(this, nullptr), 2349| 434| nullptr), 2350| 434| ts_(ColumnStorage::Create()), 2351| 434| name_(ColumnStorage::Create()), 2352| 434| utid_(ColumnStorage::Create()), 2353| 434| arg_set_id_(ColumnStorage::Create()) 2354| |, 2355| 434| id_storage_layer_(new column::IdStorage()), 2356| 434| ts_storage_layer_( 2357| 434| new column::NumericStorage( 2358| 434| &ts_.vector(), 2359| 434| ColumnTypeHelper::ToColumnType(), 2360| 434| true)), 2361| 434| name_storage_layer_( 2362| 434| new column::StringStorage(string_pool(), &name_.vector())), 2363| 434| utid_storage_layer_( 2364| 434| new column::NumericStorage( 2365| 434| &utid_.vector(), 2366| 434| ColumnTypeHelper::ToColumnType(), 2367| 434| false)), 2368| 434| arg_set_id_storage_layer_( 2369| 434| new column::NumericStorage( 2370| 434| &arg_set_id_.vector(), 2371| 434| ColumnTypeHelper::ToColumnType(), 2372| 434| false)) 2373| 434| { 2374| 434| static_assert( 2375| 434| ColumnLegacy::IsFlagsAndTypeValid( 2376| 434| ColumnFlag::ts), 2377| 434| "Column type and flag combination is not valid"); 2378| 434| static_assert( 2379| 434| ColumnLegacy::IsFlagsAndTypeValid( 2380| 434| ColumnFlag::name), 2381| 434| "Column type and flag combination is not valid"); 2382| 434| static_assert( 2383| 434| ColumnLegacy::IsFlagsAndTypeValid( 2384| 434| ColumnFlag::utid), 2385| 434| "Column type and flag combination is not valid"); 2386| 434| static_assert( 2387| 434| ColumnLegacy::IsFlagsAndTypeValid( 2388| 434| ColumnFlag::arg_set_id), 2389| 434| "Column type and flag combination is not valid"); 2390| 434| OnConstructionCompletedRegularConstructor( 2391| 434| {id_storage_layer_,ts_storage_layer_,name_storage_layer_,utid_storage_layer_,arg_set_id_storage_layer_}, 2392| 434| {{},{},{},{},{}}); 2393| 434| } _ZN8perfetto15trace_processor6tables14ChromeRawTable8FindByIdENS2_2IdE: 2463| 1.44M| std::optional FindById(Id find_id) { 2464| 1.44M| std::optional row = id().IndexOf(find_id); 2465| 1.44M| return row ? std::make_optional(RowReference(this, *row)) : std::nullopt; ------------------ | Branch (2465:12): [True: 1.44M, False: 0] ------------------ 2466| 1.44M| } _ZN8perfetto15trace_processor6tables14ChromeRawTable6InsertERKNS2_3RowE: 2468| 1.41M| IdAndRow Insert(const Row& row) { 2469| 1.41M| uint32_t row_number = row_count(); 2470| 1.41M| Id id = Id{row_number}; 2471| 1.41M| mutable_ts()->Append(row.ts); 2472| 1.41M| mutable_name()->Append(row.name); 2473| 1.41M| mutable_utid()->Append(row.utid); 2474| 1.41M| mutable_arg_set_id()->Append(row.arg_set_id); 2475| 1.41M| UpdateSelfOverlayAfterInsert(); 2476| 1.41M| return IdAndRow{id, row_number, RowReference(this, row_number), 2477| 1.41M| RowNumber(row_number)}; 2478| 1.41M| } _ZNK8perfetto15trace_processor6tables14ChromeRawTable2idEv: 2482| 1.44M| const IdColumn& id() const { 2483| 1.44M| return static_cast(columns()[ColumnIndex::id]); 2484| 1.44M| } _ZN8perfetto15trace_processor6tables14ChromeRawTable10mutable_tsEv: 2498| 1.41M| TypedColumn* mutable_ts() { 2499| 1.41M| return static_cast( 2500| 1.41M| GetColumn(ColumnIndex::ts)); 2501| 1.41M| } _ZN8perfetto15trace_processor6tables14ChromeRawTable12mutable_nameEv: 2502| 1.41M| TypedColumn* mutable_name() { 2503| 1.41M| return static_cast( 2504| 1.41M| GetColumn(ColumnIndex::name)); 2505| 1.41M| } _ZN8perfetto15trace_processor6tables14ChromeRawTable12mutable_utidEv: 2506| 1.41M| TypedColumn* mutable_utid() { 2507| 1.41M| return static_cast( 2508| 1.41M| GetColumn(ColumnIndex::utid)); 2509| 1.41M| } _ZN8perfetto15trace_processor6tables14ChromeRawTable18mutable_arg_set_idEv: 2510| 2.85M| TypedColumn* mutable_arg_set_id() { 2511| 2.85M| return static_cast( 2512| 2.85M| GetColumn(ColumnIndex::arg_set_id)); 2513| 2.85M| } _ZN8perfetto15trace_processor6tables18ClockSnapshotTable2IdC2Ej: 2539| 25.1k| explicit constexpr Id(uint32_t v) : BaseId(v) {} _ZN8perfetto15trace_processor6tables18ClockSnapshotTable3RowC2EllNSt3__18optionalINS0_10StringPool2IdEEEljNS5_INS1_12MachineTable2IdEEEDn: 2570| 25.1k| : macros_internal::RootParentTable::Row(), 2571| 25.1k| ts(in_ts), 2572| 25.1k| clock_id(in_clock_id), 2573| 25.1k| clock_name(in_clock_name), 2574| 25.1k| clock_value(in_clock_value), 2575| 25.1k| snapshot_id(in_snapshot_id), 2576| 25.1k| machine_id(in_machine_id) {} _ZN8perfetto15trace_processor6tables18ClockSnapshotTable9RowNumberC2Ej: 2610| 25.1k| : AbstractRowNumber(row_number) {} _ZN8perfetto15trace_processor6tables18ClockSnapshotTable17ConstRowReferenceC2EPKS2_j: 2619| 25.1k| : AbstractConstRowReference(table, row_number) {} _ZN8perfetto15trace_processor6tables18ClockSnapshotTable12RowReferenceC2EPKS2_j: 2648| 25.1k| : ConstRowReference(table, row_number) {} _ZN8perfetto15trace_processor6tables18ClockSnapshotTable10GetColumnsEPS2_PKNS0_15macros_internal10MacroTableE: 2759| 434| const macros_internal::MacroTable* parent) { 2760| 434| std::vector columns = 2761| 434| CopyColumnsFromParentOrAddRootColumns(parent); 2762| 434| uint32_t olay_idx = OverlayCount(parent); 2763| 434| AddColumnToVector(columns, "ts", &self->ts_, ColumnFlag::ts, 2764| 434| static_cast(columns.size()), olay_idx); 2765| 434| AddColumnToVector(columns, "clock_id", &self->clock_id_, ColumnFlag::clock_id, 2766| 434| static_cast(columns.size()), olay_idx); 2767| 434| AddColumnToVector(columns, "clock_name", &self->clock_name_, ColumnFlag::clock_name, 2768| 434| static_cast(columns.size()), olay_idx); 2769| 434| AddColumnToVector(columns, "clock_value", &self->clock_value_, ColumnFlag::clock_value, 2770| 434| static_cast(columns.size()), olay_idx); 2771| 434| AddColumnToVector(columns, "snapshot_id", &self->snapshot_id_, ColumnFlag::snapshot_id, 2772| 434| static_cast(columns.size()), olay_idx); 2773| 434| AddColumnToVector(columns, "machine_id", &self->machine_id_, ColumnFlag::machine_id, 2774| 434| static_cast(columns.size()), olay_idx); 2775| 434| base::ignore_result(self); 2776| 434| return columns; 2777| 434| } _ZN8perfetto15trace_processor6tables18ClockSnapshotTableC2EPNS0_10StringPoolE: 2780| 434| : macros_internal::MacroTable( 2781| 434| pool, 2782| 434| GetColumns(this, nullptr), 2783| 434| nullptr), 2784| 434| ts_(ColumnStorage::Create()), 2785| 434| clock_id_(ColumnStorage::Create()), 2786| 434| clock_name_(ColumnStorage::Create()), 2787| 434| clock_value_(ColumnStorage::Create()), 2788| 434| snapshot_id_(ColumnStorage::Create()), 2789| 434| machine_id_(ColumnStorage::Create()) 2790| |, 2791| 434| id_storage_layer_(new column::IdStorage()), 2792| 434| ts_storage_layer_( 2793| 434| new column::NumericStorage( 2794| 434| &ts_.vector(), 2795| 434| ColumnTypeHelper::ToColumnType(), 2796| 434| false)), 2797| 434| clock_id_storage_layer_( 2798| 434| new column::NumericStorage( 2799| 434| &clock_id_.vector(), 2800| 434| ColumnTypeHelper::ToColumnType(), 2801| 434| false)), 2802| 434| clock_name_storage_layer_( 2803| 434| new column::StringStorage(string_pool(), &clock_name_.vector())), 2804| 434| clock_value_storage_layer_( 2805| 434| new column::NumericStorage( 2806| 434| &clock_value_.vector(), 2807| 434| ColumnTypeHelper::ToColumnType(), 2808| 434| false)), 2809| 434| snapshot_id_storage_layer_( 2810| 434| new column::NumericStorage( 2811| 434| &snapshot_id_.vector(), 2812| 434| ColumnTypeHelper::ToColumnType(), 2813| 434| false)), 2814| 434| machine_id_storage_layer_( 2815| 434| new column::NumericStorage( 2816| 434| &machine_id_.non_null_vector(), 2817| 434| ColumnTypeHelper::ToColumnType(), 2818| 434| false)) 2819| |, 2820| 434| machine_id_null_layer_(new column::NullOverlay(machine_id_.bv())) { 2821| 434| static_assert( 2822| 434| ColumnLegacy::IsFlagsAndTypeValid( 2823| 434| ColumnFlag::ts), 2824| 434| "Column type and flag combination is not valid"); 2825| 434| static_assert( 2826| 434| ColumnLegacy::IsFlagsAndTypeValid( 2827| 434| ColumnFlag::clock_id), 2828| 434| "Column type and flag combination is not valid"); 2829| 434| static_assert( 2830| 434| ColumnLegacy::IsFlagsAndTypeValid( 2831| 434| ColumnFlag::clock_name), 2832| 434| "Column type and flag combination is not valid"); 2833| 434| static_assert( 2834| 434| ColumnLegacy::IsFlagsAndTypeValid( 2835| 434| ColumnFlag::clock_value), 2836| 434| "Column type and flag combination is not valid"); 2837| 434| static_assert( 2838| 434| ColumnLegacy::IsFlagsAndTypeValid( 2839| 434| ColumnFlag::snapshot_id), 2840| 434| "Column type and flag combination is not valid"); 2841| 434| static_assert( 2842| 434| ColumnLegacy::IsFlagsAndTypeValid( 2843| 434| ColumnFlag::machine_id), 2844| 434| "Column type and flag combination is not valid"); 2845| 434| OnConstructionCompletedRegularConstructor( 2846| 434| {id_storage_layer_,ts_storage_layer_,clock_id_storage_layer_,clock_name_storage_layer_,clock_value_storage_layer_,snapshot_id_storage_layer_,machine_id_storage_layer_}, 2847| 434| {{},{},{},{},{},{},machine_id_null_layer_}); 2848| 434| } _ZN8perfetto15trace_processor6tables18ClockSnapshotTable6InsertERKNS2_3RowE: 2935| 25.1k| IdAndRow Insert(const Row& row) { 2936| 25.1k| uint32_t row_number = row_count(); 2937| 25.1k| Id id = Id{row_number}; 2938| 25.1k| mutable_ts()->Append(row.ts); 2939| 25.1k| mutable_clock_id()->Append(row.clock_id); 2940| 25.1k| mutable_clock_name()->Append(row.clock_name); 2941| 25.1k| mutable_clock_value()->Append(row.clock_value); 2942| 25.1k| mutable_snapshot_id()->Append(row.snapshot_id); 2943| 25.1k| mutable_machine_id()->Append(row.machine_id); 2944| 25.1k| UpdateSelfOverlayAfterInsert(); 2945| 25.1k| return IdAndRow{id, row_number, RowReference(this, row_number), 2946| 25.1k| RowNumber(row_number)}; 2947| 25.1k| } _ZN8perfetto15trace_processor6tables18ClockSnapshotTable10mutable_tsEv: 2973| 25.1k| TypedColumn* mutable_ts() { 2974| 25.1k| return static_cast( 2975| 25.1k| GetColumn(ColumnIndex::ts)); 2976| 25.1k| } _ZN8perfetto15trace_processor6tables18ClockSnapshotTable16mutable_clock_idEv: 2977| 25.1k| TypedColumn* mutable_clock_id() { 2978| 25.1k| return static_cast( 2979| 25.1k| GetColumn(ColumnIndex::clock_id)); 2980| 25.1k| } _ZN8perfetto15trace_processor6tables18ClockSnapshotTable18mutable_clock_nameEv: 2981| 25.1k| TypedColumn>* mutable_clock_name() { 2982| 25.1k| return static_cast( 2983| 25.1k| GetColumn(ColumnIndex::clock_name)); 2984| 25.1k| } _ZN8perfetto15trace_processor6tables18ClockSnapshotTable19mutable_clock_valueEv: 2985| 25.1k| TypedColumn* mutable_clock_value() { 2986| 25.1k| return static_cast( 2987| 25.1k| GetColumn(ColumnIndex::clock_value)); 2988| 25.1k| } _ZN8perfetto15trace_processor6tables18ClockSnapshotTable19mutable_snapshot_idEv: 2989| 25.1k| TypedColumn* mutable_snapshot_id() { 2990| 25.1k| return static_cast( 2991| 25.1k| GetColumn(ColumnIndex::snapshot_id)); 2992| 25.1k| } _ZN8perfetto15trace_processor6tables18ClockSnapshotTable18mutable_machine_idEv: 2993| 25.1k| TypedColumn>* mutable_machine_id() { 2994| 25.1k| return static_cast( 2995| 25.1k| GetColumn(ColumnIndex::machine_id)); 2996| 25.1k| } _ZN8perfetto15trace_processor6tables8CpuTable2IdC2Ej: 3026| 8.34M| explicit constexpr Id(uint32_t v) : BaseId(v) {} _ZN8perfetto15trace_processor6tables8CpuTable3RowC2ENSt3__18optionalIjEEjNS0_10StringPool2IdENS5_INS1_12MachineTable2IdEEES6_S6_Dn: 3057| 8.34M| : macros_internal::RootParentTable::Row(), 3058| 8.34M| cpu(in_cpu), 3059| 8.34M| cluster_id(in_cluster_id), 3060| 8.34M| processor(in_processor), 3061| 8.34M| machine_id(in_machine_id), 3062| 8.34M| capacity(in_capacity), 3063| 8.34M| arg_set_id(in_arg_set_id) {} _ZN8perfetto15trace_processor6tables8CpuTable9RowNumberC2Ej: 3097| 8.34M| : AbstractRowNumber(row_number) {} _ZN8perfetto15trace_processor6tables8CpuTable17ConstRowReferenceC2EPKS2_j: 3106| 8.34M| : AbstractConstRowReference(table, row_number) {} _ZN8perfetto15trace_processor6tables8CpuTable12RowReferenceC2EPKS2_j: 3135| 8.34M| : ConstRowReference(table, row_number) {} _ZN8perfetto15trace_processor6tables8CpuTable10GetColumnsEPS2_PKNS0_15macros_internal10MacroTableE: 3246| 434| const macros_internal::MacroTable* parent) { 3247| 434| std::vector columns = 3248| 434| CopyColumnsFromParentOrAddRootColumns(parent); 3249| 434| uint32_t olay_idx = OverlayCount(parent); 3250| 434| AddColumnToVector(columns, "cpu", &self->cpu_, ColumnFlag::cpu, 3251| 434| static_cast(columns.size()), olay_idx); 3252| 434| AddColumnToVector(columns, "cluster_id", &self->cluster_id_, ColumnFlag::cluster_id, 3253| 434| static_cast(columns.size()), olay_idx); 3254| 434| AddColumnToVector(columns, "processor", &self->processor_, ColumnFlag::processor, 3255| 434| static_cast(columns.size()), olay_idx); 3256| 434| AddColumnToVector(columns, "machine_id", &self->machine_id_, ColumnFlag::machine_id, 3257| 434| static_cast(columns.size()), olay_idx); 3258| 434| AddColumnToVector(columns, "capacity", &self->capacity_, ColumnFlag::capacity, 3259| 434| static_cast(columns.size()), olay_idx); 3260| 434| AddColumnToVector(columns, "arg_set_id", &self->arg_set_id_, ColumnFlag::arg_set_id, 3261| 434| static_cast(columns.size()), olay_idx); 3262| 434| base::ignore_result(self); 3263| 434| return columns; 3264| 434| } _ZN8perfetto15trace_processor6tables8CpuTableC2EPNS0_10StringPoolE: 3267| 434| : macros_internal::MacroTable( 3268| 434| pool, 3269| 434| GetColumns(this, nullptr), 3270| 434| nullptr), 3271| 434| cpu_(ColumnStorage::Create()), 3272| 434| cluster_id_(ColumnStorage::Create()), 3273| 434| processor_(ColumnStorage::Create()), 3274| 434| machine_id_(ColumnStorage::Create()), 3275| 434| capacity_(ColumnStorage::Create()), 3276| 434| arg_set_id_(ColumnStorage::Create()) 3277| |, 3278| 434| id_storage_layer_(new column::IdStorage()), 3279| 434| cpu_storage_layer_( 3280| 434| new column::NumericStorage( 3281| 434| &cpu_.non_null_vector(), 3282| 434| ColumnTypeHelper::ToColumnType(), 3283| 434| false)), 3284| 434| cluster_id_storage_layer_( 3285| 434| new column::NumericStorage( 3286| 434| &cluster_id_.vector(), 3287| 434| ColumnTypeHelper::ToColumnType(), 3288| 434| false)), 3289| 434| processor_storage_layer_( 3290| 434| new column::StringStorage(string_pool(), &processor_.vector())), 3291| 434| machine_id_storage_layer_( 3292| 434| new column::NumericStorage( 3293| 434| &machine_id_.non_null_vector(), 3294| 434| ColumnTypeHelper::ToColumnType(), 3295| 434| false)), 3296| 434| capacity_storage_layer_( 3297| 434| new column::NumericStorage( 3298| 434| &capacity_.non_null_vector(), 3299| 434| ColumnTypeHelper::ToColumnType(), 3300| 434| false)), 3301| 434| arg_set_id_storage_layer_( 3302| 434| new column::NumericStorage( 3303| 434| &arg_set_id_.non_null_vector(), 3304| 434| ColumnTypeHelper::ToColumnType(), 3305| 434| false)) 3306| |, 3307| 434| cpu_null_layer_(new column::NullOverlay(cpu_.bv())), 3308| 434| machine_id_null_layer_(new column::NullOverlay(machine_id_.bv())), 3309| 434| capacity_null_layer_(new column::NullOverlay(capacity_.bv())), 3310| 434| arg_set_id_null_layer_(new column::NullOverlay(arg_set_id_.bv())) { 3311| 434| static_assert( 3312| 434| ColumnLegacy::IsFlagsAndTypeValid( 3313| 434| ColumnFlag::cpu), 3314| 434| "Column type and flag combination is not valid"); 3315| 434| static_assert( 3316| 434| ColumnLegacy::IsFlagsAndTypeValid( 3317| 434| ColumnFlag::cluster_id), 3318| 434| "Column type and flag combination is not valid"); 3319| 434| static_assert( 3320| 434| ColumnLegacy::IsFlagsAndTypeValid( 3321| 434| ColumnFlag::processor), 3322| 434| "Column type and flag combination is not valid"); 3323| 434| static_assert( 3324| 434| ColumnLegacy::IsFlagsAndTypeValid( 3325| 434| ColumnFlag::machine_id), 3326| 434| "Column type and flag combination is not valid"); 3327| 434| static_assert( 3328| 434| ColumnLegacy::IsFlagsAndTypeValid( 3329| 434| ColumnFlag::capacity), 3330| 434| "Column type and flag combination is not valid"); 3331| 434| static_assert( 3332| 434| ColumnLegacy::IsFlagsAndTypeValid( 3333| 434| ColumnFlag::arg_set_id), 3334| 434| "Column type and flag combination is not valid"); 3335| 434| OnConstructionCompletedRegularConstructor( 3336| 434| {id_storage_layer_,cpu_storage_layer_,cluster_id_storage_layer_,processor_storage_layer_,machine_id_storage_layer_,capacity_storage_layer_,arg_set_id_storage_layer_}, 3337| 434| {{},cpu_null_layer_,{},{},machine_id_null_layer_,capacity_null_layer_,arg_set_id_null_layer_}); 3338| 434| } _ZN8perfetto15trace_processor6tables8CpuTable6InsertERKNS2_3RowE: 3425| 8.34M| IdAndRow Insert(const Row& row) { 3426| 8.34M| uint32_t row_number = row_count(); 3427| 8.34M| Id id = Id{row_number}; 3428| 8.34M| mutable_cpu()->Append(row.cpu); 3429| 8.34M| mutable_cluster_id()->Append(row.cluster_id); 3430| 8.34M| mutable_processor()->Append(row.processor); 3431| 8.34M| mutable_machine_id()->Append(row.machine_id); 3432| 8.34M| mutable_capacity()->Append(row.capacity); 3433| 8.34M| mutable_arg_set_id()->Append(row.arg_set_id); 3434| 8.34M| UpdateSelfOverlayAfterInsert(); 3435| 8.34M| return IdAndRow{id, row_number, RowReference(this, row_number), 3436| 8.34M| RowNumber(row_number)}; 3437| 8.34M| } _ZN8perfetto15trace_processor6tables8CpuTable11mutable_cpuEv: 3463| 8.34M| TypedColumn>* mutable_cpu() { 3464| 8.34M| return static_cast( 3465| 8.34M| GetColumn(ColumnIndex::cpu)); 3466| 8.34M| } _ZN8perfetto15trace_processor6tables8CpuTable18mutable_cluster_idEv: 3467| 8.34M| TypedColumn* mutable_cluster_id() { 3468| 8.34M| return static_cast( 3469| 8.34M| GetColumn(ColumnIndex::cluster_id)); 3470| 8.34M| } _ZN8perfetto15trace_processor6tables8CpuTable17mutable_processorEv: 3471| 8.34M| TypedColumn* mutable_processor() { 3472| 8.34M| return static_cast( 3473| 8.34M| GetColumn(ColumnIndex::processor)); 3474| 8.34M| } _ZN8perfetto15trace_processor6tables8CpuTable18mutable_machine_idEv: 3475| 8.34M| TypedColumn>* mutable_machine_id() { 3476| 8.34M| return static_cast( 3477| 8.34M| GetColumn(ColumnIndex::machine_id)); 3478| 8.34M| } _ZN8perfetto15trace_processor6tables8CpuTable16mutable_capacityEv: 3479| 8.34M| TypedColumn>* mutable_capacity() { 3480| 8.34M| return static_cast( 3481| 8.34M| GetColumn(ColumnIndex::capacity)); 3482| 8.34M| } _ZN8perfetto15trace_processor6tables8CpuTable18mutable_arg_set_idEv: 3483| 8.34M| TypedColumn>* mutable_arg_set_id() { 3484| 8.34M| return static_cast( 3485| 8.34M| GetColumn(ColumnIndex::arg_set_id)); 3486| 8.34M| } _ZN8perfetto15trace_processor6tables12CpuFreqTable10GetColumnsEPS2_PKNS0_15macros_internal10MacroTableE: 3663| 434| const macros_internal::MacroTable* parent) { 3664| 434| std::vector columns = 3665| 434| CopyColumnsFromParentOrAddRootColumns(parent); 3666| 434| uint32_t olay_idx = OverlayCount(parent); 3667| 434| AddColumnToVector(columns, "ucpu", &self->ucpu_, ColumnFlag::ucpu, 3668| 434| static_cast(columns.size()), olay_idx); 3669| 434| AddColumnToVector(columns, "freq", &self->freq_, ColumnFlag::freq, 3670| 434| static_cast(columns.size()), olay_idx); 3671| 434| base::ignore_result(self); 3672| 434| return columns; 3673| 434| } _ZN8perfetto15trace_processor6tables12CpuFreqTableC2EPNS0_10StringPoolE: 3676| 434| : macros_internal::MacroTable( 3677| 434| pool, 3678| 434| GetColumns(this, nullptr), 3679| 434| nullptr), 3680| 434| ucpu_(ColumnStorage::Create()), 3681| 434| freq_(ColumnStorage::Create()) 3682| |, 3683| 434| id_storage_layer_(new column::IdStorage()), 3684| 434| ucpu_storage_layer_( 3685| 434| new column::NumericStorage( 3686| 434| &ucpu_.vector(), 3687| 434| ColumnTypeHelper::ToColumnType(), 3688| 434| false)), 3689| 434| freq_storage_layer_( 3690| 434| new column::NumericStorage( 3691| 434| &freq_.vector(), 3692| 434| ColumnTypeHelper::ToColumnType(), 3693| 434| false)) 3694| 434| { 3695| 434| static_assert( 3696| 434| ColumnLegacy::IsFlagsAndTypeValid( 3697| 434| ColumnFlag::ucpu), 3698| 434| "Column type and flag combination is not valid"); 3699| 434| static_assert( 3700| 434| ColumnLegacy::IsFlagsAndTypeValid( 3701| 434| ColumnFlag::freq), 3702| 434| "Column type and flag combination is not valid"); 3703| 434| OnConstructionCompletedRegularConstructor( 3704| 434| {id_storage_layer_,ucpu_storage_layer_,freq_storage_layer_}, 3705| 434| {{},{},{}}); 3706| 434| } _ZN8perfetto15trace_processor6tables25ExpMissingChromeProcTable2IdC2Ej: 3820| 361k| explicit constexpr Id(uint32_t v) : BaseId(v) {} _ZN8perfetto15trace_processor6tables25ExpMissingChromeProcTable3RowC2EjNSt3__18optionalIlEEDn: 3839| 361k| : macros_internal::RootParentTable::Row(), 3840| 361k| upid(in_upid), 3841| 361k| reliable_from(in_reliable_from) {} _ZN8perfetto15trace_processor6tables25ExpMissingChromeProcTable9RowNumberC2Ej: 3863| 361k| : AbstractRowNumber(row_number) {} _ZN8perfetto15trace_processor6tables25ExpMissingChromeProcTable17ConstRowReferenceC2EPKS2_j: 3872| 361k| : AbstractConstRowReference(table, row_number) {} _ZN8perfetto15trace_processor6tables25ExpMissingChromeProcTable12RowReferenceC2EPKS2_j: 3889| 361k| : ConstRowReference(table, row_number) {} _ZN8perfetto15trace_processor6tables25ExpMissingChromeProcTable10GetColumnsEPS2_PKNS0_15macros_internal10MacroTableE: 3964| 434| const macros_internal::MacroTable* parent) { 3965| 434| std::vector columns = 3966| 434| CopyColumnsFromParentOrAddRootColumns(parent); 3967| 434| uint32_t olay_idx = OverlayCount(parent); 3968| 434| AddColumnToVector(columns, "upid", &self->upid_, ColumnFlag::upid, 3969| 434| static_cast(columns.size()), olay_idx); 3970| 434| AddColumnToVector(columns, "reliable_from", &self->reliable_from_, ColumnFlag::reliable_from, 3971| 434| static_cast(columns.size()), olay_idx); 3972| 434| base::ignore_result(self); 3973| 434| return columns; 3974| 434| } _ZN8perfetto15trace_processor6tables25ExpMissingChromeProcTableC2EPNS0_10StringPoolE: 3977| 434| : macros_internal::MacroTable( 3978| 434| pool, 3979| 434| GetColumns(this, nullptr), 3980| 434| nullptr), 3981| 434| upid_(ColumnStorage::Create()), 3982| 434| reliable_from_(ColumnStorage::Create()) 3983| |, 3984| 434| id_storage_layer_(new column::IdStorage()), 3985| 434| upid_storage_layer_( 3986| 434| new column::NumericStorage( 3987| 434| &upid_.vector(), 3988| 434| ColumnTypeHelper::ToColumnType(), 3989| 434| false)), 3990| 434| reliable_from_storage_layer_( 3991| 434| new column::NumericStorage( 3992| 434| &reliable_from_.non_null_vector(), 3993| 434| ColumnTypeHelper::ToColumnType(), 3994| 434| false)) 3995| |, 3996| 434| reliable_from_null_layer_(new column::NullOverlay(reliable_from_.bv())) { 3997| 434| static_assert( 3998| 434| ColumnLegacy::IsFlagsAndTypeValid( 3999| 434| ColumnFlag::upid), 4000| 434| "Column type and flag combination is not valid"); 4001| 434| static_assert( 4002| 434| ColumnLegacy::IsFlagsAndTypeValid( 4003| 434| ColumnFlag::reliable_from), 4004| 434| "Column type and flag combination is not valid"); 4005| 434| OnConstructionCompletedRegularConstructor( 4006| 434| {id_storage_layer_,upid_storage_layer_,reliable_from_storage_layer_}, 4007| 434| {{},{},reliable_from_null_layer_}); 4008| 434| } _ZN8perfetto15trace_processor6tables25ExpMissingChromeProcTable6InsertERKNS2_3RowE: 4071| 361k| IdAndRow Insert(const Row& row) { 4072| 361k| uint32_t row_number = row_count(); 4073| 361k| Id id = Id{row_number}; 4074| 361k| mutable_upid()->Append(row.upid); 4075| 361k| mutable_reliable_from()->Append(row.reliable_from); 4076| 361k| UpdateSelfOverlayAfterInsert(); 4077| 361k| return IdAndRow{id, row_number, RowReference(this, row_number), 4078| 361k| RowNumber(row_number)}; 4079| 361k| } _ZN8perfetto15trace_processor6tables25ExpMissingChromeProcTable12mutable_upidEv: 4093| 361k| TypedColumn* mutable_upid() { 4094| 361k| return static_cast( 4095| 361k| GetColumn(ColumnIndex::upid)); 4096| 361k| } _ZN8perfetto15trace_processor6tables25ExpMissingChromeProcTable21mutable_reliable_fromEv: 4097| 361k| TypedColumn>* mutable_reliable_from() { 4098| 361k| return static_cast( 4099| 361k| GetColumn(ColumnIndex::reliable_from)); 4100| 361k| } _ZN8perfetto15trace_processor6tables19FiledescriptorTable10GetColumnsEPS2_PKNS0_15macros_internal10MacroTableE: 4323| 434| const macros_internal::MacroTable* parent) { 4324| 434| std::vector columns = 4325| 434| CopyColumnsFromParentOrAddRootColumns(parent); 4326| 434| uint32_t olay_idx = OverlayCount(parent); 4327| 434| AddColumnToVector(columns, "ufd", &self->ufd_, ColumnFlag::ufd, 4328| 434| static_cast(columns.size()), olay_idx); 4329| 434| AddColumnToVector(columns, "fd", &self->fd_, ColumnFlag::fd, 4330| 434| static_cast(columns.size()), olay_idx); 4331| 434| AddColumnToVector(columns, "ts", &self->ts_, ColumnFlag::ts, 4332| 434| static_cast(columns.size()), olay_idx); 4333| 434| AddColumnToVector(columns, "upid", &self->upid_, ColumnFlag::upid, 4334| 434| static_cast(columns.size()), olay_idx); 4335| 434| AddColumnToVector(columns, "path", &self->path_, ColumnFlag::path, 4336| 434| static_cast(columns.size()), olay_idx); 4337| 434| base::ignore_result(self); 4338| 434| return columns; 4339| 434| } _ZN8perfetto15trace_processor6tables19FiledescriptorTableC2EPNS0_10StringPoolE: 4342| 434| : macros_internal::MacroTable( 4343| 434| pool, 4344| 434| GetColumns(this, nullptr), 4345| 434| nullptr), 4346| 434| ufd_(ColumnStorage::Create()), 4347| 434| fd_(ColumnStorage::Create()), 4348| 434| ts_(ColumnStorage::Create()), 4349| 434| upid_(ColumnStorage::Create()), 4350| 434| path_(ColumnStorage::Create()) 4351| |, 4352| 434| id_storage_layer_(new column::IdStorage()), 4353| 434| ufd_storage_layer_( 4354| 434| new column::NumericStorage( 4355| 434| &ufd_.vector(), 4356| 434| ColumnTypeHelper::ToColumnType(), 4357| 434| false)), 4358| 434| fd_storage_layer_( 4359| 434| new column::NumericStorage( 4360| 434| &fd_.vector(), 4361| 434| ColumnTypeHelper::ToColumnType(), 4362| 434| false)), 4363| 434| ts_storage_layer_( 4364| 434| new column::NumericStorage( 4365| 434| &ts_.non_null_vector(), 4366| 434| ColumnTypeHelper::ToColumnType(), 4367| 434| false)), 4368| 434| upid_storage_layer_( 4369| 434| new column::NumericStorage( 4370| 434| &upid_.non_null_vector(), 4371| 434| ColumnTypeHelper::ToColumnType(), 4372| 434| false)), 4373| 434| path_storage_layer_( 4374| 434| new column::StringStorage(string_pool(), &path_.vector())) 4375| |, 4376| 434| ts_null_layer_(new column::NullOverlay(ts_.bv())), 4377| 434| upid_null_layer_(new column::NullOverlay(upid_.bv())) { 4378| 434| static_assert( 4379| 434| ColumnLegacy::IsFlagsAndTypeValid( 4380| 434| ColumnFlag::ufd), 4381| 434| "Column type and flag combination is not valid"); 4382| 434| static_assert( 4383| 434| ColumnLegacy::IsFlagsAndTypeValid( 4384| 434| ColumnFlag::fd), 4385| 434| "Column type and flag combination is not valid"); 4386| 434| static_assert( 4387| 434| ColumnLegacy::IsFlagsAndTypeValid( 4388| 434| ColumnFlag::ts), 4389| 434| "Column type and flag combination is not valid"); 4390| 434| static_assert( 4391| 434| ColumnLegacy::IsFlagsAndTypeValid( 4392| 434| ColumnFlag::upid), 4393| 434| "Column type and flag combination is not valid"); 4394| 434| static_assert( 4395| 434| ColumnLegacy::IsFlagsAndTypeValid( 4396| 434| ColumnFlag::path), 4397| 434| "Column type and flag combination is not valid"); 4398| 434| OnConstructionCompletedRegularConstructor( 4399| 434| {id_storage_layer_,ufd_storage_layer_,fd_storage_layer_,ts_storage_layer_,upid_storage_layer_,path_storage_layer_}, 4400| 434| {{},{},{},ts_null_layer_,upid_null_layer_,{}}); 4401| 434| } _ZN8perfetto15trace_processor6tables16FtraceEventTable10GetColumnsEPS2_PKNS0_15macros_internal10MacroTableE: 4784| 434| const macros_internal::MacroTable* parent) { 4785| 434| std::vector columns = 4786| 434| CopyColumnsFromParentOrAddRootColumns(parent); 4787| 434| uint32_t olay_idx = OverlayCount(parent); 4788| 434| AddColumnToVector(columns, "ts", &self->ts_, ColumnFlag::ts, 4789| 434| static_cast(columns.size()), olay_idx); 4790| 434| AddColumnToVector(columns, "name", &self->name_, ColumnFlag::name, 4791| 434| static_cast(columns.size()), olay_idx); 4792| 434| AddColumnToVector(columns, "utid", &self->utid_, ColumnFlag::utid, 4793| 434| static_cast(columns.size()), olay_idx); 4794| 434| AddColumnToVector(columns, "arg_set_id", &self->arg_set_id_, ColumnFlag::arg_set_id, 4795| 434| static_cast(columns.size()), olay_idx); 4796| 434| AddColumnToVector(columns, "common_flags", &self->common_flags_, ColumnFlag::common_flags, 4797| 434| static_cast(columns.size()), olay_idx); 4798| 434| AddColumnToVector(columns, "ucpu", &self->ucpu_, ColumnFlag::ucpu, 4799| 434| static_cast(columns.size()), olay_idx); 4800| 434| base::ignore_result(self); 4801| 434| return columns; 4802| 434| } _ZN8perfetto15trace_processor6tables16FtraceEventTableC2EPNS0_10StringPoolE: 4805| 434| : macros_internal::MacroTable( 4806| 434| pool, 4807| 434| GetColumns(this, nullptr), 4808| 434| nullptr), 4809| 434| ts_(ColumnStorage::Create()), 4810| 434| name_(ColumnStorage::Create()), 4811| 434| utid_(ColumnStorage::Create()), 4812| 434| arg_set_id_(ColumnStorage::Create()), 4813| 434| common_flags_(ColumnStorage::Create()), 4814| 434| ucpu_(ColumnStorage::Create()) 4815| |, 4816| 434| id_storage_layer_(new column::IdStorage()), 4817| 434| ts_storage_layer_( 4818| 434| new column::NumericStorage( 4819| 434| &ts_.vector(), 4820| 434| ColumnTypeHelper::ToColumnType(), 4821| 434| true)), 4822| 434| name_storage_layer_( 4823| 434| new column::StringStorage(string_pool(), &name_.vector())), 4824| 434| utid_storage_layer_( 4825| 434| new column::NumericStorage( 4826| 434| &utid_.vector(), 4827| 434| ColumnTypeHelper::ToColumnType(), 4828| 434| false)), 4829| 434| arg_set_id_storage_layer_( 4830| 434| new column::NumericStorage( 4831| 434| &arg_set_id_.vector(), 4832| 434| ColumnTypeHelper::ToColumnType(), 4833| 434| false)), 4834| 434| common_flags_storage_layer_( 4835| 434| new column::NumericStorage( 4836| 434| &common_flags_.vector(), 4837| 434| ColumnTypeHelper::ToColumnType(), 4838| 434| false)), 4839| 434| ucpu_storage_layer_( 4840| 434| new column::NumericStorage( 4841| 434| &ucpu_.vector(), 4842| 434| ColumnTypeHelper::ToColumnType(), 4843| 434| false)) 4844| 434| { 4845| 434| static_assert( 4846| 434| ColumnLegacy::IsFlagsAndTypeValid( 4847| 434| ColumnFlag::ts), 4848| 434| "Column type and flag combination is not valid"); 4849| 434| static_assert( 4850| 434| ColumnLegacy::IsFlagsAndTypeValid( 4851| 434| ColumnFlag::name), 4852| 434| "Column type and flag combination is not valid"); 4853| 434| static_assert( 4854| 434| ColumnLegacy::IsFlagsAndTypeValid( 4855| 434| ColumnFlag::utid), 4856| 434| "Column type and flag combination is not valid"); 4857| 434| static_assert( 4858| 434| ColumnLegacy::IsFlagsAndTypeValid( 4859| 434| ColumnFlag::arg_set_id), 4860| 434| "Column type and flag combination is not valid"); 4861| 434| static_assert( 4862| 434| ColumnLegacy::IsFlagsAndTypeValid( 4863| 434| ColumnFlag::common_flags), 4864| 434| "Column type and flag combination is not valid"); 4865| 434| static_assert( 4866| 434| ColumnLegacy::IsFlagsAndTypeValid( 4867| 434| ColumnFlag::ucpu), 4868| 434| "Column type and flag combination is not valid"); 4869| 434| OnConstructionCompletedRegularConstructor( 4870| 434| {id_storage_layer_,ts_storage_layer_,name_storage_layer_,utid_storage_layer_,arg_set_id_storage_layer_,common_flags_storage_layer_,ucpu_storage_layer_}, 4871| 434| {{},{},{},{},{},{},{}}); 4872| 434| } _ZN8perfetto15trace_processor6tables13MetadataTable2IdC2Ej: 5050| 136k| explicit constexpr Id(uint32_t v) : BaseId(v) {} _ZN8perfetto15trace_processor6tables13MetadataTable3RowC2ENS0_10StringPool2IdES5_NSt3__18optionalIlEENS7_IS5_EEDn: 5075| 66.9k| : macros_internal::RootParentTable::Row(), 5076| 66.9k| name(in_name), 5077| 66.9k| key_type(in_key_type), 5078| 66.9k| int_value(in_int_value), 5079| 66.9k| str_value(in_str_value) {} _ZN8perfetto15trace_processor6tables13MetadataTable9RowNumberC2Ej: 5107| 136k| : AbstractRowNumber(row_number) {} _ZN8perfetto15trace_processor6tables13MetadataTable17ConstRowReferenceC2EPKS2_j: 5116| 203k| : AbstractConstRowReference(table, row_number) {} _ZN8perfetto15trace_processor6tables13MetadataTable12RowReferenceC2EPKS2_j: 5139| 203k| : ConstRowReference(table, row_number) {} _ZN8perfetto15trace_processor6tables13MetadataTable12RowReference13set_int_valueEl: 5150| 112k| ColumnType::int_value::non_optional_type v) { 5151| 112k| return mutable_table()->mutable_int_value()->Set(row_number_, v); 5152| 112k| } _ZN8perfetto15trace_processor6tables13MetadataTable12RowReference13set_str_valueENS0_10StringPool2IdE: 5154| 24.6k| ColumnType::str_value::non_optional_type v) { 5155| 24.6k| return mutable_table()->mutable_str_value()->Set(row_number_, v); 5156| 24.6k| } _ZNK8perfetto15trace_processor6tables13MetadataTable12RowReference13mutable_tableEv: 5159| 136k| MetadataTable* mutable_table() const { 5160| 136k| return const_cast(table()); 5161| 136k| } _ZNK8perfetto15trace_processor6tables13MetadataTable13ConstIterator2idEv: 5170| 69.9k| ColumnType::id::type id() const { 5171| 69.9k| const auto& col = table()->id(); 5172| 69.9k| return col.GetAtIdx( 5173| 69.9k| iterator_.StorageIndexForColumn(col.index_in_table())); 5174| 69.9k| } _ZNK8perfetto15trace_processor6tables13MetadataTable13ConstIterator4nameEv: 5175| 444k| ColumnType::name::type name() const { 5176| 444k| const auto& col = table()->name(); 5177| 444k| return col.GetAtIdx( 5178| 444k| iterator_.StorageIndexForColumn(col.index_in_table())); 5179| 444k| } _ZN8perfetto15trace_processor6tables13MetadataTable13ConstIteratorC2EPKS2_NS0_5Table8IteratorE: 5199| 71.8k| : AbstractConstIterator(table, std::move(iterator)) {} _ZNK8perfetto15trace_processor6tables13MetadataTable13ConstIterator16CurrentRowNumberEv: 5201| 69.9k| uint32_t CurrentRowNumber() const { 5202| 69.9k| return iterator_.StorageIndexForLastOverlay(); 5203| 69.9k| } _ZN8perfetto15trace_processor6tables13MetadataTable8IteratorC2EPS2_NS0_5Table8IteratorE: 5220| 71.8k| : ConstIterator(table, std::move(iterator)) {} _ZN8perfetto15trace_processor6tables13MetadataTable10GetColumnsEPS2_PKNS0_15macros_internal10MacroTableE: 5232| 434| const macros_internal::MacroTable* parent) { 5233| 434| std::vector columns = 5234| 434| CopyColumnsFromParentOrAddRootColumns(parent); 5235| 434| uint32_t olay_idx = OverlayCount(parent); 5236| 434| AddColumnToVector(columns, "name", &self->name_, ColumnFlag::name, 5237| 434| static_cast(columns.size()), olay_idx); 5238| 434| AddColumnToVector(columns, "key_type", &self->key_type_, ColumnFlag::key_type, 5239| 434| static_cast(columns.size()), olay_idx); 5240| 434| AddColumnToVector(columns, "int_value", &self->int_value_, ColumnFlag::int_value, 5241| 434| static_cast(columns.size()), olay_idx); 5242| 434| AddColumnToVector(columns, "str_value", &self->str_value_, ColumnFlag::str_value, 5243| 434| static_cast(columns.size()), olay_idx); 5244| 434| base::ignore_result(self); 5245| 434| return columns; 5246| 434| } _ZN8perfetto15trace_processor6tables13MetadataTableC2EPNS0_10StringPoolE: 5249| 434| : macros_internal::MacroTable( 5250| 434| pool, 5251| 434| GetColumns(this, nullptr), 5252| 434| nullptr), 5253| 434| name_(ColumnStorage::Create()), 5254| 434| key_type_(ColumnStorage::Create()), 5255| 434| int_value_(ColumnStorage::Create()), 5256| 434| str_value_(ColumnStorage::Create()) 5257| |, 5258| 434| id_storage_layer_(new column::IdStorage()), 5259| 434| name_storage_layer_( 5260| 434| new column::StringStorage(string_pool(), &name_.vector())), 5261| 434| key_type_storage_layer_( 5262| 434| new column::StringStorage(string_pool(), &key_type_.vector())), 5263| 434| int_value_storage_layer_( 5264| 434| new column::NumericStorage( 5265| 434| &int_value_.non_null_vector(), 5266| 434| ColumnTypeHelper::ToColumnType(), 5267| 434| false)), 5268| 434| str_value_storage_layer_( 5269| 434| new column::StringStorage(string_pool(), &str_value_.vector())) 5270| |, 5271| 434| int_value_null_layer_(new column::NullOverlay(int_value_.bv())) { 5272| 434| static_assert( 5273| 434| ColumnLegacy::IsFlagsAndTypeValid( 5274| 434| ColumnFlag::name), 5275| 434| "Column type and flag combination is not valid"); 5276| 434| static_assert( 5277| 434| ColumnLegacy::IsFlagsAndTypeValid( 5278| 434| ColumnFlag::key_type), 5279| 434| "Column type and flag combination is not valid"); 5280| 434| static_assert( 5281| 434| ColumnLegacy::IsFlagsAndTypeValid( 5282| 434| ColumnFlag::int_value), 5283| 434| "Column type and flag combination is not valid"); 5284| 434| static_assert( 5285| 434| ColumnLegacy::IsFlagsAndTypeValid( 5286| 434| ColumnFlag::str_value), 5287| 434| "Column type and flag combination is not valid"); 5288| 434| OnConstructionCompletedRegularConstructor( 5289| 434| {id_storage_layer_,name_storage_layer_,key_type_storage_layer_,int_value_storage_layer_,str_value_storage_layer_}, 5290| 434| {{},{},{},int_value_null_layer_,{}}); 5291| 434| } _ZN8perfetto15trace_processor6tables13MetadataTable11IterateRowsEv: 5327| 71.8k| Iterator IterateRows() { return Iterator(this, Table::IterateRows()); } _ZN8perfetto15trace_processor6tables13MetadataTableixEj: 5347| 136k| RowReference operator[](uint32_t r) { return RowReference(this, r); } _ZN8perfetto15trace_processor6tables13MetadataTable6InsertERKNS2_3RowE: 5366| 66.9k| IdAndRow Insert(const Row& row) { 5367| 66.9k| uint32_t row_number = row_count(); 5368| 66.9k| Id id = Id{row_number}; 5369| 66.9k| mutable_name()->Append(row.name); 5370| 66.9k| mutable_key_type()->Append(row.key_type); 5371| 66.9k| mutable_int_value()->Append(row.int_value); 5372| 66.9k| mutable_str_value()->Append(row.str_value); 5373| 66.9k| UpdateSelfOverlayAfterInsert(); 5374| 66.9k| return IdAndRow{id, row_number, RowReference(this, row_number), 5375| 66.9k| RowNumber(row_number)}; 5376| 66.9k| } _ZNK8perfetto15trace_processor6tables13MetadataTable2idEv: 5380| 69.9k| const IdColumn& id() const { 5381| 69.9k| return static_cast(columns()[ColumnIndex::id]); 5382| 69.9k| } _ZNK8perfetto15trace_processor6tables13MetadataTable4nameEv: 5383| 444k| const TypedColumn& name() const { 5384| 444k| return static_cast(columns()[ColumnIndex::name]); 5385| 444k| } _ZN8perfetto15trace_processor6tables13MetadataTable12mutable_nameEv: 5396| 66.9k| TypedColumn* mutable_name() { 5397| 66.9k| return static_cast( 5398| 66.9k| GetColumn(ColumnIndex::name)); 5399| 66.9k| } _ZN8perfetto15trace_processor6tables13MetadataTable16mutable_key_typeEv: 5400| 66.9k| TypedColumn* mutable_key_type() { 5401| 66.9k| return static_cast( 5402| 66.9k| GetColumn(ColumnIndex::key_type)); 5403| 66.9k| } _ZN8perfetto15trace_processor6tables13MetadataTable17mutable_int_valueEv: 5404| 179k| TypedColumn>* mutable_int_value() { 5405| 179k| return static_cast( 5406| 179k| GetColumn(ColumnIndex::int_value)); 5407| 179k| } _ZN8perfetto15trace_processor6tables13MetadataTable17mutable_str_valueEv: 5408| 91.5k| TypedColumn>* mutable_str_value() { 5409| 91.5k| return static_cast( 5410| 91.5k| GetColumn(ColumnIndex::str_value)); 5411| 91.5k| } _ZN8perfetto15trace_processor6tables14TraceFileTable2IdC2Ej: 5437| 434| explicit constexpr Id(uint32_t v) : BaseId(v) {} _ZN8perfetto15trace_processor6tables14TraceFileTable3RowC2ENSt3__18optionalINS2_2IdEEENS5_INS0_10StringPool2IdEEElS9_NS5_IlEEDn: 5465| 434| : macros_internal::RootParentTable::Row(), 5466| 434| parent_id(in_parent_id), 5467| 434| name(in_name), 5468| 434| size(in_size), 5469| 434| trace_type(in_trace_type), 5470| 434| processing_order(in_processing_order) {} _ZN8perfetto15trace_processor6tables14TraceFileTable9RowNumberC2Ej: 5501| 434| : AbstractRowNumber(row_number) {} _ZN8perfetto15trace_processor6tables14TraceFileTable17ConstRowReferenceC2EPKS2_j: 5510| 1.20k| : AbstractConstRowReference(table, row_number) {} _ZNK8perfetto15trace_processor6tables14TraceFileTable17ConstRowReference4sizeEv: 5521| 345| ColumnType::size::type size() const { 5522| 345| return table()->size()[row_number_]; 5523| 345| } _ZNK8perfetto15trace_processor6tables14TraceFileTable17ConstRowReference10trace_typeEv: 5524| 345| ColumnType::trace_type::type trace_type() const { 5525| 345| return table()->trace_type()[row_number_]; 5526| 345| } _ZN8perfetto15trace_processor6tables14TraceFileTable12RowReferenceC2EPKS2_j: 5536| 1.20k| : ConstRowReference(table, row_number) {} _ZN8perfetto15trace_processor6tables14TraceFileTable12RowReference8set_sizeEl: 5547| 345| ColumnType::size::non_optional_type v) { 5548| 345| return mutable_table()->mutable_size()->Set(row_number_, v); 5549| 345| } _ZN8perfetto15trace_processor6tables14TraceFileTable12RowReference14set_trace_typeENS0_10StringPool2IdE: 5551| 426| ColumnType::trace_type::non_optional_type v) { 5552| 426| return mutable_table()->mutable_trace_type()->Set(row_number_, v); 5553| 426| } _ZN8perfetto15trace_processor6tables14TraceFileTable12RowReference20set_processing_orderEl: 5555| 426| ColumnType::processing_order::non_optional_type v) { 5556| 426| return mutable_table()->mutable_processing_order()->Set(row_number_, v); 5557| 426| } _ZNK8perfetto15trace_processor6tables14TraceFileTable12RowReference13mutable_tableEv: 5560| 1.19k| TraceFileTable* mutable_table() const { 5561| 1.19k| return const_cast(table()); 5562| 1.19k| } _ZN8perfetto15trace_processor6tables14TraceFileTable10GetColumnsEPS2_PKNS0_15macros_internal10MacroTableE: 5638| 434| const macros_internal::MacroTable* parent) { 5639| 434| std::vector columns = 5640| 434| CopyColumnsFromParentOrAddRootColumns(parent); 5641| 434| uint32_t olay_idx = OverlayCount(parent); 5642| 434| AddColumnToVector(columns, "parent_id", &self->parent_id_, ColumnFlag::parent_id, 5643| 434| static_cast(columns.size()), olay_idx); 5644| 434| AddColumnToVector(columns, "name", &self->name_, ColumnFlag::name, 5645| 434| static_cast(columns.size()), olay_idx); 5646| 434| AddColumnToVector(columns, "size", &self->size_, ColumnFlag::size, 5647| 434| static_cast(columns.size()), olay_idx); 5648| 434| AddColumnToVector(columns, "trace_type", &self->trace_type_, ColumnFlag::trace_type, 5649| 434| static_cast(columns.size()), olay_idx); 5650| 434| AddColumnToVector(columns, "processing_order", &self->processing_order_, ColumnFlag::processing_order, 5651| 434| static_cast(columns.size()), olay_idx); 5652| 434| base::ignore_result(self); 5653| 434| return columns; 5654| 434| } _ZN8perfetto15trace_processor6tables14TraceFileTableC2EPNS0_10StringPoolE: 5657| 434| : macros_internal::MacroTable( 5658| 434| pool, 5659| 434| GetColumns(this, nullptr), 5660| 434| nullptr), 5661| 434| parent_id_(ColumnStorage::Create()), 5662| 434| name_(ColumnStorage::Create()), 5663| 434| size_(ColumnStorage::Create()), 5664| 434| trace_type_(ColumnStorage::Create()), 5665| 434| processing_order_(ColumnStorage::Create()) 5666| |, 5667| 434| id_storage_layer_(new column::IdStorage()), 5668| 434| parent_id_storage_layer_( 5669| 434| new column::NumericStorage( 5670| 434| &parent_id_.non_null_vector(), 5671| 434| ColumnTypeHelper::ToColumnType(), 5672| 434| false)), 5673| 434| name_storage_layer_( 5674| 434| new column::StringStorage(string_pool(), &name_.vector())), 5675| 434| size_storage_layer_( 5676| 434| new column::NumericStorage( 5677| 434| &size_.vector(), 5678| 434| ColumnTypeHelper::ToColumnType(), 5679| 434| false)), 5680| 434| trace_type_storage_layer_( 5681| 434| new column::StringStorage(string_pool(), &trace_type_.vector())), 5682| 434| processing_order_storage_layer_( 5683| 434| new column::NumericStorage( 5684| 434| &processing_order_.non_null_vector(), 5685| 434| ColumnTypeHelper::ToColumnType(), 5686| 434| false)) 5687| |, 5688| 434| parent_id_null_layer_(new column::NullOverlay(parent_id_.bv())), 5689| 434| processing_order_null_layer_(new column::NullOverlay(processing_order_.bv())) { 5690| 434| static_assert( 5691| 434| ColumnLegacy::IsFlagsAndTypeValid( 5692| 434| ColumnFlag::parent_id), 5693| 434| "Column type and flag combination is not valid"); 5694| 434| static_assert( 5695| 434| ColumnLegacy::IsFlagsAndTypeValid( 5696| 434| ColumnFlag::name), 5697| 434| "Column type and flag combination is not valid"); 5698| 434| static_assert( 5699| 434| ColumnLegacy::IsFlagsAndTypeValid( 5700| 434| ColumnFlag::size), 5701| 434| "Column type and flag combination is not valid"); 5702| 434| static_assert( 5703| 434| ColumnLegacy::IsFlagsAndTypeValid( 5704| 434| ColumnFlag::trace_type), 5705| 434| "Column type and flag combination is not valid"); 5706| 434| static_assert( 5707| 434| ColumnLegacy::IsFlagsAndTypeValid( 5708| 434| ColumnFlag::processing_order), 5709| 434| "Column type and flag combination is not valid"); 5710| 434| OnConstructionCompletedRegularConstructor( 5711| 434| {id_storage_layer_,parent_id_storage_layer_,name_storage_layer_,size_storage_layer_,trace_type_storage_layer_,processing_order_storage_layer_}, 5712| 434| {{},parent_id_null_layer_,{},{},{},processing_order_null_layer_}); 5713| 434| } _ZN8perfetto15trace_processor6tables14TraceFileTable8FindByIdENS2_2IdE: 5789| 771| std::optional FindById(Id find_id) { 5790| 771| std::optional row = id().IndexOf(find_id); 5791| 771| return row ? std::make_optional(RowReference(this, *row)) : std::nullopt; ------------------ | Branch (5791:12): [True: 771, False: 0] ------------------ 5792| 771| } _ZN8perfetto15trace_processor6tables14TraceFileTable6InsertERKNS2_3RowE: 5794| 434| IdAndRow Insert(const Row& row) { 5795| 434| uint32_t row_number = row_count(); 5796| 434| Id id = Id{row_number}; 5797| 434| mutable_parent_id()->Append(row.parent_id); 5798| 434| mutable_name()->Append(row.name); 5799| 434| mutable_size()->Append(row.size); 5800| 434| mutable_trace_type()->Append(row.trace_type); 5801| 434| mutable_processing_order()->Append(row.processing_order); 5802| 434| UpdateSelfOverlayAfterInsert(); 5803| 434| return IdAndRow{id, row_number, RowReference(this, row_number), 5804| 434| RowNumber(row_number)}; 5805| 434| } _ZNK8perfetto15trace_processor6tables14TraceFileTable2idEv: 5809| 771| const IdColumn& id() const { 5810| 771| return static_cast(columns()[ColumnIndex::id]); 5811| 771| } _ZNK8perfetto15trace_processor6tables14TraceFileTable4sizeEv: 5818| 345| const TypedColumn& size() const { 5819| 345| return static_cast(columns()[ColumnIndex::size]); 5820| 345| } _ZNK8perfetto15trace_processor6tables14TraceFileTable10trace_typeEv: 5821| 345| const TypedColumn& trace_type() const { 5822| 345| return static_cast(columns()[ColumnIndex::trace_type]); 5823| 345| } _ZN8perfetto15trace_processor6tables14TraceFileTable17mutable_parent_idEv: 5828| 434| TypedColumn>* mutable_parent_id() { 5829| 434| return static_cast( 5830| 434| GetColumn(ColumnIndex::parent_id)); 5831| 434| } _ZN8perfetto15trace_processor6tables14TraceFileTable12mutable_nameEv: 5832| 434| TypedColumn>* mutable_name() { 5833| 434| return static_cast( 5834| 434| GetColumn(ColumnIndex::name)); 5835| 434| } _ZN8perfetto15trace_processor6tables14TraceFileTable12mutable_sizeEv: 5836| 779| TypedColumn* mutable_size() { 5837| 779| return static_cast( 5838| 779| GetColumn(ColumnIndex::size)); 5839| 779| } _ZN8perfetto15trace_processor6tables14TraceFileTable18mutable_trace_typeEv: 5840| 860| TypedColumn* mutable_trace_type() { 5841| 860| return static_cast( 5842| 860| GetColumn(ColumnIndex::trace_type)); 5843| 860| } _ZN8perfetto15trace_processor6tables14TraceFileTable24mutable_processing_orderEv: 5844| 860| TypedColumn>* mutable_processing_order() { 5845| 860| return static_cast( 5846| 860| GetColumn(ColumnIndex::processing_order)); 5847| 860| } _ZN8perfetto15trace_processor6tables14SpeRecordTable10GetColumnsEPS2_PKNS0_15macros_internal10MacroTableE: 383| 434| const macros_internal::MacroTable* parent) { 384| 434| std::vector columns = 385| 434| CopyColumnsFromParentOrAddRootColumns(parent); 386| 434| uint32_t olay_idx = OverlayCount(parent); 387| 434| AddColumnToVector(columns, "ts", &self->ts_, ColumnFlag::ts, 388| 434| static_cast(columns.size()), olay_idx); 389| 434| AddColumnToVector(columns, "utid", &self->utid_, ColumnFlag::utid, 390| 434| static_cast(columns.size()), olay_idx); 391| 434| AddColumnToVector(columns, "exception_level", &self->exception_level_, ColumnFlag::exception_level, 392| 434| static_cast(columns.size()), olay_idx); 393| 434| AddColumnToVector(columns, "instruction_frame_id", &self->instruction_frame_id_, ColumnFlag::instruction_frame_id, 394| 434| static_cast(columns.size()), olay_idx); 395| 434| AddColumnToVector(columns, "operation", &self->operation_, ColumnFlag::operation, 396| 434| static_cast(columns.size()), olay_idx); 397| 434| AddColumnToVector(columns, "data_virtual_address", &self->data_virtual_address_, ColumnFlag::data_virtual_address, 398| 434| static_cast(columns.size()), olay_idx); 399| 434| AddColumnToVector(columns, "data_physical_address", &self->data_physical_address_, ColumnFlag::data_physical_address, 400| 434| static_cast(columns.size()), olay_idx); 401| 434| AddColumnToVector(columns, "total_latency", &self->total_latency_, ColumnFlag::total_latency, 402| 434| static_cast(columns.size()), olay_idx); 403| 434| AddColumnToVector(columns, "issue_latency", &self->issue_latency_, ColumnFlag::issue_latency, 404| 434| static_cast(columns.size()), olay_idx); 405| 434| AddColumnToVector(columns, "translation_latency", &self->translation_latency_, ColumnFlag::translation_latency, 406| 434| static_cast(columns.size()), olay_idx); 407| 434| AddColumnToVector(columns, "events_bitmask", &self->events_bitmask_, ColumnFlag::events_bitmask, 408| 434| static_cast(columns.size()), olay_idx); 409| 434| AddColumnToVector(columns, "data_source", &self->data_source_, ColumnFlag::data_source, 410| 434| static_cast(columns.size()), olay_idx); 411| 434| base::ignore_result(self); 412| 434| return columns; 413| 434| } _ZN8perfetto15trace_processor6tables14SpeRecordTableC2EPNS0_10StringPoolE: 416| 434| : macros_internal::MacroTable( 417| 434| pool, 418| 434| GetColumns(this, nullptr), 419| 434| nullptr), 420| 434| ts_(ColumnStorage::Create()), 421| 434| utid_(ColumnStorage::Create()), 422| 434| exception_level_(ColumnStorage::Create()), 423| 434| instruction_frame_id_(ColumnStorage::Create()), 424| 434| operation_(ColumnStorage::Create()), 425| 434| data_virtual_address_(ColumnStorage::Create()), 426| 434| data_physical_address_(ColumnStorage::Create()), 427| 434| total_latency_(ColumnStorage::Create()), 428| 434| issue_latency_(ColumnStorage::Create()), 429| 434| translation_latency_(ColumnStorage::Create()), 430| 434| events_bitmask_(ColumnStorage::Create()), 431| 434| data_source_(ColumnStorage::Create()) 432| |, 433| 434| id_storage_layer_(new column::IdStorage()), 434| 434| ts_storage_layer_( 435| 434| new column::NumericStorage( 436| 434| &ts_.vector(), 437| 434| ColumnTypeHelper::ToColumnType(), 438| 434| true)), 439| 434| utid_storage_layer_( 440| 434| new column::NumericStorage( 441| 434| &utid_.non_null_vector(), 442| 434| ColumnTypeHelper::ToColumnType(), 443| 434| false)), 444| 434| exception_level_storage_layer_( 445| 434| new column::StringStorage(string_pool(), &exception_level_.vector())), 446| 434| instruction_frame_id_storage_layer_( 447| 434| new column::NumericStorage( 448| 434| &instruction_frame_id_.non_null_vector(), 449| 434| ColumnTypeHelper::ToColumnType(), 450| 434| false)), 451| 434| operation_storage_layer_( 452| 434| new column::StringStorage(string_pool(), &operation_.vector())), 453| 434| data_virtual_address_storage_layer_( 454| 434| new column::NumericStorage( 455| 434| &data_virtual_address_.vector(), 456| 434| ColumnTypeHelper::ToColumnType(), 457| 434| false)), 458| 434| data_physical_address_storage_layer_( 459| 434| new column::NumericStorage( 460| 434| &data_physical_address_.vector(), 461| 434| ColumnTypeHelper::ToColumnType(), 462| 434| false)), 463| 434| total_latency_storage_layer_( 464| 434| new column::NumericStorage( 465| 434| &total_latency_.vector(), 466| 434| ColumnTypeHelper::ToColumnType(), 467| 434| false)), 468| 434| issue_latency_storage_layer_( 469| 434| new column::NumericStorage( 470| 434| &issue_latency_.vector(), 471| 434| ColumnTypeHelper::ToColumnType(), 472| 434| false)), 473| 434| translation_latency_storage_layer_( 474| 434| new column::NumericStorage( 475| 434| &translation_latency_.vector(), 476| 434| ColumnTypeHelper::ToColumnType(), 477| 434| false)), 478| 434| events_bitmask_storage_layer_( 479| 434| new column::NumericStorage( 480| 434| &events_bitmask_.vector(), 481| 434| ColumnTypeHelper::ToColumnType(), 482| 434| false)), 483| 434| data_source_storage_layer_( 484| 434| new column::StringStorage(string_pool(), &data_source_.vector())) 485| |, 486| 434| utid_null_layer_(new column::NullOverlay(utid_.bv())), 487| 434| instruction_frame_id_null_layer_(new column::NullOverlay(instruction_frame_id_.bv())) { 488| 434| static_assert( 489| 434| ColumnLegacy::IsFlagsAndTypeValid( 490| 434| ColumnFlag::ts), 491| 434| "Column type and flag combination is not valid"); 492| 434| static_assert( 493| 434| ColumnLegacy::IsFlagsAndTypeValid( 494| 434| ColumnFlag::utid), 495| 434| "Column type and flag combination is not valid"); 496| 434| static_assert( 497| 434| ColumnLegacy::IsFlagsAndTypeValid( 498| 434| ColumnFlag::exception_level), 499| 434| "Column type and flag combination is not valid"); 500| 434| static_assert( 501| 434| ColumnLegacy::IsFlagsAndTypeValid( 502| 434| ColumnFlag::instruction_frame_id), 503| 434| "Column type and flag combination is not valid"); 504| 434| static_assert( 505| 434| ColumnLegacy::IsFlagsAndTypeValid( 506| 434| ColumnFlag::operation), 507| 434| "Column type and flag combination is not valid"); 508| 434| static_assert( 509| 434| ColumnLegacy::IsFlagsAndTypeValid( 510| 434| ColumnFlag::data_virtual_address), 511| 434| "Column type and flag combination is not valid"); 512| 434| static_assert( 513| 434| ColumnLegacy::IsFlagsAndTypeValid( 514| 434| ColumnFlag::data_physical_address), 515| 434| "Column type and flag combination is not valid"); 516| 434| static_assert( 517| 434| ColumnLegacy::IsFlagsAndTypeValid( 518| 434| ColumnFlag::total_latency), 519| 434| "Column type and flag combination is not valid"); 520| 434| static_assert( 521| 434| ColumnLegacy::IsFlagsAndTypeValid( 522| 434| ColumnFlag::issue_latency), 523| 434| "Column type and flag combination is not valid"); 524| 434| static_assert( 525| 434| ColumnLegacy::IsFlagsAndTypeValid( 526| 434| ColumnFlag::translation_latency), 527| 434| "Column type and flag combination is not valid"); 528| 434| static_assert( 529| 434| ColumnLegacy::IsFlagsAndTypeValid( 530| 434| ColumnFlag::events_bitmask), 531| 434| "Column type and flag combination is not valid"); 532| 434| static_assert( 533| 434| ColumnLegacy::IsFlagsAndTypeValid( 534| 434| ColumnFlag::data_source), 535| 434| "Column type and flag combination is not valid"); 536| 434| OnConstructionCompletedRegularConstructor( 537| 434| {id_storage_layer_,ts_storage_layer_,utid_storage_layer_,exception_level_storage_layer_,instruction_frame_id_storage_layer_,operation_storage_layer_,data_virtual_address_storage_layer_,data_physical_address_storage_layer_,total_latency_storage_layer_,issue_latency_storage_layer_,translation_latency_storage_layer_,events_bitmask_storage_layer_,data_source_storage_layer_}, 538| 434| {{},{},utid_null_layer_,{},instruction_frame_id_null_layer_,{},{},{},{},{},{},{},{}}); 539| 434| } _ZN8perfetto15trace_processor6tables15MmapRecordTable10GetColumnsEPS2_PKNS0_15macros_internal10MacroTableE: 996| 434| const macros_internal::MacroTable* parent) { 997| 434| std::vector columns = 998| 434| CopyColumnsFromParentOrAddRootColumns(parent); 999| 434| uint32_t olay_idx = OverlayCount(parent); 1000| 434| AddColumnToVector(columns, "ts", &self->ts_, ColumnFlag::ts, 1001| 434| static_cast(columns.size()), olay_idx); 1002| 434| AddColumnToVector(columns, "upid", &self->upid_, ColumnFlag::upid, 1003| 434| static_cast(columns.size()), olay_idx); 1004| 434| AddColumnToVector(columns, "mapping_id", &self->mapping_id_, ColumnFlag::mapping_id, 1005| 434| static_cast(columns.size()), olay_idx); 1006| 434| AddColumnToVector(columns, "file_id", &self->file_id_, ColumnFlag::file_id, 1007| 434| static_cast(columns.size()), olay_idx); 1008| 434| base::ignore_result(self); 1009| 434| return columns; 1010| 434| } _ZN8perfetto15trace_processor6tables15MmapRecordTableC2EPNS0_10StringPoolE: 1013| 434| : macros_internal::MacroTable( 1014| 434| pool, 1015| 434| GetColumns(this, nullptr), 1016| 434| nullptr), 1017| 434| ts_(ColumnStorage::Create()), 1018| 434| upid_(ColumnStorage::Create()), 1019| 434| mapping_id_(ColumnStorage::Create()), 1020| 434| file_id_(ColumnStorage::Create()) 1021| |, 1022| 434| id_storage_layer_(new column::IdStorage()), 1023| 434| ts_storage_layer_( 1024| 434| new column::NumericStorage( 1025| 434| &ts_.vector(), 1026| 434| ColumnTypeHelper::ToColumnType(), 1027| 434| false)), 1028| 434| upid_storage_layer_( 1029| 434| new column::NumericStorage( 1030| 434| &upid_.non_null_vector(), 1031| 434| ColumnTypeHelper::ToColumnType(), 1032| 434| false)), 1033| 434| mapping_id_storage_layer_( 1034| 434| new column::NumericStorage( 1035| 434| &mapping_id_.vector(), 1036| 434| ColumnTypeHelper::ToColumnType(), 1037| 434| false)), 1038| 434| file_id_storage_layer_( 1039| 434| new column::NumericStorage( 1040| 434| &file_id_.non_null_vector(), 1041| 434| ColumnTypeHelper::ToColumnType(), 1042| 434| false)) 1043| |, 1044| 434| upid_null_layer_(new column::NullOverlay(upid_.bv())), 1045| 434| file_id_null_layer_(new column::NullOverlay(file_id_.bv())) { 1046| 434| static_assert( 1047| 434| ColumnLegacy::IsFlagsAndTypeValid( 1048| 434| ColumnFlag::ts), 1049| 434| "Column type and flag combination is not valid"); 1050| 434| static_assert( 1051| 434| ColumnLegacy::IsFlagsAndTypeValid( 1052| 434| ColumnFlag::upid), 1053| 434| "Column type and flag combination is not valid"); 1054| 434| static_assert( 1055| 434| ColumnLegacy::IsFlagsAndTypeValid( 1056| 434| ColumnFlag::mapping_id), 1057| 434| "Column type and flag combination is not valid"); 1058| 434| static_assert( 1059| 434| ColumnLegacy::IsFlagsAndTypeValid( 1060| 434| ColumnFlag::file_id), 1061| 434| "Column type and flag combination is not valid"); 1062| 434| OnConstructionCompletedRegularConstructor( 1063| 434| {id_storage_layer_,ts_storage_layer_,upid_storage_layer_,mapping_id_storage_layer_,file_id_storage_layer_}, 1064| 434| {{},{},upid_null_layer_,{},file_id_null_layer_}); 1065| 434| } _ZN8perfetto15trace_processor6tables24StackProfileMappingTable10GetColumnsEPS2_PKNS0_15macros_internal10MacroTableE: 286| 434| const macros_internal::MacroTable* parent) { 287| 434| std::vector columns = 288| 434| CopyColumnsFromParentOrAddRootColumns(parent); 289| 434| uint32_t olay_idx = OverlayCount(parent); 290| 434| AddColumnToVector(columns, "build_id", &self->build_id_, ColumnFlag::build_id, 291| 434| static_cast(columns.size()), olay_idx); 292| 434| AddColumnToVector(columns, "exact_offset", &self->exact_offset_, ColumnFlag::exact_offset, 293| 434| static_cast(columns.size()), olay_idx); 294| 434| AddColumnToVector(columns, "start_offset", &self->start_offset_, ColumnFlag::start_offset, 295| 434| static_cast(columns.size()), olay_idx); 296| 434| AddColumnToVector(columns, "start", &self->start_, ColumnFlag::start, 297| 434| static_cast(columns.size()), olay_idx); 298| 434| AddColumnToVector(columns, "end", &self->end_, ColumnFlag::end, 299| 434| static_cast(columns.size()), olay_idx); 300| 434| AddColumnToVector(columns, "load_bias", &self->load_bias_, ColumnFlag::load_bias, 301| 434| static_cast(columns.size()), olay_idx); 302| 434| AddColumnToVector(columns, "name", &self->name_, ColumnFlag::name, 303| 434| static_cast(columns.size()), olay_idx); 304| 434| base::ignore_result(self); 305| 434| return columns; 306| 434| } _ZN8perfetto15trace_processor6tables24StackProfileMappingTableC2EPNS0_10StringPoolE: 309| 434| : macros_internal::MacroTable( 310| 434| pool, 311| 434| GetColumns(this, nullptr), 312| 434| nullptr), 313| 434| build_id_(ColumnStorage::Create()), 314| 434| exact_offset_(ColumnStorage::Create()), 315| 434| start_offset_(ColumnStorage::Create()), 316| 434| start_(ColumnStorage::Create()), 317| 434| end_(ColumnStorage::Create()), 318| 434| load_bias_(ColumnStorage::Create()), 319| 434| name_(ColumnStorage::Create()) 320| |, 321| 434| id_storage_layer_(new column::IdStorage()), 322| 434| build_id_storage_layer_( 323| 434| new column::StringStorage(string_pool(), &build_id_.vector())), 324| 434| exact_offset_storage_layer_( 325| 434| new column::NumericStorage( 326| 434| &exact_offset_.vector(), 327| 434| ColumnTypeHelper::ToColumnType(), 328| 434| false)), 329| 434| start_offset_storage_layer_( 330| 434| new column::NumericStorage( 331| 434| &start_offset_.vector(), 332| 434| ColumnTypeHelper::ToColumnType(), 333| 434| false)), 334| 434| start_storage_layer_( 335| 434| new column::NumericStorage( 336| 434| &start_.vector(), 337| 434| ColumnTypeHelper::ToColumnType(), 338| 434| false)), 339| 434| end_storage_layer_( 340| 434| new column::NumericStorage( 341| 434| &end_.vector(), 342| 434| ColumnTypeHelper::ToColumnType(), 343| 434| false)), 344| 434| load_bias_storage_layer_( 345| 434| new column::NumericStorage( 346| 434| &load_bias_.vector(), 347| 434| ColumnTypeHelper::ToColumnType(), 348| 434| false)), 349| 434| name_storage_layer_( 350| 434| new column::StringStorage(string_pool(), &name_.vector())) 351| 434| { 352| 434| static_assert( 353| 434| ColumnLegacy::IsFlagsAndTypeValid( 354| 434| ColumnFlag::build_id), 355| 434| "Column type and flag combination is not valid"); 356| 434| static_assert( 357| 434| ColumnLegacy::IsFlagsAndTypeValid( 358| 434| ColumnFlag::exact_offset), 359| 434| "Column type and flag combination is not valid"); 360| 434| static_assert( 361| 434| ColumnLegacy::IsFlagsAndTypeValid( 362| 434| ColumnFlag::start_offset), 363| 434| "Column type and flag combination is not valid"); 364| 434| static_assert( 365| 434| ColumnLegacy::IsFlagsAndTypeValid( 366| 434| ColumnFlag::start), 367| 434| "Column type and flag combination is not valid"); 368| 434| static_assert( 369| 434| ColumnLegacy::IsFlagsAndTypeValid( 370| 434| ColumnFlag::end), 371| 434| "Column type and flag combination is not valid"); 372| 434| static_assert( 373| 434| ColumnLegacy::IsFlagsAndTypeValid( 374| 434| ColumnFlag::load_bias), 375| 434| "Column type and flag combination is not valid"); 376| 434| static_assert( 377| 434| ColumnLegacy::IsFlagsAndTypeValid( 378| 434| ColumnFlag::name), 379| 434| "Column type and flag combination is not valid"); 380| 434| OnConstructionCompletedRegularConstructor( 381| 434| {id_storage_layer_,build_id_storage_layer_,exact_offset_storage_layer_,start_offset_storage_layer_,start_storage_layer_,end_storage_layer_,load_bias_storage_layer_,name_storage_layer_}, 382| 434| {{},{},{},{},{},{},{},{}}); 383| 434| } _ZN8perfetto15trace_processor6tables22StackProfileFrameTable10GetColumnsEPS2_PKNS0_15macros_internal10MacroTableE: 778| 434| const macros_internal::MacroTable* parent) { 779| 434| std::vector columns = 780| 434| CopyColumnsFromParentOrAddRootColumns(parent); 781| 434| uint32_t olay_idx = OverlayCount(parent); 782| 434| AddColumnToVector(columns, "name", &self->name_, ColumnFlag::name, 783| 434| static_cast(columns.size()), olay_idx); 784| 434| AddColumnToVector(columns, "mapping", &self->mapping_, ColumnFlag::mapping, 785| 434| static_cast(columns.size()), olay_idx); 786| 434| AddColumnToVector(columns, "rel_pc", &self->rel_pc_, ColumnFlag::rel_pc, 787| 434| static_cast(columns.size()), olay_idx); 788| 434| AddColumnToVector(columns, "symbol_set_id", &self->symbol_set_id_, ColumnFlag::symbol_set_id, 789| 434| static_cast(columns.size()), olay_idx); 790| 434| AddColumnToVector(columns, "deobfuscated_name", &self->deobfuscated_name_, ColumnFlag::deobfuscated_name, 791| 434| static_cast(columns.size()), olay_idx); 792| 434| base::ignore_result(self); 793| 434| return columns; 794| 434| } _ZN8perfetto15trace_processor6tables22StackProfileFrameTableC2EPNS0_10StringPoolE: 797| 434| : macros_internal::MacroTable( 798| 434| pool, 799| 434| GetColumns(this, nullptr), 800| 434| nullptr), 801| 434| name_(ColumnStorage::Create()), 802| 434| mapping_(ColumnStorage::Create()), 803| 434| rel_pc_(ColumnStorage::Create()), 804| 434| symbol_set_id_(ColumnStorage::Create()), 805| 434| deobfuscated_name_(ColumnStorage::Create()) 806| |, 807| 434| id_storage_layer_(new column::IdStorage()), 808| 434| name_storage_layer_( 809| 434| new column::StringStorage(string_pool(), &name_.vector())), 810| 434| mapping_storage_layer_( 811| 434| new column::NumericStorage( 812| 434| &mapping_.vector(), 813| 434| ColumnTypeHelper::ToColumnType(), 814| 434| false)), 815| 434| rel_pc_storage_layer_( 816| 434| new column::NumericStorage( 817| 434| &rel_pc_.vector(), 818| 434| ColumnTypeHelper::ToColumnType(), 819| 434| false)), 820| 434| symbol_set_id_storage_layer_( 821| 434| new column::NumericStorage( 822| 434| &symbol_set_id_.non_null_vector(), 823| 434| ColumnTypeHelper::ToColumnType(), 824| 434| false)), 825| 434| deobfuscated_name_storage_layer_( 826| 434| new column::StringStorage(string_pool(), &deobfuscated_name_.vector())) 827| |, 828| 434| symbol_set_id_null_layer_(new column::DenseNullOverlay(symbol_set_id_.bv())) { 829| 434| static_assert( 830| 434| ColumnLegacy::IsFlagsAndTypeValid( 831| 434| ColumnFlag::name), 832| 434| "Column type and flag combination is not valid"); 833| 434| static_assert( 834| 434| ColumnLegacy::IsFlagsAndTypeValid( 835| 434| ColumnFlag::mapping), 836| 434| "Column type and flag combination is not valid"); 837| 434| static_assert( 838| 434| ColumnLegacy::IsFlagsAndTypeValid( 839| 434| ColumnFlag::rel_pc), 840| 434| "Column type and flag combination is not valid"); 841| 434| static_assert( 842| 434| ColumnLegacy::IsFlagsAndTypeValid( 843| 434| ColumnFlag::symbol_set_id), 844| 434| "Column type and flag combination is not valid"); 845| 434| static_assert( 846| 434| ColumnLegacy::IsFlagsAndTypeValid( 847| 434| ColumnFlag::deobfuscated_name), 848| 434| "Column type and flag combination is not valid"); 849| 434| OnConstructionCompletedRegularConstructor( 850| 434| {id_storage_layer_,name_storage_layer_,mapping_storage_layer_,rel_pc_storage_layer_,symbol_set_id_storage_layer_,deobfuscated_name_storage_layer_}, 851| 434| {{},{},{},{},symbol_set_id_null_layer_,{}}); 852| 434| } _ZN8perfetto15trace_processor6tables25StackProfileCallsiteTable10GetColumnsEPS2_PKNS0_15macros_internal10MacroTableE: 1177| 434| const macros_internal::MacroTable* parent) { 1178| 434| std::vector columns = 1179| 434| CopyColumnsFromParentOrAddRootColumns(parent); 1180| 434| uint32_t olay_idx = OverlayCount(parent); 1181| 434| AddColumnToVector(columns, "depth", &self->depth_, ColumnFlag::depth, 1182| 434| static_cast(columns.size()), olay_idx); 1183| 434| AddColumnToVector(columns, "parent_id", &self->parent_id_, ColumnFlag::parent_id, 1184| 434| static_cast(columns.size()), olay_idx); 1185| 434| AddColumnToVector(columns, "frame_id", &self->frame_id_, ColumnFlag::frame_id, 1186| 434| static_cast(columns.size()), olay_idx); 1187| 434| base::ignore_result(self); 1188| 434| return columns; 1189| 434| } _ZN8perfetto15trace_processor6tables25StackProfileCallsiteTableC2EPNS0_10StringPoolE: 1192| 434| : macros_internal::MacroTable( 1193| 434| pool, 1194| 434| GetColumns(this, nullptr), 1195| 434| nullptr), 1196| 434| depth_(ColumnStorage::Create()), 1197| 434| parent_id_(ColumnStorage::Create()), 1198| 434| frame_id_(ColumnStorage::Create()) 1199| |, 1200| 434| id_storage_layer_(new column::IdStorage()), 1201| 434| depth_storage_layer_( 1202| 434| new column::NumericStorage( 1203| 434| &depth_.vector(), 1204| 434| ColumnTypeHelper::ToColumnType(), 1205| 434| false)), 1206| 434| parent_id_storage_layer_( 1207| 434| new column::NumericStorage( 1208| 434| &parent_id_.non_null_vector(), 1209| 434| ColumnTypeHelper::ToColumnType(), 1210| 434| false)), 1211| 434| frame_id_storage_layer_( 1212| 434| new column::NumericStorage( 1213| 434| &frame_id_.vector(), 1214| 434| ColumnTypeHelper::ToColumnType(), 1215| 434| false)) 1216| |, 1217| 434| parent_id_null_layer_(new column::NullOverlay(parent_id_.bv())) { 1218| 434| static_assert( 1219| 434| ColumnLegacy::IsFlagsAndTypeValid( 1220| 434| ColumnFlag::depth), 1221| 434| "Column type and flag combination is not valid"); 1222| 434| static_assert( 1223| 434| ColumnLegacy::IsFlagsAndTypeValid( 1224| 434| ColumnFlag::parent_id), 1225| 434| "Column type and flag combination is not valid"); 1226| 434| static_assert( 1227| 434| ColumnLegacy::IsFlagsAndTypeValid( 1228| 434| ColumnFlag::frame_id), 1229| 434| "Column type and flag combination is not valid"); 1230| 434| OnConstructionCompletedRegularConstructor( 1231| 434| {id_storage_layer_,depth_storage_layer_,parent_id_storage_layer_,frame_id_storage_layer_}, 1232| 434| {{},{},parent_id_null_layer_,{}}); 1233| 434| } _ZN8perfetto15trace_processor6tables26CpuProfileStackSampleTable10GetColumnsEPS2_PKNS0_15macros_internal10MacroTableE: 1545| 434| const macros_internal::MacroTable* parent) { 1546| 434| std::vector columns = 1547| 434| CopyColumnsFromParentOrAddRootColumns(parent); 1548| 434| uint32_t olay_idx = OverlayCount(parent); 1549| 434| AddColumnToVector(columns, "ts", &self->ts_, ColumnFlag::ts, 1550| 434| static_cast(columns.size()), olay_idx); 1551| 434| AddColumnToVector(columns, "callsite_id", &self->callsite_id_, ColumnFlag::callsite_id, 1552| 434| static_cast(columns.size()), olay_idx); 1553| 434| AddColumnToVector(columns, "utid", &self->utid_, ColumnFlag::utid, 1554| 434| static_cast(columns.size()), olay_idx); 1555| 434| AddColumnToVector(columns, "process_priority", &self->process_priority_, ColumnFlag::process_priority, 1556| 434| static_cast(columns.size()), olay_idx); 1557| 434| base::ignore_result(self); 1558| 434| return columns; 1559| 434| } _ZN8perfetto15trace_processor6tables26CpuProfileStackSampleTableC2EPNS0_10StringPoolE: 1562| 434| : macros_internal::MacroTable( 1563| 434| pool, 1564| 434| GetColumns(this, nullptr), 1565| 434| nullptr), 1566| 434| ts_(ColumnStorage::Create()), 1567| 434| callsite_id_(ColumnStorage::Create()), 1568| 434| utid_(ColumnStorage::Create()), 1569| 434| process_priority_(ColumnStorage::Create()) 1570| |, 1571| 434| id_storage_layer_(new column::IdStorage()), 1572| 434| ts_storage_layer_( 1573| 434| new column::NumericStorage( 1574| 434| &ts_.vector(), 1575| 434| ColumnTypeHelper::ToColumnType(), 1576| 434| false)), 1577| 434| callsite_id_storage_layer_( 1578| 434| new column::NumericStorage( 1579| 434| &callsite_id_.vector(), 1580| 434| ColumnTypeHelper::ToColumnType(), 1581| 434| false)), 1582| 434| utid_storage_layer_( 1583| 434| new column::NumericStorage( 1584| 434| &utid_.vector(), 1585| 434| ColumnTypeHelper::ToColumnType(), 1586| 434| false)), 1587| 434| process_priority_storage_layer_( 1588| 434| new column::NumericStorage( 1589| 434| &process_priority_.vector(), 1590| 434| ColumnTypeHelper::ToColumnType(), 1591| 434| false)) 1592| 434| { 1593| 434| static_assert( 1594| 434| ColumnLegacy::IsFlagsAndTypeValid( 1595| 434| ColumnFlag::ts), 1596| 434| "Column type and flag combination is not valid"); 1597| 434| static_assert( 1598| 434| ColumnLegacy::IsFlagsAndTypeValid( 1599| 434| ColumnFlag::callsite_id), 1600| 434| "Column type and flag combination is not valid"); 1601| 434| static_assert( 1602| 434| ColumnLegacy::IsFlagsAndTypeValid( 1603| 434| ColumnFlag::utid), 1604| 434| "Column type and flag combination is not valid"); 1605| 434| static_assert( 1606| 434| ColumnLegacy::IsFlagsAndTypeValid( 1607| 434| ColumnFlag::process_priority), 1608| 434| "Column type and flag combination is not valid"); 1609| 434| OnConstructionCompletedRegularConstructor( 1610| 434| {id_storage_layer_,ts_storage_layer_,callsite_id_storage_layer_,utid_storage_layer_,process_priority_storage_layer_}, 1611| 434| {{},{},{},{},{}}); 1612| 434| } _ZN8perfetto15trace_processor6tables20GpuCounterGroupTable10GetColumnsEPS2_PKNS0_15macros_internal10MacroTableE: 3082| 434| const macros_internal::MacroTable* parent) { 3083| 434| std::vector columns = 3084| 434| CopyColumnsFromParentOrAddRootColumns(parent); 3085| 434| uint32_t olay_idx = OverlayCount(parent); 3086| 434| AddColumnToVector(columns, "group_id", &self->group_id_, ColumnFlag::group_id, 3087| 434| static_cast(columns.size()), olay_idx); 3088| 434| AddColumnToVector(columns, "track_id", &self->track_id_, ColumnFlag::track_id, 3089| 434| static_cast(columns.size()), olay_idx); 3090| 434| base::ignore_result(self); 3091| 434| return columns; 3092| 434| } _ZN8perfetto15trace_processor6tables20GpuCounterGroupTableC2EPNS0_10StringPoolE: 3095| 434| : macros_internal::MacroTable( 3096| 434| pool, 3097| 434| GetColumns(this, nullptr), 3098| 434| nullptr), 3099| 434| group_id_(ColumnStorage::Create()), 3100| 434| track_id_(ColumnStorage::Create()) 3101| |, 3102| 434| id_storage_layer_(new column::IdStorage()), 3103| 434| group_id_storage_layer_( 3104| 434| new column::NumericStorage( 3105| 434| &group_id_.vector(), 3106| 434| ColumnTypeHelper::ToColumnType(), 3107| 434| false)), 3108| 434| track_id_storage_layer_( 3109| 434| new column::NumericStorage( 3110| 434| &track_id_.vector(), 3111| 434| ColumnTypeHelper::ToColumnType(), 3112| 434| false)) 3113| 434| { 3114| 434| static_assert( 3115| 434| ColumnLegacy::IsFlagsAndTypeValid( 3116| 434| ColumnFlag::group_id), 3117| 434| "Column type and flag combination is not valid"); 3118| 434| static_assert( 3119| 434| ColumnLegacy::IsFlagsAndTypeValid( 3120| 434| ColumnFlag::track_id), 3121| 434| "Column type and flag combination is not valid"); 3122| 434| OnConstructionCompletedRegularConstructor( 3123| 434| {id_storage_layer_,group_id_storage_layer_,track_id_storage_layer_}, 3124| 434| {{},{},{}}); 3125| 434| } _ZN8perfetto15trace_processor6tables19HeapGraphClassTable10GetColumnsEPS2_PKNS0_15macros_internal10MacroTableE: 3459| 434| const macros_internal::MacroTable* parent) { 3460| 434| std::vector columns = 3461| 434| CopyColumnsFromParentOrAddRootColumns(parent); 3462| 434| uint32_t olay_idx = OverlayCount(parent); 3463| 434| AddColumnToVector(columns, "name", &self->name_, ColumnFlag::name, 3464| 434| static_cast(columns.size()), olay_idx); 3465| 434| AddColumnToVector(columns, "deobfuscated_name", &self->deobfuscated_name_, ColumnFlag::deobfuscated_name, 3466| 434| static_cast(columns.size()), olay_idx); 3467| 434| AddColumnToVector(columns, "location", &self->location_, ColumnFlag::location, 3468| 434| static_cast(columns.size()), olay_idx); 3469| 434| AddColumnToVector(columns, "superclass_id", &self->superclass_id_, ColumnFlag::superclass_id, 3470| 434| static_cast(columns.size()), olay_idx); 3471| 434| AddColumnToVector(columns, "classloader_id", &self->classloader_id_, ColumnFlag::classloader_id, 3472| 434| static_cast(columns.size()), olay_idx); 3473| 434| AddColumnToVector(columns, "kind", &self->kind_, ColumnFlag::kind, 3474| 434| static_cast(columns.size()), olay_idx); 3475| 434| base::ignore_result(self); 3476| 434| return columns; 3477| 434| } _ZN8perfetto15trace_processor6tables19HeapGraphClassTableC2EPNS0_10StringPoolE: 3480| 434| : macros_internal::MacroTable( 3481| 434| pool, 3482| 434| GetColumns(this, nullptr), 3483| 434| nullptr), 3484| 434| name_(ColumnStorage::Create()), 3485| 434| deobfuscated_name_(ColumnStorage::Create()), 3486| 434| location_(ColumnStorage::Create()), 3487| 434| superclass_id_(ColumnStorage::Create()), 3488| 434| classloader_id_(ColumnStorage::Create()), 3489| 434| kind_(ColumnStorage::Create()) 3490| |, 3491| 434| id_storage_layer_(new column::IdStorage()), 3492| 434| name_storage_layer_( 3493| 434| new column::StringStorage(string_pool(), &name_.vector())), 3494| 434| deobfuscated_name_storage_layer_( 3495| 434| new column::StringStorage(string_pool(), &deobfuscated_name_.vector())), 3496| 434| location_storage_layer_( 3497| 434| new column::StringStorage(string_pool(), &location_.vector())), 3498| 434| superclass_id_storage_layer_( 3499| 434| new column::NumericStorage( 3500| 434| &superclass_id_.non_null_vector(), 3501| 434| ColumnTypeHelper::ToColumnType(), 3502| 434| false)), 3503| 434| classloader_id_storage_layer_( 3504| 434| new column::NumericStorage( 3505| 434| &classloader_id_.non_null_vector(), 3506| 434| ColumnTypeHelper::ToColumnType(), 3507| 434| false)), 3508| 434| kind_storage_layer_( 3509| 434| new column::StringStorage(string_pool(), &kind_.vector())) 3510| |, 3511| 434| superclass_id_null_layer_(new column::NullOverlay(superclass_id_.bv())), 3512| 434| classloader_id_null_layer_(new column::NullOverlay(classloader_id_.bv())) { 3513| 434| static_assert( 3514| 434| ColumnLegacy::IsFlagsAndTypeValid( 3515| 434| ColumnFlag::name), 3516| 434| "Column type and flag combination is not valid"); 3517| 434| static_assert( 3518| 434| ColumnLegacy::IsFlagsAndTypeValid( 3519| 434| ColumnFlag::deobfuscated_name), 3520| 434| "Column type and flag combination is not valid"); 3521| 434| static_assert( 3522| 434| ColumnLegacy::IsFlagsAndTypeValid( 3523| 434| ColumnFlag::location), 3524| 434| "Column type and flag combination is not valid"); 3525| 434| static_assert( 3526| 434| ColumnLegacy::IsFlagsAndTypeValid( 3527| 434| ColumnFlag::superclass_id), 3528| 434| "Column type and flag combination is not valid"); 3529| 434| static_assert( 3530| 434| ColumnLegacy::IsFlagsAndTypeValid( 3531| 434| ColumnFlag::classloader_id), 3532| 434| "Column type and flag combination is not valid"); 3533| 434| static_assert( 3534| 434| ColumnLegacy::IsFlagsAndTypeValid( 3535| 434| ColumnFlag::kind), 3536| 434| "Column type and flag combination is not valid"); 3537| 434| OnConstructionCompletedRegularConstructor( 3538| 434| {id_storage_layer_,name_storage_layer_,deobfuscated_name_storage_layer_,location_storage_layer_,superclass_id_storage_layer_,classloader_id_storage_layer_,kind_storage_layer_}, 3539| 434| {{},{},{},{},superclass_id_null_layer_,classloader_id_null_layer_,{}}); 3540| 434| } _ZN8perfetto15trace_processor6tables20HeapGraphObjectTable10GetColumnsEPS2_PKNS0_15macros_internal10MacroTableE: 4015| 434| const macros_internal::MacroTable* parent) { 4016| 434| std::vector columns = 4017| 434| CopyColumnsFromParentOrAddRootColumns(parent); 4018| 434| uint32_t olay_idx = OverlayCount(parent); 4019| 434| AddColumnToVector(columns, "upid", &self->upid_, ColumnFlag::upid, 4020| 434| static_cast(columns.size()), olay_idx); 4021| 434| AddColumnToVector(columns, "graph_sample_ts", &self->graph_sample_ts_, ColumnFlag::graph_sample_ts, 4022| 434| static_cast(columns.size()), olay_idx); 4023| 434| AddColumnToVector(columns, "self_size", &self->self_size_, ColumnFlag::self_size, 4024| 434| static_cast(columns.size()), olay_idx); 4025| 434| AddColumnToVector(columns, "native_size", &self->native_size_, ColumnFlag::native_size, 4026| 434| static_cast(columns.size()), olay_idx); 4027| 434| AddColumnToVector(columns, "reference_set_id", &self->reference_set_id_, ColumnFlag::reference_set_id, 4028| 434| static_cast(columns.size()), olay_idx); 4029| 434| AddColumnToVector(columns, "reachable", &self->reachable_, ColumnFlag::reachable, 4030| 434| static_cast(columns.size()), olay_idx); 4031| 434| AddColumnToVector(columns, "heap_type", &self->heap_type_, ColumnFlag::heap_type, 4032| 434| static_cast(columns.size()), olay_idx); 4033| 434| AddColumnToVector(columns, "type_id", &self->type_id_, ColumnFlag::type_id, 4034| 434| static_cast(columns.size()), olay_idx); 4035| 434| AddColumnToVector(columns, "root_type", &self->root_type_, ColumnFlag::root_type, 4036| 434| static_cast(columns.size()), olay_idx); 4037| 434| AddColumnToVector(columns, "root_distance", &self->root_distance_, ColumnFlag::root_distance, 4038| 434| static_cast(columns.size()), olay_idx); 4039| 434| base::ignore_result(self); 4040| 434| return columns; 4041| 434| } _ZN8perfetto15trace_processor6tables20HeapGraphObjectTableC2EPNS0_10StringPoolE: 4044| 434| : macros_internal::MacroTable( 4045| 434| pool, 4046| 434| GetColumns(this, nullptr), 4047| 434| nullptr), 4048| 434| upid_(ColumnStorage::Create()), 4049| 434| graph_sample_ts_(ColumnStorage::Create()), 4050| 434| self_size_(ColumnStorage::Create()), 4051| 434| native_size_(ColumnStorage::Create()), 4052| 434| reference_set_id_(ColumnStorage::Create()), 4053| 434| reachable_(ColumnStorage::Create()), 4054| 434| heap_type_(ColumnStorage::Create()), 4055| 434| type_id_(ColumnStorage::Create()), 4056| 434| root_type_(ColumnStorage::Create()), 4057| 434| root_distance_(ColumnStorage::Create()) 4058| |, 4059| 434| id_storage_layer_(new column::IdStorage()), 4060| 434| upid_storage_layer_( 4061| 434| new column::NumericStorage( 4062| 434| &upid_.vector(), 4063| 434| ColumnTypeHelper::ToColumnType(), 4064| 434| false)), 4065| 434| graph_sample_ts_storage_layer_( 4066| 434| new column::NumericStorage( 4067| 434| &graph_sample_ts_.vector(), 4068| 434| ColumnTypeHelper::ToColumnType(), 4069| 434| false)), 4070| 434| self_size_storage_layer_( 4071| 434| new column::NumericStorage( 4072| 434| &self_size_.vector(), 4073| 434| ColumnTypeHelper::ToColumnType(), 4074| 434| false)), 4075| 434| native_size_storage_layer_( 4076| 434| new column::NumericStorage( 4077| 434| &native_size_.vector(), 4078| 434| ColumnTypeHelper::ToColumnType(), 4079| 434| false)), 4080| 434| reference_set_id_storage_layer_( 4081| 434| new column::NumericStorage( 4082| 434| &reference_set_id_.non_null_vector(), 4083| 434| ColumnTypeHelper::ToColumnType(), 4084| 434| false)), 4085| 434| reachable_storage_layer_( 4086| 434| new column::NumericStorage( 4087| 434| &reachable_.vector(), 4088| 434| ColumnTypeHelper::ToColumnType(), 4089| 434| false)), 4090| 434| heap_type_storage_layer_( 4091| 434| new column::StringStorage(string_pool(), &heap_type_.vector())), 4092| 434| type_id_storage_layer_( 4093| 434| new column::NumericStorage( 4094| 434| &type_id_.vector(), 4095| 434| ColumnTypeHelper::ToColumnType(), 4096| 434| false)), 4097| 434| root_type_storage_layer_( 4098| 434| new column::StringStorage(string_pool(), &root_type_.vector())), 4099| 434| root_distance_storage_layer_( 4100| 434| new column::NumericStorage( 4101| 434| &root_distance_.vector(), 4102| 434| ColumnTypeHelper::ToColumnType(), 4103| 434| false)) 4104| |, 4105| 434| reference_set_id_null_layer_(new column::DenseNullOverlay(reference_set_id_.bv())) { 4106| 434| static_assert( 4107| 434| ColumnLegacy::IsFlagsAndTypeValid( 4108| 434| ColumnFlag::upid), 4109| 434| "Column type and flag combination is not valid"); 4110| 434| static_assert( 4111| 434| ColumnLegacy::IsFlagsAndTypeValid( 4112| 434| ColumnFlag::graph_sample_ts), 4113| 434| "Column type and flag combination is not valid"); 4114| 434| static_assert( 4115| 434| ColumnLegacy::IsFlagsAndTypeValid( 4116| 434| ColumnFlag::self_size), 4117| 434| "Column type and flag combination is not valid"); 4118| 434| static_assert( 4119| 434| ColumnLegacy::IsFlagsAndTypeValid( 4120| 434| ColumnFlag::native_size), 4121| 434| "Column type and flag combination is not valid"); 4122| 434| static_assert( 4123| 434| ColumnLegacy::IsFlagsAndTypeValid( 4124| 434| ColumnFlag::reference_set_id), 4125| 434| "Column type and flag combination is not valid"); 4126| 434| static_assert( 4127| 434| ColumnLegacy::IsFlagsAndTypeValid( 4128| 434| ColumnFlag::reachable), 4129| 434| "Column type and flag combination is not valid"); 4130| 434| static_assert( 4131| 434| ColumnLegacy::IsFlagsAndTypeValid( 4132| 434| ColumnFlag::heap_type), 4133| 434| "Column type and flag combination is not valid"); 4134| 434| static_assert( 4135| 434| ColumnLegacy::IsFlagsAndTypeValid( 4136| 434| ColumnFlag::type_id), 4137| 434| "Column type and flag combination is not valid"); 4138| 434| static_assert( 4139| 434| ColumnLegacy::IsFlagsAndTypeValid( 4140| 434| ColumnFlag::root_type), 4141| 434| "Column type and flag combination is not valid"); 4142| 434| static_assert( 4143| 434| ColumnLegacy::IsFlagsAndTypeValid( 4144| 434| ColumnFlag::root_distance), 4145| 434| "Column type and flag combination is not valid"); 4146| 434| OnConstructionCompletedRegularConstructor( 4147| 434| {id_storage_layer_,upid_storage_layer_,graph_sample_ts_storage_layer_,self_size_storage_layer_,native_size_storage_layer_,reference_set_id_storage_layer_,reachable_storage_layer_,heap_type_storage_layer_,type_id_storage_layer_,root_type_storage_layer_,root_distance_storage_layer_}, 4148| 434| {{},{},{},{},{},reference_set_id_null_layer_,{},{},{},{},{}}); 4149| 434| } _ZN8perfetto15trace_processor6tables23HeapGraphReferenceTable10GetColumnsEPS2_PKNS0_15macros_internal10MacroTableE: 4611| 434| const macros_internal::MacroTable* parent) { 4612| 434| std::vector columns = 4613| 434| CopyColumnsFromParentOrAddRootColumns(parent); 4614| 434| uint32_t olay_idx = OverlayCount(parent); 4615| 434| AddColumnToVector(columns, "reference_set_id", &self->reference_set_id_, ColumnFlag::reference_set_id, 4616| 434| static_cast(columns.size()), olay_idx); 4617| 434| AddColumnToVector(columns, "owner_id", &self->owner_id_, ColumnFlag::owner_id, 4618| 434| static_cast(columns.size()), olay_idx); 4619| 434| AddColumnToVector(columns, "owned_id", &self->owned_id_, ColumnFlag::owned_id, 4620| 434| static_cast(columns.size()), olay_idx); 4621| 434| AddColumnToVector(columns, "field_name", &self->field_name_, ColumnFlag::field_name, 4622| 434| static_cast(columns.size()), olay_idx); 4623| 434| AddColumnToVector(columns, "field_type_name", &self->field_type_name_, ColumnFlag::field_type_name, 4624| 434| static_cast(columns.size()), olay_idx); 4625| 434| AddColumnToVector(columns, "deobfuscated_field_name", &self->deobfuscated_field_name_, ColumnFlag::deobfuscated_field_name, 4626| 434| static_cast(columns.size()), olay_idx); 4627| 434| base::ignore_result(self); 4628| 434| return columns; 4629| 434| } _ZN8perfetto15trace_processor6tables23HeapGraphReferenceTableC2EPNS0_10StringPoolE: 4632| 434| : macros_internal::MacroTable( 4633| 434| pool, 4634| 434| GetColumns(this, nullptr), 4635| 434| nullptr), 4636| 434| reference_set_id_(ColumnStorage::Create()), 4637| 434| owner_id_(ColumnStorage::Create()), 4638| 434| owned_id_(ColumnStorage::Create()), 4639| 434| field_name_(ColumnStorage::Create()), 4640| 434| field_type_name_(ColumnStorage::Create()), 4641| 434| deobfuscated_field_name_(ColumnStorage::Create()) 4642| |, 4643| 434| id_storage_layer_(new column::IdStorage()), 4644| 434| reference_set_id_storage_layer_( 4645| 434| new column::SetIdStorage(&reference_set_id_.vector())), 4646| 434| owner_id_storage_layer_( 4647| 434| new column::NumericStorage( 4648| 434| &owner_id_.vector(), 4649| 434| ColumnTypeHelper::ToColumnType(), 4650| 434| false)), 4651| 434| owned_id_storage_layer_( 4652| 434| new column::NumericStorage( 4653| 434| &owned_id_.non_null_vector(), 4654| 434| ColumnTypeHelper::ToColumnType(), 4655| 434| false)), 4656| 434| field_name_storage_layer_( 4657| 434| new column::StringStorage(string_pool(), &field_name_.vector())), 4658| 434| field_type_name_storage_layer_( 4659| 434| new column::StringStorage(string_pool(), &field_type_name_.vector())), 4660| 434| deobfuscated_field_name_storage_layer_( 4661| 434| new column::StringStorage(string_pool(), &deobfuscated_field_name_.vector())) 4662| |, 4663| 434| owned_id_null_layer_(new column::NullOverlay(owned_id_.bv())) { 4664| 434| static_assert( 4665| 434| ColumnLegacy::IsFlagsAndTypeValid( 4666| 434| ColumnFlag::reference_set_id), 4667| 434| "Column type and flag combination is not valid"); 4668| 434| static_assert( 4669| 434| ColumnLegacy::IsFlagsAndTypeValid( 4670| 434| ColumnFlag::owner_id), 4671| 434| "Column type and flag combination is not valid"); 4672| 434| static_assert( 4673| 434| ColumnLegacy::IsFlagsAndTypeValid( 4674| 434| ColumnFlag::owned_id), 4675| 434| "Column type and flag combination is not valid"); 4676| 434| static_assert( 4677| 434| ColumnLegacy::IsFlagsAndTypeValid( 4678| 434| ColumnFlag::field_name), 4679| 434| "Column type and flag combination is not valid"); 4680| 434| static_assert( 4681| 434| ColumnLegacy::IsFlagsAndTypeValid( 4682| 434| ColumnFlag::field_type_name), 4683| 434| "Column type and flag combination is not valid"); 4684| 434| static_assert( 4685| 434| ColumnLegacy::IsFlagsAndTypeValid( 4686| 434| ColumnFlag::deobfuscated_field_name), 4687| 434| "Column type and flag combination is not valid"); 4688| 434| OnConstructionCompletedRegularConstructor( 4689| 434| {id_storage_layer_,reference_set_id_storage_layer_,owner_id_storage_layer_,owned_id_storage_layer_,field_name_storage_layer_,field_type_name_storage_layer_,deobfuscated_field_name_storage_layer_}, 4690| 434| {{},{},{},owned_id_null_layer_,{},{},{}}); 4691| 434| } _ZN8perfetto15trace_processor6tables22InstrumentsSampleTable10GetColumnsEPS2_PKNS0_15macros_internal10MacroTableE: 5051| 434| const macros_internal::MacroTable* parent) { 5052| 434| std::vector columns = 5053| 434| CopyColumnsFromParentOrAddRootColumns(parent); 5054| 434| uint32_t olay_idx = OverlayCount(parent); 5055| 434| AddColumnToVector(columns, "ts", &self->ts_, ColumnFlag::ts, 5056| 434| static_cast(columns.size()), olay_idx); 5057| 434| AddColumnToVector(columns, "utid", &self->utid_, ColumnFlag::utid, 5058| 434| static_cast(columns.size()), olay_idx); 5059| 434| AddColumnToVector(columns, "callsite_id", &self->callsite_id_, ColumnFlag::callsite_id, 5060| 434| static_cast(columns.size()), olay_idx); 5061| 434| AddColumnToVector(columns, "cpu", &self->cpu_, ColumnFlag::cpu, 5062| 434| static_cast(columns.size()), olay_idx); 5063| 434| base::ignore_result(self); 5064| 434| return columns; 5065| 434| } _ZN8perfetto15trace_processor6tables22InstrumentsSampleTableC2EPNS0_10StringPoolE: 5068| 434| : macros_internal::MacroTable( 5069| 434| pool, 5070| 434| GetColumns(this, nullptr), 5071| 434| nullptr), 5072| 434| ts_(ColumnStorage::Create()), 5073| 434| utid_(ColumnStorage::Create()), 5074| 434| callsite_id_(ColumnStorage::Create()), 5075| 434| cpu_(ColumnStorage::Create()) 5076| |, 5077| 434| id_storage_layer_(new column::IdStorage()), 5078| 434| ts_storage_layer_( 5079| 434| new column::NumericStorage( 5080| 434| &ts_.vector(), 5081| 434| ColumnTypeHelper::ToColumnType(), 5082| 434| true)), 5083| 434| utid_storage_layer_( 5084| 434| new column::NumericStorage( 5085| 434| &utid_.vector(), 5086| 434| ColumnTypeHelper::ToColumnType(), 5087| 434| false)), 5088| 434| callsite_id_storage_layer_( 5089| 434| new column::NumericStorage( 5090| 434| &callsite_id_.non_null_vector(), 5091| 434| ColumnTypeHelper::ToColumnType(), 5092| 434| false)), 5093| 434| cpu_storage_layer_( 5094| 434| new column::NumericStorage( 5095| 434| &cpu_.non_null_vector(), 5096| 434| ColumnTypeHelper::ToColumnType(), 5097| 434| false)) 5098| |, 5099| 434| callsite_id_null_layer_(new column::NullOverlay(callsite_id_.bv())), 5100| 434| cpu_null_layer_(new column::NullOverlay(cpu_.bv())) { 5101| 434| static_assert( 5102| 434| ColumnLegacy::IsFlagsAndTypeValid( 5103| 434| ColumnFlag::ts), 5104| 434| "Column type and flag combination is not valid"); 5105| 434| static_assert( 5106| 434| ColumnLegacy::IsFlagsAndTypeValid( 5107| 434| ColumnFlag::utid), 5108| 434| "Column type and flag combination is not valid"); 5109| 434| static_assert( 5110| 434| ColumnLegacy::IsFlagsAndTypeValid( 5111| 434| ColumnFlag::callsite_id), 5112| 434| "Column type and flag combination is not valid"); 5113| 434| static_assert( 5114| 434| ColumnLegacy::IsFlagsAndTypeValid( 5115| 434| ColumnFlag::cpu), 5116| 434| "Column type and flag combination is not valid"); 5117| 434| OnConstructionCompletedRegularConstructor( 5118| 434| {id_storage_layer_,ts_storage_layer_,utid_storage_layer_,callsite_id_storage_layer_,cpu_storage_layer_}, 5119| 434| {{},{},{},callsite_id_null_layer_,cpu_null_layer_}); 5120| 434| } _ZN8perfetto15trace_processor6tables26HeapProfileAllocationTable10GetColumnsEPS2_PKNS0_15macros_internal10MacroTableE: 5487| 434| const macros_internal::MacroTable* parent) { 5488| 434| std::vector columns = 5489| 434| CopyColumnsFromParentOrAddRootColumns(parent); 5490| 434| uint32_t olay_idx = OverlayCount(parent); 5491| 434| AddColumnToVector(columns, "ts", &self->ts_, ColumnFlag::ts, 5492| 434| static_cast(columns.size()), olay_idx); 5493| 434| AddColumnToVector(columns, "upid", &self->upid_, ColumnFlag::upid, 5494| 434| static_cast(columns.size()), olay_idx); 5495| 434| AddColumnToVector(columns, "heap_name", &self->heap_name_, ColumnFlag::heap_name, 5496| 434| static_cast(columns.size()), olay_idx); 5497| 434| AddColumnToVector(columns, "callsite_id", &self->callsite_id_, ColumnFlag::callsite_id, 5498| 434| static_cast(columns.size()), olay_idx); 5499| 434| AddColumnToVector(columns, "count", &self->count_, ColumnFlag::count, 5500| 434| static_cast(columns.size()), olay_idx); 5501| 434| AddColumnToVector(columns, "size", &self->size_, ColumnFlag::size, 5502| 434| static_cast(columns.size()), olay_idx); 5503| 434| base::ignore_result(self); 5504| 434| return columns; 5505| 434| } _ZN8perfetto15trace_processor6tables26HeapProfileAllocationTableC2EPNS0_10StringPoolE: 5508| 434| : macros_internal::MacroTable( 5509| 434| pool, 5510| 434| GetColumns(this, nullptr), 5511| 434| nullptr), 5512| 434| ts_(ColumnStorage::Create()), 5513| 434| upid_(ColumnStorage::Create()), 5514| 434| heap_name_(ColumnStorage::Create()), 5515| 434| callsite_id_(ColumnStorage::Create()), 5516| 434| count_(ColumnStorage::Create()), 5517| 434| size_(ColumnStorage::Create()) 5518| |, 5519| 434| id_storage_layer_(new column::IdStorage()), 5520| 434| ts_storage_layer_( 5521| 434| new column::NumericStorage( 5522| 434| &ts_.vector(), 5523| 434| ColumnTypeHelper::ToColumnType(), 5524| 434| false)), 5525| 434| upid_storage_layer_( 5526| 434| new column::NumericStorage( 5527| 434| &upid_.vector(), 5528| 434| ColumnTypeHelper::ToColumnType(), 5529| 434| false)), 5530| 434| heap_name_storage_layer_( 5531| 434| new column::StringStorage(string_pool(), &heap_name_.vector())), 5532| 434| callsite_id_storage_layer_( 5533| 434| new column::NumericStorage( 5534| 434| &callsite_id_.vector(), 5535| 434| ColumnTypeHelper::ToColumnType(), 5536| 434| false)), 5537| 434| count_storage_layer_( 5538| 434| new column::NumericStorage( 5539| 434| &count_.vector(), 5540| 434| ColumnTypeHelper::ToColumnType(), 5541| 434| false)), 5542| 434| size_storage_layer_( 5543| 434| new column::NumericStorage( 5544| 434| &size_.vector(), 5545| 434| ColumnTypeHelper::ToColumnType(), 5546| 434| false)) 5547| 434| { 5548| 434| static_assert( 5549| 434| ColumnLegacy::IsFlagsAndTypeValid( 5550| 434| ColumnFlag::ts), 5551| 434| "Column type and flag combination is not valid"); 5552| 434| static_assert( 5553| 434| ColumnLegacy::IsFlagsAndTypeValid( 5554| 434| ColumnFlag::upid), 5555| 434| "Column type and flag combination is not valid"); 5556| 434| static_assert( 5557| 434| ColumnLegacy::IsFlagsAndTypeValid( 5558| 434| ColumnFlag::heap_name), 5559| 434| "Column type and flag combination is not valid"); 5560| 434| static_assert( 5561| 434| ColumnLegacy::IsFlagsAndTypeValid( 5562| 434| ColumnFlag::callsite_id), 5563| 434| "Column type and flag combination is not valid"); 5564| 434| static_assert( 5565| 434| ColumnLegacy::IsFlagsAndTypeValid( 5566| 434| ColumnFlag::count), 5567| 434| "Column type and flag combination is not valid"); 5568| 434| static_assert( 5569| 434| ColumnLegacy::IsFlagsAndTypeValid( 5570| 434| ColumnFlag::size), 5571| 434| "Column type and flag combination is not valid"); 5572| 434| OnConstructionCompletedRegularConstructor( 5573| 434| {id_storage_layer_,ts_storage_layer_,upid_storage_layer_,heap_name_storage_layer_,callsite_id_storage_layer_,count_storage_layer_,size_storage_layer_}, 5574| 434| {{},{},{},{},{},{},{}}); 5575| 434| } _ZN8perfetto15trace_processor6tables16PackageListTable10GetColumnsEPS2_PKNS0_15macros_internal10MacroTableE: 5954| 434| const macros_internal::MacroTable* parent) { 5955| 434| std::vector columns = 5956| 434| CopyColumnsFromParentOrAddRootColumns(parent); 5957| 434| uint32_t olay_idx = OverlayCount(parent); 5958| 434| AddColumnToVector(columns, "package_name", &self->package_name_, ColumnFlag::package_name, 5959| 434| static_cast(columns.size()), olay_idx); 5960| 434| AddColumnToVector(columns, "uid", &self->uid_, ColumnFlag::uid, 5961| 434| static_cast(columns.size()), olay_idx); 5962| 434| AddColumnToVector(columns, "debuggable", &self->debuggable_, ColumnFlag::debuggable, 5963| 434| static_cast(columns.size()), olay_idx); 5964| 434| AddColumnToVector(columns, "profileable_from_shell", &self->profileable_from_shell_, ColumnFlag::profileable_from_shell, 5965| 434| static_cast(columns.size()), olay_idx); 5966| 434| AddColumnToVector(columns, "version_code", &self->version_code_, ColumnFlag::version_code, 5967| 434| static_cast(columns.size()), olay_idx); 5968| 434| base::ignore_result(self); 5969| 434| return columns; 5970| 434| } _ZN8perfetto15trace_processor6tables16PackageListTableC2EPNS0_10StringPoolE: 5973| 434| : macros_internal::MacroTable( 5974| 434| pool, 5975| 434| GetColumns(this, nullptr), 5976| 434| nullptr), 5977| 434| package_name_(ColumnStorage::Create()), 5978| 434| uid_(ColumnStorage::Create()), 5979| 434| debuggable_(ColumnStorage::Create()), 5980| 434| profileable_from_shell_(ColumnStorage::Create()), 5981| 434| version_code_(ColumnStorage::Create()) 5982| |, 5983| 434| id_storage_layer_(new column::IdStorage()), 5984| 434| package_name_storage_layer_( 5985| 434| new column::StringStorage(string_pool(), &package_name_.vector())), 5986| 434| uid_storage_layer_( 5987| 434| new column::NumericStorage( 5988| 434| &uid_.vector(), 5989| 434| ColumnTypeHelper::ToColumnType(), 5990| 434| false)), 5991| 434| debuggable_storage_layer_( 5992| 434| new column::NumericStorage( 5993| 434| &debuggable_.vector(), 5994| 434| ColumnTypeHelper::ToColumnType(), 5995| 434| false)), 5996| 434| profileable_from_shell_storage_layer_( 5997| 434| new column::NumericStorage( 5998| 434| &profileable_from_shell_.vector(), 5999| 434| ColumnTypeHelper::ToColumnType(), 6000| 434| false)), 6001| 434| version_code_storage_layer_( 6002| 434| new column::NumericStorage( 6003| 434| &version_code_.vector(), 6004| 434| ColumnTypeHelper::ToColumnType(), 6005| 434| false)) 6006| 434| { 6007| 434| static_assert( 6008| 434| ColumnLegacy::IsFlagsAndTypeValid( 6009| 434| ColumnFlag::package_name), 6010| 434| "Column type and flag combination is not valid"); 6011| 434| static_assert( 6012| 434| ColumnLegacy::IsFlagsAndTypeValid( 6013| 434| ColumnFlag::uid), 6014| 434| "Column type and flag combination is not valid"); 6015| 434| static_assert( 6016| 434| ColumnLegacy::IsFlagsAndTypeValid( 6017| 434| ColumnFlag::debuggable), 6018| 434| "Column type and flag combination is not valid"); 6019| 434| static_assert( 6020| 434| ColumnLegacy::IsFlagsAndTypeValid( 6021| 434| ColumnFlag::profileable_from_shell), 6022| 434| "Column type and flag combination is not valid"); 6023| 434| static_assert( 6024| 434| ColumnLegacy::IsFlagsAndTypeValid( 6025| 434| ColumnFlag::version_code), 6026| 434| "Column type and flag combination is not valid"); 6027| 434| OnConstructionCompletedRegularConstructor( 6028| 434| {id_storage_layer_,package_name_storage_layer_,uid_storage_layer_,debuggable_storage_layer_,profileable_from_shell_storage_layer_,version_code_storage_layer_}, 6029| 434| {{},{},{},{},{},{}}); 6030| 434| } _ZN8perfetto15trace_processor6tables16PerfSessionTable10GetColumnsEPS2_PKNS0_15macros_internal10MacroTableE: 6317| 434| const macros_internal::MacroTable* parent) { 6318| 434| std::vector columns = 6319| 434| CopyColumnsFromParentOrAddRootColumns(parent); 6320| 434| uint32_t olay_idx = OverlayCount(parent); 6321| 434| AddColumnToVector(columns, "cmdline", &self->cmdline_, ColumnFlag::cmdline, 6322| 434| static_cast(columns.size()), olay_idx); 6323| 434| base::ignore_result(self); 6324| 434| return columns; 6325| 434| } _ZN8perfetto15trace_processor6tables16PerfSessionTableC2EPNS0_10StringPoolE: 6328| 434| : macros_internal::MacroTable( 6329| 434| pool, 6330| 434| GetColumns(this, nullptr), 6331| 434| nullptr), 6332| 434| cmdline_(ColumnStorage::Create()) 6333| |, 6334| 434| id_storage_layer_(new column::IdStorage()), 6335| 434| cmdline_storage_layer_( 6336| 434| new column::StringStorage(string_pool(), &cmdline_.vector())) 6337| 434| { 6338| 434| static_assert( 6339| 434| ColumnLegacy::IsFlagsAndTypeValid( 6340| 434| ColumnFlag::cmdline), 6341| 434| "Column type and flag combination is not valid"); 6342| 434| OnConstructionCompletedRegularConstructor( 6343| 434| {id_storage_layer_,cmdline_storage_layer_}, 6344| 434| {{},{}}); 6345| 434| } _ZN8perfetto15trace_processor6tables15PerfSampleTable10GetColumnsEPS2_PKNS0_15macros_internal10MacroTableE: 6682| 434| const macros_internal::MacroTable* parent) { 6683| 434| std::vector columns = 6684| 434| CopyColumnsFromParentOrAddRootColumns(parent); 6685| 434| uint32_t olay_idx = OverlayCount(parent); 6686| 434| AddColumnToVector(columns, "ts", &self->ts_, ColumnFlag::ts, 6687| 434| static_cast(columns.size()), olay_idx); 6688| 434| AddColumnToVector(columns, "utid", &self->utid_, ColumnFlag::utid, 6689| 434| static_cast(columns.size()), olay_idx); 6690| 434| AddColumnToVector(columns, "cpu", &self->cpu_, ColumnFlag::cpu, 6691| 434| static_cast(columns.size()), olay_idx); 6692| 434| AddColumnToVector(columns, "cpu_mode", &self->cpu_mode_, ColumnFlag::cpu_mode, 6693| 434| static_cast(columns.size()), olay_idx); 6694| 434| AddColumnToVector(columns, "callsite_id", &self->callsite_id_, ColumnFlag::callsite_id, 6695| 434| static_cast(columns.size()), olay_idx); 6696| 434| AddColumnToVector(columns, "unwind_error", &self->unwind_error_, ColumnFlag::unwind_error, 6697| 434| static_cast(columns.size()), olay_idx); 6698| 434| AddColumnToVector(columns, "perf_session_id", &self->perf_session_id_, ColumnFlag::perf_session_id, 6699| 434| static_cast(columns.size()), olay_idx); 6700| 434| base::ignore_result(self); 6701| 434| return columns; 6702| 434| } _ZN8perfetto15trace_processor6tables15PerfSampleTableC2EPNS0_10StringPoolE: 6705| 434| : macros_internal::MacroTable( 6706| 434| pool, 6707| 434| GetColumns(this, nullptr), 6708| 434| nullptr), 6709| 434| ts_(ColumnStorage::Create()), 6710| 434| utid_(ColumnStorage::Create()), 6711| 434| cpu_(ColumnStorage::Create()), 6712| 434| cpu_mode_(ColumnStorage::Create()), 6713| 434| callsite_id_(ColumnStorage::Create()), 6714| 434| unwind_error_(ColumnStorage::Create()), 6715| 434| perf_session_id_(ColumnStorage::Create()) 6716| |, 6717| 434| id_storage_layer_(new column::IdStorage()), 6718| 434| ts_storage_layer_( 6719| 434| new column::NumericStorage( 6720| 434| &ts_.vector(), 6721| 434| ColumnTypeHelper::ToColumnType(), 6722| 434| true)), 6723| 434| utid_storage_layer_( 6724| 434| new column::NumericStorage( 6725| 434| &utid_.vector(), 6726| 434| ColumnTypeHelper::ToColumnType(), 6727| 434| false)), 6728| 434| cpu_storage_layer_( 6729| 434| new column::NumericStorage( 6730| 434| &cpu_.non_null_vector(), 6731| 434| ColumnTypeHelper::ToColumnType(), 6732| 434| false)), 6733| 434| cpu_mode_storage_layer_( 6734| 434| new column::StringStorage(string_pool(), &cpu_mode_.vector())), 6735| 434| callsite_id_storage_layer_( 6736| 434| new column::NumericStorage( 6737| 434| &callsite_id_.non_null_vector(), 6738| 434| ColumnTypeHelper::ToColumnType(), 6739| 434| false)), 6740| 434| unwind_error_storage_layer_( 6741| 434| new column::StringStorage(string_pool(), &unwind_error_.vector())), 6742| 434| perf_session_id_storage_layer_( 6743| 434| new column::NumericStorage( 6744| 434| &perf_session_id_.vector(), 6745| 434| ColumnTypeHelper::ToColumnType(), 6746| 434| false)) 6747| |, 6748| 434| cpu_null_layer_(new column::NullOverlay(cpu_.bv())), 6749| 434| callsite_id_null_layer_(new column::NullOverlay(callsite_id_.bv())) { 6750| 434| static_assert( 6751| 434| ColumnLegacy::IsFlagsAndTypeValid( 6752| 434| ColumnFlag::ts), 6753| 434| "Column type and flag combination is not valid"); 6754| 434| static_assert( 6755| 434| ColumnLegacy::IsFlagsAndTypeValid( 6756| 434| ColumnFlag::utid), 6757| 434| "Column type and flag combination is not valid"); 6758| 434| static_assert( 6759| 434| ColumnLegacy::IsFlagsAndTypeValid( 6760| 434| ColumnFlag::cpu), 6761| 434| "Column type and flag combination is not valid"); 6762| 434| static_assert( 6763| 434| ColumnLegacy::IsFlagsAndTypeValid( 6764| 434| ColumnFlag::cpu_mode), 6765| 434| "Column type and flag combination is not valid"); 6766| 434| static_assert( 6767| 434| ColumnLegacy::IsFlagsAndTypeValid( 6768| 434| ColumnFlag::callsite_id), 6769| 434| "Column type and flag combination is not valid"); 6770| 434| static_assert( 6771| 434| ColumnLegacy::IsFlagsAndTypeValid( 6772| 434| ColumnFlag::unwind_error), 6773| 434| "Column type and flag combination is not valid"); 6774| 434| static_assert( 6775| 434| ColumnLegacy::IsFlagsAndTypeValid( 6776| 434| ColumnFlag::perf_session_id), 6777| 434| "Column type and flag combination is not valid"); 6778| 434| OnConstructionCompletedRegularConstructor( 6779| 434| {id_storage_layer_,ts_storage_layer_,utid_storage_layer_,cpu_storage_layer_,cpu_mode_storage_layer_,callsite_id_storage_layer_,unwind_error_storage_layer_,perf_session_id_storage_layer_}, 6780| 434| {{},{},{},cpu_null_layer_,{},callsite_id_null_layer_,{},{}}); 6781| 434| } _ZN8perfetto15trace_processor6tables18ProfilerSmapsTable10GetColumnsEPS2_PKNS0_15macros_internal10MacroTableE: 7405| 434| const macros_internal::MacroTable* parent) { 7406| 434| std::vector columns = 7407| 434| CopyColumnsFromParentOrAddRootColumns(parent); 7408| 434| uint32_t olay_idx = OverlayCount(parent); 7409| 434| AddColumnToVector(columns, "upid", &self->upid_, ColumnFlag::upid, 7410| 434| static_cast(columns.size()), olay_idx); 7411| 434| AddColumnToVector(columns, "ts", &self->ts_, ColumnFlag::ts, 7412| 434| static_cast(columns.size()), olay_idx); 7413| 434| AddColumnToVector(columns, "path", &self->path_, ColumnFlag::path, 7414| 434| static_cast(columns.size()), olay_idx); 7415| 434| AddColumnToVector(columns, "size_kb", &self->size_kb_, ColumnFlag::size_kb, 7416| 434| static_cast(columns.size()), olay_idx); 7417| 434| AddColumnToVector(columns, "private_dirty_kb", &self->private_dirty_kb_, ColumnFlag::private_dirty_kb, 7418| 434| static_cast(columns.size()), olay_idx); 7419| 434| AddColumnToVector(columns, "swap_kb", &self->swap_kb_, ColumnFlag::swap_kb, 7420| 434| static_cast(columns.size()), olay_idx); 7421| 434| AddColumnToVector(columns, "file_name", &self->file_name_, ColumnFlag::file_name, 7422| 434| static_cast(columns.size()), olay_idx); 7423| 434| AddColumnToVector(columns, "start_address", &self->start_address_, ColumnFlag::start_address, 7424| 434| static_cast(columns.size()), olay_idx); 7425| 434| AddColumnToVector(columns, "module_timestamp", &self->module_timestamp_, ColumnFlag::module_timestamp, 7426| 434| static_cast(columns.size()), olay_idx); 7427| 434| AddColumnToVector(columns, "module_debugid", &self->module_debugid_, ColumnFlag::module_debugid, 7428| 434| static_cast(columns.size()), olay_idx); 7429| 434| AddColumnToVector(columns, "module_debug_path", &self->module_debug_path_, ColumnFlag::module_debug_path, 7430| 434| static_cast(columns.size()), olay_idx); 7431| 434| AddColumnToVector(columns, "protection_flags", &self->protection_flags_, ColumnFlag::protection_flags, 7432| 434| static_cast(columns.size()), olay_idx); 7433| 434| AddColumnToVector(columns, "private_clean_resident_kb", &self->private_clean_resident_kb_, ColumnFlag::private_clean_resident_kb, 7434| 434| static_cast(columns.size()), olay_idx); 7435| 434| AddColumnToVector(columns, "shared_dirty_resident_kb", &self->shared_dirty_resident_kb_, ColumnFlag::shared_dirty_resident_kb, 7436| 434| static_cast(columns.size()), olay_idx); 7437| 434| AddColumnToVector(columns, "shared_clean_resident_kb", &self->shared_clean_resident_kb_, ColumnFlag::shared_clean_resident_kb, 7438| 434| static_cast(columns.size()), olay_idx); 7439| 434| AddColumnToVector(columns, "locked_kb", &self->locked_kb_, ColumnFlag::locked_kb, 7440| 434| static_cast(columns.size()), olay_idx); 7441| 434| AddColumnToVector(columns, "proportional_resident_kb", &self->proportional_resident_kb_, ColumnFlag::proportional_resident_kb, 7442| 434| static_cast(columns.size()), olay_idx); 7443| 434| base::ignore_result(self); 7444| 434| return columns; 7445| 434| } _ZN8perfetto15trace_processor6tables18ProfilerSmapsTableC2EPNS0_10StringPoolE: 7448| 434| : macros_internal::MacroTable( 7449| 434| pool, 7450| 434| GetColumns(this, nullptr), 7451| 434| nullptr), 7452| 434| upid_(ColumnStorage::Create()), 7453| 434| ts_(ColumnStorage::Create()), 7454| 434| path_(ColumnStorage::Create()), 7455| 434| size_kb_(ColumnStorage::Create()), 7456| 434| private_dirty_kb_(ColumnStorage::Create()), 7457| 434| swap_kb_(ColumnStorage::Create()), 7458| 434| file_name_(ColumnStorage::Create()), 7459| 434| start_address_(ColumnStorage::Create()), 7460| 434| module_timestamp_(ColumnStorage::Create()), 7461| 434| module_debugid_(ColumnStorage::Create()), 7462| 434| module_debug_path_(ColumnStorage::Create()), 7463| 434| protection_flags_(ColumnStorage::Create()), 7464| 434| private_clean_resident_kb_(ColumnStorage::Create()), 7465| 434| shared_dirty_resident_kb_(ColumnStorage::Create()), 7466| 434| shared_clean_resident_kb_(ColumnStorage::Create()), 7467| 434| locked_kb_(ColumnStorage::Create()), 7468| 434| proportional_resident_kb_(ColumnStorage::Create()) 7469| |, 7470| 434| id_storage_layer_(new column::IdStorage()), 7471| 434| upid_storage_layer_( 7472| 434| new column::NumericStorage( 7473| 434| &upid_.vector(), 7474| 434| ColumnTypeHelper::ToColumnType(), 7475| 434| false)), 7476| 434| ts_storage_layer_( 7477| 434| new column::NumericStorage( 7478| 434| &ts_.vector(), 7479| 434| ColumnTypeHelper::ToColumnType(), 7480| 434| false)), 7481| 434| path_storage_layer_( 7482| 434| new column::StringStorage(string_pool(), &path_.vector())), 7483| 434| size_kb_storage_layer_( 7484| 434| new column::NumericStorage( 7485| 434| &size_kb_.vector(), 7486| 434| ColumnTypeHelper::ToColumnType(), 7487| 434| false)), 7488| 434| private_dirty_kb_storage_layer_( 7489| 434| new column::NumericStorage( 7490| 434| &private_dirty_kb_.vector(), 7491| 434| ColumnTypeHelper::ToColumnType(), 7492| 434| false)), 7493| 434| swap_kb_storage_layer_( 7494| 434| new column::NumericStorage( 7495| 434| &swap_kb_.vector(), 7496| 434| ColumnTypeHelper::ToColumnType(), 7497| 434| false)), 7498| 434| file_name_storage_layer_( 7499| 434| new column::StringStorage(string_pool(), &file_name_.vector())), 7500| 434| start_address_storage_layer_( 7501| 434| new column::NumericStorage( 7502| 434| &start_address_.vector(), 7503| 434| ColumnTypeHelper::ToColumnType(), 7504| 434| false)), 7505| 434| module_timestamp_storage_layer_( 7506| 434| new column::NumericStorage( 7507| 434| &module_timestamp_.vector(), 7508| 434| ColumnTypeHelper::ToColumnType(), 7509| 434| false)), 7510| 434| module_debugid_storage_layer_( 7511| 434| new column::StringStorage(string_pool(), &module_debugid_.vector())), 7512| 434| module_debug_path_storage_layer_( 7513| 434| new column::StringStorage(string_pool(), &module_debug_path_.vector())), 7514| 434| protection_flags_storage_layer_( 7515| 434| new column::NumericStorage( 7516| 434| &protection_flags_.vector(), 7517| 434| ColumnTypeHelper::ToColumnType(), 7518| 434| false)), 7519| 434| private_clean_resident_kb_storage_layer_( 7520| 434| new column::NumericStorage( 7521| 434| &private_clean_resident_kb_.vector(), 7522| 434| ColumnTypeHelper::ToColumnType(), 7523| 434| false)), 7524| 434| shared_dirty_resident_kb_storage_layer_( 7525| 434| new column::NumericStorage( 7526| 434| &shared_dirty_resident_kb_.vector(), 7527| 434| ColumnTypeHelper::ToColumnType(), 7528| 434| false)), 7529| 434| shared_clean_resident_kb_storage_layer_( 7530| 434| new column::NumericStorage( 7531| 434| &shared_clean_resident_kb_.vector(), 7532| 434| ColumnTypeHelper::ToColumnType(), 7533| 434| false)), 7534| 434| locked_kb_storage_layer_( 7535| 434| new column::NumericStorage( 7536| 434| &locked_kb_.vector(), 7537| 434| ColumnTypeHelper::ToColumnType(), 7538| 434| false)), 7539| 434| proportional_resident_kb_storage_layer_( 7540| 434| new column::NumericStorage( 7541| 434| &proportional_resident_kb_.vector(), 7542| 434| ColumnTypeHelper::ToColumnType(), 7543| 434| false)) 7544| 434| { 7545| 434| static_assert( 7546| 434| ColumnLegacy::IsFlagsAndTypeValid( 7547| 434| ColumnFlag::upid), 7548| 434| "Column type and flag combination is not valid"); 7549| 434| static_assert( 7550| 434| ColumnLegacy::IsFlagsAndTypeValid( 7551| 434| ColumnFlag::ts), 7552| 434| "Column type and flag combination is not valid"); 7553| 434| static_assert( 7554| 434| ColumnLegacy::IsFlagsAndTypeValid( 7555| 434| ColumnFlag::path), 7556| 434| "Column type and flag combination is not valid"); 7557| 434| static_assert( 7558| 434| ColumnLegacy::IsFlagsAndTypeValid( 7559| 434| ColumnFlag::size_kb), 7560| 434| "Column type and flag combination is not valid"); 7561| 434| static_assert( 7562| 434| ColumnLegacy::IsFlagsAndTypeValid( 7563| 434| ColumnFlag::private_dirty_kb), 7564| 434| "Column type and flag combination is not valid"); 7565| 434| static_assert( 7566| 434| ColumnLegacy::IsFlagsAndTypeValid( 7567| 434| ColumnFlag::swap_kb), 7568| 434| "Column type and flag combination is not valid"); 7569| 434| static_assert( 7570| 434| ColumnLegacy::IsFlagsAndTypeValid( 7571| 434| ColumnFlag::file_name), 7572| 434| "Column type and flag combination is not valid"); 7573| 434| static_assert( 7574| 434| ColumnLegacy::IsFlagsAndTypeValid( 7575| 434| ColumnFlag::start_address), 7576| 434| "Column type and flag combination is not valid"); 7577| 434| static_assert( 7578| 434| ColumnLegacy::IsFlagsAndTypeValid( 7579| 434| ColumnFlag::module_timestamp), 7580| 434| "Column type and flag combination is not valid"); 7581| 434| static_assert( 7582| 434| ColumnLegacy::IsFlagsAndTypeValid( 7583| 434| ColumnFlag::module_debugid), 7584| 434| "Column type and flag combination is not valid"); 7585| 434| static_assert( 7586| 434| ColumnLegacy::IsFlagsAndTypeValid( 7587| 434| ColumnFlag::module_debug_path), 7588| 434| "Column type and flag combination is not valid"); 7589| 434| static_assert( 7590| 434| ColumnLegacy::IsFlagsAndTypeValid( 7591| 434| ColumnFlag::protection_flags), 7592| 434| "Column type and flag combination is not valid"); 7593| 434| static_assert( 7594| 434| ColumnLegacy::IsFlagsAndTypeValid( 7595| 434| ColumnFlag::private_clean_resident_kb), 7596| 434| "Column type and flag combination is not valid"); 7597| 434| static_assert( 7598| 434| ColumnLegacy::IsFlagsAndTypeValid( 7599| 434| ColumnFlag::shared_dirty_resident_kb), 7600| 434| "Column type and flag combination is not valid"); 7601| 434| static_assert( 7602| 434| ColumnLegacy::IsFlagsAndTypeValid( 7603| 434| ColumnFlag::shared_clean_resident_kb), 7604| 434| "Column type and flag combination is not valid"); 7605| 434| static_assert( 7606| 434| ColumnLegacy::IsFlagsAndTypeValid( 7607| 434| ColumnFlag::locked_kb), 7608| 434| "Column type and flag combination is not valid"); 7609| 434| static_assert( 7610| 434| ColumnLegacy::IsFlagsAndTypeValid( 7611| 434| ColumnFlag::proportional_resident_kb), 7612| 434| "Column type and flag combination is not valid"); 7613| 434| OnConstructionCompletedRegularConstructor( 7614| 434| {id_storage_layer_,upid_storage_layer_,ts_storage_layer_,path_storage_layer_,size_kb_storage_layer_,private_dirty_kb_storage_layer_,swap_kb_storage_layer_,file_name_storage_layer_,start_address_storage_layer_,module_timestamp_storage_layer_,module_debugid_storage_layer_,module_debug_path_storage_layer_,protection_flags_storage_layer_,private_clean_resident_kb_storage_layer_,shared_dirty_resident_kb_storage_layer_,shared_clean_resident_kb_storage_layer_,locked_kb_storage_layer_,proportional_resident_kb_storage_layer_}, 7615| 434| {{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{}}); 7616| 434| } _ZN8perfetto15trace_processor6tables11SymbolTable10GetColumnsEPS2_PKNS0_15macros_internal10MacroTableE: 8152| 434| const macros_internal::MacroTable* parent) { 8153| 434| std::vector columns = 8154| 434| CopyColumnsFromParentOrAddRootColumns(parent); 8155| 434| uint32_t olay_idx = OverlayCount(parent); 8156| 434| AddColumnToVector(columns, "symbol_set_id", &self->symbol_set_id_, ColumnFlag::symbol_set_id, 8157| 434| static_cast(columns.size()), olay_idx); 8158| 434| AddColumnToVector(columns, "name", &self->name_, ColumnFlag::name, 8159| 434| static_cast(columns.size()), olay_idx); 8160| 434| AddColumnToVector(columns, "source_file", &self->source_file_, ColumnFlag::source_file, 8161| 434| static_cast(columns.size()), olay_idx); 8162| 434| AddColumnToVector(columns, "line_number", &self->line_number_, ColumnFlag::line_number, 8163| 434| static_cast(columns.size()), olay_idx); 8164| 434| base::ignore_result(self); 8165| 434| return columns; 8166| 434| } _ZN8perfetto15trace_processor6tables11SymbolTableC2EPNS0_10StringPoolE: 8169| 434| : macros_internal::MacroTable( 8170| 434| pool, 8171| 434| GetColumns(this, nullptr), 8172| 434| nullptr), 8173| 434| symbol_set_id_(ColumnStorage::Create()), 8174| 434| name_(ColumnStorage::Create()), 8175| 434| source_file_(ColumnStorage::Create()), 8176| 434| line_number_(ColumnStorage::Create()) 8177| |, 8178| 434| id_storage_layer_(new column::IdStorage()), 8179| 434| symbol_set_id_storage_layer_( 8180| 434| new column::SetIdStorage(&symbol_set_id_.vector())), 8181| 434| name_storage_layer_( 8182| 434| new column::StringStorage(string_pool(), &name_.vector())), 8183| 434| source_file_storage_layer_( 8184| 434| new column::StringStorage(string_pool(), &source_file_.vector())), 8185| 434| line_number_storage_layer_( 8186| 434| new column::NumericStorage( 8187| 434| &line_number_.non_null_vector(), 8188| 434| ColumnTypeHelper::ToColumnType(), 8189| 434| false)) 8190| |, 8191| 434| line_number_null_layer_(new column::NullOverlay(line_number_.bv())) { 8192| 434| static_assert( 8193| 434| ColumnLegacy::IsFlagsAndTypeValid( 8194| 434| ColumnFlag::symbol_set_id), 8195| 434| "Column type and flag combination is not valid"); 8196| 434| static_assert( 8197| 434| ColumnLegacy::IsFlagsAndTypeValid( 8198| 434| ColumnFlag::name), 8199| 434| "Column type and flag combination is not valid"); 8200| 434| static_assert( 8201| 434| ColumnLegacy::IsFlagsAndTypeValid( 8202| 434| ColumnFlag::source_file), 8203| 434| "Column type and flag combination is not valid"); 8204| 434| static_assert( 8205| 434| ColumnLegacy::IsFlagsAndTypeValid( 8206| 434| ColumnFlag::line_number), 8207| 434| "Column type and flag combination is not valid"); 8208| 434| OnConstructionCompletedRegularConstructor( 8209| 434| {id_storage_layer_,symbol_set_id_storage_layer_,name_storage_layer_,source_file_storage_layer_,line_number_storage_layer_}, 8210| 434| {{},{},{},{},line_number_null_layer_}); 8211| 434| } _ZN8perfetto15trace_processor6tables28VulkanMemoryAllocationsTable10GetColumnsEPS2_PKNS0_15macros_internal10MacroTableE: 8729| 434| const macros_internal::MacroTable* parent) { 8730| 434| std::vector columns = 8731| 434| CopyColumnsFromParentOrAddRootColumns(parent); 8732| 434| uint32_t olay_idx = OverlayCount(parent); 8733| 434| AddColumnToVector(columns, "arg_set_id", &self->arg_set_id_, ColumnFlag::arg_set_id, 8734| 434| static_cast(columns.size()), olay_idx); 8735| 434| AddColumnToVector(columns, "source", &self->source_, ColumnFlag::source, 8736| 434| static_cast(columns.size()), olay_idx); 8737| 434| AddColumnToVector(columns, "operation", &self->operation_, ColumnFlag::operation, 8738| 434| static_cast(columns.size()), olay_idx); 8739| 434| AddColumnToVector(columns, "timestamp", &self->timestamp_, ColumnFlag::timestamp, 8740| 434| static_cast(columns.size()), olay_idx); 8741| 434| AddColumnToVector(columns, "upid", &self->upid_, ColumnFlag::upid, 8742| 434| static_cast(columns.size()), olay_idx); 8743| 434| AddColumnToVector(columns, "device", &self->device_, ColumnFlag::device, 8744| 434| static_cast(columns.size()), olay_idx); 8745| 434| AddColumnToVector(columns, "device_memory", &self->device_memory_, ColumnFlag::device_memory, 8746| 434| static_cast(columns.size()), olay_idx); 8747| 434| AddColumnToVector(columns, "memory_type", &self->memory_type_, ColumnFlag::memory_type, 8748| 434| static_cast(columns.size()), olay_idx); 8749| 434| AddColumnToVector(columns, "heap", &self->heap_, ColumnFlag::heap, 8750| 434| static_cast(columns.size()), olay_idx); 8751| 434| AddColumnToVector(columns, "function_name", &self->function_name_, ColumnFlag::function_name, 8752| 434| static_cast(columns.size()), olay_idx); 8753| 434| AddColumnToVector(columns, "object_handle", &self->object_handle_, ColumnFlag::object_handle, 8754| 434| static_cast(columns.size()), olay_idx); 8755| 434| AddColumnToVector(columns, "memory_address", &self->memory_address_, ColumnFlag::memory_address, 8756| 434| static_cast(columns.size()), olay_idx); 8757| 434| AddColumnToVector(columns, "memory_size", &self->memory_size_, ColumnFlag::memory_size, 8758| 434| static_cast(columns.size()), olay_idx); 8759| 434| AddColumnToVector(columns, "scope", &self->scope_, ColumnFlag::scope, 8760| 434| static_cast(columns.size()), olay_idx); 8761| 434| base::ignore_result(self); 8762| 434| return columns; 8763| 434| } _ZN8perfetto15trace_processor6tables28VulkanMemoryAllocationsTableC2EPNS0_10StringPoolE: 8766| 434| : macros_internal::MacroTable( 8767| 434| pool, 8768| 434| GetColumns(this, nullptr), 8769| 434| nullptr), 8770| 434| arg_set_id_(ColumnStorage::Create()), 8771| 434| source_(ColumnStorage::Create()), 8772| 434| operation_(ColumnStorage::Create()), 8773| 434| timestamp_(ColumnStorage::Create()), 8774| 434| upid_(ColumnStorage::Create()), 8775| 434| device_(ColumnStorage::Create()), 8776| 434| device_memory_(ColumnStorage::Create()), 8777| 434| memory_type_(ColumnStorage::Create()), 8778| 434| heap_(ColumnStorage::Create()), 8779| 434| function_name_(ColumnStorage::Create()), 8780| 434| object_handle_(ColumnStorage::Create()), 8781| 434| memory_address_(ColumnStorage::Create()), 8782| 434| memory_size_(ColumnStorage::Create()), 8783| 434| scope_(ColumnStorage::Create()) 8784| |, 8785| 434| id_storage_layer_(new column::IdStorage()), 8786| 434| arg_set_id_storage_layer_( 8787| 434| new column::NumericStorage( 8788| 434| &arg_set_id_.non_null_vector(), 8789| 434| ColumnTypeHelper::ToColumnType(), 8790| 434| false)), 8791| 434| source_storage_layer_( 8792| 434| new column::StringStorage(string_pool(), &source_.vector())), 8793| 434| operation_storage_layer_( 8794| 434| new column::StringStorage(string_pool(), &operation_.vector())), 8795| 434| timestamp_storage_layer_( 8796| 434| new column::NumericStorage( 8797| 434| ×tamp_.vector(), 8798| 434| ColumnTypeHelper::ToColumnType(), 8799| 434| false)), 8800| 434| upid_storage_layer_( 8801| 434| new column::NumericStorage( 8802| 434| &upid_.non_null_vector(), 8803| 434| ColumnTypeHelper::ToColumnType(), 8804| 434| false)), 8805| 434| device_storage_layer_( 8806| 434| new column::NumericStorage( 8807| 434| &device_.non_null_vector(), 8808| 434| ColumnTypeHelper::ToColumnType(), 8809| 434| false)), 8810| 434| device_memory_storage_layer_( 8811| 434| new column::NumericStorage( 8812| 434| &device_memory_.non_null_vector(), 8813| 434| ColumnTypeHelper::ToColumnType(), 8814| 434| false)), 8815| 434| memory_type_storage_layer_( 8816| 434| new column::NumericStorage( 8817| 434| &memory_type_.non_null_vector(), 8818| 434| ColumnTypeHelper::ToColumnType(), 8819| 434| false)), 8820| 434| heap_storage_layer_( 8821| 434| new column::NumericStorage( 8822| 434| &heap_.non_null_vector(), 8823| 434| ColumnTypeHelper::ToColumnType(), 8824| 434| false)), 8825| 434| function_name_storage_layer_( 8826| 434| new column::StringStorage(string_pool(), &function_name_.vector())), 8827| 434| object_handle_storage_layer_( 8828| 434| new column::NumericStorage( 8829| 434| &object_handle_.non_null_vector(), 8830| 434| ColumnTypeHelper::ToColumnType(), 8831| 434| false)), 8832| 434| memory_address_storage_layer_( 8833| 434| new column::NumericStorage( 8834| 434| &memory_address_.non_null_vector(), 8835| 434| ColumnTypeHelper::ToColumnType(), 8836| 434| false)), 8837| 434| memory_size_storage_layer_( 8838| 434| new column::NumericStorage( 8839| 434| &memory_size_.non_null_vector(), 8840| 434| ColumnTypeHelper::ToColumnType(), 8841| 434| false)), 8842| 434| scope_storage_layer_( 8843| 434| new column::StringStorage(string_pool(), &scope_.vector())) 8844| |, 8845| 434| arg_set_id_null_layer_(new column::NullOverlay(arg_set_id_.bv())), 8846| 434| upid_null_layer_(new column::NullOverlay(upid_.bv())), 8847| 434| device_null_layer_(new column::NullOverlay(device_.bv())), 8848| 434| device_memory_null_layer_(new column::NullOverlay(device_memory_.bv())), 8849| 434| memory_type_null_layer_(new column::NullOverlay(memory_type_.bv())), 8850| 434| heap_null_layer_(new column::NullOverlay(heap_.bv())), 8851| 434| object_handle_null_layer_(new column::NullOverlay(object_handle_.bv())), 8852| 434| memory_address_null_layer_(new column::NullOverlay(memory_address_.bv())), 8853| 434| memory_size_null_layer_(new column::NullOverlay(memory_size_.bv())) { 8854| 434| static_assert( 8855| 434| ColumnLegacy::IsFlagsAndTypeValid( 8856| 434| ColumnFlag::arg_set_id), 8857| 434| "Column type and flag combination is not valid"); 8858| 434| static_assert( 8859| 434| ColumnLegacy::IsFlagsAndTypeValid( 8860| 434| ColumnFlag::source), 8861| 434| "Column type and flag combination is not valid"); 8862| 434| static_assert( 8863| 434| ColumnLegacy::IsFlagsAndTypeValid( 8864| 434| ColumnFlag::operation), 8865| 434| "Column type and flag combination is not valid"); 8866| 434| static_assert( 8867| 434| ColumnLegacy::IsFlagsAndTypeValid( 8868| 434| ColumnFlag::timestamp), 8869| 434| "Column type and flag combination is not valid"); 8870| 434| static_assert( 8871| 434| ColumnLegacy::IsFlagsAndTypeValid( 8872| 434| ColumnFlag::upid), 8873| 434| "Column type and flag combination is not valid"); 8874| 434| static_assert( 8875| 434| ColumnLegacy::IsFlagsAndTypeValid( 8876| 434| ColumnFlag::device), 8877| 434| "Column type and flag combination is not valid"); 8878| 434| static_assert( 8879| 434| ColumnLegacy::IsFlagsAndTypeValid( 8880| 434| ColumnFlag::device_memory), 8881| 434| "Column type and flag combination is not valid"); 8882| 434| static_assert( 8883| 434| ColumnLegacy::IsFlagsAndTypeValid( 8884| 434| ColumnFlag::memory_type), 8885| 434| "Column type and flag combination is not valid"); 8886| 434| static_assert( 8887| 434| ColumnLegacy::IsFlagsAndTypeValid( 8888| 434| ColumnFlag::heap), 8889| 434| "Column type and flag combination is not valid"); 8890| 434| static_assert( 8891| 434| ColumnLegacy::IsFlagsAndTypeValid( 8892| 434| ColumnFlag::function_name), 8893| 434| "Column type and flag combination is not valid"); 8894| 434| static_assert( 8895| 434| ColumnLegacy::IsFlagsAndTypeValid( 8896| 434| ColumnFlag::object_handle), 8897| 434| "Column type and flag combination is not valid"); 8898| 434| static_assert( 8899| 434| ColumnLegacy::IsFlagsAndTypeValid( 8900| 434| ColumnFlag::memory_address), 8901| 434| "Column type and flag combination is not valid"); 8902| 434| static_assert( 8903| 434| ColumnLegacy::IsFlagsAndTypeValid( 8904| 434| ColumnFlag::memory_size), 8905| 434| "Column type and flag combination is not valid"); 8906| 434| static_assert( 8907| 434| ColumnLegacy::IsFlagsAndTypeValid( 8908| 434| ColumnFlag::scope), 8909| 434| "Column type and flag combination is not valid"); 8910| 434| OnConstructionCompletedRegularConstructor( 8911| 434| {id_storage_layer_,arg_set_id_storage_layer_,source_storage_layer_,operation_storage_layer_,timestamp_storage_layer_,upid_storage_layer_,device_storage_layer_,device_memory_storage_layer_,memory_type_storage_layer_,heap_storage_layer_,function_name_storage_layer_,object_handle_storage_layer_,memory_address_storage_layer_,memory_size_storage_layer_,scope_storage_layer_}, 8912| 434| {{},arg_set_id_null_layer_,{},{},{},upid_null_layer_,device_null_layer_,device_memory_null_layer_,memory_type_null_layer_,heap_null_layer_,{},object_handle_null_layer_,memory_address_null_layer_,memory_size_null_layer_,{}}); 8913| 434| } _ZN8perfetto15trace_processor6tables15SchedSliceTable10GetColumnsEPS2_PKNS0_15macros_internal10MacroTableE: 267| 434| const macros_internal::MacroTable* parent) { 268| 434| std::vector columns = 269| 434| CopyColumnsFromParentOrAddRootColumns(parent); 270| 434| uint32_t olay_idx = OverlayCount(parent); 271| 434| AddColumnToVector(columns, "ts", &self->ts_, ColumnFlag::ts, 272| 434| static_cast(columns.size()), olay_idx); 273| 434| AddColumnToVector(columns, "dur", &self->dur_, ColumnFlag::dur, 274| 434| static_cast(columns.size()), olay_idx); 275| 434| AddColumnToVector(columns, "utid", &self->utid_, ColumnFlag::utid, 276| 434| static_cast(columns.size()), olay_idx); 277| 434| AddColumnToVector(columns, "end_state", &self->end_state_, ColumnFlag::end_state, 278| 434| static_cast(columns.size()), olay_idx); 279| 434| AddColumnToVector(columns, "priority", &self->priority_, ColumnFlag::priority, 280| 434| static_cast(columns.size()), olay_idx); 281| 434| AddColumnToVector(columns, "ucpu", &self->ucpu_, ColumnFlag::ucpu, 282| 434| static_cast(columns.size()), olay_idx); 283| 434| base::ignore_result(self); 284| 434| return columns; 285| 434| } _ZN8perfetto15trace_processor6tables15SchedSliceTableC2EPNS0_10StringPoolE: 288| 434| : macros_internal::MacroTable( 289| 434| pool, 290| 434| GetColumns(this, nullptr), 291| 434| nullptr), 292| 434| ts_(ColumnStorage::Create()), 293| 434| dur_(ColumnStorage::Create()), 294| 434| utid_(ColumnStorage::Create()), 295| 434| end_state_(ColumnStorage::Create()), 296| 434| priority_(ColumnStorage::Create()), 297| 434| ucpu_(ColumnStorage::Create()) 298| |, 299| 434| id_storage_layer_(new column::IdStorage()), 300| 434| ts_storage_layer_( 301| 434| new column::NumericStorage( 302| 434| &ts_.vector(), 303| 434| ColumnTypeHelper::ToColumnType(), 304| 434| true)), 305| 434| dur_storage_layer_( 306| 434| new column::NumericStorage( 307| 434| &dur_.vector(), 308| 434| ColumnTypeHelper::ToColumnType(), 309| 434| false)), 310| 434| utid_storage_layer_( 311| 434| new column::NumericStorage( 312| 434| &utid_.vector(), 313| 434| ColumnTypeHelper::ToColumnType(), 314| 434| false)), 315| 434| end_state_storage_layer_( 316| 434| new column::StringStorage(string_pool(), &end_state_.vector())), 317| 434| priority_storage_layer_( 318| 434| new column::NumericStorage( 319| 434| &priority_.vector(), 320| 434| ColumnTypeHelper::ToColumnType(), 321| 434| false)), 322| 434| ucpu_storage_layer_( 323| 434| new column::NumericStorage( 324| 434| &ucpu_.vector(), 325| 434| ColumnTypeHelper::ToColumnType(), 326| 434| false)) 327| 434| { 328| 434| static_assert( 329| 434| ColumnLegacy::IsFlagsAndTypeValid( 330| 434| ColumnFlag::ts), 331| 434| "Column type and flag combination is not valid"); 332| 434| static_assert( 333| 434| ColumnLegacy::IsFlagsAndTypeValid( 334| 434| ColumnFlag::dur), 335| 434| "Column type and flag combination is not valid"); 336| 434| static_assert( 337| 434| ColumnLegacy::IsFlagsAndTypeValid( 338| 434| ColumnFlag::utid), 339| 434| "Column type and flag combination is not valid"); 340| 434| static_assert( 341| 434| ColumnLegacy::IsFlagsAndTypeValid( 342| 434| ColumnFlag::end_state), 343| 434| "Column type and flag combination is not valid"); 344| 434| static_assert( 345| 434| ColumnLegacy::IsFlagsAndTypeValid( 346| 434| ColumnFlag::priority), 347| 434| "Column type and flag combination is not valid"); 348| 434| static_assert( 349| 434| ColumnLegacy::IsFlagsAndTypeValid( 350| 434| ColumnFlag::ucpu), 351| 434| "Column type and flag combination is not valid"); 352| 434| OnConstructionCompletedRegularConstructor( 353| 434| {id_storage_layer_,ts_storage_layer_,dur_storage_layer_,utid_storage_layer_,end_state_storage_layer_,priority_storage_layer_,ucpu_storage_layer_}, 354| 434| {{},{},{},{},{},{},{}}); 355| 434| } _ZN8perfetto15trace_processor6tables24SpuriousSchedWakeupTable10GetColumnsEPS2_PKNS0_15macros_internal10MacroTableE: 734| 434| const macros_internal::MacroTable* parent) { 735| 434| std::vector columns = 736| 434| CopyColumnsFromParentOrAddRootColumns(parent); 737| 434| uint32_t olay_idx = OverlayCount(parent); 738| 434| AddColumnToVector(columns, "ts", &self->ts_, ColumnFlag::ts, 739| 434| static_cast(columns.size()), olay_idx); 740| 434| AddColumnToVector(columns, "thread_state_id", &self->thread_state_id_, ColumnFlag::thread_state_id, 741| 434| static_cast(columns.size()), olay_idx); 742| 434| AddColumnToVector(columns, "irq_context", &self->irq_context_, ColumnFlag::irq_context, 743| 434| static_cast(columns.size()), olay_idx); 744| 434| AddColumnToVector(columns, "utid", &self->utid_, ColumnFlag::utid, 745| 434| static_cast(columns.size()), olay_idx); 746| 434| AddColumnToVector(columns, "waker_utid", &self->waker_utid_, ColumnFlag::waker_utid, 747| 434| static_cast(columns.size()), olay_idx); 748| 434| base::ignore_result(self); 749| 434| return columns; 750| 434| } _ZN8perfetto15trace_processor6tables24SpuriousSchedWakeupTableC2EPNS0_10StringPoolE: 753| 434| : macros_internal::MacroTable( 754| 434| pool, 755| 434| GetColumns(this, nullptr), 756| 434| nullptr), 757| 434| ts_(ColumnStorage::Create()), 758| 434| thread_state_id_(ColumnStorage::Create()), 759| 434| irq_context_(ColumnStorage::Create()), 760| 434| utid_(ColumnStorage::Create()), 761| 434| waker_utid_(ColumnStorage::Create()) 762| |, 763| 434| id_storage_layer_(new column::IdStorage()), 764| 434| ts_storage_layer_( 765| 434| new column::NumericStorage( 766| 434| &ts_.vector(), 767| 434| ColumnTypeHelper::ToColumnType(), 768| 434| true)), 769| 434| thread_state_id_storage_layer_( 770| 434| new column::NumericStorage( 771| 434| &thread_state_id_.vector(), 772| 434| ColumnTypeHelper::ToColumnType(), 773| 434| false)), 774| 434| irq_context_storage_layer_( 775| 434| new column::NumericStorage( 776| 434| &irq_context_.non_null_vector(), 777| 434| ColumnTypeHelper::ToColumnType(), 778| 434| false)), 779| 434| utid_storage_layer_( 780| 434| new column::NumericStorage( 781| 434| &utid_.vector(), 782| 434| ColumnTypeHelper::ToColumnType(), 783| 434| false)), 784| 434| waker_utid_storage_layer_( 785| 434| new column::NumericStorage( 786| 434| &waker_utid_.vector(), 787| 434| ColumnTypeHelper::ToColumnType(), 788| 434| false)) 789| |, 790| 434| irq_context_null_layer_(new column::NullOverlay(irq_context_.bv())) { 791| 434| static_assert( 792| 434| ColumnLegacy::IsFlagsAndTypeValid( 793| 434| ColumnFlag::ts), 794| 434| "Column type and flag combination is not valid"); 795| 434| static_assert( 796| 434| ColumnLegacy::IsFlagsAndTypeValid( 797| 434| ColumnFlag::thread_state_id), 798| 434| "Column type and flag combination is not valid"); 799| 434| static_assert( 800| 434| ColumnLegacy::IsFlagsAndTypeValid( 801| 434| ColumnFlag::irq_context), 802| 434| "Column type and flag combination is not valid"); 803| 434| static_assert( 804| 434| ColumnLegacy::IsFlagsAndTypeValid( 805| 434| ColumnFlag::utid), 806| 434| "Column type and flag combination is not valid"); 807| 434| static_assert( 808| 434| ColumnLegacy::IsFlagsAndTypeValid( 809| 434| ColumnFlag::waker_utid), 810| 434| "Column type and flag combination is not valid"); 811| 434| OnConstructionCompletedRegularConstructor( 812| 434| {id_storage_layer_,ts_storage_layer_,thread_state_id_storage_layer_,irq_context_storage_layer_,utid_storage_layer_,waker_utid_storage_layer_}, 813| 434| {{},{},{},irq_context_null_layer_,{},{}}); 814| 434| } _ZN8perfetto15trace_processor6tables16ThreadStateTable10GetColumnsEPS2_PKNS0_15macros_internal10MacroTableE: 1272| 434| const macros_internal::MacroTable* parent) { 1273| 434| std::vector columns = 1274| 434| CopyColumnsFromParentOrAddRootColumns(parent); 1275| 434| uint32_t olay_idx = OverlayCount(parent); 1276| 434| AddColumnToVector(columns, "ts", &self->ts_, ColumnFlag::ts, 1277| 434| static_cast(columns.size()), olay_idx); 1278| 434| AddColumnToVector(columns, "dur", &self->dur_, ColumnFlag::dur, 1279| 434| static_cast(columns.size()), olay_idx); 1280| 434| AddColumnToVector(columns, "utid", &self->utid_, ColumnFlag::utid, 1281| 434| static_cast(columns.size()), olay_idx); 1282| 434| AddColumnToVector(columns, "state", &self->state_, ColumnFlag::state, 1283| 434| static_cast(columns.size()), olay_idx); 1284| 434| AddColumnToVector(columns, "io_wait", &self->io_wait_, ColumnFlag::io_wait, 1285| 434| static_cast(columns.size()), olay_idx); 1286| 434| AddColumnToVector(columns, "blocked_function", &self->blocked_function_, ColumnFlag::blocked_function, 1287| 434| static_cast(columns.size()), olay_idx); 1288| 434| AddColumnToVector(columns, "waker_utid", &self->waker_utid_, ColumnFlag::waker_utid, 1289| 434| static_cast(columns.size()), olay_idx); 1290| 434| AddColumnToVector(columns, "waker_id", &self->waker_id_, ColumnFlag::waker_id, 1291| 434| static_cast(columns.size()), olay_idx); 1292| 434| AddColumnToVector(columns, "irq_context", &self->irq_context_, ColumnFlag::irq_context, 1293| 434| static_cast(columns.size()), olay_idx); 1294| 434| AddColumnToVector(columns, "ucpu", &self->ucpu_, ColumnFlag::ucpu, 1295| 434| static_cast(columns.size()), olay_idx); 1296| 434| base::ignore_result(self); 1297| 434| return columns; 1298| 434| } _ZN8perfetto15trace_processor6tables16ThreadStateTableC2EPNS0_10StringPoolE: 1301| 434| : macros_internal::MacroTable( 1302| 434| pool, 1303| 434| GetColumns(this, nullptr), 1304| 434| nullptr), 1305| 434| ts_(ColumnStorage::Create()), 1306| 434| dur_(ColumnStorage::Create()), 1307| 434| utid_(ColumnStorage::Create()), 1308| 434| state_(ColumnStorage::Create()), 1309| 434| io_wait_(ColumnStorage::Create()), 1310| 434| blocked_function_(ColumnStorage::Create()), 1311| 434| waker_utid_(ColumnStorage::Create()), 1312| 434| waker_id_(ColumnStorage::Create()), 1313| 434| irq_context_(ColumnStorage::Create()), 1314| 434| ucpu_(ColumnStorage::Create()) 1315| |, 1316| 434| id_storage_layer_(new column::IdStorage()), 1317| 434| ts_storage_layer_( 1318| 434| new column::NumericStorage( 1319| 434| &ts_.vector(), 1320| 434| ColumnTypeHelper::ToColumnType(), 1321| 434| true)), 1322| 434| dur_storage_layer_( 1323| 434| new column::NumericStorage( 1324| 434| &dur_.vector(), 1325| 434| ColumnTypeHelper::ToColumnType(), 1326| 434| false)), 1327| 434| utid_storage_layer_( 1328| 434| new column::NumericStorage( 1329| 434| &utid_.vector(), 1330| 434| ColumnTypeHelper::ToColumnType(), 1331| 434| false)), 1332| 434| state_storage_layer_( 1333| 434| new column::StringStorage(string_pool(), &state_.vector())), 1334| 434| io_wait_storage_layer_( 1335| 434| new column::NumericStorage( 1336| 434| &io_wait_.non_null_vector(), 1337| 434| ColumnTypeHelper::ToColumnType(), 1338| 434| false)), 1339| 434| blocked_function_storage_layer_( 1340| 434| new column::StringStorage(string_pool(), &blocked_function_.vector())), 1341| 434| waker_utid_storage_layer_( 1342| 434| new column::NumericStorage( 1343| 434| &waker_utid_.non_null_vector(), 1344| 434| ColumnTypeHelper::ToColumnType(), 1345| 434| false)), 1346| 434| waker_id_storage_layer_( 1347| 434| new column::NumericStorage( 1348| 434| &waker_id_.non_null_vector(), 1349| 434| ColumnTypeHelper::ToColumnType(), 1350| 434| false)), 1351| 434| irq_context_storage_layer_( 1352| 434| new column::NumericStorage( 1353| 434| &irq_context_.non_null_vector(), 1354| 434| ColumnTypeHelper::ToColumnType(), 1355| 434| false)), 1356| 434| ucpu_storage_layer_( 1357| 434| new column::NumericStorage( 1358| 434| &ucpu_.non_null_vector(), 1359| 434| ColumnTypeHelper::ToColumnType(), 1360| 434| false)) 1361| |, 1362| 434| io_wait_null_layer_(new column::NullOverlay(io_wait_.bv())), 1363| 434| waker_utid_null_layer_(new column::NullOverlay(waker_utid_.bv())), 1364| 434| waker_id_null_layer_(new column::NullOverlay(waker_id_.bv())), 1365| 434| irq_context_null_layer_(new column::NullOverlay(irq_context_.bv())), 1366| 434| ucpu_null_layer_(new column::NullOverlay(ucpu_.bv())) { 1367| 434| static_assert( 1368| 434| ColumnLegacy::IsFlagsAndTypeValid( 1369| 434| ColumnFlag::ts), 1370| 434| "Column type and flag combination is not valid"); 1371| 434| static_assert( 1372| 434| ColumnLegacy::IsFlagsAndTypeValid( 1373| 434| ColumnFlag::dur), 1374| 434| "Column type and flag combination is not valid"); 1375| 434| static_assert( 1376| 434| ColumnLegacy::IsFlagsAndTypeValid( 1377| 434| ColumnFlag::utid), 1378| 434| "Column type and flag combination is not valid"); 1379| 434| static_assert( 1380| 434| ColumnLegacy::IsFlagsAndTypeValid( 1381| 434| ColumnFlag::state), 1382| 434| "Column type and flag combination is not valid"); 1383| 434| static_assert( 1384| 434| ColumnLegacy::IsFlagsAndTypeValid( 1385| 434| ColumnFlag::io_wait), 1386| 434| "Column type and flag combination is not valid"); 1387| 434| static_assert( 1388| 434| ColumnLegacy::IsFlagsAndTypeValid( 1389| 434| ColumnFlag::blocked_function), 1390| 434| "Column type and flag combination is not valid"); 1391| 434| static_assert( 1392| 434| ColumnLegacy::IsFlagsAndTypeValid( 1393| 434| ColumnFlag::waker_utid), 1394| 434| "Column type and flag combination is not valid"); 1395| 434| static_assert( 1396| 434| ColumnLegacy::IsFlagsAndTypeValid( 1397| 434| ColumnFlag::waker_id), 1398| 434| "Column type and flag combination is not valid"); 1399| 434| static_assert( 1400| 434| ColumnLegacy::IsFlagsAndTypeValid( 1401| 434| ColumnFlag::irq_context), 1402| 434| "Column type and flag combination is not valid"); 1403| 434| static_assert( 1404| 434| ColumnLegacy::IsFlagsAndTypeValid( 1405| 434| ColumnFlag::ucpu), 1406| 434| "Column type and flag combination is not valid"); 1407| 434| OnConstructionCompletedRegularConstructor( 1408| 434| {id_storage_layer_,ts_storage_layer_,dur_storage_layer_,utid_storage_layer_,state_storage_layer_,io_wait_storage_layer_,blocked_function_storage_layer_,waker_utid_storage_layer_,waker_id_storage_layer_,irq_context_storage_layer_,ucpu_storage_layer_}, 1409| 434| {{},{},{},{},{},io_wait_null_layer_,{},waker_utid_null_layer_,waker_id_null_layer_,irq_context_null_layer_,ucpu_null_layer_}); 1410| 434| } _ZN8perfetto15trace_processor6tables10SliceTable2IdC2Ej: 47| 2.22M| explicit constexpr Id(uint32_t v) : BaseId(v) {} _ZN8perfetto15trace_processor6tables10SliceTable3RowC2EllNS1_10TrackTable2IdENSt3__18optionalINS0_10StringPool2IdEEESA_jllNS7_INS2_2IdEEENS7_IjEENS7_IlEESE_SE_SE_Dn: 102| 748k| : macros_internal::RootParentTable::Row(), 103| 748k| ts(in_ts), 104| 748k| dur(in_dur), 105| 748k| track_id(in_track_id), 106| 748k| category(in_category), 107| 748k| name(in_name), 108| 748k| depth(in_depth), 109| 748k| stack_id(in_stack_id), 110| 748k| parent_stack_id(in_parent_stack_id), 111| 748k| parent_id(in_parent_id), 112| 748k| arg_set_id(in_arg_set_id), 113| 748k| thread_ts(in_thread_ts), 114| 748k| thread_dur(in_thread_dur), 115| 748k| thread_instruction_count(in_thread_instruction_count), 116| 748k| thread_instruction_delta(in_thread_instruction_delta) {} _ZN8perfetto15trace_processor6tables10SliceTable9RowNumberC2Ej: 174| 2.72M| : AbstractRowNumber(row_number) {} _ZN8perfetto15trace_processor6tables10SliceTable17ConstRowReferenceC2EPKS2_j: 183| 27.6M| : AbstractConstRowReference(table, row_number) {} _ZNK8perfetto15trace_processor6tables10SliceTable17ConstRowReference2idEv: 185| 1.47M| ColumnType::id::type id() const { 186| 1.47M| return table()->id()[row_number_]; 187| 1.47M| } _ZNK8perfetto15trace_processor6tables10SliceTable17ConstRowReference2tsEv: 188| 16.3M| ColumnType::ts::type ts() const { 189| 16.3M| return table()->ts()[row_number_]; 190| 16.3M| } _ZNK8perfetto15trace_processor6tables10SliceTable17ConstRowReference3durEv: 191| 16.4M| ColumnType::dur::type dur() const { 192| 16.4M| return table()->dur()[row_number_]; 193| 16.4M| } _ZNK8perfetto15trace_processor6tables10SliceTable17ConstRowReference8categoryEv: 197| 7.87M| ColumnType::category::type category() const { 198| 7.87M| return table()->category()[row_number_]; 199| 7.87M| } _ZNK8perfetto15trace_processor6tables10SliceTable17ConstRowReference4nameEv: 200| 7.74M| ColumnType::name::type name() const { 201| 7.74M| return table()->name()[row_number_]; 202| 7.74M| } _ZNK8perfetto15trace_processor6tables10SliceTable17ConstRowReference8stack_idEv: 206| 170k| ColumnType::stack_id::type stack_id() const { 207| 170k| return table()->stack_id()[row_number_]; 208| 170k| } _ZN8perfetto15trace_processor6tables10SliceTable12RowReferenceC2EPKS2_j: 236| 19.4M| : ConstRowReference(table, row_number) {} _ZN8perfetto15trace_processor6tables10SliceTable12RowReference7set_durEl: 243| 2.03k| ColumnType::dur::non_optional_type v) { 244| 2.03k| return mutable_table()->mutable_dur()->Set(row_number_, v); 245| 2.03k| } _ZN8perfetto15trace_processor6tables10SliceTable12RowReference9set_depthEj: 259| 731k| ColumnType::depth::non_optional_type v) { 260| 731k| return mutable_table()->mutable_depth()->Set(row_number_, v); 261| 731k| } _ZN8perfetto15trace_processor6tables10SliceTable12RowReference12set_stack_idEl: 263| 731k| ColumnType::stack_id::non_optional_type v) { 264| 731k| return mutable_table()->mutable_stack_id()->Set(row_number_, v); 265| 731k| } _ZN8perfetto15trace_processor6tables10SliceTable12RowReference19set_parent_stack_idEl: 267| 731k| ColumnType::parent_stack_id::non_optional_type v) { 268| 731k| return mutable_table()->mutable_parent_stack_id()->Set(row_number_, v); 269| 731k| } _ZN8perfetto15trace_processor6tables10SliceTable12RowReference13set_parent_idENS2_2IdE: 271| 154k| ColumnType::parent_id::non_optional_type v) { 272| 154k| return mutable_table()->mutable_parent_id()->Set(row_number_, v); 273| 154k| } _ZN8perfetto15trace_processor6tables10SliceTable12RowReference13set_thread_tsEl: 279| 1| ColumnType::thread_ts::non_optional_type v) { 280| 1| return mutable_table()->mutable_thread_ts()->Set(row_number_, v); 281| 1| } _ZN8perfetto15trace_processor6tables10SliceTable12RowReference14set_thread_durEl: 283| 1| ColumnType::thread_dur::non_optional_type v) { 284| 1| return mutable_table()->mutable_thread_dur()->Set(row_number_, v); 285| 1| } _ZN8perfetto15trace_processor6tables10SliceTable12RowReference28set_thread_instruction_countEl: 287| 1| ColumnType::thread_instruction_count::non_optional_type v) { 288| 1| return mutable_table()->mutable_thread_instruction_count()->Set(row_number_, v); 289| 1| } _ZN8perfetto15trace_processor6tables10SliceTable12RowReference28set_thread_instruction_deltaEl: 291| 1| ColumnType::thread_instruction_delta::non_optional_type v) { 292| 1| return mutable_table()->mutable_thread_instruction_delta()->Set(row_number_, v); 293| 1| } _ZNK8perfetto15trace_processor6tables10SliceTable12RowReference13mutable_tableEv: 296| 2.35M| SliceTable* mutable_table() const { 297| 2.35M| return const_cast(table()); 298| 2.35M| } _ZN8perfetto15trace_processor6tables10SliceTable10GetColumnsEPS2_PKNS0_15macros_internal10MacroTableE: 419| 434| const macros_internal::MacroTable* parent) { 420| 434| std::vector columns = 421| 434| CopyColumnsFromParentOrAddRootColumns(parent); 422| 434| uint32_t olay_idx = OverlayCount(parent); 423| 434| AddColumnToVector(columns, "ts", &self->ts_, ColumnFlag::ts, 424| 434| static_cast(columns.size()), olay_idx); 425| 434| AddColumnToVector(columns, "dur", &self->dur_, ColumnFlag::dur, 426| 434| static_cast(columns.size()), olay_idx); 427| 434| AddColumnToVector(columns, "track_id", &self->track_id_, ColumnFlag::track_id, 428| 434| static_cast(columns.size()), olay_idx); 429| 434| AddColumnToVector(columns, "category", &self->category_, ColumnFlag::category, 430| 434| static_cast(columns.size()), olay_idx); 431| 434| AddColumnToVector(columns, "name", &self->name_, ColumnFlag::name, 432| 434| static_cast(columns.size()), olay_idx); 433| 434| AddColumnToVector(columns, "depth", &self->depth_, ColumnFlag::depth, 434| 434| static_cast(columns.size()), olay_idx); 435| 434| AddColumnToVector(columns, "stack_id", &self->stack_id_, ColumnFlag::stack_id, 436| 434| static_cast(columns.size()), olay_idx); 437| 434| AddColumnToVector(columns, "parent_stack_id", &self->parent_stack_id_, ColumnFlag::parent_stack_id, 438| 434| static_cast(columns.size()), olay_idx); 439| 434| AddColumnToVector(columns, "parent_id", &self->parent_id_, ColumnFlag::parent_id, 440| 434| static_cast(columns.size()), olay_idx); 441| 434| AddColumnToVector(columns, "arg_set_id", &self->arg_set_id_, ColumnFlag::arg_set_id, 442| 434| static_cast(columns.size()), olay_idx); 443| 434| AddColumnToVector(columns, "thread_ts", &self->thread_ts_, ColumnFlag::thread_ts, 444| 434| static_cast(columns.size()), olay_idx); 445| 434| AddColumnToVector(columns, "thread_dur", &self->thread_dur_, ColumnFlag::thread_dur, 446| 434| static_cast(columns.size()), olay_idx); 447| 434| AddColumnToVector(columns, "thread_instruction_count", &self->thread_instruction_count_, ColumnFlag::thread_instruction_count, 448| 434| static_cast(columns.size()), olay_idx); 449| 434| AddColumnToVector(columns, "thread_instruction_delta", &self->thread_instruction_delta_, ColumnFlag::thread_instruction_delta, 450| 434| static_cast(columns.size()), olay_idx); 451| 434| base::ignore_result(self); 452| 434| return columns; 453| 434| } _ZN8perfetto15trace_processor6tables10SliceTableC2EPNS0_10StringPoolE: 456| 434| : macros_internal::MacroTable( 457| 434| pool, 458| 434| GetColumns(this, nullptr), 459| 434| nullptr), 460| 434| ts_(ColumnStorage::Create()), 461| 434| dur_(ColumnStorage::Create()), 462| 434| track_id_(ColumnStorage::Create()), 463| 434| category_(ColumnStorage::Create()), 464| 434| name_(ColumnStorage::Create()), 465| 434| depth_(ColumnStorage::Create()), 466| 434| stack_id_(ColumnStorage::Create()), 467| 434| parent_stack_id_(ColumnStorage::Create()), 468| 434| parent_id_(ColumnStorage::Create()), 469| 434| arg_set_id_(ColumnStorage::Create()), 470| 434| thread_ts_(ColumnStorage::Create()), 471| 434| thread_dur_(ColumnStorage::Create()), 472| 434| thread_instruction_count_(ColumnStorage::Create()), 473| 434| thread_instruction_delta_(ColumnStorage::Create()) 474| |, 475| 434| id_storage_layer_(new column::IdStorage()), 476| 434| ts_storage_layer_( 477| 434| new column::NumericStorage( 478| 434| &ts_.vector(), 479| 434| ColumnTypeHelper::ToColumnType(), 480| 434| true)), 481| 434| dur_storage_layer_( 482| 434| new column::NumericStorage( 483| 434| &dur_.vector(), 484| 434| ColumnTypeHelper::ToColumnType(), 485| 434| false)), 486| 434| track_id_storage_layer_( 487| 434| new column::NumericStorage( 488| 434| &track_id_.vector(), 489| 434| ColumnTypeHelper::ToColumnType(), 490| 434| false)), 491| 434| category_storage_layer_( 492| 434| new column::StringStorage(string_pool(), &category_.vector())), 493| 434| name_storage_layer_( 494| 434| new column::StringStorage(string_pool(), &name_.vector())), 495| 434| depth_storage_layer_( 496| 434| new column::NumericStorage( 497| 434| &depth_.vector(), 498| 434| ColumnTypeHelper::ToColumnType(), 499| 434| false)), 500| 434| stack_id_storage_layer_( 501| 434| new column::NumericStorage( 502| 434| &stack_id_.vector(), 503| 434| ColumnTypeHelper::ToColumnType(), 504| 434| false)), 505| 434| parent_stack_id_storage_layer_( 506| 434| new column::NumericStorage( 507| 434| &parent_stack_id_.vector(), 508| 434| ColumnTypeHelper::ToColumnType(), 509| 434| false)), 510| 434| parent_id_storage_layer_( 511| 434| new column::NumericStorage( 512| 434| &parent_id_.non_null_vector(), 513| 434| ColumnTypeHelper::ToColumnType(), 514| 434| false)), 515| 434| arg_set_id_storage_layer_( 516| 434| new column::NumericStorage( 517| 434| &arg_set_id_.non_null_vector(), 518| 434| ColumnTypeHelper::ToColumnType(), 519| 434| false)), 520| 434| thread_ts_storage_layer_( 521| 434| new column::NumericStorage( 522| 434| &thread_ts_.non_null_vector(), 523| 434| ColumnTypeHelper::ToColumnType(), 524| 434| false)), 525| 434| thread_dur_storage_layer_( 526| 434| new column::NumericStorage( 527| 434| &thread_dur_.non_null_vector(), 528| 434| ColumnTypeHelper::ToColumnType(), 529| 434| false)), 530| 434| thread_instruction_count_storage_layer_( 531| 434| new column::NumericStorage( 532| 434| &thread_instruction_count_.non_null_vector(), 533| 434| ColumnTypeHelper::ToColumnType(), 534| 434| false)), 535| 434| thread_instruction_delta_storage_layer_( 536| 434| new column::NumericStorage( 537| 434| &thread_instruction_delta_.non_null_vector(), 538| 434| ColumnTypeHelper::ToColumnType(), 539| 434| false)) 540| |, 541| 434| parent_id_null_layer_(new column::NullOverlay(parent_id_.bv())), 542| 434| arg_set_id_null_layer_(new column::NullOverlay(arg_set_id_.bv())), 543| 434| thread_ts_null_layer_(new column::NullOverlay(thread_ts_.bv())), 544| 434| thread_dur_null_layer_(new column::NullOverlay(thread_dur_.bv())), 545| 434| thread_instruction_count_null_layer_(new column::NullOverlay(thread_instruction_count_.bv())), 546| 434| thread_instruction_delta_null_layer_(new column::NullOverlay(thread_instruction_delta_.bv())) { 547| 434| static_assert( 548| 434| ColumnLegacy::IsFlagsAndTypeValid( 549| 434| ColumnFlag::ts), 550| 434| "Column type and flag combination is not valid"); 551| 434| static_assert( 552| 434| ColumnLegacy::IsFlagsAndTypeValid( 553| 434| ColumnFlag::dur), 554| 434| "Column type and flag combination is not valid"); 555| 434| static_assert( 556| 434| ColumnLegacy::IsFlagsAndTypeValid( 557| 434| ColumnFlag::track_id), 558| 434| "Column type and flag combination is not valid"); 559| 434| static_assert( 560| 434| ColumnLegacy::IsFlagsAndTypeValid( 561| 434| ColumnFlag::category), 562| 434| "Column type and flag combination is not valid"); 563| 434| static_assert( 564| 434| ColumnLegacy::IsFlagsAndTypeValid( 565| 434| ColumnFlag::name), 566| 434| "Column type and flag combination is not valid"); 567| 434| static_assert( 568| 434| ColumnLegacy::IsFlagsAndTypeValid( 569| 434| ColumnFlag::depth), 570| 434| "Column type and flag combination is not valid"); 571| 434| static_assert( 572| 434| ColumnLegacy::IsFlagsAndTypeValid( 573| 434| ColumnFlag::stack_id), 574| 434| "Column type and flag combination is not valid"); 575| 434| static_assert( 576| 434| ColumnLegacy::IsFlagsAndTypeValid( 577| 434| ColumnFlag::parent_stack_id), 578| 434| "Column type and flag combination is not valid"); 579| 434| static_assert( 580| 434| ColumnLegacy::IsFlagsAndTypeValid( 581| 434| ColumnFlag::parent_id), 582| 434| "Column type and flag combination is not valid"); 583| 434| static_assert( 584| 434| ColumnLegacy::IsFlagsAndTypeValid( 585| 434| ColumnFlag::arg_set_id), 586| 434| "Column type and flag combination is not valid"); 587| 434| static_assert( 588| 434| ColumnLegacy::IsFlagsAndTypeValid( 589| 434| ColumnFlag::thread_ts), 590| 434| "Column type and flag combination is not valid"); 591| 434| static_assert( 592| 434| ColumnLegacy::IsFlagsAndTypeValid( 593| 434| ColumnFlag::thread_dur), 594| 434| "Column type and flag combination is not valid"); 595| 434| static_assert( 596| 434| ColumnLegacy::IsFlagsAndTypeValid( 597| 434| ColumnFlag::thread_instruction_count), 598| 434| "Column type and flag combination is not valid"); 599| 434| static_assert( 600| 434| ColumnLegacy::IsFlagsAndTypeValid( 601| 434| ColumnFlag::thread_instruction_delta), 602| 434| "Column type and flag combination is not valid"); 603| 434| OnConstructionCompletedRegularConstructor( 604| 434| {id_storage_layer_,ts_storage_layer_,dur_storage_layer_,track_id_storage_layer_,category_storage_layer_,name_storage_layer_,depth_storage_layer_,stack_id_storage_layer_,parent_stack_id_storage_layer_,parent_id_storage_layer_,arg_set_id_storage_layer_,thread_ts_storage_layer_,thread_dur_storage_layer_,thread_instruction_count_storage_layer_,thread_instruction_delta_storage_layer_}, 605| 434| {{},{},{},{},{},{},{},{},{},parent_id_null_layer_,arg_set_id_null_layer_,thread_ts_null_layer_,thread_dur_null_layer_,thread_instruction_count_null_layer_,thread_instruction_delta_null_layer_}); 606| 434| } _ZN8perfetto15trace_processor6tables10SliceTable8FindByIdENS2_2IdE: 736| 1.99M| std::optional FindById(Id find_id) { 737| 1.99M| std::optional row = id().IndexOf(find_id); 738| 1.99M| return row ? std::make_optional(RowReference(this, *row)) : std::nullopt; ------------------ | Branch (738:12): [True: 1.99M, False: 0] ------------------ 739| 1.99M| } _ZN8perfetto15trace_processor6tables10SliceTable6InsertERKNS2_3RowE: 741| 748k| IdAndRow Insert(const Row& row) { 742| 748k| uint32_t row_number = row_count(); 743| 748k| Id id = Id{row_number}; 744| 748k| mutable_ts()->Append(row.ts); 745| 748k| mutable_dur()->Append(row.dur); 746| 748k| mutable_track_id()->Append(row.track_id); 747| 748k| mutable_category()->Append(row.category); 748| 748k| mutable_name()->Append(row.name); 749| 748k| mutable_depth()->Append(row.depth); 750| 748k| mutable_stack_id()->Append(row.stack_id); 751| 748k| mutable_parent_stack_id()->Append(row.parent_stack_id); 752| 748k| mutable_parent_id()->Append(row.parent_id); 753| 748k| mutable_arg_set_id()->Append(row.arg_set_id); 754| 748k| mutable_thread_ts()->Append(row.thread_ts); 755| 748k| mutable_thread_dur()->Append(row.thread_dur); 756| 748k| mutable_thread_instruction_count()->Append(row.thread_instruction_count); 757| 748k| mutable_thread_instruction_delta()->Append(row.thread_instruction_delta); 758| 748k| UpdateSelfOverlayAfterInsert(); 759| 748k| return IdAndRow{id, row_number, RowReference(this, row_number), 760| 748k| RowNumber(row_number)}; 761| 748k| } _ZNK8perfetto15trace_processor6tables10SliceTable2idEv: 765| 3.47M| const IdColumn& id() const { 766| 3.47M| return static_cast(columns()[ColumnIndex::id]); 767| 3.47M| } _ZNK8perfetto15trace_processor6tables10SliceTable2tsEv: 768| 16.3M| const TypedColumn& ts() const { 769| 16.3M| return static_cast(columns()[ColumnIndex::ts]); 770| 16.3M| } _ZNK8perfetto15trace_processor6tables10SliceTable3durEv: 771| 16.4M| const TypedColumn& dur() const { 772| 16.4M| return static_cast(columns()[ColumnIndex::dur]); 773| 16.4M| } _ZNK8perfetto15trace_processor6tables10SliceTable8categoryEv: 777| 7.87M| const TypedColumn>& category() const { 778| 7.87M| return static_cast(columns()[ColumnIndex::category]); 779| 7.87M| } _ZNK8perfetto15trace_processor6tables10SliceTable4nameEv: 780| 7.74M| const TypedColumn>& name() const { 781| 7.74M| return static_cast(columns()[ColumnIndex::name]); 782| 7.74M| } _ZNK8perfetto15trace_processor6tables10SliceTable8stack_idEv: 786| 170k| const TypedColumn& stack_id() const { 787| 170k| return static_cast(columns()[ColumnIndex::stack_id]); 788| 170k| } _ZNK8perfetto15trace_processor6tables10SliceTable10arg_set_idEv: 795| 518k| const TypedColumn>& arg_set_id() const { 796| 518k| return static_cast(columns()[ColumnIndex::arg_set_id]); 797| 518k| } _ZN8perfetto15trace_processor6tables10SliceTable10mutable_tsEv: 811| 748k| TypedColumn* mutable_ts() { 812| 748k| return static_cast( 813| 748k| GetColumn(ColumnIndex::ts)); 814| 748k| } _ZN8perfetto15trace_processor6tables10SliceTable11mutable_durEv: 815| 750k| TypedColumn* mutable_dur() { 816| 750k| return static_cast( 817| 750k| GetColumn(ColumnIndex::dur)); 818| 750k| } _ZN8perfetto15trace_processor6tables10SliceTable16mutable_track_idEv: 819| 748k| TypedColumn* mutable_track_id() { 820| 748k| return static_cast( 821| 748k| GetColumn(ColumnIndex::track_id)); 822| 748k| } _ZN8perfetto15trace_processor6tables10SliceTable16mutable_categoryEv: 823| 748k| TypedColumn>* mutable_category() { 824| 748k| return static_cast( 825| 748k| GetColumn(ColumnIndex::category)); 826| 748k| } _ZN8perfetto15trace_processor6tables10SliceTable12mutable_nameEv: 827| 748k| TypedColumn>* mutable_name() { 828| 748k| return static_cast( 829| 748k| GetColumn(ColumnIndex::name)); 830| 748k| } _ZN8perfetto15trace_processor6tables10SliceTable13mutable_depthEv: 831| 1.47M| TypedColumn* mutable_depth() { 832| 1.47M| return static_cast( 833| 1.47M| GetColumn(ColumnIndex::depth)); 834| 1.47M| } _ZN8perfetto15trace_processor6tables10SliceTable16mutable_stack_idEv: 835| 1.47M| TypedColumn* mutable_stack_id() { 836| 1.47M| return static_cast( 837| 1.47M| GetColumn(ColumnIndex::stack_id)); 838| 1.47M| } _ZN8perfetto15trace_processor6tables10SliceTable23mutable_parent_stack_idEv: 839| 1.47M| TypedColumn* mutable_parent_stack_id() { 840| 1.47M| return static_cast( 841| 1.47M| GetColumn(ColumnIndex::parent_stack_id)); 842| 1.47M| } _ZN8perfetto15trace_processor6tables10SliceTable17mutable_parent_idEv: 843| 902k| TypedColumn>* mutable_parent_id() { 844| 902k| return static_cast( 845| 902k| GetColumn(ColumnIndex::parent_id)); 846| 902k| } _ZN8perfetto15trace_processor6tables10SliceTable18mutable_arg_set_idEv: 847| 1.99M| TypedColumn>* mutable_arg_set_id() { 848| 1.99M| return static_cast( 849| 1.99M| GetColumn(ColumnIndex::arg_set_id)); 850| 1.99M| } _ZN8perfetto15trace_processor6tables10SliceTable17mutable_thread_tsEv: 851| 748k| TypedColumn>* mutable_thread_ts() { 852| 748k| return static_cast( 853| 748k| GetColumn(ColumnIndex::thread_ts)); 854| 748k| } _ZN8perfetto15trace_processor6tables10SliceTable18mutable_thread_durEv: 855| 748k| TypedColumn>* mutable_thread_dur() { 856| 748k| return static_cast( 857| 748k| GetColumn(ColumnIndex::thread_dur)); 858| 748k| } _ZN8perfetto15trace_processor6tables10SliceTable32mutable_thread_instruction_countEv: 859| 748k| TypedColumn>* mutable_thread_instruction_count() { 860| 748k| return static_cast( 861| 748k| GetColumn(ColumnIndex::thread_instruction_count)); 862| 748k| } _ZN8perfetto15trace_processor6tables10SliceTable32mutable_thread_instruction_deltaEv: 863| 748k| TypedColumn>* mutable_thread_instruction_delta() { 864| 748k| return static_cast( 865| 748k| GetColumn(ColumnIndex::thread_instruction_delta)); 866| 748k| } _ZN8perfetto15trace_processor6tables26AndroidNetworkPacketsTable10GetColumnsEPS2_PKNS0_15macros_internal10MacroTableE: 1508| 434| const macros_internal::MacroTable* parent) { 1509| 434| std::vector columns = 1510| 434| CopyColumnsFromParentOrAddRootColumns(parent); 1511| 434| uint32_t olay_idx = OverlayCount(parent); 1512| 434| AddColumnToVector(columns, "iface", &self->iface_, ColumnFlag::iface, 1513| 434| static_cast(columns.size()), olay_idx); 1514| 434| AddColumnToVector(columns, "direction", &self->direction_, ColumnFlag::direction, 1515| 434| static_cast(columns.size()), olay_idx); 1516| 434| AddColumnToVector(columns, "packet_transport", &self->packet_transport_, ColumnFlag::packet_transport, 1517| 434| static_cast(columns.size()), olay_idx); 1518| 434| AddColumnToVector(columns, "packet_length", &self->packet_length_, ColumnFlag::packet_length, 1519| 434| static_cast(columns.size()), olay_idx); 1520| 434| AddColumnToVector(columns, "packet_count", &self->packet_count_, ColumnFlag::packet_count, 1521| 434| static_cast(columns.size()), olay_idx); 1522| 434| AddColumnToVector(columns, "socket_tag", &self->socket_tag_, ColumnFlag::socket_tag, 1523| 434| static_cast(columns.size()), olay_idx); 1524| 434| AddColumnToVector(columns, "socket_tag_str", &self->socket_tag_str_, ColumnFlag::socket_tag_str, 1525| 434| static_cast(columns.size()), olay_idx); 1526| 434| AddColumnToVector(columns, "socket_uid", &self->socket_uid_, ColumnFlag::socket_uid, 1527| 434| static_cast(columns.size()), olay_idx); 1528| 434| AddColumnToVector(columns, "local_port", &self->local_port_, ColumnFlag::local_port, 1529| 434| static_cast(columns.size()), olay_idx); 1530| 434| AddColumnToVector(columns, "remote_port", &self->remote_port_, ColumnFlag::remote_port, 1531| 434| static_cast(columns.size()), olay_idx); 1532| 434| AddColumnToVector(columns, "packet_icmp_type", &self->packet_icmp_type_, ColumnFlag::packet_icmp_type, 1533| 434| static_cast(columns.size()), olay_idx); 1534| 434| AddColumnToVector(columns, "packet_icmp_code", &self->packet_icmp_code_, ColumnFlag::packet_icmp_code, 1535| 434| static_cast(columns.size()), olay_idx); 1536| 434| AddColumnToVector(columns, "packet_tcp_flags", &self->packet_tcp_flags_, ColumnFlag::packet_tcp_flags, 1537| 434| static_cast(columns.size()), olay_idx); 1538| 434| AddColumnToVector(columns, "packet_tcp_flags_str", &self->packet_tcp_flags_str_, ColumnFlag::packet_tcp_flags_str, 1539| 434| static_cast(columns.size()), olay_idx); 1540| 434| base::ignore_result(self); 1541| 434| return columns; 1542| 434| } _ZN8perfetto15trace_processor6tables26AndroidNetworkPacketsTableC2EPNS0_10StringPoolEPNS1_10SliceTableE: 1545| 434| : macros_internal::MacroTable( 1546| 434| pool, 1547| 434| GetColumns(this, parent), 1548| 434| parent), 1549| 434| parent_(parent), const_parent_(parent), iface_(ColumnStorage::Create()), 1550| 434| direction_(ColumnStorage::Create()), 1551| 434| packet_transport_(ColumnStorage::Create()), 1552| 434| packet_length_(ColumnStorage::Create()), 1553| 434| packet_count_(ColumnStorage::Create()), 1554| 434| socket_tag_(ColumnStorage::Create()), 1555| 434| socket_tag_str_(ColumnStorage::Create()), 1556| 434| socket_uid_(ColumnStorage::Create()), 1557| 434| local_port_(ColumnStorage::Create()), 1558| 434| remote_port_(ColumnStorage::Create()), 1559| 434| packet_icmp_type_(ColumnStorage::Create()), 1560| 434| packet_icmp_code_(ColumnStorage::Create()), 1561| 434| packet_tcp_flags_(ColumnStorage::Create()), 1562| 434| packet_tcp_flags_str_(ColumnStorage::Create()) 1563| |, 1564| 434| iface_storage_layer_( 1565| 434| new column::StringStorage(string_pool(), &iface_.vector())), 1566| 434| direction_storage_layer_( 1567| 434| new column::StringStorage(string_pool(), &direction_.vector())), 1568| 434| packet_transport_storage_layer_( 1569| 434| new column::StringStorage(string_pool(), &packet_transport_.vector())), 1570| 434| packet_length_storage_layer_( 1571| 434| new column::NumericStorage( 1572| 434| &packet_length_.vector(), 1573| 434| ColumnTypeHelper::ToColumnType(), 1574| 434| false)), 1575| 434| packet_count_storage_layer_( 1576| 434| new column::NumericStorage( 1577| 434| &packet_count_.vector(), 1578| 434| ColumnTypeHelper::ToColumnType(), 1579| 434| false)), 1580| 434| socket_tag_storage_layer_( 1581| 434| new column::NumericStorage( 1582| 434| &socket_tag_.vector(), 1583| 434| ColumnTypeHelper::ToColumnType(), 1584| 434| false)), 1585| 434| socket_tag_str_storage_layer_( 1586| 434| new column::StringStorage(string_pool(), &socket_tag_str_.vector())), 1587| 434| socket_uid_storage_layer_( 1588| 434| new column::NumericStorage( 1589| 434| &socket_uid_.vector(), 1590| 434| ColumnTypeHelper::ToColumnType(), 1591| 434| false)), 1592| 434| local_port_storage_layer_( 1593| 434| new column::NumericStorage( 1594| 434| &local_port_.non_null_vector(), 1595| 434| ColumnTypeHelper::ToColumnType(), 1596| 434| false)), 1597| 434| remote_port_storage_layer_( 1598| 434| new column::NumericStorage( 1599| 434| &remote_port_.non_null_vector(), 1600| 434| ColumnTypeHelper::ToColumnType(), 1601| 434| false)), 1602| 434| packet_icmp_type_storage_layer_( 1603| 434| new column::NumericStorage( 1604| 434| &packet_icmp_type_.non_null_vector(), 1605| 434| ColumnTypeHelper::ToColumnType(), 1606| 434| false)), 1607| 434| packet_icmp_code_storage_layer_( 1608| 434| new column::NumericStorage( 1609| 434| &packet_icmp_code_.non_null_vector(), 1610| 434| ColumnTypeHelper::ToColumnType(), 1611| 434| false)), 1612| 434| packet_tcp_flags_storage_layer_( 1613| 434| new column::NumericStorage( 1614| 434| &packet_tcp_flags_.non_null_vector(), 1615| 434| ColumnTypeHelper::ToColumnType(), 1616| 434| false)), 1617| 434| packet_tcp_flags_str_storage_layer_( 1618| 434| new column::StringStorage(string_pool(), &packet_tcp_flags_str_.vector())) 1619| |, 1620| 434| local_port_null_layer_(new column::NullOverlay(local_port_.bv())), 1621| 434| remote_port_null_layer_(new column::NullOverlay(remote_port_.bv())), 1622| 434| packet_icmp_type_null_layer_(new column::NullOverlay(packet_icmp_type_.bv())), 1623| 434| packet_icmp_code_null_layer_(new column::NullOverlay(packet_icmp_code_.bv())), 1624| 434| packet_tcp_flags_null_layer_(new column::NullOverlay(packet_tcp_flags_.bv())) { 1625| 434| static_assert( 1626| 434| ColumnLegacy::IsFlagsAndTypeValid( 1627| 434| ColumnFlag::iface), 1628| 434| "Column type and flag combination is not valid"); 1629| 434| static_assert( 1630| 434| ColumnLegacy::IsFlagsAndTypeValid( 1631| 434| ColumnFlag::direction), 1632| 434| "Column type and flag combination is not valid"); 1633| 434| static_assert( 1634| 434| ColumnLegacy::IsFlagsAndTypeValid( 1635| 434| ColumnFlag::packet_transport), 1636| 434| "Column type and flag combination is not valid"); 1637| 434| static_assert( 1638| 434| ColumnLegacy::IsFlagsAndTypeValid( 1639| 434| ColumnFlag::packet_length), 1640| 434| "Column type and flag combination is not valid"); 1641| 434| static_assert( 1642| 434| ColumnLegacy::IsFlagsAndTypeValid( 1643| 434| ColumnFlag::packet_count), 1644| 434| "Column type and flag combination is not valid"); 1645| 434| static_assert( 1646| 434| ColumnLegacy::IsFlagsAndTypeValid( 1647| 434| ColumnFlag::socket_tag), 1648| 434| "Column type and flag combination is not valid"); 1649| 434| static_assert( 1650| 434| ColumnLegacy::IsFlagsAndTypeValid( 1651| 434| ColumnFlag::socket_tag_str), 1652| 434| "Column type and flag combination is not valid"); 1653| 434| static_assert( 1654| 434| ColumnLegacy::IsFlagsAndTypeValid( 1655| 434| ColumnFlag::socket_uid), 1656| 434| "Column type and flag combination is not valid"); 1657| 434| static_assert( 1658| 434| ColumnLegacy::IsFlagsAndTypeValid( 1659| 434| ColumnFlag::local_port), 1660| 434| "Column type and flag combination is not valid"); 1661| 434| static_assert( 1662| 434| ColumnLegacy::IsFlagsAndTypeValid( 1663| 434| ColumnFlag::remote_port), 1664| 434| "Column type and flag combination is not valid"); 1665| 434| static_assert( 1666| 434| ColumnLegacy::IsFlagsAndTypeValid( 1667| 434| ColumnFlag::packet_icmp_type), 1668| 434| "Column type and flag combination is not valid"); 1669| 434| static_assert( 1670| 434| ColumnLegacy::IsFlagsAndTypeValid( 1671| 434| ColumnFlag::packet_icmp_code), 1672| 434| "Column type and flag combination is not valid"); 1673| 434| static_assert( 1674| 434| ColumnLegacy::IsFlagsAndTypeValid( 1675| 434| ColumnFlag::packet_tcp_flags), 1676| 434| "Column type and flag combination is not valid"); 1677| 434| static_assert( 1678| 434| ColumnLegacy::IsFlagsAndTypeValid( 1679| 434| ColumnFlag::packet_tcp_flags_str), 1680| 434| "Column type and flag combination is not valid"); 1681| 434| OnConstructionCompletedRegularConstructor( 1682| 434| {const_parent_->storage_layers()[ColumnIndex::id],const_parent_->storage_layers()[ColumnIndex::ts],const_parent_->storage_layers()[ColumnIndex::dur],const_parent_->storage_layers()[ColumnIndex::track_id],const_parent_->storage_layers()[ColumnIndex::category],const_parent_->storage_layers()[ColumnIndex::name],const_parent_->storage_layers()[ColumnIndex::depth],const_parent_->storage_layers()[ColumnIndex::stack_id],const_parent_->storage_layers()[ColumnIndex::parent_stack_id],const_parent_->storage_layers()[ColumnIndex::parent_id],const_parent_->storage_layers()[ColumnIndex::arg_set_id],const_parent_->storage_layers()[ColumnIndex::thread_ts],const_parent_->storage_layers()[ColumnIndex::thread_dur],const_parent_->storage_layers()[ColumnIndex::thread_instruction_count],const_parent_->storage_layers()[ColumnIndex::thread_instruction_delta],iface_storage_layer_,direction_storage_layer_,packet_transport_storage_layer_,packet_length_storage_layer_,packet_count_storage_layer_,socket_tag_storage_layer_,socket_tag_str_storage_layer_,socket_uid_storage_layer_,local_port_storage_layer_,remote_port_storage_layer_,packet_icmp_type_storage_layer_,packet_icmp_code_storage_layer_,packet_tcp_flags_storage_layer_,packet_tcp_flags_str_storage_layer_}, 1683| 434| {{},{},{},{},{},{},{},{},{},const_parent_->null_layers()[ColumnIndex::parent_id],const_parent_->null_layers()[ColumnIndex::arg_set_id],const_parent_->null_layers()[ColumnIndex::thread_ts],const_parent_->null_layers()[ColumnIndex::thread_dur],const_parent_->null_layers()[ColumnIndex::thread_instruction_count],const_parent_->null_layers()[ColumnIndex::thread_instruction_delta],{},{},{},{},{},{},{},{},local_port_null_layer_,remote_port_null_layer_,packet_icmp_type_null_layer_,packet_icmp_code_null_layer_,packet_tcp_flags_null_layer_,{}}); 1684| 434| } _ZN8perfetto15trace_processor6tables26ExperimentalProtoPathTable10GetColumnsEPS2_PKNS0_15macros_internal10MacroTableE: 229| 434| const macros_internal::MacroTable* parent) { 230| 434| std::vector columns = 231| 434| CopyColumnsFromParentOrAddRootColumns(parent); 232| 434| uint32_t olay_idx = OverlayCount(parent); 233| 434| AddColumnToVector(columns, "parent_id", &self->parent_id_, ColumnFlag::parent_id, 234| 434| static_cast(columns.size()), olay_idx); 235| 434| AddColumnToVector(columns, "field_type", &self->field_type_, ColumnFlag::field_type, 236| 434| static_cast(columns.size()), olay_idx); 237| 434| AddColumnToVector(columns, "field_name", &self->field_name_, ColumnFlag::field_name, 238| 434| static_cast(columns.size()), olay_idx); 239| 434| AddColumnToVector(columns, "arg_set_id", &self->arg_set_id_, ColumnFlag::arg_set_id, 240| 434| static_cast(columns.size()), olay_idx); 241| 434| base::ignore_result(self); 242| 434| return columns; 243| 434| } _ZN8perfetto15trace_processor6tables26ExperimentalProtoPathTableC2EPNS0_10StringPoolE: 246| 434| : macros_internal::MacroTable( 247| 434| pool, 248| 434| GetColumns(this, nullptr), 249| 434| nullptr), 250| 434| parent_id_(ColumnStorage::Create()), 251| 434| field_type_(ColumnStorage::Create()), 252| 434| field_name_(ColumnStorage::Create()), 253| 434| arg_set_id_(ColumnStorage::Create()) 254| |, 255| 434| id_storage_layer_(new column::IdStorage()), 256| 434| parent_id_storage_layer_( 257| 434| new column::NumericStorage( 258| 434| &parent_id_.non_null_vector(), 259| 434| ColumnTypeHelper::ToColumnType(), 260| 434| false)), 261| 434| field_type_storage_layer_( 262| 434| new column::StringStorage(string_pool(), &field_type_.vector())), 263| 434| field_name_storage_layer_( 264| 434| new column::StringStorage(string_pool(), &field_name_.vector())), 265| 434| arg_set_id_storage_layer_( 266| 434| new column::NumericStorage( 267| 434| &arg_set_id_.non_null_vector(), 268| 434| ColumnTypeHelper::ToColumnType(), 269| 434| false)) 270| |, 271| 434| parent_id_null_layer_(new column::NullOverlay(parent_id_.bv())), 272| 434| arg_set_id_null_layer_(new column::NullOverlay(arg_set_id_.bv())) { 273| 434| static_assert( 274| 434| ColumnLegacy::IsFlagsAndTypeValid( 275| 434| ColumnFlag::parent_id), 276| 434| "Column type and flag combination is not valid"); 277| 434| static_assert( 278| 434| ColumnLegacy::IsFlagsAndTypeValid( 279| 434| ColumnFlag::field_type), 280| 434| "Column type and flag combination is not valid"); 281| 434| static_assert( 282| 434| ColumnLegacy::IsFlagsAndTypeValid( 283| 434| ColumnFlag::field_name), 284| 434| "Column type and flag combination is not valid"); 285| 434| static_assert( 286| 434| ColumnLegacy::IsFlagsAndTypeValid( 287| 434| ColumnFlag::arg_set_id), 288| 434| "Column type and flag combination is not valid"); 289| 434| OnConstructionCompletedRegularConstructor( 290| 434| {id_storage_layer_,parent_id_storage_layer_,field_type_storage_layer_,field_name_storage_layer_,arg_set_id_storage_layer_}, 291| 434| {{},parent_id_null_layer_,{},{},arg_set_id_null_layer_}); 292| 434| } _ZN8perfetto15trace_processor6tables29ExperimentalProtoContentTable10GetColumnsEPS2_PKNS0_15macros_internal10MacroTableE: 640| 434| const macros_internal::MacroTable* parent) { 641| 434| std::vector columns = 642| 434| CopyColumnsFromParentOrAddRootColumns(parent); 643| 434| uint32_t olay_idx = OverlayCount(parent); 644| 434| AddColumnToVector(columns, "path", &self->path_, ColumnFlag::path, 645| 434| static_cast(columns.size()), olay_idx); 646| 434| AddColumnToVector(columns, "path_id", &self->path_id_, ColumnFlag::path_id, 647| 434| static_cast(columns.size()), olay_idx); 648| 434| AddColumnToVector(columns, "total_size", &self->total_size_, ColumnFlag::total_size, 649| 434| static_cast(columns.size()), olay_idx); 650| 434| AddColumnToVector(columns, "size", &self->size_, ColumnFlag::size, 651| 434| static_cast(columns.size()), olay_idx); 652| 434| AddColumnToVector(columns, "count", &self->count_, ColumnFlag::count, 653| 434| static_cast(columns.size()), olay_idx); 654| 434| base::ignore_result(self); 655| 434| return columns; 656| 434| } _ZN8perfetto15trace_processor6tables29ExperimentalProtoContentTableC2EPNS0_10StringPoolE: 659| 434| : macros_internal::MacroTable( 660| 434| pool, 661| 434| GetColumns(this, nullptr), 662| 434| nullptr), 663| 434| path_(ColumnStorage::Create()), 664| 434| path_id_(ColumnStorage::Create()), 665| 434| total_size_(ColumnStorage::Create()), 666| 434| size_(ColumnStorage::Create()), 667| 434| count_(ColumnStorage::Create()) 668| |, 669| 434| id_storage_layer_(new column::IdStorage()), 670| 434| path_storage_layer_( 671| 434| new column::StringStorage(string_pool(), &path_.vector())), 672| 434| path_id_storage_layer_( 673| 434| new column::NumericStorage( 674| 434| &path_id_.vector(), 675| 434| ColumnTypeHelper::ToColumnType(), 676| 434| false)), 677| 434| total_size_storage_layer_( 678| 434| new column::NumericStorage( 679| 434| &total_size_.vector(), 680| 434| ColumnTypeHelper::ToColumnType(), 681| 434| false)), 682| 434| size_storage_layer_( 683| 434| new column::NumericStorage( 684| 434| &size_.vector(), 685| 434| ColumnTypeHelper::ToColumnType(), 686| 434| false)), 687| 434| count_storage_layer_( 688| 434| new column::NumericStorage( 689| 434| &count_.vector(), 690| 434| ColumnTypeHelper::ToColumnType(), 691| 434| false)) 692| 434| { 693| 434| static_assert( 694| 434| ColumnLegacy::IsFlagsAndTypeValid( 695| 434| ColumnFlag::path), 696| 434| "Column type and flag combination is not valid"); 697| 434| static_assert( 698| 434| ColumnLegacy::IsFlagsAndTypeValid( 699| 434| ColumnFlag::path_id), 700| 434| "Column type and flag combination is not valid"); 701| 434| static_assert( 702| 434| ColumnLegacy::IsFlagsAndTypeValid( 703| 434| ColumnFlag::total_size), 704| 434| "Column type and flag combination is not valid"); 705| 434| static_assert( 706| 434| ColumnLegacy::IsFlagsAndTypeValid( 707| 434| ColumnFlag::size), 708| 434| "Column type and flag combination is not valid"); 709| 434| static_assert( 710| 434| ColumnLegacy::IsFlagsAndTypeValid( 711| 434| ColumnFlag::count), 712| 434| "Column type and flag combination is not valid"); 713| 434| OnConstructionCompletedRegularConstructor( 714| 434| {id_storage_layer_,path_storage_layer_,path_id_storage_layer_,total_size_storage_layer_,size_storage_layer_,count_storage_layer_}, 715| 434| {{},{},{},{},{},{}}); 716| 434| } _ZN8perfetto15trace_processor6tables10TrackTable2IdC2Ej: 47| 267k| explicit constexpr Id(uint32_t v) : BaseId(v) {} _ZN8perfetto15trace_processor6tables10TrackTable3RowC2ENS0_10StringPool2IdENSt3__18optionalINS2_2IdEEENS7_IjEENS7_INS1_12MachineTable2IdEEES5_SA_S5_NS7_IS5_EESA_SA_Dn: 90| 267k| : macros_internal::RootParentTable::Row(), 91| 267k| name(in_name), 92| 267k| parent_id(in_parent_id), 93| 267k| source_arg_set_id(in_source_arg_set_id), 94| 267k| machine_id(in_machine_id), 95| 267k| type(in_type), 96| 267k| dimension_arg_set_id(in_dimension_arg_set_id), 97| 267k| event_type(in_event_type), 98| 267k| counter_unit(in_counter_unit), 99| 267k| utid(in_utid), 100| 267k| upid(in_upid) {} _ZN8perfetto15trace_processor6tables10TrackTable9RowNumberC2Ej: 146| 419k| : AbstractRowNumber(row_number) {} _ZN8perfetto15trace_processor6tables10TrackTable17ConstRowReferenceC2EPKS2_j: 155| 509k| : AbstractConstRowReference(table, row_number) {} _ZNK8perfetto15trace_processor6tables10TrackTable17ConstRowReference4nameEv: 160| 1.93k| ColumnType::name::type name() const { 161| 1.93k| return table()->name()[row_number_]; 162| 1.93k| } _ZNK8perfetto15trace_processor6tables10TrackTable17ConstRowReference4utidEv: 184| 44.8k| ColumnType::utid::type utid() const { 185| 44.8k| return table()->utid()[row_number_]; 186| 44.8k| } _ZNK8perfetto15trace_processor6tables10TrackTable17ConstRowReference4upidEv: 187| 84.4k| ColumnType::upid::type upid() const { 188| 84.4k| return table()->upid()[row_number_]; 189| 84.4k| } _ZN8perfetto15trace_processor6tables10TrackTable12RowReferenceC2EPKS2_j: 196| 509k| : ConstRowReference(table, row_number) {} _ZN8perfetto15trace_processor6tables10TrackTable12RowReference8set_nameENS0_10StringPool2IdE: 199| 47.7k| ColumnType::name::non_optional_type v) { 200| 47.7k| return mutable_table()->mutable_name()->Set(row_number_, v); 201| 47.7k| } _ZN8perfetto15trace_processor6tables10TrackTable12RowReference13set_parent_idENS2_2IdE: 203| 23| ColumnType::parent_id::non_optional_type v) { 204| 23| return mutable_table()->mutable_parent_id()->Set(row_number_, v); 205| 23| } _ZNK8perfetto15trace_processor6tables10TrackTable12RowReference13mutable_tableEv: 240| 47.7k| TrackTable* mutable_table() const { 241| 47.7k| return const_cast(table()); 242| 47.7k| } _ZN8perfetto15trace_processor6tables10TrackTable10GetColumnsEPS2_PKNS0_15macros_internal10MacroTableE: 343| 434| const macros_internal::MacroTable* parent) { 344| 434| std::vector columns = 345| 434| CopyColumnsFromParentOrAddRootColumns(parent); 346| 434| uint32_t olay_idx = OverlayCount(parent); 347| 434| AddColumnToVector(columns, "name", &self->name_, ColumnFlag::name, 348| 434| static_cast(columns.size()), olay_idx); 349| 434| AddColumnToVector(columns, "parent_id", &self->parent_id_, ColumnFlag::parent_id, 350| 434| static_cast(columns.size()), olay_idx); 351| 434| AddColumnToVector(columns, "source_arg_set_id", &self->source_arg_set_id_, ColumnFlag::source_arg_set_id, 352| 434| static_cast(columns.size()), olay_idx); 353| 434| AddColumnToVector(columns, "machine_id", &self->machine_id_, ColumnFlag::machine_id, 354| 434| static_cast(columns.size()), olay_idx); 355| 434| AddColumnToVector(columns, "type", &self->type_, ColumnFlag::type, 356| 434| static_cast(columns.size()), olay_idx); 357| 434| AddColumnToVector(columns, "dimension_arg_set_id", &self->dimension_arg_set_id_, ColumnFlag::dimension_arg_set_id, 358| 434| static_cast(columns.size()), olay_idx); 359| 434| AddColumnToVector(columns, "event_type", &self->event_type_, ColumnFlag::event_type, 360| 434| static_cast(columns.size()), olay_idx); 361| 434| AddColumnToVector(columns, "counter_unit", &self->counter_unit_, ColumnFlag::counter_unit, 362| 434| static_cast(columns.size()), olay_idx); 363| 434| AddColumnToVector(columns, "utid", &self->utid_, ColumnFlag::utid, 364| 434| static_cast(columns.size()), olay_idx); 365| 434| AddColumnToVector(columns, "upid", &self->upid_, ColumnFlag::upid, 366| 434| static_cast(columns.size()), olay_idx); 367| 434| base::ignore_result(self); 368| 434| return columns; 369| 434| } _ZN8perfetto15trace_processor6tables10TrackTableC2EPNS0_10StringPoolE: 372| 434| : macros_internal::MacroTable( 373| 434| pool, 374| 434| GetColumns(this, nullptr), 375| 434| nullptr), 376| 434| name_(ColumnStorage::Create()), 377| 434| parent_id_(ColumnStorage::Create()), 378| 434| source_arg_set_id_(ColumnStorage::Create()), 379| 434| machine_id_(ColumnStorage::Create()), 380| 434| type_(ColumnStorage::Create()), 381| 434| dimension_arg_set_id_(ColumnStorage::Create()), 382| 434| event_type_(ColumnStorage::Create()), 383| 434| counter_unit_(ColumnStorage::Create()), 384| 434| utid_(ColumnStorage::Create()), 385| 434| upid_(ColumnStorage::Create()) 386| |, 387| 434| id_storage_layer_(new column::IdStorage()), 388| 434| name_storage_layer_( 389| 434| new column::StringStorage(string_pool(), &name_.vector())), 390| 434| parent_id_storage_layer_( 391| 434| new column::NumericStorage( 392| 434| &parent_id_.non_null_vector(), 393| 434| ColumnTypeHelper::ToColumnType(), 394| 434| false)), 395| 434| source_arg_set_id_storage_layer_( 396| 434| new column::NumericStorage( 397| 434| &source_arg_set_id_.non_null_vector(), 398| 434| ColumnTypeHelper::ToColumnType(), 399| 434| false)), 400| 434| machine_id_storage_layer_( 401| 434| new column::NumericStorage( 402| 434| &machine_id_.non_null_vector(), 403| 434| ColumnTypeHelper::ToColumnType(), 404| 434| false)), 405| 434| type_storage_layer_( 406| 434| new column::StringStorage(string_pool(), &type_.vector())), 407| 434| dimension_arg_set_id_storage_layer_( 408| 434| new column::NumericStorage( 409| 434| &dimension_arg_set_id_.non_null_vector(), 410| 434| ColumnTypeHelper::ToColumnType(), 411| 434| false)), 412| 434| event_type_storage_layer_( 413| 434| new column::StringStorage(string_pool(), &event_type_.vector())), 414| 434| counter_unit_storage_layer_( 415| 434| new column::StringStorage(string_pool(), &counter_unit_.vector())), 416| 434| utid_storage_layer_( 417| 434| new column::NumericStorage( 418| 434| &utid_.non_null_vector(), 419| 434| ColumnTypeHelper::ToColumnType(), 420| 434| false)), 421| 434| upid_storage_layer_( 422| 434| new column::NumericStorage( 423| 434| &upid_.non_null_vector(), 424| 434| ColumnTypeHelper::ToColumnType(), 425| 434| false)) 426| |, 427| 434| parent_id_null_layer_(new column::NullOverlay(parent_id_.bv())), 428| 434| source_arg_set_id_null_layer_(new column::NullOverlay(source_arg_set_id_.bv())), 429| 434| machine_id_null_layer_(new column::NullOverlay(machine_id_.bv())), 430| 434| dimension_arg_set_id_null_layer_(new column::NullOverlay(dimension_arg_set_id_.bv())), 431| 434| utid_null_layer_(new column::NullOverlay(utid_.bv())), 432| 434| upid_null_layer_(new column::NullOverlay(upid_.bv())) { 433| 434| static_assert( 434| 434| ColumnLegacy::IsFlagsAndTypeValid( 435| 434| ColumnFlag::name), 436| 434| "Column type and flag combination is not valid"); 437| 434| static_assert( 438| 434| ColumnLegacy::IsFlagsAndTypeValid( 439| 434| ColumnFlag::parent_id), 440| 434| "Column type and flag combination is not valid"); 441| 434| static_assert( 442| 434| ColumnLegacy::IsFlagsAndTypeValid( 443| 434| ColumnFlag::source_arg_set_id), 444| 434| "Column type and flag combination is not valid"); 445| 434| static_assert( 446| 434| ColumnLegacy::IsFlagsAndTypeValid( 447| 434| ColumnFlag::machine_id), 448| 434| "Column type and flag combination is not valid"); 449| 434| static_assert( 450| 434| ColumnLegacy::IsFlagsAndTypeValid( 451| 434| ColumnFlag::type), 452| 434| "Column type and flag combination is not valid"); 453| 434| static_assert( 454| 434| ColumnLegacy::IsFlagsAndTypeValid( 455| 434| ColumnFlag::dimension_arg_set_id), 456| 434| "Column type and flag combination is not valid"); 457| 434| static_assert( 458| 434| ColumnLegacy::IsFlagsAndTypeValid( 459| 434| ColumnFlag::event_type), 460| 434| "Column type and flag combination is not valid"); 461| 434| static_assert( 462| 434| ColumnLegacy::IsFlagsAndTypeValid( 463| 434| ColumnFlag::counter_unit), 464| 434| "Column type and flag combination is not valid"); 465| 434| static_assert( 466| 434| ColumnLegacy::IsFlagsAndTypeValid( 467| 434| ColumnFlag::utid), 468| 434| "Column type and flag combination is not valid"); 469| 434| static_assert( 470| 434| ColumnLegacy::IsFlagsAndTypeValid( 471| 434| ColumnFlag::upid), 472| 434| "Column type and flag combination is not valid"); 473| 434| OnConstructionCompletedRegularConstructor( 474| 434| {id_storage_layer_,name_storage_layer_,parent_id_storage_layer_,source_arg_set_id_storage_layer_,machine_id_storage_layer_,type_storage_layer_,dimension_arg_set_id_storage_layer_,event_type_storage_layer_,counter_unit_storage_layer_,utid_storage_layer_,upid_storage_layer_}, 475| 434| {{},{},parent_id_null_layer_,source_arg_set_id_null_layer_,machine_id_null_layer_,{},dimension_arg_set_id_null_layer_,{},{},utid_null_layer_,upid_null_layer_}); 476| 434| } _ZN8perfetto15trace_processor6tables10TrackTable8FindByIdENS2_2IdE: 582| 241k| std::optional FindById(Id find_id) { 583| 241k| std::optional row = id().IndexOf(find_id); 584| 241k| return row ? std::make_optional(RowReference(this, *row)) : std::nullopt; ------------------ | Branch (584:12): [True: 241k, False: 0] ------------------ 585| 241k| } _ZN8perfetto15trace_processor6tables10TrackTable6InsertERKNS2_3RowE: 587| 267k| IdAndRow Insert(const Row& row) { 588| 267k| uint32_t row_number = row_count(); 589| 267k| Id id = Id{row_number}; 590| 267k| mutable_name()->Append(row.name); 591| 267k| mutable_parent_id()->Append(row.parent_id); 592| 267k| mutable_source_arg_set_id()->Append(row.source_arg_set_id); 593| 267k| mutable_machine_id()->Append(row.machine_id); 594| 267k| mutable_type()->Append(row.type); 595| 267k| mutable_dimension_arg_set_id()->Append(row.dimension_arg_set_id); 596| 267k| mutable_event_type()->Append(row.event_type); 597| 267k| mutable_counter_unit()->Append(row.counter_unit); 598| 267k| mutable_utid()->Append(row.utid); 599| 267k| mutable_upid()->Append(row.upid); 600| 267k| UpdateSelfOverlayAfterInsert(); 601| 267k| return IdAndRow{id, row_number, RowReference(this, row_number), 602| 267k| RowNumber(row_number)}; 603| 267k| } _ZNK8perfetto15trace_processor6tables10TrackTable2idEv: 607| 241k| const IdColumn& id() const { 608| 241k| return static_cast(columns()[ColumnIndex::id]); 609| 241k| } _ZNK8perfetto15trace_processor6tables10TrackTable4nameEv: 610| 1.93k| const TypedColumn& name() const { 611| 1.93k| return static_cast(columns()[ColumnIndex::name]); 612| 1.93k| } _ZNK8perfetto15trace_processor6tables10TrackTable4utidEv: 634| 44.8k| const TypedColumn>& utid() const { 635| 44.8k| return static_cast(columns()[ColumnIndex::utid]); 636| 44.8k| } _ZNK8perfetto15trace_processor6tables10TrackTable4upidEv: 637| 84.4k| const TypedColumn>& upid() const { 638| 84.4k| return static_cast(columns()[ColumnIndex::upid]); 639| 84.4k| } _ZN8perfetto15trace_processor6tables10TrackTable12mutable_nameEv: 641| 315k| TypedColumn* mutable_name() { 642| 315k| return static_cast( 643| 315k| GetColumn(ColumnIndex::name)); 644| 315k| } _ZN8perfetto15trace_processor6tables10TrackTable17mutable_parent_idEv: 645| 268k| TypedColumn>* mutable_parent_id() { 646| 268k| return static_cast( 647| 268k| GetColumn(ColumnIndex::parent_id)); 648| 268k| } _ZN8perfetto15trace_processor6tables10TrackTable25mutable_source_arg_set_idEv: 649| 419k| TypedColumn>* mutable_source_arg_set_id() { 650| 419k| return static_cast( 651| 419k| GetColumn(ColumnIndex::source_arg_set_id)); 652| 419k| } _ZN8perfetto15trace_processor6tables10TrackTable18mutable_machine_idEv: 653| 267k| TypedColumn>* mutable_machine_id() { 654| 267k| return static_cast( 655| 267k| GetColumn(ColumnIndex::machine_id)); 656| 267k| } _ZN8perfetto15trace_processor6tables10TrackTable12mutable_typeEv: 657| 267k| TypedColumn* mutable_type() { 658| 267k| return static_cast( 659| 267k| GetColumn(ColumnIndex::type)); 660| 267k| } _ZN8perfetto15trace_processor6tables10TrackTable28mutable_dimension_arg_set_idEv: 661| 267k| TypedColumn>* mutable_dimension_arg_set_id() { 662| 267k| return static_cast( 663| 267k| GetColumn(ColumnIndex::dimension_arg_set_id)); 664| 267k| } _ZN8perfetto15trace_processor6tables10TrackTable18mutable_event_typeEv: 665| 267k| TypedColumn* mutable_event_type() { 666| 267k| return static_cast( 667| 267k| GetColumn(ColumnIndex::event_type)); 668| 267k| } _ZN8perfetto15trace_processor6tables10TrackTable20mutable_counter_unitEv: 669| 267k| TypedColumn>* mutable_counter_unit() { 670| 267k| return static_cast( 671| 267k| GetColumn(ColumnIndex::counter_unit)); 672| 267k| } _ZN8perfetto15trace_processor6tables10TrackTable12mutable_utidEv: 673| 267k| TypedColumn>* mutable_utid() { 674| 267k| return static_cast( 675| 267k| GetColumn(ColumnIndex::utid)); 676| 267k| } _ZN8perfetto15trace_processor6tables10TrackTable12mutable_upidEv: 677| 267k| TypedColumn>* mutable_upid() { 678| 267k| return static_cast( 679| 267k| GetColumn(ColumnIndex::upid)); 680| 267k| } _ZN8perfetto15trace_processor6tables14V8IsolateTable10GetColumnsEPS2_PKNS0_15macros_internal10MacroTableE: 305| 434| const macros_internal::MacroTable* parent) { 306| 434| std::vector columns = 307| 434| CopyColumnsFromParentOrAddRootColumns(parent); 308| 434| uint32_t olay_idx = OverlayCount(parent); 309| 434| AddColumnToVector(columns, "upid", &self->upid_, ColumnFlag::upid, 310| 434| static_cast(columns.size()), olay_idx); 311| 434| AddColumnToVector(columns, "internal_isolate_id", &self->internal_isolate_id_, ColumnFlag::internal_isolate_id, 312| 434| static_cast(columns.size()), olay_idx); 313| 434| AddColumnToVector(columns, "embedded_blob_code_start_address", &self->embedded_blob_code_start_address_, ColumnFlag::embedded_blob_code_start_address, 314| 434| static_cast(columns.size()), olay_idx); 315| 434| AddColumnToVector(columns, "embedded_blob_code_size", &self->embedded_blob_code_size_, ColumnFlag::embedded_blob_code_size, 316| 434| static_cast(columns.size()), olay_idx); 317| 434| AddColumnToVector(columns, "code_range_base_address", &self->code_range_base_address_, ColumnFlag::code_range_base_address, 318| 434| static_cast(columns.size()), olay_idx); 319| 434| AddColumnToVector(columns, "code_range_size", &self->code_range_size_, ColumnFlag::code_range_size, 320| 434| static_cast(columns.size()), olay_idx); 321| 434| AddColumnToVector(columns, "shared_code_range", &self->shared_code_range_, ColumnFlag::shared_code_range, 322| 434| static_cast(columns.size()), olay_idx); 323| 434| AddColumnToVector(columns, "embedded_blob_code_copy_start_address", &self->embedded_blob_code_copy_start_address_, ColumnFlag::embedded_blob_code_copy_start_address, 324| 434| static_cast(columns.size()), olay_idx); 325| 434| base::ignore_result(self); 326| 434| return columns; 327| 434| } _ZN8perfetto15trace_processor6tables14V8IsolateTableC2EPNS0_10StringPoolE: 330| 434| : macros_internal::MacroTable( 331| 434| pool, 332| 434| GetColumns(this, nullptr), 333| 434| nullptr), 334| 434| upid_(ColumnStorage::Create()), 335| 434| internal_isolate_id_(ColumnStorage::Create()), 336| 434| embedded_blob_code_start_address_(ColumnStorage::Create()), 337| 434| embedded_blob_code_size_(ColumnStorage::Create()), 338| 434| code_range_base_address_(ColumnStorage::Create()), 339| 434| code_range_size_(ColumnStorage::Create()), 340| 434| shared_code_range_(ColumnStorage::Create()), 341| 434| embedded_blob_code_copy_start_address_(ColumnStorage::Create()) 342| |, 343| 434| id_storage_layer_(new column::IdStorage()), 344| 434| upid_storage_layer_( 345| 434| new column::NumericStorage( 346| 434| &upid_.vector(), 347| 434| ColumnTypeHelper::ToColumnType(), 348| 434| false)), 349| 434| internal_isolate_id_storage_layer_( 350| 434| new column::NumericStorage( 351| 434| &internal_isolate_id_.vector(), 352| 434| ColumnTypeHelper::ToColumnType(), 353| 434| false)), 354| 434| embedded_blob_code_start_address_storage_layer_( 355| 434| new column::NumericStorage( 356| 434| &embedded_blob_code_start_address_.vector(), 357| 434| ColumnTypeHelper::ToColumnType(), 358| 434| false)), 359| 434| embedded_blob_code_size_storage_layer_( 360| 434| new column::NumericStorage( 361| 434| &embedded_blob_code_size_.vector(), 362| 434| ColumnTypeHelper::ToColumnType(), 363| 434| false)), 364| 434| code_range_base_address_storage_layer_( 365| 434| new column::NumericStorage( 366| 434| &code_range_base_address_.non_null_vector(), 367| 434| ColumnTypeHelper::ToColumnType(), 368| 434| false)), 369| 434| code_range_size_storage_layer_( 370| 434| new column::NumericStorage( 371| 434| &code_range_size_.non_null_vector(), 372| 434| ColumnTypeHelper::ToColumnType(), 373| 434| false)), 374| 434| shared_code_range_storage_layer_( 375| 434| new column::NumericStorage( 376| 434| &shared_code_range_.non_null_vector(), 377| 434| ColumnTypeHelper::ToColumnType(), 378| 434| false)), 379| 434| embedded_blob_code_copy_start_address_storage_layer_( 380| 434| new column::NumericStorage( 381| 434| &embedded_blob_code_copy_start_address_.non_null_vector(), 382| 434| ColumnTypeHelper::ToColumnType(), 383| 434| false)) 384| |, 385| 434| code_range_base_address_null_layer_(new column::NullOverlay(code_range_base_address_.bv())), 386| 434| code_range_size_null_layer_(new column::NullOverlay(code_range_size_.bv())), 387| 434| shared_code_range_null_layer_(new column::NullOverlay(shared_code_range_.bv())), 388| 434| embedded_blob_code_copy_start_address_null_layer_(new column::NullOverlay(embedded_blob_code_copy_start_address_.bv())) { 389| 434| static_assert( 390| 434| ColumnLegacy::IsFlagsAndTypeValid( 391| 434| ColumnFlag::upid), 392| 434| "Column type and flag combination is not valid"); 393| 434| static_assert( 394| 434| ColumnLegacy::IsFlagsAndTypeValid( 395| 434| ColumnFlag::internal_isolate_id), 396| 434| "Column type and flag combination is not valid"); 397| 434| static_assert( 398| 434| ColumnLegacy::IsFlagsAndTypeValid( 399| 434| ColumnFlag::embedded_blob_code_start_address), 400| 434| "Column type and flag combination is not valid"); 401| 434| static_assert( 402| 434| ColumnLegacy::IsFlagsAndTypeValid( 403| 434| ColumnFlag::embedded_blob_code_size), 404| 434| "Column type and flag combination is not valid"); 405| 434| static_assert( 406| 434| ColumnLegacy::IsFlagsAndTypeValid( 407| 434| ColumnFlag::code_range_base_address), 408| 434| "Column type and flag combination is not valid"); 409| 434| static_assert( 410| 434| ColumnLegacy::IsFlagsAndTypeValid( 411| 434| ColumnFlag::code_range_size), 412| 434| "Column type and flag combination is not valid"); 413| 434| static_assert( 414| 434| ColumnLegacy::IsFlagsAndTypeValid( 415| 434| ColumnFlag::shared_code_range), 416| 434| "Column type and flag combination is not valid"); 417| 434| static_assert( 418| 434| ColumnLegacy::IsFlagsAndTypeValid( 419| 434| ColumnFlag::embedded_blob_code_copy_start_address), 420| 434| "Column type and flag combination is not valid"); 421| 434| OnConstructionCompletedRegularConstructor( 422| 434| {id_storage_layer_,upid_storage_layer_,internal_isolate_id_storage_layer_,embedded_blob_code_start_address_storage_layer_,embedded_blob_code_size_storage_layer_,code_range_base_address_storage_layer_,code_range_size_storage_layer_,shared_code_range_storage_layer_,embedded_blob_code_copy_start_address_storage_layer_}, 423| 434| {{},{},{},{},{},code_range_base_address_null_layer_,code_range_size_null_layer_,shared_code_range_null_layer_,embedded_blob_code_copy_start_address_null_layer_}); 424| 434| } _ZN8perfetto15trace_processor6tables15V8JsScriptTable10GetColumnsEPS2_PKNS0_15macros_internal10MacroTableE: 838| 434| const macros_internal::MacroTable* parent) { 839| 434| std::vector columns = 840| 434| CopyColumnsFromParentOrAddRootColumns(parent); 841| 434| uint32_t olay_idx = OverlayCount(parent); 842| 434| AddColumnToVector(columns, "v8_isolate_id", &self->v8_isolate_id_, ColumnFlag::v8_isolate_id, 843| 434| static_cast(columns.size()), olay_idx); 844| 434| AddColumnToVector(columns, "internal_script_id", &self->internal_script_id_, ColumnFlag::internal_script_id, 845| 434| static_cast(columns.size()), olay_idx); 846| 434| AddColumnToVector(columns, "script_type", &self->script_type_, ColumnFlag::script_type, 847| 434| static_cast(columns.size()), olay_idx); 848| 434| AddColumnToVector(columns, "name", &self->name_, ColumnFlag::name, 849| 434| static_cast(columns.size()), olay_idx); 850| 434| AddColumnToVector(columns, "source", &self->source_, ColumnFlag::source, 851| 434| static_cast(columns.size()), olay_idx); 852| 434| base::ignore_result(self); 853| 434| return columns; 854| 434| } _ZN8perfetto15trace_processor6tables15V8JsScriptTableC2EPNS0_10StringPoolE: 857| 434| : macros_internal::MacroTable( 858| 434| pool, 859| 434| GetColumns(this, nullptr), 860| 434| nullptr), 861| 434| v8_isolate_id_(ColumnStorage::Create()), 862| 434| internal_script_id_(ColumnStorage::Create()), 863| 434| script_type_(ColumnStorage::Create()), 864| 434| name_(ColumnStorage::Create()), 865| 434| source_(ColumnStorage::Create()) 866| |, 867| 434| id_storage_layer_(new column::IdStorage()), 868| 434| v8_isolate_id_storage_layer_( 869| 434| new column::NumericStorage( 870| 434| &v8_isolate_id_.vector(), 871| 434| ColumnTypeHelper::ToColumnType(), 872| 434| false)), 873| 434| internal_script_id_storage_layer_( 874| 434| new column::NumericStorage( 875| 434| &internal_script_id_.vector(), 876| 434| ColumnTypeHelper::ToColumnType(), 877| 434| false)), 878| 434| script_type_storage_layer_( 879| 434| new column::StringStorage(string_pool(), &script_type_.vector())), 880| 434| name_storage_layer_( 881| 434| new column::StringStorage(string_pool(), &name_.vector())), 882| 434| source_storage_layer_( 883| 434| new column::StringStorage(string_pool(), &source_.vector())) 884| 434| { 885| 434| static_assert( 886| 434| ColumnLegacy::IsFlagsAndTypeValid( 887| 434| ColumnFlag::v8_isolate_id), 888| 434| "Column type and flag combination is not valid"); 889| 434| static_assert( 890| 434| ColumnLegacy::IsFlagsAndTypeValid( 891| 434| ColumnFlag::internal_script_id), 892| 434| "Column type and flag combination is not valid"); 893| 434| static_assert( 894| 434| ColumnLegacy::IsFlagsAndTypeValid( 895| 434| ColumnFlag::script_type), 896| 434| "Column type and flag combination is not valid"); 897| 434| static_assert( 898| 434| ColumnLegacy::IsFlagsAndTypeValid( 899| 434| ColumnFlag::name), 900| 434| "Column type and flag combination is not valid"); 901| 434| static_assert( 902| 434| ColumnLegacy::IsFlagsAndTypeValid( 903| 434| ColumnFlag::source), 904| 434| "Column type and flag combination is not valid"); 905| 434| OnConstructionCompletedRegularConstructor( 906| 434| {id_storage_layer_,v8_isolate_id_storage_layer_,internal_script_id_storage_layer_,script_type_storage_layer_,name_storage_layer_,source_storage_layer_}, 907| 434| {{},{},{},{},{},{}}); 908| 434| } _ZN8perfetto15trace_processor6tables17V8WasmScriptTable10GetColumnsEPS2_PKNS0_15macros_internal10MacroTableE: 1271| 434| const macros_internal::MacroTable* parent) { 1272| 434| std::vector columns = 1273| 434| CopyColumnsFromParentOrAddRootColumns(parent); 1274| 434| uint32_t olay_idx = OverlayCount(parent); 1275| 434| AddColumnToVector(columns, "v8_isolate_id", &self->v8_isolate_id_, ColumnFlag::v8_isolate_id, 1276| 434| static_cast(columns.size()), olay_idx); 1277| 434| AddColumnToVector(columns, "internal_script_id", &self->internal_script_id_, ColumnFlag::internal_script_id, 1278| 434| static_cast(columns.size()), olay_idx); 1279| 434| AddColumnToVector(columns, "url", &self->url_, ColumnFlag::url, 1280| 434| static_cast(columns.size()), olay_idx); 1281| 434| AddColumnToVector(columns, "wire_bytes_base64", &self->wire_bytes_base64_, ColumnFlag::wire_bytes_base64, 1282| 434| static_cast(columns.size()), olay_idx); 1283| 434| AddColumnToVector(columns, "source", &self->source_, ColumnFlag::source, 1284| 434| static_cast(columns.size()), olay_idx); 1285| 434| base::ignore_result(self); 1286| 434| return columns; 1287| 434| } _ZN8perfetto15trace_processor6tables17V8WasmScriptTableC2EPNS0_10StringPoolE: 1290| 434| : macros_internal::MacroTable( 1291| 434| pool, 1292| 434| GetColumns(this, nullptr), 1293| 434| nullptr), 1294| 434| v8_isolate_id_(ColumnStorage::Create()), 1295| 434| internal_script_id_(ColumnStorage::Create()), 1296| 434| url_(ColumnStorage::Create()), 1297| 434| wire_bytes_base64_(ColumnStorage::Create()), 1298| 434| source_(ColumnStorage::Create()) 1299| |, 1300| 434| id_storage_layer_(new column::IdStorage()), 1301| 434| v8_isolate_id_storage_layer_( 1302| 434| new column::NumericStorage( 1303| 434| &v8_isolate_id_.vector(), 1304| 434| ColumnTypeHelper::ToColumnType(), 1305| 434| false)), 1306| 434| internal_script_id_storage_layer_( 1307| 434| new column::NumericStorage( 1308| 434| &internal_script_id_.vector(), 1309| 434| ColumnTypeHelper::ToColumnType(), 1310| 434| false)), 1311| 434| url_storage_layer_( 1312| 434| new column::StringStorage(string_pool(), &url_.vector())), 1313| 434| wire_bytes_base64_storage_layer_( 1314| 434| new column::StringStorage(string_pool(), &wire_bytes_base64_.vector())), 1315| 434| source_storage_layer_( 1316| 434| new column::StringStorage(string_pool(), &source_.vector())) 1317| 434| { 1318| 434| static_assert( 1319| 434| ColumnLegacy::IsFlagsAndTypeValid( 1320| 434| ColumnFlag::v8_isolate_id), 1321| 434| "Column type and flag combination is not valid"); 1322| 434| static_assert( 1323| 434| ColumnLegacy::IsFlagsAndTypeValid( 1324| 434| ColumnFlag::internal_script_id), 1325| 434| "Column type and flag combination is not valid"); 1326| 434| static_assert( 1327| 434| ColumnLegacy::IsFlagsAndTypeValid( 1328| 434| ColumnFlag::url), 1329| 434| "Column type and flag combination is not valid"); 1330| 434| static_assert( 1331| 434| ColumnLegacy::IsFlagsAndTypeValid( 1332| 434| ColumnFlag::wire_bytes_base64), 1333| 434| "Column type and flag combination is not valid"); 1334| 434| static_assert( 1335| 434| ColumnLegacy::IsFlagsAndTypeValid( 1336| 434| ColumnFlag::source), 1337| 434| "Column type and flag combination is not valid"); 1338| 434| OnConstructionCompletedRegularConstructor( 1339| 434| {id_storage_layer_,v8_isolate_id_storage_layer_,internal_script_id_storage_layer_,url_storage_layer_,wire_bytes_base64_storage_layer_,source_storage_layer_}, 1340| 434| {{},{},{},{},{},{}}); 1341| 434| } _ZN8perfetto15trace_processor6tables17V8JsFunctionTable10GetColumnsEPS2_PKNS0_15macros_internal10MacroTableE: 1723| 434| const macros_internal::MacroTable* parent) { 1724| 434| std::vector columns = 1725| 434| CopyColumnsFromParentOrAddRootColumns(parent); 1726| 434| uint32_t olay_idx = OverlayCount(parent); 1727| 434| AddColumnToVector(columns, "name", &self->name_, ColumnFlag::name, 1728| 434| static_cast(columns.size()), olay_idx); 1729| 434| AddColumnToVector(columns, "v8_js_script_id", &self->v8_js_script_id_, ColumnFlag::v8_js_script_id, 1730| 434| static_cast(columns.size()), olay_idx); 1731| 434| AddColumnToVector(columns, "is_toplevel", &self->is_toplevel_, ColumnFlag::is_toplevel, 1732| 434| static_cast(columns.size()), olay_idx); 1733| 434| AddColumnToVector(columns, "kind", &self->kind_, ColumnFlag::kind, 1734| 434| static_cast(columns.size()), olay_idx); 1735| 434| AddColumnToVector(columns, "line", &self->line_, ColumnFlag::line, 1736| 434| static_cast(columns.size()), olay_idx); 1737| 434| AddColumnToVector(columns, "col", &self->col_, ColumnFlag::col, 1738| 434| static_cast(columns.size()), olay_idx); 1739| 434| base::ignore_result(self); 1740| 434| return columns; 1741| 434| } _ZN8perfetto15trace_processor6tables17V8JsFunctionTableC2EPNS0_10StringPoolE: 1744| 434| : macros_internal::MacroTable( 1745| 434| pool, 1746| 434| GetColumns(this, nullptr), 1747| 434| nullptr), 1748| 434| name_(ColumnStorage::Create()), 1749| 434| v8_js_script_id_(ColumnStorage::Create()), 1750| 434| is_toplevel_(ColumnStorage::Create()), 1751| 434| kind_(ColumnStorage::Create()), 1752| 434| line_(ColumnStorage::Create()), 1753| 434| col_(ColumnStorage::Create()) 1754| |, 1755| 434| id_storage_layer_(new column::IdStorage()), 1756| 434| name_storage_layer_( 1757| 434| new column::StringStorage(string_pool(), &name_.vector())), 1758| 434| v8_js_script_id_storage_layer_( 1759| 434| new column::NumericStorage( 1760| 434| &v8_js_script_id_.vector(), 1761| 434| ColumnTypeHelper::ToColumnType(), 1762| 434| false)), 1763| 434| is_toplevel_storage_layer_( 1764| 434| new column::NumericStorage( 1765| 434| &is_toplevel_.vector(), 1766| 434| ColumnTypeHelper::ToColumnType(), 1767| 434| false)), 1768| 434| kind_storage_layer_( 1769| 434| new column::StringStorage(string_pool(), &kind_.vector())), 1770| 434| line_storage_layer_( 1771| 434| new column::NumericStorage( 1772| 434| &line_.non_null_vector(), 1773| 434| ColumnTypeHelper::ToColumnType(), 1774| 434| false)), 1775| 434| col_storage_layer_( 1776| 434| new column::NumericStorage( 1777| 434| &col_.non_null_vector(), 1778| 434| ColumnTypeHelper::ToColumnType(), 1779| 434| false)) 1780| |, 1781| 434| line_null_layer_(new column::NullOverlay(line_.bv())), 1782| 434| col_null_layer_(new column::NullOverlay(col_.bv())) { 1783| 434| static_assert( 1784| 434| ColumnLegacy::IsFlagsAndTypeValid( 1785| 434| ColumnFlag::name), 1786| 434| "Column type and flag combination is not valid"); 1787| 434| static_assert( 1788| 434| ColumnLegacy::IsFlagsAndTypeValid( 1789| 434| ColumnFlag::v8_js_script_id), 1790| 434| "Column type and flag combination is not valid"); 1791| 434| static_assert( 1792| 434| ColumnLegacy::IsFlagsAndTypeValid( 1793| 434| ColumnFlag::is_toplevel), 1794| 434| "Column type and flag combination is not valid"); 1795| 434| static_assert( 1796| 434| ColumnLegacy::IsFlagsAndTypeValid( 1797| 434| ColumnFlag::kind), 1798| 434| "Column type and flag combination is not valid"); 1799| 434| static_assert( 1800| 434| ColumnLegacy::IsFlagsAndTypeValid( 1801| 434| ColumnFlag::line), 1802| 434| "Column type and flag combination is not valid"); 1803| 434| static_assert( 1804| 434| ColumnLegacy::IsFlagsAndTypeValid( 1805| 434| ColumnFlag::col), 1806| 434| "Column type and flag combination is not valid"); 1807| 434| OnConstructionCompletedRegularConstructor( 1808| 434| {id_storage_layer_,name_storage_layer_,v8_js_script_id_storage_layer_,is_toplevel_storage_layer_,kind_storage_layer_,line_storage_layer_,col_storage_layer_}, 1809| 434| {{},{},{},{},{},line_null_layer_,col_null_layer_}); 1810| 434| } _ZN8perfetto15trace_processor6tables13V8JsCodeTable10GetColumnsEPS2_PKNS0_15macros_internal10MacroTableE: 2171| 434| const macros_internal::MacroTable* parent) { 2172| 434| std::vector columns = 2173| 434| CopyColumnsFromParentOrAddRootColumns(parent); 2174| 434| uint32_t olay_idx = OverlayCount(parent); 2175| 434| AddColumnToVector(columns, "jit_code_id", &self->jit_code_id_, ColumnFlag::jit_code_id, 2176| 434| static_cast(columns.size()), olay_idx); 2177| 434| AddColumnToVector(columns, "v8_js_function_id", &self->v8_js_function_id_, ColumnFlag::v8_js_function_id, 2178| 434| static_cast(columns.size()), olay_idx); 2179| 434| AddColumnToVector(columns, "tier", &self->tier_, ColumnFlag::tier, 2180| 434| static_cast(columns.size()), olay_idx); 2181| 434| AddColumnToVector(columns, "bytecode_base64", &self->bytecode_base64_, ColumnFlag::bytecode_base64, 2182| 434| static_cast(columns.size()), olay_idx); 2183| 434| base::ignore_result(self); 2184| 434| return columns; 2185| 434| } _ZN8perfetto15trace_processor6tables13V8JsCodeTableC2EPNS0_10StringPoolE: 2188| 434| : macros_internal::MacroTable( 2189| 434| pool, 2190| 434| GetColumns(this, nullptr), 2191| 434| nullptr), 2192| 434| jit_code_id_(ColumnStorage::Create()), 2193| 434| v8_js_function_id_(ColumnStorage::Create()), 2194| 434| tier_(ColumnStorage::Create()), 2195| 434| bytecode_base64_(ColumnStorage::Create()) 2196| |, 2197| 434| id_storage_layer_(new column::IdStorage()), 2198| 434| jit_code_id_storage_layer_( 2199| 434| new column::NumericStorage( 2200| 434| &jit_code_id_.non_null_vector(), 2201| 434| ColumnTypeHelper::ToColumnType(), 2202| 434| false)), 2203| 434| v8_js_function_id_storage_layer_( 2204| 434| new column::NumericStorage( 2205| 434| &v8_js_function_id_.vector(), 2206| 434| ColumnTypeHelper::ToColumnType(), 2207| 434| false)), 2208| 434| tier_storage_layer_( 2209| 434| new column::StringStorage(string_pool(), &tier_.vector())), 2210| 434| bytecode_base64_storage_layer_( 2211| 434| new column::StringStorage(string_pool(), &bytecode_base64_.vector())) 2212| |, 2213| 434| jit_code_id_null_layer_(new column::NullOverlay(jit_code_id_.bv())) { 2214| 434| static_assert( 2215| 434| ColumnLegacy::IsFlagsAndTypeValid( 2216| 434| ColumnFlag::jit_code_id), 2217| 434| "Column type and flag combination is not valid"); 2218| 434| static_assert( 2219| 434| ColumnLegacy::IsFlagsAndTypeValid( 2220| 434| ColumnFlag::v8_js_function_id), 2221| 434| "Column type and flag combination is not valid"); 2222| 434| static_assert( 2223| 434| ColumnLegacy::IsFlagsAndTypeValid( 2224| 434| ColumnFlag::tier), 2225| 434| "Column type and flag combination is not valid"); 2226| 434| static_assert( 2227| 434| ColumnLegacy::IsFlagsAndTypeValid( 2228| 434| ColumnFlag::bytecode_base64), 2229| 434| "Column type and flag combination is not valid"); 2230| 434| OnConstructionCompletedRegularConstructor( 2231| 434| {id_storage_layer_,jit_code_id_storage_layer_,v8_js_function_id_storage_layer_,tier_storage_layer_,bytecode_base64_storage_layer_}, 2232| 434| {{},jit_code_id_null_layer_,{},{},{}}); 2233| 434| } _ZN8perfetto15trace_processor6tables19V8InternalCodeTable10GetColumnsEPS2_PKNS0_15macros_internal10MacroTableE: 2561| 434| const macros_internal::MacroTable* parent) { 2562| 434| std::vector columns = 2563| 434| CopyColumnsFromParentOrAddRootColumns(parent); 2564| 434| uint32_t olay_idx = OverlayCount(parent); 2565| 434| AddColumnToVector(columns, "jit_code_id", &self->jit_code_id_, ColumnFlag::jit_code_id, 2566| 434| static_cast(columns.size()), olay_idx); 2567| 434| AddColumnToVector(columns, "v8_isolate_id", &self->v8_isolate_id_, ColumnFlag::v8_isolate_id, 2568| 434| static_cast(columns.size()), olay_idx); 2569| 434| AddColumnToVector(columns, "function_name", &self->function_name_, ColumnFlag::function_name, 2570| 434| static_cast(columns.size()), olay_idx); 2571| 434| AddColumnToVector(columns, "code_type", &self->code_type_, ColumnFlag::code_type, 2572| 434| static_cast(columns.size()), olay_idx); 2573| 434| base::ignore_result(self); 2574| 434| return columns; 2575| 434| } _ZN8perfetto15trace_processor6tables19V8InternalCodeTableC2EPNS0_10StringPoolE: 2578| 434| : macros_internal::MacroTable( 2579| 434| pool, 2580| 434| GetColumns(this, nullptr), 2581| 434| nullptr), 2582| 434| jit_code_id_(ColumnStorage::Create()), 2583| 434| v8_isolate_id_(ColumnStorage::Create()), 2584| 434| function_name_(ColumnStorage::Create()), 2585| 434| code_type_(ColumnStorage::Create()) 2586| |, 2587| 434| id_storage_layer_(new column::IdStorage()), 2588| 434| jit_code_id_storage_layer_( 2589| 434| new column::NumericStorage( 2590| 434| &jit_code_id_.vector(), 2591| 434| ColumnTypeHelper::ToColumnType(), 2592| 434| false)), 2593| 434| v8_isolate_id_storage_layer_( 2594| 434| new column::NumericStorage( 2595| 434| &v8_isolate_id_.vector(), 2596| 434| ColumnTypeHelper::ToColumnType(), 2597| 434| false)), 2598| 434| function_name_storage_layer_( 2599| 434| new column::StringStorage(string_pool(), &function_name_.vector())), 2600| 434| code_type_storage_layer_( 2601| 434| new column::StringStorage(string_pool(), &code_type_.vector())) 2602| 434| { 2603| 434| static_assert( 2604| 434| ColumnLegacy::IsFlagsAndTypeValid( 2605| 434| ColumnFlag::jit_code_id), 2606| 434| "Column type and flag combination is not valid"); 2607| 434| static_assert( 2608| 434| ColumnLegacy::IsFlagsAndTypeValid( 2609| 434| ColumnFlag::v8_isolate_id), 2610| 434| "Column type and flag combination is not valid"); 2611| 434| static_assert( 2612| 434| ColumnLegacy::IsFlagsAndTypeValid( 2613| 434| ColumnFlag::function_name), 2614| 434| "Column type and flag combination is not valid"); 2615| 434| static_assert( 2616| 434| ColumnLegacy::IsFlagsAndTypeValid( 2617| 434| ColumnFlag::code_type), 2618| 434| "Column type and flag combination is not valid"); 2619| 434| OnConstructionCompletedRegularConstructor( 2620| 434| {id_storage_layer_,jit_code_id_storage_layer_,v8_isolate_id_storage_layer_,function_name_storage_layer_,code_type_storage_layer_}, 2621| 434| {{},{},{},{},{}}); 2622| 434| } _ZN8perfetto15trace_processor6tables15V8WasmCodeTable10GetColumnsEPS2_PKNS0_15macros_internal10MacroTableE: 2988| 434| const macros_internal::MacroTable* parent) { 2989| 434| std::vector columns = 2990| 434| CopyColumnsFromParentOrAddRootColumns(parent); 2991| 434| uint32_t olay_idx = OverlayCount(parent); 2992| 434| AddColumnToVector(columns, "jit_code_id", &self->jit_code_id_, ColumnFlag::jit_code_id, 2993| 434| static_cast(columns.size()), olay_idx); 2994| 434| AddColumnToVector(columns, "v8_isolate_id", &self->v8_isolate_id_, ColumnFlag::v8_isolate_id, 2995| 434| static_cast(columns.size()), olay_idx); 2996| 434| AddColumnToVector(columns, "v8_wasm_script_id", &self->v8_wasm_script_id_, ColumnFlag::v8_wasm_script_id, 2997| 434| static_cast(columns.size()), olay_idx); 2998| 434| AddColumnToVector(columns, "function_name", &self->function_name_, ColumnFlag::function_name, 2999| 434| static_cast(columns.size()), olay_idx); 3000| 434| AddColumnToVector(columns, "tier", &self->tier_, ColumnFlag::tier, 3001| 434| static_cast(columns.size()), olay_idx); 3002| 434| AddColumnToVector(columns, "code_offset_in_module", &self->code_offset_in_module_, ColumnFlag::code_offset_in_module, 3003| 434| static_cast(columns.size()), olay_idx); 3004| 434| base::ignore_result(self); 3005| 434| return columns; 3006| 434| } _ZN8perfetto15trace_processor6tables15V8WasmCodeTableC2EPNS0_10StringPoolE: 3009| 434| : macros_internal::MacroTable( 3010| 434| pool, 3011| 434| GetColumns(this, nullptr), 3012| 434| nullptr), 3013| 434| jit_code_id_(ColumnStorage::Create()), 3014| 434| v8_isolate_id_(ColumnStorage::Create()), 3015| 434| v8_wasm_script_id_(ColumnStorage::Create()), 3016| 434| function_name_(ColumnStorage::Create()), 3017| 434| tier_(ColumnStorage::Create()), 3018| 434| code_offset_in_module_(ColumnStorage::Create()) 3019| |, 3020| 434| id_storage_layer_(new column::IdStorage()), 3021| 434| jit_code_id_storage_layer_( 3022| 434| new column::NumericStorage( 3023| 434| &jit_code_id_.vector(), 3024| 434| ColumnTypeHelper::ToColumnType(), 3025| 434| false)), 3026| 434| v8_isolate_id_storage_layer_( 3027| 434| new column::NumericStorage( 3028| 434| &v8_isolate_id_.vector(), 3029| 434| ColumnTypeHelper::ToColumnType(), 3030| 434| false)), 3031| 434| v8_wasm_script_id_storage_layer_( 3032| 434| new column::NumericStorage( 3033| 434| &v8_wasm_script_id_.vector(), 3034| 434| ColumnTypeHelper::ToColumnType(), 3035| 434| false)), 3036| 434| function_name_storage_layer_( 3037| 434| new column::StringStorage(string_pool(), &function_name_.vector())), 3038| 434| tier_storage_layer_( 3039| 434| new column::StringStorage(string_pool(), &tier_.vector())), 3040| 434| code_offset_in_module_storage_layer_( 3041| 434| new column::NumericStorage( 3042| 434| &code_offset_in_module_.vector(), 3043| 434| ColumnTypeHelper::ToColumnType(), 3044| 434| false)) 3045| 434| { 3046| 434| static_assert( 3047| 434| ColumnLegacy::IsFlagsAndTypeValid( 3048| 434| ColumnFlag::jit_code_id), 3049| 434| "Column type and flag combination is not valid"); 3050| 434| static_assert( 3051| 434| ColumnLegacy::IsFlagsAndTypeValid( 3052| 434| ColumnFlag::v8_isolate_id), 3053| 434| "Column type and flag combination is not valid"); 3054| 434| static_assert( 3055| 434| ColumnLegacy::IsFlagsAndTypeValid( 3056| 434| ColumnFlag::v8_wasm_script_id), 3057| 434| "Column type and flag combination is not valid"); 3058| 434| static_assert( 3059| 434| ColumnLegacy::IsFlagsAndTypeValid( 3060| 434| ColumnFlag::function_name), 3061| 434| "Column type and flag combination is not valid"); 3062| 434| static_assert( 3063| 434| ColumnLegacy::IsFlagsAndTypeValid( 3064| 434| ColumnFlag::tier), 3065| 434| "Column type and flag combination is not valid"); 3066| 434| static_assert( 3067| 434| ColumnLegacy::IsFlagsAndTypeValid( 3068| 434| ColumnFlag::code_offset_in_module), 3069| 434| "Column type and flag combination is not valid"); 3070| 434| OnConstructionCompletedRegularConstructor( 3071| 434| {id_storage_layer_,jit_code_id_storage_layer_,v8_isolate_id_storage_layer_,v8_wasm_script_id_storage_layer_,function_name_storage_layer_,tier_storage_layer_,code_offset_in_module_storage_layer_}, 3072| 434| {{},{},{},{},{},{},{}}); 3073| 434| } _ZN8perfetto15trace_processor6tables17V8RegexpCodeTable10GetColumnsEPS2_PKNS0_15macros_internal10MacroTableE: 3414| 434| const macros_internal::MacroTable* parent) { 3415| 434| std::vector columns = 3416| 434| CopyColumnsFromParentOrAddRootColumns(parent); 3417| 434| uint32_t olay_idx = OverlayCount(parent); 3418| 434| AddColumnToVector(columns, "jit_code_id", &self->jit_code_id_, ColumnFlag::jit_code_id, 3419| 434| static_cast(columns.size()), olay_idx); 3420| 434| AddColumnToVector(columns, "v8_isolate_id", &self->v8_isolate_id_, ColumnFlag::v8_isolate_id, 3421| 434| static_cast(columns.size()), olay_idx); 3422| 434| AddColumnToVector(columns, "pattern", &self->pattern_, ColumnFlag::pattern, 3423| 434| static_cast(columns.size()), olay_idx); 3424| 434| base::ignore_result(self); 3425| 434| return columns; 3426| 434| } _ZN8perfetto15trace_processor6tables17V8RegexpCodeTableC2EPNS0_10StringPoolE: 3429| 434| : macros_internal::MacroTable( 3430| 434| pool, 3431| 434| GetColumns(this, nullptr), 3432| 434| nullptr), 3433| 434| jit_code_id_(ColumnStorage::Create()), 3434| 434| v8_isolate_id_(ColumnStorage::Create()), 3435| 434| pattern_(ColumnStorage::Create()) 3436| |, 3437| 434| id_storage_layer_(new column::IdStorage()), 3438| 434| jit_code_id_storage_layer_( 3439| 434| new column::NumericStorage( 3440| 434| &jit_code_id_.vector(), 3441| 434| ColumnTypeHelper::ToColumnType(), 3442| 434| false)), 3443| 434| v8_isolate_id_storage_layer_( 3444| 434| new column::NumericStorage( 3445| 434| &v8_isolate_id_.vector(), 3446| 434| ColumnTypeHelper::ToColumnType(), 3447| 434| false)), 3448| 434| pattern_storage_layer_( 3449| 434| new column::StringStorage(string_pool(), &pattern_.vector())) 3450| 434| { 3451| 434| static_assert( 3452| 434| ColumnLegacy::IsFlagsAndTypeValid( 3453| 434| ColumnFlag::jit_code_id), 3454| 434| "Column type and flag combination is not valid"); 3455| 434| static_assert( 3456| 434| ColumnLegacy::IsFlagsAndTypeValid( 3457| 434| ColumnFlag::v8_isolate_id), 3458| 434| "Column type and flag combination is not valid"); 3459| 434| static_assert( 3460| 434| ColumnLegacy::IsFlagsAndTypeValid( 3461| 434| ColumnFlag::pattern), 3462| 434| "Column type and flag combination is not valid"); 3463| 434| OnConstructionCompletedRegularConstructor( 3464| 434| {id_storage_layer_,jit_code_id_storage_layer_,v8_isolate_id_storage_layer_,pattern_storage_layer_}, 3465| 434| {{},{},{},{}}); 3466| 434| } _ZN8perfetto15trace_processor6tables13ProtoLogTable10GetColumnsEPS2_PKNS0_15macros_internal10MacroTableE: 267| 434| const macros_internal::MacroTable* parent) { 268| 434| std::vector columns = 269| 434| CopyColumnsFromParentOrAddRootColumns(parent); 270| 434| uint32_t olay_idx = OverlayCount(parent); 271| 434| AddColumnToVector(columns, "ts", &self->ts_, ColumnFlag::ts, 272| 434| static_cast(columns.size()), olay_idx); 273| 434| AddColumnToVector(columns, "level", &self->level_, ColumnFlag::level, 274| 434| static_cast(columns.size()), olay_idx); 275| 434| AddColumnToVector(columns, "tag", &self->tag_, ColumnFlag::tag, 276| 434| static_cast(columns.size()), olay_idx); 277| 434| AddColumnToVector(columns, "message", &self->message_, ColumnFlag::message, 278| 434| static_cast(columns.size()), olay_idx); 279| 434| AddColumnToVector(columns, "stacktrace", &self->stacktrace_, ColumnFlag::stacktrace, 280| 434| static_cast(columns.size()), olay_idx); 281| 434| AddColumnToVector(columns, "location", &self->location_, ColumnFlag::location, 282| 434| static_cast(columns.size()), olay_idx); 283| 434| base::ignore_result(self); 284| 434| return columns; 285| 434| } _ZN8perfetto15trace_processor6tables13ProtoLogTableC2EPNS0_10StringPoolE: 288| 434| : macros_internal::MacroTable( 289| 434| pool, 290| 434| GetColumns(this, nullptr), 291| 434| nullptr), 292| 434| ts_(ColumnStorage::Create()), 293| 434| level_(ColumnStorage::Create()), 294| 434| tag_(ColumnStorage::Create()), 295| 434| message_(ColumnStorage::Create()), 296| 434| stacktrace_(ColumnStorage::Create()), 297| 434| location_(ColumnStorage::Create()) 298| |, 299| 434| id_storage_layer_(new column::IdStorage()), 300| 434| ts_storage_layer_( 301| 434| new column::NumericStorage( 302| 434| &ts_.vector(), 303| 434| ColumnTypeHelper::ToColumnType(), 304| 434| true)), 305| 434| level_storage_layer_( 306| 434| new column::StringStorage(string_pool(), &level_.vector())), 307| 434| tag_storage_layer_( 308| 434| new column::StringStorage(string_pool(), &tag_.vector())), 309| 434| message_storage_layer_( 310| 434| new column::StringStorage(string_pool(), &message_.vector())), 311| 434| stacktrace_storage_layer_( 312| 434| new column::StringStorage(string_pool(), &stacktrace_.vector())), 313| 434| location_storage_layer_( 314| 434| new column::StringStorage(string_pool(), &location_.vector())) 315| 434| { 316| 434| static_assert( 317| 434| ColumnLegacy::IsFlagsAndTypeValid( 318| 434| ColumnFlag::ts), 319| 434| "Column type and flag combination is not valid"); 320| 434| static_assert( 321| 434| ColumnLegacy::IsFlagsAndTypeValid( 322| 434| ColumnFlag::level), 323| 434| "Column type and flag combination is not valid"); 324| 434| static_assert( 325| 434| ColumnLegacy::IsFlagsAndTypeValid( 326| 434| ColumnFlag::tag), 327| 434| "Column type and flag combination is not valid"); 328| 434| static_assert( 329| 434| ColumnLegacy::IsFlagsAndTypeValid( 330| 434| ColumnFlag::message), 331| 434| "Column type and flag combination is not valid"); 332| 434| static_assert( 333| 434| ColumnLegacy::IsFlagsAndTypeValid( 334| 434| ColumnFlag::stacktrace), 335| 434| "Column type and flag combination is not valid"); 336| 434| static_assert( 337| 434| ColumnLegacy::IsFlagsAndTypeValid( 338| 434| ColumnFlag::location), 339| 434| "Column type and flag combination is not valid"); 340| 434| OnConstructionCompletedRegularConstructor( 341| 434| {id_storage_layer_,ts_storage_layer_,level_storage_layer_,tag_storage_layer_,message_storage_layer_,stacktrace_storage_layer_,location_storage_layer_}, 342| 434| {{},{},{},{},{},{},{}}); 343| 434| } _ZN8perfetto15trace_processor6tables23InputMethodClientsTable10GetColumnsEPS2_PKNS0_15macros_internal10MacroTableE: 684| 434| const macros_internal::MacroTable* parent) { 685| 434| std::vector columns = 686| 434| CopyColumnsFromParentOrAddRootColumns(parent); 687| 434| uint32_t olay_idx = OverlayCount(parent); 688| 434| AddColumnToVector(columns, "ts", &self->ts_, ColumnFlag::ts, 689| 434| static_cast(columns.size()), olay_idx); 690| 434| AddColumnToVector(columns, "arg_set_id", &self->arg_set_id_, ColumnFlag::arg_set_id, 691| 434| static_cast(columns.size()), olay_idx); 692| 434| AddColumnToVector(columns, "base64_proto_id", &self->base64_proto_id_, ColumnFlag::base64_proto_id, 693| 434| static_cast(columns.size()), olay_idx); 694| 434| base::ignore_result(self); 695| 434| return columns; 696| 434| } _ZN8perfetto15trace_processor6tables23InputMethodClientsTableC2EPNS0_10StringPoolE: 699| 434| : macros_internal::MacroTable( 700| 434| pool, 701| 434| GetColumns(this, nullptr), 702| 434| nullptr), 703| 434| ts_(ColumnStorage::Create()), 704| 434| arg_set_id_(ColumnStorage::Create()), 705| 434| base64_proto_id_(ColumnStorage::Create()) 706| |, 707| 434| id_storage_layer_(new column::IdStorage()), 708| 434| ts_storage_layer_( 709| 434| new column::NumericStorage( 710| 434| &ts_.vector(), 711| 434| ColumnTypeHelper::ToColumnType(), 712| 434| true)), 713| 434| arg_set_id_storage_layer_( 714| 434| new column::NumericStorage( 715| 434| &arg_set_id_.non_null_vector(), 716| 434| ColumnTypeHelper::ToColumnType(), 717| 434| false)), 718| 434| base64_proto_id_storage_layer_( 719| 434| new column::NumericStorage( 720| 434| &base64_proto_id_.non_null_vector(), 721| 434| ColumnTypeHelper::ToColumnType(), 722| 434| false)) 723| |, 724| 434| arg_set_id_null_layer_(new column::NullOverlay(arg_set_id_.bv())), 725| 434| base64_proto_id_null_layer_(new column::NullOverlay(base64_proto_id_.bv())) { 726| 434| static_assert( 727| 434| ColumnLegacy::IsFlagsAndTypeValid( 728| 434| ColumnFlag::ts), 729| 434| "Column type and flag combination is not valid"); 730| 434| static_assert( 731| 434| ColumnLegacy::IsFlagsAndTypeValid( 732| 434| ColumnFlag::arg_set_id), 733| 434| "Column type and flag combination is not valid"); 734| 434| static_assert( 735| 434| ColumnLegacy::IsFlagsAndTypeValid( 736| 434| ColumnFlag::base64_proto_id), 737| 434| "Column type and flag combination is not valid"); 738| 434| OnConstructionCompletedRegularConstructor( 739| 434| {id_storage_layer_,ts_storage_layer_,arg_set_id_storage_layer_,base64_proto_id_storage_layer_}, 740| 434| {{},{},arg_set_id_null_layer_,base64_proto_id_null_layer_}); 741| 434| } _ZN8perfetto15trace_processor6tables30InputMethodManagerServiceTable10GetColumnsEPS2_PKNS0_15macros_internal10MacroTableE: 1035| 434| const macros_internal::MacroTable* parent) { 1036| 434| std::vector columns = 1037| 434| CopyColumnsFromParentOrAddRootColumns(parent); 1038| 434| uint32_t olay_idx = OverlayCount(parent); 1039| 434| AddColumnToVector(columns, "ts", &self->ts_, ColumnFlag::ts, 1040| 434| static_cast(columns.size()), olay_idx); 1041| 434| AddColumnToVector(columns, "arg_set_id", &self->arg_set_id_, ColumnFlag::arg_set_id, 1042| 434| static_cast(columns.size()), olay_idx); 1043| 434| AddColumnToVector(columns, "base64_proto_id", &self->base64_proto_id_, ColumnFlag::base64_proto_id, 1044| 434| static_cast(columns.size()), olay_idx); 1045| 434| base::ignore_result(self); 1046| 434| return columns; 1047| 434| } _ZN8perfetto15trace_processor6tables30InputMethodManagerServiceTableC2EPNS0_10StringPoolE: 1050| 434| : macros_internal::MacroTable( 1051| 434| pool, 1052| 434| GetColumns(this, nullptr), 1053| 434| nullptr), 1054| 434| ts_(ColumnStorage::Create()), 1055| 434| arg_set_id_(ColumnStorage::Create()), 1056| 434| base64_proto_id_(ColumnStorage::Create()) 1057| |, 1058| 434| id_storage_layer_(new column::IdStorage()), 1059| 434| ts_storage_layer_( 1060| 434| new column::NumericStorage( 1061| 434| &ts_.vector(), 1062| 434| ColumnTypeHelper::ToColumnType(), 1063| 434| true)), 1064| 434| arg_set_id_storage_layer_( 1065| 434| new column::NumericStorage( 1066| 434| &arg_set_id_.non_null_vector(), 1067| 434| ColumnTypeHelper::ToColumnType(), 1068| 434| false)), 1069| 434| base64_proto_id_storage_layer_( 1070| 434| new column::NumericStorage( 1071| 434| &base64_proto_id_.non_null_vector(), 1072| 434| ColumnTypeHelper::ToColumnType(), 1073| 434| false)) 1074| |, 1075| 434| arg_set_id_null_layer_(new column::NullOverlay(arg_set_id_.bv())), 1076| 434| base64_proto_id_null_layer_(new column::NullOverlay(base64_proto_id_.bv())) { 1077| 434| static_assert( 1078| 434| ColumnLegacy::IsFlagsAndTypeValid( 1079| 434| ColumnFlag::ts), 1080| 434| "Column type and flag combination is not valid"); 1081| 434| static_assert( 1082| 434| ColumnLegacy::IsFlagsAndTypeValid( 1083| 434| ColumnFlag::arg_set_id), 1084| 434| "Column type and flag combination is not valid"); 1085| 434| static_assert( 1086| 434| ColumnLegacy::IsFlagsAndTypeValid( 1087| 434| ColumnFlag::base64_proto_id), 1088| 434| "Column type and flag combination is not valid"); 1089| 434| OnConstructionCompletedRegularConstructor( 1090| 434| {id_storage_layer_,ts_storage_layer_,arg_set_id_storage_layer_,base64_proto_id_storage_layer_}, 1091| 434| {{},{},arg_set_id_null_layer_,base64_proto_id_null_layer_}); 1092| 434| } _ZN8perfetto15trace_processor6tables23InputMethodServiceTable10GetColumnsEPS2_PKNS0_15macros_internal10MacroTableE: 1386| 434| const macros_internal::MacroTable* parent) { 1387| 434| std::vector columns = 1388| 434| CopyColumnsFromParentOrAddRootColumns(parent); 1389| 434| uint32_t olay_idx = OverlayCount(parent); 1390| 434| AddColumnToVector(columns, "ts", &self->ts_, ColumnFlag::ts, 1391| 434| static_cast(columns.size()), olay_idx); 1392| 434| AddColumnToVector(columns, "arg_set_id", &self->arg_set_id_, ColumnFlag::arg_set_id, 1393| 434| static_cast(columns.size()), olay_idx); 1394| 434| AddColumnToVector(columns, "base64_proto_id", &self->base64_proto_id_, ColumnFlag::base64_proto_id, 1395| 434| static_cast(columns.size()), olay_idx); 1396| 434| base::ignore_result(self); 1397| 434| return columns; 1398| 434| } _ZN8perfetto15trace_processor6tables23InputMethodServiceTableC2EPNS0_10StringPoolE: 1401| 434| : macros_internal::MacroTable( 1402| 434| pool, 1403| 434| GetColumns(this, nullptr), 1404| 434| nullptr), 1405| 434| ts_(ColumnStorage::Create()), 1406| 434| arg_set_id_(ColumnStorage::Create()), 1407| 434| base64_proto_id_(ColumnStorage::Create()) 1408| |, 1409| 434| id_storage_layer_(new column::IdStorage()), 1410| 434| ts_storage_layer_( 1411| 434| new column::NumericStorage( 1412| 434| &ts_.vector(), 1413| 434| ColumnTypeHelper::ToColumnType(), 1414| 434| true)), 1415| 434| arg_set_id_storage_layer_( 1416| 434| new column::NumericStorage( 1417| 434| &arg_set_id_.non_null_vector(), 1418| 434| ColumnTypeHelper::ToColumnType(), 1419| 434| false)), 1420| 434| base64_proto_id_storage_layer_( 1421| 434| new column::NumericStorage( 1422| 434| &base64_proto_id_.non_null_vector(), 1423| 434| ColumnTypeHelper::ToColumnType(), 1424| 434| false)) 1425| |, 1426| 434| arg_set_id_null_layer_(new column::NullOverlay(arg_set_id_.bv())), 1427| 434| base64_proto_id_null_layer_(new column::NullOverlay(base64_proto_id_.bv())) { 1428| 434| static_assert( 1429| 434| ColumnLegacy::IsFlagsAndTypeValid( 1430| 434| ColumnFlag::ts), 1431| 434| "Column type and flag combination is not valid"); 1432| 434| static_assert( 1433| 434| ColumnLegacy::IsFlagsAndTypeValid( 1434| 434| ColumnFlag::arg_set_id), 1435| 434| "Column type and flag combination is not valid"); 1436| 434| static_assert( 1437| 434| ColumnLegacy::IsFlagsAndTypeValid( 1438| 434| ColumnFlag::base64_proto_id), 1439| 434| "Column type and flag combination is not valid"); 1440| 434| OnConstructionCompletedRegularConstructor( 1441| 434| {id_storage_layer_,ts_storage_layer_,arg_set_id_storage_layer_,base64_proto_id_storage_layer_}, 1442| 434| {{},{},arg_set_id_null_layer_,base64_proto_id_null_layer_}); 1443| 434| } _ZN8perfetto15trace_processor6tables33SurfaceFlingerLayersSnapshotTable10GetColumnsEPS2_PKNS0_15macros_internal10MacroTableE: 1737| 434| const macros_internal::MacroTable* parent) { 1738| 434| std::vector columns = 1739| 434| CopyColumnsFromParentOrAddRootColumns(parent); 1740| 434| uint32_t olay_idx = OverlayCount(parent); 1741| 434| AddColumnToVector(columns, "ts", &self->ts_, ColumnFlag::ts, 1742| 434| static_cast(columns.size()), olay_idx); 1743| 434| AddColumnToVector(columns, "arg_set_id", &self->arg_set_id_, ColumnFlag::arg_set_id, 1744| 434| static_cast(columns.size()), olay_idx); 1745| 434| AddColumnToVector(columns, "base64_proto_id", &self->base64_proto_id_, ColumnFlag::base64_proto_id, 1746| 434| static_cast(columns.size()), olay_idx); 1747| 434| base::ignore_result(self); 1748| 434| return columns; 1749| 434| } _ZN8perfetto15trace_processor6tables33SurfaceFlingerLayersSnapshotTableC2EPNS0_10StringPoolE: 1752| 434| : macros_internal::MacroTable( 1753| 434| pool, 1754| 434| GetColumns(this, nullptr), 1755| 434| nullptr), 1756| 434| ts_(ColumnStorage::Create()), 1757| 434| arg_set_id_(ColumnStorage::Create()), 1758| 434| base64_proto_id_(ColumnStorage::Create()) 1759| |, 1760| 434| id_storage_layer_(new column::IdStorage()), 1761| 434| ts_storage_layer_( 1762| 434| new column::NumericStorage( 1763| 434| &ts_.vector(), 1764| 434| ColumnTypeHelper::ToColumnType(), 1765| 434| true)), 1766| 434| arg_set_id_storage_layer_( 1767| 434| new column::NumericStorage( 1768| 434| &arg_set_id_.non_null_vector(), 1769| 434| ColumnTypeHelper::ToColumnType(), 1770| 434| false)), 1771| 434| base64_proto_id_storage_layer_( 1772| 434| new column::NumericStorage( 1773| 434| &base64_proto_id_.non_null_vector(), 1774| 434| ColumnTypeHelper::ToColumnType(), 1775| 434| false)) 1776| |, 1777| 434| arg_set_id_null_layer_(new column::NullOverlay(arg_set_id_.bv())), 1778| 434| base64_proto_id_null_layer_(new column::NullOverlay(base64_proto_id_.bv())) { 1779| 434| static_assert( 1780| 434| ColumnLegacy::IsFlagsAndTypeValid( 1781| 434| ColumnFlag::ts), 1782| 434| "Column type and flag combination is not valid"); 1783| 434| static_assert( 1784| 434| ColumnLegacy::IsFlagsAndTypeValid( 1785| 434| ColumnFlag::arg_set_id), 1786| 434| "Column type and flag combination is not valid"); 1787| 434| static_assert( 1788| 434| ColumnLegacy::IsFlagsAndTypeValid( 1789| 434| ColumnFlag::base64_proto_id), 1790| 434| "Column type and flag combination is not valid"); 1791| 434| OnConstructionCompletedRegularConstructor( 1792| 434| {id_storage_layer_,ts_storage_layer_,arg_set_id_storage_layer_,base64_proto_id_storage_layer_}, 1793| 434| {{},{},arg_set_id_null_layer_,base64_proto_id_null_layer_}); 1794| 434| } _ZN8perfetto15trace_processor6tables24SurfaceFlingerLayerTable10GetColumnsEPS2_PKNS0_15macros_internal10MacroTableE: 2088| 434| const macros_internal::MacroTable* parent) { 2089| 434| std::vector columns = 2090| 434| CopyColumnsFromParentOrAddRootColumns(parent); 2091| 434| uint32_t olay_idx = OverlayCount(parent); 2092| 434| AddColumnToVector(columns, "snapshot_id", &self->snapshot_id_, ColumnFlag::snapshot_id, 2093| 434| static_cast(columns.size()), olay_idx); 2094| 434| AddColumnToVector(columns, "arg_set_id", &self->arg_set_id_, ColumnFlag::arg_set_id, 2095| 434| static_cast(columns.size()), olay_idx); 2096| 434| AddColumnToVector(columns, "base64_proto_id", &self->base64_proto_id_, ColumnFlag::base64_proto_id, 2097| 434| static_cast(columns.size()), olay_idx); 2098| 434| base::ignore_result(self); 2099| 434| return columns; 2100| 434| } _ZN8perfetto15trace_processor6tables24SurfaceFlingerLayerTableC2EPNS0_10StringPoolE: 2103| 434| : macros_internal::MacroTable( 2104| 434| pool, 2105| 434| GetColumns(this, nullptr), 2106| 434| nullptr), 2107| 434| snapshot_id_(ColumnStorage::Create()), 2108| 434| arg_set_id_(ColumnStorage::Create()), 2109| 434| base64_proto_id_(ColumnStorage::Create()) 2110| |, 2111| 434| id_storage_layer_(new column::IdStorage()), 2112| 434| snapshot_id_storage_layer_( 2113| 434| new column::NumericStorage( 2114| 434| &snapshot_id_.vector(), 2115| 434| ColumnTypeHelper::ToColumnType(), 2116| 434| false)), 2117| 434| arg_set_id_storage_layer_( 2118| 434| new column::NumericStorage( 2119| 434| &arg_set_id_.non_null_vector(), 2120| 434| ColumnTypeHelper::ToColumnType(), 2121| 434| false)), 2122| 434| base64_proto_id_storage_layer_( 2123| 434| new column::NumericStorage( 2124| 434| &base64_proto_id_.non_null_vector(), 2125| 434| ColumnTypeHelper::ToColumnType(), 2126| 434| false)) 2127| |, 2128| 434| arg_set_id_null_layer_(new column::NullOverlay(arg_set_id_.bv())), 2129| 434| base64_proto_id_null_layer_(new column::NullOverlay(base64_proto_id_.bv())) { 2130| 434| static_assert( 2131| 434| ColumnLegacy::IsFlagsAndTypeValid( 2132| 434| ColumnFlag::snapshot_id), 2133| 434| "Column type and flag combination is not valid"); 2134| 434| static_assert( 2135| 434| ColumnLegacy::IsFlagsAndTypeValid( 2136| 434| ColumnFlag::arg_set_id), 2137| 434| "Column type and flag combination is not valid"); 2138| 434| static_assert( 2139| 434| ColumnLegacy::IsFlagsAndTypeValid( 2140| 434| ColumnFlag::base64_proto_id), 2141| 434| "Column type and flag combination is not valid"); 2142| 434| OnConstructionCompletedRegularConstructor( 2143| 434| {id_storage_layer_,snapshot_id_storage_layer_,arg_set_id_storage_layer_,base64_proto_id_storage_layer_}, 2144| 434| {{},{},arg_set_id_null_layer_,base64_proto_id_null_layer_}); 2145| 434| } _ZN8perfetto15trace_processor6tables31SurfaceFlingerTransactionsTable10GetColumnsEPS2_PKNS0_15macros_internal10MacroTableE: 2439| 434| const macros_internal::MacroTable* parent) { 2440| 434| std::vector columns = 2441| 434| CopyColumnsFromParentOrAddRootColumns(parent); 2442| 434| uint32_t olay_idx = OverlayCount(parent); 2443| 434| AddColumnToVector(columns, "ts", &self->ts_, ColumnFlag::ts, 2444| 434| static_cast(columns.size()), olay_idx); 2445| 434| AddColumnToVector(columns, "arg_set_id", &self->arg_set_id_, ColumnFlag::arg_set_id, 2446| 434| static_cast(columns.size()), olay_idx); 2447| 434| AddColumnToVector(columns, "base64_proto_id", &self->base64_proto_id_, ColumnFlag::base64_proto_id, 2448| 434| static_cast(columns.size()), olay_idx); 2449| 434| base::ignore_result(self); 2450| 434| return columns; 2451| 434| } _ZN8perfetto15trace_processor6tables31SurfaceFlingerTransactionsTableC2EPNS0_10StringPoolE: 2454| 434| : macros_internal::MacroTable( 2455| 434| pool, 2456| 434| GetColumns(this, nullptr), 2457| 434| nullptr), 2458| 434| ts_(ColumnStorage::Create()), 2459| 434| arg_set_id_(ColumnStorage::Create()), 2460| 434| base64_proto_id_(ColumnStorage::Create()) 2461| |, 2462| 434| id_storage_layer_(new column::IdStorage()), 2463| 434| ts_storage_layer_( 2464| 434| new column::NumericStorage( 2465| 434| &ts_.vector(), 2466| 434| ColumnTypeHelper::ToColumnType(), 2467| 434| true)), 2468| 434| arg_set_id_storage_layer_( 2469| 434| new column::NumericStorage( 2470| 434| &arg_set_id_.non_null_vector(), 2471| 434| ColumnTypeHelper::ToColumnType(), 2472| 434| false)), 2473| 434| base64_proto_id_storage_layer_( 2474| 434| new column::NumericStorage( 2475| 434| &base64_proto_id_.non_null_vector(), 2476| 434| ColumnTypeHelper::ToColumnType(), 2477| 434| false)) 2478| |, 2479| 434| arg_set_id_null_layer_(new column::NullOverlay(arg_set_id_.bv())), 2480| 434| base64_proto_id_null_layer_(new column::NullOverlay(base64_proto_id_.bv())) { 2481| 434| static_assert( 2482| 434| ColumnLegacy::IsFlagsAndTypeValid( 2483| 434| ColumnFlag::ts), 2484| 434| "Column type and flag combination is not valid"); 2485| 434| static_assert( 2486| 434| ColumnLegacy::IsFlagsAndTypeValid( 2487| 434| ColumnFlag::arg_set_id), 2488| 434| "Column type and flag combination is not valid"); 2489| 434| static_assert( 2490| 434| ColumnLegacy::IsFlagsAndTypeValid( 2491| 434| ColumnFlag::base64_proto_id), 2492| 434| "Column type and flag combination is not valid"); 2493| 434| OnConstructionCompletedRegularConstructor( 2494| 434| {id_storage_layer_,ts_storage_layer_,arg_set_id_storage_layer_,base64_proto_id_storage_layer_}, 2495| 434| {{},{},arg_set_id_null_layer_,base64_proto_id_null_layer_}); 2496| 434| } _ZN8perfetto15trace_processor6tables16ViewCaptureTable10GetColumnsEPS2_PKNS0_15macros_internal10MacroTableE: 2790| 434| const macros_internal::MacroTable* parent) { 2791| 434| std::vector columns = 2792| 434| CopyColumnsFromParentOrAddRootColumns(parent); 2793| 434| uint32_t olay_idx = OverlayCount(parent); 2794| 434| AddColumnToVector(columns, "ts", &self->ts_, ColumnFlag::ts, 2795| 434| static_cast(columns.size()), olay_idx); 2796| 434| AddColumnToVector(columns, "arg_set_id", &self->arg_set_id_, ColumnFlag::arg_set_id, 2797| 434| static_cast(columns.size()), olay_idx); 2798| 434| AddColumnToVector(columns, "base64_proto_id", &self->base64_proto_id_, ColumnFlag::base64_proto_id, 2799| 434| static_cast(columns.size()), olay_idx); 2800| 434| base::ignore_result(self); 2801| 434| return columns; 2802| 434| } _ZN8perfetto15trace_processor6tables16ViewCaptureTableC2EPNS0_10StringPoolE: 2805| 434| : macros_internal::MacroTable( 2806| 434| pool, 2807| 434| GetColumns(this, nullptr), 2808| 434| nullptr), 2809| 434| ts_(ColumnStorage::Create()), 2810| 434| arg_set_id_(ColumnStorage::Create()), 2811| 434| base64_proto_id_(ColumnStorage::Create()) 2812| |, 2813| 434| id_storage_layer_(new column::IdStorage()), 2814| 434| ts_storage_layer_( 2815| 434| new column::NumericStorage( 2816| 434| &ts_.vector(), 2817| 434| ColumnTypeHelper::ToColumnType(), 2818| 434| true)), 2819| 434| arg_set_id_storage_layer_( 2820| 434| new column::NumericStorage( 2821| 434| &arg_set_id_.non_null_vector(), 2822| 434| ColumnTypeHelper::ToColumnType(), 2823| 434| false)), 2824| 434| base64_proto_id_storage_layer_( 2825| 434| new column::NumericStorage( 2826| 434| &base64_proto_id_.non_null_vector(), 2827| 434| ColumnTypeHelper::ToColumnType(), 2828| 434| false)) 2829| |, 2830| 434| arg_set_id_null_layer_(new column::NullOverlay(arg_set_id_.bv())), 2831| 434| base64_proto_id_null_layer_(new column::NullOverlay(base64_proto_id_.bv())) { 2832| 434| static_assert( 2833| 434| ColumnLegacy::IsFlagsAndTypeValid( 2834| 434| ColumnFlag::ts), 2835| 434| "Column type and flag combination is not valid"); 2836| 434| static_assert( 2837| 434| ColumnLegacy::IsFlagsAndTypeValid( 2838| 434| ColumnFlag::arg_set_id), 2839| 434| "Column type and flag combination is not valid"); 2840| 434| static_assert( 2841| 434| ColumnLegacy::IsFlagsAndTypeValid( 2842| 434| ColumnFlag::base64_proto_id), 2843| 434| "Column type and flag combination is not valid"); 2844| 434| OnConstructionCompletedRegularConstructor( 2845| 434| {id_storage_layer_,ts_storage_layer_,arg_set_id_storage_layer_,base64_proto_id_storage_layer_}, 2846| 434| {{},{},arg_set_id_null_layer_,base64_proto_id_null_layer_}); 2847| 434| } _ZN8perfetto15trace_processor6tables20ViewCaptureViewTable10GetColumnsEPS2_PKNS0_15macros_internal10MacroTableE: 3141| 434| const macros_internal::MacroTable* parent) { 3142| 434| std::vector columns = 3143| 434| CopyColumnsFromParentOrAddRootColumns(parent); 3144| 434| uint32_t olay_idx = OverlayCount(parent); 3145| 434| AddColumnToVector(columns, "snapshot_id", &self->snapshot_id_, ColumnFlag::snapshot_id, 3146| 434| static_cast(columns.size()), olay_idx); 3147| 434| AddColumnToVector(columns, "arg_set_id", &self->arg_set_id_, ColumnFlag::arg_set_id, 3148| 434| static_cast(columns.size()), olay_idx); 3149| 434| AddColumnToVector(columns, "base64_proto_id", &self->base64_proto_id_, ColumnFlag::base64_proto_id, 3150| 434| static_cast(columns.size()), olay_idx); 3151| 434| base::ignore_result(self); 3152| 434| return columns; 3153| 434| } _ZN8perfetto15trace_processor6tables20ViewCaptureViewTableC2EPNS0_10StringPoolE: 3156| 434| : macros_internal::MacroTable( 3157| 434| pool, 3158| 434| GetColumns(this, nullptr), 3159| 434| nullptr), 3160| 434| snapshot_id_(ColumnStorage::Create()), 3161| 434| arg_set_id_(ColumnStorage::Create()), 3162| 434| base64_proto_id_(ColumnStorage::Create()) 3163| |, 3164| 434| id_storage_layer_(new column::IdStorage()), 3165| 434| snapshot_id_storage_layer_( 3166| 434| new column::NumericStorage( 3167| 434| &snapshot_id_.vector(), 3168| 434| ColumnTypeHelper::ToColumnType(), 3169| 434| false)), 3170| 434| arg_set_id_storage_layer_( 3171| 434| new column::NumericStorage( 3172| 434| &arg_set_id_.non_null_vector(), 3173| 434| ColumnTypeHelper::ToColumnType(), 3174| 434| false)), 3175| 434| base64_proto_id_storage_layer_( 3176| 434| new column::NumericStorage( 3177| 434| &base64_proto_id_.non_null_vector(), 3178| 434| ColumnTypeHelper::ToColumnType(), 3179| 434| false)) 3180| |, 3181| 434| arg_set_id_null_layer_(new column::NullOverlay(arg_set_id_.bv())), 3182| 434| base64_proto_id_null_layer_(new column::NullOverlay(base64_proto_id_.bv())) { 3183| 434| static_assert( 3184| 434| ColumnLegacy::IsFlagsAndTypeValid( 3185| 434| ColumnFlag::snapshot_id), 3186| 434| "Column type and flag combination is not valid"); 3187| 434| static_assert( 3188| 434| ColumnLegacy::IsFlagsAndTypeValid( 3189| 434| ColumnFlag::arg_set_id), 3190| 434| "Column type and flag combination is not valid"); 3191| 434| static_assert( 3192| 434| ColumnLegacy::IsFlagsAndTypeValid( 3193| 434| ColumnFlag::base64_proto_id), 3194| 434| "Column type and flag combination is not valid"); 3195| 434| OnConstructionCompletedRegularConstructor( 3196| 434| {id_storage_layer_,snapshot_id_storage_layer_,arg_set_id_storage_layer_,base64_proto_id_storage_layer_}, 3197| 434| {{},{},arg_set_id_null_layer_,base64_proto_id_null_layer_}); 3198| 434| } _ZN8perfetto15trace_processor6tables28ViewCaptureInternedDataTable10GetColumnsEPS2_PKNS0_15macros_internal10MacroTableE: 3511| 434| const macros_internal::MacroTable* parent) { 3512| 434| std::vector columns = 3513| 434| CopyColumnsFromParentOrAddRootColumns(parent); 3514| 434| uint32_t olay_idx = OverlayCount(parent); 3515| 434| AddColumnToVector(columns, "base64_proto_id", &self->base64_proto_id_, ColumnFlag::base64_proto_id, 3516| 434| static_cast(columns.size()), olay_idx); 3517| 434| AddColumnToVector(columns, "flat_key", &self->flat_key_, ColumnFlag::flat_key, 3518| 434| static_cast(columns.size()), olay_idx); 3519| 434| AddColumnToVector(columns, "iid", &self->iid_, ColumnFlag::iid, 3520| 434| static_cast(columns.size()), olay_idx); 3521| 434| AddColumnToVector(columns, "deinterned_value", &self->deinterned_value_, ColumnFlag::deinterned_value, 3522| 434| static_cast(columns.size()), olay_idx); 3523| 434| base::ignore_result(self); 3524| 434| return columns; 3525| 434| } _ZN8perfetto15trace_processor6tables28ViewCaptureInternedDataTableC2EPNS0_10StringPoolE: 3528| 434| : macros_internal::MacroTable( 3529| 434| pool, 3530| 434| GetColumns(this, nullptr), 3531| 434| nullptr), 3532| 434| base64_proto_id_(ColumnStorage::Create()), 3533| 434| flat_key_(ColumnStorage::Create()), 3534| 434| iid_(ColumnStorage::Create()), 3535| 434| deinterned_value_(ColumnStorage::Create()) 3536| |, 3537| 434| id_storage_layer_(new column::IdStorage()), 3538| 434| base64_proto_id_storage_layer_( 3539| 434| new column::NumericStorage( 3540| 434| &base64_proto_id_.vector(), 3541| 434| ColumnTypeHelper::ToColumnType(), 3542| 434| false)), 3543| 434| flat_key_storage_layer_( 3544| 434| new column::StringStorage(string_pool(), &flat_key_.vector())), 3545| 434| iid_storage_layer_( 3546| 434| new column::NumericStorage( 3547| 434| &iid_.vector(), 3548| 434| ColumnTypeHelper::ToColumnType(), 3549| 434| false)), 3550| 434| deinterned_value_storage_layer_( 3551| 434| new column::StringStorage(string_pool(), &deinterned_value_.vector())) 3552| 434| { 3553| 434| static_assert( 3554| 434| ColumnLegacy::IsFlagsAndTypeValid( 3555| 434| ColumnFlag::base64_proto_id), 3556| 434| "Column type and flag combination is not valid"); 3557| 434| static_assert( 3558| 434| ColumnLegacy::IsFlagsAndTypeValid( 3559| 434| ColumnFlag::flat_key), 3560| 434| "Column type and flag combination is not valid"); 3561| 434| static_assert( 3562| 434| ColumnLegacy::IsFlagsAndTypeValid( 3563| 434| ColumnFlag::iid), 3564| 434| "Column type and flag combination is not valid"); 3565| 434| static_assert( 3566| 434| ColumnLegacy::IsFlagsAndTypeValid( 3567| 434| ColumnFlag::deinterned_value), 3568| 434| "Column type and flag combination is not valid"); 3569| 434| OnConstructionCompletedRegularConstructor( 3570| 434| {id_storage_layer_,base64_proto_id_storage_layer_,flat_key_storage_layer_,iid_storage_layer_,deinterned_value_storage_layer_}, 3571| 434| {{},{},{},{},{}}); 3572| 434| } _ZN8perfetto15trace_processor6tables34WindowManagerShellTransitionsTable10GetColumnsEPS2_PKNS0_15macros_internal10MacroTableE: 3881| 434| const macros_internal::MacroTable* parent) { 3882| 434| std::vector columns = 3883| 434| CopyColumnsFromParentOrAddRootColumns(parent); 3884| 434| uint32_t olay_idx = OverlayCount(parent); 3885| 434| AddColumnToVector(columns, "ts", &self->ts_, ColumnFlag::ts, 3886| 434| static_cast(columns.size()), olay_idx); 3887| 434| AddColumnToVector(columns, "transition_id", &self->transition_id_, ColumnFlag::transition_id, 3888| 434| static_cast(columns.size()), olay_idx); 3889| 434| AddColumnToVector(columns, "arg_set_id", &self->arg_set_id_, ColumnFlag::arg_set_id, 3890| 434| static_cast(columns.size()), olay_idx); 3891| 434| base::ignore_result(self); 3892| 434| return columns; 3893| 434| } _ZN8perfetto15trace_processor6tables34WindowManagerShellTransitionsTableC2EPNS0_10StringPoolE: 3896| 434| : macros_internal::MacroTable( 3897| 434| pool, 3898| 434| GetColumns(this, nullptr), 3899| 434| nullptr), 3900| 434| ts_(ColumnStorage::Create()), 3901| 434| transition_id_(ColumnStorage::Create()), 3902| 434| arg_set_id_(ColumnStorage::Create()) 3903| |, 3904| 434| id_storage_layer_(new column::IdStorage()), 3905| 434| ts_storage_layer_( 3906| 434| new column::NumericStorage( 3907| 434| &ts_.vector(), 3908| 434| ColumnTypeHelper::ToColumnType(), 3909| 434| false)), 3910| 434| transition_id_storage_layer_( 3911| 434| new column::NumericStorage( 3912| 434| &transition_id_.vector(), 3913| 434| ColumnTypeHelper::ToColumnType(), 3914| 434| true)), 3915| 434| arg_set_id_storage_layer_( 3916| 434| new column::NumericStorage( 3917| 434| &arg_set_id_.non_null_vector(), 3918| 434| ColumnTypeHelper::ToColumnType(), 3919| 434| false)) 3920| |, 3921| 434| arg_set_id_null_layer_(new column::NullOverlay(arg_set_id_.bv())) { 3922| 434| static_assert( 3923| 434| ColumnLegacy::IsFlagsAndTypeValid( 3924| 434| ColumnFlag::ts), 3925| 434| "Column type and flag combination is not valid"); 3926| 434| static_assert( 3927| 434| ColumnLegacy::IsFlagsAndTypeValid( 3928| 434| ColumnFlag::transition_id), 3929| 434| "Column type and flag combination is not valid"); 3930| 434| static_assert( 3931| 434| ColumnLegacy::IsFlagsAndTypeValid( 3932| 434| ColumnFlag::arg_set_id), 3933| 434| "Column type and flag combination is not valid"); 3934| 434| OnConstructionCompletedRegularConstructor( 3935| 434| {id_storage_layer_,ts_storage_layer_,transition_id_storage_layer_,arg_set_id_storage_layer_}, 3936| 434| {{},{},{},arg_set_id_null_layer_}); 3937| 434| } _ZN8perfetto15trace_processor6tables41WindowManagerShellTransitionHandlersTable10GetColumnsEPS2_PKNS0_15macros_internal10MacroTableE: 4230| 434| const macros_internal::MacroTable* parent) { 4231| 434| std::vector columns = 4232| 434| CopyColumnsFromParentOrAddRootColumns(parent); 4233| 434| uint32_t olay_idx = OverlayCount(parent); 4234| 434| AddColumnToVector(columns, "handler_id", &self->handler_id_, ColumnFlag::handler_id, 4235| 434| static_cast(columns.size()), olay_idx); 4236| 434| AddColumnToVector(columns, "handler_name", &self->handler_name_, ColumnFlag::handler_name, 4237| 434| static_cast(columns.size()), olay_idx); 4238| 434| AddColumnToVector(columns, "base64_proto_id", &self->base64_proto_id_, ColumnFlag::base64_proto_id, 4239| 434| static_cast(columns.size()), olay_idx); 4240| 434| base::ignore_result(self); 4241| 434| return columns; 4242| 434| } _ZN8perfetto15trace_processor6tables41WindowManagerShellTransitionHandlersTableC2EPNS0_10StringPoolE: 4245| 434| : macros_internal::MacroTable( 4246| 434| pool, 4247| 434| GetColumns(this, nullptr), 4248| 434| nullptr), 4249| 434| handler_id_(ColumnStorage::Create()), 4250| 434| handler_name_(ColumnStorage::Create()), 4251| 434| base64_proto_id_(ColumnStorage::Create()) 4252| |, 4253| 434| id_storage_layer_(new column::IdStorage()), 4254| 434| handler_id_storage_layer_( 4255| 434| new column::NumericStorage( 4256| 434| &handler_id_.vector(), 4257| 434| ColumnTypeHelper::ToColumnType(), 4258| 434| false)), 4259| 434| handler_name_storage_layer_( 4260| 434| new column::StringStorage(string_pool(), &handler_name_.vector())), 4261| 434| base64_proto_id_storage_layer_( 4262| 434| new column::NumericStorage( 4263| 434| &base64_proto_id_.non_null_vector(), 4264| 434| ColumnTypeHelper::ToColumnType(), 4265| 434| false)) 4266| |, 4267| 434| base64_proto_id_null_layer_(new column::NullOverlay(base64_proto_id_.bv())) { 4268| 434| static_assert( 4269| 434| ColumnLegacy::IsFlagsAndTypeValid( 4270| 434| ColumnFlag::handler_id), 4271| 434| "Column type and flag combination is not valid"); 4272| 434| static_assert( 4273| 434| ColumnLegacy::IsFlagsAndTypeValid( 4274| 434| ColumnFlag::handler_name), 4275| 434| "Column type and flag combination is not valid"); 4276| 434| static_assert( 4277| 434| ColumnLegacy::IsFlagsAndTypeValid( 4278| 434| ColumnFlag::base64_proto_id), 4279| 434| "Column type and flag combination is not valid"); 4280| 434| OnConstructionCompletedRegularConstructor( 4281| 434| {id_storage_layer_,handler_id_storage_layer_,handler_name_storage_layer_,base64_proto_id_storage_layer_}, 4282| 434| {{},{},{},base64_proto_id_null_layer_}); 4283| 434| } _ZN8perfetto15trace_processor6tables39WindowManagerShellTransitionProtosTable10GetColumnsEPS2_PKNS0_15macros_internal10MacroTableE: 4557| 434| const macros_internal::MacroTable* parent) { 4558| 434| std::vector columns = 4559| 434| CopyColumnsFromParentOrAddRootColumns(parent); 4560| 434| uint32_t olay_idx = OverlayCount(parent); 4561| 434| AddColumnToVector(columns, "transition_id", &self->transition_id_, ColumnFlag::transition_id, 4562| 434| static_cast(columns.size()), olay_idx); 4563| 434| AddColumnToVector(columns, "base64_proto_id", &self->base64_proto_id_, ColumnFlag::base64_proto_id, 4564| 434| static_cast(columns.size()), olay_idx); 4565| 434| base::ignore_result(self); 4566| 434| return columns; 4567| 434| } _ZN8perfetto15trace_processor6tables39WindowManagerShellTransitionProtosTableC2EPNS0_10StringPoolE: 4570| 434| : macros_internal::MacroTable( 4571| 434| pool, 4572| 434| GetColumns(this, nullptr), 4573| 434| nullptr), 4574| 434| transition_id_(ColumnStorage::Create()), 4575| 434| base64_proto_id_(ColumnStorage::Create()) 4576| |, 4577| 434| id_storage_layer_(new column::IdStorage()), 4578| 434| transition_id_storage_layer_( 4579| 434| new column::NumericStorage( 4580| 434| &transition_id_.vector(), 4581| 434| ColumnTypeHelper::ToColumnType(), 4582| 434| false)), 4583| 434| base64_proto_id_storage_layer_( 4584| 434| new column::NumericStorage( 4585| 434| &base64_proto_id_.vector(), 4586| 434| ColumnTypeHelper::ToColumnType(), 4587| 434| false)) 4588| 434| { 4589| 434| static_assert( 4590| 434| ColumnLegacy::IsFlagsAndTypeValid( 4591| 434| ColumnFlag::transition_id), 4592| 434| "Column type and flag combination is not valid"); 4593| 434| static_assert( 4594| 434| ColumnLegacy::IsFlagsAndTypeValid( 4595| 434| ColumnFlag::base64_proto_id), 4596| 434| "Column type and flag combination is not valid"); 4597| 434| OnConstructionCompletedRegularConstructor( 4598| 434| {id_storage_layer_,transition_id_storage_layer_,base64_proto_id_storage_layer_}, 4599| 434| {{},{},{}}); 4600| 434| } _ZN8perfetto15trace_processor6tables18WindowManagerTable10GetColumnsEPS2_PKNS0_15macros_internal10MacroTableE: 4877| 434| const macros_internal::MacroTable* parent) { 4878| 434| std::vector columns = 4879| 434| CopyColumnsFromParentOrAddRootColumns(parent); 4880| 434| uint32_t olay_idx = OverlayCount(parent); 4881| 434| AddColumnToVector(columns, "ts", &self->ts_, ColumnFlag::ts, 4882| 434| static_cast(columns.size()), olay_idx); 4883| 434| AddColumnToVector(columns, "arg_set_id", &self->arg_set_id_, ColumnFlag::arg_set_id, 4884| 434| static_cast(columns.size()), olay_idx); 4885| 434| AddColumnToVector(columns, "base64_proto_id", &self->base64_proto_id_, ColumnFlag::base64_proto_id, 4886| 434| static_cast(columns.size()), olay_idx); 4887| 434| base::ignore_result(self); 4888| 434| return columns; 4889| 434| } _ZN8perfetto15trace_processor6tables18WindowManagerTableC2EPNS0_10StringPoolE: 4892| 434| : macros_internal::MacroTable( 4893| 434| pool, 4894| 434| GetColumns(this, nullptr), 4895| 434| nullptr), 4896| 434| ts_(ColumnStorage::Create()), 4897| 434| arg_set_id_(ColumnStorage::Create()), 4898| 434| base64_proto_id_(ColumnStorage::Create()) 4899| |, 4900| 434| id_storage_layer_(new column::IdStorage()), 4901| 434| ts_storage_layer_( 4902| 434| new column::NumericStorage( 4903| 434| &ts_.vector(), 4904| 434| ColumnTypeHelper::ToColumnType(), 4905| 434| true)), 4906| 434| arg_set_id_storage_layer_( 4907| 434| new column::NumericStorage( 4908| 434| &arg_set_id_.non_null_vector(), 4909| 434| ColumnTypeHelper::ToColumnType(), 4910| 434| false)), 4911| 434| base64_proto_id_storage_layer_( 4912| 434| new column::NumericStorage( 4913| 434| &base64_proto_id_.non_null_vector(), 4914| 434| ColumnTypeHelper::ToColumnType(), 4915| 434| false)) 4916| |, 4917| 434| arg_set_id_null_layer_(new column::NullOverlay(arg_set_id_.bv())), 4918| 434| base64_proto_id_null_layer_(new column::NullOverlay(base64_proto_id_.bv())) { 4919| 434| static_assert( 4920| 434| ColumnLegacy::IsFlagsAndTypeValid( 4921| 434| ColumnFlag::ts), 4922| 434| "Column type and flag combination is not valid"); 4923| 434| static_assert( 4924| 434| ColumnLegacy::IsFlagsAndTypeValid( 4925| 434| ColumnFlag::arg_set_id), 4926| 434| "Column type and flag combination is not valid"); 4927| 434| static_assert( 4928| 434| ColumnLegacy::IsFlagsAndTypeValid( 4929| 434| ColumnFlag::base64_proto_id), 4930| 434| "Column type and flag combination is not valid"); 4931| 434| OnConstructionCompletedRegularConstructor( 4932| 434| {id_storage_layer_,ts_storage_layer_,arg_set_id_storage_layer_,base64_proto_id_storage_layer_}, 4933| 434| {{},{},arg_set_id_null_layer_,base64_proto_id_null_layer_}); 4934| 434| }