Beispiel #1
0
static void restart_thread(pthread_t *waiter, int cancelable)
{
  int status;

  /* Destroy the condition variable */

  printf("restart_thread: Destroying cond\n");
  status = pthread_cond_destroy(&cond);
  if (status != 0)
    {
      printf("restart_thread: ERROR pthread_cond_destroy failed, status=%d\n", status);
    }

  /* Destroy the mutex */

  printf("restart_thread: Destroying mutex\n");
  status = pthread_cond_destroy(&cond);
  if (status != 0)
    {
      printf("restart_thread: ERROR pthread_mutex_destroy failed, status=%d\n", status);
    }

  /* Then restart the thread */

  printf("restart_thread: Re-starting thread\n");
  start_thread(waiter, cancelable);
}
Beispiel #2
0
void main(void)
{
    startup_board();

    start_thread(&service_thread, service, 0, stack, sizeof(stack));

    start_cdc_service();
    set_cdc_timeout(10);
    while (1)
    {
        yield_thread((condition_t)has_cdc_connection, 0);
        debug("connected\n");
        while (has_cdc_connection())
        {
            static u8_t buffer[1024];

            const u32_t count = read_cdc_data(buffer, sizeof(buffer));
            if (count)
            {
                write_cdc_data(buffer, count);
                debug("%m\n", buffer, count);
            }
        }

        debug("disconnected\n");
    }
}
Beispiel #3
0
    recoder(const char* local_ip_1, const char* local_port_1,
            const char* remote_ip_1, const char* remote_port_1,
            const char* local_ip_2, const char* local_port_2,
            const char* remote_ip_2, const char* remote_port_2)
    {
        udp1 = new udp_recoder_stack({ {"udp_socket::local_ip", local_ip_1},
                                       {"udp_socket::local_port", local_port_1},
                                       {"udp_socket::remote_ip", remote_ip_1},
                                       {"udp_socket::remote_port", remote_port_1},
                                       {"kodo::tx_redundancy", 1.167} });

        udp2 = new udp_recoder_stack({ {"udp_socket::local_ip", local_ip_2},
                                       {"udp_socket::local_port", local_port_2},
                                       {"udp_socket::remote_ip", remote_ip_2},
                                       {"udp_socket::remote_port", remote_port_2},
                                       {"kodo::tx_redundancy", 1.167} });

        udp1->connect_signal_fw(boost::bind(&udp_recoder_stack::write_pkt, udp2, _1));
        udp2->connect_signal_fw(boost::bind(&udp_recoder_stack::write_pkt, udp1, _1));

        start_thread();

#ifdef VERBOSE
        printf("%s\n", "recoder class created");
#endif
    }
Beispiel #4
0
void main(void)
{
    startup_board();

    start_thread(&service_thread, service, 0, stack, sizeof(stack));

    start_hid_service();
    while (1)
    {
        yield_thread((condition_t)has_hid_connection, 0);
        debug("connected\n");

        while (has_hid_connection())
        {
            press(0x04);
            press(0x05);
            press(0x06);
            sleep(250);
            move(0, -100);
            sleep(250);
            move(-100, 0);
            sleep(250);
            move(0, 100);
            sleep(250);
            move(100, 0);
            sleep(200);
        }

        debug("disconnected\n");
    }
}
Beispiel #5
0
 void Thread::fork(STATE) {
   if(int error = start_thread(state, Thread::run)) {
     char buf[RBX_STRERROR_BUFSIZE];
     char* err = RBX_STRERROR(error, buf, RBX_STRERROR_BUFSIZE);
     Exception::raise_thread_error(state, err);
   }
 }
