AthCUDAServicesConfig Namespace Reference

Functions
	GPUSystemInfoSvcCfg (flags)
	HostMemoryResourceToolCfg (flags, **kwargs)
	DeviceMemoryResourceToolCfg (flags, **kwargs)
	ManagedMemoryResourceToolCfg (flags, **kwargs)
	MemoryResourcesToolCfg (flags, **kwargs)
	SingleStreamToolCfg (flags, **kwargs)
	PerEventStreamToolCfg (flags, **kwargs)
	PerComponentStreamToolCfg (flags, **kwargs)
	PerEventAndComponentStreamToolCfg (flags, **kwargs)
	StreamToolCfg (flags, **kwargs)
	SyncCopyToolCfg (flags, **kwargs)
	AsyncCopyToolCfg (flags, **kwargs)
	CopyToolCfg (flags, **kwargs)
	CopiesToolCfg (flags, **kwargs)

Function Documentation

AsyncCopyToolCfg()

AsyncCopyToolCfg	(		flags,
		**	kwargs )

Asynchronous copy object provider tool

Definition at line 326 of file AthCUDAServicesConfig.py.

def AsyncCopyToolCfg(flags, **kwargs):
    '''Asynchronous copy object provider tool
    '''
 
    # Create an accumulator to hold the configuration.
    result = ComponentAccumulator()
 
    # Create the tool. Attaching a stream tool to it.
    copyTool = CompFactory.AthCUDA.AsyncCopyTool(**kwargs)
    streamTool = StreamToolCfg(flags, **kwargs)
    copyTool.StreamTool = streamTool.getPrimary()
    result.merge(streamTool)
    result.setPrivateTools(copyTool)
 
    # Return the CA.
    return result
 
 

CopiesToolCfg()

CopiesToolCfg	(		flags,
		**	kwargs )

Default tool providing the ICopiesTool interface for CUDA

Definition at line 364 of file AthCUDAServicesConfig.py.

def CopiesToolCfg(flags, **kwargs):
    '''Default tool providing the ICopiesTool interface for CUDA
    '''
 
    # Create an accumulator to hold the configuration.
    result = ComponentAccumulator()
 
    # Create the main tool that would provide the AthDevice::ICopiesTool
    # interface.
    tool = CompFactory.AthDevice.CopiesAdaptorTool(**kwargs)
 
    # Set up the "host" copy tool. Which is always the same in our current code.
    from AthDeviceComps.AthDeviceCompsConfig import HostCopyToolCfg
    tool.HostCopyTool = \
        result.popToolsAndMerge(HostCopyToolCfg(flags, **kwargs))
 
    # Set up the device copy tool according to the received flags.
    if flags.Device.Copy.Async:
        tool.DeviceCopyTool = \
            result.popToolsAndMerge(AsyncCopyToolCfg(flags, **kwargs))
    else:
        tool.DeviceCopyTool = \
            result.popToolsAndMerge(SyncCopyToolCfg(flags, **kwargs))
        pass
 
    # Return the adaptor tool as the main component of the CA.
    result.setPrivateTools(tool)
 
    # Return the CA.
    return result

CopyToolCfg()

CopyToolCfg	(		flags,
		**	kwargs )

Default tool providing the ICopyTool interface for CUDA

Definition at line 344 of file AthCUDAServicesConfig.py.

def CopyToolCfg(flags, **kwargs):
    '''Default tool providing the ICopyTool interface for CUDA
    '''
 
    # Create an accumulator to hold the configuration.
    result = ComponentAccumulator()
 
    # Set up the device copy tool according to the received flags.
    if flags.Device.Copy.Async:
        result.setPrivateTools(result.popToolsAndMerge(
            AsyncCopyToolCfg(flags, **kwargs)))
    else:
        result.setPrivateTools(result.popToolsAndMerge(
            SyncCopyToolCfg(flags, **kwargs)))
        pass
 
    # Return the CA.
    return result
 
 

DeviceMemoryResourceToolCfg()

DeviceMemoryResourceToolCfg	(		flags,
		**	kwargs )

Default CUDA device memory resource tool to use

It makes sure that appropriate caching would be used, as allocating device
memory is relatively slow.

Definition at line 71 of file AthCUDAServicesConfig.py.

