OpenCL API interface arrangement

Enterprise 2023-08-12 20:29:01 views: null

opencl_tool.c

#include "opencl_tool.h"
#include <math.h>
#include "utils.h"
#include "blas.h"
#include <assert.h>
#include <stdlib.h>
#include <time.h>
extern cl_kernel *clKernel;
/**创建平台、设备、上下文、命令队列、程序对象,对大部分 OpenCL 程序相同。
 */
int CreateTool(cl_platform_id *platform,cl_device_id *device,cl_context *context,
                cl_command_queue *commandQueue,cl_program *program,const char *fileName){
    
    
    cl_int err;
    cl_uint num;
    //获得第一个可用平台
    err=clGetPlatformIDs(1, platform, &num);
    if(err!=CL_SUCCESS||num<=0||platform==NULL){
    
    
        fprintf(stderr,"no platform.\n");
        return -1;
    }
    //获得第一个可用设备
    err=clGetDeviceIDs(*platform, CL_DEVICE_TYPE_GPU, 1, device, &num);
    if(err!=CL_SUCCESS||num<=0||device==NULL){
    
    
        fprintf(stderr,"no device.\n");
        return -1;
    }
    //获得一个上下文
    cl_context_properties properties[]={
    
    
        CL_CONTEXT_PLATFORM,(cl_context_properties)*platform,0
    };
    *context=clCreateContextFromType(properties,CL_DEVICE_TYPE_GPU,NULL,NULL,&err);
    if(err!=CL_SUCCESS||context==NULL){
    
    
        fprintf(stderr,"no context.\n");
        return -1;
    }
    //通过上下文对指定设备构建命令队列
    *commandQueue=clCreateCommandQueue(*context, *device, 0, &err);
    if(err!=CL_SUCCESS||commandQueue==NULL){
    
    
        fprintf(stderr,"no commandQueue.\n");
        return -1;
    }
    //读取内核文件并转换为字符串
    FILE *kernelFile;
    kernelFile=fopen(fileName,"r");
    if(kernelFile==NULL){
    
    
        fprintf(stderr,"kernel file open failed.\n");
        return -1;
    }
    fseek(kernelFile, 0, SEEK_END);
    int fileLen = ftell(kernelFile);
    char *srcStr = (char *) malloc(sizeof(char) * fileLen);
    fseek(kernelFile, 0, SEEK_SET);
    fread(srcStr, fileLen, sizeof(char), kernelFile);
    fclose(kernelFile);
    srcStr[fileLen]='\0';
    //在上下文环境下编译指定内核文件的程序对象
    *program=clCreateProgramWithSource(*context, 1, (const char **)&srcStr, NULL, &err);
    if(err!=CL_SUCCESS||program==NULL){
    
    
        fprintf(stderr,"no program.\n");
        return -1;
    }
    err=clBuildProgram(*program, 0, NULL, NULL,NULL,NULL);
    if(err!=CL_SUCCESS){
    
    
        fprintf(stderr,"can not build program.\n");
        char buildLog[16384];
        clGetProgramBuildInfo(*program,*device,CL_PROGRAM_BUILD_LOG,sizeof(buildLog),
            buildLog,NULL);
        fprintf(stderr,buildLog);
        return -1;
    }
    return 0;
}
//资源释放
void clean(cl_context *context,cl_command_queue *commandQueue,cl_program *program,cl_kernel *kernel)
{
    
    
    if(*commandQueue!=0)
        clReleaseCommandQueue(*commandQueue);
    if(*kernel!=0)
        clReleaseKernel(*kernel);
    if(*program!=0)
        clReleaseProgram(*program);
    if(*context!=0)
        clReleaseContext(*context);
}

void setWorkItemSize(size_t n,size_t global_work_size[3],size_t local_work_size[3]){
    
    

    local_work_size[0] = BLOCK;
    local_work_size[1] = 1;
    local_work_size[2] = 1;

    size_t k = (n-1) / BLOCK + 1;
    size_t x = k;
    size_t y = 1;
    if(x > 65535){
    
    
        x = ceil(sqrt(k));
        y = (n-1)/(x*BLOCK) + 1;
    }
    global_work_size[0] = x*BLOCK;
    global_work_size[1] = y;
    global_work_size[2] = 1;
}

