/* module_sigrokdecode.c */
extern SRD_PRIV PyObject *srd_logic_type;
+static void srd_inst_join_decode_thread(struct srd_decoder_inst *di);
+static void srd_inst_reset_state(struct srd_decoder_inst *di);
+SRD_PRIV void oldpins_array_free(struct srd_decoder_inst *di);
+
/** @endcond */
/**
di->channel_samples = g_malloc(di->dec_num_channels);
}
+ /* Default to the initial pins being the same as in sample 0. */
+ di->old_pins_array = g_array_sized_new(FALSE, TRUE, sizeof(uint8_t),
+ di->dec_num_channels);
+ g_array_set_size(di->old_pins_array, di->dec_num_channels);
+ memset(di->old_pins_array->data, SRD_INITIAL_PIN_SAME_AS_SAMPLE0,
+ di->dec_num_channels);
+
/* Create a new instance of this decoder class. */
if (!(di->py_inst = PyObject_CallObject(dec->py_dec, NULL))) {
if (PyErr_Occurred())
di->inbuf = NULL;
di->inbuflen = 0;
di->abs_cur_samplenum = 0;
- di->old_pins_array = NULL;
di->thread_handle = NULL;
di->got_new_samples = FALSE;
di->handled_all_samples = FALSE;
+ di->want_wait_terminate = FALSE;
+
+ /*
+ * Strictly speaking initialization of statically allocated
+ * condition and mutex variables (or variables allocated on the
+ * stack) is not required, but won't harm either. Explicitly
+ * running init() will better match subsequent clear() calls.
+ */
+ g_cond_init(&di->got_new_samples_cond);
+ g_cond_init(&di->handled_all_samples_cond);
+ g_mutex_init(&di->data_mutex);
/* Instance takes input from a frontend by default. */
sess->di_list = g_slist_append(sess->di_list, di);
return di;
}
+static void srd_inst_join_decode_thread(struct srd_decoder_inst *di)
+{
+ if (!di)
+ return;
+ if (!di->thread_handle)
+ return;
+
+ srd_dbg("%s: Joining decoder thread.", di->inst_id);
+
+ /*
+ * Terminate potentially running threads which still
+ * execute the decoder instance's decode() method.
+ */
+ srd_dbg("%s: Raising want_term, sending got_new.", di->inst_id);
+ g_mutex_lock(&di->data_mutex);
+ di->want_wait_terminate = TRUE;
+ g_cond_signal(&di->got_new_samples_cond);
+ g_mutex_unlock(&di->data_mutex);
+
+ srd_dbg("%s: Running join().", di->inst_id);
+ (void)g_thread_join(di->thread_handle);
+ srd_dbg("%s: Call to join() done.", di->inst_id);
+ di->thread_handle = NULL;
+
+ /*
+ * Reset condition and mutex variables, such that next
+ * operations on them will find them in a clean state.
+ */
+ g_cond_clear(&di->got_new_samples_cond);
+ g_cond_init(&di->got_new_samples_cond);
+ g_cond_clear(&di->handled_all_samples_cond);
+ g_cond_init(&di->handled_all_samples_cond);
+ g_mutex_clear(&di->data_mutex);
+ g_mutex_init(&di->data_mutex);
+}
+
+static void srd_inst_reset_state(struct srd_decoder_inst *di)
+{
+ if (!di)
+ return;
+
+ srd_dbg("%s: Resetting decoder state.", di->inst_id);
+
+ /*
+ * Reset internal state of the decoder.
+ */
+ condition_list_free(di);
+ match_array_free(di);
+ di->abs_start_samplenum = 0;
+ di->abs_end_samplenum = 0;
+ di->inbuf = NULL;
+ di->inbuflen = 0;
+ di->abs_cur_samplenum = 0;
+ oldpins_array_free(di);
+ di->got_new_samples = FALSE;
+ di->handled_all_samples = FALSE;
+ di->want_wait_terminate = FALSE;
+ /* Conditions and mutex got reset after joining the thread. */
+}
+
/**
* Stack a decoder instance on top of another.
*
/**
* Set the list of initial (assumed) pin values.
*
- * If the list already exists, do nothing.
- *
* @param di Decoder instance to use. Must not be NULL.
+ * @param initial_pins A GArray of uint8_t values. Must not be NULL.
*
- * @private
+ * @since 0.5.0
*/
-static void set_initial_pin_values(struct srd_decoder_inst *di)
+SRD_API int srd_inst_initial_pins_set_all(struct srd_decoder_inst *di, GArray *initial_pins)
{
int i;
GString *s;
- PyObject *py_initial_pins;
- if (!di || !di->py_inst) {
+ if (!di) {
srd_err("Invalid decoder instance.");
- return;
- }
-
- /* Nothing to do if di->old_pins_array is already != NULL. */
- if (di->old_pins_array) {
- srd_dbg("Initial pins already set, nothing to do.");
- return;
+ return SRD_ERR_ARG;
}
- /* Create an array of old (previous sample) pins, init to 0. */
- di->old_pins_array = g_array_sized_new(FALSE, TRUE, sizeof(uint8_t), di->dec_num_channels);
- g_array_set_size(di->old_pins_array, di->dec_num_channels);
+ if (!initial_pins)
+ return SRD_ERR_ARG;
- /* Check if the decoder has set self.initial_pins. */
- if (!PyObject_HasAttrString(di->py_inst, "initial_pins")) {
- srd_dbg("Initial pins: all 0 (self.initial_pins not set).");
- return;
+ if (initial_pins->len != (guint)di->dec_num_channels) {
+ srd_err("Incorrect number of channels (need %d, got %d).",
+ di->dec_num_channels, initial_pins->len);
+ return SRD_ERR_ARG;
}
- /* Get self.initial_pins. */
- py_initial_pins = PyObject_GetAttrString(di->py_inst, "initial_pins");
+ /* Sanity-check initial pin state values. */
+ for (i = 0; i < di->dec_num_channels; i++) {
+ if (initial_pins->data[i] <= 2)
+ continue;
+ srd_err("Invalid initial channel %d pin state: %d.",
+ i, initial_pins->data[i]);
+ return SRD_ERR_ARG;
+ }
- /* Fill di->old_pins_array based on self.initial_pins. */
s = g_string_sized_new(100);
for (i = 0; i < di->dec_num_channels; i++) {
- di->old_pins_array->data[i] = PyLong_AsLong(PyList_GetItem(py_initial_pins, i));
+ di->old_pins_array->data[i] = initial_pins->data[i];
g_string_append_printf(s, "%d, ", di->old_pins_array->data[i]);
}
s = g_string_truncate(s, s->len - 2);
srd_dbg("Initial pins: %s.", s->str);
g_string_free(s, TRUE);
+
+ return SRD_OK;
+}
+
+SRD_PRIV void oldpins_array_free(struct srd_decoder_inst *di)
+{
+ if (!di)
+ return;
+ if (!di->old_pins_array)
+ return;
+
+ srd_dbg("%s: Releasing initial pin state.", di->inst_id);
+
+ g_array_free(di->old_pins_array, TRUE);
+ di->old_pins_array = NULL;
}
/** @private */
}
Py_DecRef(py_res);
- /* Set the initial pins based on self.initial_pins. */
- set_initial_pin_values(di);
-
/* Set self.samplenum to 0. */
PyObject_SetAttrString(di->py_inst, "samplenum", PyLong_FromLong(0));
}
}
+static void update_old_pins_array_initial_pins(struct srd_decoder_inst *di)
+{
+ uint8_t sample;
+ int i, byte_offset, bit_offset;
+ const uint8_t *sample_pos;
+
+ if (!di || !di->dec_channelmap)
+ return;
+
+ sample_pos = di->inbuf + ((di->abs_cur_samplenum - di->abs_start_samplenum) * di->data_unitsize);
+
+ for (i = 0; i < di->dec_num_channels; i++) {
+ if (di->old_pins_array->data[i] != SRD_INITIAL_PIN_SAME_AS_SAMPLE0)
+ continue;
+ byte_offset = di->dec_channelmap[i] / 8;
+ bit_offset = di->dec_channelmap[i] % 8;
+ sample = *(sample_pos + byte_offset) & (1 << bit_offset) ? 1 : 0;
+ di->old_pins_array->data[i] = sample;
+ }
+}
+
static gboolean term_matches(const struct srd_decoder_inst *di,
struct srd_term *term, const uint8_t *sample_pos)
{
di->match_array = g_array_sized_new(FALSE, TRUE, sizeof(gboolean), num_conditions);
g_array_set_size(di->match_array, num_conditions);
+ /* Sample 0: Set di->old_pins_array for SRD_INITIAL_PIN_SAME_AS_SAMPLE0 pins. */
+ if (di->abs_cur_samplenum == 0)
+ update_old_pins_array_initial_pins(di);
+
for (i = 0, s = 0; i < num_samples_to_process; i++, s++, (di->abs_cur_samplenum)++) {
sample_pos = di->inbuf + ((di->abs_cur_samplenum - di->abs_start_samplenum) * di->data_unitsize);
*
* This function returns if there is an error, or when a match is found, or
* when all samples have been processed (whether a match was found or not).
+ * This function immediately terminates when the decoder's wait() method
+ * invocation shall get terminated.
*
* @param di The decoder instance to use. Must not be NULL.
* @param found_match Will be set to TRUE if at least one condition matched,
if (!di || !found_match)
return SRD_ERR_ARG;
+ *found_match = FALSE;
+ if (di->want_wait_terminate)
+ return SRD_OK;
+
/* Check if any of the current condition(s) match. */
while (TRUE) {
/* Feed the (next chunk of the) buffer to find_match(). */
{
PyObject *py_res;
struct srd_decoder_inst *di;
+ int wanted_term;
if (!data)
return NULL;
di = data;
- /* Call self.decode(). Only returns if the PD throws an exception. */
+ srd_dbg("%s: Starting thread routine for decoder.", di->inst_id);
+
+ /*
+ * Call self.decode(). Only returns if the PD throws an exception.
+ * "Regular" termination of the decode() method is not expected.
+ */
Py_IncRef(di->py_inst);
- if (!(py_res = PyObject_CallMethod(di->py_inst, "decode", NULL))) {
+ srd_dbg("%s: Calling decode() method.", di->inst_id);
+ py_res = PyObject_CallMethod(di->py_inst, "decode", NULL);
+ srd_dbg("%s: decode() method terminated.", di->inst_id);
+
+ /*
+ * Make sure to unblock potentially pending srd_inst_decode()
+ * calls in application threads after the decode() method might
+ * have terminated, while it neither has processed sample data
+ * nor has terminated upon request. This happens e.g. when "need
+ * a samplerate to decode" exception is thrown.
+ */
+ g_mutex_lock(&di->data_mutex);
+ wanted_term = di->want_wait_terminate;
+ di->want_wait_terminate = TRUE;
+ di->handled_all_samples = TRUE;
+ g_cond_signal(&di->handled_all_samples_cond);
+ g_mutex_unlock(&di->data_mutex);
+
+ /*
+ * Check for the termination cause of the decode() method.
+ * Though this is mostly for information.
+ */
+ if (!py_res && wanted_term) {
+ /*
+ * Silently ignore errors upon return from decode() calls
+ * when termination was requested. Terminate the thread
+ * which executed this instance's decode() logic.
+ */
+ srd_dbg("%s: Thread done (!res, want_term).", di->inst_id);
+ PyErr_Clear();
+ return NULL;
+ }
+ if (!py_res) {
+ /*
+ * The decode() invocation terminated unexpectedly. Have
+ * the back trace printed, and terminate the thread which
+ * executed the decode() method.
+ */
+ srd_dbg("%s: decode() terminated unrequested.", di->inst_id);
srd_exception_catch("Protocol decoder instance %s: ", di->inst_id);
- exit(1); /* TODO: Proper shutdown. This is a hack. */
+ srd_dbg("%s: Thread done (!res, !want_term).", di->inst_id);
return NULL;
}
+
+ /*
+ * TODO: By design the decode() method is not supposed to terminate.
+ * Nevertheless we have the thread joined, and srd backend calls to
+ * decode() will re-start another thread transparently.
+ */
+ srd_dbg("%s: decode() terminated (req %d).", di->inst_id, wanted_term);
Py_DecRef(py_res);
+ PyErr_Clear();
+
+ srd_dbg("%s: Thread done (with res).", di->inst_id);
return NULL;
}
Py_DecRef(py_res);
} else {
/* If this is the first call, start the worker thread. */
- if (!di->thread_handle)
- di->thread_handle = g_thread_new("di_thread",
+ if (!di->thread_handle) {
+ srd_dbg("No worker thread for this decoder stack "
+ "exists yet, creating one: %s.", di->inst_id);
+ di->thread_handle = g_thread_new(di->inst_id,
di_thread, di);
+ }
/* Push the new sample chunk to the worker thread. */
g_mutex_lock(&di->data_mutex);
di->inbuflen = inbuflen;
di->got_new_samples = TRUE;
di->handled_all_samples = FALSE;
+ di->want_wait_terminate = FALSE;
/* Signal the thread that we have new data. */
g_cond_signal(&di->got_new_samples_cond);
/* When all samples in this chunk were handled, return. */
g_mutex_lock(&di->data_mutex);
- while (!di->handled_all_samples)
+ while (!di->handled_all_samples && !di->want_wait_terminate)
g_cond_wait(&di->handled_all_samples_cond, &di->data_mutex);
g_mutex_unlock(&di->data_mutex);
}
srd_dbg("Freeing instance %s", di->inst_id);
+ srd_inst_join_decode_thread(di);
+ srd_inst_reset_state(di);
+
Py_DecRef(di->py_inst);
g_free(di->inst_id);
g_free(di->dec_channelmap);
projects / libsigrokdecode.git / blobdiff