HAP_compute_res.h

Go to the documentation of this file.

/*-----------------------------------------------------------------------------
   Copyright (c) 2019-2020-2022,2024 QUALCOMM Technologies, Incorporated.
   All Rights Reserved.
   QUALCOMM Proprietary.
-----------------------------------------------------------------------------*/

#ifndef HAP_COMPUTE_RES_H_
#define HAP_COMPUTE_RES_H_

#ifdef __cplusplus
extern "C" {
#endif

#define HAP_COMPUTE_RES_NOT_SUPPORTED                           0x80000404

#define HAP_COMPUTE_RES_MAX_NUM_THREADS                         16

typedef struct {
    unsigned long long attributes[8]; 
} compute_res_attr_t;

typedef struct {
    unsigned int page_size;  
    unsigned int num_pages;  
} compute_res_vtcm_page_def_t;

typedef struct {
    unsigned int block_size;           
    unsigned int page_list_len;      
    compute_res_vtcm_page_def_t page_list[8];  
} compute_res_vtcm_page_t;

typedef enum {
    HAP_COMPUTE_RES_HMX_NON_SHARED = 0,      
    HAP_COMPUTE_RES_HMX_SHARED = 1,          
} compute_res_hmx_type_t;

typedef enum {
    HAP_COMPUTE_RES_PREEMPTION_CAPABILITY = 1,  
} compute_res_capability_id;

#define HAP_COMPUTE_RES_COOPERATIVE_PREEMPTION                  1

#define HAP_COMPUTE_RES_AUTONOMOUS_PREEMPTION                   2

#define HAP_COMPUTE_RES_THREADS_FOR_AUTONOMOUS_PREEMPTION       4

typedef enum {
    HAP_COMPUTE_RES_THREADS_OVERRIDE = 1,
    HAP_COMPUTE_RES_THREADS_APPEND = 2,
    HAP_COMPUTE_RES_THREADS_REMOVE = 3,
} compute_res_threads_cmd_id;

typedef struct {
    void *mutex;
    void (*lock)(void *mutex);
    void (*unlock)(void *mutex);
} compute_res_hmx_mutex_t;

typedef struct {
    unsigned int num_preemptions;
    unsigned long long preempted_duration;
    unsigned long long preemption_overhead;
} compute_res_preempt_data_t;

int __attribute__((weak)) compute_resource_attr_init(
                                        compute_res_attr_t* attr);

int __attribute__((weak)) compute_resource_attr_set_serialize(
                                        compute_res_attr_t* attr,
                                        unsigned char b_enable);

int __attribute__((weak)) compute_resource_attr_set_hmx_param(
                                        compute_res_attr_t* attr,
                                        unsigned char b_enable);

int __attribute__((weak)) compute_resource_attr_set_vtcm_param(
                                        compute_res_attr_t* attr,
                                        unsigned int vtcm_size,
                                        unsigned char b_single_page);

int __attribute__((weak)) compute_resource_attr_set_vtcm_param_v2(
                                        compute_res_attr_t* attr,
                                        unsigned int vtcm_size,
                                        unsigned int min_page_size,
                                        unsigned int min_vtcm_size);

int __attribute__((weak)) compute_resource_attr_set_app_type(
                                        compute_res_attr_t* attr,
                                        unsigned int application_id);

int __attribute__((weak)) compute_resource_attr_set_cache_mode(
                                        compute_res_attr_t* attr,
                                        unsigned char b_enable);

int __attribute__((weak)) compute_resource_attr_set_release_callback(
                                        compute_res_attr_t* attr,
                                        int (*release_callback)(
                                            unsigned int context_id,
                                            void* client_context),
                                        void* client_context);

void* __attribute__((weak)) compute_resource_attr_get_vtcm_ptr(
                                        compute_res_attr_t* attr);

int __attribute__((weak)) compute_resource_attr_get_vtcm_ptr_v2(
                                        compute_res_attr_t* attr,
                                        void** vtcm_ptr,
                                        unsigned int* vtcm_size);

int __attribute__((weak)) compute_resource_query_VTCM(
                                unsigned int application_id,
                                unsigned int* total_block_size,
                                compute_res_vtcm_page_t* total_block_layout,
                                unsigned int* avail_block_size,
                                compute_res_vtcm_page_t* avail_block_layout);

unsigned int __attribute__((weak)) compute_resource_acquire(
                                        compute_res_attr_t* attr,
                                        unsigned int timeout_us);

int __attribute__((weak)) compute_resource_release(
                                        unsigned int context_id);

int __attribute__((weak)) compute_resource_acquire_cached(
                                        unsigned int context_id,
                                        unsigned int timeout_us);

int __attribute__((weak)) compute_resource_release_cached(
                                        unsigned int context_id);

int __attribute__((weak)) compute_resource_hmx_lock(
                                        unsigned int context_id);

int __attribute__((weak)) compute_resource_hmx_unlock(
                                        unsigned int context_id);

int __attribute__((weak)) compute_resource_check_release_request(
                                        unsigned int context_id);

int __attribute__((weak)) compute_resource_hmx_lock2(
                                        unsigned int context_id,
                                        compute_res_hmx_type_t type);

int __attribute__((weak)) compute_resource_hmx_unlock2(
                                        unsigned int context_id,
                                        compute_res_hmx_type_t type);

int __attribute__((weak)) compute_resource_update_priority(
                                        unsigned int context_id,
                                        unsigned short priority);

int __attribute__((weak)) crm_hmx_lock3(unsigned int context_id,
                                        compute_res_hmx_type_t type,
                                        compute_res_hmx_mutex_t *mutex,
                                        unsigned int timeout_us);

int __attribute__((weak)) crm_hmx_unlock3(unsigned int context_id,
                                          compute_res_hmx_type_t type,
                                          compute_res_hmx_mutex_t *mutex);

int __attribute__ ((weak)) crm_attr_set_vtcm_backup(
                                        compute_res_attr_t* attr,
                                        void *buffer,
                                        unsigned int buffer_size);

int __attribute__ ((weak)) crm_attr_set_threads(
                                        compute_res_attr_t* attr,
                                        unsigned int *threads,
                                        unsigned int num_threads);

int __attribute__ ((weak)) crm_attr_set_vtcm_clear_on_release(
                                        compute_res_attr_t* attr,
                                        unsigned char enable);

int __attribute__ ((weak)) crm_cached_set_threads(compute_res_threads_cmd_id command,
                                                  unsigned int context_id,
                                                  unsigned int *threads,
                                                  unsigned int num_threads);

int __attribute__((weak)) crm_query_capability(compute_res_capability_id capability_id,
                                               unsigned int* data);

int __attribute__((weak)) crm_get_preempt_data(unsigned int context_id,
                                                 compute_res_preempt_data_t *data);

int __attribute__((weak)) crm_tid_preemption_lock(void);

int __attribute__((weak)) crm_tid_preemption_unlock(void);
static inline int HAP_compute_res_attr_init(compute_res_attr_t* attr)
{
    if (compute_resource_attr_init)
        return compute_resource_attr_init(attr);

    return HAP_COMPUTE_RES_NOT_SUPPORTED;
}

static inline int HAP_compute_res_attr_set_serialize(
                                                compute_res_attr_t* attr,
                                                unsigned char b_serialize)
{
    if (compute_resource_attr_set_serialize)
    {
        return compute_resource_attr_set_serialize(attr,
                                                   b_serialize);
    }

    return HAP_COMPUTE_RES_NOT_SUPPORTED;
}

static inline int HAP_compute_res_attr_set_vtcm_param(
                                             compute_res_attr_t* attr,
                                             unsigned int vtcm_size,
                                             unsigned char b_single_page)
{
    if (compute_resource_attr_set_vtcm_param)
    {
        return compute_resource_attr_set_vtcm_param(attr,
                                                    vtcm_size,
                                                    b_single_page);
    }

    return HAP_COMPUTE_RES_NOT_SUPPORTED;
}

static inline void* HAP_compute_res_attr_get_vtcm_ptr(compute_res_attr_t* attr)
{
    if (compute_resource_attr_get_vtcm_ptr)
    {
        return compute_resource_attr_get_vtcm_ptr(attr);
    }

    return 0;
}

static inline int HAP_compute_res_attr_set_vtcm_param_v2(
                                             compute_res_attr_t* attr,
                                             unsigned int vtcm_size,
                                             unsigned int min_page_size,
                                             unsigned int min_vtcm_size)
{
    if (compute_resource_attr_set_vtcm_param_v2)
    {
        return compute_resource_attr_set_vtcm_param_v2(attr,
                                                       vtcm_size,
                                                       min_page_size,
                                                       min_vtcm_size);
    }

    return HAP_COMPUTE_RES_NOT_SUPPORTED;
}

static inline int HAP_compute_res_attr_set_vtcm_backup(
                                            compute_res_attr_t* attr,
                                            void *buffer,
                                            unsigned int buffer_size)
{
    if (crm_attr_set_vtcm_backup)
    {
        return crm_attr_set_vtcm_backup(attr, buffer, buffer_size);
    }

    return HAP_COMPUTE_RES_NOT_SUPPORTED;
}

static inline int HAP_compute_res_attr_set_threads(
                                            compute_res_attr_t* attr,
                                            unsigned int *threads,
                                            unsigned int num_threads)
{
    if (crm_attr_set_threads)
    {
        return crm_attr_set_threads(attr, threads, num_threads);
    }

    return HAP_COMPUTE_RES_NOT_SUPPORTED;
}

static inline int HAP_compute_res_cached_set_threads(compute_res_threads_cmd_id command,
                                                     unsigned int context_id,
                                                     unsigned int *threads,
                                                     unsigned int num_threads)
{
    if (crm_cached_set_threads)
    {
        return crm_cached_set_threads(command, context_id, threads, num_threads);
    }

    return HAP_COMPUTE_RES_NOT_SUPPORTED;
}

static inline int HAP_compute_res_attr_set_vtcm_clear_on_release(
                                            compute_res_attr_t* attr,
                                            unsigned char enable)
{
    if (crm_attr_set_vtcm_clear_on_release)
    {
        return crm_attr_set_vtcm_clear_on_release(attr, enable);
    }

    return HAP_COMPUTE_RES_NOT_SUPPORTED;
}

static inline int HAP_compute_res_attr_get_vtcm_ptr_v2(
                                        compute_res_attr_t* attr,
                                        void** vtcm_ptr,
                                        unsigned int* vtcm_size)
{
    if (compute_resource_attr_get_vtcm_ptr_v2)
    {
        return compute_resource_attr_get_vtcm_ptr_v2(attr,
                                                     vtcm_ptr,
                                                     vtcm_size);
    }

    return HAP_COMPUTE_RES_NOT_SUPPORTED;
}

static inline int HAP_compute_res_attr_set_hmx_param(
                                                compute_res_attr_t* attr,
                                                unsigned char b_enable)
{
    if (compute_resource_attr_set_hmx_param)
    {
        return compute_resource_attr_set_hmx_param(attr,
                                                   b_enable);
    }

    return HAP_COMPUTE_RES_NOT_SUPPORTED;
}

static inline int HAP_compute_res_attr_set_cache_mode(
                                              compute_res_attr_t* attr,
                                              unsigned char b_enable)
{
    if (compute_resource_attr_set_cache_mode)
    {
        return compute_resource_attr_set_cache_mode(attr,
                                                    b_enable);
    }

    return HAP_COMPUTE_RES_NOT_SUPPORTED;
}

static inline int HAP_compute_res_attr_set_app_type(
                                              compute_res_attr_t* attr,
                                              unsigned int application_id)
{
    if (compute_resource_attr_set_app_type)
    {
        return compute_resource_attr_set_app_type(attr,
                                                  application_id);
    }

    return HAP_COMPUTE_RES_NOT_SUPPORTED;
}

static inline int HAP_compute_res_query_VTCM(
                                unsigned int application_id,
                                unsigned int* total_block_size,
                                compute_res_vtcm_page_t* total_block_layout,
                                unsigned int* avail_block_size,
                                compute_res_vtcm_page_t* avail_block_layout)
{
    if (compute_resource_query_VTCM)
    {
        return compute_resource_query_VTCM(application_id,
                                           total_block_size,
                                           total_block_layout,
                                           avail_block_size,
                                           avail_block_layout);
    }

    return HAP_COMPUTE_RES_NOT_SUPPORTED;
}

static inline int HAP_compute_res_check_release_request(
                                                    unsigned int context_id)
{
    if (compute_resource_check_release_request)
    {
        return compute_resource_check_release_request(context_id);
    }

    return HAP_COMPUTE_RES_NOT_SUPPORTED;
}

static inline unsigned int HAP_compute_res_acquire(
                                              compute_res_attr_t* attr,
                                              unsigned int timeout_us)
{
    if (compute_resource_acquire)
    {
        return compute_resource_acquire(attr, timeout_us);
    }

    return 0;
}

static inline int HAP_compute_res_release(unsigned int context_id)
{
    if (compute_resource_release)
    {
        return compute_resource_release(context_id);
    }

    return HAP_COMPUTE_RES_NOT_SUPPORTED;
}

static inline int HAP_compute_res_acquire_cached(
                                              unsigned int context_id,
                                              unsigned int timeout_us)
{
    if (compute_resource_acquire_cached)
    {
        return compute_resource_acquire_cached(context_id, timeout_us);
    }

    return HAP_COMPUTE_RES_NOT_SUPPORTED;
}

static inline int HAP_compute_res_release_cached(unsigned int context_id)
{
    if (compute_resource_release_cached)
    {
        return compute_resource_release_cached(context_id);
    }

    return HAP_COMPUTE_RES_NOT_SUPPORTED;
}

static inline int HAP_compute_res_attr_set_release_callback(
                                        compute_res_attr_t* attr,
                                        int (*release_callback)(
                                            unsigned int context_id,
                                            void* client_context),
                                        void* client_context)
{
    if (compute_resource_attr_set_release_callback)
    {
        return compute_resource_attr_set_release_callback(attr,
                                                          release_callback,
                                                          client_context);
    }

    return HAP_COMPUTE_RES_NOT_SUPPORTED;
}

static inline int HAP_compute_res_update_priority(unsigned int context_id,
                                                  unsigned short priority)
{
    if (compute_resource_update_priority)
    {
        return compute_resource_update_priority(context_id, priority);
    }

    return HAP_COMPUTE_RES_NOT_SUPPORTED;
}

static inline int HAP_compute_res_tid_preemption_lock(void)
{
    if (crm_tid_preemption_lock)
    {
        return crm_tid_preemption_lock();
    }

    return HAP_COMPUTE_RES_NOT_SUPPORTED;
}

static inline int HAP_compute_res_tid_preemption_unlock(void)
{
    if (crm_tid_preemption_unlock)
    {
        return crm_tid_preemption_unlock();
    }

    return HAP_COMPUTE_RES_NOT_SUPPORTED;
}

static inline int HAP_compute_res_query_capability(compute_res_capability_id capability_id,
                                                   unsigned int* data)
{
    if (crm_query_capability)
    {
        return crm_query_capability(capability_id, data);
    }

    return HAP_COMPUTE_RES_NOT_SUPPORTED;
}

static inline int HAP_compute_res_get_preempt_data(unsigned int context_id,
                                                   compute_res_preempt_data_t* data)
{
    if (crm_get_preempt_data)
    {
        return crm_get_preempt_data(context_id, data);
    }

    return HAP_COMPUTE_RES_NOT_SUPPORTED;
}

static inline int HAP_compute_res_hmx_lock(unsigned int context_id)
{
    if (compute_resource_hmx_lock)
    {
        return compute_resource_hmx_lock(context_id);
    }

    return HAP_COMPUTE_RES_NOT_SUPPORTED;
}

static inline int HAP_compute_res_hmx_unlock(unsigned int context_id)
{
    if (compute_resource_hmx_unlock)
    {
        return compute_resource_hmx_unlock(context_id);
    }

    return HAP_COMPUTE_RES_NOT_SUPPORTED;
}

static inline int HAP_compute_res_hmx_lock2(unsigned int context_id,
                                            compute_res_hmx_type_t type)
{
    if (compute_resource_hmx_lock2)
    {
        return compute_resource_hmx_lock2(context_id, type);
    }

    return HAP_COMPUTE_RES_NOT_SUPPORTED;
}

static inline int HAP_compute_res_hmx_unlock2(unsigned int context_id,
                                              compute_res_hmx_type_t type)
{
    if (compute_resource_hmx_unlock2)
    {
        return compute_resource_hmx_unlock2(context_id, type);
    }

    return HAP_COMPUTE_RES_NOT_SUPPORTED;
}

static inline int HAP_compute_res_hmx_lock3(unsigned int context_id,
                                              compute_res_hmx_type_t type,
                                              compute_res_hmx_mutex_t *hmx_mutex,
                                              unsigned int timeout_us)
{
    if (crm_hmx_lock3)
    {
        return crm_hmx_lock3(context_id, type, hmx_mutex, timeout_us);
    }

    return HAP_COMPUTE_RES_NOT_SUPPORTED;
}

static inline int HAP_compute_res_hmx_unlock3(unsigned int context_id,
                                              compute_res_hmx_type_t type,
                                              compute_res_hmx_mutex_t *hmx_mutex)
{
    if (crm_hmx_unlock3)
    {
        return crm_hmx_unlock3(context_id, type, hmx_mutex);
    }

    return HAP_COMPUTE_RES_NOT_SUPPORTED;
}

#ifdef __cplusplus
}
#endif

#endif //HAP_COMPUTE_RES_H_