em_core.c

/*
 *   Copyright (c) 2015, Nokia Solutions and Networks
 *   All rights reserved.
 *
 *   Redistribution and use in source and binary forms, with or without
 *   modification, are permitted provided that the following conditions
 *   are met:
 *
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Neither the name of the copyright holder nor the names of its
 *       contributors may be used to endorse or promote products derived
 *       from this software without specific prior written permission.
 *
 *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
#include "em_include.h"
 
em_status_t core_map_init(core_map_t *const core_map, int core_count,
                          const em_core_mask_t *phys_mask)
{
        int phys_id = 0;
        int logic_id = 0;
        int mask_count;
        int last_phys_id;
 
        if (core_count > EM_MAX_CORES || core_count > odp_thread_count_max())
                return EM_ERR_TOO_LARGE;
 
        mask_count = em_core_mask_count(phys_mask);
        if (mask_count != core_count)
                return EM_ERR_BAD_STATE;
 
        last_phys_id = em_core_mask_idx(core_count, phys_mask);
        if (last_phys_id >= EM_MAX_CORES)
                return EM_ERR_BAD_ID;
 
        memset(core_map, 0, sizeof(core_map_t));
 
        env_spinlock_init(&core_map->lock);
        odp_atomic_init_u32(&core_map->current_core_count, 0);
 
        /* Store the EM core count, returned by em_core_count() */
        core_map->count = core_count;
 
        em_core_mask_copy(&core_map->phys_mask, phys_mask);
        em_core_mask_set_count(core_count, &core_map->logic_mask);
 
        while (logic_id < core_count && phys_id < EM_MAX_CORES) {
                if (em_core_mask_isset(phys_id, &core_map->phys_mask)) {
                        core_map->phys_vs_logic.logic[phys_id] = logic_id;
                        core_map->phys_vs_logic.phys[logic_id] = phys_id;
                        logic_id++;
                }
                phys_id++;
        }
 
        return EM_OK;
}
 
em_status_t core_map_init_local(core_map_t *const core_map)
{
        em_locm_t *const locm = &em_locm;
        const int phys_core = odp_cpu_id();
        const int odp_thr = odp_thread_id();
        int32_t current_core_count;
 
        if (unlikely(phys_core >= EM_MAX_CORES))
                return EM_ERR_BAD_ID;
        if (odp_thr >= ODP_THREAD_COUNT_MAX ||
            odp_thr >= odp_thread_count_max())
                return EM_ERR_LIB_FAILED;
 
        /* Store the EM core id of this core, returned by em_core_id() */
        locm->core_id = core_map->phys_vs_logic.logic[phys_core];
 
        if (unlikely(locm->core_id < 0))
                return EM_ERR_TOO_SMALL;
        if (unlikely(locm->core_id >= EM_MAX_CORES))
                return EM_ERR_TOO_LARGE;
 
        env_spinlock_lock(&core_map->lock);
        current_core_count = odp_atomic_fetch_inc_u32(&core_map->current_core_count);
        core_map->thr_vs_logic.logic[odp_thr] = locm->core_id;
        core_map->thr_vs_logic.odp_thr[locm->core_id] = odp_thr;
        env_spinlock_unlock(&core_map->lock);
 
        EM_DBG("EM-core%02d: %s() - current core count:%d\n",
               em_locm.core_id, __func__, current_core_count + 1);
 
        return EM_OK;
}
 
em_status_t core_map_term_local(core_map_t *const core_map)
{
        int32_t current_core_count = odp_atomic_fetch_dec_u32(&core_map->current_core_count);
 
        if (unlikely(current_core_count < 1)) {
                EM_LOG(EM_LOG_ERR, "Current core count invalid: %d", current_core_count);
                return EM_ERR_TOO_SMALL;
        }
 
        EM_DBG("EM-core%02d: %s() - current core count:%d\n",
               em_locm.core_id, __func__, current_core_count);
 
        return EM_OK;
}
 
int logic_to_thr_core_id(const int logic_core)
{
        if (unlikely(logic_core >= EM_MAX_CORES))
                return -1;
 
        return em_shm->core_map.thr_vs_logic.odp_thr[logic_core];
}
 
int thr_to_logic_core_id(const int thr_id)
{
        if (unlikely(thr_id >= ODP_THREAD_COUNT_MAX))
                return -1;
 
        return em_shm->core_map.thr_vs_logic.logic[thr_id];
}
 
void mask_em2odp(const em_core_mask_t *const em_core_mask,
                 odp_thrmask_t *const odp_thrmask /*out*/)
{
        int core_count = em_core_count();
        int odp_thread_id;
 
        odp_thrmask_zero(odp_thrmask);
 
        /* EM cores are consecutive 0 -> em_core_count()-1 */
        for (int i = 0; i < core_count; i++) {
                if (em_core_mask_isset(i, em_core_mask)) {
                        odp_thread_id = logic_to_thr_core_id(i);
                        odp_thrmask_set(odp_thrmask, odp_thread_id);
                }
        }
}
 
void mask_em2phys(const em_core_mask_t *const em_core_mask,
                  odp_cpumask_t *const odp_cpumask /*out*/)
{
        int core_count = em_core_count();
        int cpu_id;
 
        odp_cpumask_zero(odp_cpumask);
 
        /* EM cores are consecutive 0 -> em_core_count()-1 */
        for (int i = 0; i < core_count; i++) {
                if (em_core_mask_isset(i, em_core_mask)) {
                        cpu_id = logic_to_phys_core_id(i);
                        odp_cpumask_set(odp_cpumask, cpu_id);
                }
        }
}