X-Git-Url: https://sigrok.org/gitweb/?p=libsigrokdecode.git;a=blobdiff_plain;f=instance.c;h=6d38738b70d12bce88cf0c04c830103caad523f4;hp=79b72e18eb630ecb775892275cf554b78710d066;hb=cdb49509e85443129f2d60180eb818813030901e;hpb=3262ef0203e23399f3cab796391da06969c8306b diff --git a/instance.c b/instance.c index 79b72e1..6d38738 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 */ /** @@ -367,15 +371,26 @@ SRD_API struct srd_decoder_inst *srd_inst_new(struct srd_session *sess, di->condition_list = NULL; di->match_array = NULL; - di->start_samplenum = 0; - di->end_samplenum = 0; + di->abs_start_samplenum = 0; + di->abs_end_samplenum = 0; di->inbuf = NULL; di->inbuflen = 0; - di->cur_samplenum = 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 +399,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. * @@ -423,11 +498,43 @@ SRD_API int srd_inst_stack(struct srd_session *sess, return SRD_OK; } +/** + * Search a decoder instance and its stack for instance ID. + * + * @param[in] inst_id ID to search for. + * @param[in] stack A decoder instance, potentially with stacked instances. + * + * @return The matching instance, or NULL. + */ +static struct srd_decoder_inst *srd_inst_find_by_id_stack(const char *inst_id, + struct srd_decoder_inst *stack) +{ + const GSList *l; + struct srd_decoder_inst *tmp, *di; + + if (!strcmp(stack->inst_id, inst_id)) + return stack; + + /* Otherwise, look recursively in our stack. */ + di = NULL; + if (stack->next_di) { + for (l = stack->next_di; l; l = l->next) { + tmp = l->data; + if (!strcmp(tmp->inst_id, inst_id)) { + di = tmp; + break; + } + } + } + + return di; +} + /** * Find a decoder instance by its instance ID. * - * Only the bottom level of instances are searched -- instances already stacked - * on top of another one will not be found. + * This will recurse to find the instance anywhere in the stack tree of the + * given session. * * @param sess The session holding the protocol decoder instance. * @param inst_id The instance ID to be found. @@ -450,10 +557,8 @@ SRD_API struct srd_decoder_inst *srd_inst_find_by_id(struct srd_session *sess, di = NULL; for (l = sess->di_list; l; l = l->next) { tmp = l->data; - if (!strcmp(tmp->inst_id, inst_id)) { - di = tmp; + if ((di = srd_inst_find_by_id_stack(inst_id, tmp)) != NULL) break; - } } return di; @@ -567,6 +672,19 @@ static void set_initial_pin_values(struct srd_decoder_inst *di) g_string_free(s, TRUE); } +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 */ SRD_PRIV int srd_inst_start(struct srd_decoder_inst *di) { @@ -592,8 +710,8 @@ SRD_PRIV int srd_inst_start(struct srd_decoder_inst *di) /* Set self.samplenum to 0. */ PyObject_SetAttrString(di->py_inst, "samplenum", PyLong_FromLong(0)); - /* Set self.matches to None. */ - PyObject_SetAttrString(di->py_inst, "matches", Py_None); + /* Set self.matched to None. */ + PyObject_SetAttrString(di->py_inst, "matched", Py_None); /* Start all the PDs stacked on top of this one. */ for (l = di->next_di; l; l = l->next) { @@ -799,16 +917,16 @@ static gboolean find_match(struct srd_decoder_inst *di) return TRUE; } - num_samples_to_process = di->end_samplenum - di->cur_samplenum; + num_samples_to_process = di->abs_end_samplenum - di->abs_cur_samplenum; num_conditions = g_slist_length(di->condition_list); /* di->match_array is NULL here. Create a new GArray. */ di->match_array = g_array_sized_new(FALSE, TRUE, sizeof(gboolean), num_conditions); g_array_set_size(di->match_array, num_conditions); - for (i = 0, s = 0; i < num_samples_to_process; i++, s++, (di->cur_samplenum)++) { + for (i = 0, s = 0; i < num_samples_to_process; i++, s++, (di->abs_cur_samplenum)++) { - sample_pos = di->inbuf + ((di->cur_samplenum - di->start_samplenum) * di->data_unitsize); + sample_pos = di->inbuf + ((di->abs_cur_samplenum - di->abs_start_samplenum) * di->data_unitsize); /* Check whether the current sample matches at least one of the conditions (logical OR). */ /* IMPORTANT: We need to check all conditions, even if there was a match already! */ @@ -835,6 +953,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, @@ -850,15 +970,20 @@ 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(). */ *found_match = find_match(di); /* Did we handle all samples yet? */ - if (di->cur_samplenum >= di->end_samplenum) { - srd_dbg("Done, handled all samples (%" PRIu64 "/%" PRIu64 ").", - di->cur_samplenum, di->end_samplenum); + if (di->abs_cur_samplenum >= di->abs_end_samplenum) { + srd_dbg("Done, handled all samples (abs cur %" PRIu64 + " / abs end %" PRIu64 ").", + di->abs_cur_samplenum, di->abs_end_samplenum); return SRD_OK; } @@ -885,20 +1010,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; } @@ -906,11 +1085,45 @@ static gpointer di_thread(gpointer data) /** * Decode a chunk of samples. * + * The calls to this function must provide the samples that shall be + * used by the protocol decoder + * - in the correct order ([...]5, 6, 4, 7, 8[...] is a bug), + * - starting from sample zero (2, 3, 4, 5, 6[...] is a bug), + * - consecutively, with no gaps (0, 1, 2, 4, 5[...] is a bug). + * + * The start- and end-sample numbers are absolute sample numbers (relative + * to the start of the whole capture/file/stream), i.e. they are not relative + * 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, 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, 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, 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 start_samplenum The starting sample number for the buffer's sample - * set, relative to the start of capture. - * @param end_samplenum The ending sample number for the buffer's sample - * set, relative to the start of capture. + * @param abs_start_samplenum The absolute starting sample number for the + * buffer's sample set, relative to the start of capture. + * @param abs_end_samplenum The absolute ending sample number for the + * buffer's sample set, relative to the start of capture. * @param inbuf The buffer to decode. Must not be NULL. * @param inbuflen Length of the buffer. Must be > 0. * @param unitsize The number of bytes per sample. Must be > 0. @@ -920,7 +1133,7 @@ static gpointer di_thread(gpointer data) * @private */ SRD_PRIV int srd_inst_decode(struct srd_decoder_inst *di, - uint64_t start_samplenum, uint64_t end_samplenum, + uint64_t abs_start_samplenum, uint64_t abs_end_samplenum, const uint8_t *inbuf, uint64_t inbuflen, uint64_t unitsize) { PyObject *py_res; @@ -945,12 +1158,20 @@ SRD_PRIV int srd_inst_decode(struct srd_decoder_inst *di, return SRD_ERR_ARG; } + if (abs_start_samplenum != di->abs_cur_samplenum || + abs_end_samplenum < abs_start_samplenum) { + 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; + } + di->data_unitsize = unitsize; - srd_dbg("Decoding: start sample %" PRIu64 ", end sample %" + srd_dbg("Decoding: abs start sample %" PRIu64 ", abs end sample %" PRIu64 " (%" PRIu64 " samples, %" PRIu64 " bytes, unitsize = " - "%d), instance %s.", start_samplenum, end_samplenum, - end_samplenum - start_samplenum, inbuflen, di->data_unitsize, + "%d), instance %s.", abs_start_samplenum, abs_end_samplenum, + abs_end_samplenum - abs_start_samplenum, inbuflen, di->data_unitsize, di->inst_id); apiver = srd_decoder_apiver(di->decoder); @@ -963,7 +1184,7 @@ SRD_PRIV int srd_inst_decode(struct srd_decoder_inst *di, logic = PyObject_New(srd_logic, (PyTypeObject *)srd_logic_type); Py_INCREF(logic); logic->di = (struct srd_decoder_inst *)di; - logic->start_samplenum = start_samplenum; + logic->abs_start_samplenum = abs_start_samplenum; logic->itercnt = 0; logic->inbuf = (uint8_t *)inbuf; logic->inbuflen = inbuflen; @@ -972,26 +1193,31 @@ SRD_PRIV int srd_inst_decode(struct srd_decoder_inst *di, Py_IncRef(di->py_inst); if (!(py_res = PyObject_CallMethod(di->py_inst, "decode", - "KKO", start_samplenum, end_samplenum, logic))) { + "KKO", abs_start_samplenum, abs_end_samplenum, logic))) { srd_exception_catch("Protocol decoder instance %s", di->inst_id); return SRD_ERR_PYTHON; } + di->abs_cur_samplenum = abs_end_samplenum; 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->start_samplenum = start_samplenum; - di->end_samplenum = end_samplenum; + di->abs_start_samplenum = abs_start_samplenum; + di->abs_end_samplenum = abs_end_samplenum; di->inbuf = inbuf; 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); @@ -999,7 +1225,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); } @@ -1015,6 +1241,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);