void SyImageBase::loadQImage(const QImage &imageIn)
{
SProfileFunction
int width = imageIn.width();
int height = imageIn.height();
XVector<float> data;
data.resize(width * height);
xsize bytesPerPixel = imageIn.depth()/8;
const quint8 *pixel = imageIn.bits();
for(int i = 0; i < height; ++i )
{
xsize rowPos = i * width;
for(int j = 0; j < width; ++j)
{
data[rowPos+j] = (float)*pixel/255.0f;
pixel += bytesPerPixel;
}
}
image.set(width, height, data);
postSet();
}
void XWndPrivateRaidSpot::Update()
{
XWndSpot::Update();
// 도전마크를 스팟위에 그림
const auto size = GetSizeFinal();
XVector<XWnd*> aryChild;
XE::VEC2 vlPos = XE::VEC2( -8, -size.h );
for( int i = 0; i < 2; ++i ) {
const bool bOn = !(i < m_pSpot->GetnumWins());
const std::string ids = XE::Format( "img.mark%d", i );
auto pImg = XWndImage::sUpdateCtrl( this, ids );
if( pImg ) {
if( i == 0 ) {
//vlPos.y -= pImg->GetSizeLocal().h;
}
aryChild.push_back( pImg );
if( bOn ) {
pImg->SetSurfaceRes( PATH_UI("chall_mark_on.png") );
} else {
pImg->SetSurfaceRes( PATH_UI( "chall_mark_off.png" ) );
}
pImg->SetPosLocal( vlPos );
vlPos.x += pImg->GetSizeLocal().w;
}
}
// AutoLayoutHCenterWithAry( aryChild, 0.f );
}
/**
@brief 효과 시전
pEffect의 효과를 기준타겟(pBaseTarget)을 기준으로 시전대상을 선정하여 시전한다.
현재 _vPos는 사용하지 않는다
*/
xtError XSkillUser::UseEffect( const XSkillDat *pDat,
EFFECT *pEffect,
int level,
XSkillReceiver *pBaseTarget,
const XE::VEC2& vBaseTarget, // 기준타겟이 좌표형일경우.
ID idCallerSkill )
{
// 좌표에 값이 있으면 타겟은 널이어야 한다.,
XBREAK( vBaseTarget.IsNotZero() && pBaseTarget != nullptr );
XVector<XSkillReceiver*> aryCastTargets; // 시전대상
// 기준타겟이나 기준좌표로 시전대상을 얻는다.
XBREAK( pBaseTarget == nullptr && vBaseTarget.IsZero() );
//
XE::VEC2 vCastTarget;
GetCastingTargetList( &aryCastTargets,
&vCastTarget,
pEffect->castTarget,
pDat,
pEffect,
level,
pBaseTarget,
vBaseTarget );
//
if( vCastTarget.IsZero() && aryCastTargets.empty() ) {
return xERR_NOT_FOUND_CASTING_TARGET; // 시전대상을 찾지 못함
}
if( aryCastTargets.size() ) {
// 캐스팅 대상들에게 효과를 시전한다.
for( auto pCastingTarget : aryCastTargets ) {
// 즉시시전 or 버프방식
const XE::VEC2 vZero;
CastEffToCastTarget( pDat,
pEffect,
level,
// pBaseTarget,
pCastingTarget,
vZero,
idCallerSkill );
}
} else
if( vCastTarget.IsNotZero() ) {
// 시전대상이 좌표형
CastEffToCastTarget( pDat,
pEffect,
level,
nullptr,
vCastTarget,
idCallerSkill );
} else {
XBREAK(1);
}
return xOK;
}
RVector V_AddVector( const RVector & r,const typename XVector::scalar_type &av,const XVector & x,
const typename XVector::scalar_type &bv, const YVector & y)
{
V_AddVectorFunctor<RVector,XVector,YVector,doalpha,dobeta> f(r,av,x,bv,y);
parallel_for(x.dimension_0(),f);
return r;
}
RVector MV_Add( const RVector & r, const XVector & x, const YVector & y)
{
KokkosArray::View<typename XVector::value_type* , KokkosArray::LayoutRight, typename XVector::device_type> dummy;
if(x.dimension(1)>16)
return MV_AddVector( r,dummy,x,dummy,y,1,1);
return MV_AddUnroll( r,dummy,x,dummy,y,1,1);
}
/**
@brief 즉시시전형태(비버프형)의 효과를 시전대상에게 시전한다.
*/
xtError XSkillUser::CastEffToCastTargetByDirect( const XSkillDat *pDat,
const EFFECT *pEffect,
int level,
XSkillReceiver *pCastingTarget,
const XE::VEC2& vCastTarget )
{
XVector<XSkillReceiver*> aryInvokeTarget;
// 1회성이기때문에 루아도 쓰고 바로 파괴되는걸로 함
// 시전대상자(pCastingTarget)기준 발동대상 얻음
XE::VEC2 vIvkTarget; // 발동대상이 좌표형태일때 여기로 좌표가 담긴다.
int numInvoke = GetInvokeTarget( &aryInvokeTarget,
&vIvkTarget,
pDat,
level,
pEffect->invokeTarget,
pEffect,
pCastingTarget,
vCastTarget );
if( numInvoke > 0 || vIvkTarget.IsNotZero() ) {
bool bCreateSfx = ( pEffect->m_invokeTargetEff.m_strSpr.empty() ) ? false : true;
if( aryInvokeTarget.size() ) {
for( auto pInvokeTarget : aryInvokeTarget ) {
// 발동대상들에게 효과 적용
ApplyInvokeEffToIvkTarget( pInvokeTarget,
vIvkTarget,
pDat,
pEffect,
GetThisRecv(), // invoker
bCreateSfx,
level,
nullptr ); // pBuff
} // for
} else
if( vIvkTarget.IsNotZero() ) {
// 발동좌표에 효과적용
ApplyInvokeEffToIvkTarget( nullptr,
vIvkTarget,
pDat,
pEffect,
GetThisRecv(), // invoker
bCreateSfx,
level,
nullptr ); // pBuff
}
}
return xOK;
} // CastEffToCastTargetByDirect
RVector MV_Add( const RVector & r,const aVector &av,const XVector & x,
const bVector &bv, const YVector & y,
int a=2,int b=2)
{
if(x.dimension(1)>16)
return MV_AddVector( r,av,x,bv,y,a,b);
return MV_AddUnroll( r,av,x,bv,y,a,b);
}
static KOKKOS_INLINE_FUNCTION void team_axpby (const TeamType& team,
const typename XVector::non_const_value_type& a, const XVector& x,
const typename YVector::non_const_value_type& b, const YVector& y) {
const int N = x.extent(0);
Kokkos::parallel_for(Kokkos::TeamThreadRange(team,N), [&] (const int& i) {
y(i) = b*y(i) + a*x(i);
});
}
/// \brief Return the dot product of x and y.
///
/// \param x [in] First vector.
/// \param y [in] Second vector.
/// \param label [in] This is passed into Kokkos::parallel_for, as a
/// label for profiling.
static dot_type
dot (const std::string& label, const XVector& x, const YVector& y)
{
dot_type result;
if (x.dimension_0 () < typename XVector::size_type (INT_MAX)) {
Kokkos::RangePolicy<typename XVector::execution_space, int> policy (0, x.dimension_0 ());
typedef DotFunctor<XVector, YVector, int> functor_type;
Kokkos::parallel_reduce (label, policy, functor_type (x, y), result);
}
else {
typedef typename XVector::size_type size_type;
Kokkos::RangePolicy<typename XVector::execution_space, size_type> policy (0, x.dimension_0 ());
typedef DotFunctor<XVector, YVector, size_type> functor_type;
Kokkos::parallel_reduce (label, policy, functor_type (x, y), result);
}
return result;
}
RVector V_MulScalar( const RVector & r, const typename KokkosArray::View<DataType,Layout,Device,MemoryManagement,Specialisation> & a, const XVector & x)
{
typedef typename KokkosArray::View<DataType,Layout,Device,MemoryManagement> aVector;
if(r==x) {
V_MulScalarFunctorSelf<aVector,XVector> op ;
op.m_x = x ;
op.m_a = a ;
KokkosArray::parallel_for( x.dimension(0) , op );
return r;
}
V_MulScalarFunctor<RVector,aVector,XVector> op ;
op.m_r = r ;
op.m_x = x ;
op.m_a = a ;
KokkosArray::parallel_for( x.dimension(0) , op );
return r;
}
// int XMain::GetResIdxByCheckSum( XArrayLinear<XPatch::XRES_INFO> &ary, XUINT64 llCheckSum )
int XMain::GetResIdxByCheckSum( const XVector<XPatch::XRES_INFO> &ary, XUINT64 llCheckSum )
{
int max = ary.size();
for( int i = 0; i < max; ++i ) {
if( ary[ i ].llChecksum == llCheckSum )
return i;
}
return -1;
}
RVector MV_MulScalar( const RVector & r, const typename XVector::scalar_type &a, const XVector & x)
{
if(r==x) {
MV_MulScalarFunctorSelf<typename XVector::scalar_type,XVector> op ;
op.m_x = x ;
op.m_a = a ;
op.n = x.dimension(1);
KokkosArray::parallel_for( x.dimension(0) , op );
return r;
}
MV_MulScalarFunctor<RVector,typename XVector::scalar_type,XVector> op ;
op.m_r = r ;
op.m_x = x ;
op.m_a = a ;
op.n = x.dimension(1);
KokkosArray::parallel_for( x.dimension(0) , op );
return r;
}
RVector V_MulScalar( const RVector & r, const typename XVector::scalar_type &a, const XVector & x)
{
printf("HUHU\n");
if(r==x) {
V_MulScalarFunctorSelf<typename XVector::scalar_type,XVector> op ;
op.m_x = x ;
op.m_a = a ;
KokkosArray::parallel_for( x.dimension(0) , op );
printf("HUHU2\n");
return r;
}
V_MulScalarFunctor<RVector,typename XVector::scalar_type,XVector> op ;
op.m_r = r ;
op.m_x = x ;
op.m_a = a ;
KokkosArray::parallel_for( x.dimension(0) , op );
printf("HUHU2\n");
return r;
}
//! Return the dot product of x and y.
static dot_type
dot (const XVector& x, const YVector& y)
{
dot_type result;
// With Intel 15, Scalar = double, Kokkos::Serial execution space,
// with 100000 entries for 1000 trials, using int instead of
// size_t is 2x faster.
if (x.dimension_0 () < typename XVector::size_type (INT_MAX)) {
Kokkos::RangePolicy<typename XVector::execution_space, int> policy (0, x.dimension_0 ());
typedef DotFunctor<XVector, YVector, int> functor_type;
Kokkos::parallel_reduce (policy, functor_type (x, y), result);
}
else {
typedef typename XVector::size_type size_type;
Kokkos::RangePolicy<typename XVector::execution_space, size_type> policy (0, x.dimension_0 ());
typedef DotFunctor<XVector, YVector, size_type> functor_type;
Kokkos::parallel_reduce (policy, functor_type (x, y), result);
}
return result;
}
void XGeometry::setAttribute( const QString &n, const XVector<XVector4D> &v )
{
if( v.size() )
{
_attr4[n] = v;
if( _attr4[n].size() != _attributeSize )
{
_attributeSize = _attr4[n].size();
_attributeSizeChanged = true;
}
}
else
{
_attr1.remove(n);
}
_changedA4 << n;
_changedAttrs = true;
}
// full_list.txt를 쓴다.
// int XMain::WriteFullList( XArrayLinear<XPatch::XRES_INFO>& aryAll )
int XMain::WriteFullList( const XVector<XPatch::XRES_INFO>& aryAll )
{
char cPath[ 1024 ];
strcpy_s( cPath, SZ2C( XE::_GetPathPackageRoot() ) );
strcat_s( cPath, "full_list.txt" );
FILE *fp = NULL;
fopen_s( &fp, cPath, "wt" );
if( fp == NULL )
return 0;
char cBuff[ 1024 ];
// XARRAYLINEAR_LOOP( aryAll, XPatch::XRES_INFO, info )
for( auto& info : aryAll ) {
strcpy_s( cBuff, SZ2C( info.strFile.c_str() ) );
strReplace( cBuff, '\\', '/' );
fprintf_s( fp, "\"%s\"\t%d\t%llu\n", cBuff, info.size, info.llChecksum );
}
fprintf_s( fp, "// num files %d \n", aryAll.size() );
fclose( fp );
return 1;
}
// core_list.txt를 쓴다.
//int XMain::WriteCoreList( XArrayLinear<_tstring>& aryCore )
int XMain::WriteCoreList( const XVector<_tstring>& aryCore )
{
char cPath[ 1024 ];
strcpy_s( cPath, SZ2C( XE::_GetPathPackageRoot() ) );
strcat_s( cPath, "core_list.txt" );
FILE *fp = NULL;
fopen_s( &fp, cPath, "wt" );
if( fp == NULL )
return 0;
char cBuff[ 1024 ];
// XARRAYLINEAR_LOOP( aryCore, _tstring, strRes )
for( auto& strRes : aryCore ) {
strcpy_s( cBuff, SZ2C( strRes.c_str() ) );
strReplace( cBuff, '\\', '/' );
fprintf_s( fp, "\"%s\"\n", cBuff );
// fprintf_s( fp, "\"%s\"\n", SZ2C( strRes.c_str() ) );
}
fprintf_s( fp, "// num files %d \n", aryCore.size() );
fclose( fp );
return 1;
}
RVector MV_AddUnroll( const RVector & r,const aVector &av,const XVector & x,
const bVector &bv, const YVector & y,
int a=2,int b=2)
{
switch (x.dimension(1)){
case 1: MV_AddUnroll<RVector, aVector, XVector, bVector, YVector, 1>( r,av,x,bv,y,a,b);
break;
case 2: MV_AddUnroll<RVector, aVector, XVector, bVector, YVector, 2>( r,av,x,bv,y,a,b);
break;
case 3: MV_AddUnroll<RVector, aVector, XVector, bVector, YVector, 3>( r,av,x,bv,y,a,b);
break;
case 4: MV_AddUnroll<RVector, aVector, XVector, bVector, YVector, 4>( r,av,x,bv,y,a,b);
break;
case 5: MV_AddUnroll<RVector, aVector, XVector, bVector, YVector, 5>( r,av,x,bv,y,a,b);
break;
case 6: MV_AddUnroll<RVector, aVector, XVector, bVector, YVector, 6>( r,av,x,bv,y,a,b);
break;
case 7: MV_AddUnroll<RVector, aVector, XVector, bVector, YVector, 7>( r,av,x,bv,y,a,b);
break;
case 8: MV_AddUnroll<RVector, aVector, XVector, bVector, YVector, 8>( r,av,x,bv,y,a,b);
break;
case 9: MV_AddUnroll<RVector, aVector, XVector, bVector, YVector, 9>( r,av,x,bv,y,a,b);
break;
case 10: MV_AddUnroll<RVector, aVector, XVector, bVector, YVector, 10>( r,av,x,bv,y,a,b);
break;
case 11: MV_AddUnroll<RVector, aVector, XVector, bVector, YVector, 11>( r,av,x,bv,y,a,b);
break;
case 12: MV_AddUnroll<RVector, aVector, XVector, bVector, YVector, 12>( r,av,x,bv,y,a,b);
break;
case 13: MV_AddUnroll<RVector, aVector, XVector, bVector, YVector, 13>( r,av,x,bv,y,a,b);
break;
case 14: MV_AddUnroll<RVector, aVector, XVector, bVector, YVector, 14>( r,av,x,bv,y,a,b);
break;
case 15: MV_AddUnroll<RVector, aVector, XVector, bVector, YVector, 15>( r,av,x,bv,y,a,b);
break;
case 16: MV_AddUnroll<RVector, aVector, XVector, bVector, YVector, 16>( r,av,x,bv,y,a,b);
break;
}
return r;
}
RVector MV_Add( const RVector & r, const XVector & x, const bVector & bv, const YVector & y )
{
if(x.dimension(1)>16)
return MV_AddVector(r,bv,x,bv,y,1,2);
return MV_AddUnroll(r,bv,x,bv,y,1,2);
}
void
spmv(const char mode[],
const AlphaType& alpha_in,
const AMatrix& A,
const XVector& x,
const BetaType& beta_in,
const YVector& y,
const RANK_TWO) {
typedef typename Impl::GetCoeffView<AlphaType, typename XVector::device_type>::view_type alpha_view_type;
typedef typename Impl::GetCoeffView<BetaType, typename XVector::device_type>::view_type beta_view_type;
//alpha_view_type alpha = Impl::GetCoeffView<AlphaType, typename XVector::device_type>::get_view(alpha_in,x.dimension_1());
//beta_view_type beta = Impl::GetCoeffView<AlphaType, typename XVector::device_type>::get_view(beta_in, x.dimension_1());
#ifdef KOKKOS_HAVE_CXX11
// Make sure that both x and y have the same rank.
static_assert (XVector::rank == YVector::rank, "KokkosBlas::spmv: Vector ranks do not match.");
// Make sure that y is non-const.
static_assert (Kokkos::Impl::is_same<typename YVector::value_type,
typename YVector::non_const_value_type>::value,
"KokkosBlas::spmv: Output Vector must be non-const.");
#else
// We prefer to use C++11 static_assert, because it doesn't give
// "unused typedef" warnings, like the constructs below do.
//
// Make sure that both x and y have the same rank.
typedef typename
Kokkos::Impl::StaticAssert<XVector::rank == YVector::rank>::type Blas1_spmv_vector_ranks_do_not_match;
#endif // KOKKOS_HAVE_CXX11
// Check compatibility of dimensions at run time.
if((mode[0]==NoTranspose[0])||(mode[0]==Conjugate[0])) {
if ((x.dimension_1 () != y.dimension_1 ()) ||
(static_cast<size_t> (A.numCols ()) > static_cast<size_t> (x.dimension_0 ())) ||
(static_cast<size_t> (A.numRows ()) > static_cast<size_t> (y.dimension_0 ()))) {
std::ostringstream os;
os << "KokkosBlas::spmv: Dimensions do not match: "
<< ", A: " << A.numRows () << " x " << A.numCols()
<< ", x: " << x.dimension_0 () << " x " << x.dimension_1 ()
<< ", y: " << y.dimension_0 () << " x " << y.dimension_1 ();
Kokkos::Impl::throw_runtime_exception (os.str ());
}
} else {
if ((x.dimension_1 () != y.dimension_1 ()) ||
(static_cast<size_t> (A.numCols ()) > static_cast<size_t> (y.dimension_0 ())) ||
(static_cast<size_t> (A.numRows ()) > static_cast<size_t> (x.dimension_0 ()))) {
std::ostringstream os;
os << "KokkosBlas::spmv: Dimensions do not match (transpose): "
<< ", A: " << A.numRows () << " x " << A.numCols()
<< ", x: " << x.dimension_0 () << " x " << x.dimension_1 ()
<< ", y: " << y.dimension_0 () << " x " << y.dimension_1 ();
Kokkos::Impl::throw_runtime_exception (os.str ());
}
}
typedef KokkosSparse::CrsMatrix<typename AMatrix::const_value_type,
typename AMatrix::const_ordinal_type,
typename AMatrix::device_type,
typename AMatrix::memory_traits,
typename AMatrix::const_size_type> AMatrix_Internal;
AMatrix_Internal A_i = A;
// Call single vector version if appropriate
if( x.dimension_1() == 1) {
typedef Kokkos::View<typename XVector::const_value_type*,
typename Kokkos::Impl::if_c<Kokkos::Impl::is_same<typename YVector::array_layout,Kokkos::LayoutLeft>::value,
Kokkos::LayoutLeft,Kokkos::LayoutStride>::type,
typename XVector::device_type,
Kokkos::MemoryTraits<Kokkos::Unmanaged|Kokkos::RandomAccess> > XVector_SubInternal;
typedef Kokkos::View<typename YVector::non_const_value_type*,
typename Kokkos::Impl::if_c<Kokkos::Impl::is_same<typename YVector::array_layout,Kokkos::LayoutLeft>::value,
Kokkos::LayoutLeft,Kokkos::LayoutStride>::type,
typename YVector::device_type,
Kokkos::MemoryTraits<Kokkos::Unmanaged> > YVector_SubInternal;
XVector_SubInternal x_i = Kokkos::subview(x,Kokkos::ALL(),0);
YVector_SubInternal y_i = Kokkos::subview(y,Kokkos::ALL(),0);
alpha_view_type alpha = Impl::GetCoeffView<AlphaType, typename XVector::device_type>::get_view(alpha_in,x.dimension_1());
beta_view_type beta = Impl::GetCoeffView<BetaType, typename XVector::device_type>::get_view(beta_in, x.dimension_1());
typename alpha_view_type::non_const_type::HostMirror h_alpha =
Kokkos::create_mirror_view(alpha);
Kokkos::deep_copy(h_alpha,alpha);
typename beta_view_type::non_const_type::HostMirror h_beta =
Kokkos::create_mirror_view(beta);
Kokkos::deep_copy(h_beta,beta);
spmv(mode,h_alpha(0),A,x_i,h_beta(0),y_i);
return;
} else {
typedef Kokkos::View<typename XVector::const_value_type**,
typename XVector::array_layout,
typename XVector::device_type,
Kokkos::MemoryTraits<Kokkos::Unmanaged|Kokkos::RandomAccess> > XVector_Internal;
typedef Kokkos::View<typename YVector::non_const_value_type**,
typename YVector::array_layout,
typename YVector::device_type,
Kokkos::MemoryTraits<Kokkos::Unmanaged> > YVector_Internal;
XVector_Internal x_i = x;
YVector_Internal y_i = y;
typedef Kokkos::View<typename alpha_view_type::const_value_type*,
typename alpha_view_type::array_layout,
typename alpha_view_type::device_type,
Kokkos::MemoryTraits<Kokkos::Unmanaged> > alpha_view_type_Internal;
typedef Kokkos::View<typename beta_view_type::const_value_type*,
typename beta_view_type::array_layout,
typename beta_view_type::device_type,
Kokkos::MemoryTraits<Kokkos::Unmanaged> > beta_view_type_Internal;
//alpha_view_type_Internal alpha_c = alpha;
//beta_view_type_Internal beta_c = beta;
return Impl::SPMV_MV<typename alpha_view_type_Internal::value_type*,
typename alpha_view_type_Internal::array_layout,
typename alpha_view_type_Internal::device_type,
typename alpha_view_type_Internal::memory_traits,
typename AMatrix_Internal::value_type,
typename AMatrix_Internal::ordinal_type,
typename AMatrix_Internal::device_type,
typename AMatrix_Internal::memory_traits,
typename AMatrix_Internal::size_type,
typename XVector_Internal::value_type**,
typename XVector_Internal::array_layout,
typename XVector_Internal::device_type,
typename XVector_Internal::memory_traits,
typename beta_view_type_Internal::value_type*,
typename beta_view_type_Internal::array_layout,
typename beta_view_type_Internal::device_type,
typename beta_view_type_Internal::memory_traits,
typename YVector_Internal::value_type**,
typename YVector_Internal::array_layout,
typename YVector_Internal::device_type,
typename YVector_Internal::memory_traits>::spmv_mv(mode,alpha_in,A,x,beta_in,y);
}
}
typename XVector::scalar_type V_Dot( const XVector & x, const YVector & y)
{
V_DotFunctor<XVector,YVector> f(x,y);
return parallel_reduce(x.dimension_0(),f);
}
/**
full_list.txt를 만든다.
core_list.txt를 만든다.(apk50메가선을 유지하도록)
*/
void XMain::DoExtract( void )
{
// 일단 모든 리소스 파일의 목록을 뽑는다.
// XArrayLinear<XSYSTEM::XFILE_INFO> aryAll;
XVector<XSYSTEM::XFILE_INFO> aryAll;
// XSYSTEM::CreateFileList( XE::_GetPathPackageRoot(), _T("*.*"), &aryAll );
XSYSTEM::GetFileList( XE::_GetPathPackageRoot(), _T("*.*"), &aryAll, _T("") );
if( aryAll.Size() > 1500 ) {
}
// full_list.txt를 만든다.
{
// XArrayLinear<XPatch::XRES_INFO> ary;
// ary.Create( aryAll.size() );
XVector<XPatch::XRES_INFO> ary;
int cnt = 1;
// 파일별로 체크섬을 뽑아 둔다.
// XARRAYLINEAR_LOOP( aryAll, XSYSTEM::XFILE_INFO, info )
for( auto& info : aryAll ) {
XPatch::XRES_INFO resInfo;
resInfo.strFile = info.strFile;
resInfo.size = info.size;
resInfo.llChecksum = XE::CalcCheckSum( info.strFile.c_str() );
_tstring strFilename = XE::GetFileName( resInfo.strFile.c_str() );
int idxDuplicate = GetResIdxByCheckSum( ary, resInfo.llChecksum );
if( idxDuplicate != -1 ) {
XALERT( "duplicate checksum file: idx=%d,%d", idxDuplicate, cnt );
}
ary.Add( resInfo );
CONSOLE( "%d:%s.... %d byte ....checksum=0x%I64x",
cnt++,
strFilename.c_str(),
resInfo.size,
resInfo.llChecksum );
}
// full_list.txt를 생성한다.
WriteFullList( ary );
}
// core_list.txt를 뽑아낸다.
{
// XArrayLinear<_tstring> aryCore;
// aryCore.Create( aryAll.size() );
XVector<_tstring> aryCore;
int i = 0;
// XARRAYLINEAR_LOOP( aryAll, XSYSTEM::XFILE_INFO, info )
for( auto& info : aryAll ) {
// TCHAR szFlename[ 256 ];
// _tcscpy_s( szFlename, XE::GetFileName( info.strFile.c_str() ) );
const _tstring strFileName = XE::GetFileName( info.strFile );
// 테마에 속하지 않는 몬스터중에 mob_ 으로 시작하는 몬스터는
// 제작은 되었으나 아직 테마에 반영이 안된 몬스터이므로 제외시킨다.
BOOL bCore = TRUE;
// TCHAR szExt[ 16 ];
// _tcscpy_s( szExt, XE::GetFileExt( strFileName ) );
const _tstring strExt = XE::GetFileExt( strFileName );
// 다음 단어가 포함되어 있는 파일은 모두 제외
// if( _tcsstr( szFlename, _T( "treant" ) ) ||
// _tcsstr( szFlename, _T( "rock" ) ) )
// bCore = FALSE;
// 액셀 파일 제외
// if( XE::IsSame( szExt, _T("xlsx") ) )
if( strExt == _T("xlsx") )
bCore = FALSE;
// if( XE::IsSame( szFlename, _T("core_list.txt") ) ||
// XE::IsSame( szFlename, _T("full_list.txt") ) )
// bCore = FALSE;
if( strFileName == _T("core_list.txt")
|| strFileName == _T("full_list.txt") )
bCore = FALSE;
if( _tcsstr( strFileName.c_str(), _T("sample")) )
bCore = FALSE;
//
if( bCore )
{
aryCore.Add( info.strFile );
XTRACE( "%d: %s", i ++, info.strFile.c_str() );
} else
{
// 제외된 파일명
XTRACE( "-----------%s", info.strFile.c_str() );
}
}
// core_list.txt로 저장한다.
WriteCoreList( aryCore );
}
}
/**
@brief pCenter(or vCenter)를 중심으로 radius범위내의 유닛들을 얻어 어레이에 담는다.
@return 얻어낸 타겟수
@param pCenter 중심타겟. null이면 vCenter를 사용한다.
@param vCenter 중심좌표. pCenter가 있다면 사용되지 않는다.
@param pixelRadius 픽셀단위 반지름.
@param bitSideFilter 검색해야할 진영
@param numCost 총 코스트값. 각 유닛은 크기 코스트가 있으며 타겟이 검색될때마다 numCost에서 차감한다. 0이되면 더이상 담지 않는다. 차감한 코스값이 마이너스가 될수는 없다.
0은 코스트에 관계없이 무조건 타겟1개만 검색. -1은 무효값.
@param bIncludeCenter 중심타겟(pCenter가 있을경우)을 대상에 포함할지 말지. pCenter가 없다면 이 옵션은 무시된다.
*/
int XEObjMngWithType::GetListUnitRadius2( XVector<XSPUnit> *pOutAry,
XEBaseWorldObj *pCenter,
const XE::VEC2& vCenter,
float pixelRadius,
BIT bitSideFilter,
int numCost,
bool bIncludeCenter,
BIT bitFlag ) const // 생존필터
{
if( numCost < 0 )
return 0;
//
XVector<XSPUnit> aryInNew; // pOutAry에 이미 타겟이 있는채로 들어왔을때 그것은 제한 리스트
XVector<XSPUnit> aryIn = *pOutAry; // 기존타겟에 반경검사타겟까지 포함.
int costSum = 0;
for( auto spUnit : m_listUnits ) {
if( spUnit->IsDestroy() )
continue;
XBREAK( spUnit == nullptr );
if( (spUnit->GetCamp() & bitSideFilter) == 0 )
continue;
if( (bitFlag & XSKILL::xTF_LIVE) == 0 && spUnit->IsLive() )
continue;
if( (bitFlag & XSKILL::xTF_DEAD) == 0 && spUnit->IsDead() )
continue;
// 시전대상을 포함하지 않는 조건일때 유닛이 시전대상이면 스킵
if( pCenter
&& pCenter->GetsnObj() == spUnit->GetsnObj() // spUnit이 중심타겟일때
&& bIncludeCenter == false ) // 중심타겟안포함 옵션이면 스킵한다.
continue;
if( bitFlag & XSKILL::xTF_DIFF_SQUAD ) {
// spUnit이 이미 찾은 유닛과 같은 부대면 스킵
bool bExisted = false;
for( auto& spFinded : aryIn ) {
if( spUnit->GetpSquadObj()->GetsnSquadObj() == spFinded->GetpSquadObj()->GetsnSquadObj() ) {
bExisted = true;
break;
}
}
if( bExisted )
continue;
}
const XE::VEC2 vDist = spUnit->GetvwPos().ToVec2() - vCenter;
const float distsq = vDist.Lengthsq();
// 코스트와 관계없이 일단 범위안에 들어가는 타겟은 모두 담은후 거기서 다시 코스트에 따라 랜덤으로 꺼낸다.
if( distsq <= pixelRadius * pixelRadius ) {
aryIn.Add( spUnit );
aryInNew.Add( spUnit );
costSum += spUnit->GetSizeCost(); // 배열에 들어간 유닛들의 토탈코스트
} // in radius
} // for
// 목표코스트를 다 채우지 못했거나 딱맞게 채웠을때는 전체 리스트에서 랜덤으로 뽑을필요가 없으므로 그냥 검색된 리스트를 모두 리턴한다.
if( costSum <= numCost ) {
*pOutAry = aryIn;
return pOutAry->Size();
}
int currCost = numCost;
// XVector<XSPUnit> ary = *pOutAry;
// pOutAry->Clear();
// 영역안에 들어온 타겟들을 대상으로 다시 코스트에 따라 실제 타겟을 선정한다.
while( aryInNew.Size() > 0 ) {
auto spUnit = aryInNew.PopFromRandom();
if( numCost == 0 ) {
if( pOutAry->Size() == 0 )
pOutAry->Add( spUnit );
return 1;
} else {
const auto costUnit = spUnit->GetSizeCost();
if( costUnit <= currCost ) {
// 유닛 코스트가 남은 코스트를 깔수 있을때만.
currCost -= costUnit;
XBREAK( currCost < 0 );
pOutAry->Add( spUnit );
if( currCost == 0 ) // 코스트를 다 채웠으면 리턴.
return pOutAry->Size();
}
}
}
return pOutAry->size();
}
void
spmv(const char mode[],
const AlphaType& alpha,
const AMatrix& A,
const XVector& x,
const BetaType& beta,
const YVector& y,
const RANK_ONE)
{
#ifdef KOKKOS_HAVE_CXX11
// Make sure that both x and y have the same rank.
static_assert ((int) XVector::rank == (int) YVector::rank,
"KokkosBlas::spmv: Vector ranks do not match.");
// Make sure that x (and therefore y) is rank 1.
static_assert ((int) XVector::rank == 1, "KokkosBlas::spmv: "
"Both Vector inputs must have rank 1 or 2.");
// Make sure that y is non-const.
static_assert (Kokkos::Impl::is_same<typename YVector::value_type,
typename YVector::non_const_value_type>::value,
"KokkosBlas::spmv: Output Vector must be non-const.");
#else
// We prefer to use C++11 static_assert, because it doesn't give
// "unused typedef" warnings, like the constructs below do.
//
// Make sure that both x and y have the same rank.
typedef typename
Kokkos::Impl::StaticAssert<(int) XVector::rank == (int) YVector::rank>::type
Blas1_spmv_vector_ranks_do_not_match;
// Make sure that x (and therefore y) is rank 1.
typedef typename
Kokkos::Impl::StaticAssert<(int) XVector::rank == 1 >::type
Blas1_spmv_vector_rank_not_one;
#endif // KOKKOS_HAVE_CXX11
// Check compatibility of dimensions at run time.
if((mode[0]==NoTranspose[0])||(mode[0]==Conjugate[0])) {
if ((x.dimension_1 () != y.dimension_1 ()) ||
(static_cast<size_t> (A.numCols ()) > static_cast<size_t> (x.dimension_0 ())) ||
(static_cast<size_t> (A.numRows ()) > static_cast<size_t> (y.dimension_0 ()))) {
std::ostringstream os;
os << "KokkosBlas::spmv: Dimensions do not match: "
<< ", A: " << A.numRows () << " x " << A.numCols()
<< ", x: " << x.dimension_0 () << " x " << x.dimension_1()
<< ", y: " << y.dimension_0 () << " x " << y.dimension_1()
;
Kokkos::Impl::throw_runtime_exception (os.str ());
}
} else {
if ((x.dimension_1 () != y.dimension_1 ()) ||
(static_cast<size_t> (A.numCols ()) > static_cast<size_t> (y.dimension_0 ())) ||
(static_cast<size_t> (A.numRows ()) > static_cast<size_t> (x.dimension_0()))) {
std::ostringstream os;
os << "KokkosBlas::spmv: Dimensions do not match (transpose): "
<< ", A: " << A.numRows () << " x " << A.numCols()
<< ", x: " << x.dimension_0 () << " x " << x.dimension_1()
<< ", y: " << y.dimension_0 () << " x " << y.dimension_1()
;
Kokkos::Impl::throw_runtime_exception (os.str ());
}
}
typedef KokkosSparse::CrsMatrix<typename AMatrix::const_value_type,
typename AMatrix::non_const_ordinal_type,
typename AMatrix::device_type,
Kokkos::MemoryTraits<Kokkos::Unmanaged>,
typename AMatrix::const_size_type> AMatrix_Internal;
typedef Kokkos::View<typename XVector::const_value_type*,
typename XVector::array_layout,
typename XVector::device_type,
Kokkos::MemoryTraits<Kokkos::Unmanaged|Kokkos::RandomAccess> > XVector_Internal;
typedef Kokkos::View<typename YVector::non_const_value_type*,
typename YVector::array_layout,
typename YVector::device_type,
Kokkos::MemoryTraits<Kokkos::Unmanaged> > YVector_Internal;
AMatrix_Internal A_i = A;
XVector_Internal x_i = x;
YVector_Internal y_i = y;
return Impl::SPMV<typename AMatrix_Internal::value_type,
typename AMatrix_Internal::ordinal_type,
typename AMatrix_Internal::device_type,
typename AMatrix_Internal::memory_traits,
typename AMatrix_Internal::size_type,
typename XVector_Internal::value_type*,
typename XVector_Internal::array_layout,
typename XVector_Internal::device_type,
typename XVector_Internal::memory_traits,
typename YVector_Internal::value_type*,
typename YVector_Internal::array_layout,
typename YVector_Internal::device_type,
typename YVector_Internal::memory_traits>::spmv(mode,alpha,A,x,beta,y);
}
void XEWinSocketSvr::ProcessLoginedList()
{
XVector<XSPWinConnInServer> aryDestroy;
auto llMilli1 = GET_FREQ_TIME();
XPROF_OBJ( "listLogined" );
auto plistLogined = &m_Logined.m_shoList.GetSharedObj();
// 동접이 많으면 이 많은 커넥션들 다 패킷펌핑하기전까진 워커스레드 접속스레드 멈춰야 되는데... 이래선 싱글스레드와 다를바 없지 않은가.
// 로그인된 커넥션들 프로세스
XINT64 llProcessTotal = 0;
XINT64 lllock = 0;
// for( auto spConnect : *plistLogined ) {
XINT64 llStart = XE::GetFreqTime();;
for( auto itor = (*plistLogined).begin(); itor != (*plistLogined).end(); ) {
auto spConnect = (*itor);
auto pConnect = spConnect.get();
XINT64 lllock1 = XE::GetFreqTime();;
if( lllock1 - llStart > 100000 ) // 처리속도가 너무 올래걸릴거 같으면 일단 그냥 루프 빠져나감.
break;
pConnect->GetspLock()->Lock( __TFUNC__ );
lllock += GET_FREQ_TIME() - lllock1;
const int cntUse = spConnect.use_count();
if( XASSERT( pConnect ) ) {
if( pConnect->IsDisconnected() ) {
OnDisconnectConnection( spConnect );
pConnect->OnDisconnect();
}
if( !pConnect->GetbDestroy() ) {
auto llProcess = GET_FREQ_TIME();
pConnect->Process();
llProcessTotal += (GET_FREQ_TIME() - llProcess);
//
if( pConnect->IsDisconnected() ) { // 연결은 끊어졌어도 클라측에서 중요한 패킷을 보냈을수도 있으므로 패킷펌핑은 다 끝내고 삭제하도록 바뀜.
pConnect->SetbDestroy( true );
}
// 커넥션이 비동기 파괴명령을 처리
pConnect->ProcesssAsyncDisconnect();
}
if( pConnect->GetbDestroy() ) {
++m_numDestroyAdd;
aryDestroy.Add( spConnect );
plistLogined->erase( itor++ );
} else
++itor;
}
pConnect->GetspLock()->Unlock();
}
auto llPass = GET_FREQ_TIME() - llMilli1;
m_aryTime.Add( xProfile(_T("process list"), llPass ) );
m_aryTime.Add( xProfile(_T("process"), llProcessTotal ) );
m_aryTime.Add( xProfile( _T( "lock" ), lllock ) );
m_aryTime.Add( xProfile( _T( "num process" ), plistLogined->size() ) );
// Logined 프로세스 & destroy
//////////////////////////////////////////////////////////////////////////
auto pListConnected = &m_Connected.m_shoList.GetSharedObj();
m_numConnected = pListConnected->size(); // 멀티스레드이므로 여기에 값이 있을 수 있음.
if( m_numConnected > m_maxConnected )
m_maxConnected = m_numConnected;
m_Connected.m_shoList.ReleaseSharedObj();
m_numLogined = plistLogined->size();
if( m_numLogined > m_maxLogined )
m_maxLogined = m_numLogined;
// 순간적으로 numConnect수보다 커넥션객체의 생성수가 훨씬 많을때가 있다.
// leak으로 보이지만 봇 클라이언트를 종료시키는 순간 모두 사라지는걸로 보아 순간적으로 접속이 몰릴때 메인스레드 프로세스에서
// 다 처리를 못해서 그런듯 하다.
// unlock
m_Logined.m_shoList.ReleaseSharedObj();
// 삭제예정된 커넥션들 참조해제
ProcessDestroyList( aryDestroy );
aryDestroy.clear();
} // process & destroy
RVector MV_AddVector( const RVector & r,const aVector &av,const XVector & x,
const bVector &bv, const YVector & y,
int a=2,int b=2)
{
if(a==1&&b==1) {
MV_AddVectorFunctor<RVector,aVector,XVector,bVector,YVector,1,1> op ;
op.m_r = r ;
op.m_x = x ;
op.m_y = y ;
op.m_a = av ;
op.m_b = bv ;
op.n = x.dimension(1);
KokkosArray::parallel_for( x.dimension(0) , op );
return r;
}
if(a==1&&b==-1) {
MV_AddVectorFunctor<RVector,aVector,XVector,bVector,YVector,1,-1> op ;
op.m_r = r ;
op.m_x = x ;
op.m_y = y ;
op.m_a = av ;
op.m_b = bv ;
op.n = x.dimension(1);
KokkosArray::parallel_for( x.dimension(0) , op );
return r;
}
if(a==-1&&b==1) {
MV_AddVectorFunctor<RVector,aVector,XVector,bVector,YVector,-1,1> op ;
op.m_r = r ;
op.m_x = x ;
op.m_y = y ;
op.m_a = av ;
op.m_b = bv ;
op.n = x.dimension(1);
KokkosArray::parallel_for( x.dimension(0) , op );
return r;
}
if(a==-1&&b==-1) {
MV_AddVectorFunctor<RVector,aVector,XVector,bVector,YVector,-1,-1> op ;
op.m_r = r ;
op.m_x = x ;
op.m_y = y ;
op.m_a = av ;
op.m_b = bv ;
op.n = x.dimension(1);
KokkosArray::parallel_for( x.dimension(0) , op );
return r;
}
if(a*a!=1&&b==1) {
MV_AddVectorFunctor<RVector,aVector,XVector,bVector,YVector,2,1> op ;
op.m_r = r ;
op.m_x = x ;
op.m_y = y ;
op.m_a = av ;
op.m_b = bv ;
op.n = x.dimension(1);
KokkosArray::parallel_for( x.dimension(0) , op );
return r;
}
if(a*a!=1&&b==-1) {
MV_AddVectorFunctor<RVector,aVector,XVector,bVector,YVector,2,-1> op ;
op.m_r = r ;
op.m_x = x ;
op.m_y = y ;
op.m_a = av ;
op.m_b = bv ;
op.n = x.dimension(1);
KokkosArray::parallel_for( x.dimension(0) , op );
return r;
}
if(a==1&&b*b!=1) {
MV_AddVectorFunctor<RVector,aVector,XVector,bVector,YVector,1,2> op ;
op.m_r = r ;
op.m_x = x ;
op.m_y = y ;
op.m_a = av ;
op.m_b = bv ;
op.n = x.dimension(1);
KokkosArray::parallel_for( x.dimension(0) , op );
return r;
}
if(a==-1&&b*b!=1) {
MV_AddVectorFunctor<RVector,aVector,XVector,bVector,YVector,-1,2> op ;
op.m_r = r ;
op.m_x = x ;
op.m_y = y ;
op.m_a = av ;
op.m_b = bv ;
op.n = x.dimension(1);
KokkosArray::parallel_for( x.dimension(0) , op );
return r;
}
MV_AddVectorFunctor<RVector,aVector,XVector,bVector,YVector,2,2> op ;
op.m_r = r ;
op.m_x = x ;
op.m_y = y ;
op.m_a = av ;
op.m_b = bv ;
op.n = x.dimension(1);
KokkosArray::parallel_for( x.dimension(0) , op );
return r;
}
rVector MV_Dot(const rVector &r, const XVector & x, const YVector & y)
{
typedef typename XVector::size_type size_type;
const size_type numVecs = x.dimension(1);
if(numVecs>16){
MV_DotProduct_Right_FunctorVector<XVector,YVector> op;
op.m_x = x;
op.m_y = y;
op.value_count = numVecs;
KokkosArray::parallel_reduce( x.dimension(0) , op, r );
return r;
}
else
switch(numVecs) {
case 16: {
MV_DotProduct_Right_FunctorUnroll<XVector,YVector,16> op;
op.m_x = x;
op.m_y = y;
op.value_count = numVecs;
KokkosArray::parallel_reduce( x.dimension(0) , op, r );
break;
}
case 15: {
MV_DotProduct_Right_FunctorUnroll<XVector,YVector,15> op;
op.m_x = x;
op.m_y = y;
op.value_count = numVecs;
KokkosArray::parallel_reduce( x.dimension(0) , op, r );
break;
}
case 14: {
MV_DotProduct_Right_FunctorUnroll<XVector,YVector,14> op;
op.m_x = x;
op.m_y = y;
op.value_count = numVecs;
KokkosArray::parallel_reduce( x.dimension(0) , op, r );
break;
}
case 13: {
MV_DotProduct_Right_FunctorUnroll<XVector,YVector,13> op;
op.m_x = x;
op.m_y = y;
op.value_count = numVecs;
KokkosArray::parallel_reduce( x.dimension(0) , op, r );
break;
}
case 12: {
MV_DotProduct_Right_FunctorUnroll<XVector,YVector,12> op;
op.m_x = x;
op.m_y = y;
op.value_count = numVecs;
KokkosArray::parallel_reduce( x.dimension(0) , op, r );
break;
}
case 11: {
MV_DotProduct_Right_FunctorUnroll<XVector,YVector,11> op;
op.m_x = x;
op.m_y = y;
op.value_count = numVecs;
KokkosArray::parallel_reduce( x.dimension(0) , op, r );
break;
}
case 10: {
MV_DotProduct_Right_FunctorUnroll<XVector,YVector,10> op;
op.m_x = x;
op.m_y = y;
op.value_count = numVecs;
KokkosArray::parallel_reduce( x.dimension(0) , op, r );
break;
}
case 9: {
MV_DotProduct_Right_FunctorUnroll<XVector,YVector,9> op;
op.m_x = x;
op.m_y = y;
op.value_count = numVecs;
KokkosArray::parallel_reduce( x.dimension(0) , op, r );
break;
}
case 8: {
MV_DotProduct_Right_FunctorUnroll<XVector,YVector,8> op;
op.m_x = x;
op.m_y = y;
op.value_count = numVecs;
KokkosArray::parallel_reduce( x.dimension(0) , op, r );
break;
}
case 7: {
MV_DotProduct_Right_FunctorUnroll<XVector,YVector,7> op;
op.m_x = x;
op.m_y = y;
op.value_count = numVecs;
KokkosArray::parallel_reduce( x.dimension(0) , op, r );
break;
}
case 6: {
MV_DotProduct_Right_FunctorUnroll<XVector,YVector,6> op;
op.m_x = x;
op.m_y = y;
op.value_count = numVecs;
KokkosArray::parallel_reduce( x.dimension(0) , op, r );
break;
}
case 5: {
MV_DotProduct_Right_FunctorUnroll<XVector,YVector,5> op;
op.m_x = x;
op.m_y = y;
op.value_count = numVecs;
KokkosArray::parallel_reduce( x.dimension(0) , op, r );
break;
}
case 4: {
MV_DotProduct_Right_FunctorUnroll<XVector,YVector,4> op;
op.m_x = x;
op.m_y = y;
op.value_count = numVecs;
KokkosArray::parallel_reduce( x.dimension(0) , op, r );
break;
}
case 3: {
MV_DotProduct_Right_FunctorUnroll<XVector,YVector,3> op;
op.m_x = x;
op.m_y = y;
op.value_count = numVecs;
KokkosArray::parallel_reduce( x.dimension(0) , op, r );
break;
}
case 2: {
MV_DotProduct_Right_FunctorUnroll<XVector,YVector,2> op;
op.m_x = x;
op.m_y = y;
op.value_count = numVecs;
KokkosArray::parallel_reduce( x.dimension(0) , op, r );
break;
}
case 1: {
MV_DotProduct_Right_FunctorUnroll<XVector,YVector,1> op;
op.m_x = x;
op.m_y = y;
op.value_count = numVecs;
KokkosArray::parallel_reduce(x.dimension(0) , op, r);
break;
}
}
return r;
}
