virtualenv/FFmpeg
1
0
Fork 0
mirror of https://github.com/FFmpeg/FFmpeg.git synced 2024-12-23 12:43:46 +02:00
Code Issues Releases Activity

avutil/opencl: compile kernels separately

Browse Source 
Reviewed-by: Wei Gao <highgod0401@gmail.com>
Signed-off-by: Michael Niedermayer <michaelni@gmx.at>
This commit is contained in:
Lenny Wang 2013-11-03 21:58:09 -06:00 committed by Michael Niedermayer
parent e3f384b428
commit 6682554790
3 changed files with 109 additions and 129 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

193
libavutil/opencl.c
View File

@ -1,7 +1,8 @@
/* /*
* Copyright (C) 2012 Peng Gao <peng@multicorewareinc.com> * Copyright (C) 2012 Peng Gao <peng@multicorewareinc.com>
* Copyright (C) 2012 Li Cao <li@multicorewareinc.com> * Copyright (C) 2012 Li Cao <li@multicorewareinc.com>
* Copyright (C) 2012 Wei Gao <weigao@multicorewareinc.com> * Copyright (C) 2012 Wei Gao <weigao@multicorewareinc.com>
* Copyright (C) 2013 Lenny Wang <lwanghpc@gmail.com>
* *
* This file is part of FFmpeg. * This file is part of FFmpeg.
* *
@ -39,8 +40,6 @@ static pthread_mutex_t atomic_opencl_lock = PTHREAD_MUTEX_INITIALIZER;
#define UNLOCK_OPENCL #define UNLOCK_OPENCL
#endif #endif
#define MAX_KERNEL_NUM 500
#define MAX_KERNEL_CODE_NUM 200 #define MAX_KERNEL_CODE_NUM 200
typedef struct { typedef struct {
@ -61,17 +60,19 @@ typedef struct {
int is_user_created; int is_user_created;
int platform_idx; int platform_idx;
int device_idx; int device_idx;
char *build_options;
cl_platform_id platform_id; cl_platform_id platform_id;
cl_device_type device_type; cl_device_type device_type;
cl_context context; cl_context context;
cl_device_id device_id; cl_device_id device_id;
cl_command_queue command_queue; cl_command_queue command_queue;
#if FF_API_OLD_OPENCL
char *build_options;
int program_count; int program_count;
cl_program programs[MAX_KERNEL_CODE_NUM]; cl_program programs[MAX_KERNEL_CODE_NUM];
int kernel_count;
#endif
int kernel_code_count; int kernel_code_count;
KernelCode kernel_code[MAX_KERNEL_CODE_NUM]; KernelCode kernel_code[MAX_KERNEL_CODE_NUM];
int kernel_count;
AVOpenCLDeviceList device_list; AVOpenCLDeviceList device_list;
} OpenclContext; } OpenclContext;
@ -80,7 +81,9 @@ typedef struct {
static const AVOption opencl_options[] = { static const AVOption opencl_options[] = {
{ "platform_idx", "set platform index value", OFFSET(platform_idx), AV_OPT_TYPE_INT, {.i64=-1}, -1, INT_MAX}, { "platform_idx", "set platform index value", OFFSET(platform_idx), AV_OPT_TYPE_INT, {.i64=-1}, -1, INT_MAX},
{ "device_idx", "set device index value", OFFSET(device_idx), AV_OPT_TYPE_INT, {.i64=-1}, -1, INT_MAX}, { "device_idx", "set device index value", OFFSET(device_idx), AV_OPT_TYPE_INT, {.i64=-1}, -1, INT_MAX},
#if FF_API_OLD_OPENCL
{ "build_options", "build options of opencl", OFFSET(build_options), AV_OPT_TYPE_STRING, {.str="-I."}, CHAR_MIN, CHAR_MAX}, { "build_options", "build options of opencl", OFFSET(build_options), AV_OPT_TYPE_STRING, {.str="-I."}, CHAR_MIN, CHAR_MAX},
#endif
{ NULL } { NULL }
}; };
@ -194,7 +197,7 @@ static void free_device_list(AVOpenCLDeviceList *device_list)
static int get_device_list(AVOpenCLDeviceList *device_list) static int get_device_list(AVOpenCLDeviceList *device_list)
{ {
cl_int status; cl_int status;
int i, j, k, device_num, total_devices_num,ret = 0; int i, j, k, device_num, total_devices_num, ret = 0;
int *devices_num; int *devices_num;
cl_platform_id *platform_ids = NULL; cl_platform_id *platform_ids = NULL;
cl_device_id *device_ids = NULL; cl_device_id *device_ids = NULL;
@ -388,66 +391,72 @@ end:
return ret; return ret;
} }
int av_opencl_create_kernel(AVOpenCLKernelEnv *env, const char *kernel_name) cl_program av_opencl_compile(const char *program_name, const char *build_opts)
{ {
int i;
cl_int status; cl_int status;
int i, ret = 0; int kernel_code_idx = 0;
const char *kernel_source;
size_t kernel_code_len;
char* ptr = NULL;
cl_program program = NULL;
LOCK_OPENCL; LOCK_OPENCL;
if (strlen(kernel_name) + 1 > AV_OPENCL_MAX_KERNEL_NAME_SIZE) { for (i = 0; i < opencl_ctx.kernel_code_count; i++) {
av_log(&opencl_ctx, AV_LOG_ERROR, "Created kernel name %s is too long\n", kernel_name); // identify a program using a unique name within the kernel source
ret = AVERROR(EINVAL); ptr = av_stristr(opencl_ctx.kernel_code[i].kernel_string, program_name);
if (ptr && !opencl_ctx.kernel_code[i].is_compiled) {
kernel_source = opencl_ctx.kernel_code[i].kernel_string;
kernel_code_len = strlen(opencl_ctx.kernel_code[i].kernel_string);
kernel_code_idx = i;
break;
}
}
if (!kernel_source) {
av_log(&opencl_ctx, AV_LOG_ERROR,
"Unable to find OpenCL kernel source '%s'\n", program_name);
goto end; goto end;
} }
if (!env->kernel) {
if (opencl_ctx.kernel_count >= MAX_KERNEL_NUM) { /* create a CL program from kernel source */
av_log(&opencl_ctx, AV_LOG_ERROR, program = clCreateProgramWithSource(opencl_ctx.context, 1, &kernel_source, &kernel_code_len, &status);
"Could not create kernel with name '%s', maximum number of kernels %d already reached\n", if(status != CL_SUCCESS) {
kernel_name, MAX_KERNEL_NUM); av_log(&opencl_ctx, AV_LOG_ERROR,
ret = AVERROR(EINVAL); "Unable to create OpenCL program '%s': %s\n", program_name, av_opencl_errstr(status));
goto end; program = NULL;
} goto end;
if (opencl_ctx.program_count == 0) {
av_log(&opencl_ctx, AV_LOG_ERROR, "Program count of OpenCL is 0, can not create kernel\n");
ret = AVERROR(EINVAL);
goto end;
}
for (i = 0; i < opencl_ctx.program_count; i++) {
env->kernel = clCreateKernel(opencl_ctx.programs[i], kernel_name, &status);
if (status == CL_SUCCESS)
break;
}
if (status != CL_SUCCESS) {
av_log(&opencl_ctx, AV_LOG_ERROR, "Could not create OpenCL kernel: %s\n", av_opencl_errstr(status));
ret = AVERROR_EXTERNAL;
goto end;
}
opencl_ctx.kernel_count++;
env->command_queue = opencl_ctx.command_queue;
av_strlcpy(env->kernel_name, kernel_name, sizeof(env->kernel_name));
} }
status = clBuildProgram(program, 1, &(opencl_ctx.device_id), build_opts, NULL, NULL);
if (status != CL_SUCCESS) {
av_log(&opencl_ctx, AV_LOG_ERROR,
"Compilation failed with OpenCL program: %s\n", program_name);
program = NULL;
goto end;
}
opencl_ctx.kernel_code[kernel_code_idx].is_compiled = 1;
end: end:
UNLOCK_OPENCL; UNLOCK_OPENCL;
return ret; return program;
}
cl_command_queue av_opencl_get_command_queue(void)
{
return opencl_ctx.command_queue;
}
#if FF_API_OLD_OPENCL
int av_opencl_create_kernel(AVOpenCLKernelEnv *env, const char *kernel_name)
{
av_log(&opencl_ctx, AV_LOG_ERROR, "Could not create OpenCL kernel %s, please update libavfilter.\n", kernel_name);
return AVERROR(EINVAL);
} }
void av_opencl_release_kernel(AVOpenCLKernelEnv *env) void av_opencl_release_kernel(AVOpenCLKernelEnv *env)
{ {
cl_int status; av_log(&opencl_ctx, AV_LOG_ERROR, "Could not release OpenCL kernel, please update libavfilter.\n");
LOCK_OPENCL;
if (!env->kernel)
goto end;
status = clReleaseKernel(env->kernel);
if (status != CL_SUCCESS) {
av_log(&opencl_ctx, AV_LOG_ERROR, "Could not release kernel: %s\n",
av_opencl_errstr(status));
}
env->kernel = NULL;
env->command_queue = NULL;
env->kernel_name[0] = 0;
opencl_ctx.kernel_count--;
end:
UNLOCK_OPENCL;
} }
#endif
static int init_opencl_env(OpenclContext *opencl_ctx, AVOpenCLExternalEnv *ext_opencl_env) static int init_opencl_env(OpenclContext *opencl_ctx, AVOpenCLExternalEnv *ext_opencl_env)
{ {
@ -542,49 +551,6 @@ static int init_opencl_env(OpenclContext *opencl_ctx, AVOpenCLExternalEnv *ext_o
return ret; return ret;
} }
static int compile_kernel_file(OpenclContext *opencl_ctx)
{
cl_int status;
int i, kernel_code_count = 0;
const char *kernel_code[MAX_KERNEL_CODE_NUM] = {NULL};
size_t kernel_code_len[MAX_KERNEL_CODE_NUM] = {0};
for (i = 0; i < opencl_ctx->kernel_code_count; i++) {
if (!opencl_ctx->kernel_code[i].is_compiled) {
kernel_code[kernel_code_count] = opencl_ctx->kernel_code[i].kernel_string;
kernel_code_len[kernel_code_count] = strlen(opencl_ctx->kernel_code[i].kernel_string);
opencl_ctx->kernel_code[i].is_compiled = 1;
kernel_code_count++;
}
}
if (!kernel_code_count)
return 0;
/* create a CL program using the kernel source */
opencl_ctx->programs[opencl_ctx->program_count] = clCreateProgramWithSource(opencl_ctx->context,
kernel_code_count,
kernel_code,
kernel_code_len,
&status);
if(status != CL_SUCCESS) {
av_log(opencl_ctx, AV_LOG_ERROR,
"Could not create OpenCL program with source code: %s\n", av_opencl_errstr(status));
return AVERROR_EXTERNAL;
}
if (!opencl_ctx->programs[opencl_ctx->program_count]) {
av_log(opencl_ctx, AV_LOG_ERROR, "Created program is NULL\n");
return AVERROR_EXTERNAL;
}
status = clBuildProgram(opencl_ctx->programs[opencl_ctx->program_count], 1, &(opencl_ctx->device_id),
opencl_ctx->build_options, NULL, NULL);
if (status != CL_SUCCESS) {
av_log(opencl_ctx, AV_LOG_ERROR,
"Could not compile OpenCL kernel: %s\n", av_opencl_errstr(status));
return AVERROR_EXTERNAL;
}
opencl_ctx->program_count++;
return 0;
}
int av_opencl_init(AVOpenCLExternalEnv *ext_opencl_env) int av_opencl_init(AVOpenCLExternalEnv *ext_opencl_env)
{ {
int ret = 0; int ret = 0;
@ -597,18 +563,14 @@ int av_opencl_init(AVOpenCLExternalEnv *ext_opencl_env)
ret = init_opencl_env(&opencl_ctx, ext_opencl_env); ret = init_opencl_env(&opencl_ctx, ext_opencl_env);
if (ret < 0) if (ret < 0)
goto end; goto end;
} if (opencl_ctx.kernel_code_count <= 0) {
ret = compile_kernel_file(&opencl_ctx); av_log(&opencl_ctx, AV_LOG_ERROR,
if (ret < 0) "No kernel code is registered, compile kernel file failed\n");
goto end; ret = AVERROR(EINVAL);
if (opencl_ctx.kernel_code_count <= 0) { goto end;
av_log(&opencl_ctx, AV_LOG_ERROR, }
"No kernel code is registered, compile kernel file failed\n");
ret = AVERROR(EINVAL);
goto end;
} }
opencl_ctx.init_count++; opencl_ctx.init_count++;
end: end:
UNLOCK_OPENCL; UNLOCK_OPENCL;
return ret; return ret;
@ -617,23 +579,12 @@ end:
void av_opencl_uninit(void) void av_opencl_uninit(void)
{ {
cl_int status; cl_int status;
int i;
LOCK_OPENCL; LOCK_OPENCL;
opencl_ctx.init_count--; opencl_ctx.init_count--;
if (opencl_ctx.is_user_created) if (opencl_ctx.is_user_created)
goto end; goto end;
if (opencl_ctx.init_count > 0 || opencl_ctx.kernel_count > 0) if (opencl_ctx.init_count > 0)
goto end; goto end;
for (i = 0; i < opencl_ctx.program_count; i++) {
if (opencl_ctx.programs[i]) {
status = clReleaseProgram(opencl_ctx.programs[i]);
if (status != CL_SUCCESS) {
av_log(&opencl_ctx, AV_LOG_ERROR,
"Could not release OpenCL program: %s\n", av_opencl_errstr(status));
}
opencl_ctx.programs[i] = NULL;
}
}
if (opencl_ctx.command_queue) { if (opencl_ctx.command_queue) {
status = clReleaseCommandQueue(opencl_ctx.command_queue); status = clReleaseCommandQueue(opencl_ctx.command_queue);
if (status != CL_SUCCESS) { if (status != CL_SUCCESS) {
@ -652,7 +603,7 @@ void av_opencl_uninit(void)
} }
free_device_list(&opencl_ctx.device_list); free_device_list(&opencl_ctx.device_list);
end: end:
if ((opencl_ctx.init_count <= 0) && (opencl_ctx.kernel_count <= 0)) if (opencl_ctx.init_count <= 0)
av_opt_free(&opencl_ctx); //FIXME: free openclutils context av_opt_free(&opencl_ctx); //FIXME: free openclutils context
UNLOCK_OPENCL; UNLOCK_OPENCL;
} }

40
libavutil/opencl.h
View File

@ -1,7 +1,8 @@
/* /*
* Copyright (C) 2012 Peng Gao <peng@multicorewareinc.com> * Copyright (C) 2012 Peng Gao <peng@multicorewareinc.com>
* Copyright (C) 2012 Li Cao <li@multicorewareinc.com> * Copyright (C) 2012 Li Cao <li@multicorewareinc.com>
* Copyright (C) 2012 Wei Gao <weigao@multicorewareinc.com> * Copyright (C) 2012 Wei Gao <weigao@multicorewareinc.com>
* Copyright (C) 2013 Lenny Wang <lwanghpc@gmail.com>
* *
* This file is part of FFmpeg. * This file is part of FFmpeg.
* *
@ -39,6 +40,8 @@
#endif #endif
#include "dict.h" #include "dict.h"
#include "libavutil/version.h"
#define AV_OPENCL_KERNEL( ... )# __VA_ARGS__ #define AV_OPENCL_KERNEL( ... )# __VA_ARGS__
#define AV_OPENCL_MAX_KERNEL_NAME_SIZE 150 #define AV_OPENCL_MAX_KERNEL_NAME_SIZE 150
@ -65,11 +68,13 @@ typedef struct {
AVOpenCLPlatformNode **platform_node; AVOpenCLPlatformNode **platform_node;
} AVOpenCLDeviceList; } AVOpenCLDeviceList;
#if FF_API_OLD_OPENCL
typedef struct { typedef struct {
cl_command_queue command_queue; cl_command_queue command_queue;
cl_kernel kernel; cl_kernel kernel;
char kernel_name[AV_OPENCL_MAX_KERNEL_NAME_SIZE]; char kernel_name[AV_OPENCL_MAX_KERNEL_NAME_SIZE];
} AVOpenCLKernelEnv; } AVOpenCLKernelEnv;
#endif
typedef struct { typedef struct {
cl_platform_id platform_id; cl_platform_id platform_id;
@ -107,7 +112,6 @@ void av_opencl_free_device_list(AVOpenCLDeviceList **device_list);
* av_opencl_init() operation. * av_opencl_init() operation.
* *
* The currently accepted options are: * The currently accepted options are:
* - build_options: set options to compile registered kernels code
* - platform: set index of platform in device list * - platform: set index of platform in device list
* - device: set index of device in device list * - device: set index of device in device list
* *
@ -174,15 +178,15 @@ const char *av_opencl_errstr(cl_int status);
int av_opencl_register_kernel_code(const char *kernel_code); int av_opencl_register_kernel_code(const char *kernel_code);
/** /**
* Initialize the run time OpenCL environment and compile the kernel * Initialize the run time OpenCL environment
* code registered with av_opencl_register_kernel_code().
* *
* @param ext_opencl_env external OpenCL environment, created by an * @param ext_opencl_env external OpenCL environment, created by an
* application program, ignored if set to NULL * application program, ignored if set to NULL
* @return >=0 on success, a negative error code in case of failure * @return >=0 on success, a negative error code in case of failure
*/ */
int av_opencl_init(AVOpenCLExternalEnv *ext_opencl_env); int av_opencl_init(AVOpenCLExternalEnv *ext_opencl_env);
#if FF_API_OLD_OPENCL
/** /**
* Create kernel object in the specified kernel environment. * Create kernel object in the specified kernel environment.
* *
@ -190,8 +194,27 @@ int av_opencl_register_kernel_code(const char *kernel_code);
* the environment used to run the kernel * the environment used to run the kernel
* @param kernel_name kernel function name * @param kernel_name kernel function name
* @return >=0 on success, a negative error code in case of failure * @return >=0 on success, a negative error code in case of failure
* @deprecated, use clCreateKernel
*/ */
int av_opencl_create_kernel(AVOpenCLKernelEnv *env, const char *kernel_name); int av_opencl_create_kernel(AVOpenCLKernelEnv *env, const char *kernel_name);
#endif
/**
* compile specific OpenCL kernel source
*
* @param program_name pointer to a program name used for identification
* @param build_opts pointer to a string that describes the preprocessor
* build options to be used for building the program
* @return a cl_program object
*/
cl_program av_opencl_compile(const char *program_name, const char* build_opts);
/**
* get OpenCL command queue
*
* @return a cl_command_queue object
*/
cl_command_queue av_opencl_get_command_queue(void);
/** /**
* Create OpenCL buffer. * Create OpenCL buffer.
@ -268,13 +291,16 @@ int av_opencl_buffer_read_image(uint8_t **dst_data, int *plane_size, int plane_n
*/ */
void av_opencl_buffer_release(cl_mem *cl_buf); void av_opencl_buffer_release(cl_mem *cl_buf);
#if FF_API_OLD_OPENCL
/** /**
* Release kernel object. * Release kernel object.
* *
* @param env kernel environment where the kernel object was created * @param env kernel environment where the kernel object was created
* with av_opencl_create_kernel() * with av_opencl_create_kernel()
* @deprecated, use clReleaseKernel
*/ */
void av_opencl_release_kernel(AVOpenCLKernelEnv *env); void av_opencl_release_kernel(AVOpenCLKernelEnv *env);
#endif
/** /**
* Release OpenCL environment. * Release OpenCL environment.

5
libavutil/version.h
View File

@ -75,7 +75,7 @@
*/ */
#define LIBAVUTIL_VERSION_MAJOR 52 #define LIBAVUTIL_VERSION_MAJOR 52
#define LIBAVUTIL_VERSION_MINOR 51 #define LIBAVUTIL_VERSION_MINOR 52
#define LIBAVUTIL_VERSION_MICRO 100 #define LIBAVUTIL_VERSION_MICRO 100
#define LIBAVUTIL_VERSION_INT AV_VERSION_INT(LIBAVUTIL_VERSION_MAJOR, \ #define LIBAVUTIL_VERSION_INT AV_VERSION_INT(LIBAVUTIL_VERSION_MAJOR, \
@ -141,6 +141,9 @@
#ifndef FF_API_GET_CHANNEL_LAYOUT_COMPAT #ifndef FF_API_GET_CHANNEL_LAYOUT_COMPAT
#define FF_API_GET_CHANNEL_LAYOUT_COMPAT (LIBAVUTIL_VERSION_MAJOR < 53) #define FF_API_GET_CHANNEL_LAYOUT_COMPAT (LIBAVUTIL_VERSION_MAJOR < 53)
#endif #endif
#ifndef FF_API_OLD_OPENCL
#define FF_API_OLD_OPENCL (LIBAVUTIL_VERSION_MAJOR < 53)
#endif
/** /**
* @} * @}