int pthread_create(FAR pthread_t *thread, FAR const pthread_attr_t *attr,
                   pthread_startroutine_t start_routine, pthread_addr_t arg)
{
  FAR struct pthread_tcb_s *ptcb;
  FAR struct join_s *pjoin;
  struct sched_param param;
  int policy;
  int errcode;
  pid_t pid;
  int ret;
#ifdef HAVE_TASK_GROUP
  bool group_joined = false;
#endif

  /* If attributes were not supplied, use the default attributes */

  if (!attr)
    {
      attr = &g_default_pthread_attr;
    }

  /* Allocate a TCB for the new task. */

  ptcb = (FAR struct pthread_tcb_s *)kmm_zalloc(sizeof(struct pthread_tcb_s));
  if (!ptcb)
    {
      sdbg("ERROR: Failed to allocate TCB\n");
      return ENOMEM;
    }

#ifdef HAVE_TASK_GROUP
  /* Bind the parent's group to the new TCB (we have not yet joined the
   * group).
   */

  ret = group_bind(ptcb);
  if (ret < 0)
    {
      errcode = ENOMEM;
      goto errout_with_tcb;
    }
#endif

#ifdef CONFIG_ARCH_ADDRENV
  /* Share the address environment of the parent task group. */

  ret = up_addrenv_attach(ptcb->cmn.group,
                          (FAR struct tcb_s *)g_readytorun.head);
  if (ret < 0)
    {
      errcode = -ret;
      goto errout_with_tcb;
    }
#endif

  /* Allocate a detachable structure to support pthread_join logic */

  pjoin = (FAR struct join_s *)kmm_zalloc(sizeof(struct join_s));
  if (!pjoin)
    {
      sdbg("ERROR: Failed to allocate join\n");
      errcode = ENOMEM;
      goto errout_with_tcb;
    }

  /* Allocate the stack for the TCB */

  ret = up_create_stack((FAR struct tcb_s *)ptcb, attr->stacksize,
                        TCB_FLAG_TTYPE_PTHREAD);
  if (ret != OK)
    {
      errcode = ENOMEM;
      goto errout_with_join;
    }

  /* Should we use the priority and scheduler specified in the pthread
   * attributes?  Or should we use the current thread's priority and
   * scheduler?
   */

  if (attr->inheritsched == PTHREAD_INHERIT_SCHED)
    {
      /* Get the priority (and any other scheduling parameters) for this
       * thread.
       */

      ret = sched_getparam(0, &param);
      if (ret == ERROR)
        {
          errcode = get_errno();
          goto errout_with_join;
        }

      /* Get the scheduler policy for this thread */

      policy = sched_getscheduler(0);
      if (policy == ERROR)
        {
          errcode = get_errno();
          goto errout_with_join;
        }
    }
  else
    {
      /* Use the scheduler policy and policy the attributes */

      policy                             = attr->policy;
      param.sched_priority               = attr->priority;

#ifdef CONFIG_SCHED_SPORADIC
      param.sched_ss_low_priority        = attr->low_priority;
      param.sched_ss_max_repl            = attr->max_repl;
      param.sched_ss_repl_period.tv_sec  = attr->repl_period.tv_sec;
      param.sched_ss_repl_period.tv_nsec = attr->repl_period.tv_nsec;
      param.sched_ss_init_budget.tv_sec  = attr->budget.tv_sec;
      param.sched_ss_init_budget.tv_nsec = attr->budget.tv_nsec;
#endif
    }

#ifdef CONFIG_SCHED_SPORADIC
  if (policy == SCHED_SPORADIC)
    {
      FAR struct sporadic_s *sporadic;
      int repl_ticks;
      int budget_ticks;

      /* Convert timespec values to system clock ticks */

      (void)clock_time2ticks(&param.sched_ss_repl_period, &repl_ticks);
      (void)clock_time2ticks(&param.sched_ss_init_budget, &budget_ticks);

      /* The replenishment period must be greater than or equal to the
       * budget period.
       */

      if (repl_ticks < budget_ticks)
        {
          errcode = EINVAL;
          goto errout_with_join;
        }

      /* Initialize the sporadic policy */

      ret = sched_sporadic_initialize(&ptcb->cmn);
      if (ret >= 0)
        {
          sporadic               = ptcb->cmn.sporadic;
          DEBUGASSERT(sporadic != NULL);

          /* Save the sporadic scheduling parameters */

          sporadic->hi_priority  = param.sched_priority;
          sporadic->low_priority = param.sched_ss_low_priority;
          sporadic->max_repl     = param.sched_ss_max_repl;
          sporadic->repl_period  = repl_ticks;
          sporadic->budget       = budget_ticks;

          /* And start the first replenishment interval */

          ret = sched_sporadic_start(&ptcb->cmn);
        }

      /* Handle any failures */

      if (ret < 0)
        {
          errcode = -ret;
          goto errout_with_join;
        }
    }
#endif

  /* Initialize the task control block */

  ret = pthread_schedsetup(ptcb, param.sched_priority, pthread_start,
                           start_routine);
  if (ret != OK)
    {
      errcode = EBUSY;
      goto errout_with_join;
    }

  /* Configure the TCB for a pthread receiving on parameter
   * passed by value
   */

  pthread_argsetup(ptcb, arg);

#ifdef HAVE_TASK_GROUP
  /* Join the parent's task group */

  ret = group_join(ptcb);
  if (ret < 0)
    {
      errcode = ENOMEM;
      goto errout_with_join;
    }

  group_joined = true;
#endif

  /* Attach the join info to the TCB. */

  ptcb->joininfo = (FAR void *)pjoin;

  /* Set the appropriate scheduling policy in the TCB */

  ptcb->cmn.flags &= ~TCB_FLAG_POLICY_MASK;
  switch (policy)
    {
      default:
        DEBUGPANIC();
      case SCHED_FIFO:
        ptcb->cmn.flags    |= TCB_FLAG_SCHED_FIFO;
        break;

#if CONFIG_RR_INTERVAL > 0
      case SCHED_RR:
        ptcb->cmn.flags    |= TCB_FLAG_SCHED_RR;
        ptcb->cmn.timeslice = MSEC2TICK(CONFIG_RR_INTERVAL);
        break;
#endif

#ifdef CONFIG_SCHED_SPORADIC
      case SCHED_SPORADIC:
        ptcb->cmn.flags    |= TCB_FLAG_SCHED_SPORADIC;
        break;
#endif

#if 0 /* Not supported */
      case SCHED_OTHER:
        ptcb->cmn.flags    |= TCB_FLAG_SCHED_OTHER;
        break;
#endif
    }

  /* Get the assigned pid before we start the task (who knows what
   * could happen to ptcb after this!).  Copy this ID into the join structure
   * as well.
   */

  pid = (int)ptcb->cmn.pid;
  pjoin->thread = (pthread_t)pid;

  /* Initialize the semaphores in the join structure to zero. */

  ret = sem_init(&pjoin->data_sem, 0, 0);
  if (ret == OK)
    {
      ret = sem_init(&pjoin->exit_sem, 0, 0);
    }

  /* Activate the task */

  sched_lock();
  if (ret == OK)
    {
      ret = task_activate((FAR struct tcb_s *)ptcb);
    }

  if (ret == OK)
    {
      /* Wait for the task to actually get running and to register
       * its join structure.
       */

      (void)pthread_takesemaphore(&pjoin->data_sem);

      /* Return the thread information to the caller */

      if (thread)
       {
         *thread = (pthread_t)pid;
       }

      if (!pjoin->started)
        {
          ret = EINVAL;
        }

      sched_unlock();
      (void)sem_destroy(&pjoin->data_sem);
    }
  else
    {
      sched_unlock();
      dq_rem((FAR dq_entry_t *)ptcb, (FAR dq_queue_t *)&g_inactivetasks);
      (void)sem_destroy(&pjoin->data_sem);
      (void)sem_destroy(&pjoin->exit_sem);

      errcode = EIO;
      goto errout_with_join;
    }

  return ret;

errout_with_join:
  sched_kfree(pjoin);
  ptcb->joininfo = NULL;

errout_with_tcb:
#ifdef HAVE_TASK_GROUP
  /* Clear group binding */

  if (ptcb && !group_joined)
    {
      ptcb->cmn.group = NULL;
    }
#endif

  sched_releasetcb((FAR struct tcb_s *)ptcb, TCB_FLAG_TTYPE_PTHREAD);
  return errcode;
}
Exemple #2
0
/* main: this is supposedly required for a C program
 * 1. Create threads to handle clients
 * 2. Add clients from the file
 * 3. Join threads and leave
 * Returns 0 if everything was done correctly.
 */
int main(int argc, char** argv)
{	
	int num_queries, num_threads;
	long i;
	pthread_t * tids;

	if(argc != 3)
	{	
		fprintf(stderr,
			"USAGE: %s [input_file_path] [num_threads]\n",
			argv[0]);
		exit(1);
	}	

	// do preliminary work (database, queue, etc.)
	setup_queue();
	populate_database("TwitterDB.txt");

	num_threads = atoi(argv[2]);

	sem_init(&queue_access, 0, 1);
	sem_init(&empty, 0, 0);
	sem_init(&served, 0, 1);
	sem_init(&full, 0, num_threads);


	// create threads to handle clients
	tids = calloc(num_threads, sizeof(pthread_t));
	for(i = 0; i < num_threads; i++)
	{
	 	if(pthread_create(&tids[i], NULL, serveClients, (void *)(i + 1)))
		{
			perror("main: could not create create thread");
		    exit(1);
		}
	}	

	// populate queue
	num_queries = buildQueue(argv[1]);

	while(num_served != num_queries);
	

   	// cancel threads
	for (i = 0; i < num_threads; i++) 
	{
		if(pthread_cancel(tids[i])) 
		{
			perror("main: could not join thread");
		    exit(1);
		}
	}

	// clean up
	destroy_database();
	destroy_queue();

	free(tids);

	printf("Finished handling all clients\n");
	return 0;
}
Exemple #3
0
int
main(int argc, char **argv, char **envp)
{
	int	i;

	scale_init(argc, argv);

#define ALIGNMENTOFFSET 2 /* adjust alignment */
        i = sizeof(workStruct_t)*
            (narrays+ALIGNMENTOFFSET);
        element = memalign(64, i);
	if ( element == NULL ) {
	    perror("calloc( narrays, sizeof(workStruct_t) )");
	    exit(1);
	}
        compute_set(element);
        memset(element, 0, i);
        element+=ALIGNMENTOFFSET;

#ifdef SELFTEST
	start_prof();
#endif

	fid = open_output("mttest.acct");
	if (job_index == -1) {
		i = (sizeof(scripttab)/sizeof( struct scripttab) -1 );
	} else {
		i = 1;
	}
	fprintf(fid, "Number of tests: %d  Repeat count: %d\n",
		i, repeat_count);

	fprintf(fid, "MHz: %d\n", get_clock_rate() );

	fprintf(fid,
	    "X    Incl. Total   Incl. CPU   Incl. Sync. Wait   Name (%s)\n",
		model);
	fflush(fid);
  
	name = strdup(argv[0]);

	init_micro_acct();
#if OS(Solaris) 
	if(uniprocessor != 0) {
	    /* call processor_bind to force single CPU */
	    processor_bind(P_PID, P_MYID, cpuid, NULL);
	}
#endif /* OS(Solaris) */

#ifdef SOLARIS
	sema_init(&global_sema_lock, count, USYNC_THREAD, NULL);
#endif
#ifdef POSIX
	pthread_attr_init(&attr);

    #ifdef BOUND
	pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM);
    #endif

	sem_init(&global_sema_lock, 0, count);
#endif

#if 0
	if ((s5_sema_id = semget(IPC_PRIVATE, 1, 0600)) == -1)
		perror("semget: IPC_PRIVATE");

	arg.val = count;
	if (semctl(s5_sema_id, 0, SETVAL, arg) == -1)
		perror("semctl: SETVAL");
#endif

	resolve_symbols();

	i = locktest();
#if 0
	if (semctl(s5_sema_id, 0, IPC_RMID) == -1)
		perror("semctl: IPC_RMID");
#endif

	close_file(fid);

#ifdef SELFTEST
        finish_prof();
