U
|
O ±d% ã @ sÆ d Z ddlZddlZddlZddlZddlZddlZddlZddddgZG dd dZ G d d
|
d
|
Z
|
i Z G d d d Z G d d dZ G dd dZG dd dZG dd de e
|
e e eeZdd ZdS )a Provides the `CCompilerOpt` class, used for handling the CPU/hardware
|
optimization, starting from parsing the command arguments, to managing the
|
relation between the CPU baseline and dispatch-able features,
|
also generating the required C headers and ending with compiling
|
the sources with proper compiler's flags.
|
|
`CCompilerOpt` doesn't provide runtime detection for the CPU features,
|
instead only focuses on the compiler side, but it creates abstract C headers
|
that can be used later for the final runtime dispatching process.é Nz
|
-std=c++11z-D__STDC_VERSION__=0z-fno-exceptionsz -fno-rttic ' @ sf e Zd ZdZdZdZdZdZej
|
ej ej e ¡¡d¡Zi ZdZdZeeddd d
|
eddd d
|
ed dd d
|
ed ddd
|
edddd
|
dZeddddddddZeedddd ed d d d ed!dd"d ed#d$d%d ed&d'd(d ed)d*d+d ed,d-d.ed/d0d1dd2ed3d4d5d ed6d4d5d ed7d4d.ed8d9d.ed:d9d.ed;d<dd=d>ed?d@d.edAdBdCdDddEedFdDdGdHddEedIdBdJdKddLdMedNdKdOdPdQedRdKdSdTddEedUdVdWdXddEeddYdZd[ed d\dd]ed!d^dd]ed#d_dd`d>eddadbed dcdd]ed!dddd]eddedbed dfd.ed!dgd.ed#dhdd]ed&did.ed)did.ed,djd.dk#Zdldm Zdndo ZdS )pÚ_ConfigaÉ An abstract class holds all configurable attributes of `CCompilerOpt`,
|
these class attributes can be used to change the default behavior
|
of `CCompilerOpt` in order to fit other requirements.
|
|
Attributes
|
----------
|
conf_nocache : bool
|
Set True to disable memory and file cache.
|
Default is False.
|
|
conf_noopt : bool
|
Set True to forces the optimization to be disabled,
|
in this case `CCompilerOpt` tends to generate all
|
expected headers in order to 'not' break the build.
|
Default is False.
|
|
conf_cache_factors : list
|
Add extra factors to the primary caching factors. The caching factors
|
are utilized to determine if there are changes had happened that
|
requires to discard the cache and re-updating it. The primary factors
|
are the arguments of `CCompilerOpt` and `CCompiler`'s properties(type, flags, etc).
|
Default is list of two items, containing the time of last modification
|
of `ccompiler_opt` and value of attribute "conf_noopt"
|
|
conf_tmp_path : str,
|
The path of temporary directory. Default is auto-created
|
temporary directory via ``tempfile.mkdtemp()``.
|
|
conf_check_path : str
|
The path of testing files. Each added CPU feature must have a
|
**C** source file contains at least one intrinsic or instruction that
|
related to this feature, so it can be tested against the compiler.
|
Default is ``./distutils/checks``.
|
|
conf_target_groups : dict
|
Extra tokens that can be reached from dispatch-able sources through
|
the special mark ``@targets``. Default is an empty dictionary.
|
|
**Notes**:
|
- case-insensitive for tokens and group names
|
- sign '#' must stick in the begin of group name and only within ``@targets``
|
|
**Example**:
|
.. code-block:: console
|
|
$ "@targets #avx_group other_tokens" > group_inside.c
|
|
>>> CCompilerOpt.conf_target_groups["avx_group"] = \
|
"$werror $maxopt avx2 avx512f avx512_skx"
|
>>> cco = CCompilerOpt(cc_instance)
|
>>> cco.try_dispatch(["group_inside.c"])
|
|
conf_c_prefix : str
|
The prefix of public C definitions. Default is ``"NPY_"``.
|
|
conf_c_prefix_ : str
|
The prefix of internal C definitions. Default is ``"NPY__"``.
|
|
conf_cc_flags : dict
|
Nested dictionaries defining several compiler flags
|
that linked to some major functions, the main key
|
represent the compiler name and sub-keys represent
|
flags names. Default is already covers all supported
|
**C** compilers.
|
|
Sub-keys explained as follows:
|
|
"native": str or None
|
used by argument option `native`, to detect the current
|
machine support via the compiler.
|
"werror": str or None
|
utilized to treat warning as errors during testing CPU features
|
against the compiler and also for target's policy `$werror`
|
via dispatch-able sources.
|
"maxopt": str or None
|
utilized for target's policy '$maxopt' and the value should
|
contains the maximum acceptable optimization by the compiler.
|
e.g. in gcc `'-O3'`
|
|
**Notes**:
|
* case-sensitive for compiler names and flags
|
* use space to separate multiple flags
|
* any flag will tested against the compiler and it will skipped
|
if it's not applicable.
|
|
conf_min_features : dict
|
A dictionary defines the used CPU features for
|
argument option `'min'`, the key represent the CPU architecture
|
name e.g. `'x86'`. Default values provide the best effort
|
on wide range of users platforms.
|
|
**Note**: case-sensitive for architecture names.
|
|
conf_features : dict
|
Nested dictionaries used for identifying the CPU features.
|
the primary key is represented as a feature name or group name
|
that gathers several features. Default values covers all
|
supported features but without the major options like "flags",
|
these undefined options handle it by method `conf_features_partial()`.
|
Default value is covers almost all CPU features for *X86*, *IBM/Power64*
|
and *ARM 7/8*.
|
|
Sub-keys explained as follows:
|
|
"implies" : str or list, optional,
|
List of CPU feature names to be implied by it,
|
the feature name must be defined within `conf_features`.
|
Default is None.
|
|
"flags": str or list, optional
|
List of compiler flags. Default is None.
|
|
"detect": str or list, optional
|
List of CPU feature names that required to be detected
|
in runtime. By default, its the feature name or features
|
in "group" if its specified.
|
|
"implies_detect": bool, optional
|
If True, all "detect" of implied features will be combined.
|
Default is True. see `feature_detect()`.
|
|
"group": str or list, optional
|
Same as "implies" but doesn't require the feature name to be
|
defined within `conf_features`.
|
|
"interest": int, required
|
a key for sorting CPU features
|
|
"headers": str or list, optional
|
intrinsics C header file
|
|
"disable": str, optional
|
force disable feature, the string value should contains the
|
reason of disabling.
|
|
"autovec": bool or None, optional
|
True or False to declare that CPU feature can be auto-vectorized
|
by the compiler.
|
By default(None), treated as True if the feature contains at
|
least one applicable flag. see `feature_can_autovec()`
|
|
"extra_checks": str or list, optional
|
Extra test case names for the CPU feature that need to be tested
|
against the compiler.
|
|
Each test case must have a C file named ``extra_xxxx.c``, where
|
``xxxx`` is the case name in lower case, under 'conf_check_path'.
|
It should contain at least one intrinsic or function related to the test case.
|
|
If the compiler able to successfully compile the C file then `CCompilerOpt`
|
will add a C ``#define`` for it into the main dispatch header, e.g.
|
``#define {conf_c_prefix}_XXXX`` where ``XXXX`` is the case name in upper case.
|
|
**NOTES**:
|
* space can be used as separator with options that supports "str or list"
|
* case-sensitive for all values and feature name must be in upper-case.
|
* if flags aren't applicable, its will skipped rather than disable the
|
CPU feature
|
* the CPU feature will disabled if the compiler fail to compile
|
the test file
|
FNZchecksZNPY_ZNPY__z -march=nativez-O3z-Werror)ÚnativeÚoptÚwerrorz-Werror=switch -Werrorz-xHostz/QxHostz/O3z/Werrorz/O2z/WX)ÚgccÚclangÚiccÚiccwÚmsvczSSE SSE2z SSE SSE2 SSE3Ú zVSX VSX2z NEON NEON_FP16 NEON_VFPV4 ASIMD)Úx86Úx64Úppc64Úppc64leÚs390xÚarmhfÚaarch64é z xmmintrin.hÚSSE2)ÚinterestÚheadersÚimpliesé ÚSSEz emmintrin.h)r r r é z pmmintrin.hé ÚSSE3z tmmintrin.hé ÚSSSE3z smmintrin.hé ÚSSE41zpopcntintrin.hé ÚPOPCNT)r r é ÚSSE42z immintrin.h)r r r Úimplies_detecté ÚAVXz x86intrin.hé
|
é é ÚF16Cé é z FMA3 AVX2ZAVX512F_REDUCE)r r r% Ú extra_checksé ÚAVX512Fé( ÚAVX512CDzAVX512ER AVX512PFÚ
|
AVX512_KNL)r r ÚgroupÚdetectr% é) z)AVX5124FMAPS AVX5124VNNIW AVX512VPOPCNTDQÚ
|
AVX512_KNMé* zAVX512VL AVX512BW AVX512DQÚ
|
AVX512_SKXzAVX512BW_MASK AVX512DQ_MASK)r r r4 r5 r% r. é+ Z
|
AVX512VNNIÚ
|
AVX512_CLX)r r r4 r5 é, zAVX512IFMA AVX512VBMIÚ
|
AVX512_CNLé- zAVX512_CLX AVX512_CNLz(AVX512VBMI2 AVX512BITALG AVX512VPOPCNTDQÚ
|
AVX512_ICLz altivec.hZVSX_ASM)r r r. ÚVSX)r r r% ÚVSX2ÚVSX3ZVSX4_MMAz vecintrin.h)r r ÚVXÚVXEz
|
arm_neon.hÚNEONÚ NEON_FP16zNEON_FP16 NEON_VFPV4ÚASIMDÚASIMDHP)#r r r r r r" r$ r' ÚXOPÚFMA4r+ ÚFMA3ÚAVX2r0 r2 r3 r7 r9 r; r= r? r@ rA rB ÚVSX4rC rD ÚVXE2rE rF Ú
|
NEON_VFPV4rG rH ÚASIMDDPÚASIMDFHMc C sd | j r
|
i S | jp| j}| jp | j}|rÚ|rÚttddtddtddtddtddtddtddtd dtd
|
dtd dtd dtd dtddtddtddtddtddtddtddtddtdddS |r| jrttddtddtddtddtddi tddtd di tddtddtddd td dd td d d td d d td!dtd"dtd#dtd$dtd%dtd&ddS |rN| jrNttd'dtd(dtd)dtd*dtd+di td,dtd-di tddtddtdd.d td d.d td d/d td d/d td0dtd1dtd2dtd3dtd4dtd5ddS |rü| jrüt| jrptd'dni | jrtd(dni i i i td6d7i td-di td8d7td8d7tdd9d td:d9d td;d<d td=d<d td>dtd>dtd<di i i dS | j p| j
|
}|rtt| j r d?nd@dAd tdBdCdDtdEdCdDtdFdCdDdG}| jrdH|dI dJ< dK|d? dJ< dL|dM dJ< dN|dO dJ< |S | j }|r¼ttdPdtdQdCdDtdRdCdDdS}|S | j r|rttdTdUdVtdWdUdVtdXdUdVtdYdUdVtdZdtd[dtd\dd]S | j r`|r`ttd^dtd_dtd`dtdadtdZdtd[dtd\dd]S i S )ba7 Return a dictionary of supported CPU features by the platform,
|
and accumulate the rest of undefined options in `conf_features`,
|
the returned dict has same rules and notes in
|
class attribute `conf_features`, also its override
|
any options that been set in 'conf_features'.
|
z-msse)Úflagsz-msse2z-msse3z-mssse3z-msse4.1z-mpopcntz-msse4.2z-mavxz-mf16cz-mxopz-mfma4z-mfmaz-mavx2z-mavx512f -mno-mmxz
|
-mavx512cdz-mavx512er -mavx512pfz/-mavx5124fmaps -mavx5124vnniw -mavx512vpopcntdqz -mavx512vl -mavx512bw -mavx512dqz -mavx512vnniz-mavx512ifma -mavx512vbmiz.-mavx512vbmi2 -mavx512bitalg -mavx512vpopcntdq)r r r r r r" r$ r' r+ rI rJ rK rL r0 r2 r3 r7 r9 r; r= r? z!Intel Compiler doesn't support it)Údisablez F16C AVX2z-march=core-avx2)r rR rK z AVX2 AVX512CDz-march=common-avx512z AVX2 AVX512Fz-xKNLz-xKNMz-xSKYLAKE-AVX512z -xCASCADELAKEz -xCANNONLAKEz-xICELAKE-CLIENTz /arch:SSEz
|
/arch:SSE2z
|
/arch:SSE3z /arch:SSSE3z /arch:SSE4.1z /arch:SSE4.2z /arch:AVXz/arch:CORE-AVX2z/Qx:COMMON-AVX512z/Qx:KNLz/Qx:KNMz/Qx:SKYLAKE-AVX512z/Qx:CASCADELAKEz/Qx:CANNONLAKEz/Qx:ICELAKE-CLIENTz nmmintrin.h)r z ammintrin.hz
|
/arch:AVX2z F16C FMA3zAVX2 AVX512CD AVX512_SKXz /arch:AVX512zAVX512F AVX512_SKXz MSVC compiler doesn't support itrA r z-mvsxz -mcpu=power8F)rR r% z-mcpu=power9 -mtune=power9z -mcpu=power10 -mtune=power10)r@ rA rB rM z-maltivec -mvsxr@ rR z-mpower8-vectorz-mpower9-vectorrB z-mpower10-vectorrM z-march=arch11 -mzvectorz -march=arch12z -march=arch13)rC rD rN zNEON_FP16 NEON_VFPV4 ASIMDT)r ÚautoveczNEON NEON_VFPV4 ASIMDzNEON NEON_FP16 ASIMDzNEON NEON_FP16 NEON_VFPV4z-march=armv8.2-a+fp16z-march=armv8.2-a+dotprodz-march=armv8.2-a+fp16fml)rE rF rO rG rH rP rQ z
|
-mfpu=neonz"-mfpu=neon-fp16 -mfp16-format=ieeez-mfpu=neon-vfpv4z'-mfpu=neon-fp-armv8 -march=armv8-a+simd)Úcc_nooptÚ cc_on_x86Ú cc_on_x64Ú cc_is_gccÚ cc_is_clangÚdictÚ cc_is_iccÚ
|
cc_is_iccwÚ
|
cc_is_msvcÚ cc_on_ppc64leÚ cc_on_ppc64Ú cc_on_s390xÚ cc_on_aarch64Ú cc_on_armhf)ÚselfZon_x86Zis_unixZon_powerÚpartialZon_zarch© re úTd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\numpy/distutils/ccompiler_opt.pyÚconf_features_partialI sØ ÿÿé ÿ
|
ÿ ÿã ÿ ÿ ÿ ÿá! ÿ ÿ ÿ ÿÿÿÜ'þ ÿ ÿ ÿõ ÿ ÿ ÿù ÿ ÿ ÿ ÿÿÿÿí ÿÿÿÿÿÿÿíz _Config.conf_features_partialc sb | j d kr@dd l dd l}| ¡ fdd}t |¡ | _ | jd kr^tj t
|
¡| j g| _d S )Nr c s( z ¡ W n tk
|
r" Y nX d S ©N)ÚrmtreeÚOSErrorre ©ÚshutilÚtmpre rf Úrm_temp9 s z!_Config.__init__.<locals>.rm_temp) Ú conf_tmp_pathrl ÚtempfileÚmkdtempÚatexitÚregisterÚconf_cache_factorsÚosÚpathÚgetmtimeÚ__file__Ú conf_nocache)rc rp rn re rk rf Ú__init__4 s
|
|
|
|
þz_Config.__init__)Ú__name__Ú
|
__module__Ú __qualname__Ú__doc__ry Ú
|
conf_nooptrt ro ru rv ÚjoinÚdirnameÚrealpathrx Úconf_check_pathÚconf_target_groupsÚ conf_c_prefixÚconf_c_prefix_rZ Ú conf_cc_flagsÚconf_min_featuresÚ conf_featuresrg rz re re re rf r s " ÿûø
|
ýýýä"ù ü
|
þ
|
|
|
þ
|
þ ý ý þ þ ý ÿ
|
|
|
|
|
|
|
¬V lr c @ s e Zd ZdZdd Zd ddZg fddZd d
|
Zed d Z ed d Z
|
eddddZ edd Z edd Z d ddZe d¡Zed ddZdS ) Ú
|
_Distutilsa¾ A helper class that provides a collection of fundamental methods
|
implemented in a top of Python and NumPy Distutils.
|
|
The idea behind this class is to gather all methods that it may
|
need to override in case of reuse 'CCompilerOpt' in environment
|
different than of what NumPy has.
|
|
Parameters
|
----------
|
ccompiler : `CCompiler`
|
The generate instance that returned from `distutils.ccompiler.new_compiler()`.
|
c C s
|
|| _ d S rh )Ú
|
_ccompiler)rc Ú ccompilerre re rf rz T s z_Distutils.__init__Nc K sL t |tstt |ts t| dg ¡| }|s6| j}|j|fd|i|S )zWrap CCompiler.compile()Zextra_postargs)Ú
|
isinstanceÚlistÚAssertionErrorÚpopr Úcompile)rc ÚsourcesrR r Úkwargsre re rf Ú dist_compileW s z_Distutils.dist_compilec
|
|
C sÐ t |tstddlm} | j}t|dd}|rdt| jdd}|dkrVt|d| j nt|d| j d}z | j
|
|g||| j d d
|
}W n4 |k
|
rº } z| j t| d
|
d W 5 d} ~ X Y nX |rÌt|d| |S ) zgReturn True if 'CCompiler.compile()' able to compile
|
a source file with certain flags.
|
r ©Ú CompileErrorÚspawnNÚ compiler_typer )r
|
F)ÚmacrosÚ
|
output_dirT©Ústderr) r Ústrr Údistutils.errorsr r ÚgetattrÚsetattrÚ_dist_test_spawn_pathsÚ_dist_test_spawnr ro Údist_log)
|
rc ÚsourcerR r r ÚccZbk_spawnÚcc_typeÚtestÚere re rf Ú dist_testa s. ÿ$ z_Distutils.dist_testc C sî t | dr| jS t| jdd}|dkr,d}n |dkr:d}ndd lm} | }t| jd
|
t| jd d}|rp|d krt |d r|d }qt|}n|}t |d r¼t|dkr¼d |dd
¡}n t j
|
dd¡}|t j
|
dd¡7 }|||f| _| jS )a!
|
Return a tuple containing info about (platform, compiler, extra_args),
|
required by the abstract class '_CCompiler' for discovering the
|
platform environment. This is also used as a cache factor in order
|
to detect any changes happening from outside.
|
Ú
|
_dist_infor r )ZintelemZintelemwÚx86_64)ÚintelZintelwZinteler r )Ú get_platformÚcompilerÚ compiler_soÚunixÚ__iter__r ú NÚCFLAGSÚCPPFLAGS) Úhasattrrª r r Údistutils.utilr r Úlenr ru ÚenvironÚget)rc r¦ Úplatformr Zcc_infor® Ú
|
extra_argsre re rf Ú dist_info{ s*
|
|
|
|
z_Distutils.dist_infoc G s ddl m} |tj| dS )zRaise a compiler errorr r N)r r r Ú _dist_str)Úargsr re re rf Ú
|
dist_error s z_Distutils.dist_errorc G s ddl m} |tj| dS )zRaise a distutils errorr )ÚDistutilsErrorN)r rÀ r r½ )r¾ rÀ re re rf Ú
|
dist_fatal¦ s z_Distutils.dist_fatalFr c G s4 ddl m} tj| }| r&| |¡ n
|
| |¡ dS )zPrint a console messager )ÚlogN)Znumpy.distutilsr r r½ ÚwarnÚinfo)r r¾ r Úoutre re rf r£ ¬ s
|
|
z_Distutils.dist_logc
|
C sN ddl m} z || |W S tk
|
rH } ztj|dd W 5 d}~X Y nX dS )zALoad a module from file, required by the abstract class '_Cache'.r )Úexec_mod_from_locationTr N)Z misc_utilrÆ Ú Exceptionr r£ )Únamerv rÆ r¨ re re rf Údist_load_module¶ s z_Distutils.dist_load_modulec sJ fdd t ¡ d }d|j|jf }d fdd| D ¡}|| S )z+Return a string to print by log and errors.c sJ t | tsBt| drBg }| D ]}| |¡ q dd |¡ d S t| S )Nr± ú(r² ú))r r rµ Úappendr )ÚargÚretÚa©Úto_strre rf rÑ Ã s z$_Distutils._dist_str.<locals>.to_strr zCCompilerOpt.%s[%d] : r² c s g | ] } |qS re re )Ú.0rÏ rÐ re rf Ú
|
<listcomp>Í s ÿz(_Distutils._dist_str.<locals>.<listcomp>)ÚinspectÚstackÚfunctionÚlinenor )r¾ rÕ ÚstartrÅ re rÐ rf r½ À s þz_Distutils._dist_strc C sR t | jds| |¡ dS t d¡}z | jjtjd< | |¡ W 5 |tjd< X dS )z
|
Fix msvc SDK ENV path same as distutils do
|
without it we get c1: fatal error C1356: unable to find mspdbcore.dll
|
Ú_pathsNrv )rµ r r¢ ru Úgetenvr¸ rÙ )rc ÚcmdÚdisplayÚold_pathre re rf r¡ Ó s
|
|
z!_Distutils._dist_test_spawn_pathsz/.*(warning D9002|invalid argument for option).*c
|
C s² z:t j| t jdd}|r8t tj|¡r8t d| d| ¡ W nX t jk
|
rj } z|j }|j
|
}W 5 d }~X Y n. t k
|
r } z |}d}W 5 d }~X Y nX d S t d| d||f ¡ d S )NT)r ÚtextzFlags in commandz/aren't supported by the compiler, output ->
|
%sé ÚCommandz(failed with exit status %d output ->
|
%s) Ú
|
subprocessÚ check_outputÚSTDOUTÚreÚmatchr Ú_dist_warn_regexr¿ ÚCalledProcessErrorÚoutputÚ
|
returncoderj )rÛ rÜ ÚoÚexcÚsr¨ re re rf r¢ ê s6
|
ÿ ÿÿ ÿÿz_Distutils._dist_test_spawn)N)N)N)r{ r| r} r~ rz r r© r¼ Ú staticmethodr¿ rÁ r£ rÉ r½ r¡ rä r ræ r¢ re re re rf r G s*
|
|
%
|
|
|
|
|
ýr c @ sH e Zd ZdZe d¡ZdddZdd Zdd Z d
|
d Z
|
e d d Z dS )Ú_Cachea' An abstract class handles caching functionality, provides two
|
levels of caching, in-memory by share instances attributes among
|
each other and by store attributes into files.
|
|
**Note**:
|
any attributes that start with ``_`` or ``conf_`` will be ignored.
|
|
Parameters
|
----------
|
cache_path : str or None
|
The path of cache file, if None then cache in file will disabled.
|
|
*factors :
|
The caching factors that need to utilize next to `conf_cache_factors`.
|
|
Attributes
|
----------
|
cache_private : set
|
Hold the attributes that need be skipped from "in-memory cache".
|
|
cache_infile : bool
|
Utilized during initializing this class, to determine if the cache was able
|
to loaded from the specified cache path in 'cache_path'.
|
z
|
^(_|conf_)Nc G sn i | _ t | _d| _d | _| jr.| d¡ d S | j|| j | _ || _|rît
|
j |¡rî| d|¡ | d|¡}|s| jddd nlt|drt|d s¦| jd
|
dd nH| j |jkrä| d ¡ |j ¡ D ]\}}t| || qÆd| _n
|
| d ¡ | jsTt | j ¡}|rT| d ¡ |j ¡ D ]6\}}||jks t | j|¡rDq t| || q | t| j < t | j¡ d S )NFz cache is disabled by `Config`zload cache from file ->Úcachez)unable to load the cache file as a moduleTr ÚhashÚdatazinvalid cache filezhit the file cachezmiss the file cachezhit the memory cache) Úcache_meÚsetÚ cache_privateÚ cache_infileÚ _cache_pathry r£ Ú
|
cache_hashrt Ú _cache_hashru rv ÚexistsrÉ rµ rð rñ Úitemsr Ú _share_cacher¹ Ú__dict__rä rå Ú _cache_ignorerr rs Ú cache_flush)rc Ú
|
cache_pathÚfactorsZ cache_modÚattrÚvalZ other_cachere re rf rz sP
|
þ
|
ÿ
|
|
|
ÿ
|
z_Cache.__init__c C s, t ¡ D ] \}}|| krt |¡ q(qd S rh )rû rú r )rc Úhrê re re rf Ú__del__L s
|
z_Cache.__del__c C sº | j s
|
dS | d| j ¡ | j ¡ }| j ¡ D ] }t | j|¡r,| |¡ q,t j
|
| j ¡}t j
|
|¡snt |¡ tj|dd}t| j d(}| t d¡ | j¡¡ | |¡ W 5 Q R X dS )z)
|
Force update the cache.
|
Nzwrite cache to path ->T)ÚcompactÚwz¿ # AUTOGENERATED DON'T EDIT
|
# Please make changes to the code generator (distutils/ccompiler_opt.py)
|
hash = {}
|
data = \
|
)rö r£ rü ÚcopyÚkeysrä rå rý r ru rv r rù ÚmakedirsÚpprintÚpformatÚopenÚwriteÚtextwrapÚdedentÚformatrø )rc Zcdictr ÚdÚ repr_dictÚfre re rf rþ R s
|
|
úz_Cache.cache_flushc G sD d}|D ]6}t |D ](}t||d> |d> | }|dM }qq|S )Nr r é l ÿÿ )r Úord)rc r Zchashr Úcharre re rf r÷ n s z_Cache.cache_hashc s fdd}|S )zr
|
A static method that can be treated as a decorator to
|
dynamically cache certain methods.
|
c sN t jf|| ¡ | ¡ }|| jkr0| j| S | f||}|| j|< |S rh )r r{ r Úvaluesrò )rc r¾ r Ú cache_keyZccb©Úcbre rf Ú cache_wrap_me~ s ÿ ÿ
|
|
|
z _Cache.me.<locals>.cache_wrap_mere )r r re r rf Úmex s
|
z _Cache.me)N) r{ r| r} r~ rä r rý rz r rþ r÷ rí r re re re rf rî s
|
|
-
|
rî c @ s e Zd ZdZdd Zejdd Zejg fddZdd Z e
|
d
|
¡Z e
|
d ¡Z e
|
d ¡Ze
|
d ¡Zdd Ze
|
d¡Ze
|
d¡Zdd ZdS )Ú
|
_CCompilera2 A helper class for `CCompilerOpt` containing all utilities that
|
related to the fundamental compiler's functions.
|
|
Attributes
|
----------
|
cc_on_x86 : bool
|
True when the target architecture is 32-bit x86
|
cc_on_x64 : bool
|
True when the target architecture is 64-bit x86
|
cc_on_ppc64 : bool
|
True when the target architecture is 64-bit big-endian powerpc
|
cc_on_ppc64le : bool
|
True when the target architecture is 64-bit litle-endian powerpc
|
cc_on_s390x : bool
|
True when the target architecture is IBM/ZARCH on linux
|
cc_on_armhf : bool
|
True when the target architecture is 32-bit ARMv7+
|
cc_on_aarch64 : bool
|
True when the target architecture is 64-bit Armv8-a+
|
cc_on_noarch : bool
|
True when the target architecture is unknown or not supported
|
cc_is_gcc : bool
|
True if the compiler is GNU or
|
if the compiler is unknown
|
cc_is_clang : bool
|
True if the compiler is Clang
|
cc_is_icc : bool
|
True if the compiler is Intel compiler (unix like)
|
cc_is_iccw : bool
|
True if the compiler is Intel compiler (msvc like)
|
cc_is_nocc : bool
|
True if the compiler isn't supported directly,
|
Note: that cause a fail-back to gcc
|
cc_has_debug : bool
|
True if the compiler has debug flags
|
cc_has_native : bool
|
True if the compiler has native flags
|
cc_noopt : bool
|
True if the compiler has definition 'DISABLE_OPT*',
|
or 'cc_on_noarch' is True
|
cc_march : str
|
The target architecture name, or "unknown" if
|
the architecture isn't supported
|
cc_name : str
|
The compiler name, or "unknown" if the compiler isn't supported
|
cc_flags : dict
|
Dictionary containing the initialized flags of `_Config.conf_cc_flags`
|
c C sV t | drd S d}d}d}| ¡ }|\}}}|||fD ] }|D ]\} }
|
} t| | d q>q6||f||ffD ]N\} } | D ]@\} }
|
} |
|
rt |
|
| tj¡sqt| r¤| | ¡s¤qtt| | d qhqtqh|D ]<\} }
|
} |
|
rÜt |
|
|tj¡sÜq¼| rì| | ¡sìq¼t| | d q¼| jr | jd| ddd d| _ | j
|
r:| jd
|
dd d| _ | j r^| jd | ddd d| _ d | _ d D ]"}t| d| rh|| _ qqhd | _dD ]"}t| d| r|| _ qºqi | _| j | j¡}|d krè| d| j ¡ | ¡ D ]Z\}}g | j|< }|rðt|ts t| ¡ }|D ] }| |g¡r(| |¡ q(qðd| _d S )NÚ cc_is_cached))rW z.*(x|x86_|amd)64.*r )rV z.*(win32|x86|i386|i686).*r )r^ z&.*(powerpc|ppc)64(el|le).*|.*powerpc.*z4defined(__powerpc64__) && defined(__LITTLE_ENDIAN__))r_ z .*(powerpc|ppc).*|.*powerpc.*z1defined(__powerpc64__) && defined(__BIG_ENDIAN__))ra z.*(aarch64|arm64).*r )rb z.*arm.*z3defined(__ARM_ARCH_7__) || defined(__ARM_ARCH_7A__))r` z .*s390x.*r )Ú cc_on_noarchr r ))rX z.*(gcc|gnu\-g).*r )rY z .*clang.*r )r\ z.*(intelw|intelemw|iccw).*r )r[ z.*(intel|icc).*r )r] z.*msvc.*r )Ú
|
cc_is_noccr r ))Ú cc_has_debugz$.*(O0|Od|ggdb|coverage|debug:full).*r )Ú cc_has_nativez".*(-march=native|-xHost|/QxHost).*r )rU z.*DISABLE_OPT.*r FTz]unable to detect CPU architecture which lead to disable the optimization. check dist_info:<<
|
z
|
>>r z&Optimization is disabled by the Configzªunable to detect compiler type which leads to treating it as GCC. this is a normal behavior if you're using gcc-like compiler such as MinGW or IBM/XLC.check dist_info:<<
|
Úunknown)r r r r r r r Zcc_on_)r r r r r
|
Zcc_is_z=undefined flag for compiler '%s', leave an empty dict instead) rµ r¼ r rä rå Ú
|
IGNORECASEÚ cc_test_cexprr r£ rU r r rX Úcc_marchr Úcc_nameÚcc_flagsr r¹ rÁ rú r r r ÚsplitÚ cc_test_flagsrÌ r )rc Z detect_archZdetect_compilerZ detect_argsr¼ rº Z compiler_infor» Úsectionr ZrgexÚcexprr5 ZsearchinÚarchrÈ Zcompiler_flagsrR Znflagsr re re rf rz » s
|
|
|
|
ý
|
ü
|
|
|
ÿÿz_CCompiler.__init__c C sL t |tst| d|¡ tj | jd¡}| ||¡}|sH| jddd |S )z@
|
Returns True if the compiler supports 'flags'.
|
z testing flagsz test_flags.cútesting failedTr ) r r r r£ ru rv r r r© )rc rR Ú test_pathr§ re re rf r* / s z_CCompiler.cc_test_flagsc C sl | d|¡ tj | jd¡}t|d }| t d| d¡¡ W 5 Q R X | ||¡}|sh| j ddd |S ) zJ
|
Same as the above but supports compile-time expressions.
|
ztesting compiler expressionznpy_dist_test_cexpr.cr z #if !(zq)
|
#error "unsupported expression"
|
#endif
|
int dummy;
|
r. Tr )
|
r£ ru rv r ro r r r r r© )rc r, rR r/ Úfdr§ re re rf r% < s
|
ÿ z_CCompiler.cc_test_cexprc C sD t |tst| js | js | jr*| |¡S | js6| jr@| |¡S |S )a
|
Remove the conflicts that caused due gathering implied features flags.
|
|
Parameters
|
----------
|
'flags' list, compiler flags
|
flags should be sorted from the lowest to the highest interest.
|
|
Returns
|
-------
|
list, filtered from any conflicts.
|
|
Examples
|
--------
|
>>> self.cc_normalize_flags(['-march=armv8.2-a+fp16', '-march=armv8.2-a+dotprod'])
|
['armv8.2-a+fp16+dotprod']
|
|
>>> self.cc_normalize_flags(
|
['-msse', '-msse2', '-msse3', '-mssse3', '-msse4.1', '-msse4.2', '-mavx', '-march=core-avx2']
|
)
|
['-march=core-avx2']
|
)
|
r r r rX rY r[ Ú_cc_normalize_unixr] r\ Ú_cc_normalize_win)rc rR re re rf Úcc_normalize_flagsO s
|
|
z _CCompiler.cc_normalize_flagsz ^(-mcpu=|-march=|-x[A-Z0-9\-])zB^(?!(-mcpu=|-march=|-x[A-Z0-9\-]|-m[a-z0-9\-\.]*.$))|(?:-mzvector)z^(-mfpu|-mtune)z[0-9.]c sP fdd}t |dkr |S tt|D ]Ä\}}t j|¡s@q(|d |d
}|| d
}tt jj |}||\}} }
|
|dkrÎt |
|
dkrÎ|D ]"} || \} } }|| kr||
|
}
|
q| d d
|
|
|
¡ }||g }|dkrè||7 } qîq(g }t }t|D ]J}t j |¡}|sn"|d |kr.q n| |d ¡ | d|¡ q |S )Nc s@ | d¡}tdd t j|d ¡¡ }||d |dd
fS )Nú+Ú0r r r )r) Úfloatr rä ÚfindallÚ_cc_normalize_arch_ver)r ÚtokensÚver©rc re rf Ú ver_flags s
|
|
ÿz0_CCompiler._cc_normalize_unix.<locals>.ver_flagsr r r4 )r· Ú enumerateÚreversedrä rå Ú_cc_normalize_unix_mrgxr ÚfilterÚ_cc_normalize_unix_frgxÚsearchr ró Ú_cc_normalize_unix_krgxÚaddÚinsert)rc rR r< ÚiZcur_flagZ lower_flagsZ upper_flagsZfilterdr: r- ZsubflagsZxflagZxverÚ_Z xsubflagsZ final_flagsÚmatchedr rå re r; rf r1 sD ÿ
|
|
z _CCompiler._cc_normalize_unixz^(?!(/arch\:|/Qx\:))z ^(/arch|/Qx:)c C s^ t t|D ]L\}}t | j|¡s$q |d7 }tt| jj|d |
|| d
S |S )Nr ) r= r> rä rå Ú_cc_normalize_win_mrgxr r@ Ú_cc_normalize_win_frgxrB )rc rR rF r re re rf r2 · s ÿ þz _CCompiler._cc_normalize_winN)r{ r| r} r~ rz rî r r* r% r3 rä r r? rA rC r8 r1 rJ rI r2 re re re rf r s6 0t
|
þýþÿ1ÿÿr c @ sÈ e Zd ZdZdd Zddg fddZdd Zd%d
|
d Zd&d d Zdd Z dd Z
|
dd Z dd Z dd Z ejdd Zejdg fddZejdg fd d Zejd d Zejd d! Zd'd#d$ZdS )(Ú_Featureaâ A helper class for `CCompilerOpt` that managing CPU features.
|
|
Attributes
|
----------
|
feature_supported : dict
|
Dictionary containing all CPU features that supported
|
by the platform, according to the specified values in attribute
|
`_Config.conf_features` and `_Config.conf_features_partial()`
|
|
feature_min : set
|
The minimum support of CPU features, according to
|
the specified values in attribute `_Config.conf_min_features`.
|
c s t | drd S | ¡ | _}t| ¡ D ]}|| | j| } fdd| ¡ D ¡ d¡}|d k r| |¡ | j
|
d| |dd q(dD ]$} |¡}t |t r| ¡ |< qq(t | _| j | jd ¡}| ¡ ¡ D ]}|| jkrÜ| j |¡ qÜd| _d S )
|
NÚfeature_is_cachedc s i | ]\}}| kr||qS re re )rÒ ÚkÚv©Úfeaturere rf Ú
|
<dictcomp>Ö s z%_Feature.__init__.<locals>.<dictcomp>rS zfeature '%s' is disabled,Tr )r r4 r5 r rR r. r )rµ rg Úfeature_supportedr r r Úupdaterú r¹ r r£ r r r) ró Ú feature_minr r& ÚupperrD rL ) rc Z pfeaturesÚ feature_nameZcfeatureÚdisabledÚoptionZovalZmin_fÚFre rO rf rz Ï s8
|
|
ÿ
|
|
þ
|
|
|
z_Feature.__init__Nc C sv |dks t |ts t|ds t|dks6t |ts6t|dkrH| j ¡ }t }|D ] }| j|||drR| |¡ qR|S )a
|
Returns a set of CPU feature names that supported by platform and the **C** compiler.
|
|
Parameters
|
----------
|
names : sequence or None, optional
|
Specify certain CPU features to test it against the **C** compiler.
|
if None(default), it will test all current supported features.
|
**Note**: feature names must be in upper-case.
|
|
force_flags : list or None, optional
|
If None(default), default compiler flags for every CPU feature will
|
be used during the test.
|
|
macros : list of tuples, optional
|
A list of C macro definitions.
|
Nr± ©Ú force_flagsr )
|
r r rµ r r rR r ró Úfeature_is_supportedrD )rc Únamesr[ r Zsupported_namesr re re rf Ú feature_namesñ s$ ÿþý
|
ÿ z_Feature.feature_namesc C s | ¡ s t|| jkS )zÒ
|
Returns True if a certain feature is exist and covered within
|
`_Config.conf_features`.
|
|
Parameters
|
----------
|
'name': str
|
feature name in uppercase.
|
)Úisupperr r )rc rÈ re re rf Úfeature_is_exist s
|
z_Feature.feature_is_existFc s fdd}t |||dS )az
|
Sort a list of CPU features ordered by the lowest interest.
|
|
Parameters
|
----------
|
'names': sequence
|
sequence of supported feature names in uppercase.
|
'reverse': bool, optional
|
If true, the sorted features is reversed. (highest interest)
|
|
Returns
|
-------
|
list, sorted CPU features
|
c sB t | tr j| d S t fdd| D }|t| d 7 }|S )Nr c s g | ]} j | d qS )r )rR ©rÒ r r; re rf rÓ 4 s z<_Feature.feature_sorted.<locals>.sort_cb.<locals>.<listcomp>r )r r rR Úmaxr· )rM Zrankr; re rf Úsort_cb0 s
|
|
z(_Feature.feature_sorted.<locals>.sort_cb)ÚreverseÚkey)Úsorted)rc r] rd rc re r; rf Úfeature_sorted! s z_Feature.feature_sortedc sl t f fdd t|tr. |}|g}n,t|ds<tt }|D ]}| |¡}qF|sh| |¡ |S )aÇ
|
Return a set of CPU features that implied by 'names'
|
|
Parameters
|
----------
|
names : str or sequence of str
|
CPU feature name(s) in uppercase.
|
|
keep_origins : bool
|
if False(default) then the returned set will not contain any
|
features from 'names'. This case happens only when two features
|
imply each other.
|
|
Examples
|
--------
|
>>> self.feature_implies("SSE3")
|
{'SSE', 'SSE2'}
|
>>> self.feature_implies("SSE2")
|
{'SSE'}
|
>>> self.feature_implies("SSE2", keep_origins=True)
|
# 'SSE2' found here since 'SSE' and 'SSE2' imply each other
|
{'SSE', 'SSE2'}
|
c sT t }j| }| dg ¡D ]2}| |¡ ||kr4q | | ¡ | ||¡}q |S )Nr )ró rR r¹ rD Úunion)rÈ Z_callerr r rF ©Ú get_impliesrc re rf rj S s
|
|
|
z-_Feature.feature_implies.<locals>.get_impliesr± )ró r r rµ r rh Údifference_update)rc r] Ú keep_originsr Únre ri rf Úfeature_implies; s
|
|
z_Feature.feature_impliesc C s. t |trt|f}nt|}| | |¡¡S )z/same as feature_implies() but combining 'names')r r ró rh rn )rc r] re re rf Úfeature_implies_cl s
|
z_Feature.feature_implies_cc s^ t |tst|dst| j|dd fdd|D }t|dkrZ| j|dddd
}|S )
|
a
|
Return list of features in 'names' after remove any
|
implied features and keep the origins.
|
|
Parameters
|
----------
|
'names': sequence
|
sequence of CPU feature names in uppercase.
|
|
Returns
|
-------
|
list of CPU features sorted as-is 'names'
|
|
Examples
|
--------
|
>>> self.feature_ahead(["SSE2", "SSE3", "SSE41"])
|
["SSE41"]
|
# assume AVX2 and FMA3 implies each other and AVX2
|
# is the highest interest
|
>>> self.feature_ahead(["SSE2", "SSE3", "SSE41", "AVX2", "FMA3"])
|
["AVX2"]
|
# assume AVX2 and FMA3 don't implies each other
|
>>> self.feature_ahead(["SSE2", "SSE3", "SSE41", "AVX2", "FMA3"])
|
["AVX2", "FMA3"]
|
r± T)rl c s g | ]}| kr|qS re re )rÒ rm ©r re rf rÓ s z*_Feature.feature_ahead.<locals>.<listcomp>r ©rd Nr )r r rµ r rn r· rg )rc r] Zaheadre rp rf Ú feature_aheadt s ÿþ z_Feature.feature_aheadc s t |tst|dstg }|D ]j ¡ fdd|D }|r |g ¡}|dd
krjq | |dd
d ¡ | ¡ q |S )am
|
same as 'feature_ahead()' but if both features implied each other
|
and keep the highest interest.
|
|
Parameters
|
----------
|
'names': sequence
|
sequence of CPU feature names in uppercase.
|
|
Returns
|
-------
|
list of CPU features sorted as-is 'names'
|
|
Examples
|
--------
|
>>> self.feature_untied(["SSE2", "SSE3", "SSE41"])
|
["SSE2", "SSE3", "SSE41"]
|
# assume AVX2 and FMA3 implies each other
|
>>> self.feature_untied(["SSE2", "SSE3", "SSE41", "FMA3", "AVX2"])
|
["SSE2", "SSE3", "SSE41", "AVX2"]
|
r± c s& g | ] }| kr |¡kr|qS re )rn )rÒ Únn©r rm rc re rf rÓ · s ÿz+_Feature.feature_untied.<locals>.<listcomp>r Nr )r r rµ r rn rg ÚremoverÌ )rc r] ÚfinalZtiedre rt rf Úfeature_untied s" ÿþ
|
ÿ z_Feature.feature_untiedc s^ fddt |ts$t|dkr8|}| ¡ |S |¡}fdd|D } |¡S )zÝ
|
same as `feature_implies_c()` but stop collecting implied
|
features when feature's option that provided through
|
parameter 'keyisfalse' is False, also sorting the returned
|
features.
|
c sT | ¡} j| dd} t| D ].\}}j| d¡s | d |d
} qPq | S )NTrq r )ro rg r= rR r¹ )ZtnamesrF rm )Ú
|
keyisfalserc re rf ÚtilÊ s
|
z%_Feature.feature_get_til.<locals>.tilr c s h | ]} |D ]}|qqS re re )rÒ rm Út)ry re rf Ú <setcomp>Û s
|
z+_Feature.feature_get_til.<locals>.<setcomp>)r r r· rd rr rg )rc r] rx re )rx rc ry rf Úfeature_get_tilà s
|
|
z_Feature.feature_get_tilc C sB | |d¡}g }|D ](}| j| }|| d| d|g¡¡7 }q|S )z
|
Return a list of CPU features that required to be detected
|
sorted from the lowest to highest interest.
|
r% r5 r4 )r| rR r¹ )rc r] r5 rm r re re rf Úfeature_detectÞ s
|
z_Feature.feature_detectc C sV | | |¡¡}g }|D ]2}| j| }| dg ¡}|r| |¡sBq||7 }q| |¡S )zi
|
Return a list of CPU features flags sorted from the lowest
|
to highest interest.
|
rR )rg ro rR r¹ r* r3 )rc r] rR rm r r re re rf Ú feature_flagsê s
|
|
z_Feature.feature_flagsc C s |dkr| |¡}| d|d |¡f ¡ tj | jd| ¡ ¡}tj |¡sZ| d|¡ | j ||| j
|
d |d}|s| jdd d
|
|S ) a
|
Test a certain CPU feature against the compiler through its own
|
check file.
|
|
Parameters
|
----------
|
name : str
|
Supported CPU feature name.
|
|
force_flags : list or None, optional
|
If None(default), the returned flags from `feature_flags()`
|
will be used.
|
|
macros : list of tuples, optional
|
A list of C macro definitions.
|
Nz$testing feature '%s' with flags (%s)r² zcpu_%s.cz feature test file is not existr ©r r. Tr ) r~ r£ r ru rv r Úlowerrù rÁ r© r( )rc rÈ r[ r r/ r§ re re rf Ú feature_testú s,
|
ÿÿ
|
ÿ ÿz_Feature.feature_testc C sn | ¡ s t|dks"t|ts"t|| jk}|rj| |¡D ]}| j|||ds: dS q:| j|||dsjdS |S )aµ
|
Check if a certain CPU feature is supported by the platform and compiler.
|
|
Parameters
|
----------
|
name : str
|
CPU feature name in uppercase.
|
|
force_flags : list or None, optional
|
If None(default), default compiler flags for every CPU feature will
|
be used during test.
|
|
macros : list of tuples, optional
|
A list of C macro definitions.
|
Nr F)r_ r r r rR rn r )rc rÈ r[ r Ú supportedÚimplre re rf r\ " s
|
z _Feature.feature_is_supportedc sV t |tst j| }| dd¡}|dkrR fdd| dg ¡D }|oPt|}|S )zM
|
check if the feature can be auto-vectorized by the compiler
|
rT Nc s g | ]} |g¡qS re )r* ra r; re rf rÓ H s z0_Feature.feature_can_autovec.<locals>.<listcomp>rR )r r r rR r¹ Úany)rc rÈ r ÚcanZ valid_flagsre r; rf Úfeature_can_autovec? s
|
|
|
ÿ z _Feature.feature_can_autovecc
|
C sÐ t |tst| j| }| dg ¡}|s,g S | d| |¡ | |¡}g }g }|D ]d}tj | j
|
d| ¡ ¡}tj |¡s| d|¡ | ||| jd ¡} | r¬| |¡ qR| |¡ qR|rÌ| jd|dd |S ) zÐ
|
Return a list of supported extra checks after testing them against
|
the compiler.
|
|
Parameters
|
----------
|
names : str
|
CPU feature name in uppercase.
|
r. z%Testing extra checks for feature '%s'z
|
extra_%s.cz extra check file does not existr ztesting failed for checksTr )r r r rR r¹ r£ r~ ru rv r r r rù rÁ r© r( rÌ )
|
rc rÈ r r. rR Ú availableZ not_availableZchkr/ Ú is_supportedre re rf Úfeature_extra_checksN s.
|
|
|
ÿ z _Feature.feature_extra_checksr c s¾ | ¡ s t| j |¡}|dk s$td| d| j|f g}|dd | dg ¡D 7 }| dg ¡}|| |¡7 }|D ]&}|d| j|f d | j|f d
|
g7 }qr d kr´ fd d|D }d |¡S )a"
|
Generate C preprocessor definitions and include headers of a CPU feature.
|
|
Parameters
|
----------
|
'feature_name': str
|
CPU feature name in uppercase.
|
'tabs': int
|
if > 0, align the generated strings to the right depend on number of tabs.
|
|
Returns
|
-------
|
str, generated C preprocessor
|
|
Examples
|
--------
|
>>> self.feature_c_preprocessor("SSE3")
|
/** SSE3 **/
|
#define NPY_HAVE_SSE3 1
|
#include <pmmintrin.h>
|
Nz
|
/** %s **/z#define %sHAVE_%s 1c S s g | ] }d | qS )z #include <%s>re )rÒ r re re rf rÓ s z3_Feature.feature_c_preprocessor.<locals>.<listcomp>r r4 z#ifndef %sHAVE_%sz #define %sHAVE_%s 1z#endifr c s g | ]}d | qS )ú re )rÒ Úl©Útabsre rf rÓ £ s Ú
|
)r_ r rR r¹ r
r r )rc rV r rP ZpreprZ
|
extra_defsZedefre r rf Úfeature_c_preprocessoru s( þ
|
ÿ ýz _Feature.feature_c_preprocessor)F)F)r )r{ r| r} r~ rz r^ r` rg rn ro rr rw r| r} rî r r~ r r\ r r r re re re rf rK Á s, "#
|
|
1&)
|
'
|
|
&rK c @ s e Zd ZdZdd Zdd Ze d¡Zdd Z e d ¡Z
|
d
|
d Z d d Z dd Z dd Zdd Zdd Zdd Zdd Zdd Zd d Zd S ) Ú_Parseaé A helper class that parsing main arguments of `CCompilerOpt`,
|
also parsing configuration statements in dispatch-able sources.
|
|
Parameters
|
----------
|
cpu_baseline : str or None
|
minimal set of required CPU features or special options.
|
|
cpu_dispatch : str or None
|
dispatched set of additional CPU features or special options.
|
|
Special options can be:
|
- **MIN**: Enables the minimum CPU features that utilized via `_Config.conf_min_features`
|
- **MAX**: Enables all supported CPU features by the Compiler and platform.
|
- **NATIVE**: Enables all CPU features that supported by the current machine.
|
- **NONE**: Enables nothing
|
- **Operand +/-**: remove or add features, useful with options **MAX**, **MIN** and **NATIVE**.
|
NOTE: operand + is only added for nominal reason.
|
|
NOTES:
|
- Case-insensitive among all CPU features and special options.
|
- Comma or space can be used as a separator.
|
- If the CPU feature is not supported by the user platform or compiler,
|
it will be skipped rather than raising a fatal error.
|
- Any specified CPU features to 'cpu_dispatch' will be skipped if its part of CPU baseline features
|
- 'cpu_baseline' force enables implied features.
|
|
Attributes
|
----------
|
parse_baseline_names : list
|
Final CPU baseline's feature names(sorted from low to high)
|
parse_baseline_flags : list
|
Compiler flags of baseline features
|
parse_dispatch_names : list
|
Final CPU dispatch-able feature names(sorted from low to high)
|
parse_target_groups : dict
|
Dictionary containing initialized target groups that configured
|
through class attribute `conf_target_groups`.
|
|
The key is represent the group name and value is a tuple
|
contains three items :
|
- bool, True if group has the 'baseline' option.
|
- list, list of CPU features.
|
- list, list of extra compiler flags.
|
|
c s¦ t d jg f j jg f jd g f jd g f jd dgfd _t drNd S g _ g _
|
g _ i _ j rtd }} d¡ |d k rº d|¡} |¡} |¡ _
|
|¡¡ _ d¡ |d k r$ d|¡} fdd |D }| |¡} |¡¡ _ t|d
|
kr$ d |d ¡ d ¡ j ¡ D ]b\}} d|¡ | ¡ }|rd| ¡ sxdg g f j |< q8 |¡\} }
|
} | |
|
| f j |< q8d _d S )NÚMAXOPT)Z KEEP_BASELINEZ KEEP_SORTr ZWERRORZAUTOVECÚparse_is_cachedzcheck requested baselineÚ cpu_baselinez&check requested dispatch-able featuresÚ cpu_dispatchc s h | ]}| j kr|qS re ©Úparse_baseline_namesra r; re rf r{ s
|
ÿz"_Parse.__init__.<locals>.<setcomp>r z skip featureszsince its part of baselinezinitialize targets groupszparse target groupFT) rZ Ú_parse_policy_not_keepbaseÚ_parse_policy_keepsortÚ_parse_policy_not_keepsortÚ_parse_policy_maxoptÚ_parse_policy_werrorÚ_parse_policy_autovecÚ_parse_policiesrµ r Úparse_baseline_flagsÚparse_dispatch_namesÚparse_target_groupsrU r£ Ú_parse_arg_featuresr^ r~ rg ro Ú
|
differencer· r rú rU ÚstripÚ_parse_target_tokensr ) rc r r Úbaseline_namesZ cpu_dispatch_Zconflict_baselineZ
|
group_namer9 Z
|
GROUP_NAMEÚ has_baselineÚfeaturesÚ extra_flagsre r; rf rz Õ s þý þ þ þí
|
|
|
ÿ
|
|
|
ÿ
|
ÿ ÿ
|
ÿ
|
ÿ ÿz_Parse.__init__c C sü | d|¡ t| }d}d}d}d}d}d}t|D ]x\} }
|
| |krT| d¡ q°|dkr||
|
|¡}|dkrpq6|t|7 }||
|
7 }|
|
|¡}|dkr6|t|t|
|
7 } q°q6W 5 Q R X |dkrÐ| d| ¡ |dkræ| d | ¡ |||
}| |¡S )
|
aÖ
|
Fetch and parse configuration statements that required for
|
defining the targeted CPU features, statements should be declared
|
in the top of source in between **C** comment and start
|
with a special mark **@targets**.
|
|
Configuration statements are sort of keywords representing
|
CPU features names, group of statements and policies, combined
|
together to determine the required optimization.
|
|
Parameters
|
----------
|
source : str
|
the path of **C** source file.
|
|
Returns
|
-------
|
- bool, True if group has the 'baseline' option
|
- list, list of CPU features
|
- list, list of extra compiler flags
|
z!looking for '@targets' inside -> r iè z@targetséÿÿÿÿz*/zreached the max of linesz(expected to find '%s' within a C commentzexpected to end with '%s')r£ r r= rÁ Úfindr· r¤ ) rc r¤ r0 r9 Z max_to_reachZ
|
start_withZ start_posZend_withZend_posÚ current_lineÚlinere re rf Ú parse_targets' s8
|
|
|
|
z_Parse.parse_targetsz \s|,|([+-])c
|
C s> t |ts| d| ¡ t }ttd t | j|¡}d}|D ]ú}|d dkrZ| |d¡ |dkrhd}q>|dkrvd}q>| ¡ }t }|d krn|d
|
krÂ| j
|
d } | s°| |d ¡ | j | d gd}nV|dkrÖ| j ¡ }nB|dkræ| j}n2|| j krü| |¡ n | |¡s| |d| ¡ |r*| |¡}n
|
| |¡}d}q>|S )Nzexpected a string in '%s'Tr )ú#ú$zYtarget groups and policies aren't allowed from arguments, only from dispatch-able sourcesr4 ú-FÚNONEZNATIVEr z-native option isn't supported by the compiler)ZDETECT_FEATURESr rZ ÚMAXZMINz&, '%s' isn't a known feature or option)r r rÁ ró r r@ rä r) Ú_parse_regex_argrU r( r^ rR r rT rD r` rh r¢ )
|
rc Zarg_nameZ req_featuresZfinal_featuresr9 rÌ ÚtokÚTOKZ features_tor re re rf r¡ ^ s\
|
ÿ
|
ÿ ÿ
|
ÿ
|
z_Parse._parse_arg_featuresz\s|[*,/]|([()])c C sø t |tstg }g }d}t }t }d }ttd t | j|¡}|sP| d¡ |D ]°}|
|
¡ } |d }
|
|
|
dkr~| d¡ qT|
|
dkrª|d k r| d¡ | | | ¡¡ qT|
|
dkrÜ|d k rÄ| d ¡ | | |||¡\}}}qT|
|
d
|
kr |d k rø| d ¡ t }qT|
|
d krx|d kr | d ¡ | |¡} | d krB| t|¡ n0t| dkrX| d } | rr| |krr| | ¡ d }qT| dkr|d k r| d¡ d}qT|d k r²| | ¡ qT| | ¡sÌ| d| ¡ | | jkpà| | jk} | rü| |krT| | ¡ qT| | ¡ qT|d k r | d ¡ |r0| d|d¡ | |¡}t|D ]L} | j| \}}}|D ]0}||krlqZ| d| |f ¡ | |¡ qZqB| j ¡ D ]R\} \}}}d }| |krÊ|}| d| ¡ n|}|sØq||||\}}}q|||fS )NFzexpected one token at leastr )r4 r° ze+/- are 'not' allowed from target's groups or @targets, only from cpu_baseline and cpu_dispatch parmsr¯ zCpolicies aren't allowed inside multi-target '()', only CPU featuresr® zHtarget groups aren't allowed inside multi-target '()', only CPU featuresrÊ z"unclosed multi-target, missing ')'rË z$multi-target opener '(' wasn't foundr ZBASELINEz/baseline isn't allowed inside multi-target '()'Tzinvalid target name '%s'z skip targetsz.not part of baseline or dispatch-able featuresz policy '%s' force enables '%s'zpolicy '%s' is ON)r r r ró r r@ rä r) Ú_parse_regex_targetrÁ rU rD Ú_parse_token_policyÚ_parse_token_groupÚ_parse_multi_targetÚtupler· rÌ r` r r r£ rw r rú )rc r9 Ú final_targetsr¨ r¦ ÚskippedZpoliciesZ multi_targetr´ rµ ÚchÚtargetsÚ
|
is_enabledÚprG Údepsr ZhaveZnhaveÚfuncre re rf r¤ sÄ
|
|
ÿÿÿÿ
|
|
|
|
|
|
|
|
|
|
|
|
|
|
þ
|
|
|
þ
|
|
ÿÿ
|
ÿz_Parse._parse_target_tokensc C sZ t |dks |dd
|d kr*| d¡ |dd
}|| jkrV| d| | j ¡ ¡ |S )zvalidate policy tokenr r© Nr z*'$' must stuck in the begin of policy namez6'%s' is an invalid policy name, available policies are)r· rÁ r r )rc Útokenre re rf r· s
|
|
þz_Parse._parse_token_policyc s° t |dks |dd
|d kr*| d¡ |dd
}| j |ddg f¡\}}}|dkrr| d| d | j ¡ ¡ |rzd }fd
|
d |D 7 fd d |D 7 | fS ) zvalidate group tokenr r© Nr z)'#' must stuck in the begin of group nameFz&'%s' is an invalid target group name, zavailable target groups areTc s g | ]}| kr|qS re re ra )r» re rf rÓ ) s z-_Parse._parse_token_group.<locals>.<listcomp>c s g | ]}| kr|qS re re ra )r¨ re rf rÓ * s )r· rÁ r r¹ r )rc rà r¦ r» r¨ Z ghas_baselineZgtargetsZ gextra_flagsre )r¨ r» rf r¸ s&
|
ÿ
|
ÿýz_Parse._parse_token_groupc sr |s d¡ t fdd|D s0 d|¡ t fdd|D sJdS |¡}|s\dS |¡}t|}|S )z9validate multi targets that defined between parentheses()zempty multi-target '()'c s g | ]} |¡qS re )r` ©rÒ Útarr; re rf rÓ 2 s z._Parse._parse_multi_target.<locals>.<listcomp>z#invalid target name in multi-targetc s g | ]}| j kp| jkqS re )r r rÄ r; re rf rÓ 6 s ý
|
N)rÁ Úallrr rg rº )rc r¾ re r; rf r¹ - s
|
ÿ û
|
|
z_Parse._parse_multi_targetc sx g }|dd
D ]L}d}t |tr.| jk}nt fdd|D }|r| |¡ | |¡ q|rn d|¡ |||fS )zskip all baseline featuresNFc s g | ]}| j kqS re r ra r; re rf rÓ O s ÿz5_Parse._parse_policy_not_keepbase.<locals>.<listcomp>zskip baseline features)r r r rÆ rÌ ru r£ )rc r¦ r» r¨ r¼ rÅ Zis_basere r; rf r F s
|
þ
|
z!_Parse._parse_policy_not_keepbasec C s | d|d¡ |||fS )z$leave a notice that $keep_sort is onz/policy 'keep_sort' is on, dispatch-able targetszo
|
are 'not' sorted depend on the highest interest butas specified in the dispatch-able source or the extra group)r£ ©rc r¦ r» r¨ re re rf r \ s ÿz _Parse._parse_policy_keepsortc C s | j |dd}|||fS )z%sorted depend on the highest interestTrq )rg rÇ re re rf r e s z!_Parse._parse_policy_not_keepsortc C sT | j r| d¡ n8| jr$| d¡ n&| jd }|sB| jddd n||7 }|||fS )z&append the compiler optimization flagsz3debug mode is detected, policy 'maxopt' is skipped.z5optimization is disabled, policy 'maxopt' is skipped.r zOcurrent compiler doesn't support optimization flags, policy 'maxopt' is skippedTr )r! r£ rU r( ©rc r¦ r» r¨ rR re re rf r j s
|
þz_Parse._parse_policy_maxoptc C s: | j d }|s | jddd n| d¡ ||7 }|||fS )z#force warnings to treated as errorsr zTcurrent compiler doesn't support werror flags, warnings will 'not' treated as errorsTr z'compiler warnings are treated as errors)r( r£ rÈ re re rf r { s
|
þ
|
z_Parse._parse_policy_werrorc st g }|dd
D ]H}t |tr* |¡}nt fdd|D }|s| |¡ | |¡ q|rj d|¡ |||fS )z=skip features that has no auto-vectorized support by compilerNc s g | ]} |¡qS re )r ©rÒ rz r; re rf rÓ s ÿz0_Parse._parse_policy_autovec.<locals>.<listcomp>z!skip non auto-vectorized features)r r r rÆ ru rÌ r£ )rc r¦ r» r¨ r¼ rÅ r
re r; rf r s
|
þ
|
z _Parse._parse_policy_autovecN)r{ r| r} r~ rz r rä r r³ r¡ r¶ r¤ r· r¸ r¹ r r r r r r re re re rf r ¦ s .R6
|
8
|
t r c @ sj e Zd ZdZdddZdd Zd d
|
Zd d Zd d ZdddZ dd Z
|
d ddZ d ddZ d ddZ dS ) Ú CCompilerOptz°
|
A helper class for `CCompiler` aims to provide extra build options
|
to effectively control of compiler optimizations that are directly
|
related to CPU features.
|
Úminrb Nc C s t | ¡ t | |¡ t | || ¡ ||¡ t | ¡ t | ¡ | jsZ| jrZ| d¡ d}t
|
| ||¡ || _ || _ t | di | _| j d¡ t| d| _d S )NzSnative flag is specified through environment variables. force cpu-baseline='native'r Úsources_statusÚ hit_cache)r rz r rî r¼ r rK rU r" r£ r Ú_requested_baselineÚ_requested_dispatchr rÌ rô rD rµ rÍ )rc r r r rÿ re re rf rz ¢ s
|
|
|
ÿ zCCompilerOpt.__init__c C s | j o
|
| jS )zF
|
Returns True if the class loaded from the cache file
|
)rõ rÍ r; re re rf Ú is_cached¼ s zCCompilerOpt.is_cachedc C s | j S )zE
|
Returns a list of final CPU baseline compiler flags
|
)r r; re re rf Úcpu_baseline_flags s z CCompilerOpt.cpu_baseline_flagsc C s | j S )zC
|
return a list of final CPU baseline feature names
|
r r; re re rf Úcpu_baseline_namesÈ s z CCompilerOpt.cpu_baseline_namesc C s | j S )zC
|
return a list of final CPU dispatch feature names
|
)r r; re re rf Úcpu_dispatch_namesÎ s z CCompilerOpt.cpu_dispatch_namesc K s& i }| ¡ }| dg ¡}|D ]Î}tj |¡} |rZ| |¡sHtj || ¡} | |krZ| | ¡ | |¡\}
|
} } | | || |
|
¡} | D ]:}| j
|
| ||| d}t | | |¡ }| |g ¡ |¡ q~|
|
rÜt | | }| |g ¡ |¡ |
|
| f| j |< q g }| ¡ D ](\}}|| j|t|fd|i|7 }qø|S )a
|
Compile one or more dispatch-able sources and generates object files,
|
also generates abstract C config headers and macros that
|
used later for the final runtime dispatching process.
|
|
The mechanism behind it is to takes each source file that specified
|
in 'sources' and branching it into several files depend on
|
special configuration statements that must be declared in the
|
top of each source which contains targeted CPU features,
|
then it compiles every branched source with the proper compiler flags.
|
|
Parameters
|
----------
|
sources : list
|
Must be a list of dispatch-able sources file paths,
|
and configuration statements must be declared inside
|
each file.
|
|
src_dir : str
|
Path of parent directory for the generated headers and wrapped sources.
|
If None(default) the files will generated in-place.
|
|
ccompiler : CCompiler
|
Distutils `CCompiler` instance to be used for compilation.
|
If None (default), the provided instance during the initialization
|
will be used instead.
|
|
**kwargs : any
|
Arguments to pass on to the `CCompiler.compile()`
|
|
Returns
|
-------
|
list : generated object files
|
|
Raises
|
------
|
CompileError
|
Raises by `CCompiler.compile()` on compiling failure.
|
DistutilsError
|
Some errors during checking the sanity of configuration statements.
|
|
See Also
|
--------
|
parse_targets :
|
Parsing the configuration statements of dispatch-able sources.
|
Ú include_dirs)Únochanger )rÑ Ú
|
setdefaultru rv r Ú
|
startswithr rÌ r Ú_generate_configÚ _wrap_targetrº r~ rÌ rú r r )rc r Úsrc_dirr r Z
|
to_compileÚbaseline_flagsrÔ Úsrcr r¦ r¾ r¨ rÕ rÅ Ztar_srcrR ZobjectsZsrcsre re rf Ú try_dispatchÔ s> /
|
|
ÿÿÿ
|
zCCompilerOpt.try_dispatchc sZ d| ¡ ¡ } ¡ }t|}t|}tj |¡}tj |¡sf j d| ddd t |¡ t |dà}d
|
fdd |D ¡}d
|
fd
|
d |D ¡} | t d ¡j jd
|
|¡d
|
|¡|||| d ¡ d}
|
|D ]} |
|
j| ddd 7 }
|
qÜd} |D ],} | t d¡j j| j| ddd7 } q | t d¡j j|
|
| d¡ W 5 Q R X dS )ax
|
Generate the dispatch header which contains the #definitions and headers
|
for platform-specific instruction-sets for the enabled CPU baseline and
|
dispatch-able features.
|
|
Its highly recommended to take a look at the generated header
|
also the generated source files via `try_dispatch()`
|
in order to get the full picture.
|
z"generate CPU dispatch header: (%s)zdispatch header dir z does not exist, creating itTr r ú \
|
c s g | ]}d j |f qS ©z3 %sWITH_CPU_EXPAND_(MACRO_TO_CALL(%s, __VA_ARGS__))©r
ra r; re rf rÓ E s þþz9CCompilerOpt.generate_dispatch_header.<locals>.<listcomp>c s g | ]}d j |f qS rß rà ra r; re rf rÓ K s þþaà /*
|
* AUTOGENERATED DON'T EDIT
|
* Please make changes to the code generator (distutils/ccompiler_opt.py)
|
*/
|
#define {pfx}WITH_CPU_BASELINE "{baseline_str}"
|
#define {pfx}WITH_CPU_DISPATCH "{dispatch_str}"
|
#define {pfx}WITH_CPU_BASELINE_N {baseline_len}
|
#define {pfx}WITH_CPU_DISPATCH_N {dispatch_len}
|
#define {pfx}WITH_CPU_EXPAND_(X) X
|
#define {pfx}WITH_CPU_BASELINE_CALL(MACRO_TO_CALL, ...) \
|
{baseline_calls}
|
#define {pfx}WITH_CPU_DISPATCH_CALL(MACRO_TO_CALL, ...) \
|
{dispatch_calls}
|
r² )ÚpfxZ baseline_strZ dispatch_strÚ baseline_lenÚ dispatch_lenÚbaseline_callsÚdispatch_callsr r r r z #ifdef {pfx}CPU_TARGET_{name}
|
{pre}
|
#endif /*{pfx}CPU_TARGET_{name}*/
|
)rá rÈ Úprez¢ /******* baseline features *******/
|
{baseline_pre}
|
/******* dispatch features *******/
|
{dispatch_pre}
|
)rá Ú baseline_preÚ dispatch_preN)r£ rÒ rÓ r· ru rv r rù r r r r r r r r
r r ) rc Z header_pathr¥ Údispatch_namesrâ rã Ú
|
header_dirr rä rå rç rÈ rè re r; rf Úgenerate_dispatch_header+ s\
|
|
þ
|
üü î ÿû ùz%CCompilerOpt.generate_dispatch_headerFc C s g }g }g }g }| d|f¡ | d¡ | d|f¡ | d¡ | d|f¡ | d| jr^dn| jf¡ | d| jrxdn| jf¡ | jr| d ¡ n| d
|
t| jf¡ | ¡ }| d |rÄd |¡nd f¡ |
|
¡ }| d|rèd |¡nd f¡ g }|D ]} || | ¡7 }qø| d|r"d |¡nd f¡ | jr>| d ¡ n| d
|
t| j f¡ | ¡ }
|
| d |
|
rpd |
|
¡nd f¡ i } | j ¡ D ],\} \} }|D ]}| |g ¡ | ¡ qq|rÀ| s4d}| | ¡D ]@}| | }t|trê|n dd |¡ } || dt| 7 }qÎ| d|r(|d d
nd f¡ n| d¡ | | ¡D ]}| | }t|trf|n dd |¡ }d | |¡¡}d | | |¡¡¡}d | |¡¡}g }t|trÀ|fn|D ]} || | ¡7 }qÄ|rêd |¡nd }| d¡ | ||f¡ | d|f¡ | d|f¡ | d|f¡ |D ]}| d|f¡ q4qHg }dd |D }dd |D }d}tt|t|}|D ]~\} } | s¤| d¡ q| d |t| 7 } | | | d ¡ | D ]4\} } | d |t| 7 } | || d | ¡ qÎqd |¡S ) NÚPlatform)r r z CPU baselinez CPU dispatchZ ArchitectureÚ unsupportedZCompilerz unix-like)Ú Requestedzoptimization disabledrî ZEnabledr² ÚnoneZFlagsz Extra checksr z(%s)z[%d] Ú Generatedr© )rð r ZDetectc S s g | ]\}}t |qS re ©r· )rÒ ZsecsrG re re rf rÓ Û s z'CCompilerOpt.report.<locals>.<listcomp>c S s& g | ] \}}|D ]\}}t |qqS re rñ )rÒ rG ÚrowsÚcolre re rf rÓ Ü s z z: r )rÌ r r& r r' rU ÚreprrÎ rÒ r rÑ r rÏ rÓ rÌ rú rÖ rg r r r· r~ rn r} rb ) rc ÚfullÚreportZ platform_rowsZ baseline_rowsZ dispatch_rowsr¥ rÛ r. rÈ ré Ztarget_sourcesr¤ rG r¾ rÅ Ú generatedr Z pretty_namerR r r5 rÜ rÞ Zsecs_lenZcols_lenÚtabÚpadÚsecrò ró r re re rf rö ~ s®
|
|
ÿÿ ÿ ÿ ÿ ÿ $
|
|
|
zCCompilerOpt.reportc s t |ttfstt |tr&| }}nd |¡}d |¡}tj |tj |¡¡}djtj |¡|
|
¡ f }|rtj |¡r|S | d|¡ | | |¡¡}d| j fdd|D } d | ¡} t|d .}
|
|
|
t d
|
¡j| j|tj |¡| d ¡ W 5 Q R X |S ) NÚ.Ú__z
|
{0}.{2}{1}z wrap dispatch-able target -> z#define %sCPU_TARGET_c s g | ] } | qS re re ra ©Z target_joinre rf rÓ ý s z-CCompilerOpt._wrap_target.<locals>.<listcomp>r r aR /**
|
* AUTOGENERATED DON'T EDIT
|
* Please make changes to the code generator (distutils/ccompiler_opt.py)
|
*/
|
#define {pfx}CPU_TARGET_MODE
|
#define {pfx}CPU_TARGET_CURRENT {target_name}
|
{target_defs}
|
#include "{path}"
|
)rá Ú target_namerv Ú target_defs)r r rº r r ru rv Úbasenamer Úsplitextr rù r£ rg ro r r r r r Úabspath) rc r Ú dispatch_srcÚtargetrÕ Zext_namerþ Z wrap_pathr§ rÿ r0 re rý rf rÙ ë s,
|
|
|
|
|
|
|
ôzCCompilerOpt._wrap_targetc C s t j |¡}t j |¡d d }t j ||¡}| ||¡}zRt|@}| ¡ d¡}t |dkrt
|
|d |krW 5 Q R £ W dS W 5 Q R X W n t k
|
r Y nX t j t j |¡dd | d|¡ g } |D ]\}
|
t|
|
trà|
|
} nd d
|
d |
|
D ¡} | |
|
¡} d d d | D ¡} | d| j| | f ¡ qÌd | ¡} |rFd| j } nd} t|d&}| t d¡j| j| | |d¡ W 5 Q R X dS )Nr z.hz cache_hash:r r T)Úexist_okz generate dispatched config -> rü c S s g | ]}|qS re re rÉ re re rf rÓ '
|
s z1CCompilerOpt._generate_config.<locals>.<listcomp>z&&c S s g | ] }d | qS )zCHK(%s)re ra re re rf rÓ )
|
s z2 %sCPU_DISPATCH_EXPAND_(CB((%s), %s, __VA_ARGS__))rÞ z( %sCPU_DISPATCH_EXPAND_(CB(__VA_ARGS__))r r aZ // cache_hash:{cache_hash}
|
/**
|
* AUTOGENERATED DON'T EDIT
|
* Please make changes to the code generator (distutils/ccompiler_opt.py)
|
*/
|
#ifndef {pfx}CPU_DISPATCH_EXPAND_
|
#define {pfx}CPU_DISPATCH_EXPAND_(X) X
|
#endif
|
#undef {pfx}CPU_DISPATCH_BASELINE_CALL
|
#undef {pfx}CPU_DISPATCH_CALL
|
#define {pfx}CPU_DISPATCH_BASELINE_CALL(CB, ...) \
|
{baseline_calls}
|
#define {pfx}CPU_DISPATCH_CALL(CHK, CB, ...) \
|
{dispatch_calls}
|
)rá rä rå r÷ F)ru rv r r r r÷ r Úreadliner) r· Úintrj r r r£ r r r} rÌ r r r r r )rc r r r¾ r¦ Z config_pathr÷ r Z last_hashrå rÅ rþ Z
|
req_detecträ r0 re re rf rØ
|
sV
|
|
|
|
ÿ ÿÿ
|
þ ïz CCompilerOpt._generate_config)rË rb N)NN)F)F)F)r{ r| r} r~ rz rÐ rÑ rÒ rÓ rÝ rë rö rÙ rØ re re re rf rÊ s
|
|
WS
|
m
|
&rÊ c K s. t | f|}tj |¡r | ¡ s*| |¡ |S )aÏ
|
Create a new instance of 'CCompilerOpt' and generate the dispatch header
|
which contains the #definitions and headers of platform-specific instruction-sets for
|
the enabled CPU baseline and dispatch-able features.
|
|
Parameters
|
----------
|
compiler : CCompiler instance
|
dispatch_hpath : str
|
path of the dispatch header
|
|
**kwargs: passed as-is to `CCompilerOpt(...)`
|
Returns
|
-------
|
new instance of CCompilerOpt
|
)rÊ ru rv rù rÐ rë )r® Zdispatch_hpathr r re re rf Únew_ccompiler_optO
|
s
|
r )r~ rr rÔ ru r
|
rä rá r Z NPY_CXX_FLAGSr r rû rî r rK r rÊ r re re re rf Ú<module> sL
|
ü / ; 9 h y 6
|
