static gpointer delayed_control (gpointer data) { GstPoll *set = data; GstPollFD fd = GST_POLL_FD_INIT; fd.fd = 1; THREAD_START (); g_usleep (500000); gst_poll_add_fd (set, &fd); gst_poll_fd_ctl_write (set, &fd, TRUE); gst_poll_restart (set); THREAD_SYNCHRONIZE (); g_usleep (500000); gst_poll_add_fd (set, &fd); gst_poll_fd_ctl_write (set, &fd, TRUE); gst_poll_restart (set); return NULL; }
static gpointer post_delayed_thread (gpointer data) { THREAD_START (); send_5app_1el_1err_2app_messages (1 * G_USEC_PER_SEC); return NULL; }
int main(void) { CLKPR = (1<<7); CLKPR = 0; /* Disable watchdog timer */ MCUSR = 0; wdt_disable(); /* Start the multi-threading kernel */ init_kernel(STACK_MAIN); /* Timer */ TCCR2B = 0x03; /* Pre-scaler for timer0 */ TCCR2A = 1<<WGM21; /* CTC mode */ TIMSK2 = 1<<OCIE2A; /* Interrupt on compare match */ OCR2A = (SCALED_F_CPU / 32 / 2400) - 1; TRACE_INIT; sei(); t_stackErrorHandler(stackOverflow); fbuf_errorHandler(bufferOverflow); reset_params(); /* HDLC and AFSK setup */ mon_init(&cdc_outstr); adf7021_init(); inframes = hdlc_init_decoder( afsk_init_decoder() ); outframes = hdlc_init_encoder( afsk_init_encoder() ); digipeater_init(); /* Activate digipeater in ui thread */ /* USB */ usb_init(); THREAD_START(usbSerListener, STACK_USBLISTENER); ui_init(); /* GPS and tracking */ gps_init(&cdc_outstr); tracker_init(); TRACE(1); while(1) { lbeep(); if (t_is_idle()) { /* Enter idle mode or sleep mode here */ powerdown_handler(); sleep_mode(); } else t_yield(); } }
static void start_threads_callback(evutil_socket_t fd, short what, void *arg) { int i; for (i = 0; i < QUEUE_THREAD_COUNT; ++i) { THREAD_START(load_threads[i], load_deferred_queue, &deferred_data[i]); } }
static void thread_link_unlink (gpointer data) { THREAD_START (); while (THREAD_TEST_RUNNING ()) { gst_pad_link (src, sink); gst_pad_unlink (src, sink); THREAD_SWITCH (); } }
static gpointer delayed_flush (gpointer data) { GstPoll *set = data; THREAD_START (); g_usleep (500000); gst_poll_set_flushing (set, TRUE); return NULL; }
void gps_init(Stream *outstr) { cond_init(&wait_gps); monitor_pos = monitor_raw = false; uint16_t baud; GET_PARAM(GPS_BAUD, &baud); in = uart_rx_init(baud, FALSE); out = outstr; THREAD_START(nmeaListener, STACK_GPSLISTENER); make_output(GPSON); set_port(GPSON); }
static void thread_unref (GstMiniObject * mobj) { int j; THREAD_START (); for (j = 0; j < refs_per_thread; ++j) { gst_mini_object_unref (mobj); if (j % num_threads == 0) THREAD_SWITCH (); } }
static void thread_buffer_producer (MyBufferPool * pool) { int j; THREAD_START (); for (j = 0; j < recycle_buffer_count; ++j) { GstBuffer *buf = my_recycle_buffer_new (pool); gst_buffer_unref (buf); } pool->is_closed = TRUE; }
void usb_init() { /* Initialize USB Subsystem */ /* See makefile for mode constraints */ USB_Init(); sem_init(&cdc_run, 0); bcond_init(&usb_active, usb_con()); STREAM_INIT( cdc_instr, CDC_BUF_SIZE); STREAM_INIT( cdc_outstr, CDC_BUF_SIZE); cdc_outstr.kick = NULL; THREAD_START(usb_thread, STACK_USB); }
/* test thread-safe refcounting of GstMiniObject */ static void thread_ref (GstMiniObject * mobj) { int j; THREAD_START (); for (j = 0; j < refs_per_thread; ++j) { gst_mini_object_ref (mobj); if (j % num_threads == 0) THREAD_SWITCH (); } GST_DEBUG ("thread stopped"); }
static void thread_buffer_consumer (MyBufferPool * pool) { THREAD_START (); do { GstBuffer *buf; buf = my_buffer_pool_drain_one (pool); if (buf != NULL) my_recycle_buffer_destroy (MY_RECYCLE_BUFFER_CAST (buf)); THREAD_SWITCH (); } while (!pool->is_closed); }
int CThread::Start() { int status; THREAD_OBJ threadHandle; m_isRunning = true; // Here we start the thread. The entry point is the // run_internal() function, which on it's turn calls this->Run() THREAD_START(run_internal, this, threadHandle, m_SyncHandle, status); if (status != 0) m_isRunning = false; return status; }
/* thread function for threaded default name change test */ static gpointer thread_name_object_default (int *i) { int j; THREAD_START (); for (j = *i; j < num_objects; j += num_threads) { GstObject *o = GST_OBJECT (g_list_nth_data (object_list, j)); /* g_message ("THREAD %p: setting default name on object %d\n", g_thread_self (), j); */ gst_object_set_name (o, NULL); THREAD_SWITCH (); } /* thread is done, so let's return */ g_message ("THREAD %p: set name\n", g_thread_self ()); g_free (i); return NULL; }
void mon_activate(bool m) { /* Start if not on already */ bool tstart = m && !mon_on; /* Stop if not stopped already */ bool tstop = !m && mon_on; mon_on = m; FBQ* mq = (mon_on? &mon : NULL); hdlc_subscribe_rx(mq, 0); if (!mon_on || GET_BYTE_PARAM(TXMON_ON)) hdlc_monitor_tx(mq); if (tstart) THREAD_START(mon_thread, STACK_MONITOR); if (tstop) { hdlc_monitor_tx(NULL); hdlc_subscribe_rx(NULL, 0); fbq_signal(&mon); } }
static void thread_no_events(void *arg) { THREAD_T thread; struct basic_test_data *data = arg; struct timeval starttime, endtime; int i; exit_base = data->base; memset(times,0,sizeof(times)); for (i=0;i<5;++i) { event_assign(&time_events[i], data->base, -1, 0, note_time_cb, ×[i]); } evutil_gettimeofday(&starttime, NULL); THREAD_START(thread, register_events_subthread, data->base); event_base_loop(data->base, EVLOOP_NO_EXIT_ON_EMPTY); evutil_gettimeofday(&endtime, NULL); tt_assert(event_base_got_break(data->base)); THREAD_JOIN(thread); for (i=0; i<5; ++i) { struct timeval diff; double sec; evutil_timersub(×[i], &starttime, &diff); sec = diff.tv_sec + diff.tv_usec/1.0e6; TT_BLATHER(("event %d at %.4f seconds", i, sec)); } test_timeval_diff_eq(&starttime, ×[0], 100); test_timeval_diff_eq(&starttime, ×[1], 200); test_timeval_diff_eq(&starttime, ×[2], 400); test_timeval_diff_eq(&starttime, ×[3], 450); test_timeval_diff_eq(&starttime, ×[4], 500); test_timeval_diff_eq(&starttime, &endtime, 500); end: ; }
/*[ Method -------------------------------------------------------------------- Name: ivThreadWnd::createThread Description: Creates a new thread for handling window's message. Exceptions: Throws IvtException if thread cannot be created. Hazard Key: None API: no -----------------------------------------------------------------------------*/ BOOL ivThreadWnd::createThread() /*] END Method */ { if (mhThread) return TRUE; // set up main thread for processing THREAD_START(mhThread, ThreadWnd_ServiceThread, this); if(!mhThread) { // THREAD_START() failed. return FALSE; } // wait for thread to be started (reports the thread id) while (!mThreadId) { // TBD: add timeout ::Sleep(100); } return TRUE; }
/* thread function for threaded name change test */ static gpointer thread_name_object (GstObject * object) { gchar *thread_id = g_strdup_printf ("%p", g_thread_self ()); THREAD_START (); /* give main thread a head start */ g_usleep (100000); /* write our name repeatedly */ g_message ("THREAD %s: starting loop\n", thread_id); while (THREAD_TEST_RUNNING ()) { gst_object_set_name (object, thread_id); /* a minimal sleep invokes a thread switch */ THREAD_SWITCH (); } /* thread is done, so let's return */ g_message ("THREAD %s: set name\n", thread_id); g_free (thread_id); return NULL; }
static void thread_conditions_simple(void *arg) { struct timeval tv_signal, tv_timeout, tv_broadcast; struct alerted_record alerted[NUM_THREADS]; THREAD_T threads[NUM_THREADS]; struct cond_wait cond; int i; struct timeval launched_at; struct event wake_one; struct event wake_all; struct basic_test_data *data = arg; struct event_base *base = data->base; int n_timed_out=0, n_signal=0, n_broadcast=0; tv_signal.tv_sec = tv_timeout.tv_sec = tv_broadcast.tv_sec = 0; tv_signal.tv_usec = 30*1000; tv_timeout.tv_usec = 150*1000; tv_broadcast.tv_usec = 500*1000; EVTHREAD_ALLOC_LOCK(cond.lock, EVTHREAD_LOCKTYPE_RECURSIVE); EVTHREAD_ALLOC_COND(cond.cond); tt_assert(cond.lock); tt_assert(cond.cond); for (i = 0; i < NUM_THREADS; ++i) { memset(&alerted[i], 0, sizeof(struct alerted_record)); alerted[i].cond = &cond; } /* Threads 5 and 6 will be allowed to time out */ memcpy(&alerted[5].delay, &tv_timeout, sizeof(tv_timeout)); memcpy(&alerted[6].delay, &tv_timeout, sizeof(tv_timeout)); evtimer_assign(&wake_one, base, wake_one_timeout, &cond); evtimer_assign(&wake_all, base, wake_all_timeout, &cond); evutil_gettimeofday(&launched_at, NULL); /* Launch the threads... */ for (i = 0; i < NUM_THREADS; ++i) { THREAD_START(threads[i], wait_for_condition, &alerted[i]); } /* Start the timers... */ tt_int_op(event_add(&wake_one, &tv_signal), ==, 0); tt_int_op(event_add(&wake_all, &tv_broadcast), ==, 0); /* And run for a bit... */ event_base_dispatch(base); /* And wait till the threads are done. */ for (i = 0; i < NUM_THREADS; ++i) THREAD_JOIN(threads[i]); /* Now, let's see what happened. At least one of 5 or 6 should * have timed out. */ n_timed_out = alerted[5].timed_out + alerted[6].timed_out; tt_int_op(n_timed_out, >=, 1); tt_int_op(n_timed_out, <=, 2); for (i = 0; i < NUM_THREADS; ++i) { const struct timeval *target_delay; struct timeval target_time, actual_delay; if (alerted[i].timed_out) { TT_BLATHER(("%d looks like a timeout\n", i)); target_delay = &tv_timeout; tt_assert(i == 5 || i == 6); } else if (evutil_timerisset(&alerted[i].alerted_at)) { long diff1,diff2; evutil_timersub(&alerted[i].alerted_at, &launched_at, &actual_delay); diff1 = timeval_msec_diff(&actual_delay, &tv_signal); diff2 = timeval_msec_diff(&actual_delay, &tv_broadcast); if (abs(diff1) < abs(diff2)) { TT_BLATHER(("%d looks like a signal\n", i)); target_delay = &tv_signal; ++n_signal; } else { TT_BLATHER(("%d looks like a broadcast\n", i)); target_delay = &tv_broadcast; ++n_broadcast; } } else { TT_FAIL(("Thread %d never got woken", i)); continue; } evutil_timeradd(target_delay, &launched_at, &target_time); test_timeval_diff_leq(&target_time, &alerted[i].alerted_at, 0, 50); } tt_int_op(n_broadcast + n_signal + n_timed_out, ==, NUM_THREADS); tt_int_op(n_signal, ==, 1); end: ; }
static void broadsheet_start_watchdog_thread(void) { THREAD_START(broadsheet_watchdog_thread_id, &broadsheet_watchdog_thread_exit, broadsheet_watchdog_thread, BROADSHEET_WATCHDOG_THREAD_NAME); }
int main(int argc, char **argv) { natsConnection *conn = NULL; natsOptions *opts = NULL; natsSubscription *sub = NULL; natsStatus s = NATS_OK; struct event_base *evLoop= NULL; THREAD_T pub; threadInfo info; nats_Open(-1); opts = parseArgs(argc, argv, usage); printf("Sending %" PRId64 " messages to subject '%s'\n", total, subj); // One time initialization of things that we need. natsLibevent_Init(); // Create a loop. evLoop = event_base_new(); if (evLoop == NULL) s = NATS_ERR; // Indicate which loop and callbacks to use once connected. if (s == NATS_OK) s = natsOptions_SetEventLoop(opts, (void*) evLoop, natsLibevent_Attach, natsLibevent_Read, natsLibevent_Write, natsLibevent_Detach); if (s == NATS_OK) s = natsConnection_Connect(&conn, opts); if (s == NATS_OK) start = nats_Now(); if (s == NATS_OK) { info.conn = conn; info.status = NATS_OK; THREAD_START(pub, pubThread, (void*) &info); } if (s == NATS_OK) { event_base_dispatch(evLoop); THREAD_JOIN(pub); s = info.status; } if (s == NATS_OK) { printPerf("Sent", count, start, elapsed); } else { printf("Error: %d - %s\n", s, natsStatus_GetText(s)); nats_PrintLastErrorStack(stderr); } // Destroy all our objects to avoid report of memory leak natsSubscription_Destroy(sub); natsConnection_Destroy(conn); natsOptions_Destroy(opts); if (evLoop != NULL) event_base_free(evLoop); // To silence reports of memory still in used with valgrind nats_Close(); libevent_global_shutdown(); return 0; }