#endif

	return 0;
}
Exemple #4
0
int main(int argc, char**argv)
{
  // Set up our exception signal handler for asserts and segfaults.
  signal(SIGABRT, signal_handler);
  signal(SIGSEGV, signal_handler);

  sem_init(&term_sem, 0, 0);
  signal(SIGTERM, terminate_handler);

  AstaireResolver* astaire_resolver = NULL;

  struct options options;
  options.local_host = "127.0.0.1";
  options.http_address = "0.0.0.0";
  options.http_port = 11888;
  options.http_threads = 1;
  options.http_worker_threads = 50;
  options.homestead_http_name = "homestead-http-name.unknown";
  options.digest_timeout = 300;
  options.home_domain = "home.domain";
  options.sas_system_name = "";
  options.access_log_enabled = false;
  options.log_to_file = false;
  options.log_level = 0;
  options.astaire = "";
  options.cassandra = "";
  options.memcached_write_format = MemcachedWriteFormat::JSON;
  options.target_latency_us = 100000;
  options.max_tokens = 1000;
  options.init_token_rate = 100.0;
  options.min_token_rate = 10.0;
  options.min_token_rate = 0.0;
  options.exception_max_ttl = 600;
  options.astaire_blacklist_duration = AstaireResolver::DEFAULT_BLACKLIST_DURATION;
  options.http_blacklist_duration = HttpResolver::DEFAULT_BLACKLIST_DURATION;
  options.pidfile = "";
  options.daemon = false;

  if (init_logging_options(argc, argv, options) != 0)
  {
    return 1;
  }

  Utils::daemon_log_setup(argc,
                          argv,
                          options.daemon,
                          options.log_directory,
                          options.log_level,
                          options.log_to_file);

  std::stringstream options_ss;

  for (int ii = 0; ii < argc; ii++)
  {
    options_ss << argv[ii];
    options_ss << " ";
  }

  std::string options_str = "Command-line options were: " + options_ss.str();

  TRC_INFO(options_str.c_str());

  if (init_options(argc, argv, options) != 0)
  {
    return 1;
  }

  if (options.pidfile != "")
  {
    int rc = Utils::lock_and_write_pidfile(options.pidfile);
    if (rc == -1)
    {
      // Failure to acquire pidfile lock
      TRC_ERROR("Could not write pidfile - exiting");
      return 2;
    }
  }

  start_signal_handlers();

  AccessLogger* access_logger = NULL;

  if (options.access_log_enabled)
  {
    TRC_STATUS("Access logging enabled to %s", options.access_log_directory.c_str());
    access_logger = new AccessLogger(options.access_log_directory);
  }

  HealthChecker* hc = new HealthChecker();
  hc->start_thread();

  // Create an exception handler. The exception handler doesn't need
  // to quiesce the process before killing it.
  exception_handler = new ExceptionHandler(options.exception_max_ttl,
                                           false,
                                           hc);

  // Initialise the SasService, to read the SAS config to pass into SAS::Init
  SasService* sas_service = new SasService(options.sas_system_name, "memento", false);

  // Ensure our random numbers are unpredictable.
  unsigned int seed;
  seed = time(NULL) ^ getpid();
  srand(seed);

  // Create a DNS resolver.
  int af = AF_INET;
  struct in6_addr dummy_addr;
  if (inet_pton(AF_INET6, options.local_host.c_str(), &dummy_addr) == 1)
  {
    TRC_DEBUG("Local host is an IPv6 address");
    af = AF_INET6;
  }

  DnsCachedResolver* dns_resolver = new DnsCachedResolver("127.0.0.1");

  // Create alarm and communication monitor objects for the conditions
  // reported by memento.
  AlarmManager* alarm_manager = new AlarmManager();
  CommunicationMonitor* astaire_comm_monitor = new CommunicationMonitor(new Alarm(alarm_manager,
                                                                                  "memento",
                                                                                  AlarmDef::MEMENTO_ASTAIRE_COMM_ERROR,
                                                                                  AlarmDef::CRITICAL),
                                                                        "Memento",
                                                                        "Astaire");
  CommunicationMonitor* hs_comm_monitor = new CommunicationMonitor(new Alarm(alarm_manager,
                                                                             "memento",
                                                                             AlarmDef::MEMENTO_HOMESTEAD_COMM_ERROR,
                                                                             AlarmDef::CRITICAL),
                                                                   "Memento",
                                                                   "Homestead");
  CommunicationMonitor* cass_comm_monitor = new CommunicationMonitor(new Alarm(alarm_manager,
                                                                               "memento",
                                                                               AlarmDef::MEMENTO_CASSANDRA_COMM_ERROR,
                                                                               AlarmDef::CRITICAL),
                                                                     "Memento",
                                                                     "Cassandra");

  astaire_resolver = new AstaireResolver(dns_resolver,
                                         af,
                                         options.astaire_blacklist_duration);

  // Default the astaire hostname to the loopback IP
  if (options.astaire == "")
  {
    if (af == AF_INET6)
    {
      options.astaire = "[::1]";
    }
    else
    {
      options.astaire = "127.0.0.1";
    }
  }

  memcached_store = (Store*)new TopologyNeutralMemcachedStore(options.astaire,
                                                              astaire_resolver,
                                                              false,
                                                              astaire_comm_monitor);

  AuthStore::SerializerDeserializer* serializer;
  std::vector<AuthStore::SerializerDeserializer*> deserializers;

  if (options.memcached_write_format == MemcachedWriteFormat::JSON)
  {
    serializer = new AuthStore::JsonSerializerDeserializer();
  }
  else
  {
    serializer = new AuthStore::BinarySerializerDeserializer();
  }

  deserializers.push_back(new AuthStore::JsonSerializerDeserializer());
  deserializers.push_back(new AuthStore::BinarySerializerDeserializer());

  AuthStore* auth_store = new AuthStore(memcached_store,
                                        serializer,
                                        deserializers,
                                        options.digest_timeout);

  LoadMonitor* load_monitor = new LoadMonitor(options.target_latency_us,
                                              options.max_tokens,
                                              options.init_token_rate,
                                              options.min_token_rate,
                                              options.max_token_rate);

  LastValueCache* stats_aggregator = new MementoLVC();

  // Create a HTTP specific resolver.
  HttpResolver* http_resolver = new HttpResolver(dns_resolver,
                                                 af,
                                                 options.http_blacklist_duration);

  HttpClient* http_client = new HttpClient(false,
                                           http_resolver,
                                           nullptr,
                                           load_monitor,
                                           SASEvent::HttpLogLevel::PROTOCOL,
                                           hs_comm_monitor);

  HttpConnection* http_connection = new HttpConnection(options.homestead_http_name,
                                                       http_client);

  HomesteadConnection* homestead_conn = new HomesteadConnection(http_connection);

  // Default to a 30s blacklist/graylist duration and port 9160
  CassandraResolver* cass_resolver = new CassandraResolver(dns_resolver,
                                                           af,
                                                           30,
                                                           30,
                                                           9160);
  // Default the cassandra hostname to the loopback IP
  if (options.cassandra == "")
  {
    if (af == AF_INET6)
    {
      options.cassandra = "[::1]";
    }
    else
    {
      options.cassandra = "127.0.0.1";
    }
  }

  // Create and start the call list store.
  CallListStore::Store* call_list_store = new CallListStore::Store();
  call_list_store->configure_connection(options.cassandra, 9160, cass_comm_monitor, cass_resolver);

  // Test Cassandra connectivity.
  CassandraStore::ResultCode store_rc = call_list_store->connection_test();

  if (store_rc == CassandraStore::OK)
  {
    // Store can connect to Cassandra, so start it.
    store_rc = call_list_store->start();
  }

  if (store_rc != CassandraStore::OK)
  {
    TRC_ERROR("Unable to create call list store (RC = %d)", store_rc);
    exit(3);
  }

  HttpStackUtils::SimpleStatsManager stats_manager(stats_aggregator);
  HttpStack* http_stack = new HttpStack(options.http_threads,
                                        exception_handler,
                                        access_logger,
                                        load_monitor,
                                        &stats_manager);

  CallListTask::Config call_list_config(auth_store, homestead_conn, call_list_store, options.home_domain, stats_aggregator, hc, options.api_key);

  MementoSasLogger sas_logger;
  HttpStackUtils::PingHandler ping_handler;
  HttpStackUtils::SpawningHandler<CallListTask, CallListTask::Config> call_list_handler(&call_list_config, &sas_logger);
  HttpStackUtils::HandlerThreadPool pool(options.http_worker_threads, exception_handler);

  try
  {
    http_stack->initialize();
    http_stack->bind_tcp_socket(options.http_address,
                                options.http_port);
    http_stack->register_handler("^/ping$", &ping_handler);
    http_stack->register_handler("^/org.projectclearwater.call-list/users/[^/]*/call-list.xml$",
                                    pool.wrap(&call_list_handler));
    http_stack->start();
  }
  catch (HttpStack::Exception& e)
  {
    TRC_ERROR("Failed to initialize HttpStack stack - function %s, rc %d", e._func, e._rc);
    exit(2);
  }

  TRC_STATUS("Start-up complete - wait for termination signal");
  sem_wait(&term_sem);
  TRC_STATUS("Termination signal received - terminating");

  try
  {
    http_stack->stop();
    http_stack->wait_stopped();
  }
  catch (HttpStack::Exception& e)
  {
    TRC_ERROR("Failed to stop HttpStack stack - function %s, rc %d", e._func, e._rc);
  }

  call_list_store->stop();
  call_list_store->wait_stopped();

  hc->stop_thread();

  delete homestead_conn; homestead_conn = NULL;
  delete http_connection; http_connection = NULL;
  delete http_client; http_client = NULL;
  delete call_list_store; call_list_store = NULL;
  delete http_resolver; http_resolver = NULL;
  delete cass_resolver; cass_resolver = NULL;
  delete dns_resolver; dns_resolver = NULL;
  delete load_monitor; load_monitor = NULL;
  delete auth_store; auth_store = NULL;
  delete call_list_store; call_list_store = NULL;
  delete astaire_resolver; astaire_resolver = NULL;
  delete memcached_store; memcached_store = NULL;
  delete exception_handler; exception_handler = NULL;
  delete hc; hc = NULL;
  delete http_stack; http_stack = NULL;

  delete astaire_comm_monitor; astaire_comm_monitor = NULL;
  delete hs_comm_monitor; hs_comm_monitor = NULL;
  delete cass_comm_monitor; cass_comm_monitor = NULL;
  delete alarm_manager; alarm_manager = NULL;

  delete sas_service; sas_service = NULL;

  signal(SIGTERM, SIG_DFL);
  sem_destroy(&term_sem);
}
int main() {

    // 初始化线程同步变量
    sem_init(&sem,0,0);

    // 从环境变量中读取登录信息
    char * CTP_FrontAddress = getenv("CTP_FrontAddress");
    if ( CTP_FrontAddress == NULL ) {
        printf("环境变量CTP_FrontAddress没有设置\n");
        return(0);
    }

    char * CTP_BrokerId = getenv("CTP_BrokerId");
    if ( CTP_BrokerId == NULL ) {
        printf("环境变量CTP_BrokerId没有设置\n");
        return(0);
    }
    strcpy(userLoginField.BrokerID,CTP_BrokerId);

    char * CTP_UserId = getenv("CTP_UserId");
    if ( CTP_UserId == NULL ) {
        printf("环境变量CTP_UserId没有设置\n");
        return(0);
    }
    strcpy(userLoginField.UserID,CTP_UserId);

    char * CTP_Password = getenv("CTP_Password");
    if ( CTP_Password == NULL ) {
        printf("环境变量CTP_Password没有设置\n");
        return(0);
    }
    strcpy(userLoginField.Password,CTP_Password);

    // 创建TraderAPI和回调响应控制器的实例
    CThostFtdcTraderApi *pTraderApi = CThostFtdcTraderApi::CreateFtdcTraderApi();
    CTraderHandler traderHandler = CTraderHandler();
    CTraderHandler * pTraderHandler = &traderHandler;
    pTraderApi->RegisterSpi(pTraderHandler);

    // 设置服务器地址
    pTraderApi->RegisterFront(CTP_FrontAddress);
    // 链接交易系统
    pTraderApi->Init();
    // 等待服务器发出登录消息
    sem_wait(&sem);
    // 发出登陆请求
    pTraderApi->ReqUserLogin(&userLoginField, requestID++);
    // 等待登录成功消息
    sem_wait(&sem);

    ////////////////////////////////////////////////////////////////////////////////////////////////
    ///请求查询资金账户
    ///////////////////////////////////////////////////////////////////////////////////////////////
    // 定义调用API的数据结构
    CThostFtdcQryTradingAccountField requestData;
    // 确保没有初始化的数据不会被访问
    memset(&requestData,0,sizeof(requestData));
    // 为调用结构题设置参数信息
    ///经纪公司代码 TThostFtdcBrokerIDType char[11]
    strcpy(requestData.BrokerID,"");
    ///投资者代码 TThostFtdcInvestorIDType char[13]
    strcpy(requestData.InvestorID,"");
    ///币种代码 TThostFtdcCurrencyIDType char[4]
    strcpy(requestData.CurrencyID,"");


    // 调用API,并等待响应函数返回
    int result = pTraderApi->ReqQryTradingAccount(&requestData,requestID++);
    sem_wait(&sem);

    /////////////////////////////////////////////////////////////////////////////////////////////////


    // 拷贝用户登录信息到登出信息
    strcpy(userLogoutField.BrokerID,userLoginField.BrokerID);
    strcpy(userLogoutField.UserID, userLoginField.UserID);
    pTraderApi->ReqUserLogout(&userLogoutField, requestID++);

    // 等待登出成功
    sem_wait(&sem);

    printf("主线程执行完毕!\n");
    return(0);

}
Exemple #6
0
//添加一个新的连接目标
static int add_list(st_sock* sts, s_link* pslink)
{
	int res = EX_UDP_ERROR;
	int id = 0;
	st_idList* idList = NULL;

	if (list_empty(&sts->listIDAllocationHead))
	{
		LOG_WRITE_POS(LOG_ERR, "ERROR: More than the maximum number of links !\r\n");
		free(pslink);
		return EX_UDP_ERROR;
	}
	idList = (st_idList*)list_begin(&sts->listIDAllocationHead);
	id = idList->id;
	list_erase(&idList->list);

	//初始从第一个序号开始读和发送
	pslink->SeqRead = 1;
	pslink->SeqMaxSend = 1;
	pslink->SeqCheckSend = 0;
	pslink->timeoutCheckLack.tv_sec = 0;
	pslink->timeoutCheckLack.tv_usec = CHECK_INTERVAL_INIT;
	pslink->paArrayRecv[0].head.seq = 1;
	pslink->paArraySend[0].head.seq = 1;
	pslink->timeout_times = 1;
	pslink->timeout.tv_sec = 0;
	pslink->tsWaitTime = sts->tsWaitTime;
	gettimeofday(&pslink->timeoutSend, NULL);
	//pslink->timeoutReportLack = pslink->timeoutSend;
	pslink->linkState = 0;

	printf_debug2("&pslink=%x, pslink=%x, pslink->SeqRead=%d\n", &pslink, pslink, pslink->SeqRead);
	
	//初始化互斥量,使用默认的互斥量属性
	res = sem_init(&pslink->semRecvList, 0, 1);
	if(res != 0)  
	{
		LOG_WRITE_POS(LOG_ERR, "sem_init failed\n");
		exit(EXIT_FAILURE);  
	}

	res = sem_init(&pslink->semSendList, 0, 1);
	if(res != 0)  
	{  
		LOG_WRITE_POS(LOG_ERR, "sem_init failed\n");  
		exit(EXIT_FAILURE);  
	}

	res = sem_init(&pslink->semRecvListMutex, 0, 1);
	if(res != 0)  
	{
		LOG_WRITE_POS(LOG_ERR, "sem_init failed\n");
		exit(EXIT_FAILURE);  
	}

	res = sem_init(&pslink->semSendListMutex, 0, 1);
	if(res != 0)  
	{  
		LOG_WRITE_POS(LOG_ERR, "sem_init failed\n");  
		exit(EXIT_FAILURE);  
	}

	pslink->id = id;
	sts->pLinkIDArray[id] = pslink;
	list_push_back(&sts->list, &pslink->list);
	LOG_WRITE_POS(LOG_NOTICE, "Add connection id. id=%d, ip=%s, port=%d, sock=%d\r\n", pslink->id, inet_ntoa(*(struct in_addr*)&pslink->ip), pslink->port, pslink->socket);
	sem_post(&sts->semAccept);
	sem_post(&sts->semListen);
	printf_debug2("add_list id=%d\r\n", pslink->id);
	return EX_UDP_OK;
}
Exemple #7
0
void priority_inheritance(void)
{
#if defined(CONFIG_PRIORITY_INHERITANCE) && !defined(CONFIG_DISABLE_SIGNALS) && !defined(CONFIG_DISABLE_PTHREAD)
	pthread_t lowpri[NLOWPRI_THREADS];
	pthread_t medpri;
	pthread_t highpri[NHIGHPRI_THREADS];
	pthread_addr_t result;
	pthread_attr_t attr;
	struct sched_param sparam;
	int my_pri;
	int status;
	int i;

	printf("priority_inheritance: Started\n");

	g_middlestate = NOTSTARTED;
	for (i = 0; i < NHIGHPRI_THREADS; i++) {
		g_highstate[i] = NOTSTARTED;
	}
	for (i = 0; i < NLOWPRI_THREADS; i++) {
		g_lowstate[i]  = NOTSTARTED;
	}

	status = sched_getparam(getpid(), &sparam);
	if (status != 0) {
		printf("priority_inheritance: sched_getparam failed\n");
		sparam.sched_priority = PTHREAD_DEFAULT_PRIORITY;
	}
	my_pri  = sparam.sched_priority;

	g_highpri = sched_get_priority_max(SCHED_FIFO);
	g_lowpri = sched_get_priority_min(SCHED_FIFO);
	g_medpri = my_pri - 1;

	sem_init(&g_sem, 0, NLOWPRI_THREADS);
	dump_nfreeholders("priority_inheritance:");

	/* Start the low priority threads */

	for (i = 0; i < NLOWPRI_THREADS; i++) {
		int threadno = i + 1;
		printf("priority_inheritance: Starting lowpri_thread-%d (of %d) at %d\n",
			   threadno, NLOWPRI_THREADS, g_lowpri);
		status = pthread_attr_init(&attr);
		if (status != 0) {
			printf("priority_inheritance: pthread_attr_init failed, status=%d\n", status);
		}
		sparam.sched_priority = g_lowpri;
		status = pthread_attr_setschedparam(&attr, & sparam);
		if (status != OK) {
			printf("priority_inheritance: pthread_attr_setschedparam failed, status=%d\n", status);
		} else {
			printf("priority_inheritance: Set lowpri_thread-%d priority to %d\n",
				   threadno, sparam.sched_priority);
		}

		status = pthread_create(&lowpri[i], &attr, lowpri_thread, (void *)threadno);
		if (status != 0) {
			printf("priority_inheritance: pthread_create failed, status=%d\n", status);
		}
	}
	printf("priority_inheritance: Waiting...\n");
	sleep(2);
	dump_nfreeholders("priority_inheritance:");

	/* Start the medium priority thread */

	printf("priority_inheritance: Starting medpri_thread at %d\n", g_medpri);
	status = pthread_attr_init(&attr);
	if (status != 0) {
		printf("priority_inheritance: pthread_attr_init failed, status=%d\n", status);
	}

	sparam.sched_priority = g_medpri;
	status = pthread_attr_setschedparam(&attr, & sparam);
	if (status != OK) {
		printf("priority_inheritance: pthread_attr_setschedparam failed, status=%d\n", status);
	} else {
		printf("priority_inheritance: Set medpri_thread priority to %d\n", sparam.sched_priority);
	}
	FFLUSH();

	status = pthread_create(&medpri, &attr, medpri_thread, NULL);
	if (status != 0) {
		printf("priority_inheritance: pthread_create failed, status=%d\n", status);
	}
	printf("priority_inheritance: Waiting...\n");
	sleep(1);
	dump_nfreeholders("priority_inheritance:");

	/* Start the high priority threads */

	for (i = 0; i < NHIGHPRI_THREADS; i++) {
		int threadno = i + 1;
		printf("priority_inheritance: Starting highpri_thread-%d (of %d) at %d\n",
			   threadno, NHIGHPRI_THREADS, g_highpri);
		status = pthread_attr_init(&attr);
		if (status != 0) {
			printf("priority_inheritance: pthread_attr_init failed, status=%d\n", status);
		}

		sparam.sched_priority = g_highpri - i;
		status = pthread_attr_setschedparam(&attr, & sparam);
		if (status != OK) {
			printf("priority_inheritance: pthread_attr_setschedparam failed, status=%d\n", status);
		} else {
			printf("priority_inheritance: Set highpri_thread-%d priority to %d\n",
				   threadno, sparam.sched_priority);
		}
		FFLUSH();

		status = pthread_create(&highpri[i], &attr, highpri_thread, (void *)threadno);
		if (status != 0) {
			printf("priority_inheritance: pthread_create failed, status=%d\n", status);
		}
	}
	dump_nfreeholders("priority_inheritance:");
	FFLUSH();

	/* Wait for all thread instances to complete */

	for (i = 0; i < NHIGHPRI_THREADS; i++) {
		printf("priority_inheritance: Waiting for highpri_thread-%d to complete\n", i + 1);
		FFLUSH();
		(void)pthread_join(highpri[i], &result);
		dump_nfreeholders("priority_inheritance:");
	}
	printf("priority_inheritance: Waiting for medpri_thread to complete\n");
	FFLUSH();
	(void)pthread_join(medpri, &result);
	dump_nfreeholders("priority_inheritance:");
	for (i = 0; i < NLOWPRI_THREADS; i++) {
		printf("priority_inheritance: Waiting for lowpri_thread-%d to complete\n", i + 1);
		FFLUSH();
		(void)pthread_join(lowpri[i], &result);
		dump_nfreeholders("priority_inheritance:");
	}

	printf("priority_inheritance: Finished\n");
	sem_destroy(&g_sem);
	dump_nfreeholders("priority_inheritance:");
	FFLUSH();
#endif /* CONFIG_PRIORITY_INHERITANCE && !CONFIG_DISABLE_SIGNALS && !CONFIG_DISABLE_PTHREAD */
}
Exemple #8
0
Semaphore::Semaphore(int initial = 0) {
	sem_init(&sem,0,initial);
}
Int main (Int argc, Char * argv [])
{
    pid_t   child_pid;
    pid_t   child_sid;
    Int     status      = 0;
    Bool    daemon      = TRUE;
    Int     o;
    Int     i;
    Char  * images []   = {NULL, NULL};
    Int     numImages   = sizeof (images) / sizeof (images [0]);

    if (isDaemonRunning (argv [0])) {
        Osal_printf ("Multiple instances of syslink_daemon.out are not "
                     "supported!\n");
        return (-1);
    }

    /* Determine args */
    while ((o = getopt (argc, argv, ":fs:a:")) != -1) {
        switch (o) {
        case 's':
            images [0] = optarg;
            break;
        case 'a':
            images [1] = optarg;
            break;
        case 'f':
            daemon = FALSE;
            break;
        case ':':
            status = -1;
            Osal_printf ("Option -%c requires an operand\n", optopt);
            break;
        case '?':
            status = -1;
            Osal_printf ("Unrecognized option: -%c\n", optopt);
            break;
        }
    }

    for (i = 0; optind < argc; optind++) {
        while (i < numImages && images [i]) i++;
        if (i == numImages) {
            printUsage ();
        }
        images [i++] = argv [optind];
    }

    for (i = 0; i < numImages; i++) {
        if (images [i] && access (images [i], R_OK)) {
            Osal_printf ("Error opening %s\n", images [i]);
            printUsage ();
        }
    }

    if (status || optind < argc || !images [0]) {
        printUsage ();
    }

    /* Process will be daemonised if daemon flag is true */
    if (daemon) {
        Osal_printf ("Spawning SysLink Daemon...\n");
        /* Fork off the parent process */
        child_pid = fork ();
        if (child_pid < 0) {
            Osal_printf ("Spawn daemon failed!\n");
            exit (EXIT_FAILURE);     /* Failure */
        }
        /* If we got a good PID, then we can exit the parent process. */
        if (child_pid > 0) {
            exit (EXIT_SUCCESS);    /* Success */
        }

        /* Change file mode mask */
        umask (0);

        /* Create a new SID for the child process */
        child_sid = setsid ();
        if (child_sid < 0) {
            exit (EXIT_FAILURE);     /* Failure */
        }

        /* Change the current working directory */
        if ((chdir("/")) < 0) {
            exit (EXIT_FAILURE);     /* Failure */
        }
    }

    /* Setup the signal handlers */
    if (signal (SIGINT, signal_handler) == SIG_ERR) {
        Osal_printf ("SIGINT registration failed!");
    }
    if (signal (SIGTERM, signal_handler) == SIG_ERR) {
        Osal_printf ("SIGTERM registration failed!");
    }

    while (restart) {
        restart = FALSE;
        isSysM3Event = FALSE;
        isAppM3Event = FALSE;

        sem_init (&semDaemonWait, 0, 0);

        status = ipcSetup (images [0], images [1]);
        if (status < 0) {
            Osal_printf ("ipcSetup failed!\n");
            sem_destroy (&semDaemonWait);
            return (-1);
        }
        Osal_printf ("ipcSetup succeeded!\n");

        /* Create the SysM3 fault handler thread */
        Osal_printf ("Create SysM3 event handler thread\n");
        status = pthread_create (&sysM3EvtHandlerThrd, NULL,
                                    (Void *)&sysM3EventHandler, NULL);

        if (status) {
            Osal_printf ("Error Creating SysM3 event handler thread:%d\n",
                            status);
            ipcCleanup ();
            sem_destroy (&semDaemonWait);
            exit (EXIT_FAILURE);
        }
        /* Only if AppM3 image is specified */
        if (images [1]) {
            /* Create an AppM3 fault handler thread */
            Osal_printf ("Create AppM3 event handler thread\n");
            status = pthread_create (&appM3EvtHandlerThrd, NULL,
                                        (Void *)&appM3EventHandler, NULL);
            if (status) {
                Osal_printf ("Error Creating AppM3 event handler thread:%d\n",
                                status);
                pthread_kill (sysM3EvtHandlerThrd, SIGTERM);
                sysM3EvtHandlerThrd = 0;
                ipcCleanup ();
                sem_destroy (&semDaemonWait);
                exit (EXIT_FAILURE);
            }
        }

        /* Wait for any event handler thread to be unblocked */
        sem_wait (&semDaemonWait);

        /* Clean up event handler threads */
        if (sysM3EvtHandlerThrd) {
            if (isSysM3Event) {
                status = pthread_join (sysM3EvtHandlerThrd, NULL);
                Osal_printf ("pthread_join SysM3 Thread = %d\n", status);
            }
            else {
                if (pthread_kill (sysM3EvtHandlerThrd, SIGTERM) == 0) {
                    status = pthread_join (sysM3EvtHandlerThrd, NULL);
                    Osal_printf ("pthread_kill & join SysM3 Thread = %d\n",
                                    status);
                }
            }
            sysM3EvtHandlerThrd = 0;
        }
        if (appM3EvtHandlerThrd) {
            if (isAppM3Event) {
                status = pthread_join (appM3EvtHandlerThrd, NULL);
                Osal_printf ("pthread_join AppM3 Thread = %d\n", status);
            }
            else {
                if (pthread_kill (appM3EvtHandlerThrd, SIGTERM) == 0) {
                    status = pthread_join (appM3EvtHandlerThrd, NULL);
                    Osal_printf ("pthread_kill & join AppM3 Thread = %d\n",
                                    status);
                }
            }
            appM3EvtHandlerThrd = 0;
        }

        /* IPC_Cleanup function */
        ipcCleanup ();

        sem_destroy (&semDaemonWait);
    }

    return 0;
}
Exemple #10
0
/***** main program *****/
int main(int argc, char *argv[])
{
	pthread_mutex_t mtx_null, mtx_def;
	pthread_mutexattr_t mattr;
	pthread_t thr;
	
	pthread_mutex_t * tab_mutex[2]={&mtx_null, &mtx_def};
	int tab_res[2][3]={{0,0,0},{0,0,0}};
	
	int ret;
	void * th_ret;
	
	int i;
	
	output_init();
	
	#if VERBOSE >1
	output("Test starting...\n");
	#endif
	
	/* We first initialize the two mutexes. */
	if ((ret=pthread_mutex_init(&mtx_null, NULL)))
	{ UNRESOLVED(ret, "NULL mutex init"); }
	
	if ((ret=pthread_mutexattr_init(&mattr)))
	{ UNRESOLVED(ret, "Mutex attribute init"); }
	if ((ret=pthread_mutex_init(&mtx_def, &mattr)))
	{ UNRESOLVED(ret, "Default attribute mutex init"); }
	
	if ((ret=pthread_mutexattr_destroy(&mattr)))
	{ UNRESOLVED(ret, "Mutex attribute destroy"); }

	
	if ((ret=sem_init(&semA, 0, 0)))
	{ UNRESOLVED(errno, "Sem A init"); }
	if ((ret=sem_init(&semB, 0, 0)))
	{ UNRESOLVED(errno, "Sem B init"); }

	#if VERBOSE >1
	output("Data initialized...\n");
	#endif
	
	
	/* OK let's go for the first part of the test : abnormals unlocking */
	
	/* We first check if unlocking an unlocked mutex returns an error. */
	retval = pthread_mutex_unlock(tab_mutex[0]);
	ret = pthread_mutex_unlock(tab_mutex[1]);
	#if VERBOSE >0
	output("Results for unlock issue #1:\n mutex 1 unlocking returned %i\n mutex 2 unlocking returned %i\n",
				retval, ret);
	#endif
	if (ret != retval)
	{
		FAILED("Unlocking an unlocked mutex behaves differently.");
	}
	
    /* Now we focus on unlocking a mutex lock by another thread */
	for (i=0; i<2; i++)
	{
		p_mtx = tab_mutex[i];
		tab_res[i][0]=0;
		tab_res[i][1]=0;
		tab_res[i][2]=0;
				
		#if VERBOSE >1
		output("Creating thread (unlock)...\n");
		#endif

		if ((ret = pthread_create(&thr, NULL, unlock_issue, NULL)))
		{ UNRESOLVED(ret, "Unlock issue thread create"); }
		
		if ((ret = sem_wait(&semA)))
		{ UNRESOLVED(errno, "Sem A wait failed for unlock issue."); }
	
		#if VERBOSE >1
		output("Unlocking in parent...\n");
		#endif
		retval = pthread_mutex_unlock(p_mtx);
		
		if ((ret = sem_post(&semB)))
		{ UNRESOLVED(errno, "Sem B post failed for unlock issue."); }
		
		if ((ret=pthread_join(thr, &th_ret)))
		{ UNRESOLVED(ret, "Join thread"); }

		#if VERBOSE >1
		output("Thread joined successfully...\n");
		#endif
		
		tab_res[i][0] = retval;
	}
	#if VERBOSE >0
	output("Results for unlock issue #2:\n mutex 1 returned %i\n mutex 2 returned %i\n",
				tab_res[0][0],tab_res[1][0]);
	#endif
	
	if (tab_res[0][0] != tab_res[1][0])
	{
		FAILED("Unlocking an unowned mutex behaves differently.");
	}

	
	/* We now are going to test the deadlock issue
	 */
	
	/* We start with testing the NULL mutex features */
	for (i=0; i<2; i++)
	{
		p_mtx = tab_mutex[i];
		tab_res[i][0]=0;
		tab_res[i][1]=0;
		tab_res[i][2]=0;
				
		#if VERBOSE >1
		output("Creating thread (deadlk)...\n");
		#endif

		if ((ret = pthread_create(&thr, NULL, deadlk_issue, NULL)))
		{ UNRESOLVED(ret, "Deadlk_issue thread create"); }
		
		/* Now we are waiting the thread is ready to relock the mutex. */
		if ((ret=sem_wait(&semA)))
		{ UNRESOLVED(errno, "Sem wait"); }
		
		/* To ensure thread runs until second lock, we yield here */
		sched_yield();
		
		/* OK, now we cancel the thread */
		canceled=0;
		#if VERBOSE >1
		output("Cancel thread...\n");
		#endif
		if (returned ==0)
			if ((ret=pthread_cancel(thr)))
			{ UNRESOLVED(ret, "Cancel thread (deadlk_issue)"); }

		#if VERBOSE >1
		output("Thread canceled...\n");
		#endif
		
		if ((ret=pthread_join(thr, &th_ret)))
		{ UNRESOLVED(ret, "Join thread"); }

		#if VERBOSE >1
		output("Thread joined successfully...\n");
		#endif
		
		tab_res[i][2] = retval;
		tab_res[i][1] = returned;
		tab_res[i][0] = canceled;
	}
	
	/* Now we parse the results */
	#if VERBOSE >0
	output("Results for deadlock issue:\n mutex 1 \t%s\t%s%i\n mutex 2 \t%s\t%s%i\n",
				tab_res[0][0]?"deadlock" : "no deadlock",
				tab_res[0][1]?"returned " : "did not return ",
				tab_res[0][2],
				tab_res[1][0]?"deadlock" : "no deadlock",
				tab_res[1][1]?"returned " : "did not return ",
				tab_res[1][2]);
	#endif
	
	if (tab_res[0][0] != tab_res[1][0])
	{ FAILED("One mutex deadlocks, not the other"); }
	
	if (tab_res[0][1] != tab_res[1][1])
	{ UNRESOLVED(tab_res[0][1], "Abnormal situation!"); }
	
	if ((tab_res[0][1] == 1) && (tab_res[0][2] != tab_res[1][2]))
	{ FAILED("The locks returned different error codes."); }
		
	PASSED;
} 
Exemple #11
0
int standby_list_init(standby_list *s, int size) {
    s->head = NULL;
    s->tail = NULL;
    s->avail_size = size;
    return sem_init(&s->lock, 1);
}
Exemple #12
0
void Sem_init(sem_t *sem, int pshared, unsigned int value) 
{
    if (sem_init(sem, pshared, value) < 0)
	unix_error("Sem_init error");
}
//sem_getvalue on a semaphore waited on n times
TInt CTestSemgetvalue::TestSem318( )
	{
	
	int retval = 0;
	int errsum=0, err = 0;
	ThreadData lThreadData;
	
	sem_t lSignalSemaphore;
	sem_t lSuspendSemaphore;

	sem_t           lTestSemaphore;
	pthread_mutex_t lTestMutex;
	pthread_cond_t  lTestCondVar;
	pthread_condattr_t  lCondAttr;
	pthread_mutexattr_t lTestMutexAttr;

	pthread_mutexattr_t defaultattr;
	pthread_mutexattr_t errorcheckattr;
	pthread_mutexattr_t recursiveattr;

	pthread_mutexattr_init(&defaultattr);
	pthread_mutexattr_init(&errorcheckattr);
	pthread_mutexattr_init(&recursiveattr);

	pthread_mutexattr_settype(&errorcheckattr,PTHREAD_MUTEX_ERRORCHECK);
	pthread_mutexattr_settype(&recursiveattr,PTHREAD_MUTEX_RECURSIVE);


	pthread_mutex_t l_staticmutex = PTHREAD_MUTEX_INITIALIZER;
	pthread_mutex_t l_errorcheckmutex = PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP;
	pthread_mutex_t l_recursivemutex = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
    pthread_cond_t  l_staticcondvar = PTHREAD_COND_INITIALIZER;

    CommonData lCommonData;
    lCommonData.iStaticMutex = &l_staticmutex;
	lCommonData.iErrorCheckMutex = &l_errorcheckmutex;
	lCommonData.iRecursiveMutex = &l_recursivemutex;
	lCommonData.iStaticCondVar = &l_staticcondvar;

	retval = sem_init(&lSignalSemaphore,0,0);
	if(retval != 0)
		{
		return retval;
		}

	retval = sem_init(&lSuspendSemaphore,0,0);
	if(retval != 0)
		{
		return retval;
		}

	lThreadData.iSignalSemaphore = &lSignalSemaphore;
	lThreadData.iSuspendSemaphore = &lSuspendSemaphore;
	lThreadData.iTestSemaphore   = &lTestSemaphore;
	lThreadData.iTestMutex       = &lTestMutex;
	lThreadData.iTestMutexAttr   = &lTestMutexAttr;
	lThreadData.iTestCondVar     = &lTestCondVar;
	lThreadData.iDefaultAttr     = &defaultattr;
	lThreadData.iErrorcheckAttr = &errorcheckattr;
	lThreadData.iRecursiveAttr   = &recursiveattr;

	lThreadData.iCondAttr        = &lCondAttr;
	for (int loop = 0; loop < EThreadMain; loop++)
		{
	    g_spinFlag[loop] = true;
		}
	lThreadData.iSuspending      = false;
	lThreadData.iSpinCounter     = 0;
	lThreadData.iCurrentCommand  = -1;
	lThreadData.iSelf            = EThreadMain;
	lThreadData.iValue           = 0;
	lThreadData.iRetValue        = 0;
	lThreadData.ierrno           = 0;
	lThreadData.iExpectederrno   = 0;
	lThreadData.iTimes           = 0;
	lThreadData.iStopped         = false;
	lThreadData.iCommonData      = &lCommonData;
	
	
	retval = SemInit(&lThreadData);
	
	fp=func1;
	retval = ThreadCreate(&lThreadData, (void*) EThread1);
	
	fp=func2;
	retval = ThreadCreate(&lThreadData, (void*) EThread2);
	
	fp=func3;
	retval = ThreadCreate(&lThreadData, (void*) EThread3);
	
	fp=func4;
	retval = ThreadCreate(&lThreadData, (void*) EThread4);
	
	WaitTillSuspended(&lThreadData, (void*) EThread1);
	WaitTillSuspended(&lThreadData, (void*) EThread2);
	WaitTillSuspended(&lThreadData, (void*) EThread3);
	WaitTillSuspended(&lThreadData, (void*) EThread4);
	retval = SemGetValue(&lThreadData);
	retval = CheckValue(&lThreadData,-4);
	retval = SemPost(&lThreadData);
	retval = SemPost(&lThreadData);
	retval = SemGetValue(&lThreadData);
	retval = CheckValue(&lThreadData,-2);
	retval = SemPost(&lThreadData);
	retval = SemPost(&lThreadData);
	retval = SemGetValue(&lThreadData);
	retval = ThreadDestroy(&lThreadData, (void*) EThread1);
	retval = ThreadDestroy(&lThreadData, (void*) EThread2);
	retval = ThreadDestroy(&lThreadData, (void*) EThread3);
	retval = ThreadDestroy(&lThreadData, (void*) EThread4);
	retval = SemDestroy(&lThreadData);
	StopThread(&lThreadData);
	
	err = pthread_cond_destroy(&l_staticcondvar);
	if(err != EINVAL)
		{
		errsum += err;
		}
    err = pthread_mutex_destroy(&l_recursivemutex);
	if(err != EINVAL)
		{
		errsum += err;
		}
    err = pthread_mutex_destroy(&l_errorcheckmutex);
	if(err != EINVAL)
		{
		errsum += err;
		}
    err = pthread_mutex_destroy(&l_staticmutex);
	if(err != EINVAL)
		{
		errsum += err;
		}
    err = pthread_mutexattr_destroy(&recursiveattr);
	if(err != EINVAL)
		{
		errsum += err;
		}
	err = pthread_mutexattr_destroy(&errorcheckattr);
	if(err != EINVAL)
		{
		errsum += err;
		}
	err = pthread_mutexattr_destroy(&defaultattr);
	if(err != EINVAL)
		{
		errsum += err;
		}
    err = sem_destroy(&lSignalSemaphore);
	if(err != EINVAL)
		{	
		errsum += err;
		}
	err = sem_destroy(&lSuspendSemaphore);
	if(err != EINVAL)
		{
		errsum += err;
		}

	return retval+errsum;
	}
