경고 없이 잘 빌드 되던 프로젝트가 #pragma deprecated 경고를 뱉기 시작했다.

문제는 관련 코드를 사용하지도 않고 윈도우 기본 헤더에서 포함하고 있는 헤더 파일에서 발생한다는 점!!

1>D:\Program Files (x86)\Microsoft Visual Studio 10.0\VC\include\intrin.h(1092): error C2220: 경고가 오류로 처리되어 생성된 ‘object’ 파일이 없습니다.
1>D:\Program Files (x86)\Microsoft Visual Studio 10.0\VC\include\intrin.h(1092): warning C4995: ‘wcscat’: 이름이 #pragma deprecated로 표시되었습니다.
1>D:\Program Files (x86)\Microsoft Visual Studio 10.0\VC\include\intrin.h(1094): warning C4995: ‘wcscpy’: 이름이 #pragma deprecated로 표시되었습니다.

위와 같이 intrin.h 에서 나는데 이게 은근히 사람 속을 뒤집는군요.

해결 방법은

#define STRSAFE_NO_DEPRECATE

위 전처리기를 최상단에 위치시키면!!!! 해결이 됩니다.

아 머리 아포. ㅠ_ㅠ;

하지만 SRW Lock 에 대한 체크는 못 하고 있는걸 발견을 하게 되었다는.

테스트는 동일 락 순서를 가지고 criticalsection 과 SRW Lock 로 테스트를 진행함.

테스트 코드는 대략 아래와 같은 상황

SRWLOCK    gLock1;
SRWLOCK    gLock2;

unsigned __stdcall ThreadFun1(void* pParm)
{
	Lock(gLock1);    

	::Sleep(1000);    

	Lock(gLock2);        

	Unlock(gLock2);
	Unlock(gLock1)     

	return 0;
} 

unsigned __stdcall ThreadFun2(void* pParm)
{
	Lock(gLock2);    

	::Sleep(1000);    

	Lock(gLock1);        

	Unlock(gLock1);
	Unlock(gLock2);
	return 0;
}

중간에 Sleep 을 넣어 데드락의 발생확률을 높였으며, (10번하면 10번 정도 데드락이 발생) ciriticalsection 으로 하는 경우 테스트 조건에 데드락 발생시 프로그램 종료 옵션을 넣으면 분석 즉시 테스트 프로그램이 종료되고 데드락 정보를 통보 해줬는데, SRW Lock 으로 하면 그냥 계속 분석만 하고 있는구나. (테스트 프로그램 종료도 되지 않은 상황)

그리고, 위의 코드에서 Sleep 을 제거하면 데드락 상황이 잘 발생하지 않는데, 이 상태로 테스트 프로그램이 종료 되면 분석은 잘 해주네.  (물론 criticalsection 의 경우)

스레드 프로파일러를 구매하려는 이유가 shared 와 writer 가 공존하는 상황에 대해 대비를 할려고 하는건데. 애매하게 됐구나. 흠 어쩐다. 다른 프로그램 없나. ㅠ_ㅠ;

• Shared mode
  • 공유 리소스에 대해 읽기 전용으로 접근하는 경우 사용하는 잠금 모드이며, 동시에 여러 스레드에서 읽기 모드로 잠금이 가능하다. 만약 읽기 작업이 쓰기 작업보다 많은 경우 CRITICAL_SECTION 에 비해 동시성 처리 능력이 상승한다.
• Exclusive mode
  • 기존 CRITICAL_SECTION 의 잠금 모드와 동일한 잠금 모드로서, 하나의 스레드만이 접근 가능하다. 쓰기 작업에 사용한다.

하나의 SWR 객체를 통해 두가지 잠금 모드로 사용이 가능하며, 소유권 획득은 요청 순서를 따르지 않는다. 하지만 공정하다(?) 라고 한다. SWR 객체 크기는 포인터 사이즈이며, 이로 인한 잠금 상태를 업데이트 하는 속도가 빠르다라는 장점이 존재한다. 하지만 매우 작은 상태 정보만 저장이 가능함에 따른 재귀적으로 잠금을 획득할 수 없는 단점이 존재한다. 위의 단점때문에 단일로 사용하기는 힘들고 랩핑을 통해 중복적으로 락을 획득하는 경우를 방지해야한다. Exclusive mode 로 하나의 스레드에서 두번 lock 을 걸면 두번째 lock 획득 시도에서 무한 대기상태로 진입한다. (추가로 Shared mode 로 잠금을 획득한 상태에서 Exclusive mode 로 업그레이드는 불가능하다.) 관련 함수는 다음과 같다.

• AcquireSRWLockExclusive
  • SWR 객체에 대해 Exclusive mode 로 잠금을 획득한다.