void cl_error(cl_int err,char * funName){
    
    
    if(err!=CL_SUCCESS){
    
    
        fprintf(stderr,funName);
        fprintf(stderr,": opencl error: %d, ",err);
        switch(err){
    
    
            case -1:fprintf(stderr,"CL_DEVICE_NOT_FOUND\n");break;
            case -2:fprintf(stderr,"CL_DEVICE_NOT_AVAILABLE\n");break;
            case -3:fprintf(stderr,"CL_COMPILER_NOT_AVAILABLE\n");break;
            case -4:fprintf(stderr,"CL_MEM_OBJECT_ALLOCATION_FAILURE\n");break;
            case -5:fprintf(stderr,"CL_OUT_OF_RESOURCES\n");break;
            case -6:fprintf(stderr,"CL_OUT_OF_HOST_MEMORY\n");break;
            case -7:fprintf(stderr,"CL_PROFILING_INFO_NOT_AVAILABLE\n");break;
            case -8:fprintf(stderr,"CL_MEM_COPY_OVERLAP\n");break;
            case -9:fprintf(stderr,"CL_IMAGE_FORMAT_MISMATCH\n");break;
            case -10:fprintf(stderr,"CL_IMAGE_FORMAT_NOT_SUPPORTED\n");break;
            case -11:fprintf(stderr,"CL_BUILD_PROGRAM_FAILURE\n");break;
            case -12:fprintf(stderr,"CL_MAP_FAILURE\n");break;
            case -13:fprintf(stderr,"CL_MISALIGNED_SUB_BUFFER_OFFSET\n");break;
            case -14:fprintf(stderr,"CL_EXEC_STATUS_ERROR_FOR_EVENTS_IN_WAIT_LIST\n");break;
            case -30:fprintf(stderr,"CL_INVALID_VALUE\n");break;
            case -31:fprintf(stderr,"CL_INVALID_DEVICE_TYPE\n");break;
            case -32:fprintf(stderr,"CL_INVALID_PLATFORM\n");break;
            case -33:fprintf(stderr,"CL_INVALID_DEVICE\n");break;
            case -34:fprintf(stderr,"CL_INVALID_CONTEXT\n");break;
            case -35:fprintf(stderr,"CL_INVALID_QUEUE_PROPERTIES\n");break;
            case -36:fprintf(stderr,"CL_INVALID_COMMAND_QUEUE\n");break;
            case -37:fprintf(stderr,"CL_INVALID_HOST_PTR\n");break;
            case -38:fprintf(stderr,"CL_INVALID_MEM_OBJECT\n");break;
            case -39:fprintf(stderr,"CL_INVALID_IMAGE_FORMAT_DESCRIPTOR\n");break;
            case -40:fprintf(stderr,"CL_INVALID_IMAGE_SIZE\n");break;
            case -41:fprintf(stderr,"CL_INVALID_SAMPLER\n");break;
            case -42:fprintf(stderr,"CL_INVALID_BINARY\n");break;
            case -43:fprintf(stderr,"CL_INVALID_BUILD_OPTIONS\n");break;
            case -44:fprintf(stderr,"CL_INVALID_PROGRAM\n");break;
            case -45:fprintf(stderr,"CL_INVALID_PROGRAM_EXECUTABLE\n");break;
            case -46:fprintf(stderr,"CL_INVALID_KERNEL_NAME\n");break;
            case -47:fprintf(stderr,"CL_INVALID_KERNEL_DEFINITION\n");break;
            case -48:fprintf(stderr,"CL_INVALID_KERNEL\n");break;
            case -49:fprintf(stderr,"CL_INVALID_ARG_INDEX\n");break;
            case -50:fprintf(stderr,"CL_INVALID_ARG_VALUE\n");break;
            case -51:fprintf(stderr,"CL_INVALID_ARG_SIZE\n");break;
            case -52:fprintf(stderr,"CL_INVALID_KERNEL_ARGS\n");break;
            case -53:fprintf(stderr,"CL_INVALID_WORK_DIMENSION\n");break;
            case -54:fprintf(stderr,"CL_INVALID_WORK_GROUP_SIZE\n");break;
            case -55:fprintf(stderr,"CL_INVALID_WORK_ITEM_SIZE\n");break;
            case -56:fprintf(stderr,"CL_INVALID_GLOBAL_OFFSET\n");break;
            case -57:fprintf(stderr,"CL_INVALID_EVENT_WAIT_LIST\n");break;
            case -58:fprintf(stderr,"CL_INVALID_EVENT\n");break;
            case -59:fprintf(stderr,"CL_INVALID_OPERATION\n");break;
            case -60:fprintf(stderr,"CL_INVALID_GL_OBJECT\n");break;
            case -61:fprintf(stderr,"CL_INVALID_BUFFER_SIZE\n");break;
            case -62:fprintf(stderr,"CL_INVALID_MIP_LEVEL\n");break;
            case -63:fprintf(stderr,"CL_INVALID_GLOBAL_WORK_SIZE\n");break;
            case -64:fprintf(stderr,"CL_INVALID_PROPERTY\n");break;
            default:fprintf(stderr,"unknown error.\n");break;
        }
        exit(-1);
    }
}

