DeviceSpecHelpers.h

Go to the documentation of this file.

// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
// All rights not expressly granted are reserved.
//
// This software is distributed under the terms of the GNU General Public
// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
//
// In applying this license CERN does not waive the privileges and immunities
// granted to it by virtue of its status as an Intergovernmental Organization
// or submit itself to any jurisdiction.
#ifndef O2_FRAMEWORK_DEVICESPECHELPERS_H_
#define O2_FRAMEWORK_DEVICESPECHELPERS_H_
 
#include "Framework/WorkflowSpec.h"
#include "Framework/ChannelConfigurationPolicy.h"
#include "Framework/DataProcessorSpec.h"
#include "Framework/ChannelSpec.h"
#include "Framework/CompletionPolicy.h"
#include "Framework/DispatchPolicy.h"
#include "Framework/DeviceControl.h"
#include "Framework/DeviceExecution.h"
#include "Framework/DeviceSpec.h"
#include "Framework/AlgorithmSpec.h"
#include "Framework/ConfigParamSpec.h"
#include "Framework/OutputRoute.h"
#include "Framework/DataProcessorInfo.h"
#include "Framework/ProcessingPolicies.h"
#include "ResourceManager.h"
#include "WorkflowHelpers.h"
 
#include <boost/program_options.hpp>
 
#include <vector>
#include <string>
#include <map>
#include <functional>
 
namespace o2::framework
{
struct InputChannelSpec;
struct OutputChannelSpec;
struct ConfigContext;
struct DriverConfig;
 
struct DeviceSpecHelpers {
  static void dataProcessorSpecs2DeviceSpecs(
    const WorkflowSpec& workflow,
    std::vector<ChannelConfigurationPolicy> const& channelPolicies,
    std::vector<CompletionPolicy> const& completionPolicies,
    std::vector<DispatchPolicy> const& dispatchPolicies,
    std::vector<ResourcePolicy> const& resourcePolicies,
    std::vector<CallbacksPolicy> const& callbacksPolicies,
    std::vector<SendingPolicy> const& sendingPolicy,
    std::vector<ForwardingPolicy> const& forwardingPolicies,
    std::vector<DeviceSpec>& devices,
    ResourceManager& resourceManager,
    std::string const& uniqueWorkflowId,
    ConfigContext const& configContext,
    bool optimizeTopology = false,
    unsigned short resourcesMonitoringInterval = 0,
    std::string const& channelPrefix = "",
    OverrideServiceSpecs const& overrideServices = {});
 
  static void validate(WorkflowSpec const& workflow);
  static void dataProcessorSpecs2DeviceSpecs(
    const WorkflowSpec& workflow,
    std::vector<ChannelConfigurationPolicy> const& channelPolicies,
    std::vector<CompletionPolicy> const& completionPolicies,
    std::vector<CallbacksPolicy> const& callbacksPolicies,
    std::vector<DeviceSpec>& devices,
    ResourceManager& resourceManager,
    std::string const& uniqueWorkflowId,
    ConfigContext const& configContext,
    bool optimizeTopology = false,
    unsigned short resourcesMonitoringInterval = 0,
    std::string const& channelPrefix = "",
    OverrideServiceSpecs const& overrideServices = {})
  {
    std::vector<DispatchPolicy> dispatchPolicies = DispatchPolicy::createDefaultPolicies();
    std::vector<ResourcePolicy> resourcePolicies = ResourcePolicy::createDefaultPolicies();
    std::vector<SendingPolicy> sendingPolicies = SendingPolicy::createDefaultPolicies();
    std::vector<ForwardingPolicy> forwardingPolicies = ForwardingPolicy::createDefaultPolicies();
    dataProcessorSpecs2DeviceSpecs(workflow, channelPolicies, completionPolicies,
                                   dispatchPolicies, resourcePolicies, callbacksPolicies,
                                   sendingPolicies, forwardingPolicies, devices,
                                   resourceManager, uniqueWorkflowId, configContext, optimizeTopology,
                                   resourcesMonitoringInterval, channelPrefix, overrideServices);
  }
 
  static std::string inputChannel2String(const InputChannelSpec& channel);
 
  static std::string outputChannel2String(const OutputChannelSpec& channel);
 
  static void reworkHomogeneousOption(std::vector<DataProcessorInfo>& infos,
                                      char const* name, char const* defaultValue);
 
  static void reworkIntegerOption(std::vector<DataProcessorInfo>& infos,
                                  char const* name,
                                  std::function<long long()> defaultValueCallback,
                                  long long startValue,
                                  std::function<long long(long long, long long)> bestValue);
  static void reworkShmSegmentSize(std::vector<DataProcessorInfo>& infos);
  static void prepareArguments(
    bool defaultQuiet,
    bool defaultStopped,
    bool intereactive,
    unsigned short driverPort,
    DriverConfig const& driverConfig,
    std::vector<DataProcessorInfo> const& processorInfos,
    std::vector<DeviceSpec> const& deviceSpecs,
    std::vector<DeviceExecution>& deviceExecutions,
    std::vector<DeviceControl>& deviceControls,
    std::vector<ConfigParamSpec> const& detectedOptions,
    std::string const& uniqueWorkflowId);
 
  static std::string reworkTimeslicePlaceholder(std::string const& str, DeviceSpec const& spec);
 
  static void processOutEdgeActions(
    ConfigContext const& configContext,
    std::vector<DeviceSpec>& devices,
    std::vector<DeviceId>& deviceIndex,
    std::vector<DeviceConnectionId>& connections,
    ResourceManager& resourceManager,
    const std::vector<size_t>& outEdgeIndex,
    const std::vector<DeviceConnectionEdge>& logicalEdges,
    const std::vector<EdgeAction>& actions,
    const WorkflowSpec& workflow,
    const std::vector<OutputSpec>& outputs,
    std::vector<ChannelConfigurationPolicy> const& channelPolicies,
    std::vector<SendingPolicy> const& sendingPolicies,
    std::vector<ForwardingPolicy> const& forwardingPolicies,
    std::string const& channelPrefix,
    ComputingOffer const& defaultOffer,
    OverrideServiceSpecs const& overrideServices = {});
 
  static void processInEdgeActions(
    std::vector<DeviceSpec>& devices,
    std::vector<DeviceId>& deviceIndex,
    const std::vector<DeviceConnectionId>& connections,
    ResourceManager& resourceManager,
    const std::vector<size_t>& inEdgeIndex,
    const std::vector<DeviceConnectionEdge>& logicalEdges,
    const std::vector<EdgeAction>& actions,
    const WorkflowSpec& workflow,
    const std::vector<LogicalForwardInfo>& availableForwardsInfo,
    std::vector<ChannelConfigurationPolicy> const& channelPolicies,
    std::string const& channelPrefix,
    ComputingOffer const& defaultOffer,
    OverrideServiceSpecs const& overrideServices = {});
 
  static boost::program_options::options_description getForwardedDeviceOptions();
  static bool hasLabel(DeviceSpec const& spec, char const* label);
};
 
} // namespace o2::framework
#endif // O2_FRAMEWORK_DEVICESPECHELPERS_H_