Jeu Videz votre presse-papier - Page 1041

fixes/physics-and-framerate

- SIMD : added 'Float4::IntMulHi' method, that returns the high-32 bits of a signed 32-bit * 32-bit integer multiplication

0^2 ./31198>
oui c'est normal.
cette fonction 'IDivMulInv' calcule le resultat d'une division entiere entre deux nombres 32bits signes: une variable divisee par une constante, sans utiliser d'instruction idiv.

le principe c'est de la faire en fixed-point, tu multiplie ta variable 'x' par (1<<32)/constante et tu recupere les 32-bits hauts du resultat.
sauf qu'il faut offsetter le complement a deux pour avoir la bonne troncation (?frenglish ftw), et pour eviter de perdre de la precision et avoir des erreurs d'arrondis en fait c'est pas (1<<32)/constante, mais (1<<(32+n))/constante, de sorte a ce que la constante prenne le max de bits utiles dans les 32 bits du multiplicateur constant.
donc pour une division par une constante 'k' tu peux calculer un multiplicateur 'km' et un shifteur 'ks', et t'as un truc de la forme:

xdivk = mulhi(x, km) >> ks

en rajoutant les corrections de signe:

offset = (km < 0 && kDiv > 0) ? +x : (km > 0 && kDiv < 0) ? -x : 0;
a = mulhi(x, km);
b = (a + offset ) >> ks;
xdivk = b + sign(b)

en virant les branches du calcul de 'offset' (qui est aussi constant vu qu'il depend que des constantes calculees depuis le diviseur constant) ca donne le code du copy/paste d'au dessus ^^
la version sans bugs:

static HH_FORCEINLINE hh_i32	_MulHiS32(hh_i32 x, hh_i32 y)
{
	const hh_u64	mulloS64 = hh_i64(x) * hh_i64(y);
	return mulloS64 >> 32;
}

//----------------------------------------------------------------------------

static HH_FORCEINLINE hh_i32	_IDivMulInv(hh_i32 x, hh_i32 kMul, hh_i32 kSra, hh_i32 kAddMask, hh_i32 kSubMask)
{
	const hh_i32	offset = (x & kAddMask) - (x & kSubMask);
	const hh_i32	mulHi = _MulHiS32(x, kMul) + offset;
	const hh_i32	mulHiS = mulHi >> kSra;
	const hh_i32	sign = hh_u32(mulHiS) >> 31;	// rounding offset for negative values
	const hh_i32	d = mulHiS + sign;
	return d;
}

//----------------------------------------------------------------------------

static HH_FORCEINLINE hh_i32	_IDivMulInv(hh_i32 x, hh_i32 kDiv, hh_i32 kMul, hh_i32 kSra)
{
#if 1
	const hh_i32	kDivSign = (kDiv >> 31);
	const hh_i32	kMulSign = (kMul >> 31);
	const hh_i32	kAddMask = kMulSign & ~kDivSign;
	const hh_i32	kSubMask = kDivSign & ~kMulSign;
	return _IDivMulInv(x, kMul, kSra, kAddMask, kSubMask);
#else
	return (kDiv != 0) ? x / kDiv : 0;
#endif
}

C'est au passage ce qui est utilise par tous les compilateurs un minimum potables (ceci inclut msvc ) lorsque tu divise (ou modulo) par une constante.
la division ou modulo non signes sont plus simples vu que t'as pas toute la partie correction de signe. (mais c'est pas les memes km et ks)

on fait aussi ca pour les nombres entiers arbitraires style RSA et courbes elliptiques

Ah OK, je vois le truc

