159 int rateLimitingIPCID = std::stoi(ctx.options().get<std::string>(
"timeframes-rate-limit-ipcid"));
161 .
name =
"internal-dpl-ccdb-backend",
164 {
"condition-timestamp",
VariantType::Int64, 0ll, {
"Force timestamp for CCDB lookup"}},
165 {
"condition-not-before",
VariantType::Int64, 0ll, {
"do not fetch from CCDB objects created before provide timestamp"}},
166 {
"condition-not-after",
VariantType::Int64, 3385078236000ll, {
"do not fetch from CCDB objects created after the timestamp"}},
167 {
"condition-remap",
VariantType::String,
"", {
"remap condition path in CCDB based on the provided string."}},
170 {
"condition-use-slice-for-prescaling",
VariantType::Int, 0, {
"use TFslice instead of TFcounter to control validation frequency. If > query rate, do not allow TFCounter excursion exceeding it"}},
171 {
"condition-time-tolerance",
VariantType::Int64, 5000ll, {
"prefer creation time if its difference to orbit-derived time exceeds threshold (ms), impose if <0"}},
172 {
"orbit-offset-enumeration",
VariantType::Int64, 0ll, {
"initial value for the orbit"}},
173 {
"orbit-multiplier-enumeration",
VariantType::Int64, 0ll, {
"multiplier to get the orbit from the counter"}},
174 {
"start-value-enumeration",
VariantType::Int64, 0ll, {
"initial value for the enumeration"}},
175 {
"end-value-enumeration",
VariantType::Int64, -1ll, {
"final value for the enumeration"}},
176 {
"step-value-enumeration",
VariantType::Int64, 1ll, {
"step between one value and the other"}}},
179 .
name =
"internal-dpl-aod-ccdb",
184 {
"condition-not-before",
VariantType::Int64, 0ll, {
"do not fetch from CCDB objects created before provide timestamp"}},
185 {
"condition-not-after",
VariantType::Int64, 3385078236000ll, {
"do not fetch from CCDB objects created after the timestamp"}},
186 {
"condition-remap",
VariantType::String,
"", {
"remap condition path in CCDB based on the provided string."}},
189 {
"condition-use-slice-for-prescaling",
VariantType::Int, 0, {
"use TFslice instead of TFcounter to control validation frequency. If > query rate, do not allow TFCounter excursion exceeding it"}},
190 {
"condition-time-tolerance",
VariantType::Int64, 5000ll, {
"prefer creation time if its difference to orbit-derived time exceeds threshold (ms), impose if <0"}},
191 {
"start-value-enumeration",
VariantType::Int64, 0ll, {
"initial value for the enumeration"}},
192 {
"end-value-enumeration",
VariantType::Int64, -1ll, {
"final value for the enumeration"}},
193 {
"step-value-enumeration",
VariantType::Int64, 1ll, {
"step between one value and the other"}}}};
214 auto aodLifetime = Lifetime::Enumeration;
217 .
name =
"internal-dpl-aod-reader",
230 ConfigParamSpec{
"aod-reader-buffer-mb",
VariantType::Int, -1, {
"Most MB the native AOD reader holds in read buffers: 0 for no limit, -1 for 16 MB for local files and 64 MB for remote ones"}},
240 ctx.services().registerService(ServiceRegistryHelpers::handleForService<DanglingEdgesContext>(
new DanglingEdgesContext));
243 std::vector<InputSpec> requestedCCDBs;
244 std::vector<OutputSpec> providedCCDBs;
246 for (
size_t wi = 0; wi < workflow.size(); ++wi) {
247 auto& processor = workflow[wi];
248 auto name = processor.name;
250 dec.outTskMap.push_back({
hash,
name});
252 std::string prefix =
"internal-dpl-";
253 if (processor.inputs.empty() && processor.name.compare(0, prefix.size(), prefix) != 0) {
261 bool hasTimeframeInputs = std::ranges::any_of(processor.inputs, [](
auto const& input) { return input.lifetime == Lifetime::Timeframe; });
262 bool hasTimeframeOutputs = std::ranges::any_of(processor.outputs, [](
auto const&
output) { return output.lifetime == Lifetime::Timeframe; });
266 bool timeframeSink = hasTimeframeInputs && !hasTimeframeOutputs;
267 if (rateLimitingIPCID != -1) {
268 if (timeframeSink && processor.name.find(
"internal-dpl-injected-dummy-sink") == std::string::npos) {
270 bool hasMatch =
false;
272 auto summaryOutput = std::ranges::find_if(processor.outputs, [&summaryMatcher](
auto const&
output) { return DataSpecUtils::match(output, summaryMatcher); });
273 if (summaryOutput != processor.outputs.end()) {
274 O2_SIGNPOST_EVENT_EMIT(workflow_helpers, sid,
"output enumeration",
"%{public}s already there in %{public}s",
280 O2_SIGNPOST_EVENT_EMIT(workflow_helpers, sid,
"output enumeration",
"Adding DPL/SUMMARY/%d to %{public}s",
hash, processor.name.c_str());
285 bool hasConditionOption =
false;
286 for (
size_t ii = 0; ii < processor.inputs.size(); ++ii) {
287 auto& input = processor.inputs[ii];
288 bool hasProjectors =
false;
289 bool hasIndexRecords =
false;
290 bool hasCCDBURLs =
false;
293 for (
auto const& p : input.metadata) {
294 if (
p.name.starts_with(
"aod-origin-replaced")) {
297 if (
p.name.compare(
"projectors") == 0) {
298 hasProjectors =
true;
301 if (
p.name.compare(
"index-records") == 0) {
302 hasIndexRecords =
true;
305 if (
p.name.starts_with(
"ccdb:")) {
310 switch (input.lifetime) {
311 case Lifetime::Timer: {
313 auto hasOption = std::ranges::any_of(processor.options, [&input](
auto const&
option) { return (option.name ==
"period-" + input.binding); });
314 if (hasOption ==
false) {
315 processor.options.push_back(ConfigParamSpec{
"period-" + input.binding,
VariantType::Int, 1000, {
"period of the timer in milliseconds"}});
317 timer.outputs.emplace_back(
OutputSpec{concrete.origin, concrete.description, concrete.subSpec, Lifetime::Timer});
319 case Lifetime::Signal: {
321 timer.outputs.emplace_back(
OutputSpec{concrete.origin, concrete.description, concrete.subSpec, Lifetime::Signal});
323 case Lifetime::Enumeration: {
325 timer.outputs.emplace_back(
OutputSpec{concrete.origin, concrete.description, concrete.subSpec, Lifetime::Enumeration});
327 case Lifetime::Condition: {
328 requestedCCDBs.emplace_back(input);
329 if ((hasConditionOption ==
false) && std::ranges::none_of(processor.options, [](
auto const&
option) { return (option.name.compare(
"condition-backend") == 0); })) {
331 processor.options.emplace_back(ConfigParamSpec{
"condition-timestamp",
VariantType::Int64, 0ll, {
"Force timestamp for CCDB lookup"}});
332 hasConditionOption =
true;
335 case Lifetime::OutOfBand: {
337 auto hasOption = std::ranges::any_of(processor.options, [&input](
auto const&
option) { return (option.name ==
"out-of-band-channel-name-" + input.binding); });
338 if (hasOption ==
false) {
339 processor.options.push_back(ConfigParamSpec{
"out-of-band-channel-name-" + input.binding,
VariantType::String,
"out-of-band", {
"channel to listen for out of band data"}});
341 timer.outputs.emplace_back(
OutputSpec{concrete.origin, concrete.description, concrete.subSpec, Lifetime::Enumeration});
344 case Lifetime::Transient:
345 case Lifetime::Timeframe:
346 case Lifetime::Optional:
351 }
else if (hasIndexRecords) {
353 }
else if (hasCCDBURLs) {
360 std::ranges::stable_sort(timer.outputs, [](
OutputSpec const&
a,
OutputSpec const&
b) { return *DataSpecUtils::getOptionalSubSpec(a) < *DataSpecUtils::getOptionalSubSpec(b); });
362 for (
auto&
output : processor.outputs) {
363 bool hasProjectors =
false;
364 bool hasIndexRecords =
false;
365 bool hasCCDBURLs =
false;
368 for (
auto const& p :
output.metadata) {
369 if (
p.name.starts_with(
"aod-origin-replaced")) {
372 if (
p.name.compare(
"projectors") == 0) {
373 hasProjectors =
true;
376 if (
p.name.compare(
"index-records") == 0) {
377 hasIndexRecords =
true;
380 if (
p.name.starts_with(
"ccdb:")) {
386 dec.providedDYNs.emplace_back(
output);
387 }
else if (hasCCDBURLs) {
388 dec.providedTIMs.emplace_back(
output);
389 }
else if (hasIndexRecords) {
390 dec.providedIDXs.emplace_back(
output);
392 dec.providedAODs.emplace_back(
output);
394 dec.providedOutputObjHist.emplace_back(
output);
395 auto it = std::ranges::find_if(dec.outObjHistMap, [&](
auto&&
x) { return x.id == hash; });
396 if (it == dec.outObjHistMap.end()) {
397 dec.outObjHistMap.push_back({
hash, {
output.binding.value}});
399 it->bindings.push_back(
output.binding.value);
403 if (
output.lifetime == Lifetime::Condition) {
404 providedCCDBs.push_back(
output);
413 "internal-dpl-aod-index-builder",
418 std::ranges::sort(dec.requestedIDXs, inputSpecLessThan);
419 std::ranges::sort(dec.providedIDXs, outputSpecLessThan);
420 dec.requestedIDXs | views::filter_not_matching(dec.providedIDXs) | sinks::append_to{dec.builderInputs};
423 std::ranges::sort(dec.requestedTIMs, inputSpecLessThan);
424 std::ranges::sort(dec.providedTIMs, outputSpecLessThan);
425 dec.requestedTIMs | views::filter_not_matching(dec.providedTIMs) | sinks::append_to{dec.analysisCCDBInputs};
428 std::ranges::sort(dec.requestedDYNs, inputSpecLessThan);
429 std::ranges::sort(dec.providedDYNs, outputSpecLessThan);
430 dec.requestedDYNs | views::filter_not_matching(dec.providedDYNs) | sinks::append_to{dec.spawnerInputs};
433 "internal-dpl-aod-spawner",
440 std::ranges::sort(dec.requestedAODs, inputSpecLessThan);
441 std::ranges::sort(dec.providedAODs, outputSpecLessThan);
444 std::ranges::sort(requestedCCDBs, inputSpecLessThan);
445 std::ranges::sort(providedCCDBs, outputSpecLessThan);
448 std::vector<DataProcessorSpec> extraSpecs;
450 if (transientStore.outputs.empty() ==
false) {
451 extraSpecs.push_back(transientStore);
453 if (qaStore.outputs.empty() ==
false) {
454 extraSpecs.push_back(qaStore);
457 if (aodSpawner.outputs.empty() ==
false) {
461 if (indexBuilder.outputs.empty() ==
false) {
462 extraSpecs.push_back(indexBuilder);
467 if (deploymentMode != DeploymentMode::OnlineDDS && deploymentMode != DeploymentMode::OnlineECS) {
468 if (analysisCCDBBackend.outputs.empty() ==
false) {
469 extraSpecs.push_back(analysisCCDBBackend);
473 auto tfnsource = std::ranges::find_if(workflow, [](
DataProcessorSpec const& spec) {
475 return DataSpecUtils::match(output,
"TFN",
"TFNumber", 0);
480 if (aodReader.outputs.empty() ==
false) {
481 if (tfnsource == workflow.end()) {
483 aodReader.outputs.emplace_back(
OutputSpec{
"TFN",
"TFNumber"});
484 aodReader.outputs.emplace_back(
OutputSpec{
"TFF",
"TFFilename"});
487 aodReader.algorithm = AlgorithmSpec{
489 [](DeviceSpec
const& spec) {
490 LOGP(warn,
"Workflow with injected AODs has unsatisfied inputs:");
491 for (
auto const&
output : spec.outputs) {
494 LOGP(fatal,
"Stopping.");
500 timer.outputs.emplace_back(concrete.origin, concrete.description, concrete.subSpec, Lifetime::Enumeration);
505 auto& dstf = std::get<ConcreteDataMatcher>(
matcher.matcher);
508 bool providesDISTSTF = std::ranges::any_of(workflow,
509 [&matcher](
auto const& dp) {
510 return std::any_of(dp.outputs.begin(), dp.outputs.end(), [&matcher](
auto const&
output) {
511 return DataSpecUtils::match(matcher, output);
518 bool requiresDISTSUBTIMEFRAME = std::ranges::any_of(workflow,
519 [&dstf](
auto const& dp) {
520 return std::any_of(dp.inputs.begin(), dp.inputs.end(), [&dstf](
auto const& input) {
521 return DataSpecUtils::match(input, dstf);
529 int enumCandidate = -1;
530 int timerCandidate = -1;
531 for (
auto wi = 0U; wi < workflow.size(); ++wi) {
532 auto& dp = workflow[wi];
533 if (dp.inputs.size() != 1) {
536 auto lifetime = dp.inputs[0].lifetime;
537 if (lifetime == Lifetime::Enumeration && (enumCandidate == -1 || workflow[enumCandidate].
name > dp.name)) {
540 if (lifetime == Lifetime::Timer && (timerCandidate == -1 || workflow[timerCandidate].
name > dp.name)) {
551 if (ccdbBackend.outputs.empty() ==
false) {
552 if (aodReader.outputs.empty() ==
false) {
554 ccdbBackend.inputs.push_back(
InputSpec{
"tfn",
"TFN",
"TFNumber"});
555 }
else if (providesDISTSTF) {
557 ccdbBackend.inputs.push_back(
InputSpec{
"tfn", dstf, Lifetime::Timeframe});
559 if (enumCandidate != -1) {
563 ccdbBackend.inputs.push_back(
InputSpec{
"tfn", dstf, Lifetime::Timeframe});
564 }
else if (timerCandidate != -1) {
567 ccdbBackend.inputs.push_back(
InputSpec{
"tfn", timer_dstf, Lifetime::Timeframe});
571 ccdbBackend.outputs.push_back(
OutputSpec{
"CTP",
"OrbitReset", 0});
575 }
else if (requiresDISTSUBTIMEFRAME && enumCandidate != -1) {
581 if (timer.outputs.empty() ==
false) {
582 extraSpecs.push_back(timer);
587 if (dec.providedOutputObjHist.empty() ==
false) {
589 extraSpecs.push_back(rootSink);
592 workflow.insert(workflow.end(), extraSpecs.begin(), extraSpecs.end());
595 injectAODWriter(workflow, ctx);
598 std::vector<InputSpec> redirectedOutputsInputs;
599 for (
auto ii = 0u; ii < dec.outputsInputs.size(); ii++) {
600 if (
ctx.options().get<std::string>(
"forwarding-policy") ==
"none") {
605 if (!dec.isDangling[ii] && (
ctx.options().get<std::string>(
"forwarding-policy") !=
"all")) {
612 redirectedOutputsInputs.emplace_back(dec.outputsInputs[ii]);
615 std::vector<InputSpec> unmatched;
616 auto forwardingDestination =
ctx.options().get<std::string>(
"forwarding-destination");
620 return DataSpecUtils::match(output,
"TFN",
"TFNumber", 0);
623 if (redirectedOutputsInputs.size() > 0 && forwardingDestination ==
"file") {
625 if (unmatched.size() != redirectedOutputsInputs.size()) {
626 extraSpecs.push_back(fileSink);
628 }
else if (redirectedOutputsInputs.size() > 0 && forwardingDestination ==
"fairmq") {
630 extraSpecs.push_back(fairMQSink);
631 }
else if (forwardingDestination !=
"drop") {
632 throw runtime_error_f(
"Unknown forwarding destination %s", forwardingDestination.c_str());
634 if ((unmatched.size() > 0) || (redirectedOutputsInputs.size() > 0) || (tfnsource != workflow.end())) {
635 std::vector<InputSpec> ignored = unmatched;
636 ignored.insert(ignored.end(), redirectedOutputsInputs.begin(), redirectedOutputsInputs.end());
637 for (
auto& ignoredInput : ignored) {
638 ignoredInput.lifetime = Lifetime::Sporadic;
643 if (tfnsource != workflow.end()) {
648 if (tfnsource != workflow.end() && !tfnsource->name.starts_with(
"aod-producer-workflow")) {
653 O2_SIGNPOST_EVENT_EMIT(workflow_helpers, sid,
"injectServiceDevices",
"Injecting rate limited dummy sink");
654 std::string rateLimitingChannelConfigOutput;
655 if (rateLimitingIPCID != -1) {
656 rateLimitingChannelConfigOutput = fmt::format(
"name=metric-feedback,type=push,method=bind,address=ipc://{}metric-feedback-{},transport=shmem,rateLogging=0",
ChannelSpecHelpers::defaultIPCFolder(), rateLimitingIPCID);
662 workflow.insert(workflow.end(), extraSpecs.begin(), extraSpecs.end());
785 std::vector<DeviceConnectionEdge>& logicalEdges,
786 std::vector<OutputSpec>& outputs,
787 std::vector<LogicalForwardInfo>& forwardedInputsInfo)
790 if (workflow.empty()) {
795 std::vector<LogicalOutputInfo> availableOutputsInfo;
796 auto const& constOutputs = outputs;
798 std::vector<LogicalOutputInfo> forwards;
802 auto enumerateAvailableOutputs = [&workflow, &outputs, &availableOutputsInfo]() {
804 for (
size_t wi = 0; wi < workflow.size(); ++wi) {
805 auto& producer = workflow[wi];
806 if (producer.outputs.empty()) {
807 O2_SIGNPOST_EVENT_EMIT(workflow_helpers, sid,
"output enumeration",
"No outputs for [%zu] %{public}s", wi, producer.name.c_str());
809 O2_SIGNPOST_START(workflow_helpers, sid,
"output enumeration",
"Enumerating outputs for producer [%zu] %{}s public", wi, producer.name.c_str());
811 for (
size_t oi = 0; oi < producer.outputs.size(); ++oi) {
812 auto& out = producer.outputs[oi];
813 auto uniqueOutputId = outputs.size();
817 outputs.push_back(out);
823 auto errorDueToMissingOutputFor = [&workflow, &constOutputs](
size_t ci,
size_t ii) {
824 auto input = workflow[ci].inputs[ii];
825 std::ostringstream
str;
826 str <<
"No matching output found for "
827 <<
DataSpecUtils::describe(input) <<
" as requested by data processor \"" << workflow[ci].name <<
"\". Candidates:\n";
829 for (
auto&
output : constOutputs) {
833 throw std::runtime_error(
str.str());
847 enumerateAvailableOutputs();
849 std::vector<bool> matches(constOutputs.size());
850 for (
size_t consumer = 0; consumer < workflow.size(); ++consumer) {
852 O2_SIGNPOST_START(workflow_helpers, sid,
"input matching",
"Matching inputs of consumer [%zu] %{}s public", consumer, workflow[consumer].
name.c_str());
853 for (
size_t input = 0; input < workflow[consumer].inputs.size(); ++input) {
855 for (
size_t i = 0;
i < constOutputs.size();
i++) {
864 for (
size_t i = 0;
i < availableOutputsInfo.size();
i++) {
866 if (!matches[availableOutputsInfo[
i].outputGlobalIndex]) {
869 auto* oif = &availableOutputsInfo[
i];
873 auto producer = oif->specIndex;
874 auto uniqueOutputId = oif->outputGlobalIndex;
875 for (
size_t tpi = 0; tpi < workflow[consumer].maxInputTimeslices; ++tpi) {
876 for (
size_t ptpi = 0; ptpi < workflow[producer].maxInputTimeslices; ++ptpi) {
877 O2_SIGNPOST_EVENT_EMIT(workflow_helpers, sid,
"output",
"Adding edge between %{public}s and %{public}s", workflow[consumer].
name.c_str(),
878 workflow[producer].name.c_str());
879 logicalEdges.emplace_back(
DeviceConnectionEdge{producer, consumer, tpi, ptpi, uniqueOutputId, input, oif->forward});
884 oif->enabled =
false;
886 if (forwards.empty()) {
887 errorDueToMissingOutputFor(consumer, input);
889 availableOutputsInfo.erase(std::remove_if(availableOutputsInfo.begin(), availableOutputsInfo.end(), [](
auto const& info) { return info.enabled == false; }), availableOutputsInfo.end());
890 std::ranges::copy(forwards, std::back_inserter(availableOutputsInfo));
configStandalone Reconstruction rec_tpc multiplier for the combined cluster track error during track following area in cm for the search of for z only used if decrease removal by when above this local occupancy rowx Shift of TPC revert cluster flag edge bit distance to edge exceeds this ZOffset for secondary multiple of radius max P of electron K BB bands crossing max P of electron p BB bands crossing max P of electron d BB bands crossing max P of electron t BB bands crossing min accepted dEdxMaxTPC of the track Additive extra cluster error for Y2 if edge flag set Additive extra cluster error for Y2 if single set Additive extra cluster error for Y2 if or single set Additive extra cluster error for Z2 if or single set Extra errors to add to track when crossing depending on addErrorsCECrossing Inner portion of y range in sector that is not used in searching for extrapolated track candidates factor2YS for track merging factor2K for track merging Margin in cm of Y position when rejecting edge clusters based on uncorrected track Y Max fraction of shared clusters for tracklet Except pad from cluster finding if total number of charges in a fragment is above this Except pad from cluster finding if number of consecutive charges in a fragment is above this Threshold where a timebin is considered disabling the noisy pad check for that pad Treat signal above this minimum as saturated Smoothing factor for the exponential Highly Ionising Particle tail filter Number of timebins to use for the averaging Add additional custom track errors when crossing relative as fraction of Do N fit passes in final fit of< 0:reject at max -n hits") AddOptionRTC(rejectIFCLowRadiusCluster, uint8_t, 1, "", 0, "Reject clusters that get the IFC mask error during refit") AddOptionRTC(dEdxTruncLow, uint8_t, 2, "", 0, "Low truncation threshold, fraction of 128") AddOptionRTC(dEdxTruncHigh, uint8_t, 77, "", 0, "High truncation threshold, fraction of 128") AddOptionRTC(extrapolationTracking, int8_t, 1, "", 0, "Enable Extrapolation Tracking(prolong tracks to adjacent sectors to find short segments)") AddOptionRTC(disableRefitAttachment, uint8_t, 0, "", 0, "Bitmask to disable certain attachment steps during refit(1:attachment, 2:propagation, 4:loop following, 8:mirroring)") AddOptionRTC(rejectionStrategy, uint8_t, o2::gpu::GPUSettings::RejectionStrategyA, "", 0, "Enable rejection of TPC clusters for compression(0=no, 1=strategy A, 2=strategy B)") AddOptionRTC(mergeLoopersAfterburner, uint8_t, 1, "", 0, "Run afterburner for additional looper merging") AddOptionRTC(compressionTypeMask, uint8_t, o2::gpu::GPUSettings::CompressionFull, "", 0, "TPC Compression mode bits(1=truncate charge/width LSB, 2=differences, 4=track-model)") AddOptionRTC(compressionSortOrder, uint8_t, o2::gpu::GPUSettings::SortTime, "", 0, "Sort order of TPC compression(0=time, 1=pad, 2=Z-time-pad, 3=Z-pad-time, 4=no sorting(use incoming order))") AddOptionRTC(sigBitsCharge, uint8_t, 4, "", 0, "Number of significant bits for TPC cluster charge in compression mode 1") AddOptionRTC(sigBitsWidth, uint8_t, 3, "", 0, "Number of significant bits for TPC cluster width in compression mode 1") AddOptionRTC(dropLoopers, uint8_t, 0, "", 0, "Drop looping tracks starting from second loop") AddOptionRTC(mergerInterpolateErrors, uint8_t, 1, "", 0, "Use interpolation instead of extrapolation for chi2 based cluster rejection") AddOptionRTC(mergerInterpolateRejectAlsoOnCurrentPosition, uint8_t, 1, "", 0, "When using mergerInterpolateErrors, reject based on chi2 twice computed with interpolated and current track position starting from NDF > mergerNonInterpolateRejectMinNDF Merge tracks accross the central electrode Enable PID response Add sub threshold clusters in TPC dEdx computation OR mask of TPC flags that will reject the cluster in alternative dEdx Reject edge clusters based on uncorrected track Y during track fit Increase decrease removal by when on this number of pads from the edge h configStandalone Reconstruction rec_trd Max chi2 for TRD tracklets to be matched to a track Chi2 cut for strict matching mode Number of sigmas for ITS TPC track time error estimate Addition to search road around track prolongation along Y in cm Optimal tracklet rphi resolution in maximum chi2 per attached tracklet for TRD tracks take into account the full likelihood of the slope including exponential tails Tracks with less attached tracklets are discarded after the tracking Post trigger Pile up integration time in BCs fits all iterations but the last one in projections Use material lookup table for TPC refit Apply workarounds to avoid cyclic merge should not be needed tpc dyn configStandalone Processing proc_rtc Replace constant variables static by constexpr expressions Compile RTC in deterministic with NO_FAST_MATH flags and GPUCA_DETERMINISTIC_MODE define Use RTC to optimize GPU code h configStandalone Processing proc_rtctech Use a file lock to serialize access to the cache folder Print launch bounds used for RTC code as debugging option