• AcquireSRWLockShared
  • SWR 객체에 대해 Shared mode 로 잠금을 획득한다.
• InitializeSRWLock
  • SWR 객체를 초기화 한다.
• ReleaseSRWLockExclusive
  • Exclusive mode 로 잠금된 SWR 객체를 잠금 해제한다.
• ReleaseSRWLockShared
  • Shared mode 로 잠금된 SWR 객체를 잠금 해제한다.
• TryAcquireSRWLockExclusive
  • SWR 객체에 대해 Exclusive mode 로 호출 시점에 잠금 획득이 가능한 경우 true 를 불가능한 경우 false 를 반환한다.
  • SWR 잠금 기능이 최초 추가되었을 때에는 Try 함수가 존재하지 않았었다.
• TryAcquireSRWLockShared
  • SWR 객체에 대해 Shared mode 로 호출 시점에 잠금 획득이 가능한 경우 true 를 불가능한 경우 false 를 반환한다.
  • SWR 잠금 기능이 최초 추가되었을 때에는 Try 함수가 존재하지 않았었다.

CRITICAL_SECTION 과는 다르게 메모리 해제 관련 작업이 존재하지 않는다. (이와는 별도로 condition variable 과 연동 가능한 함수가 존재하지만 여기에서는 다루지 않는다.) i5-760 에서 단순 테스트 한 결과를 올림.

DWORD gTotalTime = 0;

SRWLOCK gSRWLock;
CRITICAL_SECTION gCS; 

unsigned __stdcall ThreadFun(void* pParm)
{
	for(size_t ii = 0; ii < 1000000; ++ii)
	{
		#if defined(SRW_LOCK)
		::AcquireSRWLockExclusive(&gSRWLock);
		#else
		::EnterCriticalSection(&gCS);
		#endif         

		++ gValue;         

		#if defined(SRW_LOCK)
		::ReleaseSRWLockExclusive(&gSRWLock);
		#else
		::LeaveCriticalSection(&gCS);
		#endif
	}     

	return 0;
}

INT    _tmain()
{
	typedef std::array
	TThreadHndList;     

	::InitializeCriticalSectionAndSpinCount(&gCS, 0x8000);
	::InitializeSRWLock(&gSRWLock);     

	TThreadHndList    aHndList;    

	std::fill(aHndList.begin(), aHndList.end(), static_cast(NULL));     

	for(size_t ii = 0; ii < ahndlist.size(); ++ii)
	{
		unsigned aThreadID;
		aHndList[ii]= reinterpret_cast<HANDLE>(::_beginthreadex(NULL, 0, ThreadFun, NULL, CREATE_SUSPENDED, &aThreadID));
	}     

	gTotalTime = ::GetTickCount();    

	std::for_each(aHndList.begin(), aHndList.end(), std::ptr_fun(ResumeThread));     

	DWORD aRV = ::WaitForMultipleObjects(aHndList.size(), aHndList.data(), TRUE, INFINITE);    

	gTotalTime = ::GetTickCount() - gTotalTime;    

	std::cout << "gVal : " << gValue << "\tTotal Time : " << gTotalTime << std::endl;     

	std::for_each(aHndList.begin(), aHndList.end(), std::ptr_fun(CloseHandle));     

	::DeleteCriticalSection(&gCS);
	return 0;
}

