NdbThread.c
上传用户:romrleung
上传日期:2022-05-23
资源大小:18897k
文件大小:4k
源码类别:

MySQL数据库

开发平台:

Visual C++

  1. /* Copyright (C) 2003 MySQL AB
  2.    This program is free software; you can redistribute it and/or modify
  3.    it under the terms of the GNU General Public License as published by
  4.    the Free Software Foundation; either version 2 of the License, or
  5.    (at your option) any later version.
  6.    This program is distributed in the hope that it will be useful,
  7.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  8.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  9.    GNU General Public License for more details.
  10.    You should have received a copy of the GNU General Public License
  11.    along with this program; if not, write to the Free Software
  12.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  13. #include "NdbThread.h"
  14. #include <pthread.h>
  15. #include <malloc.h>
  16. #include <string.h>
  17. #include <NdbOut.hpp>
  18. #define MAX_THREAD_NAME 16
  19. struct NdbThread 
  20.   PROCESS pid;
  21.   char thread_name[MAX_THREAD_NAME];
  22. };
  23. #define NDBTHREAD_SIGBASE  4010
  24.    
  25. #define NDBTHREAD_START           (NDBTHREAD_SIGBASE + 1)  /* !-SIGNO(struct NdbThreadStart)-! */  
  26. struct NdbThreadStart
  27. {
  28.   SIGSELECT sigNo;
  29.   NDB_THREAD_FUNC* func;
  30.   NDB_THREAD_ARG arg;
  31. };
  32. struct NdbThreadStopped
  33. {
  34.   SIGSELECT sigNo;
  35. };
  36. union SIGNAL 
  37. {
  38.   SIGSELECT sigNo;
  39.   struct NdbThreadStart          threadStart;
  40.   struct NdbThreadStopped        threadStopped;
  41. };
  42. OS_PROCESS(thread_starter){
  43.   static const SIGSELECT sel_start[] = {1, NDBTHREAD_START};
  44.   struct NdbThreadStart* sigstart;
  45.   union SIGNAL* sig;
  46.   /* Receive function adress and params */
  47.   sig = receive((SIGSELECT*)sel_start);
  48.   if (sig != NIL){
  49.     if (sig->sigNo == NDBTHREAD_START){
  50.       sigstart = ((struct NdbThreadStart*)sig);
  51.       /* Execute function with arg */
  52.       (*sigstart->func)(sigstart->arg);
  53.     }else{
  54.       assert(1==0);
  55.     }
  56.     free_buf(&sig);
  57.   }
  58. }
  59. struct NdbThread* NdbThread_Create(NDB_THREAD_FUNC* p_thread_func,
  60.                       NDB_THREAD_ARG *p_thread_arg,
  61.          const NDB_THREAD_STACKSIZE thread_stack_size,
  62.       const char* p_thread_name,
  63.                       NDB_THREAD_PRIO thread_prio)
  64. {
  65.   struct NdbThread* tmpThread;
  66.   union SIGNAL* sig;
  67.   int ose_prio;
  68.   if (p_thread_func == NULL)
  69.     return 0;
  70.   tmpThread = (struct NdbThread*)malloc(sizeof(struct NdbThread));
  71.   if (tmpThread == NULL)
  72.     return NULL;
  73.   strncpy((char*)&tmpThread->thread_name, p_thread_name, MAX_THREAD_NAME);
  74.   switch(thread_prio){
  75.   case NDB_THREAD_PRIO_HIGHEST:
  76.     ose_prio = 1;
  77.     break;
  78.   case NDB_THREAD_PRIO_HIGH:
  79.     ose_prio = 10;
  80.     break;
  81.   case NDB_THREAD_PRIO_MEAN:
  82.     ose_prio = 16;
  83.     break;
  84.   case NDB_THREAD_PRIO_LOW:
  85.     ose_prio = 23;
  86.     break;
  87.   case NDB_THREAD_PRIO_LOWEST:
  88.     ose_prio = 31;
  89.     break;
  90.   default:
  91.     return NULL;
  92.     break;
  93.   }
  94.   /* Create process */
  95.   tmpThread->pid = create_process(OS_PRI_PROC,    /* Process type */
  96.                                   (char*)p_thread_name,  /* Name */
  97.                                   thread_starter,  /* Entry point */
  98.                                   thread_stack_size, /* Stack size */
  99.                                   ose_prio,              /* Priority */
  100.                                   0,              /* Time slice */
  101.                                   get_bid(current_process()), /* Block */
  102.                                   NULL,           /* Redir table */
  103.                                   0,
  104.                                   0);
  105.   /* Send params to process */ 
  106.   sig = alloc(sizeof(struct NdbThreadStart), NDBTHREAD_START);
  107.   ((struct NdbThreadStart*)sig)->func = p_thread_func;
  108.   ((struct NdbThreadStart*)sig)->arg = p_thread_arg;
  109.   send(&sig, tmpThread->pid);
  110.   /* Enable NDB_HOME environment variable for the thread */
  111.   {
  112.     /* Hardcoded NDB_HOME...*/
  113.     char* ndb_home_env = get_env(current_process(), "NDB_HOME");
  114.     if (ndb_home_env != NULL)
  115.     {
  116.       /* Set NDB_HOME */
  117.       int rc = set_env(tmpThread->pid, "NDB_HOME", ndb_home_env);
  118.       if (rc != 0)
  119.       {
  120. /* Not really a problem */
  121.       }
  122.     } /* Enable NDB_HOME */
  123.   }
  124.   /* Start process */
  125.   start(tmpThread->pid);
  126.   return tmpThread;
  127. }
  128. void NdbThread_Destroy(struct NdbThread** p_thread)
  129. {
  130.   free(* p_thread); * p_thread = 0;
  131. }
  132. int NdbThread_WaitFor(struct NdbThread* p_wait_thread, void** status)
  133. {
  134.   while(hunt(p_wait_thread->thread_name, 0, NULL, NULL) != 0) 
  135.     delay(1000);
  136.   * status = 0;
  137.   
  138.   return 0;
  139. }
  140. void NdbThread_Exit(int a)
  141. {
  142.   kill_proc(current_process());
  143. }
  144. int NdbThread_SetConcurrencyLevel(int level)
  145. {
  146.   return 0;
  147. }