def DeviceMemoryResourceToolCfg(flags, **kwargs):
    '''Default CUDA device memory resource tool to use
 
    It makes sure that appropriate caching would be used, as allocating device
    memory is relatively slow.
    '''
 
    # Create an accumulator to hold the configuration.
    result = ComponentAccumulator()
 
    # Create the components that would collaborate to provide thread-safe
    # caching to the "bare" memory resource.
    tool = CompFactory.AthCUDA.DeviceMemoryResourceTool(**kwargs)
    if flags.Device.Memory.Monitor:
        monitorTool = CompFactory.AthDevice.MonitoredMemoryResourceTool(
            'CUDADeviceMemoryResourceMonitorTool',
            MRTool=tool)
        tool = monitorTool
        pass
    if flags.Device.Memory.Debug:
        debugTool = CompFactory.AthDevice.DebugMemoryResourceTool(
            'CUDADeviceMemoryResourceDebugTool',
            MRTool=tool)
        tool = debugTool
        pass
    if flags.Device.Memory.Cache:
        cacheSvc = CompFactory.AthDevice.BinaryPageMemoryResourceSvc(
            'CUDADeviceCachedMemoryResourceSvc',
            MRTool=tool)
        result.addService(cacheSvc)
        cacheTool = CompFactory.AthDevice.MemoryResourceSvcAdaptorTool(
            'CUDADeviceCachedMemoryResourceTool',
            MRSvc=cacheSvc)
        tool = cacheTool
        if flags.Device.Memory.Debug:
            debugTool = CompFactory.AthDevice.DebugMemoryResourceTool(
                'CUDADeviceCachedMemoryResourceDebugTool',
                MRTool=tool)
            tool = debugTool
            pass
        pass
    if flags.Device.Memory.Monitor and flags.Device.Memory.Cache:
        monitorTool = CompFactory.AthDevice.MonitoredMemoryResourceTool(
            'CUDADeviceCachedMemoryResourceMonitorTool',
            MRTool=tool)
        tool = monitorTool
        pass
    result.setPrivateTools(tool)
 
    # Return the CA.
    return result
 
 

GPUSystemInfoSvcCfg()

GPUSystemInfoSvcCfg

(

flags

)

Definition at line 11 of file AthCUDAServicesConfig.py.

def GPUSystemInfoSvcCfg(flags):
    acc = ComponentAccumulator()
    svc = CompFactory.getComp("AthCUDA::GPUSystemInfoSvc")("GPUSystemInfoSvc")
    acc.addService(svc)
    return acc
 
 

HostMemoryResourceToolCfg()

HostMemoryResourceToolCfg	(		flags,
		**	kwargs )

Default CUDA host memory resource tool to use

It makes sure that appropriate caching would be used, as allocating pinned
host memory is relatively slow.

Definition at line 18 of file AthCUDAServicesConfig.py.

def HostMemoryResourceToolCfg(flags, **kwargs):
    '''Default CUDA host memory resource tool to use
 
    It makes sure that appropriate caching would be used, as allocating pinned
    host memory is relatively slow.
    '''
 
    # Create an accumulator to hold the configuration.
    result = ComponentAccumulator()
 
    # Create the components that would collaborate to provide thread-safe
    # caching to the "bare" memory resource.
    tool = CompFactory.AthCUDA.HostMemoryResourceTool(**kwargs)
    if flags.Device.Memory.Monitor:
        monitorTool = CompFactory.AthDevice.MonitoredMemoryResourceTool(
            'CUDAHostMemoryResourceMonitorTool',
            MRTool=tool)
        tool = monitorTool
        pass
    if flags.Device.Memory.Debug:
        debugTool = CompFactory.AthDevice.DebugMemoryResourceTool(
            'CUDAHostMemoryResourceDebugTool',
            MRTool=tool)
        tool = debugTool
        pass
    if flags.Device.Memory.Cache:
        cacheSvc = CompFactory.AthDevice.BinaryPageMemoryResourceSvc(
            'CUDAHostCachedMemoryResourceSvc',
            MRTool=tool)
        result.addService(cacheSvc)
        cacheTool = CompFactory.AthDevice.MemoryResourceSvcAdaptorTool(
            'CUDAHostCachedMemoryResourceTool',
            MRSvc=cacheSvc)
        tool = cacheTool
        if flags.Device.Memory.Debug:
            debugTool = CompFactory.AthDevice.DebugMemoryResourceTool(
                'CUDAHostCachedMemoryResourceDebugTool',
                MRTool=tool)
            tool = debugTool
            pass
        pass
    if flags.Device.Memory.Monitor and flags.Device.Memory.Cache:
        monitorTool = CompFactory.AthDevice.MonitoredMemoryResourceTool(
            'CUDAHostCachedMemoryResourceMonitorTool',
            MRTool=tool)
        tool = monitorTool
        pass
    result.setPrivateTools(tool)
 
    # Return the CA.
    return result
 
 

ManagedMemoryResourceToolCfg()

