Chinaunix首页 | 论坛 | 博客

路漫漫vincent.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

vincent-cws

  • 博客访问： 955413
  • 博文数量： 116
  • 博客积分： 3923
  • 博客等级： 中校
  • 技术积分： 1337
  • 用 户 组： 普通用户
  • 注册时间： 2009-04-23 01:22
文章分类

全部博文（116）

文章存档

2013年（1）

2012年（17）

2011年（69）

2009年（29）

我的朋友
最近访客
推荐博文
相关博文
实现一个debug系统

分类： WINDOWS

2011-09-18 19:00:52

http://vincent.blog.chinaunix.net

这两天终于把debugx写完，主要是针对windows平台，还没有porting到linux平台，下一步就是porting到linux,不过还有一些还完善的，如何信号发消息时还有个MOD_POOL_FIX的分支还没实现，或者到时可能把自己以前写的xmalloc和xfree用上，不用系统的那个，这样可能更适合自己，不过主要任务还是得同时支持linux的gcc编译器，之前没任何linux的C开发经验，对我来说又是一个很好的锻炼机会，爽～～～

file: debugx.h
  1. /**
  2.  * author: vincent.cws2008@gmail.com
  3.  * history:
  4.  * initial @ 2011-09-18
  5.  */

  7. #ifndef _DEBUGX_H_
  8. #define _DEBUGX_H_

  10. #include <stdio.h>
  11. #include <stdarg.h>


  14. #define REPORTE out2file

  16. #define MAX_OUTPUT 100

  18. /* where to output */
  19. #define out2screen 1
  20. #define out2file 2

  22. #if defined(WIN32)&&(_MSC_VER < 1300) /* if lower or equal to VC6 under win32 */
  23. #    define __func__ "?"
  24. #    if REPORTE!=out2screen && REPORTE!=out2file
  25.         void outputx(const char* fmt,...){}
  26. #    else
  27.         extern void outputx(const char* fmt,...);     
  28. #    endif
  29. #else
  30. #    define __func__ __FUNCTION__
  31. #    if REPORTE!=out2screen && REPORTE!=out2file
  32. #        define outputx(fmt,...)
  33. #    else
  34.         extern void outputx(const char* fmt,...);
  35. #    endif
  36. #endif


  39. #define __bit(x) ((unsigned)1<<(x))

  41. /** generic data dump */
  42. #define xinfo        __bit(0)
  43. #define xdata        __bit(1)
  44. /** function invoke */
  45. #define xentry        __bit(2)
  46. /** interruption signal */
  47. #define xevent        __bit(3)
  48. #define xmsg        __bit(4)
  49. /** warning level */
  50. #define xwarn        __bit(5)
  51. #define xerror        __bit(6)
  52. #define xfatal        __bit(7)

  54. /** debug level */
  55. #define debugx_level0    (0)
  56. #define debugx_level1    (xinfo|xdata|xentry)
  57. #define debugx_level2    (xevent|xmsg)
  58. #define debugx_level3    (xwarn|xerror|xfatal)
  59. #define debugx_level4    (debugx_level1|debugx_level2|debugx_level3)

  61. extern unsigned int dbx;

  63. #define DBX(x)    "debug(" #x ",%s,%d): "

  65. #define INFO __func__, __LINE__ /** function name and line information */

  67. #if defined(WIN32)&&(_MSC_VER < 1300) /* if lower or equal to VC6 under win32 */
  68.     extern void debugx(unsigned int level,const char* fmt,...);
  69. #else
  70. #    define debugx_xinfo(fmt,...) do {if (dbx & xinfo) outputx(DBX(info) fmt, INFO, __VA_ARGS__);} while(0)
  71. #    define debugx_xdata(fmt,...) do {if (dbx & xdata) outputx(DBX(data) fmt, INFO, __VA_ARGS__);} while(0)
  72. #    define debugx_xentry(fmt,...) do {if (dbx & xentry) outputx(DBX(entry) fmt,INFO, __VA_ARGS__);} while(0)
  73. #    define debugx_xevent(fmt,...) do {if (dbx & xevent) outputx(DBX(event) fmt,INFO, __VA_ARGS__);} while(0)
  74. #    define debugx_xmsg(fmt,...) do {if (dbx & xmsg) outputx(DBX(msg) fmt, INFO, __VA_ARGS__);} while(0)
  75. #    define debugx_xwarn(fmt,...) do {if (dbx & xwarn) outputx(DBX(warn) fmt,INFO, __VA_ARGS__);} while(0)
  76. #    define debugx_xerror(fmt,...) do {if (dbx & xerror) outputx(DBX(error) fmt,INFO, __VA_ARGS__);} while(0)
  77. #    define debugx_xfatal(fmt,...) do {if (dbx & xfatal) outputx(DBX(fatal) fmt,INFO, __VA_ARGS__);} while(0)
  78. #    define debugx(level,fmt,...) debugx_##level(fmt, __VA_ARGS__)
  79. #endif



  83. #endif

