various speed-ups in TF_WriteImpl and elsewhere

remotes/github/faster
Ondřej Hruška 6 years ago
parent 5687196bdd
commit 3654bf2206
Signed by: MightyPork
GPG Key ID: 2C5FD5035250423D
  1. 62
      TinyFrame/TF_Integration.c
  2. 10
      TinyFrame/TinyFrame.c
  3. 2
      TinyFrame/TinyFrame.h
  4. 2
      USB/usbd_cdc_if.c
  5. 8
      comm/messages.c
  6. 2
      freertos.c
  7. 3
      units/adc/_adc_core.c

@ -4,48 +4,40 @@
// TinyFrame integration // TinyFrame integration
// //
#include <USB/usb_device.h>
#include "platform.h" #include "platform.h"
#include "task_main.h" #include "task_main.h"
#include "USB/usbd_cdc_if.h" #include "USB/usbd_cdc_if.h"
#include "USB/usb_device.h"
#include "TinyFrame.h" #include "TinyFrame.h"
extern osSemaphoreId semVcomTxReadyHandle; extern osSemaphoreId semVcomTxReadyHandle;
extern osMutexId mutTinyFrameTxHandle; extern osMutexId mutTinyFrameTxHandle;
static volatile bool first_tx = false; // XXX global
void TF_WriteImpl(TinyFrame *tf, const uint8_t *buff, uint32_t len) void TF_WriteImpl(TinyFrame *tf, const uint8_t *buff, uint32_t len)
{ {
#if 1 #if 1
// if (!first_tx) { const uint32_t real_size = len;
// // wait for the last USB transmission to be finished
// int32_t mxStatus; // Padding to a multiple of 64 bytes - this is supposed to maximize the bulk transfer speed
// mxStatus = osSemaphoreWait(semVcomTxReadyHandle, 100);
// if (mxStatus != osOK) {
// TF_Error("Tx stalled");
// return;
// }
// }
// first_tx = false;
// Padding to a multiple of 64 bytes
if (len&0x3F) { if (len&0x3F) {
uint32_t pad = (64 - (len&0x3F)); uint32_t pad = (64 - (len&0x3F));
memset((void *) (buff + len), 0, pad); memset((void *) (buff + len), 0, pad);
len += pad; // padding to a multiple of 64 (size of the endpoint) len += pad; // padding to a multiple of 64 (size of the endpoint)
} }
// We bypass the USBD driver library's overhead by using the HAL function directly
assert_param(HAL_OK == HAL_PCD_EP_Transmit(hUsbDeviceFS.pData, CDC_IN_EP, (uint8_t *) buff, len)); assert_param(HAL_OK == HAL_PCD_EP_Transmit(hUsbDeviceFS.pData, CDC_IN_EP, (uint8_t *) buff, len));
// Wait for the semaphore - HAL keeps a pointer to the buffer, and it's the TinyFrame Tx buffer, // The buffer is the TF transmit buffer, we can't leave it to work asynchronously because
// so if we let it process it in the background, it could get corrupted before the Tx is completed. // the next call could modify it before it's been transmitted (in the case of a chunked / multi-part frame)
int32_t mxStatus;
mxStatus = osSemaphoreWait(semVcomTxReadyHandle, 100); // the assumption here is that all until the last chunk use the full buffer capacity
if (mxStatus != osOK) { if (real_size == TF_SENDBUF_LEN) {
TF_Error("Tx stalled"); if (pdTRUE != xSemaphoreTake(semVcomTxReadyHandle, 100)) {
return; TF_Error("Tx stalled in WriteImpl");
return;
}
} }
#else #else
(void) tf; (void) tf;
@ -76,20 +68,18 @@ void TF_WriteImpl(TinyFrame *tf, const uint8_t *buff, uint32_t len)
bool TF_ClaimTx(TinyFrame *tf) bool TF_ClaimTx(TinyFrame *tf)
{ {
(void) tf; (void) tf;
// assert_param(osThreadGetId() != tskMainHandle); // assert_param(!inIRQ()); // useless delay
assert_param(!inIRQ()); assert_param(pdTRUE == xSemaphoreTake(mutTinyFrameTxHandle, 5000)); // trips the wd
assert_param(osOK == osMutexWait(mutTinyFrameTxHandle, 5000));
// // wait for the last USB transmission to be finished // The last chunk from some previous frame may still be being transmitted,
// int32_t mxStatus; // wait for it to finish (the semaphore is given in the CDC tx done handler)
// mxStatus = osSemaphoreWait(semVcomTxReadyHandle, 100); if (pdTRUE != xSemaphoreTake(semVcomTxReadyHandle, 100)) {
// if (mxStatus != osOK) { TF_Error("Tx stalled in Claim");
// TF_Error("Tx stalled");
// return false;
// }
first_tx = true; // release the guarding mutex again
assert_param(pdTRUE == xSemaphoreGive(mutTinyFrameTxHandle));
return false;
}
return true; return true;
} }
@ -98,5 +88,7 @@ bool TF_ClaimTx(TinyFrame *tf)
void TF_ReleaseTx(TinyFrame *tf) void TF_ReleaseTx(TinyFrame *tf)
{ {
(void) tf; (void) tf;
assert_param(osOK == osMutexRelease(mutTinyFrameTxHandle)); assert_param(pdTRUE == xSemaphoreGive(mutTinyFrameTxHandle));
// the last payload is sent asynchronously
} }

@ -870,7 +870,11 @@ static inline uint32_t _TF_FN TF_ComposeTail(uint8_t *outbuff, TF_CKSUM *cksum)
*/ */
static bool _TF_FN TF_SendFrame_Begin(TinyFrame *tf, TF_Msg *msg, TF_Listener listener, TF_TICKS timeout) static bool _TF_FN TF_SendFrame_Begin(TinyFrame *tf, TF_Msg *msg, TF_Listener listener, TF_TICKS timeout)
{ {
TF_TRY(TF_ClaimTx(tf)); bool suc = TF_ClaimTx(tf);
if (!suc) {
TF_Error("TF lock not free");
return false;
}
tf->tx_pos = (uint32_t) TF_ComposeHead(tf, tf->sendbuf, msg); // frame ID is incremented here if it's not a response tf->tx_pos = (uint32_t) TF_ComposeHead(tf, tf->sendbuf, msg); // frame ID is incremented here if it's not a response
tf->tx_len = msg->len; tf->tx_len = msg->len;
@ -1031,10 +1035,10 @@ bool _TF_FN TF_Query_Multipart(TinyFrame *tf, TF_Msg *msg, TF_Listener listener,
return TF_Query(tf, msg, listener, timeout); return TF_Query(tf, msg, listener, timeout);
} }
void _TF_FN TF_Respond_Multipart(TinyFrame *tf, TF_Msg *msg) bool _TF_FN TF_Respond_Multipart(TinyFrame *tf, TF_Msg *msg)
{ {
msg->data = NULL; msg->data = NULL;
TF_Respond(tf, msg); return TF_Respond(tf, msg);
} }
void _TF_FN TF_Multipart_Payload(TinyFrame *tf, const uint8_t *buff, uint32_t length) void _TF_FN TF_Multipart_Payload(TinyFrame *tf, const uint8_t *buff, uint32_t length)

@ -369,7 +369,7 @@ bool TF_Query_Multipart(TinyFrame *tf, TF_Msg *msg, TF_Listener listener, TF_TIC
* TF_Respond() with multipart payload. * TF_Respond() with multipart payload.
* msg.data is ignored and set to NULL * msg.data is ignored and set to NULL
*/ */
void TF_Respond_Multipart(TinyFrame *tf, TF_Msg *msg); bool TF_Respond_Multipart(TinyFrame *tf, TF_Msg *msg);
/** /**
* Send the payload for a started multipart frame. This can be called multiple times * Send the payload for a started multipart frame. This can be called multiple times

@ -314,7 +314,7 @@ void USBD_CDC_TransmitDone(USBD_HandleTypeDef *pdev)
assert_param(inIRQ()); assert_param(inIRQ());
portBASE_TYPE taskWoken = pdFALSE; portBASE_TYPE taskWoken = pdFALSE;
assert_param(xSemaphoreGiveFromISR(semVcomTxReadyHandle, &taskWoken) == pdTRUE); assert_param(pdTRUE == xSemaphoreGiveFromISR(semVcomTxReadyHandle, &taskWoken));
portYIELD_FROM_ISR(taskWoken); portYIELD_FROM_ISR(taskWoken);
} }
/* USER CODE END PRIVATE_FUNCTIONS_IMPLEMENTATION */ /* USER CODE END PRIVATE_FUNCTIONS_IMPLEMENTATION */

@ -65,7 +65,7 @@ static void settings_bulkread_cb(BulkRead *bulk, uint32_t chunk, uint8_t *buffer
if (buffer == NULL) { if (buffer == NULL) {
free_ck(bulk); free_ck(bulk);
iw_end(); iw_end();
dbg("INI read complete."); // dbg("INI read complete.");
return; return;
} }
@ -81,7 +81,7 @@ static void settings_bulkread_cb(BulkRead *bulk, uint32_t chunk, uint8_t *buffer
*/ */
static TF_Result lst_ini_export(TinyFrame *tf, TF_Msg *msg) static TF_Result lst_ini_export(TinyFrame *tf, TF_Msg *msg)
{ {
dbg("Bulk read INI file"); // dbg("Bulk read INI file");
BulkRead *bulk = malloc_ck(sizeof(BulkRead)); BulkRead *bulk = malloc_ck(sizeof(BulkRead));
assert_param(bulk != NULL); assert_param(bulk != NULL);
@ -114,7 +114,7 @@ static void settings_bulkwrite_cb(BulkWrite *bulk, const uint8_t *chunk, uint32_
if (bulk->offset > 0) { if (bulk->offset > 0) {
settings_load_ini_end(); settings_load_ini_end();
dbg("INI write complete"); // dbg("INI write complete");
} else { } else {
dbg("INI write failed"); dbg("INI write failed");
} }
@ -131,7 +131,7 @@ static void settings_bulkwrite_cb(BulkWrite *bulk, const uint8_t *chunk, uint32_
*/ */
static TF_Result lst_ini_import(TinyFrame *tf, TF_Msg *msg) static TF_Result lst_ini_import(TinyFrame *tf, TF_Msg *msg)
{ {
dbg("Bulk write INI file"); // dbg("Bulk write INI file");
BulkWrite *bulk = malloc_ck(sizeof(BulkWrite)); BulkWrite *bulk = malloc_ck(sizeof(BulkWrite));
assert_param(bulk); assert_param(bulk);

@ -169,7 +169,7 @@ void MX_FREERTOS_Init(void) {
/* USER CODE BEGIN RTOS_SEMAPHORES */ /* USER CODE BEGIN RTOS_SEMAPHORES */
/* add semaphores, ... */ /* add semaphores, ... */
// xSemaphoreGive(semVcomTxReadyHandle); xSemaphoreGive(semVcomTxReadyHandle);
/* USER CODE END RTOS_SEMAPHORES */ /* USER CODE END RTOS_SEMAPHORES */
/* USER CODE BEGIN RTOS_TIMERS */ /* USER CODE BEGIN RTOS_TIMERS */

@ -40,7 +40,8 @@ static void UADC_JobSendBlockChunk(Job *job)
.len = (TF_LEN) (1 /*seq*/ + count * sizeof(uint16_t)), .len = (TF_LEN) (1 /*seq*/ + count * sizeof(uint16_t)),
.type = type, .type = type,
}; };
TF_Respond_Multipart(comm, &msg);
assert_param(true == TF_Respond_Multipart(comm, &msg));
TF_Multipart_Payload(comm, &priv->stream_serial, 1); TF_Multipart_Payload(comm, &priv->stream_serial, 1);
TF_Multipart_Payload(comm, (uint8_t *) (priv->dma_buffer + start), count * sizeof(uint16_t)); TF_Multipart_Payload(comm, (uint8_t *) (priv->dma_buffer + start), count * sizeof(uint16_t));
TF_Multipart_Close(comm); TF_Multipart_Close(comm);

Loading…
Cancel
Save