numam-dpdk/examples/ip_pipeline/cpu_core_map.c

/*-
 *   BSD LICENSE
 *
 *   Copyright(c) 2010-2015 Intel Corporation. All rights reserved.
 *   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 Intel Corporation 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 <inttypes.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

#include <rte_lcore.h>

#include "cpu_core_map.h"

struct cpu_core_map {
	uint32_t n_max_sockets;
	uint32_t n_max_cores_per_socket;
	uint32_t n_max_ht_per_core;
	uint32_t n_sockets;
	uint32_t n_cores_per_socket;
	uint32_t n_ht_per_core;
	int map[0];
};

static inline uint32_t
cpu_core_map_pos(struct cpu_core_map *map,
	uint32_t socket_id,
	uint32_t core_id,
	uint32_t ht_id)
{
	return (socket_id * map->n_max_cores_per_socket + core_id) *
		map->n_max_ht_per_core + ht_id;
}

static int
cpu_core_map_compute_eal(struct cpu_core_map *map);

static int
cpu_core_map_compute_linux(struct cpu_core_map *map);

static int
cpu_core_map_compute_and_check(struct cpu_core_map *map);

struct cpu_core_map *
cpu_core_map_init(uint32_t n_max_sockets,
	uint32_t n_max_cores_per_socket,
	uint32_t n_max_ht_per_core,
	uint32_t eal_initialized)
{
	uint32_t map_size, map_mem_size, i;
	struct cpu_core_map *map;
	int status;

	/* Check input arguments */
	if ((n_max_sockets == 0) ||
		(n_max_cores_per_socket == 0) ||
		(n_max_ht_per_core == 0))
		return NULL;

	/* Memory allocation */
	map_size = n_max_sockets * n_max_cores_per_socket * n_max_ht_per_core;
	map_mem_size = sizeof(struct cpu_core_map) + map_size * sizeof(int);
	map = (struct cpu_core_map *) malloc(map_mem_size);
	if (map == NULL)
		return NULL;

	/* Initialization */
	map->n_max_sockets = n_max_sockets;
	map->n_max_cores_per_socket = n_max_cores_per_socket;
	map->n_max_ht_per_core = n_max_ht_per_core;
	map->n_sockets = 0;
	map->n_cores_per_socket = 0;
	map->n_ht_per_core = 0;

	for (i = 0; i < map_size; i++)
		map->map[i] = -1;

	status = (eal_initialized) ?
		cpu_core_map_compute_eal(map) :
		cpu_core_map_compute_linux(map);

	if (status) {
		free(map);
		return NULL;
	}

	status = cpu_core_map_compute_and_check(map);
	if (status) {
		free(map);
		return NULL;
	}

	return map;
}

int
cpu_core_map_compute_eal(struct cpu_core_map *map)
{
	uint32_t socket_id, core_id, ht_id;

	/* Compute map */
	for (socket_id = 0; socket_id < map->n_max_sockets; socket_id++) {
		uint32_t n_detected, core_id_contig;
		int lcore_id;

		n_detected = 0;
		for (lcore_id = 0; lcore_id < RTE_MAX_LCORE; lcore_id++) {
			struct lcore_config *p = &lcore_config[lcore_id];

			if ((p->detected) && (p->socket_id == socket_id))
				n_detected++;
		}

		core_id_contig = 0;

		for (core_id = 0; n_detected ; core_id++) {
			ht_id = 0;

			for (lcore_id = 0;
				lcore_id < RTE_MAX_LCORE;
				lcore_id++) {
				struct lcore_config *p =
					&lcore_config[lcore_id];

				if ((p->detected) &&
					(p->socket_id == socket_id) &&
					(p->core_id == core_id)) {
					uint32_t pos = cpu_core_map_pos(map,
						socket_id,
						core_id_contig,
						ht_id);

					map->map[pos] = lcore_id;
					ht_id++;
					n_detected--;
				}
			}

			if (ht_id) {
				core_id_contig++;
				if (core_id_contig ==
					map->n_max_cores_per_socket)
					return -1;
			}
		}
	}

	return 0;
}

