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; }