Chinaunix首页 | 论坛 | 博客

路漫漫vincent.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

vincent-cws

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

全部博文（116）

文章存档

2013年（1）

2012年（17）

2011年（69）

2009年（29）

我的朋友
最近访客
推荐博文
相关博文
实现一个dubug系统(支持win32和linux平台)

分类： LINUX

2011-09-20 13:59:17

http://vincent.blog.chinaunix.net

今天终于把linux平台也支持，不过我目前只是在cygwin平台上调试过，没做具体的详细的测试，简单的测试通过，目前支持VC6, VS2005和gcc编译器，下面是代码：

file: debugx.h
  1. /**
  2.  * author: vincent.cws2008@gmail.com
  3.  * history:
  4.  * initial @ 2011-09-18
  5.  * porting to linux(cygwin) @ 2011-09-20
  6.  */

  8. #ifndef _DEBUGX_H_
  9. #define _DEBUGX_H_

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


  15. #define REPORTE out2screen

  17. #define MAX_OUTPUT 100

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

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


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

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

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

  62. extern unsigned int dbx;

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

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

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

  82. #endif

file: debugx.c
  1. /**
  2.  * author: vincent.cws2008@gmail.com
  3.  * history:
  4.  * initial @ 2011-09-18
  5.  * porting to linux(cygwin) @ 2011-09-20
  6.  */

  8. #include "debugx.h"

  10. unsigned int dbx = debugx_level4;

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

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

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

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

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

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

  54. void debugx(unsigned int level,const char* fmt,...)
  55. {
  56.     switch (level)
  57.     {
  58.     case xinfo: if (dbx & xinfo) OUTPUT_MSG(info) break;
  59.     case xdata: if (dbx & xdata) OUTPUT_MSG(data) break;
  60.     case xentry: if (dbx & xentry) OUTPUT_MSG(entry) break;
  61.     case xevent: if (dbx & xevent) OUTPUT_MSG(event) break;
  62.     case xmsg: if (dbx & xmsg) OUTPUT_MSG(msg) break;
  63.     case xwarn: if (dbx & xwarn) OUTPUT_MSG(warn) break;
  64.     case xerror: if (dbx & xerror) OUTPUT_MSG(error) break;
  65.     case xfatal: if (dbx & xfatal) OUTPUT_MSG(fatal) break;
  66.     default: return;
  67.     }
  68. }
  69. #endif
file: logx.h
  1. /**
  2.  * author: vincent.cws2008@gmail.com
  3.  * history:
  4.  * initial @ 2011-09-18
  5.  * porting to linux(cygwin) @ 2011-09-20
  6.  */

  8. #ifndef _LOGX_H_
  9. #define _LOGX_H_

  11. #include <stdio.h>

  13. #define LOG_MOD    LOG_MUL_THREAD

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

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

  22. #include "signalx.h"

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

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

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


  44. #endif