. 내부 구조는 기존 배열과 동일하지만 std::algorithm 에 적용하기 쉽게 랩핑되어 있습니다.

   1: // TEMPLATE CLASS array

   2: template<class _Ty,

   3:    size_t _Size>

   4:    class array

   5:    {   // fixed size array of values

   6: public:

   7:    enum {_EEN_SIZE = _Size};   // helper for expression evaluator

   8:  

   9:    typedef array<_Ty, _Size> _Myt;

  10:    typedef _Ty value_type;

  11:    typedef size_t size_type;

  12:    typedef ptrdiff_t difference_type;

  13:    typedef _Ty *pointer;

  14:    typedef const _Ty *const_pointer;

  15:    typedef _Ty& reference;

  16:    typedef const _Ty& const_reference;

  17:  

  18:    typedef _Array_iterator<_Ty, _Size> iterator;

  19:    typedef _Array_const_iterator<_Ty, _Size> const_iterator;

  20:  

  21:    typedef std::reverse_iterator<iterator> reverse_iterator;

  22:    typedef std::reverse_iterator<const_iterator> const_reverse_iterator;

  23:  

  24:    void assign(const _Ty& _Value)

  25:       {   // assign value to all elements

  26:       std::fill_n(_Elems, _Size, _Value);

  27:       }

  28:  

  29:    void swap(_Myt& _Other)

  30:       {   // swap contents with _Other

  31:       std::swap_ranges(_Other.begin(), _Other.end(), begin());

  32:       }

  33:  

  34:    iterator begin()

  35:       {   // return iterator for beginning of mutable sequence

  36:       return (iterator(&_Elems[0], 0));

  37:       }

  38:  

  39:    const_iterator begin() const

  40:       {   // return iterator for beginning of nonmutable sequence

  41:       return (const_iterator((pointer)&_Elems[0], 0));

  42:       }

  43:  

  44:    iterator end()

  45:       {   // return iterator for end of mutable sequence

  46:       return (iterator(&_Elems[0], _Size));

  47:       }

  48:  

  49:    const_iterator end() const

  50:       {   // return iterator for beginning of nonmutable sequence

  51:       return (const_iterator((pointer)&_Elems[0], _Size));

  52:       }

  53:  

  54:    reverse_iterator rbegin()

  55:       {   // return iterator for beginning of reversed mutable sequence

  56:       return (reverse_iterator(end()));

  57:       }

  58:  

  59:    const_reverse_iterator rbegin() const

  60:       {   // return iterator for beginning of reversed nonmutable sequence

  61:       return (const_reverse_iterator(end()));

  62:       }

  63:  

  64:    reverse_iterator rend()

  65:       {   // return iterator for end of reversed mutable sequence

  66:       return (reverse_iterator(begin()));

  67:       }

  68:  

  69:    const_reverse_iterator rend() const

  70:       {   // return iterator for end of reversed nonmutable sequence

  71:       return (const_reverse_iterator(begin()));

  72:       }

  73:  

  74:    size_type size() const

  75:       {   // return length of sequence

  76:       return (_Size);

  77:       }

  78:  

  79:    size_type max_size() const

  80:       {   // return maximum possible length of sequence

  81:       return (_Size);

  82:       }

  83:  

  84:    bool empty() const

  85:       {   // test if sequence is empty

  86:       return (_Size == 0);

  87:       }

  88:  

  89:    reference at(size_type _Pos)

  90:       {   // subscript mutable sequence with checking

  91:       if (_Size <= _Pos)

  92:          _Xoutrange();

  93:       return (_Elems[_Pos]);

  94:       }

  95:  

  96:    const_reference at(size_type _Pos) const

  97:       {   // subscript nonmutable sequence with checking

  98:       if (_Size <= _Pos)

  99:          _Xoutrange();

 100:       return (_Elems[_Pos]);

 101:       }

 102:  

 103:    reference operator[](size_type _Pos)

 104:       {   // subscript mutable sequence

 105:  #if _HAS_ITERATOR_DEBUGGING

 106:       if (_Size <= _Pos)

 107:          _DEBUG_ERROR("array subscript out of range");

 108:  #endif /* _HAS_ITERATOR_DEBUGGING */

 109:  

 110:       _SCL_SECURE_VALIDATE_RANGE(_Pos < _Size);

 111:  

 112:       return (_Elems[_Pos]);

 113:       }

 114:  

 115:    const_reference operator[](size_type _Pos) const

 116:       {   // subscript nonmutable sequence

 117:  #if _HAS_ITERATOR_DEBUGGING

 118:       if (_Size <= _Pos)

 119:          _DEBUG_ERROR("array subscript out of range");

 120:  #endif /* _HAS_ITERATOR_DEBUGGING */

 121:  

 122:       _SCL_SECURE_VALIDATE_RANGE(_Pos < _Size);

 123:  

 124:       return (_Elems[_Pos]);

 125:       }

 126:  

 127:    reference front()

 128:       {   // return first element of mutable sequence

 129:  #if _HAS_ITERATOR_DEBUGGING

 130:       if (_Size == 0)

 131:          _DEBUG_ERROR("array<T, 0>::front() invalid");

 132:  #endif /* _HAS_ITERATOR_DEBUGGING */

 133:  

 134:       _SCL_SECURE_VALIDATE_RANGE(0 < _Size);

 135:  

 136:       return (_Elems[0]);

 137:       }

 138:  

 139:    const_reference front() const

 140:       {   // return first element of nonmutable sequence

 141:  #if _HAS_ITERATOR_DEBUGGING

 142:       if (_Size == 0)

 143:          _DEBUG_ERROR("array<T, 0>::front() invalid");

 144:  #endif /* _HAS_ITERATOR_DEBUGGING */

 145:  

 146:       _SCL_SECURE_VALIDATE_RANGE(0 < _Size);

 147:  

 148:       return (_Elems[0]);

 149:       }

 150:  

 151:    reference back()

 152:       {   // return last element of mutable sequence

 153:  #if _HAS_ITERATOR_DEBUGGING

 154:       if (_Size == 0)

 155:          _DEBUG_ERROR("array<T, 0>::back() invalid");

 156:  #endif /* _HAS_ITERATOR_DEBUGGING */

 157:  

 158:       _SCL_SECURE_VALIDATE_RANGE(0 < _Size);

 159:  

 160:       return (_Elems[_Size - 1]);

 161:       }

 162:  

 163:    const_reference back() const

 164:       {   // return last element of nonmutable sequence

 165:  #if _HAS_ITERATOR_DEBUGGING

 166:       if (_Size == 0)

 167:          _DEBUG_ERROR("array<T, 0>::back() invalid");

 168:  #endif /* _HAS_ITERATOR_DEBUGGING */

 169:  

 170:       _SCL_SECURE_VALIDATE_RANGE(0 < _Size);

 171:  

 172:       return (_Elems[_Size - 1]);

 173:       }

 174:  

 175:    _Ty *data()

 176:       {   // return pointer to mutable data array

 177:       return (_Elems);

 178:       }

 179:  

 180:    const _Ty *data() const

 181:       {   // return pointer to nonmutable data array

 182:       return (_Elems);

 183:       }

 184:  

 185:    _Ty _Elems[_Size == 0 ? 1 : _Size];

 186:    };

