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                 if (pthread_create(&NSThread[i], NULL, NSTopicSchedule, NULL) != 0)
 153                 {
 154                    NS_LOG(ERROR, "Unable to create the NSThread");
 155                    return false;
 156                 }
 157 #endif
 158             }
 159                 break;
 160             default:
 161                 break;
 162
 163         }
 164
 165         NSHeadMsg[i] = NSTailMsg[i] = NULL;
 166
 167         pthread_mutex_unlock(&NSMutex[i]);
 168
 169     }
 170
 171     return true;
 172 }
 173
 174 bool NSStopScheduler()
 175 {
 176     NS_LOG(DEBUG, "NSStopScheduler - IN");
 177     int i = 0;
 178
 179     for (i = THREAD_COUNT - 1; i >= 0; --i)
 180     {
 181         int status = -1;
 182
 183         NSIsRunning[i] = false;
 184
 185         sem_post(&(NSSemaphore[i]));
 186         pthread_join(NSThread[i], (void **) &status);
 187
 188         NSThread[i] = 0;
 189
 190         pthread_mutex_lock(&NSMutex[i]);
 191
 192         while (NSHeadMsg[i] != NULL)
 193         {
 194             NSTask* temp = NSHeadMsg[i];
 195             NSHeadMsg[i] = NSHeadMsg[i]->nextTask;
 196             NSFreeData(i, temp);
 197             NSOICFree(temp);
 198         }
 199
 200         NSTailMsg[i] = NSHeadMsg[i] = NULL;
 201
 202         pthread_mutex_unlock(&NSMutex[i]);
 203         pthread_mutex_destroy(&NSMutex[i]);
 204     }
 205
 206     NS_LOG(DEBUG, "NSStopScheduler - OUT");
 207
 208     return true;
 209 }
 210
 211 void NSPushQueue(NSSchedulerType schedulerType, NSTaskType taskType, void* data)
 212 {
 213
 214     if (!NSIsRunning[schedulerType])
 215     {
 216         return;
 217     }
 218
 219     pthread_mutex_lock(&NSMutex[schedulerType]);
 220
 221     NS_LOG(DEBUG, "NSPushQueue - IN");
 222     NS_LOG_V(DEBUG, "NSSchedulerType = %d", schedulerType);
 223     NS_LOG_V(DEBUG, "NSTaskType = %d", taskType);
 224
 225     if (NSHeadMsg[schedulerType] == NULL)
 226     {
 227         NSHeadMsg[schedulerType] = (NSTask*) OICMalloc(sizeof(NSTask));
 228
 229         if (NSHeadMsg[schedulerType])
 230         {
 231             NSHeadMsg[schedulerType]->taskType = taskType;
 232             NSHeadMsg[schedulerType]->taskData = data;
 233             NSHeadMsg[schedulerType]->nextTask = NULL;
 234             NSTailMsg[schedulerType] = NSHeadMsg[schedulerType];
 235         }
 236     }
 237     else
 238     {
 239         NSTask* newNode = (NSTask*) OICMalloc(sizeof(NSTask));
 240         if (newNode)
 241         {
 242             newNode->taskType = taskType;
 243             newNode->taskData = data;
 244             newNode->nextTask = NULL;
 245
 246             NSTailMsg[schedulerType]->nextTask = newNode;
 247             NSTailMsg[schedulerType] = newNode;
 248         }
 249     }
 250
 251     sem_post(&(NSSemaphore[schedulerType]));
 252     NS_LOG(DEBUG, "NSPushQueue - OUT");
 253     pthread_mutex_unlock(&NSMutex[schedulerType]);
 254 }
 255
 256 void NSFreeData(NSSchedulerType type, NSTask * task)
 257 {
 258     NS_LOG(DEBUG, "NSFreeData - IN");
 259
 260     if (type == CALLBACK_RESPONSE_SCHEDULER)
 261     {
 262         switch (task->taskType)
 263         {
 264             case TASK_CB_SUBSCRIPTION:
 265                 NS_LOG(DEBUG, "CASE TASK_CB_SUBSCRIPTION : Free");
 266                 NSFreeOCEntityHandlerRequest((OCEntityHandlerRequest*) task->taskData);
 267                 break;
 268             case TASK_CB_SYNC:
 269                 NS_LOG(DEBUG, "CASE TASK_CB_SYNC : Free");
 270                 NSFreeSync((NSSyncInfo*) task->taskData);
 271                 break;
 272             default:
 273                 NS_LOG(DEBUG, "No Task Type");
 274                 break;
 275         }
 276     }
 277     else if (type == DISCOVERY_SCHEDULER)
 278     {
 279         switch (task->taskType)
 280         {
 281             case TASK_START_PRESENCE:
 282             case TASK_STOP_PRESENCE:
 283             case TASK_REGISTER_RESOURCE:
 284                 NS_LOG(DEBUG, "Not required Free");
 285                 break;
 286             default:
 287                 NS_LOG(DEBUG, "No Task Type");
 288                 break;
 289         }
 290     }
 291     else if (type == SUBSCRIPTION_SCHEDULER)
 292     {
 293         switch (task->taskType)
 294         {
 295             case TASK_SEND_POLICY:
 296             case TASK_RECV_SUBSCRIPTION:
 297             case TASK_RECV_UNSUBSCRIPTION:
 298             case TASK_SYNC_SUBSCRIPTION:
 299                 NS_LOG(DEBUG, "NSFreeOCEntityHandlerRequest : Free ");
 300                 NSFreeOCEntityHandlerRequest((OCEntityHandlerRequest*) task->taskData);
 301                 break;
 302             case TASK_SEND_ALLOW:
 303             case TASK_SEND_DENY:
 304                 NS_LOG(DEBUG, "NSFreeConsumer : Free ");
 305                 NSFreeConsumer((NSConsumer *) task->taskData);
 306                 break;
 307             default:
 308                 NS_LOG(DEBUG, "No Task Type");
 309                 break;
 310         }
 311     }
 312     else if (type == NOTIFICATION_SCHEDULER)
 313     {
 314         switch (task->taskType)
 315         {
 316             case TASK_SEND_NOTIFICATION:
 317             {
 318                 NS_LOG(DEBUG, "NSFreeMessage : Free ");
 319                 NSFreeMessage((NSMessage *)task->taskData);
 320                 break;
 321             }
 322             case TASK_SEND_READ:
 323             case TASK_RECV_READ:
 324                 NS_LOG(DEBUG, "NSFreeSync : Free ");
 325                 NSFreeSync((NSSyncInfo*) task->taskData);
 326                 break;
 327
 328             default:
 329                 NS_LOG(DEBUG, "No Task Type");
 330                 break;
 331         }
 332     }
 333     else if (type == TOPIC_SCHEDULER)
 334     {
 335         switch (task->taskType)
 336         {
 337             case TASK_SUBSCRIBE_TOPIC:
 338             case TASK_UNSUBSCRIBE_TOPIC:
 339             {
 340                 NSCacheTopicSubData * data = task->taskData;
 341                 NSOICFree(data->topicName);
 342                 NSOICFree(data);
 343             }
 344                 break;
 345             case TASK_REGISTER_TOPIC:
 346             case TASK_UNREGISTER_TOPIC:
 347             {
 348                 NSOICFree(task->taskData);
 349             }
 350                 break;
 351             case TASK_SEND_TOPICS:
 352             case TASK_POST_TOPIC:
 353             {
 354                 NS_LOG(DEBUG, "TASK_POST_TOPIC : ");
 355                 NSFreeOCEntityHandlerRequest((OCEntityHandlerRequest*) task->taskData);
 356             }
 357                 break;
 358             default:
 359                 break;
 360         }
 361     }
 362     NS_LOG(DEBUG, "NSFreeData - OUT");
 363 }