file: debugx.c
  1. /**
  2.  * author: vincent.cws2008@gmail.com
  3.  * history:
  4.  * initial @ 2011-09-18
  5.  */

  7. #include "debugx.h"

  9. unsigned int dbx = debugx_level4;

  11. #ifdef    WIN32
  12. #    define vsnprintf    _vsnprintf
  13. #endif

  15. /** you should define your output2file by yourself */
  16. extern int output2file(const char* pszbuf);

  18. /** */
  19. #if REPORTE==out2screen
  20. #    define xprintf printf
  21. #else
  22. #    define xprintf output2file
  23. #endif

  25. #if REPORTE==out2screen || REPORTE==out2file
  26. void outputx(const char* fmt,...)
  27. {
  28.     int ret;
  29.     char buf[MAX_OUTPUT]="";
  30.     va_list args;
  31.     va_start(args, fmt);    
  32.     ret = vsnprintf(buf, sizeof(buf), fmt, args);
  33.     if(ret<0) buf[MAX_OUTPUT-1]=0; /** output has been truncated */
  34.     xprintf(buf);
  35.     va_end(args);
  36. }
  37. #endif

  39. #if defined(WIN32)&&(_MSC_VER < 1300) /* if lower or equal to VC6 under win32 */

  41. #define OUTPUT_MSG(lv) \
  42. {\
  43.     int ret;\
  44.     char buf[MAX_OUTPUT]="";\
  45.     va_list args;\
  46.     va_start(args, fmt);\
  47.     ret = vsnprintf(buf, sizeof(buf), fmt, args);\
  48.     if(ret<0) buf[MAX_OUTPUT-1]=0;\
  49.     xprintf(buf);\
  50.     va_end(args);\
  51. }

  53. void debugx(unsigned int level,const char* fmt,...)
  54. {
  55.     switch (level)
  56.     {
  57.     case xinfo: if (dbx & xinfo) OUTPUT_MSG(info) break;
  58.     case xdata: if (dbx & xdata) OUTPUT_MSG(data) break;
  59.     case xentry: if (dbx & xentry) OUTPUT_MSG(entry) break;
  60.     case xevent: if (dbx & xevent) OUTPUT_MSG(event) break;
  61.     case xmsg: if (dbx & xmsg) OUTPUT_MSG(msg) break;
  62.     case xwarn: if (dbx & xwarn) OUTPUT_MSG(warn) break;
  63.     case xerror: if (dbx & xerror) OUTPUT_MSG(error) break;
  64.     case xfatal: if (dbx & xfatal) OUTPUT_MSG(fatal) break;
  65.     default: return;
  66.     }
  67. }
  68. #endif

file: logx.h
  1. /**
  2.  * author: vincent.cws2008@gmail.com
  3.  * history:
  4.  * initial @ 2011-09-18
  5.  */

  7. #ifndef _LOGX_H_
  8. #define _LOGX_H_

  10. #include <stdio.h>

  12. #define LOG_MOD    LOG_MUL_THREAD

  14. #define LOG_MUL_THREAD 1
  15. #define LOG_SIG_THREAD 2

  17. #ifndef __assert
  18. #define __assert(x)
  19. #endif

  21. #include "signalx.h"

  23. typedef struct logx_s{
  24.     
  25.     int (*writex)(struct logx_s *this, const char* pbuf, size_t sz);
  26.     int (*openx)(struct logx_s *this, const char* psz_path);
  27.     int (*clo***)(struct logx_s *this);
  28.     int (*initx)(struct logx_s *this, int mode);
  29.     int (*exitx)(struct logx_s *this);    
  30.     
  31.     int mode;
  32.     FILE *fh;
  33.     signalx_t signalx;
  34. }logx_t;

  36. extern void logx_init(const char* psz_path, int mode);
  37. extern void logx_exit();

  39. extern void logx_post(const char* pszbuf);    
  40. extern void logx_postx(const char* pbuf, size_t sz);


  43. #endif

