API接口 ​

int ubsmem_init_attributes(ubsmem_options_t *ubsm_shmem_opts);

int ubsmem_initialize(const ubsmem_options_t *ubsm_shmem_opts);

int ubsmem_finalize(void);

int ubsmem_set_logger_level(int level);

int ubsmem_set_extern_logger(void (*func)(int level, const char *msg));

int ubsmem_lookup_regions(ubsmem_regions_t *regions);

#define MAX_HOST_NAME_DESC_LENGTH 64
#define MAX_REGION_NODE_NUM 16
#define MAX_REGIONS_NUM 6

typedef struct {
  char host_name[MAX_HOST_NAME_DESC_LENGTH];  // 需包含 '\0'
  bool affinity;  // 节点亲和，设置为true时则指定从该节点申请共享或借用内存
} ubsmem_region_node_desc_t;

typedef struct {
  int host_num;
  ubsmem_region_node_desc_t hosts[MAX_REGION_NODE_NUM];
} ubsmem_region_attributes_t;

typedef struct {
  int num;
  ubsmem_region_attributes_t region[MAX_REGIONS_NUM];
} ubsmem_regions_t;

int ubsmem_create_region(const char *region_name, size_t size, const ubsmem_region_attributes_t *reg_attr);

int ubsmem_lookup_region(const char *region_name, ubsmem_region_desc_t *region_desc);

#define MAX_REGION_NAME_DESC_LENGTH 48

typedef struct {
    char region_name[MAX_REGION_NAME_DESC_LENGTH];
    size_t size;
    ubsmem_region_attributes_t region_attr;
} ubsmem_region_desc_t;

int ubsmem_destroy_region(const char *region_name);

int ubsmem_shmem_allocate(const char *region_name, const char *name, size_t size, mode_t mode, uint64_t flags);

int ubsmem_shmem_allocate_with_provider(const ubs_mem_provider_t *src_loc, const char *name, size_t size, mode_t mode, uint64_t flags);

int ubsmem_shmem_deallocate(const char *name);

int ubsmem_shmem_map(void *addr, size_t length, int prot, int flags, const char *name, off_t offset, void **local_ptr);

int ubsmem_shmem_unmap(void *local_ptr, size_t length);

int ubsmem_lookup_cluster_statistic(ubsmem_cluster_info_t* info);

#define MAX_HOST_NUM 16
#define MAX_NUMA_NUM 32
#define MAX_NUMA_RESV_LEN 16
#define MAX_HOST_NAME_DESC_LENGTH 64

typedef struct {
  uint32_t slot_id;    // 节点唯一标识，采用slot id，与UBS Eengine一致
  uint32_t socket_id;
  uint32_t numa_id;    
  uint32_t mem_lend_ratio;  // 池化内存借出比例上限
  uint64_t mem_total;       // 节点内存总量，单位字节
  uint64_t mem_free;        // 内存空闲量，单位字节
  uint64_t mem_borrow;      // 借用的内存量，单位字节
  uint64_t mem_lend;        // 借出的内存量，单位字节
  uint8_t resv[MAX_NUMA_RESV_LEN];
} ubsmem_numa_mem_t;

typedef struct {
  char host_name[MAX_HOST_NAME_DESC_LENGTH];
  int numa_num;
  ubsmem_numa_mem_t numa[MAX_NUMA_NUM];
} ubsmem_host_info_t;

typedef struct {
  int host_num;   // Number of available nodes in the cluster
  ubsmem_host_info_t host[MAX_HOST_NUM];
} ubsmem_cluster_info_t;

int ubsmem_shmem_faults_register(shmem_faults_func registerFunc);

typedef int32_t (*shmem_faults_func)(const char *shm_name, ubsmem_fault_type_t fault_type);

typedef enum {
    UBMEM_ATOMIC_DATA_ERR = 0,
    UBMEM_READ_DATA_ERR,
    UBMEM_FLOW_POISON,
    UBMEM_FLOW_READ_AUTH_POISON,
    UBMEM_FLOW_READ_AUTH_RESPERR,
    UBMEM_TIMEOUT_POISON,
    UBMEM_TIMEOUT_RESPERR,
    UBMEM_READ_DATA_POISON,
    UBMEM_READ_DATA_RESPERR,
    UBMEM_MAR_NOPORT_VLD_INT_ERR,
    UBMEM_MAR_FLUX_INT_ERR,
    UBMEM_MAR_WITHOUT_CXT_ERR,
    UBMEM_RSP_BKPRE_OVER_TIMEOUT_ERR,
    UBMEM_MAR_NEAR_AUTH_FAIL_ERR,
    UBMEM_MAR_FAR_AUTH_FAIL_ERR,
    UBMEM_MAR_TIMEOUT_ERR,
    UBMEM_MAR_ILLEGAL_ACCESS_ERR,
    UBMEM_REMOTE_READ_DATA_ERR_OR_WRITE_RESPONSE_ERR,
    UBMEM_HEALTHY = 1000,
} ubsmem_fault_type_t;

int ubsmem_local_nid_query(uint32_t* nid);

int ubsmem_shmem_set_ownership(const char *name, void *start, size_t length, int prot);

int ubsmem_shmem_lookup(const char *name, ubsmem_shmem_info_t *shm_info);

int ubsmem_shmem_list_lookup(const char *prefix, ubsmem_shmem_desc_t shm_list[], uint32_t *shm_cnt);

int ubsmem_lease_malloc(const char *region_name, size_t size, ubsmem_distance_t mem_distance, uint64_t flags, void **local_ptr);