. 실제 구현 코드이며 소스 젤 아래 부분을 보시면 _Ty 에 대해 _Size 만큼 배열을 잡는걸 볼 수 있습니다. (0 이면 크기를 1로 잡는군요 –_-ㅋ)

. 실제 배열을 가지고 있으며 인터페이스는 size() 와 max_size() 가 동일하게 _Size 를 돌려주는 애매한 상황만 말고는 다들 이름만 보고도 이해가 갈만합니다.

. 요즘 배열보다는 array 를 더 자주 사용하고있습니다. 보기도 좋군요 @_@ㅋ (개인적인 취향입니다)

성능 테스트 방법은 N 개의 스레드에서 동시적은 push 와 N 개의 스레드에서 동시적인 pop 으로 동시성 위주의 테스트를 진행했습니다.

테스트 코드는 다음과 같습니다.

   1: #define   USE_TBB_CONCURRENT_QUEUE   __DEFINE_DEFAULT_VALUE__

   2:  

   3: volatile LONGLONG                  gPushTerm(0);

   4: volatile LONGLONG                  gPopTerm(0);

   5:  

   6: #ifdef   USE_TBB_CONCURRENT_QUEUE

   7: typedef   tbb::concurrent_queue<INT>   TIntQueue;

   8: TIntQueue                     gQueue;

   9: #else

  10: typedef   CQueue<INT>               TIntQueue;

  11: TIntQueue                     gQueue;

  12: #endif

  13:  

  14:  

  15: unsigned WINAPI   Producer(VOID*)

  16: {

  17:    CStopWatch   aWatch;

  18:  

  19:    ::Sleep(1 * 1000);

  20:  

  21:    aWatch.Start();

  22:    for(INT ii(0); ii < 100000; ++ii)

  23:    {

  24:       #ifdef   USE_TBB_CONCURRENT_QUEUE

  25:       gQueue.push(ii);

  26:       #else

  27:       gQueue.Push(ii);

  28:       #endif

  29:    }

  30:    aWatch.Stop();

  31:  

  32:    std::cout << "Producer Thread : " << GetThreadId(GetCurrentThread()) << '\t' << aWatch.GetUser() + aWatch.GetKernel() << std::endl;

  33:  

  34:    ::InterlockedExchangeAdd64(&gPushTerm, aWatch.GetUser() + aWatch.GetKernel());

  35:    return(0);

  36: }

  37:  

  38: unsigned WINAPI Consumer(VOID*)

  39: {

  40:    CStopWatch   aWatch;

  41:  

  42:    ::Sleep(1 * 1000);

  43:  

  44:    aWatch.Start();

  45:    for(INT ii(0); ii < 100000; ++ii)

  46:    {

  47:       INT aVal(0);

  48:       #ifdef   USE_TBB_CONCURRENT_QUEUE

  49:       gQueue.try_pop(aVal);

  50:       #else

  51:       gQueue.PopFifo(aVal);

  52:       #endif

  53:    }

  54:    aWatch.Stop();

  55:  

  56:    std::cout << "Consumer Thread : " << GetThreadId(GetCurrentThread()) << '\t' << aWatch.GetUser() + aWatch.GetKernel() << std::endl;

  57:  

  58:    ::InterlockedExchangeAdd64(&gPopTerm, aWatch.GetUser() + aWatch.GetKernel());

  59:    return(0);

  60: }

  61:  

  62: INT   _tmain(VOID)

  63: {

  64:    typedef   std::tr1::array<HANDLE, 10>   THandleArray;

  65:    tbb::task_scheduler_init         aInit(10);

  66:    size_t                        aHndleCnt(0);

  67:    THandleArray                  aHandleArray;

  68:    

  69:    #ifndef   USE_TBB_CONCURRENT_QUEUE

  70:    gQueue.Open();

  71:    #endif

  72:  

  73:    for(size_t ii(0); ii < aHandleArray.size(); ++ii)

  74:    {

  75:       unsigned aThreadID;

  76:       aHandleArray[aHndleCnt ++] = (HANDLE) ::_beginthreadex(NULL, 0, Producer, NULL, CREATE_SUSPENDED, &aThreadID);

  77:    }

  78:  

  79:    std::for_each(aHandleArray.begin(), aHandleArray.end(), ResumeThread);

  80:    WaitForMultipleObjects(aHandleArray.size(), aHandleArray.data(), TRUE, INFINITE);

  81:    std::for_each(aHandleArray.begin(), aHandleArray.end(), CloseHandle);

  82:  

  83:    aHndleCnt = 0;

  84:  

  85:    for(size_t ii(0); ii < aHandleArray.size(); ++ii)

  86:    {

  87:       unsigned aThreadID;

  88:       aHandleArray[aHndleCnt ++] = (HANDLE) ::_beginthreadex(NULL, 0, Consumer, NULL, CREATE_SUSPENDED, &aThreadID);

  89:    }

  90:  

  91:    std::for_each(aHandleArray.begin(), aHandleArray.end(), ResumeThread);

  92:    WaitForMultipleObjects(aHandleArray.size(), aHandleArray.data(), TRUE, INFINITE);

  93:    std::for_each(aHandleArray.begin(), aHandleArray.end(), CloseHandle);

  94:  

  95:  

  96:    std::cout << std::endl;

  97:  

  98:    #ifdef   USE_TBB_CONCURRENT_QUEUE

  99:    std::cout << gQueue.unsafe_size() << std::endl;

 100:    #else

 101:    std::cout << gQueue.GetCnt() << std::endl;

 102:    #endif   

 103:  

 104:    #ifndef   USE_TBB_CONCURRENT_QUEUE

 105:    gQueue.Close();

 106:    #endif

 107:  

 108:    std::cout << "PushTerm : " << gPushTerm << std::endl;

 109:    std::cout << "PopTerm : " << gPopTerm << std::endl;

 110:    return(0);

 111: }