cl_mem cl_make_array(float *x, size_t n)
{
    
    
    cl_mem x_cl;
    if(x){
    
    
        x_cl=clCreateBuffer(*clContext,CL_MEM_READ_WRITE|CL_MEM_COPY_HOST_PTR,sizeof(float)*n,x,NULL);
    } else {
    
    
        x_cl=clCreateBuffer(*clContext,CL_MEM_READ_WRITE,sizeof(float)*n,NULL,NULL);
        fill_cl(n, 0, x_cl, 1,0);
    }
    if(!x_cl) error("Cl malloc failed\n");
    return x_cl;
}

void cl_random(cl_mem x_cl, size_t n)
{
    
    
}

float cl_compare(cl_mem x_cl,float *x, size_t n, char *s)
{
    
    
    float *tmp = calloc(n, sizeof(float));
    cl_pull_array(x_cl, tmp, n,0);
    //int i;
    //for(i = 0; i < n; ++i) printf("%f %f\n", tmp[i], x[i]);
    axpy_cpu(n, -1, x, 1, tmp, 1);
    float err = dot_cpu(n, tmp, 1, tmp, 1);
    printf("Error %s: %f\n", s, sqrt(err/n));
    free(tmp);
    return err;
}

cl_mem cl_make_int_array(int *x, size_t n)
{
    
    
    cl_mem x_cl;
    if(x){
    
    
        x_cl=clCreateBuffer(*clContext,CL_MEM_READ_WRITE|CL_MEM_COPY_HOST_PTR,sizeof(int)*n,x,NULL);
    } else {
    
    
        x_cl=clCreateBuffer(*clContext,CL_MEM_READ_WRITE,sizeof(int)*n,NULL,NULL);
    }
    if(!x_cl) error("Cl malloc failed\n");
    return x_cl;
}

void cl_free(cl_mem x_cl)
{
    
    
    clReleaseMemObject(x_cl);
}

void cl_push_array(cl_mem x_cl, float *x, size_t n,int off1)
{
    
    
    size_t size = sizeof(float)*n;
    clEnqueueWriteBuffer(*clCommandQueue,x_cl,CL_TRUE,off1,size,x,0,NULL,NULL);
}

void cl_pull_array(cl_mem x_cl, float *x, size_t n,int off1)
{
    
    
    size_t size = sizeof(float)*n;
    clEnqueueReadBuffer(*clCommandQueue,x_cl,CL_TRUE,off1,size,x,0,NULL,NULL);
}

float cl_mag_array(cl_mem x_cl, size_t n,int off1)
{
    
    
    float *temp = calloc(n, sizeof(float));
    cl_pull_array(x_cl, temp, n,off1);
    float m = mag_array(temp, n);
    free(temp);
    return m;
}

opencl_tool.h

#ifndef OPENCL_TOOL_H
#define OPENCL_TOOL_H

#ifdef OPENCL

#include "CL/cl.h"
#include <stdio.h>
#include <stdlib.h>

extern cl_platform_id *clPlatform;
extern cl_device_id *clDevice;
extern cl_context *clContext;
extern cl_command_queue *clCommandQueue;
extern cl_program *clProgram;
extern cl_kernel *clKernel;
#define BLOCK 512

int CreateTool(cl_platform_id *platform,cl_device_id *device,cl_context *context,
                cl_command_queue *commandQueue,cl_program *program,const char *fileName);

void clean(cl_context *context,cl_command_queue *commandQueue,cl_program *program,cl_kernel *kernel);