file: logx.h
  1. /**
  2.  * author: vincent.cws2008@gmail.com
  3.  * history:
  4.  * initial @ 2011-09-18
  5.  * porting to linux(cygwin) @ 2011-09-20
  6.  */

  8. #include "logx.h"

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

  14. static logx_t s_logx= {
  15. #ifdef WIN32
  16. 0,0,0,0,0
  17. #else
  18. .writex = 0,
  19. .openx = 0,
  20. .clo*** = 0,
  21. .initx = 0,
  22. .exitx = 0,
  23. .mode = 0,
  24. .fh = 0,
  25. #endif
  26. };

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

  30. static int __writex(struct logx_s *this, const char* pbuf, size_t sz)
  31. {
  32.     size_t cnts=0;
  33.     __assert(this!=null&&pbuf!=null&&sz>0);
  34.     if (this->fh) {
  35.         /* cnts = fprintf(this->fh, "%s", pbuf);*/
  36.         cnts = fwrite(pbuf,sizeof(pbuf[0]),sz,this->fh);
  37.         __assert(cnts==sz);
  38.         fflush(this->fh);
  39.     }
  40.     return 0;
  41. }

  43. static int __openx(struct logx_s *this, const char* psz_path)
  44. {
  45.     __assert(this!=null && psz_path!=null);

  47.     if (null == (this->fh = fopen(psz_path, "w+")))
  48.         return -1;
  49.     
  50.     return 0;
  51. }

  53. static int __clo***(struct logx_s *this)
  54. {
  55.     __assert(this!=null);
  56.     if(this->fh){
  57.         fclose(this->fh);
  58.         this->fh=0;
  59.     }
  60.     return 0;
  61. }

  63. static int __initx(struct logx_s *this, int mode)
  64. {
  65.     __assert(this!=null);
  66.     
  67.     if (mode==LOG_MUL_THREAD){
  68.         this->mode = mode;
  69.         signalx_init(&this->signalx, logx_do_signalx);         
  70.     }
  71.     return 0;
  72. }

  74. static int __exitx(struct logx_s *this)
  75. {
  76.     __assert(this!=null);
  77.     
  78.     if (this->mode==LOG_MUL_THREAD)
  79.         signalx_exit(&this->signalx);
  80.     return 0;
  81. }


  84. void logx_do_signalx(const char* pbuf, size_t sz)
  85. {
  86.     __assert(pbuf!=null&&sz>0);
  87.     if (s_logx.writex)
  88.         s_logx.writex(&s_logx, pbuf, sz);
  89. }


  92. void logx_init(const char* psz_path, int mode)
  93. {

  95.     __assert(psz_path!=null);
  96.     *(&s_logx.writex) = &__writex;
  97.     *(&s_logx.openx) = &__openx;
  98.     *(&s_logx.clo***) = &__clo***;
  99.     *(&s_logx.initx) = &__initx;
  100.     *(&s_logx.exitx) = &__exitx;
  101.     
  102.     s_logx.initx(&s_logx, mode);
  103.     s_logx.openx(&s_logx, psz_path);

  105. }

  107. void logx_exit()
  108. {
  109.     s_logx.clo***(&s_logx);
  110.     s_logx.exitx(&s_logx);
  111. }

  113. void logx_post(const char* pszbuf)
  114. {
  115.     __assert(pszbuf!=null);
  116.     if (s_logx.mode==LOG_MUL_THREAD)
  117.         signalx_post(s_logx.signalx,pszbuf);
  118.     else
  119.         s_logx.writex(&s_logx, pszbuf, strlen(pszbuf));
  120. }
  121. void logx_postx(const char* pbuf, size_t sz)
  122. {
  123.     __assert(pbuf!=null&&sz>0);
  124.     
  125.     if (s_logx.mode==LOG_MUL_THREAD)
  126.         signalx_postx(s_logx.signalx,pbuf,sz);
  127.     else
  128.         s_logx.writex(&s_logx, pbuf, sz);
  129. }


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

  135. #if REPORTE==out2file
  136. int output2file(const char* pszbuf)
  137. {
  138.     logx_post(pszbuf);
  139.     return 0;
  140. }
  141. #endif