생산자 스레드 10개 소비자 스레드 10개로 테스트를 진행했으며 스레드는 모두 생성이 된 후 시작시켰습니다.

결과는 다음과 같습니다.

. 단순 배열에 값을 대입

   1: VOID    TestSerial(__in INT* pArray, __in size_t pCount)

   2: {

   3:     for(size_t ii = 0; ii < pCount; ++ii)

   4:     {

   5:         pArray[ii]    = ii;

   6:     }

   7: }

   8:  

   9: VOID    TestParallel(__in INT* pArray, __in size_t pCount)

  10: {

  11:     struct    SFunctor

  12:     {

  13:         INT*            mArray;

  14:         SFunctor(__in INT* pArray) : mArray(pArray)    {}

  15:         VOID    operator() (const tbb::blocked_range<size_t>& pArg) const

  16:         {

  17:             for(size_t ii = pArg.begin(); ii != pArg.end(); ++ii)

  18:             {

  19:                 mArray[ii] = ii;

  20:             }

  21:         }

  22:     };

  23:  

  24:     tbb::parallel_for(tbb::blocked_range<size_t>(0, pCount, 1000), SFunctor(pArray));

  25: }

  26:  

  27: INT    _tmain(VOID)

  28: {

  29:     const size_t        aSz     = 100000000;

  30:     INT*                aArray  = new INT[aSz];

  31:     std::fill(aArray, aArray + aSz, 0);

  32:     

  33:     tbb::task_scheduler_init    aInit;

  34:  

  35:     CStopWatch        aWatch;

  36:  

  37:     ::Sleep(1 * 1000);

  38:  

  39:     aWatch.Start();

  40:     TestSerial(aArray, aSz);

  41:     aWatch.Stop();

  42:  

  43:     std::cout << "Serial User Time: " << aWatch.GetUser() << std::endl;

  44:     std::cout << "Serial Kernel Time: " << aWatch.GetKernel() << std::endl;

  45:  

  46:     ::Sleep(1 * 1000);

  47:  

  48:     std::fill(aArray, aArray + aSz, 0);

  49:  

  50:     aWatch.Start();

  51:     TestParallel(aArray, aSz);

  52:     aWatch.Stop();

  53:  

  54:     std::cout << "Parallel User Time: " << aWatch.GetUser() << std::endl;

  55:     std::cout << "Parallel Kernel Time: " << aWatch.GetKernel() << std::endl;

  56:  

  57:     delete[]    aArray;

  58:     return(0);

  59: }

