2010-09-08 15:07:14 +00:00
|
|
|
/*
|
|
|
|
* This file is part of FFmpeg.
|
|
|
|
*
|
|
|
|
* FFmpeg is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
|
|
* License as published by the Free Software Foundation; either
|
|
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
|
|
*
|
|
|
|
* FFmpeg 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
|
|
|
|
* Lesser General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
|
|
* License along with FFmpeg; if not, write to the Free Software
|
|
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
|
|
|
*/
|
|
|
|
|
2022-04-14 21:14:27 +00:00
|
|
|
#include "config.h"
|
|
|
|
|
|
|
|
#if HAVE_SCHED_GETAFFINITY
|
|
|
|
#ifndef _GNU_SOURCE
|
|
|
|
# define _GNU_SOURCE
|
|
|
|
#endif
|
|
|
|
#include <sched.h>
|
|
|
|
#endif
|
|
|
|
|
2017-02-08 08:32:17 +00:00
|
|
|
#include <stddef.h>
|
2013-11-23 20:32:55 +00:00
|
|
|
#include <stdint.h>
|
2016-12-07 02:16:13 +00:00
|
|
|
#include <stdatomic.h>
|
2013-11-23 20:32:55 +00:00
|
|
|
|
2017-09-28 01:56:53 +00:00
|
|
|
#include "attributes.h"
|
2010-09-08 15:07:14 +00:00
|
|
|
#include "cpu.h"
|
2013-08-20 15:49:01 +00:00
|
|
|
#include "cpu_internal.h"
|
2012-04-25 17:06:51 +00:00
|
|
|
#include "opt.h"
|
2013-05-24 09:24:27 +00:00
|
|
|
#include "common.h"
|
2010-09-08 15:07:14 +00:00
|
|
|
|
2015-09-29 10:11:03 +00:00
|
|
|
#if HAVE_GETPROCESSAFFINITYMASK || HAVE_WINRT
|
2013-05-23 06:59:07 +00:00
|
|
|
#include <windows.h>
|
|
|
|
#endif
|
|
|
|
#if HAVE_SYSCTL
|
|
|
|
#if HAVE_SYS_PARAM_H
|
|
|
|
#include <sys/param.h>
|
|
|
|
#endif
|
|
|
|
#include <sys/types.h>
|
|
|
|
#include <sys/sysctl.h>
|
|
|
|
#endif
|
2014-07-08 00:50:24 +00:00
|
|
|
#if HAVE_UNISTD_H
|
2013-05-23 06:59:07 +00:00
|
|
|
#include <unistd.h>
|
|
|
|
#endif
|
|
|
|
|
2016-12-07 02:16:13 +00:00
|
|
|
static atomic_int cpu_flags = ATOMIC_VAR_INIT(-1);
|
2021-06-06 13:15:00 +00:00
|
|
|
static atomic_int cpu_count = ATOMIC_VAR_INIT(-1);
|
2016-11-23 19:21:56 +00:00
|
|
|
|
|
|
|
static int get_cpu_flags(void)
|
|
|
|
{
|
2022-06-12 03:51:12 +00:00
|
|
|
#if ARCH_MIPS
|
|
|
|
return ff_get_cpu_flags_mips();
|
|
|
|
#elif ARCH_AARCH64
|
|
|
|
return ff_get_cpu_flags_aarch64();
|
|
|
|
#elif ARCH_ARM
|
|
|
|
return ff_get_cpu_flags_arm();
|
|
|
|
#elif ARCH_PPC
|
|
|
|
return ff_get_cpu_flags_ppc();
|
2022-09-26 14:52:21 +00:00
|
|
|
#elif ARCH_RISCV
|
|
|
|
return ff_get_cpu_flags_riscv();
|
2022-06-12 03:51:12 +00:00
|
|
|
#elif ARCH_X86
|
|
|
|
return ff_get_cpu_flags_x86();
|
|
|
|
#elif ARCH_LOONGARCH
|
|
|
|
return ff_get_cpu_flags_loongarch();
|
|
|
|
#endif
|
2016-11-23 19:21:56 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2011-06-02 14:09:22 +00:00
|
|
|
|
|
|
|
void av_force_cpu_flags(int arg){
|
2017-06-28 13:20:45 +00:00
|
|
|
if (ARCH_X86 &&
|
|
|
|
(arg & ( AV_CPU_FLAG_3DNOW |
|
2014-05-20 03:23:52 +00:00
|
|
|
AV_CPU_FLAG_3DNOWEXT |
|
2015-03-26 05:11:55 +00:00
|
|
|
AV_CPU_FLAG_MMXEXT |
|
2014-05-20 03:23:52 +00:00
|
|
|
AV_CPU_FLAG_SSE |
|
|
|
|
AV_CPU_FLAG_SSE2 |
|
|
|
|
AV_CPU_FLAG_SSE2SLOW |
|
|
|
|
AV_CPU_FLAG_SSE3 |
|
|
|
|
AV_CPU_FLAG_SSE3SLOW |
|
|
|
|
AV_CPU_FLAG_SSSE3 |
|
|
|
|
AV_CPU_FLAG_SSE4 |
|
|
|
|
AV_CPU_FLAG_SSE42 |
|
|
|
|
AV_CPU_FLAG_AVX |
|
2015-05-27 06:30:20 +00:00
|
|
|
AV_CPU_FLAG_AVXSLOW |
|
2014-05-20 03:23:52 +00:00
|
|
|
AV_CPU_FLAG_XOP |
|
|
|
|
AV_CPU_FLAG_FMA3 |
|
|
|
|
AV_CPU_FLAG_FMA4 |
|
2017-10-26 17:48:26 +00:00
|
|
|
AV_CPU_FLAG_AVX2 |
|
|
|
|
AV_CPU_FLAG_AVX512 ))
|
2014-05-20 03:23:52 +00:00
|
|
|
&& !(arg & AV_CPU_FLAG_MMX)) {
|
|
|
|
av_log(NULL, AV_LOG_WARNING, "MMX implied by specified flags\n");
|
|
|
|
arg |= AV_CPU_FLAG_MMX;
|
|
|
|
}
|
|
|
|
|
2016-12-07 02:16:13 +00:00
|
|
|
atomic_store_explicit(&cpu_flags, arg, memory_order_relaxed);
|
2011-06-02 14:09:22 +00:00
|
|
|
}
|
|
|
|
|
2010-09-08 15:07:14 +00:00
|
|
|
int av_get_cpu_flags(void)
|
|
|
|
{
|
2016-12-07 02:16:13 +00:00
|
|
|
int flags = atomic_load_explicit(&cpu_flags, memory_order_relaxed);
|
2016-11-23 19:21:56 +00:00
|
|
|
if (flags == -1) {
|
|
|
|
flags = get_cpu_flags();
|
2016-12-07 02:16:13 +00:00
|
|
|
atomic_store_explicit(&cpu_flags, flags, memory_order_relaxed);
|
2016-11-23 19:21:56 +00:00
|
|
|
}
|
2010-09-09 18:51:49 +00:00
|
|
|
return flags;
|
2010-09-08 15:07:14 +00:00
|
|
|
}
|
|
|
|
|
2012-04-26 21:21:43 +00:00
|
|
|
int av_parse_cpu_caps(unsigned *flags, const char *s)
|
|
|
|
{
|
|
|
|
static const AVOption cpuflags_opts[] = {
|
2012-09-05 12:09:09 +00:00
|
|
|
{ "flags" , NULL, 0, AV_OPT_TYPE_FLAGS, { .i64 = 0 }, INT64_MIN, INT64_MAX, .unit = "flags" },
|
2012-04-26 21:21:43 +00:00
|
|
|
#if ARCH_PPC
|
2012-09-05 11:58:11 +00:00
|
|
|
{ "altivec" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_ALTIVEC }, .unit = "flags" },
|
2012-04-26 21:21:43 +00:00
|
|
|
#elif ARCH_X86
|
2012-09-05 11:58:11 +00:00
|
|
|
{ "mmx" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_MMX }, .unit = "flags" },
|
|
|
|
{ "mmx2" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_MMX2 }, .unit = "flags" },
|
|
|
|
{ "mmxext" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_MMX2 }, .unit = "flags" },
|
|
|
|
{ "sse" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_SSE }, .unit = "flags" },
|
|
|
|
{ "sse2" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_SSE2 }, .unit = "flags" },
|
|
|
|
{ "sse2slow", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_SSE2SLOW }, .unit = "flags" },
|
|
|
|
{ "sse3" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_SSE3 }, .unit = "flags" },
|
|
|
|
{ "sse3slow", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_SSE3SLOW }, .unit = "flags" },
|
|
|
|
{ "ssse3" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_SSSE3 }, .unit = "flags" },
|
|
|
|
{ "atom" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_ATOM }, .unit = "flags" },
|
|
|
|
{ "sse4.1" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_SSE4 }, .unit = "flags" },
|
|
|
|
{ "sse4.2" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_SSE42 }, .unit = "flags" },
|
|
|
|
{ "avx" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_AVX }, .unit = "flags" },
|
2015-05-27 06:30:20 +00:00
|
|
|
{ "avxslow" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_AVXSLOW }, .unit = "flags" },
|
2012-09-05 11:58:11 +00:00
|
|
|
{ "xop" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_XOP }, .unit = "flags" },
|
2014-02-22 05:47:01 +00:00
|
|
|
{ "fma3" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_FMA3 }, .unit = "flags" },
|
2012-09-05 11:58:11 +00:00
|
|
|
{ "fma4" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_FMA4 }, .unit = "flags" },
|
2014-02-06 04:34:01 +00:00
|
|
|
{ "avx2" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_AVX2 }, .unit = "flags" },
|
2014-02-22 05:47:02 +00:00
|
|
|
{ "bmi1" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_BMI1 }, .unit = "flags" },
|
|
|
|
{ "bmi2" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_BMI2 }, .unit = "flags" },
|
2012-09-05 11:58:11 +00:00
|
|
|
{ "3dnow" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_3DNOW }, .unit = "flags" },
|
|
|
|
{ "3dnowext", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_3DNOWEXT }, .unit = "flags" },
|
2012-11-17 01:04:30 +00:00
|
|
|
{ "cmov", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_CMOV }, .unit = "flags" },
|
2015-10-26 07:08:58 +00:00
|
|
|
{ "aesni", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_AESNI }, .unit = "flags" },
|
2017-10-26 17:48:26 +00:00
|
|
|
{ "avx512" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_AVX512 }, .unit = "flags" },
|
2022-02-23 08:57:30 +00:00
|
|
|
{ "avx512icl", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_AVX512ICL }, .unit = "flags" },
|
2021-12-21 20:51:03 +00:00
|
|
|
{ "slowgather", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_SLOW_GATHER }, .unit = "flags" },
|
2012-11-17 01:08:12 +00:00
|
|
|
|
|
|
|
#define CPU_FLAG_P2 AV_CPU_FLAG_CMOV | AV_CPU_FLAG_MMX
|
|
|
|
#define CPU_FLAG_P3 CPU_FLAG_P2 | AV_CPU_FLAG_MMX2 | AV_CPU_FLAG_SSE
|
|
|
|
#define CPU_FLAG_P4 CPU_FLAG_P3| AV_CPU_FLAG_SSE2
|
|
|
|
{ "pentium2", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = CPU_FLAG_P2 }, .unit = "flags" },
|
|
|
|
{ "pentium3", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = CPU_FLAG_P3 }, .unit = "flags" },
|
|
|
|
{ "pentium4", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = CPU_FLAG_P4 }, .unit = "flags" },
|
|
|
|
|
|
|
|
#define CPU_FLAG_K62 AV_CPU_FLAG_MMX | AV_CPU_FLAG_3DNOW
|
|
|
|
#define CPU_FLAG_ATHLON CPU_FLAG_K62 | AV_CPU_FLAG_CMOV | AV_CPU_FLAG_3DNOWEXT | AV_CPU_FLAG_MMX2
|
|
|
|
#define CPU_FLAG_ATHLONXP CPU_FLAG_ATHLON | AV_CPU_FLAG_SSE
|
|
|
|
#define CPU_FLAG_K8 CPU_FLAG_ATHLONXP | AV_CPU_FLAG_SSE2
|
|
|
|
{ "k6", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_MMX }, .unit = "flags" },
|
|
|
|
{ "k62", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = CPU_FLAG_K62 }, .unit = "flags" },
|
|
|
|
{ "athlon", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = CPU_FLAG_ATHLON }, .unit = "flags" },
|
|
|
|
{ "athlonxp", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = CPU_FLAG_ATHLONXP }, .unit = "flags" },
|
|
|
|
{ "k8", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = CPU_FLAG_K8 }, .unit = "flags" },
|
2012-04-26 21:21:43 +00:00
|
|
|
#elif ARCH_ARM
|
2012-09-05 11:58:11 +00:00
|
|
|
{ "armv5te", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_ARMV5TE }, .unit = "flags" },
|
|
|
|
{ "armv6", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_ARMV6 }, .unit = "flags" },
|
|
|
|
{ "armv6t2", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_ARMV6T2 }, .unit = "flags" },
|
|
|
|
{ "vfp", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_VFP }, .unit = "flags" },
|
2016-01-02 18:07:08 +00:00
|
|
|
{ "vfp_vm", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_VFP_VM }, .unit = "flags" },
|
2012-09-05 11:58:11 +00:00
|
|
|
{ "vfpv3", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_VFPV3 }, .unit = "flags" },
|
|
|
|
{ "neon", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_NEON }, .unit = "flags" },
|
2014-08-07 16:34:35 +00:00
|
|
|
{ "setend", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_SETEND }, .unit = "flags" },
|
2014-08-06 11:59:18 +00:00
|
|
|
#elif ARCH_AARCH64
|
|
|
|
{ "armv8", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_ARMV8 }, .unit = "flags" },
|
|
|
|
{ "neon", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_NEON }, .unit = "flags" },
|
|
|
|
{ "vfp", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_VFP }, .unit = "flags" },
|
2020-07-18 15:35:39 +00:00
|
|
|
#elif ARCH_MIPS
|
|
|
|
{ "mmi", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_MMI }, .unit = "flags" },
|
|
|
|
{ "msa", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_MSA }, .unit = "flags" },
|
2021-12-15 03:51:04 +00:00
|
|
|
#elif ARCH_LOONGARCH
|
|
|
|
{ "lsx", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_LSX }, .unit = "flags" },
|
|
|
|
{ "lasx", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_LASX }, .unit = "flags" },
|
2022-09-26 14:52:21 +00:00
|
|
|
#elif ARCH_RISCV
|
|
|
|
{ "rvi", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_RVI }, .unit = "flags" },
|
|
|
|
{ "rvf", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_RVF }, .unit = "flags" },
|
|
|
|
{ "rvd", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_RVD }, .unit = "flags" },
|
lavu/cpu: CPU flags for the RISC-V Vector extension
RVV defines a total of 12 different extensions, including:
- 5 different instruction subsets:
- Zve32x: 8-, 16- and 32-bit integers,
- Zve32f: Zve32x plus single precision floats,
- Zve64x: Zve32x plus 64-bit integers,
- Zve64f: Zve32f plus Zve64x,
- Zve64d: Zve64f plus double precision floats.
- 6 different vector lengths:
- Zvl32b (embedded only),
- Zvl64b (embedded only),
- Zvl128b,
- Zvl256b,
- Zvl512b,
- Zvl1024b,
- and the V extension proper: equivalent to Zve64f and Zvl128b.
In total, there are 6 different possible sets of supported instructions
(including the empty set), but for convenience we allocate one bit for
each type sets: up-to-32-bit ints (RVV_I32), floats (RVV_F32),
64-bit ints (RVV_I64) and doubles (RVV_F64).
Whence the vector size is needed, it can be retrieved by reading the
unprivileged read-only vlenb CSR. This should probably be a separate
helper macro if needed at a later point.
2022-09-26 14:52:25 +00:00
|
|
|
{ "rvv-i32", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_RVV_I32 }, .unit = "flags" },
|
|
|
|
{ "rvv-f32", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_RVV_F32 }, .unit = "flags" },
|
|
|
|
{ "rvv-i64", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_RVV_I64 }, .unit = "flags" },
|
|
|
|
{ "rvv", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_RVV_F64 }, .unit = "flags" },
|
lavu/riscv: CPU flag for the Zbb extension
Unfortunately, it is common, and will remain so, that the Bit
manipulations are not enabled at compilation time. This is an official
policy for Debian ports in general (though they do not support RISC-V
officially as of yet) to stick to the minimal target baseline, which
does not include the B extension or even its Zbb subset.
For inline helpers (CPOP, REV8), compiler builtins (CTZ, CLZ) or
even plain C code (MIN, MAX, MINU, MAXU), run-time detection seems
impractical. But at least it can work for the byte-swap DSP functions.
2022-10-02 11:54:58 +00:00
|
|
|
{ "rvb-basic",NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_RVB_BASIC }, .unit = "flags" },
|
2012-04-26 21:21:43 +00:00
|
|
|
#endif
|
|
|
|
{ NULL },
|
|
|
|
};
|
|
|
|
static const AVClass class = {
|
|
|
|
.class_name = "cpuflags",
|
|
|
|
.item_name = av_default_item_name,
|
|
|
|
.option = cpuflags_opts,
|
|
|
|
.version = LIBAVUTIL_VERSION_INT,
|
|
|
|
};
|
|
|
|
const AVClass *pclass = &class;
|
|
|
|
|
|
|
|
return av_opt_eval_flags(&pclass, &cpuflags_opts[0], s, flags);
|
|
|
|
}
|
2013-05-24 11:13:03 +00:00
|
|
|
|
2013-05-23 06:59:07 +00:00
|
|
|
int av_cpu_count(void)
|
|
|
|
{
|
2020-12-02 22:57:16 +00:00
|
|
|
static atomic_int printed = ATOMIC_VAR_INIT(0);
|
2013-05-26 00:18:38 +00:00
|
|
|
|
2013-06-01 13:38:51 +00:00
|
|
|
int nb_cpus = 1;
|
2021-06-06 13:15:00 +00:00
|
|
|
int count = 0;
|
2015-09-29 10:11:03 +00:00
|
|
|
#if HAVE_WINRT
|
|
|
|
SYSTEM_INFO sysinfo;
|
|
|
|
#endif
|
2013-05-23 06:59:07 +00:00
|
|
|
#if HAVE_SCHED_GETAFFINITY && defined(CPU_COUNT)
|
|
|
|
cpu_set_t cpuset;
|
|
|
|
|
|
|
|
CPU_ZERO(&cpuset);
|
|
|
|
|
2013-06-01 13:38:51 +00:00
|
|
|
if (!sched_getaffinity(0, sizeof(cpuset), &cpuset))
|
2013-05-23 06:59:07 +00:00
|
|
|
nb_cpus = CPU_COUNT(&cpuset);
|
|
|
|
#elif HAVE_GETPROCESSAFFINITYMASK
|
|
|
|
DWORD_PTR proc_aff, sys_aff;
|
2013-06-01 13:38:51 +00:00
|
|
|
if (GetProcessAffinityMask(GetCurrentProcess(), &proc_aff, &sys_aff))
|
2013-05-23 06:59:07 +00:00
|
|
|
nb_cpus = av_popcount64(proc_aff);
|
2021-04-03 18:49:20 +00:00
|
|
|
#elif HAVE_SYSCTL && defined(HW_NCPUONLINE)
|
|
|
|
int mib[2] = { CTL_HW, HW_NCPUONLINE };
|
|
|
|
size_t len = sizeof(nb_cpus);
|
|
|
|
|
|
|
|
if (sysctl(mib, 2, &nb_cpus, &len, NULL, 0) == -1)
|
|
|
|
nb_cpus = 0;
|
2013-05-23 06:59:07 +00:00
|
|
|
#elif HAVE_SYSCTL && defined(HW_NCPU)
|
|
|
|
int mib[2] = { CTL_HW, HW_NCPU };
|
|
|
|
size_t len = sizeof(nb_cpus);
|
|
|
|
|
2013-06-01 13:38:51 +00:00
|
|
|
if (sysctl(mib, 2, &nb_cpus, &len, NULL, 0) == -1)
|
2013-05-23 06:59:07 +00:00
|
|
|
nb_cpus = 0;
|
|
|
|
#elif HAVE_SYSCONF && defined(_SC_NPROC_ONLN)
|
|
|
|
nb_cpus = sysconf(_SC_NPROC_ONLN);
|
|
|
|
#elif HAVE_SYSCONF && defined(_SC_NPROCESSORS_ONLN)
|
|
|
|
nb_cpus = sysconf(_SC_NPROCESSORS_ONLN);
|
2015-09-29 10:11:03 +00:00
|
|
|
#elif HAVE_WINRT
|
|
|
|
GetNativeSystemInfo(&sysinfo);
|
|
|
|
nb_cpus = sysinfo.dwNumberOfProcessors;
|
2013-05-23 06:59:07 +00:00
|
|
|
#endif
|
|
|
|
|
2020-12-02 22:57:16 +00:00
|
|
|
if (!atomic_exchange_explicit(&printed, 1, memory_order_relaxed))
|
2013-05-26 00:18:38 +00:00
|
|
|
av_log(NULL, AV_LOG_DEBUG, "detected %d logical cores\n", nb_cpus);
|
|
|
|
|
2021-06-06 13:15:00 +00:00
|
|
|
count = atomic_load_explicit(&cpu_count, memory_order_relaxed);
|
|
|
|
|
|
|
|
if (count > 0) {
|
|
|
|
nb_cpus = count;
|
|
|
|
av_log(NULL, AV_LOG_DEBUG, "overriding to %d logical cores\n", nb_cpus);
|
|
|
|
}
|
|
|
|
|
2013-05-23 06:59:07 +00:00
|
|
|
return nb_cpus;
|
|
|
|
}
|
2017-02-08 08:32:17 +00:00
|
|
|
|
2021-07-20 07:33:47 +00:00
|
|
|
void av_cpu_force_count(int count)
|
|
|
|
{
|
2021-06-06 13:15:00 +00:00
|
|
|
atomic_store_explicit(&cpu_count, count, memory_order_relaxed);
|
|
|
|
}
|
|
|
|
|
2017-02-08 08:32:17 +00:00
|
|
|
size_t av_cpu_max_align(void)
|
|
|
|
{
|
2022-06-12 03:51:12 +00:00
|
|
|
#if ARCH_MIPS
|
|
|
|
return ff_get_cpu_max_align_mips();
|
|
|
|
#elif ARCH_AARCH64
|
|
|
|
return ff_get_cpu_max_align_aarch64();
|
|
|
|
#elif ARCH_ARM
|
|
|
|
return ff_get_cpu_max_align_arm();
|
|
|
|
#elif ARCH_PPC
|
|
|
|
return ff_get_cpu_max_align_ppc();
|
|
|
|
#elif ARCH_X86
|
|
|
|
return ff_get_cpu_max_align_x86();
|
|
|
|
#elif ARCH_LOONGARCH
|
|
|
|
return ff_get_cpu_max_align_loongarch();
|
|
|
|
#endif
|
2017-02-08 08:32:17 +00:00
|
|
|
|
|
|
|
return 8;
|
|
|
|
}
|