mirror of
https://github.com/gnss-sdr/gnss-sdr
synced 2024-06-25 22:43:14 +00:00
125 lines
4.0 KiB
C
125 lines
4.0 KiB
C
/* Copyright (C) 2010-2019 (see AUTHORS file for a list of contributors)
|
|
*
|
|
* This file is part of GNSS-SDR.
|
|
*
|
|
* GNSS-SDR is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* GNSS-SDR is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with GNSS-SDR. If not, see <https://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
|
|
#include <volk_gnsssdr_rank_archs.h>
|
|
#include <volk_gnsssdr/volk_gnsssdr_prefs.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
#if __GNUC__ > 3 || __GNUC__ == 3 && __GNUC_MINOR__ >= 4
|
|
#define __popcnt __builtin_popcount
|
|
#else
|
|
inline unsigned __popcnt(unsigned num)
|
|
{
|
|
unsigned pop = 0;
|
|
while (num)
|
|
{
|
|
if (num & 0x1) pop++;
|
|
num >>= 1;
|
|
}
|
|
return pop;
|
|
}
|
|
#endif
|
|
|
|
int volk_gnsssdr_get_index(
|
|
const char *impl_names[], //list of implementations by name
|
|
const size_t n_impls, //number of implementations available
|
|
const char *impl_name //the implementation name to find
|
|
)
|
|
{
|
|
unsigned int i;
|
|
for (i = 0; i < n_impls; i++)
|
|
{
|
|
if (!strncmp(impl_names[i], impl_name, 20))
|
|
{
|
|
return i;
|
|
}
|
|
}
|
|
//TODO return -1;
|
|
//something terrible should happen here
|
|
fprintf(stderr, "VOLK_GNSSSDR warning: no arch found, returning generic impl\n");
|
|
return volk_gnsssdr_get_index(impl_names, n_impls, "generic"); //but we'll fake it for now
|
|
}
|
|
|
|
|
|
int volk_gnsssdr_rank_archs(
|
|
const char *kern_name, //name of the kernel to rank
|
|
const char *impl_names[], //list of implementations by name
|
|
const int *impl_deps, //requirement mask per implementation
|
|
const bool *alignment, //alignment status of each implementation
|
|
size_t n_impls, //number of implementations available
|
|
const bool align //if false, filter aligned implementations
|
|
)
|
|
{
|
|
size_t i;
|
|
static volk_gnsssdr_arch_pref_t *volk_gnsssdr_arch_prefs;
|
|
static size_t n_arch_prefs = 0;
|
|
static int prefs_loaded = 0;
|
|
if (!prefs_loaded)
|
|
{
|
|
n_arch_prefs = volk_gnsssdr_load_preferences(&volk_gnsssdr_arch_prefs);
|
|
prefs_loaded = 1;
|
|
}
|
|
|
|
// If we've defined VOLK_GENERIC to be anything, always return the
|
|
// 'generic' kernel. Used in GR's QA code.
|
|
char *gen_env = getenv("VOLK_GENERIC");
|
|
if (gen_env)
|
|
{
|
|
return volk_gnsssdr_get_index(impl_names, n_impls, "generic");
|
|
}
|
|
|
|
//now look for the function name in the prefs list
|
|
for (i = 0; i < n_arch_prefs; i++)
|
|
{
|
|
if (!strncmp(kern_name, volk_gnsssdr_arch_prefs[i].name, sizeof(volk_gnsssdr_arch_prefs[i].name))) //found it
|
|
{
|
|
const char *impl_name = align ? volk_gnsssdr_arch_prefs[i].impl_a : volk_gnsssdr_arch_prefs[i].impl_u;
|
|
return volk_gnsssdr_get_index(impl_names, n_impls, impl_name);
|
|
}
|
|
}
|
|
|
|
//return the best index with the largest deps
|
|
size_t best_index_a = 0;
|
|
size_t best_index_u = 0;
|
|
int best_value_a = -1;
|
|
int best_value_u = -1;
|
|
for (i = 0; i < n_impls; i++)
|
|
{
|
|
const signed val = __popcnt(impl_deps[i]);
|
|
if (alignment[i] && val > best_value_a)
|
|
{
|
|
best_index_a = i;
|
|
best_value_a = val;
|
|
}
|
|
if (!alignment[i] && val > best_value_u)
|
|
{
|
|
best_index_u = i;
|
|
best_value_u = val;
|
|
}
|
|
}
|
|
|
|
//when align and we found a best aligned, use it
|
|
if (align && best_value_a != -1) return best_index_a;
|
|
|
|
//otherwise return the best unaligned
|
|
return best_index_u;
|
|
}
|