TSP: The Transport Sample Protocol



Main Page | Modules | Alphabetical List | Data Structures | File List | Data Fields | Globals | Related Pages

bb_simple.c

Go to the documentation of this file.
00001 
00037 #include <sys/types.h>
00038 #include <sys/msg.h>
00039 #include <string.h>
00040 
00041 #include <bb_utils.h>
00042 #include <bb_core.h>
00043 #include <bb_simple.h>
00044 
00045 static int bb_simple_synchro_type = BB_SIMPLE_SYNCHRO_PROCESS;
00046 
00047 pthread_cond_t  bb_simple_go_condvar       = PTHREAD_COND_INITIALIZER;
00048 pthread_mutex_t bb_simple_go_mutex         = PTHREAD_MUTEX_INITIALIZER;
00049 pthread_cond_t  bb_simple_stockage_condvar = PTHREAD_COND_INITIALIZER;
00050 pthread_mutex_t bb_simple_stcokage_mutex   = PTHREAD_MUTEX_INITIALIZER;
00051 
00052 void* bb_simple_publish(S_BB_T* bb_simple,
00053                         const char* var_name, 
00054                         const char* module_name,
00055                         const int module_instance,
00056                         E_BB_TYPE_T type,
00057                         int type_size,
00058                         int dimension) {
00059   
00060   void* retval;
00061   S_BB_DATADESC_T s_data_desc;
00062 
00063   memset(s_data_desc.name,0,VARNAME_MAX_SIZE);
00064   if (-1!=module_instance) {
00065     snprintf(s_data_desc.name,VARNAME_MAX_SIZE,
00066              "%s_%d_%s",
00067              module_name,module_instance,var_name);
00068   } else {
00069     snprintf(s_data_desc.name,VARNAME_MAX_SIZE,
00070              "%s_%s",
00071              module_name,var_name);
00072   }
00073   s_data_desc.type        = type;
00074   s_data_desc.type_size   = type_size;
00075   s_data_desc.dimension   = dimension;
00076   retval = bb_publish(bb_simple,&s_data_desc);
00077   if (retval == NULL) {
00078     bb_logMsg(BB_LOG_SEVERE,"BlackBoard::bb_simple_publish", 
00079                 "Cannot publish data <%s> instance <%d> module <%s>",
00080                 var_name,module_instance,module_name);
00081   }  
00082   
00083   return retval;
00084 } /* end of bb_simple_publish */
00085 
00086 
00087 void* bb_simple_subscribe(S_BB_T* bb_simple,
00088                           const char* var_name,
00089                           const char* module_name,
00090                           const int module_instance,
00091                           E_BB_TYPE_T*  type,
00092                           int* type_size,
00093                           int* dimension) {
00094   
00095   void* retval;
00096   S_BB_DATADESC_T s_data_desc;
00097 
00098   memset(s_data_desc.name,0,VARNAME_MAX_SIZE);
00099   if (0!=module_instance) {
00100     snprintf(s_data_desc.name,VARNAME_MAX_SIZE,
00101              "%s_%d_%s",
00102              module_name,module_instance,var_name);
00103   } else {
00104     snprintf(s_data_desc.name,VARNAME_MAX_SIZE,
00105              "%s_%s",
00106              module_name,var_name);
00107   }
00108   
00109   retval = bb_subscribe(bb_simple,&s_data_desc);  
00110   *type      = s_data_desc.type;
00111   *type_size = s_data_desc.type_size;
00112   *dimension = s_data_desc.dimension;
00113   return retval;
00114 } /* end of bb_simple_subscribe */
00115 
00116 
00117 
00118 int32_t 
00119 bb_simple_synchro_config(int synchro_type) {
00120   
00121   int32_t retcode=E_OK;
00122   
00123   switch (synchro_type) {
00124   case BB_SIMPLE_SYNCHRO_PROCESS:
00125   case BB_SIMPLE_SYNCHRO_THREAD:
00126     bb_simple_synchro_type = synchro_type;
00127     break;
00128   default:
00129     bb_logMsg(BB_LOG_SEVERE,"BlackBoard::bb_simple_synchro_config",
00130                 "Invalid synchro type <%d>, BB_SIMPLE_SYNCHRO_PROCESS <%d> used",
00131                 synchro_type,BB_SIMPLE_SYNCHRO_PROCESS);
00132     bb_simple_synchro_type = BB_SIMPLE_SYNCHRO_PROCESS;
00133   }
00134   
00135   return retcode;
00136 } /* end of bb_simple_synchro_config */
00137 
00138 int32_t 
00139 bb_simple_synchro_go(S_BB_T* bb_simple,int type_msg) {
00140   
00141   int32_t retcode;
00142   S_BB_MSG_T s_bb_msg;
00143   
00144   switch (bb_simple_synchro_type) {
00145   case BB_SIMPLE_SYNCHRO_PROCESS:
00146     s_bb_msg.mtype = type_msg;
00147     retcode = bb_snd_msg(bb_simple,&s_bb_msg);
00148     break;
00149   case BB_SIMPLE_SYNCHRO_THREAD:
00150     retcode=bb_simple_thread_synchro_go(type_msg);
00151     break;
00152   default:
00153     retcode=bb_simple_thread_synchro_go(type_msg); 
00154   }
00155   
00156   return retcode;
00157 } /* end of bb_simple_synchro_go */
00158 
00159 int32_t 
00160 bb_simple_synchro_wait(S_BB_T* bb_simple,int type_msg) {
00161   
00162   int32_t retcode;
00163   S_BB_MSG_T s_bb_msg;
00164   
00165   switch (bb_simple_synchro_type) {
00166   case BB_SIMPLE_SYNCHRO_PROCESS:
00167     s_bb_msg.mtype = type_msg;
00168     retcode = bb_rcv_msg(bb_simple,&s_bb_msg);      
00169     break;
00170   case BB_SIMPLE_SYNCHRO_THREAD:
00171     retcode=bb_simple_thread_synchro_wait(type_msg);
00172     break;
00173   default:
00174     retcode=bb_simple_thread_synchro_wait(type_msg);    
00175   }
00176   
00177   return retcode;
00178 } /* end of bb_simple_synchro_wait */
00179 
00180 int32_t 
00181 bb_simple_synchro_verify(S_BB_T* bb_simple) {
00182   
00183   int32_t retcode;
00184   struct msqid_ds s_msgq_stat;
00185 
00186   msgctl(bb_msg_id(bb_simple),
00187          IPC_STAT,
00188          &s_msgq_stat);
00189   
00190   if (s_msgq_stat.msg_qnum > 0) {
00191     retcode = E_NOK;
00192     
00193   } else {
00194     retcode = E_OK;
00195   }  
00196   
00197   return retcode;
00198 } /* end of bb_simple_synchro_verify */
00199 
00200 int32_t 
00201 bb_simple_thread_synchro_go(int msg_type) {
00202   
00203   int32_t retcode;
00204   
00205   switch (msg_type) {
00206   case BB_SIMPLE_MSGID_SYNCHRO_COPY:
00207     pthread_mutex_lock(&bb_simple_go_mutex);
00208     pthread_cond_broadcast(&bb_simple_go_condvar);
00209     pthread_mutex_unlock(&bb_simple_go_mutex);
00210     break;
00211   case BB_SIMPLE_MSGID_SYNCHRO_COPY_ACK:
00212     pthread_mutex_lock(&bb_simple_stockage_mutex);
00213     pthread_cond_broadcast(&bb_simple_stockage_condvar);
00214     pthread_mutex_unlock(&bb_simple_stockage_mutex);
00215     break;
00216   default:
00217     bb_logMsg(BB_LOG_SEVERE,"BlackBoard::bb_simple_thread_synchro_go", 
00218               "Invalid thread synchro ID <%d>",msg_type);
00219   }
00220   /* pthread_cond_broadcast always succeed */
00221   retcode = E_OK;
00222   
00223   return retcode;
00224 } /* end of bb_simple_synchro_go */
00225 
00226 int32_t 
00227 bb_simple_thread_synchro_wait(int msg_type) {
00228   
00229   int32_t retcode;
00230   
00231   switch (msg_type) {
00232   case BB_SIMPLE_MSGID_SYNCHRO_COPY:
00233     pthread_mutex_lock(&bb_simple_go_mutex);
00234     pthread_cond_wait(&bb_simple_go_condvar,&bb_simple_go_mutex);
00235     pthread_mutex_unlock(&bb_simple_go_mutex);
00236     break;
00237   case BB_SIMPLE_MSGID_SYNCHRO_COPY_ACK:
00238     pthread_mutex_lock(&bb_simple_stockage_mutex);
00239     pthread_cond_wait(&bb_simple_stockage_condvar,&bb_simple_stockage_mutex);
00240     pthread_mutex_unlock(&bb_simple_stockage_mutex);
00241     break;
00242   default:
00243     bb_logMsg(BB_LOG_SEVERE,"BlackBoard::bb_simple_thread_synchro_wait", 
00244               "Invalid thread synchro ID <%d>",msg_type);
00245   }
00246   /* pthread_cond_wait always succeed (or never return)*/
00247   retcode = E_OK;
00248   
00249   return retcode;
00250 } /* end of bb_simple_synchro_wait */
Framework Home Page.

Beware !! TSP wave is coming...