file: signalx.h
  1. /**
  2.  * author: vincent.cws2008@gmail.com
  3.  * history:
  4.  * initial @ 2011-09-18
  5.  * porting to linux(cygwin) @ 2011-09-20
  6.  */

  8. #ifndef _SIGNALX_H_
  9. #define _SIGNALX_H_

  11. #include <stdio.h>


  14. #ifdef WIN32
  15. #    include "windows.h"
  16. #else
  17. # include <pthread.h>
  18. #endif


  21. #ifndef MAX_PATH
  22. #define MAX_PATH 260
  23. #endif

  25. #ifndef MAX_POOL
  26. #define MAX_POOL 100
  27. #endif

  29. #define MOD_POOL_FIX 1
  30. #define MOD_POOL_DYN 2

  32. #define POOL_ITEM_LEN    100

  34. #define MOD_POOL MOD_POOL_DYN

  36. #ifndef __xmalloc
  37. #define __xmalloc malloc
  38. #endif

  40. #ifndef __xfree
  41. #define __xfree    free
  42. #endif

  44. #ifndef __assert
  45. #define __assert(x)
  46. #endif


  49. extern struct signalx_s;

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

  53. typedef struct signalx_s{
  54.     
  55.     void (*do_signalx)(const char* pbuf, size_t sz);
  56.     
  57. #if MOD_POOL==MOD_POOL_FIX
  58.     char pool[MAX_POOL][POOL_ITEM_LEN];
  59. #elif MOD_POOL==MOD_POOL_DYN
  60.     char* pool[MAX_POOL];
  61. #endif
  62.     unsigned int index1; /* index 1 for the circular pool */
  63.     unsigned int index2; /* index 2 for the circular pool */
  64. #ifdef WIN32
  65.     HANDLE hthread;    /* server thread for logging out */
  66.     HANDLE hevent_post; /* server thread will be hold except post event occur */
  67.     HANDLE hevent_exit; /* notify the server thread exit normally */
  68.     CRITICAL_SECTION cslock;
  69. #else
  70.     pthread_t hthread;
  71.     pthread_cond_t hevent_post;
  72.   /*    pthread_cond_t hevent_exit; */
  73.     pthread_mutex_t cslock;
  74.     pthread_mutexattr_t attr;
  75. #endif
  76.     void (*post_msgx)(struct signalx_s *this, const char* fmt, ...);
  77.     void (*post_msg)(struct signalx_s *this, const char* pbuf, size_t sz);
  78.     int (*serv_init)(struct signalx_s *this, f_signalx_t pf_signalx);
  79.     int (*serv_exit)(struct signalx_s *this);
  80.     int (*serv_start)(struct signalx_s *this);
  81.     int (*serv_stop)(struct signalx_s *this);
  82.     
  83. }signalx_t;


  86. extern int signalx_init(signalx_t *psignalx, f_signalx_t pf_signalx);
  87. extern int signalx_exit(signalx_t *psignalx);

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

  92. #endif