file: logx.c
  1. /**
  2.  * author: vincent.cws2008@gmail.com
  3.  * history:
  4.  * initial @ 2011-09-18
  5.  */

  7. #include "logx.h"

  9. #ifndef null
  10. #define null NULL
  11. #endif

  13. static logx_t s_logx={0,0,0,0,0};

  15. extern void logx_do_signalx(const char* pbuf, size_t sz);

  17. static int __writex(struct logx_s *this, const char* pbuf, size_t sz)
  18. {
  19.     size_t cnts=0;
  20.     __assert(this!=null&&pbuf!=null&&sz>0);
  21.     if (this->fh) {
  22.         /* cnts = fprintf(this->fh, "%s", pbuf);*/
  23.         cnts = fwrite(pbuf,sizeof(pbuf[0]),sz,this->fh);
  24.         __assert(cnts==sz);
  25.         fflush(this->fh);
  26.     }
  27.     return 0;
  28. }

  30. static int __openx(struct logx_s *this, const char* psz_path)
  31. {
  32.     __assert(this!=null && psz_path!=null);

  34.     if (null == (this->fh = fopen(psz_path, "w+")))
  35.         return -1;
  36.     
  37.     return 0;
  38. }

  40. static int __clo***(struct logx_s *this)
  41. {
  42.     __assert(this!=null);
  43.     if(this->fh){
  44.         fclose(this->fh);
  45.         this->fh=0;
  46.     }
  47.     return 0;
  48. }

  50. static int __initx(struct logx_s *this, int mode)
  51. {
  52.     __assert(this!=null);
  53.     
  54.     if (mode==LOG_MUL_THREAD){
  55.         this->mode = mode;
  56.         signalx_init(&this->signalx, logx_do_signalx);         
  57.     }
  58.     return 0;
  59. }

  61. static int __exitx(struct logx_s *this)
  62. {
  63.     __assert(this!=null);
  64.     
  65.     if (this->mode==LOG_MUL_THREAD)
  66.         signalx_exit(&this->signalx);
  67.     return 0;
  68. }


  71. void logx_do_signalx(const char* pbuf, size_t sz)
  72. {
  73.     __assert(pbuf!=null&&sz>0);
  74.     if (s_logx.writex)
  75.         s_logx.writex(&s_logx, pbuf, sz);
  76. }


  79. void logx_init(const char* psz_path, int mode)
  80. {

  82.     __assert(psz_path!=null);
  83.     *(s_logx.writex) = __writex;
  84.     *(s_logx.openx) = __openx;
  85.     *(s_logx.clo***) = __clo***;
  86.     *(s_logx.initx) = __initx;
  87.     *(s_logx.exitx) = __exitx;
  88.     
  89.     s_logx.initx(&s_logx, mode);
  90.     s_logx.openx(&s_logx, psz_path);

  92. }

  94. void logx_exit()
  95. {
  96.     s_logx.clo***(&s_logx);
  97.     s_logx.exitx(&s_logx);
  98. }

  100. void logx_post(const char* pszbuf)
  101. {
  102.     __assert(pszbuf!=null);
  103.     if (s_logx.mode==LOG_MUL_THREAD)
  104.         signalx_post(s_logx.signalx,pszbuf);
  105.     else
  106.         s_logx.writex(&s_logx, pszbuf, strlen(pszbuf)+1);
  107. }
  108. void logx_postx(const char* pbuf, size_t sz)
  109. {
  110.     __assert(pbuf!=null&&sz>0);
  111.     
  112.     if (s_logx.mode==LOG_MUL_THREAD)
  113.         signalx_postx(s_logx.signalx,pbuf,sz);
  114.     else
  115.         s_logx.writex(&s_logx, pbuf, sz);
  116. }


  119. /** following part is only for debugx redirect the output to log file */
  120. #include "debugx.h"

  122. #if REPORTE==out2file
  123. int output2file(const char* pszbuf)
  124. {
  125.     logx_post(pszbuf);
  126.     return 0;
  127. }
  128. #endif