void setWorkItemSize(size_t num,size_t global_work_size[3],size_t local_work_size[3]);
void cl_error(cl_int err,char * funName);
cl_mem cl_make_array(float *x, size_t n);
void cl_random(cl_mem x_cl, size_t n);
float cl_compare(cl_mem x_cl,float *x, size_t n, char *s);
cl_mem cl_make_int_array(int *x, size_t n);
void cl_free(cl_mem x_cl);
void cl_push_array(cl_mem x_cl, float *x, size_t n,int off1);
void cl_pull_array(cl_mem x_cl, float *x, size_t n,int off1);
float cl_mag_array(cl_mem x_cl, size_t n,int off1);

#endif

#endif

utils.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <assert.h>
#include <unistd.h>
#include <float.h>
#include <limits.h>
#include <time.h>
#include <sys/time.h>

#include "utils.h"


/*
// old timing. is it better? who knows!!
double get_wall_time()
{
    struct timeval time;
    if (gettimeofday(&time,NULL)){
        return 0;
    }
    return (double)time.tv_sec + (double)time.tv_usec * .000001;
}
*/

double what_time_is_it_now()
{
    
    
    struct timeval time;
    if (gettimeofday(&time,NULL)){
    
    
        return 0;
    }
    return (double)time.tv_sec + (double)time.tv_usec * .000001;
}

int *read_intlist(char *gpu_list, int *ngpus, int d)
{
    
    
    int *gpus = 0;
    if(gpu_list){
    
    
        int len = strlen(gpu_list);
        *ngpus = 1;
        int i;
        for(i = 0; i < len; ++i){
    
    
            if (gpu_list[i] == ',') ++*ngpus;
        }
        gpus = calloc(*ngpus, sizeof(int));
        for(i = 0; i < *ngpus; ++i){
    
    
            gpus[i] = atoi(gpu_list);
            gpu_list = strchr(gpu_list, ',')+1;
        }
    } else {
    
    
        gpus = calloc(1, sizeof(float));
        *gpus = d;
        *ngpus = 1;
    }
    return gpus;
}

int *read_map(char *filename)
{
    
    
    int n = 0;
    int *map = 0;
    char *str;
    FILE *file = fopen(filename, "r");
    if(!file) file_error(filename);
    while((str=fgetl(file))){
    
    
        ++n;
        map = realloc(map, n*sizeof(int));
        map[n-1] = atoi(str);
    }
    return map;
}

void sorta_shuffle(void *arr, size_t n, size_t size, size_t sections)
{
    
    
    size_t i;
    for(i = 0; i < sections; ++i){
    
    
        size_t start = n*i/sections;
        size_t end = n*(i+1)/sections;
        size_t num = end-start;
        shuffle(arr+(start*size), num, size);
    }
}

void shuffle(void *arr, size_t n, size_t size)
{
    
    
    size_t i;
    void *swp = calloc(1, size);
    for(i = 0; i < n-1; ++i){
    
    
        size_t j = i + rand()/(RAND_MAX / (n-i)+1);
        memcpy(swp,          arr+(j*size), size);
        memcpy(arr+(j*size), arr+(i*size), size);
        memcpy(arr+(i*size), swp,          size);
    }
}

int *random_index_order(int min, int max)
{
    
    
    int *inds = calloc(max-min, sizeof(int));
    int i;
    for(i = min; i < max; ++i){
    
    
        inds[i] = i;
    }
    for(i = min; i < max-1; ++i){
    
    
        int swap = inds[i];
        int index = i + rand()%(max-i);
        inds[i] = inds[index];
        inds[index] = swap;
    }
    return inds;
}

void del_arg(int argc, char **argv, int index)
{
    
    
    int i;
    for(i = index; i < argc-1; ++i) argv[i] = argv[i+1];
    argv[i] = 0;
}

int find_arg(int argc, char* argv[], char *arg)
{
    
    
    int i;
    for(i = 0; i < argc; ++i) {
    
    
        if(!argv[i]) continue;
        if(0==strcmp(argv[i], arg)) {
    
    
            del_arg(argc, argv, i);
            return 1;
        }
    }
    return 0;
}

int find_int_arg(int argc, char **argv, char *arg, int def)
{
    
    
    int i;
    for(i = 0; i < argc-1; ++i){
    
    
        if(!argv[i]) continue;
        if(0==strcmp(argv[i], arg)){
    
    
            def = atoi(argv[i+1]);
            del_arg(argc, argv, i);
            del_arg(argc, argv, i);
            break;
        }
    }
    return def;
}