. 테스트는 Intel Core2 Quad 2.4G 에서 진행했습니다. (물리적 코어 4)

. TestSerial 함수는 직렬 처리 함수입니다. 단순하게 배열의 인덱스에 현재 인덱스 카운트를 설정합니다.

. TestParallel 함수는 병렬 처리 함수입니다. 루프작업을 분할해서 처리합니다.

 

	직렬 처리	병렬 처리
1회	1560010 (1560010 + 0)	1404009 (1404009 + 0)
2회	1560010 (1560010 + 0)	1404009 (1404009 + 0)
3회	1560010 (1560010 + 0)	1404009 (1404009 + 0)
4회	1560010 (1560010 + 0)	1404009 (1404009 + 0)
5회	1560010 (1560010 + 0)	1404009 (1404009 + 0)
6회	1560010 (1560010 + 0)	1404009 (1404009 + 0)
7회	1560010 (1560010 + 0)	1404009 (1404009 + 0)
8회	1560010 (1560010 + 0)	1404009 (1404009 + 0)
9회	1560010 (1560010 + 0)	1404009 (1404009 + 0)
10회	1716011 (1716011 + 0)	1404009 (1404009 + 0)
평균	1575610 (1575610 + 0)	1404009 (1404009 + 0)

 

10번 테스트 해봤습니다. 단위는 nsec 로 병렬처리가 약간(?) 효율이 좋네요.

(앞쪽이 유저 모드 소모시간 뒤쪽이 커널 모드 소모 시간입니다.)

 

. 반복문 마다 파일 Open, Read, Close 하는 경우

 

   1: VOID   TestFun(__in INT pIndex)

   2: {

   3:    std::ifstream   aFile;

   4:    aFile.open(L"test.txt", std::ios_base::in);

   5:  

   6:    if(aFile.is_open())

   7:    {

   8:       CHAR   aBuf[MAX_PATH];

   9:       aFile.getline(aBuf, _countof(aBuf));

  10:    }

  11:  

  12:    aFile.close();

  13: }

  14:  

  15: VOID   TestSerial(__in INT* pArray, __in size_t pCount)

  16: {

  17:    for(size_t ii = 0; ii < pCount; ++ii)

  18:    {

  19:       pArray[ii]   = ii;

  20:       TestFun(ii);

  21:    }

  22: }

  23:  

  24: VOID   TestParallel(__in INT* pArray, __in size_t pCount)

  25: {

  26:    struct   SFunctor

  27:    {

  28:       INT*         mArray;

  29:       SFunctor(__in INT* pArray) : mArray(pArray)   {}

  30:       VOID   operator() (const tbb::blocked_range<size_t>& pArg) const

  31:       {

  32:          for(size_t ii = pArg.begin(); ii != pArg.end(); ++ii)

  33:          {

  34:             mArray[ii] = ii;

  35:             TestFun(ii);

  36:          }

  37:       }

  38:    };

  39:  

  40:    tbb::parallel_for(tbb::blocked_range<size_t>(0, pCount, 100), SFunctor(pArray));

  41: }

  42:  

  43: INT   _tmain(VOID)

  44: {

  45:    const size_t      aSz      = 1000;

  46:    INT*            aArray  = new INT[aSz];

  47:    std::fill(aArray, aArray + aSz, 0);

  48:    

  49:    tbb::task_scheduler_init   aInit;

  50:  

  51:    CStopWatch      aWatch;

  52:  

  53:    ::Sleep(1 * 1000);

  54:    for(INT ii = 0; ii < 10; ++ii)

  55:    {

  56:       aWatch.Start();

  57:       TestSerial(aArray, aSz);

  58:       aWatch.Stop();

  59:  

  60:       std::cout << "Serial User Time: " << aWatch.GetUser() << std::endl;

  61:       std::cout << "Serial Kernel Time: " << aWatch.GetKernel() << std::endl;

  62:       std::cout << "Serial Total Time : " << aWatch.GetUser() + aWatch.GetKernel() << std::endl;

  63:  

  64:       ::Sleep(1 * 1000);

  65:  

  66:       std::fill(aArray, aArray + aSz, 0);

  67:  

  68:       aWatch.Start();

  69:       TestParallel(aArray, aSz);

  70:       aWatch.Stop();

  71:  

  72:       std::cout << "Parallel User Time: " << aWatch.GetUser() << std::endl;

  73:       std::cout << "Parallel Kernel Time: " << aWatch.GetKernel() << std::endl;

  74:       std::cout << "Parallel Total Time : " << aWatch.GetUser() + aWatch.GetKernel() << std::endl;

  75:  

  76:       std::cout << std::endl;

  77:       ::Sleep(1 * 1000);

  78:    }

  79:  

  80:    delete[]   aArray;

  81:    return(0);

  82: }