file: signalx.h
  1. /**
  2.  * author: vincent.cws2008@gmail.com
  3.  * history:
  4.  * initial @ 2011-09-18
  5.  */

  7. #ifndef _SIGNALX_H_
  8. #define _SIGNALX_H_

  10. #include <stdio.h>


  13. #ifdef WIN32
  14. #    include "windows.h"
  15. #endif


  18. #ifndef MAX_PATH
  19. #define MAX_PATH 260
  20. #endif

  22. #ifndef MAX_POOL
  23. #define MAX_POOL 100
  24. #endif

  26. #define MOD_POOL_FIX 1
  27. #define MOD_POOL_DYN 2

  29. #define POOL_ITEM_LEN    100

  31. #define MOD_POOL MOD_POOL_DYN

  33. #ifndef __xmalloc
  34. #define __xmalloc malloc
  35. #endif

  37. #ifndef __xfree
  38. #define __xfree    free
  39. #endif

  41. #ifndef __assert
  42. #define __assert(x)
  43. #endif


  46. extern struct signalx_s;

  48. typedef void (*f_signalx_t)(const char* pbuf, size_t sz);

  50. typedef struct signalx_s{

  52.     void (*do_signalx)(const char* pbuf, size_t sz);

  54. #if MOD_POOL==MOD_POOL_FIX
  55.     char pool[MAX_POOL][POOL_ITEM_LEN];
  56. #elif MOD_POOL==MOD_POOL_DYN
  57.     char* pool[MAX_POOL];
  58. #endif
  59.     unsigned int index1; /* index 1 for the circular pool */
  60.     unsigned int index2; /* index 2 for the circular pool */
  61.     HANDLE hthread;    /* server thread for logging out */
  62.     HANDLE hevent_post; /* server thread will be hold except post event occur */
  63.     HANDLE hevent_exit; /* notify the server thread exit normally */
  64.     CRITICAL_SECTION cslock;

  66.     void (*post_msgx)(struct signalx_s *this, const char* fmt, ...);
  67.     void (*post_msg)(struct signalx_s *this, const char* pbuf, size_t sz);
  68.     int (*serv_init)(struct signalx_s *this, f_signalx_t pf_signalx);
  69.     int (*serv_exit)(struct signalx_s *this);
  70.     int (*serv_start)(struct signalx_s *this);
  71.     int (*serv_stop)(struct signalx_s *this);
  72.     
  73. }signalx_t;


  76. extern int signalx_init(signalx_t *psignalx, f_signalx_t pf_signalx);
  77. extern int signalx_exit(signalx_t *psignalx);

  79. #define signalx_post(signalx,pszbuf) ((signalx).post_msg(&(signalx),(pszbuf),strlen(pszbuf)+1))
  80. #define signalx_postx(signalx,pbuf,sz) ((signalx).post_msg(&(signalx),(pbuf),(sz)))




  85. #endif