float find_float_arg(int argc, char **argv, char *arg, float def)
{
    
    
    int i;
    for(i = 0; i < argc-1; ++i){
    
    
        if(!argv[i]) continue;
        if(0==strcmp(argv[i], arg)){
    
    
            def = atof(argv[i+1]);
            del_arg(argc, argv, i);
            del_arg(argc, argv, i);
            break;
        }
    }
    return def;
}

char *find_char_arg(int argc, char **argv, char *arg, char *def)
{
    
    
    int i;
    for(i = 0; i < argc-1; ++i){
    
    
        if(!argv[i]) continue;
        if(0==strcmp(argv[i], arg)){
    
    
            def = argv[i+1];
            del_arg(argc, argv, i);
            del_arg(argc, argv, i);
            break;
        }
    }
    return def;
}


char *basecfg(char *cfgfile)
{
    
    
    char *c = cfgfile;
    char *next;
    while((next = strchr(c, '/')))
    {
    
    
        c = next+1;
    }
    c = copy_string(c);
    next = strchr(c, '.');
    if (next) *next = 0;
    return c;
}

int alphanum_to_int(char c)
{
    
    
    return (c < 58) ? c - 48 : c-87;
}
char int_to_alphanum(int i)
{
    
    
    if (i == 36) return '.';
    return (i < 10) ? i + 48 : i + 87;
}

void pm(int M, int N, float *A)
{
    
    
    int i,j;
    for(i =0 ; i < M; ++i){
    
    
        printf("%d ", i+1);
        for(j = 0; j < N; ++j){
    
    
            printf("%2.4f, ", A[i*N+j]);
        }
        printf("\n");
    }
    printf("\n");
}

void find_replace(char *str, char *orig, char *rep, char *output)
{
    
    
    char buffer[4096] = {
    
    0};
    char *p;

    sprintf(buffer, "%s", str);
    if(!(p = strstr(buffer, orig))){
    
      // Is 'orig' even in 'str'?
        sprintf(output, "%s", str);
        return;
    }

    *p = '\0';

    sprintf(output, "%s%s%s", buffer, rep, p+strlen(orig));
}

float sec(clock_t clocks)
{
    
    
    return (float)clocks/CLOCKS_PER_SEC;
}

void top_k(float *a, int n, int k, int *index)
{
    
    
    int i,j;
    for(j = 0; j < k; ++j) index[j] = -1;
    for(i = 0; i < n; ++i){
    
    
        int curr = i;
        for(j = 0; j < k; ++j){
    
    
            if((index[j] < 0) || a[curr] > a[index[j]]){
    
    
                int swap = curr;
                curr = index[j];
                index[j] = swap;
            }
        }
    }
}

void error(const char *s)
{
    
    
    perror(s);
    assert(0);
    exit(-1);
}

unsigned char *read_file(char *filename)
{
    
    
    FILE *fp = fopen(filename, "rb");
    size_t size;

    fseek(fp, 0, SEEK_END); 
    size = ftell(fp);
    fseek(fp, 0, SEEK_SET); 

    unsigned char *text = calloc(size+1, sizeof(char));
    fread(text, 1, size, fp);
    fclose(fp);
    return text;
}

void malloc_error()
{
    
    
    fprintf(stderr, "Malloc error\n");
    exit(-1);
}

void file_error(char *s)
{
    
    
    fprintf(stderr, "Couldn't open file: %s\n", s);
    exit(0);
}

list *split_str(char *s, char delim)
{
    
    
    size_t i;
    size_t len = strlen(s);
    list *l = make_list();
    list_insert(l, s);
    for(i = 0; i < len; ++i){
    
    
        if(s[i] == delim){
    
    
            s[i] = '\0';
            list_insert(l, &(s[i+1]));
        }
    }
    return l;
}

void strip(char *s)
{
    
    
    size_t i;
    size_t len = strlen(s);
    size_t offset = 0;
    for(i = 0; i < len; ++i){
    
    
        char c = s[i];
        if(c==' '||c=='\t'||c=='\n') ++offset;
        else s[i-offset] = c;
    }
    s[len-offset] = '\0';
}

void strip_char(char *s, char bad)
{
    
    
    size_t i;
    size_t len = strlen(s);
    size_t offset = 0;
    for(i = 0; i < len; ++i){
    
    
        char c = s[i];
        if(c==bad) ++offset;
        else s[i-offset] = c;
    }
    s[len-offset] = '\0';
}

