clfft 0.3.3

Bindings for clFFT, a FFT library for OpenCL.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103

/* ************************************************************************
 * Copyright 2013 Advanced Micro Devices, 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.
 * ************************************************************************/


// clfft.lifetime.cpp : Functions that control the lifetime of the FFT library and their supporting functions
//

#include "stdafx.h"
#include "private.h"
#include "repo.h"
#include "../include/sharedLibrary.h"
#include "../statTimer/statisticalTimer.extern.h"

clfftStatus clfftInitSetupData( clfftSetupData* setupData )
{
	setupData->major	= clfftVersionMajor;
	setupData->minor	= clfftVersionMinor;
	setupData->patch	= clfftVersionPatch;
	setupData->debugFlags	= 0;

	return	CLFFT_SUCCESS;
}

//	Allow AMD's implementation of FFT's to allocate internal resources
clfftStatus	clfftSetup( const clfftSetupData* sData )
{
	//	Static data is not thread safe (to create), so we implement a lock to protect instantiation for the first call
	//	Implemented outside of FFTRepo::getInstance to minimize lock overhead; this is only necessary on first creation
	scopedLock sLock( FFTRepo::lockRepo(), _T( "FFTRepo::getInstance" ) );

	//	First invocation of this function will allocate the FFTRepo singleton; thereafter the object always exists
	FFTRepo& fftRepo	= FFTRepo::getInstance( );

	clfftInitRequestLibNoMemAlloc();
	clfftInitBinaryCache();

	//	Discover and load the timer module if present
	fftRepo.timerHandle = LoadSharedLibrary( "lib", "StatTimer", true );
	if( fftRepo.timerHandle )
	{
		//	Timer module discovered and loaded successfully
		//	Initialize function pointers to call into the shared module
		PFGETSTATTIMER pfGetStatTimer = reinterpret_cast< PFGETSTATTIMER > ( LoadFunctionAddr( fftRepo.timerHandle, "getStatTimer" ) );

		//	Create and initialize our timer class, if the external timer shared library loaded
		if( pfGetStatTimer )
		{
			fftRepo.pStatTimer = reinterpret_cast< GpuStatTimer* > ( pfGetStatTimer( CLFFT_GPU ) );
		}
	}

	// If the client has no setupData, we are done
	if( sData == NULL )
		return CLFFT_SUCCESS;

	//	Versioning checks commented out until necessary
	////	If the major version number between the client and library do not match, return mismatch
	//if( sData->major > clfftVersionMajor )
	//	return CLFFT_VERSION_MISMATCH;

	////	If the minor version number between the client and library do not match, return mismatch
	//if( sData->minor > clfftVersionMinor )
	//	return CLFFT_VERSION_MISMATCH;

	////	We ignore patch version number for version validation

	fftRepo.setupData	= *sData;

	return	CLFFT_SUCCESS;
}

//	Allow AMD's implementation of FFT's to destroy internal resources
clfftStatus	clfftTeardown( )
{
	FFTRepo& fftRepo	= FFTRepo::getInstance( );
	fftRepo.releaseResources( );

	FreeSharedLibrary( fftRepo.timerHandle );

	return	CLFFT_SUCCESS;
}

clfftStatus clfftGetVersion( cl_uint* major, cl_uint* minor, cl_uint* patch )
{
	*major	= clfftVersionMajor;
	*minor	= clfftVersionMinor;
	*patch	= clfftVersionPatch;

	return	CLFFT_SUCCESS;
}