Exemple #14
0
/****************************** INITIALIZATION *******************************/
int SCP_concurrent::init( bool bcount = false )
{
	/* lock global mutex */
	int result = pthread_mutex_lock( &mrh_mutex );
	int ret, ret_init;
	switch (result)
	{
	case 0:		// OK
		/* initialize binary semaphore with 0 */
		ret_init = sem_init( &(mr_event_table[ mn_id ]), 0, 0 );
		if(bcount)
		{
			/* iterator for count table */
			std::map<int, int>::iterator it;
			/* pick first element in the map */
			it = mr_count_table.begin();
			/* check if its count is valid number */
			if( (*it).second >= 0 )
			{
				/* runtime; init count variable with count
				 * variable of any other object (let it
				 * be first) */
				mr_count_table[ mn_id ] = (*it).second;
			}
			else
			{
				/* assign 0 in case of bad element */
				mr_count_table[ mn_id ] = 0;
			}
		}
		else
		{
			/* startup; init count variable with 0 */
			mr_count_table[ mn_id ] = 0;
		}
		/* init missedwakeups variable with 0 */
		mr_missed_wakeups[ mn_id ] = 0;
		/* release global mutex */
		ret = pthread_mutex_unlock( &mrh_mutex );
		switch(ret)
		{
		case 0:		/* success */
			/* if not zero,return semaphore initialization error */
			if( ret_init != 0 )
				return -3;
			else
				break;
		case EINVAL:
			/* mutex has not been properly initialized */
			return -2;
		default:
			/* other mutex problem */
			return -1;
		}

		break;
	case EINVAL:
		/* mutex has not been properly initialized */
		return -2;
	case EDEADLK:
		/* mutex is already owned by the calling thread */
		return -4;
	default:
		/* other mutex problem */
		return -1;
	}
	return 1;	/* return SUCCESS */
}
Int main (Int argc, Char * argv [])
{
    pthread_t           thread_sys; /* server thread object */
    pthread_t           thread_app; /* server thread object */
    pthread_t           thread_dsp; /* server thread object */
    Char              * log_file    = NULL;
    Bool                daemon      = TRUE;
    Int                 i;
    traceBufferParams   args_sys;
    traceBufferParams   args_app;
    traceBufferParams   args_dsp;

    /* parse cmd-line args */
    for (i = 1; i < argc; i++) {
        if (!strcmp ("-l", argv[i])) {
            if (++i >= argc) {
                printUsageExit (argv[0]);
            }
            log_file = argv[i];
        }
        else if (!strcmp ("-f", argv[i])) {
            daemon = FALSE;
        }
        else if (!strcmp ("-h", argv[i])) {
            printUsageExit (argv[0]);
        }
    }

    Osal_printf ("Spawning Ducati-Tesla Trace daemon...\n");

    if (daemon) {
        pid_t child_pid;
        pid_t child_sid;

        /* Fork off the parent process */
        child_pid = fork ();
        if (child_pid < 0) {
            Osal_printf ("Spawning Trace daemon failed!\n");
            exit (EXIT_FAILURE);     /* Failure */
        }

        /* If we got a good PID, then we can exit the parent process. */
        if (child_pid > 0) {
            exit (EXIT_SUCCESS);    /* Success */
        }

        /* Create a new SID for the child process */
        child_sid = setsid ();
        if (child_sid < 0) {
            Osal_printf ("setsid failed!\n");
            exit (EXIT_FAILURE);     /* Failure */
        }
    }

    if (log_file == NULL) {
        log = NULL;
    }
    else {
        if (strcmp (log_file, "stdout") == 0) {
            /* why do we need this?  It would be an issue when logging to file.. */
            /* Change file mode mask */
            umask (0);
            log = stdout;
        }
        else {
            log = fopen (log_file, "a+");
            if (log == NULL ) {
                Osal_printf("Failed to open file: %s\n", log_file);
                exit (EXIT_FAILURE);     /* Failure */
            }
        }
    }

    /* Change the current working directory */
    if ((chdir("/")) < 0) {
        Osal_printf ("chdir failed!\n");
        exit (EXIT_FAILURE);     /* Failure */
    }

    sem_init (&semPrint, 0, 1);

    UsrUtilsDrv_setup ();

    args_sys.coreName = "[SYSM3]: ";
    args_sys.bufferAddress = SYSM3_TRACE_BUFFER_PHYS_ADDR;
    args_app.coreName = "[APPM3]: ";
    args_app.bufferAddress = APPM3_TRACE_BUFFER_PHYS_ADDR;
    args_dsp.coreName = "[DSP]: ";
    args_dsp.bufferAddress = TESLA_TRACE_BUFFER_PHYS_ADDR;

    pthread_create (&thread_sys, NULL, (Void *)&printRemoteTraces,
                    (Void*)&args_sys);
    pthread_create (&thread_app, NULL, (Void *)&printRemoteTraces,
                    (Void*)&args_app);
    pthread_create (&thread_dsp, NULL, (Void *)&printRemoteTraces,
                    (Void*)&args_dsp);

    pthread_join (thread_sys, NULL);
    Osal_printf ("SysM3 trace thread exited\n");
    pthread_join (thread_app, NULL);
    Osal_printf ("AppM3 trace thread exited\n");
    pthread_join (thread_dsp, NULL);
    Osal_printf ("Tesla trace thread exited\n");

    UsrUtilsDrv_destroy ();

    sem_destroy (&semPrint);

    if (log != NULL && log != stdout ) {
        fclose(log);
    }

    return 0;
}
int main(void){

	int ret = -1;
	pthread_t thread_uartRec;
	int on = 1;



	//Initialize socket
	if((sockfd = socket(AF_INET, SOCK_STREAM,0))==-1){
		perror("socket");
		exit(1);
	};

	bzero(&servaddr, sizeof(servaddr));
	servaddr.sin_family = AF_INET;
	servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
	servaddr.sin_port = htons(SERV_PORT);

	if (setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) < 0){
		perror("sockopt error");
		exit(1);
	}

	if(bind(sockfd, (struct sockaddr *)&servaddr,sizeof(servaddr)) == -1){
		perror("bind error");
		exit(1);
	}
	if(listen(sockfd,10)<0){  
		perror("listen");  
		exit(1);  
	}
	//Initialize UART2
	if((uartfd=open_port(uartfd,4)) < 0)//打开串口 3
	{
		perror("open_port error1\n");
		exit(1);
	}
	if((ret=set_opt(uartfd,9600,8,'N',1)) < 0)//设置串口 9600 8 N 1
	{
		perror("set_opt error1\n");
		exit(1);
	}
	/*Initialize list*/
	clientListHead = initList();

	/*Intialize semaphore*/
	ret = sem_init(&uart_sem, 0, 1);
	if(ret == -1){
		perror("semaphore create fail!");
		exit(EXIT_FAILURE);
	}
	ret = pthread_create (&thread_uartRec, NULL, (void*)(&pthread_UART2WiFi), NULL);
	if (ret != 0)
	{
	 perror ("pthread_create error!");
	}




	while(1){
		pthread_t thread_id = 0;
		size_t len = sizeof(struct sockaddr);

		clifd = accept(sockfd, (struct sockaddr *)&cliaddr, &len);
		if(clifd < 0){
			perror("error accept\n");
		}

		appendList(clifd);
		/*Create Thread to send CMD from uart to wifi*/
		ret = pthread_create (&thread_id, NULL, (void*)(&pthread_wifiUart), (void*)(&clifd));
		if (ret != 0)
		{
		 perror ("pthread_create error!");
		}
	}



	ret = shutdown(sockfd,SHUT_WR);
	assert(ret != -1);
	return 0;
}
Exemple #17
0
int group_allocate(FAR struct task_tcb_s *tcb, uint8_t ttype)
{
  FAR struct task_group_s *group;
  int ret;

  DEBUGASSERT(tcb && !tcb->cmn.group);

  /* Allocate the group structure and assign it to the TCB */

  group = (FAR struct task_group_s *)kmm_zalloc(sizeof(struct task_group_s));
  if (!group)
    {
      return -ENOMEM;
    }

#if CONFIG_NFILE_STREAMS > 0 && (defined(CONFIG_BUILD_PROTECTED) || \
    defined(CONFIG_BUILD_KERNEL)) && defined(CONFIG_MM_KERNEL_HEAP)
  /* If this group is being created for a privileged thread, then all elements
   * of the group must be created for privileged access.
   */

  if ((ttype & TCB_FLAG_TTYPE_MASK) == TCB_FLAG_TTYPE_KERNEL)
    {
      group->tg_flags |= GROUP_FLAG_PRIVILEGED;
    }

  /* In a flat, single-heap build.  The stream list is allocated with the
   * group structure.  But in a kernel build with a kernel allocator, it
   * must be separately allocated using a user-space allocator.
   */

  group->tg_streamlist = (FAR struct streamlist *)
    group_zalloc(group, sizeof(struct streamlist));

  if (!group->tg_streamlist)
    {
      kmm_free(group);
      return -ENOMEM;
    }

