Showing preview only (4,123K chars total). Download the full file or copy to clipboard to get everything.
Repository: csiro-robotics/ohm
Branch: master
Commit: 4e2e76945e55
Files: 551
Total size: 3.8 MB
Directory structure:
gitextract_waem9xm7/
├── .clang-format
├── .clang-tidy
├── .gitignore
├── 3rdparty/
│ └── 3es-core/
│ └── 3esservermacros.h
├── CMakeLists.txt
├── LICENSE
├── OpenCL.md
├── clearance-performance-notes.md
├── clu/
│ ├── 3rdparty/
│ │ └── CL/
│ │ └── opencl.hpp
│ ├── CMakeLists.txt
│ ├── clu.cpp
│ ├── clu.h
│ ├── cluBuffer.h
│ ├── cluConfig.in.h
│ ├── cluConstraint.cpp
│ ├── cluConstraint.h
│ ├── cluKernel.cpp
│ ├── cluKernel.h
│ ├── cluProgram.cpp
│ └── cluProgram.h
├── cmake/
│ ├── ClangTidy.cmake
│ ├── FindLASZIP.cmake
│ ├── FindLIBLAS.cmake
│ ├── FindOctomap.cmake
│ ├── FindTBB.cmake
│ ├── Findglm.cmake
│ ├── LeakTrack.cmake
│ ├── OhmCuda.cmake
│ ├── OhmGTest.cmake
│ ├── TextFileResource.cmake
│ ├── TextFileResource.py
│ ├── compilerSetup.cmake
│ ├── doxyfile.in
│ ├── doxygen.cmake
│ ├── ohm-config.cmake
│ ├── ohm-packages.cmake
│ ├── tidy/
│ │ ├── clang-tidy-names.yaml
│ │ └── wrap-clang-tidy.py
│ └── utils.cmake
├── docs/
│ ├── docglossary.md
│ ├── docmain.h
│ ├── docusage.md
│ ├── docutils.md
│ ├── docvoxellayers.md
│ └── gpu/
│ ├── docgpualgorithm.md
│ └── docgpudetail.md
├── gputil/
│ ├── CMakeLists.txt
│ ├── cl/
│ │ ├── gpuApiExceptionCode.cpp
│ │ ├── gpuBuffer.cpp
│ │ ├── gpuBufferDetail.h
│ │ ├── gpuDevice.cpp
│ │ ├── gpuDeviceDetail.h
│ │ ├── gpuEvent.cpp
│ │ ├── gpuEventDetail.h
│ │ ├── gpuKernel.cpp
│ │ ├── gpuKernel2.h
│ │ ├── gpuKernelDetail.h
│ │ ├── gpuPinnedBuffer.cpp
│ │ ├── gpuPlatform2.h
│ │ ├── gpuProgram.cpp
│ │ ├── gpuProgramDetail.h
│ │ ├── gpuQueue.cpp
│ │ └── gpuQueueDetail.h
│ ├── cuda/
│ │ ├── cutil_atomic.h
│ │ ├── cutil_decl.h
│ │ ├── cutil_importcl.h
│ │ ├── cutil_math.h
│ │ ├── gpuApiExceptionCode.cpp
│ │ ├── gpuBuffer.cpp
│ │ ├── gpuBufferDetail.h
│ │ ├── gpuDevice.cpp
│ │ ├── gpuDeviceDetail.h
│ │ ├── gpuDirtyRegion
│ │ ├── gpuEvent.cpp
│ │ ├── gpuEventDetail.h
│ │ ├── gpuKernel.cpp
│ │ ├── gpuKernel2.h
│ │ ├── gpuKernelDetail.h
│ │ ├── gpuMemRegion.cpp
│ │ ├── gpuMemRegion.h
│ │ ├── gpuPinnedBuffer.cpp
│ │ ├── gpuPlatform2.h
│ │ ├── gpuProgram.cpp
│ │ ├── gpuProgramDetail.h
│ │ ├── gpuQueue.cpp
│ │ ├── gpuQueueDetail.h
│ │ └── ref.h
│ ├── gpuApiException.cpp
│ ├── gpuApiException.h
│ ├── gpuBuffer.h
│ ├── gpuConfig.in.h
│ ├── gpuDevice.h
│ ├── gpuDeviceInfo.h
│ ├── gpuEvent.h
│ ├── gpuEventList.cpp
│ ├── gpuEventList.h
│ ├── gpuException.cpp
│ ├── gpuException.h
│ ├── gpuKernel.h
│ ├── gpuPinMode.h
│ ├── gpuPinnedBuffer.h
│ ├── gpuPlatform.h
│ ├── gpuProgram.h
│ ├── gpuQueue.h
│ ├── gpuThrow.cpp
│ ├── gpuThrow.h
│ ├── gpuVersion.h
│ └── gpu_ext.h
├── logutil/
│ ├── CMakeLists.txt
│ ├── LogUtil.cpp
│ ├── LogUtil.h
│ ├── LogUtilConfig.in.h
│ ├── Logger.cpp
│ ├── Logger.h
│ └── LoggerDetail.h
├── ohm/
│ ├── Aabb.h
│ ├── CMakeLists.txt
│ ├── CalculateSegmentKeys.cpp
│ ├── CalculateSegmentKeys.h
│ ├── ClearingPattern.cpp
│ ├── ClearingPattern.h
│ ├── CompareMaps.cpp
│ ├── CompareMaps.h
│ ├── CopyUtil.cpp
│ ├── CopyUtil.h
│ ├── CovarianceVoxel.cpp
│ ├── CovarianceVoxel.h
│ ├── CovarianceVoxelCompute.h
│ ├── DataType.cpp
│ ├── DataType.h
│ ├── DebugDraw.cpp
│ ├── DebugDraw.h
│ ├── DebugIDs.h
│ ├── DefaultLayer.cpp
│ ├── DefaultLayer.h
│ ├── Density.cpp
│ ├── Density.h
│ ├── Key.cpp
│ ├── Key.h
│ ├── KeyHash.cpp
│ ├── KeyHash.h
│ ├── KeyList.cpp
│ ├── KeyList.h
│ ├── KeyRange.cpp
│ ├── KeyRange.h
│ ├── KeyStream.h
│ ├── LineKeysQuery.cpp
│ ├── LineKeysQuery.h
│ ├── LineQuery.cpp
│ ├── LineQuery.h
│ ├── LineWalk.h
│ ├── LineWalkCompute.h
│ ├── MapChunk.cpp
│ ├── MapChunk.h
│ ├── MapChunkFlag.h
│ ├── MapCoord.h
│ ├── MapFlag.cpp
│ ├── MapFlag.h
│ ├── MapInfo.cpp
│ ├── MapInfo.h
│ ├── MapLayer.cpp
│ ├── MapLayer.h
│ ├── MapLayout.cpp
│ ├── MapLayout.h
│ ├── MapLayoutMatch.h
│ ├── MapProbability.h
│ ├── MapRegion.cpp
│ ├── MapRegion.h
│ ├── MapRegionCache.cpp
│ ├── MapRegionCache.h
│ ├── MapSerialise.cpp
│ ├── MapSerialise.h
│ ├── Mapper.cpp
│ ├── Mapper.h
│ ├── MappingProcess.cpp
│ ├── MappingProcess.h
│ ├── Mutex.cpp
│ ├── Mutex.h
│ ├── NdtMap.cpp
│ ├── NdtMap.h
│ ├── NdtMode.cpp
│ ├── NdtMode.h
│ ├── NearestNeighbours.cpp
│ ├── NearestNeighbours.h
│ ├── OccupancyMap.cpp
│ ├── OccupancyMap.h
│ ├── OccupancyType.cpp
│ ├── OccupancyType.h
│ ├── OccupancyUtil.cpp
│ ├── OccupancyUtil.h
│ ├── OhmConfig.in.h
│ ├── Query.cpp
│ ├── Query.h
│ ├── QueryFlag.h
│ ├── RayFilter.cpp
│ ├── RayFilter.h
│ ├── RayFlag.h
│ ├── RayMapper.cpp
│ ├── RayMapper.h
│ ├── RayMapperNdt.cpp
│ ├── RayMapperNdt.h
│ ├── RayMapperOccupancy.cpp
│ ├── RayMapperOccupancy.h
│ ├── RayMapperSecondarySample.cpp
│ ├── RayMapperSecondarySample.h
│ ├── RayMapperTrace.cpp
│ ├── RayMapperTrace.h
│ ├── RayMapperTsdf.cpp
│ ├── RayMapperTsdf.h
│ ├── RayPattern.cpp
│ ├── RayPattern.h
│ ├── RayPatternConical.cpp
│ ├── RayPatternConical.h
│ ├── RaysQuery.cpp
│ ├── RaysQuery.h
│ ├── Stream.cpp
│ ├── Stream.h
│ ├── Trace.cpp
│ ├── Trace.h
│ ├── Voxel.cpp
│ ├── Voxel.h
│ ├── VoxelBlock.cpp
│ ├── VoxelBlock.h
│ ├── VoxelBlockCompressionQueue.cpp
│ ├── VoxelBlockCompressionQueue.h
│ ├── VoxelBuffer.cpp
│ ├── VoxelBuffer.h
│ ├── VoxelData.h
│ ├── VoxelIncident.h
│ ├── VoxelIncidentCompute.h
│ ├── VoxelLayout.cpp
│ ├── VoxelLayout.h
│ ├── VoxelMean.h
│ ├── VoxelMeanCompute.h
│ ├── VoxelOccupancy.h
│ ├── VoxelOccupancyCompute.h
│ ├── VoxelSecondarySample.h
│ ├── VoxelTouchTime.h
│ ├── VoxelTouchTimeCompute.h
│ ├── VoxelTsdf.cpp
│ ├── VoxelTsdf.h
│ ├── VoxelTsdfCompute.h
│ ├── private/
│ │ ├── ClearingPatternDetail.h
│ │ ├── LineKeysQueryDetail.h
│ │ ├── LineQueryDetail.h
│ │ ├── MapLayerDetail.h
│ │ ├── MapLayoutDetail.h
│ │ ├── MapperDetail.h
│ │ ├── NdtMapDetail.h
│ │ ├── NearestNeighboursDetail.h
│ │ ├── OccupancyMapDetail.cpp
│ │ ├── OccupancyMapDetail.h
│ │ ├── OccupancyQueryAlg.h
│ │ ├── QueryDetail.h
│ │ ├── RayPatternDetail.h
│ │ ├── RaysQueryDetail.h
│ │ ├── SerialiseUtil.h
│ │ ├── VoxelAlgorithms.cpp
│ │ ├── VoxelAlgorithms.h
│ │ ├── VoxelBlockCompressionQueueDetail.h
│ │ └── VoxelLayoutDetail.h
│ └── serialise/
│ ├── MapSerialiseV0.1.cpp
│ ├── MapSerialiseV0.1.h
│ ├── MapSerialiseV0.2.cpp
│ ├── MapSerialiseV0.2.h
│ ├── MapSerialiseV0.4.cpp
│ ├── MapSerialiseV0.4.h
│ ├── MapSerialiseV0.5.cpp
│ ├── MapSerialiseV0.5.h
│ ├── MapSerialiseV0.cpp
│ └── MapSerialiseV0.h
├── ohm.natvis
├── ohmapp/
│ ├── CMakeLists.txt
│ ├── DataSource.cpp
│ ├── DataSource.h
│ ├── MapHarness.cpp
│ ├── MapHarness.h
│ ├── OhmAppConfig.in.h
│ ├── OhmAppCpu.cpp
│ ├── OhmAppCpu.h
│ ├── OhmAppGpu.cpp
│ ├── OhmAppGpu.h
│ ├── OhmAppGpuConfig.in.h
│ ├── SlamIOSource.cpp
│ ├── SlamIOSource.h
│ └── ohmappmain.inl
├── ohmgpu/
│ ├── CMakeLists.txt
│ ├── ClearanceProcess.cpp
│ ├── ClearanceProcess.h
│ ├── GpuCache.cpp
│ ├── GpuCache.h
│ ├── GpuCachePostSyncHandler.h
│ ├── GpuCacheStats.h
│ ├── GpuKey.h
│ ├── GpuLayerCache.cpp
│ ├── GpuLayerCache.h
│ ├── GpuLayerCacheParams.cpp
│ ├── GpuLayerCacheParams.h
│ ├── GpuMap.cpp
│ ├── GpuMap.h
│ ├── GpuNdtMap.cpp
│ ├── GpuNdtMap.h
│ ├── GpuTransformSamples.cpp
│ ├── GpuTransformSamples.h
│ ├── GpuTsdfMap.cpp
│ ├── GpuTsdfMap.h
│ ├── LineKeysQueryGpu.cpp
│ ├── LineKeysQueryGpu.h
│ ├── LineQueryGpu.cpp
│ ├── LineQueryGpu.h
│ ├── OhmGpu.cpp
│ ├── OhmGpu.h
│ ├── OhmGpuConfig.in.h
│ ├── RayItem.h
│ ├── RaysQueryGpu.cpp
│ ├── RaysQueryGpu.h
│ ├── gpu/
│ │ ├── AdjustNdt.cl
│ │ ├── AdjustOccupancy.cl
│ │ ├── CovarianceHitNdt.cl
│ │ ├── CovarianceHitNdt.cu
│ │ ├── CovarianceHitNdt_h.cl
│ │ ├── LineKeys.cl
│ │ ├── LineKeys.cu
│ │ ├── LineWalk.cl
│ │ ├── LineWalkMarkers.cl
│ │ ├── RaysQuery.cl
│ │ ├── RaysQuery.cu
│ │ ├── RaysQueryResult.h
│ │ ├── RegionUpdate.cl
│ │ ├── RegionUpdate.cu
│ │ ├── RegionUpdateNdt.cu
│ │ ├── Regions.cl
│ │ ├── RoiRangeFill.cl
│ │ ├── RoiRangeFill.cu
│ │ ├── TransformSamples.cl
│ │ ├── TransformSamples.cu
│ │ ├── Traversal.cl
│ │ ├── TsdfUpdate.cl
│ │ ├── TsdfUpdate.cu
│ │ ├── VoxelIncident.cl
│ │ └── VoxelMean.cl
│ └── private/
│ ├── ClearanceProcessDetail.cpp
│ ├── ClearanceProcessDetail.h
│ ├── GpuMapDetail.cpp
│ ├── GpuMapDetail.h
│ ├── GpuNdtMapDetail.h
│ ├── GpuProgramRef.cpp
│ ├── GpuProgramRef.h
│ ├── GpuTransformSamplesDetail.h
│ ├── GpuTsdfMapDetail.h
│ ├── LineKeysQueryDetailGpu.h
│ ├── LineQueryDetailGpu.h
│ ├── RaysQueryDetailGpu.cpp
│ ├── RaysQueryDetailGpu.h
│ ├── RoiRangeFill.cpp
│ └── RoiRangeFill.h
├── ohmheightmap/
│ ├── 3rdparty/
│ │ └── delaunator.hpp
│ ├── CMakeLists.txt
│ ├── Heightmap.cpp
│ ├── Heightmap.h
│ ├── HeightmapMesh.cpp
│ ├── HeightmapMesh.h
│ ├── HeightmapMode.cpp
│ ├── HeightmapMode.h
│ ├── HeightmapSerialise.cpp
│ ├── HeightmapSerialise.h
│ ├── HeightmapUtil.cpp
│ ├── HeightmapUtil.h
│ ├── HeightmapVoxel.cpp
│ ├── HeightmapVoxel.h
│ ├── HeightmapVoxelType.h
│ ├── OhmHeightmapConfig.in.h
│ ├── PlaneFillLayeredWalker.cpp
│ ├── PlaneFillLayeredWalker.h
│ ├── PlaneFillWalker.cpp
│ ├── PlaneFillWalker.h
│ ├── PlaneWalkVisitMode.h
│ ├── PlaneWalker.cpp
│ ├── PlaneWalker.h
│ ├── TriangleEdge.h
│ ├── TriangleNeighbours.h
│ ├── UpAxis.h
│ └── private/
│ ├── HeightmapDetail.cpp
│ ├── HeightmapDetail.h
│ ├── HeightmapOperations.cpp
│ └── HeightmapOperations.h
├── ohmheightmapimage/
│ ├── CMakeLists.txt
│ ├── HeightmapImage.cpp
│ ├── HeightmapImage.h
│ └── OhmHeightmapImageConfig.in.h
├── ohmtools/
│ ├── CMakeLists.txt
│ ├── OhmCloud.cpp
│ ├── OhmCloud.h
│ ├── OhmGen.cpp
│ ├── OhmGen.h
│ └── OhmToolsConfig.in.h
├── ohmutil/
│ ├── 3rdparty/
│ │ ├── cxxopts/
│ │ │ └── cxxopts.hpp
│ │ └── ska/
│ │ ├── bytell_hash_map.hpp
│ │ ├── flat_hash_map.hpp
│ │ ├── ska_sort.hpp
│ │ └── unordered_map.hpp
│ ├── CMakeLists.txt
│ ├── Colour.cpp
│ ├── Colour.h
│ ├── GlmStream.h
│ ├── OhmUtilConfig.in.h
│ ├── Options.h
│ ├── PlyMesh.cpp
│ ├── PlyMesh.h
│ ├── PlyPointStream.cpp
│ ├── PlyPointStream.h
│ ├── Profile.cpp
│ ├── Profile.h
│ ├── ProfileMarker.cpp
│ ├── ProfileMarker.h
│ ├── ProgressMonitor.cpp
│ ├── ProgressMonitor.h
│ ├── SafeIO.cpp
│ ├── SafeIO.h
│ ├── ScopedTimeDisplay.cpp
│ ├── ScopedTimeDisplay.h
│ ├── VectorHash.h
│ └── p2p.h
├── package.xml
├── readme.md
├── scripts/
│ ├── ohm-parse-timing.py
│ ├── ohm-timing-run.py
│ └── setup.cfg
├── slamio/
│ ├── CMakeLists.txt
│ ├── DataChannel.h
│ ├── PointCloudReader.cpp
│ ├── PointCloudReader.h
│ ├── PointCloudReaderPdal.cpp
│ ├── PointCloudReaderPdal.h
│ ├── PointCloudReaderPly.cpp
│ ├── PointCloudReaderPly.h
│ ├── PointCloudReaderTraj.cpp
│ ├── PointCloudReaderTraj.h
│ ├── PointCloudReaderXyz.cpp
│ ├── PointCloudReaderXyz.h
│ ├── Points.cpp
│ ├── Points.h
│ ├── SlamCloudLoader.cpp
│ ├── SlamCloudLoader.h
│ ├── SlamIO.cpp
│ ├── SlamIO.h
│ ├── SlamIOConfig.in.h
│ ├── pdal/
│ │ ├── PointStream.cpp
│ │ └── PointStream.h
│ └── rply/
│ ├── LICENSE
│ ├── rply.c
│ ├── rply.h
│ └── rplyfile.h
├── tests/
│ ├── CMakeLists.txt
│ ├── data/
│ │ ├── CMakeLists.txt
│ │ ├── readme.md
│ │ ├── test-map.0.1.0.ohm
│ │ ├── test-map.0.2.0.ohm
│ │ ├── test-map.0.3.0.ohm
│ │ ├── test-map.0.4.0.ohm
│ │ └── test-map.0.ohm
│ ├── gputiltest/
│ │ ├── CMakeLists.txt
│ │ ├── GpuBufferTest.cpp
│ │ ├── GpuDeviceTest.cpp
│ │ ├── KernelTest.cpp
│ │ ├── TestMain.cpp
│ │ ├── cuda/
│ │ │ └── matrix_kernel.cu
│ │ └── matrix.cl
│ ├── ohmtest/
│ │ ├── CMakeLists.txt
│ │ ├── CompressionTests.cpp
│ │ ├── CopyTests.cpp
│ │ ├── IncidentsTests.cpp
│ │ ├── KeyTests.cpp
│ │ ├── LayoutTests.cpp
│ │ ├── LineQueryTests.cpp
│ │ ├── LineWalkTests.cpp
│ │ ├── MapTests.cpp
│ │ ├── MathsTests.cpp
│ │ ├── NdtTests.cpp
│ │ ├── OhmConfig.in.h
│ │ ├── OhmTestConfig.in.h
│ │ ├── RayPatternTests.cpp
│ │ ├── RayValidation.cpp
│ │ ├── RayValidation.h
│ │ ├── RaysQueryTests.cpp
│ │ ├── SecondarySampleTests.cpp
│ │ ├── SerialisationTests.cpp
│ │ ├── TestMain.cpp
│ │ ├── TouchTimeTests.cpp
│ │ ├── TraversalTests.cpp
│ │ ├── TsdfTests.cpp
│ │ └── VoxelMeanTests.cpp
│ ├── ohmtestcommon/
│ │ ├── CMakeLists.txt
│ │ ├── CovarianceTestUtil.cpp
│ │ ├── CovarianceTestUtil.h
│ │ ├── OhmTestUtil.cpp
│ │ ├── OhmTestUtil.h
│ │ ├── RayPatternTestUtil.h
│ │ ├── TraversalTest.cpp
│ │ ├── TraversalTest.h
│ │ ├── WalkSegmentKeysLegacy.cpp
│ │ └── WalkSegmentKeysLegacy.h
│ ├── ohmtestgpu/
│ │ ├── CMakeLists.txt
│ │ ├── GpuCopyTests.cpp
│ │ ├── GpuIncidentsTests.cpp
│ │ ├── GpuLineKeysTests.cpp
│ │ ├── GpuLineQueryTests.cpp
│ │ ├── GpuMapTest.cpp
│ │ ├── GpuMapperTests.cpp
│ │ ├── GpuNdtTests.cpp
│ │ ├── GpuRangesTests.cpp
│ │ ├── GpuRayPatternTests.cpp
│ │ ├── GpuRaysQueryTests.cpp
│ │ ├── GpuSerialisationTests.cpp
│ │ ├── GpuTestMain.cpp
│ │ ├── GpuTests.cpp
│ │ ├── GpuTouchTimeTests.cpp
│ │ ├── GpuTraversalTests.cpp
│ │ ├── GpuTsdfTests.cpp
│ │ └── GpuVoxelMeanTests.cpp
│ ├── ohmtestheightmap/
│ │ ├── CMakeLists.txt
│ │ └── HeightmapTests.cpp
│ └── slamiotest/
│ ├── CMakeLists.txt
│ ├── Loader.cpp
│ └── SlamCloudLoader.cpp
├── todo.md
├── utils/
│ ├── CMakeLists.txt
│ ├── ohm2ply/
│ │ ├── CMakeLists.txt
│ │ └── ohm2ply.cpp
│ ├── ohmcmp/
│ │ ├── CMakeLists.txt
│ │ └── ohmcmp.cpp
│ ├── ohmfilter/
│ │ ├── CMakeLists.txt
│ │ └── ohmfilter.cpp
│ ├── ohmheightmap/
│ │ ├── CMakeLists.txt
│ │ └── ohmheightmap.cpp
│ ├── ohmhm2img/
│ │ ├── CMakeLists.txt
│ │ └── ohmhm2img.cpp
│ ├── ohminfo/
│ │ ├── CMakeLists.txt
│ │ └── ohminfo.cpp
│ ├── ohmpop/
│ │ ├── CMakeLists.txt
│ │ ├── OhmPopConfig.in.h
│ │ ├── ohmpopmaincpu.cpp
│ │ └── ohmpopmaingpu.cpp
│ ├── ohmprob/
│ │ ├── CMakeLists.txt
│ │ └── ohmprob.cpp
│ ├── ohmquery/
│ │ ├── CMakeLists.txt
│ │ ├── OhmQueryConfig.in.h
│ │ └── ohmquery.cpp
│ └── ohmsubmap/
│ ├── CMakeLists.txt
│ └── ohmsubmap.cpp
└── vcpkg.json
================================================
FILE CONTENTS
================================================
================================================
FILE: .clang-format
================================================
# Expected version: clang-format-10
Language: Cpp
BasedOnStyle: Google
AccessModifierOffset: -2
AlignAfterOpenBracket: Align
AlignConsecutiveAssignments: false
AlignConsecutiveDeclarations: false
AlignConsecutiveMacros: true
AlignEscapedNewlines: Left
AlignOperands: true
AlignTrailingComments: true
AllowAllArgumentsOnNextLine: false
AllowAllConstructorInitializersOnNextLine: true
AllowAllParametersOfDeclarationOnNextLine: true
AllowShortBlocksOnASingleLine: Never
AllowShortCaseLabelsOnASingleLine: false
AllowShortFunctionsOnASingleLine: InlineOnly
AllowShortIfStatementsOnASingleLine: Never
AllowShortLambdasOnASingleLine: All
AllowShortLoopsOnASingleLine: false
AlwaysBreakAfterDefinitionReturnType: None
AlwaysBreakAfterReturnType: None
AlwaysBreakBeforeMultilineStrings: false
AlwaysBreakTemplateDeclarations: Yes
BinPackArguments: true
BinPackParameters: true
BreakBeforeBraces: Custom
BraceWrapping:
AfterCaseLabel: true
AfterClass: true
AfterControlStatement: true
AfterEnum: true
AfterFunction: true
AfterNamespace: true
AfterStruct: true
AfterUnion: true
# AfterExternBlock: false
BeforeCatch: true
BeforeElse: true
IndentBraces: false
SplitEmptyFunction: false
SplitEmptyRecord: true
SplitEmptyNamespace: false
BreakBeforeBinaryOperators: None
BreakBeforeInheritanceComma: false
BreakBeforeTernaryOperators: false
BreakConstructorInitializers: BeforeComma
BreakInheritanceList: BeforeComma
BreakStringLiterals: true
ColumnLimit: 120
CompactNamespaces: false
ConstructorInitializerAllOnOneLineOrOnePerLine: false
ConstructorInitializerIndentWidth: 2
ContinuationIndentWidth: 2
Cpp11BracedListStyle: false
DerivePointerAlignment: false
FixNamespaceComments: true
IncludeBlocks: Preserve
# IncludeCategories:
# - Regex: '^"(llvm|llvm-c|clang|clang-c)/'
# Priority: 2
# - Regex: '^(<|"(gtest|gmock|isl|json)/)'
# Priority: 3
# - Regex: '.*'
# Priority: 1
# IncludeCategories: TODO
# IncludeMainReges: TODO
IndentCaseLabels: false
IndentGotoLabels: false
# IndentPPDirectives: None
IndentWidth: 2
IndentWrappedFunctionNames: true
KeepEmptyLinesAtTheStartOfBlocks: false
# MacroBlockBegin: <strings>
# MacroBlockEnd: <strings>
MaxEmptyLinesToKeep: 2
NamespaceIndentation: None
# PenaltyBreakAssignment: <int>
# PenaltyBreakBeforeFirstCallParameter: <int>
# PenaltyBreakComment: <int>
# PenaltyBreakFirstLessLess: <int>
# PenaltyBreakString: <int>
# PenaltyExcessCharacter: <int>
# PenaltyReturnTypeOnItsOwnLine: <int>
PointerAlignment: Right
ReflowComments: true
SortIncludes: true
SortUsingDeclarations: true
SpaceAfterCStyleCast: false
SpaceAfterLogicalNot: false
SpaceAfterTemplateKeyword: true
SpaceBeforeAssignmentOperators: true
SpaceBeforeCpp11BracedList: false
SpaceBeforeCtorInitializerColon: true
SpaceBeforeInheritanceColon: true
SpaceBeforeParens: ControlStatements
SpaceBeforeRangeBasedForLoopColon: true
SpaceBeforeSquareBrackets: false
SpaceInEmptyParentheses: false
SpacesBeforeTrailingComments: 2
SpacesInAngles: false
SpacesInCStyleCastParentheses: false
SpacesInConditionalStatement: false
SpacesInContainerLiterals: true
SpacesInParentheses: false
SpacesInSquareBrackets: false
Standard: Auto
TabWidth: 2
UseCRLF: false
UseTab: Never
================================================
FILE: .clang-tidy
================================================
# Run clang tidy general analysis, excluding variable naming checks.
---
Checks: >
clang-diagnostic-*,
clang-analyzer-*,
boost-use-to-string,
bugprone-*,
cert-dcl58-cpp,
cert-env33-c,
cert-err34-c,
cert-err52-cpp,
cert-err58-cpp,
cert-mem57-cpp,
cert-oop57-cpp,
cert-oop58-cpp,
cppcoreguildelines-*,
-cppcoreguidelines-macro-usage,
-cppcoreguidelines-pro-bounds-pointer-arithmatic,
google-*,
-google-runtime-references,
llvm-include-order,
llvm-namespace-comment,
misc-*,
-misc-no-recursion,
-misc-non-private-member-variables-in-classes,
-misc-unused-parameters,
modernize-*,
-modernize-use-trailing-return-type,
performance-*,
readability-*,
-readability-implicit-bool-conversion,
-readability-uppercase-literal-suffix,
hicpp-signed-bitwise
WarningsAsErrors: ''
HeaderFilterRegex: '.*'
AnalyzeTemporaryDtors: false
FormatStyle: none
User: csiro
CheckOptions:
- key: bugprone-argument-comment.StrictMode
value: '1'
- key: bugprone-misplaced-widening-cast.CheckImplicitCasts
value: '1'
- key: performance-move-constructor-init.IncludeStyle
value: 'llvm'
- key: cppcoreguidelines-special-member-functions.AllowSoleDefaultDtor
value: '1'
- key: cppcoreguidelines-special-member-functions.AllowMissingMoveFunctions
value: '1'
- key: google-runtime-int.TypeSuffix
value: '_t'
- key: modernize-use-default-member-init.UseAssignment
value: '1'
# ---------------------------------------------------------------------------
# Classes and structs
# Class names
- key: readability-identifier-naming.ClassCase
value: CamelCase
# Structs
- key: readability-identifier-naming.StructCase
value: CamelCase
# static const class members
- key: readability-identifier-naming.ClassConstantCase
value: CamelCase
- key: readability-identifier-naming.ClassConstantPrefix
value: 'k'
# static class members (non-const)
- key: readability-identifier-naming.ClassMemberCase
value: lower_case
# Class members which are const, but not static - omitted to control by access scope (public, private, etc)
# - key: readability-identifier-naming.ConstantMemberCase
# value: lower_case
# Class member functions - any access modifier (public, private, etc)
- key: readability-identifier-naming.ClassMethodCase
value: camelBack
# Class member variable catchall
- key: readability-identifier-naming.MemberCase
value: lower_case
# Private class member variables
- key: readability-identifier-naming.PrivateMemberCase
value: lower_case
- key: readability-identifier-naming.PrivateMemberSuffix
value: '_'
# Protected member variables
- key: readability-identifier-naming.ProtectedMemberCase
value: lower_case
- key: readability-identifier-naming.ProtectedMemberSuffix
value: '_'
# ---------------------------------------------------------------------------
# Enum declaration name case
- key: readability-identifier-naming.EnumCase
value: CamelCase
# Enum value declarations (the stuff inside the enum)
- key: readability-identifier-naming.EnumConstantCase
value: CamelCase
- key: readability-identifier-naming.EnumConstantPrefix
value: 'k'
# ---------------------------------------------------------------------------
# Templates
- key: readability-identifier-naming.TemplateParameterCase
value: CamelCase
# - key: readability-identifier-naming.TemplateTemplateParameterCase
# value: CamelCase
# - key: readability-identifier-naming.TypeTemplateParameterCase
# value: CamelCase
# - key: readability-identifier-naming.ValueTemplateParameterCase
# value: CamelCase
# ---------------------------------------------------------------------------
# General and global
# constexpr variable assignments
- key: readability-identifier-naming.ConstexprVariableCase
value: CamelCase
- key: readability-identifier-naming.ConstexprVariablePrefix
value: 'k'
# Namespaces
- key: readability-identifier-naming.NamespaceCase
value: lower_case
# General function parameter names
- key: readability-identifier-naming.ParameterCase
value: lower_case
# Union names
- key: readability-identifier-naming.UnionCase
value: CamelCase
# General variable declarations
- key: readability-identifier-naming.VariableCase
value: lower_case
# Typedef names
- key: readability-identifier-naming.TypedefCase
value: CamelCase
# Names for type aliases: using Name = OtherThing;
# Includes aliases declared in classes.
- key: readability-identifier-naming.TypeAliasCase
value: CamelCase
# Free function case
- key: readability-identifier-naming.FunctionCase
value: camelBack
# Global/free constant variable case. Includes anynomous namespaces.
- key: readability-identifier-naming.GlobalConstantCase
value: CamelCase
- key: readability-identifier-naming.GlobalConstantPrefix
value: 'k'
# Variables in the global scope.
- key: readability-identifier-naming.GlobalVariableCase
value: lower_case
- key: readability-identifier-naming.GlobalVariablePrefix
value: 'g_'
# Constants declared within local function scopes. Same as normal variables.
- key: readability-identifier-naming.LocalConstantCase
value: lower_case
- key: readability-identifier-naming.LocalConstantPrefix
value: ''
# Local variable
- key: readability-identifier-naming.LocalVariableCase
value: lower_case
# Magic number ignore list
- key: readability-magic-numbers.IgnoredIntegerValues
value: 0;1;2;3;4;5;6;7;8;9;10;100;1000;16;32;64;128;255;512;1024;2048;4096;8192;16384;32768;32768
- key: readability-magic-numbers.IgnorePowersOf2IntegerValues
value: true
- key: readability-magic-numbers.IgnoredFloatingPointValues
value: 0.25;0.5;0.75;1.0;2.0;3.0;10.0;100.0;1000.0;0.1;0.001;0.0001;;-1.0;-2.0;-3.0;
...
================================================
FILE: .gitignore
================================================
.vscode/
.vs/
build*/
# Visual Studio output directory for CMake projects.
out/
vcpkg_installed/
================================================
FILE: 3rdparty/3es-core/3esservermacros.h
================================================
// 3rd Eye Scene macros
// This file disables all 3rd Eye Scene macros. To be used when the library is not available.
#ifndef _3ESSERVERMACROS_H
#define _3ESSERVERMACROS_H
namespace tes
{
inline void noopohm() {}
} // namespace tes
#define TES_STMT(statement) tes::noopohm()
#define TES_IF(condition) if (false)
#define TES_RGB(r, g, b) tes::noopohm()
#define TES_RGBA(r, g, b, a) tes::noopohm()
#define TES_COLOUR(name) tes::noopohm()
#define TES_COLOUR_I(index) tes::noopohm()
#define TES_COLOUR_A(name, a) tes::noopohm()
#define TES_BUFFER(...) tes::noopohm()
#define TES_CATEGORY(server, ...) tes::noopohm()
#define TES_SERVER_DECL(server) tes::noopohm()
#define TES_SETTINGS(server, ...) tes::noopohm()
#define TES_SERVER_INFO(server, ...) tes::noopohm()
#define TES_SERVER_INFO_TIME(server, ...) tes::noopohm()
#define TES_SERVER_CREATE(server, ...) tes::noopohm()
#define TES_SERVER_START(server, ...) tes::noopohm()
#define TES_SERVER_START_WAIT(server, ...) tes::noopohm()
#define TES_SET_CONNECTION_CALLBACK(...) tes::noopohm()
#define TES_SERVER_UPDATE(server, ...) tes::noopohm()
#define TES_SERVER_STOP(server) tes::noopohm()
#define TES_LOCAL_FILE_STREAM(server, ...) tes::noopohm()
#define TES_ACTIVE(server) false
#define TES_SET_ACTIVE(server, ...) tes::noopohm()
#define TES_FEATURE(feature) false
#define TES_FEATURE_FLAG(feature) 0
#define TES_FEATURES(featureFlags) tes::noopohm()
#define TES_IF_FEATURES(featureFlags, ...) tes::noopohm()
#define TES_REFERENCE_RESOURCE(server, ...) tes::noopohm()
#define TES_RELEASE_RESOURCE(server, ...) tes::noopohm()
#define TES_MESH_PLACEHOLDER(id) tes::noopohm()
#define TES_ARROW(server, ...) tes::noopohm()
#define TES_ARROW_T(server, ...) tes::noopohm()
#define TES_ARROW_W(server, ...) tes::noopohm()
#define TES_BOX_AABB(server, ...) tes::noopohm()
#define TES_BOX_AABB_T(server, ...) tes::noopohm()
#define TES_BOX_AABB_W(server, ...) tes::noopohm()
#define TES_BOX(server, ...) tes::noopohm()
#define TES_BOX_T(server, ...) tes::noopohm()
#define TES_BOX_W(server, ...) tes::noopohm()
#define TES_CAPSULE(server, ...) tes::noopohm()
#define TES_CAPSULE_T(server, ...) tes::noopohm()
#define TES_CAPSULE_W(server, ...) tes::noopohm()
#define TES_CONE(server, ...) tes::noopohm()
#define TES_CONE_T(server, ...) tes::noopohm()
#define TES_CONE_W(server, ...) tes::noopohm()
#define TES_CYLINDER(server, ...) tes::noopohm()
#define TES_CYLINDER_T(server, ...) tes::noopohm()
#define TES_CYLINDER_W(server, ...) tes::noopohm()
#define TES_LINES(server, ...) tes::noopohm()
#define TES_LINES_E(server, ...) tes::noopohm()
#define TES_LINE(server, ...) tes::noopohm()
#define TES_MESHSET(server, ...) tes::noopohm()
#define TES_PLANE(server, ...) tes::noopohm()
#define TES_PLANE_T(server, ...) tes::noopohm()
#define TES_PLANE_W(server, ...) tes::noopohm()
#define TES_POINTCLOUDSHAPE(server, ...) tes::noopohm()
#define TES_POINTS(server, ...) tes::noopohm()
#define TES_POINTS_C(server, ...) tes::noopohm()
#define TES_POINTS_E(server, ...) tes::noopohm()
#define TES_POSE(server, ...) tes::noopohm()
#define TES_POSE_T(server, ...) tes::noopohm()
#define TES_POSE_W(server, ...) tes::noopohm()
#define TES_SPHERE(server, ...) tes::noopohm()
#define TES_SPHERE_T(server, ...) tes::noopohm()
#define TES_SPHERE_W(server, ...) tes::noopohm()
#define TES_STAR(server, ...) tes::noopohm()
#define TES_STAR_T(server, ...) tes::noopohm()
#define TES_STAR_W(server, ...) tes::noopohm()
#define TES_TEXT2D_SCREEN(server, ...) tes::noopohm()
#define TES_TEXT2D_WORLD(server, ...) tes::noopohm()
#define TES_TEXT3D(server, ...) tes::noopohm()
#define TES_TEXT3D_FACING(server, ...) tes::noopohm()
#define TES_TRIANGLES(server, ...) tes::noopohm()
#define TES_TRIANGLES_E(server, ...) tes::noopohm()
#define TES_TRIANGLES_N(server, ...) tes::noopohm()
#define TES_TRIANGLES_NE(server, ...) tes::noopohm()
#define TES_TRIANGLES_W(server, ...) tes::noopohm()
#define TES_TRIANGLES_WE(server, ...) tes::noopohm()
#define TES_TRIANGLES_T(server, ...) tes::noopohm()
#define TES_TRIANGLES_TE(server, ...) tes::noopohm()
#define TES_TRIANGLE(server, ...) tes::noopohm()
#define TES_TRIANGLE_W(server, ...) tes::noopohm()
#define TES_TRIANGLE_T(server, ...) tes::noopohm()
#define TES_VOXELS(server, ...) tes::noopohm()
#define TES_ARROW_END(server, ...) tes::noopohm()
#define TES_BOX_END(server, ...) tes::noopohm()
#define TES_CAPSULE_END(server, ...) tes::noopohm()
#define TES_CONE_END(server, ...) tes::noopohm()
#define TES_CYLINDER_END(server, ...) tes::noopohm()
#define TES_LINES_END(server, ...) tes::noopohm()
#define TES_MESHSET_END(server, ...) tes::noopohm()
#define TES_PLANE_END(server, ...) tes::noopohm()
#define TES_POINTCLOUDSHAPE_END(server, ...) tes::noopohm()
#define TES_POINTS_END(server, ...) tes::noopohm()
#define TES_POSE_END(server, ...) tes::noopohm()
#define TES_VOXELS_END(server, ...) tes::noopohm()
#define TES_SPHERE_END(server, ...) tes::noopohm()
#define TES_STAR_END(server, ...) tes::noopohm()
#define TES_TEXT2D_END(server, ...) tes::noopohm()
#define TES_TEXT3D_END(server, ...) tes::noopohm()
#define TES_TRIANGLES_END(server, ...) tes::noopohm()
#define TES_TRIANGLE_END(server, ...) tes::noopohm()
#define TES_VOXELS_END(server, ...) tes::noopohm()
#define TES_POS_UPDATE(server, ...) tes::noopohm()
#define TES_ROT_UPDATE(server, ...) tes::noopohm()
#define TES_SCALE_UPDATE(server, ...) tes::noopohm()
#define TES_COLOUR_UPDATE(server, ...) tes::noopohm()
#define TES_COLOR_UPDATE(server, ...) tes::noopohm()
#define TES_POSROT_UPDATE(server, ...) tes::noopohm()
#define TES_POSSCALE_UPDATE(server, ...) tes::noopohm()
#define TES_ROTSCALE_UPDATE(server, ...) tes::noopohm()
#define TES_PRS_UPDATE(server, ...) tes::noopohm()
#define TES_PRC_UPDATE(server, ...) tes::noopohm()
#define TES_PSC_UPDATE(server, ...) tes::noopohm()
#define TES_RSC_UPDATE(server, ...) tes::noopohm()
#define TES_PRSC_UPDATE(server, ...) tes::noopohm()
#endif // _3ESSERVERMACROS_H
================================================
FILE: CMakeLists.txt
================================================
cmake_minimum_required(VERSION 3.10)
project(ohm)
# Set CMAKE_CXX_STANDARD to the minimum if not externally set - e.g., from command line.
# We'll set it in such a way that it remains it the Cache and stays set.
if(NOT CMAKE_CXX_STANDARD)
set(CMAKE_CXX_STANDARD 14 CACHE INTERNAL "C++ standard")
endif(NOT CMAKE_CXX_STANDARD)
set(CMAKE_CXX_STANDARD_REQUIRED TRUE)
# Ensure -fPIC is added.
set(CMAKE_POSITION_INDEPENDENT_CODE ON)
set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
# Read version from package.xml
file(READ package.xml ohm_VERSION)
string(REGEX MATCH "\\<version\\>(.*)\\</version\\>" ohm_VERSION ${ohm_VERSION})
string(REGEX REPLACE "\\<version\\>(.*)\\</version\\>" "\\1" ohm_VERSION ${ohm_VERSION})
list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}/cmake")
include(utils)
# Work out if we are using VCPKG.
set(OHM_VCPKG FALSE)
if(CMAKE_TOOLCHAIN_FILE MATCHES ".*vcpkg\.cmake;?.*")
set(OHM_VCPKG TRUE)
endif(CMAKE_TOOLCHAIN_FILE MATCHES ".*vcpkg\.cmake;?.*")
# Setup core ohm build options.
# Default to building shared libs.
set(OHM_BUILD_SHARED_DEFAULT OFF)
if(DEFINED BUILD_SHARED_LIBS)
# But use BUILD_SHARED_LIBS as the default if it's specified (like from the command line).
set(OHM_BUILD_SHARED_DEFAULT ${BUILD_SHARED_LIBS})
endif(DEFINED BUILD_SHARED_LIBS)
option(OHM_BUILD_SHARED "Build shared ohm libraries?" ${OHM_BUILD_SHARED_DEFAULT})
# For details on OHM_BUILD_SHARED_SUPPRESS_WARNINGS, see usage in compilerSetup.cmake
option(OHM_BUILD_SHARED_SUPPRESS_WARNINGS
"Suppress warnings relating the DLL export symbols when building shared? Disables MSC warnings C4251 and C4275" ON)
option(OHM_PROFILE "Enable timing information messages for some queries." Off)
option(OHM_TES_DEBUG "Enable visual debugging code?" Off)
option(OHM_VALIDATION "Enable various validation tests in the occupancy map code. Has some performance impact." Off)
# OHM_FEATURE_CUDA is found in OhmCuda.cmake
option(OHM_LEAK_TRACK "Enable memory leak tracking?" OFF)
# Build options; what extensions are we going to build. These options are authoritative and flow down from here.
# For CUDA and OpenCL, we only need one, and we prefer CUDA based on what we find. However, vcpkg can guarantee we'll
# find one, so it because a dependent option.
option(OHM_BUILD_DOXYGEN "Build doxygen documentation?" Off)
ohm_feature(EIGEN "Use Eigen for more significant linear algebra algorithms (e.g., eigen decomposition)?" FIND Eigen3)
ohm_feature(HEIGHTMAP "Build heightmap library?")
ohm_feature(HEIGHTMAP_IMAGE "Build heightmap image conversion?" FIND OpenGL GLEW glfw3)
ohm_feature(PDAL "Build with PDAL reader support?" FIND pdal)
ohm_feature(THREADS "Enable CPU threading (using Thread Building Blocks)?" FIND tbb)
ohm_feature(TEST "Build unit tests?" FIND GTest)
# include CUDA config here to prime OHM_FEATURE_CUDA as we prefer CUDA over OpenCL.
# OHM_FEATURE_CUDA is in OhmCuda.cmake
include(OhmCuda)
set(OHM_FEATURE_OPENCL_DEFAULT ON)
if(OHM_FEATURE_CUDA)
set(OHM_FEATURE_OPENCL_DEFAULT OFF)
endif(OHM_FEATURE_CUDA)
ohm_feature(OPENCL "Build with OpenCL support?" FIND OpenCL DEFAULT OHM_FEATURE_OPENCL_DEFAULT)
# # Windows vcpkg does not provide CUDA.
# add_vcpkg_feature_if("cuda" "OHM_CUDA AND NOT WIN32")
# Migrate ohm specific setting for building shared libraries to the CMake global option.
set(BUILD_SHARED_LIBS ${OHM_BUILD_SHARED})
if(BUILD_SHARED_LIBS)
message(STATUS "Building shared ohm libraries.")
endif(BUILD_SHARED_LIBS)
# Setup clang-tidy
include(ClangTidy)
# Allow the use of folders to group targets in supporting environments.
# For example Visual Studio solution folders.
set_property(GLOBAL PROPERTY USE_FOLDERS ON)
set(CMAKE_DEBUG_POSTFIX _d)
set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/lib")
set(CMAKE_LIBRARY_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin")
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin")
foreach(CONF Debug;Release;MinSizeRel;RelWithDebInfo)
string(TOUPPER ${CONF} CONFU)
set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY_${CONFU} "${CMAKE_BINARY_DIR}/lib")
set(CMAKE_LIBRARY_OUTPUT_DIRECTORY_${CONFU} "${CMAKE_BINARY_DIR}/bin")
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_${CONFU} "${CMAKE_BINARY_DIR}/bin")
endforeach(CONF)
# Add memory leak tracking support.
include(LeakTrack)
# Configure installation prefixes.
# set(OHM_PREFIX_PACKAGE lib/cmake/${CMAKE_PROJECT_NAME})
set(OHM_PREFIX_PACKAGE share/${CMAKE_PROJECT_NAME}/cmake) # For catkin interoperation
# Prefix for include directories.
set(OHM_PREFIX_INCLUDE include/ohm)
# General, required library
# We use our own FindGLM to cater for differences between Ubuntu 18.04 and 20.04.
# From 20.04 on, we can just just find_config(glm CONFIG REQUIRED)
find_package(glm MODULE REQUIRED)
if(OHM_FEATURE_OPENCL)
find_package(OpenCL)
endif(OHM_FEATURE_OPENCL)
if(OpenCL_FOUND)
option(OHM_EMBED_GPU_CODE "Embed GPU code into the executable (OpenCL)? Otherwise GPU code files are loaded from disk (better for development)." ON)
set(OHM_OPENCL_SDK_VER 1.2 CACHE STRING "Select the OpenCL runtime API to use.")
set_property(CACHE OHM_OPENCL_SDK_VER PROPERTY STRINGS 1.2 2.0 2.1 2.2 3.0)
set(OHM_OPENCL_STD 2.0 CACHE STRING "Select the default OpenCL standard to compile GPU code against. Also runtime configurable. [max] uses the reported device allowing for 2.x requires features.")
set_property(CACHE OHM_OPENCL_STD PROPERTY STRINGS 1.2 2.0 3.0 max)
endif(OpenCL_FOUND)
# Identify any extensions required to compile with OpenCL 2.0 std.
set(OHM_OPENCL_2_FEATURES "" CACHE STRING "Features required for OpenCL 2.x. Fallback to 1.2 otherwise.")
# Look for CUDA to setup CUDA build options and work out which CMake CUDA paradigm we'll use.
if(OHM_FEATURE_CUDA)
if(NOT OHM_USE_DEPRECATED_CMAKE_CUDA)
find_package(CUDAToolkit REQUIRED)
else(NOT OHM_USE_DEPRECATED_CMAKE_CUDA)
# Need to find CUDA for deprecated project configuration
find_package(CUDA REQUIRED)
endif(NOT OHM_USE_DEPRECATED_CMAKE_CUDA)
endif(OHM_FEATURE_CUDA)
if(OHM_FEATURE_EIGEN)
find_package(Eigen3 CONFIG REQUIRED)
endif(OHM_FEATURE_EIGEN)
# Manage compiler warnings.
# Use CMAKE_MODULE_PATH and include(warnings) if warnings.cmake is moved.
include(compilerSetup)
# Now setup CUDA after knowing if we are building shared libraries or not.
cuda_setup()
# Setup default memory leak tracking suppressions and options (GCC/Clang AddressSanitizer).
set(OHM_LEAK_SUPPRESS_OCL_INIT
# OpenCL memory allocation overrides
"__interceptor_malloc"
"__interceptor_calloc"
# Intel OpenCL leaks
"libigdrcl"
"llvm::FPPassManager::runOnFunction"
"llvm::SmallVectorBase"
"libigc"
"basic_string<char, std::char_traits<char>, std::allocator<char> >::_M_mutate"
)
set(OHM_LEAK_SUPPRESS_TBB_INIT
"libtbb"
)
set(OHM_LEAK_SUPPRESS_CUDA_INIT
)
set(OHM_ASAN_OPTIONS_CUDA_INIT "protect_shadow_gap=0")
set(OHM_LEAK_SUPPRESS_OCL "${OHM_LEAK_SUPPRESS_OCL_INIT}" CACHE STRING "Memory leak suppression list for OpenCL")
set(OHM_LEAK_SUPPRESS_TBB "${OHM_LEAK_SUPPRESS_TBB_INIT}" CACHE STRING "Memory leak suppression list for Intel Threading Building Blocks")
set(OHM_LEAK_SUPPRESS_CUDA "${OHM_LEAK_SUPPRESS_CUDA_INIT}" CACHE STRING "Memory leak suppression list for CUDA")
set(OHM_ASAN_OPTIONS_CUDA "${OHM_ASAN_OPTIONS_CUDA_INIT}" CACHE STRING "Address Sanitizer options for CUDA")
# Configure OHM_GPU as a value for configure_file
set(OHM_GPU_OPENCL 1)
set(OHM_GPU_CUDA 2)
set(OHM_GPU 0)
# Configure use of 3rd-Eye-Scene visual debugging (use for development only)
if(OHM_TES_DEBUG)
find_package(3es)
else(OHM_TES_DEBUG)
# Include path to 3esservermarcos.h which effectively disables all 3es macros.
set(3ES_INCLUDE_DIRS "${CMAKE_CURRENT_LIST_DIR}/3rdparty/3es-core")
endif(OHM_TES_DEBUG)
add_subdirectory(logutil)
if(OHM_FEATURE_OPENCL)
add_subdirectory(clu)
endif(OHM_FEATURE_OPENCL)
if(OHM_FEATURE_CUDA OR OHM_FEATURE_OPENCL)
add_subdirectory(gputil)
endif(OHM_FEATURE_CUDA OR OHM_FEATURE_OPENCL)
add_subdirectory(ohmutil)
add_subdirectory(slamio)
add_subdirectory(ohm)
if(OHM_FEATURE_CUDA OR OHM_FEATURE_OPENCL)
add_subdirectory(ohmgpu)
endif(OHM_FEATURE_CUDA OR OHM_FEATURE_OPENCL)
if(OHM_FEATURE_HEIGHTMAP)
add_subdirectory(ohmheightmap)
endif(OHM_FEATURE_HEIGHTMAP)
if(OHM_FEATURE_HEIGHTMAP_IMAGE)
# Experimental
add_subdirectory(ohmheightmapimage)
endif(OHM_FEATURE_HEIGHTMAP_IMAGE)
add_subdirectory(ohmtools)
add_subdirectory(ohmapp)
add_subdirectory(utils)
if(OHM_FEATURE_TEST)
enable_testing()
add_subdirectory(tests)
endif(OHM_FEATURE_TEST)
clang_tidy_global()
export(EXPORT ${CMAKE_PROJECT_NAME}-config-targets
FILE "${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_PROJECT_NAME}-config-targets.cmake"
NAMESPACE ohm::
)
install(EXPORT ${CMAKE_PROJECT_NAME}-config-targets
FILE ${CMAKE_PROJECT_NAME}-config-targets.cmake
NAMESPACE ohm::
DESTINATION ${OHM_PREFIX_PACKAGE}
)
# Setup import scripts.
include(CMakePackageConfigHelpers)
write_basic_package_version_file(
"${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_PROJECT_NAME}-version.cmake"
VERSION ${ohm_VERSION}
COMPATIBILITY AnyNewerVersion
)
# Installation of the package configuration file.
configure_file(cmake/${CMAKE_PROJECT_NAME}-packages.cmake "${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_PROJECT_NAME}-packages.cmake")
configure_file(cmake/${CMAKE_PROJECT_NAME}-config.cmake "${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_PROJECT_NAME}-config.cmake" @ONLY)
install(FILES
"${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_PROJECT_NAME}-config.cmake"
"${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_PROJECT_NAME}-packages.cmake"
"${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_PROJECT_NAME}-version.cmake"
DESTINATION ${OHM_PREFIX_PACKAGE}
COMPONENT Devel)
# Install MSVC runtime libraries. This will also affect the CPack installation.
include(InstallRequiredSystemLibraries)
# Doxygen setup.
if(OHM_BUILD_DOXYGEN)
# Include Doxygen helper functions. This also finds the Doxygen package.
include(doxygen)
set(DOXYGEN_DIRS
gputil
ohm
ohmtools
ohmutil
slamio
)
set(DOXYGE_EXCLUDE_DIRS
clu/3rdparty
gputil/cl
gputil/cuda
ohm/cl
ohm/gpu
ohm/private
ohmgpu/private
ohmutil/3rdparty
slamio/miniply
slamio/pdal
)
if(OHM_FEATURE_CUDA OR OHM_FEATURE_OPENCL)
list(APPEND DOXYGEN_DIRS ohmgpu)
endif(OHM_FEATURE_CUDA OR OHM_FEATURE_OPENCL)
if(OHM_FEATURE_OPENCL)
list(APPEND DOXYGEN_DIRS clu)
endif(OHM_FEATURE_OPENCL)
list(APPEND DOXYGEN_DIRS docs)
if(DOXYGEN_FOUND)
# Create a target to build the documentation.
# Here we also setup various documentation variables passed through to the doxyfile configuration.
# Each named argument below describes the Doxygen variable it sets.
doxygen_create(
# DOXYFILE cmake/doxyfile.in # Doxyfile to configure.
PROJECT ${CMAKE_PROJECT_NAME} # PROJECT_NAME
VERSION ${ohm_VERSION} # PROJECT_NUMBER
OUTPUT_DIR html # HTML_OUPTUT
# CSS <style>.css # HTML_STYLESHEET
PUBLISHER "CSIRO" # DOCSET_PUBLISHER_NAME
PUBLISHER_ID au.csiro # DOCSET_PUBLISHER_ID
PROJECT_ID au.csiro.ohm # DOCSET_BUNDLE_ID, QHP_NAMESPACE, ECLIPSE_DOC_ID
PATHS # INPUT (RECURSIVE is on)
${DOXYGEN_DIRS}
EXCLUDE_PATHS # EXCLUDE
${DOXYGE_EXCLUDE_DIRS}
# Where to find source code examples.
# EXAMPLE_PATHS <paths> # EXAMPLE_PATH
# Where to find images.
# IMAGE_PATHS <paths> # IMAGE_PATH
)
# Setup installation of the generated documentation: source, destination.
doxygen_install(${CMAKE_CURRENT_BINARY_DIR}/html ohm)
endif(DOXYGEN_FOUND)
endif(OHM_BUILD_DOXYGEN)
================================================
FILE: LICENSE
================================================
The Software is copyright (c) Commonwealth Scientific and Industrial Research Organisation (CSIRO)
ABN 41 687 119 230.
CSIRO grants you a licence to the Software on the terms of the BSD 3-Clause Licence.
Redistribution and use in source and binary forms, with or without modification, are permitted
provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice, this list of conditions
and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions
and the following disclaimer in the documentation and/or other materials provided with the
distribution.
3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse
or promote products derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR
IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
___________________________________________________________________
ZLib https://www.zlib.net/
his software is licensed under ZLib license
https://www.zlib.net/zlib_license.html
___________________________________________________________________
___________________________________________________________________
Miniply https://github.com/vilya/miniply
This software is licensed under MIT License.
___________________________________________________________________
___________________________________________________________________
Point Data Abstraction Library (PDAL) https://pdal.io/
This software is licensed under BSD Licence
___________________________________________________________________
___________________________________________________________________
OpenGL Mathematics https://glm.g-truc.net/
This software is licensed under the Happy Bunny License (Modified MIT).
___________________________________________________________________
___________________________________________________________________
Intel Threading Building Blocks https://www.threadingbuildingblocks.org/
This software is licensed under the Apache 2.0 license.
___________________________________________________________________
___________________________________________________________________
Google Test https://github.com/google/googletest
This software is licensed under the New BSD License.
___________________________________________________________________
___________________________________________________________________
CMake https://cmake.org/
This software is licensed under the BSD 3-Clause license.
___________________________________________________________________
___________________________________________________________________
cxxopts https://github.com/jarro2783/cxxopts
This software is licensed under the cxxopts licence
https://github.com/jarro2783/cxxopts/blob/master/LICENSE
___________________________________________________________________
___________________________________________________________________
Third Eye Scene
This software is licensed under a modified MIT license:
https://github.com/data61/3rdEyeScene/blob/master/license.txt
___________________________________________________________________
___________________________________________________________________
delaunator https://github.com/delfrrr/delaunator-cpp
This software is licensed under the MIT licence
https://github.com/delfrrr/delaunator-cpp/blob/master/LICENSE
___________________________________________________________________
___________________________________________________________________
libpng http://www.libpng.org/
This software is licensed under the PNG Reference Library License version
___________________________________________________________________
___________________________________________________________________
OpenGL Extension Wrangler (GLEW) Library http://glew.sourceforge.net/
This software is licensed under The OpenGL Extension Wrangler Library license
___________________________________________________________________
___________________________________________________________________
GLFW Library https://www.glfw.org/
This software is licensed under the zlib/libpng license
___________________________________________________________________
___________________________________________________________________
SKA fast hash https://github.com/skarupke/flat_hash_map
This software is licensed under the Boost Software License, Version 1.0.
___________________________________________________________________
___________________________________________________________________
SKA fast sort https://github.com/skarupke/ska_sort
This software is licensed under the Boost Software License, Version 1.0.
___________________________________________________________________
___________________________________________________________________
RPly https://github.com/lkiesow/librply
This software is license under the RPly license
___________________________________________________________________
================================================
FILE: OpenCL.md
================================================
# OpenCL Usage
OpenCL is one of the two GPU library options required for the Occupancy map (ohm). Most development has occurred on top of the Intel OpenCL implementation, but the NVIDIA implementation also works. These instructions focus on installation requirements for Intel OpenCL. For the NVIDIA support, download and install the [CUDA development kit](https://developer.nvidia.com/cuda-zone).
Both runtime drivers and an SDK need to be installed in order to get it running. Getting Intel drivers running can be an issue so the following instructions are maintained to help the installation process. The following process is focused entirely on Ubuntu 18.04.
## Windows SDK and Drvier Installation
The [Intel OpenCL SDK](https://software.intel.com/en-us/intel-opencl) is recommended for Windows development. Follow the installation instructions in the link.
Note that there are some pathing issues which may cause issues under Windows, especially when the CUDA SDK is also installed. It is recommended that the PATH environment variable is set up to find the Intel OpenCL DLLs and executables before the NVIDIA implementation is located.
OpenCL runtime drivers are installed as part of the video card driver package.
## Linux SDK Installation
The Intel OpenCL SDK is also available for Linux, however, for most Debian installations it is enough to install the appropriate apt packages provided the correct device drivers are installed.
```
sudo apt-get install opencl-headers ocl-icd-dev ocl-icd-libopencl1 ocl-icd-opencl-dev
```
### Installing Intel OpenCL Drivers
Extensive Intel CPU/GPU testing has not been made, but the following information may help address some OpenCL standard compatibility issues. The OpenCL standard defines the GPU code compilation, not the SDK version. This can be set on OHM_OPENCL_STD.
| Intel CPU Generation | Recommended OpenCL Standard |
| -------------------- | --------------------------- |
| < 6th Generation | Unknown |
| 6th Generation | 1.2 |
| 7th Generation | 2.0 |
| 8th Generation | 2.0 |
| 9th Generation | 2.0 |
There are three different drivers which may be relevant to the installation process.
1. Intel Linux drivers:
- Direct link: https://github.com/intel/compute-runtime/releases
- General information https://software.intel.com/en-us/articles/opencl-drivers
2. beignet: apt package for Intel NEO drivers.
3. Intel Legacy Linux drivers: https://software.intel.com/en-us/articles/legacy-opencl-drivers#latest_linux_SDK_release
For general installation:
- Determine your CPU generation:
- `grep -m 1 name /proc/cpuinfo`
- Results should look something like: `Intel(R) Core(TM) i7-6700 CPU @ 3.40GHz` The first digit of the CPU number - in this case 6700 - indicates the generation '6'.
- Install the most appropriate driver (see below) based on your CPU generation.
- For 6th generation use the legacy drivers (option 3).
- For 7th+ generation use the current Intel Drives (option 1).
- Install `clinfo` apt package to confirm successful installation
- `sudo apt-get install clinfo`
- Verify installation:
- `clinfo | grep "Device Name"`
If installation is successful you should see a results like the following:
```
Device Name GeForce GT 640
Device Name Intel(R) HD Graphics
Device Name Intel(R) Core(TM) i7-6700 CPU @ 3.40GHz
```
Not that this example is also listing a CUDA device.
#### Intel Linux Driver
This installs the current Intel OpenCL drivers for 7th, 8th and 9th generation CPU. These are the perferred drivers as they are continually updated by Intel. Drivers may be downloaded from https://github.com/intel/compute-runtime/releases with accompanying installation instructions.
These drivers are incompatible with beignet.
#### Beignet
In 18.04 these are drivers for the NEO architecture used in 7th, 8th and 9th generation core processors. Run the following command to install the Beignet drivers:
```
sudo apt-get install beignet-dev
```
Verify the installation (above).
If this fails, you will need to `apt-get purge <package>` the following apt-packages before continuing:
- beignet
- beignet-dev
- beignet-opencl-icd
#### Intel Legacy Linux Driver
Legacy drivers are appropriate only for 6th (and 5th) generation intel chips. These are downloaded from https://software.intel.com/en-us/articles/legacy-opencl-drivers#latest_linux_SDK_release and the installation process is described at http://registrationcenter-download.intel.com/akdlm/irc_nas/11396/SRB5.0_intel-opencl-installation.pdf
These drivers are incompatible with beignet.
## NVidia OpenCL Compatibility
NVidia OpenCL requires installation of official NVidia drivers for your video card. Discussion of how to do so is beyond the scope of this document. Use `clinfo | grep "Device Name"` to determine whether NVidia drivers are correctly installed. You should see an NVidia related device name such as "GeForce XXX".
In order to build ohm to run on NVidia, the library must be build for OpenCL 1.2 (host API) and OpenCL 1.2 runtime (device standard). To do so, configure the following CMake variables to "1.2" using `ccmake`, `cmake-gui`, or editing the `CMakeCache.txt` file directly.
- `OHM_OPENCL_STD` : 1.2 (OpenCL runtime compilation)
- `OHM_OPENCL_SDK_VER` : 1.2 (OpenCL SDK selection)
Note that NVidia performance will generally be worse than Intel OpenCL because of the way ohm uses global memory.
================================================
FILE: clearance-performance-notes.md
================================================
# Performance Notes on Calculating Voxel Clearance Values
Here we note the techniques explored to general voxel clearance values on GPU and the associated performance impacts. The end goal has been to maximise performance whilst maintaining reasonable accuracy. A voxel's clearance value is the distance to its nearest occupied neighbour (or unknown neighbour depending on flags) within the specified search range.
## Techniques
Three primary techniques have been evaluated:
- Neighbour propagation
- Open list flood fill
- ROI propagation (Region of Interest propagation)
### Neighbour Propagation
This was the first technique and is essentially an iterative flood fill technique with no voxel contention. The region of interest (ROI) is defined as the map chunk/region we wish to generate clearance values for. This is padded by an appropriate number of voxels to reach the desired search range and the padded extents define the GPU working dimensions. Two buffers of voxels sized to the padded region are maintained and alternated to ensure new data do not overwrite old. The algorithm then proceeds:
1. Seed the first buffer with each voxel writing its own 3D index within the working region and 0 if it's not an obstruction (is free) or 1 if it is an obstruction (occupied or unknown and unknown flagged as obstacles).
2. Propagate obstacles with each voxel inspecting its face neighbours and selecting the nearest obstruction. Keep current value if it is a closer obstruction.
3. Iterate an appropriate number of times to fill out to the search range.
1. Alternate read/write buffers each time.
4. Migrate results back to the CPU.
Pros:
- No contention
- Fixed iterations based on search range
- Fixed performance regardless of data content
Cons:
- Scalability: higher range searches make for higher GPU usage.
- High border overhead
### Open List Flood Fill
The next technique attempted. There an open list is generated from each obstructing voxel at processed at each iteration. This continued until the open list is empty. The ROI is padded just as in Neighbour Propagation and the padded region defines the working region on GPU.
1. Seed the working voxels similar to neighbour propagation, however the coordinates written are relative to the target voxel.
1. Only every writes (0, 0, 0, 0) or (0, 0, 0, 1)
2. Each obstruction pushes its face neighbours into an open list.
2. Process the open list, writing new obstructions to the open list voxels.
1. Expand the open list with neighbours currently tracking farther obstacles or currently clear and within the search range.
3. Iterate on the open list until empty (or hard capped).
Pros:
- Reduced memory usage: working memory uses char4 rather than int4.
- Must use 32-bit data type to support atomic CAS operations
- Lower GPU load: can fix number of workers
- Better scalability
- Less GPU thread overhead
Cons:
- CPU needed to determine whether another iteration is required and the number of workers.
- Higher number of GPU invocations, especially in worst case scenario
- Contention on writing to GPU nodes
- Limited search range because of char4 usage.
### ROI Propagation
A variant of Neighbour Propagation where we only have propagation iterations operate on the true ROI, not the padded region. This reduces the number of GPU threads to a fixed number and limits the maximum number of iterations required to cover the search range. Obstacles from outside the ROI, but within the search range have a separate seeding cycle which has memory contention, but greatly reduces the amount of work done. Uses alternating buffers just like Neighbour Propagation.
1. Seed the ROI (not padded) with each voxel writing *relative* coordinates to its nearest obstruction and flagging if it is an obstruction.
1. Only every writes (0, 0, 0, 0) or (0, 0, 0, 1)
2. Seed obstacles from outside the ROI into nearest border voxels of the ROI
1. Write to the nearest ROI border voxel and its face neighbour border voxels.
2. This part has contention.
3. Propagate obstructions by having each ROI voxel inspect its face neighbours (and itself) and choose the closest obstruction.
4. Iterate an appropriate number of times to fill out to the search range or cover ROI from end to end (whichever is smaller)
1. Alternate read/write buffers each time.
5. Migrate results back to the CPU.
Pros:
- Hybrid approach
- Far less work to do => best performance
- Reduced memory usage: working memory uses char4 rather than int4.
- Must use 32-bit data type to support atomic CAS operations
- Fixed maximum number of iterations
- Reduce cost of scaling search range
Cons:
- Contention during seeding.
- Limited search range because of char4 usage.
- Seeding effects a down sampling which risks data loss.
- This has been mitigated by seeding to ROI border neighbours as well as the closest ROI border voxel.
## Technique Evaluation
Evaluation using QCAT tower map data from 30-40s.
- Map resolution: 0.25
- Region size: (32, 32, 32) => (8m, 8m, 8m)
Technique | Range | Total Time | Average GPU Time/Region
--------------------- | ----- | ----------- | -----------------------
Neighbour propagation | 5m | 76.6s | 60.0ms
Neighbour propagation | 7.75m | 229.8s | 191.7ms
Open list | 5m | 72.7s | 60.7ms
Open list | 7.75m | 108.0s | 90.8ms
ROI propagation | 5m | 21.6s | 18ms
ROI propagation | 7.5m | 30s | 25ms
ROI propagation | 15.5m | 78.5s | 65.4ms
================================================
FILE: clu/3rdparty/CL/opencl.hpp
================================================
//
// Copyright (c) 2008-2020 The Khronos Group Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
/*! \file
*
* \brief C++ bindings for OpenCL 1.0, OpenCL 1.1, OpenCL 1.2,
* OpenCL 2.0, OpenCL 2.1, OpenCL 2.2, and OpenCL 3.0.
* \author Lee Howes and Bruce Merry
*
* Derived from the OpenCL 1.x C++ bindings written by
* Benedict R. Gaster, Laurent Morichetti and Lee Howes
* With additions and fixes from:
* Brian Cole, March 3rd 2010 and April 2012
* Matt Gruenke, April 2012.
* Bruce Merry, February 2013.
* Tom Deakin and Simon McIntosh-Smith, July 2013
* James Price, 2015-
* \version 2.2.0
* \date 2019-09-18
*
* Optional extension support
*
* cl_ext_device_fission
* #define CL_HPP_USE_CL_DEVICE_FISSION
* cl_khr_d3d10_sharing
* #define CL_HPP_USE_DX_INTEROP
* cl_khr_sub_groups
* #define CL_HPP_USE_CL_SUB_GROUPS_KHR
* cl_khr_image2d_from_buffer
* #define CL_HPP_USE_CL_IMAGE2D_FROM_BUFFER_KHR
*
* Doxygen documentation for this header is available here:
*
* http://khronosgroup.github.io/OpenCL-CLHPP/
*
* The latest version of this header can be found on the GitHub releases page:
*
* https://github.com/KhronosGroup/OpenCL-CLHPP/releases
*
* Bugs and patches can be submitted to the GitHub repository:
*
* https://github.com/KhronosGroup/OpenCL-CLHPP
*/
/*! \mainpage
* \section intro Introduction
* For many large applications C++ is the language of choice and so it seems
* reasonable to define C++ bindings for OpenCL.
*
* The interface is contained with a single C++ header file \em opencl.hpp and all
* definitions are contained within the namespace \em cl. There is no additional
* requirement to include \em cl.h and to use either the C++ or original C
* bindings; it is enough to simply include \em opencl.hpp.
*
* The bindings themselves are lightweight and correspond closely to the
* underlying C API. Using the C++ bindings introduces no additional execution
* overhead.
*
* There are numerous compatibility, portability and memory management
* fixes in the new header as well as additional OpenCL 2.0 features.
* As a result the header is not directly backward compatible and for this
* reason we release it as opencl.hpp rather than a new version of cl.hpp.
*
*
* \section compatibility Compatibility
* Due to the evolution of the underlying OpenCL API the 2.0 C++ bindings
* include an updated approach to defining supported feature versions
* and the range of valid underlying OpenCL runtime versions supported.
*
* The combination of preprocessor macros CL_HPP_TARGET_OPENCL_VERSION and
* CL_HPP_MINIMUM_OPENCL_VERSION control this range. These are three digit
* decimal values representing OpenCL runime versions. The default for
* the target is 200, representing OpenCL 2.0 and the minimum is also
* defined as 200. These settings would use 2.0 API calls only.
* If backward compatibility with a 1.2 runtime is required, the minimum
* version may be set to 120.
*
* Note that this is a compile-time setting, and so affects linking against
* a particular SDK version rather than the versioning of the loaded runtime.
*
* The earlier versions of the header included basic vector and string
* classes based loosely on STL versions. These were difficult to
* maintain and very rarely used. For the 2.0 header we now assume
* the presence of the standard library unless requested otherwise.
* We use std::array, std::vector, std::shared_ptr and std::string
* throughout to safely manage memory and reduce the chance of a
* recurrance of earlier memory management bugs.
*
* These classes are used through typedefs in the cl namespace:
* cl::array, cl::vector, cl::pointer and cl::string.
* In addition cl::allocate_pointer forwards to std::allocate_shared
* by default.
* In all cases these standard library classes can be replaced with
* custom interface-compatible versions using the CL_HPP_NO_STD_ARRAY,
* CL_HPP_NO_STD_VECTOR, CL_HPP_NO_STD_UNIQUE_PTR and
* CL_HPP_NO_STD_STRING macros.
*
* The OpenCL 1.x versions of the C++ bindings included a size_t wrapper
* class to interface with kernel enqueue. This caused unpleasant interactions
* with the standard size_t declaration and led to namespacing bugs.
* In the 2.0 version we have replaced this with a std::array-based interface.
* However, the old behaviour can be regained for backward compatibility
* using the CL_HPP_ENABLE_SIZE_T_COMPATIBILITY macro.
*
* Finally, the program construction interface used a clumsy vector-of-pairs
* design in the earlier versions. We have replaced that with a cleaner
* vector-of-vectors and vector-of-strings design. However, for backward
* compatibility old behaviour can be regained with the
* CL_HPP_ENABLE_PROGRAM_CONSTRUCTION_FROM_ARRAY_COMPATIBILITY macro.
*
* In OpenCL 2.0 OpenCL C is not entirely backward compatibility with
* earlier versions. As a result a flag must be passed to the OpenCL C
* compiled to request OpenCL 2.0 compilation of kernels with 1.2 as
* the default in the absence of the flag.
* In some cases the C++ bindings automatically compile code for ease.
* For those cases the compilation defaults to OpenCL C 2.0.
* If this is not wanted, the CL_HPP_CL_1_2_DEFAULT_BUILD macro may
* be specified to assume 1.2 compilation.
* If more fine-grained decisions on a per-kernel bases are required
* then explicit build operations that take the flag should be used.
*
*
* \section parameterization Parameters
* This header may be parameterized by a set of preprocessor macros.
*
* - CL_HPP_TARGET_OPENCL_VERSION
*
* Defines the target OpenCL runtime version to build the header
* against. Defaults to 200, representing OpenCL 2.0.
*
* - CL_HPP_NO_STD_STRING
*
* Do not use the standard library string class. cl::string is not
* defined and may be defined by the user before opencl.hpp is
* included.
*
* - CL_HPP_NO_STD_VECTOR
*
* Do not use the standard library vector class. cl::vector is not
* defined and may be defined by the user before opencl.hpp is
* included.
*
* - CL_HPP_NO_STD_ARRAY
*
* Do not use the standard library array class. cl::array is not
* defined and may be defined by the user before opencl.hpp is
* included.
*
* - CL_HPP_NO_STD_UNIQUE_PTR
*
* Do not use the standard library unique_ptr class. cl::pointer and
* the cl::allocate_pointer functions are not defined and may be
* defined by the user before opencl.hpp is included.
*
* - CL_HPP_ENABLE_EXCEPTIONS
*
* Enable exceptions for use in the C++ bindings header. This is the
* preferred error handling mechanism but is not required.
*
* - CL_HPP_ENABLE_SIZE_T_COMPATIBILITY
*
* Backward compatibility option to support cl.hpp-style size_t
* class. Replaces the updated std::array derived version and
* removal of size_t from the namespace. Note that in this case the
* new size_t class is placed in the cl::compatibility namespace and
* thus requires an additional using declaration for direct backward
* compatibility.
*
* - CL_HPP_ENABLE_PROGRAM_CONSTRUCTION_FROM_ARRAY_COMPATIBILITY
*
* Enable older vector of pairs interface for construction of
* programs.
*
* - CL_HPP_CL_1_2_DEFAULT_BUILD
*
* Default to OpenCL C 1.2 compilation rather than OpenCL C 2.0
* applies to use of cl::Program construction and other program
* build variants.
*
* - CL_HPP_USE_CL_DEVICE_FISSION
*
* Enable the cl_ext_device_fission extension.
*
* - CL_HPP_USE_CL_IMAGE2D_FROM_BUFFER_KHR
*
* Enable the cl_khr_image2d_from_buffer extension.
*
* - CL_HPP_USE_CL_SUB_GROUPS_KHR
*
* Enable the cl_khr_subgroups extension.
*
* - CL_HPP_USE_DX_INTEROP
*
* Enable the cl_khr_d3d10_sharing extension.
*
* - CL_HPP_USE_IL_KHR
*
* Enable the cl_khr_il_program extension.
*
*
* \section example Example
*
* The following example shows a general use case for the C++
* bindings, including support for the optional exception feature and
* also the supplied vector and string classes, see following sections for
* decriptions of these features.
*
* Note: the C++ bindings use std::call_once and therefore may need to be
* compiled using special command-line options (such as "-pthread") on some
* platforms!
*
* \code
#define CL_HPP_ENABLE_EXCEPTIONS
#define CL_HPP_TARGET_OPENCL_VERSION 200
#include <CL/opencl.hpp>
#include <algorithm>
#include <iostream>
#include <memory>
#include <vector>
const int numElements = 32;
int main(void)
{
// Filter for a 2.0 or newer platform and set it as the default
std::vector<cl::Platform> platforms;
cl::Platform::get(&platforms);
cl::Platform plat;
for (auto &p : platforms) {
std::string platver = p.getInfo<CL_PLATFORM_VERSION>();
if (platver.find("OpenCL 2.") != std::string::npos ||
platver.find("OpenCL 3.") != std::string::npos) {
// Note: an OpenCL 3.x platform may not support all required features!
plat = p;
}
}
if (plat() == 0) {
std::cout << "No OpenCL 2.0 or newer platform found.\n";
return -1;
}
cl::Platform newP = cl::Platform::setDefault(plat);
if (newP != plat) {
std::cout << "Error setting default platform.\n";
return -1;
}
// C++11 raw string literal for the first kernel
std::string kernel1{R"CLC(
global int globalA;
kernel void updateGlobal()
{
globalA = 75;
}
)CLC"};
// Raw string literal for the second kernel
std::string kernel2{R"CLC(
typedef struct { global int *bar; } Foo;
kernel void vectorAdd(global const Foo* aNum, global const int *inputA, global const int *inputB,
global int *output, int val, write_only pipe int outPipe, queue_t childQueue)
{
output[get_global_id(0)] = inputA[get_global_id(0)] + inputB[get_global_id(0)] + val + *(aNum->bar);
write_pipe(outPipe, &val);
queue_t default_queue = get_default_queue();
ndrange_t ndrange = ndrange_1D(get_global_size(0)/2, get_global_size(0)/2);
// Have a child kernel write into third quarter of output
enqueue_kernel(default_queue, CLK_ENQUEUE_FLAGS_WAIT_KERNEL, ndrange,
^{
output[get_global_size(0)*2 + get_global_id(0)] =
inputA[get_global_size(0)*2 + get_global_id(0)] + inputB[get_global_size(0)*2 + get_global_id(0)]
+ globalA;
});
// Have a child kernel write into last quarter of output
enqueue_kernel(childQueue, CLK_ENQUEUE_FLAGS_WAIT_KERNEL, ndrange,
^{
output[get_global_size(0)*3 + get_global_id(0)] =
inputA[get_global_size(0)*3 + get_global_id(0)] + inputB[get_global_size(0)*3 + get_global_id(0)]
+ globalA + 2;
});
}
)CLC"};
std::vector<std::string> programStrings;
programStrings.push_back(kernel1);
programStrings.push_back(kernel2);
cl::Program vectorAddProgram(programStrings);
try {
vectorAddProgram.build("-cl-std=CL2.0");
}
catch (...) {
// Print build info for all devices
cl_int buildErr = CL_SUCCESS;
auto buildInfo = vectorAddProgram.getBuildInfo<CL_PROGRAM_BUILD_LOG>(&buildErr);
for (auto &pair : buildInfo) {
std::cerr << pair.second << std::endl << std::endl;
}
return 1;
}
typedef struct { int *bar; } Foo;
// Get and run kernel that initializes the program-scope global
// A test for kernels that take no arguments
auto program2Kernel =
cl::KernelFunctor<>(vectorAddProgram, "updateGlobal");
program2Kernel(
cl::EnqueueArgs(
cl::NDRange(1)));
//////////////////
// SVM allocations
auto anSVMInt = cl::allocate_svm<int, cl::SVMTraitCoarse<>>();
*anSVMInt = 5;
cl::SVMAllocator<Foo, cl::SVMTraitCoarse<cl::SVMTraitReadOnly<>>> svmAllocReadOnly;
auto fooPointer = cl::allocate_pointer<Foo>(svmAllocReadOnly);
fooPointer->bar = anSVMInt.get();
cl::SVMAllocator<int, cl::SVMTraitCoarse<>> svmAlloc;
std::vector<int, cl::SVMAllocator<int, cl::SVMTraitCoarse<>>> inputA(numElements, 1, svmAlloc);
cl::coarse_svm_vector<int> inputB(numElements, 2, svmAlloc);
//////////////
// Traditional cl_mem allocations
std::vector<int> output(numElements, 0xdeadbeef);
cl::Buffer outputBuffer(begin(output), end(output), false);
cl::Pipe aPipe(sizeof(cl_int), numElements / 2);
// Default command queue, also passed in as a parameter
cl::DeviceCommandQueue defaultDeviceQueue = cl::DeviceCommandQueue::makeDefault(
cl::Context::getDefault(), cl::Device::getDefault());
auto vectorAddKernel =
cl::KernelFunctor<
decltype(fooPointer)&,
int*,
cl::coarse_svm_vector<int>&,
cl::Buffer,
int,
cl::Pipe&,
cl::DeviceCommandQueue
>(vectorAddProgram, "vectorAdd");
// Ensure that the additional SVM pointer is available to the kernel
// This one was not passed as a parameter
vectorAddKernel.setSVMPointers(anSVMInt);
cl_int error;
vectorAddKernel(
cl::EnqueueArgs(
cl::NDRange(numElements/2),
cl::NDRange(numElements/2)),
fooPointer,
inputA.data(),
inputB,
outputBuffer,
3,
aPipe,
defaultDeviceQueue,
error
);
cl::copy(outputBuffer, begin(output), end(output));
cl::Device d = cl::Device::getDefault();
std::cout << "Output:\n";
for (int i = 1; i < numElements; ++i) {
std::cout << "\t" << output[i] << "\n";
}
std::cout << "\n\n";
return 0;
}
*
* \endcode
*
*/
#ifndef CL_HPP_
#define CL_HPP_
/* Handle deprecated preprocessor definitions. In each case, we only check for
* the old name if the new name is not defined, so that user code can define
* both and hence work with either version of the bindings.
*/
#if !defined(CL_HPP_USE_DX_INTEROP) && defined(USE_DX_INTEROP)
#pragma message("opencl.hpp: USE_DX_INTEROP is deprecated. Define CL_HPP_USE_DX_INTEROP instead")
#define CL_HPP_USE_DX_INTEROP
#endif
#if !defined(CL_HPP_USE_CL_DEVICE_FISSION) && defined(USE_CL_DEVICE_FISSION)
#pragma message("opencl.hpp: USE_CL_DEVICE_FISSION is deprecated. Define CL_HPP_USE_CL_DEVICE_FISSION instead")
#define CL_HPP_USE_CL_DEVICE_FISSION
#endif
#if !defined(CL_HPP_ENABLE_EXCEPTIONS) && defined(__CL_ENABLE_EXCEPTIONS)
#pragma message("opencl.hpp: __CL_ENABLE_EXCEPTIONS is deprecated. Define CL_HPP_ENABLE_EXCEPTIONS instead")
#define CL_HPP_ENABLE_EXCEPTIONS
#endif
#if !defined(CL_HPP_NO_STD_VECTOR) && defined(__NO_STD_VECTOR)
#pragma message("opencl.hpp: __NO_STD_VECTOR is deprecated. Define CL_HPP_NO_STD_VECTOR instead")
#define CL_HPP_NO_STD_VECTOR
#endif
#if !defined(CL_HPP_NO_STD_STRING) && defined(__NO_STD_STRING)
#pragma message("opencl.hpp: __NO_STD_STRING is deprecated. Define CL_HPP_NO_STD_STRING instead")
#define CL_HPP_NO_STD_STRING
#endif
#if defined(VECTOR_CLASS)
#pragma message("opencl.hpp: VECTOR_CLASS is deprecated. Alias cl::vector instead")
#endif
#if defined(STRING_CLASS)
#pragma message("opencl.hpp: STRING_CLASS is deprecated. Alias cl::string instead.")
#endif
#if !defined(CL_HPP_USER_OVERRIDE_ERROR_STRINGS) && defined(__CL_USER_OVERRIDE_ERROR_STRINGS)
#pragma message( \
"opencl.hpp: __CL_USER_OVERRIDE_ERROR_STRINGS is deprecated. Define CL_HPP_USER_OVERRIDE_ERROR_STRINGS instead")
#define CL_HPP_USER_OVERRIDE_ERROR_STRINGS
#endif
/* Warn about features that are no longer supported
*/
#if defined(__USE_DEV_VECTOR)
#pragma message("opencl.hpp: __USE_DEV_VECTOR is no longer supported. Expect compilation errors")
#endif
#if defined(__USE_DEV_STRING)
#pragma message("opencl.hpp: __USE_DEV_STRING is no longer supported. Expect compilation errors")
#endif
/* Detect which version to target */
#if !defined(CL_HPP_TARGET_OPENCL_VERSION)
#pragma message("opencl.hpp: CL_HPP_TARGET_OPENCL_VERSION is not defined. It will default to 300 (OpenCL 3.0)")
#define CL_HPP_TARGET_OPENCL_VERSION 300
#endif
#if CL_HPP_TARGET_OPENCL_VERSION != 100 && CL_HPP_TARGET_OPENCL_VERSION != 110 && \
CL_HPP_TARGET_OPENCL_VERSION != 120 && CL_HPP_TARGET_OPENCL_VERSION != 200 && CL_HPP_TARGET_OPENCL_VERSION != 210 && \
CL_HPP_TARGET_OPENCL_VERSION != 220 && CL_HPP_TARGET_OPENCL_VERSION != 300
#pragma message( \
"opencl.hpp: CL_HPP_TARGET_OPENCL_VERSION is not a valid value (100, 110, 120, 200, 210, 220 or 300). It will be set to 300 (OpenCL 3.0).")
#undef CL_HPP_TARGET_OPENCL_VERSION
#define CL_HPP_TARGET_OPENCL_VERSION 300
#endif
/* Forward target OpenCL version to C headers if necessary */
#if defined(CL_TARGET_OPENCL_VERSION)
/* Warn if prior definition of CL_TARGET_OPENCL_VERSION is lower than
* requested C++ bindings version */
#if CL_TARGET_OPENCL_VERSION < CL_HPP_TARGET_OPENCL_VERSION
#pragma message("CL_TARGET_OPENCL_VERSION is already defined as is lower than CL_HPP_TARGET_OPENCL_VERSION")
#endif
#else
#define CL_TARGET_OPENCL_VERSION CL_HPP_TARGET_OPENCL_VERSION
#endif
#if !defined(CL_HPP_MINIMUM_OPENCL_VERSION)
#define CL_HPP_MINIMUM_OPENCL_VERSION 200
#endif
#if CL_HPP_MINIMUM_OPENCL_VERSION != 100 && CL_HPP_MINIMUM_OPENCL_VERSION != 110 && \
CL_HPP_MINIMUM_OPENCL_VERSION != 120 && CL_HPP_MINIMUM_OPENCL_VERSION != 200 && \
CL_HPP_MINIMUM_OPENCL_VERSION != 210 && CL_HPP_MINIMUM_OPENCL_VERSION != 220 && CL_HPP_MINIMUM_OPENCL_VERSION != 300
#pragma message( \
"opencl.hpp: CL_HPP_MINIMUM_OPENCL_VERSION is not a valid value (100, 110, 120, 200, 210, 220 or 300). It will be set to 100")
#undef CL_HPP_MINIMUM_OPENCL_VERSION
#define CL_HPP_MINIMUM_OPENCL_VERSION 100
#endif
#if CL_HPP_MINIMUM_OPENCL_VERSION > CL_HPP_TARGET_OPENCL_VERSION
#error "CL_HPP_MINIMUM_OPENCL_VERSION must not be greater than CL_HPP_TARGET_OPENCL_VERSION"
#endif
#if CL_HPP_MINIMUM_OPENCL_VERSION <= 100 && !defined(CL_USE_DEPRECATED_OPENCL_1_0_APIS)
#define CL_USE_DEPRECATED_OPENCL_1_0_APIS
#endif
#if CL_HPP_MINIMUM_OPENCL_VERSION <= 110 && !defined(CL_USE_DEPRECATED_OPENCL_1_1_APIS)
#define CL_USE_DEPRECATED_OPENCL_1_1_APIS
#endif
#if CL_HPP_MINIMUM_OPENCL_VERSION <= 120 && !defined(CL_USE_DEPRECATED_OPENCL_1_2_APIS)
#define CL_USE_DEPRECATED_OPENCL_1_2_APIS
#endif
#if CL_HPP_MINIMUM_OPENCL_VERSION <= 200 && !defined(CL_USE_DEPRECATED_OPENCL_2_0_APIS)
#define CL_USE_DEPRECATED_OPENCL_2_0_APIS
#endif
#if CL_HPP_MINIMUM_OPENCL_VERSION <= 210 && !defined(CL_USE_DEPRECATED_OPENCL_2_1_APIS)
#define CL_USE_DEPRECATED_OPENCL_2_1_APIS
#endif
#if CL_HPP_MINIMUM_OPENCL_VERSION <= 220 && !defined(CL_USE_DEPRECATED_OPENCL_2_2_APIS)
#define CL_USE_DEPRECATED_OPENCL_2_2_APIS
#endif
#ifdef _WIN32
#include <malloc.h>
#if defined(CL_HPP_USE_DX_INTEROP)
#include <CL/cl_d3d10.h>
#include <CL/cl_dx9_media_sharing.h>
#endif
#endif // _WIN32
#if defined(_MSC_VER)
#include <intrin.h>
#endif // _MSC_VER
// Check for a valid C++ version
// Need to do both tests here because for some reason __cplusplus is not
// updated in visual studio
#if (!defined(_MSC_VER) && __cplusplus < 201103L) || (defined(_MSC_VER) && _MSC_VER < 1700)
#error Visual studio 2013 or another C++11-supporting compiler required
#endif
//
#if defined(CL_HPP_USE_CL_DEVICE_FISSION) || defined(CL_HPP_USE_CL_SUB_GROUPS_KHR)
#include <CL/cl_ext.h>
#endif
#if defined(__APPLE__) || defined(__MACOSX)
#include <OpenCL/opencl.h>
#else
#include <CL/opencl.h>
#endif // !__APPLE__
#if (__cplusplus >= 201103L || _MSVC_LANG >= 201103L)
#define CL_HPP_NOEXCEPT_ noexcept
#else
#define CL_HPP_NOEXCEPT_
#endif
#if __cplusplus >= 201703L
#define CL_HPP_DEFINE_STATIC_MEMBER_ inline
#elif defined(_MSC_VER)
#define CL_HPP_DEFINE_STATIC_MEMBER_ __declspec(selectany)
#elif defined(__MINGW32__)
#define CL_HPP_DEFINE_STATIC_MEMBER_ __attribute__((selectany))
#else
#define CL_HPP_DEFINE_STATIC_MEMBER_ __attribute__((weak))
#endif // !_MSC_VER
// Define deprecated prefixes and suffixes to ensure compilation
// in case they are not pre-defined
#if !defined(CL_API_PREFIX__VERSION_1_1_DEPRECATED)
#define CL_API_PREFIX__VERSION_1_1_DEPRECATED
#endif // #if !defined(CL_API_PREFIX__VERSION_1_1_DEPRECATED)
#if !defined(CL_API_SUFFIX__VERSION_1_1_DEPRECATED)
#define CL_API_SUFFIX__VERSION_1_1_DEPRECATED
#endif // #if !defined(CL_API_SUFFIX__VERSION_1_1_DEPRECATED)
#if !defined(CL_API_PREFIX__VERSION_1_2_DEPRECATED)
#define CL_API_PREFIX__VERSION_1_2_DEPRECATED
#endif // #if !defined(CL_API_PREFIX__VERSION_1_2_DEPRECATED)
#if !defined(CL_API_SUFFIX__VERSION_1_2_DEPRECATED)
#define CL_API_SUFFIX__VERSION_1_2_DEPRECATED
#endif // #if !defined(CL_API_SUFFIX__VERSION_1_2_DEPRECATED)
#if !defined(CL_API_PREFIX__VERSION_2_2_DEPRECATED)
#define CL_API_PREFIX__VERSION_2_2_DEPRECATED
#endif // #if !defined(CL_API_PREFIX__VERSION_2_2_DEPRECATED)
#if !defined(CL_API_SUFFIX__VERSION_2_2_DEPRECATED)
#define CL_API_SUFFIX__VERSION_2_2_DEPRECATED
#endif // #if !defined(CL_API_SUFFIX__VERSION_2_2_DEPRECATED)
#if !defined(CL_CALLBACK)
#define CL_CALLBACK
#endif // CL_CALLBACK
#include <cstring>
#include <functional>
#include <iterator>
#include <limits>
#include <mutex>
#include <utility>
// Define a size_type to represent a correctly resolved size_t
#if defined(CL_HPP_ENABLE_SIZE_T_COMPATIBILITY)
namespace cl
{
using size_type = ::size_t;
} // namespace cl
#else // #if defined(CL_HPP_ENABLE_SIZE_T_COMPATIBILITY)
namespace cl
{
using size_type = size_t;
} // namespace cl
#endif // #if defined(CL_HPP_ENABLE_SIZE_T_COMPATIBILITY)
#if defined(CL_HPP_ENABLE_EXCEPTIONS)
#include <exception>
#endif // #if defined(CL_HPP_ENABLE_EXCEPTIONS)
#if !defined(CL_HPP_NO_STD_VECTOR)
#include <vector>
namespace cl
{
template <class T, class Alloc = std::allocator<T>>
using vector = std::vector<T, Alloc>;
} // namespace cl
#endif // #if !defined(CL_HPP_NO_STD_VECTOR)
#if !defined(CL_HPP_NO_STD_STRING)
#include <string>
namespace cl
{
using string = std::string;
} // namespace cl
#endif // #if !defined(CL_HPP_NO_STD_STRING)
#if CL_HPP_TARGET_OPENCL_VERSION >= 200
#if !defined(CL_HPP_NO_STD_UNIQUE_PTR)
#include <memory>
namespace cl
{
// Replace unique_ptr and allocate_pointer for internal use
// to allow user to replace them
template <class T, class D>
using pointer = std::unique_ptr<T, D>;
} // namespace cl
#endif
#endif // #if CL_HPP_TARGET_OPENCL_VERSION >= 200
#if !defined(CL_HPP_NO_STD_ARRAY)
#include <array>
namespace cl
{
template <class T, size_type N>
using array = std::array<T, N>;
} // namespace cl
#endif // #if !defined(CL_HPP_NO_STD_ARRAY)
// Define size_type appropriately to allow backward-compatibility
// use of the old size_t interface class
#if defined(CL_HPP_ENABLE_SIZE_T_COMPATIBILITY)
namespace cl
{
namespace compatibility
{
/*! \brief class used to interface between C++ and
* OpenCL C calls that require arrays of size_t values, whose
* size is known statically.
*/
template <int N>
class size_t
{
private:
size_type data_[N];
public:
//! \brief Initialize size_t to all 0s
size_t()
{
for (int i = 0; i < N; ++i)
{
data_[i] = 0;
}
}
size_t(const array<size_type, N> &rhs)
{
for (int i = 0; i < N; ++i)
{
data_[i] = rhs[i];
}
}
size_type &operator[](int index) { return data_[index]; }
const size_type &operator[](int index) const { return data_[index]; }
//! \brief Conversion operator to T*.
operator size_type *() { return data_; }
//! \brief Conversion operator to const T*.
operator const size_type *() const { return data_; }
operator array<size_type, N>() const
{
array<size_type, N> ret;
for (int i = 0; i < N; ++i)
{
ret[i] = data_[i];
}
return ret;
}
};
} // namespace compatibility
template <int N>
using size_t = compatibility::size_t<N>;
} // namespace cl
#endif // #if defined(CL_HPP_ENABLE_SIZE_T_COMPATIBILITY)
// Helper alias to avoid confusing the macros
namespace cl
{
namespace detail
{
using size_t_array = array<size_type, 3>;
} // namespace detail
} // namespace cl
/*! \namespace cl
*
* \brief The OpenCL C++ bindings are defined within this namespace.
*
*/
namespace cl
{
class Memory;
#define CL_HPP_INIT_CL_EXT_FCN_PTR_(name) \
if (!pfn_##name) \
{ \
pfn_##name = (PFN_##name)clGetExtensionFunctionAddress(#name); \
if (!pfn_##name) \
{ \
} \
}
#define CL_HPP_INIT_CL_EXT_FCN_PTR_PLATFORM_(platform, name) \
if (!pfn_##name) \
{ \
pfn_##name = (PFN_##name)clGetExtensionFunctionAddressForPlatform(platform, #name); \
if (!pfn_##name) \
{ \
} \
}
class Program;
class Device;
class Context;
class CommandQueue;
class DeviceCommandQueue;
class Memory;
class Buffer;
class Pipe;
#if defined(CL_HPP_ENABLE_EXCEPTIONS)
/*! \brief Exception class
*
* This may be thrown by API functions when CL_HPP_ENABLE_EXCEPTIONS is defined.
*/
class Error : public std::exception
{
private:
cl_int err_;
const char *errStr_;
public:
/*! \brief Create a new CL error exception for a given error code
* and corresponding message.
*
* \param err error code value.
*
* \param errStr a descriptive string that must remain in scope until
* handling of the exception has concluded. If set, it
* will be returned by what().
*/
Error(cl_int err, const char *errStr = NULL)
: err_(err)
, errStr_(errStr)
{}
~Error() throw() {}
/*! \brief Get error string associated with exception
*
* \return A memory pointer to the error message string.
*/
virtual const char *what() const throw()
{
if (errStr_ == NULL)
{
return "empty";
}
else
{
return errStr_;
}
}
/*! \brief Get error code associated with exception
*
* \return The error code.
*/
cl_int err(void) const { return err_; }
};
#define CL_HPP_ERR_STR_(x) #x
#else
#define CL_HPP_ERR_STR_(x) NULL
#endif // CL_HPP_ENABLE_EXCEPTIONS
namespace detail
{
#if defined(CL_HPP_ENABLE_EXCEPTIONS)
static inline cl_int errHandler(cl_int err, const char *errStr = NULL)
{
if (err != CL_SUCCESS)
{
throw Error(err, errStr);
}
return err;
}
#else
static inline cl_int errHandler(cl_int err, const char *errStr = NULL)
{
(void)errStr; // suppress unused variable warning
return err;
}
#endif // CL_HPP_ENABLE_EXCEPTIONS
} // namespace detail
//! \cond DOXYGEN_DETAIL
#if !defined(CL_HPP_USER_OVERRIDE_ERROR_STRINGS)
#define __GET_DEVICE_INFO_ERR CL_HPP_ERR_STR_(clGetDeviceInfo)
#define __GET_PLATFORM_INFO_ERR CL_HPP_ERR_STR_(clGetPlatformInfo)
#define __GET_DEVICE_IDS_ERR CL_HPP_ERR_STR_(clGetDeviceIDs)
#define __GET_PLATFORM_IDS_ERR CL_HPP_ERR_STR_(clGetPlatformIDs)
#define __GET_CONTEXT_INFO_ERR CL_HPP_ERR_STR_(clGetContextInfo)
#define __GET_EVENT_INFO_ERR CL_HPP_ERR_STR_(clGetEventInfo)
#define __GET_EVENT_PROFILE_INFO_ERR CL_HPP_ERR_STR_(clGetEventProfileInfo)
#define __GET_MEM_OBJECT_INFO_ERR CL_HPP_ERR_STR_(clGetMemObjectInfo)
#define __GET_IMAGE_INFO_ERR CL_HPP_ERR_STR_(clGetImageInfo)
#define __GET_SAMPLER_INFO_ERR CL_HPP_ERR_STR_(clGetSamplerInfo)
#define __GET_KERNEL_INFO_ERR CL_HPP_ERR_STR_(clGetKernelInfo)
#if CL_HPP_TARGET_OPENCL_VERSION >= 120
#define __GET_KERNEL_ARG_INFO_ERR CL_HPP_ERR_STR_(clGetKernelArgInfo)
#endif // CL_HPP_TARGET_OPENCL_VERSION >= 120
#if CL_HPP_TARGET_OPENCL_VERSION >= 200
#define __GET_KERNEL_SUB_GROUP_INFO_ERR CL_HPP_ERR_STR_(clGetKernelSubGroupInfo)
#endif // CL_HPP_TARGET_OPENCL_VERSION >= 200
#define __GET_KERNEL_WORK_GROUP_INFO_ERR CL_HPP_ERR_STR_(clGetKernelWorkGroupInfo)
#define __GET_PROGRAM_INFO_ERR CL_HPP_ERR_STR_(clGetProgramInfo)
#define __GET_PROGRAM_BUILD_INFO_ERR CL_HPP_ERR_STR_(clGetProgramBuildInfo)
#define __GET_COMMAND_QUEUE_INFO_ERR CL_HPP_ERR_STR_(clGetCommandQueueInfo)
#define __CREATE_CONTEXT_ERR CL_HPP_ERR_STR_(clCreateContext)
#define __CREATE_CONTEXT_FROM_TYPE_ERR CL_HPP_ERR_STR_(clCreateContextFromType)
#define __GET_SUPPORTED_IMAGE_FORMATS_ERR CL_HPP_ERR_STR_(clGetSupportedImageFormats)
#define __CREATE_BUFFER_ERR CL_HPP_ERR_STR_(clCreateBuffer)
#define __COPY_ERR CL_HPP_ERR_STR_(cl::copy)
#define __CREATE_SUBBUFFER_ERR CL_HPP_ERR_STR_(clCreateSubBuffer)
#define __CREATE_GL_BUFFER_ERR CL_HPP_ERR_STR_(clCreateFromGLBuffer)
#define __CREATE_GL_RENDER_BUFFER_ERR CL_HPP_ERR_STR_(clCreateFromGLBuffer)
#define __GET_GL_OBJECT_INFO_ERR CL_HPP_ERR_STR_(clGetGLObjectInfo)
#if CL_HPP_TARGET_OPENCL_VERSION >= 120
#define __CREATE_IMAGE_ERR CL_HPP_ERR_STR_(clCreateImage)
#define __CREATE_GL_TEXTURE_ERR CL_HPP_ERR_STR_(clCreateFromGLTexture)
#define __IMAGE_DIMENSION_ERR CL_HPP_ERR_STR_(Incorrect image dimensions)
#endif // CL_HPP_TARGET_OPENCL_VERSION >= 120
#define __SET_MEM_OBJECT_DESTRUCTOR_CALLBACK_ERR CL_HPP_ERR_STR_(clSetMemObjectDestructorCallback)
#define __CREATE_USER_EVENT_ERR CL_HPP_ERR_STR_(clCreateUserEvent)
#define __SET_USER_EVENT_STATUS_ERR CL_HPP_ERR_STR_(clSetUserEventStatus)
#define __SET_EVENT_CALLBACK_ERR CL_HPP_ERR_STR_(clSetEventCallback)
#define __WAIT_FOR_EVENTS_ERR CL_HPP_ERR_STR_(clWaitForEvents)
#define __CREATE_KERNEL_ERR CL_HPP_ERR_STR_(clCreateKernel)
#define __SET_KERNEL_ARGS_ERR CL_HPP_ERR_STR_(clSetKernelArg)
#define __CREATE_PROGRAM_WITH_SOURCE_ERR CL_HPP_ERR_STR_(clCreateProgramWithSource)
#if CL_HPP_TARGET_OPENCL_VERSION >= 200
#define __CREATE_PROGRAM_WITH_IL_ERR CL_HPP_ERR_STR_(clCreateProgramWithIL)
#endif // #if CL_HPP_TARGET_OPENCL_VERSION >= 200
#define __CREATE_PROGRAM_WITH_BINARY_ERR CL_HPP_ERR_STR_(clCreateProgramWithBinary)
#if CL_HPP_TARGET_OPENCL_VERSION >= 210
#define __CREATE_PROGRAM_WITH_IL_ERR CL_HPP_ERR_STR_(clCreateProgramWithIL)
#endif // CL_HPP_TARGET_OPENCL_VERSION >= 210
#if CL_HPP_TARGET_OPENCL_VERSION >= 120
#define __CREATE_PROGRAM_WITH_BUILT_IN_KERNELS_ERR CL_HPP_ERR_STR_(clCreateProgramWithBuiltInKernels)
#endif // CL_HPP_TARGET_OPENCL_VERSION >= 120
#define __BUILD_PROGRAM_ERR CL_HPP_ERR_STR_(clBuildProgram)
#if CL_HPP_TARGET_OPENCL_VERSION >= 120
#define __COMPILE_PROGRAM_ERR CL_HPP_ERR_STR_(clCompileProgram)
#define __LINK_PROGRAM_ERR CL_HPP_ERR_STR_(clLinkProgram)
#endif // CL_HPP_TARGET_OPENCL_VERSION >= 120
#define __CREATE_KERNELS_IN_PROGRAM_ERR CL_HPP_ERR_STR_(clCreateKernelsInProgram)
#if CL_HPP_TARGET_OPENCL_VERSION >= 200
#define __CREATE_COMMAND_QUEUE_WITH_PROPERTIES_ERR CL_HPP_ERR_STR_(clCreateCommandQueueWithProperties)
#define __CREATE_SAMPLER_WITH_PROPERTIES_ERR CL_HPP_ERR_STR_(clCreateSamplerWithProperties)
#endif // CL_HPP_TARGET_OPENCL_VERSION >= 200
#define __SET_COMMAND_QUEUE_PROPERTY_ERR CL_HPP_ERR_STR_(clSetCommandQueueProperty)
#define __ENQUEUE_READ_BUFFER_ERR CL_HPP_ERR_STR_(clEnqueueReadBuffer)
#define __ENQUEUE_READ_BUFFER_RECT_ERR CL_HPP_ERR_STR_(clEnqueueReadBufferRect)
#define __ENQUEUE_WRITE_BUFFER_ERR CL_HPP_ERR_STR_(clEnqueueWriteBuffer)
#define __ENQUEUE_WRITE_BUFFER_RECT_ERR CL_HPP_ERR_STR_(clEnqueueWriteBufferRect)
#define __ENQEUE_COPY_BUFFER_ERR CL_HPP_ERR_STR_(clEnqueueCopyBuffer)
#define __ENQEUE_COPY_BUFFER_RECT_ERR CL_HPP_ERR_STR_(clEnqueueCopyBufferRect)
#define __ENQUEUE_FILL_BUFFER_ERR CL_HPP_ERR_STR_(clEnqueueFillBuffer)
#define __ENQUEUE_READ_IMAGE_ERR CL_HPP_ERR_STR_(clEnqueueReadImage)
#define __ENQUEUE_WRITE_IMAGE_ERR CL_HPP_ERR_STR_(clEnqueueWriteImage)
#define __ENQUEUE_COPY_IMAGE_ERR CL_HPP_ERR_STR_(clEnqueueCopyImage)
#define __ENQUEUE_FILL_IMAGE_ERR CL_HPP_ERR_STR_(clEnqueueFillImage)
#define __ENQUEUE_COPY_IMAGE_TO_BUFFER_ERR CL_HPP_ERR_STR_(clEnqueueCopyImageToBuffer)
#define __ENQUEUE_COPY_BUFFER_TO_IMAGE_ERR CL_HPP_ERR_STR_(clEnqueueCopyBufferToImage)
#define __ENQUEUE_MAP_BUFFER_ERR CL_HPP_ERR_STR_(clEnqueueMapBuffer)
#define __ENQUEUE_MAP_IMAGE_ERR CL_HPP_ERR_STR_(clEnqueueMapImage)
#define __ENQUEUE_UNMAP_MEM_OBJECT_ERR CL_HPP_ERR_STR_(clEnqueueUnMapMemObject)
#define __ENQUEUE_NDRANGE_KERNEL_ERR CL_HPP_ERR_STR_(clEnqueueNDRangeKernel)
#define __ENQUEUE_NATIVE_KERNEL CL_HPP_ERR_STR_(clEnqueueNativeKernel)
#if CL_HPP_TARGET_OPENCL_VERSION >= 120
#define __ENQUEUE_MIGRATE_MEM_OBJECTS_ERR CL_HPP_ERR_STR_(clEnqueueMigrateMemObjects)
#endif // CL_HPP_TARGET_OPENCL_VERSION >= 120
#if CL_HPP_TARGET_OPENCL_VERSION >= 210
#define __ENQUEUE_MIGRATE_SVM_ERR CL_HPP_ERR_STR_(clEnqueueSVMMigrateMem)
#define __SET_DEFAULT_DEVICE_COMMAND_QUEUE_ERR CL_HPP_ERR_STR_(clSetDefaultDeviceCommandQueue)
#endif // CL_HPP_TARGET_OPENCL_VERSION >= 210
#define __ENQUEUE_ACQUIRE_GL_ERR CL_HPP_ERR_STR_(clEnqueueAcquireGLObjects)
#define __ENQUEUE_RELEASE_GL_ERR CL_HPP_ERR_STR_(clEnqueueReleaseGLObjects)
#define __CREATE_PIPE_ERR CL_HPP_ERR_STR_(clCreatePipe)
#define __GET_PIPE_INFO_ERR CL_HPP_ERR_STR_(clGetPipeInfo)
#define __RETAIN_ERR CL_HPP_ERR_STR_(Retain Object)
#define __RELEASE_ERR CL_HPP_ERR_STR_(Release Object)
#define __FLUSH_ERR CL_HPP_ERR_STR_(clFlush)
#define __FINISH_ERR CL_HPP_ERR_STR_(clFinish)
#define __VECTOR_CAPACITY_ERR CL_HPP_ERR_STR_(Vector capacity error)
#if CL_HPP_TARGET_OPENCL_VERSION >= 210
#define __GET_HOST_TIMER_ERR CL_HPP_ERR_STR_(clGetHostTimer)
#define __GET_DEVICE_AND_HOST_TIMER_ERR CL_HPP_ERR_STR_(clGetDeviceAndHostTimer)
#endif
#if CL_HPP_TARGET_OPENCL_VERSION >= 220
#define __SET_PROGRAM_RELEASE_CALLBACK_ERR CL_HPP_ERR_STR_(clSetProgramReleaseCallback)
#define __SET_PROGRAM_SPECIALIZATION_CONSTANT_ERR CL_HPP_ERR_STR_(clSetProgramSpecializationConstant)
#endif
/**
* CL 1.2 version that uses device fission.
*/
#if CL_HPP_TARGET_OPENCL_VERSION >= 120
#define __CREATE_SUB_DEVICES_ERR CL_HPP_ERR_STR_(clCreateSubDevices)
#else
#define __CREATE_SUB_DEVICES_ERR CL_HPP_ERR_STR_(clCreateSubDevicesEXT)
#endif // CL_HPP_TARGET_OPENCL_VERSION >= 120
/**
* Deprecated APIs for 1.2
*/
#if defined(CL_USE_DEPRECATED_OPENCL_1_1_APIS)
#define __ENQUEUE_MARKER_ERR CL_HPP_ERR_STR_(clEnqueueMarker)
#define __ENQUEUE_WAIT_FOR_EVENTS_ERR CL_HPP_ERR_STR_(clEnqueueWaitForEvents)
#define __ENQUEUE_BARRIER_ERR CL_HPP_ERR_STR_(clEnqueueBarrier)
#define __UNLOAD_COMPILER_ERR CL_HPP_ERR_STR_(clUnloadCompiler)
#define __CREATE_GL_TEXTURE_2D_ERR CL_HPP_ERR_STR_(clCreateFromGLTexture2D)
#define __CREATE_GL_TEXTURE_3D_ERR CL_HPP_ERR_STR_(clCreateFromGLTexture3D)
#define __CREATE_IMAGE2D_ERR CL_HPP_ERR_STR_(clCreateImage2D)
#define __CREATE_IMAGE3D_ERR CL_HPP_ERR_STR_(clCreateImage3D)
#endif // #if defined(CL_USE_DEPRECATED_OPENCL_1_1_APIS)
/**
* Deprecated APIs for 2.0
*/
#if defined(CL_USE_DEPRECATED_OPENCL_1_2_APIS)
#define __CREATE_COMMAND_QUEUE_ERR CL_HPP_ERR_STR_(clCreateCommandQueue)
#define __ENQUEUE_TASK_ERR CL_HPP_ERR_STR_(clEnqueueTask)
#define __CREATE_SAMPLER_ERR CL_HPP_ERR_STR_(clCreateSampler)
#endif // #if defined(CL_USE_DEPRECATED_OPENCL_1_1_APIS)
/**
* CL 1.2 marker and barrier commands
*/
#if CL_HPP_TARGET_OPENCL_VERSION >= 120
#define __ENQUEUE_MARKER_WAIT_LIST_ERR CL_HPP_ERR_STR_(clEnqueueMarkerWithWaitList)
#define __ENQUEUE_BARRIER_WAIT_LIST_ERR CL_HPP_ERR_STR_(clEnqueueBarrierWithWaitList)
#endif // CL_HPP_TARGET_OPENCL_VERSION >= 120
#if CL_HPP_TARGET_OPENCL_VERSION >= 210
#define __CLONE_KERNEL_ERR CL_HPP_ERR_STR_(clCloneKernel)
#endif // CL_HPP_TARGET_OPENCL_VERSION >= 210
#endif // CL_HPP_USER_OVERRIDE_ERROR_STRINGS
//! \endcond
namespace detail
{
// Generic getInfoHelper. The final parameter is used to guide overload
// resolution: the actual parameter passed is an int, which makes this
// a worse conversion sequence than a specialization that declares the
// parameter as an int.
template <typename Functor, typename T>
inline cl_int getInfoHelper(Functor f, cl_uint name, T *param, long)
{
return f(name, sizeof(T), param, NULL);
}
// Specialized for getInfo<CL_PROGRAM_BINARIES>
// Assumes that the output vector was correctly resized on the way in
template <typename Func>
inline cl_int getInfoHelper(Func f, cl_uint name, vector<vector<unsigned char>> *param, int)
{
if (name != CL_PROGRAM_BINARIES)
{
return CL_INVALID_VALUE;
}
if (param)
{
// Create array of pointers, calculate total size and pass pointer array in
size_type numBinaries = param->size();
vector<unsigned char *> binariesPointers(numBinaries);
for (size_type i = 0; i < numBinaries; ++i)
{
binariesPointers[i] = (*param)[i].data();
}
cl_int err = f(name, numBinaries * sizeof(unsigned char *), binariesPointers.data(), NULL);
if (err != CL_SUCCESS)
{
return err;
}
}
return CL_SUCCESS;
}
// Specialized getInfoHelper for vector params
template <typename Func, typename T>
inline cl_int getInfoHelper(Func f, cl_uint name, vector<T> *param, long)
{
size_type required;
cl_int err = f(name, 0, NULL, &required);
if (err != CL_SUCCESS)
{
return err;
}
const size_type elements = required / sizeof(T);
// Temporary to avoid changing param on an error
vector<T> localData(elements);
err = f(name, required, localData.data(), NULL);
if (err != CL_SUCCESS)
{
return err;
}
if (param)
{
*param = std::move(localData);
}
return CL_SUCCESS;
}
/* Specialization for reference-counted types. This depends on the
* existence of Wrapper<T>::cl_type, and none of the other types having the
* cl_type member. Note that simplify specifying the parameter as Wrapper<T>
* does not work, because when using a derived type (e.g. Context) the generic
* template will provide a better match.
*/
template <typename Func, typename T>
inline cl_int getInfoHelper(Func f, cl_uint name, vector<T> *param, int, typename T::cl_type = 0)
{
size_type required;
cl_int err = f(name, 0, NULL, &required);
if (err != CL_SUCCESS)
{
return err;
}
const size_type elements = required / sizeof(typename T::cl_type);
vector<typename T::cl_type> value(elements);
err = f(name, required, value.data(), NULL);
if (err != CL_SUCCESS)
{
return err;
}
if (param)
{
// Assign to convert CL type to T for each element
param->resize(elements);
// Assign to param, constructing with retain behaviour
// to correctly capture each underlying CL object
for (size_type i = 0; i < elements; i++)
{
(*param)[i] = T(value[i], true);
}
}
return CL_SUCCESS;
}
// Specialized GetInfoHelper for string params
template <typename Func>
inline cl_int getInfoHelper(Func f, cl_uint name, string *param, long)
{
size_type required;
cl_int err = f(name, 0, NULL, &required);
if (err != CL_SUCCESS)
{
return err;
}
// std::string has a constant data member
// a char vector does not
if (required > 0)
{
vector<char> value(required);
err = f(name, required, value.data(), NULL);
if (err != CL_SUCCESS)
{
return err;
}
if (param)
{
param->assign(begin(value), prev(end(value)));
}
}
else if (param)
{
param->assign("");
}
return CL_SUCCESS;
}
// Specialized GetInfoHelper for clsize_t params
template <typename Func, size_type N>
inline cl_int getInfoHelper(Func f, cl_uint name, array<size_type, N> *param, long)
{
size_type required;
cl_int err = f(name, 0, NULL, &required);
if (err != CL_SUCCESS)
{
return err;
}
size_type elements = required / sizeof(size_type);
vector<size_type> value(elements, 0);
err = f(name, required, value.data(), NULL);
if (err != CL_SUCCESS)
{
return err;
}
// Bound the copy with N to prevent overruns
// if passed N > than the amount copied
if (elements > N)
{
elements = N;
}
for (size_type i = 0; i < elements; ++i)
{
(*param)[i] = value[i];
}
return CL_SUCCESS;
}
template <typename T>
struct ReferenceHandler;
/* Specialization for reference-counted types. This depends on the
* existence of Wrapper<T>::cl_type, and none of the other types having the
* cl_type member. Note that simplify specifying the parameter as Wrapper<T>
* does not work, because when using a derived type (e.g. Context) the generic
* template will provide a better match.
*/
template <typename Func, typename T>
inline cl_int getInfoHelper(Func f, cl_uint name, T *param, int, typename T::cl_type = 0)
{
typename T::cl_type value;
cl_int err = f(name, sizeof(value), &value, NULL);
if (err != CL_SUCCESS)
{
return err;
}
*param = value;
if (value != NULL)
{
err = param->retain();
if (err != CL_SUCCESS)
{
return err;
}
}
return CL_SUCCESS;
}
#define CL_HPP_PARAM_NAME_INFO_1_0_(F) \
F(cl_platform_info, CL_PLATFORM_PROFILE, string) \
F(cl_platform_info, CL_PLATFORM_VERSION, string) \
F(cl_platform_info, CL_PLATFORM_NAME, string) \
F(cl_platform_info, CL_PLATFORM_VENDOR, string) \
F(cl_platform_info, CL_PLATFORM_EXTENSIONS, string) \
\
F(cl_device_info, CL_DEVICE_TYPE, cl_device_type) \
F(cl_device_info, CL_DEVICE_VENDOR_ID, cl_uint) \
F(cl_device_info, CL_DEVICE_MAX_COMPUTE_UNITS, cl_uint) \
F(cl_device_info, CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS, cl_uint) \
F(cl_device_info, CL_DEVICE_MAX_WORK_GROUP_SIZE, size_type) \
F(cl_device_info, CL_DEVICE_MAX_WORK_ITEM_SIZES, cl::vector<size_type>) \
F(cl_device_info, CL_DEVICE_PREFERRED_VECTOR_WIDTH_CHAR, cl_uint) \
F(cl_device_info, CL_DEVICE_PREFERRED_VECTOR_WIDTH_SHORT, cl_uint) \
F(cl_device_info, CL_DEVICE_PREFERRED_VECTOR_WIDTH_INT, cl_uint) \
F(cl_device_info, CL_DEVICE_PREFERRED_VECTOR_WIDTH_LONG, cl_uint) \
F(cl_device_info, CL_DEVICE_PREFERRED_VECTOR_WIDTH_FLOAT, cl_uint) \
F(cl_device_info, CL_DEVICE_PREFERRED_VECTOR_WIDTH_DOUBLE, cl_uint) \
F(cl_device_info, CL_DEVICE_MAX_CLOCK_FREQUENCY, cl_uint) \
F(cl_device_info, CL_DEVICE_ADDRESS_BITS, cl_uint) \
F(cl_device_info, CL_DEVICE_MAX_READ_IMAGE_ARGS, cl_uint) \
F(cl_device_info, CL_DEVICE_MAX_WRITE_IMAGE_ARGS, cl_uint) \
F(cl_device_info, CL_DEVICE_MAX_MEM_ALLOC_SIZE, cl_ulong) \
F(cl_device_info, CL_DEVICE_IMAGE2D_MAX_WIDTH, size_type) \
F(cl_device_info, CL_DEVICE_IMAGE2D_MAX_HEIGHT, size_type) \
F(cl_device_info, CL_DEVICE_IMAGE3D_MAX_WIDTH, size_type) \
F(cl_device_info, CL_DEVICE_IMAGE3D_MAX_HEIGHT, size_type) \
F(cl_device_info, CL_DEVICE_IMAGE3D_MAX_DEPTH, size_type) \
F(cl_device_info, CL_DEVICE_IMAGE_SUPPORT, cl_bool) \
F(cl_device_info, CL_DEVICE_MAX_PARAMETER_SIZE, size_type) \
F(cl_device_info, CL_DEVICE_MAX_SAMPLERS, cl_uint) \
F(cl_device_info, CL_DEVICE_MEM_BASE_ADDR_ALIGN, cl_uint) \
F(cl_device_info, CL_DEVICE_MIN_DATA_TYPE_ALIGN_SIZE, cl_uint) \
F(cl_device_info, CL_DEVICE_SINGLE_FP_CONFIG, cl_device_fp_config) \
F(cl_device_info, CL_DEVICE_DOUBLE_FP_CONFIG, cl_device_fp_config) \
F(cl_device_info, CL_DEVICE_HALF_FP_CONFIG, cl_device_fp_config) \
F(cl_device_info, CL_DEVICE_GLOBAL_MEM_CACHE_TYPE, cl_device_mem_cache_type) \
F(cl_device_info, CL_DEVICE_GLOBAL_MEM_CACHELINE_SIZE, cl_uint) \
F(cl_device_info, CL_DEVICE_GLOBAL_MEM_CACHE_SIZE, cl_ulong) \
F(cl_device_info, CL_DEVICE_GLOBAL_MEM_SIZE, cl_ulong) \
F(cl_device_info, CL_DEVICE_MAX_CONSTANT_BUFFER_SIZE, cl_ulong) \
F(cl_device_info, CL_DEVICE_MAX_CONSTANT_ARGS, cl_uint) \
F(cl_device_info, CL_DEVICE_LOCAL_MEM_TYPE, cl_device_local_mem_type) \
F(cl_device_info, CL_DEVICE_LOCAL_MEM_SIZE, cl_ulong) \
F(cl_device_info, CL_DEVICE_ERROR_CORRECTION_SUPPORT, cl_bool) \
F(cl_device_info, CL_DEVICE_PROFILING_TIMER_RESOLUTION, size_type) \
F(cl_device_info, CL_DEVICE_ENDIAN_LITTLE, cl_bool) \
F(cl_device_info, CL_DEVICE_AVAILABLE, cl_bool) \
F(cl_device_info, CL_DEVICE_COMPILER_AVAILABLE, cl_bool) \
F(cl_device_info, CL_DEVICE_EXECUTION_CAPABILITIES, cl_device_exec_capabilities) \
F(cl_device_info, CL_DEVICE_PLATFORM, cl_platform_id) \
F(cl_device_info, CL_DEVICE_NAME, string) \
F(cl_device_info, CL_DEVICE_VENDOR, string) \
F(cl_device_info, CL_DRIVER_VERSION, string) \
F(cl_device_info, CL_DEVICE_PROFILE, string) \
F(cl_device_info, CL_DEVICE_VERSION, string) \
F(cl_device_info, CL_DEVICE_EXTENSIONS, string) \
\
F(cl_context_info, CL_CONTEXT_REFERENCE_COUNT, cl_uint) \
F(cl_context_info, CL_CONTEXT_DEVICES, cl::vector<Device>) \
F(cl_context_info, CL_CONTEXT_PROPERTIES, cl::vector<cl_context_properties>) \
\
F(cl_event_info, CL_EVENT_COMMAND_QUEUE, cl::CommandQueue) \
F(cl_event_info, CL_EVENT_COMMAND_TYPE, cl_command_type) \
F(cl_event_info, CL_EVENT_REFERENCE_COUNT, cl_uint) \
F(cl_event_info, CL_EVENT_COMMAND_EXECUTION_STATUS, cl_int) \
\
F(cl_profiling_info, CL_PROFILING_COMMAND_QUEUED, cl_ulong) \
F(cl_profiling_info, CL_PROFILING_COMMAND_SUBMIT, cl_ulong) \
F(cl_profiling_info, CL_PROFILING_COMMAND_START, cl_ulong) \
F(cl_profiling_info, CL_PROFILING_COMMAND_END, cl_ulong) \
\
F(cl_mem_info, CL_MEM_TYPE, cl_mem_object_type) \
F(cl_mem_info, CL_MEM_FLAGS, cl_mem_flags) \
F(cl_mem_info, CL_MEM_SIZE, size_type) \
F(cl_mem_info, CL_MEM_HOST_PTR, void *) \
F(cl_mem_info, CL_MEM_MAP_COUNT, cl_uint) \
F(cl_mem_info, CL_MEM_REFERENCE_COUNT, cl_uint) \
F(cl_mem_info, CL_MEM_CONTEXT, cl::Context) \
\
F(cl_image_info, CL_IMAGE_FORMAT, cl_image_format) \
F(cl_image_info, CL_IMAGE_ELEMENT_SIZE, size_type) \
F(cl_image_info, CL_IMAGE_ROW_PITCH, size_type) \
F(cl_image_info, CL_IMAGE_SLICE_PITCH, size_type) \
F(cl_image_info, CL_IMAGE_WIDTH, size_type) \
F(cl_image_info, CL_IMAGE_HEIGHT, size_type) \
F(cl_image_info, CL_IMAGE_DEPTH, size_type) \
\
F(cl_sampler_info, CL_SAMPLER_REFERENCE_COUNT, cl_uint) \
F(cl_sampler_info, CL_SAMPLER_CONTEXT, cl::Context) \
F(cl_sampler_info, CL_SAMPLER_NORMALIZED_COORDS, cl_bool) \
F(cl_sampler_info, CL_SAMPLER_ADDRESSING_MODE, cl_addressing_mode) \
F(cl_sampler_info, CL_SAMPLER_FILTER_MODE, cl_filter_mode) \
\
F(cl_program_info, CL_PROGRAM_REFERENCE_COUNT, cl_uint) \
F(cl_program_info, CL_PROGRAM_CONTEXT, cl::Context) \
F(cl_program_info, CL_PROGRAM_NUM_DEVICES, cl_uint) \
F(cl_program_info, CL_PROGRAM_DEVICES, cl::vector<Device>) \
F(cl_program_info, CL_PROGRAM_SOURCE, string) \
F(cl_program_info, CL_PROGRAM_BINARY_SIZES, cl::vector<size_type>) \
F(cl_program_info, CL_PROGRAM_BINARIES, cl::vector<cl::vector<unsigned char>>) \
\
F(cl_program_build_info, CL_PROGRAM_BUILD_STATUS, cl_build_status) \
F(cl_program_build_info, CL_PROGRAM_BUILD_OPTIONS, string) \
F(cl_program_build_info, CL_PROGRAM_BUILD_LOG, string) \
\
F(cl_kernel_info, CL_KERNEL_FUNCTION_NAME, string) \
F(cl_kernel_info, CL_KERNEL_NUM_ARGS, cl_uint) \
F(cl_kernel_info, CL_KERNEL_REFERENCE_COUNT, cl_uint) \
F(cl_kernel_info, CL_KERNEL_CONTEXT, cl::Context) \
F(cl_kernel_info, CL_KERNEL_PROGRAM, cl::Program) \
\
F(cl_kernel_work_group_info, CL_KERNEL_WORK_GROUP_SIZE, size_type) \
F(cl_kernel_work_group_info, CL_KERNEL_COMPILE_WORK_GROUP_SIZE, cl::detail::size_t_array) \
F(cl_kernel_work_group_info, CL_KERNEL_LOCAL_MEM_SIZE, cl_ulong) \
\
F(cl_command_queue_info, CL_QUEUE_CONTEXT, cl::Context) \
F(cl_command_queue_info, CL_QUEUE_DEVICE, cl::Device) \
F(cl_command_queue_info, CL_QUEUE_REFERENCE_COUNT, cl_uint) \
F(cl_command_queue_info, CL_QUEUE_PROPERTIES, cl_command_queue_properties)
#define CL_HPP_PARAM_NAME_INFO_1_1_(F) \
F(cl_context_info, CL_CONTEXT_NUM_DEVICES, cl_uint) \
F(cl_device_info, CL_DEVICE_PREFERRED_VECTOR_WIDTH_HALF, cl_uint) \
F(cl_device_info, CL_DEVICE_NATIVE_VECTOR_WIDTH_CHAR, cl_uint) \
F(cl_device_info, CL_DEVICE_NATIVE_VECTOR_WIDTH_SHORT, cl_uint) \
F(cl_device_info, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, cl_uint) \
F(cl_device_info, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, cl_uint) \
F(cl_device_info, CL_DEVICE_NATIVE_VECTOR_WIDTH_FLOAT, cl_uint) \
F(cl_device_info, CL_DEVICE_NATIVE_VECTOR_WIDTH_DOUBLE, cl_uint) \
F(cl_device_info, CL_DEVICE_NATIVE_VECTOR_WIDTH_HALF, cl_uint) \
F(cl_device_info, CL_DEVICE_OPENCL_C_VERSION, string) \
\
F(cl_mem_info, CL_MEM_ASSOCIATED_MEMOBJECT, cl::Memory) \
F(cl_mem_info, CL_MEM_OFFSET, size_type) \
\
F(cl_kernel_work_group_info, CL_KERNEL_PREFERRED_WORK_GROUP_SIZE_MULTIPLE, size_type) \
F(cl_kernel_work_group_info, CL_KERNEL_PRIVATE_MEM_SIZE, cl_ulong) \
\
F(cl_event_info, CL_EVENT_CONTEXT, cl::Context)
#define CL_HPP_PARAM_NAME_INFO_1_2_(F) \
F(cl_program_info, CL_PROGRAM_NUM_KERNELS, size_type) \
F(cl_program_info, CL_PROGRAM_KERNEL_NAMES, string) \
\
F(cl_program_build_info, CL_PROGRAM_BINARY_TYPE, cl_program_binary_type) \
\
F(cl_kernel_info, CL_KERNEL_ATTRIBUTES, string) \
\
F(cl_kernel_arg_info, CL_KERNEL_ARG_ADDRESS_QUALIFIER, cl_kernel_arg_address_qualifier) \
F(cl_kernel_arg_info, CL_KERNEL_ARG_ACCESS_QUALIFIER, cl_kernel_arg_access_qualifier) \
F(cl_kernel_arg_info, CL_KERNEL_ARG_TYPE_NAME, string) \
F(cl_kernel_arg_info, CL_KERNEL_ARG_NAME, string) \
F(cl_kernel_arg_info, CL_KERNEL_ARG_TYPE_QUALIFIER, cl_kernel_arg_type_qualifier) \
\
F(cl_kernel_work_group_info, CL_KERNEL_GLOBAL_WORK_SIZE, cl::detail::size_t_array) \
\
F(cl_device_info, CL_DEVICE_LINKER_AVAILABLE, cl_bool) \
F(cl_device_info, CL_DEVICE_IMAGE_MAX_BUFFER_SIZE, size_type) \
F(cl_device_info, CL_DEVICE_IMAGE_MAX_ARRAY_SIZE, size_type) \
F(cl_device_info, CL_DEVICE_PARENT_DEVICE, cl::Device) \
F(cl_device_info, CL_DEVICE_PARTITION_MAX_SUB_DEVICES, cl_uint) \
F(cl_device_info, CL_DEVICE_PARTITION_PROPERTIES, cl::vector<cl_device_partition_property>) \
F(cl_device_info, CL_DEVICE_PARTITION_TYPE, cl::vector<cl_device_partition_property>) \
F(cl_device_info, CL_DEVICE_REFERENCE_COUNT, cl_uint) \
F(cl_device_info, CL_DEVICE_PREFERRED_INTEROP_USER_SYNC, cl_bool) \
F(cl_device_info, CL_DEVICE_PARTITION_AFFINITY_DOMAIN, cl_device_affinity_domain) \
F(cl_device_info, CL_DEVICE_BUILT_IN_KERNELS, string) \
F(cl_device_info, CL_DEVICE_PRINTF_BUFFER_SIZE, size_type) \
\
F(cl_image_info, CL_IMAGE_ARRAY_SIZE, size_type) \
F(cl_image_info, CL_IMAGE_NUM_MIP_LEVELS, cl_uint) \
F(cl_image_info, CL_IMAGE_NUM_SAMPLES, cl_uint)
#define CL_HPP_PARAM_NAME_INFO_2_0_(F) \
F(cl_device_info, CL_DEVICE_QUEUE_ON_HOST_PROPERTIES, cl_command_queue_properties) \
F(cl_device_info, CL_DEVICE_QUEUE_ON_DEVICE_PROPERTIES, cl_command_queue_properties) \
F(cl_device_info, CL_DEVICE_QUEUE_ON_DEVICE_PREFERRED_SIZE, cl_uint) \
F(cl_device_info, CL_DEVICE_QUEUE_ON_DEVICE_MAX_SIZE, cl_uint) \
F(cl_device_info, CL_DEVICE_MAX_ON_DEVICE_QUEUES, cl_uint) \
F(cl_device_info, CL_DEVICE_MAX_ON_DEVICE_EVENTS, cl_uint) \
F(cl_device_info, CL_DEVICE_MAX_PIPE_ARGS, cl_uint) \
F(cl_device_info, CL_DEVICE_PIPE_MAX_ACTIVE_RESERVATIONS, cl_uint) \
F(cl_device_info, CL_DEVICE_PIPE_MAX_PACKET_SIZE, cl_uint) \
F(cl_device_info, CL_DEVICE_SVM_CAPABILITIES, cl_device_svm_capabilities) \
F(cl_device_info, CL_DEVICE_PREFERRED_PLATFORM_ATOMIC_ALIGNMENT, cl_uint) \
F(cl_device_info, CL_DEVICE_PREFERRED_GLOBAL_ATOMIC_ALIGNMENT, cl_uint) \
F(cl_device_info, CL_DEVICE_PREFERRED_LOCAL_ATOMIC_ALIGNMENT, cl_uint) \
F(cl_device_info, CL_DEVICE_IMAGE_PITCH_ALIGNMENT, cl_uint) \
F(cl_device_info, CL_DEVICE_IMAGE_BASE_ADDRESS_ALIGNMENT, cl_uint) \
F(cl_device_info, CL_DEVICE_MAX_READ_WRITE_IMAGE_ARGS, cl_uint) \
F(cl_device_info, CL_DEVICE_MAX_GLOBAL_VARIABLE_SIZE, size_type) \
F(cl_device_info, CL_DEVICE_GLOBAL_VARIABLE_PREFERRED_TOTAL_SIZE, size_type) \
F(cl_profiling_info, CL_PROFILING_COMMAND_COMPLETE, cl_ulong) \
F(cl_kernel_exec_info, CL_KERNEL_EXEC_INFO_SVM_FINE_GRAIN_SYSTEM, cl_bool) \
F(cl_kernel_exec_info, CL_KERNEL_EXEC_INFO_SVM_PTRS, void **) \
F(cl_command_queue_info, CL_QUEUE_SIZE, cl_uint) \
F(cl_mem_info, CL_MEM_USES_SVM_POINTER, cl_bool) \
F(cl_program_build_info, CL_PROGRAM_BUILD_GLOBAL_VARIABLE_TOTAL_SIZE, size_type) \
F(cl_pipe_info, CL_PIPE_PACKET_SIZE, cl_uint) \
F(cl_pipe_info, CL_PIPE_MAX_PACKETS, cl_uint)
#define CL_HPP_PARAM_NAME_INFO_SUBGROUP_KHR_(F) \
F(cl_kernel_sub_group_info, CL_KERNEL_MAX_SUB_GROUP_SIZE_FOR_NDRANGE_KHR, size_type) \
F(cl_kernel_sub_group_info, CL_KERNEL_SUB_GROUP_COUNT_FOR_NDRANGE_KHR, size_type)
#define CL_HPP_PARAM_NAME_INFO_IL_KHR_(F) \
F(cl_device_info, CL_DEVICE_IL_VERSION_KHR, string) \
F(cl_program_info, CL_PROGRAM_IL_KHR, cl::vector<unsigned char>)
#define CL_HPP_PARAM_NAME_INFO_2_1_(F) \
F(cl_platform_info, CL_PLATFORM_HOST_TIMER_RESOLUTION, cl_ulong) \
F(cl_program_info, CL_PROGRAM_IL, cl::vector<unsigned char>) \
F(cl_device_info, CL_DEVICE_MAX_NUM_SUB_GROUPS, cl_uint) \
F(cl_device_info, CL_DEVICE_IL_VERSION, string) \
F(cl_device_info, CL_DEVICE_SUB_GROUP_INDEPENDENT_FORWARD_PROGRESS, cl_bool) \
F(cl_command_queue_info, CL_QUEUE_DEVICE_DEFAULT, cl::DeviceCommandQueue) \
F(cl_kernel_sub_group_info, CL_KERNEL_MAX_SUB_GROUP_SIZE_FOR_NDRANGE, size_type) \
F(cl_kernel_sub_group_info, CL_KERNEL_SUB_GROUP_COUNT_FOR_NDRANGE, size_type) \
F(cl_kernel_sub_group_info, CL_KERNEL_LOCAL_SIZE_FOR_SUB_GROUP_COUNT, cl::detail::size_t_array) \
F(cl_kernel_sub_group_info, CL_KERNEL_MAX_NUM_SUB_GROUPS, size_type) \
F(cl_kernel_sub_group_info, CL_KERNEL_COMPILE_NUM_SUB_GROUPS, size_type)
#define CL_HPP_PARAM_NAME_INFO_2_2_(F) \
F(cl_program_info, CL_PROGRAM_SCOPE_GLOBAL_CTORS_PRESENT, cl_bool) \
F(cl_program_info, CL_PROGRAM_SCOPE_GLOBAL_DTORS_PRESENT, cl_bool)
#define CL_HPP_PARAM_NAME_DEVICE_FISSION_(F) \
F(cl_device_info, CL_DEVICE_PARENT_DEVICE_EXT, cl_device_id) \
F(cl_device_info, CL_DEVICE_PARTITION_TYPES_EXT, cl::vector<cl_device_partition_property_ext>) \
F(cl_device_info, CL_DEVICE_AFFINITY_DOMAINS_EXT, cl::vector<cl_device_partition_property_ext>) \
F(cl_device_info, CL_DEVICE_REFERENCE_COUNT_EXT, cl_uint) \
F(cl_device_info, CL_DEVICE_PARTITION_STYLE_EXT, cl::vector<cl_device_partition_property_ext>)
#define CL_HPP_PARAM_NAME_CL_KHR_EXTENDED_VERSIONING_CL3_SHARED_(F) \
F(cl_platform_info, CL_PLATFORM_NUMERIC_VERSION_KHR, cl_version_khr) \
F(cl_platform_info, CL_PLATFORM_EXTENSIONS_WITH_VERSION_KHR, cl::vector<cl_name_version_khr>) \
\
F(cl_device_info, CL_DEVICE_NUMERIC_VERSION_KHR, cl_version_khr) \
F(cl_device_info, CL_DEVICE_EXTENSIONS_WITH_VERSION_KHR, cl::vector<cl_name_version_khr>) \
F(cl_device_info, CL_DEVICE_ILS_WITH_VERSION_KHR, cl::vector<cl_name_version_khr>) \
F(cl_device_info, CL_DEVICE_BUILT_IN_KERNELS_WITH_VERSION_KHR, cl::vector<cl_name_version_khr>)
#define CL_HPP_PARAM_NAME_CL_KHR_EXTENDED_VERSIONING_KHRONLY_(F) \
F(cl_device_info, CL_DEVICE_OPENCL_C_NUMERIC_VERSION_KHR, cl_version_khr)
#define CL_HPP_PARAM_NAME_INFO_3_0_(F) \
F(cl_platform_info, CL_PLATFORM_NUMERIC_VERSION, cl_version) \
F(cl_platform_info, CL_PLATFORM_EXTENSIONS_WITH_VERSION, cl::vector<cl_name_version>) \
\
F(cl_device_info, CL_DEVICE_NUMERIC_VERSION, cl_version) \
F(cl_device_info, CL_DEVICE_EXTENSIONS_WITH_VERSION, cl::vector<cl_name_version>) \
F(cl_device_info, CL_DEVICE_ILS_WITH_VERSION, cl::vector<cl_name_version>) \
F(cl_device_info, CL_DEVICE_BUILT_IN_KERNELS_WITH_VERSION, cl::vector<cl_name_version>) \
F(cl_device_info, CL_DEVICE_ATOMIC_MEMORY_CAPABILITIES, cl_device_atomic_capabilities) \
F(cl_device_info, CL_DEVICE_ATOMIC_FENCE_CAPABILITIES, cl_device_atomic_capabilities) \
F(cl_device_info, CL_DEVICE_NON_UNIFORM_WORK_GROUP_SUPPORT, cl_bool) \
F(cl_device_info, CL_DEVICE_OPENCL_C_ALL_VERSIONS, cl::vector<cl_name_version>) \
F(cl_device_info, CL_DEVICE_PREFERRED_WORK_GROUP_SIZE_MULTIPLE, size_type) \
F(cl_device_info, CL_DEVICE_WORK_GROUP_COLLECTIVE_FUNCTIONS_SUPPORT, cl_bool) \
F(cl_device_info, CL_DEVICE_GENERIC_ADDRESS_SPACE_SUPPORT, cl_bool) \
F(cl_device_info, CL_DEVICE_OPENCL_C_FEATURES, cl::vector<cl_name_version>) \
F(cl_device_info, CL_DEVICE_DEVICE_ENQUEUE_CAPABILITIES, cl_device_device_enqueue_capabilities) \
F(cl_device_info, CL_DEVICE_PIPE_SUPPORT, cl_bool) \
F(cl_device_info, CL_DEVICE_LATEST_CONFORMANCE_VERSION_PASSED, string) \
\
F(cl_command_queue_info, CL_QUEUE_PROPERTIES_ARRAY, cl::vector<cl_queue_properties>) \
F(cl_mem_info, CL_MEM_PROPERTIES, cl::vector<cl_mem_properties>) \
F(cl_pipe_info, CL_PIPE_PROPERTIES, cl::vector<cl_pipe_properties>) \
F(cl_sampler_info, CL_SAMPLER_PROPERTIES, cl::vector<cl_sampler_properties>)
template <typename enum_type, cl_int Name>
struct param_traits
{
};
#define CL_HPP_DECLARE_PARAM_TRAITS_(token, param_name, T) \
struct token; \
template <> \
struct param_traits<detail::token, param_name> \
{ \
enum \
{ \
value = param_name \
}; \
typedef T param_type; \
};
CL_HPP_PARAM_NAME_INFO_1_0_(CL_HPP_DECLARE_PARAM_TRAITS_)
#if CL_HPP_TARGET_OPENCL_VERSION >= 110
CL_HPP_PARAM_NAME_INFO_1_1_(CL_HPP_DECLARE_PARAM_TRAITS_)
#endif // CL_HPP_TARGET_OPENCL_VERSION >= 110
#if CL_HPP_TARGET_OPENCL_VERSION >= 120
CL_HPP_PARAM_NAME_INFO_1_2_(CL_HPP_DECLARE_PARAM_TRAITS_)
#endif // CL_HPP_TARGET_OPENCL_VERSION >= 120
#if CL_HPP_TARGET_OPENCL_VERSION >= 200
CL_HPP_PARAM_NAME_INFO_2_0_(CL_HPP_DECLARE_PARAM_TRAITS_)
#endif // CL_HPP_TARGET_OPENCL_VERSION >= 200
#if CL_HPP_TARGET_OPENCL_VERSION >= 210
CL_HPP_PARAM_NAME_INFO_2_1_(CL_HPP_DECLARE_PARAM_TRAITS_)
#endif // CL_HPP_TARGET_OPENCL_VERSION >= 210
#if CL_HPP_TARGET_OPENCL_VERSION >= 220
CL_HPP_PARAM_NAME_INFO_2_2_(CL_HPP_DECLARE_PARAM_TRAITS_)
#endif // CL_HPP_TARGET_OPENCL_VERSION >= 220
#if CL_HPP_TARGET_OPENCL_VERSION >= 300
CL_HPP_PARAM_NAME_INFO_3_0_(CL_HPP_DECLARE_PARAM_TRAITS_)
#endif // CL_HPP_TARGET_OPENCL_VERSION >= 300
#if defined(CL_HPP_USE_CL_SUB_GROUPS_KHR) && CL_HPP_TARGET_OPENCL_VERSION < 210
CL_HPP_PARAM_NAME_INFO_SUBGROUP_KHR_(CL_HPP_DECLARE_PARAM_TRAITS_)
#endif // #if defined(CL_HPP_USE_CL_SUB_GROUPS_KHR) && CL_HPP_TARGET_OPENCL_VERSION < 210
#if defined(CL_HPP_USE_IL_KHR) && CL_HPP_TARGET_OPENCL_VERSION < 210
CL_HPP_PARAM_NAME_INFO_IL_KHR_(CL_HPP_DECLARE_PARAM_TRAITS_)
#endif // #if defined(CL_HPP_USE_IL_KHR)
// Flags deprecated in OpenCL 2.0
#define CL_HPP_PARAM_NAME_INFO_1_0_DEPRECATED_IN_2_0_(F) \
F(cl_device_info, CL_DEVICE_QUEUE_PROPERTIES, cl_command_queue_properties)
#define CL_HPP_PARAM_NAME_INFO_1_1_DEPRECATED_IN_2_0_(F) F(cl_device_info, CL_DEVICE_HOST_UNIFIED_MEMORY, cl_bool)
#define CL_HPP_PARAM_NAME_INFO_1_2_DEPRECATED_IN_2_0_(F) F(cl_image_info, CL_IMAGE_BUFFER, cl::Buffer)
// Include deprecated query flags based on versions
// Only include deprecated 1.0 flags if 2.0 not active as there is an enum clash
#if CL_HPP_TARGET_OPENCL_VERSION > 100 && CL_HPP_MINIMUM_OPENCL_VERSION < 200 && CL_HPP_TARGET_OPENCL_VERSION < 200
CL_HPP_PARAM_NAME_INFO_1_0_DEPRECATED_IN_2_0_(CL_HPP_DECLARE_PARAM_TRAITS_)
#endif // CL_HPP_MINIMUM_OPENCL_VERSION < 110
#if CL_HPP_TARGET_OPENCL_VERSION > 110 && CL_HPP_MINIMUM_OPENCL_VERSION < 200
CL_HPP_PARAM_NAME_INFO_1_1_DEPRECATED_IN_2_0_(CL_HPP_DECLARE_PARAM_TRAITS_)
#endif // CL_HPP_MINIMUM_OPENCL_VERSION < 120
#if CL_HPP_TARGET_OPENCL_VERSION > 120 && CL_HPP_MINIMUM_OPENCL_VERSION < 200
CL_HPP_PARAM_NAME_INFO_1_2_DEPRECATED_IN_2_0_(CL_HPP_DECLARE_PARAM_TRAITS_)
#endif // CL_HPP_MINIMUM_OPENCL_VERSION < 200
#if defined(CL_HPP_USE_CL_DEVICE_FISSION)
CL_HPP_PARAM_NAME_DEVICE_FISSION_(CL_HPP_DECLARE_PARAM_TRAITS_);
#endif // CL_HPP_USE_CL_DEVICE_FISSION
#if defined(cl_khr_extended_versioning)
#if CL_HPP_TARGET_OPENCL_VERSION < 300
CL_HPP_PARAM_NAME_CL_KHR_EXTENDED_VERSIONING_CL3_SHARED_(CL_HPP_DECLARE_PARAM_TRAITS_)
#endif // CL_HPP_TARGET_OPENCL_VERSION < 300
CL_HPP_PARAM_NAME_CL_KHR_EXTENDED_VERSIONING_KHRONLY_(CL_HPP_DECLARE_PARAM_TRAITS_)
#endif // cl_khr_extended_versioning
#if defined(cl_khr_device_uuid)
using uuid_array = array<cl_uchar, CL_UUID_SIZE_KHR>;
using luid_array = array<cl_uchar, CL_LUID_SIZE_KHR>;
CL_HPP_DECLARE_PARAM_TRAITS_(cl_device_info, CL_DEVICE_UUID_KHR, uuid_array)
CL_HPP_DECLARE_PARAM_TRAITS_(cl_device_info, CL_DRIVER_UUID_KHR, uuid_array)
CL_HPP_DECLARE_PARAM_TRAITS_(cl_device_info, CL_DEVICE_LUID_VALID_KHR, cl_bool)
CL_HPP_DECLARE_PARAM_TRAITS_(cl_device_info, CL_DEVICE_LUID_KHR, luid_array)
CL_HPP_DECLARE_PARAM_TRAITS_(cl_device_info, CL_DEVICE_NODE_MASK_KHR, cl_uint)
#endif
#if defined(cl_khr_pci_bus_info)
CL_HPP_DECLARE_PARAM_TRAITS_(cl_device_info, CL_DEVICE_PCI_BUS_INFO_KHR, cl_device_pci_bus_info_khr)
#endif
#if defined(cl_khr_integer_dot_product)
CL_HPP_DECLARE_PARAM_TRAITS_(cl_device_info, CL_DEVICE_INTEGER_DOT_PRODUCT_CAPABILITIES_KHR,
cl_device_integer_dot_product_capabilities_khr)
#if defined(CL_DEVICE_INTEGER_DOT_PRODUCT_ACCELERATION_PROPERTIES_8BIT_KHR)
CL_HPP_DECLARE_PARAM_TRAITS_(cl_device_info, CL_DEVICE_INTEGER_DOT_PRODUCT_ACCELERATION_PROPERTIES_8BIT_KHR,
cl_device_integer_dot_product_acceleration_properties_khr)
CL_HPP_DECLARE_PARAM_TRAITS_(cl_device_info, CL_DEVICE_INTEGER_DOT_PRODUCT_ACCELERATION_PROPERTIES_4x8BIT_PACKED_KHR,
cl_device_integer_dot_product_acceleration_properties_khr)
#endif // defined(CL_DEVICE_INTEGER_DOT_PRODUCT_ACCELERATION_PROPERTIES_8BIT_KHR)
#endif // defined(cl_khr_integer_dot_product)
#ifdef CL_PLATFORM_ICD_SUFFIX_KHR
CL_HPP_DECLARE_PARAM_TRAITS_(cl_platform_info, CL_PLATFORM_ICD_SUFFIX_KHR, string)
#endif
#ifdef CL_DEVICE_PROFILING_TIMER_OFFSET_AMD
CL_HPP_DECLARE_PARAM_TRAITS_(cl_device_info, CL_DEVICE_PROFILING_TIMER_OFFSET_AMD, cl_ulong)
#endif
#ifdef CL_DEVICE_GLOBAL_FREE_MEMORY_AMD
CL_HPP_DECLARE_PARAM_TRAITS_(cl_device_info, CL_DEVICE_GLOBAL_FREE_MEMORY_AMD, vector<size_type>)
#endif
#ifdef CL_DEVICE_SIMD_PER_COMPUTE_UNIT_AMD
CL_HPP_DECLARE_PARAM_TRAITS_(cl_device_info, CL_DEVICE_SIMD_PER_COMPUTE_UNIT_AMD, cl_uint)
#endif
#ifdef CL_DEVICE_SIMD_WIDTH_AMD
CL_HPP_DECLARE_PARAM_TRAITS_(cl_device_info, CL_DEVICE_SIMD_WIDTH_AMD, cl_uint)
#endif
#ifdef CL_DEVICE_SIMD_INSTRUCTION_WIDTH_AMD
CL_HPP_DECLARE_PARAM_TRAITS_(cl_device_info, CL_DEVICE_SIMD_INSTRUCTION_WIDTH_AMD, cl_uint)
#endif
#ifdef CL_DEVICE_WAVEFRONT_WIDTH_AMD
CL_HPP_DECLARE_PARAM_TRAITS_(cl_device_info, CL_DEVICE_WAVEFRONT_WIDTH_AMD, cl_uint)
#endif
#ifdef CL_DEVICE_GLOBAL_MEM_CHANNELS_AMD
CL_HPP_DECLARE_PARAM_TRAITS_(cl_device_info, CL_DEVICE_GLOBAL_MEM_CHANNELS_AMD, cl_uint)
#endif
#ifdef CL_DEVICE_GLOBAL_MEM_CHANNEL_BANKS_AMD
CL_HPP_DECLARE_PARAM_TRAITS_(cl_device_info, CL_DEVICE_GLOBAL_MEM_CHANNEL_BANKS_AMD, cl_uint)
#endif
#ifdef CL_DEVICE_GLOBAL_MEM_CHANNEL_BANK_WIDTH_AMD
CL_HPP_DECLARE_PARAM_TRAITS_(cl_device_info, CL_DEVICE_GLOBAL_MEM_CHANNEL_BANK_WIDTH_AMD, cl_uint)
#endif
#ifdef CL_DEVICE_LOCAL_MEM_SIZE_PER_COMPUTE_UNIT_AMD
CL_HPP_DECLARE_PARAM_TRAITS_(cl_device_info, CL_DEVICE_LOCAL_MEM_SIZE_PER_COMPUTE_UNIT_AMD, cl_uint)
#endif
#ifdef CL_DEVICE_LOCAL_MEM_BANKS_AMD
CL_HPP_DECLARE_PARAM_TRAITS_(cl_device_info, CL_DEVICE_LOCAL_MEM_BANKS_AMD, cl_uint)
#endif
#ifdef CL_DEVICE_BOARD_NAME_AMD
CL_HPP_DECLARE_PARAM_TRAITS_(cl_device_info, CL_DEVICE_BOARD_NAME_AMD, string)
#endif
#ifdef CL_DEVICE_COMPUTE_UNITS_BITFIELD_ARM
CL_HPP_DECLARE_PARAM_TRAITS_(cl_device_info, CL_DEVICE_COMPUTE_UNITS_BITFIELD_ARM, cl_ulong)
#endif
#ifdef CL_DEVICE_JOB_SLOTS_ARM
CL_HPP_DECLARE_PARAM_TRAITS_(cl_device_info, CL_DEVICE_JOB_SLOTS_ARM, cl_uint)
#endif
#ifdef CL_DEVICE_SCHEDULING_CONTROLS_CAPABILITIES_ARM
CL_HPP_DECLARE_PARAM_TRAITS_(cl_device_info, CL_DEVICE_SCHEDULING_CONTROLS_CAPABILITIES_ARM, cl_bitfield)
#endif
#ifdef CL_DEVICE_SUPPORTED_REGISTER_ALLOCATIONS_ARM
CL_HPP_DECLARE_PARAM_TRAITS_(cl_device_info, CL_DEVICE_SUPPORTED_REGISTER_ALLOCATIONS_ARM, vector<cl_uint>)
#endif
#ifdef CL_KERNEL_EXEC_INFO_WORKGROUP_BATCH_SIZE_ARM
CL_HPP_DECLARE_PARAM_TRAITS_(cl_kernel_exec_info, CL_KERNEL_EXEC_INFO_WORKGROUP_BATCH_SIZE_ARM, cl_uint)
#endif
#ifdef CL_KERNEL_EXEC_INFO_WORKGROUP_BATCH_SIZE_MODIFIER_ARM
CL_HPP_DECLARE_PARAM_TRAITS_(cl_kernel_exec_info, CL_KERNEL_EXEC_INFO_WORKGROUP_BATCH_SIZE_MODIFIER_ARM, cl_int)
#endif
#ifdef CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV
CL_HPP_DECLARE_PARAM_TRAITS_(cl_device_info, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, cl_uint)
#endif
#ifdef CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV
CL_HPP_DECLARE_PARAM_TRAITS_(cl_device_info, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, cl_uint)
#endif
#ifdef CL_DEVICE_REGISTERS_PER_BLOCK_NV
CL_HPP_DECLARE_PARAM_TRAITS_(cl_device_info, CL_DEVICE_REGISTERS_PER_BLOCK_NV, cl_uint)
#endif
#ifdef CL_DEVICE_WARP_SIZE_NV
CL_HPP_DECLARE_PARAM_TRAITS_(cl_device_info, CL_DEVICE_WARP_SIZE_NV, cl_uint)
#endif
#ifdef CL_DEVICE_GPU_OVERLAP_NV
CL_HPP_DECLARE_PARAM_TRAITS_(cl_device_info, CL_DEVICE_GPU_OVERLAP_NV, cl_bool)
#endif
#ifdef CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV
CL_HPP_DECLARE_PARAM_TRAITS_(cl_device_info, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, cl_bool)
#endif
#ifdef CL_DEVICE_INTEGRATED_MEMORY_NV
CL_HPP_DECLARE_PARAM_TRAITS_(cl_device_info, CL_DEVICE_INTEGRATED_MEMORY_NV, cl_bool)
#endif
// Convenience functions
template <typename Func, typename T>
inline cl_int getInfo(Func f, cl_uint name, T *param)
{
return getInfoHelper(f, name, param, 0);
}
template <typename Func, typename Arg0>
struct GetInfoFunctor0
{
Func f_;
const Arg0 &arg0_;
cl_int operator()(cl_uint param, size_type size, void *value, size_type *size_ret)
{
return f_(arg0_, param, size, value, size_ret);
}
};
template <typename Func, typename Arg0, typename Arg1>
struct GetInfoFunctor1
{
Func f_;
const Arg0 &arg0_;
const Arg1 &arg1_;
cl_int operator()(cl_uint param, size_type size, void *value, size_type *size_ret)
{
return f_(arg0_, arg1_, param, size, value, size_ret);
}
};
template <typename Func, typename Arg0, typename T>
inline cl_int getInfo(Func f, const Arg0 &arg0, cl_uint name, T *param)
{
GetInfoFunctor0<Func, Arg0> f0 = { f, arg0 };
return getInfoHelper(f0, name, param, 0);
}
template <typename Func, typename Arg0, typename Arg1, typename T>
inline cl_int getInfo(Func f, const Arg0 &arg0, const Arg1 &arg1, cl_uint name, T *param)
{
GetInfoFunctor1<Func, Arg0, Arg1> f0 = { f, arg0, arg1 };
return getInfoHelper(f0, name, param, 0);
}
template <typename T>
struct ReferenceHandler
{
};
#if CL_HPP_TARGET_OPENCL_VERSION >= 120
/**
* OpenCL 1.2 devices do have retain/release.
*/
template <>
struct ReferenceHandler<cl_device_id>
{
/**
* Retain the device.
* \param device A valid device created using createSubDevices
* \return
* CL_SUCCESS if the function executed successfully.
* CL_INVALID_DEVICE if device was not a valid subdevice
* CL_OUT_OF_RESOURCES
* CL_OUT_OF_HOST_MEMORY
*/
static cl_int retain(cl_device_id device) { return ::clRetainDevice(device); }
/**
* Retain the device.
* \param device A valid device created using createSubDevices
* \return
* CL_SUCCESS if the function executed successfully.
* CL_INVALID_DEVICE if device was not a valid subdevice
* CL_OUT_OF_RESOURCES
* CL_OUT_OF_HOST_MEMORY
*/
static cl_int release(cl_device_id device) { return ::clReleaseDevice(device); }
};
#else // CL_HPP_TARGET_OPENCL_VERSION >= 120
/**
* OpenCL 1.1 devices do not have retain/release.
*/
template <>
struct ReferenceHandler<cl_device_id>
{
// cl_device_id does not have retain().
static cl_int retain(cl_device_id) { return CL_SUCCESS; }
// cl_device_id does not have release().
static cl_int release(cl_device_id) { return CL_SUCCESS; }
};
#endif // ! (CL_HPP_TARGET_OPENCL_VERSION >= 120)
template <>
struct ReferenceHandler<cl_platform_id>
{
// cl_platform_id does not have retain().
static cl_int retain(cl_platform_id) { return CL_SUCCESS; }
// cl_platform_id does not have release().
static cl_int release(cl_platform_id) { return CL_SUCCESS; }
};
template <>
struct ReferenceHandler<cl_context>
{
static cl_int retain(cl_context context) { return ::clRetainContext(context); }
static cl_int release(cl_context context) { return ::clReleaseContext(context); }
};
template <>
struct ReferenceHandler<cl_command_queue>
{
static cl_int retain(cl_command_queue queue) { return ::clRetainCommandQueue(queue); }
static cl_int release(cl_command_queue queue) { return ::clReleaseCommandQueue(queue); }
};
template <>
struct ReferenceHandler<cl_mem>
{
static cl_int retain(cl_mem memory) { return ::clRetainMemObject(memory); }
static cl_int release(cl_mem memory) { return ::clReleaseMemObject(memory); }
};
template <>
struct ReferenceHandler<cl_sampler>
{
static cl_int retain(cl_sampler sampler) { return ::clRetainSampler(sampler); }
static cl_int release(cl_sampler sampler) { return ::clReleaseSampler(sampler); }
};
template <>
struct ReferenceHandler<cl_program>
{
static cl_int retain(cl_program program) { return ::clRetainProgram(program); }
static cl_int release(cl_program program) { return ::clReleaseProgram(program); }
};
template <>
struct ReferenceHandler<cl_kernel>
{
static cl_int retain(cl_kernel kernel) { return ::clRetainKernel(kernel); }
static cl_int release(cl_kernel kernel) { return ::clReleaseKernel(kernel); }
};
template <>
struct ReferenceHandler<cl_event>
{
static cl_int retain(cl_event event) { return ::clRetainEvent(event); }
static cl_int release(cl_event event) { return ::clReleaseEvent(event); }
};
#if CL_HPP_TARGET_OPENCL_VERSION >= 120 && CL_HPP_MINIMUM_OPENCL_VERSION < 200
// Extracts version number with major in the upper 16 bits, minor in the lower 16
static cl_uint getVersion(const vector<char> &versionInfo)
{
int highVersion = 0;
int lowVersion = 0;
int index = 7;
while (versionInfo[index] != '.')
{
highVersion *= 10;
highVersion += versionInfo[index] - '0';
++index;
}
++index;
while (versionInfo[index] != ' ' && versionInfo[index] != '\0')
{
lowVersion *= 10;
lowVersion += versionInfo[index] - '0';
++index;
}
return (highVersion << 16) | lowVersion;
}
static cl_uint getPlatformVersion(cl_platform_id platform)
{
size_type size = 0;
clGetPlatformInfo(platform, CL_PLATFORM_VERSION, 0, NULL, &size);
vector<char> versionInfo(size);
clGetPlatformInfo(platform, CL_PLATFORM_VERSION, size, versionInfo.data(), &size);
return getVersion(versionInfo);
}
static cl_uint getDevicePlatformVersion(cl_device_id device)
{
cl_platform_id platform;
clGetDeviceInfo(device, CL_DEVICE_PLATFORM, sizeof(platform), &platform, NULL);
return getPlatformVersion(platform);
}
static cl_uint getContextPlatformVersion(cl_context context)
{
// The platform cannot be queried directly, so we first have to grab a
// device and obtain its context
size_type size = 0;
clGetContextInfo(context, CL_CONTEXT_DEVICES, 0, NULL, &size);
if (size == 0)
return 0;
vector<cl_device_id> devices(size / sizeof(cl_device_id));
clGetContextInfo(context, CL_CONTEXT_DEVICES, size, devices.data(), NULL);
return getDevicePlatformVersion(devices[0]);
}
#endif // CL_HPP_TARGET_OPENCL_VERSION >= 120 && CL_HPP_MINIMUM_OPENCL_VERSION < 200
template <typename T>
class Wrapper
{
public:
typedef T cl_type;
protected:
cl_type object_;
public:
Wrapper()
: object_(NULL)
{}
Wrapper(const cl_type &obj, bool retainObject)
: object_(obj)
{
if (retainObject)
{
detail::errHandler(retain(), __RETAIN_ERR);
}
}
~Wrapper()
{
if (object_ != NULL)
{
release();
}
}
Wrapper(const Wrapper<cl_type> &rhs)
{
object_ = rhs.object_;
detail::errHandler(retain(), __RETAIN_ERR);
}
Wrapper(Wrapper<cl_type> &&rhs) CL_HPP_NOEXCEPT_
{
object_ = rhs.object_;
rhs.object_ = NULL;
}
Wrapper<cl_type> &operator=(const Wrapper<cl_type> &rhs)
{
if (this != &rhs)
{
detail::errHandler(release(), __RELEASE_ERR);
object_ = rhs.object_;
detail::errHandler(retain(), __RETAIN_ERR);
}
return *this;
}
Wrapper<cl_type> &operator=(Wrapper<cl_type> &&rhs)
{
if (this != &rhs)
{
detail::errHandler(release(), __RELEASE_ERR);
object_ = rhs.object_;
rhs.object_ = NULL;
}
return *this;
}
Wrapper<cl_type> &operator=(const cl_type &rhs)
{
detail::errHandler(release(), __RELEASE_ERR);
object_ = rhs;
return *this;
}
const cl_type &operator()() const { return object_; }
cl_type &operator()() { return object_; }
cl_type get() const { return object_; }
protected:
template <typename Func, typename U>
friend inline cl_int getInfoHelper(Func, cl_uint, U *, int, typename U::cl_type);
cl_int retain() const
{
if (object_ != nullptr)
{
return ReferenceHandler<cl_type>::retain(object_);
}
else
{
return CL_SUCCESS;
}
}
cl_int release() const
{
if (object_ != nullptr)
{
return ReferenceHandler<cl_type>::release(object_);
}
else
{
return CL_SUCCESS;
}
}
};
template <>
class Wrapper<cl_device_id>
{
public:
typedef cl_device_id cl_type;
protected:
cl_type object_;
bool referenceCountable_;
static bool isReferenceCountable(cl_device_id device)
{
bool retVal = false;
#if CL_HPP_TARGET_OPENCL_VERSION >= 120
#if CL_HPP_MINIMUM_OPENCL_VERSION < 120
if (device != NULL)
{
int version = getDevicePlatformVersion(device);
if (version > ((1 << 16) + 1))
{
retVal = true;
}
}
#else // CL_HPP_MINIMUM_OPENCL_VERSION < 120
retVal = true;
#endif // CL_HPP_MINIMUM_OPENCL_VERSION < 120
#endif // CL_HPP_TARGET_OPENCL_VERSION >= 120
return retVal;
}
public:
Wrapper()
: object_(NULL)
, referenceCountable_(false)
{}
Wrapper(const cl_type &obj, bool retainObject)
: object_(obj)
, referenceCountable_(false)
{
referenceCountable_ = isReferenceCountable(obj);
if (retainObject)
{
detail::errHandler(retain(), __RETAIN_ERR);
}
}
~Wrapper() { release(); }
Wrapper(const Wrapper<cl_type> &rhs)
{
object_ = rhs.object_;
referenceCountable_ = isReferenceCountable(object_);
detail::errHandler(retain(), __RETAIN_ERR);
}
Wrapper(Wrapper<cl_type> &&rhs) CL_HPP_NOEXCEPT_
{
object_ = rhs.object_;
referenceCountable_ = rhs.referenceCountable_;
rhs.object_ = NULL;
rhs.referenceCountable_ = false;
}
Wrapper<cl_type> &operator=(const Wrapper<cl_type> &rhs)
{
if (this != &rhs)
{
detail::errHandler(release(), __RELEASE_ERR);
object_ = rhs.object_;
referenceCountable_ = rhs.referenceCountable_;
detail::errHandler(retain(), __RETAIN_ERR);
}
return *this;
}
Wrapper<cl_type> &operator=(Wrapper<cl_type> &&rhs)
{
if (this != &rhs)
{
detail::errHandler(release(), __RELEASE_ERR);
object_ = rhs.object_;
referenceCountable_ = rhs.referenceCountable_;
rhs.object_ = NULL;
rhs.referenceCountable_ = false;
}
return *this;
}
Wrapper<cl_type> &operator=(const cl_type &rhs)
{
detail::errHandler(release(), __RELEASE_ERR);
object_ = rhs;
referenceCountable_ = isReferenceCountable(object_);
return *this;
}
const cl_type &operator()() const { return object_; }
cl_type &operator()() { return object_; }
cl_type get() const { return object_; }
protected:
template <typename Func, typename U>
friend inline cl_int getInfoHelper(Func, cl_uint, U *, int, typename U::cl_type);
template <typename Func, typename U>
friend inline cl_int getInfoHelper(Func, cl_uint, vector<U> *, int, typename U::cl_type);
cl_int retain() const
{
if (object_ != nullptr && referenceCountable_)
{
return ReferenceHandler<cl_type>::retain(object_);
}
else
{
return CL_SUCCESS;
}
}
cl_int release() const
{
if (object_ != nullptr && referenceCountable_)
{
return ReferenceHandler<cl_type>::release(object_);
}
else
{
return CL_SUCCESS;
}
}
};
template <typename T>
inline bool operator==(const Wrapper<T> &lhs, const Wrapper<T> &rhs)
{
return lhs() == rhs();
}
template <typename T>
inline bool operator!=(const Wrapper<T> &lhs, const Wrapper<T> &rhs)
{
return !operator==(lhs, rhs);
}
} // namespace detail
//! \endcond
using BuildLogType =
vector<std::pair<cl::Device,
typename detail::param_traits<detail::cl_program_build_info, CL_PROGRAM_BUILD_LOG>::param_type>>;
#if defined(CL_HPP_ENABLE_EXCEPTIONS)
/**
* Exception class for build errors to carry build info
*/
class BuildError : public Error
{
private:
BuildLogType buildLogs;
public:
BuildError(cl_int err, const char *errStr, const BuildLogType &vec)
: Error(err, errStr)
, buildLogs(vec)
{}
BuildLogType getBuildLog() const { return buildLogs; }
};
namespace detail
{
static inline cl_int buildErrHandler(cl_int err, const char *errStr, const BuildLogType &buildLogs)
{
if (err != CL_SUCCESS)
{
throw BuildError(err, errStr, buildLogs);
}
return err;
}
} // namespace detail
#else
namespace detail
{
static inline cl_int buildErrHandler(cl_int err, const char *errStr, const BuildLogType &buildLogs)
{
(void)buildLogs; // suppress unused variable warning
(void)errStr;
return err;
}
} // namespace detail
#endif // #if defined(CL_HPP_ENABLE_EXCEPTIONS)
/*! \stuct ImageFormat
* \brief Adds constructors and member functions for cl_image_format.
*
* \see cl_image_format
*/
struct ImageFormat : public cl_image_format
{
//! \brief Default constructor - performs no initialization.
ImageFormat() {}
//! \brief Initializing constructor.
ImageFormat(cl_channel_order order, cl_channel_type type)
{
image_channel_order = order;
image_channel_data_type = type;
}
//! \brief Copy constructor.
ImageFormat(const ImageFormat &other) { *this = other; }
//! \brief Assignment operator.
ImageFormat &operator=(const ImageFormat &rhs)
{
if (this != &rhs)
{
this->image_channel_data_type = rhs.image_channel_data_type;
this->image_channel_order = rhs.image_channel_order;
}
return *this;
}
};
/*! \brief Class interface for cl_device_id.
*
* \note Copies of these objects are inexpensive, since they don't 'own'
* any underlying resources or data structures.
*
* \see cl_device_id
*/
class Device : public detail::Wrapper<cl_device_id>
{
private:
static std::once_flag default_initialized_;
static Device default_;
static cl_int default_error_;
/*! \brief Create the default context.
*
* This sets @c default_ and @c default_error_. It does not throw
* @c cl::Error.
*/
static void makeDefault();
/*! \brief Create the default platform from a provided platform.
*
* This sets @c default_. It does not throw
* @c cl::Error.
*/
static void makeDefaultProvided(const Device &p) { default_ = p; }
public:
#ifdef CL_HPP_UNIT_TEST_ENABLE
/*! \brief Reset the default.
*
* This sets @c default_ to an empty value to support cleanup in
* the unit test framework.
* This function is not thread safe.
*/
static void unitTestClearDefault() { default_ = Device(); }
#endif // #ifdef CL_HPP_UNIT_TEST_ENABLE
//! \brief Default constructor - initializes to NULL.
Device()
: detail::Wrapper<cl_type>()
{}
/*! \brief Constructor from cl_device_id.
*
* This simply copies the device ID value, which is an inexpensive operation.
*/
explicit Device(const cl_device_id &device, bool retainObject = false)
: detail::Wrapper<cl_type>(device, retainObject)
{}
/*! \brief Returns the first device on the default context.
*
* \see Context::getDefault()
*/
static Device getDefault(cl_int *errResult = NULL)
{
std::call_once(default_initialized_, makeDefault);
detail::errHandler(default_error_);
if (errResult != NULL)
{
*errResult = default_error_;
}
return default_;
}
/**
* Modify the default device to be used by
* subsequent operations.
* Will only set the default if no default was previously created.
* @return updated default device.
* Should be compared to the passed value to ensure that it was updated.
*/
static Device setDefault(const Device &default_device)
{
std::call_once(default_initialized_, makeDefaultProvided, std::cref(default_device));
detail::errHandler(default_error_);
return default_;
}
/*! \brief Assignment operator from cl_device_id.
*
* This simply copies the device ID value, which is an inexpensive operation.
*/
Device &operator=(const cl_device_id &rhs)
{
detail::Wrapper<cl_type>::operator=(rhs);
return *this;
}
/*! \brief Copy constructor to forward copy to the superclass correctly.
* Required for MSVC.
*/
Device(const Device &dev)
: detail::Wrapper<cl_type>(dev)
{}
/*! \brief Copy assignment to forward copy to the superclass correctly.
* Required for MSVC.
*/
Device &operator=(const Device &dev)
{
detail::Wrapper<cl_type>::operator=(dev);
return *this;
}
/*! \brief Move constructor to forward move to the superclass correctly.
* Required for MSVC.
*/
Device(Device &&dev) CL_HPP_NOEXCEPT_ : detail::Wrapper<cl_type>(std::move(dev)) {}
/*! \brief Move assignment to forward move to the superclass correctly.
* Required for MSVC.
*/
Device &operator=(Device &&dev)
{
detail::Wrapper<cl_type>::operator=(std::move(dev));
return *this;
}
//! \brief Wrapper for clGetDeviceInfo().
template <typename T>
cl_int getInfo(cl_device_info name, T *param) const
{
return detail::errHandler(detail::getInfo(&::clGetDeviceInfo, object_, name, param), __GET_DEVICE_INFO_ERR);
}
//! \brief Wrapper for clGetDeviceInfo() that returns by value.
template <cl_device_info name>
typename detail::param_traits<detail::cl_device_info, name>::param_type getInfo(cl_int *err = NULL) const
{
typename detail::param_traits<detail::cl_device_info, name>::param_type param;
cl_int result = getInfo(name, ¶m);
if (err != NULL)
{
*err = result;
}
return param;
}
#if CL_HPP_TARGET_OPENCL_VERSION >= 210
/**
* Return the current value of the host clock as seen by the device.
* The resolution of the device timer may be queried with the
* CL_DEVICE_PROFILING_TIMER_RESOLUTION query.
* @return The host timer value.
*/
cl_ulong getHostTimer(cl_int *error = nullptr)
{
cl_ulong retVal = 0;
cl_int err = clGetHostTimer(this->get(), &retVal);
detail::errHandler(err, __GET_HOST_TIMER_ERR);
if (error)
{
*error = err;
}
return retVal;
}
/**
* Return a synchronized pair of host and device timestamps as seen by device.
* Use to correlate the clocks and get the host timer only using getHostTimer
* as a lower cost mechanism in between calls.
* The resolution of the host timer may be queried with the
* CL_PLATFORM_HOST_TIMER_RESOLUTION query.
* The resolution of the device timer may be queried with the
* CL_DEVICE_PROFILING_TIMER_RESOLUTION query.
* @return A pair of (device timer, host timer) timer values.
*/
std::pair<cl_ulong, cl_ulong> getDeviceAndHostTimer(cl_int *error = nullptr)
{
std::pair<cl_ulong, cl_ulong> retVal;
cl_int err = clGetDeviceAndHostTimer(this->get(), &(retVal.first), &(retVal.second));
detail::errHandler(err, __GET_DEVICE_AND_HOST_TIMER_ERR);
if (error)
{
*error = err;
}
return retVal;
}
#endif // #if CL_HPP_TARGET_OPENCL_VERSION >= 210
/**
* CL 1.2 version
*/
#if CL_HPP_TARGET_OPENCL_VERSION >= 120
//! \brief Wrapper for clCreateSubDevices().
cl_int createSubDevices(const cl_device_partition_property *properties, vector<Device> *devices)
{
cl_uint n = 0;
cl_int err = clCreateSubDevices(object_, properties, 0, NULL, &n);
if (err != CL_SUCCESS)
{
return detail::errHandler(err, __CREATE_SUB_DEVICES_ERR);
}
vector<cl_device_id> ids(n);
err = clCreateSubDevices(object_, properties, n, ids.data(), NULL);
if (err != CL_SUCCESS)
{
return detail::errHandler(err, __CREATE_SUB_DEVICES_ERR);
}
// Cannot trivially assign because we need to capture intermediates
// with safe construction
if (devices)
{
devices->resize(ids.size());
// Assign to param, constructing with retain behaviour
// to correctly capture each underlying CL object
for (size_type i = 0; i < ids.size(); i++)
{
// We do not need to retain because this device is being created
// by the runtime
(*devices)[i] = Device(ids[i], false);
}
}
return CL_SUCCESS;
}
#elif defined(CL_HPP_USE_CL_DEVICE_FISSION)
/**
* CL 1.1 version that uses device fission extension.
*/
cl_int createSubDevices(const cl_device_partition_property_ext *properties, vector<Device> *devices)
{
typedef CL_API_ENTRY cl_int(CL_API_CALL * PFN_clCreateSubDevicesEXT)(
cl_device_id /*in_device*/, const cl_device_partition_property_ext * /* properties */, cl_uint /*num_entries*/,
cl_device_id * /*out_devices*/, cl_uint * /*num_devices*/) CL_API_SUFFIX__VERSION_1_1;
static PFN_clCreateSubDevicesEXT pfn_clCreateSubDevicesEXT = NULL;
CL_HPP_INIT_CL_EXT_FCN_PTR_(clCreateSubDevicesEXT);
cl_uint n = 0;
cl_int err = pfn_clCreateSubDevicesEXT(object_, properties, 0, NULL, &n);
if (err != CL_SUCCESS)
{
return detail::errHandler(err, __CREATE_SUB_DEVICES_ERR);
}
vector<cl_device_id> ids(n);
err = pfn_clCreateSubDevicesEXT(object_, properties, n, ids.data(), NULL);
if (err != CL_SUCCESS)
{
return detail::errHandler(err, __CREATE_SUB_DEVICES_ERR);
}
// Cannot trivially assign because we need to capture intermediates
// with safe construction
if (devices)
{
devices->resize(ids.size());
// Assign to param, constructing with retain behaviour
// to correctly capture each underlying CL object
for (size_type i = 0; i < ids.size(); i++)
{
// We do not need to retain because this device is being created
// by the runtime
(*devices)[i] = Device(ids[i], false);
}
}
return CL_SUCCESS;
}
#endif // defined(CL_HPP_USE_CL_DEVICE_FISSION)
};
CL_HPP_DEFINE_STATIC_MEMBER_ std::once_flag Device::default_initialized_;
CL_HPP_DEFINE_STATIC_MEMBER_ Device Device::default_;
CL_HPP_DEFINE_STATIC_MEMBER_ cl_int Device::default_error_ = CL_SUCCESS;
/*! \brief Class interface for cl_platform_id.
*
* \note Copies of these objects are inexpensive, since they don't 'own'
* any underlying resources or data structures.
*
* \see cl_platform_id
*/
class Platform : public detail::Wrapper<cl_platform_id>
{
private:
static std::once_flag default_initialized_;
static Platform default_;
static cl_int default_error_;
/*! \brief Create the default context.
*
* This sets @c default_ and @c default_error_. It does not throw
* @c cl::Error.
*/
static void makeDefault()
{
/* Throwing an exception from a call_once invocation does not do
* what we wish, so we catch it and save the error.
*/
#if defined(CL_HPP_ENABLE_EXCEPTIONS)
try
#endif
{
// If default wasn't passed ,generate one
// Otherwise set it
cl_uint n = 0;
cl_int err = ::clGetPlatformIDs(0, NULL, &n);
if (err != CL_SUCCESS)
{
default_error_ = err;
return;
}
if (n == 0)
{
default_error_ = CL_INVALID_PLATFORM;
return;
}
vector<cl_platform_id> ids(n);
err = ::clGetPlatformIDs(n, ids.data(), NULL);
if (err != CL_SUCCESS)
{
default_error_ = err;
return;
}
default_ = Platform(ids[0]);
}
#if defined(CL_HPP_ENABLE_EXCEPTIONS)
catch (cl::Error &e)
{
default_error_ = e.err();
}
#endif
}
/*! \brief Create the default platform from a provided platform.
*
* This sets @c default_. It does not throw
* @c cl::Error.
*/
static void makeDefaultProvided(const Platform &p) { default_ = p; }
public:
#ifdef CL_HPP_UNIT_TEST_ENABLE
/*! \brief Reset the default.
*
* This sets @c default_ to an empty value to support cleanup in
* the unit test framework.
* This function is not thread safe.
*/
static void unitTestClearDefault() { default_ = Platform(); }
#endif // #ifdef CL_HPP_UNIT_TEST_ENABLE
//! \brief Default constructor - initializes to NULL.
Platform()
: detail::Wrapper<cl_type>()
{}
/*! \brief Constructor from cl_platform_id.
*
* \param retainObject will cause the constructor to retain its cl object.
* Defaults to false to maintain compatibility with
* earlier versions.
* This simply copies the platform ID value, which is an inexpensive operation.
*/
explicit Platform(const cl_platform_id &platform, bool retainObject = false)
: detail::Wrapper<cl_type>(platform, retainObject)
{}
/*! \brief Assignment operator from cl_platform_id.
*
* This simply copies the platform ID value, which is an inexpensive operation.
*/
Platform &operator=(const cl_platform_id &rhs)
{
detail::Wrapper<cl_type>::operator=(rhs);
return *this;
}
static Platform getDefault(cl_int *errResult = NULL)
{
std::call_once(default_initialized_, makeDefault);
detail::errHandler(default_error_);
if (errResult != NULL)
{
*errResult = default_error_;
}
return default_;
}
/**
* Modify the default platform to be used by
* subsequent operations.
* Will only set the default if no default was previously created.
* @return updated default platform.
* Should be compared to the passed value to ensure that it was updated.
*/
static Platform setDefault(const Platform &default_platform)
{
std::call_once(default_initialized_, makeDefaultProvided, std::cref(default_platform));
detail::errHandler(default_error_);
return default_;
}
//! \brief Wrapper for clGetPlatformInfo().
template <typename T>
cl_int getInfo(cl_platform_info name, T *param) const
{
return detail::errHandler(detail::getInfo(&::clGetPlatformInfo, object_, name, param), __GET_PLATFORM_INFO_ERR);
}
//! \brief Wrapper for clGetPlatformInfo() that returns by value.
template <cl_platform_info name>
typename detail::param_traits<detail::cl_platform_info, name>::param_type getInfo(cl_int *err = NULL) const
{
typename detail::param_traits<detail::cl_platform_info, name>::param_type param;
cl_int result = getInfo(name, ¶m);
if (err != NULL)
{
*err = result;
}
return param;
}
/*! \brief Gets a list of devices for this platform.
*
* Wraps clGetDeviceIDs().
*/
cl_int getDevices(cl_device_type type, vector<Device> *devices) const
{
cl_uint n = 0;
if (devices == NULL)
{
return detail::errHandler(CL_INVALID_ARG_VALUE, __GET_DEVICE_IDS_ERR);
}
cl_int err = ::clGetDeviceIDs(object_, type, 0, NULL, &n);
if (err != CL_SUCCESS && err != CL_DEVICE_NOT_FOUND)
{
return detail::errHandler(err, __GET_DEVICE_IDS_ERR);
}
vector<cl_device_id> ids(n);
if (n > 0)
{
err = ::clGetDeviceIDs(object_, type, n, ids.data(), NULL);
if (err != CL_SUCCESS)
{
return detail::errHandler(err, __GET_DEVICE_IDS_ERR);
}
}
// Cannot trivially assign because we need to capture intermediates
// with safe construction
// We must retain things we obtain from the API to avoid releasing
// API-owned objects.
if (devices)
{
devices->resize(ids.size());
// Assign to param, constructing with retain behaviour
// to correctly capture each underlying CL object
for (size_type i = 0; i < ids.size(); i++)
{
(*devices)[i] = Device(ids[i], true);
}
}
return CL_SUCCESS;
}
#if defined(CL_HPP_USE_DX_INTEROP)
/*! \brief Get the list of available D3D10 devices.
*
* \param d3d_device_source.
*
* \param d3d_object.
*
* \param d3d_device_set.
*
* \param devices returns a vector of OpenCL D3D10 devices found. The cl::Device
* values returned in devices can be used to identify a specific OpenCL
* device. If \a devices argument is NULL, this argument is ignored.
*
* \return One of the following values:
* - CL_SUCCESS if the function is executed successfully.
*
* The application can query specific capabilities of the OpenCL device(s)
* returned by cl::getDevices. This can be used by the application to
* determine which device(s) to use.
*
* \note In the case that exceptions are enabled and a return value
* other than CL_SUCCESS is generated, then cl::Error exception is
* generated.
*/
cl_int getDevices(cl_d3d10_device_source_khr d3d_device_source, void *d3d_object,
cl_d3d10_device_set_khr d3d_device_set, vector<Device> *devices) const
{
typedef CL_API_ENTRY cl_int(CL_API_CALL * PFN_clGetDeviceIDsFromD3D10KHR)(
cl_platform_id platform, cl_d3d10_device_source_khr d3d_device_source, void *d3d_object,
cl_d3d10_device_set_khr d3d_device_set, cl_uint num_entries, cl_device_id *devices, cl_uint *num_devices);
if (devices == NULL)
{
return detail::errHandler(CL_INVALID_ARG_VALUE, __GET_DEVICE_IDS_ERR);
}
static PFN_clGetDeviceIDsFromD3D10KHR pfn_clGetDeviceIDsFromD3D10KHR = NULL;
CL_HPP_INIT_CL_EXT_FCN_PTR_PLATFORM_(object_, clGetDeviceIDsFromD3D10KHR);
cl_uint n = 0;
cl_int err = pfn_clGetDeviceIDsFromD3D10KHR(object_, d3d_device_source, d3d_object, d3d_device_set, 0, NULL, &n);
if (err != CL_SUCCESS)
{
return detail::errHandler(err, __GET_DEVICE_IDS_ERR);
}
vector<cl_device_id> ids(n);
err = pfn_clGetDeviceIDsFromD3D10KHR(object_, d3d_device_source, d3d_object, d3d_device_set, n, ids.data(), NULL);
if (err != CL_SUCCESS)
{
return detail::errHandler(err, __GET_DEVICE_IDS_ERR);
}
// Cannot trivially assign because we need to capture intermediates
// with safe construction
// We must retain things we obtain from the API to avoid releasing
// API-owned objects.
if (devices)
{
devices->resize(ids.size());
// Assign to param, constructing with retain behaviour
// to correctly capture each underlying CL object
for (size_type i = 0; i < ids.size(); i++)
{
(*devices)[i] = Device(ids[i], true);
}
}
return CL_SUCCESS;
}
#endif
/*! \brief Gets a list of available platforms.
*
* Wraps clGetPlatformIDs().
*/
static cl_int get(vector<Platform> *platforms)
{
cl_uint n = 0;
if (platforms == NULL)
{
return detail::errHandler(CL_INVALID_ARG_VALUE, __GET_PLATFORM_IDS_ERR);
}
cl_int err = ::clGetPlatformIDs(0, NULL, &n);
if (err != CL_SUCCESS)
{
return detail::errHandler(err, __GET_PLATFORM_IDS_ERR);
}
vector<cl_platform_id> ids(n);
err = ::clGetPlatformIDs(n, ids.data(), NULL);
if (err != CL_SUCCESS)
{
return detail::errHandler(err, __GET_PLATFORM_IDS_ERR);
}
if (platforms)
{
platforms->resize(ids.size());
// Platforms don't reference count
for (size_type i = 0; i < ids.size(); i++)
{
(*platforms)[i] = Platform(ids[i]);
}
}
return CL_SUCCESS;
}
/*! \brief Gets the first available platform.
*
* Wraps clGetPlatformIDs(), returning the first result.
*/
static cl_int get(Platform *platform)
{
cl_int err;
Platform default_platform = Platform::getDefault(&err);
if (platform)
{
*platform = default_platform;
}
return err;
}
/*! \brief Gets the first available platform, returning it by value.
*
* \return Returns a valid platform if one is available.
* If no platform is available will return a null platform.
* Throws an exception if no platforms are available
* or an error condition occurs.
* Wraps clGetPlatformIDs(), returning the first result.
*/
static Platform get(cl_int *errResult = NULL)
{
cl_int err;
Platform default_platform = Platform::getDefault(&err);
if (errResult)
{
*errResult = err;
}
return default_platform;
}
#if CL_HPP_TARGET_OPENCL_VERSION >= 120
//! \brief Wrapper for clUnloadCompiler().
cl_int unloadCompiler() { return ::clUnloadPlatformCompiler(object_); }
#endif // CL_HPP_TARGET_OPENCL_VERSION >= 120
}; // class Platform
CL_HPP_DEFINE_STATIC_MEMBER_ std::once_flag Platform::default_initialized_;
CL_HPP_DEFINE_STATIC_MEMBER_ Platform Platform::default_;
CL_HPP_DEFINE_STATIC_MEMBER_ cl_int Platform::default_error_ = CL_SUCCESS;
/**
* Deprecated APIs for 1.2
*/
#if defined(CL_USE_DEPRECATED_OPENCL_1_1_APIS)
/**
* Unload the OpenCL compiler.
* \note Deprecated for OpenCL 1.2. Use Platform::unloadCompiler instead.
*/
inline CL_API_PREFIX__VERSION_1_1_DEPRECATED cl_int UnloadCompiler() CL_API_SUFFIX__VERSION_1_1_DEPRECATED;
inline cl_int UnloadCompiler()
{
return ::clUnloadCompiler();
}
#endif // #if defined(CL_USE_DEPRECATED_OPENCL_1_1_APIS)
/*! \brief Class interface for cl_context.
*
* \note Copies of these objects are shallow, meaning that the copy will refer
* to the same underlying cl_context as the original. For details, see
* clRetainContext() and clReleaseContext().
*
* \see cl_context
*/
class Context : public detail::Wrapper<cl_context>
{
private:
static std::once_flag default_initialized_;
static Context default_;
static cl_int default_error_;
/*! \brief Create the default context from the default device type in the default platform.
*
* This sets @c default_ and @c default_error_. It does not throw
* @c cl::Error.
*/
static void makeDefault()
{
/* Throwing an exception from a call_once invocation does not do
* what we wish, so we catch it and save the error.
*/
#if defined(CL_HPP_ENABLE_EXCEPTIONS)
try
#endif
{
#if !defined(__APPLE__) && !defined(__MACOS)
const Platform &p = Platform::getDefault();
cl_platform_id defaultPlatform = p();
cl_context_properties properties[3] = { CL_CONTEXT_PLATFORM, (cl_context_properties)defaultPlatform, 0 };
#else // #if !defined(__APPLE__) && !defined(__MACOS)
cl_context_properties *properties = nullptr;
#endif // #if !defined(__APPLE__) && !defined(__MACOS)
default_ = Context(CL_DEVICE_TYPE_DEFAULT, properties, NULL, NULL, &default_error_);
}
#if defined(CL_HPP_ENABLE_EXCEPTIONS)
catch (cl::Error &e)
{
default_error_ = e.err();
}
#endif
}
/*! \brief Create the default context from a provided Context.
*
* This sets @c default_. It does not throw
* @c cl::Error.
*/
static void makeDefaultProvided(const Context &c) { default_ = c; }
public:
#ifdef CL_HPP_UNIT_TEST_ENABLE
/*! \brief Reset the default.
*
* This sets @c default_ to an empty value to support cleanup in
* the unit test framework.
* This function is not thread safe.
*/
static void unitTestClearDefault() { default_ = Context(); }
#endif // #ifdef CL_HPP_UNIT_TEST_ENABLE
/*! \brief Constructs a context including a list of specified devices.
*
* Wraps clCreateContext().
*/
Context(const vector<Device> &devices, const cl_context_properties *properties = NULL,
void(CL_CALLBACK *notifyFptr)(const char *, const void *, size_type, void *) = NULL, void *data = NULL,
cl_int *err = NULL)
{
cl_int error;
size_type numDevices = devices.size();
vector<cl_device_id> deviceIDs(numDevices);
for (size_type deviceIndex = 0; deviceIndex < numDevices; ++deviceIndex)
{
deviceIDs[deviceIndex] = (devices[deviceIndex])();
}
object_ = ::clCreateContext(properties, (cl_uint)numDevices, deviceIDs.data(), notifyFptr, data, &error);
detail::errHandler(error, __CREATE_CONTEXT_ERR);
if (err != NULL)
{
*err = error;
}
}
/*! \brief Constructs a context including a specific device.
*
* Wraps clCreateContext().
*/
Context(const Device &device, const cl_context_properties *properties = NULL,
void(CL_CALLBACK *notifyFptr)(const char *, const void *, size_type, void *) = NULL, void *data = NULL,
cl_int *err = NULL)
{
cl_int error;
cl_device_id deviceID = device();
object_ = ::clCreateContext(properties, 1, &deviceID, notifyFptr, data, &error);
detail::errHandler(error, __CREATE_CONTEXT_ERR);
if (err != NULL)
{
*err = error;
}
}
/*! \brief Constructs a context including all or a subset of devices of a specified type.
*
* Wraps clCreateContextFromType().
*/
Context(cl_device_type type, const cl_context_properties *properties = NULL,
void(CL_CALLBACK *notifyFptr)(const char *, const void *, size_type, void *) = NULL, void *data = NULL,
cl_int *err = NULL)
{
cl_int error;
#if !defined(__APPLE__) && !defined(__MACOS)
cl_context_properties prop[4] = { CL_CONTEXT_PLATFORM, 0, 0, 0 };
if (properties == NULL)
{
// Get a valid platform ID as we cannot send in a blank one
vector<Platform> platforms;
error = Platform::get(&platforms);
if (error != CL_SUCCESS)
{
detail::errHandler(error, __CREATE_CONTEXT_FROM_TYPE_ERR);
if (err != NULL)
{
*err = error;
}
return;
}
// Check the platforms we found for a device of our specified type
cl_context_properties platform_id = 0;
for (unsigned int i = 0; i < platforms.size(); i++)
{
vector<Device> devices;
#if defined(CL_HPP_ENABLE_EXCEPTIONS)
try
{
#endif
error = platforms[i].getDevices(type, &devices);
#if defined(CL_HPP_ENABLE_EXCEPTIONS)
}
catch (cl::Error &e)
{
error = e.err();
}
// Catch if exceptions are enabled as we don't want to exit if first platform has no devices of type
// We do error checking next anyway, and can throw there if needed
#endif
// Only squash CL_SUCCESS and CL_DEVICE_NOT_FOUND
if (error != CL_SUCCESS && error != CL_DEVICE_NOT_FOUND)
{
detail::errHandler(error, __CREATE_CONTEXT_FROM_TYPE_ERR);
if (err != NULL)
{
*err = error;
}
}
if (devices.size() > 0)
{
platform_id = (cl_context_properties)platforms[i]();
break;
}
}
if (platform_id == 0)
{
detail::errHandler(CL_DEVICE_NOT_FOUND, __CREATE_CONTEXT_FROM_TYPE_ERR);
if (err != NULL)
{
*err = CL_DEVICE_NOT_FOUND;
}
return;
}
prop[1] = platform_id;
properties = &prop[0];
}
#endif
object_ = ::clCreateContextFromType(properties, type, notifyFptr, data, &error);
detail::errHandler(error, __CREATE_CONTEXT_FROM_TYPE_ERR);
if (err != NULL)
{
*err = error;
}
}
/*! \brief Copy constructor to forward copy to the superclass correctly.
* Required for MSVC.
*/
Context(const Context &ctx)
: detail::Wrapper<cl_type>(ctx)
{}
/*! \brief Copy assignment to forward copy to the superclass correctly.
* Required for MSVC.
*/
Context &operator=(const Context &ctx)
{
detail::Wrapper<cl_type>::operator=(ctx);
return *this;
}
/*! \brief Move constructor to forward move to the superclass correctly.
* Required for MSVC.
*/
Context(Context &&ctx) CL_HPP_NOEXCEPT_ : detail::Wrapper<cl_type>(std::move(ctx)) {}
/*! \brief Move assignment to forward move to the superclass correctly.
* Required for MSVC.
*/
Context &operator=(Context &&ctx)
{
detail::Wrapper<cl_type>::operator=(std::move(ctx));
return *this;
}
/*! \brief Returns a singleton context including all devices of CL_DEVICE_TYPE_DEFAULT.
*
* \note All calls to this function return the same cl_context as the first.
*/
static Context getDefault(cl_int *err = NULL)
{
std::call_once(default_initialized_, makeDefault);
detail::errHandler(default_error_);
if (err != NULL)
{
*err = default_error_;
}
return default_;
}
/**
* Modify the default context to be used by
* subsequent operations.
* Will only set the default if no default was previously created.
* @return updated default context.
* Should be compared to the passed value to ensure that it was updated.
*/
static Context setDefault(const Context &default_context)
{
std::call_once(default_initialized_, makeDefaultProvided, std::cref(default_context));
detail::errHandler(default_error_);
return default_;
}
//! \brief Default constructor - initializes to NULL.
Context()
: detail::Wrapper<cl_type>()
{}
/*! \brief Constructor from cl_context - takes ownership.
*
* This effectively transfers ownership of a refcount on the cl_context
* into the new Context object.
*/
explicit Context(const cl_context &context, bool retainObject = false)
: detail::Wrapper<cl_type>(context, retainObject)
{}
/*! \brief Assignment operator from cl_context - takes ownership.
*
* This effectively transfers ownership of a refcount on the rhs and calls
* clReleaseContext() on the value previously held by this instance.
*/
Context &operator=(const cl_context &rhs)
{
detail::Wrapper<cl_type>::operator=(rhs);
return *this;
}
//! \brief Wrapper for clGetContextInfo().
template <typename T>
cl_int getInfo(cl_context_info name, T *param) const
{
return detail::errHandler(detail::getInfo(&::clGetContextInfo, object_, name, param), __GET_CONTEXT_INFO_ERR);
}
//! \brief Wrapper for clGetContextInfo() that returns by value.
template <cl_context_info name>
typename detail::param_traits<detail::cl_context_info, name>::param_type getInfo(cl_int *err = NULL) const
{
typename detail::param_traits<detail::cl_context_info, name>::param_type param;
cl_int result = getInfo(name, ¶m);
if (err != NULL)
{
*err = result;
}
return param;
}
/*! \brief Gets a list of supported image formats.
*
* Wraps clGetSupportedImageFormats().
*/
cl_int getSupportedImageFormats(cl_mem_flags flags, cl_mem_object_type type, vector<ImageFormat> *formats) const
{
cl_uint numEntries;
if (!formats)
{
return CL_SUCCESS;
}
cl_int err = ::clGetSupportedImageFormats(object_, flags, type, 0, NULL, &numEntries);
if (err != CL_SUCCESS)
{
return detail::errHandler(err, __GET_SUPPORTED_IMAGE_FORMATS_ERR);
}
if (numEntries > 0)
{
vector<ImageFormat> value(numEntries);
err = ::clGetSupportedImageFormats(object_, flags, type, numEntries, (cl_image_format *)value.data(), NULL);
if (err != CL_SUCCESS)
{
return detail::errHandler(err, __GET_SUPPORTED_IMAGE_FORMATS_ERR);
}
formats->assign(begin(value), end(value));
}
else
{
// If no values are being returned, ensure an empty vector comes back
formats->clear();
}
return CL_SUCCESS;
}
};
inline void Device::makeDefault()
{
/* Throwing an exception from a call_once invocation does not do
* what we wish, so we catch it and save the error.
*/
#if defined(CL_HPP_ENABLE_EXCEPTIONS)
try
#endif
{
cl_int error = 0;
Context context = Context::getDefault(&error);
detail::errHandler(error, __CREATE_CONTEXT_ERR);
if (error != CL_SUCCESS)
{
default_error_ = error;
}
else
{
default_ = context.getInfo<CL_CONTEXT_DEVICES>()[0];
default_error_ = CL_SUCCESS;
}
}
#if defined(CL_HPP_ENABLE_EXCEPTIONS)
catch (cl::Error &e)
{
default_error_ = e.err();
}
#endif
}
CL_HPP_DEFINE_STATIC_MEMBER_ std::once_flag Context::default_initialized_;
CL_HPP_DEFINE_STATIC_MEMBER_ Context Context::default_;
CL_HPP_DEFINE_STATIC_MEMBER_ cl_int Context::default_error_ = CL_SUCCESS;
/*! \brief Class interface for cl_event.
*
* \note Copies of these objects are shallow, meaning that the copy will refer
* to the same underlying cl_event as the original. For details, see
* clRetainEvent() and clReleaseEvent().
*
* \see cl_event
*/
class Event : public detail::Wrapper<cl_event>
{
public:
//! \brief Default constructor - initializes to NULL.
Event()
: detail::Wrapper<cl_type>()
{}
/*! \brief Constructor from cl_event - takes ownership.
*
* \param retainObject will cause the constructor to retain its cl object.
* Defaults to false to maintain compatibility with
* earlier versions.
* This effectively transfers ownership of a refcount on the cl_event
* into the new Event object.
*/
explicit Event(const cl_event &event, bool retainObject = false)
: detail::Wrapper<cl_type>(event, retainObject)
{}
/*! \brief Assignment operator from cl_event - takes ownership.
*
* This effectively transfers ownership of a refcount on the rhs and calls
* clReleaseEvent() on the value previously held by this instance.
*/
Event &operator=(const cl_event &rhs)
{
detail::Wrapper<cl_type>::operator=(rhs);
return *this;
}
//! \brief Wrapper for clGetEventInfo().
template <typename T>
cl_int getInfo(cl_event_info name, T *param) const
{
return detail::errHandler(detail::getInfo(&::clGetEventInfo, object_, name, param), __GET_EVENT_INFO_ERR);
}
//! \brief Wrapper for clGetEventInfo() that returns by value.
template <cl_event_info name>
typename detail::param_traits<detail::cl_event_info, name>::param_type getInfo(cl_int *err = NULL) const
{
typename detail::param_traits<detail::cl_event_info, name>::param_type param;
cl_int result = getInfo(name, ¶m);
if (err != NULL)
{
*err = result;
}
return param;
}
//! \brief Wrapper for clGetEventProfilingInfo().
template <typename T>
cl_int getProfilingInfo(cl_profiling_info name, T *param) const
{
return detail::errHandler(detail::getInfo(&::clGetEventProfilingInfo, object_, name, param),
__GET_EVENT_PROFILE_INFO_ERR);
}
//! \brief Wrapper for clGetEventProfilingInfo() that returns by value.
template <cl_profiling_info name>
typename detail::param_traits<detail::cl_profiling_info, name>::param_type getProfilingInfo(cl_int *err = NULL) const
{
typename detail::param_traits<detail::cl_profiling_info, name>::param_type param;
cl_int result = getProfilingInfo(name, ¶m);
if (err != NULL)
{
*err = result;
}
return param;
}
/*! \brief Blocks the calling thread until this event completes.
*
* Wraps clWaitForEvents().
*/
cl_int wait() const { return detail::errHandler(::clWaitForEvents(1, &object_), __WAIT_FOR_EVENTS_ERR); }
#if CL_HPP_TARGET_OPENCL_VERSION >= 110
/*! \brief Registers a user callback function for a specific command execution status.
*
* Wraps clSetEventCallback().
*/
cl_int setCallback(cl_int type, void(CL_CALLBACK *pfn_notify)(cl_event, cl_int, void *), void *user_data = NULL)
{
return detail::errHandler(::clSetEventCallback(object_, type, pfn_notify, user_data), __SET_EVENT_CALLBACK_ERR);
}
#endif // CL_HPP_TARGET_OPENCL_VERSION >= 110
/*! \brief Blocks the calling thread until every event specified is complete.
*
* Wraps clWaitForEvents().
*/
static cl_int waitForEvents(const vector<Event> &events)
{
return detail::errHandler(
::clWaitForEvents((cl_uint)events.size(), (events.size() > 0) ? (cl_event *)&events.front() : NULL),
__WAIT_FOR_EVENTS_ERR);
}
};
#if CL_HPP_TARGET_OPENCL_VERSION >= 110
/*! \brief Class interface for user events (a subset of cl_event's).
*
* See Event for details about copy semantics, etc.
*/
class UserEvent : public Event
{
public:
/*! \brief Constructs a user event on a given context.
*
* Wraps clCreateUserEvent().
*/
UserEvent(const Context &context, cl_int *err = NULL)
{
cl_int error;
object_ = ::clCreateUserEvent(context(), &error);
detail::errHandler(error, __CREATE_USER_EVENT_ERR);
if (err != NULL)
{
*err = error;
}
}
//! \brief Default constructor - initializes to NULL.
UserEvent()
: Event()
{}
/*! \brief Sets the execution status of a user event object.
*
* Wraps clSetUserEventStatus().
*/
cl_int setStatus(cl_int status)
{
return detail::errHandler(::clSetUserEventStatus(object_, status), __SET_USER_EVENT_STATUS_ERR);
}
};
#endif // CL_HPP_TARGET_OPENCL_VERSION >= 110
/*! \brief Blocks the calling thread until every event specified is complete.
*
* Wraps clWaitForEvents().
*/
inline static cl_int WaitForEvents(const vector<Event> &events)
{
return detail::errHandler(
::clWaitForEvents((cl_uint)events.size(), (events.size() > 0) ? (cl_event *)&events.front() : NULL),
__WAIT_FOR_EVENTS_ERR);
}
/*! \brief Class interface for cl_mem.
*
* \note Copies of these objects are shallow, meaning that the copy will refer
* to the same underlying cl_mem as the original. For details, see
* clRetainMemObject() and clReleaseMemObject().
*
* \see cl_mem
*/
class Memory : public detail::Wrapper<cl_mem>
{
public:
//! \brief Default constructor - initializes to NULL.
Memory()
: detail::Wrapper<cl_type>()
{}
/*! \brief Constructor from cl_mem - takes ownership.
*
* Optionally transfer ownership of a refcount on the cl_mem
* into the new Memory object.
*
* \param retainObject will cause the constructor to retain its cl object.
* Defaults to false to maintain compatibility with
* earlier versions.
*
* See Memory for further details.
*/
explicit Memory(const cl_mem &memory, bool retainObject)
: detail::Wrapper<cl_type>(memory, retainObject)
{}
/*! \brief Assignment operator from cl_mem - takes ownership.
*
* This effectively transfers ownership of a refcount on the rhs and calls
* clReleaseMemObject() on the value previously held by this instance.
*/
Memory &operator=(const cl_mem &rhs)
{
detail::Wrapper<cl_type>::operator=(rhs);
return *this;
}
/*! \brief Copy constructor to forward copy to the superclass correctly.
* Required for MSVC.
*/
Memory(const Memory &mem)
: detail::Wrapper<cl_type>(mem)
{}
/*! \brief Copy assignment to forward copy to the superclass correctly.
* Required for MSVC.
*/
Memory &operator=(const Memory &mem)
{
detail::Wrapper<cl_type>::operator=(mem);
return *this;
}
/*! \brief Move constructor to forward move to the superclass correctly.
* Required for MSVC.
*/
Memory(Memory &&mem) CL_HPP_NOEXCEPT_ : detail::Wrapper<cl_type>(std::move(mem)) {}
/*! \brief Move assignment to forward move to the superclass correctly.
* Required for MSVC.
*/
Memory &operator=(Memory &&mem)
{
detail::Wrapper<cl_type>::operator=(std::move(mem));
return *this;
}
//! \brief Wrapper for clGetMemObjectInfo().
template <typename T>
cl_int getInfo(cl_mem_info name, T *param) const
{
return detail::errHandler(detail::getInfo(&::clGetMemObjectInfo, object_, name, param), __GET_MEM_OBJECT_INFO_ERR);
}
//! \brief Wrapper for clGetMemObjectInfo() that returns by value.
template <cl_mem_info name>
typename detail::param_traits<detail::cl_mem_info, name>::param_type getInfo(cl_int *err = NULL) const
{
typename detail::param_traits<detail::cl_mem_info, name>::param_type param;
cl_int result = getInfo(name, ¶m);
if (err != NULL)
{
*err = result;
}
return param;
}
#if CL_HPP_TARGET_OPENCL_VERSION >= 110
/*! \brief Registers a callback function to be called when the memory object
* is no longer needed.
*
* Wraps clSetMemObjectDestructorCallback().
*
* Repeated calls to this function, for a given cl_mem value, will append
* to the list of functions called (in reverse order) when memory object's
* resources are freed and the memory object is deleted.
*
* \note
* The registered callbacks are associated with the underlying cl_mem
* value - not the Memory class instance.
*/
cl_int setDestructorCallback(void(CL_CALLBACK *pfn_notify)(cl_mem, void *), void *user_data = NULL)
{
return detail::errHandler(::clSetMemObjectDestructorCallback(object_, pfn_notify, user_data),
__SET_MEM_OBJECT_DESTRUCTOR_CALLBACK_ERR);
}
#endif // CL_HPP_TARGET_OPENCL_VERSION >= 110
};
// Pre-declare copy functions
class Buffer;
template <typename IteratorType>
cl_int copy(IteratorType startIterator, IteratorType endIterator, cl::Buffer &buffer);
template <typename IteratorType>
cl_int copy(const cl::Buffer &buffer, IteratorType startIterator, IteratorType endIterator);
template <typename IteratorType>
cl_int copy(const CommandQueue &queue, IteratorType startIterator, IteratorType endIterator, cl::Buffer &buffer);
template <typename IteratorType>
cl_int copy(const CommandQueue &queue, const cl::Buffer &buffer, IteratorType startIterator, IteratorType endIterator);
#if CL_HPP_TARGET_OPENCL_VERSION >= 200
namespace detail
{
class SVMTraitNull
{
public:
static cl_svm_mem_flags getSVMMemFlags() { return 0; }
};
} // namespace detail
template <class Trait = detail::SVMTraitNull>
class SVMTraitReadWrite
{
public:
static cl_svm_mem_flags getSVMMemFlags() { return CL_MEM_READ_WRITE | Trait::getSVMMemFlags(); }
};
template <class Trait = detail::SVMTraitNull>
class SVMTraitReadOnly
{
public:
static cl_svm_mem_flags getSVMMemFlags() { return CL_MEM_READ_ONLY | Trait::getSVMMemFlags(); }
};
template <class Trait = detail::SVMTraitNull>
class SVMTraitWriteOnly
{
public:
static cl_svm_mem_flags getSVMMemFlags() { return CL_MEM_WRITE_ONLY | Trait::getSVMMemFlags(); }
};
template <class Trait = SVMTraitReadWrite<>>
class SVMTraitCoarse
{
public:
static cl_svm_mem_flags getSVMMemFlags() { return Trait::getSVMMemFlags(); }
};
template <class Trait = SVMTraitReadWrite<>>
class SVMTraitFine
{
public:
static cl_svm_mem_flags getSVMMemFlags() { return CL_MEM_SVM_FINE_GRAIN_BUFFER | Trait::getSVMMemFlags(); }
};
template <class Trait = SVMTraitReadWrite<>>
class SVMTraitAtomic
{
public:
static cl_svm_mem_flags getSVMMemFlags()
{
return CL_MEM_SVM_FINE_GRAIN_BUFFER | CL_MEM_SVM_ATOMICS | Trait::getSVMMemFlags();
}
};
// Pre-declare SVM map function
template <typename T>
inline cl_int enqueueMapSVM(T *ptr, cl_bool blocking, cl_map_flags flags, size_type size,
const vector<Event> *events = NULL, Event *event = NULL);
/**
* STL-like allocator class for managing SVM objects provided for convenience.
*
* Note that while this behaves like an allocator for the purposes of constructing vectors and similar objects,
* care must be taken when using with smart pointers.
* The allocator should not be used to construct a unique_ptr if we are using coarse-grained SVM mode because
* the coarse-grained management behaviour would behave incorrectly with respect to reference counting.
*
* Instead the allocator embeds a Deleter which may be used with unique_ptr and is used
* with the allocate_shared and allocate_ptr supplied operations.
*/
template <typename T, class SVMTrait>
class SVMAllocator
{
private:
Context context_;
public:
typedef T value_type;
typedef value_type *pointer;
typedef const value_type *const_pointer;
typedef value_type &reference;
typedef const value_type &const_reference;
typedef std::size_t size_type;
typedef std::ptrdiff_t difference_type;
template <typename U>
struct rebind
{
typedef SVMAllocator<U, SVMTrait> other;
};
template <typename U, typename V>
friend class SVMAllocator;
SVMAllocator()
: context_(Context::getDefault())
{}
explicit SVMAllocator(cl::Context context)
: context_(context)
{}
SVMAllocator(const SVMAllocator &other)
: context_(other.context_)
{}
template <typename U>
SVMAllocator(const SVMAllocator<U, SVMTrait> &other)
: context_(other.context_)
{}
~SVMAllocator() {}
pointer address(reference r) CL_HPP_NOEXCEPT_ { return std::addressof(r); }
const_pointer address(const_reference r) CL_HPP_NOEXCEPT_ { return std::addressof(r); }
/**
* Allocate an SVM pointer.
*
* If the allocator is coarse-grained, this will take ownership to allow
* containers to correctly construct data in place.
*/
pointer allocate(size_type size, typename cl::SVMAllocator<void, SVMTrait>::const_pointer = 0)
{
// Allocate memory with default alignment matching the size of the type
void *voidPointer = clSVMAlloc(context_(), SVMTrait::getSVMMemFlags(), size * sizeof(T), 0);
pointer retValue = reinterpret_cast<pointer>(voidPointer);
#if defined(CL_HPP_ENABLE_EXCEPTIONS)
if (!retValue)
{
std::bad_alloc excep;
throw excep;
}
#endif // #if defined(CL_HPP_ENABLE_EXCEPTIONS)
// If allocation was coarse-grained then map it
if (!(SVMTrait::getSVMMemFlags() & CL_MEM_SVM_FINE_GRAIN_BUFFER))
{
cl_int err = enqueueMapSVM(retValue, CL_TRUE, CL_MAP_READ | CL_MAP_WRITE, size * sizeof(T));
if (err != CL_SUCCESS)
{
std::bad_alloc excep;
throw excep;
}
}
// If exceptions disabled, return null pointer from allocator
return retValue;
}
void deallocate(pointer p, size_type) { clSVMFree(context_(), p); }
/**
* Return the maximum possible allocation size.
* This is the minimum of the maximum sizes of all devices in the context.
*/
size_type max_size() const CL_HPP_NOEXCEPT_
{
size_type maxSize = std::numeric_limits<size_type>::max() / sizeof(T);
for (const Device &d : context_.getInfo<CL_CONTEXT_DEVICES>())
{
maxSize = std::min(maxSize, static_cast<size_type>(d.getInfo<CL_DEVICE_MAX_MEM_ALLOC_SIZE>()));
}
return maxSize;
}
template <class U, class... Args>
void construct(U *p, Args &&...args)
{
new (p) T(args...);
}
template <class U>
void destroy(U *p)
{
p->~U();
}
/**
* Returns true if the contexts match.
*/
inline bool operator==(SVMAllocator const &rhs) { return (context_ == rhs.context_); }
inline bool operator!=(SVMAllocator const &a) { return !operator==(a); }
}; // class SVMAllocator return cl::pointer<T>(tmp, detail::Deleter<T, Alloc>{alloc, copies});
template <class SVMTrait>
class SVMAllocator<void, SVMTrait>
{
public:
typedef void value_type;
typedef value_type *pointer;
typedef const value_type *const_pointer;
template <typename U>
struct rebind
{
typedef SVMAllocator<U, SVMTrait> other;
};
template <typename U, typename V>
friend class SVMAllocator;
};
#if !defined(CL_HPP_NO_STD_UNIQUE_PTR)
namespace detail
{
template <class Alloc>
class Deleter
{
private:
Alloc alloc_;
size_type copies_;
public:
typedef typename std::allocator_traits<Alloc>::pointer pointer;
Deleter(const Alloc &alloc, size_type copies)
: alloc_{ alloc }
, copies_{ copies }
{}
void operator()(pointer ptr) const
{
Alloc tmpAlloc{ alloc_ };
std::allocator_traits<Alloc>::destroy(tmpAlloc, std::addressof(*ptr));
std::allocator_traits<Alloc>::deallocate(tmpAlloc, ptr, copies_);
}
};
} // namespace detail
/**
* Allocation operation compatible with std::allocate_ptr.
* Creates a unique_ptr<T> by default.
* This requirement is to ensure that the control block is not
* allocated in memory inaccessible to the host.
*/
template <class T, class Alloc, class... Args>
cl::pointer<T, detail::Deleter<Alloc>> allocate_pointer(const Alloc &alloc_, Args &&...args)
{
Alloc alloc(alloc_);
static const size_type copies = 1;
// Ensure that creation of the management block and the
// object are dealt with separately such that we only provide a deleter
T *tmp = std::allocator_traits<Alloc>::allocate(alloc, copies);
if (!tmp)
{
std::bad_alloc excep;
throw excep;
}
try
{
std::allocator_traits<Alloc>::construct(alloc, std::addressof(*tmp), std::forward<Args>(args)...);
return cl::pointer<T, detail::Deleter<Alloc>>(tmp, detail::Deleter<Alloc>{ alloc, copies });
}
catch (std::bad_alloc &b)
{
std::allocator_traits<Alloc>::deallocate(alloc, tmp, copies);
throw;
}
}
template <class T, class SVMTrait, class... Args>
cl::pointer<T, detail::Deleter<SVMAllocator<T, SVMTrait>>> allocate_svm(Args... args)
{
SVMAllocator<T, SVMTrait> alloc;
return cl::allocate_pointer<T>(alloc, args...);
}
template <class T, class SVMTrait, class... Args>
cl::pointer<T, detail::Deleter<SVMAllocator<T, SVMTrait>>> allocate_svm(const cl::Context &c, Args... args)
{
SVMAllocator<T, SVMTrait> alloc(c);
return cl::allocate_pointer<T>(alloc, args...);
}
#endif // #if !defined(CL_HPP_NO_STD_UNIQUE_PTR)
/*! \brief Vector alias to simplify contruction of coarse-grained SVM containers.
*
*/
template <class T>
using coarse_svm_vector = vector<T, cl::SVMAllocator<int, cl::SVMTraitCoarse<>>>;
/*! \brief Vector alias to simplify contruction of fine-grained SVM containers.
*
*/
template <class T>
using fine_svm_vector = vector<T, cl::SVMAllocator<int, cl::SVMTraitFine<>>>;
/*! \brief Vector alias to simplify contruction of fine-grained SVM containers that support platform atomics.
*
*/
template <class T>
using atomic_svm_vector = vector<T, cl::SVMAllocator<int, cl::SVMTraitAtomic<>>>;
#endif // #if CL_HPP_TARGET_OPENCL_VERSION >= 200
/*! \brief Class interface for Buffer Memory Objects.
*
* See Memory for details about copy semantics, etc.
*
* \see Memory
*/
class Buffer : public Memory
{
public:
/*! \brief Constructs a Buffer in a specified context.
*
* Wraps clCreateBuffer().
*
* \param host_ptr Storage to be used if the CL_MEM_USE_HOST_PTR flag was
* specified. Note alignment & exclusivity requirements.
*/
Buffer(const Context &context, cl_mem_flags flags, size_type size, void *host_ptr = NULL, cl_int *err = NULL)
{
cl_int error;
object_ = ::clCreateBuffer(context(), flags, size, host_ptr, &error);
detail::errHandler(error, __CREATE_BUFFER_ERR);
if (err != NULL)
{
*err = error;
}
}
/*! \brief Constructs a Buffer in the default context.
*
* Wraps clCreateBuffer().
*
* \param host_ptr Storage to be used if the CL_MEM_USE_HOST_PTR flag was
* specified. Note alignment & exclusivity requirements.
*
* \see Context::getDefault()
*/
Buffer(cl_mem_flags flags, size_type size, void *host_ptr = NULL, cl_int *err = NULL)
{
cl_int error;
Context context = Context::getDefault(err);
object_ = ::clCreateBuffer(context(), flags, size, host_ptr, &error);
detail::errHandler(error, __CREATE_BUFFER_ERR);
if (err != NULL)
{
*err = error;
}
}
/*!
* \brief Construct a Buffer from a host container via iterators.
* IteratorType must be random access.
* If useHostPtr is specified iterators must represent contiguous data.
*/
template <typename IteratorType>
Buffer(IteratorType startIterator, IteratorType endIterator, bool readOnly, bool useHostPtr = false,
cl_int *err = NULL)
{
typedef typename std::iterator_traits<IteratorType>::value_type DataType;
cl_int error;
cl_mem_flags flags = 0;
if (readOnly)
{
flags |= CL_MEM_READ_ONLY;
}
else
{
flags |= CL_MEM_READ_WRITE;
}
if (useHostPtr)
{
flags |= CL_MEM_USE_HOST_PTR;
}
size_type size = sizeof(DataType) * (endIterator - startIterator);
Context context = Context::getDefault(err);
if (useHostPtr)
{
object_ = ::clCreateBuffer(context(), flags, size, static_cast<DataType *>(&*startIterator), &error);
}
else
{
object_ = ::clCreateBuffer(context(), flags, size, 0, &error);
}
detail::errHandler(error, __CREATE_BUFFER_ERR);
if (err != NULL)
{
*err = error;
}
if (!useHostPtr)
{
error = cl::copy(startIterator, endIterator, *this);
detail::errHandler(error, __CREATE_BUFFER_ERR);
if (err != NULL)
{
*err = error;
}
}
}
/*!
* \brief Construct a Buffer from a host container via iterators using a specified context.
* IteratorType must be random access.
* If useHostPtr is specified iterators must represent contiguous data.
*/
template <typename IteratorType>
Buffer(const Context &context, IteratorType startIterator, IteratorType endIterator, bool readOnly,
bool useHostPtr = false, cl_int *err = NULL);
/*!
* \brief Construct a Buffer from a host container via iterators using a specified queue.
* If useHostPtr is specified iterators must be random access.
*/
template <typename IteratorType>
Buffer(const CommandQueue &queue, IteratorType startIterator, IteratorType endIterator, bool readOnly,
bool useHostPtr = false, cl_int *err = NULL);
//! \brief Default constructor - initializes to NULL.
Buffer()
: Memory()
{}
/*! \brief Constructor from cl_mem - takes ownership.
*
* \param retainObject will cause the constructor to retain its cl object.
* Defaults to false to maintain compatibility with earlier versions.
*
* See Memory for further details.
*/
explicit Buffer(const cl_mem &buffer, bool retainObject = false)
: Memory(buffer, retainObject)
{}
/*! \brief Assignment from cl_mem - performs shallow copy.
*
* See Memory for further details.
*/
Buffer &operator=(const cl_mem &rhs)
{
Memory::operator=(rhs);
return *this;
}
/*! \brief Copy constructor to forward copy to the superclass correctly.
* Required for MSVC.
*/
Buffer(const Buffer &buf)
: Memory(buf)
{}
/*! \brief Copy assignment to forward copy to the superclass correctly.
* Required for MSVC.
*/
Buffer &operator=(const Buffer &buf)
{
Memory::operator=(buf);
return *this;
}
/*! \brief Move constructor to forward move to the superclass correctly.
* Required for MSVC.
*/
Buffer(Buffer &&buf) CL_HPP_NOEXCEPT_ : Memory(std::move(buf)) {}
/*! \brief Move assignment to forward move to the superclass correctly.
* Required for MSVC.
*/
Buffer &operator=(Buffer &&buf)
{
Memory::operator=(std::move(buf));
return *this;
}
#if CL_HPP_TARGET_OPENCL_VERSION >= 110
/*! \brief Creates a new buffer object from this.
*
* Wraps clCreateSubBuffer().
*/
Buffer createSubBuffer(cl_mem_flags flags, cl_buffer_create_type buffer_create_type, const void *buffer_create_info,
cl_int *err = NULL)
{
Buffer result;
cl_int error;
result.object_ = ::clCreateSubBuffer(object_, flags, buffer_create_type, buffer_create_info, &error);
detail::errHandler(error, __CREATE_SUBBUFFER_ERR);
if (err != NULL)
{
*err = error;
}
return result;
}
#endif // CL_HPP_TARGET_OPENCL_VERSION >= 110
};
#if defined(CL_HPP_USE_DX_INTEROP)
/*! \brief Class interface for creating OpenCL buffers from ID3D10Buffer's.
*
* This is provided to facilitate interoperability with Direct3D.
*
* See Memory for details about copy semantics, etc.
*
* \see Memory
*/
class BufferD3D10 : public Buffer
{
public:
/*! \brief Constructs a BufferD3D10, in a specified context, from a
* given ID3D10Buffer.
*
* Wraps clCreateFromD3D10BufferKHR().
*/
BufferD3D10(const Context &context, cl_mem_flags flags, ID3D10Buffer *bufobj, cl_int *err = NULL)
: pfn_clCreateFromD3D10BufferKHR(nullptr)
{
typedef CL_API_ENTRY cl_mem(CL_API_CALL * PFN_clCreateFromD3D10BufferKHR)(
cl_context context, cl_mem_flags flags, ID3D10Buffer * buffer, cl_int * errcode_ret);
PFN_clCreateFromD3D10BufferKHR pfn_clCreateFromD3D10BufferKHR;
#if CL_HPP_TARGET_OPENCL_VERSION >= 120
vector<cl_context_properties> props = context.getInfo<CL_CONTEXT_PROPERTIES>();
cl_platform platform = -1;
for (int i = 0; i < props.size(); ++i)
{
if (props[i] == CL_CONTEXT_PLATFORM)
{
platform = props[i + 1];
}
}
CL_HPP_INIT_CL_EXT_FCN_PTR_PLATFORM_(platform, clCreateFromD3D10BufferKHR);
#elif CL_HPP_TARGET_OPENCL_VERSION >= 110
CL_HPP_INIT_CL_EXT_FCN_PTR_(clCreateFromD3D10BufferKHR);
#endif
cl_int error;
object_ = pfn_clCreateFromD3D10BufferKHR(context(), flags, bufobj, &error);
detail::errHandler(error, __CREATE_GL_BUFFER_ERR);
if (err != NULL)
{
*err = error;
}
}
//! \brief Default constructor - initializes to NULL.
BufferD3D10()
: Buffer()
{}
/*! \brief Constructor from cl_mem - takes ownership.
*
* \param retainObject will cause the constructor to retain its cl object.
* Defaults to false to maintain compatibility with
* earlier versions.
* See Memory for further details.
*/
explicit BufferD3D10(const cl_mem &buffer, bool retainObject = false)
: Buffer(buffer, retainObject)
{}
/*! \brief Assignment from cl_mem - performs shallow copy.
*
* See Memory for further details.
*/
BufferD3D10 &operator=(const cl_mem &rhs)
{
Buffer::operator=(rhs);
return *this;
}
/*! \brief Copy constructor to forward copy to the superclass correctly.
* Required for MSVC.
*/
BufferD3D10(const BufferD3D10 &buf)
: Buffer(buf)
{}
/*! \brief Copy assignment to forward copy to the superclass correctly.
* Required for MSVC.
*/
BufferD3D10 &operator=(const BufferD3D10 &buf)
{
Buffer::operator=(buf);
return *this;
}
/*! \brief Move constructor to forward move to the superclass correctly.
* Required for MSVC.
*/
BufferD3D10(BufferD3D10 &&buf) CL_HPP_NOEXCEPT_ : Buffer(std::move(buf)) {}
/*! \brief Move assignment to forward move to the superclass correctly.
* Required for MSVC.
*/
BufferD3D10 &operator=(BufferD3D10 &&buf)
{
Buffer::operator=(std::move(buf));
return *this;
}
};
#endif
/*! \brief Class interface for GL Buffer Memory Objects.
*
* This is provided to facilitate interoperability with OpenGL.
*
* See Memory for details about copy semantics, etc.
*
* \see Memory
*/
class BufferGL : public Buffer
{
public:
/*! \brief Constructs a BufferGL in a specified context, from a given
* GL buffer.
*
* Wraps clCreateFromGLBuffer().
*/
BufferGL(const Context &context, cl_mem_flags flags, cl_GLuint bufobj, cl_int *err = NULL)
{
cl_int error;
object_ = ::clCreateFromGLBuffer(context(), flags, bufobj, &error);
detail::errHandler(error, __CREATE_GL_BUFFER_ERR);
if (err != NULL)
{
*err = error;
}
}
//! \brief Default constructor - initializes to NULL.
BufferGL()
: Buffer()
{}
/*! \brief Constructor from cl_mem - takes ownership.
*
* \param retainObject will cause the constructor to retain its cl object.
* Defaults to false to maintain compatibility with
* earlier versions.
* See Memory for further details.
*/
explicit BufferGL(const cl_mem &buffer, bool retainObject = false)
: Buffer(buffer, retainObject)
{}
/*! \brief Assignment from cl_mem - performs shallow copy.
*
* See Memory for further details.
*/
BufferGL &operator=(const cl_mem &rhs)
{
Buffer::operator=(rhs);
return *this;
}
/*! \brief Copy constructor to forward copy to the superclass correctly.
* Required for MSVC.
*/
BufferGL(const BufferGL &buf)
: Buffer(buf)
{}
/*! \brief Copy assignment to forward copy to the superclass correctly.
* Required for MSVC.
*/
BufferGL &operator=(const BufferGL &buf)
{
Buffer::operator=(buf);
return *this;
}
/*! \brief Move constructor to forward move to the superclass correctly.
* Required for MSVC.
*/
BufferGL(BufferGL &&buf) CL_HPP_NOEXCEPT_ : Buffer(std::move(buf)) {}
/*! \brief Move assignment to forward move to the superclass correctly.
* Required for MSVC.
*/
BufferGL &operator=(BufferGL &&buf)
{
Buffer::operator=(std::move(buf));
return *this;
}
//! \brief Wrapper for clGetGLObjectInfo().
cl_int getObjectInfo(cl_gl_object_type *type, cl_GLuint *gl_object_name)
{
return detail::errHandler(::clGetGLObjectInfo(object_, type, gl_object_name), __GET_GL_OBJECT_INFO_ERR);
}
};
/*! \brief Class interface for GL Render Buffer Memory Objects.
*
* This is provided to facilitate interoperability with OpenGL.
*
* See Memory for details about copy semantics, etc.
*
* \see Memory
*/
class BufferRenderGL : public Buffer
{
public:
/*! \brief Constructs a BufferRenderGL in a specified context, from a given
* GL Renderbuffer.
*
* Wraps clCreateFromGLRenderbuffer().
*/
BufferRenderGL(const Context &context, cl_mem_flags flags, cl_GLuint bufobj, cl_int *err = NULL)
{
cl_int error;
object_ = ::clCreateFromGLRenderbuffer(context(), flags, bufobj, &error);
detail::errHandler(error, __CREATE_GL_RENDER_BUFFER_ERR);
if (err != NULL)
{
*err = error;
}
}
//! \brief Default constructor - initializes to NULL.
BufferRenderGL()
: Buffer()
{}
/*! \brief Constructor from cl_mem - takes ownership.
*
* \param retainObject will cause the constructor to retain its cl object.
* Defaults to false to maintain compatibility with
* earlier versions.
* See Memory for further details.
*/
explicit BufferRenderGL(const cl_mem &buffer, bool retainObject = false)
: Buffer(buffer, retainObject)
{}
/*! \brief Assignment from cl_mem - performs shallow copy.
*
* See Memory for further details.
*/
BufferRenderGL &operator=(const cl_mem &rhs)
{
Buffer::operator=(rhs);
return *this;
}
/*! \brief Copy constructor to forward copy to the superclass correctly.
* Required for MSVC.
*/
BufferRenderGL(const BufferRenderGL &buf)
: Buffer(buf)
{}
/*! \brief Copy assignment to forward copy to the superclass correctly.
* Required for MSVC.
*/
BufferRenderGL &operator=(const BufferRenderGL &buf)
{
Buffer::operator=(buf);
return *this;
}
/*! \brief Move constructor to forward move to the superclass correctly.
* Required for MSVC.
*/
BufferRenderGL(BufferRenderGL &&buf) CL_HPP_NOEXCEPT_ : Buffer(std::move(buf)) {}
/*! \brief Move assignment to forward move to the superclass correctly.
* Required for MSVC.
*/
BufferRenderGL &operator=(BufferRenderGL &&buf)
{
Buffer::operator=(std::move(buf));
return *this;
}
//! \brief Wrapper for clGetGLObjectInfo().
cl_int getObjectInfo(cl_gl_object_type *type, cl_GLuint *gl_object_name)
{
return detail::errHandler(::clGetGLObjectInfo(object_, type, gl_object_name), __GET_GL_OBJECT_INFO_ERR);
}
};
/*! \brief C++ base class for Image Memory objects.
*
* See Memory for details about copy semantics, etc.
*
* \see Memory
*/
class Image : public Memory
{
protected:
//! \brief Default constructor - initializes to NULL.
Image()
: Memory()
{}
/*! \brief Constructor from cl_mem - takes ownership.
*
* \param retainObject will cause the constructor to retain its cl object.
* Defaults to false to maintain compatibility with
* earlier versions.
* See Memory for further details.
*/
explicit Image(const cl_mem &image, bool retainObject = false)
: Memory(image, retainObject)
{}
/*! \brief Assignment from cl_mem - performs shallow copy.
*
* See Memory for further details.
*/
Image &operator=(const cl_mem &rhs)
{
Memory::operator=(rhs);
return *this;
}
/*! \brief Copy constructor to forward copy to the superclass correctly.
* Required for MSVC.
*/
Image(const Image &img)
: Memory(img)
{}
/*! \brief Copy assignment to forward copy to the superclass correctly.
* Required for MSVC.
*/
Image &operator=(const Image &img)
{
Memory::operator=(img);
return *this;
}
/*! \brief Move constructor to forward move to the superclass correctly.
* Required for MSVC.
*/
Image(Image &&img) CL_HPP_NOEXCEPT_ : Memory(std::move(img)) {}
/*! \brief Move assignment to forward move to the superclass correctly.
* Required for MSVC.
*/
Image &operator=(Image &&img)
{
Memory::operator=(std::move(img));
return *this;
}
public:
//! \brief Wrapper for clGetImageInfo().
template <typename T>
cl_int getImageInfo(cl_image_info name, T *param) const
{
return detail::errHandler(detail::getInfo(&::clGetImageInfo, object_, name, param), __GET_IMAGE_INFO_ERR);
}
//! \brief Wrapper for clGetImageInfo() that returns by value.
template <cl_image_info name>
typename detail::param_traits<detail::cl_image_info, name>::param_type getImageInfo(cl_int *err = NULL) const
{
typename detail::param_traits<detail::cl_image_info, name>::param_type param;
cl_int result = getImageInfo(name, ¶m);
if (err != NULL)
{
*err = result;
}
return param;
}
};
#if CL_HPP_TARGET_OPENCL_VERSION >= 120
/*! \brief Class interface for 1D Image Memory objects.
*
* See Memory for details about copy semantics, etc.
*
* \see Memory
*/
class Image1D : public Image
{
public:
/*! \brief Constructs a 1D Image in a specified context.
*
* Wraps clCreateImage().
*/
Image1D(const Context &context, cl_mem_flags flags, ImageFormat format, size_type width, void *host_ptr = NULL,
cl_int *err = NULL)
{
cl_int error;
cl_image_desc desc = { 0 };
desc.image_type = CL_MEM_OBJECT_IMAGE1D;
desc.image_width = width;
object_ = ::clCreateImage(context(), flags, &format, &desc, host_ptr, &error);
detail::errHandler(error, __CREATE_IMAGE_ERR);
if (err != NULL)
{
*err = error;
}
}
//! \brief Default constructor - initializes to NULL.
Image1D() {}
/*! \brief Constructor from cl_mem - takes ownership.
*
* \param retainObject will cause the constructor to retain its cl object.
* Defaults to false to maintain compatibility with
* earlier versions.
* See Memory for further details.
*/
explicit Image1D(const cl_mem &image1D, bool retainObject = false)
: Image(image1D, retainObject)
{}
/*! \brief Assignment from cl_mem - performs shallow copy.
*
* See Memory for further details.
*/
Image1D &operator=(const cl_mem &rhs)
{
Image::operator=(rhs);
return *this;
}
/*! \brief Copy constructor to forward copy to the superclass correctly.
* Required for MSVC.
*/
Image1D(const Image1D &img)
: Image(img)
{}
/*! \brief Copy assignment to forward copy to the superclass correctly.
* Required for MSVC.
*/
Image1D &operator=(const Image1D &img)
{
Image::operator=(img);
return *this;
}
/*! \brief Move constructor to forward move to the superclass correctly.
* Required for MSVC.
*/
Image1D(Image1D &&img) CL_HPP_NOEXCEPT_ : Image(std::move(img)) {}
/*! \brief Move assignment to forward move to the superclass correctly.
* Required for MSVC.
*/
Image1D &operator=(Image1D &&img)
{
Image::operator=(std::move(img));
return *this;
}
};
/*! \class Image1DBuffer
* \brief Image interface for 1D buffer images.
*/
class Image1DBuffer : public Image
{
public:
Image1DBuffer(const Context &context, cl_mem_flags flags, ImageFormat format, size_type width, const Buffer &buffe
gitextract_waem9xm7/ ├── .clang-format ├── .clang-tidy ├── .gitignore ├── 3rdparty/ │ └── 3es-core/ │ └── 3esservermacros.h ├── CMakeLists.txt ├── LICENSE ├── OpenCL.md ├── clearance-performance-notes.md ├── clu/ │ ├── 3rdparty/ │ │ └── CL/ │ │ └── opencl.hpp │ ├── CMakeLists.txt │ ├── clu.cpp │ ├── clu.h │ ├── cluBuffer.h │ ├── cluConfig.in.h │ ├── cluConstraint.cpp │ ├── cluConstraint.h │ ├── cluKernel.cpp │ ├── cluKernel.h │ ├── cluProgram.cpp │ └── cluProgram.h ├── cmake/ │ ├── ClangTidy.cmake │ ├── FindLASZIP.cmake │ ├── FindLIBLAS.cmake │ ├── FindOctomap.cmake │ ├── FindTBB.cmake │ ├── Findglm.cmake │ ├── LeakTrack.cmake │ ├── OhmCuda.cmake │ ├── OhmGTest.cmake │ ├── TextFileResource.cmake │ ├── TextFileResource.py │ ├── compilerSetup.cmake │ ├── doxyfile.in │ ├── doxygen.cmake │ ├── ohm-config.cmake │ ├── ohm-packages.cmake │ ├── tidy/ │ │ ├── clang-tidy-names.yaml │ │ └── wrap-clang-tidy.py │ └── utils.cmake ├── docs/ │ ├── docglossary.md │ ├── docmain.h │ ├── docusage.md │ ├── docutils.md │ ├── docvoxellayers.md │ └── gpu/ │ ├── docgpualgorithm.md │ └── docgpudetail.md ├── gputil/ │ ├── CMakeLists.txt │ ├── cl/ │ │ ├── gpuApiExceptionCode.cpp │ │ ├── gpuBuffer.cpp │ │ ├── gpuBufferDetail.h │ │ ├── gpuDevice.cpp │ │ ├── gpuDeviceDetail.h │ │ ├── gpuEvent.cpp │ │ ├── gpuEventDetail.h │ │ ├── gpuKernel.cpp │ │ ├── gpuKernel2.h │ │ ├── gpuKernelDetail.h │ │ ├── gpuPinnedBuffer.cpp │ │ ├── gpuPlatform2.h │ │ ├── gpuProgram.cpp │ │ ├── gpuProgramDetail.h │ │ ├── gpuQueue.cpp │ │ └── gpuQueueDetail.h │ ├── cuda/ │ │ ├── cutil_atomic.h │ │ ├── cutil_decl.h │ │ ├── cutil_importcl.h │ │ ├── cutil_math.h │ │ ├── gpuApiExceptionCode.cpp │ │ ├── gpuBuffer.cpp │ │ ├── gpuBufferDetail.h │ │ ├── gpuDevice.cpp │ │ ├── gpuDeviceDetail.h │ │ ├── gpuDirtyRegion │ │ ├── gpuEvent.cpp │ │ ├── gpuEventDetail.h │ │ ├── gpuKernel.cpp │ │ ├── gpuKernel2.h │ │ ├── gpuKernelDetail.h │ │ ├── gpuMemRegion.cpp │ │ ├── gpuMemRegion.h │ │ ├── gpuPinnedBuffer.cpp │ │ ├── gpuPlatform2.h │ │ ├── gpuProgram.cpp │ │ ├── gpuProgramDetail.h │ │ ├── gpuQueue.cpp │ │ ├── gpuQueueDetail.h │ │ └── ref.h │ ├── gpuApiException.cpp │ ├── gpuApiException.h │ ├── gpuBuffer.h │ ├── gpuConfig.in.h │ ├── gpuDevice.h │ ├── gpuDeviceInfo.h │ ├── gpuEvent.h │ ├── gpuEventList.cpp │ ├── gpuEventList.h │ ├── gpuException.cpp │ ├── gpuException.h │ ├── gpuKernel.h │ ├── gpuPinMode.h │ ├── gpuPinnedBuffer.h │ ├── gpuPlatform.h │ ├── gpuProgram.h │ ├── gpuQueue.h │ ├── gpuThrow.cpp │ ├── gpuThrow.h │ ├── gpuVersion.h │ └── gpu_ext.h ├── logutil/ │ ├── CMakeLists.txt │ ├── LogUtil.cpp │ ├── LogUtil.h │ ├── LogUtilConfig.in.h │ ├── Logger.cpp │ ├── Logger.h │ └── LoggerDetail.h ├── ohm/ │ ├── Aabb.h │ ├── CMakeLists.txt │ ├── CalculateSegmentKeys.cpp │ ├── CalculateSegmentKeys.h │ ├── ClearingPattern.cpp │ ├── ClearingPattern.h │ ├── CompareMaps.cpp │ ├── CompareMaps.h │ ├── CopyUtil.cpp │ ├── CopyUtil.h │ ├── CovarianceVoxel.cpp │ ├── CovarianceVoxel.h │ ├── CovarianceVoxelCompute.h │ ├── DataType.cpp │ ├── DataType.h │ ├── DebugDraw.cpp │ ├── DebugDraw.h │ ├── DebugIDs.h │ ├── DefaultLayer.cpp │ ├── DefaultLayer.h │ ├── Density.cpp │ ├── Density.h │ ├── Key.cpp │ ├── Key.h │ ├── KeyHash.cpp │ ├── KeyHash.h │ ├── KeyList.cpp │ ├── KeyList.h │ ├── KeyRange.cpp │ ├── KeyRange.h │ ├── KeyStream.h │ ├── LineKeysQuery.cpp │ ├── LineKeysQuery.h │ ├── LineQuery.cpp │ ├── LineQuery.h │ ├── LineWalk.h │ ├── LineWalkCompute.h │ ├── MapChunk.cpp │ ├── MapChunk.h │ ├── MapChunkFlag.h │ ├── MapCoord.h │ ├── MapFlag.cpp │ ├── MapFlag.h │ ├── MapInfo.cpp │ ├── MapInfo.h │ ├── MapLayer.cpp │ ├── MapLayer.h │ ├── MapLayout.cpp │ ├── MapLayout.h │ ├── MapLayoutMatch.h │ ├── MapProbability.h │ ├── MapRegion.cpp │ ├── MapRegion.h │ ├── MapRegionCache.cpp │ ├── MapRegionCache.h │ ├── MapSerialise.cpp │ ├── MapSerialise.h │ ├── Mapper.cpp │ ├── Mapper.h │ ├── MappingProcess.cpp │ ├── MappingProcess.h │ ├── Mutex.cpp │ ├── Mutex.h │ ├── NdtMap.cpp │ ├── NdtMap.h │ ├── NdtMode.cpp │ ├── NdtMode.h │ ├── NearestNeighbours.cpp │ ├── NearestNeighbours.h │ ├── OccupancyMap.cpp │ ├── OccupancyMap.h │ ├── OccupancyType.cpp │ ├── OccupancyType.h │ ├── OccupancyUtil.cpp │ ├── OccupancyUtil.h │ ├── OhmConfig.in.h │ ├── Query.cpp │ ├── Query.h │ ├── QueryFlag.h │ ├── RayFilter.cpp │ ├── RayFilter.h │ ├── RayFlag.h │ ├── RayMapper.cpp │ ├── RayMapper.h │ ├── RayMapperNdt.cpp │ ├── RayMapperNdt.h │ ├── RayMapperOccupancy.cpp │ ├── RayMapperOccupancy.h │ ├── RayMapperSecondarySample.cpp │ ├── RayMapperSecondarySample.h │ ├── RayMapperTrace.cpp │ ├── RayMapperTrace.h │ ├── RayMapperTsdf.cpp │ ├── RayMapperTsdf.h │ ├── RayPattern.cpp │ ├── RayPattern.h │ ├── RayPatternConical.cpp │ ├── RayPatternConical.h │ ├── RaysQuery.cpp │ ├── RaysQuery.h │ ├── Stream.cpp │ ├── Stream.h │ ├── Trace.cpp │ ├── Trace.h │ ├── Voxel.cpp │ ├── Voxel.h │ ├── VoxelBlock.cpp │ ├── VoxelBlock.h │ ├── VoxelBlockCompressionQueue.cpp │ ├── VoxelBlockCompressionQueue.h │ ├── VoxelBuffer.cpp │ ├── VoxelBuffer.h │ ├── VoxelData.h │ ├── VoxelIncident.h │ ├── VoxelIncidentCompute.h │ ├── VoxelLayout.cpp │ ├── VoxelLayout.h │ ├── VoxelMean.h │ ├── VoxelMeanCompute.h │ ├── VoxelOccupancy.h │ ├── VoxelOccupancyCompute.h │ ├── VoxelSecondarySample.h │ ├── VoxelTouchTime.h │ ├── VoxelTouchTimeCompute.h │ ├── VoxelTsdf.cpp │ ├── VoxelTsdf.h │ ├── VoxelTsdfCompute.h │ ├── private/ │ │ ├── ClearingPatternDetail.h │ │ ├── LineKeysQueryDetail.h │ │ ├── LineQueryDetail.h │ │ ├── MapLayerDetail.h │ │ ├── MapLayoutDetail.h │ │ ├── MapperDetail.h │ │ ├── NdtMapDetail.h │ │ ├── NearestNeighboursDetail.h │ │ ├── OccupancyMapDetail.cpp │ │ ├── OccupancyMapDetail.h │ │ ├── OccupancyQueryAlg.h │ │ ├── QueryDetail.h │ │ ├── RayPatternDetail.h │ │ ├── RaysQueryDetail.h │ │ ├── SerialiseUtil.h │ │ ├── VoxelAlgorithms.cpp │ │ ├── VoxelAlgorithms.h │ │ ├── VoxelBlockCompressionQueueDetail.h │ │ └── VoxelLayoutDetail.h │ └── serialise/ │ ├── MapSerialiseV0.1.cpp │ ├── MapSerialiseV0.1.h │ ├── MapSerialiseV0.2.cpp │ ├── MapSerialiseV0.2.h │ ├── MapSerialiseV0.4.cpp │ ├── MapSerialiseV0.4.h │ ├── MapSerialiseV0.5.cpp │ ├── MapSerialiseV0.5.h │ ├── MapSerialiseV0.cpp │ └── MapSerialiseV0.h ├── ohm.natvis ├── ohmapp/ │ ├── CMakeLists.txt │ ├── DataSource.cpp │ ├── DataSource.h │ ├── MapHarness.cpp │ ├── MapHarness.h │ ├── OhmAppConfig.in.h │ ├── OhmAppCpu.cpp │ ├── OhmAppCpu.h │ ├── OhmAppGpu.cpp │ ├── OhmAppGpu.h │ ├── OhmAppGpuConfig.in.h │ ├── SlamIOSource.cpp │ ├── SlamIOSource.h │ └── ohmappmain.inl ├── ohmgpu/ │ ├── CMakeLists.txt │ ├── ClearanceProcess.cpp │ ├── ClearanceProcess.h │ ├── GpuCache.cpp │ ├── GpuCache.h │ ├── GpuCachePostSyncHandler.h │ ├── GpuCacheStats.h │ ├── GpuKey.h │ ├── GpuLayerCache.cpp │ ├── GpuLayerCache.h │ ├── GpuLayerCacheParams.cpp │ ├── GpuLayerCacheParams.h │ ├── GpuMap.cpp │ ├── GpuMap.h │ ├── GpuNdtMap.cpp │ ├── GpuNdtMap.h │ ├── GpuTransformSamples.cpp │ ├── GpuTransformSamples.h │ ├── GpuTsdfMap.cpp │ ├── GpuTsdfMap.h │ ├── LineKeysQueryGpu.cpp │ ├── LineKeysQueryGpu.h │ ├── LineQueryGpu.cpp │ ├── LineQueryGpu.h │ ├── OhmGpu.cpp │ ├── OhmGpu.h │ ├── OhmGpuConfig.in.h │ ├── RayItem.h │ ├── RaysQueryGpu.cpp │ ├── RaysQueryGpu.h │ ├── gpu/ │ │ ├── AdjustNdt.cl │ │ ├── AdjustOccupancy.cl │ │ ├── CovarianceHitNdt.cl │ │ ├── CovarianceHitNdt.cu │ │ ├── CovarianceHitNdt_h.cl │ │ ├── LineKeys.cl │ │ ├── LineKeys.cu │ │ ├── LineWalk.cl │ │ ├── LineWalkMarkers.cl │ │ ├── RaysQuery.cl │ │ ├── RaysQuery.cu │ │ ├── RaysQueryResult.h │ │ ├── RegionUpdate.cl │ │ ├── RegionUpdate.cu │ │ ├── RegionUpdateNdt.cu │ │ ├── Regions.cl │ │ ├── RoiRangeFill.cl │ │ ├── RoiRangeFill.cu │ │ ├── TransformSamples.cl │ │ ├── TransformSamples.cu │ │ ├── Traversal.cl │ │ ├── TsdfUpdate.cl │ │ ├── TsdfUpdate.cu │ │ ├── VoxelIncident.cl │ │ └── VoxelMean.cl │ └── private/ │ ├── ClearanceProcessDetail.cpp │ ├── ClearanceProcessDetail.h │ ├── GpuMapDetail.cpp │ ├── GpuMapDetail.h │ ├── GpuNdtMapDetail.h │ ├── GpuProgramRef.cpp │ ├── GpuProgramRef.h │ ├── GpuTransformSamplesDetail.h │ ├── GpuTsdfMapDetail.h │ ├── LineKeysQueryDetailGpu.h │ ├── LineQueryDetailGpu.h │ ├── RaysQueryDetailGpu.cpp │ ├── RaysQueryDetailGpu.h │ ├── RoiRangeFill.cpp │ └── RoiRangeFill.h ├── ohmheightmap/ │ ├── 3rdparty/ │ │ └── delaunator.hpp │ ├── CMakeLists.txt │ ├── Heightmap.cpp │ ├── Heightmap.h │ ├── HeightmapMesh.cpp │ ├── HeightmapMesh.h │ ├── HeightmapMode.cpp │ ├── HeightmapMode.h │ ├── HeightmapSerialise.cpp │ ├── HeightmapSerialise.h │ ├── HeightmapUtil.cpp │ ├── HeightmapUtil.h │ ├── HeightmapVoxel.cpp │ ├── HeightmapVoxel.h │ ├── HeightmapVoxelType.h │ ├── OhmHeightmapConfig.in.h │ ├── PlaneFillLayeredWalker.cpp │ ├── PlaneFillLayeredWalker.h │ ├── PlaneFillWalker.cpp │ ├── PlaneFillWalker.h │ ├── PlaneWalkVisitMode.h │ ├── PlaneWalker.cpp │ ├── PlaneWalker.h │ ├── TriangleEdge.h │ ├── TriangleNeighbours.h │ ├── UpAxis.h │ └── private/ │ ├── HeightmapDetail.cpp │ ├── HeightmapDetail.h │ ├── HeightmapOperations.cpp │ └── HeightmapOperations.h ├── ohmheightmapimage/ │ ├── CMakeLists.txt │ ├── HeightmapImage.cpp │ ├── HeightmapImage.h │ └── OhmHeightmapImageConfig.in.h ├── ohmtools/ │ ├── CMakeLists.txt │ ├── OhmCloud.cpp │ ├── OhmCloud.h │ ├── OhmGen.cpp │ ├── OhmGen.h │ └── OhmToolsConfig.in.h ├── ohmutil/ │ ├── 3rdparty/ │ │ ├── cxxopts/ │ │ │ └── cxxopts.hpp │ │ └── ska/ │ │ ├── bytell_hash_map.hpp │ │ ├── flat_hash_map.hpp │ │ ├── ska_sort.hpp │ │ └── unordered_map.hpp │ ├── CMakeLists.txt │ ├── Colour.cpp │ ├── Colour.h │ ├── GlmStream.h │ ├── OhmUtilConfig.in.h │ ├── Options.h │ ├── PlyMesh.cpp │ ├── PlyMesh.h │ ├── PlyPointStream.cpp │ ├── PlyPointStream.h │ ├── Profile.cpp │ ├── Profile.h │ ├── ProfileMarker.cpp │ ├── ProfileMarker.h │ ├── ProgressMonitor.cpp │ ├── ProgressMonitor.h │ ├── SafeIO.cpp │ ├── SafeIO.h │ ├── ScopedTimeDisplay.cpp │ ├── ScopedTimeDisplay.h │ ├── VectorHash.h │ └── p2p.h ├── package.xml ├── readme.md ├── scripts/ │ ├── ohm-parse-timing.py │ ├── ohm-timing-run.py │ └── setup.cfg ├── slamio/ │ ├── CMakeLists.txt │ ├── DataChannel.h │ ├── PointCloudReader.cpp │ ├── PointCloudReader.h │ ├── PointCloudReaderPdal.cpp │ ├── PointCloudReaderPdal.h │ ├── PointCloudReaderPly.cpp │ ├── PointCloudReaderPly.h │ ├── PointCloudReaderTraj.cpp │ ├── PointCloudReaderTraj.h │ ├── PointCloudReaderXyz.cpp │ ├── PointCloudReaderXyz.h │ ├── Points.cpp │ ├── Points.h │ ├── SlamCloudLoader.cpp │ ├── SlamCloudLoader.h │ ├── SlamIO.cpp │ ├── SlamIO.h │ ├── SlamIOConfig.in.h │ ├── pdal/ │ │ ├── PointStream.cpp │ │ └── PointStream.h │ └── rply/ │ ├── LICENSE │ ├── rply.c │ ├── rply.h │ └── rplyfile.h ├── tests/ │ ├── CMakeLists.txt │ ├── data/ │ │ ├── CMakeLists.txt │ │ ├── readme.md │ │ ├── test-map.0.1.0.ohm │ │ ├── test-map.0.2.0.ohm │ │ ├── test-map.0.3.0.ohm │ │ ├── test-map.0.4.0.ohm │ │ └── test-map.0.ohm │ ├── gputiltest/ │ │ ├── CMakeLists.txt │ │ ├── GpuBufferTest.cpp │ │ ├── GpuDeviceTest.cpp │ │ ├── KernelTest.cpp │ │ ├── TestMain.cpp │ │ ├── cuda/ │ │ │ └── matrix_kernel.cu │ │ └── matrix.cl │ ├── ohmtest/ │ │ ├── CMakeLists.txt │ │ ├── CompressionTests.cpp │ │ ├── CopyTests.cpp │ │ ├── IncidentsTests.cpp │ │ ├── KeyTests.cpp │ │ ├── LayoutTests.cpp │ │ ├── LineQueryTests.cpp │ │ ├── LineWalkTests.cpp │ │ ├── MapTests.cpp │ │ ├── MathsTests.cpp │ │ ├── NdtTests.cpp │ │ ├── OhmConfig.in.h │ │ ├── OhmTestConfig.in.h │ │ ├── RayPatternTests.cpp │ │ ├── RayValidation.cpp │ │ ├── RayValidation.h │ │ ├── RaysQueryTests.cpp │ │ ├── SecondarySampleTests.cpp │ │ ├── SerialisationTests.cpp │ │ ├── TestMain.cpp │ │ ├── TouchTimeTests.cpp │ │ ├── TraversalTests.cpp │ │ ├── TsdfTests.cpp │ │ └── VoxelMeanTests.cpp │ ├── ohmtestcommon/ │ │ ├── CMakeLists.txt │ │ ├── CovarianceTestUtil.cpp │ │ ├── CovarianceTestUtil.h │ │ ├── OhmTestUtil.cpp │ │ ├── OhmTestUtil.h │ │ ├── RayPatternTestUtil.h │ │ ├── TraversalTest.cpp │ │ ├── TraversalTest.h │ │ ├── WalkSegmentKeysLegacy.cpp │ │ └── WalkSegmentKeysLegacy.h │ ├── ohmtestgpu/ │ │ ├── CMakeLists.txt │ │ ├── GpuCopyTests.cpp │ │ ├── GpuIncidentsTests.cpp │ │ ├── GpuLineKeysTests.cpp │ │ ├── GpuLineQueryTests.cpp │ │ ├── GpuMapTest.cpp │ │ ├── GpuMapperTests.cpp │ │ ├── GpuNdtTests.cpp │ │ ├── GpuRangesTests.cpp │ │ ├── GpuRayPatternTests.cpp │ │ ├── GpuRaysQueryTests.cpp │ │ ├── GpuSerialisationTests.cpp │ │ ├── GpuTestMain.cpp │ │ ├── GpuTests.cpp │ │ ├── GpuTouchTimeTests.cpp │ │ ├── GpuTraversalTests.cpp │ │ ├── GpuTsdfTests.cpp │ │ └── GpuVoxelMeanTests.cpp │ ├── ohmtestheightmap/ │ │ ├── CMakeLists.txt │ │ └── HeightmapTests.cpp │ └── slamiotest/ │ ├── CMakeLists.txt │ ├── Loader.cpp │ └── SlamCloudLoader.cpp ├── todo.md ├── utils/ │ ├── CMakeLists.txt │ ├── ohm2ply/ │ │ ├── CMakeLists.txt │ │ └── ohm2ply.cpp │ ├── ohmcmp/ │ │ ├── CMakeLists.txt │ │ └── ohmcmp.cpp │ ├── ohmfilter/ │ │ ├── CMakeLists.txt │ │ └── ohmfilter.cpp │ ├── ohmheightmap/ │ │ ├── CMakeLists.txt │ │ └── ohmheightmap.cpp │ ├── ohmhm2img/ │ │ ├── CMakeLists.txt │ │ └── ohmhm2img.cpp │ ├── ohminfo/ │ │ ├── CMakeLists.txt │ │ └── ohminfo.cpp │ ├── ohmpop/ │ │ ├── CMakeLists.txt │ │ ├── OhmPopConfig.in.h │ │ ├── ohmpopmaincpu.cpp │ │ └── ohmpopmaingpu.cpp │ ├── ohmprob/ │ │ ├── CMakeLists.txt │ │ └── ohmprob.cpp │ ├── ohmquery/ │ │ ├── CMakeLists.txt │ │ ├── OhmQueryConfig.in.h │ │ └── ohmquery.cpp │ └── ohmsubmap/ │ ├── CMakeLists.txt │ └── ohmsubmap.cpp └── vcpkg.json
Showing preview only (1,793K chars total). Download the full file or copy to clipboard to get everything.
SYMBOL INDEX (3267 symbols across 422 files)
FILE: 3rdparty/3es-core/3esservermacros.h
function namespace (line 7) | namespace tes
FILE: clu/3rdparty/CL/opencl.hpp
type cl (line 591) | namespace cl
type compatibility (line 651) | namespace compatibility
class size_t (line 658) | class size_t
method size_type (line 681) | size_type &operator[](int index) { return data_[index]; }
method size_type (line 683) | const size_type &operator[](int index) const { return data_[index]; }
type make_kernel (line 9290) | struct make_kernel
method make_kernel (line 9296) | make_kernel(const Program &program, const string name, cl_int *err...
method make_kernel (line 9300) | make_kernel(const Kernel kernel)
method Event (line 9310) | Event operator()(const EnqueueArgs &enqueueArgs, Ts... args) { ret...
type detail (line 712) | namespace detail
function cl_int (line 814) | static inline cl_int errHandler(cl_int err, const char *errStr = NULL)
function cl_int (line 823) | static inline cl_int errHandler(cl_int err, const char *errStr = NULL)
function cl_int (line 1008) | inline cl_int getInfoHelper(Functor f, cl_uint name, T *param, long)
function cl_int (line 1016) | inline cl_int getInfoHelper(Func f, cl_uint name, vector<vector<unsi...
function cl_int (line 1047) | inline cl_int getInfoHelper(Func f, cl_uint name, vector<T> *param, ...
function cl_int (line 1079) | inline cl_int getInfoHelper(Func f, cl_uint name, vector<T> *param, ...
function cl_int (line 1114) | inline cl_int getInfoHelper(Func f, cl_uint name, string *param, long)
function cl_int (line 1147) | inline cl_int getInfoHelper(Func f, cl_uint name, array<size_type, N...
type ReferenceHandler (line 1180) | struct ReferenceHandler
function cl_int (line 1189) | inline cl_int getInfoHelper(Func f, cl_uint name, T *param, int, typ...
type param_traits (line 1483) | struct param_traits
function cl_int (line 1669) | inline cl_int getInfo(Func f, cl_uint name, T *param)
type GetInfoFunctor0 (line 1675) | struct GetInfoFunctor0
method cl_int (line 1679) | cl_int operator()(cl_uint param, size_type size, void *value, size...
type GetInfoFunctor1 (line 1686) | struct GetInfoFunctor1
method cl_int (line 1691) | cl_int operator()(cl_uint param, size_type size, void *value, size...
function cl_int (line 1698) | inline cl_int getInfo(Func f, const Arg0 &arg0, cl_uint name, T *param)
function cl_int (line 1705) | inline cl_int getInfo(Func f, const Arg0 &arg0, const Arg1 &arg1, cl...
type ReferenceHandler (line 1713) | struct ReferenceHandler
type ReferenceHandler<cl_device_id> (line 1722) | struct ReferenceHandler<cl_device_id>
method cl_int (line 1733) | static cl_int retain(cl_device_id device) { return ::clRetainDevic...
method cl_int (line 1743) | static cl_int release(cl_device_id device) { return ::clReleaseDev...
method cl_int (line 1753) | static cl_int retain(cl_device_id) { return CL_SUCCESS; }
method cl_int (line 1755) | static cl_int release(cl_device_id) { return CL_SUCCESS; }
type ReferenceHandler<cl_device_id> (line 1750) | struct ReferenceHandler<cl_device_id>
method cl_int (line 1733) | static cl_int retain(cl_device_id device) { return ::clRetainDevic...
method cl_int (line 1743) | static cl_int release(cl_device_id device) { return ::clReleaseDev...
method cl_int (line 1753) | static cl_int retain(cl_device_id) { return CL_SUCCESS; }
method cl_int (line 1755) | static cl_int release(cl_device_id) { return CL_SUCCESS; }
type ReferenceHandler<cl_platform_id> (line 1760) | struct ReferenceHandler<cl_platform_id>
method cl_int (line 1763) | static cl_int retain(cl_platform_id) { return CL_SUCCESS; }
method cl_int (line 1765) | static cl_int release(cl_platform_id) { return CL_SUCCESS; }
type ReferenceHandler<cl_context> (line 1769) | struct ReferenceHandler<cl_context>
method cl_int (line 1771) | static cl_int retain(cl_context context) { return ::clRetainContex...
method cl_int (line 1772) | static cl_int release(cl_context context) { return ::clReleaseCont...
type ReferenceHandler<cl_command_queue> (line 1776) | struct ReferenceHandler<cl_command_queue>
method cl_int (line 1778) | static cl_int retain(cl_command_queue queue) { return ::clRetainCo...
method cl_int (line 1779) | static cl_int release(cl_command_queue queue) { return ::clRelease...
type ReferenceHandler<cl_mem> (line 1783) | struct ReferenceHandler<cl_mem>
method cl_int (line 1785) | static cl_int retain(cl_mem memory) { return ::clRetainMemObject(m...
method cl_int (line 1786) | static cl_int release(cl_mem memory) { return ::clReleaseMemObject...
type ReferenceHandler<cl_sampler> (line 1790) | struct ReferenceHandler<cl_sampler>
method cl_int (line 1792) | static cl_int retain(cl_sampler sampler) { return ::clRetainSample...
method cl_int (line 1793) | static cl_int release(cl_sampler sampler) { return ::clReleaseSamp...
type ReferenceHandler<cl_program> (line 1797) | struct ReferenceHandler<cl_program>
method cl_int (line 1799) | static cl_int retain(cl_program program) { return ::clRetainProgra...
method cl_int (line 1800) | static cl_int release(cl_program program) { return ::clReleaseProg...
type ReferenceHandler<cl_kernel> (line 1804) | struct ReferenceHandler<cl_kernel>
method cl_int (line 1806) | static cl_int retain(cl_kernel kernel) { return ::clRetainKernel(k...
method cl_int (line 1807) | static cl_int release(cl_kernel kernel) { return ::clReleaseKernel...
type ReferenceHandler<cl_event> (line 1811) | struct ReferenceHandler<cl_event>
method cl_int (line 1813) | static cl_int retain(cl_event event) { return ::clRetainEvent(even...
method cl_int (line 1814) | static cl_int release(cl_event event) { return ::clReleaseEvent(ev...
function cl_uint (line 1820) | static cl_uint getVersion(const vector<char> &versionInfo)
function cl_uint (line 1841) | static cl_uint getPlatformVersion(cl_platform_id platform)
function cl_uint (line 1851) | static cl_uint getDevicePlatformVersion(cl_device_id device)
function cl_uint (line 1858) | static cl_uint getContextPlatformVersion(cl_context context)
class Wrapper (line 1873) | class Wrapper
method Wrapper (line 1882) | Wrapper()
method Wrapper (line 1886) | Wrapper(const cl_type &obj, bool retainObject)
method Wrapper (line 1903) | Wrapper(const Wrapper<cl_type> &rhs)
method Wrapper (line 1909) | Wrapper(Wrapper<cl_type> &&rhs) CL_HPP_NOEXCEPT_
method cl_type (line 1944) | const cl_type &operator()() const { return object_; }
method cl_type (line 1946) | cl_type &operator()() { return object_; }
method cl_type (line 1948) | cl_type get() const { return object_; }
method cl_int (line 1954) | cl_int retain() const
method cl_int (line 1966) | cl_int release() const
class Wrapper<cl_device_id> (line 1980) | class Wrapper<cl_device_id>
method isReferenceCountable (line 1989) | static bool isReferenceCountable(cl_device_id device)
method Wrapper (line 2010) | Wrapper()
method Wrapper (line 2015) | Wrapper(const cl_type &obj, bool retainObject)
method Wrapper (line 2029) | Wrapper(const Wrapper<cl_type> &rhs)
method Wrapper (line 2036) | Wrapper(Wrapper<cl_type> &&rhs) CL_HPP_NOEXCEPT_
method cl_type (line 2077) | const cl_type &operator()() const { return object_; }
method cl_type (line 2079) | cl_type &operator()() { return object_; }
method cl_type (line 2081) | cl_type get() const { return object_; }
method cl_int (line 2090) | cl_int retain() const
method cl_int (line 2102) | cl_int release() const
function cl_int (line 2153) | static inline cl_int buildErrHandler(cl_int err, const char *errStr,...
function cl_int (line 2166) | static inline cl_int buildErrHandler(cl_int err, const char *errStr,...
class SVMTraitNull (line 3525) | class SVMTraitNull
method cl_svm_mem_flags (line 3528) | static cl_svm_mem_flags getSVMMemFlags() { return 0; }
class Deleter (line 3736) | class Deleter
method Deleter (line 3745) | Deleter(const Alloc &alloc, size_type copies)
type KernelArgumentHandler (line 5646) | struct KernelArgumentHandler
type KernelArgumentHandler<T, typename std::enable_if<!std::is_base_of<cl::Memory, T>::value>::type> (line 5651) | struct KernelArgumentHandler<T, typename std::enable_if<!std::is_bas...
method size_type (line 5653) | static size_type size(const T &) { return sizeof(T); }
method T (line 5654) | static const T *ptr(const T &value) { return &value; }
type KernelArgumentHandler<T, typename std::enable_if<std::is_base_of<cl::Memory, T>::value>::type> (line 5660) | struct KernelArgumentHandler<T, typename std::enable_if<std::is_base...
method size_type (line 5662) | static size_type size(const T &) { return sizeof(cl_mem); }
method cl_mem (line 5663) | static const cl_mem *ptr(const T &value) { return &(value()); }
type KernelArgumentHandler<LocalSpaceArg, void> (line 5669) | struct KernelArgumentHandler<LocalSpaceArg, void>
method size_type (line 5671) | static size_type size(const LocalSpaceArg &value) { return value.s...
type KernelArgumentHandler<cl::DeviceCommandQueue, void> (line 8429) | struct KernelArgumentHandler<cl::DeviceCommandQueue, void>
method size_type (line 8431) | static size_type size(const cl::DeviceCommandQueue &) { return siz...
method cl_command_queue (line 8432) | static const cl_command_queue *ptr(const cl::DeviceCommandQueue &v...
class Memory (line 726) | class Memory
method Memory (line 3407) | Memory()
method Memory (line 3422) | explicit Memory(const cl_mem &memory, bool retainObject)
method Memory (line 3431) | Memory &operator=(const cl_mem &rhs)
method Memory (line 3440) | Memory(const Memory &mem)
method Memory (line 3447) | Memory &operator=(const Memory &mem)
method Memory (line 3456) | Memory(Memory &&mem) CL_HPP_NOEXCEPT_ : detail::Wrapper<cl_type>(std...
method Memory (line 3461) | Memory &operator=(Memory &&mem)
method cl_int (line 3470) | cl_int getInfo(cl_mem_info name, T *param) const
method getInfo (line 3477) | typename detail::param_traits<detail::cl_mem_info, name>::param_type...
method cl_int (line 3502) | cl_int setDestructorCallback(void(CL_CALLBACK *pfn_notify)(cl_mem, v...
class Program (line 746) | class Program
method Program (line 6018) | Program(const string &source, bool build = false, cl_int *err = NULL)
method Program (line 6050) | Program(const Context &context, const string &source, bool build = f...
method Program (line 6084) | Program(const Sources &sources, cl_int *err = NULL)
method Program (line 6118) | Program(const Context &context, const Sources &sources, cl_int *err ...
method Program (line 6153) | Program(const vector<char> &IL, bool build = false, cl_int *err = NULL)
method Program (line 6199) | Program(const Context &context, const vector<char> &IL, bool build =...
method Program (line 6258) | Program(const Context &context, const vector<Device> &devices, const...
method Program (line 6322) | Program(const Context &context, const vector<Device> &devices, const...
method Program (line 6345) | Program() {}
method Program (line 6354) | explicit Program(const cl_program &program, bool retainObject = false)
method Program (line 6358) | Program &operator=(const cl_program &rhs)
method Program (line 6367) | Program(const Program &program)
method Program (line 6374) | Program &operator=(const Program &program)
method Program (line 6383) | Program(Program &&program) CL_HPP_NOEXCEPT_ : detail::Wrapper<cl_typ...
method Program (line 6388) | Program &operator=(Program &&program)
method cl_int (line 6394) | cl_int build(const vector<Device> &devices, const char *options = NULL,
method cl_int (line 6410) | cl_int build(const Device &device, const char *options = NULL,
method cl_int (line 6422) | cl_int build(const char *options = NULL, void(CL_CALLBACK *notifyFpt...
method cl_int (line 6431) | cl_int compile(const char *options = NULL, void(CL_CALLBACK *notifyF...
method cl_int (line 6440) | cl_int getInfo(cl_program_info name, T *param) const
method getInfo (line 6446) | typename detail::param_traits<detail::cl_program_info, name>::param_...
method cl_int (line 6458) | cl_int getBuildInfo(const Device &device, cl_program_build_info name...
method getBuildInfo (line 6465) | typename detail::param_traits<detail::cl_program_build_info, name>::...
method getBuildInfo (line 6483) | vector<std::pair<cl::Device, typename detail::param_traits<detail::c...
method cl_int (line 6526) | cl_int createKernels(vector<Kernel> *kernels)
method CL_API_PREFIX__VERSION_2_2_DEPRECATED (line 6571) | CL_API_PREFIX__VERSION_2_2_DEPRECATED cl_int
method setSpecializationConstant (line 6585) | typename std::enable_if<!std::is_pointer<T>::value, cl_int>::type se...
method cl_int (line 6596) | cl_int setSpecializationConstant(cl_uint index, size_type size, cons...
class Device (line 747) | class Device
method makeDefaultProvided (line 2234) | static void makeDefaultProvided(const Device &p) { default_ = p; }
method unitTestClearDefault (line 2244) | static void unitTestClearDefault() { default_ = Device(); }
method Device (line 2248) | Device()
method Device (line 2256) | explicit Device(const cl_device_id &device, bool retainObject = false)
method Device (line 2264) | static Device getDefault(cl_int *errResult = NULL)
method Device (line 2282) | static Device setDefault(const Device &default_device)
method Device (line 2293) | Device &operator=(const cl_device_id &rhs)
method Device (line 2302) | Device(const Device &dev)
method Device (line 2309) | Device &operator=(const Device &dev)
method Device (line 2318) | Device(Device &&dev) CL_HPP_NOEXCEPT_ : detail::Wrapper<cl_type>(std...
method Device (line 2323) | Device &operator=(Device &&dev)
method cl_int (line 2331) | cl_int getInfo(cl_device_info name, T *param) const
method getInfo (line 2338) | typename detail::param_traits<detail::cl_device_info, name>::param_t...
method cl_ulong (line 2357) | cl_ulong getHostTimer(cl_int *error = nullptr)
method getDeviceAndHostTimer (line 2379) | std::pair<cl_ulong, cl_ulong> getDeviceAndHostTimer(cl_int *error = ...
method cl_int (line 2397) | cl_int createSubDevices(const cl_device_partition_property *properti...
method cl_int (line 2436) | cl_int createSubDevices(const cl_device_partition_property_ext *prop...
class Context (line 748) | class Context
method makeDefault (line 2869) | static void makeDefault()
method makeDefaultProvided (line 2902) | static void makeDefaultProvided(const Context &c) { default_ = c; }
method unitTestClearDefault (line 2912) | static void unitTestClearDefault() { default_ = Context(); }
method Context (line 2919) | Context(const vector<Device> &devices, const cl_context_properties *...
method Context (line 2946) | Context(const Device &device, const cl_context_properties *propertie...
method Context (line 2967) | Context(cl_device_type type, const cl_context_properties *properties...
method Context (line 3057) | Context(const Context &ctx)
method Context (line 3064) | Context &operator=(const Context &ctx)
method Context (line 3073) | Context(Context &&ctx) CL_HPP_NOEXCEPT_ : detail::Wrapper<cl_type>(s...
method Context (line 3078) | Context &operator=(Context &&ctx)
method Context (line 3089) | static Context getDefault(cl_int *err = NULL)
method Context (line 3107) | static Context setDefault(const Context &default_context)
method Context (line 3115) | Context()
method Context (line 3124) | explicit Context(const cl_context &context, bool retainObject = false)
method Context (line 3133) | Context &operator=(const cl_context &rhs)
method cl_int (line 3141) | cl_int getInfo(cl_context_info name, T *param) const
method getInfo (line 3148) | typename detail::param_traits<detail::cl_context_info, name>::param_...
method cl_int (line 3163) | cl_int getSupportedImageFormats(cl_mem_flags flags, cl_mem_object_ty...
class CommandQueue (line 749) | class CommandQueue
method makeDefault (line 6759) | static void makeDefault()
method makeDefaultProvided (line 6794) | static void makeDefaultProvided(const CommandQueue &c) { default_ = ...
method unitTestClearDefault (line 6804) | static void unitTestClearDefault() { default_ = CommandQueue(); }
method CommandQueue (line 6812) | CommandQueue(cl_command_queue_properties properties, cl_int *err = N...
method CommandQueue (line 6882) | CommandQueue(QueueProperties properties, cl_int *err = NULL)
method CommandQueue (line 6948) | explicit CommandQueue(const Context &context, cl_command_queue_prope...
method CommandQueue (line 7016) | explicit CommandQueue(const Context &context, QueueProperties proper...
method CommandQueue (line 7078) | CommandQueue(const Context &context, const Device &device, cl_comman...
method CommandQueue (line 7127) | CommandQueue(const Context &context, const Device &device, QueueProp...
method CommandQueue (line 7172) | static CommandQueue getDefault(cl_int *err = NULL)
method CommandQueue (line 7194) | static CommandQueue setDefault(const CommandQueue &default_queue)
method CommandQueue (line 7201) | CommandQueue() {}
method CommandQueue (line 7210) | explicit CommandQueue(const cl_command_queue &commandQueue, bool ret...
method CommandQueue (line 7214) | CommandQueue &operator=(const cl_command_queue &rhs)
method CommandQueue (line 7223) | CommandQueue(const CommandQueue &queue)
method CommandQueue (line 7230) | CommandQueue &operator=(const CommandQueue &queue)
method CommandQueue (line 7239) | CommandQueue(CommandQueue &&queue) CL_HPP_NOEXCEPT_ : detail::Wrappe...
method CommandQueue (line 7244) | CommandQueue &operator=(CommandQueue &&queue)
method cl_int (line 7251) | cl_int getInfo(cl_command_queue_info name, T *param) const
method getInfo (line 7258) | typename detail::param_traits<detail::cl_command_queue_info, name>::...
method cl_int (line 7269) | cl_int enqueueReadBuffer(const Buffer &buffer, cl_bool blocking, siz...
method cl_int (line 7285) | cl_int enqueueWriteBuffer(const Buffer &buffer, cl_bool blocking, si...
method cl_int (line 7301) | cl_int enqueueCopyBuffer(const Buffer &src, const Buffer &dst, size_...
method cl_int (line 7317) | cl_int enqueueReadBufferRect(const Buffer &buffer, cl_bool blocking,...
method cl_int (line 7337) | cl_int enqueueWriteBufferRect(const Buffer &buffer, cl_bool blocking...
method cl_int (line 7357) | cl_int enqueueCopyBufferRect(const Buffer &src, const Buffer &dst, c...
method cl_int (line 7389) | cl_int enqueueFillBuffer(const Buffer &buffer, PatternType pattern, ...
method cl_int (line 7407) | cl_int enqueueReadImage(const Image &image, cl_bool blocking, const ...
method cl_int (line 7425) | cl_int enqueueWriteImage(const Image &image, cl_bool blocking, const...
method cl_int (line 7443) | cl_int enqueueCopyImage(const Image &src, const Image &dst, const ar...
method cl_int (line 7469) | cl_int enqueueFillImage(const Image &image, cl_float4 fillColor, con...
method cl_int (line 7494) | cl_int enqueueFillImage(const Image &image, cl_int4 fillColor, const...
method cl_int (line 7519) | cl_int enqueueFillImage(const Image &image, cl_uint4 fillColor, cons...
method cl_int (line 7538) | cl_int enqueueCopyImageToBuffer(const Image &src, const Buffer &dst,...
method cl_int (line 7556) | cl_int enqueueCopyBufferToImage(const Buffer &src, const Image &dst,...
method cl_int (line 7622) | cl_int enqueueMapSVM(T *ptr, cl_bool blocking, cl_map_flags flags, s...
method cl_int (line 7644) | cl_int enqueueMapSVM(cl::pointer<T, D> &ptr, cl_bool blocking, cl_ma...
method cl_int (line 7665) | cl_int enqueueMapSVM(cl::vector<T, Alloc> &container, cl_bool blocki...
method cl_int (line 7683) | cl_int enqueueUnmapMemObject(const Memory &memory, void *mapped_ptr,...
method cl_int (line 7706) | cl_int enqueueUnmapSVM(T *ptr, const vector<Event> *events = NULL, E...
method cl_int (line 7726) | cl_int enqueueUnmapSVM(cl::pointer<T, D> &ptr, const vector<Event> *...
method cl_int (line 7746) | cl_int enqueueUnmapSVM(cl::vector<T, Alloc> &container, const vector...
method cl_int (line 7774) | cl_int enqueueMarkerWithWaitList(const vector<Event> *events = 0, Ev...
method cl_int (line 7800) | cl_int enqueueBarrierWithWaitList(const vector<Event> *events = 0, E...
method cl_int (line 7819) | cl_int enqueueMigrateMemObjects(const vector<Memory> &memObjects, cl...
method cl_int (line 7853) | cl_int enqueueMigrateSVM(const cl::vector<T *> &svmRawPointers, cons...
method cl_int (line 7877) | cl_int enqueueMigrateSVM(const cl::vector<T *> &svmRawPointers, cl_m...
method cl_int (line 7890) | cl_int enqueueMigrateSVM(const cl::vector<cl::pointer<T, D>> &svmPoi...
method cl_int (line 7910) | cl_int enqueueMigrateSVM(const cl::vector<cl::pointer<T, D>> &svmPoi...
method cl_int (line 7922) | cl_int enqueueMigrateSVM(const cl::vector<cl::vector<T, Alloc>> &svm...
method cl_int (line 7941) | cl_int enqueueMigrateSVM(const cl::vector<cl::vector<T, Alloc>> &svm...
method cl_int (line 7949) | cl_int enqueueNDRangeKernel(const Kernel &kernel, const NDRange &off...
method CL_API_PREFIX__VERSION_1_2_DEPRECATED (line 7969) | CL_API_PREFIX__VERSION_1_2_DEPRECATED cl_int
method cl_int (line 7987) | cl_int enqueueNativeKernel(void(CL_CALLBACK *userFptr)(void *), std:...
method CL_API_PREFIX__VERSION_1_1_DEPRECATED (line 8021) | CL_API_PREFIX__VERSION_1_1_DEPRECATED
method CL_API_PREFIX__VERSION_1_1_DEPRECATED (line 8033) | CL_API_PREFIX__VERSION_1_1_DEPRECATED
method cl_int (line 8042) | cl_int enqueueAcquireGLObjects(const vector<Memory> *mem_objects = N...
method cl_int (line 8060) | cl_int enqueueReleaseGLObjects(const vector<Memory> *mem_objects = N...
method cl_int (line 8086) | cl_int enqueueAcquireD3D10Objects(const vector<Memory> *mem_objects ...
method cl_int (line 8115) | cl_int enqueueReleaseD3D10Objects(const vector<Memory> *mem_objects ...
method CL_API_PREFIX__VERSION_1_1_DEPRECATED (line 8149) | CL_API_PREFIX__VERSION_1_1_DEPRECATED
method cl_int (line 8156) | cl_int flush() const { return detail::errHandler(::clFlush(object_),...
method cl_int (line 8158) | cl_int finish() const { return detail::errHandler(::clFinish(object_...
class DeviceCommandQueue (line 750) | class DeviceCommandQueue
method DeviceCommandQueue (line 8188) | DeviceCommandQueue() {}
method DeviceCommandQueue (line 8193) | DeviceCommandQueue(DeviceQueueProperties properties, cl_int *err = N...
method DeviceCommandQueue (line 8215) | DeviceCommandQueue(const Context &context, const Device &device,
method DeviceCommandQueue (line 8235) | DeviceCommandQueue(const Context &context, const Device &device, cl_...
method DeviceCommandQueue (line 8258) | explicit DeviceCommandQueue(const cl_command_queue &commandQueue, bo...
method DeviceCommandQueue (line 8262) | DeviceCommandQueue &operator=(const cl_command_queue &rhs)
method DeviceCommandQueue (line 8271) | DeviceCommandQueue(const DeviceCommandQueue &queue)
method DeviceCommandQueue (line 8278) | DeviceCommandQueue &operator=(const DeviceCommandQueue &queue)
method DeviceCommandQueue (line 8287) | DeviceCommandQueue(DeviceCommandQueue &&queue) CL_HPP_NOEXCEPT_ : de...
method DeviceCommandQueue (line 8292) | DeviceCommandQueue &operator=(DeviceCommandQueue &&queue)
method cl_int (line 8299) | cl_int getInfo(cl_command_queue_info name, T *param) const
method getInfo (line 8306) | typename detail::param_traits<detail::cl_command_queue_info, name>::...
method DeviceCommandQueue (line 8323) | static DeviceCommandQueue makeDefault(cl_int *err = nullptr)
method DeviceCommandQueue (line 8349) | static DeviceCommandQueue makeDefault(const Context &context, const ...
method DeviceCommandQueue (line 8373) | static DeviceCommandQueue makeDefault(const Context &context, const ...
method DeviceCommandQueue (line 8400) | static DeviceCommandQueue updateDefault(const Context &context, cons...
method DeviceCommandQueue (line 8417) | static DeviceCommandQueue getDefault(const CommandQueue &queue, cl_i...
class Memory (line 751) | class Memory
method Memory (line 3407) | Memory()
method Memory (line 3422) | explicit Memory(const cl_mem &memory, bool retainObject)
method Memory (line 3431) | Memory &operator=(const cl_mem &rhs)
method Memory (line 3440) | Memory(const Memory &mem)
method Memory (line 3447) | Memory &operator=(const Memory &mem)
method Memory (line 3456) | Memory(Memory &&mem) CL_HPP_NOEXCEPT_ : detail::Wrapper<cl_type>(std...
method Memory (line 3461) | Memory &operator=(Memory &&mem)
method cl_int (line 3470) | cl_int getInfo(cl_mem_info name, T *param) const
method getInfo (line 3477) | typename detail::param_traits<detail::cl_mem_info, name>::param_type...
method cl_int (line 3502) | cl_int setDestructorCallback(void(CL_CALLBACK *pfn_notify)(cl_mem, v...
class Buffer (line 752) | class Buffer
method Buffer (line 3845) | Buffer(const Context &context, cl_mem_flags flags, size_type size, v...
method Buffer (line 3866) | Buffer(cl_mem_flags flags, size_type size, void *host_ptr = NULL, cl...
method Buffer (line 3887) | Buffer(IteratorType startIterator, IteratorType endIterator, bool re...
method Buffer (line 3955) | Buffer()
method Buffer (line 3966) | explicit Buffer(const cl_mem &buffer, bool retainObject = false)
method Buffer (line 3974) | Buffer &operator=(const cl_mem &rhs)
method Buffer (line 3983) | Buffer(const Buffer &buf)
method Buffer (line 3990) | Buffer &operator=(const Buffer &buf)
method Buffer (line 3999) | Buffer(Buffer &&buf) CL_HPP_NOEXCEPT_ : Memory(std::move(buf)) {}
method Buffer (line 4004) | Buffer &operator=(Buffer &&buf)
method Buffer (line 4015) | Buffer createSubBuffer(cl_mem_flags flags, cl_buffer_create_type buf...
class Pipe (line 753) | class Pipe
method Pipe (line 5327) | Pipe(const Context &context, cl_uint packet_size, cl_uint max_packet...
method Pipe (line 5349) | Pipe(cl_uint packet_size, cl_uint max_packets, cl_int *err = NULL)
method Pipe (line 5366) | Pipe()
method Pipe (line 5377) | explicit Pipe(const cl_mem &pipe, bool retainObject = false)
method Pipe (line 5385) | Pipe &operator=(const cl_mem &rhs)
method Pipe (line 5394) | Pipe(const Pipe &pipe)
method Pipe (line 5401) | Pipe &operator=(const Pipe &pipe)
method Pipe (line 5410) | Pipe(Pipe &&pipe) CL_HPP_NOEXCEPT_ : Memory(std::move(pipe)) {}
method Pipe (line 5415) | Pipe &operator=(Pipe &&pipe)
method cl_int (line 5423) | cl_int getInfo(cl_pipe_info name, T *param) const
method getInfo (line 5430) | typename detail::param_traits<detail::cl_pipe_info, name>::param_typ...
class Error (line 760) | class Error : public std::exception
method Error (line 776) | Error(cl_int err, const char *errStr = NULL)
method cl_int (line 803) | cl_int err(void) const { return err_; }
type detail (line 811) | namespace detail
function cl_int (line 814) | static inline cl_int errHandler(cl_int err, const char *errStr = NULL)
function cl_int (line 823) | static inline cl_int errHandler(cl_int err, const char *errStr = NULL)
function cl_int (line 1008) | inline cl_int getInfoHelper(Functor f, cl_uint name, T *param, long)
function cl_int (line 1016) | inline cl_int getInfoHelper(Func f, cl_uint name, vector<vector<unsi...
function cl_int (line 1047) | inline cl_int getInfoHelper(Func f, cl_uint name, vector<T> *param, ...
function cl_int (line 1079) | inline cl_int getInfoHelper(Func f, cl_uint name, vector<T> *param, ...
function cl_int (line 1114) | inline cl_int getInfoHelper(Func f, cl_uint name, string *param, long)
function cl_int (line 1147) | inline cl_int getInfoHelper(Func f, cl_uint name, array<size_type, N...
type ReferenceHandler (line 1180) | struct ReferenceHandler
function cl_int (line 1189) | inline cl_int getInfoHelper(Func f, cl_uint name, T *param, int, typ...
type param_traits (line 1483) | struct param_traits
function cl_int (line 1669) | inline cl_int getInfo(Func f, cl_uint name, T *param)
type GetInfoFunctor0 (line 1675) | struct GetInfoFunctor0
method cl_int (line 1679) | cl_int operator()(cl_uint param, size_type size, void *value, size...
type GetInfoFunctor1 (line 1686) | struct GetInfoFunctor1
method cl_int (line 1691) | cl_int operator()(cl_uint param, size_type size, void *value, size...
function cl_int (line 1698) | inline cl_int getInfo(Func f, const Arg0 &arg0, cl_uint name, T *param)
function cl_int (line 1705) | inline cl_int getInfo(Func f, const Arg0 &arg0, const Arg1 &arg1, cl...
type ReferenceHandler (line 1713) | struct ReferenceHandler
type ReferenceHandler<cl_device_id> (line 1722) | struct ReferenceHandler<cl_device_id>
method cl_int (line 1733) | static cl_int retain(cl_device_id device) { return ::clRetainDevic...
method cl_int (line 1743) | static cl_int release(cl_device_id device) { return ::clReleaseDev...
method cl_int (line 1753) | static cl_int retain(cl_device_id) { return CL_SUCCESS; }
method cl_int (line 1755) | static cl_int release(cl_device_id) { return CL_SUCCESS; }
type ReferenceHandler<cl_device_id> (line 1750) | struct ReferenceHandler<cl_device_id>
method cl_int (line 1733) | static cl_int retain(cl_device_id device) { return ::clRetainDevic...
method cl_int (line 1743) | static cl_int release(cl_device_id device) { return ::clReleaseDev...
method cl_int (line 1753) | static cl_int retain(cl_device_id) { return CL_SUCCESS; }
method cl_int (line 1755) | static cl_int release(cl_device_id) { return CL_SUCCESS; }
type ReferenceHandler<cl_platform_id> (line 1760) | struct ReferenceHandler<cl_platform_id>
method cl_int (line 1763) | static cl_int retain(cl_platform_id) { return CL_SUCCESS; }
method cl_int (line 1765) | static cl_int release(cl_platform_id) { return CL_SUCCESS; }
type ReferenceHandler<cl_context> (line 1769) | struct ReferenceHandler<cl_context>
method cl_int (line 1771) | static cl_int retain(cl_context context) { return ::clRetainContex...
method cl_int (line 1772) | static cl_int release(cl_context context) { return ::clReleaseCont...
type ReferenceHandler<cl_command_queue> (line 1776) | struct ReferenceHandler<cl_command_queue>
method cl_int (line 1778) | static cl_int retain(cl_command_queue queue) { return ::clRetainCo...
method cl_int (line 1779) | static cl_int release(cl_command_queue queue) { return ::clRelease...
type ReferenceHandler<cl_mem> (line 1783) | struct ReferenceHandler<cl_mem>
method cl_int (line 1785) | static cl_int retain(cl_mem memory) { return ::clRetainMemObject(m...
method cl_int (line 1786) | static cl_int release(cl_mem memory) { return ::clReleaseMemObject...
type ReferenceHandler<cl_sampler> (line 1790) | struct ReferenceHandler<cl_sampler>
method cl_int (line 1792) | static cl_int retain(cl_sampler sampler) { return ::clRetainSample...
method cl_int (line 1793) | static cl_int release(cl_sampler sampler) { return ::clReleaseSamp...
type ReferenceHandler<cl_program> (line 1797) | struct ReferenceHandler<cl_program>
method cl_int (line 1799) | static cl_int retain(cl_program program) { return ::clRetainProgra...
method cl_int (line 1800) | static cl_int release(cl_program program) { return ::clReleaseProg...
type ReferenceHandler<cl_kernel> (line 1804) | struct ReferenceHandler<cl_kernel>
method cl_int (line 1806) | static cl_int retain(cl_kernel kernel) { return ::clRetainKernel(k...
method cl_int (line 1807) | static cl_int release(cl_kernel kernel) { return ::clReleaseKernel...
type ReferenceHandler<cl_event> (line 1811) | struct ReferenceHandler<cl_event>
method cl_int (line 1813) | static cl_int retain(cl_event event) { return ::clRetainEvent(even...
method cl_int (line 1814) | static cl_int release(cl_event event) { return ::clReleaseEvent(ev...
function cl_uint (line 1820) | static cl_uint getVersion(const vector<char> &versionInfo)
function cl_uint (line 1841) | static cl_uint getPlatformVersion(cl_platform_id platform)
function cl_uint (line 1851) | static cl_uint getDevicePlatformVersion(cl_device_id device)
function cl_uint (line 1858) | static cl_uint getContextPlatformVersion(cl_context context)
class Wrapper (line 1873) | class Wrapper
method Wrapper (line 1882) | Wrapper()
method Wrapper (line 1886) | Wrapper(const cl_type &obj, bool retainObject)
method Wrapper (line 1903) | Wrapper(const Wrapper<cl_type> &rhs)
method Wrapper (line 1909) | Wrapper(Wrapper<cl_type> &&rhs) CL_HPP_NOEXCEPT_
method cl_type (line 1944) | const cl_type &operator()() const { return object_; }
method cl_type (line 1946) | cl_type &operator()() { return object_; }
method cl_type (line 1948) | cl_type get() const { return object_; }
method cl_int (line 1954) | cl_int retain() const
method cl_int (line 1966) | cl_int release() const
class Wrapper<cl_device_id> (line 1980) | class Wrapper<cl_device_id>
method isReferenceCountable (line 1989) | static bool isReferenceCountable(cl_device_id device)
method Wrapper (line 2010) | Wrapper()
method Wrapper (line 2015) | Wrapper(const cl_type &obj, bool retainObject)
method Wrapper (line 2029) | Wrapper(const Wrapper<cl_type> &rhs)
method Wrapper (line 2036) | Wrapper(Wrapper<cl_type> &&rhs) CL_HPP_NOEXCEPT_
method cl_type (line 2077) | const cl_type &operator()() const { return object_; }
method cl_type (line 2079) | cl_type &operator()() { return object_; }
method cl_type (line 2081) | cl_type get() const { return object_; }
method cl_int (line 2090) | cl_int retain() const
method cl_int (line 2102) | cl_int release() const
function cl_int (line 2153) | static inline cl_int buildErrHandler(cl_int err, const char *errStr,...
function cl_int (line 2166) | static inline cl_int buildErrHandler(cl_int err, const char *errStr,...
class SVMTraitNull (line 3525) | class SVMTraitNull
method cl_svm_mem_flags (line 3528) | static cl_svm_mem_flags getSVMMemFlags() { return 0; }
class Deleter (line 3736) | class Deleter
method Deleter (line 3745) | Deleter(const Alloc &alloc, size_type copies)
type KernelArgumentHandler (line 5646) | struct KernelArgumentHandler
type KernelArgumentHandler<T, typename std::enable_if<!std::is_base_of<cl::Memory, T>::value>::type> (line 5651) | struct KernelArgumentHandler<T, typename std::enable_if<!std::is_bas...
method size_type (line 5653) | static size_type size(const T &) { return sizeof(T); }
method T (line 5654) | static const T *ptr(const T &value) { return &value; }
type KernelArgumentHandler<T, typename std::enable_if<std::is_base_of<cl::Memory, T>::value>::type> (line 5660) | struct KernelArgumentHandler<T, typename std::enable_if<std::is_base...
method size_type (line 5662) | static size_type size(const T &) { return sizeof(cl_mem); }
method cl_mem (line 5663) | static const cl_mem *ptr(const T &value) { return &(value()); }
type KernelArgumentHandler<LocalSpaceArg, void> (line 5669) | struct KernelArgumentHandler<LocalSpaceArg, void>
method size_type (line 5671) | static size_type size(const LocalSpaceArg &value) { return value.s...
type KernelArgumentHandler<cl::DeviceCommandQueue, void> (line 8429) | struct KernelArgumentHandler<cl::DeviceCommandQueue, void>
method size_type (line 8431) | static size_type size(const cl::DeviceCommandQueue &) { return siz...
method cl_command_queue (line 8432) | static const cl_command_queue *ptr(const cl::DeviceCommandQueue &v...
type detail (line 1001) | namespace detail
function cl_int (line 814) | static inline cl_int errHandler(cl_int err, const char *errStr = NULL)
function cl_int (line 823) | static inline cl_int errHandler(cl_int err, const char *errStr = NULL)
function cl_int (line 1008) | inline cl_int getInfoHelper(Functor f, cl_uint name, T *param, long)
function cl_int (line 1016) | inline cl_int getInfoHelper(Func f, cl_uint name, vector<vector<unsi...
function cl_int (line 1047) | inline cl_int getInfoHelper(Func f, cl_uint name, vector<T> *param, ...
function cl_int (line 1079) | inline cl_int getInfoHelper(Func f, cl_uint name, vector<T> *param, ...
function cl_int (line 1114) | inline cl_int getInfoHelper(Func f, cl_uint name, string *param, long)
function cl_int (line 1147) | inline cl_int getInfoHelper(Func f, cl_uint name, array<size_type, N...
type ReferenceHandler (line 1180) | struct ReferenceHandler
function cl_int (line 1189) | inline cl_int getInfoHelper(Func f, cl_uint name, T *param, int, typ...
type param_traits (line 1483) | struct param_traits
function cl_int (line 1669) | inline cl_int getInfo(Func f, cl_uint name, T *param)
type GetInfoFunctor0 (line 1675) | struct GetInfoFunctor0
method cl_int (line 1679) | cl_int operator()(cl_uint param, size_type size, void *value, size...
type GetInfoFunctor1 (line 1686) | struct GetInfoFunctor1
method cl_int (line 1691) | cl_int operator()(cl_uint param, size_type size, void *value, size...
function cl_int (line 1698) | inline cl_int getInfo(Func f, const Arg0 &arg0, cl_uint name, T *param)
function cl_int (line 1705) | inline cl_int getInfo(Func f, const Arg0 &arg0, const Arg1 &arg1, cl...
type ReferenceHandler (line 1713) | struct ReferenceHandler
type ReferenceHandler<cl_device_id> (line 1722) | struct ReferenceHandler<cl_device_id>
method cl_int (line 1733) | static cl_int retain(cl_device_id device) { return ::clRetainDevic...
method cl_int (line 1743) | static cl_int release(cl_device_id device) { return ::clReleaseDev...
method cl_int (line 1753) | static cl_int retain(cl_device_id) { return CL_SUCCESS; }
method cl_int (line 1755) | static cl_int release(cl_device_id) { return CL_SUCCESS; }
type ReferenceHandler<cl_device_id> (line 1750) | struct ReferenceHandler<cl_device_id>
method cl_int (line 1733) | static cl_int retain(cl_device_id device) { return ::clRetainDevic...
method cl_int (line 1743) | static cl_int release(cl_device_id device) { return ::clReleaseDev...
method cl_int (line 1753) | static cl_int retain(cl_device_id) { return CL_SUCCESS; }
method cl_int (line 1755) | static cl_int release(cl_device_id) { return CL_SUCCESS; }
type ReferenceHandler<cl_platform_id> (line 1760) | struct ReferenceHandler<cl_platform_id>
method cl_int (line 1763) | static cl_int retain(cl_platform_id) { return CL_SUCCESS; }
method cl_int (line 1765) | static cl_int release(cl_platform_id) { return CL_SUCCESS; }
type ReferenceHandler<cl_context> (line 1769) | struct ReferenceHandler<cl_context>
method cl_int (line 1771) | static cl_int retain(cl_context context) { return ::clRetainContex...
method cl_int (line 1772) | static cl_int release(cl_context context) { return ::clReleaseCont...
type ReferenceHandler<cl_command_queue> (line 1776) | struct ReferenceHandler<cl_command_queue>
method cl_int (line 1778) | static cl_int retain(cl_command_queue queue) { return ::clRetainCo...
method cl_int (line 1779) | static cl_int release(cl_command_queue queue) { return ::clRelease...
type ReferenceHandler<cl_mem> (line 1783) | struct ReferenceHandler<cl_mem>
method cl_int (line 1785) | static cl_int retain(cl_mem memory) { return ::clRetainMemObject(m...
method cl_int (line 1786) | static cl_int release(cl_mem memory) { return ::clReleaseMemObject...
type ReferenceHandler<cl_sampler> (line 1790) | struct ReferenceHandler<cl_sampler>
method cl_int (line 1792) | static cl_int retain(cl_sampler sampler) { return ::clRetainSample...
method cl_int (line 1793) | static cl_int release(cl_sampler sampler) { return ::clReleaseSamp...
type ReferenceHandler<cl_program> (line 1797) | struct ReferenceHandler<cl_program>
method cl_int (line 1799) | static cl_int retain(cl_program program) { return ::clRetainProgra...
method cl_int (line 1800) | static cl_int release(cl_program program) { return ::clReleaseProg...
type ReferenceHandler<cl_kernel> (line 1804) | struct ReferenceHandler<cl_kernel>
method cl_int (line 1806) | static cl_int retain(cl_kernel kernel) { return ::clRetainKernel(k...
method cl_int (line 1807) | static cl_int release(cl_kernel kernel) { return ::clReleaseKernel...
type ReferenceHandler<cl_event> (line 1811) | struct ReferenceHandler<cl_event>
method cl_int (line 1813) | static cl_int retain(cl_event event) { return ::clRetainEvent(even...
method cl_int (line 1814) | static cl_int release(cl_event event) { return ::clReleaseEvent(ev...
function cl_uint (line 1820) | static cl_uint getVersion(const vector<char> &versionInfo)
function cl_uint (line 1841) | static cl_uint getPlatformVersion(cl_platform_id platform)
function cl_uint (line 1851) | static cl_uint getDevicePlatformVersion(cl_device_id device)
function cl_uint (line 1858) | static cl_uint getContextPlatformVersion(cl_context context)
class Wrapper (line 1873) | class Wrapper
method Wrapper (line 1882) | Wrapper()
method Wrapper (line 1886) | Wrapper(const cl_type &obj, bool retainObject)
method Wrapper (line 1903) | Wrapper(const Wrapper<cl_type> &rhs)
method Wrapper (line 1909) | Wrapper(Wrapper<cl_type> &&rhs) CL_HPP_NOEXCEPT_
method cl_type (line 1944) | const cl_type &operator()() const { return object_; }
method cl_type (line 1946) | cl_type &operator()() { return object_; }
method cl_type (line 1948) | cl_type get() const { return object_; }
method cl_int (line 1954) | cl_int retain() const
method cl_int (line 1966) | cl_int release() const
class Wrapper<cl_device_id> (line 1980) | class Wrapper<cl_device_id>
method isReferenceCountable (line 1989) | static bool isReferenceCountable(cl_device_id device)
method Wrapper (line 2010) | Wrapper()
method Wrapper (line 2015) | Wrapper(const cl_type &obj, bool retainObject)
method Wrapper (line 2029) | Wrapper(const Wrapper<cl_type> &rhs)
method Wrapper (line 2036) | Wrapper(Wrapper<cl_type> &&rhs) CL_HPP_NOEXCEPT_
method cl_type (line 2077) | const cl_type &operator()() const { return object_; }
method cl_type (line 2079) | cl_type &operator()() { return object_; }
method cl_type (line 2081) | cl_type get() const { return object_; }
method cl_int (line 2090) | cl_int retain() const
method cl_int (line 2102) | cl_int release() const
function cl_int (line 2153) | static inline cl_int buildErrHandler(cl_int err, const char *errStr,...
function cl_int (line 2166) | static inline cl_int buildErrHandler(cl_int err, const char *errStr,...
class SVMTraitNull (line 3525) | class SVMTraitNull
method cl_svm_mem_flags (line 3528) | static cl_svm_mem_flags getSVMMemFlags() { return 0; }
class Deleter (line 3736) | class Deleter
method Deleter (line 3745) | Deleter(const Alloc &alloc, size_type copies)
type KernelArgumentHandler (line 5646) | struct KernelArgumentHandler
type KernelArgumentHandler<T, typename std::enable_if<!std::is_base_of<cl::Memory, T>::value>::type> (line 5651) | struct KernelArgumentHandler<T, typename std::enable_if<!std::is_bas...
method size_type (line 5653) | static size_type size(const T &) { return sizeof(T); }
method T (line 5654) | static const T *ptr(const T &value) { return &value; }
type KernelArgumentHandler<T, typename std::enable_if<std::is_base_of<cl::Memory, T>::value>::type> (line 5660) | struct KernelArgumentHandler<T, typename std::enable_if<std::is_base...
method size_type (line 5662) | static size_type size(const T &) { return sizeof(cl_mem); }
method cl_mem (line 5663) | static const cl_mem *ptr(const T &value) { return &(value()); }
type KernelArgumentHandler<LocalSpaceArg, void> (line 5669) | struct KernelArgumentHandler<LocalSpaceArg, void>
method size_type (line 5671) | static size_type size(const LocalSpaceArg &value) { return value.s...
type KernelArgumentHandler<cl::DeviceCommandQueue, void> (line 8429) | struct KernelArgumentHandler<cl::DeviceCommandQueue, void>
method size_type (line 8431) | static size_type size(const cl::DeviceCommandQueue &) { return siz...
method cl_command_queue (line 8432) | static const cl_command_queue *ptr(const cl::DeviceCommandQueue &v...
class BuildError (line 2138) | class BuildError : public Error
method BuildError (line 2144) | BuildError(cl_int err, const char *errStr, const BuildLogType &vec)
method BuildLogType (line 2149) | BuildLogType getBuildLog() const { return buildLogs; }
type detail (line 2151) | namespace detail
function cl_int (line 814) | static inline cl_int errHandler(cl_int err, const char *errStr = NULL)
function cl_int (line 823) | static inline cl_int errHandler(cl_int err, const char *errStr = NULL)
function cl_int (line 1008) | inline cl_int getInfoHelper(Functor f, cl_uint name, T *param, long)
function cl_int (line 1016) | inline cl_int getInfoHelper(Func f, cl_uint name, vector<vector<unsi...
function cl_int (line 1047) | inline cl_int getInfoHelper(Func f, cl_uint name, vector<T> *param, ...
function cl_int (line 1079) | inline cl_int getInfoHelper(Func f, cl_uint name, vector<T> *param, ...
function cl_int (line 1114) | inline cl_int getInfoHelper(Func f, cl_uint name, string *param, long)
function cl_int (line 1147) | inline cl_int getInfoHelper(Func f, cl_uint name, array<size_type, N...
type ReferenceHandler (line 1180) | struct ReferenceHandler
function cl_int (line 1189) | inline cl_int getInfoHelper(Func f, cl_uint name, T *param, int, typ...
type param_traits (line 1483) | struct param_traits
function cl_int (line 1669) | inline cl_int getInfo(Func f, cl_uint name, T *param)
type GetInfoFunctor0 (line 1675) | struct GetInfoFunctor0
method cl_int (line 1679) | cl_int operator()(cl_uint param, size_type size, void *value, size...
type GetInfoFunctor1 (line 1686) | struct GetInfoFunctor1
method cl_int (line 1691) | cl_int operator()(cl_uint param, size_type size, void *value, size...
function cl_int (line 1698) | inline cl_int getInfo(Func f, const Arg0 &arg0, cl_uint name, T *param)
function cl_int (line 1705) | inline cl_int getInfo(Func f, const Arg0 &arg0, const Arg1 &arg1, cl...
type ReferenceHandler (line 1713) | struct ReferenceHandler
type ReferenceHandler<cl_device_id> (line 1722) | struct ReferenceHandler<cl_device_id>
method cl_int (line 1733) | static cl_int retain(cl_device_id device) { return ::clRetainDevic...
method cl_int (line 1743) | static cl_int release(cl_device_id device) { return ::clReleaseDev...
method cl_int (line 1753) | static cl_int retain(cl_device_id) { return CL_SUCCESS; }
method cl_int (line 1755) | static cl_int release(cl_device_id) { return CL_SUCCESS; }
type ReferenceHandler<cl_device_id> (line 1750) | struct ReferenceHandler<cl_device_id>
method cl_int (line 1733) | static cl_int retain(cl_device_id device) { return ::clRetainDevic...
method cl_int (line 1743) | static cl_int release(cl_device_id device) { return ::clReleaseDev...
method cl_int (line 1753) | static cl_int retain(cl_device_id) { return CL_SUCCESS; }
method cl_int (line 1755) | static cl_int release(cl_device_id) { return CL_SUCCESS; }
type ReferenceHandler<cl_platform_id> (line 1760) | struct ReferenceHandler<cl_platform_id>
method cl_int (line 1763) | static cl_int retain(cl_platform_id) { return CL_SUCCESS; }
method cl_int (line 1765) | static cl_int release(cl_platform_id) { return CL_SUCCESS; }
type ReferenceHandler<cl_context> (line 1769) | struct ReferenceHandler<cl_context>
method cl_int (line 1771) | static cl_int retain(cl_context context) { return ::clRetainContex...
method cl_int (line 1772) | static cl_int release(cl_context context) { return ::clReleaseCont...
type ReferenceHandler<cl_command_queue> (line 1776) | struct ReferenceHandler<cl_command_queue>
method cl_int (line 1778) | static cl_int retain(cl_command_queue queue) { return ::clRetainCo...
method cl_int (line 1779) | static cl_int release(cl_command_queue queue) { return ::clRelease...
type ReferenceHandler<cl_mem> (line 1783) | struct ReferenceHandler<cl_mem>
method cl_int (line 1785) | static cl_int retain(cl_mem memory) { return ::clRetainMemObject(m...
method cl_int (line 1786) | static cl_int release(cl_mem memory) { return ::clReleaseMemObject...
type ReferenceHandler<cl_sampler> (line 1790) | struct ReferenceHandler<cl_sampler>
method cl_int (line 1792) | static cl_int retain(cl_sampler sampler) { return ::clRetainSample...
method cl_int (line 1793) | static cl_int release(cl_sampler sampler) { return ::clReleaseSamp...
type ReferenceHandler<cl_program> (line 1797) | struct ReferenceHandler<cl_program>
method cl_int (line 1799) | static cl_int retain(cl_program program) { return ::clRetainProgra...
method cl_int (line 1800) | static cl_int release(cl_program program) { return ::clReleaseProg...
type ReferenceHandler<cl_kernel> (line 1804) | struct ReferenceHandler<cl_kernel>
method cl_int (line 1806) | static cl_int retain(cl_kernel kernel) { return ::clRetainKernel(k...
method cl_int (line 1807) | static cl_int release(cl_kernel kernel) { return ::clReleaseKernel...
type ReferenceHandler<cl_event> (line 1811) | struct ReferenceHandler<cl_event>
method cl_int (line 1813) | static cl_int retain(cl_event event) { return ::clRetainEvent(even...
method cl_int (line 1814) | static cl_int release(cl_event event) { return ::clReleaseEvent(ev...
function cl_uint (line 1820) | static cl_uint getVersion(const vector<char> &versionInfo)
function cl_uint (line 1841) | static cl_uint getPlatformVersion(cl_platform_id platform)
function cl_uint (line 1851) | static cl_uint getDevicePlatformVersion(cl_device_id device)
function cl_uint (line 1858) | static cl_uint getContextPlatformVersion(cl_context context)
class Wrapper (line 1873) | class Wrapper
method Wrapper (line 1882) | Wrapper()
method Wrapper (line 1886) | Wrapper(const cl_type &obj, bool retainObject)
method Wrapper (line 1903) | Wrapper(const Wrapper<cl_type> &rhs)
method Wrapper (line 1909) | Wrapper(Wrapper<cl_type> &&rhs) CL_HPP_NOEXCEPT_
method cl_type (line 1944) | const cl_type &operator()() const { return object_; }
method cl_type (line 1946) | cl_type &operator()() { return object_; }
method cl_type (line 1948) | cl_type get() const { return object_; }
method cl_int (line 1954) | cl_int retain() const
method cl_int (line 1966) | cl_int release() const
class Wrapper<cl_device_id> (line 1980) | class Wrapper<cl_device_id>
method isReferenceCountable (line 1989) | static bool isReferenceCountable(cl_device_id device)
method Wrapper (line 2010) | Wrapper()
method Wrapper (line 2015) | Wrapper(const cl_type &obj, bool retainObject)
method Wrapper (line 2029) | Wrapper(const Wrapper<cl_type> &rhs)
method Wrapper (line 2036) | Wrapper(Wrapper<cl_type> &&rhs) CL_HPP_NOEXCEPT_
method cl_type (line 2077) | const cl_type &operator()() const { return object_; }
method cl_type (line 2079) | cl_type &operator()() { return object_; }
method cl_type (line 2081) | cl_type get() const { return object_; }
method cl_int (line 2090) | cl_int retain() const
method cl_int (line 2102) | cl_int release() const
function cl_int (line 2153) | static inline cl_int buildErrHandler(cl_int err, const char *errStr,...
function cl_int (line 2166) | static inline cl_int buildErrHandler(cl_int err, const char *errStr,...
class SVMTraitNull (line 3525) | class SVMTraitNull
method cl_svm_mem_flags (line 3528) | static cl_svm_mem_flags getSVMMemFlags() { return 0; }
class Deleter (line 3736) | class Deleter
method Deleter (line 3745) | Deleter(const Alloc &alloc, size_type copies)
type KernelArgumentHandler (line 5646) | struct KernelArgumentHandler
type KernelArgumentHandler<T, typename std::enable_if<!std::is_base_of<cl::Memory, T>::value>::type> (line 5651) | struct KernelArgumentHandler<T, typename std::enable_if<!std::is_bas...
method size_type (line 5653) | static size_type size(const T &) { return sizeof(T); }
method T (line 5654) | static const T *ptr(const T &value) { return &value; }
type KernelArgumentHandler<T, typename std::enable_if<std::is_base_of<cl::Memory, T>::value>::type> (line 5660) | struct KernelArgumentHandler<T, typename std::enable_if<std::is_base...
method size_type (line 5662) | static size_type size(const T &) { return sizeof(cl_mem); }
method cl_mem (line 5663) | static const cl_mem *ptr(const T &value) { return &(value()); }
type KernelArgumentHandler<LocalSpaceArg, void> (line 5669) | struct KernelArgumentHandler<LocalSpaceArg, void>
method size_type (line 5671) | static size_type size(const LocalSpaceArg &value) { return value.s...
type KernelArgumentHandler<cl::DeviceCommandQueue, void> (line 8429) | struct KernelArgumentHandler<cl::DeviceCommandQueue, void>
method size_type (line 8431) | static size_type size(const cl::DeviceCommandQueue &) { return siz...
method cl_command_queue (line 8432) | static const cl_command_queue *ptr(const cl::DeviceCommandQueue &v...
type detail (line 2164) | namespace detail
function cl_int (line 814) | static inline cl_int errHandler(cl_int err, const char *errStr = NULL)
function cl_int (line 823) | static inline cl_int errHandler(cl_int err, const char *errStr = NULL)
function cl_int (line 1008) | inline cl_int getInfoHelper(Functor f, cl_uint name, T *param, long)
function cl_int (line 1016) | inline cl_int getInfoHelper(Func f, cl_uint name, vector<vector<unsi...
function cl_int (line 1047) | inline cl_int getInfoHelper(Func f, cl_uint name, vector<T> *param, ...
function cl_int (line 1079) | inline cl_int getInfoHelper(Func f, cl_uint name, vector<T> *param, ...
function cl_int (line 1114) | inline cl_int getInfoHelper(Func f, cl_uint name, string *param, long)
function cl_int (line 1147) | inline cl_int getInfoHelper(Func f, cl_uint name, array<size_type, N...
type ReferenceHandler (line 1180) | struct ReferenceHandler
function cl_int (line 1189) | inline cl_int getInfoHelper(Func f, cl_uint name, T *param, int, typ...
type param_traits (line 1483) | struct param_traits
function cl_int (line 1669) | inline cl_int getInfo(Func f, cl_uint name, T *param)
type GetInfoFunctor0 (line 1675) | struct GetInfoFunctor0
method cl_int (line 1679) | cl_int operator()(cl_uint param, size_type size, void *value, size...
type GetInfoFunctor1 (line 1686) | struct GetInfoFunctor1
method cl_int (line 1691) | cl_int operator()(cl_uint param, size_type size, void *value, size...
function cl_int (line 1698) | inline cl_int getInfo(Func f, const Arg0 &arg0, cl_uint name, T *param)
function cl_int (line 1705) | inline cl_int getInfo(Func f, const Arg0 &arg0, const Arg1 &arg1, cl...
type ReferenceHandler (line 1713) | struct ReferenceHandler
type ReferenceHandler<cl_device_id> (line 1722) | struct ReferenceHandler<cl_device_id>
method cl_int (line 1733) | static cl_int retain(cl_device_id device) { return ::clRetainDevic...
method cl_int (line 1743) | static cl_int release(cl_device_id device) { return ::clReleaseDev...
method cl_int (line 1753) | static cl_int retain(cl_device_id) { return CL_SUCCESS; }
method cl_int (line 1755) | static cl_int release(cl_device_id) { return CL_SUCCESS; }
type ReferenceHandler<cl_device_id> (line 1750) | struct ReferenceHandler<cl_device_id>
method cl_int (line 1733) | static cl_int retain(cl_device_id device) { return ::clRetainDevic...
method cl_int (line 1743) | static cl_int release(cl_device_id device) { return ::clReleaseDev...
method cl_int (line 1753) | static cl_int retain(cl_device_id) { return CL_SUCCESS; }
method cl_int (line 1755) | static cl_int release(cl_device_id) { return CL_SUCCESS; }
type ReferenceHandler<cl_platform_id> (line 1760) | struct ReferenceHandler<cl_platform_id>
method cl_int (line 1763) | static cl_int retain(cl_platform_id) { return CL_SUCCESS; }
method cl_int (line 1765) | static cl_int release(cl_platform_id) { return CL_SUCCESS; }
type ReferenceHandler<cl_context> (line 1769) | struct ReferenceHandler<cl_context>
method cl_int (line 1771) | static cl_int retain(cl_context context) { return ::clRetainContex...
method cl_int (line 1772) | static cl_int release(cl_context context) { return ::clReleaseCont...
type ReferenceHandler<cl_command_queue> (line 1776) | struct ReferenceHandler<cl_command_queue>
method cl_int (line 1778) | static cl_int retain(cl_command_queue queue) { return ::clRetainCo...
method cl_int (line 1779) | static cl_int release(cl_command_queue queue) { return ::clRelease...
type ReferenceHandler<cl_mem> (line 1783) | struct ReferenceHandler<cl_mem>
method cl_int (line 1785) | static cl_int retain(cl_mem memory) { return ::clRetainMemObject(m...
method cl_int (line 1786) | static cl_int release(cl_mem memory) { return ::clReleaseMemObject...
type ReferenceHandler<cl_sampler> (line 1790) | struct ReferenceHandler<cl_sampler>
method cl_int (line 1792) | static cl_int retain(cl_sampler sampler) { return ::clRetainSample...
method cl_int (line 1793) | static cl_int release(cl_sampler sampler) { return ::clReleaseSamp...
type ReferenceHandler<cl_program> (line 1797) | struct ReferenceHandler<cl_program>
method cl_int (line 1799) | static cl_int retain(cl_program program) { return ::clRetainProgra...
method cl_int (line 1800) | static cl_int release(cl_program program) { return ::clReleaseProg...
type ReferenceHandler<cl_kernel> (line 1804) | struct ReferenceHandler<cl_kernel>
method cl_int (line 1806) | static cl_int retain(cl_kernel kernel) { return ::clRetainKernel(k...
method cl_int (line 1807) | static cl_int release(cl_kernel kernel) { return ::clReleaseKernel...
type ReferenceHandler<cl_event> (line 1811) | struct ReferenceHandler<cl_event>
method cl_int (line 1813) | static cl_int retain(cl_event event) { return ::clRetainEvent(even...
method cl_int (line 1814) | static cl_int release(cl_event event) { return ::clReleaseEvent(ev...
function cl_uint (line 1820) | static cl_uint getVersion(const vector<char> &versionInfo)
function cl_uint (line 1841) | static cl_uint getPlatformVersion(cl_platform_id platform)
function cl_uint (line 1851) | static cl_uint getDevicePlatformVersion(cl_device_id device)
function cl_uint (line 1858) | static cl_uint getContextPlatformVersion(cl_context context)
class Wrapper (line 1873) | class Wrapper
method Wrapper (line 1882) | Wrapper()
method Wrapper (line 1886) | Wrapper(const cl_type &obj, bool retainObject)
method Wrapper (line 1903) | Wrapper(const Wrapper<cl_type> &rhs)
method Wrapper (line 1909) | Wrapper(Wrapper<cl_type> &&rhs) CL_HPP_NOEXCEPT_
method cl_type (line 1944) | const cl_type &operator()() const { return object_; }
method cl_type (line 1946) | cl_type &operator()() { return object_; }
method cl_type (line 1948) | cl_type get() const { return object_; }
method cl_int (line 1954) | cl_int retain() const
method cl_int (line 1966) | cl_int release() const
class Wrapper<cl_device_id> (line 1980) | class Wrapper<cl_device_id>
method isReferenceCountable (line 1989) | static bool isReferenceCountable(cl_device_id device)
method Wrapper (line 2010) | Wrapper()
method Wrapper (line 2015) | Wrapper(const cl_type &obj, bool retainObject)
method Wrapper (line 2029) | Wrapper(const Wrapper<cl_type> &rhs)
method Wrapper (line 2036) | Wrapper(Wrapper<cl_type> &&rhs) CL_HPP_NOEXCEPT_
method cl_type (line 2077) | const cl_type &operator()() const { return object_; }
method cl_type (line 2079) | cl_type &operator()() { return object_; }
method cl_type (line 2081) | cl_type get() const { return object_; }
method cl_int (line 2090) | cl_int retain() const
method cl_int (line 2102) | cl_int release() const
function cl_int (line 2153) | static inline cl_int buildErrHandler(cl_int err, const char *errStr,...
function cl_int (line 2166) | static inline cl_int buildErrHandler(cl_int err, const char *errStr,...
class SVMTraitNull (line 3525) | class SVMTraitNull
method cl_svm_mem_flags (line 3528) | static cl_svm_mem_flags getSVMMemFlags() { return 0; }
class Deleter (line 3736) | class Deleter
method Deleter (line 3745) | Deleter(const Alloc &alloc, size_type copies)
type KernelArgumentHandler (line 5646) | struct KernelArgumentHandler
type KernelArgumentHandler<T, typename std::enable_if<!std::is_base_of<cl::Memory, T>::value>::type> (line 5651) | struct KernelArgumentHandler<T, typename std::enable_if<!std::is_bas...
method size_type (line 5653) | static size_type size(const T &) { return sizeof(T); }
method T (line 5654) | static const T *ptr(const T &value) { return &value; }
type KernelArgumentHandler<T, typename std::enable_if<std::is_base_of<cl::Memory, T>::value>::type> (line 5660) | struct KernelArgumentHandler<T, typename std::enable_if<std::is_base...
method size_type (line 5662) | static size_type size(const T &) { return sizeof(cl_mem); }
method cl_mem (line 5663) | static const cl_mem *ptr(const T &value) { return &(value()); }
type KernelArgumentHandler<LocalSpaceArg, void> (line 5669) | struct KernelArgumentHandler<LocalSpaceArg, void>
method size_type (line 5671) | static size_type size(const LocalSpaceArg &value) { return value.s...
type KernelArgumentHandler<cl::DeviceCommandQueue, void> (line 8429) | struct KernelArgumentHandler<cl::DeviceCommandQueue, void>
method size_type (line 8431) | static size_type size(const cl::DeviceCommandQueue &) { return siz...
method cl_command_queue (line 8432) | static const cl_command_queue *ptr(const cl::DeviceCommandQueue &v...
type ImageFormat (line 2181) | struct ImageFormat : public cl_image_format
method ImageFormat (line 2184) | ImageFormat() {}
method ImageFormat (line 2187) | ImageFormat(cl_channel_order order, cl_channel_type type)
method ImageFormat (line 2194) | ImageFormat(const ImageFormat &other) { *this = other; }
method ImageFormat (line 2197) | ImageFormat &operator=(const ImageFormat &rhs)
class Device (line 2215) | class Device : public detail::Wrapper<cl_device_id>
method makeDefaultProvided (line 2234) | static void makeDefaultProvided(const Device &p) { default_ = p; }
method unitTestClearDefault (line 2244) | static void unitTestClearDefault() { default_ = Device(); }
method Device (line 2248) | Device()
method Device (line 2256) | explicit Device(const cl_device_id &device, bool retainObject = false)
method Device (line 2264) | static Device getDefault(cl_int *errResult = NULL)
method Device (line 2282) | static Device setDefault(const Device &default_device)
method Device (line 2293) | Device &operator=(const cl_device_id &rhs)
method Device (line 2302) | Device(const Device &dev)
method Device (line 2309) | Device &operator=(const Device &dev)
method Device (line 2318) | Device(Device &&dev) CL_HPP_NOEXCEPT_ : detail::Wrapper<cl_type>(std...
method Device (line 2323) | Device &operator=(Device &&dev)
method cl_int (line 2331) | cl_int getInfo(cl_device_info name, T *param) const
method getInfo (line 2338) | typename detail::param_traits<detail::cl_device_info, name>::param_t...
method cl_ulong (line 2357) | cl_ulong getHostTimer(cl_int *error = nullptr)
method getDeviceAndHostTimer (line 2379) | std::pair<cl_ulong, cl_ulong> getDeviceAndHostTimer(cl_int *error = ...
method cl_int (line 2397) | cl_int createSubDevices(const cl_device_partition_property *properti...
method cl_int (line 2436) | cl_int createSubDevices(const cl_device_partition_property_ext *prop...
class Platform (line 2489) | class Platform : public detail::Wrapper<cl_platform_id>
method makeDefault (line 2501) | static void makeDefault()
method makeDefaultProvided (line 2549) | static void makeDefaultProvided(const Platform &p) { default_ = p; }
method unitTestClearDefault (line 2559) | static void unitTestClearDefault() { default_ = Platform(); }
method Platform (line 2563) | Platform()
method Platform (line 2574) | explicit Platform(const cl_platform_id &platform, bool retainObject ...
method Platform (line 2582) | Platform &operator=(const cl_platform_id &rhs)
method Platform (line 2588) | static Platform getDefault(cl_int *errResult = NULL)
method Platform (line 2606) | static Platform setDefault(const Platform &default_platform)
method cl_int (line 2615) | cl_int getInfo(cl_platform_info name, T *param) const
method getInfo (line 2622) | typename detail::param_traits<detail::cl_platform_info, name>::param...
method cl_int (line 2637) | cl_int getDevices(cl_device_type type, vector<Device> *devices) const
method cl_int (line 2702) | cl_int getDevices(cl_d3d10_device_source_khr d3d_device_source, void...
method cl_int (line 2754) | static cl_int get(vector<Platform> *platforms)
method cl_int (line 2793) | static cl_int get(Platform *platform)
method Platform (line 2812) | static Platform get(cl_int *errResult = NULL)
method cl_int (line 2825) | cl_int unloadCompiler() { return ::clUnloadPlatformCompiler(object_); }
function cl_int (line 2843) | inline cl_int UnloadCompiler()
class Context (line 2857) | class Context : public detail::Wrapper<cl_context>
method makeDefault (line 2869) | static void makeDefault()
method makeDefaultProvided (line 2902) | static void makeDefaultProvided(const Context &c) { default_ = c; }
method unitTestClearDefault (line 2912) | static void unitTestClearDefault() { default_ = Context(); }
method Context (line 2919) | Context(const vector<Device> &devices, const cl_context_properties *...
method Context (line 2946) | Context(const Device &device, const cl_context_properties *propertie...
method Context (line 2967) | Context(cl_device_type type, const cl_context_properties *properties...
method Context (line 3057) | Context(const Context &ctx)
method Context (line 3064) | Context &operator=(const Context &ctx)
method Context (line 3073) | Context(Context &&ctx) CL_HPP_NOEXCEPT_ : detail::Wrapper<cl_type>(s...
method Context (line 3078) | Context &operator=(Context &&ctx)
method Context (line 3089) | static Context getDefault(cl_int *err = NULL)
method Context (line 3107) | static Context setDefault(const Context &default_context)
method Context (line 3115) | Context()
method Context (line 3124) | explicit Context(const cl_context &context, bool retainObject = false)
method Context (line 3133) | Context &operator=(const cl_context &rhs)
method cl_int (line 3141) | cl_int getInfo(cl_context_info name, T *param) const
method getInfo (line 3148) | typename detail::param_traits<detail::cl_context_info, name>::param_...
method cl_int (line 3163) | cl_int getSupportedImageFormats(cl_mem_flags flags, cl_mem_object_ty...
function catch (line 3224) | catch (cl::Error &e)
class Event (line 3243) | class Event : public detail::Wrapper<cl_event>
method Event (line 3247) | Event()
method Event (line 3259) | explicit Event(const cl_event &event, bool retainObject = false)
method Event (line 3268) | Event &operator=(const cl_event &rhs)
method cl_int (line 3276) | cl_int getInfo(cl_event_info name, T *param) const
method getInfo (line 3283) | typename detail::param_traits<detail::cl_event_info, name>::param_ty...
method cl_int (line 3296) | cl_int getProfilingInfo(cl_profiling_info name, T *param) const
method getProfilingInfo (line 3304) | typename detail::param_traits<detail::cl_profiling_info, name>::para...
method cl_int (line 3319) | cl_int wait() const { return detail::errHandler(::clWaitForEvents(1,...
method cl_int (line 3326) | cl_int setCallback(cl_int type, void(CL_CALLBACK *pfn_notify)(cl_eve...
method cl_int (line 3336) | static cl_int waitForEvents(const vector<Event> &events)
class UserEvent (line 3349) | class UserEvent : public Event
method UserEvent (line 3356) | UserEvent(const Context &context, cl_int *err = NULL)
method UserEvent (line 3369) | UserEvent()
method cl_int (line 3377) | cl_int setStatus(cl_int status)
function cl_int (line 3388) | inline static cl_int WaitForEvents(const vector<Event> &events)
class Memory (line 3403) | class Memory : public detail::Wrapper<cl_mem>
method Memory (line 3407) | Memory()
method Memory (line 3422) | explicit Memory(const cl_mem &memory, bool retainObject)
method Memory (line 3431) | Memory &operator=(const cl_mem &rhs)
method Memory (line 3440) | Memory(const Memory &mem)
method Memory (line 3447) | Memory &operator=(const Memory &mem)
method Memory (line 3456) | Memory(Memory &&mem) CL_HPP_NOEXCEPT_ : detail::Wrapper<cl_type>(std...
method Memory (line 3461) | Memory &operator=(Memory &&mem)
method cl_int (line 3470) | cl_int getInfo(cl_mem_info name, T *param) const
method getInfo (line 3477) | typename detail::param_traits<detail::cl_mem_info, name>::param_type...
method cl_int (line 3502) | cl_int setDestructorCallback(void(CL_CALLBACK *pfn_notify)(cl_mem, v...
class Buffer (line 3511) | class Buffer
method Buffer (line 3845) | Buffer(const Context &context, cl_mem_flags flags, size_type size, v...
method Buffer (line 3866) | Buffer(cl_mem_flags flags, size_type size, void *host_ptr = NULL, cl...
method Buffer (line 3887) | Buffer(IteratorType startIterator, IteratorType endIterator, bool re...
method Buffer (line 3955) | Buffer()
method Buffer (line 3966) | explicit Buffer(const cl_mem &buffer, bool retainObject = false)
method Buffer (line 3974) | Buffer &operator=(const cl_mem &rhs)
method Buffer (line 3983) | Buffer(const Buffer &buf)
method Buffer (line 3990) | Buffer &operator=(const Buffer &buf)
method Buffer (line 3999) | Buffer(Buffer &&buf) CL_HPP_NOEXCEPT_ : Memory(std::move(buf)) {}
method Buffer (line 4004) | Buffer &operator=(Buffer &&buf)
method Buffer (line 4015) | Buffer createSubBuffer(cl_mem_flags flags, cl_buffer_create_type buf...
type detail (line 3523) | namespace detail
function cl_int (line 814) | static inline cl_int errHandler(cl_int err, const char *errStr = NULL)
function cl_int (line 823) | static inline cl_int errHandler(cl_int err, const char *errStr = NULL)
function cl_int (line 1008) | inline cl_int getInfoHelper(Functor f, cl_uint name, T *param, long)
function cl_int (line 1016) | inline cl_int getInfoHelper(Func f, cl_uint name, vector<vector<unsi...
function cl_int (line 1047) | inline cl_int getInfoHelper(Func f, cl_uint name, vector<T> *param, ...
function cl_int (line 1079) | inline cl_int getInfoHelper(Func f, cl_uint name, vector<T> *param, ...
function cl_int (line 1114) | inline cl_int getInfoHelper(Func f, cl_uint name, string *param, long)
function cl_int (line 1147) | inline cl_int getInfoHelper(Func f, cl_uint name, array<size_type, N...
type ReferenceHandler (line 1180) | struct ReferenceHandler
function cl_int (line 1189) | inline cl_int getInfoHelper(Func f, cl_uint name, T *param, int, typ...
type param_traits (line 1483) | struct param_traits
function cl_int (line 1669) | inline cl_int getInfo(Func f, cl_uint name, T *param)
type GetInfoFunctor0 (line 1675) | struct GetInfoFunctor0
method cl_int (line 1679) | cl_int operator()(cl_uint param, size_type size, void *value, size...
type GetInfoFunctor1 (line 1686) | struct GetInfoFunctor1
method cl_int (line 1691) | cl_int operator()(cl_uint param, size_type size, void *value, size...
function cl_int (line 1698) | inline cl_int getInfo(Func f, const Arg0 &arg0, cl_uint name, T *param)
function cl_int (line 1705) | inline cl_int getInfo(Func f, const Arg0 &arg0, const Arg1 &arg1, cl...
type ReferenceHandler (line 1713) | struct ReferenceHandler
type ReferenceHandler<cl_device_id> (line 1722) | struct ReferenceHandler<cl_device_id>
method cl_int (line 1733) | static cl_int retain(cl_device_id device) { return ::clRetainDevic...
method cl_int (line 1743) | static cl_int release(cl_device_id device) { return ::clReleaseDev...
method cl_int (line 1753) | static cl_int retain(cl_device_id) { return CL_SUCCESS; }
method cl_int (line 1755) | static cl_int release(cl_device_id) { return CL_SUCCESS; }
type ReferenceHandler<cl_device_id> (line 1750) | struct ReferenceHandler<cl_device_id>
method cl_int (line 1733) | static cl_int retain(cl_device_id device) { return ::clRetainDevic...
method cl_int (line 1743) | static cl_int release(cl_device_id device) { return ::clReleaseDev...
method cl_int (line 1753) | static cl_int retain(cl_device_id) { return CL_SUCCESS; }
method cl_int (line 1755) | static cl_int release(cl_device_id) { return CL_SUCCESS; }
type ReferenceHandler<cl_platform_id> (line 1760) | struct ReferenceHandler<cl_platform_id>
method cl_int (line 1763) | static cl_int retain(cl_platform_id) { return CL_SUCCESS; }
method cl_int (line 1765) | static cl_int release(cl_platform_id) { return CL_SUCCESS; }
type ReferenceHandler<cl_context> (line 1769) | struct ReferenceHandler<cl_context>
method cl_int (line 1771) | static cl_int retain(cl_context context) { return ::clRetainContex...
method cl_int (line 1772) | static cl_int release(cl_context context) { return ::clReleaseCont...
type ReferenceHandler<cl_command_queue> (line 1776) | struct ReferenceHandler<cl_command_queue>
method cl_int (line 1778) | static cl_int retain(cl_command_queue queue) { return ::clRetainCo...
method cl_int (line 1779) | static cl_int release(cl_command_queue queue) { return ::clRelease...
type ReferenceHandler<cl_mem> (line 1783) | struct ReferenceHandler<cl_mem>
method cl_int (line 1785) | static cl_int retain(cl_mem memory) { return ::clRetainMemObject(m...
method cl_int (line 1786) | static cl_int release(cl_mem memory) { return ::clReleaseMemObject...
type ReferenceHandler<cl_sampler> (line 1790) | struct ReferenceHandler<cl_sampler>
method cl_int (line 1792) | static cl_int retain(cl_sampler sampler) { return ::clRetainSample...
method cl_int (line 1793) | static cl_int release(cl_sampler sampler) { return ::clReleaseSamp...
type ReferenceHandler<cl_program> (line 1797) | struct ReferenceHandler<cl_program>
method cl_int (line 1799) | static cl_int retain(cl_program program) { return ::clRetainProgra...
method cl_int (line 1800) | static cl_int release(cl_program program) { return ::clReleaseProg...
type ReferenceHandler<cl_kernel> (line 1804) | struct ReferenceHandler<cl_kernel>
method cl_int (line 1806) | static cl_int retain(cl_kernel kernel) { return ::clRetainKernel(k...
method cl_int (line 1807) | static cl_int release(cl_kernel kernel) { return ::clReleaseKernel...
type ReferenceHandler<cl_event> (line 1811) | struct ReferenceHandler<cl_event>
method cl_int (line 1813) | static cl_int retain(cl_event event) { return ::clRetainEvent(even...
method cl_int (line 1814) | static cl_int release(cl_event event) { return ::clReleaseEvent(ev...
function cl_uint (line 1820) | static cl_uint getVersion(const vector<char> &versionInfo)
function cl_uint (line 1841) | static cl_uint getPlatformVersion(cl_platform_id platform)
function cl_uint (line 1851) | static cl_uint getDevicePlatformVersion(cl_device_id device)
function cl_uint (line 1858) | static cl_uint getContextPlatformVersion(cl_context context)
class Wrapper (line 1873) | class Wrapper
method Wrapper (line 1882) | Wrapper()
method Wrapper (line 1886) | Wrapper(const cl_type &obj, bool retainObject)
method Wrapper (line 1903) | Wrapper(const Wrapper<cl_type> &rhs)
method Wrapper (line 1909) | Wrapper(Wrapper<cl_type> &&rhs) CL_HPP_NOEXCEPT_
method cl_type (line 1944) | const cl_type &operator()() const { return object_; }
method cl_type (line 1946) | cl_type &operator()() { return object_; }
method cl_type (line 1948) | cl_type get() const { return object_; }
method cl_int (line 1954) | cl_int retain() const
method cl_int (line 1966) | cl_int release() const
class Wrapper<cl_device_id> (line 1980) | class Wrapper<cl_device_id>
method isReferenceCountable (line 1989) | static bool isReferenceCountable(cl_device_id device)
method Wrapper (line 2010) | Wrapper()
method Wrapper (line 2015) | Wrapper(const cl_type &obj, bool retainObject)
method Wrapper (line 2029) | Wrapper(const Wrapper<cl_type> &rhs)
method Wrapper (line 2036) | Wrapper(Wrapper<cl_type> &&rhs) CL_HPP_NOEXCEPT_
method cl_type (line 2077) | const cl_type &operator()() const { return object_; }
method cl_type (line 2079) | cl_type &operator()() { return object_; }
method cl_type (line 2081) | cl_type get() const { return object_; }
method cl_int (line 2090) | cl_int retain() const
method cl_int (line 2102) | cl_int release() const
function cl_int (line 2153) | static inline cl_int buildErrHandler(cl_int err, const char *errStr,...
function cl_int (line 2166) | static inline cl_int buildErrHandler(cl_int err, const char *errStr,...
class SVMTraitNull (line 3525) | class SVMTraitNull
method cl_svm_mem_flags (line 3528) | static cl_svm_mem_flags getSVMMemFlags() { return 0; }
class Deleter (line 3736) | class Deleter
method Deleter (line 3745) | Deleter(const Alloc &alloc, size_type copies)
type KernelArgumentHandler (line 5646) | struct KernelArgumentHandler
type KernelArgumentHandler<T, typename std::enable_if<!std::is_base_of<cl::Memory, T>::value>::type> (line 5651) | struct KernelArgumentHandler<T, typename std::enable_if<!std::is_bas...
method size_type (line 5653) | static size_type size(const T &) { return sizeof(T); }
method T (line 5654) | static const T *ptr(const T &value) { return &value; }
type KernelArgumentHandler<T, typename std::enable_if<std::is_base_of<cl::Memory, T>::value>::type> (line 5660) | struct KernelArgumentHandler<T, typename std::enable_if<std::is_base...
method size_type (line 5662) | static size_type size(const T &) { return sizeof(cl_mem); }
method cl_mem (line 5663) | static const cl_mem *ptr(const T &value) { return &(value()); }
type KernelArgumentHandler<LocalSpaceArg, void> (line 5669) | struct KernelArgumentHandler<LocalSpaceArg, void>
method size_type (line 5671) | static size_type size(const LocalSpaceArg &value) { return value.s...
type KernelArgumentHandler<cl::DeviceCommandQueue, void> (line 8429) | struct KernelArgumentHandler<cl::DeviceCommandQueue, void>
method size_type (line 8431) | static size_type size(const cl::DeviceCommandQueue &) { return siz...
method cl_command_queue (line 8432) | static const cl_command_queue *ptr(const cl::DeviceCommandQueue &v...
class SVMTraitReadWrite (line 3533) | class SVMTraitReadWrite
method cl_svm_mem_flags (line 3536) | static cl_svm_mem_flags getSVMMemFlags() { return CL_MEM_READ_WRITE ...
class SVMTraitReadOnly (line 3540) | class SVMTraitReadOnly
method cl_svm_mem_flags (line 3543) | static cl_svm_mem_flags getSVMMemFlags() { return CL_MEM_READ_ONLY |...
class SVMTraitWriteOnly (line 3547) | class SVMTraitWriteOnly
method cl_svm_mem_flags (line 3550) | static cl_svm_mem_flags getSVMMemFlags() { return CL_MEM_WRITE_ONLY ...
class SVMTraitCoarse (line 3554) | class SVMTraitCoarse
method cl_svm_mem_flags (line 3557) | static cl_svm_mem_flags getSVMMemFlags() { return Trait::getSVMMemFl...
class SVMTraitFine (line 3561) | class SVMTraitFine
method cl_svm_mem_flags (line 3564) | static cl_svm_mem_flags getSVMMemFlags() { return CL_MEM_SVM_FINE_GR...
class SVMTraitAtomic (line 3568) | class SVMTraitAtomic
method cl_svm_mem_flags (line 3571) | static cl_svm_mem_flags getSVMMemFlags()
class SVMAllocator (line 3594) | class SVMAllocator
type rebind (line 3609) | struct rebind
method SVMAllocator (line 3617) | SVMAllocator()
method SVMAllocator (line 3621) | explicit SVMAllocator(cl::Context context)
method SVMAllocator (line 3626) | SVMAllocator(const SVMAllocator &other)
method SVMAllocator (line 3631) | SVMAllocator(const SVMAllocator<U, SVMTrait> &other)
method pointer (line 3637) | pointer address(reference r) CL_HPP_NOEXCEPT_ { return std::addresso...
method const_pointer (line 3639) | const_pointer address(const_reference r) CL_HPP_NOEXCEPT_ { return s...
method pointer (line 3647) | pointer allocate(size_type size, typename cl::SVMAllocator<void, SVM...
method deallocate (line 3675) | void deallocate(pointer p, size_type) { clSVMFree(context_(), p); }
method size_type (line 3681) | size_type max_size() const CL_HPP_NOEXCEPT_
method construct (line 3694) | void construct(U *p, Args &&...args)
method destroy (line 3700) | void destroy(U *p)
class SVMAllocator<void, SVMTrait> (line 3715) | class SVMAllocator<void, SVMTrait>
type rebind (line 3723) | struct rebind
type detail (line 3733) | namespace detail
function cl_int (line 814) | static inline cl_int errHandler(cl_int err, const char *errStr = NULL)
function cl_int (line 823) | static inline cl_int errHandler(cl_int err, const char *errStr = NULL)
function cl_int (line 1008) | inline cl_int getInfoHelper(Functor f, cl_uint name, T *param, long)
function cl_int (line 1016) | inline cl_int getInfoHelper(Func f, cl_uint name, vector<vector<unsi...
function cl_int (line 1047) | inline cl_int getInfoHelper(Func f, cl_uint name, vector<T> *param, ...
function cl_int (line 1079) | inline cl_int getInfoHelper(Func f, cl_uint name, vector<T> *param, ...
function cl_int (line 1114) | inline cl_int getInfoHelper(Func f, cl_uint name, string *param, long)
function cl_int (line 1147) | inline cl_int getInfoHelper(Func f, cl_uint name, array<size_type, N...
type ReferenceHandler (line 1180) | struct ReferenceHandler
function cl_int (line 1189) | inline cl_int getInfoHelper(Func f, cl_uint name, T *param, int, typ...
type param_traits (line 1483) | struct param_traits
function cl_int (line 1669) | inline cl_int getInfo(Func f, cl_uint name, T *param)
type GetInfoFunctor0 (line 1675) | struct GetInfoFunctor0
method cl_int (line 1679) | cl_int operator()(cl_uint param, size_type size, void *value, size...
type GetInfoFunctor1 (line 1686) | struct GetInfoFunctor1
method cl_int (line 1691) | cl_int operator()(cl_uint param, size_type size, void *value, size...
function cl_int (line 1698) | inline cl_int getInfo(Func f, const Arg0 &arg0, cl_uint name, T *param)
function cl_int (line 1705) | inline cl_int getInfo(Func f, const Arg0 &arg0, const Arg1 &arg1, cl...
type ReferenceHandler (line 1713) | struct ReferenceHandler
type ReferenceHandler<cl_device_id> (line 1722) | struct ReferenceHandler<cl_device_id>
method cl_int (line 1733) | static cl_int retain(cl_device_id device) { return ::clRetainDevic...
method cl_int (line 1743) | static cl_int release(cl_device_id device) { return ::clReleaseDev...
method cl_int (line 1753) | static cl_int retain(cl_device_id) { return CL_SUCCESS; }
method cl_int (line 1755) | static cl_int release(cl_device_id) { return CL_SUCCESS; }
type ReferenceHandler<cl_device_id> (line 1750) | struct ReferenceHandler<cl_device_id>
method cl_int (line 1733) | static cl_int retain(cl_device_id device) { return ::clRetainDevic...
method cl_int (line 1743) | static cl_int release(cl_device_id device) { return ::clReleaseDev...
method cl_int (line 1753) | static cl_int retain(cl_device_id) { return CL_SUCCESS; }
method cl_int (line 1755) | static cl_int release(cl_device_id) { return CL_SUCCESS; }
type ReferenceHandler<cl_platform_id> (line 1760) | struct ReferenceHandler<cl_platform_id>
method cl_int (line 1763) | static cl_int retain(cl_platform_id) { return CL_SUCCESS; }
method cl_int (line 1765) | static cl_int release(cl_platform_id) { return CL_SUCCESS; }
type ReferenceHandler<cl_context> (line 1769) | struct ReferenceHandler<cl_context>
method cl_int (line 1771) | static cl_int retain(cl_context context) { return ::clRetainContex...
method cl_int (line 1772) | static cl_int release(cl_context context) { return ::clReleaseCont...
type ReferenceHandler<cl_command_queue> (line 1776) | struct ReferenceHandler<cl_command_queue>
method cl_int (line 1778) | static cl_int retain(cl_command_queue queue) { return ::clRetainCo...
method cl_int (line 1779) | static cl_int release(cl_command_queue queue) { return ::clRelease...
type ReferenceHandler<cl_mem> (line 1783) | struct ReferenceHandler<cl_mem>
method cl_int (line 1785) | static cl_int retain(cl_mem memory) { return ::clRetainMemObject(m...
method cl_int (line 1786) | static cl_int release(cl_mem memory) { return ::clReleaseMemObject...
type ReferenceHandler<cl_sampler> (line 1790) | struct ReferenceHandler<cl_sampler>
method cl_int (line 1792) | static cl_int retain(cl_sampler sampler) { return ::clRetainSample...
method cl_int (line 1793) | static cl_int release(cl_sampler sampler) { return ::clReleaseSamp...
type ReferenceHandler<cl_program> (line 1797) | struct ReferenceHandler<cl_program>
method cl_int (line 1799) | static cl_int retain(cl_program program) { return ::clRetainProgra...
method cl_int (line 1800) | static cl_int release(cl_program program) { return ::clReleaseProg...
type ReferenceHandler<cl_kernel> (line 1804) | struct ReferenceHandler<cl_kernel>
method cl_int (line 1806) | static cl_int retain(cl_kernel kernel) { return ::clRetainKernel(k...
method cl_int (line 1807) | static cl_int release(cl_kernel kernel) { return ::clReleaseKernel...
type ReferenceHandler<cl_event> (line 1811) | struct ReferenceHandler<cl_event>
method cl_int (line 1813) | static cl_int retain(cl_event event) { return ::clRetainEvent(even...
method cl_int (line 1814) | static cl_int release(cl_event event) { return ::clReleaseEvent(ev...
function cl_uint (line 1820) | static cl_uint getVersion(const vector<char> &versionInfo)
function cl_uint (line 1841) | static cl_uint getPlatformVersion(cl_platform_id platform)
function cl_uint (line 1851) | static cl_uint getDevicePlatformVersion(cl_device_id device)
function cl_uint (line 1858) | static cl_uint getContextPlatformVersion(cl_context context)
class Wrapper (line 1873) | class Wrapper
method Wrapper (line 1882) | Wrapper()
method Wrapper (line 1886) | Wrapper(const cl_type &obj, bool retainObject)
method Wrapper (line 1903) | Wrapper(const Wrapper<cl_type> &rhs)
method Wrapper (line 1909) | Wrapper(Wrapper<cl_type> &&rhs) CL_HPP_NOEXCEPT_
method cl_type (line 1944) | const cl_type &operator()() const { return object_; }
method cl_type (line 1946) | cl_type &operator()() { return object_; }
method cl_type (line 1948) | cl_type get() const { return object_; }
method cl_int (line 1954) | cl_int retain() const
method cl_int (line 1966) | cl_int release() const
class Wrapper<cl_device_id> (line 1980) | class Wrapper<cl_device_id>
method isReferenceCountable (line 1989) | static bool isReferenceCountable(cl_device_id device)
method Wrapper (line 2010) | Wrapper()
method Wrapper (line 2015) | Wrapper(const cl_type &obj, bool retainObject)
method Wrapper (line 2029) | Wrapper(const Wrapper<cl_type> &rhs)
method Wrapper (line 2036) | Wrapper(Wrapper<cl_type> &&rhs) CL_HPP_NOEXCEPT_
method cl_type (line 2077) | const cl_type &operator()() const { return object_; }
method cl_type (line 2079) | cl_type &operator()() { return object_; }
method cl_type (line 2081) | cl_type get() const { return object_; }
method cl_int (line 2090) | cl_int retain() const
method cl_int (line 2102) | cl_int release() const
function cl_int (line 2153) | static inline cl_int buildErrHandler(cl_int err, const char *errStr,...
function cl_int (line 2166) | static inline cl_int buildErrHandler(cl_int err, const char *errStr,...
class SVMTraitNull (line 3525) | class SVMTraitNull
method cl_svm_mem_flags (line 3528) | static cl_svm_mem_flags getSVMMemFlags() { return 0; }
class Deleter (line 3736) | class Deleter
method Deleter (line 3745) | Deleter(const Alloc &alloc, size_type copies)
type KernelArgumentHandler (line 5646) | struct KernelArgumentHandler
type KernelArgumentHandler<T, typename std::enable_if<!std::is_base_of<cl::Memory, T>::value>::type> (line 5651) | struct KernelArgumentHandler<T, typename std::enable_if<!std::is_bas...
method size_type (line 5653) | static size_type size(const T &) { return sizeof(T); }
method T (line 5654) | static const T *ptr(const T &value) { return &value; }
type KernelArgumentHandler<T, typename std::enable_if<std::is_base_of<cl::Memory, T>::value>::type> (line 5660) | struct KernelArgumentHandler<T, typename std::enable_if<std::is_base...
method size_type (line 5662) | static size_type size(const T &) { return sizeof(cl_mem); }
method cl_mem (line 5663) | static const cl_mem *ptr(const T &value) { return &(value()); }
type KernelArgumentHandler<LocalSpaceArg, void> (line 5669) | struct KernelArgumentHandler<LocalSpaceArg, void>
method size_type (line 5671) | static size_type size(const LocalSpaceArg &value) { return value.s...
type KernelArgumentHandler<cl::DeviceCommandQueue, void> (line 8429) | struct KernelArgumentHandler<cl::DeviceCommandQueue, void>
method size_type (line 8431) | static size_type size(const cl::DeviceCommandQueue &) { return siz...
method cl_command_queue (line 8432) | static const cl_command_queue *ptr(const cl::DeviceCommandQueue &v...
function allocate_pointer (line 3766) | cl::pointer<T, detail::Deleter<Alloc>> allocate_pointer(const Alloc &a...
function allocate_svm (line 3794) | cl::pointer<T, detail::Deleter<SVMAllocator<T, SVMTrait>>> allocate_sv...
function allocate_svm (line 3801) | cl::pointer<T, detail::Deleter<SVMAllocator<T, SVMTrait>>> allocate_sv...
class Buffer (line 3835) | class Buffer : public Memory
method Buffer (line 3845) | Buffer(const Context &context, cl_mem_flags flags, size_type size, v...
method Buffer (line 3866) | Buffer(cl_mem_flags flags, size_type size, void *host_ptr = NULL, cl...
method Buffer (line 3887) | Buffer(IteratorType startIterator, IteratorType endIterator, bool re...
method Buffer (line 3955) | Buffer()
method Buffer (line 3966) | explicit Buffer(const cl_mem &buffer, bool retainObject = false)
method Buffer (line 3974) | Buffer &operator=(const cl_mem &rhs)
method Buffer (line 3983) | Buffer(const Buffer &buf)
method Buffer (line 3990) | Buffer &operator=(const Buffer &buf)
method Buffer (line 3999) | Buffer(Buffer &&buf) CL_HPP_NOEXCEPT_ : Memory(std::move(buf)) {}
method Buffer (line 4004) | Buffer &operator=(Buffer &&buf)
method Buffer (line 4015) | Buffer createSubBuffer(cl_mem_flags flags, cl_buffer_create_type buf...
class BufferD3D10 (line 4042) | class BufferD3D10 : public Buffer
method BufferD3D10 (line 4050) | BufferD3D10(const Context &context, cl_mem_flags flags, ID3D10Buffer...
method BufferD3D10 (line 4082) | BufferD3D10()
method BufferD3D10 (line 4093) | explicit BufferD3D10(const cl_mem &buffer, bool retainObject = false)
method BufferD3D10 (line 4101) | BufferD3D10 &operator=(const cl_mem &rhs)
method BufferD3D10 (line 4110) | BufferD3D10(const BufferD3D10 &buf)
method BufferD3D10 (line 4117) | BufferD3D10 &operator=(const BufferD3D10 &buf)
method BufferD3D10 (line 4126) | BufferD3D10(BufferD3D10 &&buf) CL_HPP_NOEXCEPT_ : Buffer(std::move(b...
method BufferD3D10 (line 4131) | BufferD3D10 &operator=(BufferD3D10 &&buf)
class BufferGL (line 4147) | class BufferGL : public Buffer
method BufferGL (line 4155) | BufferGL(const Context &context, cl_mem_flags flags, cl_GLuint bufob...
method BufferGL (line 4168) | BufferGL()
method BufferGL (line 4179) | explicit BufferGL(const cl_mem &buffer, bool retainObject = false)
method BufferGL (line 4187) | BufferGL &operator=(const cl_mem &rhs)
method BufferGL (line 4196) | BufferGL(const BufferGL &buf)
method BufferGL (line 4203) | BufferGL &operator=(const BufferGL &buf)
method BufferGL (line 4212) | BufferGL(BufferGL &&buf) CL_HPP_NOEXCEPT_ : Buffer(std::move(buf)) {}
method BufferGL (line 4217) | BufferGL &operator=(BufferGL &&buf)
method cl_int (line 4224) | cl_int getObjectInfo(cl_gl_object_type *type, cl_GLuint *gl_object_n...
class BufferRenderGL (line 4238) | class BufferRenderGL : public Buffer
method BufferRenderGL (line 4246) | BufferRenderGL(const Context &context, cl_mem_flags flags, cl_GLuint...
method BufferRenderGL (line 4259) | BufferRenderGL()
method BufferRenderGL (line 4270) | explicit BufferRenderGL(const cl_mem &buffer, bool retainObject = fa...
method BufferRenderGL (line 4278) | BufferRenderGL &operator=(const cl_mem &rhs)
method BufferRenderGL (line 4287) | BufferRenderGL(const BufferRenderGL &buf)
method BufferRenderGL (line 4294) | BufferRenderGL &operator=(const BufferRenderGL &buf)
method BufferRenderGL (line 4303) | BufferRenderGL(BufferRenderGL &&buf) CL_HPP_NOEXCEPT_ : Buffer(std::...
method BufferRenderGL (line 4308) | BufferRenderGL &operator=(BufferRenderGL &&buf)
method cl_int (line 4315) | cl_int getObjectInfo(cl_gl_object_type *type, cl_GLuint *gl_object_n...
class Image (line 4327) | class Image : public Memory
method Image (line 4331) | Image()
method Image (line 4342) | explicit Image(const cl_mem &image, bool retainObject = false)
method Image (line 4350) | Image &operator=(const cl_mem &rhs)
method Image (line 4359) | Image(const Image &img)
method Image (line 4366) | Image &operator=(const Image &img)
method Image (line 4375) | Image(Image &&img) CL_HPP_NOEXCEPT_ : Memory(std::move(img)) {}
method Image (line 4380) | Image &operator=(Image &&img)
method cl_int (line 4390) | cl_int getImageInfo(cl_image_info name, T *param) const
method getImageInfo (line 4397) | typename detail::param_traits<detail::cl_image_info, name>::param_ty...
class Image1D (line 4416) | class Image1D : public Image
method Image1D (line 4423) | Image1D(const Context &context, cl_mem_flags flags, ImageFormat form...
method Image1D (line 4442) | Image1D() {}
method Image1D (line 4451) | explicit Image1D(const cl_mem &image1D, bool retainObject = false)
method Image1D (line 4459) | Image1D &operator=(const cl_mem &rhs)
method Image1D (line 4468) | Image1D(const Image1D &img)
method Image1D (line 4475) | Image1D &operator=(const Image1D &img)
method Image1D (line 4484) | Image1D(Image1D &&img) CL_HPP_NOEXCEPT_ : Image(std::move(img)) {}
method Image1D (line 4489) | Image1D &operator=(Image1D &&img)
class Image1DBuffer (line 4499) | class Image1DBuffer : public Image
method Image1DBuffer (line 4502) | Image1DBuffer(const Context &context, cl_mem_flags flags, ImageForma...
method Image1DBuffer (line 4521) | Image1DBuffer() {}
method Image1DBuffer (line 4530) | explicit Image1DBuffer(const cl_mem &image1D, bool retainObject = fa...
method Image1DBuffer (line 4534) | Image1DBuffer &operator=(const cl_mem &rhs)
method Image1DBuffer (line 4543) | Image1DBuffer(const Image1DBuffer &img)
method Image1DBuffer (line 4550) | Image1DBuffer &operator=(const Image1DBuffer &img)
method Image1DBuffer (line 4559) | Image1DBuffer(Image1DBuffer &&img) CL_HPP_NOEXCEPT_ : Image(std::mov...
method Image1DBuffer (line 4564) | Image1DBuffer &operator=(Image1DBuffer &&img)
class Image1DArray (line 4574) | class Image1DArray : public Image
method Image1DArray (line 4577) | Image1DArray(const Context &context, cl_mem_flags flags, ImageFormat...
method Image1DArray (line 4597) | Image1DArray() {}
method Image1DArray (line 4606) | explicit Image1DArray(const cl_mem &imageArray, bool retainObject = ...
method Image1DArray (line 4611) | Image1DArray &operator=(const cl_mem &rhs)
method Image1DArray (line 4620) | Image1DArray(const Image1DArray &img)
method Image1DArray (line 4627) | Image1DArray &operator=(const Image1DArray &img)
method Image1DArray (line 4636) | Image1DArray(Image1DArray &&img) CL_HPP_NOEXCEPT_ : Image(std::move(...
method Image1DArray (line 4641) | Image1DArray &operator=(Image1DArray &&img)
class Image2D (line 4656) | class Image2D : public Image
method Image2D (line 4663) | Image2D(const Context &context, cl_mem_flags flags, ImageFormat form...
method Image2D (line 4719) | Image2D(const Context &context, ImageFormat format, const Buffer &so...
method Image2D (line 4756) | Image2D(const Context &context, cl_channel_order order, const Image ...
method Image2D (line 4794) | Image2D() {}
method Image2D (line 4803) | explicit Image2D(const cl_mem &image2D, bool retainObject = false)
method Image2D (line 4811) | Image2D &operator=(const cl_mem &rhs)
method Image2D (line 4820) | Image2D(const Image2D &img)
method Image2D (line 4827) | Image2D &operator=(const Image2D &img)
method Image2D (line 4836) | Image2D(Image2D &&img) CL_HPP_NOEXCEPT_ : Image(std::move(img)) {}
method Image2D (line 4841) | Image2D &operator=(Image2D &&img)
function Image2DGL (line 4859) | class CL_API_PREFIX__VERSION_1_1_DEPRECATED Image2DGL : public Image2D
class Image2DArray (line 4943) | class Image2DArray : public Image
method Image2DArray (line 4946) | Image2DArray(const Context &context, cl_mem_flags flags, ImageFormat...
method Image2DArray (line 4968) | Image2DArray() {}
method Image2DArray (line 4977) | explicit Image2DArray(const cl_mem &imageArray, bool retainObject = ...
method Image2DArray (line 4981) | Image2DArray &operator=(const cl_mem &rhs)
method Image2DArray (line 4990) | Image2DArray(const Image2DArray &img)
method Image2DArray (line 4997) | Image2DArray &operator=(const Image2DArray &img)
method Image2DArray (line 5006) | Image2DArray(Image2DArray &&img) CL_HPP_NOEXCEPT_ : Image(std::move(...
method Image2DArray (line 5011) | Image2DArray &operator=(Image2DArray &&img)
class Image3D (line 5025) | class Image3D : public Image
method Image3D (line 5032) | Image3D(const Context &context, cl_mem_flags flags, ImageFormat form...
method Image3D (line 5087) | Image3D()
method Image3D (line 5098) | explicit Image3D(const cl_mem &image3D, bool retainObject = false)
method Image3D (line 5106) | Image3D &operator=(const cl_mem &rhs)
method Image3D (line 5115) | Image3D(const Image3D &img)
method Image3D (line 5122) | Image3D &operator=(const Image3D &img)
method Image3D (line 5131) | Image3D(Image3D &&img) CL_HPP_NOEXCEPT_ : Image(std::move(img)) {}
method Image3D (line 5136) | Image3D &operator=(Image3D &&img)
class Image3DGL (line 5152) | class Image3DGL : public Image3D
method Image3DGL (line 5160) | Image3DGL(const Context &context, cl_mem_flags flags, cl_GLenum targ...
method Image3DGL (line 5174) | Image3DGL()
method Image3DGL (line 5185) | explicit Image3DGL(const cl_mem &image, bool retainObject = false)
method Image3DGL (line 5193) | Image3DGL &operator=(const cl_mem &rhs)
method Image3DGL (line 5202) | Image3DGL(const Image3DGL &img)
method Image3DGL (line 5209) | Image3DGL &operator=(const Image3DGL &img)
method Image3DGL (line 5218) | Image3DGL(Image3DGL &&img) CL_HPP_NOEXCEPT_ : Image3D(std::move(img)...
method Image3DGL (line 5223) | Image3DGL &operator=(Image3DGL &&img)
class ImageGL (line 5238) | class ImageGL : public Image
method ImageGL (line 5241) | ImageGL(const Context &context, cl_mem_flags flags, cl_GLenum target...
method ImageGL (line 5254) | ImageGL()
method ImageGL (line 5265) | explicit ImageGL(const cl_mem &image, bool retainObject = false)
method ImageGL (line 5269) | ImageGL &operator=(const cl_mem &rhs)
method ImageGL (line 5278) | ImageGL(const ImageGL &img)
method ImageGL (line 5285) | ImageGL &operator=(const ImageGL &img)
method ImageGL (line 5294) | ImageGL(ImageGL &&img) CL_HPP_NOEXCEPT_ : Image(std::move(img)) {}
method ImageGL (line 5299) | ImageGL &operator=(ImageGL &&img)
class Pipe (line 5315) | class Pipe : public Memory
method Pipe (line 5327) | Pipe(const Context &context, cl_uint packet_size, cl_uint max_packet...
method Pipe (line 5349) | Pipe(cl_uint packet_size, cl_uint max_packets, cl_int *err = NULL)
method Pipe (line 5366) | Pipe()
method Pipe (line 5377) | explicit Pipe(const cl_mem &pipe, bool retainObject = false)
method Pipe (line 5385) | Pipe &operator=(const cl_mem &rhs)
method Pipe (line 5394) | Pipe(const Pipe &pipe)
method Pipe (line 5401) | Pipe &operator=(const Pipe &pipe)
method Pipe (line 5410) | Pipe(Pipe &&pipe) CL_HPP_NOEXCEPT_ : Memory(std::move(pipe)) {}
method Pipe (line 5415) | Pipe &operator=(Pipe &&pipe)
method cl_int (line 5423) | cl_int getInfo(cl_pipe_info name, T *param) const
method getInfo (line 5430) | typename detail::param_traits<detail::cl_pipe_info, name>::param_typ...
class Sampler (line 5452) | class Sampler : public detail::Wrapper<cl_sampler>
method Sampler (line 5456) | Sampler() {}
method Sampler (line 5462) | Sampler(const Context &context, cl_bool normalized_coords, cl_addres...
method Sampler (line 5501) | explicit Sampler(const cl_sampler &sampler, bool retainObject = false)
method Sampler (line 5510) | Sampler &operator=(const cl_sampler &rhs)
method Sampler (line 5519) | Sampler(const Sampler &sam)
method Sampler (line 5526) | Sampler &operator=(const Sampler &sam)
method Sampler (line 5535) | Sampler(Sampler &&sam) CL_HPP_NOEXCEPT_ : detail::Wrapper<cl_type>(s...
method Sampler (line 5540) | Sampler &operator=(Sampler &&sam)
method cl_int (line 5548) | cl_int getInfo(cl_sampler_info name, T *param) const
method getInfo (line 5555) | typename detail::param_traits<detail::cl_sampler_info, name>::param_...
class Program (line 5567) | class Program
method Program (line 6018) | Program(const string &source, bool build = false, cl_int *err = NULL)
method Program (line 6050) | Program(const Context &context, const string &source, bool build = f...
method Program (line 6084) | Program(const Sources &sources, cl_int *err = NULL)
method Program (line 6118) | Program(const Context &context, const Sources &sources, cl_int *err ...
method Program (line 6153) | Program(const vector<char> &IL, bool build = false, cl_int *err = NULL)
method Program (line 6199) | Program(const Context &context, const vector<char> &IL, bool build =...
method Program (line 6258) | Program(const Context &context, const vector<Device> &devices, const...
method Program (line 6322) | Program(const Context &context, const vector<Device> &devices, const...
method Program (line 6345) | Program() {}
method Program (line 6354) | explicit Program(const cl_program &program, bool retainObject = false)
method Program (line 6358) | Program &operator=(const cl_program &rhs)
method Program (line 6367) | Program(const Program &program)
method Program (line 6374) | Program &operator=(const Program &program)
method Program (line 6383) | Program(Program &&program) CL_HPP_NOEXCEPT_ : detail::Wrapper<cl_typ...
method Program (line 6388) | Program &operator=(Program &&program)
method cl_int (line 6394) | cl_int build(const vector<Device> &devices, const char *options = NULL,
method cl_int (line 6410) | cl_int build(const Device &device, const char *options = NULL,
method cl_int (line 6422) | cl_int build(const char *options = NULL, void(CL_CALLBACK *notifyFpt...
method cl_int (line 6431) | cl_int compile(const char *options = NULL, void(CL_CALLBACK *notifyF...
method cl_int (line 6440) | cl_int getInfo(cl_program_info name, T *param) const
method getInfo (line 6446) | typename detail::param_traits<detail::cl_program_info, name>::param_...
method cl_int (line 6458) | cl_int getBuildInfo(const Device &device, cl_program_build_info name...
method getBuildInfo (line 6465) | typename detail::param_traits<detail::cl_program_build_info, name>::...
method getBuildInfo (line 6483) | vector<std::pair<cl::Device, typename detail::param_traits<detail::c...
method cl_int (line 6526) | cl_int createKernels(vector<Kernel> *kernels)
method CL_API_PREFIX__VERSION_2_2_DEPRECATED (line 6571) | CL_API_PREFIX__VERSION_2_2_DEPRECATED cl_int
method setSpecializationConstant (line 6585) | typename std::enable_if<!std::is_pointer<T>::value, cl_int>::type se...
method cl_int (line 6596) | cl_int setSpecializationConstant(cl_uint index, size_type size, cons...
class CommandQueue (line 5568) | class CommandQueue
method makeDefault (line 6759) | static void makeDefault()
method makeDefaultProvided (line 6794) | static void makeDefaultProvided(const CommandQueue &c) { default_ = ...
method unitTestClearDefault (line 6804) | static void unitTestClearDefault() { default_ = CommandQueue(); }
method CommandQueue (line 6812) | CommandQueue(cl_command_queue_properties properties, cl_int *err = N...
method CommandQueue (line 6882) | CommandQueue(QueueProperties properties, cl_int *err = NULL)
method CommandQueue (line 6948) | explicit CommandQueue(const Context &context, cl_command_queue_prope...
method CommandQueue (line 7016) | explicit CommandQueue(const Context &context, QueueProperties proper...
method CommandQueue (line 7078) | CommandQueue(const Context &context, const Device &device, cl_comman...
method CommandQueue (line 7127) | CommandQueue(const Context &context, const Device &device, QueueProp...
method CommandQueue (line 7172) | static CommandQueue getDefault(cl_int *err = NULL)
method CommandQueue (line 7194) | static CommandQueue setDefault(const CommandQueue &default_queue)
method CommandQueue (line 7201) | CommandQueue() {}
method CommandQueue (line 7210) | explicit CommandQueue(const cl_command_queue &commandQueue, bool ret...
method CommandQueue (line 7214) | CommandQueue &operator=(const cl_command_queue &rhs)
method CommandQueue (line 7223) | CommandQueue(const CommandQueue &queue)
method CommandQueue (line 7230) | CommandQueue &operator=(const CommandQueue &queue)
method CommandQueue (line 7239) | CommandQueue(CommandQueue &&queue) CL_HPP_NOEXCEPT_ : detail::Wrappe...
method CommandQueue (line 7244) | CommandQueue &operator=(CommandQueue &&queue)
method cl_int (line 7251) | cl_int getInfo(cl_command_queue_info name, T *param) const
method getInfo (line 7258) | typename detail::param_traits<detail::cl_command_queue_info, name>::...
method cl_int (line 7269) | cl_int enqueueReadBuffer(const Buffer &buffer, cl_bool blocking, siz...
method cl_int (line 7285) | cl_int enqueueWriteBuffer(const Buffer &buffer, cl_bool blocking, si...
method cl_int (line 7301) | cl_int enqueueCopyBuffer(const Buffer &src, const Buffer &dst, size_...
method cl_int (line 7317) | cl_int enqueueReadBufferRect(const Buffer &buffer, cl_bool blocking,...
method cl_int (line 7337) | cl_int enqueueWriteBufferRect(const Buffer &buffer, cl_bool blocking...
method cl_int (line 7357) | cl_int enqueueCopyBufferRect(const Buffer &src, const Buffer &dst, c...
method cl_int (line 7389) | cl_int enqueueFillBuffer(const Buffer &buffer, PatternType pattern, ...
method cl_int (line 7407) | cl_int enqueueReadImage(const Image &image, cl_bool blocking, const ...
method cl_int (line 7425) | cl_int enqueueWriteImage(const Image &image, cl_bool blocking, const...
method cl_int (line 7443) | cl_int enqueueCopyImage(const Image &src, const Image &dst, const ar...
method cl_int (line 7469) | cl_int enqueueFillImage(const Image &image, cl_float4 fillColor, con...
method cl_int (line 7494) | cl_int enqueueFillImage(const Image &image, cl_int4 fillColor, const...
method cl_int (line 7519) | cl_int enqueueFillImage(const Image &image, cl_uint4 fillColor, cons...
method cl_int (line 7538) | cl_int enqueueCopyImageToBuffer(const Image &src, const Buffer &dst,...
method cl_int (line 7556) | cl_int enqueueCopyBufferToImage(const Buffer &src, const Image &dst,...
method cl_int (line 7622) | cl_int enqueueMapSVM(T *ptr, cl_bool blocking, cl_map_flags flags, s...
method cl_int (line 7644) | cl_int enqueueMapSVM(cl::pointer<T, D> &ptr, cl_bool blocking, cl_ma...
method cl_int (line 7665) | cl_int enqueueMapSVM(cl::vector<T, Alloc> &container, cl_bool blocki...
method cl_int (line 7683) | cl_int enqueueUnmapMemObject(const Memory &memory, void *mapped_ptr,...
method cl_int (line 7706) | cl_int enqueueUnmapSVM(T *ptr, const vector<Event> *events = NULL, E...
method cl_int (line 7726) | cl_int enqueueUnmapSVM(cl::pointer<T, D> &ptr, const vector<Event> *...
method cl_int (line 7746) | cl_int enqueueUnmapSVM(cl::vector<T, Alloc> &container, const vector...
method cl_int (line 7774) | cl_int enqueueMarkerWithWaitList(const vector<Event> *events = 0, Ev...
method cl_int (line 7800) | cl_int enqueueBarrierWithWaitList(const vector<Event> *events = 0, E...
method cl_int (line 7819) | cl_int enqueueMigrateMemObjects(const vector<Memory> &memObjects, cl...
method cl_int (line 7853) | cl_int enqueueMigrateSVM(const cl::vector<T *> &svmRawPointers, cons...
method cl_int (line 7877) | cl_int enqueueMigrateSVM(const cl::vector<T *> &svmRawPointers, cl_m...
method cl_int (line 7890) | cl_int enqueueMigrateSVM(const cl::vector<cl::pointer<T, D>> &svmPoi...
method cl_int (line 7910) | cl_int enqueueMigrateSVM(const cl::vector<cl::pointer<T, D>> &svmPoi...
method cl_int (line 7922) | cl_int enqueueMigrateSVM(const cl::vector<cl::vector<T, Alloc>> &svm...
method cl_int (line 7941) | cl_int enqueueMigrateSVM(const cl::vector<cl::vector<T, Alloc>> &svm...
method cl_int (line 7949) | cl_int enqueueNDRangeKernel(const Kernel &kernel, const NDRange &off...
method CL_API_PREFIX__VERSION_1_2_DEPRECATED (line 7969) | CL_API_PREFIX__VERSION_1_2_DEPRECATED cl_int
method cl_int (line 7987) | cl_int enqueueNativeKernel(void(CL_CALLBACK *userFptr)(void *), std:...
method CL_API_PREFIX__VERSION_1_1_DEPRECATED (line 8021) | CL_API_PREFIX__VERSION_1_1_DEPRECATED
method CL_API_PREFIX__VERSION_1_1_DEPRECATED (line 8033) | CL_API_PREFIX__VERSION_1_1_DEPRECATED
method cl_int (line 8042) | cl_int enqueueAcquireGLObjects(const vector<Memory> *mem_objects = N...
method cl_int (line 8060) | cl_int enqueueReleaseGLObjects(const vector<Memory> *mem_objects = N...
method cl_int (line 8086) | cl_int enqueueAcquireD3D10Objects(const vector<Memory> *mem_objects ...
method cl_int (line 8115) | cl_int enqueueReleaseD3D10Objects(const vector<Memory> *mem_objects ...
method CL_API_PREFIX__VERSION_1_1_DEPRECATED (line 8149) | CL_API_PREFIX__VERSION_1_1_DEPRECATED
method cl_int (line 8156) | cl_int flush() const { return detail::errHandler(::clFlush(object_),...
method cl_int (line 8158) | cl_int finish() const { return detail::errHandler(::clFinish(object_...
class DeviceCommandQueue (line 5569) | class DeviceCommandQueue
method DeviceCommandQueue (line 8188) | DeviceCommandQueue() {}
method DeviceCommandQueue (line 8193) | DeviceCommandQueue(DeviceQueueProperties properties, cl_int *err = N...
method DeviceCommandQueue (line 8215) | DeviceCommandQueue(const Context &context, const Device &device,
method DeviceCommandQueue (line 8235) | DeviceCommandQueue(const Context &context, const Device &device, cl_...
method DeviceCommandQueue (line 8258) | explicit DeviceCommandQueue(const cl_command_queue &commandQueue, bo...
method DeviceCommandQueue (line 8262) | DeviceCommandQueue &operator=(const cl_command_queue &rhs)
method DeviceCommandQueue (line 8271) | DeviceCommandQueue(const DeviceCommandQueue &queue)
method DeviceCommandQueue (line 8278) | DeviceCommandQueue &operator=(const DeviceCommandQueue &queue)
method DeviceCommandQueue (line 8287) | DeviceCommandQueue(DeviceCommandQueue &&queue) CL_HPP_NOEXCEPT_ : de...
method DeviceCommandQueue (line 8292) | DeviceCommandQueue &operator=(DeviceCommandQueue &&queue)
method cl_int (line 8299) | cl_int getInfo(cl_command_queue_info name, T *param) const
method getInfo (line 8306) | typename detail::param_traits<detail::cl_command_queue_info, name>::...
method DeviceCommandQueue (line 8323) | static DeviceCommandQueue makeDefault(cl_int *err = nullptr)
method DeviceCommandQueue (line 8349) | static DeviceCommandQueue makeDefault(const Context &context, const ...
method DeviceCommandQueue (line 8373) | static DeviceCommandQueue makeDefault(const Context &context, const ...
method DeviceCommandQueue (line 8400) | static DeviceCommandQueue updateDefault(const Context &context, cons...
method DeviceCommandQueue (line 8417) | static DeviceCommandQueue getDefault(const CommandQueue &queue, cl_i...
class Kernel (line 5570) | class Kernel
method Kernel (line 5701) | Kernel() {}
method Kernel (line 5711) | explicit Kernel(const cl_kernel &kernel, bool retainObject = false)
method Kernel (line 5720) | Kernel &operator=(const cl_kernel &rhs)
method Kernel (line 5729) | Kernel(const Kernel &kernel)
method Kernel (line 5736) | Kernel &operator=(const Kernel &kernel)
method Kernel (line 5745) | Kernel(Kernel &&kernel) CL_HPP_NOEXCEPT_ : detail::Wrapper<cl_type>(...
method Kernel (line 5750) | Kernel &operator=(Kernel &&kernel)
method cl_int (line 5757) | cl_int getInfo(cl_kernel_info name, T *param) const
method getInfo (line 5763) | typename detail::param_traits<detail::cl_kernel_info, name>::param_t...
method cl_int (line 5776) | cl_int getArgInfo(cl_uint argIndex, cl_kernel_arg_info name, T *para...
method getArgInfo (line 5783) | typename detail::param_traits<detail::cl_kernel_arg_info, name>::par...
method cl_int (line 5797) | cl_int getWorkGroupInfo(const Device &device, cl_kernel_work_group_i...
method getWorkGroupInfo (line 5804) | typename detail::param_traits<detail::cl_kernel_work_group_info, nam...
method cl_int (line 5818) | cl_int getSubGroupInfo(const cl::Device &dev, cl_kernel_sub_group_in...
method size_type (line 5841) | size_type getSubGroupInfo(const cl::Device &dev, const cl::NDRange &...
method cl_int (line 5857) | cl_int setArg(cl_uint index, const cl::pointer<T, D> &argPtr)
method cl_int (line 5865) | cl_int setArg(cl_uint index, const cl::vector<T, Alloc> &argPtr)
method setArg (line 5873) | typename std::enable_if<std::is_pointer<T>::value, cl_int>::type set...
method setArg (line 5882) | typename std::enable_if<!std::is_pointer<T>::value, cl_int>::type se...
method cl_int (line 5889) | cl_int setArg(cl_uint index, size_type size, const void *argPtr)
method cl_int (line 5899) | cl_int setSVMPointers(const vector<void *> &pointerList)
method cl_int (line 5910) | cl_int setSVMPointers(const std::array<void *, ArrayLength> &pointer...
method cl_int (line 5927) | cl_int enableFineGrainedSystemSVM(bool svmEnabled)
method setSVMPointersHelper (line 5935) | void setSVMPointersHelper(std::array<void *, ArrayLength> &pointerLi...
method setSVMPointersHelper (line 5943) | typename std::enable_if<std::is_pointer<T0>::value, void>::type setS...
method setSVMPointersHelper (line 5951) | void setSVMPointersHelper(std::array<void *, ArrayLength> &pointerLi...
method setSVMPointersHelper (line 5958) | typename std::enable_if<std::is_pointer<T0>::value, void>::type setS...
method cl_int (line 5965) | cl_int setSVMPointers(const T0 &t0, Ts &...ts)
method cl_int (line 5975) | cl_int setExecInfo(cl_kernel_exec_info param_name, const T &val)
method cl_int (line 5981) | cl_int setExecInfo(typename detail::param_traits<detail::cl_kernel_e...
method Kernel (line 5993) | Kernel clone()
class NDRange (line 5573) | class NDRange
method NDRange (line 5581) | NDRange()
method NDRange (line 5590) | NDRange(size_type size0)
method NDRange (line 5599) | NDRange(size_type size0, size_type size1)
method NDRange (line 5608) | NDRange(size_type size0, size_type size1, size_type size2)
method size_type (line 5623) | size_type dimensions() const { return dimensions_; }
method size_type (line 5627) | size_type size() const { return dimensions_ * sizeof(size_type); }
method size_type (line 5629) | size_type *get() { return sizes_; }
method size_type (line 5631) | const size_type *get() const { return sizes_; }
type LocalSpaceArg (line 5638) | struct LocalSpaceArg
type detail (line 5643) | namespace detail
function cl_int (line 814) | static inline cl_int errHandler(cl_int err, const char *errStr = NULL)
function cl_int (line 823) | static inline cl_int errHandler(cl_int err, const char *errStr = NULL)
function cl_int (line 1008) | inline cl_int getInfoHelper(Functor f, cl_uint name, T *param, long)
function cl_int (line 1016) | inline cl_int getInfoHelper(Func f, cl_uint name, vector<vector<unsi...
function cl_int (line 1047) | inline cl_int getInfoHelper(Func f, cl_uint name, vector<T> *param, ...
function cl_int (line 1079) | inline cl_int getInfoHelper(Func f, cl_uint name, vector<T> *param, ...
function cl_int (line 1114) | inline cl_int getInfoHelper(Func f, cl_uint name, string *param, long)
function cl_int (line 1147) | inline cl_int getInfoHelper(Func f, cl_uint name, array<size_type, N...
type ReferenceHandler (line 1180) | struct ReferenceHandler
function cl_int (line 1189) | inline cl_int getInfoHelper(Func f, cl_uint name, T *param, int, typ...
type param_traits (line 1483) | struct param_traits
function cl_int (line 1669) | inline cl_int getInfo(Func f, cl_uint name, T *param)
type GetInfoFunctor0 (line 1675) | struct GetInfoFunctor0
method cl_int (line 1679) | cl_int operator()(cl_uint param, size_type size, void *value, size...
type GetInfoFunctor1 (line 1686) | struct GetInfoFunctor1
method cl_int (line 1691) | cl_int operator()(cl_uint param, size_type size, void *value, size...
function cl_int (line 1698) | inline cl_int getInfo(Func f, const Arg0 &arg0, cl_uint name, T *param)
function cl_int (line 1705) | inline cl_int getInfo(Func f, const Arg0 &arg0, const Arg1 &arg1, cl...
type ReferenceHandler (line 1713) | struct ReferenceHandler
type ReferenceHandler<cl_device_id> (line 1722) | struct ReferenceHandler<cl_device_id>
method cl_int (line 1733) | static cl_int retain(cl_device_id device) { return ::clRetainDevic...
method cl_int (line 1743) | static cl_int release(cl_device_id device) { return ::clReleaseDev...
method cl_int (line 1753) | static cl_int retain(cl_device_id) { return CL_SUCCESS; }
method cl_int (line 1755) | static cl_int release(cl_device_id) { return CL_SUCCESS; }
type ReferenceHandler<cl_device_id> (line 1750) | struct ReferenceHandler<cl_device_id>
method cl_int (line 1733) | static cl_int retain(cl_device_id device) { return ::clRetainDevic...
method cl_int (line 1743) | static cl_int release(cl_device_id device) { return ::clReleaseDev...
method cl_int (line 1753) | static cl_int retain(cl_device_id) { return CL_SUCCESS; }
method cl_int (line 1755) | static cl_int release(cl_device_id) { return CL_SUCCESS; }
type ReferenceHandler<cl_platform_id> (line 1760) | struct ReferenceHandler<cl_platform_id>
method cl_int (line 1763) | static cl_int retain(cl_platform_id) { return CL_SUCCESS; }
method cl_int (line 1765) | static cl_int release(cl_platform_id) { return CL_SUCCESS; }
type ReferenceHandler<cl_context> (line 1769) | struct ReferenceHandler<cl_context>
method cl_int (line 1771) | static cl_int retain(cl_context context) { return ::clRetainContex...
method cl_int (line 1772) | static cl_int release(cl_context context) { return ::clReleaseCont...
type ReferenceHandler<cl_command_queue> (line 1776) | struct ReferenceHandler<cl_command_queue>
method cl_int (line 1778) | static cl_int retain(cl_command_queue queue) { return ::clRetainCo...
method cl_int (line 1779) | static cl_int release(cl_command_queue queue) { return ::clRelease...
type ReferenceHandler<cl_mem> (line 1783) | struct ReferenceHandler<cl_mem>
method cl_int (line 1785) | static cl_int retain(cl_mem memory) { return ::clRetainMemObject(m...
method cl_int (line 1786) | static cl_int release(cl_mem memory) { return ::clReleaseMemObject...
type ReferenceHandler<cl_sampler> (line 1790) | struct ReferenceHandler<cl_sampler>
method cl_int (line 1792) | static cl_int retain(cl_sampler sampler) { return ::clRetainSample...
method cl_int (line 1793) | static cl_int release(cl_sampler sampler) { return ::clReleaseSamp...
type ReferenceHandler<cl_program> (line 1797) | struct ReferenceHandler<cl_program>
method cl_int (line 1799) | static cl_int retain(cl_program program) { return ::clRetainProgra...
method cl_int (line 1800) | static cl_int release(cl_program program) { return ::clReleaseProg...
type ReferenceHandler<cl_kernel> (line 1804) | struct ReferenceHandler<cl_kernel>
method cl_int (line 1806) | static cl_int retain(cl_kernel kernel) { return ::clRetainKernel(k...
method cl_int (line 1807) | static cl_int release(cl_kernel kernel) { return ::clReleaseKernel...
type ReferenceHandler<cl_event> (line 1811) | struct ReferenceHandler<cl_event>
method cl_int (line 1813) | static cl_int retain(cl_event event) { return ::clRetainEvent(even...
method cl_int (line 1814) | static cl_int release(cl_event event) { return ::clReleaseEvent(ev...
function cl_uint (line 1820) | static cl_uint getVersion(const vector<char> &versionInfo)
function cl_uint (line 1841) | static cl_uint getPlatformVersion(cl_platform_id platform)
function cl_uint (line 1851) | static cl_uint getDevicePlatformVersion(cl_device_id device)
function cl_uint (line 1858) | static cl_uint getContextPlatformVersion(cl_context context)
class Wrapper (line 1873) | class Wrapper
method Wrapper (line 1882) | Wrapper()
method Wrapper (line 1886) | Wrapper(const cl_type &obj, bool retainObject)
method Wrapper (line 1903) | Wrapper(const Wrapper<cl_type> &rhs)
method Wrapper (line 1909) | Wrapper(Wrapper<cl_type> &&rhs) CL_HPP_NOEXCEPT_
method cl_type (line 1944) | const cl_type &operator()() const { return object_; }
method cl_type (line 1946) | cl_type &operator()() { return object_; }
method cl_type (line 1948) | cl_type get() const { return object_; }
method cl_int (line 1954) | cl_int retain() const
method cl_int (line 1966) | cl_int release() const
class Wrapper<cl_device_id> (line 1980) | class Wrapper<cl_device_id>
method isReferenceCountable (line 1989) | static bool isReferenceCountable(cl_device_id device)
method Wrapper (line 2010) | Wrapper()
method Wrapper (line 2015) | Wrapper(const cl_type &obj, bool retainObject)
method Wrapper (line 2029) | Wrapper(const Wrapper<cl_type> &rhs)
method Wrapper (line 2036) | Wrapper(Wrapper<cl_type> &&rhs) CL_HPP_NOEXCEPT_
method cl_type (line 2077) | const cl_type &operator()() const { return object_; }
method cl_type (line 2079) | cl_type &operator()() { return object_; }
method cl_type (line 2081) | cl_type get() const { return object_; }
method cl_int (line 2090) | cl_int retain() const
method cl_int (line 2102) | cl_int release() const
function cl_int (line 2153) | static inline cl_int buildErrHandler(cl_int err, const char *errStr,...
function cl_int (line 2166) | static inline cl_int buildErrHandler(cl_int err, const char *errStr,...
class SVMTraitNull (line 3525) | class SVMTraitNull
method cl_svm_mem_flags (line 3528) | static cl_svm_mem_flags getSVMMemFlags() { return 0; }
class Deleter (line 3736) | class Deleter
method Deleter (line 3745) | Deleter(const Alloc &alloc, size_type copies)
type KernelArgumentHandler (line 5646) | struct KernelArgumentHandler
type KernelArgumentHandler<T, typename std::enable_if<!std::is_base_of<cl::Memory, T>::value>::type> (line 5651) | struct KernelArgumentHandler<T, typename std::enable_if<!std::is_bas...
method size_type (line 5653) | static size_type size(const T &) { return sizeof(T); }
method T (line 5654) | static const T *ptr(const T &value) { return &value; }
type KernelArgumentHandler<T, typename std::enable_if<std::is_base_of<cl::Memory, T>::value>::type> (line 5660) | struct KernelArgumentHandler<T, typename std::enable_if<std::is_base...
method size_type (line 5662) | static size_type size(const T &) { return sizeof(cl_mem); }
method cl_mem (line 5663) | static const cl_mem *ptr(const T &value) { return &(value()); }
type KernelArgumentHandler<LocalSpaceArg, void> (line 5669) | struct KernelArgumentHandler<LocalSpaceArg, void>
method size_type (line 5671) | static size_type size(const LocalSpaceArg &value) { return value.s...
type KernelArgumentHandler<cl::DeviceCommandQueue, void> (line 8429) | struct KernelArgumentHandler<cl::DeviceCommandQueue, void>
method size_type (line 8431) | static size_type size(const cl::DeviceCommandQueue &) { return siz...
method cl_command_queue (line 8432) | static const cl_command_queue *ptr(const cl::DeviceCommandQueue &v...
function LocalSpaceArg (line 5681) | inline LocalSpaceArg Local(size_type size)
class Kernel (line 5695) | class Kernel : public detail::Wrapper<cl_kernel>
method Kernel (line 5701) | Kernel() {}
method Kernel (line 5711) | explicit Kernel(const cl_kernel &kernel, bool retainObject = false)
method Kernel (line 5720) | Kernel &operator=(const cl_kernel &rhs)
method Kernel (line 5729) | Kernel(const Kernel &kernel)
method Kernel (line 5736) | Kernel &operator=(const Kernel &kernel)
method Kernel (line 5745) | Kernel(Kernel &&kernel) CL_HPP_NOEXCEPT_ : detail::Wrapper<cl_type>(...
method Kernel (line 5750) | Kernel &operator=(Kernel &&kernel)
method cl_int (line 5757) | cl_int getInfo(cl_kernel_info name, T *param) const
method getInfo (line 5763) | typename detail::param_traits<detail::cl_kernel_info, name>::param_t...
method cl_int (line 5776) | cl_int getArgInfo(cl_uint argIndex, cl_kernel_arg_info name, T *para...
method getArgInfo (line 5783) | typename detail::param_traits<detail::cl_kernel_arg_info, name>::par...
method cl_int (line 5797) | cl_int getWorkGroupInfo(const Device &device, cl_kernel_work_group_i...
method getWorkGroupInfo (line 5804) | typename detail::param_traits<detail::cl_kernel_work_group_info, nam...
method cl_int (line 5818) | cl_int getSubGroupInfo(const cl::Device &dev, cl_kernel_sub_group_in...
method size_type (line 5841) | size_type getSubGroupInfo(const cl::Device &dev, const cl::NDRange &...
method cl_int (line 5857) | cl_int setArg(cl_uint index, const cl::pointer<T, D> &argPtr)
method cl_int (line 5865) | cl_int setArg(cl_uint index, const cl::vector<T, Alloc> &argPtr)
method setArg (line 5873) | typename std::enable_if<std::is_pointer<T>::value, cl_int>::type set...
method setArg (line 5882) | typename std::enable_if<!std::is_pointer<T>::value, cl_int>::type se...
method cl_int (line 5889) | cl_int setArg(cl_uint index, size_type size, const void *argPtr)
method cl_int (line 5899) | cl_int setSVMPointers(const vector<void *> &pointerList)
method cl_int (line 5910) | cl_int setSVMPointers(const std::array<void *, ArrayLength> &pointer...
method cl_int (line 5927) | cl_int enableFineGrainedSystemSVM(bool svmEnabled)
method setSVMPointersHelper (line 5935) | void setSVMPointersHelper(std::array<void *, ArrayLength> &pointerLi...
method setSVMPointersHelper (line 5943) | typename std::enable_if<std::is_pointer<T0>::value, void>::type setS...
method setSVMPointersHelper (line 5951) | void setSVMPointersHelper(std::array<void *, ArrayLength> &pointerLi...
method setSVMPointersHelper (line 5958) | typename std::enable_if<std::is_pointer<T0>::value, void>::type setS...
method cl_int (line 5965) | cl_int setSVMPointers(const T0 &t0, Ts &...ts)
method cl_int (line 5975) | cl_int setExecInfo(cl_kernel_exec_info param_name, const T &val)
method cl_int (line 5981) | cl_int setExecInfo(typename detail::param_traits<detail::cl_kernel_e...
method Kernel (line 5993) | Kernel clone()
class Program (line 6007) | class Program : public detail::Wrapper<cl_program>
method Program (line 6018) | Program(const string &source, bool build = false, cl_int *err = NULL)
method Program (line 6050) | Program(const Context &context, const string &source, bool build = f...
method Program (line 6084) | Program(const Sources &sources, cl_int *err = NULL)
method Program (line 6118) | Program(const Context &context, const Sources &sources, cl_int *err ...
method Program (line 6153) | Program(const vector<char> &IL, bool build = false, cl_int *err = NULL)
method Program (line 6199) | Program(const Context &context, const vector<char> &IL, bool build =...
method Program (line 6258) | Program(const Context &context, const vector<Device> &devices, const...
method Program (line 6322) | Program(const Context &context, const vector<Device> &devices, const...
method Program (line 6345) | Program() {}
method Program (line 6354) | explicit Program(const cl_program &program, bool retainObject = false)
method Program (line 6358) | Program &operator=(const cl_program &rhs)
method Program (line 6367) | Program(const Program &program)
method Program (line 6374) | Program &operator=(const Program &program)
method Program (line 6383) | Program(Program &&program) CL_HPP_NOEXCEPT_ : detail::Wrapper<cl_typ...
method Program (line 6388) | Program &operator=(Program &&program)
method cl_int (line 6394) | cl_int build(const vector<Device> &devices, const char *options = NULL,
method cl_int (line 6410) | cl_int build(const Device &device, const char *options = NULL,
method cl_int (line 6422) | cl_int build(const char *options = NULL, void(CL_CALLBACK *notifyFpt...
method cl_int (line 6431) | cl_int compile(const char *options = NULL, void(CL_CALLBACK *notifyF...
method cl_int (line 6440) | cl_int getInfo(cl_program_info name, T *param) const
method getInfo (line 6446) | typename detail::param_traits<detail::cl_program_info, name>::param_...
method cl_int (line 6458) | cl_int getBuildInfo(const Device &device, cl_program_build_info name...
method getBuildInfo (line 6465) | typename detail::param_traits<detail::cl_program_build_info, name>::...
method getBuildInfo (line 6483) | vector<std::pair<cl::Device, typename detail::param_traits<detail::c...
method cl_int (line 6526) | cl_int createKernels(vector<Kernel> *kernels)
method CL_API_PREFIX__VERSION_2_2_DEPRECATED (line 6571) | CL_API_PREFIX__VERSION_2_2_DEPRECATED cl_int
method setSpecializationConstant (line 6585) | typename std::enable_if<!std::is_pointer<T>::value, cl_int>::type se...
method cl_int (line 6596) | cl_int setSpecializationConstant(cl_uint index, size_type size, cons...
function Program (line 6605) | inline Program linkProgram(Program input1, Program input2, const char ...
method Program (line 6018) | Program(const string &source, bool build = false, cl_int *err = NULL)
method Program (line 6050) | Program(const Context &context, const string &source, bool build = f...
method Program (line 6084) | Program(const Sources &sources, cl_int *err = NULL)
method Program (line 6118) | Program(const Context &context, const Sources &sources, cl_int *err ...
method Program (line 6153) | Program(const vector<char> &IL, bool build = false, cl_int *err = NULL)
method Program (line 6199) | Program(const Context &context, const vector<char> &IL, bool build =...
method Program (line 6258) | Program(const Context &context, const vector<Device> &devices, const...
method Program (line 6322) | Program(const Context &context, const vector<Device> &devices, const...
method Program (line 6345) | Program() {}
method Program (line 6354) | explicit Program(const cl_program &program, bool retainObject = false)
method Program (line 6358) | Program &operator=(const cl_program &rhs)
method Program (line 6367) | Program(const Program &program)
method Program (line 6374) | Program &operator=(const Program &program)
method Program (line 6383) | Program(Program &&program) CL_HPP_NOEXCEPT_ : detail::Wrapper<cl_typ...
method Program (line 6388) | Program &operator=(Program &&program)
method cl_int (line 6394) | cl_int build(const vector<Device> &devices, const char *options = NULL,
method cl_int (line 6410) | cl_int build(const Device &device, const char *options = NULL,
method cl_int (line 6422) | cl_int build(const char *options = NULL, void(CL_CALLBACK *notifyFpt...
method cl_int (line 6431) | cl_int compile(const char *options = NULL, void(CL_CALLBACK *notifyF...
method cl_int (line 6440) | cl_int getInfo(cl_program_info name, T *param) const
method getInfo (line 6446) | typename detail::param_traits<detail::cl_program_info, name>::param_...
method cl_int (line 6458) | cl_int getBuildInfo(const Device &device, cl_program_build_info name...
method getBuildInfo (line 6465) | typename detail::param_traits<detail::cl_program_build_info, name>::...
method getBuildInfo (line 6483) | vector<std::pair<cl::Device, typename detail::param_traits<detail::c...
method cl_int (line 6526) | cl_int createKernels(vector<Kernel> *kernels)
method CL_API_PREFIX__VERSION_2_2_DEPRECATED (line 6571) | CL_API_PREFIX__VERSION_2_2_DEPRECATED cl_int
method setSpecializationConstant (line 6585) | typename std::enable_if<!std::is_pointer<T>::value, cl_int>::type se...
method cl_int (line 6596) | cl_int setSpecializationConstant(cl_uint index, size_type size, cons...
function Program (line 6630) | inline Program linkProgram(vector<Program> inputPrograms, const char *...
method Program (line 6018) | Program(const string &source, bool build = false, cl_int *err = NULL)
method Program (line 6050) | Program(const Context &context, const string &source, bool build = f...
method Program (line 6084) | Program(const Sources &sources, cl_int *err = NULL)
method Program (line 6118) | Program(const Context &context, const Sources &sources, cl_int *err ...
method Program (line 6153) | Program(const vector<char> &IL, bool build = false, cl_int *err = NULL)
method Program (line 6199) | Program(const Context &context, const vector<char> &IL, bool build =...
method Program (line 6258) | Program(const Context &context, const vector<Device> &devices, const...
method Program (line 6322) | Program(const Context &context, const vector<Device> &devices, const...
method Program (line 6345) | Program() {}
method Program (line 6354) | explicit Program(const cl_program &program, bool retainObject = false)
method Program (line 6358) | Program &operator=(const cl_program &rhs)
method Program (line 6367) | Program(const Program &program)
method Program (line 6374) | Program &operator=(const Program &program)
method Program (line 6383) | Program(Program &&program) CL_HPP_NOEXCEPT_ : detail::Wrapper<cl_typ...
method Program (line 6388) | Program &operator=(Program &&program)
method cl_int (line 6394) | cl_int build(const vector<Device> &devices, const char *options = NULL,
method cl_int (line 6410) | cl_int build(const Device &device, const char *options = NULL,
method cl_int (line 6422) | cl_int build(const char *options = NULL, void(CL_CALLBACK *notifyFpt...
method cl_int (line 6431) | cl_int compile(const char *options = NULL, void(CL_CALLBACK *notifyF...
method cl_int (line 6440) | cl_int getInfo(cl_program_info name, T *param) const
method getInfo (line 6446) | typename detail::param_traits<detail::cl_program_info, name>::param_...
method cl_int (line 6458) | cl_int getBuildInfo(const Device &device, cl_program_build_info name...
method getBuildInfo (line 6465) | typename detail::param_traits<detail::cl_program_build_info, name>::...
method getBuildInfo (line 6483) | vector<std::pair<cl::Device, typename detail::param_traits<detail::c...
method cl_int (line 6526) | cl_int createKernels(vector<Kernel> *kernels)
method CL_API_PREFIX__VERSION_2_2_DEPRECATED (line 6571) | CL_API_PREFIX__VERSION_2_2_DEPRECATED cl_int
method setSpecializationConstant (line 6585) | typename std::enable_if<!std::is_pointer<T>::value, cl_int>::type se...
method cl_int (line 6596) | cl_int setSpecializationConstant(cl_uint index, size_type size, cons...
function cl_int (line 6667) | inline cl_int cl::Program::getInfo(cl_program_info name, vector<vector...
function cl_int (line 6710) | inline cl_int cl::Program::setSpecializationConstant(cl_uint index, co...
type QueueProperties (line 6731) | enum class QueueProperties : cl_command_queue_properties
function QueueProperties (line 6738) | inline QueueProperties operator|(QueueProperties lhs, QueueProperties ...
class CommandQueue (line 6747) | class CommandQueue : public detail::Wrapper<cl_command_queue>
method makeDefault (line 6759) | static void makeDefault()
method makeDefaultProvided (line 6794) | static void makeDefaultProvided(const CommandQueue &c) { default_ = ...
method unitTestClearDefault (line 6804) | static void unitTestClearDefault() { default_ = CommandQueue(); }
method CommandQueue (line 6812) | CommandQueue(cl_command_queue_properties properties, cl_int *err = N...
method CommandQueue (line 6882) | CommandQueue(QueueProperties properties, cl_int *err = NULL)
method CommandQueue (line 6948) | explicit CommandQueue(const Context &context, cl_command_queue_prope...
method CommandQueue (line 7016) | explicit CommandQueue(const Context &context, QueueProperties proper...
method CommandQueue (line 7078) | CommandQueue(const Context &context, const Device &device, cl_comman...
method CommandQueue (line 7127) | CommandQueue(const Context &context, const Device &device, QueueProp...
method CommandQueue (line 7172) | static CommandQueue getDefault(cl_int *err = NULL)
method CommandQueue (line 7194) | static CommandQueue setDefault(const CommandQueue &default_queue)
method CommandQueue (line 7201) | CommandQueue() {}
method CommandQueue (line 7210) | explicit CommandQueue(const cl_command_queue &commandQueue, bool ret...
method CommandQueue (line 7214) | CommandQueue &operator=(const cl_command_queue &rhs)
method CommandQueue (line 7223) | CommandQueue(const CommandQueue &queue)
method CommandQueue (line 7230) | CommandQueue &operator=(const CommandQueue &queue)
method CommandQueue (line 7239) | CommandQueue(CommandQueue &&queue) CL_HPP_NOEXCEPT_ : detail::Wrappe...
method CommandQueue (line 7244) | CommandQueue &operator=(CommandQueue &&queue)
method cl_int (line 7251) | cl_int getInfo(cl_command_queue_info name, T *param) const
method getInfo (line 7258) | typename detail::param_traits<detail::cl_command_queue_info, name>::...
method cl_int (line 7269) | cl_int enqueueReadBuffer(const Buffer &buffer, cl_bool blocking, siz...
method cl_int (line 7285) | cl_int enqueueWriteBuffer(const Buffer &buffer, cl_bool blocking, si...
method cl_int (line 7301) | cl_int enqueueCopyBuffer(const Buffer &src, const Buffer &dst, size_...
method cl_int (line 7317) | cl_int enqueueReadBufferRect(const Buffer &buffer, cl_bool blocking,...
method cl_int (line 7337) | cl_int enqueueWriteBufferRect(const Buffer &buffer, cl_bool blocking...
method cl_int (line 7357) | cl_int enqueueCopyBufferRect(const Buffer &src, const Buffer &dst, c...
method cl_int (line 7389) | cl_int enqueueFillBuffer(const Buffer &buffer, PatternType pattern, ...
method cl_int (line 7407) | cl_int enqueueReadImage(const Image &image, cl_bool blocking, const ...
method cl_int (line 7425) | cl_int enqueueWriteImage(const Image &image, cl_bool blocking, const...
method cl_int (line 7443) | cl_int enqueueCopyImage(const Image &src, const Image &dst, const ar...
method cl_int (line 7469) | cl_int enqueueFillImage(const Image &image, cl_float4 fillColor, con...
method cl_int (line 7494) | cl_int enqueueFillImage(const Image &image, cl_int4 fillColor, const...
method cl_int (line 7519) | cl_int enqueueFillImage(const Image &image, cl_uint4 fillColor, cons...
method cl_int (line 7538) | cl_int enqueueCopyImageToBuffer(const Image &src, const Buffer &dst,...
method cl_int (line 7556) | cl_int enqueueCopyBufferToImage(const Buffer &src, const Image &dst,...
method cl_int (line 7622) | cl_int enqueueMapSVM(T *ptr, cl_bool blocking, cl_map_flags flags, s...
method cl_int (line 7644) | cl_int enqueueMapSVM(cl::pointer<T, D> &ptr, cl_bool blocking, cl_ma...
method cl_int (line 7665) | cl_int enqueueMapSVM(cl::vector<T, Alloc> &container, cl_bool blocki...
method cl_int (line 7683) | cl_int enqueueUnmapMemObject(const Memory &memory, void *mapped_ptr,...
method cl_int (line 7706) | cl_int enqueueUnmapSVM(T *ptr, const vector<Event> *events = NULL, E...
method cl_int (line 7726) | cl_int enqueueUnmapSVM(cl::pointer<T, D> &ptr, const vector<Event> *...
method cl_int (line 7746) | cl_int enqueueUnmapSVM(cl::vector<T, Alloc> &container, const vector...
method cl_int (line 7774) | cl_int enqueueMarkerWithWaitList(const vector<Event> *events = 0, Ev...
method cl_int (line 7800) | cl_int enqueueBarrierWithWaitList(const vector<Event> *events = 0, E...
method cl_int (line 7819) | cl_int enqueueMigrateMemObjects(const vector<Memory> &memObjects, cl...
method cl_int (line 7853) | cl_int enqueueMigrateSVM(const cl::vector<T *> &svmRawPointers, cons...
method cl_int (line 7877) | cl_int enqueueMigrateSVM(const cl::vector<T *> &svmRawPointers, cl_m...
method cl_int (line 7890) | cl_int enqueueMigrateSVM(const cl::vector<cl::pointer<T, D>> &svmPoi...
method cl_int (line 7910) | cl_int enqueueMigrateSVM(const cl::vector<cl::pointer<T, D>> &svmPoi...
method cl_int (line 7922) | cl_int enqueueMigrateSVM(const cl::vector<cl::vector<T, Alloc>> &svm...
method cl_int (line 7941) | cl_int enqueueMigrateSVM(const cl::vector<cl::vector<T, Alloc>> &svm...
method cl_int (line 7949) | cl_int enqueueNDRangeKernel(const Kernel &kernel, const NDRange &off...
method CL_API_PREFIX__VERSION_1_2_DEPRECATED (line 7969) | CL_API_PREFIX__VERSION_1_2_DEPRECATED cl_int
method cl_int (line 7987) | cl_int enqueueNativeKernel(void(CL_CALLBACK *userFptr)(void *), std:...
method CL_API_PREFIX__VERSION_1_1_DEPRECATED (line 8021) | CL_API_PREFIX__VERSION_1_1_DEPRECATED
method CL_API_PREFIX__VERSION_1_1_DEPRECATED (line 8033) | CL_API_PREFIX__VERSION_1_1_DEPRECATED
method cl_int (line 8042) | cl_int enqueueAcquireGLObjects(const vector<Memory> *mem_objects = N...
method cl_int (line 8060) | cl_int enqueueReleaseGLObjects(const vector<Memory> *mem_objects = N...
method cl_int (line 8086) | cl_int enqueueAcquireD3D10Objects(const vector<Memory> *mem_objects ...
method cl_int (line 8115) | cl_int enqueueReleaseD3D10Objects(const vector<Memory> *mem_objects ...
method CL_API_PREFIX__VERSION_1_1_DEPRECATED (line 8149) | CL_API_PREFIX__VERSION_1_1_DEPRECATED
method cl_int (line 8156) | cl_int flush() const { return detail::errHandler(::clFlush(object_),...
method cl_int (line 8158) | cl_int finish() const { return detail::errHandler(::clFinish(object_...
type DeviceQueueProperties (line 8167) | enum class DeviceQueueProperties : cl_command_queue_properties
function DeviceQueueProperties (line 8173) | inline DeviceQueueProperties operator|(DeviceQueueProperties lhs, Devi...
class DeviceCommandQueue (line 8182) | class DeviceCommandQueue : public detail::Wrapper<cl_command_queue>
method DeviceCommandQueue (line 8188) | DeviceCommandQueue() {}
method DeviceCommandQueue (line 8193) | DeviceCommandQueue(DeviceQueueProperties properties, cl_int *err = N...
method DeviceCommandQueue (line 8215) | DeviceCommandQueue(const Context &context, const Device &device,
method DeviceCommandQueue (line 8235) | DeviceCommandQueue(const Context &context, const Device &device, cl_...
method DeviceCommandQueue (line 8258) | explicit DeviceCommandQueue(const cl_command_queue &commandQueue, bo...
method DeviceCommandQueue (line 8262) | DeviceCommandQueue &operator=(const cl_command_queue &rhs)
method DeviceCommandQueue (line 8271) | DeviceCommandQueue(const DeviceCommandQueue &queue)
method DeviceCommandQueue (line 8278) | DeviceCommandQueue &operator=(const DeviceCommandQueue &queue)
method DeviceCommandQueue (line 8287) | DeviceCommandQueue(DeviceCommandQueue &&queue) CL_HPP_NOEXCEPT_ : de...
method DeviceCommandQueue (line 8292) | DeviceCommandQueue &operator=(DeviceCommandQueue &&queue)
method cl_int (line 8299) | cl_int getInfo(cl_command_queue_info name, T *param) const
method getInfo (line 8306) | typename detail::param_traits<detail::cl_command_queue_info, name>::...
method DeviceCommandQueue (line 8323) | static DeviceCommandQueue makeDefault(cl_int *err = nullptr)
method DeviceCommandQueue (line 8349) | static DeviceCommandQueue makeDefault(const Context &context, const ...
method DeviceCommandQueue (line 8373) | static DeviceCommandQueue makeDefault(const Context &context, const ...
method DeviceCommandQueue (line 8400) | static DeviceCommandQueue updateDefault(const Context &context, cons...
method DeviceCommandQueue (line 8417) | static DeviceCommandQueue getDefault(const CommandQueue &queue, cl_i...
type detail (line 8425) | namespace detail
function cl_int (line 814) | static inline cl_int errHandler(cl_int err, const char *errStr = NULL)
function cl_int (line 823) | static inline cl_int errHandler(cl_int err, const char *errStr = NULL)
function cl_int (line 1008) | inline cl_int getInfoHelper(Functor f, cl_uint name, T *param, long)
function cl_int (line 1016) | inline cl_int getInfoHelper(Func f, cl_uint name, vector<vector<unsi...
function cl_int (line 1047) | inline cl_int getInfoHelper(Func f, cl_uint name, vector<T> *param, ...
function cl_int (line 1079) | inline cl_int getInfoHelper(Func f, cl_uint name, vector<T> *param, ...
function cl_int (line 1114) | inline cl_int getInfoHelper(Func f, cl_uint name, string *param, long)
function cl_int (line 1147) | inline cl_int getInfoHelper(Func f, cl_uint name, array<size_type, N...
type ReferenceHandler (line 1180) | struct ReferenceHandler
function cl_int (line 1189) | inline cl_int getInfoHelper(Func f, cl_uint name, T *param, int, typ...
type param_traits (line 1483) | struct param_traits
function cl_int (line 1669) | inline cl_int getInfo(Func f, cl_uint name, T *param)
type GetInfoFunctor0 (line 1675) | struct GetInfoFunctor0
method cl_int (line 1679) | cl_int operator()(cl_uint param, size_type size, void *value, size...
type GetInfoFunctor1 (line 1686) | struct GetInfoFunctor1
method cl_int (line 1691) | cl_int operator()(cl_uint param, size_type size, void *value, size...
function cl_int (line 1698) | inline cl_int getInfo(Func f, const Arg0 &arg0, cl_uint name, T *param)
function cl_int (line 1705) | inline cl_int getInfo(Func f, const Arg0 &arg0, const Arg1 &arg1, cl...
type ReferenceHandler (line 1713) | struct ReferenceHandler
type ReferenceHandler<cl_device_id> (line 1722) | struct ReferenceHandler<cl_device_id>
method cl_int (line 1733) | static cl_int retain(cl_device_id device) { return ::clRetainDevic...
method cl_int (line 1743) | static cl_int release(cl_device_id device) { return ::clReleaseDev...
method cl_int (line 1753) | static cl_int retain(cl_device_id) { return CL_SUCCESS; }
method cl_int (line 1755) | static cl_int release(cl_device_id) { return CL_SUCCESS; }
type ReferenceHandler<cl_device_id> (line 1750) | struct ReferenceHandler<cl_device_id>
method cl_int (line 1733) | static cl_int retain(cl_device_id device) { return ::clRetainDevic...
method cl_int (line 1743) | static cl_int release(cl_device_id device) { return ::clReleaseDev...
method cl_int (line 1753) | static cl_int retain(cl_device_id) { return CL_SUCCESS; }
method cl_int (line 1755) | static cl_int release(cl_device_id) { return CL_SUCCESS; }
type ReferenceHandler<cl_platform_id> (line 1760) | struct ReferenceHandler<cl_platform_id>
method cl_int (line 1763) | static cl_int retain(cl_platform_id) { return CL_SUCCESS; }
method cl_int (line 1765) | static cl_int release(cl_platform_id) { return CL_SUCCESS; }
type ReferenceHandler<cl_context> (line 1769) | struct ReferenceHandler<cl_context>
method cl_int (line 1771) | static cl_int retain(cl_context context) { return ::clRetainContex...
method cl_int (line 1772) | static cl_int release(cl_context context) { return ::clReleaseCont...
type ReferenceHandler<cl_command_queue> (line 1776) | struct ReferenceHandler<cl_command_queue>
method cl_int (line 1778) | static cl_int retain(cl_command_queue queue) { return ::clRetainCo...
method cl_int (line 1779) | static cl_int release(cl_command_queue queue) { return ::clRelease...
type ReferenceHandler<cl_mem> (line 1783) | struct ReferenceHandler<cl_mem>
method cl_int (line 1785) | static cl_int retain(cl_mem memory) { return ::clRetainMemObject(m...
method cl_int (line 1786) | static cl_int release(cl_mem memory) { return ::clReleaseMemObject...
type ReferenceHandler<cl_sampler> (line 1790) | struct ReferenceHandler<cl_sampler>
method cl_int (line 1792) | static cl_int retain(cl_sampler sampler) { return ::clRetainSample...
method cl_int (line 1793) | static cl_int release(cl_sampler sampler) { return ::clReleaseSamp...
type ReferenceHandler<cl_program> (line 1797) | struct ReferenceHandler<cl_program>
method cl_int (line 1799) | static cl_int retain(cl_program program) { return ::clRetainProgra...
method cl_int (line 1800) | static cl_int release(cl_program program) { return ::clReleaseProg...
type ReferenceHandler<cl_kernel> (line 1804) | struct ReferenceHandler<cl_kernel>
method cl_int (line 1806) | static cl_int retain(cl_kernel kernel) { return ::clRetainKernel(k...
method cl_int (line 1807) | static cl_int release(cl_kernel kernel) { return ::clReleaseKernel...
type ReferenceHandler<cl_event> (line 1811) | struct ReferenceHandler<cl_event>
method cl_int (line 1813) | static cl_int retain(cl_event event) { return ::clRetainEvent(even...
method cl_int (line 1814) | static cl_int release(cl_event event) { return ::clReleaseEvent(ev...
function cl_uint (line 1820) | static cl_uint getVersion(const vector<char> &versionInfo)
function cl_uint (line 1841) | static cl_uint getPlatformVersion(cl_platform_id platform)
function cl_uint (line 1851) | static cl_uint getDevicePlatformVersion(cl_device_id device)
function cl_uint (line 1858) | static cl_uint getContextPlatformVersion(cl_context context)
class Wrapper (line 1873) | class Wrapper
method Wrapper (line 1882) | Wrapper()
method Wrapper (line 1886) | Wrapper(const cl_type &obj, bool retainObject)
method Wrapper (line 1903) | Wrapper(const Wrapper<cl_type> &rhs)
method Wrapper (line 1909) | Wrapper(Wrapper<cl_type> &&rhs) CL_HPP_NOEXCEPT_
method cl_type (line 1944) | const cl_type &operator()() const { return object_; }
method cl_type (line 1946) | cl_type &operator()() { return object_; }
method cl_type (line 1948) | cl_type get() const { return object_; }
method cl_int (line 1954) | cl_int retain() const
method cl_int (line 1966) | cl_int release() const
class Wrapper<cl_device_id> (line 1980) | class Wrapper<cl_device_id>
method isReferenceCountable (line 1989) | static bool isReferenceCountable(cl_device_id device)
method Wrapper (line 2010) | Wrapper()
method Wrapper (line 2015) | Wrapper(const cl_type &obj, bool retainObject)
method Wrapper (line 2029) | Wrapper(const Wrapper<cl_type> &rhs)
method Wrapper (line 2036) | Wrapper(Wrapper<cl_type> &&rhs) CL_HPP_NOEXCEPT_
method cl_type (line 2077) | const cl_type &operator()() const { return object_; }
method cl_type (line 2079) | cl_type &operator()() { return object_; }
method cl_type (line 2081) | cl_type get() const { return object_; }
method cl_int (line 2090) | cl_int retain() const
method cl_int (line 2102) | cl_int release() const
function cl_int (line 2153) | static inline cl_int buildErrHandler(cl_int err, const char *errStr,...
function cl_int (line 2166) | static inline cl_int buildErrHandler(cl_int err, const char *errStr,...
class SVMTraitNull (line 3525) | class SVMTraitNull
method cl_svm_mem_flags (line 3528) | static cl_svm_mem_flags getSVMMemFlags() { return 0; }
class Deleter (line 3736) | class Deleter
method Deleter (line 3745) | Deleter(const Alloc &alloc, size_type copies)
type KernelArgumentHandler (line 5646) | struct KernelArgumentHandler
type KernelArgumentHandler<T, typename std::enable_if<!std::is_base_of<cl::Memory, T>::value>::type> (line 5651) | struct KernelArgumentHandler<T, typename std::enable_if<!std::is_bas...
method size_type (line 5653) | static size_type size(const T &) { return sizeof(T); }
method T (line 5654) | static const T *ptr(const T &value) { return &value; }
type KernelArgumentHandler<T, typename std::enable_if<std::is_base_of<cl::Memory, T>::value>::type> (line 5660) | struct KernelArgumentHandler<T, typename std::enable_if<std::is_base...
method size_type (line 5662) | static size_type size(const T &) { return sizeof(cl_mem); }
method cl_mem (line 5663) | static const cl_mem *ptr(const T &value) { return &(value()); }
type KernelArgumentHandler<LocalSpaceArg, void> (line 5669) | struct KernelArgumentHandler<LocalSpaceArg, void>
method size_type (line 5671) | static size_type size(const LocalSpaceArg &value) { return value.s...
type KernelArgumentHandler<cl::DeviceCommandQueue, void> (line 8429) | struct KernelArgumentHandler<cl::DeviceCommandQueue, void>
method size_type (line 8431) | static size_type size(const cl::DeviceCommandQueue &) { return siz...
method cl_command_queue (line 8432) | static const cl_command_queue *ptr(const cl::DeviceCommandQueue &v...
function cl_int (line 8546) | inline cl_int enqueueReadBuffer(const Buffer &buffer, cl_bool blocking...
function cl_int (line 8560) | inline cl_int enqueueWriteBuffer(const Buffer &buffer, cl_bool blockin...
function cl_int (line 8606) | inline cl_int enqueueMapSVM(T *ptr, cl_bool blocking, cl_map_flags fla...
function cl_int (line 8625) | inline cl_int enqueueMapSVM(cl::pointer<T, D> &ptr, cl_bool blocking, ...
function cl_int (line 8644) | inline cl_int enqueueMapSVM(cl::vector<T, Alloc> &container, cl_bool b...
function cl_int (line 8659) | inline cl_int enqueueUnmapMemObject(const Memory &memory, void *mapped...
function cl_int (line 8690) | inline cl_int enqueueUnmapSVM(T *ptr, const vector<Event> *events = NU...
function cl_int (line 8708) | inline cl_int enqueueUnmapSVM(cl::pointer<T, D> &ptr, const vector<Eve...
function cl_int (line 8726) | inline cl_int enqueueUnmapSVM(cl::vector<T, Alloc> &container, const v...
function cl_int (line 8740) | inline cl_int enqueueCopyBuffer(const Buffer &src, const Buffer &dst, ...
function cl_int (line 8760) | inline cl_int copy(IteratorType startIterator, IteratorType endIterato...
function cl_int (line 8776) | inline cl_int copy(const cl::Buffer &buffer, IteratorType startIterato...
function cl_int (line 8792) | inline cl_int copy(const CommandQueue &queue, IteratorType startIterat...
function cl_int (line 8829) | inline cl_int copy(const CommandQueue &queue, const cl::Buffer &buffer...
function cl_int (line 8863) | inline cl_int mapSVM(cl::vector<T, Alloc> &container)
function cl_int (line 8872) | inline cl_int unmapSVM(cl::vector<T, Alloc> &container)
function cl_int (line 8880) | inline cl_int enqueueReadBufferRect(const Buffer &buffer, cl_bool bloc...
function cl_int (line 8898) | inline cl_int enqueueWriteBufferRect(const Buffer &buffer, cl_bool blo...
function cl_int (line 8916) | inline cl_int enqueueCopyBufferRect(const Buffer &src, const Buffer &d...
function cl_int (line 8934) | inline cl_int enqueueReadImage(const Image &image, cl_bool blocking, c...
function cl_int (line 8949) | inline cl_int enqueueWriteImage(const Image &image, cl_bool blocking, ...
function cl_int (line 8964) | inline cl_int enqueueCopyImage(const Image &src, const Image &dst, con...
function cl_int (line 8979) | inline cl_int enqueueCopyImageToBuffer(const Image &src, const Buffer ...
function cl_int (line 8994) | inline cl_int enqueueCopyBufferToImage(const Buffer &src, const Image ...
function cl_int (line 9010) | inline cl_int flush(void)
function cl_int (line 9023) | inline cl_int finish(void)
class EnqueueArgs (line 9037) | class EnqueueArgs
method EnqueueArgs (line 9050) | EnqueueArgs(NDRange global)
method EnqueueArgs (line 9057) | EnqueueArgs(NDRange global, NDRange local)
method EnqueueArgs (line 9064) | EnqueueArgs(NDRange offset, NDRange global, NDRange local)
method EnqueueArgs (line 9071) | EnqueueArgs(Event e, NDRange global)
method EnqueueArgs (line 9080) | EnqueueArgs(Event e, NDRange global, NDRange local)
method EnqueueArgs (line 9089) | EnqueueArgs(Event e, NDRange offset, NDRange global, NDRange local)
method EnqueueArgs (line 9098) | EnqueueArgs(const vector<Event> &events, NDRange global)
method EnqueueArgs (line 9106) | EnqueueArgs(const vector<Event> &events, NDRange global, NDRange local)
method EnqueueArgs (line 9114) | EnqueueArgs(const vector<Event> &events, NDRange offset, NDRange glo...
method EnqueueArgs (line 9122) | EnqueueArgs(CommandQueue &queue, NDRange global)
method EnqueueArgs (line 9129) | EnqueueArgs(CommandQueue &queue, NDRange global, NDRange local)
method EnqueueArgs (line 9136) | EnqueueArgs(CommandQueue &queue, NDRange offset, NDRange global, NDR...
method EnqueueArgs (line 9143) | EnqueueArgs(CommandQueue &queue, Event e, NDRange global)
method EnqueueArgs (line 9152) | EnqueueArgs(CommandQueue &queue, Event e, NDRange global, NDRange lo...
method EnqueueArgs (line 9161) | EnqueueArgs(CommandQueue &queue, Event e, NDRange offset, NDRange gl...
method EnqueueArgs (line 9170) | EnqueueArgs(CommandQueue &queue, const vector<Event> &events, NDRang...
method EnqueueArgs (line 9178) | EnqueueArgs(CommandQueue &queue, const vector<Event> &events, NDRang...
method EnqueueArgs (line 9186) | EnqueueArgs(CommandQueue &queue, const vector<Event> &events, NDRang...
class KernelFunctor (line 9204) | class KernelFunctor
method setArgs (line 9210) | void setArgs(T0 &&t0, T1s &&...t1s)
method setArgs (line 9217) | void setArgs(T0 &&t0)
method setArgs (line 9223) | void setArgs()
method KernelFunctor (line 9228) | KernelFunctor(Kernel kernel)
method KernelFunctor (line 9232) | KernelFunctor(const Program &program, const string name, cl_int *err...
method Event (line 9244) | Event operator()(const EnqueueArgs &args, Ts... ts)
method Event (line 9260) | Event operator()(const EnqueueArgs &args, Ts... ts, cl_int &error)
method cl_int (line 9271) | cl_int setSVMPointers(const vector<void *> &pointerList) { return ke...
method cl_int (line 9274) | cl_int setSVMPointers(const T0 &t0, T1s &...ts)
method Kernel (line 9280) | Kernel getKernel() { return kernel_; }
type compatibility (line 9283) | namespace compatibility
class size_t (line 658) | class size_t
method size_type (line 681) | size_type &operator[](int index) { return data_[index]; }
method size_type (line 683) | const size_type &operator[](int index) const { return data_[index]; }
type make_kernel (line 9290) | struct make_kernel
method make_kernel (line 9296) | make_kernel(const Program &program, const string name, cl_int *err...
method make_kernel (line 9300) | make_kernel(const Kernel kernel)
method Event (line 9310) | Event operator()(const EnqueueArgs &enqueueArgs, Ts... args) { ret...
type cl (line 596) | namespace cl
type compatibility (line 651) | namespace compatibility
class size_t (line 658) | class size_t
method size_type (line 681) | size_type &operator[](int index) { return data_[index]; }
method size_type (line 683) | const size_type &operator[](int index) const { return data_[index]; }
type make_kernel (line 9290) | struct make_kernel
method make_kernel (line 9296) | make_kernel(const Program &program, const string name, cl_int *err...
method make_kernel (line 9300) | make_kernel(const Kernel kernel)
method Event (line 9310) | Event operator()(const EnqueueArgs &enqueueArgs, Ts... args) { ret...
type detail (line 712) | namespace detail
function cl_int (line 814) | static inline cl_int errHandler(cl_int err, const char *errStr = NULL)
function cl_int (line 823) | static inline cl_int errHandler(cl_int err, const char *errStr = NULL)
function cl_int (line 1008) | inline cl_int getInfoHelper(Functor f, cl_uint name, T *param, long)
function cl_int (line 1016) | inline cl_int getInfoHelper(Func f, cl_uint name, vector<vector<unsi...
function cl_int (line 1047) | inline cl_int getInfoHelper(Func f, cl_uint name, vector<T> *param, ...
function cl_int (line 1079) | inline cl_int getInfoHelper(Func f, cl_uint name, vector<T> *param, ...
function cl_int (line 1114) | inline cl_int getInfoHelper(Func f, cl_uint name, string *param, long)
function cl_int (line 1147) | inline cl_int getInfoHelper(Func f, cl_uint name, array<size_type, N...
type ReferenceHandler (line 1180) | struct ReferenceHandler
function cl_int (line 1189) | inline cl_int getInfoHelper(Func f, cl_uint name, T *param, int, typ...
type param_traits (line 1483) | struct param_traits
function cl_int (line 1669) | inline cl_int getInfo(Func f, cl_uint name, T *param)
type GetInfoFunctor0 (line 1675) | struct GetInfoFunctor0
method cl_int (line 1679) | cl_int operator()(cl_uint param, size_type size, void *value, size...
type GetInfoFunctor1 (line 1686) | struct GetInfoFunctor1
method cl_int (line 1691) | cl_int operator()(cl_uint param, size_type size, void *value, size...
function cl_int (line 1698) | inline cl_int getInfo(Func f, const Arg0 &arg0, cl_uint name, T *param)
function cl_int (line 1705) | inline cl_int getInfo(Func f, const Arg0 &arg0, const Arg1 &arg1, cl...
type ReferenceHandler (line 1713) | struct ReferenceHandler
type ReferenceHandler<cl_device_id> (line 1722) | struct ReferenceHandler<cl_device_id>
method cl_int (line 1733) | static cl_int retain(cl_device_id device) { return ::clRetainDevic...
method cl_int (line 1743) | static cl_int release(cl_device_id device) { return ::clReleaseDev...
method cl_int (line 1753) | static cl_int retain(cl_device_id) { return CL_SUCCESS; }
method cl_int (line 1755) | static cl_int release(cl_device_id) { return CL_SUCCESS; }
type ReferenceHandler<cl_device_id> (line 1750) | struct ReferenceHandler<cl_device_id>
method cl_int (line 1733) | static cl_int retain(cl_device_id device) { return ::clRetainDevic...
method cl_int (line 1743) | static cl_int release(cl_device_id device) { return ::clReleaseDev...
method cl_int (line 1753) | static cl_int retain(cl_device_id) { return CL_SUCCESS; }
method cl_int (line 1755) | static cl_int release(cl_device_id) { return CL_SUCCESS; }
type ReferenceHandler<cl_platform_id> (line 1760) | struct ReferenceHandler<cl_platform_id>
method cl_int (line 1763) | static cl_int retain(cl_platform_id) { return CL_SUCCESS; }
method cl_int (line 1765) | static cl_int release(cl_platform_id) { return CL_SUCCESS; }
type ReferenceHandler<cl_context> (line 1769) | struct ReferenceHandler<cl_context>
method cl_int (line 1771) | static cl_int retain(cl_context context) { return ::clRetainContex...
method cl_int (line 1772) | static cl_int release(cl_context context) { return ::clReleaseCont...
type ReferenceHandler<cl_command_queue> (line 1776) | struct ReferenceHandler<cl_command_queue>
method cl_int (line 1778) | static cl_int retain(cl_command_queue queue) { return ::clRetainCo...
method cl_int (line 1779) | static cl_int release(cl_command_queue queue) { return ::clRelease...
type ReferenceHandler<cl_mem> (line 1783) | struct ReferenceHandler<cl_mem>
method cl_int (line 1785) | static cl_int retain(cl_mem memory) { return ::clRetainMemObject(m...
method cl_int (line 1786) | static cl_int release(cl_mem memory) { return ::clReleaseMemObject...
type ReferenceHandler<cl_sampler> (line 1790) | struct ReferenceHandler<cl_sampler>
method cl_int (line 1792) | static cl_int retain(cl_sampler sampler) { return ::clRetainSample...
method cl_int (line 1793) | static cl_int release(cl_sampler sampler) { return ::clReleaseSamp...
type ReferenceHandler<cl_program> (line 1797) | struct ReferenceHandler<cl_program>
method cl_int (line 1799) | static cl_int retain(cl_program program) { return ::clRetainProgra...
method cl_int (line 1800) | static cl_int release(cl_program program) { return ::clReleaseProg...
type ReferenceHandler<cl_kernel> (line 1804) | struct ReferenceHandler<cl_kernel>
method cl_int (line 1806) | static cl_int retain(cl_kernel kernel) { return ::clRetainKernel(k...
method cl_int (line 1807) | static cl_int release(cl_kernel kernel) { return ::clReleaseKernel...
type ReferenceHandler<cl_event> (line 1811) | struct ReferenceHandler<cl_event>
method cl_int (line 1813) | static cl_int retain(cl_event event) { return ::clRetainEvent(even...
method cl_int (line 1814) | static cl_int release(cl_event event) { return ::clReleaseEvent(ev...
function cl_uint (line 1820) | static cl_uint getVersion(const vector<char> &versionInfo)
function cl_uint (line 1841) | static cl_uint getPlatformVersion(cl_platform_id platform)
function cl_uint (line 1851) | static cl_uint getDevicePlatformVersion(cl_device_id device)
function cl_uint (line 1858) | static cl_uint getContextPlatformVersion(cl_context context)
class Wrapper (line 1873) | class Wrapper
method Wrapper (line 1882) | Wrapper()
method Wrapper (line 1886) | Wrapper(const cl_type &obj, bool retainObject)
method Wrapper (line 1903) | Wrapper(const Wrapper<cl_type> &rhs)
method Wrapper (line 1909) | Wrapper(Wrapper<cl_type> &&rhs) CL_HPP_NOEXCEPT_
method cl_type (line 1944) | const cl_type &operator()() const { return object_; }
method cl_type (line 1946) | cl_type &operator()() { return object_; }
method cl_type (line 1948) | cl_type get() const { return object_; }
method cl_int (line 1954) | cl_int retain() const
method cl_int (line 1966) | cl_int release() const
class Wrapper<cl_device_id> (line 1980) | class Wrapper<cl_device_id>
method isReferenceCountable (line 1989) | static bool isReferenceCountable(cl_device_id device)
method Wrapper (line 2010) | Wrapper()
method Wrapper (line 2015) | Wrapper(const cl_type &obj, bool retainObject)
method Wrapper (line 2029) | Wrapper(const Wrapper<cl_type> &rhs)
method Wrapper (line 2036) | Wrapper(Wrapper<cl_type> &&rhs) CL_HPP_NOEXCEPT_
method cl_type (line 2077) | const cl_type &operator()() const { return object_; }
method cl_type (line 2079) | cl_type &operator()() { return object_; }
method cl_type (line 2081) | cl_type get() const { return object_; }
method cl_int (line 2090) | cl_int retain() const
method cl_int (line 2102) | cl_int release() const
function cl_int (line 2153) | static inline cl_int buildErrHandler(cl_int err, const char *errStr,...
function cl_int (line 2166) | static inline cl_int buildErrHandler(cl_int err, const char *errStr,...
class SVMTraitNull (line 3525) | class SVMTraitNull
method cl_svm_mem_flags (line 3528) | static cl_svm_mem_flags getSVMMemFlags() { return 0; }
class Deleter (line 3736) | class Deleter
method Deleter (line 3745) | Deleter(const Alloc &alloc, size_type copies)
type KernelArgumentHandler (line 5646) | struct KernelArgumentHandler
type KernelArgumentHandler<T, typename std::enable_if<!std::is_base_of<cl::Memory, T>::value>::type> (line 5651) | struct KernelArgumentHandler<T, typename std::enable_if<!std::is_bas...
method size_type (line 5653) | static size_type size(const T &) { return sizeof(T); }
method T (line 5654) | static const T *ptr(const T &value) { return &value; }
type KernelArgumentHandler<T, typename std::enable_if<std::is_base_of<cl::Memory, T>::value>::type> (line 5660) | struct KernelArgumentHandler<T, typename std::enable_if<std::is_base...
method size_type (line 5662) | static size_type size(const T &) { return sizeof(cl_mem); }
method cl_mem (line 5663) | static const cl_mem *ptr(const T &value) { return &(value()); }
type KernelArgumentHandler<LocalSpaceArg, void> (line 5669) | struct KernelArgumentHandler<LocalSpaceArg, void>
method size_type (line 5671) | static size_type size(const LocalSpaceArg &value) { return value.s...
type KernelArgumentHandler<cl::DeviceCommandQueue, void> (line 8429) | struct KernelArgumentHandler<cl::DeviceCommandQueue, void>
method size_type (line 8431) | static size_type size(const cl::DeviceCommandQueue &) { return siz...
method cl_command_queue (line 8432) | static const cl_command_queue *ptr(const cl::DeviceCommandQueue &v...
class Memory (line 726) | class Memory
method Memory (line 3407) | Memory()
method Memory (line 3422) | explicit Memory(const cl_mem &memory, bool retainObject)
method Memory (line 3431) | Memory &operator=(const cl_mem &rhs)
method Memory (line 3440) | Memory(const Memory &mem)
method Memory (line 3447) | Memory &operator=(const Memory &mem)
method Memory (line 3456) | Memory(Memory &&mem) CL_HPP_NOEXCEPT_ : detail::Wrapper<cl_type>(std...
method Memory (line 3461) | Memory &operator=(Memory &&mem)
method cl_int (line 3470) | cl_int getInfo(cl_mem_info name, T *param) const
method getInfo (line 3477) | typename detail::param_traits<detail::cl_mem_info, name>::param_type...
method cl_int (line 3502) | cl_int setDestructorCallback(void(CL_CALLBACK *pfn_notify)(cl_mem, v...
class Program (line 746) | class Program
method Program (line 6018) | Program(const string &source, bool build = false, cl_int *err = NULL)
method Program (line 6050) | Program(const Context &context, const string &source, bool build = f...
method Program (line 6084) | Program(const Sources &sources, cl_int *err = NULL)
method Program (line 6118) | Program(const Context &context, const Sources &sources, cl_int *err ...
method Program (line 6153) | Program(const vector<char> &IL, bool build = false, cl_int *err = NULL)
method Program (line 6199) | Program(const Context &context, const vector<char> &IL, bool build =...
method Program (line 6258) | Program(const Context &context, const vector<Device> &devices, const...
method Program (line 6322) | Program(const Context &context, const vector<Device> &devices, const...
method Program (line 6345) | Program() {}
method Program (line 6354) | explicit Program(const cl_program &program, bool retainObject = false)
method Program (line 6358) | Program &operator=(const cl_program &rhs)
method Program (line 6367) | Program(const Program &program)
method Program (line 6374) | Program &operator=(const Program &program)
method Program (line 6383) | Program(Program &&program) CL_HPP_NOEXCEPT_ : detail::Wrapper<cl_typ...
method Program (line 6388) | Program &operator=(Program &&program)
method cl_int (line 6394) | cl_int build(const vector<Device> &devices, const char *options = NULL,
method cl_int (line 6410) | cl_int build(const Device &device, const char *options = NULL,
method cl_int (line 6422) | cl_int build(const char *options = NULL, void(CL_CALLBACK *notifyFpt...
method cl_int (line 6431) | cl_int compile(const char *options = NULL, void(CL_CALLBACK *notifyF...
method cl_int (line 6440) | cl_int getInfo(cl_program_info name, T *param) const
method getInfo (line 6446) | typename detail::param_traits<detail::cl_program_info, name>::param_...
method cl_int (line 6458) | cl_int getBuildInfo(const Device &device, cl_program_build_info name...
method getBuildInfo (line 6465) | typename detail::param_traits<detail::cl_program_build_info, name>::...
method getBuildInfo (line 6483) | vector<std::pair<cl::Device, typename detail::param_traits<detail::c...
method cl_int (line 6526) | cl_int createKernels(vector<Kernel> *kernels)
method CL_API_PREFIX__VERSION_2_2_DEPRECATED (line 6571) | CL_API_PREFIX__VERSION_2_2_DEPRECATED cl_int
method setSpecializationConstant (line 6585) | typename std::enable_if<!std::is_pointer<T>::value, cl_int>::type se...
method cl_int (line 6596) | cl_int setSpecializationConstant(cl_uint index, size_type size, cons...
class Device (line 747) | class Device
method makeDefaultProvided (line 2234) | static void makeDefaultProvided(const Device &p) { default_ = p; }
method unitTestClearDefault (line 2244) | static void unitTestClearDefault() { default_ = Device(); }
method Device (line 2248) | Device()
method Device (line 2256) | explicit Device(const cl_device_id &device, bool retainObject = false)
method Device (line 2264) | static Device getDefault(cl_int *errResult = NULL)
method Device (line 2282) | static Device setDefault(const Device &default_device)
method Device (line 2293) | Device &operator=(const cl_device_id &rhs)
method Device (line 2302) | Device(const Device &dev)
method Device (line 2309) | Device &operator=(const Device &dev)
method Device (line 2318) | Device(Device &&dev) CL_HPP_NOEXCEPT_ : detail::Wrapper<cl_type>(std...
method Device (line 2323) | Device &operator=(Device &&dev)
method cl_int (line 2331) | cl_int getInfo(cl_device_info name, T *param) const
method getInfo (line 2338) | typename detail::param_traits<detail::cl_device_info, name>::param_t...
method cl_ulong (line 2357) | cl_ulong getHostTimer(cl_int *error = nullptr)
method getDeviceAndHostTimer (line 2379) | std::pair<cl_ulong, cl_ulong> getDeviceAndHostTimer(cl_int *error = ...
method cl_int (line 2397) | cl_int createSubDevices(const cl_device_partition_property *properti...
method cl_int (line 2436) | cl_int createSubDevices(const cl_device_partition_property_ext *prop...
class Context (line 748) | class Context
method makeDefault (line 2869) | static void makeDefault()
method makeDefaultProvided (line 2902) | static void makeDefaultProvided(const Context &c) { default_ = c; }
method unitTestClearDefault (line 2912) | static void unitTestClearDefault() { default_ = Context(); }
method Context (line 2919) | Context(const vector<Device> &devices, const cl_context_properties *...
method Context (line 2946) | Context(const Device &device, const cl_context_properties *propertie...
method Context (line 2967) | Context(cl_device_type type, const cl_context_properties *properties...
method Context (line 3057) | Context(const Context &ctx)
method Context (line 3064) | Context &operator=(const Context &ctx)
method Context (line 3073) | Context(Context &&ctx) CL_HPP_NOEXCEPT_ : detail::Wrapper<cl_type>(s...
method Context (line 3078) | Context &operator=(Context &&ctx)
method Context (line 3089) | static Context getDefault(cl_int *err = NULL)
method Context (line 3107) | static Context setDefault(const Context &default_context)
method Context (line 3115) | Context()
method Context (line 3124) | explicit Context(const cl_context &context, bool retainObject = false)
method Context (line 3133) | Context &operator=(const cl_context &rhs)
method cl_int (line 3141) | cl_int getInfo(cl_context_info name, T *param) const
method getInfo (line 3148) | typename detail::param_traits<detail::cl_context_info, name>::param_...
method cl_int (line 3163) | cl_int getSupportedImageFormats(cl_mem_flags flags, cl_mem_object_ty...
class CommandQueue (line 749) | class CommandQueue
method makeDefault (line 6759) | static void makeDefault()
method makeDefaultProvided (line 6794) | static void makeDefaultProvided(const CommandQueue &c) { default_ = ...
method unitTestClearDefault (line 6804) | static void unitTestClearDefault() { default_ = CommandQueue(); }
method CommandQueue (line 6812) | CommandQueue(cl_command_queue_properties properties, cl_int *err = N...
method CommandQueue (line 6882) | CommandQueue(QueueProperties properties, cl_int *err = NULL)
method CommandQueue (line 6948) | explicit CommandQueue(const Context &context, cl_command_queue_prope...
method CommandQueue (line 7016) | explicit CommandQueue(const Context &context, QueueProperties proper...
method CommandQueue (line 7078) | CommandQueue(const Context &context, const Device &device, cl_comman...
method CommandQueue (line 7127) | CommandQueue(const Context &context, const Device &device, QueueProp...
method CommandQueue (line 7172) | static CommandQueue getDefault(cl_int *err = NULL)
method CommandQueue (line 7194) | static CommandQueue setDefault(const CommandQueue &default_queue)
method CommandQueue (line 7201) | CommandQueue() {}
method CommandQueue (line 7210) | explicit CommandQueue(const cl_command_queue &commandQueue, bool ret...
method CommandQueue (line 7214) | CommandQueue &operator=(const cl_command_queue &rhs)
method CommandQueue (line 7223) | CommandQueue(const CommandQueue &queue)
method CommandQueue (line 7230) | CommandQueue &operator=(const CommandQueue &queue)
method CommandQueue (line 7239) | CommandQueue(CommandQueue &&queue) CL_HPP_NOEXCEPT_ : detail::Wrappe...
method CommandQueue (line 7244) | CommandQueue &operator=(CommandQueue &&queue)
method cl_int (line 7251) | cl_int getInfo(cl_command_queue_info name, T *param) const
method getInfo (line 7258) | typename detail::param_traits<detail::cl_command_queue_info, name>::...
method cl_int (line 7269) | cl_int enqueueReadBuffer(const Buffer &buffer, cl_bool blocking, siz...
method cl_int (line 7285) | cl_int enqueueWriteBuffer(const Buffer &buffer, cl_bool blocking, si...
method cl_int (line 7301) | cl_int enqueueCopyBuffer(const Buffer &src, const Buffer &dst, size_...
method cl_int (line 7317) | cl_int enqueueReadBufferRect(const Buffer &buffer, cl_bool blocking,...
method cl_int (line 7337) | cl_int enqueueWriteBufferRect(const Buffer &buffer, cl_bool blocking...
method cl_int (line 7357) | cl_int enqueueCopyBufferRect(const Buffer &src, const Buffer &dst, c...
method cl_int (line 7389) | cl_int enqueueFillBuffer(const Buffer &buffer, PatternType pattern, ...
method cl_int (line 7407) | cl_int enqueueReadImage(const Image &image, cl_bool blocking, const ...
method cl_int (line 7425) | cl_int enqueueWriteImage(const Image &image, cl_bool blocking, const...
method cl_int (line 7443) | cl_int enqueueCopyImage(const Image &src, const Image &dst, const ar...
method cl_int (line 7469) | cl_int enqueueFillImage(const Image &image, cl_float4 fillColor, con...
method cl_int (line 7494) | cl_int enqueueFillImage(const Image &image, cl_int4 fillColor, const...
method cl_int (line 7519) | cl_int enqueueFillImage(const Image &image, cl_uint4 fillColor, cons...
method cl_int (line 7538) | cl_int enqueueCopyImageToBuffer(const Image &src, const Buffer &dst,...
method cl_int (line 7556) | cl_int enqueueCopyBufferToImage(const Buffer &src, const Image &dst,...
method cl_int (line 7622) | cl_int enqueueMapSVM(T *ptr, cl_bool blocking, cl_map_flags flags, s...
method cl_int (line 7644) | cl_int enqueueMapSVM(cl::pointer<T, D> &ptr, cl_bool blocking, cl_ma...
method cl_int (line 7665) | cl_int enqueueMapSVM(cl::vector<T, Alloc> &container, cl_bool blocki...
method cl_int (line 7683) | cl_int enqueueUnmapMemObject(const Memory &memory, void *mapped_ptr,...
method cl_int (line 7706) | cl_int enqueueUnmapSVM(T *ptr, const vector<Event> *events = NULL, E...
method cl_int (line 7726) | cl_int enqueueUnmapSVM(cl::pointer<T, D> &ptr, const vector<Event> *...
method cl_int (line 7746) | cl_int enqueueUnmapSVM(cl::vector<T, Alloc> &container, const vector...
method cl_int (line 7774) | cl_int enqueueMarkerWithWaitList(const vector<Event> *events = 0, Ev...
method cl_int (line 7800) | cl_int enqueueBarrierWithWaitList(const vector<Event> *events = 0, E...
method cl_int (line 7819) | cl_int enqueueMigrateMemObjects(const vector<Memory> &memObjects, cl...
method cl_int (line 7853) | cl_int enqueueMigrateSVM(const cl::vector<T *> &svmRawPointers, cons...
method cl_int (line 7877) | cl_int enqueueMigrateSVM(const cl::vector<T *> &svmRawPointers, cl_m...
method cl_int (line 7890) | cl_int enqueueMigrateSVM(const cl::vector<cl::pointer<T, D>> &svmPoi...
method cl_int (line 7910) | cl_int enqueueMigrateSVM(const cl::vector<cl::pointer<T, D>> &svmPoi...
method cl_int (line 7922) | cl_int enqueueMigrateSVM(const cl::vector<cl::vector<T, Alloc>> &svm...
method cl_int (line 7941) | cl_int enqueueMigrateSVM(const cl::vector<cl::vector<T, Alloc>> &svm...
method cl_int (line 7949) | cl_int enqueueNDRangeKernel(const Kernel &kernel, const NDRange &off...
method CL_API_PREFIX__VERSION_1_2_DEPRECATED (line 7969) | CL_API_PREFIX__VERSION_1_2_DEPRECATED cl_int
method cl_int (line 7987) | cl_int enqueueNativeKernel(void(CL_CALLBACK *userFptr)(void *), std:...
method CL_API_PREFIX__VERSION_1_1_DEPRECATED (line 8021) | CL_API_PREFIX__VERSION_1_1_DEPRECATED
method CL_API_PREFIX__VERSION_1_1_DEPRECATED (line 8033) | CL_API_PREFIX__VERSION_1_1_DEPRECATED
method cl_int (line 8042) | cl_int enqueueAcquireGLObjects(const vector<Memory> *mem_objects = N...
method cl_int (line 8060) | cl_int enqueueReleaseGLObjects(const vector<Memory> *mem_objects = N...
method cl_int (line 8086) | cl_int enqueueAcquireD3D10Objects(const vector<Memory> *mem_objects ...
method cl_int (line 8115) | cl_int enqueueReleaseD3D10Objects(const vector<Memory> *mem_objects ...
method CL_API_PREFIX__VERSION_1_1_DEPRECATED (line 8149) | CL_API_PREFIX__VERSION_1_1_DEPRECATED
method cl_int (line 8156) | cl_int flush() const { return detail::errHandler(::clFlush(object_),...
method cl_int (line 8158) | cl_int finish() const { return detail::errHandler(::clFinish(object_...
class DeviceCommandQueue (line 750) | class DeviceCommandQueue
method DeviceCommandQueue (line 8188) | DeviceCommandQueue() {}
method DeviceCommandQueue (line 8193) | DeviceCommandQueue(DeviceQueueProperties properties, cl_int *err = N...
method DeviceCommandQueue (line 8215) | DeviceCommandQueue(const Context &context, const Device &device,
method DeviceCommandQueue (line 8235) | DeviceCommandQueue(const Context &context, const Device &device, cl_...
method DeviceCommandQueue (line 8258) | explicit DeviceCommandQueue(const cl_command_queue &commandQueue, bo...
method DeviceCommandQueue (line 8262) | DeviceCommandQueue &operator=(const cl_command_queue &rhs)
method DeviceCommandQueue (line 8271) | DeviceCommandQueue(const DeviceCommandQueue &queue)
method DeviceCommandQueue (line 8278) | DeviceCommandQueue &operator=(const DeviceCommandQueue &queue)
method DeviceCommandQueue (line 8287) | DeviceCommandQueue(DeviceCommandQueue &&queue) CL_HPP_NOEXCEPT_ : de...
method DeviceCommandQueue (line 8292) | DeviceCommandQueue &operator=(DeviceCommandQueue &&queue)
method cl_int (line 8299) | cl_int getInfo(cl_command_queue_info name, T *param) const
method getInfo (line 8306) | typename detail::param_traits<detail::cl_command_queue_info, name>::...
method DeviceCommandQueue (line 8323) | static DeviceCommandQueue makeDefault(cl_int *err = nullptr)
method DeviceCommandQueue (line 8349) | static DeviceCommandQueue makeDefault(const Context &context, const ...
method DeviceCommandQueue (line 8373) | static DeviceCommandQueue makeDefault(const Context &context, const ...
method DeviceCommandQueue (line 8400) | static DeviceCommandQueue updateDefault(const Context &context, cons...
method DeviceCommandQueue (line 8417) | static DeviceCommandQueue getDefault(const CommandQueue &queue, cl_i...
class Memory (line 751) | class Memory
method Memory (line 3407) | Memory()
method Memory (line 3422) | explicit Memory(const cl_mem &memory, bool retainObject)
method Memory (line 3431) | Memory &operator=(const cl_mem &rhs)
method Memory (line 3440) | Memory(const Memory &mem)
method Memory (line 3447) | Memory &operator=(const Memory &mem)
method Memory (line 3456) | Memory(Memory &&mem) CL_HPP_NOEXCEPT_ : detail::Wrapper<cl_type>(std...
method Memory (line 3461) | Memory &operator=(Memory &&mem)
method cl_int (line 3470) | cl_int getInfo(cl_mem_info name, T *param) const
method getInfo (line 3477) | typename detail::param_traits<detail::cl_mem_info, name>::param_type...
method cl_int (line 3502) | cl_int setDestructorCallback(void(CL_CALLBACK *pfn_notify)(cl_mem, v...
class Buffer (line 752) | class Buffer
method Buffer (line 3845) | Buffer(const Context &context, cl_mem_flags flags, size_type size, v...
method Buffer (line 3866) | Buffer(cl_mem_flags flags, size_type size, void *host_ptr = NULL, cl...
method Buffer (line 3887) | Buffer(IteratorType startIterator, IteratorType endIterator, bool re...
method Buffer (line 3955) | Buffer()
method Buffer (line 3966) | explicit Buffer(const cl_mem &buffer, bool retainObject = false)
method Buffer (line 3974) | Buffer &operator=(const cl_mem &rhs)
method Buffer (line 3983) | Buffer(const Buffer &buf)
method Buffer (line 3990) | Buffer &operator=(const Buffer &buf)
method Buffer (line 3999) | Buffer(Buffer &&buf) CL_HPP_NOEXCEPT_ : Memory(std::move(buf)) {}
method Buffer (line 4004) | Buffer &operator=(Buffer &&buf)
method Buffer (line 4015) | Buffer createSubBuffer(cl_mem_flags flags, cl_buffer_create_type buf...
class Pipe (line 753) | class Pipe
method Pipe (line 5327) | Pipe(const Context &context, cl_uint packet_size, cl_uint max_packet...
method Pipe (line 5349) | Pipe(cl_uint packet_size, cl_uint max_packets, cl_int *err = NULL)
method Pipe (line 5366) | Pipe()
method Pipe (line 5377) | explicit Pipe(const cl_mem &pipe, bool retainObject = false)
method Pipe (line 5385) | Pipe &operator=(const cl_mem &rhs)
method Pipe (line 5394) | Pipe(const Pipe &pipe)
method Pipe (line 5401) | Pipe &operator=(const Pipe &pipe)
method Pipe (line 5410) | Pipe(Pipe &&pipe) CL_HPP_NOEXCEPT_ : Memory(std::move(pipe)) {}
method Pipe (line 5415) | Pipe &operator=(Pipe &&pipe)
method cl_int (line 5423) | cl_int getInfo(cl_pipe_info name, T *param) const
method getInfo (line 5430) | typename detail::param_traits<detail::cl_pipe_info, name>::param_typ...
class Error (line 760) | class Error : public std::exception
method Error (line 776) | Error(cl_int err, const char *errStr = NULL)
method cl_int (line 803) | cl_int err(void) const { return err_; }
type detail (line 811) | namespace detail
function cl_int (line 814) | static inline cl_int errHandler(cl_int err, const char *errStr = NULL)
function cl_int (line 823) | static inline cl_int errHandler(cl_int err, const char *errStr = NULL)
function cl_int (line 1008) | inline cl_int getInfoHelper(Functor f, cl_uint name, T *param, long)
function cl_int (line 1016) | inline cl_int getInfoHelper(Func f, cl_uint name, vector<vector<unsi...
function cl_int (line 1047) | inline cl_int getInfoHelper(Func f, cl_uint name, vector<T> *param, ...
function cl_int (line 1079) | inline cl_int getInfoHelper(Func f, cl_uint name, vector<T> *param, ...
function cl_int (line 1114) | inline cl_int getInfoHelper(Func f, cl_uint name, string *param, long)
function cl_int (line 1147) | inline cl_int getInfoHelper(Func f, cl_uint name, array<size_type, N...
type ReferenceHandler (line 1180) | struct ReferenceHandler
function cl_int (line 1189) | inline cl_int getInfoHelper(Func f, cl_uint name, T *param, int, typ...
type param_traits (line 1483) | struct param_traits
function cl_int (line 1669) | inline cl_int getInfo(Func f, cl_uint name, T *param)
type GetInfoFunctor0 (line 1675) | struct GetInfoFunctor0
method cl_int (line 1679) | cl_int operator()(cl_uint param, size_type size, void *value, size...
type GetInfoFunctor1 (line 1686) | struct GetInfoFunctor1
method cl_int (line 1691) | cl_int operator()(cl_uint param, size_type size, void *value, size...
function cl_int (line 1698) | inline cl_int getInfo(Func f, const Arg0 &arg0, cl_uint name, T *param)
function cl_int (line 1705) | inline cl_int getInfo(Func f, const Arg0 &arg0, const Arg1 &arg1, cl...
type ReferenceHandler (line 1713) | struct ReferenceHandler
type ReferenceHandler<cl_device_id> (line 1722) | struct ReferenceHandler<cl_device_id>
method cl_int (line 1733) | static cl_int retain(cl_device_id device) { return ::clRetainDevic...
method cl_int (line 1743) | static cl_int release(cl_device_id device) { return ::clReleaseDev...
method cl_int (line 1753) | static cl_int retain(cl_device_id) { return CL_SUCCESS; }
method cl_int (line 1755) | static cl_int release(cl_device_id) { return CL_SUCCESS; }
type ReferenceHandler<cl_device_id> (line 1750) | struct ReferenceHandler<cl_device_id>
method cl_int (line 1733) | static cl_int retain(cl_device_id device) { return ::clRetainDevic...
method cl_int (line 1743) | static cl_int release(cl_device_id device) { return ::clReleaseDev...
method cl_int (line 1753) | static cl_int retain(cl_device_id) { return CL_SUCCESS; }
method cl_int (line 1755) | static cl_int release(cl_device_id) { return CL_SUCCESS; }
type ReferenceHandler<cl_platform_id> (line 1760) | struct ReferenceHandler<cl_platform_id>
method cl_int (line 1763) | static cl_int retain(cl_platform_id) { return CL_SUCCESS; }
method cl_int (line 1765) | static cl_int release(cl_platform_id) { return CL_SUCCESS; }
type ReferenceHandler<cl_context> (line 1769) | struct ReferenceHandler<cl_context>
method cl_int (line 1771) | static cl_int retain(cl_context context) { return ::clRetainContex...
method cl_int (line 1772) | static cl_int release(cl_context context) { return ::clReleaseCont...
type ReferenceHandler<cl_command_queue> (line 1776) | struct ReferenceHandler<cl_command_queue>
method cl_int (line 1778) | static cl_int retain(cl_command_queue queue) { return ::clRetainCo...
method cl_int (line 1779) | static cl_int release(cl_command_queue queue) { return ::clRelease...
type ReferenceHandler<cl_mem> (line 1783) | struct ReferenceHandler<cl_mem>
method cl_int (line 1785) | static cl_int retain(cl_mem memory) { return ::clRetainMemObject(m...
method cl_int (line 1786) | static cl_int release(cl_mem memory) { return ::clReleaseMemObject...
type ReferenceHandler<cl_sampler> (line 1790) | struct ReferenceHandler<cl_sampler>
method cl_int (line 1792) | static cl_int retain(cl_sampler sampler) { return ::clRetainSample...
method cl_int (line 1793) | static cl_int release(cl_sampler sampler) { return ::clReleaseSamp...
type ReferenceHandler<cl_program> (line 1797) | struct ReferenceHandler<cl_program>
method cl_int (line 1799) | static cl_int retain(cl_program program) { return ::clRetainProgra...
method cl_int (line 1800) | static cl_int release(cl_program program) { return ::clReleaseProg...
type ReferenceHandler<cl_kernel> (line 1804) | struct ReferenceHandler<cl_kernel>
method cl_int (line 1806) | static cl_int retain(cl_kernel kernel) { return :
Condensed preview — 551 files, each showing path, character count, and a content snippet. Download the .json file or copy for the full structured content (4,188K chars).
[
{
"path": ".clang-format",
"chars": 3263,
"preview": "# Expected version: clang-format-10\nLanguage: Cpp\nBasedOnStyle: Google\n\nAccessModifierOffset: -2\nAlignAfterOpenBracket: "
},
{
"path": ".clang-tidy",
"chars": 5932,
"preview": "# Run clang tidy general analysis, excluding variable naming checks.\n---\nChecks: >\n clang-diagnostic-*,\n clang-analyze"
},
{
"path": ".gitignore",
"chars": 97,
"preview": ".vscode/\n.vs/\nbuild*/\n# Visual Studio output directory for CMake projects.\nout/\nvcpkg_installed/\n"
},
{
"path": "3rdparty/3es-core/3esservermacros.h",
"chars": 5969,
"preview": "// 3rd Eye Scene macros\n// This file disables all 3rd Eye Scene macros. To be used when the library is not available.\n\n#"
},
{
"path": "CMakeLists.txt",
"chars": 11685,
"preview": "cmake_minimum_required(VERSION 3.10)\nproject(ohm)\n\n# Set CMAKE_CXX_STANDARD to the minimum if not externally set - e.g.,"
},
{
"path": "LICENSE",
"chars": 5691,
"preview": "The Software is copyright (c) Commonwealth Scientific and Industrial Research Organisation (CSIRO)\nABN 41 687 119 230.\n\n"
},
{
"path": "OpenCL.md",
"chars": 5666,
"preview": "# OpenCL Usage\n\nOpenCL is one of the two GPU library options required for the Occupancy map (ohm). Most development has "
},
{
"path": "clearance-performance-notes.md",
"chars": 5556,
"preview": "# Performance Notes on Calculating Voxel Clearance Values\n\nHere we note the techniques explored to general voxel clearan"
},
{
"path": "clu/3rdparty/CL/opencl.hpp",
"chars": 317021,
"preview": "//\n// Copyright (c) 2008-2020 The Khronos Group Inc.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\""
},
{
"path": "clu/CMakeLists.txt",
"chars": 2433,
"preview": "\n\n# Convert version string to a list of versions.\nstring(REPLACE \".\" \";\" OPENCL_VERSION_LIST \"${OHM_OPENCL_SDK_VER}\")\n\ns"
},
{
"path": "clu/clu.cpp",
"chars": 21713,
"preview": "//\n// @author Kazys Stepanas\n//\n// Copyright (c) CSIRO 2016\n//\n#include \"clu.h\"\n\n#include <mutex>\n#include <sstream>\n\n#i"
},
{
"path": "clu/clu.h",
"chars": 14863,
"preview": "//\n// @author Kazys Stepanas\n//\n// Copyright (c) CSIRO 2016\n//\n#ifndef CLU_H\n#define CLU_H\n\n#include \"cluConfig.h\"\n\n#ifd"
},
{
"path": "clu/cluBuffer.h",
"chars": 8330,
"preview": "//\n// @author Kazys Stepanas\n//\n// Copyright (c) CSIRO 2016\n//\n#ifndef CLUBUFFER_H\n#define CLUBUFFER_H\n\n#include \"clu.h\""
},
{
"path": "clu/cluConfig.in.h",
"chars": 857,
"preview": "//\n// Project configuration header. This is a generated header; do not modify\n// it directly. Instead, modify the config"
},
{
"path": "clu/cluConstraint.cpp",
"chars": 4324,
"preview": "//\n// @author Kazys Stepanas\n//\n// Copyright (c) CSIRO 2016\n//\n#include \"cluConstraint.h\"\n\n#include <algorithm>\n#include"
},
{
"path": "clu/cluConstraint.h",
"chars": 2900,
"preview": "#ifndef CLUCONSTRAINT_H\n#define CLUCONSTRAINT_H\n\n#include \"clu.h\"\n\nnamespace clu\n{\n/// Create a platform constraint requ"
},
{
"path": "clu/cluKernel.cpp",
"chars": 4118,
"preview": "// Copyright (c) 2017\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "clu/cluKernel.h",
"chars": 18907,
"preview": "//\n// @author Kazys Stepanas\n//\n// Copyright (c) CSIRO 2017\n//\n#ifndef CLUKERNEL_H\n#define CLUKERNEL_H\n\n#include \"clu.h\""
},
{
"path": "clu/cluProgram.cpp",
"chars": 19388,
"preview": "//\n// @author Kazys Stepanas\n//\n// Copyright (c) CSIRO 2016\n//\n#include \"cluProgram.h\"\n\n#include \"clu.h\"\n\n#include <arra"
},
{
"path": "clu/cluProgram.h",
"chars": 7772,
"preview": "//\n// @author Kazys Stepanas\n//\n// Copyright (c) CSIRO 2016\n//\n#ifndef CLUPROGRAM_H\n#define CLUPROGRAM_H\n\n#include \"clu."
},
{
"path": "cmake/ClangTidy.cmake",
"chars": 17570,
"preview": "# Copyright (c) 2018\n# Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n# ABN 41 687 119 230\n#\n# Aut"
},
{
"path": "cmake/FindLASZIP.cmake",
"chars": 2095,
"preview": "# This module searches LASzip and defines\n# LASZIP_LIBRARIES - link libraries\n# LASZIP_FOUND, if false, do not try to li"
},
{
"path": "cmake/FindLIBLAS.cmake",
"chars": 3212,
"preview": "# This module searches liblas and defines\n# LIBLAS_LIBRARIES - link libraries\n# LIBLAS_RUNTIME_LIBRARIES - runtime binar"
},
{
"path": "cmake/FindOctomap.cmake",
"chars": 2835,
"preview": "# This module searches liboctoma and defines\n# OCTOMAP_LIBRARIES - link libraries\n# OCTOMAP_FOUND, if false, do not try "
},
{
"path": "cmake/FindTBB.cmake",
"chars": 17123,
"preview": "# Locate Intel Threading Building Blocks include paths and libraries\n# FindTBB.cmake can be found at https://code.google"
},
{
"path": "cmake/Findglm.cmake",
"chars": 1394,
"preview": "\n# FindGLM (OpenGL Mathematics library)\n# --------\n#\n# try to find include files.\n#\n# IMPORTED Targets\n# ^^^^^^^^^^^^^^^"
},
{
"path": "cmake/LeakTrack.cmake",
"chars": 10135,
"preview": "# Copyright (c) 2019\n# Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n# ABN 41 687 119 230\n#\n# Aut"
},
{
"path": "cmake/OhmCuda.cmake",
"chars": 12777,
"preview": "# OHM_FEATURE_CUDA_DEFAULT is used to initialise the OHM_FEATURE_CUDA option. We have to work out if CUDA is present fir"
},
{
"path": "cmake/OhmGTest.cmake",
"chars": 4262,
"preview": "option(OHM_SYSTEM_GTEST \"Have ohm use a system available version of Googletest via find_package()?\" ${OHM_VCPKG})\n\nif(OH"
},
{
"path": "cmake/TextFileResource.cmake",
"chars": 6116,
"preview": "include(CMakeParseArguments)\n\nset(_TEXT_FILE_RESOURCE_PY \"${CMAKE_CURRENT_LIST_DIR}/TextFileResource.py\")\n\n# text_file_r"
},
{
"path": "cmake/TextFileResource.py",
"chars": 13138,
"preview": "\"\"\"Convert a text file into a symbol into a symbol contained in a source file.\n\nThis can be used to embed a text file in"
},
{
"path": "cmake/compilerSetup.cmake",
"chars": 4628,
"preview": "# Copyright (c) 2017\n# Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n# ABN 41 687 119 230\n#\n# Aut"
},
{
"path": "cmake/doxyfile.in",
"chars": 116628,
"preview": "# Doxyfile 1.9.2\n\n# This file describes the settings to be used by the documentation system\n# doxygen (www.doxygen.org) "
},
{
"path": "cmake/doxygen.cmake",
"chars": 5498,
"preview": "# Copyright (c) 2017\n# Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n# ABN 41 687 119 230\n#\n# Aut"
},
{
"path": "cmake/ohm-config.cmake",
"chars": 5924,
"preview": "# Copyright (c) 2017\n# Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n# ABN 41 687 119 230\n#\n# Aut"
},
{
"path": "cmake/ohm-packages.cmake",
"chars": 621,
"preview": "# Copyright (c) 2017\n# Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n# ABN 41 687 119 230\n#\n# Aut"
},
{
"path": "cmake/tidy/clang-tidy-names.yaml",
"chars": 4289,
"preview": "# Run clang tidy variable naming checks only.\n---\nChecks: >\n -*,\n readability-identifier-naming\nWarningsAsErrors: ''\nH"
},
{
"path": "cmake/tidy/wrap-clang-tidy.py",
"chars": 13231,
"preview": "#!/usr/bin/python3\n\"\"\"This script wraps up running clang tidy to acheive the goals listed below.\n\n1. Support specifying "
},
{
"path": "cmake/utils.cmake",
"chars": 7546,
"preview": "# Copyright (c) 2018\n# Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n# ABN 41 687 119 230\n#\n# Aut"
},
{
"path": "docs/docglossary.md",
"chars": 1368,
"preview": "<!--\nCopyright (c) 2022\nCommonwealth Scientific and Industrial Research Organisation (CSIRO)\nABN 41 687 119 230\n\nAuthor:"
},
{
"path": "docs/docmain.h",
"chars": 811,
"preview": "// Copyright (c) 2020\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n\n// "
},
{
"path": "docs/docusage.md",
"chars": 14142,
"preview": "<!--\nCopyright (c) 2020\nCommonwealth Scientific and Industrial Research Organisation (CSIRO)\nABN 41 687 119 230\n\nAuthor:"
},
{
"path": "docs/docutils.md",
"chars": 7057,
"preview": "<!--\nCopyright (c) 2021\nCommonwealth Scientific and Industrial Research Organisation (CSIRO)\nABN 41 687 119 230\n\nAuthor:"
},
{
"path": "docs/docvoxellayers.md",
"chars": 7744,
"preview": "<!--\nCopyright (c) 2020\nCommonwealth Scientific and Industrial Research Organisation (CSIRO)\nABN 41 687 119 230\n\nAuthor:"
},
{
"path": "docs/gpu/docgpualgorithm.md",
"chars": 5910,
"preview": "<!--\nCopyright (c) 2022\nCommonwealth Scientific and Industrial Research Organisation (CSIRO)\nABN 41 687 119 230\n\nAuthor:"
},
{
"path": "docs/gpu/docgpudetail.md",
"chars": 7227,
"preview": "<!--\nCopyright (c) 2022\nCommonwealth Scientific and Industrial Research Organisation (CSIRO)\nABN 41 687 119 230\n\nAuthor:"
},
{
"path": "gputil/CMakeLists.txt",
"chars": 6038,
"preview": "include(GenerateExportHeader)\n\nif(NOT OHM_FEATURE_CUDA AND NOT OHM_FEATURE_OPENCL)\n message(FATAL_ERROR \"Neither OHM_FE"
},
{
"path": "gputil/cl/gpuApiExceptionCode.cpp",
"chars": 343,
"preview": "// Copyright (c) 2017\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "gputil/cl/gpuBuffer.cpp",
"chars": 20993,
"preview": "// Copyright (c) 2017\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "gputil/cl/gpuBufferDetail.h",
"chars": 859,
"preview": "// Copyright (c) 2017\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "gputil/cl/gpuDevice.cpp",
"chars": 11883,
"preview": "// Copyright (c) 2017\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "gputil/cl/gpuDeviceDetail.h",
"chars": 756,
"preview": "// Copyright (c) 2017\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "gputil/cl/gpuEvent.cpp",
"chars": 3208,
"preview": "// Copyright (c) 2017\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "gputil/cl/gpuEventDetail.h",
"chars": 355,
"preview": "// Copyright (c) 2017\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "gputil/cl/gpuKernel.cpp",
"chars": 5466,
"preview": "// Copyright (c) 2018\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "gputil/cl/gpuKernel2.h",
"chars": 7478,
"preview": "// Copyright (c) 2018\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "gputil/cl/gpuKernelDetail.h",
"chars": 561,
"preview": "// Copyright (c) 2018\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "gputil/cl/gpuPinnedBuffer.cpp",
"chars": 5146,
"preview": "// Copyright (c) 2017\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "gputil/cl/gpuPlatform2.h",
"chars": 2022,
"preview": "// Copyright (c) 2017\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "gputil/cl/gpuProgram.cpp",
"chars": 4743,
"preview": "// Copyright (c) 2018\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "gputil/cl/gpuProgramDetail.h",
"chars": 456,
"preview": "// Copyright (c) 2018\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "gputil/cl/gpuQueue.cpp",
"chars": 3465,
"preview": "// Copyright (c) 2017\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "gputil/cl/gpuQueueDetail.h",
"chars": 397,
"preview": "// Copyright (c) 2017\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "gputil/cuda/cutil_atomic.h",
"chars": 6022,
"preview": "// Copyright (c) 2019\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "gputil/cuda/cutil_decl.h",
"chars": 2832,
"preview": "// Copyright (c) 2019\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "gputil/cuda/cutil_importcl.h",
"chars": 4745,
"preview": "// Copyright (c) 2017\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "gputil/cuda/cutil_math.h",
"chars": 52116,
"preview": "// Copyright (c) 2019\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "gputil/cuda/gpuApiExceptionCode.cpp",
"chars": 381,
"preview": "// Copyright (c) 2017\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "gputil/cuda/gpuBuffer.cpp",
"chars": 16460,
"preview": "// Copyright (c) 2017\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "gputil/cuda/gpuBufferDetail.h",
"chars": 1148,
"preview": "// Copyright (c) 2017\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "gputil/cuda/gpuDevice.cpp",
"chars": 8573,
"preview": "// Copyright (c) 2017\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "gputil/cuda/gpuDeviceDetail.h",
"chars": 511,
"preview": "// Copyright (c) 2017\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "gputil/cuda/gpuDirtyRegion",
"chars": 0,
"preview": ""
},
{
"path": "gputil/cuda/gpuEvent.cpp",
"chars": 2445,
"preview": "// Copyright (c) 2017\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "gputil/cuda/gpuEventDetail.h",
"chars": 808,
"preview": "// Copyright (c) 2017\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "gputil/cuda/gpuKernel.cpp",
"chars": 9110,
"preview": "// Copyright (c) 2019\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "gputil/cuda/gpuKernel2.h",
"chars": 6209,
"preview": "// Copyright (c) 2018\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "gputil/cuda/gpuKernelDetail.h",
"chars": 729,
"preview": "// Copyright (c) 2018\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "gputil/cuda/gpuMemRegion.cpp",
"chars": 997,
"preview": "// Copyright (c) 2019\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "gputil/cuda/gpuMemRegion.h",
"chars": 1641,
"preview": "// Copyright (c) 2019\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "gputil/cuda/gpuPinnedBuffer.cpp",
"chars": 6458,
"preview": "// Copyright (c) 2017\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "gputil/cuda/gpuPlatform2.h",
"chars": 2010,
"preview": "// Copyright (c) 2017\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "gputil/cuda/gpuProgram.cpp",
"chars": 1858,
"preview": "// Copyright (c) 2019\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "gputil/cuda/gpuProgramDetail.h",
"chars": 418,
"preview": "// Copyright (c) 2018\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "gputil/cuda/gpuQueue.cpp",
"chars": 2997,
"preview": "// Copyright (c) 2017\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "gputil/cuda/gpuQueueDetail.h",
"chars": 801,
"preview": "// Copyright (c) 2017\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "gputil/cuda/ref.h",
"chars": 2847,
"preview": "// Copyright (c) 2017\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "gputil/gpuApiException.cpp",
"chars": 985,
"preview": "// Copyright (c) 2017\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "gputil/gpuApiException.h",
"chars": 1832,
"preview": "// Copyright (c) 2017\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "gputil/gpuBuffer.h",
"chars": 25178,
"preview": "// Copyright (c) 2017\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "gputil/gpuConfig.in.h",
"chars": 552,
"preview": "// Copyright (c) 2017\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "gputil/gpuDevice.h",
"chars": 6443,
"preview": "// Copyright (c) 2017\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "gputil/gpuDeviceInfo.h",
"chars": 1382,
"preview": "// Copyright (c) 2018\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "gputil/gpuEvent.h",
"chars": 2581,
"preview": "// Copyright (c) 2017\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "gputil/gpuEventList.cpp",
"chars": 2595,
"preview": "// Copyright (c) 2017\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "gputil/gpuEventList.h",
"chars": 3829,
"preview": "// Copyright (c) 2017\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "gputil/gpuException.cpp",
"chars": 1310,
"preview": "// Copyright (c) 2017\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "gputil/gpuException.h",
"chars": 1946,
"preview": "// Copyright (c) 2017\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "gputil/gpuKernel.h",
"chars": 13150,
"preview": "// Copyright (c) 2018\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "gputil/gpuPinMode.h",
"chars": 499,
"preview": "// Copyright (c) 2017\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "gputil/gpuPinnedBuffer.h",
"chars": 9759,
"preview": "// Copyright (c) 2017\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "gputil/gpuPlatform.h",
"chars": 446,
"preview": "// Copyright (c) 2017\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "gputil/gpuProgram.h",
"chars": 3721,
"preview": "// Copyright (c) 2018\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "gputil/gpuQueue.h",
"chars": 4827,
"preview": "// Copyright (c) 2017\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "gputil/gpuThrow.cpp",
"chars": 499,
"preview": "// Copyright (c) 2017\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "gputil/gpuThrow.h",
"chars": 1520,
"preview": "// Copyright (c) 2017\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "gputil/gpuVersion.h",
"chars": 825,
"preview": "// Copyright (c) 2018\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "gputil/gpu_ext.h",
"chars": 15426,
"preview": "// Copyright (c) 2017\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "logutil/CMakeLists.txt",
"chars": 1235,
"preview": "\ninclude(GenerateExportHeader)\ninclude(TextFileResource)\n\nconfigure_file(LogUtilConfig.in.h \"${CMAKE_CURRENT_BINARY_DIR}"
},
{
"path": "logutil/LogUtil.cpp",
"chars": 2845,
"preview": "// Copyright (c) 2017\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "logutil/LogUtil.h",
"chars": 8995,
"preview": "// Copyright (c) 2017\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "logutil/LogUtilConfig.in.h",
"chars": 750,
"preview": "//\n// Project configuration header. This is a generated header; do not modify\n// it directly. Instead, modify the config"
},
{
"path": "logutil/Logger.cpp",
"chars": 1302,
"preview": "// Copyright (c) 2021\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "logutil/Logger.h",
"chars": 7878,
"preview": "// Copyright (c) 2021\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "logutil/LoggerDetail.h",
"chars": 992,
"preview": "// Copyright (c) 2021\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "ohm/Aabb.h",
"chars": 19357,
"preview": "// Copyright (c) 2018\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "ohm/CMakeLists.txt",
"chars": 7169,
"preview": "\ninclude(GenerateExportHeader)\ninclude(TextFileResource)\n\n\nfind_package(ZLIB)\nif(OHM_FEATURE_THREADS)\n find_package(TBB"
},
{
"path": "ohm/CalculateSegmentKeys.cpp",
"chars": 1013,
"preview": "// Copyright (c) 2020\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "ohm/CalculateSegmentKeys.h",
"chars": 1429,
"preview": "// Copyright (c) 2020\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "ohm/ClearingPattern.cpp",
"chars": 1834,
"preview": "// Copyright (c) 2019\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "ohm/ClearingPattern.h",
"chars": 6161,
"preview": "// Copyright (c) 2019\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "ohm/CompareMaps.cpp",
"chars": 16237,
"preview": "// Copyright (c) 2021\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "ohm/CompareMaps.h",
"chars": 7125,
"preview": "// Copyright (c) 2021\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "ohm/CopyUtil.cpp",
"chars": 5868,
"preview": "// Copyright (c) 2021\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "ohm/CopyUtil.h",
"chars": 6178,
"preview": "// Copyright (c) 2021\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "ohm/CovarianceVoxel.cpp",
"chars": 13927,
"preview": "// Copyright (c) 2020\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "ohm/CovarianceVoxel.h",
"chars": 5622,
"preview": "// Copyright (c) 2020\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "ohm/CovarianceVoxelCompute.h",
"chars": 31935,
"preview": "// Copyright (c) 2020\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "ohm/DataType.cpp",
"chars": 1229,
"preview": "// Copyright (c) 2018\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "ohm/DataType.h",
"chars": 1207,
"preview": "// Copyright (c) 2018\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "ohm/DebugDraw.cpp",
"chars": 8448,
"preview": "// Copyright (c) 2021\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "ohm/DebugDraw.h",
"chars": 1276,
"preview": "// Copyright (c) 2021\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "ohm/DebugIDs.h",
"chars": 390,
"preview": "//\n// author Kazys Stepanas\n//\n#ifndef DEBUG_IDS_H_\n#define DEBUG_IDS_H_\n\nnamespace ohm\n{\nenum class Category\n{\n kDefau"
},
{
"path": "ohm/DefaultLayer.cpp",
"chars": 8760,
"preview": "// Copyright (c) 2018\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "ohm/DefaultLayer.h",
"chars": 7561,
"preview": "// Copyright (c) 2018\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "ohm/Density.cpp",
"chars": 735,
"preview": "// Copyright (c) 2021\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "ohm/Density.h",
"chars": 2188,
"preview": "// Copyright (c) 2021\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "ohm/Key.cpp",
"chars": 1865,
"preview": "//\n// Author: Kazys Stepanas\n// Copyright (c) CSIRO 2017\n//\n#include \"Key.h\"\n\n#include <ohmutil/VectorHash.h>\n\n#define I"
},
{
"path": "ohm/Key.h",
"chars": 14111,
"preview": "//\n// Author: Kazys Stepanas\n// Copyright (c) CSIRO 2017\n//\n#ifndef OHM_KEY_H\n#define OHM_KEY_H\n\n#include \"OhmConfig.h\"\n"
},
{
"path": "ohm/KeyHash.cpp",
"chars": 231,
"preview": "// Copyright (c) 2021\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "ohm/KeyHash.h",
"chars": 738,
"preview": "// Copyright (c) 2019\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "ohm/KeyList.cpp",
"chars": 599,
"preview": "//\n// Author: Kazys Stepanas\n// Copyright (c) CSIRO 2017\n//\n#include \"KeyList.h\"\n\n#include <cmath>\n#include <cstring>\n\nn"
},
{
"path": "ohm/KeyList.h",
"chars": 9215,
"preview": "//\n// Author: Kazys Stepanas\n// Copyright (c) CSIRO 2017\n//\n#ifndef OHM_KEYLIST_H\n#define OHM_KEYLIST_H\n\n#include \"OhmCo"
},
{
"path": "ohm/KeyRange.cpp",
"chars": 4133,
"preview": "// Copyright (c) 2020\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "ohm/KeyRange.h",
"chars": 12871,
"preview": "// Copyright (c) 2020\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "ohm/KeyStream.h",
"chars": 319,
"preview": "// Copyright (c) 2021\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "ohm/LineKeysQuery.cpp",
"chars": 3325,
"preview": "// Copyright (c) 2017\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "ohm/LineKeysQuery.h",
"chars": 4865,
"preview": "// Copyright (c) 2017\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "ohm/LineQuery.cpp",
"chars": 5325,
"preview": "// Copyright (c) 2017\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "ohm/LineQuery.h",
"chars": 7628,
"preview": "// Copyright (c) 2017\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "ohm/LineWalk.h",
"chars": 5059,
"preview": "// Copyright (c) 2018\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "ohm/LineWalkCompute.h",
"chars": 17914,
"preview": "// Copyright (c) 2022\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "ohm/MapChunk.cpp",
"chars": 8876,
"preview": "// Copyright (c) 2017\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "ohm/MapChunk.h",
"chars": 14664,
"preview": "// Copyright (c) 2017\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "ohm/MapChunkFlag.h",
"chars": 339,
"preview": "// Copyright (c) 2017\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "ohm/MapCoord.h",
"chars": 3696,
"preview": "// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// Copyright (c) 2017\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "ohm/MapFlag.cpp",
"chars": 867,
"preview": "// Copyright (c) 2019\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "ohm/MapFlag.h",
"chars": 2446,
"preview": "// Copyright (c) 2019\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "ohm/MapInfo.cpp",
"chars": 14316,
"preview": "//\n// @author Kazys Stepanas\n//\n// Copyright (c) 2015 CSIRO\n//\n#include \"MapInfo.h\"\n\n#include <cstring>\n#include <sstrea"
},
{
"path": "ohm/MapInfo.h",
"chars": 13134,
"preview": "//\n// @author Kazys Stepanas\n//\n// Copyright (c) 2015 CSIRO\n//\n#ifndef MAPINFO_H\n#define MAPINFO_H\n\n#include \"OhmConfig."
},
{
"path": "ohm/MapLayer.cpp",
"chars": 5172,
"preview": "// Copyright (c) 2018\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "ohm/MapLayer.h",
"chars": 5208,
"preview": "// Copyright (c) 2018\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "ohm/MapLayout.cpp",
"chars": 7669,
"preview": "// Copyright (c) 2018\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "ohm/MapLayout.h",
"chars": 10916,
"preview": "// Copyright (c) 2018\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "ohm/MapLayoutMatch.h",
"chars": 513,
"preview": "//\n// Author: Kazys Stepanas\n// Copyright (c) CSIRO 2020\n//\n#ifndef MAPLAYOUTMATCH_H\n#define MAPLAYOUTMATCH_H\n\n#include "
},
{
"path": "ohm/MapProbability.h",
"chars": 1293,
"preview": "//\n// @author Kazys Stepanas\n//\n// Copyright (c) 2015 CSIRO\n//\n#ifndef OHM_PROBABILITY_H\n#define OHM_PROBABILITY_H\n\n#inc"
},
{
"path": "ohm/MapRegion.cpp",
"chars": 2139,
"preview": "//\n// Author: Kazys Stepanas\n// Copyright (c) CSIRO 2017\n//\n#include \"MapRegion.h\"\n\n#include <ohmutil/VectorHash.h>\n\n#in"
},
{
"path": "ohm/MapRegion.h",
"chars": 3315,
"preview": "//\n// Author: Kazys Stepanas\n// Copyright (c) CSIRO 2017\n//\n#ifndef OHM_MAPREGION_H\n#define OHM_MAPREGION_H\n\n#include \"O"
},
{
"path": "ohm/MapRegionCache.cpp",
"chars": 346,
"preview": "// Copyright (c) 2019\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "ohm/MapRegionCache.h",
"chars": 3381,
"preview": "// Copyright (c) 2019\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "ohm/MapSerialise.cpp",
"chars": 23490,
"preview": "// Copyright (c) 2017\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "ohm/MapSerialise.h",
"chars": 8513,
"preview": "// Copyright (c) 2017\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "ohm/Mapper.cpp",
"chars": 3206,
"preview": "// Copyright (c) 2018\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "ohm/Mapper.h",
"chars": 4962,
"preview": "// Copyright (c) 2018\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "ohm/MappingProcess.cpp",
"chars": 300,
"preview": "// Copyright (c) 2018\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "ohm/MappingProcess.h",
"chars": 1813,
"preview": "// Copyright (c) 2018\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "ohm/Mutex.cpp",
"chars": 177,
"preview": "// Copyright (c) 2020\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "ohm/Mutex.h",
"chars": 613,
"preview": "// Copyright (c) 2020\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "ohm/NdtMap.cpp",
"chars": 4067,
"preview": "// Copyright (c) 2020\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "ohm/NdtMap.h",
"chars": 7776,
"preview": "//\n// Author: Kazys Stepanas\n// Copyright (c) CSIRO 2020\n//\n#ifndef NDTMAP_H\n#define NDTMAP_H\n\n#include \"OhmConfig.h\"\n\n#"
},
{
"path": "ohm/NdtMode.cpp",
"chars": 769,
"preview": "// Copyright (c) 2021\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "ohm/NdtMode.h",
"chars": 848,
"preview": "//\n// Author: Kazys Stepanas\n// Copyright (c) CSIRO 2021\n//\n#ifndef OHM_NDTMODE_H\n#define OHM_NDTMODE_H\n\n#include \"OhmCo"
},
{
"path": "ohm/NearestNeighbours.cpp",
"chars": 9254,
"preview": "// Copyright (c) 2017\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "ohm/NearestNeighbours.h",
"chars": 3456,
"preview": "// Copyright (c) 2017\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "ohm/OccupancyMap.cpp",
"chars": 35258,
"preview": "// Copyright (c) 2017\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "ohm/OccupancyMap.h",
"chars": 47872,
"preview": "// Copyright (c) 2017\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "ohm/OccupancyType.cpp",
"chars": 618,
"preview": "// Copyright (c) 2017\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "ohm/OccupancyType.h",
"chars": 653,
"preview": "// Copyright (c) 2017\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "ohm/OccupancyUtil.cpp",
"chars": 279,
"preview": "// Copyright (c) 2017\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "ohm/OccupancyUtil.h",
"chars": 799,
"preview": "// Copyright (c) 2017\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "ohm/OhmConfig.in.h",
"chars": 1594,
"preview": "//\n// Project configuration header. This is a generated header; do not modify\n// it directly. Instead, modify the config"
},
{
"path": "ohm/Query.cpp",
"chars": 1473,
"preview": "// Copyright (c) 2017\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "ohm/Query.h",
"chars": 6520,
"preview": "// Copyright (c) 2017\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "ohm/QueryFlag.h",
"chars": 2917,
"preview": "// Copyright (c) 2017\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "ohm/RayFilter.cpp",
"chars": 2475,
"preview": "// Copyright (c) 2018\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "ohm/RayFilter.h",
"chars": 4899,
"preview": "// Copyright (c) 2018\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "ohm/RayFlag.h",
"chars": 2675,
"preview": "// Copyright (c) 2019\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "ohm/RayMapper.cpp",
"chars": 275,
"preview": "// Copyright (c) 2020\n// Commonwealth Scientific and Industrial Research Organisation (CSIRO)\n// ABN 41 687 119 230\n//\n/"
},
{
"path": "ohm/RayMapper.h",
"chars": 2867,
"preview": "//\n// Author: Kazys Stepanas\n// Copyright (c) CSIRO 2020\n//\n#ifndef RAYMAPPER_H\n#define RAYMAPPER_H\n\n#include \"OhmConfig"
},
{
"path": "ohm/RayMapperNdt.cpp",
"chars": 17316,
"preview": "//\n// Author: Kazys Stepanas\n// Copyright (c) CSIRO 2020\n//\n#include \"RayMapperNdt.h\"\n\n#define GLM_ENABLE_EXPERIMENTAL\n#"
}
]
// ... and 351 more files (download for full content)
About this extraction
This page contains the full source code of the csiro-robotics/ohm GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 551 files (3.8 MB), approximately 1.0M tokens, and a symbol index with 3267 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.