Ce qui m'a induit en erreur, c'est que je pensais que kMul et kShift étaient indépendants de kDiv, vu que tu les passes en paramètre plutôt que de les calculer dans ta fonction (il y a une raison d'ailleurs ?)

(genre montgomery mul?)

(cross)
ouai, le calcul des constantes est lourd compare au calcul de la div avec les constantes, il est calcule en amont, cette fonction est call dans une boucle sur un batch de valeurs toutes divisees par la meme constante.
(en gros c'est un stream d'instructions qui passent dans un optimiseur qui transforme les divs par des constantes en ca, et bake les constantes au compile-time, et la VM appelle cette fonction la (enfin, elle appelle une implem SIMD dans le gros de la boucle, ca c'est la version scalaire qui est call que dans les quelques dernieres iterations qui sont pas passees dans l'unroll principal)

OK, je pensais que c'était un truc que le compilo aurait pu calculer lui-même à la compil ^^

tiens, code de calcul des constantes dispo ici pour avoir une meilleure idee ^^ (view page source):
http://www.hackersdelight.org/magic.htm

bah justement, c'est un compilo
mais on a une version template aussi, pour implem des fast IntDiv SIMD
quand t'ecris "x / 6" le compilo C++ va effectivement convertir ca en truc comme:

movsxd rax, eax
imul rax, rax, 0x2AAAAAAB
mov rcx, rax
shr rcx, 63
shr rax, 32
add eax, ecx

mais il y a pas d'intrinsics int div en SSE ou Neon du coup la version template est utile quand meme, pour pouvoir ecrire genre:

SIMD::Int4 x = ...;
SIMD::Int4 y = x.IntDiv<6>();

le 'IntDiv' va appeler la template avec '6', qui lui donnera acces au multiplicateur et shifter constants, quel l'implem de la fonction 'IntDiv' pourra ensuite utiliser dans un mulHi, etc.. (comme la version scalaire d'avant)
bref

Intéressant, merci

(je connaissais le principe mais j'avais jamais creusé)

bear: pas genre, c'est montgomery oui.

ok
-------
2010-109A.PDF

r-base r-base-dev

CParticleNodeTemplateExport $LOCAL$/$0
{
EditorInfosPosition = int2(638, 110);
Input_Pins =
{
"$LOCAL$/$1",
};
ExportedName = "Value_5";
ExportedType = event;
Type = Output;
}
CParticleNodePinIn $LOCAL$/$1
{
SelfName = "Value";
Owner = "$LOCAL$/$0";
}

Sixsmith

tools/mkkconfig.bat

> data[,`:=`("tata",24)]
Error in `[.data.frame`(data, , `:=`("tata", 24)) :
could not find function ":="

1>------ Build started: Project: sim, Configuration: Release Win32 ------
1>lennard_jones.cpp
1>C:\Program Files (x86)\Microsoft Visual Studio\2017\Community\VC\Tools\MSVC\14.10.25017\include\xmemory0(840): error C2664: 'std::function<void (void)>::function(std::function<void (void)> &&)': cannot convert argument 1 from 'std::_Binder<std::_Unforced,Func &,_Ty &,f64 &>' to 'std::nullptr_t'
1> with
1> [
1> Func=physics::energy::lennard_jones::calculate_kinetic::<lambda_f5e0816f53490dc6282f141a4fdddeeb>,
1> _Ty=simulation:bject *
1> ]
1>C:\Program Files (x86)\Microsoft Visual Studio\2017\Community\VC\Tools\MSVC\14.10.25017\include\xmemory0(840): note: nullptr can only be converted to pointer or handle types
1>C:\Program Files (x86)\Microsoft Visual Studio\2017\Community\VC\Tools\MSVC\14.10.25017\include\xmemory0(959): note: see reference to function template instantiation 'void std::allocator<_Ty>::construct<_Objty,std::_Binder<std::_Unforced,Func &,simulation:bject *&,f64 &>>(_Objty *,std::_Binder<std::_Unforced,Func &,simulation:bject *&,f64 &> &&)' being compiled
1> with
1> [
1> _Ty=std::function<void (void)>,
1> _Objty=std::function<void (void)>,
1> Func=physics::energy::lennard_jones::calculate_kinetic::<lambda_f5e0816f53490dc6282f141a4fdddeeb>
1> ]
1>C:\Program Files (x86)\Microsoft Visual Studio\2017\Community\VC\Tools\MSVC\14.10.25017\include\xmemory0(959): note: see reference to function template instantiation 'void std::allocator<_Ty>::construct<_Objty,std::_Binder<std::_Unforced,Func &,simulation:bject *&,f64 &>>(_Objty *,std::_Binder<std::_Unforced,Func &,simulation:bject *&,f64 &> &&)' being compiled
1> with
1> [
1> _Ty=std::function<void (void)>,
1> _Objty=std::function<void (void)>,
1> Func=physics::energy::lennard_jones::calculate_kinetic::<lambda_f5e0816f53490dc6282f141a4fdddeeb>
1> ]
1>C:\Program Files (x86)\Microsoft Visual Studio\2017\Community\VC\Tools\MSVC\14.10.25017\include\xmemory0(1097): note: see reference to function template instantiation 'void std::allocator_traits<_Alloc>::construct<_Ty,std::_Binder<std::_Unforced,Func &,simulation:bject *&,f64 &>>(std::allocator<_Ty> &,_Objty *,std::_Binder<std::_Unforced,Func &,simulation:bject *&,f64 &> &&)' being compiled
1> with
1> [
1> _Alloc=std::allocator<std::function<void (void)>>,
1> _Ty=std::function<void (void)>,
1> Func=physics::energy::lennard_jones::calculate_kinetic::<lambda_f5e0816f53490dc6282f141a4fdddeeb>,
1> _Objty=std::function<void (void)>
1> ]
1>C:\Program Files (x86)\Microsoft Visual Studio\2017\Community\VC\Tools\MSVC\14.10.25017\include\xmemory0(1096): note: see reference to function template instantiation 'void std::allocator_traits<_Alloc>::construct<_Ty,std::_Binder<std::_Unforced,Func &,simulation:bject *&,f64 &>>(std::allocator<_Ty> &,_Objty *,std::_Binder<std::_Unforced,Func &,simulation:bject *&,f64 &> &&)' being compiled
1> with
1> [
1> _Alloc=std::allocator<std::function<void (void)>>,
1> _Ty=std::function<void (void)>,
1> Func=physics::energy::lennard_jones::calculate_kinetic::<lambda_f5e0816f53490dc6282f141a4fdddeeb>,
1> _Objty=std::function<void (void)>
1> ]
1>C:\Program Files (x86)\Microsoft Visual Studio\2017\Community\VC\Tools\MSVC\14.10.25017\include\deque(1189): note: see reference to function template instantiation 'void std::_Wrap_alloc<std::allocator<_Ty>>::construct<_Ty,std::_Binder<std::_Unforced,Func &,simulation:bject *&,f64 &>>(_Ty *,std::_Binder<std::_Unforced,Func &,simulation:bject *&,f64 &> &&)' being compiled
1> with
1> [
1> _Ty=std::function<void (void)>,
1> Func=physics::energy::lennard_jones::calculate_kinetic::<lambda_f5e0816f53490dc6282f141a4fdddeeb>
1> ]
1>C:\Program Files (x86)\Microsoft Visual Studio\2017\Community\VC\Tools\MSVC\14.10.25017\include\deque(1187): note: see reference to function template instantiation 'void std::_Wrap_alloc<std::allocator<_Ty>>::construct<_Ty,std::_Binder<std::_Unforced,Func &,simulation:bject *&,f64 &>>(_Ty *,std::_Binder<std::_Unforced,Func &,simulation:bject *&,f64 &> &&)' being compiled
1> with
1> [
1> _Ty=std::function<void (void)>,
1> Func=physics::energy::lennard_jones::calculate_kinetic::<lambda_f5e0816f53490dc6282f141a4fdddeeb>
1> ]
1>C:\Program Files (x86)\Microsoft Visual Studio\2017\Community\VC\Tools\MSVC\14.10.25017\include\queue(94): note: see reference to function template instantiation 'void std::deque<_Ty,std::allocator<_Ty>>::emplace_back<std::_Binder<std::_Unforced,Func &,simulation:bject *&,f64 &>>(std::_Binder<std::_Unforced,Func &,simulation:bject *&,f64 &> &&)' being compiled
1> with
1> [
1> _Ty=std::function<void (void)>,
1> Func=physics::energy::lennard_jones::calculate_kinetic::<lambda_f5e0816f53490dc6282f141a4fdddeeb>
1> ]
1>C:\Program Files (x86)\Microsoft Visual Studio\2017\Community\VC\Tools\MSVC\14.10.25017\include\queue(94): note: see reference to function template instantiation 'void std::deque<_Ty,std::allocator<_Ty>>::emplace_back<std::_Binder<std::_Unforced,Func &,simulation:bject *&,f64 &>>(std::_Binder<std::_Unforced,Func &,simulation:bject *&,f64 &> &&)' being compiled
1> with
1> [
1> _Ty=std::function<void (void)>,
1> Func=physics::energy::lennard_jones::calculate_kinetic::<lambda_f5e0816f53490dc6282f141a4fdddeeb>
1> ]

FAR struct si4463_dev_s *priv = (FAR struct si4463_dev_s *)dev;

- Maths SIMD : cleaned up, trashed old assembly versions (PI COMMIT !!)

math::vector<f64> rij = box()->particles[i]->position - box()->particles[j]->position;
rij -= std::round(rij / box()->side_length) * box()->side_length;
f64 rijd = rij.lengthSquared();

xInt

#birdbot pic.twitter.com/3mEdsYNiXK

— bird/h (@BirdPerHour) May 22, 2017

? (à part que c'est super joli des Brunni-oiseaux si seulement ils contenaient du rouge)

Brunni (./31226) :
? (à part que c'est super joli des Brunni-oiseaux si seulement ils contenaient du rouge)

(ils en contiennent, mais ça sous entend de les ouvrir pour le voir)

Donc ce sont des Brunni-oiseaux

Quick shipping, good packing, and product as described, thanks!

Brunni > y'a pas mal de perroquets qui sont Brunniesques
(tiens d'ailleurs, tu ne lis pas le topic yN & IRL ? on te voit rarement réagir là-bas, pourtant il y a plein de trucs pour toi)