Beispiel #6
0
  SignalHandler::SignalHandler(STATE, Configuration& config)
    : AuxiliaryThread()
    , shared_(state->shared())
    , target_(state->vm())
    , self_(NULL)
    , queued_signals_(0)
    , paused_(false)
    , exit_(false)
    , thread_(state)
  {
    signal_handler_ = this;

    shared_.auxiliary_threads()->register_thread(this);
    shared_.set_signal_handler(this);

    for(int i = 0; i < NSIG; i++) {
      pending_signals_[i] = 0;
    }

    worker_lock_.init();
    worker_cond_.init();
    pause_cond_.init();

    setup_default_handlers(config.report_path.value);

    start_thread(state);
  }
Beispiel #7
0
void open_console()
{
	safe_pipe(&control_read,&control_write);
	safe_pipe(&size_read,&size_write);
	safe_pipe(&stdin_read,&stdin_write);
	start_thread(stdin_loop,NULL);
}
void test_thread_move_from_rvalue_using_explicit_move()
{
    //boost::thread x(boost::move(start_thread()));
    boost::thread x=start_thread();
    BOOST_CHECK(x.get_id()!=boost::thread::id());
    x.join();
}
Beispiel #9
0
int pigpio_start(char *addrStr, char *portStr)
{
   if (!gPigStarted)
   {
      gPigCommand = pigpioOpenSocket(addrStr, portStr);

      if (gPigCommand >= 0)
      {
         gPigNotify = pigpioOpenSocket(addrStr, portStr);

         if (gPigNotify >= 0)
         {
            gPigHandle = pigpio_command(gPigNotify, PI_CMD_NOIB, 0, 0, 1);

            if (gPigHandle < 0) return pigif_bad_noib;
            else
            {
               pthNotify = start_thread(pthNotifyThread, 0);
               if (pthNotify)
               {
                  gPigStarted = 1;
                  return 0;
               }
               else return pigif_notify_failed;
            }
         }
         else return gPigNotify;
      }
      else return gPigCommand;
   }
   return 0;
}
Beispiel #10
0
int main(int argc, const char *argv[]){
   printf("\n\n");

   // Listen to SIGINT signals (program termination)
   signal(SIGINT, signal_handler);

   // Tell linux not to use the user leds in the board.
   take_over_leds();

   // Load device tree overlay to enable PRU hardware.
   load_device_tree_overlay();

   // Load and run binary into pru0
   init_pru_program();

   open_sound_file();
   start_thread();

   /* while(!finish){ */
   sleep(5);
   /* } */
   prussdrv_pru_disable(PRU_NUM);
   prussdrv_exit ();
   stop_thread();

   close_sound_file();

   return 0;
}
Beispiel #11
0
static void cmd_poll(void)
{
	printf("#####################################\n");
	printf("##     NFC demo through Neardal    ##\n");
	printf("#####################################\n");

	if (create_loop(&main_loop) != NEARDAL_SUCCESS) return;

	do
	{
		main_loop_state = wait;

		/* Start discovery Loop */
		if (start_discovery(NEARD_ADP_MODE_DUAL) != NEARDAL_SUCCESS) return;	

		printf("---- Waiting for a Tag/Device");
		/* Start a thread to get keystroke */
		if (start_thread(&wait_for_keystroke) != NEARDAL_SUCCESS) return;


		/* Wait for tag/device lost to restart the discovery or for keystroke to leave */
		g_timeout_add (100 , wait_lost , main_loop);
		g_main_loop_run(main_loop);

	/* loop until keystroke */
	} while (main_loop_state != keystroke);


	g_main_loop_unref(main_loop);
	neardal_stop_poll(AdpName);
	printf("Leaving ...\n");
}
Beispiel #12
0
static uae_u32 scsidev_open (void)
{
    uaecptr tmp1 = m68k_areg (regs, 1); /* IOReq */
    uae_u32 unit = m68k_dreg (regs, 0);
    struct scsidevdata *sdd;

#ifdef DEBUGME
    printf("scsidev_open(0x%x, %d)\n", tmp1, unit);
#endif

    /* Check unit number */
    if ((sdd = get_scsidev_data (unit)) &&
	start_thread (sdd)) {
		opencount++;
		put_word (m68k_areg (regs, 6)+32, get_word (m68k_areg (regs, 6)+32) + 1);
		put_long (tmp1 + 24, unit); /* io_Unit */
		put_byte (tmp1 + 31, 0); /* io_Error */
		put_byte (tmp1 + 8, 7); /* ln_type = NT_REPLYMSG */
		return 0;
    }

    put_long (tmp1 + 20, (uae_u32)-1);
    put_byte (tmp1 + 31, (uae_u8)-1);
    return (uae_u32)-1;
}
Beispiel #13
0
int main()
{   
    initports();
    printf("\nCreating a client\n");
    clientid++;
    start_thread(client);
    printf("\nCreating a client\n");
    clientid++;
    start_thread(client1);
   printf("\nCreating a server\n");
    start_thread(server);
    printf("\n\n");
    run();
    while (1) 
	{ sleep(1);}
}   
Beispiel #14
0
void simple_test(func_args* args)
{
    THREAD_TYPE serverThread;

    func_args svrArgs;
    char *svrArgv[NUMARGS];
    char argc0s[32];
    char argc1s[32];
    char argc2s[32];

    func_args cliArgs;
    char *cliArgv[NUMARGS];
    char argc0c[32];
    char argc1c[32];
    char argc2c[32];

    svrArgv[0] = argc0s;
    svrArgv[1] = argc1s;
    svrArgv[2] = argc2s;
    cliArgv[0] = argc0c;
    cliArgv[1] = argc1c;
    cliArgv[2] = argc2c;

    svrArgs.argc = 1;
    svrArgs.argv = svrArgv;
    svrArgs.return_code = 0;
    cliArgs.argc = 1;
    cliArgs.argv = cliArgv;
    cliArgs.return_code = 0;
   
    strcpy(svrArgs.argv[0], "SimpleServer");
    #if !defined(USE_WINDOWS_API) && !defined(CYASSL_SNIFFER)
        svrArgs.argc = NUMARGS;
        strcpy(svrArgs.argv[1], "-p");
        strcpy(svrArgs.argv[2], "0");
    #endif
    /* Set the last arg later, when it is known. */

    args->return_code = 0;
    svrArgs.signal = args->signal;
    start_thread(server_test, &svrArgs, &serverThread);
    wait_tcp_ready(&svrArgs);
   
    /* Setting the actual port number. */
    strcpy(cliArgs.argv[0], "SimpleClient");
    #ifndef USE_WINDOWS_API
        cliArgs.argc = NUMARGS;
        strcpy(cliArgs.argv[1], "-p");
        snprintf(cliArgs.argv[2], sizeof(argc2c), "%d", svrArgs.signal->port);
    #endif

    client_test(&cliArgs);
    if (cliArgs.return_code != 0) {
        args->return_code = cliArgs.return_code;
        return;
    }
    join_thread(serverThread);
    if (svrArgs.return_code != 0) args->return_code = svrArgs.return_code;
}
Beispiel #15
0
void lcd_thread_start(void)
{
	if(cfg.enablelcd)
	{
		running = 1;
		start_thread((void *) &refresh_lcd_file, "LCD");
	}
}
Beispiel #16
0
void lcd_thread_start(void)
{
	if(cfg.enablelcd)
	{
		running = 1;
		start_thread("LCD", (void *) &refresh_lcd_file, NULL, NULL, 1, 1);
	}
}
Beispiel #17
0
void
thread_pool_start(thread_pool_t *tp)
{
    ASSERT(tp, "start thread from empty thread pool");
	int i = 0;
	for (; i < tp->thread_count; ++i)
		start_thread(tp->threads + i);
}
Beispiel #18
0
static void schedule_new_thread(struct k_thread *thread, s32_t delay)
{
#ifdef CONFIG_SYS_CLOCK_EXISTS
	if (delay == 0) {
		start_thread(thread);
	} else {
		s32_t ticks = _TICK_ALIGN + _ms_to_ticks(delay);
		int key = irq_lock();

		_add_thread_timeout(thread, NULL, ticks);
		irq_unlock(key);
	}
#else
	ARG_UNUSED(delay);
	start_thread(thread);
#endif
}
Beispiel #19
0
static HANDLE
w32_create_thread(DWORD stack_size, w32_thread_start_func func, void *val)
{
    return start_thread(0, stack_size, func, val, CREATE_SUSPENDED
#ifdef _WIN32_WCE
        |STACK_SIZE_PARAM_IS_A_RESERVATION
#endif
        ,0);
}
int main()
{   
   p[0].in=0; p[0].out=0;
   p[20].in=0; p[20].out=0;
   p[99].in=0; p[99].out=0;
    init_port();
	printf("\n\t\t\tCreating a client1");
    start_thread(client1);
	printf("\n\t\t\tCreating a client2");
    start_thread(client2);
	printf("\n\t\t\tCreating a client3");
    start_thread(client3);
	printf("\n\t\t\tCreating a server");
	printf("\n\t\t\t*******************\n");
    start_thread(server);
	run();
    while (1) sleep(1);
}   
Beispiel #21
0
  void FinalizerHandler::after_fork_child(STATE) {
    live_guard_.init();
    worker_lock_.init();
    worker_cond_.init();
    supervisor_lock_.init();
    supervisor_cond_.init();

    start_thread(state);
  }