ManagedMemoryResourceToolCfg	(		flags,
		**	kwargs )

Default CUDA managed memory resource tool to use

It makes sure that appropriate caching would be used, as allocating managed
memory is relatively slow.

Definition at line 124 of file AthCUDAServicesConfig.py.

def ManagedMemoryResourceToolCfg(flags, **kwargs):
    '''Default CUDA managed memory resource tool to use
 
    It makes sure that appropriate caching would be used, as allocating managed
    memory is relatively slow.
    '''
 
    # Create an accumulator to hold the configuration.
    result = ComponentAccumulator()
 
    # Create the components that would collaborate to provide thread-safe
    # caching to the "bare" memory resource.
    tool = CompFactory.AthCUDA.ManagedMemoryResourceTool(**kwargs)
    if flags.Device.Memory.Monitor:
        monitorTool = CompFactory.AthDevice.MonitoredMemoryResourceTool(
            'CUDAManagedMemoryResourceMonitorTool',
            MRTool=tool)
        tool = monitorTool
        pass
    if flags.Device.Memory.Debug:
        debugTool = CompFactory.AthDevice.DebugMemoryResourceTool(
            'CUDAManagedMemoryResourceDebugTool',
            MRTool=tool)
        tool = debugTool
        pass
    if flags.Device.Memory.Cache:
        cacheSvc = CompFactory.AthDevice.BinaryPageMemoryResourceSvc(
            'CUDAManagedCachedMemoryResourceSvc',
            MRTool=tool)
        result.addService(cacheSvc)
        cacheTool = CompFactory.AthDevice.MemoryResourceSvcAdaptorTool(
            'CUDAManagedCachedMemoryResourceTool',
            MRSvc=cacheSvc)
        tool = cacheTool
        if flags.Device.Memory.Debug:
            debugTool = CompFactory.AthDevice.DebugMemoryResourceTool(
                'CUDAManagedCachedMemoryResourceDebugTool',
                MRTool=tool)
            tool = debugTool
            pass
        pass
    if flags.Device.Memory.Monitor and flags.Device.Memory.Cache:
        monitorTool = CompFactory.AthDevice.MonitoredMemoryResourceTool(
            'CUDAManagedCachedMemoryResourceMonitorTool',
            MRTool=tool)
        tool = monitorTool
        pass
    result.setPrivateTools(tool)
 
    # Return the CA.
    return result
 
 

MemoryResourcesToolCfg()

MemoryResourcesToolCfg	(		flags,
		**	kwargs )

Default tool providing the IMemoryResourcesTool interface for CUDA

Definition at line 177 of file AthCUDAServicesConfig.py.

def MemoryResourcesToolCfg(flags, **kwargs):
    '''Default tool providing the IMemoryResourcesTool interface for CUDA
    '''
 
    # Create an accumulator to hold the configuration.
    result = ComponentAccumulator()
 
    # Create the main tool that would provide the
    # AthDevice::IMemoryResourcesTool interface.
    tool = CompFactory.AthDevice.MemoryResourcesAdaptorTool(**kwargs)
 
    # Set up the main tool according to the received flags.
    if flags.Device.Memory.Shared:
        mainMRTool = ManagedMemoryResourceToolCfg(flags)
        tool.MainMRTool = mainMRTool.getPrimary()
        result.merge(mainMRTool)
    else:
        mainMRTool = DeviceMemoryResourceToolCfg(flags)
        tool.MainMRTool = mainMRTool.getPrimary()
        result.merge(mainMRTool)
 
        hostMRTool = HostMemoryResourceToolCfg(flags)
        tool.HostMRTool = hostMRTool.getPrimary()
        result.merge(hostMRTool)
        pass
 
    # Return the adaptor tool as the main component of the CA.
    result.setPrivateTools(tool)
    return result
 
 

PerComponentStreamToolCfg()

PerComponentStreamToolCfg	(		flags,
		**	kwargs )

Tool providing one CUDA stream per component (algorithm/tool/service)

Definition at line 250 of file AthCUDAServicesConfig.py.

def PerComponentStreamToolCfg(flags, **kwargs):
    '''Tool providing one CUDA stream per component (algorithm/tool/service)
    '''
 
    # Create an accumulator to hold the configuration.
    result = ComponentAccumulator()
 
    # Create an tool that implements this behaviour.
    streamTool = CompFactory.AthCUDA.PerComponentStreamTool(**kwargs)
    result.setPrivateTools(streamTool)
 
    # Return the CA.
    return result
 
 

PerEventAndComponentStreamToolCfg()

PerEventAndComponentStreamToolCfg	(		flags,
		**	kwargs )