#endif

  /* Attach the group to the TCB */

  tcb->cmn.group = group;

#if defined(HAVE_GROUP_MEMBERS) || defined(CONFIG_ARCH_ADDRENV)
  /* Assign the group a unique ID.  If g_gidcounter were to wrap before we
   * finish with task creation, that would be a problem.
   */

  group_assigngid(group);
#endif

  /* Duplicate the parent tasks environment */

  ret = env_dup(group);
  if (ret < 0)
    {
#if CONFIG_NFILE_STREAMS > 0 && (defined(CONFIG_BUILD_PROTECTED) || \
    defined(CONFIG_BUILD_KERNEL)) && defined(CONFIG_MM_KERNEL_HEAP)
      group_free(group, group->tg_streamlist);
#endif
      kmm_free(group);
      tcb->cmn.group = NULL;
      return ret;
    }

#ifndef CONFIG_DISABLE_PTHREAD
  /* Initialize the pthread join semaphore */

  (void)sem_init(&group->tg_joinsem, 0, 1);
#endif

#if defined(CONFIG_SCHED_WAITPID) && !defined(CONFIG_SCHED_HAVE_PARENT)
  /* Initialize the exit/wait semaphores
   *
   * This semaphore is used for signaling and, hence, should not have
   * priority inheritance enabled.
   */

  (void)sem_init(&group->tg_exitsem, 0, 0);
  (void)sem_setprotocol(&group->tg_exitsem, SEM_PRIO_NONE);