file: signalx.c
  1. /**
  2.  * author: vincent.cws2008@gmail.com
  3.  * history:
  4.  * initial @ 2011-09-18
  5.  * porting to linux(cygwin) @ 2011-09-20
  6.  */

  8. #include "signalx.h"

  10. #ifdef WIN32

  12. #ifndef hnull
  13. #define hnull INVALID_HANDLE_VALUE
  14. #endif
  15. #ifndef null
  16. #define null NULL
  17. #endif
  18. #define __lockx() EnterCriticalSection(&this->cslock)
  19. #define __unlockx()    LeaveCriticalSection(&this->cslock)
  20. #define __lockx_init() InitializeCriticalSection(&this->cslock)
  21. #define __lockx_exit() DeleteCriticalSection(&this->cslock);

  23. #else

  25. #ifndef hnull
  26. #define hnull (void*)0
  27. #endif
  28. #ifndef null
  29. #define null (void*)0
  30. #endif
  31. #define __lockx() pthread_mutex_lock(&this->cslock)
  32. #define __unlockx()    pthread_mutex_unlock(&this->cslock)
  33. #define __lockx_init() \
  34.     pthread_mutexattr_init(&this->attr); \
  35.     pthread_mutexattr_settype(&this->attr,PTHREAD_MUTEX_RECURSIVE); \
  36.     pthread_mutex_init(&this->cslock,&this->attr); \

  38. #define __lockx_exit() \
  39.     pthread_mutex_destroy(&this->cslock); \
  40.     pthread_mutexattr_destroy(&this->attr); \
  41.     
  42. #endif

  44. #ifdef WIN32
  45. DWORD WINAPI __thread_do_signalx(LPVOID lpThreadParameter)
  46. #else
  47. void __thread_do_signalx(void* lpThreadParameter)
  48. #endif
  49. {
  50.     char *ptmp = null;
  51.     
  52.     signalx_t *this = (signalx_t*)lpThreadParameter;
  53.     __assert(this!=null);
  54.     
  55.     while (1)
  56.     {
  57. #ifdef WIN32
  58.         if (WaitForSingleObject((HANDLE)(this->hevent_post), INFINITE) == WAIT_OBJECT_0)
  59. #else
  60.         int ret=0;
  61.         __lockx();
  62.         ret = pthread_cond_wait(&this->hevent_post, &this->cslock);
  63.         __unlockx();
  64.         if (ret == 0)
  65. #endif
  66.         {
  67.             for (;;) /* write out the buffer */
  68.             {
  69.                 __lockx();
  70.                 
  71.                 ptmp = null;
  72.                 
  73.                 /* get buffer pointer out of m_tcDataPool[] */
  74.                 if (MAX_POOL == this->index1)
  75.                     this->index1 = 0;
  76.                 if (NULL != this->pool[this->index1]) {
  77.                     ptmp = this->pool[this->index1];
  78.                     this->pool[this->index1] = null;
  79.                     this->index1++;
  80.                 }
  81.                 
  82.                 __unlockx();
  83.                 
  84.                 /* do signal */
  85.                 if (null != ptmp && null != this->do_signalx) {        
  86.                     this->do_signalx(ptmp, strlen(ptmp));
  87.                     __xfree(ptmp);
  88.                 } else {
  89. #ifdef WIN32
  90.                     if (hnull != this->hevent_post)
  91.                         ResetEvent(this->hevent_post);
  92. #endif
  93.                     break;
  94.                 }        
  95.             } /* for(;;) */
  96.         }
  97. #ifdef WIN32
  98.         if (WaitForSingleObject(this->hevent_exit, 0) == WAIT_OBJECT_0)
  99.             break;
  100. #endif
  101.     } /* while(1) */
  102.     return 0;
  103. }

  105. static void __post_msgx(struct signalx_s *this, const char* fmt, ...)
  106. {
  107.     
  108. }

  110. static void __post_msg(struct signalx_s *this, const char* pbuf, size_t sz)
  111. {
  112.     char *pnew_buf=null;
  113.     
  114.     __assert(this!=null&&pbuf!=null);
  115.     
  116.     if (hnull==this->hthread) return;
  117.     
  118.     pnew_buf = (char*)__xmalloc(sz * sizeof(char));
  119.     
  120.     if (pnew_buf) {
  121.         memcpy(pnew_buf, pbuf, sz);
  122.         
  123.         __lockx();
  124.         
  125.         /* put buffer pointer into pool[MAX_POOL] */
  126.         if (MAX_POOL == this->index2)
  127.             this->index2 = 0;
  128.         /* case: index2 == index1, so abandon the new data */
  129.         if (null == this->pool[this->index2])
  130.             this->pool[this->index2++] = pnew_buf;
  131.         else {
  132.             /* do NOT forget to free the new data when the pool was overflow */
  133.             __xfree (pnew_buf);
  134.             pnew_buf=null;
  135.         }
  136.         if (hnull != this->hevent_post)
  137.         {
  138. #ifdef WIN32
  139.             SetEvent(this->hevent_post);
  140. #else
  141.             pthread_cond_signal(&this->hevent_post);
  142. #endif        
  143.         }
  144.         __unlockx();    
  145.     }
  146. }

  148. static int __serv_init(struct signalx_s *this, f_signalx_t pf_signalx)
  149. {
  150.     __assert(this!=null && pf_signalx!=null);
  151.     
  152.     this->hthread = hnull;
  153.     this->hevent_post = hnull;
  154. #ifdef WIN32
  155.     this->hevent_exit = hnull;
  156. #endif
  157.     this->index1 = 0;
  158.     this->index2 = 0;
  159.     /* NOTE: must initialize pool, else assert _CrtIsValidHeapPointer(pUserData) occur */
  160.     memset(this->pool, 0, sizeof(this->pool));
  161.     
  162.     this->do_signalx = pf_signalx; /* register user custom signal function */
  163.     
  164.     __lockx_init();
  165. #ifdef WIN32    
  166.     this->hevent_post = CreateEvent(NULL, TRUE, FALSE, NULL);
  167.     this->hevent_exit = CreateEvent(NULL, TRUE, FALSE, NULL);
  168. #else
  169.     pthread_cond_init(&this->hevent_post,null);
  170.     /* pthread_cond_init(&this->hevent_exit,null); */
  171. #endif
  172.     return 0;
  173. }

  175. static int __serv_exit(struct signalx_s *this)
  176. {
  177.     __assert(this!=null);

  179. #ifdef WIN32
  180.     if (hnull != this->hevent_exit) SetEvent(this->hevent_exit);
  181.     if (hnull != this->hevent_post) SetEvent(this->hevent_post);
  182. #else
  183.     pthread_cond_signal(&this->hevent_post);
  184.     sleep(1);
  185.     pthread_cancel(this->hthread);
  186. #endif
  187.     
  188.     /* wait the thread exit */
  189.     if (hnull != this->hthread)
  190.     {
  191. #ifdef WIN32
  192.         /* terminal the log server thread until 1 second over */
  193.         unsigned long state = WaitForSingleObject (this->hthread, 1000);
  194.         switch (state)
  195.         {
  196.         case WAIT_TIMEOUT:
  197.             {
  198.                 unsigned long exit_code = 0;
  199.                 if (0 != TerminateThread(this->hthread, exit_code))
  200.                     ; /* terminate the server thread */
  201.                 else
  202.                     ; /* terminate the LogSrv thread failed */
  203.                 break;
  204.             }
  205.         case WAIT_ABANDONED: break; /* the Thread abandoned */
  206.         case WAIT_OBJECT_0: break; /* exit the server thread */
  207.         default: break;
  208.         }
  209.         CloseHandle(this->hthread);
  210. #else
  211.         int state = pthread_join(this->hthread, null);
  212. #endif
  213.         this->hthread=hnull;
  214.     }
  215.     
  216.     __lockx_exit();
  217.     
  218. #ifdef WIN32
  219.     if (hnull != this->hevent_exit) CloseHandle(this->hevent_exit);
  220.     if (hnull != this->hevent_post) CloseHandle(this->hevent_post);
  221. #else
  222.     /* pthread_cond_destroy(&this->hevent_exit);*/
  223.     pthread_cond_destroy(&this->hevent_post);
  224. #endif
  225.     return 0;
  226. }

  228. static int __serv_start(struct signalx_s *this)
  229. {
  230.     unsigned long thread_id;
  231.     __assert(this!=null);
  232.     if (hnull == this->hthread) {
  233. #ifdef WIN32
  234.         this->hthread = CreateThread(
  235.             NULL, /* default security attributes */
  236.             0, /* use default stack size */
  237.             __thread_do_signalx, /* thread function */
  238.             (LPVOID)this, /* argument to thread function */
  239.             0, /* use default creation flags */
  240.             &thread_id); /* returns the thread identifier */
  241. #else
  242.         if(pthread_create(&this->hthread, null, __thread_do_signalx, (void*)this)!=0)
  243.             return -1;
  244. #endif
  245.     }
  246.     return 0;
  247. }

  249. static int __serv_stop(signalx_t *this)
  250. {
  251.     return 0;
  252. }


  255. int signalx_init(signalx_t *this, f_signalx_t pf_signalx)
  256. {
  257.     __assert(this!=null&&pf_signalx!=null);
  258.     
  259.     *(&this->post_msgx) = &__post_msgx;
  260.     *(&this->post_msg) = &__post_msg;
  261.     *(&this->serv_init) = &__serv_init;
  262.     *(&this->serv_exit) = &__serv_exit;
  263.     *(&this->serv_start) = &__serv_start;
  264.     *(&this->serv_stop) = &__serv_stop;
  265.     
  266.     this->serv_init(this, pf_signalx);
  267.     
  268.     this->serv_start(this);
  269.     return 0;
  270. }

  272. int signalx_exit(signalx_t *this)
  273. {
  274.     __assert(this!=null);
  275.     this->serv_exit(this);
  276.     return 0;
  277. }