int
cpu_core_map_compute_and_check(struct cpu_core_map *map)
{
	uint32_t socket_id, core_id, ht_id;

	/* Compute n_ht_per_core, n_cores_per_socket, n_sockets */
	for (ht_id = 0; ht_id < map->n_max_ht_per_core; ht_id++) {
		if (map->map[ht_id] == -1)
			break;

		map->n_ht_per_core++;
	}

	if (map->n_ht_per_core == 0)
		return -1;

	for (core_id = 0; core_id < map->n_max_cores_per_socket; core_id++) {
		uint32_t pos = core_id * map->n_max_ht_per_core;

		if (map->map[pos] == -1)
			break;

		map->n_cores_per_socket++;
	}

	if (map->n_cores_per_socket == 0)
		return -1;

	for (socket_id = 0; socket_id < map->n_max_sockets; socket_id++) {
		uint32_t pos = socket_id * map->n_max_cores_per_socket *
			map->n_max_ht_per_core;

		if (map->map[pos] == -1)
			break;

		map->n_sockets++;
	}

	if (map->n_sockets == 0)
		return -1;

	/* Check that each socket has exactly the same number of cores
	and that each core has exactly the same number of hyper-threads */
	for (socket_id = 0; socket_id < map->n_sockets; socket_id++) {
		for (core_id = 0; core_id < map->n_cores_per_socket; core_id++)
			for (ht_id = 0;
				ht_id < map->n_max_ht_per_core;
				ht_id++) {
				uint32_t pos = (socket_id *
					map->n_max_cores_per_socket + core_id) *
					map->n_max_ht_per_core + ht_id;

				if (((ht_id < map->n_ht_per_core) &&
					(map->map[pos] == -1)) ||
					((ht_id >= map->n_ht_per_core) &&
					(map->map[pos] != -1)))
					return -1;
			}

		for ( ; core_id < map->n_max_cores_per_socket; core_id++)
			for (ht_id = 0;
				ht_id < map->n_max_ht_per_core;
				ht_id++) {
				uint32_t pos = cpu_core_map_pos(map,
					socket_id,
					core_id,
					ht_id);

				if (map->map[pos] != -1)
					return -1;
			}
	}

	return 0;
}

#define FILE_LINUX_CPU_N_LCORES \
	"/sys/devices/system/cpu/present"

static int
cpu_core_map_get_n_lcores_linux(void)
{
	char buffer[64], *string;
	FILE *fd;

	fd = fopen(FILE_LINUX_CPU_N_LCORES, "r");
	if (fd == NULL)
		return -1;

	if (fgets(buffer, sizeof(buffer), fd) == NULL) {
		fclose(fd);
		return -1;
	}

	fclose(fd);

	string = index(buffer, '-');
	if (string == NULL)
		return -1;

	return atoi(++string) + 1;
}

#define FILE_LINUX_CPU_CORE_ID \
	"/sys/devices/system/cpu/cpu%" PRIu32 "/topology/core_id"

static int
cpu_core_map_get_core_id_linux(int lcore_id)
{
	char buffer[64];
	FILE *fd;
	int core_id;

	snprintf(buffer, sizeof(buffer), FILE_LINUX_CPU_CORE_ID, lcore_id);
	fd = fopen(buffer, "r");
	if (fd == NULL)
		return -1;

	if (fgets(buffer, sizeof(buffer), fd) == NULL) {
		fclose(fd);
		return -1;
	}

	fclose(fd);

	core_id = atoi(buffer);
	return core_id;
}

#define FILE_LINUX_CPU_SOCKET_ID \
	"/sys/devices/system/cpu/cpu%" PRIu32 "/topology/physical_package_id"

static int
cpu_core_map_get_socket_id_linux(int lcore_id)
{
	char buffer[64];
	FILE *fd;
	int socket_id;

	snprintf(buffer, sizeof(buffer), FILE_LINUX_CPU_SOCKET_ID, lcore_id);
	fd = fopen(buffer, "r");
	if (fd == NULL)
		return -1;

	if (fgets(buffer, sizeof(buffer), fd) == NULL) {
		fclose(fd);
		return -1;
	}

	fclose(fd);

	socket_id = atoi(buffer);
	return socket_id;
}