Beispiel #22
0
int main(int argc, char* argv[]) {
    start_thread();
    
    //wait 10 seconds before exiting main
    std::this_thread::sleep_for(std::chrono::seconds(10));
    std::cout << "Exit main!" << std::endl;
    
    return 0;
}
        WriterThread(Pipe<SendableThing *> *fpipe, int in_fd) {
            assert(fpipe != NULL);
            assert(in_fd >= 0);

            _fpipe = fpipe;
            _in_fd = in_fd;

            start_thread( );
        }
Beispiel #24
0
/* Main function to test */
int main()
{
 Q = InitQ(Q);
 start_thread(function1);
// start_thread(function2);
// start_thread(function3);
// start_thread(function4);
 run();
}
Beispiel #25
0
void MainWindow::createcapthread()
{
    capture = new Capture_thread;
    connect(capture, SIGNAL(start_cap()),
            this, SLOT(start_thread()));
    connect(capture, SIGNAL(show_listdata(const ListData, QString)),
            this, SLOT(update_show(const ListData, QString)), Qt::QueuedConnection);

}
SvgSubprocessCharacterGenerator::SvgSubprocessCharacterGenerator(
    const char *cmd, unsigned int dirty_level
) : CharacterGenerator(1), _dirty_level(dirty_level) {

    _cmd = strdup(cmd);
    send_fd = -1;
    recv_fd = -1;
    start_thread( );
}
Beispiel #27
0
void factor_vm::open_console() {
  FACTOR_ASSERT(!stdin_thread_initialized_p);
  safe_pipe(&control_read, &control_write);
  safe_pipe(&size_read, &size_write);
  safe_pipe(&stdin_read, &stdin_write);
  stdin_thread = start_thread(stdin_loop, NULL);
  stdin_thread_initialized_p = true;
  pthread_mutex_init(&stdin_mutex, NULL);
}
Beispiel #28
0
  void SignalHandler::after_fork_child(STATE) {
    worker_lock_.init();
    worker_cond_.init();
    pause_cond_.init();

    VM::discard(state, self_);
    self_ = NULL;

    start_thread(state);
  }
K init(K x)
{
    dumb_socketpair(sockets, 0);
    sd1(sockets[1], recieve_data);
    
    FEED_STATE = FF_CONTINUE_FEED;
    start_thread();

    return (K) 0;
}
Beispiel #30
0
    void Metrics::start(STATE) {
      vm_ = NULL;
      thread_exit_ = false;

      timer_ = new timer::Timer;

      metrics_collection_.init();
      metrics_history_.init();

      start_thread(state);
    }