X-Git-Url: https://sigrok.org/gitweb/?p=libsigrokdecode.git;a=blobdiff_plain;f=instance.c;h=61e0ea895360df67b76375fe1e7bbac868cc0cf6;hp=0e27ca31e1190edb2e8269ce9a08f53d4f948b21;hb=97b874bd0b6913ed52df1b8aac5e7491479fac9a;hpb=de23c992a48b5f9f145a7c26a62f10cd5b87b218

diff --git a/instance.c b/instance.c
index 0e27ca3..61e0ea8 100644
--- a/instance.c
+++ b/instance.c
@@ -33,6 +33,10 @@ extern SRD_PRIV GSList *sessions;
 /* 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 */
 
 /**
@@ -349,6 +353,13 @@ SRD_API struct srd_decoder_inst *srd_inst_new(struct srd_session *sess,
 		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())
@@ -372,10 +383,20 @@ SRD_API struct srd_decoder_inst *srd_inst_new(struct srd_session *sess,
 	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);
@@ -384,6 +405,66 @@ SRD_API struct srd_decoder_inst *srd_inst_new(struct srd_session *sess,
 	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.
  *
@@ -550,51 +631,62 @@ SRD_PRIV struct srd_decoder_inst *srd_inst_find_by_obj(const GSList *stack,
 /**
  * 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 */
@@ -616,9 +708,6 @@ SRD_PRIV int srd_inst_start(struct srd_decoder_inst *di)
 	}
 	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));
 
@@ -752,6 +841,27 @@ static void update_old_pins_array(struct srd_decoder_inst *di,
 	}
 }
 
+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)
 {
@@ -836,6 +946,10 @@ static gboolean find_match(struct srd_decoder_inst *di)
 	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);
@@ -865,6 +979,8 @@ static gboolean find_match(struct srd_decoder_inst *di)
  *
  * 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,
@@ -880,6 +996,10 @@ SRD_PRIV int process_samples_until_condition_match(struct srd_decoder_inst *di,
 	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(). */
@@ -916,20 +1036,74 @@ static gpointer di_thread(gpointer data)
 {
 	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;
 }
@@ -948,28 +1122,28 @@ static gpointer di_thread(gpointer data)
  * sample numbers within the chunk specified by 'inbuf' and 'inbuflen'.
  *
  * Correct example (4096 samples total, 4 chunks @ 1024 samples each):
- *   srd_inst_decode(di, 0,    1023, inbuf, 1024, 1);
- *   srd_inst_decode(di, 1024, 2047, inbuf, 1024, 1);
- *   srd_inst_decode(di, 2048, 3071, inbuf, 1024, 1);
- *   srd_inst_decode(di, 3072, 4095, inbuf, 1024, 1);
+ *   srd_inst_decode(di, 0,    1024, inbuf, 1024, 1);
+ *   srd_inst_decode(di, 1024, 2048, inbuf, 1024, 1);
+ *   srd_inst_decode(di, 2048, 3072, inbuf, 1024, 1);
+ *   srd_inst_decode(di, 3072, 4096, inbuf, 1024, 1);
  *
  * The chunk size ('inbuflen') can be arbitrary and can differ between calls.
  *
  * Correct example (4096 samples total, 7 chunks @ various samples each):
- *   srd_inst_decode(di, 0,    1023, inbuf, 1024, 1);
- *   srd_inst_decode(di, 1024, 1123, inbuf,  100, 1);
- *   srd_inst_decode(di, 1124, 1423, inbuf,  300, 1);
- *   srd_inst_decode(di, 1424, 1642, inbuf,  219, 1);
- *   srd_inst_decode(di, 1643, 2047, inbuf,  405, 1);
- *   srd_inst_decode(di, 2048, 3071, inbuf, 1024, 1);
- *   srd_inst_decode(di, 3072, 4095, inbuf, 1024, 1);
+ *   srd_inst_decode(di, 0,    1024, inbuf, 1024, 1);
+ *   srd_inst_decode(di, 1024, 1124, inbuf,  100, 1);
+ *   srd_inst_decode(di, 1124, 1424, inbuf,  300, 1);
+ *   srd_inst_decode(di, 1424, 1643, inbuf,  219, 1);
+ *   srd_inst_decode(di, 1643, 2048, inbuf,  405, 1);
+ *   srd_inst_decode(di, 2048, 3072, inbuf, 1024, 1);
+ *   srd_inst_decode(di, 3072, 4096, inbuf, 1024, 1);
  *
  * INCORRECT example (4096 samples total, 4 chunks @ 1024 samples each, but
  * the start- and end-samplenumbers are not absolute):
- *   srd_inst_decode(di, 0,    1023, inbuf, 1024, 1);
- *   srd_inst_decode(di, 0,    1023, inbuf, 1024, 1);
- *   srd_inst_decode(di, 0,    1023, inbuf, 1024, 1);
- *   srd_inst_decode(di, 0,    1023, inbuf, 1024, 1);
+ *   srd_inst_decode(di, 0,    1024, inbuf, 1024, 1);
+ *   srd_inst_decode(di, 0,    1024, inbuf, 1024, 1);
+ *   srd_inst_decode(di, 0,    1024, inbuf, 1024, 1);
+ *   srd_inst_decode(di, 0,    1024, inbuf, 1024, 1);
  *
  * @param di The decoder instance to call. Must not be NULL.
  * @param abs_start_samplenum The absolute starting sample number for the
@@ -1012,7 +1186,9 @@ SRD_PRIV int srd_inst_decode(struct srd_decoder_inst *di,
 
 	if (abs_start_samplenum != di->abs_cur_samplenum ||
 	    abs_end_samplenum < abs_start_samplenum) {
-		srd_dbg("incorrect sample numbers");
+		srd_dbg("Incorrect sample numbers: start=%" PRIu64 ", cur=%"
+			PRIu64 ", end=%" PRIu64 ".", abs_start_samplenum,
+			di->abs_cur_samplenum, abs_end_samplenum);
 		return SRD_ERR_ARG;
 	}
 
@@ -1052,9 +1228,12 @@ SRD_PRIV int srd_inst_decode(struct srd_decoder_inst *di,
 		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);
@@ -1064,6 +1243,7 @@ SRD_PRIV int srd_inst_decode(struct srd_decoder_inst *di,
 		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);
@@ -1071,7 +1251,7 @@ SRD_PRIV int srd_inst_decode(struct srd_decoder_inst *di,
 
 		/* 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);
 	}
@@ -1087,6 +1267,9 @@ SRD_PRIV void srd_inst_free(struct srd_decoder_inst *di)
 
 	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);