. 기존 테스트 루틴에 추가로 각각의 루프안에서 파일 Open, Read, Close 를 하는 루틴을 넣고, 반복회수를 기존 1억번에서 1000번으로 줄였습니다.

	직렬 처리	병렬 처리
1회	624004 (0 + 624004)	312002 (0 + 312002)
2회	624004 (156001 + 468003)	312002 (156001 + 156001)
3회	624004 (0 + 624004)	312002 (0 + 312002)
4회	624004 (156001 + 468003)	312002 (156001 + 156001)
5회	624004 (312002 + 312002)	312002 (156001 + 156001)
6회	624004 (0 + 624004)	312002 (0 + 312002)
7회	624004 (0 + 624004)	312002 (0 + 312002)
8회	624004 (312002 + 312002)	312002 (156001 + 156001)
9회	624004 (0 + 624004)	312002 (0 + 312002)
10회	624004 (156001 + 468003)	312002 (0 + 312002)
평균	624004 (109200 + 514803)	312002 (62400 + 249061)

 

커널 모드와 유저 모드의 시간이 뒤죽박이네요.

 

합치면 같은 시간이고 –_-ㅋ 무엇이 잘된건가? @_@ㅋ

 

병렬 처리가 직렬 처리에 비해 두배 정도 성능이 좋게 나오는군요

 

덧) 테스트시 tbb::task_scheduler_init 을 할때 스레드 생성 수를 변경시키니(코어수 보다 높게) 성능이 더 좋게 나오는군요. (기본으로 하면 스레드가 4개 생성이 되었습니다. 쿼드코어라서 코어 수만큼 생성시키는것인가?)

이번에 구매한 책입니다.

이전부터 TDD 관련해서 관심이 많았습니다.

실제 테스팅을 어떤방식으로 진행해야할지 난감했었습니다.

이번에 박PD님꼐서 고생을 하셔서 이렇게 번역서가 나왔네요. 기대가 됩니다 @_@

회사에서 지원해줘서 가는데 도움이 됐으면 합니다. ㅠ_ㅠ;

최근에 (머 포스팅도 하지 않았었지만) windows live writer 를 사용해서 마눌님 블로그에 하나를 올려봤는데 상당히 편하더군요.

실제 블로그의 스킨 및 스타일을 가져와서 포스팅하는데 미리 볼수도 있고 나름괜찮았었습니다.

그런 도중 소스코드 하이라이팅관련된건 없나 하고 구글에 쳐보니 그냥 나오더군요. code snippet 플러그인만 설치하고 소스 타입 설정하고

내용넣고 insert 하니 이쁘게 들어가네요. 한가지 문제는 한글 한글자라도 들어가면 라인이 정렬이 안된다는거 –_-

소스코드에 한글 안넣으면 될것이고. –_- 그래서 지금 대 만족중입니다. ㅋ

. std::pair 의 일반화시킨 클래스 템플릿

. 기존 std::pair 는 두 개의 원소를 담았지만 tuple 은 N 개의 원소를 담는다. (실제 최대 N 은 라이브러리 구현마다 다를수 있으며, 기술보고서에서 N 을 최소 10개 이상으로 권장한다.)

. tuple 객체 생성

. 기본 생성자

   1: #include <tchar.h>

   2: #include <windows.h>

   3: #include <iostream>

   4: #include <tuple>

   5:  

   6: int   _tmain(void)

   7: {

   8:    std::tr1::tuple<>      t0;            // 1  

   9:    std::tr1::tuple<int>   t1;            // 2

  10:    std::tr1::tuple<int>   t2(3);         // 3

  11:    std::tr1::tuple<int>   t3(t2);        // 4

  12:  

  13:    return   0;

  14: }

1. 아무런 데이터를 갖지 않는 tuple 기본 생성자
2. int 형 데이터를 하나 갖는 tuple 기본 생성자
3. int 형 데이터를 하나 갖는 tuple 을 3으로 초기화 하는 생성자
4. int 형 대이터를 하나 갖는 tuple 을 동일 데이터 타입의 tuple 객체로 초기화.

. make_tuple 함수를 통한 tuple 객체 생성

   1: #include <tchar.h>

   2: #include <windows.h>

   3: #include <iostream>

   4: #include <tuple>

   5:  

   6: int   _tmain(void)

   7: {

   8:    int      i0   = 0;

   9:    std::tr1::tuple<int, int&, const int&>   t0 = std::tr1::make_tuple(10, std::tr1::ref(i0), std::tr1::cref(i0));

  10:    return   0;

  11: }