void free_ptrs(void **ptrs, int n)
{
    
    
    int i;
    for(i = 0; i < n; ++i) free(ptrs[i]);
    free(ptrs);
}

char *fgetl(FILE *fp)
{
    
    
    if(feof(fp)) return 0; //判断文件是否空
    size_t size = 512;
    char *line = malloc(size*sizeof(char));
    if(!fgets(line, size, fp)){
    
    
        free(line);
        return 0;
    }

    size_t curr = strlen(line);

    while((line[curr-1] != '\n') && !feof(fp)){
    
    
        if(curr == size-1){
    
    
            size *= 2;
            line = realloc(line, size*sizeof(char));
            if(!line) {
    
    
                printf("%ld\n", size);
                malloc_error();
            }
        }
        size_t readsize = size-curr;
        if(readsize > INT_MAX) readsize = INT_MAX-1;
        fgets(&line[curr], readsize, fp);
        curr = strlen(line);
    }
    if(line[curr-1] == '\n') line[curr-1] = '\0';

    return line;
}

int read_int(int fd)
{
    
    
    int n = 0;
    int next = read(fd, &n, sizeof(int));
    if(next <= 0) return -1;
    return n;
}

void write_int(int fd, int n)
{
    
    
    int next = write(fd, &n, sizeof(int));
    if(next <= 0) error("read failed");
}

int read_all_fail(int fd, char *buffer, size_t bytes)
{
    
    
    size_t n = 0;
    while(n < bytes){
    
    
        int next = read(fd, buffer + n, bytes-n);
        if(next <= 0) return 1;
        n += next;
    }
    return 0;
}

int write_all_fail(int fd, char *buffer, size_t bytes)
{
    
    
    size_t n = 0;
    while(n < bytes){
    
    
        size_t next = write(fd, buffer + n, bytes-n);
        if(next <= 0) return 1;
        n += next;
    }
    return 0;
}

void read_all(int fd, char *buffer, size_t bytes)
{
    
    
    size_t n = 0;
    while(n < bytes){
    
    
        int next = read(fd, buffer + n, bytes-n);
        if(next <= 0) error("read failed");
        n += next;
    }
}

void write_all(int fd, char *buffer, size_t bytes)
{
    
    
    size_t n = 0;
    while(n < bytes){
    
    
        size_t next = write(fd, buffer + n, bytes-n);
        if(next <= 0) error("write failed");
        n += next;
    }
}


char *copy_string(char *s)
{
    
    
    char *copy = malloc(strlen(s)+1);
    strncpy(copy, s, strlen(s)+1);
    return copy;
}

list *parse_csv_line(char *line)
{
    
    
    list *l = make_list();
    char *c, *p;
    int in = 0;
    for(c = line, p = line; *c != '\0'; ++c){
    
    
        if(*c == '"') in = !in;
        else if(*c == ',' && !in){
    
    
            *c = '\0';
            list_insert(l, copy_string(p));
            p = c+1;
        }
    }
    list_insert(l, copy_string(p));
    return l;
}

int count_fields(char *line)
{
    
    
    int count = 0;
    int done = 0;
    char *c;
    for(c = line; !done; ++c){
    
    
        done = (*c == '\0');
        if(*c == ',' || done) ++count;
    }
    return count;
}

float *parse_fields(char *line, int n)
{
    
    
    float *field = calloc(n, sizeof(float));
    char *c, *p, *end;
    int count = 0;
    int done = 0;
    for(c = line, p = line; !done; ++c){
    
    
        done = (*c == '\0');
        if(*c == ',' || done){
    
    
            *c = '\0';
            field[count] = strtod(p, &end);
            if(p == c) field[count] = nan("");
            if(end != c && (end != c-1 || *end != '\r')) field[count] = nan(""); //DOS file formats!
            p = c+1;
            ++count;
        }
    }
    return field;
}

float sum_array(float *a, int n)
{
    
    
    int i;
    float sum = 0;
    for(i = 0; i < n; ++i) sum += a[i];
    return sum;
}

float mean_array(float *a, int n)
{
    
    
    return sum_array(a,n)/n;
}

