%
%
*/
-
+\f
/*
-Include declarations.
+ Include declarations.
*/
#include "MagickCore/studio.h"
#include "MagickCore/artifact.h"
#endif
-#define NUM_CL_RAND_GENERATORS 1024 /* number of random number generators running in parallel */
+#define NUM_CL_RAND_GENERATORS 1024 /* number of random number generators running in parallel */
/*
- *
+ *
* Dynamic library loading functions
*
*/
{
#ifdef MAGICKCORE_WINDOWS_SUPPORT
return (void *)LoadLibraryA(libraryName);
-#else
+#else
return (void *)dlopen(libraryName, RTLD_NOW);
#endif
}
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
-% AcquireMagickOpenCLEnv() allocates the MagickCLEnv structure
+% AcquireMagickOpenCLEnv() allocates the MagickCLEnv structure
%
*/
}
MagickLibrary * GetOpenCLLib()
-{
+{
if (OpenCLLib == NULL)
{
if (OpenCLLibLock == NULL)
#ifdef MAGICKCORE_OPENCL_MACOSX
status = bindOpenCLFunctions(library);
#else
-
+
memset(OpenCLLib, 0, sizeof(MagickLibrary));
#ifdef MAGICKCORE_WINDOWS_SUPPORT
library = OsLibraryLoad("OpenCL.dll");
#endif
}
- UnlockSemaphoreInfo(OpenCLLibLock);
+ UnlockSemaphoreInfo(OpenCLLibLock);
}
-
- return OpenCLLib;
+
+ return OpenCLLib;
}
*/
MagickExport MagickCLEnv GetDefaultOpenCLEnv()
-{
+{
if (defaultCLEnv == NULL)
{
if (defaultCLEnvLock == NULL)
}
LockSemaphoreInfo(defaultCLEnvLock);
defaultCLEnv = AcquireMagickOpenCLEnv();
- UnlockSemaphoreInfo(defaultCLEnvLock);
+ UnlockSemaphoreInfo(defaultCLEnvLock);
}
- return defaultCLEnv;
+ return defaultCLEnv;
}
static void LockDefaultOpenCLEnv() {
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
-% SetDefaultOpenCLEnv() sets the new OpenCL environment as default
+% SetDefaultOpenCLEnv() sets the new OpenCL environment as default
% and returns the old OpenCL environment
-%
+%
% The format of the SetDefaultOpenCLEnv() method is:
%
% MagickCLEnv SetDefaultOpenCLEnv(MagickCLEnv clEnv)
% o clEnv: the new default OpenCL environment.
%
*/
-MagickExport MagickCLEnv SetDefaultOpenCLEnv(MagickCLEnv clEnv)
+MagickExport MagickCLEnv SetDefaultOpenCLEnv(MagickCLEnv clEnv)
{
MagickCLEnv oldEnv;
LockDefaultOpenCLEnv();
defaultCLEnv = clEnv;
UnlockDefaultOpenCLEnv();
return oldEnv;
-}
+}
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
-% SetMagickOpenCLEnvParam() sets the parameters in the OpenCL environment
-%
+% SetMagickOpenCLEnvParam() sets the parameters in the OpenCL environment
+%
% The format of the SetMagickOpenCLEnvParam() method is:
%
-% MagickBooleanType SetMagickOpenCLEnvParam(MagickCLEnv clEnv,
-% MagickOpenCLEnvParam param, size_t dataSize, void* data,
+% MagickBooleanType SetMagickOpenCLEnvParam(MagickCLEnv clEnv,
+% MagickOpenCLEnvParam param, size_t dataSize, void* data,
% ExceptionInfo* exception)
%
% A description of each parameter follows:
%
% o clEnv: the OpenCL environment.
-%
+%
% o param: the parameter to be set.
%
% o dataSize: the data size of the parameter value.
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
-% GetMagickOpenCLEnvParam() gets the parameters in the OpenCL environment
-%
+% GetMagickOpenCLEnvParam() gets the parameters in the OpenCL environment
+%
% The format of the GetMagickOpenCLEnvParam() method is:
%
-% MagickBooleanType GetMagickOpenCLEnvParam(MagickCLEnv clEnv,
-% MagickOpenCLEnvParam param, size_t dataSize, void* data,
+% MagickBooleanType GetMagickOpenCLEnvParam(MagickCLEnv clEnv,
+% MagickOpenCLEnvParam param, size_t dataSize, void* data,
% ExceptionInfo* exception)
%
% A description of each parameter follows:
%
% o clEnv: the OpenCL environment.
-%
+%
% o param: the parameter to be returned.
%
% o dataSize: the data size of the parameter value.
%
-% o data: the location where the returned parameter value will be stored
+% o data: the location where the returned parameter value will be stored
%
% o exception: return any errors or warnings
%
MagickBooleanType GetMagickOpenCLEnvParam(MagickCLEnv clEnv, MagickOpenCLEnvParam param
, size_t dataSize, void* data, ExceptionInfo* exception)
{
- MagickBooleanType
+ MagickBooleanType
status;
magick_unreferenced(exception);
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
-% GetOpenCLContext() returns the OpenCL context
-%
+% GetOpenCLContext() returns the OpenCL context
+%
% The format of the GetOpenCLContext() method is:
%
-% cl_context GetOpenCLContext(MagickCLEnv clEnv)
+% cl_context GetOpenCLContext(MagickCLEnv clEnv)
%
% A description of each parameter follows:
%
/* strip out illegal characters for file names */
while (*ptr != '\0')
{
- if ( *ptr == ' ' || *ptr == '\\' || *ptr == '/' || *ptr == ':' || *ptr == '*'
+ if ( *ptr == ' ' || *ptr == '\\' || *ptr == '/' || *ptr == ':' || *ptr == '*'
|| *ptr == '?' || *ptr == '"' || *ptr == '<' || *ptr == '>' || *ptr == '|')
{
*ptr = '_';
/* OpenCL kernels for accelerate.c */
extern const char *accelerateKernels, *accelerateKernels2;
-static MagickBooleanType CompileOpenCLKernels(MagickCLEnv clEnv, ExceptionInfo* exception)
+static MagickBooleanType CompileOpenCLKernels(MagickCLEnv clEnv, ExceptionInfo* exception)
{
MagickBooleanType status = MagickFalse;
cl_int clStatus;
char* accelerateKernelsBuffer = NULL;
/* The index of the program strings in this array has to match the value of the enum MagickOpenCLProgram */
- const char* MagickOpenCLProgramStrings[MAGICK_OPENCL_NUM_PROGRAMS];
+ const char* MagickOpenCLProgramStrings[MAGICK_OPENCL_NUM_PROGRAMS];
char options[MagickPathExtent];
unsigned int optionsSignature;
sprintf(accelerateKernelsBuffer,"%s%s",accelerateKernels,accelerateKernels2);
MagickOpenCLProgramStrings[MAGICK_OPENCL_ACCELERATE] = accelerateKernelsBuffer;
- for (i = 0; i < MAGICK_OPENCL_NUM_PROGRAMS; i++)
+ for (i = 0; i < MAGICK_OPENCL_NUM_PROGRAMS; i++)
{
MagickBooleanType loadSuccessful = MagickFalse;
unsigned int programSignature = stringSignature(MagickOpenCLProgramStrings[i]) ^ optionsSignature;
status = clEnv->library->clGetPlatformIDs(0, NULL, &numPlatforms);
if (status != CL_SUCCESS)
{
- (void) ThrowMagickException(exception, GetMagickModule(), DelegateWarning,
+ (void) ThrowMagickException(exception, GetMagickModule(), DelegateWarning,
"clGetplatformIDs failed.", "(%d)", status);
goto cleanup;
}
/* Device selection */
clEnv->device = NULL;
- for (j = 0; j < 2; j++)
+ for (j = 0; j < 2; j++)
{
cl_device_type deviceType;
SetMagickOpenCLEnvParamInternal(clEnv, MAGICK_OPENCL_ENV_PARAM_OPENCL_DISABLED
, sizeof(MagickBooleanType), &flag, exception);
}
-
+
if (clEnv->OpenCLDisabled != MagickFalse)
goto cleanup;
%
% The format of the AcquireOpenCLKernel method is:
%
-% cl_kernel AcquireOpenCLKernel(MagickCLEnv clEnv,
+% cl_kernel AcquireOpenCLKernel(MagickCLEnv clEnv,
% MagickOpenCLProgram program, const char* kernelName)
%
% A description of each parameter follows:
/* device type */
typedef enum {
DS_DEVICE_NATIVE_CPU = 0
- ,DS_DEVICE_OPENCL_DEVICE
+ ,DS_DEVICE_OPENCL_DEVICE
} ds_device_type;
profile = (ds_profile*)malloc(sizeof(ds_profile));
if (profile == NULL)
return DS_MEMORY_ERROR;
-
+
memset(profile, 0, sizeof(ds_profile));
OpenCLLib->clGetPlatformIDs(0, NULL, &numPlatforms);
profile->numDevices = numDevices+1; /* +1 to numDevices to include the native CPU */
- profile->devices = (ds_device*)malloc(profile->numDevices*sizeof(ds_device));
+ profile->devices = (ds_device*)malloc(profile->numDevices*sizeof(ds_device));
if (profile->devices == NULL) {
profile->numDevices = 0;
status = DS_MEMORY_ERROR;
- goto cleanup;
+ goto cleanup;
}
memset(profile->devices, 0, profile->numDevices*sizeof(ds_device));
cl_uint num;
int d;
- for (d = 0; d < 2; d++) {
+ for (d = 0; d < 2; d++) {
unsigned int j;
cl_device_type deviceType;
switch(d) {
return status;
}
-/* Pointer to a function that calculates the score of a device (ex: device->score)
- update the data size of score. The encoding and the format of the score data
+/* Pointer to a function that calculates the score of a device (ex: device->score)
+ update the data size of score. The encoding and the format of the score data
is implementation defined. The function should return DS_SUCCESS if there's no error to be reported.
*/
typedef ds_status (*ds_perf_evaluator)(ds_device* device, void* data);
for (i = 0; i < profile->numDevices; i++) {
ds_status evaluatorStatus;
-
+
switch (type) {
case DS_EVALUATE_NEW_ONLY:
if (profile->devices[i].score != NULL)
switch(profile->devices[i].type) {
case DS_DEVICE_NATIVE_CPU:
- {
+ {
/* There's no need to emit a device name for the native CPU device. */
/*
fwrite(DS_TAG_DEVICE_NAME, sizeof(char), strlen(DS_TAG_DEVICE_NAME), profileFile);
*/
}
break;
- case DS_DEVICE_OPENCL_DEVICE:
+ case DS_DEVICE_OPENCL_DEVICE:
{
char tmp[16];
return DS_FILE_ERROR;
}
- fseek(input, 0L, SEEK_END);
+ fseek(input, 0L, SEEK_END);
size = ftell(input);
rewind(input);
binary = (char*)malloc(size);
}
-typedef ds_status (*ds_score_deserializer)(ds_device* device, const unsigned char* serializedScore, unsigned int serializedScoreSize);
+typedef ds_status (*ds_score_deserializer)(ds_device* device, const unsigned char* serializedScore, unsigned int serializedScoreSize);
static ds_status readProfileFromFile(ds_profile* profile, ds_score_deserializer deserializer, const char* file) {
ds_status status = DS_SUCCESS;
}
versionStringLength = strlen(profile->version);
- if (versionStringLength!=(size_t)(dataEnd-dataStart)
+ if (versionStringLength!=(size_t)(dataEnd-dataStart)
|| strncmp(profile->version, dataStart, versionStringLength)!=(int)0) {
/* version mismatch */
status = DS_PROFILE_FILE_ERROR;
deviceTypeStart = findString(dataStart, contentEnd, DS_TAG_DEVICE_TYPE);
if (deviceTypeStart==NULL) {
status = DS_PROFILE_FILE_ERROR;
- goto cleanup;
+ goto cleanup;
}
deviceTypeStart+=strlen(DS_TAG_DEVICE_TYPE);
deviceTypeEnd = findString(deviceTypeStart, contentEnd, DS_TAG_DEVICE_TYPE_END);
deviceNameStart = findString(dataStart, contentEnd, DS_TAG_DEVICE_NAME);
if (deviceNameStart==NULL) {
status = DS_PROFILE_FILE_ERROR;
- goto cleanup;
+ goto cleanup;
}
deviceNameStart+=strlen(DS_TAG_DEVICE_NAME);
deviceNameEnd = findString(deviceNameStart, contentEnd, DS_TAG_DEVICE_NAME_END);
if (deviceNameEnd==NULL) {
status = DS_PROFILE_FILE_ERROR;
- goto cleanup;
+ goto cleanup;
}
deviceDriverStart = findString(dataStart, contentEnd, DS_TAG_DEVICE_DRIVER_VERSION);
if (deviceDriverStart==NULL) {
status = DS_PROFILE_FILE_ERROR;
- goto cleanup;
+ goto cleanup;
}
deviceDriverStart+=strlen(DS_TAG_DEVICE_DRIVER_VERSION);
deviceDriverEnd = findString(deviceDriverStart, contentEnd, DS_TAG_DEVICE_DRIVER_VERSION_END);
if (deviceDriverEnd ==NULL) {
status = DS_PROFILE_FILE_ERROR;
- goto cleanup;
+ goto cleanup;
}
tmpStart = findString(dataStart, contentEnd, DS_TAG_DEVICE_MAX_COMPUTE_UNITS);
if (tmpStart==NULL) {
status = DS_PROFILE_FILE_ERROR;
- goto cleanup;
+ goto cleanup;
}
tmpStart+=strlen(DS_TAG_DEVICE_MAX_COMPUTE_UNITS);
tmpEnd = findString(tmpStart, contentEnd, DS_TAG_DEVICE_MAX_COMPUTE_UNITS_END);
if (tmpEnd ==NULL) {
status = DS_PROFILE_FILE_ERROR;
- goto cleanup;
+ goto cleanup;
}
memcpy(tmp,tmpStart,tmpEnd-tmpStart);
tmp[tmpEnd-tmpStart] = '\0';
tmpStart = findString(dataStart, contentEnd, DS_TAG_DEVICE_MAX_CLOCK_FREQ);
if (tmpStart==NULL) {
status = DS_PROFILE_FILE_ERROR;
- goto cleanup;
+ goto cleanup;
}
tmpStart+=strlen(DS_TAG_DEVICE_MAX_CLOCK_FREQ);
tmpEnd = findString(tmpStart, contentEnd, DS_TAG_DEVICE_MAX_CLOCK_FREQ_END);
if (tmpEnd ==NULL) {
status = DS_PROFILE_FILE_ERROR;
- goto cleanup;
+ goto cleanup;
}
memcpy(tmp,tmpStart,tmpEnd-tmpStart);
tmp[tmpEnd-tmpStart] = '\0';
if (profile->devices[i].type == DS_DEVICE_OPENCL_DEVICE) {
size_t actualDeviceNameLength;
size_t driverVersionLength;
-
+
actualDeviceNameLength = strlen(profile->devices[i].oclDeviceName);
driverVersionLength = strlen(profile->devices[i].oclDriverVersion);
if (actualDeviceNameLength == (size_t)(deviceNameEnd - deviceNameStart)
deviceScoreStart = findString(dataStart, contentEnd, DS_TAG_SCORE);
if (deviceNameStart==NULL) {
status = DS_PROFILE_FILE_ERROR;
- goto cleanup;
+ goto cleanup;
}
deviceScoreStart+=strlen(DS_TAG_SCORE);
deviceScoreEnd = findString(deviceScoreStart, contentEnd, DS_TAG_SCORE_END);
deviceScoreStart = findString(dataStart, contentEnd, DS_TAG_SCORE);
if (deviceScoreStart==NULL) {
status = DS_PROFILE_FILE_ERROR;
- goto cleanup;
+ goto cleanup;
}
deviceScoreStart+=strlen(DS_TAG_SCORE);
deviceScoreEnd = findString(deviceScoreStart, contentEnd, DS_TAG_SCORE_END);
DestroyImage(inputImage);
}
/* end of microbenchmark */
-
+
if (device->score == NULL)
device->score=malloc(sizeof(AccelerateScoreType));
*(AccelerateScoreType*)device->score=readAccelerateTimer(&timer);
ds_status canWriteProfileToFile(const char *path)
{
FILE* profileFile = fopen(path, "ab");
-
+
if (profileFile==NULL)
return DS_FILE_ERROR;
%
% InitImageMagickOpenCL() provides a simplified interface to initialize
% the OpenCL environtment in ImageMagick
-%
+%
% The format of the InitImageMagickOpenCL() method is:
%
-% MagickBooleanType InitImageMagickOpenCL(ImageMagickOpenCLMode mode,
-% void* userSelectedDevice,
-% void* selectedDevice)
+% MagickBooleanType InitImageMagickOpenCL(ImageMagickOpenCLMode mode,
+% void* userSelectedDevice,
+% void* selectedDevice)
%
% A description of each parameter follows:
%
}
MagickPrivate cl_mem GetAndLockRandSeedBuffer(MagickCLEnv clEnv)
-{
+{
LockSemaphoreInfo(clEnv->lock);
if (clEnv->seedsLock == NULL)
{
unsigned int *seeds;
queue = AcquireOpenCLCommandQueue(clEnv);
- seeds = (unsigned int*) clEnv->library->clEnqueueMapBuffer(queue, clEnv->seeds, CL_TRUE,
+ seeds = (unsigned int*) clEnv->library->clEnqueueMapBuffer(queue, clEnv->seeds, CL_TRUE,
CL_MAP_WRITE, 0,
clEnv->numGenerators*4
*sizeof(unsigned int),
randomInfo = DestroyRandomInfo(randomInfo);
}
- clStatus = clEnv->library->clEnqueueUnmapMemObject(queue, clEnv->seeds, seeds, 0,
+ clStatus = clEnv->library->clEnqueueUnmapMemObject(queue, clEnv->seeds, seeds, 0,
NULL, NULL);
clEnv->library->clFinish(queue);
cleanup:
- if (queue != NULL)
+ if (queue != NULL)
RelinquishOpenCLCommandQueue(clEnv, queue);
}
}
UnlockSemaphoreInfo(clEnv->lock);
- return clEnv->seeds;
+ return clEnv->seeds;
}
MagickPrivate void UnlockRandSeedBuffer(MagickCLEnv clEnv) {
/*
* Return the OpenCL environment
-*/
+*/
MagickExport MagickCLEnv GetDefaultOpenCLEnv(
ExceptionInfo *magick_unused(exception))
{
magick_unreferenced(clEnv);
return (MagickCLEnv) NULL;
-}
+}
MagickExport MagickBooleanType SetMagickOpenCLEnvParam(
MagickCLEnv magick_unused(clEnv),MagickOpenCLEnvParam magick_unused(param),
MagickPrivate
MagickBooleanType OpenCLThrowMagickException(ExceptionInfo *exception,
const char *module,const char *function,const size_t line,
- const ExceptionType severity,const char *tag,const char *format,...)
+ const ExceptionType severity,const char *tag,const char *format,...)
{
magick_unreferenced(exception);
magick_unreferenced(module);
char *temp = NULL;
struct stat attributes;
MagickBooleanType status;
+ int mkdirStatus = 0;
home=GetEnvironmentValue("MAGICK_OPENCL_CACHE_DIR");
if (home == (char *) NULL)
{
-#ifdef MAGICKCORE_WINDOWS_SUPPORT
- home=GetEnvironmentValue("LOCALAPPDATA");
+ home=GetEnvironmentValue("XDG_CACHE_HOME");
+ if (home == (char *) NULL)
+ home=GetEnvironmentValue("LOCALAPPDATA");
if (home == (char *) NULL)
home=GetEnvironmentValue("APPDATA");
if (home == (char *) NULL)
home=GetEnvironmentValue("USERPROFILE");
-#else
- home=GetEnvironmentValue("HOME");
-#endif
}
-
+
if (home != (char *) NULL)
{
- int mkdirStatus = 0;
- /*
- */
-
- /* first check if $HOME/.cache exists */
- (void) FormatLocaleString(path,MagickPathExtent,"%s%s.cache",
- home,DirectorySeparator);
+ /* first check if $HOME exists */
+ (void) FormatLocaleString(path,MagickPathExtent,"%s",home);
status=GetPathAttributes(path,&attributes);
- if (status == MagickFalse)
+ if (status == MagickFalse)
{
-
+
#ifdef MAGICKCORE_WINDOWS_SUPPORT
mkdirStatus = mkdir(path);
#else
mkdirStatus = mkdir(path, 0777);
#endif
}
-
- /* first check if $HOME/.cache/ImageMagick exists */
- if (mkdirStatus==0)
+
+ /* first check if $HOME/ImageMagick exists */
+ if (mkdirStatus==0)
{
(void) FormatLocaleString(path,MagickPathExtent,
- "%s%s.cache%sImageMagick",home,DirectorySeparator,
- DirectorySeparator);
-
+ "%s%sImageMagick",home,DirectorySeparator);
+
status=GetPathAttributes(path,&attributes);
- if (status == MagickFalse)
+ if (status == MagickFalse)
{
#ifdef MAGICKCORE_WINDOWS_SUPPORT
mkdirStatus = mkdir(path);
CopyMagickString(temp,path,strlen(path)+1);
}
home=DestroyString(home);
+ } else {
+ home=GetEnvironmentValue("HOME");
+ if (home != (char *) NULL)
+ {
+ /* first check if $HOME/.cache exists */
+ (void) FormatLocaleString(path,MagickPathExtent,"%s%s.cache",
+ home,DirectorySeparator);
+ status=GetPathAttributes(path,&attributes);
+ if (status == MagickFalse)
+ {
+
+#ifdef MAGICKCORE_WINDOWS_SUPPORT
+ mkdirStatus = mkdir(path);
+#else
+ mkdirStatus = mkdir(path, 0777);
+#endif
+ }
+
+ /* first check if $HOME/.cache/ImageMagick exists */
+ if (mkdirStatus==0)
+ {
+ (void) FormatLocaleString(path,MagickPathExtent,
+ "%s%s.cache%sImageMagick",home,DirectorySeparator,
+ DirectorySeparator);
+
+ status=GetPathAttributes(path,&attributes);
+ if (status == MagickFalse)
+ {
+#ifdef MAGICKCORE_WINDOWS_SUPPORT
+ mkdirStatus = mkdir(path);
+#else
+ mkdirStatus = mkdir(path, 0777);
+#endif
+ }
+ }
+
+ if (mkdirStatus==0)
+ {
+ temp = (char*)AcquireMagickMemory(strlen(path)+1);
+ CopyMagickString(temp,path,strlen(path)+1);
+ }
+ home=DestroyString(home);
+ }
}
openclCachedFilesDirectory = temp;
}
- UnlockSemaphoreInfo(openclCachedFilesDirectoryLock);
+ UnlockSemaphoreInfo(openclCachedFilesDirectoryLock);
}
return openclCachedFilesDirectory;
}
struct timeval s;
gettimeofday(&s, 0);
timer->_start = (long long)s.tv_sec * (long long)1.0E3 + (long long)s.tv_usec / (long long)1.0E3;
-#endif
+#endif
}
void stopAccelerateTimer(AccelerateTimer* timer) {
}
void resetAccelerateTimer(AccelerateTimer* timer) {
- timer->_clocks = 0;
+ timer->_clocks = 0;
timer->_start = 0;
}
resetAccelerateTimer(timer);
}
-double readAccelerateTimer(AccelerateTimer* timer) {
- return (double)timer->_clocks/(double)timer->_freq;
+double readAccelerateTimer(AccelerateTimer* timer) {
+ return (double)timer->_clocks/(double)timer->_freq;
};
magick_unreferenced(message);
#endif
}
-
-
projects / imagemagick / commitdiff