/*! \brief Releases a list of OpenCL kernel pointers */
static void free_kernels(cl_kernel *kernels, int count)
{
int i;
for (i = 0; i < count; i++)
{
free_kernel(kernels + i);
}
}
static void free_subharminfo(subharminfo * shi)
{
int ii;
for (ii = 0; ii < shi->numkern; ii++)
free_kernel(&shi->kern[ii]);
if (shi->numharm > 1)
free(shi->rinds);
free(shi->kern);
}
/* ----------------------------------------------------------------------------------------------------------- */
void routine_smooth_filter(char *src_path, char *noise_path, char *filename0, char *filename, char *denoise_path)
/* ----------------------------------------------------------------------------------------------------------- */
{
char complete_filename[1024];
char *sep;
int k;
float32 sigma;
int radius;
int ndigit;
long i0, i1, j0, j1;
uint8 **X0, **X, **Y;
float32 **K;
float32 p;
// chargement de l'image bruitee dans X, et de l'image sans bruit dans X0
// Y doit contenir l'image traitee
generate_path_filename_extension(src_path, filename0, "pgm", complete_filename); puts(complete_filename);
X0 = LoadPGM_ui8matrix(complete_filename, &i0, &i1, &j0, &j1);
generate_path_filename_extension(noise_path, filename, "pgm", complete_filename); puts(complete_filename);
X = LoadPGM_ui8matrix(complete_filename, &i0, &i1, &j0, &j1);
Y = ui8matrix(i0, i1, j0, j1);
// ---------------------
// -- gaussian kernel --
// ---------------------
sep = "_G_";
ndigit = 2; // codage sur 2 chiffre de la valeur de sigma dans le nom du fichier
sigma = 0.5; // parametre du bloc de code
k = (int) (10*sigma); // code
radius = (int) ceil(2*sigma+1);
printf("sigma = %.1f -> radius = %d\n", sigma, radius);
K = alloc_kernel(radius);
init_gaussian_kernel(K, radius, sigma);
convolve_kernel_ui8matrix(X, i0, i1, j0, j1, K, radius, Y);
p = psnr(X0, i0, i1, j0, j1, Y);
generate_path_filename_sep_k_ndigit_extension(denoise_path, filename, sep, k, ndigit, "pgm", complete_filename);
printf("%s -> PSNR = %8.2f db\n", complete_filename, p);
SavePGM_ui8matrix(Y, i0, i1, j0, j1, complete_filename);
free_kernel(K, radius);
// -----------------
// -- average kernel
// -----------------
sep = "_A_";
ndigit = 1; // codage sur 1 chiffre de la valeur de radius dans le nom du fichier
radius = 1; // parametre du bloc de code
k = radius; // code
K = alloc_kernel(radius);
init_average_kernel(K, radius);
convolve_kernel_ui8matrix(X, i0, i1, j0, j1, K, radius, Y);
p = psnr(X0, i0, i1, j0, j1, Y);
generate_path_filename_sep_k_ndigit_extension(denoise_path, filename, sep, k, ndigit, "pgm", complete_filename);
printf("%s -> PSNR = %8.2f db\n", complete_filename, p);
SavePGM_ui8matrix(Y, i0, i1, j0, j1, complete_filename);
free_kernel(K, radius);
// liberation de la memoire
free_ui8matrix(X0, i0, i1, j0, j1);
free_ui8matrix(X, i0, i1, j0, j1);
free_ui8matrix(Y, i0, i1, j0, j1);
}
/* call as model = mexsvmlearn(data,labels,options) */
void mexFunction(int nlhs, mxArray *plhs[],
int nrhs, const mxArray *prhs[])
{
char **argv;
int argc;
DOC **docs; /* training examples */
long totwords,totdoc,i;
double *target;
double *alpha_in=NULL;
KERNEL_CACHE *kernel_cache;
LEARN_PARM learn_parm;
KERNEL_PARM kernel_parm;
MODEL model;
/* check for valid calling format */
if ((nrhs != 3) || (nlhs != 1))
mexErrMsgTxt(ERR001);
if (mxGetM(prhs[0]) != mxGetM(prhs[1]))
mexErrMsgTxt(ERR002);
if (mxGetN(prhs[1]) != 1)
mexErrMsgTxt(ERR003);
/* reset static variables -- as a .DLL, static things are sticky */
global_init( );
/* convert the parameters (given in prhs[2]) into an argv/argc combination */
argv = make_argv((mxArray *)prhs[2],&argc); /* send the options */
/* this was originally supposed to be argc, argv, re-written for MATLAB ...
its cheesy - but it workss :: convert the options array into an argc,
argv pair and let svm_lite handle it from there. */
read_input_parameters(argc,argv,docfile,modelfile,restartfile,&verbosity,
&learn_parm,&kernel_parm);
extract_user_opts((mxArray *)prhs[2], &kernel_parm);
totdoc = mxGetM(prhs[0]);
totwords = mxGetN(prhs[0]);
/* prhs[0] = samples (mxn) array
prhs[1] = labels (mx1) array */
mexToDOC((mxArray *)prhs[0], (mxArray *)prhs[1], &docs, &target, NULL, NULL);
/* TODO modify to accept this array
if(restartfile[0]) alpha_in=read_alphas(restartfile,totdoc); */
if(kernel_parm.kernel_type == LINEAR) { /* don't need the cache */
kernel_cache=NULL;
}
else {
/* Always get a new kernel cache. It is not possible to use the
same cache for two different training runs */
kernel_cache=kernel_cache_init(totdoc,learn_parm.kernel_cache_size);
}
if(learn_parm.type == CLASSIFICATION) {
svm_learn_classification(docs,target,totdoc,totwords,&learn_parm,
&kernel_parm,kernel_cache,&model,alpha_in);
}
else if(learn_parm.type == REGRESSION) {
svm_learn_regression(docs,target,totdoc,totwords,&learn_parm,
&kernel_parm,&kernel_cache,&model);
}
else if(learn_parm.type == RANKING) {
svm_learn_ranking(docs,target,totdoc,totwords,&learn_parm,
&kernel_parm,&kernel_cache,&model);
}
else if(learn_parm.type == OPTIMIZATION) {
svm_learn_optimization(docs,target,totdoc,totwords,&learn_parm,
&kernel_parm,kernel_cache,&model,alpha_in);
}
else {
mexErrMsgTxt(ERR004);
}
if(kernel_cache) {
/* Free the memory used for the cache. */
kernel_cache_cleanup(kernel_cache);
}
/* **********************************
* After the training/learning portion has finished,
* copy the model back to the output arrays for MATLAB
* ********************************** */
store_model(&model, plhs);
free_kernel();
global_destroy( );
}
//! This function is documented in the header file
void nbnxn_gpu_free(gmx_nbnxn_ocl_t *nb)
{
if (nb == nullptr)
{
return;
}
/* Free kernels */
int kernel_count = sizeof(nb->kernel_ener_noprune_ptr) / sizeof(nb->kernel_ener_noprune_ptr[0][0]);
free_kernels(nb->kernel_ener_noprune_ptr[0], kernel_count);
kernel_count = sizeof(nb->kernel_ener_prune_ptr) / sizeof(nb->kernel_ener_prune_ptr[0][0]);
free_kernels(nb->kernel_ener_prune_ptr[0], kernel_count);
kernel_count = sizeof(nb->kernel_noener_noprune_ptr) / sizeof(nb->kernel_noener_noprune_ptr[0][0]);
free_kernels(nb->kernel_noener_noprune_ptr[0], kernel_count);
kernel_count = sizeof(nb->kernel_noener_prune_ptr) / sizeof(nb->kernel_noener_prune_ptr[0][0]);
free_kernels(nb->kernel_noener_prune_ptr[0], kernel_count);
free_kernel(&(nb->kernel_zero_e_fshift));
/* Free atdat */
freeDeviceBuffer(&(nb->atdat->xq));
freeDeviceBuffer(&(nb->atdat->f));
freeDeviceBuffer(&(nb->atdat->e_lj));
freeDeviceBuffer(&(nb->atdat->e_el));
freeDeviceBuffer(&(nb->atdat->fshift));
freeDeviceBuffer(&(nb->atdat->lj_comb));
freeDeviceBuffer(&(nb->atdat->atom_types));
freeDeviceBuffer(&(nb->atdat->shift_vec));
sfree(nb->atdat);
/* Free nbparam */
freeDeviceBuffer(&(nb->nbparam->nbfp_climg2d));
freeDeviceBuffer(&(nb->nbparam->nbfp_comb_climg2d));
freeDeviceBuffer(&(nb->nbparam->coulomb_tab_climg2d));
sfree(nb->nbparam);
/* Free plist */
auto *plist = nb->plist[eintLocal];
freeDeviceBuffer(&plist->sci);
freeDeviceBuffer(&plist->cj4);
freeDeviceBuffer(&plist->imask);
freeDeviceBuffer(&plist->excl);
sfree(plist);
if (nb->bUseTwoStreams)
{
auto *plist_nl = nb->plist[eintNonlocal];
freeDeviceBuffer(&plist_nl->sci);
freeDeviceBuffer(&plist_nl->cj4);
freeDeviceBuffer(&plist_nl->imask);
freeDeviceBuffer(&plist_nl->excl);
sfree(plist_nl);
}
/* Free nbst */
pfree(nb->nbst.e_lj);
nb->nbst.e_lj = nullptr;
pfree(nb->nbst.e_el);
nb->nbst.e_el = nullptr;
pfree(nb->nbst.fshift);
nb->nbst.fshift = nullptr;
/* Free command queues */
clReleaseCommandQueue(nb->stream[eintLocal]);
nb->stream[eintLocal] = nullptr;
if (nb->bUseTwoStreams)
{
clReleaseCommandQueue(nb->stream[eintNonlocal]);
nb->stream[eintNonlocal] = nullptr;
}
/* Free other events */
if (nb->nonlocal_done)
{
clReleaseEvent(nb->nonlocal_done);
nb->nonlocal_done = nullptr;
}
if (nb->misc_ops_and_local_H2D_done)
{
clReleaseEvent(nb->misc_ops_and_local_H2D_done);
nb->misc_ops_and_local_H2D_done = nullptr;
}
free_gpu_device_runtime_data(nb->dev_rundata);
sfree(nb->dev_rundata);
/* Free timers and timings */
delete nb->timers;
sfree(nb->timings);
sfree(nb);
if (debug)
{
fprintf(debug, "Cleaned up OpenCL data structures.\n");
}
}