#endif

  return OK;
}
Exemple #18
0
 PcieTestBenchIndication(unsigned int id) : PcieTestBenchIndicationWrapper(id), cnt(0)
 {
   sem_init(&sem, 0, 0);
 }
Exemple #19
0
/** parent thread function **/
int main(int argc, char * argv[])
{
	int ret;
	int i;
	pthread_mutexattr_t ma;
	pthread_t  child;

	output_init();

	#if VERBOSE >1
	output("Initialize the PTHREAD_MUTEX_RECURSIVE mutex\n");
	#endif

	/* Initialize the semaphore */
	if ((ret = sem_init(&sem, 0, 0)))
	{  UNRESOLVED(ret, "Sem init failed");  }

	/* We initialize the recursive mutex */
	if ((ret = pthread_mutexattr_init(&ma)))
	{  UNRESOLVED(ret, "Mutex attribute init failed");  }

	if ((ret = pthread_mutexattr_settype(&ma, PTHREAD_MUTEX_RECURSIVE)))
	{  UNRESOLVED(ret, "Set type RECURSIVE failed");  }

	if ((ret = pthread_mutex_init(&mtx, &ma)))
	{  UNRESOLVED(ret, "Recursive mutex init failed");  }

	if ((ret = pthread_mutexattr_destroy(&ma)))
	{  UNRESOLVED(ret, "Mutex attribute destroy failed");  }

	/* -- The mutex is now ready for testing -- */

	/* First, we lock it twice and unlock once */
	if ((ret = pthread_mutex_lock(&mtx)))
	{ UNRESOLVED(ret, "First lock failed");  }

	if ((ret = pthread_mutex_lock(&mtx)))
	{ FAILED("Second lock failed");  }

	if ((ret = pthread_mutex_unlock(&mtx)))
	{ FAILED("First unlock failed");  }

	#if VERBOSE >1
	output("The mutex has been locked twice and unlocked once, start the thread now.\n");
	#endif

	/* Here this thread owns the mutex and the internal count is "1" */

	/* We create the child thread */
	if ((ret = pthread_create(&child, NULL, threaded, NULL)))
	{  UNRESOLVED(ret, "Unable to create child thread");  }

	/* then wait for child to be ready */
	if ((ret = sem_wait(&sem)))
	{  UNRESOLVED(errno, "Wait sem in child failed");  }

	#if VERBOSE >1
	output("[main] unlock the mutex.\n");
	#endif

	/* We can now unlock the mutex */
	if ((ret = pthread_mutex_unlock(&mtx)))
	{ FAILED("Second unlock failed");  }

	/* We wait for the child to lock the mutex */
	if ((ret = sem_wait(&sem)))
	{  UNRESOLVED(errno, "Wait sem in child failed");  }

	/* Then, try to unlock the mutex (owned by the child or unlocked) */
	ret = pthread_mutex_unlock(&mtx);
	if (ret == 0)
	{ FAILED("Unlock of unowned mutex succeeds");  }

	/* Everything seems OK here */
	if ((ret = pthread_join(child, NULL)))
	{  UNRESOLVED(ret, "Child join failed");  }

	/* Simple loop to double-check */
	#if VERBOSE >1
	output("[main] joined the thread.\n");
	output("Lock & unlock the mutex 50 times.\n");
	#endif

	for (i=0; i<50; i++)
	{
		if ((ret = pthread_mutex_lock(&mtx)))
		{  FAILED("Lock failed in loop");  }
	}
	for (i=0; i<50; i++)
	{
		if ((ret = pthread_mutex_unlock(&mtx)))
		{  FAILED("Unlock failed in loop");  }
	}

	ret = pthread_mutex_unlock(&mtx);
	if (ret == 0)
	{  FAILED("Unlock succeeds after the loop");  }

	#if VERBOSE >1
	output("Everything went OK; destroy the mutex.\n");
	#endif
	/* The test passed, we destroy the mutex */
	if ((ret = pthread_mutex_destroy(&mtx)))
	{  UNRESOLVED(ret, "Final mutex destroy failed");  }

	PASSED;
}
Exemple #20
0
void dim_init()
{
	static int done = 0;
	sigset_t set1;
	pthread_t t_id;
	int ret;
/*
#ifdef LYNXOS
*/
    pthread_attr_t attr;
/*
#endif
*/
	if(!done)
	{
	  /*
		int prio;
	  */
		done = 1;
		dna_init();
		/*
		thr_getprio(thr_self(),&prio);
		thr_setprio(thr_self(),prio+3);
		*/
		INIT_thread = pthread_self();
		MAIN_thread = INIT_thread;
		
#ifndef darwin 
		
		sem_init(&DIM_INIT_Sema, 0, INIT_count);
	        sem_init(&DIM_WAIT_Sema, 0, WAIT_count);
#else
		DIM_INIT_Semap = sem_open("/Dim_INIT_Sem", O_CREAT, S_IRUSR | S_IWUSR, INIT_count);
		DIM_WAIT_Semap = sem_open("/Dim_WAIT_Sem", O_CREAT, S_IRUSR | S_IWUSR, WAIT_count);
#endif
		
		ignore_sigpipe();

#ifdef LYNXOS
		pthread_attr_create(&attr);
		pthread_create(&t_id, attr, dim_dtq_thread, 0);
#else
/*
		pthread_create(&t_id, NULL, dim_dtq_thread, 0);
*/
		pthread_attr_init(&attr);
		pthread_attr_setinheritsched(&attr, PTHREAD_INHERIT_SCHED);
		pthread_create(&t_id, &attr, dim_dtq_thread, 0);
#endif
#ifndef darwin
		ret = sem_wait(&DIM_INIT_Sema);
#else
		ret = sem_wait(DIM_INIT_Semap);
#endif
#ifdef LYNXOS		
		pthread_create(&t_id, attr, dim_tcpip_thread, 0);
#else
		pthread_create(&t_id, &attr, dim_tcpip_thread, 0);
#endif
#ifndef darwin
		ret = sem_wait(&DIM_INIT_Sema);
#else
		ret = sem_wait(DIM_INIT_Semap);
#endif
		INIT_thread = 0;
	}
}
Exemple #21
0
static struct tiva_adc_s *tiva_adc_struct_init(struct tiva_adc_cfg_s *cfg)
{
  struct tiva_adc_s     *adc           = g_adcs[cfg->adc];
  struct tiva_adc_sse_s *sse           = 0;
  uint8_t                s             = 0;

