이 어플리케이션은 하드웨어단위의 사용상태 및 프로세스 단위의 현재 상태 정보 등을 알 수 있습니다.

PDH 함수를 사용하면 이런 성능데이터를 개발자의 어플리케이션에 수집할 수 있습니다.

PDH 함수를 사용하여 성능 데이터를 수집하는 방법은 다음과 같습니다.

쿼리 생성

   1: PDH_STATUS PdhOpenQuery(

   2:   __in   LPCTSTR szDataSource,

   3:   __in   DWORD_PTR dwUserData,

   4:   __out  PDH_HQUERY *phQuery

   5: );

   1: PDH_STATUS PdhAddCounter(

   2:   __in   PDH_HQUERY hQuery,

   3:   __in   LPCTSTR szFullCounterPath,

   4:   __in   DWORD_PTR dwUserData,

   5:   __out  PDH_HCOUNTER *phCounter

   6: );

   1: PDH_STATUS PdhCollectQueryData(

   2:   __inout  PDH_HQUERY hQuery

   3: );

   1: PDH_STATUS PdhGetFormattedCounterValue(

   2:   __in   PDH_HCOUNTER hCounter,

   3:   __in   DWORD dwFormat,

   4:   __out  LPDWORD lpdwType,

   5:   __out  PPDH_FMT_COUNTERVALUE pValue

   6: );

 

   1: PDH_STATUS PdhCloseQuery(

   2:   __in  PDH_HQUERY hQuery

   3: );

사용법도 간단하고 효과도 좋은거 같습니다. 실시간 메모리 할당을 얼마나 할지는 몰라도 적용하기도 쉬운데 굳이 사용하지 않을 이유는 없을거 같네요.

간단하게 사용법은

   1: #include <tbb/tbbmalloc_proxy.h>

헤더를 추가하고 tbb 관련 dll 들만 추가시켜 주면 malloc / free, new / delete 가 tbb 관련 함수들로 치환이 됩니다.

사용하지 않으려면 단순 헤더파일만 제거해 주시면 됩니다.

코어 4개인 PC 에서 스레드 4, 10개로 테스트 해봤는데 두배 정도의 차이가 났습니다.

그런데 오름차순으로 정렬하면서 NULL 을 가장큰값으로 설정하고 싶은데 어떻게 하면 가능할까요?

   1: ORDER BY CASE WHEN mColumn IS NULL THEN 적당히 큰값 ELSE mColumn END ASC;

그냥 이것저것 둘러보는 중에 설치형 블로그와 무료 웹호스팅서비를 알게되서 (실은 묶음으로 되어있는 게시글을.-_-) 이전해봤습니다.

도메인의 넴서버 변경을 했는데 회사 PC에서는 도메인으로 접속이 안되는데.. 와이브로로는 되는군요. –_-ㅋ

둘의 네임서버가 달라서 발생하는 현상인거 같은데.. 어찌됐든 와이브로에는 되니깐.. 회사거에도 언제가는 되겠죠?

설치형 블로그는 첨이라 이것저것 헤매고있습니다. 플러그인들은 머가 좋은지 모르겠고 –_-ㅋ

그래도 도메인이 하나로 유지되니 좋긴하네요 @_@

. 내부 구조는 기존 배열과 동일하지만 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 하니 이쁘게 들어가네요. 한가지 문제는 한글 한글자라도 들어가면 라인이 정렬이 안된다는거 –_-

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