LEFT | RIGHT |
1 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */ | 1 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */ |
2 /* | 2 /* |
3 * Copyright (c) 2006,2007 INRIA | 3 * Copyright (c) 2006,2007 INRIA |
4 * | 4 * |
5 * This program is free software; you can redistribute it and/or modify | 5 * This program is free software; you can redistribute it and/or modify |
6 * it under the terms of the GNU General Public License version 2 as | 6 * it under the terms of the GNU General Public License version 2 as |
7 * published by the Free Software Foundation; | 7 * published by the Free Software Foundation; |
8 * | 8 * |
9 * This program is distributed in the hope that it will be useful, | 9 * This program is distributed in the hope that it will be useful, |
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of | 10 * but WITHOUT ANY WARRANTY; without even the implied warranty of |
(...skipping 941 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
952 if (current == tail) | 952 if (current == tail) |
953 { | 953 { |
954 break; | 954 break; |
955 } | 955 } |
956 NS_ASSERT (current != item.next); | 956 NS_ASSERT (current != item.next); |
957 current = item.next; | 957 current = item.next; |
958 } | 958 } |
959 return totalSize; | 959 return totalSize; |
960 } | 960 } |
961 | 961 |
962 uint32_t· | 962 uint64_t· |
963 PacketMetadata::GetUid (void) const | 963 PacketMetadata::GetUid (void) const |
964 { | 964 { |
965 return m_packetUid; | 965 return m_packetUid; |
966 } | |
967 uint32_t· | |
968 PacketMetadata::GetMpiRank (void) const | |
969 { | |
970 return m_mpiRank; | |
971 } | 966 } |
972 PacketMetadata::ItemIterator· | 967 PacketMetadata::ItemIterator· |
973 PacketMetadata::BeginItem (Buffer buffer) const | 968 PacketMetadata::BeginItem (Buffer buffer) const |
974 { | 969 { |
975 return ItemIterator (this, buffer); | 970 return ItemIterator (this, buffer); |
976 } | 971 } |
977 PacketMetadata::ItemIterator::ItemIterator (const PacketMetadata *metadata, Buff
er buffer) | 972 PacketMetadata::ItemIterator::ItemIterator (const PacketMetadata *metadata, Buff
er buffer) |
978 : m_metadata (metadata), | 973 : m_metadata (metadata), |
979 m_buffer (buffer), | 974 m_buffer (buffer), |
980 m_current (metadata->m_head), | 975 m_current (metadata->m_head), |
(...skipping 72 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1053 } | 1048 } |
1054 m_offset += extraItem.fragmentEnd - extraItem.fragmentStart; | 1049 m_offset += extraItem.fragmentEnd - extraItem.fragmentStart; |
1055 return item; | 1050 return item; |
1056 } | 1051 } |
1057 | 1052 |
1058 uint32_t· | 1053 uint32_t· |
1059 PacketMetadata::GetSerializedSize (void) const | 1054 PacketMetadata::GetSerializedSize (void) const |
1060 { | 1055 { |
1061 NS_LOG_FUNCTION (this); | 1056 NS_LOG_FUNCTION (this); |
1062 uint32_t totalSize = 0; | 1057 uint32_t totalSize = 0; |
1063 totalSize += 4; | 1058 |
| 1059 // add 8 bytes for the packet uid |
| 1060 totalSize += 8; |
| 1061 |
| 1062 // if packet-metadata not enabled, total size |
| 1063 // is simply 4-bytes for itself plus 8-bytes· |
| 1064 // for packet uid |
1064 if (!m_enable) | 1065 if (!m_enable) |
1065 { | 1066 { |
1066 return totalSize; | 1067 return totalSize; |
1067 } | 1068 } |
| 1069 |
1068 struct PacketMetadata::SmallItem item; | 1070 struct PacketMetadata::SmallItem item; |
1069 struct PacketMetadata::ExtraItem extraItem; | 1071 struct PacketMetadata::ExtraItem extraItem; |
1070 uint32_t current = m_head; | 1072 uint32_t current = m_head; |
1071 while (current != 0xffff) | 1073 while (current != 0xffff) |
1072 { | 1074 { |
1073 ReadItems (current, &item, &extraItem); | 1075 ReadItems (current, &item, &extraItem); |
1074 uint32_t uid = (item.typeUid & 0xfffffffe) >> 1; | 1076 uint32_t uid = (item.typeUid & 0xfffffffe) >> 1; |
1075 if (uid == 0) | 1077 if (uid == 0) |
1076 { | 1078 { |
1077 totalSize += 4; | 1079 totalSize += 4; |
1078 } | 1080 } |
1079 else | 1081 else |
1080 { | 1082 { |
1081 TypeId tid; | 1083 TypeId tid; |
1082 tid.SetUid (uid); | 1084 tid.SetUid (uid); |
1083 totalSize += 4 + tid.GetName ().size (); | 1085 totalSize += 4 + tid.GetName ().size (); |
1084 } | 1086 } |
1085 totalSize += 1 + 4 + 2 + 4 + 4 + 4; | 1087 totalSize += 1 + 4 + 2 + 4 + 4 + 8; |
1086 if (current == m_tail) | 1088 if (current == m_tail) |
1087 { | 1089 { |
1088 break; | 1090 break; |
1089 } | 1091 } |
1090 NS_ASSERT (current != item.next); | 1092 NS_ASSERT (current != item.next); |
1091 current = item.next; | 1093 current = item.next; |
1092 } | 1094 } |
1093 return totalSize; | 1095 return totalSize; |
1094 } | 1096 } |
1095 void | 1097 |
1096 PacketMetadata::Serialize (Buffer::Iterator i, uint32_t size) const | 1098 uint32_t |
| 1099 PacketMetadata::Serialize (uint8_t* buffer, uint32_t maxSize) const |
1097 { | 1100 { |
1098 NS_LOG_FUNCTION (this); | 1101 NS_LOG_FUNCTION (this); |
1099 uint32_t bytesWritten = 0; | 1102 uint8_t* start = buffer; |
1100 i.WriteU32 (size); | 1103 |
1101 bytesWritten += 4; | 1104 buffer = AddToRawU64 (m_packetUid, start, buffer, maxSize); |
| 1105 if (buffer == 0)· |
| 1106 { |
| 1107 return 0; |
| 1108 } |
| 1109 ·· |
1102 struct PacketMetadata::SmallItem item; | 1110 struct PacketMetadata::SmallItem item; |
1103 struct PacketMetadata::ExtraItem extraItem; | 1111 struct PacketMetadata::ExtraItem extraItem; |
1104 uint32_t current = m_head; | 1112 uint32_t current = m_head; |
1105 while (current != 0xffff) | 1113 while (current != 0xffff) |
1106 { | 1114 { |
1107 ReadItems (current, &item, &extraItem); | 1115 ReadItems (current, &item, &extraItem); |
1108 NS_LOG_LOGIC ("bytesWritten=" << bytesWritten << ", typeUid="<< | 1116 NS_LOG_LOGIC ("bytesWritten=" << (uint32_t)(buffer - start) << ", typeUid=
"<< |
1109 item.typeUid << ", size="<<item.size<<", chunkUid="<<item.chunkUid<< | 1117 item.typeUid << ", size="<<item.size<<", chunkUid="<<item.chunkUid<< |
1110 ", fragmentStart="<<extraItem.fragmentStart<<", fragmentEnd="<< | 1118 ", fragmentStart="<<extraItem.fragmentStart<<", fragmentEnd="<< |
1111 extraItem.fragmentEnd<< ", packetUid="<<extraItem.packetUid); | 1119 extraItem.fragmentEnd<< ", packetUid="<<extraItem.packetUid); |
| 1120 |
1112 uint32_t uid = (item.typeUid & 0xfffffffe) >> 1; | 1121 uint32_t uid = (item.typeUid & 0xfffffffe) >> 1; |
1113 if (uid != 0) | 1122 if (uid != 0) |
1114 { | 1123 { |
1115 TypeId tid; | 1124 TypeId tid; |
1116 tid.SetUid (uid); | 1125 tid.SetUid (uid); |
1117 std::string uidString = tid.GetName (); | 1126 std::string uidString = tid.GetName (); |
1118 i.WriteU32 (uidString.size ()); | 1127 uint32_t uidStringSize = uidString.size (); |
1119 bytesWritten += 4; | 1128 buffer = AddToRawU32 (uidStringSize, start, buffer, maxSize); |
1120 i.Write ((uint8_t *)uidString.c_str (), uidString.size ()); | 1129 if (buffer == 0)· |
1121 bytesWritten += uidString.size (); | 1130 { |
| 1131 return 0; |
| 1132 } |
| 1133 buffer = AddToRaw ((uint8_t *)uidString.c_str (),· |
| 1134 uidStringSize, start, buffer, maxSize); |
| 1135 if (buffer == 0)· |
| 1136 { |
| 1137 return 0; |
| 1138 } |
1122 } | 1139 } |
1123 else | 1140 else |
1124 { | 1141 { |
1125 i.WriteU32 (0); | 1142 buffer = AddToRawU32 (0, start, buffer, maxSize); |
1126 bytesWritten += 4; | 1143 if (buffer == 0)· |
1127 } | 1144 { |
| 1145 return 0; |
| 1146 } |
| 1147 } |
| 1148 |
1128 uint8_t isBig = item.typeUid & 0x1; | 1149 uint8_t isBig = item.typeUid & 0x1; |
1129 i.WriteU8 (isBig); | 1150 buffer = AddToRawU8 (isBig, start, buffer, maxSize); |
1130 bytesWritten += 1; | 1151 if (buffer == 0)· |
1131 i.WriteU32 (item.size); | 1152 { |
1132 bytesWritten += 4; | 1153 return 0; |
1133 i.WriteU16 (item.chunkUid); | 1154 } |
1134 bytesWritten += 2; | 1155 |
1135 i.WriteU32 (extraItem.fragmentStart); | 1156 buffer = AddToRawU32 (item.size, start, buffer, maxSize); |
1136 bytesWritten += 4; | 1157 if (buffer == 0)· |
1137 i.WriteU32 (extraItem.fragmentEnd); | 1158 { |
1138 bytesWritten += 4; | 1159 return 0; |
1139 i.WriteU32 (extraItem.packetUid); | 1160 } |
1140 bytesWritten += 4; | 1161 |
| 1162 buffer = AddToRawU16 (item.chunkUid, start, buffer, maxSize); |
| 1163 if (buffer == 0)· |
| 1164 { |
| 1165 return 0; |
| 1166 } |
| 1167 |
| 1168 buffer = AddToRawU32 (extraItem.fragmentStart, start, buffer, maxSize); |
| 1169 if (buffer == 0)· |
| 1170 { |
| 1171 return 0; |
| 1172 } |
| 1173 |
| 1174 buffer = AddToRawU32 (extraItem.fragmentEnd, start, buffer, maxSize); |
| 1175 if (buffer == 0)· |
| 1176 { |
| 1177 return 0; |
| 1178 } |
| 1179 |
| 1180 buffer = AddToRawU64 (extraItem.packetUid, start, buffer, maxSize); |
| 1181 if (buffer == 0)· |
| 1182 { |
| 1183 return 0; |
| 1184 } |
| 1185 |
1141 if (current == m_tail) | 1186 if (current == m_tail) |
1142 { | 1187 { |
1143 break; | 1188 break; |
1144 } | 1189 } |
1145 ······ | 1190 ······ |
1146 NS_ASSERT (current != item.next); | 1191 NS_ASSERT (current != item.next); |
1147 current = item.next; | 1192 current = item.next; |
1148 } | 1193 } |
1149 NS_ASSERT (bytesWritten == size); | 1194 |
1150 } | 1195 NS_ASSERT ((uint32_t)(buffer - start) == maxSize); |
| 1196 return 1; |
| 1197 } |
| 1198 |
1151 uint32_t· | 1199 uint32_t· |
1152 PacketMetadata::Deserialize (Buffer::Iterator i) | 1200 PacketMetadata::Deserialize (uint8_t* buffer, uint32_t size) |
1153 { | 1201 { |
1154 NS_LOG_FUNCTION (this); | 1202 NS_LOG_FUNCTION (this); |
| 1203 uint8_t* start = buffer; |
| 1204 uint32_t desSize = size - 4; |
| 1205 |
| 1206 buffer = ReadFromRawU64 (m_packetUid, start, buffer, size); |
| 1207 desSize -= 8; |
| 1208 |
1155 struct PacketMetadata::SmallItem item; | 1209 struct PacketMetadata::SmallItem item; |
1156 struct PacketMetadata::ExtraItem extraItem; | 1210 struct PacketMetadata::ExtraItem extraItem; |
1157 uint32_t totalSize = i.ReadU32 (); | 1211 while (desSize > 0) |
1158 uint32_t size = totalSize; | 1212 { |
1159 size -= 4; | 1213 uint32_t uidStringSize = 0; |
1160 while (size > 0) | 1214 buffer = ReadFromRawU32 (uidStringSize, start, buffer, size); |
1161 { | 1215 desSize -= 4; |
1162 uint32_t uidStringSize = i.ReadU32 (); | |
1163 size -= 4; | |
1164 uint32_t uid; | 1216 uint32_t uid; |
1165 if (uidStringSize == 0) | 1217 if (uidStringSize == 0) |
1166 { | 1218 { |
1167 // uid zero for payload. | 1219 // uid zero for payload. |
1168 uid = 0; | 1220 uid = 0; |
1169 } | 1221 } |
1170 else | 1222 else |
1171 { | 1223 { |
1172 std::string uidString; | 1224 std::string uidString; |
1173 for (uint32_t j = 0; j < uidStringSize; j++) | 1225 for (uint32_t j = 0; j < uidStringSize; j++) |
1174 { | 1226 { |
1175 uidString.push_back (i.ReadU8 ()); | 1227 uint8_t ch = 0; |
1176 size --; | 1228 buffer = ReadFromRawU8 (ch, start, buffer, size); |
| 1229 uidString.push_back (ch); |
| 1230 desSize --; |
1177 } | 1231 } |
1178 TypeId tid = TypeId::LookupByName (uidString); | 1232 TypeId tid = TypeId::LookupByName (uidString); |
1179 uid = tid.GetUid (); | 1233 uid = tid.GetUid (); |
1180 } | 1234 } |
1181 uint8_t isBig = i.ReadU8 (); | 1235 uint8_t isBig = 0; |
1182 size --; | 1236 buffer = ReadFromRawU8 (isBig, start, buffer, size); |
| 1237 desSize --; |
1183 item.typeUid = (uid << 1) | isBig; | 1238 item.typeUid = (uid << 1) | isBig; |
1184 item.size = i.ReadU32 (); | 1239 buffer = ReadFromRawU32 (item.size, start, buffer, size); |
1185 size -= 4; | 1240 desSize -= 4; |
1186 item.chunkUid = i.ReadU16 (); | 1241 buffer = ReadFromRawU16 (item.chunkUid, start, buffer, size); |
1187 size -= 2; | 1242 desSize -= 2; |
1188 extraItem.fragmentStart = i.ReadU32 (); | 1243 buffer = ReadFromRawU32 (extraItem.fragmentStart, start, buffer, size); |
1189 size -= 4; | 1244 desSize -= 4; |
1190 extraItem.fragmentEnd = i.ReadU32 (); | 1245 buffer = ReadFromRawU32 (extraItem.fragmentEnd, start, buffer, size); |
1191 size -= 4; | 1246 desSize -= 4; |
1192 extraItem.packetUid = i.ReadU32 (); | 1247 buffer = ReadFromRawU64 (extraItem.packetUid, start, buffer, size); |
1193 size -= 4; | 1248 desSize -= 8; |
1194 NS_LOG_LOGIC ("size=" << size << ", typeUid="<<item.typeUid << | 1249 NS_LOG_LOGIC ("size=" << size << ", typeUid="<<item.typeUid << |
1195 ", size="<<item.size<<", chunkUid="<<item.chunkUid<< | 1250 ", size="<<item.size<<", chunkUid="<<item.chunkUid<< |
1196 ", fragmentStart="<<extraItem.fragmentStart<<", fragmentEnd="<< | 1251 ", fragmentStart="<<extraItem.fragmentStart<<", fragmentEnd="<< |
1197 extraItem.fragmentEnd<< ", packetUid="<<extraItem.packetUid); | 1252 extraItem.fragmentEnd<< ", packetUid="<<extraItem.packetUid); |
1198 uint32_t tmp = AddBig (0xffff, m_tail, &item, &extraItem); | 1253 uint32_t tmp = AddBig (0xffff, m_tail, &item, &extraItem); |
1199 UpdateTail (tmp); | 1254 UpdateTail (tmp); |
1200 } | 1255 } |
1201 NS_ASSERT (size == 0); | 1256 NS_ASSERT (desSize == 0); |
1202 return totalSize; | 1257 return (desSize !=0) ? 0 : 1; |
| 1258 } |
| 1259 |
| 1260 uint8_t*· |
| 1261 PacketMetadata::AddToRawU8 (const uint8_t& data, |
| 1262 uint8_t* start, |
| 1263 uint8_t* current, |
| 1264 uint32_t maxSize) |
| 1265 { |
| 1266 // First check buffer overflow |
| 1267 if ((uint32_t)((current + sizeof (uint8_t) - start)) > maxSize)· |
| 1268 { |
| 1269 return 0; |
| 1270 } |
| 1271 memcpy (current, &data, sizeof (uint8_t)); |
| 1272 return current + sizeof (uint8_t); |
| 1273 } |
| 1274 |
| 1275 uint8_t*· |
| 1276 PacketMetadata::AddToRawU16 (const uint16_t& data, |
| 1277 uint8_t* start, |
| 1278 uint8_t* current, |
| 1279 uint32_t maxSize) |
| 1280 { |
| 1281 // First check buffer overflow |
| 1282 if ((uint32_t)((current + sizeof (uint16_t) - start)) > maxSize)· |
| 1283 { |
| 1284 return 0; |
| 1285 } |
| 1286 memcpy (current, &data, sizeof (uint16_t)); |
| 1287 return current + sizeof (uint16_t); |
| 1288 } |
| 1289 |
| 1290 uint8_t*· |
| 1291 PacketMetadata::AddToRawU32 (const uint32_t& data, |
| 1292 uint8_t* start, |
| 1293 uint8_t* current, |
| 1294 uint32_t maxSize) |
| 1295 { |
| 1296 // First check buffer overflow |
| 1297 if ((uint32_t)((current + sizeof (uint32_t) - start)) > maxSize)· |
| 1298 { |
| 1299 return 0; |
| 1300 } |
| 1301 memcpy (current, &data, sizeof (uint32_t)); |
| 1302 return current + sizeof (uint32_t); |
| 1303 } |
| 1304 |
| 1305 uint8_t*· |
| 1306 PacketMetadata::AddToRawU64 (const uint64_t& data, |
| 1307 uint8_t* start, |
| 1308 uint8_t* current, |
| 1309 uint32_t maxSize) |
| 1310 { |
| 1311 // First check buffer overflow |
| 1312 if ((uint32_t)((current + sizeof (uint64_t) - start)) > maxSize)· |
| 1313 { |
| 1314 return 0; |
| 1315 } |
| 1316 memcpy (current, &data, sizeof (uint64_t)); |
| 1317 return current + sizeof (uint64_t); |
| 1318 } |
| 1319 ·· |
| 1320 uint8_t*· |
| 1321 PacketMetadata::AddToRaw (const uint8_t* data, |
| 1322 uint32_t dataSize, |
| 1323 uint8_t* start, |
| 1324 uint8_t* current, |
| 1325 uint32_t maxSize) |
| 1326 {· |
| 1327 // First check buffer overflow |
| 1328 if ((uint32_t)((current + dataSize - start)) > maxSize)· |
| 1329 { |
| 1330 return 0; |
| 1331 } |
| 1332 memcpy (current, data, dataSize); |
| 1333 return current + dataSize; |
| 1334 } |
| 1335 ·· |
| 1336 uint8_t*· |
| 1337 PacketMetadata::ReadFromRawU8 (uint8_t& data, |
| 1338 uint8_t* start, |
| 1339 uint8_t* current, |
| 1340 uint32_t maxSize) |
| 1341 {· |
| 1342 // First check buffer underflow |
| 1343 if ((uint32_t)((current + sizeof (uint8_t) - start)) > maxSize)· |
| 1344 { |
| 1345 return 0; |
| 1346 } |
| 1347 memcpy(&data, current, sizeof (uint8_t)); |
| 1348 return current + sizeof (uint8_t); |
| 1349 } |
| 1350 |
| 1351 uint8_t*· |
| 1352 PacketMetadata::ReadFromRawU16 (uint16_t& data, |
| 1353 uint8_t* start, |
| 1354 uint8_t* current, |
| 1355 uint32_t maxSize) |
| 1356 {· |
| 1357 // First check buffer underflow |
| 1358 if ((uint32_t)((current + sizeof (uint16_t) - start)) > maxSize)· |
| 1359 { |
| 1360 return 0; |
| 1361 } |
| 1362 memcpy(&data, current, sizeof (uint16_t)); |
| 1363 return current + sizeof (uint16_t); |
| 1364 } |
| 1365 |
| 1366 uint8_t*· |
| 1367 PacketMetadata::ReadFromRawU32 (uint32_t& data, |
| 1368 uint8_t* start, |
| 1369 uint8_t* current, |
| 1370 uint32_t maxSize) |
| 1371 {· |
| 1372 // First check buffer underflow |
| 1373 if ((uint32_t)((current + sizeof (uint32_t) - start)) > maxSize)· |
| 1374 { |
| 1375 return 0; |
| 1376 } |
| 1377 memcpy(&data, current, sizeof (uint32_t)); |
| 1378 return current + sizeof (uint32_t); |
| 1379 } |
| 1380 |
| 1381 uint8_t*· |
| 1382 PacketMetadata::ReadFromRawU64 (uint64_t& data, |
| 1383 uint8_t* start, |
| 1384 uint8_t* current, |
| 1385 uint32_t maxSize) |
| 1386 {· |
| 1387 // First check buffer underflow |
| 1388 if ((uint32_t)((current + sizeof (uint64_t) - start)) > maxSize)· |
| 1389 { |
| 1390 return 0; |
| 1391 } |
| 1392 memcpy(&data, current, sizeof (uint64_t)); |
| 1393 return current + sizeof (uint64_t); |
1203 } | 1394 } |
1204 | 1395 |
1205 | 1396 |
1206 } // namespace ns3 | 1397 } // namespace ns3 |
1207 | 1398 |
LEFT | RIGHT |