  /* Do not re-initialize the run-time structures, there is a chance another
   * process is also using this ADC.
   */

  if (adc->cfg == true)
    {
      goto tiva_adc_struct_init_ok;
    }
  else
    {
      if (adc != NULL)
        {
          adc->ena = false;
          adc->devno = cfg->adc;

          for (s = 0; s < 4; s++)
            {

              /* Only configure selected SSEs */

              if (cfg->sse[s])
                {
                  sse = g_sses[SSE_IDX(cfg->adc, s)];

                  if (sse != NULL)
                    {
                      sse->adc = cfg->adc;
                      sse->num = s;
                      sem_init(&sse->exclsem, SEM_PROCESS_PRIVATE, 1);
                      sse->ena = false;
                      sse->cfg = true;
                    }
                  else
                    {
                      goto tiva_adc_struct_init_error;
                    }
                }
            }

          /* Initialize the public ADC device data structure */

          adc->dev = g_devs[cfg->adc];
          if (adc->dev != NULL)
            {
              adc->dev->ad_ops  = &g_adcops;
              adc->dev->ad_priv = adc;
            }
          else
            {
              goto tiva_adc_struct_init_error;
            }
          goto tiva_adc_struct_init_ok;
        }
      else
        {
          goto tiva_adc_struct_init_error;
        }
    }

tiva_adc_struct_init_error:
  avdbg("Invalid ADC device number: expected=%d actual=%d\n",
        0, cfg->adc);
  avdbg("ADC%d (CONFIG_TIVA_ADC%d) must be enabled in Kconfig first!",
        cfg->adc, cfg->adc);
  return NULL;

tiva_adc_struct_init_ok:
  adc->cfg = true;
  return adc;
}
Exemple #22
0
int main(int argc, char** argv)
{
	int rc;
	pid_t pid;
	
	//注册信号
	(void)signal(TFTP_SIGNAL, Tftp_Sig);
	
	//初始化缓存队列
	queue_init(&coapMsgQ, free);
	
	//初始化信号量,初始值为0
	rc = sem_init(&msgQSem, 0, 0);
	if(rc == -1)
	{
		printf("init msgQSem error!\r\n");
		exit(-1);
	}
	
	//初始化互斥量
	rc = pthread_mutex_init(&msgQ_mutex, NULL);
	if(rc != 0)
	{
		printf("msgQ_mutex init error!\r\n");
		exit(-1);
	}
	
	
	//打开数据库
	Open_db("CoapMsg.db", &db);
	
	rc = zlog_init("log.conf");
	if (rc) 
	{
		printf("init failed\n");
		return -1;
	}

	zc = zlog_get_category("my_cat");
	if (!zc) 
	{
		printf("get cat fail\n");
		zlog_fini();
		return -2;
	}
	
	zlog_info(zc, "Start!");

	zlog_info(zc, "Uart_Init!");
	//初始化串口
	Uart_Init(115200);

	//创建串口读取数据线程
	rc = pthread_create(&uartRd_Thread, NULL, Uart_ReadThread, NULL);
	if(0!=rc)
	{
		zlog_error(zc, "uartRd_Thread create error!");
		exit(-1);
	}
	else
	{
		zlog_debug(zc, "uartRd_Thread create success!");
	}
	
	//创建分发数据线程
	rc = pthread_create(&transMsg_Thread, NULL, TransMsgThread, NULL);
	if(0!=rc)
	{
		zlog_error(zc, "TransMsgThread create error!");
		exit(-1);
	}
	else
	{
		zlog_debug(zc, "TransMsgThread create success!");
	}
	
	//初始化链表
	list_init( &iplist, free);
	zlog_debug(zc, "list_init success!");
	
	//创建tftp Server进程
	pid = fork();
	if(pid == 0)
	{
		printf("enter tftp server,pid = %d\r\n", getpid());
		zlog_debug(zc, "enter tftp server,pid = %d", getpid());
		tftpd_init(NULL);
	}
	else if(pid<0)
	{
		printf("create tftp server process error!\r\n");
		zlog_error(zc, "create tftp server process error!");
	}
	else if(pid > 0)
	{
		//记录tftp子进程的pid
		tftp_pid = pid;
	}
	
	//创建coapclient任务
	CreatCoapclient(&iplist);
	
	//创建coap Server进程
	pid = fork();
	if(pid == 0)
	{
		printf("enter coap server,pid = %d\r\n", getpid());
		zlog_debug(zc, "enter coap server,pid = %d", getpid());
		CoapServ(NULL);
	}
	else if(pid<0)
	{
		printf("create coap server process error!\r\n");
		zlog_error(zc, "create coap server process error!");
	}
	else if(pid > 0)
	{
		//记录coap server子进程的pid
		coap_serv_pid = pid;
	}
	
	while(1)
	{
		sleep(1);
	}

	return 0;
}
Exemple #23
0
int
do_test (void)
{
  if (pthread_barrier_init (&b, NULL, N + 1) != 0)
    {
      puts ("barrier_init failed");
      exit (1);
    }

  if (sem_init (&s, 0, 0) != 0)
    {
      puts ("sem_init failed");
      exit (1);
    }

  struct sigaction sa;
  sa.sa_handler = handler;
  sigemptyset (&sa.sa_mask);
  sa.sa_flags = 0;
  if (sigaction (THE_SIG, &sa, NULL) != 0)
    {
      puts ("sigaction failed");
      exit (1);
    }

  pthread_attr_t a;

  if (pthread_attr_init (&a) != 0)
    {
      puts ("attr_init failed");
      exit (1);
    }

  if (pthread_attr_setstacksize (&a, 1 * 1024 * 1024) != 0)
    {
      puts ("attr_setstacksize failed");
      return 1;
    }

  int i;
  for (i = 0; i < N; ++i)
    if (pthread_create (&th[i], &a, tf, cbs[i]) != 0)
      {
	puts ("pthread_create failed");
	exit (1);
      }

  if (pthread_attr_destroy (&a) != 0)
    {
      puts ("attr_destroy failed");
      exit (1);
    }

  pthread_barrier_wait (&b);

  sigset_t ss;
  sigemptyset (&ss);
  sigaddset (&ss, THE_SIG);
  if (pthread_sigmask (SIG_BLOCK, &ss, NULL) != 0)
    {
      puts ("pthread_sigmask failed");
      exit (1);
    }

  /* Start sending signals.  */
  for (i = 0; i < TOTAL_SIGS; ++i)
    {
      if (kill (getpid (), THE_SIG) != 0)
	{
	  puts ("kill failed");
	  exit (1);
	}

      if (TEMP_FAILURE_RETRY (sem_wait (&s)) != 0)
	{
	  puts ("sem_wait failed");
	  exit (1);
	}

      ++nsigs;
    }

  pthread_barrier_wait (&b);

  for (i = 0; i < N; ++i)
    if (pthread_join (th[i], NULL) != 0)
      {
	puts ("join failed");
	exit (1);
      }

  return 0;
}
Exemple #24
0
int main(int argc, const char **argv)
{
  int i;
  int srcAlloc;
  int dstAlloc;
  unsigned int *srcBuffer = 0;
  unsigned int *dstBuffer = 0;


  FMComms1RequestProxy *device = 0;
  FMComms1Indication *deviceIndication = 0;
  BlueScopeEventPIORequestProxy *bluescope = 0;
  BlueScopeEventPIOIndication *bluescopeIndication = 0;

  fprintf(stdout, "Main::%s %s\n", __DATE__, __TIME__);

  if(sem_init(&cv_sem, 1, 0)){
    fprintf(stdout, "failed to init cv_sem\n");
    exit(1);
  }

  if(sem_init(&read_sem, 1, 0)){
    fprintf(stdout, "failed to init read_sem\n");
    exit(1);
  }

  if(sem_init(&write_sem, 1, 0)){
    fprintf(stdout, "failed to init write_sem\n");
    exit(1);
  }

  device = new FMComms1RequestProxy(IfcNames_FMComms1Request);
  DmaManager *dma = platformInit();
  deviceIndication = new FMComms1Indication(IfcNames_FMComms1Indication);
  bluescope = new BlueScopeEventPIORequestProxy(IfcNames_BlueScopeEventPIORequest);
  bluescopeIndication = new BlueScopeEventPIOIndication(IfcNames_BlueScopeEventPIOIndication);

  fprintf(stdout, "Main::allocating memory...\n");
  srcAlloc = portalAlloc(alloc_sz, 0);

  srcBuffer = (unsigned int *)portalMmap(srcAlloc, alloc_sz);
  if ((char *) srcBuffer == MAP_FAILED) perror("srcBuffer mmap failed");
  assert ((char *) srcBuffer != MAP_FAILED);

  dstAlloc = portalAlloc(alloc_sz, 0);

  dstBuffer = (unsigned int *)portalMmap(dstAlloc, alloc_sz);
  if ((char *) dstBuffer == MAP_FAILED) perror("dstBuffer mmap failed");
  assert ((char *) dstBuffer != MAP_FAILED);

  int status;
  status = setClockFrequency(0, 100000000, 0);
  /* FMComms1 refclk should be 30 MHz */
  status = setClockFrequency(1,  30000000, 0);
    
  portalCacheFlush(srcAlloc, srcBuffer, alloc_sz, 1);
  portalCacheFlush(dstAlloc, dstBuffer, alloc_sz, 1);
  fprintf(stdout, "Main::flush and invalidate complete\n");

  bluescope->doReset();
  WHERE();
  bluescope->setTriggerMask (0xFFFFFFFF);
  WHERE();
  bluescope->getCounterValue();
  WHERE();
  bluescope->enableIndications(1);
  WHERE();
  sem_wait(&cv_sem);
  fprintf(stdout, "Main::initial BlueScopeEventPIO counterValue: %d\n", counter_value);

  device->getReadStatus();
  device->getWriteStatus();
  sem_wait(&read_sem);
  sem_wait(&write_sem);
  fprintf(stdout, "Main::after getStateDbg\n");

  unsigned int ref_srcAlloc = dma->reference(srcAlloc);
  fprintf(stdout, "ref_srcAlloc=%d\n", ref_srcAlloc);
  unsigned int ref_dstAlloc = dma->reference(dstAlloc);
  fprintf(stdout, "ref_dstAlloc=%d\n", ref_dstAlloc);

  fprintf(stdout, "Main::starting read %08x\n", numWords);

  device->startRead(ref_srcAlloc, numWords, readBurstLen, 1);
  device->startWrite(ref_dstAlloc, numWords, writeBurstLen, 1);
  sem_wait(&read_sem);



   sleep(5);
  device->getReadStatus();
  device->getWriteStatus();
  sem_wait(&read_sem);
  sem_wait(&write_sem);
   sleep(5);
  fprintf(stdout, "Main::stopping reads\n");
  device->startRead(ref_srcAlloc, numWords, readBurstLen, 0);
  fprintf(stdout, "Main::stopping writes\n");
  device->startWrite(ref_dstAlloc, numWords, writeBurstLen, 0);
  device->getReadStatus();
  device->getWriteStatus();
  sem_wait(&read_sem);
  sem_wait(&write_sem);
  testi2c("/dev/i2c-1", 0x58);

  bluescope->getCounterValue();
  fprintf(stdout, "Main::getCounter\n");
 
  sem_wait(&cv_sem);
  
  fprintf(stdout, "Main::final BlueScopeEventPIO counterValue: %d\n", counter_value);
  fprintf(stdout, "received %d events\n", eventcount);
  for (i = 0; i < eventcount; i += 1) {
      fprintf(stdout, "reportEvent(0x%08x, 0x%08x)\n", events[i], timestamps[i]);
  }

  exit(0);
}
Exemple #25
0
/* 
 * Refine eigenvalues with respect to new rrr 
 */