• . make_tuple 은 인자로 넘어온 value 에 맞는 tuple 을 추론하여 해당 객체를 돌려준다.
• . std::tr1::ref 와 std::tr1::cref 는 해당 변수의 ref 와 const ref 데이터 타입을 돌려준다.

. std::tr1::tie 를 이용한 생성

• . tie 는 주어진 인수들의 참조들을 담은 tuple 객체를 생성해준다. 그리고 특정 인수에 대한 원소의 배정을 생략하고 싶은 경우  std::tr1::ignore 라는 값을 지정하면 된다.
• . 개인적의 의견으로는 tie 를 통해 객체를 생성 후 핸드링하는건 타입을 명시해서 생성해야 하고 그렇지않으면 1회용이라 그렇게 의미가 있는지 모르겠음

   1: #include <tchar.h>

   2: #include <windows.h>

   3: #include <iostream>

   4: #include <tuple>

   5:  

   6: int   _tmain(void)

   7: {

   8:    int      i0   = 0;

   9:  

  10:    std::tr1::tuple<int&> t0 = std::tr1::tie(i0) = std::tr1::make_tuple(10);

  11:    std::cout << std::tr1::get<0>(t0) << std::endl;

  12:  

  13:    std::tr1::tie(i0) = std::tr1::make_tuple(20);

  14:    std::cout << std::tr1::get<0>(t0) << std::endl;

  15:    return   0;

  16: }

• . 위의 경우는 t0 에 tie 를 통해 생성한 객체를 담았다. tie 는 make_tuple 을 통해 i0 을 10으로 설정했다.
• . 아래의 경우에는 단순 tie 를 make_tuple 로 초기화 하는 기능만을 한다.

. tuple 접근

. std::tr1::get 함수 템플릿을 이용한 데이터 접근

• . get 함수 템플릿은 tuple 객체의 한 원소에 대한 참조를 돌려줌으로서 해당 참조를 수정하면 tuple 객체의 데이터를 수정할 수 있다.
• . 해당 원소가 참조이면 실제 tuple 이 가리키는 원소에 데이터도 수정가능하다.

   1: #include <tchar.h>

   2: #include <windows.h>

   3: #include <iostream>

   4: #include <tuple>

   5:  

   6: int   _tmain(void)

   7: {

   8:    int      i0   = 0;

   9:  

  10:    std::tr1::tuple<int&> t0(i0);

  11:  

  12:    int&   ref_i = std::tr1::get<0>(t0);

  13:    ref_i   = 10;

  14:  

  15:    std::cout << std::tr1::get<0>(t0);

  16:    return   0;

  17: }

• . 위의 경우 tuple 이 참조를 가리키고 있어 실제 i0 데이터가 수정이 된다.

.  부가 기능

. tuple 의 원소의 개수를 알고싶은경우

• . std::tr1::tuple_size 라는 함수 템플릿을 사용하면 된다.
• . 인자는 변수명이 아닌 데이터 타입이기에 typedef 해서 사용하지 않으면 타이핑 노가다가 생길 수 있다. (그다지 의미있는 기능은 아닌듯함)

   1: #include <tchar.h>

   2: #include <windows.h>

   3: #include <iostream>

   4: #include <tuple>

   5:  

   6: typedef   std::tr1::tuple<int>   tuple0;

   7: int   _tmain(void)

   8: {

   9:    tuple0 t0(0);

  10:    std::cout << std::tr1::tuple_size<tuple0>::value << std::endl;

  11:    return   0;

  12: }

. tuple 의 특정 원소의 데이터 타입을 알아내기

• . std::tr1::tuple_element 템플릿 함수로 원소타입을 알아 낼 수 있다. 해당 함수는 알고자하는 인덱스와 tuple 데이터 형식이 필요하다. 역시 typedef 하고 사용하는게 정신건강에 이로울 듯 하다.
• . 특정 타입에 대해 하드 코딩을 하지 않고 실제 tuple 에 의존하기 때문에 코드가 보기 좋을 듯 하다. (데이터 타입이 변경된다고 따라서 수정하지 않으니 이 얼마나 나이스한가?)

   1: #include <tchar.h>

   2: #include <windows.h>

   3: #include <iostream>

   4: #include <tuple>

   5:  

   6: typedef   std::tr1::tuple<int>   tuple0;

   7: int   _tmain(void)

   8: {

   9:    tuple0 t0(0);

  10:  

  11:    std::tr1::tuple_element<0, tuple0>::type   tuple_0_type = 10;

  12:    std::cout << tuple_0_type;

  13:    return   0;

  14: }

. 비교연산은 사전식 비교를 합니다. 각 원소타입별 비교연산자가 선언되어있으면 가능합니다.