|
16 | 16 | #include "MemoryResources/MemoryResources.h" |
17 | 17 | #include "Framework/FairMQDeviceProxy.h" |
18 | 18 | #include "Headers/DataHeader.h" |
| 19 | +#include "Headers/DataHeaderHelpers.h" |
19 | 20 | #include "Headers/Stack.h" |
20 | 21 | #include "Framework/Logger.h" |
21 | 22 | #include "Framework/SendingPolicy.h" |
|
31 | 32 | #include "Framework/ControlService.h" |
32 | 33 | #include "Framework/DataProcessingContext.h" |
33 | 34 | #include "Framework/DeviceStateEnums.h" |
| 35 | +#include "Headers/DataHeader.h" |
| 36 | +#include "Framework/DataProcessingHeader.h" |
34 | 37 |
|
35 | 38 | #include <fairmq/Device.h> |
36 | 39 | #include <fairmq/Channel.h> |
|
41 | 44 | O2_DECLARE_DYNAMIC_LOG(device); |
42 | 45 | // Stream which keeps track of the calibration lifetime logic |
43 | 46 | O2_DECLARE_DYNAMIC_LOG(calibration); |
| 47 | +O2_DECLARE_DYNAMIC_LOG(forwarding); |
44 | 48 |
|
45 | 49 | namespace o2::framework |
46 | 50 | { |
@@ -217,4 +221,141 @@ TransitionHandlingState DataProcessingHelpers::updateStateTransition(ServiceRegi |
217 | 221 | } |
218 | 222 | } |
219 | 223 |
|
| 224 | +static auto toBeForwardedHeader = [](void* header) -> bool { |
| 225 | + // If is now possible that the record is not complete when |
| 226 | + // we forward it, because of a custom completion policy. |
| 227 | + // this means that we need to skip the empty entries in the |
| 228 | + // record for being forwarded. |
| 229 | + if (header == nullptr) { |
| 230 | + return false; |
| 231 | + } |
| 232 | + auto sih = o2::header::get<SourceInfoHeader*>(header); |
| 233 | + if (sih) { |
| 234 | + return false; |
| 235 | + } |
| 236 | + |
| 237 | + auto dih = o2::header::get<DomainInfoHeader*>(header); |
| 238 | + if (dih) { |
| 239 | + return false; |
| 240 | + } |
| 241 | + |
| 242 | + auto dh = o2::header::get<header::DataHeader*>(header); |
| 243 | + if (!dh) { |
| 244 | + return false; |
| 245 | + } |
| 246 | + auto dph = o2::header::get<DataProcessingHeader*>(header); |
| 247 | + if (!dph) { |
| 248 | + return false; |
| 249 | + } |
| 250 | + return true; |
| 251 | +}; |
| 252 | + |
| 253 | +static auto toBeforwardedMessageSet = [](std::vector<ChannelIndex>& cachedForwardingChoices, |
| 254 | + FairMQDeviceProxy& proxy, |
| 255 | + std::unique_ptr<fair::mq::Message>& header, |
| 256 | + std::unique_ptr<fair::mq::Message>& payload, |
| 257 | + size_t total, |
| 258 | + bool consume) { |
| 259 | + if (header.get() == nullptr) { |
| 260 | + // Missing an header is not an error anymore. |
| 261 | + // it simply means that we did not receive the |
| 262 | + // given input, but we were asked to |
| 263 | + // consume existing, so we skip it. |
| 264 | + return false; |
| 265 | + } |
| 266 | + if (payload.get() == nullptr && consume == true) { |
| 267 | + // If the payload is not there, it means we already |
| 268 | + // processed it with ConsumeExisiting. Therefore we |
| 269 | + // need to do something only if this is the last consume. |
| 270 | + header.reset(nullptr); |
| 271 | + return false; |
| 272 | + } |
| 273 | + |
| 274 | + auto fdph = o2::header::get<DataProcessingHeader*>(header->GetData()); |
| 275 | + if (fdph == nullptr) { |
| 276 | + LOG(error) << "Data is missing DataProcessingHeader"; |
| 277 | + return false; |
| 278 | + } |
| 279 | + auto fdh = o2::header::get<header::DataHeader*>(header->GetData()); |
| 280 | + if (fdh == nullptr) { |
| 281 | + LOG(error) << "Data is missing DataHeader"; |
| 282 | + return false; |
| 283 | + } |
| 284 | + |
| 285 | + // We need to find the forward route only for the first |
| 286 | + // part of a split payload. All the others will use the same. |
| 287 | + // but always check if we have a sequence of multiple payloads |
| 288 | + if (fdh->splitPayloadIndex == 0 || fdh->splitPayloadParts <= 1 || total > 1) { |
| 289 | + proxy.getMatchingForwardChannelIndexes(cachedForwardingChoices, *fdh, fdph->startTime); |
| 290 | + } |
| 291 | + return cachedForwardingChoices.empty() == false; |
| 292 | +}; |
| 293 | + |
| 294 | +std::vector<fair::mq::Parts> DataProcessingHelpers::routeForwardedMessages(FairMQDeviceProxy& proxy, TimesliceSlot slot, std::vector<MessageSet>& currentSetOfInputs, |
| 295 | + TimesliceIndex::OldestOutputInfo oldestTimeslice, bool copy, bool consume) |
| 296 | +{ |
| 297 | + // we collect all messages per forward in a map and send them together |
| 298 | + std::vector<fair::mq::Parts> forwardedParts; |
| 299 | + forwardedParts.resize(proxy.getNumForwards()); |
| 300 | + std::vector<ChannelIndex> cachedForwardingChoices{}; |
| 301 | + O2_SIGNPOST_ID_GENERATE(sid, forwarding); |
| 302 | + O2_SIGNPOST_START(forwarding, sid, "forwardInputs", "Starting forwarding for slot %zu with oldestTimeslice %zu %{public}s%{public}s%{public}s", |
| 303 | + slot.index, oldestTimeslice.timeslice.value, copy ? "with copy" : "", copy && consume ? " and " : "", consume ? "with consume" : ""); |
| 304 | + |
| 305 | + for (size_t ii = 0, ie = currentSetOfInputs.size(); ii < ie; ++ii) { |
| 306 | + auto& messageSet = currentSetOfInputs[ii]; |
| 307 | + // In case the messageSet is empty, there is nothing to be done. |
| 308 | + if (messageSet.size() == 0) { |
| 309 | + continue; |
| 310 | + } |
| 311 | + if (!toBeForwardedHeader(messageSet.header(0)->GetData())) { |
| 312 | + continue; |
| 313 | + } |
| 314 | + cachedForwardingChoices.clear(); |
| 315 | + |
| 316 | + for (size_t pi = 0; pi < currentSetOfInputs[ii].size(); ++pi) { |
| 317 | + auto& messageSet = currentSetOfInputs[ii]; |
| 318 | + auto& header = messageSet.header(pi); |
| 319 | + auto& payload = messageSet.payload(pi); |
| 320 | + auto total = messageSet.getNumberOfPayloads(pi); |
| 321 | + |
| 322 | + if (!toBeforwardedMessageSet(cachedForwardingChoices, proxy, header, payload, total, consume)) { |
| 323 | + continue; |
| 324 | + } |
| 325 | + |
| 326 | + // In case of more than one forward route, we need to copy the message. |
| 327 | + // This will eventually use the same mamory if running with the same backend. |
| 328 | + if (cachedForwardingChoices.size() > 1) { |
| 329 | + copy = true; |
| 330 | + } |
| 331 | + auto* dh = o2::header::get<header::DataHeader*>(header->GetData()); |
| 332 | + auto* dph = o2::header::get<DataProcessingHeader*>(header->GetData()); |
| 333 | + |
| 334 | + if (copy) { |
| 335 | + for (auto& cachedForwardingChoice : cachedForwardingChoices) { |
| 336 | + auto&& newHeader = header->GetTransport()->CreateMessage(); |
| 337 | + O2_SIGNPOST_EVENT_EMIT(forwarding, sid, "forwardInputs", "Forwarding a copy of %{public}s to route %d.", |
| 338 | + fmt::format("{}/{}/{}@timeslice:{} tfCounter:{}", dh->dataOrigin, dh->dataDescription, dh->subSpecification, dph->startTime, dh->tfCounter).c_str(), cachedForwardingChoice.value); |
| 339 | + newHeader->Copy(*header); |
| 340 | + forwardedParts[cachedForwardingChoice.value].AddPart(std::move(newHeader)); |
| 341 | + |
| 342 | + for (size_t payloadIndex = 0; payloadIndex < messageSet.getNumberOfPayloads(pi); ++payloadIndex) { |
| 343 | + auto&& newPayload = header->GetTransport()->CreateMessage(); |
| 344 | + newPayload->Copy(*messageSet.payload(pi, payloadIndex)); |
| 345 | + forwardedParts[cachedForwardingChoice.value].AddPart(std::move(newPayload)); |
| 346 | + } |
| 347 | + } |
| 348 | + } else { |
| 349 | + O2_SIGNPOST_EVENT_EMIT(forwarding, sid, "forwardInputs", "Forwarding %{public}s to route %d.", |
| 350 | + fmt::format("{}/{}/{}@timeslice:{} tfCounter:{}", dh->dataOrigin, dh->dataDescription, dh->subSpecification, dph->startTime, dh->tfCounter).c_str(), cachedForwardingChoices.back().value); |
| 351 | + forwardedParts[cachedForwardingChoices.back().value].AddPart(std::move(messageSet.header(pi))); |
| 352 | + for (size_t payloadIndex = 0; payloadIndex < messageSet.getNumberOfPayloads(pi); ++payloadIndex) { |
| 353 | + forwardedParts[cachedForwardingChoices.back().value].AddPart(std::move(messageSet.payload(pi, payloadIndex))); |
| 354 | + } |
| 355 | + } |
| 356 | + } |
| 357 | + } |
| 358 | + return forwardedParts; |
| 359 | +}; |
| 360 | + |
220 | 361 | } // namespace o2::framework |
0 commit comments