file: thread_mgmt.h
  1. /**
  2.  * author: vincent.cws2008@gmail.com
  3.  * history:
  4.  * initial @ 2011-09-18
  5.  * porting to linux(cygwin) @ 2011-09-20
  6.  */

  8. #ifndef _THREAD_MGMT_H_
  9. #define _THREAD_MGMT_H_

  11. #include <stdio.h>

  13. #ifdef WIN32
  14. #include <windows.h>
  15. #else
  16. #include <pthread.h>
  17. #endif
  18. #ifndef __assert
  19. #define __assert(x)
  20. #endif

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

  26. #ifndef MAX_THREAD
  27. #define MAX_THREAD 10
  28. #endif

  30. #ifdef WIN32
  31. typedef DWORD (WINAPI *f_thread_t)(LPVOID lpThreadParameter);
  32. #else
  33. typedef void* (*f_thread_t)(void *pvoid);
  34. #endif

  36. typedef struct thread_info_s
  37. {
  38.     unsigned long id;
  39.     char name[MAX_NAME];
  40. #ifdef WIN32
  41.     HANDLE h;
  42. #else
  43.     pthread_t h;
  44. #endif
  45.     f_thread_t f_thread;
  46. }thread_info_t;

  48. typedef struct thread_mgmt_s
  49. {
  50.     thread_info_t thread_info[MAX_THREAD];

  52.     int (*init)(struct thread_mgmt_s *this);
  53.     int (*exit)(struct thread_mgmt_s *this);
  54.     int (*create_thread)(struct thread_mgmt_s *this, const char* psz_name, f_thread_t f_thread);
  55.     int (*delete_thread)(struct thread_mgmt_s *this, const char* psz_name);
  56.     
  57. }thread_mgmt_t;

  59. void tm_init(thread_mgmt_t *ptm);

  61. void tm_exit(thread_mgmt_t *ptm);

  63. #define tm_create_thread(tm,nm,ft) ((tm).create_thread(&(tm),(nm),(ft)))
  64. #define tm_delete_thread(tm,nm)((tm).delete_thread(&(tm),(nm)))

  66. #endif