static inline 
int refine_eigvals(cluster_t *cl, int rf_begin, int rf_end,
		   int tid, proc_t *procinfo, rrr_t *RRR, 
		   val_t *Wstruct, vec_t *Zstruct,
		   tol_t *tolstruct, counter_t *num_left,
		   workQ_t *workQ, double *work,
		   int *iwork)
{
  /* From inputs */
  int              rf_size   = rf_end-rf_begin+1;
  int              bl_begin  = cl->bl_begin;
  int              bl_end    = cl->bl_end;
  int              bl_size   = bl_end - bl_begin + 1;
  double           bl_spdiam = cl->bl_spdiam;

  int              nthreads  = procinfo->nthreads;

  double *restrict D         = RRR->D;
  double *restrict L         = RRR->L;
  double *restrict DLL       = RRR->DLL;

  double *restrict W         = Wstruct->W;
  double *restrict Werr      = Wstruct->Werr;
  double *restrict Wgap      = Wstruct->Wgap;
  int    *restrict Windex    = Wstruct->Windex;
  double *restrict Wshifted  = Wstruct->Wshifted;

  int              nz        = Zstruct->nz;

  double           pivmin    = tolstruct->pivmin;
  double           rtol1     = tolstruct->rtol1;
  double           rtol2     = tolstruct->rtol2;

  /* Others */
  int              info, i, p, q, offset;
  double           sigma, savegap;
  int              MIN_REFINE_CHUNK = fmax(2,nz/(4*nthreads));
  int              left, own_part, others_part, num_tasks;
  int              ts_begin, ts_end, chunk, count;
  task_t           *task;
  sem_t            sem;
  int              num_iter;

  /* Determine if refinement should be split into tasks */
  left = PMR_get_counter_value(num_left);
  own_part = (int) fmax( ceil( (double) left / nthreads ),
			 MIN_REFINE_CHUNK);

  if (own_part < rf_size) {

    others_part = rf_size - own_part;
    num_tasks   = iceil(rf_size, own_part) - 1; /* >1 */
    chunk       = others_part/num_tasks;        /* floor */

    sem_init(&sem, 0, 0);
    ts_begin = rf_begin;
    p        = Windex[rf_begin];
    for (i=0; i<num_tasks; i++) {
      ts_end = ts_begin + chunk - 1;
      q      = p        + chunk - 1;

      task = PMR_create_r_task(ts_begin, ts_end, D, DLL, p, q, 
			       bl_size, bl_spdiam, tid, &sem);
     
      if (ts_begin <= ts_end)
	PMR_insert_task_at_back(workQ->r_queue, task);
      else
	sem_post(&sem); /* case chunk=0 */

      ts_begin = ts_end + 1;
      p        = q      + 1;
    }
    ts_end = rf_end;
    q      = Windex[rf_end];
    offset = Windex[ts_begin] - 1;

    /* Call bisection routine to refine the values */
    if (ts_begin <= ts_end) {
      LAPACK(dlarrb)
      (&bl_size, D, DLL, &p, &q, &rtol1, &rtol2, &offset, &Wshifted[ts_begin], 
       &Wgap[ts_begin], &Werr[ts_begin], work, iwork, &pivmin, &bl_spdiam, 
       &bl_size, &info);
      assert( info == 0 );
    }

    /* Empty "all" r-queue refine tasks before waiting */
    num_iter = PMR_get_num_tasks(workQ->r_queue);
    for (i=0; i<num_iter; i++) {
      task = PMR_remove_task_at_front(workQ->r_queue);
      if (task != NULL) {
	if (task->flag == REFINE_TASK_FLAG) {
	  PMR_process_r_task((refine_t *) task->data, procinfo, 
			     Wstruct, tolstruct, work, iwork);
	  free(task);
	} else {
	  PMR_insert_task_at_back(workQ->r_queue, task);
	}
      } /* if task */
    } /* end for i */
    
    /* Barrier: wait until all created tasks finished */
    count = num_tasks;
    while (count > 0) {
      while (sem_wait(&sem) != 0) { };
      count--;
    }
    sem_destroy(&sem);

    /* Edit right gap at splitting point */
    ts_begin = rf_begin;
    for (i=0; i<num_tasks; i++) {
      ts_end = ts_begin + chunk - 1;
      
      Wgap[ts_end] = Wshifted[ts_end + 1] - Werr[ts_end + 1]
	             - Wshifted[ts_end] - Werr[ts_end];
      
      ts_begin = ts_end + 1;
    }

  } else {
    /* Refinement of cluster without creating tasks */
    
    /* 'p' and 'q' are local (within block) indices of
     * the first/last eigenvalue of the cluster */
    p = Windex[rf_begin];
    q = Windex[rf_end];
    
    offset = Windex[rf_begin] - 1;    /* = p - 1 */
    
    if (p == q) {
      savegap = Wgap[rf_begin];
      Wgap[rf_begin] = 0.0;
    }  
    
    /* Bisection routine to refine the values */
    LAPACK(dlarrb)
    (&bl_size, D, DLL, &p, &q, &rtol1, &rtol2, &offset, &Wshifted[rf_begin], 
     &Wgap[rf_begin], &Werr[rf_begin], work, iwork, &pivmin, &bl_spdiam, 
     &bl_size, &info);
    assert( info == 0 );
    
    if (p == q) {
      Wgap[rf_begin] = savegap;
    }  
  
  } /* end refine with or without creating tasks */

  sigma     = L[bl_size-1];
  
  /* refined eigenvalues with all shifts applied in W */
  for (i=rf_begin; i<=rf_end; i++) {
    W[i] = Wshifted[i] + sigma;
  }

  return(0);
} /* end refine_eigvals */
Exemple #26
0
/* main function */
int main()
{
	int ret;
	pthread_t child;

	struct sigaction sa;

	/* Initialize output */
	output_init();

	/* Set the signal handler */
	sa.sa_flags = SA_RESTART;
	sa.sa_handler = handler;
	ret = sigemptyset(&sa.sa_mask);

	if (ret != 0)
	{
		UNRESOLVED(ret, "Failed to empty signal set");
	}

	/* Install the signal handler for SIGNAL */
	ret = sigaction(SIGNAL, &sa, 0);

	if (ret != 0)
	{
		UNRESOLVED(ret, "Failed to set signal handler");
	}

	/* Initialize the semaphore */
	ret = sem_init(&sem, 0, 0);

	if (ret != 0)
	{
		UNRESOLVED(ret, "Failed to init a semaphore");
	}

	/* Create the child thread */
	ret = pthread_create(&child, NULL, threaded, NULL);

	if (ret != 0)
	{
		UNRESOLVED(ret, "Failed to create a child thread");
	}

	/* Let the child thread enter the wait routine...
	  we use sched_yield as there is no certain way to test that the child
	  is waiting for the semaphore... */
	sched_yield();

	sched_yield();

	sched_yield();

	/* Ok, now kill the child */
	ret = pthread_kill(child, SIGNAL);

	if (ret != 0)
	{
		UNRESOLVED(ret, "Failed to kill the child thread");
	}

	/* wait that the child receives the signal */
	while (!caught)
		sched_yield();

	/* Now let the child run and terminate */
	ret = sem_post(&sem);

	if (ret != 0)
	{
		UNRESOLVED(errno, "Failed to post the semaphore");
	}

	ret = pthread_join(child, NULL);

	if (ret != 0)
	{
		UNRESOLVED(ret, "Failed to join the thread");
	}

	/* terminate */
	ret = sem_destroy(&sem);

	if (ret != 0)
	{
		UNRESOLVED(ret, "Failed to destroy the semaphore");
	}

	/* Test passed */
#if VERBOSE > 0

	output("Test passed\n");

#endif

	PASSED;
}
Exemple #27
0
/* The main test function. */
int main(int argc, char * argv[])
{
	int ret, i;
	sem_t *sems;
	sem_t sem_last;

	long max;

	/* Initialize output */
	output_init();

	max = sysconf(_SC_SEM_NSEMS_MAX);

	if (max <= 0)
	{
		output("sysconf(_SC_SEM_NSEMS_MAX) = %ld\n", max);
		UNTESTED("There is no constraint on SEM_NSEMS_MAX");
	}

	sems = (sem_t *) calloc(max, sizeof(sem_t));

	if (sems == NULL)
	{
		UNRESOLVED(errno, "Failed to alloc space");
	}

	for (i = 0; i < max; i++)
	{
		ret = sem_init(&sems[ i ], 0, 0);

		if (ret != 0)
		{
			output("sem_init failed to initialize the %d nth semaphore.\n", i);
			output("Tryed to initialize %ld.\n", max);
			output("Error is %d: %s\n", errno, strerror(errno));

			for (; i > 0; i--)
				sem_destroy(&sems[i-1]);

			free(sems);

			PASSED;
		}
	}

	ret = sem_init(&sem_last, 0, 1);

	if (ret == 0)
	{
		FAILED("We were able to sem_init more than SEM_NSEMS_MAX semaphores");
	}

	if (errno != ENOSPC)
	{
		output("Error is %d: %s\n", errno, strerror(errno));
	}

	for (i = 0; i < max; i++)
		sem_destroy(&sems[i]);

	free(sems);

	/* Test passed */
#if VERBOSE > 0

	output("Test passed\n");

#endif

	PASSED;
}
Exemple #28
0
int UHD_SAFE_MAIN(int argc, char *argv[]){
    
  //Seting priority in the processor to run faster -> run with sudo
  if (!(uhd::set_thread_priority_safe(1,true))) {
    std::cout << "Problem setting thread priority" << std::endl;
    return 1;
  };
  //variables to be set by po -> Set when initializing the rx program
  //double seconds_in_future=0.01;
  size_t total_num_samps;
  double rx_rate, freq, LOoffset;
  bool use_external_10MHz;
  double scaling_8bits;
  std::string filename;
  float gain;
  bool realTime;
  uhd::device_addr_t dev_addr;
  uhd::usrp::multi_usrp::sptr dev;
  uhd::tune_result_t tr;
  uhd::stream_args_t stream_args;
  uhd::rx_streamer::sptr rx_stream;


  //setup the program options-> Passing it from terminal with boost library 
  po::options_description desc("Allowed options");
  desc.add_options()
    ("help", "help message")
    ("nsamps", po::value<size_t>(&total_num_samps)->default_value(1000), "total number of samples to receive")
    ("rxrate", po::value<double>(&rx_rate)->default_value(100e6/4), "rate of incoming samples")
    ("freq", po::value<double>(&freq)->default_value(5.5e9), "rf center frequency in Hz")
    ("LOoffset", po::value<double>(&LOoffset)->default_value(10e6), "Offset between main LO and center frequency")
    ("10MHz",po::value<bool>(&use_external_10MHz)->default_value(false), "external 10MHz on 'REF CLOCK' connector (true=1=yes)")
    //  ("PPS",po::value<bool>(&trigger_with_pps)->default_value(false), "trigger reception with 'PPS IN' connector (true=1=yes)")
    ("filename",po::value<std::string>(&filename)->default_value("data_from_usrp.dat"), "output filename") 
    ("gain",po::value<float>(&gain)->default_value(30), "set the receiver gain") 
    ("8bits_scaling",po::value<double>(&scaling_8bits)->default_value(0.0), 
     "input scaling (invers) when 8bits is used, set to zero to get 16bits")
      
    /////////////////////////////
    ("realTime",po::value<bool>(&realTime)->default_value(true), "receives in loop and compares with synch sequence")
    ;
   
  //Variables stored in boost objects
  po::variables_map vm;
  po::store(po::parse_command_line(argc, argv, desc), vm);
  po::notify(vm);

  //print the help message
  if (vm.count("help")){
    std::cout << boost::format("rx %s") % desc << std::endl;
    return ~0;
  }

  ///////////Set device variables to read data////////////////
    
  dev_addr["addr0"]="192.168.10.2";
  dev = uhd::usrp::multi_usrp::make(dev_addr);//Create the device

  //receiving format
  stream_args.cpu_format="sc16";
  if (scaling_8bits==0.0) {
    stream_args.otw_format="sc16";     
  } else {
    stream_args.otw_format="sc8";
    std::stringstream temp_ss;
    temp_ss << scaling_8bits;
    stream_args.args["peak"]=temp_ss.str();
  };

  rx_stream=dev->get_rx_stream(stream_args); //set/get the streamer values to the device

  uhd::clock_config_t my_clock_config; 

  /*
    if (trigger_with_pps) {
    my_clock_config.pps_source=uhd::clock_config_t::PPS_SMA; 
    };
  */

  if (use_external_10MHz) { 
    my_clock_config.ref_source=uhd::clock_config_t::REF_SMA; 
  };  

  /////////////////Create an USRP device////////////////////////
  std::cout << std::endl;
  //uhd::device::sptr udev = dev->get_device();
  dev->set_rx_rate(rx_rate);

  bool is_xcvr2450=false;
  uhd::dict<std::string, std::string> rx_info;    
  rx_info=dev->get_usrp_rx_info(0);

  if (rx_info.has_key("rx_subdev_name")) {
    std::string str=rx_info.get("rx_subdev_name");
    uint temp=str.find("XCVR2450");
    if (temp<str.length()) {
      is_xcvr2450=true;
    };
  };

  if (is_xcvr2450) {
    dev->set_tx_antenna("J2");
    dev->set_rx_antenna("J1");      
    //uhd::meta_range_t range=dev->get_tx_bandwidth_range();

    if (LOoffset>=9e6) {
      dev->set_rx_bandwidth(3.96e+07);
    };      
  };

  std::cout << "rx_rate=" << rx_rate << std::endl;
  std::cout << "freq=" << freq << std::endl;
  std::cout << "gain=" << gain << std::endl;
  uhd::tune_request_t trq(freq,LOoffset); 
  //dev->set_rx_bandwidth(36e6);
  tr=dev->set_rx_freq(trq);
  dev->set_rx_gain(gain);

  std::cout << "tr=" << tr.actual_rf_freq << std::endl;


  if (use_external_10MHz) {
    dev->set_clock_config(my_clock_config); // PZ
    usleep(1e6); // Wait for the 10MHz to lock
  }; 

  size_t buffer_size=1000; // Select buffer size

  uint nDetect=1000;
  

  dev->set_time_now(uhd::time_spec_t(0.0));
 
  std::cout << boost::format("Setting device timestamp to 0...") << std::endl;

  

   
  //////////////////////////////////Read data to buff_short and do processing////////////


  //Launch threads
  sem_init(&isReady, 0,0); 
  std::thread storeT(storeDataX, rx_stream, dev, buffer_size, nDetect);
  std::thread detectionT(detection, nDetect);

  storeT.join();
  detectionT.join();

  //finished
  std::cout << std::endl << "Done receiving!" << std::endl << std::endl; 

  return 0;
}
void IpcYxFake_Client_Init(void)
{
	sem_init(&(s_object_lock),0,1);
	ListInit(&(s_object_list), 0, 0);
}
Exemple #30
0
/** ============================================================================
 *  @func   pool_notify_Create
 *
 *  @desc   This function allocates and initializes resources used by
 *          this application.
 *
 *  @modif  None
 *  ============================================================================
 */
