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)
	CopyToolCfg (flags, **kwargs)
	AsyncCopyToolCfg (flags, **kwargs)

Function Documentation

AsyncCopyToolCfg()

AthCUDAServicesConfig.AsyncCopyToolCfg	(		flags,
		**	kwargs )

Asynchronous copy object provider tool

Definition at line 290 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

CopyToolCfg()

AthCUDAServicesConfig.CopyToolCfg	(		flags,
		**	kwargs )

Synchronous copy object provider tool

Definition at line 276 of file AthCUDAServicesConfig.py.

def CopyToolCfg(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
 
 

DeviceMemoryResourceToolCfg()

AthCUDAServicesConfig.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 59 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.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
    result.setPrivateTools(tool)
 
    # Return the CA.
    return result
 
 

GPUSystemInfoSvcCfg()

AthCUDAServicesConfig.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()

AthCUDAServicesConfig.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.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
    result.setPrivateTools(tool)
 
    # Return the CA.
    return result
 
 

ManagedMemoryResourceToolCfg()

AthCUDAServicesConfig.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 100 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.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
    result.setPrivateTools(tool)
 
    # Return the CA.
    return result
 
 

MemoryResourcesToolCfg()

AthCUDAServicesConfig.MemoryResourcesToolCfg	(		flags,
		**	kwargs )

Default tool providing the IMemoryResourcesTool interface for CUDA

Definition at line 141 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()

AthCUDAServicesConfig.PerComponentStreamToolCfg	(		flags,
		**	kwargs )

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

Definition at line 214 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()

AthCUDAServicesConfig.PerEventAndComponentStreamToolCfg	(		flags,
		**	kwargs )

Tool providing one CUDA stream per component and event/slot

Definition at line 229 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()

AthCUDAServicesConfig.PerEventStreamToolCfg	(		flags,
		**	kwargs )

Tool providing one CUDA stream per event/slot

Definition at line 193 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(
        'PerEventStreamTool', StreamSvc=streamSvc)
    result.setPrivateTools(streamTool)
 
    # Return the CA.
    return result
 
 

SingleStreamToolCfg()

AthCUDAServicesConfig.SingleStreamToolCfg	(		flags,
		**	kwargs )

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

Definition at line 172 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(
        'SingleStreamTool', StreamSvc=streamSvc)
    result.setPrivateTools(streamTool)
 
    # Return the CA.
    return result
 
 

StreamToolCfg()

AthCUDAServicesConfig.StreamToolCfg	(		flags,
		**	kwargs )

Default CUDA stream provider tool to use

Definition at line 244 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