file: thread_mgmt.c
  1. /**
  2.  * author: vincent.cws2008@gmail.com
  3.  * history:
  4.  * initial @ 2011-09-18
  5.  * porting to linux(cygwin) @ 2011-09-20
  6.  */

  8. #include "thread_mgmt.h"

  10. #ifdef WIN32

  12. #ifndef hnull
  13. #define hnull INVALID_HANDLE_VALUE
  14. #endif
  15. #ifndef null
  16. #define null NULL
  17. #endif

  19. #else

  21. #ifndef hnull
  22. #define hnull (void*)0
  23. #endif
  24. #ifndef null
  25. #define null (void*)0
  26. #endif

  28. #endif


  31. static int __init(struct thread_mgmt_s *this)
  32. {
  33.     int i = 0;
  34.     __assert(this!=null)
  35.     for (;i<MAX_THREAD;i++)
  36.     {
  37.         this->thread_info[i].id = 0;
  38.         this->thread_info[i].h = hnull;
  39.         this->thread_info[i].f_thread=null;
  40.         this->thread_info[i].name[0]=0;
  41.     }
  42.     return 0;
  43. }

  45. static int __exit(struct thread_mgmt_s *this)
  46. {
  47.     int i = 0;
  48.     __assert(this!=null);
  49.     for (;i<MAX_THREAD;i++)
  50.     {
  51.         if(this->thread_info[i].h != hnull)
  52.         {
  53. #ifdef WIN32
  54.             /* terminal the log server thread until 1 second over */
  55.             unsigned long state = WaitForSingleObject (this->thread_info[i].h, 100);
  56.             switch (state)
  57.             {
  58.             case WAIT_TIMEOUT:
  59.                 {
  60.                     unsigned long exit_code = 0;
  61.                     if (0 != TerminateThread(this->thread_info[i].h, exit_code))
  62.                         ;
  63.                     /* terminate the server thread */
  64.                     else
  65.                         ;
  66.                     /* terminate the LogSrv thread failed */
  67.                     break;
  68.                 }
  69.             case WAIT_ABANDONED: break;
  70.                 /* the Thread abandoned */
  71.             case WAIT_OBJECT_0: break;
  72.                 /* exit the server thread */
  73.             default: break;
  74.             }
  75. #else
  76.             if(pthread_cancel(this->thread_info[i].h)!=0)
  77.                 ;/* go on to terminal others, althought error occur nowing */
  78. #endif
  79.             this->thread_info[i].h = hnull;
  80.             this->thread_info[i].name[0]=0;
  81.             this->thread_info[i].id=0;
  82.             this->thread_info[i].f_thread=0;
  83.         }
  84.         else if (this->thread_info[i].h == hnull)
  85.         {
  86.             this->thread_info[i].h = hnull;
  87.             this->thread_info[i].name[0]=0;
  88.             this->thread_info[i].id=0;
  89.             this->thread_info[i].f_thread=0;
  90.         }
  91.     }
  92.     return 0;
  93. }


  96. static int __create_thread(struct thread_mgmt_s *this, const char* psz_name, f_thread_t f_thread)
  97. {
  98.     int i=0, len=0;
  99.     __assert(this!=null && psz_name!=null && f_thread!=null);
  100.     for (;i<MAX_THREAD;i++)
  101.     {
  102.         if(this->thread_info[i].h==hnull || this->thread_info[i].f_thread==null)
  103.             break;
  104.     }
  105.     if(i==MAX_THREAD) return -1;
  106. #ifdef WIN32
  107.     this->thread_info[i].h = CreateThread(
  108.         null, // default security attributes
  109.         0, // use default stack size
  110.         f_thread,// thread function
  111.         0, // argument to thread function
  112.         0, // use default creation flags
  113.         &(this->thread_info[i].id));
  114. #else
  115.     if(pthread_create(&this->thread_info[i].h, null, f_thread, null)!=0)
  116.         return -1;
  117. #endif
  118.     len=strlen(psz_name)+1;
  119.     if (MAX_NAME < len)
  120.     {
  121.         memcpy(this->thread_info[i].name, psz_name, MAX_NAME-1);
  122.         this->thread_info[i].name[MAX_NAME-1]=0;
  123.     }
  124.     else
  125.         memcpy(this->thread_info[i].name, psz_name, len);
  126.     
  127.     this->thread_info[i].f_thread = f_thread;
  128.     
  129.     return 0;
  130. }


  133. static int __delete_thread(struct thread_mgmt_s *this, const char* psz_name)
  134. {
  135.     int i = 0;
  136.     __assert(this!=null && psz_name!=null);
  137.     for (;i<MAX_THREAD;i++)
  138.     {
  139.         if(strcmp(this->thread_info[i].name, psz_name)==0
  140.             && this->thread_info[i].h != hnull)
  141.         {
  142.             /* terminal the log server thread until 1 second over */
  143. #ifdef WIN32
  144.             unsigned long state = WaitForSingleObject (this->thread_info[i].h, 100);
  145.             switch (state)
  146.             {
  147.             case WAIT_TIMEOUT:
  148.                 {
  149.                     unsigned long exit_code = 0;
  150.                     
  151.                     if (0 != TerminateThread(this->thread_info[i].h, exit_code))
  152.                         ;
  153.                     /* terminate the server thread */
  154.                     else
  155.                         ;
  156.                     /* terminate the LogSrv thread failed */
  157.                     break;
  158.                 }
  159.             case WAIT_ABANDONED: break;
  160.                 /* the Thread abandoned */
  161.             case WAIT_OBJECT_0: break;
  162.                 /* exit the server thread */
  163.             default: break;
  164.             }
  165. #else
  166.             if(pthread_cancel(this->thread_info[i].h)!=0)
  167.                 return -1;
  168. #endif
  169.             this->thread_info[i].h = hnull;
  170.             this->thread_info[i].name[0]=0;
  171.             this->thread_info[i].id=0;
  172.             this->thread_info[i].f_thread=0;
  173.         }
  174.         else if (this->thread_info[i].h == hnull)
  175.         {
  176.             this->thread_info[i].h = hnull;
  177.             this->thread_info[i].name[0]=0;
  178.             this->thread_info[i].id=0;
  179.             this->thread_info[i].f_thread=0;
  180.         }
  181.     }
  182.     return 0;
  183. }

  185. void tm_init(thread_mgmt_t *ptm)
  186. {
  187.     __assert(ptm!=null);
  188.     *(&ptm->init) = &__init;
  189.     *(&ptm->exit) = &__exit;
  190.     *(&ptm->create_thread) = &__create_thread;
  191.     *(&ptm->delete_thread) = &__delete_thread;
  192.     ptm->init(ptm);
  193. }

  195. void tm_exit(thread_mgmt_t *ptm)
  196. {
  197.     __assert(ptm!=null);
  198.     ptm->exit(ptm);
  199. }