void mean_arrays(float **a, int n, int els, float *avg)
{
    
    
    int i;
    int j;
    memset(avg, 0, els*sizeof(float));
    for(j = 0; j < n; ++j){
    
    
        for(i = 0; i < els; ++i){
    
    
            avg[i] += a[j][i];
        }
    }
    for(i = 0; i < els; ++i){
    
    
        avg[i] /= n;
    }
}

void print_statistics(float *a, int n)
{
    
    
    float m = mean_array(a, n);
    float v = variance_array(a, n);
    printf("MSE: %.6f, Mean: %.6f, Variance: %.6f\n", mse_array(a, n), m, v);
}

float variance_array(float *a, int n)
{
    
    
    int i;
    float sum = 0;
    float mean = mean_array(a, n);
    for(i = 0; i < n; ++i) sum += (a[i] - mean)*(a[i]-mean);
    float variance = sum/n;
    return variance;
}

int constrain_int(int a, int min, int max)
{
    
    
    if (a < min) return min;
    if (a > max) return max;
    return a;
}

float constrain(float min, float max, float a)
{
    
    
    if (a < min) return min;
    if (a > max) return max;
    return a;
}

float dist_array(float *a, float *b, int n, int sub)
{
    
    
    int i;
    float sum = 0;
    for(i = 0; i < n; i += sub) sum += pow(a[i]-b[i], 2);
    return sqrt(sum);
}

float mse_array(float *a, int n)
{
    
    
    int i;
    float sum = 0;
    for(i = 0; i < n; ++i) sum += a[i]*a[i];
    return sqrt(sum/n);
}

void normalize_array(float *a, int n)
{
    
    
    int i;
    float mu = mean_array(a,n);
    float sigma = sqrt(variance_array(a,n));
    for(i = 0; i < n; ++i){
    
    
        a[i] = (a[i] - mu)/sigma;
    }
    mu = mean_array(a,n);
    sigma = sqrt(variance_array(a,n));
}

void translate_array(float *a, int n, float s)
{
    
    
    int i;
    for(i = 0; i < n; ++i){
    
    
        a[i] += s;
    }
}

float mag_array(float *a, int n)
{
    
    
    int i;
    float sum = 0;
    for(i = 0; i < n; ++i){
    
    
        sum += a[i]*a[i];   
    }
    return sqrt(sum);
}

void scale_array(float *a, int n, float s)
{
    
    
    int i;
    for(i = 0; i < n; ++i){
    
    
        a[i] *= s;
    }
}

int sample_array(float *a, int n)
{
    
    
    float sum = sum_array(a, n);
    scale_array(a, n, 1./sum);
    float r = rand_uniform(0, 1);
    int i;
    for(i = 0; i < n; ++i){
    
    
        r = r - a[i];
        if (r <= 0) return i;
    }
    return n-1;
}

int max_int_index(int *a, int n)
{
    
    
    if(n <= 0) return -1;
    int i, max_i = 0;
    int max = a[0];
    for(i = 1; i < n; ++i){
    
    
        if(a[i] > max){
    
    
            max = a[i];
            max_i = i;
        }
    }
    return max_i;
}

int max_index(float *a, int n)
{
    
    
    if(n <= 0) return -1;
    int i, max_i = 0;
    float max = a[0];
    for(i = 1; i < n; ++i){
    
    
        if(a[i] > max){
    
    
            max = a[i];
            max_i = i;
        }
    }
    return max_i;
}

int int_index(int *a, int val, int n)
{
    
    
    int i;
    for(i = 0; i < n; ++i){
    
    
        if(a[i] == val) return i;
    }
    return -1;
}

int rand_int(int min, int max)
{
    
    
    if (max < min){
    
    
        int s = min;
        min = max;
        max = s;
    }
    int r = (rand()%(max - min + 1)) + min;
    return r;
}

// From http://en.wikipedia.org/wiki/Box%E2%80%93Muller_transform
float rand_normal()
{
    
    
    static int haveSpare = 0;
    static double rand1, rand2;

    if(haveSpare)
    {
    
    
        haveSpare = 0;
        return sqrt(rand1) * sin(rand2);
    }

    haveSpare = 1;

    rand1 = rand() / ((double) RAND_MAX);
    if(rand1 < 1e-100) rand1 = 1e-100;
    rand1 = -2 * log(rand1);
    rand2 = (rand() / ((double) RAND_MAX)) * TWO_PI;

    return sqrt(rand1) * cos(rand2);
}