file: signalx.c
  1. /**
  2.  * author: vincent.cws2008@gmail.com
  3.  * history:
  4.  * initial @ 2011-09-18
  5.  */

  7. #include "signalx.h"

  9. #ifndef hnull
  10. #define hnull INVALID_HANDLE_VALUE
  11. #endif

  13. #ifndef null
  14. #define null NULL
  15. #endif

  17. #define __lockx() EnterCriticalSection(&this->cslock)
  18. #define __unlockx()    LeaveCriticalSection(&this->cslock)
  19. #define __lockx_init() InitializeCriticalSection(&this->cslock)
  20. #define __lockx_exit() DeleteCriticalSection(&this->cslock);

  22. DWORD WINAPI __thread_do_signalx(LPVOID lpThreadParameter)
  23. {
  24.     char *ptmp = NULL;
  25.     
  26.     signalx_t *this = (signalx_t*)lpThreadParameter;
  27.     __assert(this!=null);

  29.     while (1)
  30.     {
  31.         if (WaitForSingleObject((HANDLE)(this->hevent_post), INFINITE) == WAIT_OBJECT_0)
  32.         {
  33.             for (;;) /* write out the buffer */
  34.             {
  35.                 __lockx();
  36.                 
  37.                 ptmp = null;
  38.             
  39.                 /* get buffer pointer out of m_tcDataPool[] */
  40.                 if (MAX_POOL == this->index1)
  41.                     this->index1 = 0;
  42.                 if (NULL != this->pool[this->index1]) {
  43.                     ptmp = this->pool[this->index1];
  44.                     this->pool[this->index1] = null;
  45.                     this->index1++;
  46.                 }

  48.                 __unlockx();
  49.                 
  50.                 /* do signal */
  51.                 if (null != ptmp && null != this->do_signalx) {        
  52.                     this->do_signalx(ptmp, strlen(ptmp)+1);
  53.                     __xfree(ptmp);
  54.                 } else {
  55.                     if (hnull != this->hevent_post)
  56.                         ResetEvent(this->hevent_post);
  57.                     break;
  58.                 }        
  59.             } /* for(;;) */
  60.         }
  61.         if (WaitForSingleObject(this->hevent_exit, 0) == WAIT_OBJECT_0)
  62.             break;
  63.     } /* while(1) */
  64.     return 0;
  65. }

  67. static void __post_msgx(struct signalx_s *this, const char* fmt, ...)
  68. {
  69.     
  70. }

  72. static void __post_msg(struct signalx_s *this, const char* pbuf, size_t sz)
  73. {
  74.     char *pnew_buf=null;

  76.     __assert(this!=null&&pbuf!=null);

  78.     if (hnull==this->hthread) return;

  80.     pnew_buf = (char*)__xmalloc(sz * sizeof(char));
  81.     
  82.     if (pnew_buf) {
  83.         memcpy(pnew_buf, pbuf, sz);
  84.         
  85.         __lockx();
  86.         
  87.         /* put buffer pointer into pool[MAX_POOL] */
  88.         if (MAX_POOL == this->index2)
  89.             this->index2 = 0;
  90.         /* case: index2 == index1, so abandon the new data */
  91.         if (null == this->pool[this->index2])
  92.             this->pool[this->index2++] = pnew_buf;
  93.         else {
  94.             /* do NOT forget to free the new data when the pool was overflow */
  95.             __xfree (pnew_buf);
  96.             pnew_buf=null;
  97.         }
  98.         if (hnull != this->hevent_post)
  99.             SetEvent(this->hevent_post);
  100.         
  101.         __unlockx();    
  102.     }
  103. }

  105. static int __serv_init(struct signalx_s *this, f_signalx_t pf_signalx)
  106. {
  107.     __assert(this!=null && pf_signalx!=null);

  109.     this->hthread = hnull;
  110.     this->hevent_post = hnull;
  111.     this->hevent_exit = hnull;
  112.     this->index1 = 0;
  113.     this->index2 = 0;
  114.     /* NOTE: must initialize pool, else assert _CrtIsValidHeapPointer(pUserData) occur */
  115.     memset(this->pool, 0, sizeof(this->pool));

  117.     this->do_signalx = pf_signalx; /* register user custom signal function */

  119.     __lockx_init();
  120.     
  121.     this->hevent_post = CreateEvent(NULL, TRUE, FALSE, NULL);
  122.     this->hevent_exit = CreateEvent(NULL, TRUE, FALSE, NULL);
  123.     return 0;
  124. }

  126. static int __serv_exit(struct signalx_s *this)
  127. {
  128.     __assert(this!=null);
  129.     if (hnull != this->hevent_exit) SetEvent(this->hevent_exit);
  130.     if (hnull != this->hevent_post) SetEvent(this->hevent_post);
  131.     /* wait the thread exit */
  132.     if (hnull != this->hthread){
  133.         /* terminal the log server thread until 1 second over */
  134.         unsigned long state = WaitForSingleObject (this->hthread, 1000);
  135.         switch (state)
  136.         {
  137.             case WAIT_TIMEOUT:
  138.             {
  139.                 unsigned long exit_code = 0;
  140.                 if (0 != TerminateThread(this->hthread, exit_code))
  141.                     ; /* terminate the server thread */
  142.                 else
  143.                     ; /* terminate the LogSrv thread failed */
  144.                 break;
  145.             }
  146.             case WAIT_ABANDONED: break; /* the Thread abandoned */
  147.             case WAIT_OBJECT_0: break; /* exit the server thread */
  148.             default: break;
  149.         }
  150.         __lockx_exit();
  151.         CloseHandle(this->hthread);
  152.         this->hthread=hnull;
  153.     }
  154.     if (hnull != this->hevent_exit) CloseHandle(this->hevent_exit);
  155.     if (hnull != this->hevent_post) CloseHandle(this->hevent_post);
  156.     return 0;
  157. }

  159. static int __serv_start(struct signalx_s *this)
  160. {
  161.     unsigned long thread_id;
  162.     __assert(this!=null);
  163.     if (hnull == this->hthread) {
  164.         this->hthread = CreateThread(
  165.             NULL, /* default security attributes */
  166.             0, /* use default stack size */
  167.             __thread_do_signalx, /* thread function */
  168.             (LPVOID)this, /* argument to thread function */
  169.             0, /* use default creation flags */
  170.             &thread_id); /* returns the thread identifier */
  171.     }
  172.     return 0;
  173. }

  175. static int __serv_stop(signalx_t *this)
  176. {
  177.     return 0;
  178. }


  181. int signalx_init(signalx_t *this, f_signalx_t pf_signalx)
  182. {
  183.     __assert(this!=null&&pf_signalx!=null);

  185.     *(this->post_msgx) = __post_msgx;
  186.     *(this->post_msg) = __post_msg;
  187.     *(this->serv_init) = __serv_init;
  188.     *(this->serv_exit) = __serv_exit;
  189.     *(this->serv_start) = __serv_start;
  190.     *(this->serv_stop) = __serv_stop;

  192.     this->serv_init(this, pf_signalx);

  194.     this->serv_start(this);
  195.     return 0;
  196. }

  198. int signalx_exit(signalx_t *this)
  199. {
  200.     __assert(this!=null);
  201.     this->serv_exit(this);
  202.     return 0;
  203. }

