平衡堆栈？

玻璃小屋 — Wed, 20 Aug 2008 06:48:00 GMT

__declspec(naked) void f() {

__asm pushad

if(lpMessageBoxA) {

lpMessageBoxA(NULL, "this is f", "ok", MB_OK);

__asm {

popad

ret 10h

}

time_t 在 CE 和 PC 上编译不一致

玻璃小屋 — Fri, 25 Jul 2008 05:17:00 GMT

vs2005 以及以上在PC系统上，time_t 都编译成 64位的时间了（__time64_t）。
但是在CE系统上还是被编译成 32位的时间（__time32_t）。

问题就来了。。当用 socket 写程序时
定义这样的结构
struct
{
UINT uiCmd;
time_t uiCmdTime;
}

这时 PC 和 CE用socket 传递数据。问题就出来了。。。

不过 CE上面没有 time_t 类型的相关函数 time、gmtime 等~ 可能M$不推荐在CE上用time_t
自己注意一下。

Windows mobile 用CreateThread不会造成泄露~

玻璃小屋 — Wed, 23 Jul 2008 08:12:00 GMT

在win PC 系统上一般需要用 _beginthreadex 来开线程，而不是用CreateThread开线程，因为_beginthreadex 会对CRT的一些函数，比如 gmtime,strerror等函数申请(malloc)的临时内存进行释放。
具体代码可以在CRT源代码中查到，如下：

/***
*void WINAPI _freefls(void *) - free up a per-fiber data structure
*
*Purpose:
*       Called from _freeptd, as a callback from deleting a fiber, and
*       from deleting an FLS index. This routine frees up the per-fiber
*       buffer associated with a fiber that is going away. The tiddata
*       structure itself is freed, but not until its subordinate buffers
*       are freed.
*
*Entry:
*       pointer to a per-fiber data block (malloc-ed memory)
*
*Exit:
*
*Exceptions:
*
*******************************************************************************/

_CRTIMP void
WINAPI
_freefls (
    void *data
    )

{

    _ptiddata ptd;
    pthreadlocinfo ptloci;
    pthreadmbcinfo ptmbci;

    /*
     * Free up the _tiddata structure & its malloc-ed buffers.
     */

    ptd = data;
    if (ptd != NULL) {
        if(ptd->_errmsg)
            _free_crt((void *)ptd->_errmsg);

        if(ptd->_namebuf0)
            _free_crt((void *)ptd->_namebuf0);

        if(ptd->_namebuf1)
            _free_crt((void *)ptd->_namebuf1);

        if(ptd->_asctimebuf)
            _free_crt((void *)ptd->_asctimebuf);

        if(ptd->_wasctimebuf)
            _free_crt((void *)ptd->_wasctimebuf);

        if(ptd->_gmtimebuf)
            _free_crt((void *)ptd->_gmtimebuf);

        if(ptd->_cvtbuf)
            _free_crt((void *)ptd->_cvtbuf);

        if (ptd->_pxcptacttab != _XcptActTab)
            _free_crt((void *)ptd->_pxcptacttab);

        _mlock(_MB_CP_LOCK);
        __try {
            if ( ((ptmbci = ptd->ptmbcinfo) != NULL) &&
                 (InterlockedDecrement(&(ptmbci->refcount)) == 0) &&
                 (ptmbci != &__initialmbcinfo) )
                _free_crt(ptmbci);
        }
        __finally {
            _munlock(_MB_CP_LOCK);
        }

        _mlock(_SETLOCALE_LOCK);

        __try {
            if ( (ptloci = ptd->ptlocinfo) != NULL )
            {
                __removelocaleref(ptloci);
                if ( (ptloci != __ptlocinfo) &&
                     (ptloci != &__initiallocinfo) &&
                     (ptloci->refcount == 0) )
                    __freetlocinfo(ptloci);
            }
        }
        __finally {
            _munlock(_SETLOCALE_LOCK);
        }

        _free_crt((void *)ptd);
    }
    return;
}

/***
*void _freeptd(_ptiddata) - free up a per-thread data structure
*
*Purpose:
*       Called from _endthread and from a DLL thread detach handler,
*       this routine frees up the per-thread buffer associated with a
*       thread that is going away.  The tiddata structure itself is
*       freed, but not until its subordinate buffers are freed.
*
*Entry:
*       pointer to a per-thread data block (malloc-ed memory)
*       If NULL, the pointer for the current thread is fetched.
*
*Exit:
*
*Exceptions:
*
*******************************************************************************/

void __cdecl _freeptd (
        _ptiddata ptd
        )
{
        /*
         * Do nothing unless per-thread data has been allocated for this module!
         */

        if ( __flsindex != FLS_OUT_OF_INDEXES ) {

            /*
             * if parameter "ptd" is NULL, get the per-thread data pointer
             * Must NOT call _getptd because it will allocate one if none exists!
             * If FLS_GETVALUE is NULL then ptd could not have been set
             */

            if ( ptd == NULL
#ifdef _M_IX86
                 && (FLS_GETVALUE != NULL)
#endif  /* _M_IX86 */
                )
                ptd = FLS_GETVALUE(__flsindex);

            /*
             * Zero out the one pointer to the per-thread data block
             */

            FLS_SETVALUE(__flsindex, (LPVOID)0);

            _freefls(ptd);
        }

#ifdef _M_IX86
        if ( __getvalueindex != TLS_OUT_OF_INDEXES ) {
            /*
             * Zero out the FlsGetValue pointer
             */
            TlsSetValue(__getvalueindex, (LPVOID)0);
        }
#endif  /* _M_IX86 */
}

而在win mobile( wince)系统中没有这些顾虑！因为在 wm (ce) 上面根本就没有提供造成申请线程全局内存的函数。。比如 gmtime strerror等在CE上都没有被提供。所以也不会造成内存泄露~证据如下：

#if !defined(_WIN32_WCE)
/* These are not supported on CE */
using ::strcoll; using ::strerror; using ::strxfrm;
#endif

#if !defined(_WIN32_WCE)
// These are not supported on CE
using ::freopen; using ::getc; using ::perror;
using ::putc;
using ::remove; using ::rename; using ::rewind;
using ::setbuf; using ::tmpfile; using ::tmpnam;
#endif

#if !defined(_WIN32_WCE)
using ::asctime; using ::clock; using ::ctime;
using ::gmtime; using ::localtime;
using ::mktime; using ::strftime; using ::time;
#endif /* _WIN32_WCE */

还有一个证据就是 CE上的 MFC 实现的 CWinThread类，他开线程也是用的CreateThread

BOOL CWinThread::CreateThread(DWORD dwCreateFlags, UINT nStackSize,
    LPSECURITY_ATTRIBUTES lpSecurityAttrs)
{
#ifndef _MT
    dwCreateFlags;
    nStackSize;
    lpSecurityAttrs;

    return FALSE;
#else
    ENSURE(m_hThread == NULL);  // already created?

    // setup startup structure for thread initialization
    _AFX_THREAD_STARTUP startup; memset(&startup, 0, sizeof(startup));
    startup.pThreadState = AfxGetThreadState();
    startup.pThread = this;
    startup.hEvent = ::CreateEvent(NULL, TRUE, FALSE, NULL);
    startup.hEvent2 = ::CreateEvent(NULL, TRUE, FALSE, NULL);
    startup.dwCreateFlags = dwCreateFlags;
    if (startup.hEvent == NULL || startup.hEvent2 == NULL)
    {
        TRACE(traceAppMsg, 0, _T("Warning: CreateEvent failed in CWinThread::CreateThread. "));
        if (startup.hEvent != NULL)
            ::CloseHandle(startup.hEvent);
        if (startup.hEvent2 != NULL)
            ::CloseHandle(startup.hEvent2);
        return FALSE;
    }

    // create the thread (it may or may not start to run)
#ifndef _WIN32_WCE
    m_hThread = (HANDLE)(ULONG_PTR)_beginthreadex(lpSecurityAttrs, nStackSize,
        &_AfxThreadEntry, &startup, dwCreateFlags | CREATE_SUSPENDED, (UINT*)&m_nThreadID);
#else
    m_hThread = (HANDLE)(ULONG_PTR)::CreateThread(lpSecurityAttrs, nStackSize,
        (LPTHREAD_START_ROUTINE)&_AfxThreadEntry, &startup, dwCreateFlags | CREATE_SUSPENDED, (LPDWORD)&m_nThreadID);
#endif // !_WIN32_WCE
    if (m_hThread == NULL)
    {
        ::CloseHandle(startup.hEvent);
        ::CloseHandle(startup.hEvent2);
        return FALSE;
    }

    // start the thread just for MFC initialization
    VERIFY(ResumeThread() != (DWORD)-1);
    VERIFY(::WaitForSingleObject(startup.hEvent, INFINITE) == WAIT_OBJECT_0);
    ::CloseHandle(startup.hEvent);

    // if created suspended, suspend it until resume thread wakes it up
    if (dwCreateFlags & CREATE_SUSPENDED)
        VERIFY(::SuspendThread(m_hThread) != (DWORD)-1);

    // if error during startup, shut things down
    if (startup.bError)
    {
        VERIFY(::WaitForSingleObject(m_hThread, INFINITE) == WAIT_OBJECT_0);
        ::CloseHandle(m_hThread);
        m_hThread = NULL;
        ::CloseHandle(startup.hEvent2);
        return FALSE;
    }

    // allow thread to continue, once resumed (it may already be resumed)
    VERIFY(::SetEvent(startup.hEvent2));
    return TRUE;
#endif //!_MT
}