NORMAL_API
DSP_STATUS
pool_notify_Create (IN Char8 * dspExecutable,
                    IN Char8 * strBufferSize,
                    IN Uint8   processorId)
{
    DSP_STATUS      status     = DSP_SOK  ;
    Uint32          numArgs    = NUM_ARGS ;
    Void *          dspDataBuf = NULL ;
    Uint32          numBufs [NUM_BUF_SIZES] = {NUM_BUF_POOL0,
                                              } ;
    Uint32          size    [NUM_BUF_SIZES] ;
    SMAPOOL_Attrs   poolAttrs ;
    Char8 *         args [NUM_ARGS] ;

#ifdef DEBUG
    printf ("Entered pool_notify_Create ()\n") ;
#endif
 
    sem_init(&sem,0,0);

    /*
     *  Create and initialize the proc object.
     */
    status = PROC_setup (NULL) ;

    /*
     *  Attach the Dsp with which the transfers have to be done.
     */
    if (DSP_SUCCEEDED (status)) {
        status = PROC_attach (processorId, NULL) ;
        if (DSP_FAILED (status)) {
            printf ("PROC_attach () failed. Status = [0x%x]\n",
                            (int)status) ;
        }
    }
    else {
        printf ("PROC_setup () failed. Status = [0x%x]\n", (int)status) ;
    }

    /*
     *  Open the pool.
     */
    if (DSP_SUCCEEDED (status)) {
        size [0] = pool_notify_BufferSize ;
        poolAttrs.bufSizes      = (Uint32 *) &size ;
        poolAttrs.numBuffers    = (Uint32 *) &numBufs ;
        poolAttrs.numBufPools   = NUM_BUF_SIZES ;
        poolAttrs.exactMatchReq = TRUE ;
        status = POOL_open (POOL_makePoolId(processorId, SAMPLE_POOL_ID),
                            &poolAttrs) ;
        if (DSP_FAILED (status)) {
            printf ("POOL_open () failed. Status = [0x%x]\n",
                             (int)status) ;
        }
    }

    /*
     *  Allocate the data buffer to be used for the application.
     */
    if (DSP_SUCCEEDED (status)) {
        status = POOL_alloc (POOL_makePoolId(processorId, SAMPLE_POOL_ID),
                             (Void **) &pool_notify_DataBuf,
                             pool_notify_BufferSize) ;

        /* Get the translated DSP address to be sent to the DSP. */
        if (DSP_SUCCEEDED (status)) {
            status = POOL_translateAddr (
                                   POOL_makePoolId(processorId, SAMPLE_POOL_ID),
                                         &dspDataBuf,
                                         AddrType_Dsp,
                                         (Void *) pool_notify_DataBuf,
                                         AddrType_Usr) ;

            if (DSP_FAILED (status)) {
                printf ("POOL_translateAddr () DataBuf failed."
                                 " Status = [0x%x]\n",
                                 (int)status) ;
            }
        }
        else {
            printf ("POOL_alloc () DataBuf failed. Status = [0x%x]\n",
                             (int)status) ;
        }
    }

    /*
     *  Register for notification that the DSP-side application setup is
     *  complete.
     */
    if (DSP_SUCCEEDED (status)) {
        status = NOTIFY_register (processorId,
                                  pool_notify_IPS_ID,
                                  pool_notify_IPS_EVENTNO,
                                  (FnNotifyCbck) pool_notify_Notify,
                                  0/* vladms XFER_SemPtr*/) ;
        if (DSP_FAILED (status)) {
            printf ("NOTIFY_register () failed Status = [0x%x]\n",
                             (int)status) ;
        }
    }

    /*
     *  Load the executable on the DSP.
     */
    if (DSP_SUCCEEDED (status)) {
        args [0] = strBufferSize ;
        {
            status = PROC_load (processorId, dspExecutable, numArgs, args) ;
        }

        if (DSP_FAILED (status)) {
            printf ("PROC_load () failed. Status = [0x%x]\n", (int)status) ;
        }
    }

    /*
     *  Start execution on DSP.
     */
    if (DSP_SUCCEEDED (status)) {
        status = PROC_start (processorId) ;
        if (DSP_FAILED (status)) {
            printf ("PROC_start () failed. Status = [0x%x]\n",
                             (int)status) ;
        }
    }

    /*
     *  Wait for the DSP-side application to indicate that it has completed its
     *  setup. The DSP-side application sends notification of the IPS event
     *  when it is ready to proceed with further execution of the application.
     */
    if (DSP_SUCCEEDED (status)) {
        // wait for initialization 
        sem_wait(&sem);
    }

    /*
     *  Send notifications to the DSP with information about the address of the
     *  control structure and data buffer to be used by the application.
     *
     */
    status = NOTIFY_notify (processorId,
                            pool_notify_IPS_ID,
                            pool_notify_IPS_EVENTNO,
                            (Uint32) dspDataBuf);
    if (DSP_FAILED (status)) {
        printf ("NOTIFY_notify () DataBuf failed."
                " Status = [0x%x]\n",
                 (int)status) ;
    }

    status = NOTIFY_notify (processorId,
                            pool_notify_IPS_ID,
                            pool_notify_IPS_EVENTNO,
                            (Uint32) pool_notify_BufferSize);
    if (DSP_FAILED (status)) {
        printf ("NOTIFY_notify () DataBuf failed."
                " Status = [0x%x]\n",
                 (int)status) ;
    }

#ifdef DEBUG
    printf ("Leaving pool_notify_Create ()\n") ;
#endif

    return status ;
}