file: thread_mgmt.h
  1. /**
  2.  * author: vincent.cws2008@gmail.com
  3.  * history:
  4.  * initial @ 2011-09-18
  5.  */

  7. #ifndef _THREAD_MGMT_H_
  8. #define _THREAD_MGMT_H_

  10. #ifdef WIN32
  11. #    include "windows.h"
  12. #endif

  14. #ifndef __assert
  15. #define __assert(x)
  16. #endif

  18. #ifndef MAX_NAME
  19. #define MAX_NAME 100
  20. #endif

  22. #ifndef MAX_THREAD
  23. #define MAX_THREAD 10
  24. #endif

  26. typedef DWORD (WINAPI *f_thread_t)(LPVOID lpThreadParameter);

  28. typedef struct thread_info_s{
  29.     unsigned long id;    
  30.     char name[MAX_NAME];
  31.     HANDLE h;
  32.     f_thread_t f_thread;
  33. }thread_info_t;

  35. typedef struct thread_mgmt_s{
  36.     thread_info_t thread_info[MAX_THREAD];
  37.     int (*init)(struct thread_mgmt_s *this);    
  38.     int (*exit)(struct thread_mgmt_s *this);
  39.     int (*create_thread)(struct thread_mgmt_s *this, const char* psz_name, f_thread_t f_thread);
  40.     int (*delete_thread)(struct thread_mgmt_s *this, const char* psz_name);
  41. }thread_mgmt_t;

  43. void tm_init(thread_mgmt_t *ptm);

  45. void tm_exit(thread_mgmt_t *ptm);

  47. #define tm_create_thread(tm,nm,ft) ((tm).create_thread(&(tm),(nm),(ft)))
  48. #define tm_delete_thread(tm,nm)    ((tm).delete_thread(&(tm),(nm)))

  50. #endif