file: main.c
  1. /**
  2.  * author: vincent.cws2008@gmail.com
  3.  * history:
  4.  * initial @ 2011-09-18
  5.  * porting to linux(cygwin) @ 2011-09-20
  6.  */

  8. #include "debugx.h"
  9. #include "logx.h"
  10. #include "thread_mgmt.h"

  12. #ifdef WIN32
  13. #define val_time 10
  14. #define sleep Sleep
  15. #define gettidx() GetCurrentThreadId()
  16. #else
  17. #define val_time 1
  18. #define gettidx() pthread_self()
  19. #endif

  21. #ifdef WIN32
  22. DWORD WINAPI f_thread1(LPVOID pvoid)
  23. #else
  24. void *f_thread1(void *pvoid)
  25. #endif
  26. {
  27.     int i = 10;
  28.     unsigned long id = gettidx();

  30.     while (i--)
  31.     {
  32.         debugx(xinfo, "thread id(%lu): this is %s!\n", id, "xinfo");
  33.         sleep(val_time);
  34.     }
  35. }

  37. #ifdef WIN32
  38. DWORD WINAPI f_thread2(LPVOID pvoid)
  39. #else
  40. void *f_thread2(void *pvoid)
  41. #endif
  42. {
  43.     int i = 10;
  44.     unsigned long id = gettidx();

  46.     while (i--)
  47.     {
  48.         debugx(xevent, "thread id(%lu): this is %s!\n", id, "xevent");
  49.         sleep(val_time);
  50.     }
  51. }

  53. #ifdef WIN32
  54. DWORD WINAPI f_thread3(LPVOID pvoid)
  55. #else
  56. void *f_thread3(void *pvoid)
  57. #endif
  58. {
  59.     int i = 10;
  60.     unsigned long id = gettidx();
  61.     while (i--)
  62.     {
  63.         debugx(xerror, "thread id(%lu): this is %s!\n", id, "xerror");
  64.         sleep(val_time);
  65.     }
  66. }

  68. int main()
  69. {
  70.     int i = 10;
  71.     unsigned long id = 0;
  72. #if LOG_MOD==LOG_MUL_THREAD
  73.     thread_mgmt_t tm;
  74.     logx_init("D:/abc.txt", LOG_MUL_THREAD);
  75.     tm_init(&tm);
  76.     tm_create_thread(tm,"t1",f_thread1);
  77.     tm_create_thread(tm,"t2",f_thread2);
  78.     tm_create_thread(tm,"t3",f_thread3);
  79. #else
  80.     logx_init("D:/abc.txt", LOG_SIG_THREAD);
  81. #endif

  83.     debugx(xinfo, "this is %s!\n", "xinfo");
  84.     debugx(xdata, "this is %s!\n", "xdata");
  85.     debugx(xentry, "this is %s!\n", "xentry");
  86.     debugx(xevent, "this is %s!\n", "xevent");
  87.     debugx(xmsg, "this is %s!\n", "xmsg");
  88.     debugx(xwarn, "this is %s!\n", "xwarn");
  89.     debugx(xerror, "this is %s!\n", "xerror");
  90.     debugx(xfatal, "this is %s!\n", "xfatal");
  91.     debugx(xerror, "this is %s!\n", "xerror");

  93.     id = gettidx();

  95.     while (i--)
  96.     {
  97.         debugx(xfatal, "thread id(%d): this is %s!\n", id, "xfatal");
  98.         sleep(val_time);
  99.     }

  101. #if LOG_MOD==LOG_MUL_THREAD
  102.     tm_exit(&tm);
  103. #endif
  104.     logx_exit();

  106.     return 0;
  107. }

附件:
 debugx__.rar  
阅读(1722) | 评论(0) | 转发(0) |
0

上一篇：【转】Linux 的多线程编程的高效开发经验

下一篇：『转』笑话

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

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

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

16024965号-6