int
cpu_core_map_compute_linux(struct cpu_core_map *map)
{
	uint32_t socket_id, core_id, ht_id;
	int n_lcores;

	n_lcores = cpu_core_map_get_n_lcores_linux();
	if (n_lcores <= 0)
		return -1;

	/* Compute map */
	for (socket_id = 0; socket_id < map->n_max_sockets; socket_id++) {
		uint32_t n_detected, core_id_contig;
		int lcore_id;

		n_detected = 0;
		for (lcore_id = 0; lcore_id < n_lcores; lcore_id++) {
			int lcore_socket_id =
				cpu_core_map_get_socket_id_linux(lcore_id);

#if !defined(RTE_ARCH_PPC_64)
			if (lcore_socket_id < 0)
				return -1;
#endif

			if (((uint32_t) lcore_socket_id) == socket_id)
				n_detected++;
		}

		core_id_contig = 0;

		for (core_id = 0; n_detected ; core_id++) {
			ht_id = 0;

			for (lcore_id = 0; lcore_id < n_lcores; lcore_id++) {
				int lcore_socket_id =
					cpu_core_map_get_socket_id_linux(
					lcore_id);

#if !defined(RTE_ARCH_PPC_64)
				if (lcore_socket_id < 0)
					return -1;

				int lcore_core_id =
					cpu_core_map_get_core_id_linux(
						lcore_id);

				if (lcore_core_id < 0)
					return -1;
#endif

#if !defined(RTE_ARCH_PPC_64)
				if (((uint32_t) lcore_socket_id == socket_id) &&
					((uint32_t) lcore_core_id == core_id)) {
#else
				if (((uint32_t) lcore_socket_id == socket_id)) {
#endif
					uint32_t pos = cpu_core_map_pos(map,
						socket_id,
						core_id_contig,
						ht_id);

					map->map[pos] = lcore_id;
					ht_id++;
					n_detected--;
				}
			}

			if (ht_id) {
				core_id_contig++;
				if (core_id_contig ==
					map->n_max_cores_per_socket)
					return -1;
			}
		}
	}

	return 0;
}

void
cpu_core_map_print(struct cpu_core_map *map)
{
	uint32_t socket_id, core_id, ht_id;

	if (map == NULL)
		return;

	for (socket_id = 0; socket_id < map->n_sockets; socket_id++) {
		printf("Socket %" PRIu32 ":\n", socket_id);

		for (core_id = 0;
			core_id < map->n_cores_per_socket;
			core_id++) {
			printf("[%" PRIu32 "] = [", core_id);

			for (ht_id = 0; ht_id < map->n_ht_per_core; ht_id++) {
				int lcore_id = cpu_core_map_get_lcore_id(map,
					socket_id,
					core_id,
					ht_id);

				uint32_t core_id_noncontig =
					cpu_core_map_get_core_id_linux(
						lcore_id);

				printf(" %" PRId32 " (%" PRIu32 ") ",
					lcore_id,
					core_id_noncontig);
			}

			printf("]\n");
		}
	}
}

uint32_t
cpu_core_map_get_n_sockets(struct cpu_core_map *map)
{
	if (map == NULL)
		return 0;

	return map->n_sockets;
}

uint32_t
cpu_core_map_get_n_cores_per_socket(struct cpu_core_map *map)
{
	if (map == NULL)
		return 0;

	return map->n_cores_per_socket;
}

uint32_t
cpu_core_map_get_n_ht_per_core(struct cpu_core_map *map)
{
	if (map == NULL)
		return 0;

	return map->n_ht_per_core;
}

int
cpu_core_map_get_lcore_id(struct cpu_core_map *map,
	uint32_t socket_id,
	uint32_t core_id,
	uint32_t ht_id)
{
	uint32_t pos;

	if ((map == NULL) ||
		(socket_id >= map->n_sockets) ||
		(core_id >= map->n_cores_per_socket) ||
		(ht_id >= map->n_ht_per_core))
		return -1;

	pos = cpu_core_map_pos(map, socket_id, core_id, ht_id);

	return map->map[pos];
}

void
cpu_core_map_free(struct cpu_core_map *map)
{
	free(map);
}