file: thread_mgmt.c
  1. /**
  2.  * author: vincent.cws2008@gmail.com
  3.  * history:
  4.  * initial @ 2011-09-18
  5.  */

  7. #include "thread_mgmt.h"

  9. #ifndef hnull
  10. #define hnull INVALID_HANDLE_VALUE
  11. #endif

  13. #ifndef null
  14. #define null NULL
  15. #endif

  17. static int __init(struct thread_mgmt_s *this)
  18. {
  19.     int i = 0;

  21.     __assert(this!=null)
  22.     
  23.     for (;i<MAX_THREAD;i++)
  24.     {
  25.         this->thread_info[i].id = 0;
  26.         this->thread_info[i].h = hnull;
  27.         this->thread_info[i].f_thread=null;
  28.         this->thread_info[i].name[0]=0;
  29.     }
  30.     return 0;
  31. }
  32. static int __exit(struct thread_mgmt_s *this)
  33. {
  34.     int i = 0;
  35.     
  36.     __assert(this!=null);
  37.     
  38.     for (;i<MAX_THREAD;i++)
  39.     {
  40.         if(this->thread_info[i].h != hnull) {
  41.             /* terminal the log server thread until 1 second over */
  42.             unsigned long state = WaitForSingleObject (this->thread_info[i].h, 100);
  43.             switch (state)
  44.             {
  45.             case WAIT_TIMEOUT:
  46.                 {
  47.                     unsigned long exit_code = 0;
  48.                     if (0 != TerminateThread(this->thread_info[i].h, exit_code))
  49.                         ; /* terminate the server thread */
  50.                     else
  51.                         ; /* terminate the LogSrv thread failed */
  52.                     break;
  53.                 }
  54.             case WAIT_ABANDONED: break; /* the Thread abandoned */
  55.             case WAIT_OBJECT_0: break; /* exit the server thread */
  56.             default: break;
  57.             }
  58.             this->thread_info[i].h = hnull;
  59.             this->thread_info[i].name[0]=0;
  60.             this->thread_info[i].id=0;
  61.             this->thread_info[i].f_thread=0;
  62.         }
  63.         else if (this->thread_info[i].h == hnull) {
  64.             this->thread_info[i].h = hnull;
  65.             this->thread_info[i].name[0]=0;
  66.             this->thread_info[i].id=0;
  67.             this->thread_info[i].f_thread=0;
  68.         }
  69.     }
  70.     return 0;
  71. }
  72. static int __create_thread(struct thread_mgmt_s *this, const char* psz_name, f_thread_t f_thread)
  73. {
  74.     int i=0, len=0;

  76.     __assert(this!=null && psz_name!=null && f_thread!=null);

  78.     for (;i<MAX_THREAD;i++)
  79.     {
  80.         if(this->thread_info[i].h==hnull || this->thread_info[i].f_thread==null)
  81.             break;
  82.     }
  83.     if(i==MAX_THREAD) return -1;

  85.     this->thread_info[i].h = CreateThread(
  86.         null, // default security attributes
  87.         0, // use default stack size
  88.         f_thread,        // thread function
  89.         0, // argument to thread function
  90.         0, // use default creation flags
  91.         &(this->thread_info[i].id)); // returns the thread identifier

  93.     len=strlen(psz_name)+1;
  94.     if (MAX_NAME < len) {
  95.         memcpy(this->thread_info[i].name, psz_name, MAX_NAME-1);
  96.         this->thread_info[i].name[MAX_NAME-1]=0;
  97.     }
  98.     else
  99.         memcpy(this->thread_info[i].name, psz_name, len);
  100.     
  101.     this->thread_info[i].f_thread = f_thread;

  103.     return 0;
  104. }
  105. static int __delete_thread(struct thread_mgmt_s *this, const char* psz_name)
  106. {
  107.     int i = 0;

  109.     __assert(this!=null && psz_name!=null);

  111.     for (;i<MAX_THREAD;i++)
  112.     {
  113.         if(strcmp(this->thread_info[i].name, psz_name)==0
  114.             && this->thread_info[i].h != hnull)
  115.         {
  116.             /* terminal the log server thread until 1 second over */
  117.             unsigned long state = WaitForSingleObject (this->thread_info[i].h, 100);
  118.             switch (state)
  119.             {
  120.                 case WAIT_TIMEOUT:
  121.                 {
  122.                     unsigned long exit_code = 0;
  123.                     if (0 != TerminateThread(this->thread_info[i].h, exit_code))
  124.                         ; /* terminate the server thread */
  125.                     else
  126.                         ; /* terminate the LogSrv thread failed */
  127.                     break;
  128.                 }
  129.                 case WAIT_ABANDONED: break; /* the Thread abandoned */
  130.                 case WAIT_OBJECT_0: break; /* exit the server thread */
  131.                 default: break;
  132.             }
  133.             this->thread_info[i].h = hnull;
  134.             this->thread_info[i].name[0]=0;
  135.             this->thread_info[i].id=0;
  136.             this->thread_info[i].f_thread=0;
  137.         }
  138.         else if (this->thread_info[i].h == hnull)
  139.         {
  140.             this->thread_info[i].h = hnull;
  141.             this->thread_info[i].name[0]=0;
  142.             this->thread_info[i].id=0;
  143.             this->thread_info[i].f_thread=0;
  144.         }
  145.     }
  146.     return 0;
  147. }

  149. void tm_init(thread_mgmt_t *ptm)
  150. {
  151.     __assert(ptm!=null);

  153.     *(ptm->init) = __init;
  154.     *(ptm->exit) = __exit;
  155.     *(ptm->create_thread) = __create_thread;
  156.     *(ptm->delete_thread) = __delete_thread;

  158.     ptm->init(ptm);
  159. }

  161. void tm_exit(thread_mgmt_t *ptm)
  162. {
  163.     __assert(ptm!=null);

  165.     ptm->exit(ptm);
  166. }

