service/notification/src/provider/NSProviderScheduler.c

   1 //******************************************************************
   2 //
   3 // Copyright 2016 Samsung Electronics All Rights Reserved.
   4 //
   5 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
   6 //
   7 // Licensed under the Apache License, Version 2.0 (the "License");
   8 // you may not use this file except in compliance with the License.
   9 // You may obtain a copy of the License at
  10 //
  11 //      http://www.apache.org/licenses/LICENSE-2.0
  12 //
  13 // Unless required by applicable law or agreed to in writing, software
  14 // distributed under the License is distributed on an "AS IS" BASIS,
  15 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16 // See the License for the specific language governing permissions and
  17 // limitations under the License.
  18 //
  19 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  20
  21 #include "NSProviderScheduler.h"
  22
  23 #ifdef __TIZENRT__
  24 #include <tinyara/config.h>
  25 #endif
  26
  27 pthread_t NSThread[THREAD_COUNT];
  28 pthread_mutex_t NSMutex[THREAD_COUNT];
  29 sem_t NSSemaphore[THREAD_COUNT];
  30 bool NSIsRunning[THREAD_COUNT] = { false, };
  31
  32 NSTask* NSHeadMsg[THREAD_COUNT];
  33 NSTask* NSTailMsg[THREAD_COUNT];
  34
  35 void * NSCallbackResponseSchedule(void *ptr);
  36 void * NSDiscoverySchedule(void *ptr);
  37 void * NSSubScriptionSchedule(void *ptr);
  38 void * NSNotificationSchedule(void *ptr);
  39 void * NSTopicSchedule(void * ptr);
  40
  41 bool NSInitScheduler()
  42 {
  43     NS_LOG(DEBUG, "NSInitScheduler - IN");
  44
  45     int i = 0;
  46
  47     for (i = 0; i < THREAD_COUNT; i++)
  48     {
  49         pthread_mutex_init(&NSMutex[i], NULL);
  50         NSIsRunning[i] = true;
  51         sem_init(&(NSSemaphore[i]), 0, 0);
  52     }
  53
  54     NS_LOG(DEBUG, "NSInitScheduler - OUT");
  55
  56     return true;
  57 }
  58
  59 #ifdef __TIZENRT__
  60 static int ns_pthread_create(pthread_t *thread, pthread_startroutine_t start_routine,
  61                              pthread_addr_t arg, const char *task_name, int stack_size)
  62 {
  63 /* All callers have null attr, so ignore it for simple implementation*/
  64     pthread_attr_t task_attr;
  65
  66     pthread_attr_init(&task_attr);
  67
  68     (void)pthread_attr_setschedparam(&task_attr, PTHREAD_DEFAULT_PRIORITY);
  69     (void)pthread_attr_setstacksize(&task_attr, stack_size);
  70
  71     int ret = pthread_create(thread, &task_attr, start_routine, NULL);
  72     if (ret)
  73     {
  74         return ret;
  75     }
  76
  77     pthread_setname_np(*thread, task_name);
  78
  79     return 0;
  80 }
  81 #endif
  82
  83 bool NSStartScheduler()
  84 {
  85     int i = 0;
  86
  87     for (i = 0; i < THREAD_COUNT; i++)
  88     {
  89         pthread_mutex_lock(&NSMutex[i]);
  90
  91         switch (i)
  92         {
  93             case CALLBACK_RESPONSE_SCHEDULER:
  94             {
  95                 NS_LOG(DEBUG, "CASE RESPONSE_SCHEDULER :");
  96 #ifdef __TIZENRT__
  97                 ns_pthread_create(&NSThread[i], NSCallbackResponseSchedule, NULL,
  98                                   "IoT_NS_CallbackResponseSchedule",
  99                                   CONFIG_IOTIVITY_NS_CALLBACKRESPONSESCHED_PTHREAD_STACKSIZE);
 100 #else
 101                 pthread_create(&NSThread[i], NULL, NSCallbackResponseSchedule, NULL);
 102 #endif
 103             }
 104                 break;
 105
 106             case DISCOVERY_SCHEDULER:
 107             {
 108                 NS_LOG(DEBUG, "CASE DISCOVERY_SCHEDULER :");
 109 #ifdef __TIZENRT__
 110                 ns_pthread_create(&NSThread[i], NSDiscoverySchedule, NULL,
 111                                   "IoT_NS_DiscoverySchedule",
 112                                   CONFIG_IOTIVITY_NS_DISCOVERSCHED_PTHREAD_STACKSIZE);
 113 #else
 114                 pthread_create(&NSThread[i], NULL, NSDiscoverySchedule, NULL);
 115 #endif
 116             }
 117                 break;
 118
 119             case SUBSCRIPTION_SCHEDULER:
 120             {
 121                 NS_LOG(DEBUG, "CASE SUBSCRIPTION_SCHEDULER :");
 122 #ifdef __TIZENRT__
 123                 ns_pthread_create(&NSThread[i], NSSubScriptionSchedule, NULL,
 124                                   "IOT_NS_SubScriptionSchedule",
 125                                   CONFIG_IOTIVITY_NS_SUBSCRIPTIONSCHED_PTHREAD_STACKSIZE);
 126 #else
 127                 pthread_create(&NSThread[i], NULL, NSSubScriptionSchedule, NULL);
 128 #endif
 129             }
 130                 break;
 131
 132             case NOTIFICATION_SCHEDULER:
 133             {
 134                 NS_LOG(DEBUG, "CASE NOTIFICATION_SCHEDULER :");
 135 #ifdef __TIZENRT__
 136                 ns_pthread_create(&NSThread[i], NSNotificationSchedule, NULL,
 137                                   "IoT_NS_NotificationSchedule",
 138                                   CONFIG_IOTIVITY_NS_NOTIFICATIONSCHED_PTHREAD_STACKSIZE);
 139 #else
 140                 pthread_create(&NSThread[i], NULL, NSNotificationSchedule, NULL);
 141 #endif
 142             }
 143                 break;
 144
 145             case TOPIC_SCHEDULER:
 146             {
 147                 NS_LOG(DEBUG, "CASE TOPIC_SCHEDULER :");
 148 #ifdef __TIZENRT__
 149                 ns_pthread_create(&NSThread[i], NSTopicSchedule, NULL, "IoT_NS_TopicSchedule",
 150                                   CONFIG_IOTIVITY_NS_TOPICSCHED_PTHREAD_STACKSIZE);
 151 #else
 152                 pthread_create(&NSThread[i], NULL, NSTopicSchedule, NULL);
 153 #endif
 154             }
 155                 break;
 156             default:
 157                 break;
 158
 159         }
 160
 161         NSHeadMsg[i] = NSTailMsg[i] = NULL;
 162
 163         pthread_mutex_unlock(&NSMutex[i]);
 164
 165     }
 166
 167     return true;
 168 }
 169
 170 bool NSStopScheduler()
 171 {
 172     NS_LOG(DEBUG, "NSStopScheduler - IN");
 173     int i = 0;
 174
 175     for (i = THREAD_COUNT - 1; i >= 0; --i)
 176     {
 177         int status = -1;
 178
 179         NSIsRunning[i] = false;
 180
 181         sem_post(&(NSSemaphore[i]));
 182         pthread_join(NSThread[i], (void **) &status);
 183
 184         NSThread[i] = 0;
 185
 186         pthread_mutex_lock(&NSMutex[i]);
 187
 188         while (NSHeadMsg[i] != NULL)
 189         {
 190             NSTask* temp = NSHeadMsg[i];
 191             NSHeadMsg[i] = NSHeadMsg[i]->nextTask;
 192             NSFreeData(i, temp);
 193             NSOICFree(temp);
 194         }
 195
 196         NSTailMsg[i] = NSHeadMsg[i] = NULL;
 197
 198         pthread_mutex_unlock(&NSMutex[i]);
 199         pthread_mutex_destroy(&NSMutex[i]);
 200     }
 201
 202     NS_LOG(DEBUG, "NSStopScheduler - OUT");
 203
 204     return true;
 205 }
 206
 207 void NSPushQueue(NSSchedulerType schedulerType, NSTaskType taskType, void* data)
 208 {
 209
 210     if (!NSIsRunning[schedulerType])
 211     {
 212         return;
 213     }
 214
 215     pthread_mutex_lock(&NSMutex[schedulerType]);
 216
 217     NS_LOG(DEBUG, "NSPushQueue - IN");
 218     NS_LOG_V(DEBUG, "NSSchedulerType = %d", schedulerType);
 219     NS_LOG_V(DEBUG, "NSTaskType = %d", taskType);
 220
 221     if (NSHeadMsg[schedulerType] == NULL)
 222     {
 223         NSHeadMsg[schedulerType] = (NSTask*) OICMalloc(sizeof(NSTask));
 224
 225         if (NSHeadMsg[schedulerType])
 226         {
 227             NSHeadMsg[schedulerType]->taskType = taskType;
 228             NSHeadMsg[schedulerType]->taskData = data;
 229             NSHeadMsg[schedulerType]->nextTask = NULL;
 230             NSTailMsg[schedulerType] = NSHeadMsg[schedulerType];
 231         }
 232     }
 233     else
 234     {
 235         NSTask* newNode = (NSTask*) OICMalloc(sizeof(NSTask));
 236         if (newNode)
 237         {
 238             newNode->taskType = taskType;
 239             newNode->taskData = data;
 240             newNode->nextTask = NULL;
 241
 242             NSTailMsg[schedulerType]->nextTask = newNode;
 243             NSTailMsg[schedulerType] = newNode;
 244         }
 245     }
 246
 247     sem_post(&(NSSemaphore[schedulerType]));
 248     NS_LOG(DEBUG, "NSPushQueue - OUT");
 249     pthread_mutex_unlock(&NSMutex[schedulerType]);
 250 }
 251
 252 void NSFreeData(NSSchedulerType type, NSTask * task)
 253 {
 254     NS_LOG(DEBUG, "NSFreeData - IN");
 255
 256     if (type == CALLBACK_RESPONSE_SCHEDULER)
 257     {
 258         switch (task->taskType)
 259         {
 260             case TASK_CB_SUBSCRIPTION:
 261                 NS_LOG(DEBUG, "CASE TASK_CB_SUBSCRIPTION : Free");
 262                 NSFreeOCEntityHandlerRequest((OCEntityHandlerRequest*) task->taskData);
 263                 break;
 264             case TASK_CB_SYNC:
 265                 NS_LOG(DEBUG, "CASE TASK_CB_SYNC : Free");
 266                 NSFreeSync((NSSyncInfo*) task->taskData);
 267                 break;
 268             default:
 269                 NS_LOG(DEBUG, "No Task Type");
 270                 break;
 271         }
 272     }
 273     else if (type == DISCOVERY_SCHEDULER)
 274     {
 275         switch (task->taskType)
 276         {
 277             case TASK_START_PRESENCE:
 278             case TASK_STOP_PRESENCE:
 279             case TASK_REGISTER_RESOURCE:
 280                 NS_LOG(DEBUG, "Not required Free");
 281                 break;
 282             default:
 283                 NS_LOG(DEBUG, "No Task Type");
 284                 break;
 285         }
 286     }
 287     else if (type == SUBSCRIPTION_SCHEDULER)
 288     {
 289         switch (task->taskType)
 290         {
 291             case TASK_SEND_POLICY:
 292             case TASK_RECV_SUBSCRIPTION:
 293             case TASK_RECV_UNSUBSCRIPTION:
 294             case TASK_SYNC_SUBSCRIPTION:
 295                 NS_LOG(DEBUG, "NSFreeOCEntityHandlerRequest : Free ");
 296                 NSFreeOCEntityHandlerRequest((OCEntityHandlerRequest*) task->taskData);
 297                 break;
 298             case TASK_SEND_ALLOW:
 299             case TASK_SEND_DENY:
 300                 NS_LOG(DEBUG, "NSFreeConsumer : Free ");
 301                 NSFreeConsumer((NSConsumer *) task->taskData);
 302                 break;
 303             default:
 304                 NS_LOG(DEBUG, "No Task Type");
 305                 break;
 306         }
 307     }
 308     else if (type == NOTIFICATION_SCHEDULER)
 309     {
 310         switch (task->taskType)
 311         {
 312             case TASK_SEND_NOTIFICATION:
 313             {
 314                 NS_LOG(DEBUG, "NSFreeMessage : Free ");
 315                 NSFreeMessage((NSMessage *)task->taskData);
 316                 break;
 317             }
 318             case TASK_SEND_READ:
 319             case TASK_RECV_READ:
 320                 NS_LOG(DEBUG, "NSFreeSync : Free ");
 321                 NSFreeSync((NSSyncInfo*) task->taskData);
 322                 break;
 323
 324             default:
 325                 NS_LOG(DEBUG, "No Task Type");
 326                 break;
 327         }
 328     }
 329     else if (type == TOPIC_SCHEDULER)
 330     {
 331         switch (task->taskType)
 332         {
 333             case TASK_SUBSCRIBE_TOPIC:
 334             case TASK_UNSUBSCRIBE_TOPIC:
 335             {
 336                 NSCacheTopicSubData * data = task->taskData;
 337                 NSOICFree(data->topicName);
 338                 NSOICFree(data);
 339             }
 340                 break;
 341             case TASK_REGISTER_TOPIC:
 342             case TASK_UNREGISTER_TOPIC:
 343             {
 344                 NSOICFree(task->taskData);
 345             }
 346                 break;
 347             case TASK_SEND_TOPICS:
 348             case TASK_POST_TOPIC:
 349             {
 350                 NS_LOG(DEBUG, "TASK_POST_TOPIC : ");
 351                 NSFreeOCEntityHandlerRequest((OCEntityHandlerRequest*) task->taskData);
 352             }
 353                 break;
 354             default:
 355                 break;
 356         }
 357     }
 358     NS_LOG(DEBUG, "NSFreeData - OUT");
 359 }