Tool providing one CUDA stream per component and event/slot

Definition at line 265 of file AthCUDAServicesConfig.py.

def PerEventAndComponentStreamToolCfg(flags, **kwargs):
    '''Tool providing one CUDA stream per component and event/slot
    '''
 
    # Create an accumulator to hold the configuration.
    result = ComponentAccumulator()
 
    # Create an tool that implements this behaviour.
    streamTool = CompFactory.AthCUDA.PerEventAndComponentStreamTool(**kwargs)
    result.setPrivateTools(streamTool)
 
    # Return the CA.
    return result
 
 

PerEventStreamToolCfg()

PerEventStreamToolCfg	(		flags,
		**	kwargs )

Tool providing one CUDA stream per event/slot

Definition at line 229 of file AthCUDAServicesConfig.py.

def PerEventStreamToolCfg(flags, **kwargs):
    '''Tool providing one CUDA stream per event/slot
    '''
 
    # Create an accumulator to hold the configuration.
    result = ComponentAccumulator()
 
    # Create the stream service and add it to the accumulator.
    streamSvc = CompFactory.AthCUDA.PerEventStreamSvc(**kwargs)
    result.addService(streamSvc)
 
    # Create an adaptor tool on top of the service, and set that as the main
    # component of the CA.
    streamTool = CompFactory.AthCUDA.StreamSvcAdaptorTool(
        'CUDAPerEventStreamTool', StreamSvc=streamSvc)
    result.setPrivateTools(streamTool)
 
    # Return the CA.
    return result
 
 

SingleStreamToolCfg()

SingleStreamToolCfg	(		flags,
		**	kwargs )

Tool providing a single CUDA stream for all components in the entire job

Definition at line 208 of file AthCUDAServicesConfig.py.

def SingleStreamToolCfg(flags, **kwargs):
    '''Tool providing a single CUDA stream for all components in the entire job
    '''
 
    # Create an accumulator to hold the configuration.
    result = ComponentAccumulator()
 
    # Create the stream service and add it to the accumulator.
    streamSvc = CompFactory.AthCUDA.SingleStreamSvc(**kwargs)
    result.addService(streamSvc)
 
    # Create an adaptor tool on top of the service, and set that as the main
    # component of the CA.
    streamTool = CompFactory.AthCUDA.StreamSvcAdaptorTool(
        'CUDASingleStreamTool', StreamSvc=streamSvc)
    result.setPrivateTools(streamTool)
 
    # Return the CA.
    return result
 
 

StreamToolCfg()

StreamToolCfg	(		flags,
		**	kwargs )

Default CUDA stream provider tool to use

Definition at line 280 of file AthCUDAServicesConfig.py.

def StreamToolCfg(flags, **kwargs):
    '''Default CUDA stream provider tool to use
    '''
 
    # Create an accumulator to hold the configuration.
    result = ComponentAccumulator()
 
    # Create the default stream tool, depending on the job's configuration.
    if flags.CUDA.Stream == CUDAStream.Single:
        cfg = SingleStreamToolCfg(flags, **kwargs)
        result.setPrivateTools(cfg.getPrimary())
        result.merge(cfg)
    elif flags.CUDA.Stream == CUDAStream.PerEvent:
        cfg = PerEventStreamToolCfg(flags, **kwargs)
        result.setPrivateTools(cfg.getPrimary())
        result.merge(cfg)
    elif flags.CUDA.Stream == CUDAStream.PerComponent:
        cfg = PerComponentStreamToolCfg(flags, **kwargs)
        result.setPrivateTools(cfg.getPrimary())
        result.merge(cfg)
    elif flags.CUDA.Stream == CUDAStream.PerEventAndComponent:
        cfg = PerEventAndComponentStreamToolCfg(flags, **kwargs)
        result.setPrivateTools(cfg.getPrimary())
        result.merge(cfg)
    else:
        raise ValueError(f"Invalid CUDA stream strategy: {flags.CUDA.Stream}")
        pass
 
    # Return the CA.
    return result
 
 

SyncCopyToolCfg()

SyncCopyToolCfg	(		flags,
		**	kwargs )

Synchronous copy object provider tool

Definition at line 312 of file AthCUDAServicesConfig.py.

def SyncCopyToolCfg(flags, **kwargs):
    '''Synchronous copy object provider tool
    '''
 
    # Create an accumulator to hold the configuration.
    result = ComponentAccumulator()
 
    # Create the tool in a simple way.
    result.setPrivateTools(CompFactory.AthCUDA.CopyTool(**kwargs))
 
    # Return the CA.
    return result