Beispiel #1
0
static ucs_status_t uct_cuda_pd_open(const char *pd_name, const uct_pd_config_t *pd_config,
                                     uct_pd_h *pd_p)
{
    static uct_pd_ops_t pd_ops = {
        .close        = (void*)ucs_empty_function,
        .query        = uct_cuda_pd_query,
        .mkey_pack    = uct_cuda_mkey_pack,
        .mem_reg      = uct_cuda_mem_reg,
        .mem_dereg    = uct_cuda_mem_dereg
    };
    static uct_pd_t pd = {
        .ops          = &pd_ops,
        .component    = &uct_cuda_pd
    };

    *pd_p = &pd;
    return UCS_OK;
}

UCT_PD_COMPONENT_DEFINE(uct_cuda_pd, UCT_CUDA_PD_NAME,
                        uct_cuda_query_pd_resources, uct_cuda_pd_open, NULL,
                        uct_cuda_rkey_unpack, uct_cuda_rkey_release, "CUDA_",
                        uct_pd_config_table, uct_pd_config_t);
Beispiel #2
0
static ucs_status_t uct_ugni_pd_open(const char *pd_name, const uct_pd_config_t *pd_config,
                                     uct_pd_h *pd_p)
{
    int domain_id;
    ucs_status_t status = UCS_OK;

    pthread_mutex_lock(&uct_ugni_global_lock);
    static uct_pd_ops_t pd_ops = {
        .close        = uct_ugni_pd_close,
        .query        = uct_ugni_pd_query,
        .mem_alloc    = (void*)ucs_empty_function,
        .mem_free     = (void*)ucs_empty_function,
        .mem_reg      = uct_ugni_mem_reg,
        .mem_dereg    = uct_ugni_mem_dereg,
        .mkey_pack     = uct_ugni_rkey_pack
    };

    static uct_ugni_pd_t pd = {
        .super.ops          = &pd_ops,
        .super.component    = &uct_ugni_pd_component,
        .ref_count          = 0
    };

    *pd_p = &pd.super;

    if (!pd.ref_count) {
        status = init_device_list(&job_info);
        if (UCS_OK != status) {
            ucs_error("Failed to init device list, Error status: %d", status);
            goto error;
        }
        status = uct_ugni_init_nic(0, &domain_id,
                                   &pd.cdm_handle, &pd.nic_handle,
                                   &pd.address);
        if (UCS_OK != status) {
            ucs_error("Failed to UGNI NIC, Error status: %d", status);
            goto error;
        }
    }

    pd.ref_count++;

error:
    pthread_mutex_unlock(&uct_ugni_global_lock);
    return status;
}

uct_ugni_device_t * uct_ugni_device_by_name(const char *dev_name)
{
    uct_ugni_device_t *dev;
    unsigned dev_index;

    if ((NULL == dev_name)) {
        ucs_error("Bad parameter. Device name is set to NULL");
        return NULL;
    }

    for (dev_index = 0; dev_index < job_info.num_devices; ++dev_index) {
        dev = &job_info.devices[dev_index];
        if ((strlen(dev_name) == strlen(dev->fname)) &&
                (0 == strncmp(dev_name, dev->fname, strlen(dev->fname)))) {
            ucs_info("Device found: %s", dev_name);
            return dev;
        }
    }

    /* Device not found */
    ucs_error("Cannot find: %s", dev_name);
    return NULL;
}

UCT_PD_COMPONENT_DEFINE(uct_ugni_pd_component,
                        UCT_UGNI_PD_NAME,
                        uct_ugni_query_pd_resources,
                        uct_ugni_pd_open,
                        NULL,
                        (3 * sizeof(uint64_t)),
                        uct_ugni_rkey_unpack,
                        uct_ugni_rkey_release,
                        "UGNI_",
                        uct_pd_config_table,
                        uct_pd_config_t);