file: main.c
  1. /**
  2.  * author: vincent.cws2008@gmail.com
  3.  * history:
  4.  * initial @ 2011-09-18
  5.  */

  7. #include "debugx.h"

  9. #include "logx.h"

  11. #include "thread_mgmt.h"

  13. DWORD WINAPI f_thread1(LPVOID lpThreadParameter)
  14. {
  15.     DWORD id = GetCurrentThreadId();
  16.     while (1)
  17.     {
  18.         debugx(xinfo, "thread id(%d): this is %s!\n", id, "xinfo");
  19.         Sleep(10);
  20.     }
  21.     return 0;
  22. }

  24. DWORD WINAPI f_thread2(LPVOID lpThreadParameter)
  25. {
  26.     DWORD id = GetCurrentThreadId();
  27.     while (1)
  28.     {
  29.         debugx(xevent, "thread id(%d): this is %s!\n", id, "xevent");
  30.         Sleep(10);
  31.     }
  32.     return 0;
  33. }

  35. DWORD WINAPI f_thread3(LPVOID lpThreadParameter)
  36. {
  37.     DWORD id = GetCurrentThreadId();
  38.     while (1)
  39.     {
  40.         debugx(xerror, "thread id(%d): this is %s!\n", id, "xerror");
  41.         Sleep(10);
  42.     }
  43.     return 0;
  44. }


  47. int main(int argc, char* argv[])
  48. {    
  49.     int i = 1000;
  50.     DWORD id = 0;

  52. #if LOG_MOD==LOG_MUL_THREAD
  53.     thread_mgmt_t tm;
  54.     logx_init("D:/abc.txt", LOG_MUL_THREAD);
  55.     tm_init(&tm);
  56.     tm_create_thread(tm,"t1",f_thread1);
  57.     tm_create_thread(tm,"t2",f_thread2);
  58.     tm_create_thread(tm,"t3",f_thread3);
  59. #else
  60.     logx_init("D:/abc.txt", LOG_SIG_THREAD);
  61. #endif

  63.     debugx(xinfo, "this is %s!\n", "xinfo");
  64.     debugx(xdata, "this is %s!\n", "xdata");
  65.     debugx(xentry, "this is %s!\n", "xentry");
  66.     debugx(xevent, "this is %s!\n", "xevent");
  67.     debugx(xmsg, "this is %s!\n", "xmsg");
  68.     debugx(xwarn, "this is %s!\n", "xwarn");
  69.     debugx(xerror, "this is %s!\n", "xerror");
  70.     debugx(xfatal, "this is %s!\n", "xfatal");
  71.     debugx(xerror, "this is %s!\n", "xerror");

  73.     id = GetCurrentThreadId();
  74.     while (i--)
  75.     {
  76.         debugx(xfatal, "thread id(%d): this is %s!\n", id, "xfatal");
  77.         //logx_post("hello world!\n");
  78.         Sleep(10);
  79.     }

  81. #if LOG_MOD==LOG_MUL_THREAD    
  82.     tm_exit(&tm);
  83. #endif

  85.     logx_exit();

  87. //    Sleep(3000);
  88.     
  89.     return 0;
  90. }


附件：

 debugx_vc6_vs2005.rar  
阅读(1675) | 评论(0) | 转发(0) |
0

上一篇：change user into root group

下一篇：C运算符优先级表

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6