int ubsmem_lease_malloc_with_location(const ubs_mem_location_t *src_loc, size_t size, uint64_t flags, void **local_ptr);

int ubsmem_lease_free(void *local_ptr);

#include <iostream>
#include "ubs_mem_def.h"
#include "ubs_mem.h"


int ubs_mem_initialize_demo()
{
    /* Initialize ubs-mem library. */
    ubsmem_options_t ubsm_shmem_opts;
    int ret = ubsmem_init_attributes(&ubsm_shmem_opts);
    if (ret != UBSM_OK) {
        std::cerr << "Failed to initialize attributes. ret: " << ret << std::endl;
        return -1;
    }
    ret = ubsmem_initialize(&ubsm_shmem_opts);
    if (ret != UBSM_OK) {
        std::cerr << "Failed to initialize ubs-mem. ret: " << ret << std::endl;
        return -1;
    }
    /* Initialize ubs-mem library succeeded. */


    /* Do your work here... */


    /* finalize ubs-mem library. */
    ret = ubsmem_finalize();
    if (ret != UBSM_OK) {
        std::cerr << "Failed to finalize  ubs-mem. ret: " << ret << std::endl;
        return -1;
    }
    return 0;
}

#include <iostream>
#include "ubs_mem_def.h"
#include "ubs_mem.h"

int ubs_mem_lease_demo()
{
    /* Initialize ubs-mem library... */

    /* Allocate 4M memory from other host in the default region. */
    std::string region_name = "default";
    size_t size = 0x400000UL;
    ubsmem_distance_t mem_distance = DISTANCE_DIRECT_NODE;
    uint64_t flags = 0;
    void *addr = nullptr;
    auto ret = ubsmem_lease_malloc(region_name.c_str(), size, mem_distance, flags, &addr);
    if (ret != UBSM_OK) {
        std::cerr << "Failed to allocate remote memory. ret: " << ret << std::endl;
        return -1;
    }
    /* Allocate memory succeeded. */

    /* Do your work here... */

    /* Free memory. */
    ret = ubsmem_lease_free(addr);
    if (ret != UBSM_OK) {
        std::cerr << "Failed to free remote memory. ret: " << ret << std::endl;
        return -1;
    }
    return 0;
}

#include <iostream>
#include "ubs_mem_def.h"
#include "ubs_mem.h"
#include <cstring>

int ubs_mem_create_share_memory_demo()
{
    /* Initialize ubs-mem library... */

    /* Construct region attributes. */
    ubsmem_region_attributes_t attr{};
    attr.host_num = 2;
    (void)strncpy(attr.hosts[0].host_name, "host01", MAX_HOST_NAME_DESC_LENGTH);
    attr.hosts[0].affinity = true;
    (void)strncpy(attr.hosts[1].host_name, "host02", MAX_HOST_NAME_DESC_LENGTH);
    attr.hosts[1].affinity = true;

    /* Create a region. */
    std::string region_name = "region";
    auto ret = ubsmem_create_region(region_name.c_str(), 0, &attr);
    if (ret != UBSM_OK) {
        std::cerr << "Failed to create region. ret: " << ret << std::endl;
        return -1;
    }

    /* Create a 4M shared memory. */
    std::string shared_name = "shared_mem";
    size_t size = 0x400000UL;
    uint64_t flags = UBSM_FLAG_ONLY_IMPORT_NONCACHE | UBSM_FLAG_WR_DELAY_COMP;
    ret = ubsmem_shmem_allocate(region_name.c_str(), shared_name.c_str(), size, 0600, flags);
    if (ret != UBSM_OK) {
        std::cerr << "Failed to create shared memory. ret: " << ret << std::endl;
        return -1;
    }
    /* Create the shared memory succeeded. */

    /* Do your work here... */

    /* Delete the shared memory. */
    ret = ubsmem_shmem_deallocate(shared_name.c_str());
    if (ret != UBSM_OK) {
        std::cerr << "Failed to deallocate shared memory. ret: " << ret << std::endl;
        return -1;
    }
    return 0;
}

#include <iostream>
#include "ubs_mem_def.h"
#include "ubs_mem.h"
#include <sys/mman.h>

int ubs_mem_share_memory_map_demo()
{
    /* Create shared memory... */

    /* Map a shared memory. */
    std::string shared_name = "shared_mem";
    size_t length = 0x400000UL;
    void *address = nullptr;
    auto ret = ubsmem_shmem_map(nullptr, length, PROT_WRITE | PROT_READ, MAP_SHARED, shared_name.c_str(), 0, &address);
    if (ret != UBSM_OK) {
        std::cerr << "Failed to map shared memory. ret: " << ret << std::endl;
        return -1;
    }
    /* Map the shared memory succeeded. */

    /* Do your work here... */

    /* Flush and invalidate the data cache after accessing shared memory to ensure coherency. */
    /* Note: Cache flush/invalidate is invalid for non-cacheable shared memory — skip this step. */
    ret = ubsmem_shmem_set_ownership(shared_name.c_str(), address, length, PROT_NONE);
    if (ret != UBSM_OK) {
        std::cerr << "Failed to set shared memory. ret: " << ret << std::endl;
        return -1;
    }

    /* Unmap the shared memory. */
    ret = ubsmem_shmem_unmap(address, length);
    if (ret != UBSM_OK) {
        std::cerr << "Failed to unmap shared memory. ret: " << ret << std::endl;
        return -1;
    }
    return 0;
}