/*
   float rand_normal()
   {
   int n = 12;
   int i;
   float sum= 0;
   for(i = 0; i < n; ++i) sum += (float)rand()/RAND_MAX;
   return sum-n/2.;
   }
 */

size_t rand_size_t()
{
    
    
    return  ((size_t)(rand()&0xff) << 56) | 
        ((size_t)(rand()&0xff) << 48) |
        ((size_t)(rand()&0xff) << 40) |
        ((size_t)(rand()&0xff) << 32) |
        ((size_t)(rand()&0xff) << 24) |
        ((size_t)(rand()&0xff) << 16) |
        ((size_t)(rand()&0xff) << 8) |
        ((size_t)(rand()&0xff) << 0);
}

float rand_uniform(float min, float max)
{
    
    
    if(max < min){
    
    
        float swap = min;
        min = max;
        max = swap;
    }
    return ((float)rand()/RAND_MAX * (max - min)) + min;
}

float rand_scale(float s)
{
    
    
    float scale = rand_uniform(1, s);
    if(rand()%2) return scale;
    return 1./scale;
}

float **one_hot_encode(float *a, int n, int k)
{
    
    
    int i;
    float **t = calloc(n, sizeof(float*));
    for(i = 0; i < n; ++i){
    
    
        t[i] = calloc(k, sizeof(float));
        int index = (int)a[i];
        t[i][index] = 1;
    }
    return t;
}

utils.h

#ifndef UTILS_H
#define UTILS_H
#include <stdio.h>
#include <time.h>
#include "darknet.h"
#include "list.h"

#define TIME(a) \
    do {
      
       \
    double start = what_time_is_it_now(); \
    a; \
    printf("%s took: %f seconds\n", #a, what_time_is_it_now() - start); \
    } while (0)

#define TWO_PI 6.2831853071795864769252866f

double what_time_is_it_now();
void shuffle(void *arr, size_t n, size_t size);
void sorta_shuffle(void *arr, size_t n, size_t size, size_t sections);
void free_ptrs(void **ptrs, int n);
int alphanum_to_int(char c);
char int_to_alphanum(int i);
int read_int(int fd);
void write_int(int fd, int n);
void read_all(int fd, char *buffer, size_t bytes);
void write_all(int fd, char *buffer, size_t bytes);
int read_all_fail(int fd, char *buffer, size_t bytes);
int write_all_fail(int fd, char *buffer, size_t bytes);
void find_replace(char *str, char *orig, char *rep, char *output);
void malloc_error();
void file_error(char *s);
void strip(char *s);
void strip_char(char *s, char bad);
list *split_str(char *s, char delim);
char *fgetl(FILE *fp);
list *parse_csv_line(char *line);
char *copy_string(char *s);
int count_fields(char *line);
float *parse_fields(char *line, int n);
void translate_array(float *a, int n, float s);
float constrain(float min, float max, float a);
int constrain_int(int a, int min, int max);
float rand_scale(float s);
int rand_int(int min, int max);
void mean_arrays(float **a, int n, int els, float *avg);
float dist_array(float *a, float *b, int n, int sub);
float **one_hot_encode(float *a, int n, int k);
float sec(clock_t clocks);
void print_statistics(float *a, int n);
int int_index(int *a, int val, int n);

#endif

Guess you like

Origin blog.csdn.net/qq_38505858/article/details/128386239
Recommended
The number of MaxKB GitHub Stars, an open source knowledge base question and answer system based on large language models, exceeded 5,000!
Ranking
Getting the basic concepts of ROS + catkin Profile
Spring Learning (2) --- Assembling Beans in the IoC Container
js to get the src attribute of the image regularly
STM32 is based on CubeIDE and HAL library basics entry study notes: Bluetooth WIFI STM32 connects to Alibaba Cloud
Short video learning - 3, pandas simple use of pivot_table
Print directory of project configuration log, output log
Understand the difference between vi and vim in Linux in 3 minutes
1 + x certificate Web front-end development HTML5 special exercises
mangodb save and insert the difference
7-1 Family tree processing (50 points) (binary tree solution)
Daily
More
2024-05-13(8)
2024-05-12(28)
2024-05-11(32)
2024-05-10(34)
2024-05-09(32)
2024-05-08(18)
2024-05-07(34)
2024-05-06(6)
2024-05-05(0)
2024-05-04(18)

Code World

© 2018 codetd.com