Merge pull request #88 in SA/ble_examples from feature/add_heap_buffer_limit_to_sss_example to simplelink_cc2640r2_sdk-2.20-develop

Squashed commit of the following:

commit 93d0978a8d4cfdf71eadf5dc0f30fe118f102bc9
Author: Wennerfeldt <[email protected]>
Date:   Wed Oct 24 08:48:12 2018 +0200

    Added an "alloacte only if enough headroom" helper function that is sued
    by the streaming service to reserve heap for the BLE appliation/stack.

Author: Sean Lyons

examples/rtos/CC2640R2_LAUNCHXL/bleapps/simple_serial_socket_client/src/app/simple_serial_socket_client.c

@@ -9,7 +9,7 @@
  Target Device: CC2640R2
 
  ******************************************************************************
- 
+
  Copyright (c) 2018, Texas Instruments Incorporated
  All rights reserved.
 
@@ -165,6 +165,9 @@
 // UART read buffer size
 #define UART_MAX_READ_SIZE    (256)
 
+// Minimum heap headroom for BLE application
+#define MIN_HEAP_HEADROOM     (4000)
+
 // Application states
 enum
 {
@@ -515,6 +518,10 @@ static void SimpleSerialSocketClient_init(void)
   // Setup an initial read
   UART_read(uartHandle, uartReadBuffer, UART_MAX_READ_SIZE);
 
+  // Make sure to leave at least MIN_HEAP_HEADROOM of heap
+  // for the BLE stack application to operate.
+  SimpleStreamClient_setHeadroomLimit(MIN_HEAP_HEADROOM);
+
   // Setup the Central GAPRole Profile. For more information see the GAP section
   // in the User's Guide:
   // http://software-dl.ti.com/lprf/sdg-latest/html/
@@ -861,7 +868,7 @@ static void SimpleSerialSocketClient_processGATTMsg(gattMsgEvent_t *pMsg)
     if (pMsg->method == ATT_HANDLE_VALUE_NOTI)
     {
         uartMsg_t *newMsg;
-        newMsg = ICall_malloc(sizeof(uartMsg_t) + pMsg->msg.handleValueNoti.len);
+        newMsg = SimpleStreamClient_allocateWithHeadroom(sizeof(uartMsg_t) + pMsg->msg.handleValueNoti.len);
 
         if (newMsg) {
 

examples/rtos/CC2640R2_LAUNCHXL/bleapps/simple_serial_socket_client/src/app/simple_stream_profile_client.c

@@ -92,6 +92,8 @@ CONST uint8_t SimpleStreamServer_DataOutUUID[ATT_UUID_SIZE] =
 // Data queue to hold the outgoing data
 static List_List streamOutQueue;
 
+static uint16_t heapHeadroom = 0;
+
 /*********************************************************************
 * Service Discovery Table
 */
@@ -301,6 +303,57 @@ void SimpleStreamClient_disconnectStream()
     SimpleStreamClient_clearQueue();
 }
 
+/*********************************************************************
+ * @fn      SimpleStreamClient_setHeadroomLimit
+ *
+ * @brief   Sets the limit on how much heap that needs to be available
+ *          following a memory allocation.
+ *
+ * @param   minHeapHeadRoom - Smallest amount of free heap following
+ *          an memory allocation.
+ *
+ * @return  none
+ */
+void SimpleStreamClient_setHeadroomLimit(uint16_t minHeapHeadroom)
+{
+    // Store the minimal heap headroom limit
+    heapHeadroom = minHeapHeadroom;
+}
+
+/*********************************************************************
+ * @fn      SimpleStreamClient_allocateWithHeadroom
+ *
+ * @brief   Checks if there will be enough free heap left following
+ *          a memory allocation. If there is enough heap, it will allocate
+ *          the memory.
+ *
+ * @param   allocSize - number of bytes to be allocated
+ *
+ * @return  none
+ */
+void* SimpleStreamClient_allocateWithHeadroom(uint16_t allocSize)
+{
+    void *allocatedBuffer = NULL;
+    ICall_heapStats_t  stats;
+    ICall_CSState key;
+
+    // Perform this inside a critical section
+    key = ICall_enterCriticalSection();
+
+    // Get the current free heap
+    ICall_getHeapStats(&stats);
+
+    if (((int16_t) allocSize) < ((int16_t)(stats.totalFreeSize - heapHeadroom)))
+    {
+        allocatedBuffer = ICall_malloc(allocSize);
+    }
+
+    // Leave the critical section
+    ICall_leaveCriticalSection(key);
+
+    return allocatedBuffer;
+}
+
 /*********************************************************************
  * @fn      SimpleStreamClient_sendData
  *
@@ -317,14 +370,14 @@ void SimpleStreamClient_disconnectStream()
  */
 bStatus_t SimpleStreamClient_sendData(uint16_t connHandle, void *data, uint16_t len)
 {
-    bStatus_t ret = SUCCESS;
+    bStatus_t ret = bleMemAllocError;
     SimpleStreamNode_t* newNode;
 
     // Reject if service is not yet discovered
     if (NULL != streamServiceHandle.chars[0].handle)
     {
         // Store the data into the queue
-        newNode = (SimpleStreamNode_t*) ICall_malloc(sizeof(SimpleStreamNode_t) + len);
+        newNode = (SimpleStreamNode_t*) SimpleStreamClient_allocateWithHeadroom(sizeof(SimpleStreamNode_t) + len);
         if (newNode != NULL)
         {
             newNode->connHandle = connHandle;
@@ -344,10 +397,6 @@ bStatus_t SimpleStreamClient_sendData(uint16_t connHandle, void *data, uint16_t
                 ICall_free(newNode);
             }
         }
-        else
-        {
-            ret = bleMemAllocError;
-        }
     }
     else
     {

examples/rtos/CC2640R2_LAUNCHXL/bleapps/simple_serial_socket_client/src/app/simple_stream_profile_client.h

@@ -118,6 +118,19 @@ extern void      SimpleStreamClient_disconnectStream();
  *                                          and CCCD handle.
  */
 extern bStatus_t SimpleStreamClient_enableNotifications(uint16_t connHandle);
+
+/*
+ * SimpleStreamClient_setHeadroomLimit - Sets the limit on how much heap that needs to be available
+ *                                       following a memory allocation.
+ */
+extern void     SimpleStreamClient_setHeadroomLimit(uint16_t minHeapHeadroom);
+
+/*
+ * SimpleStreamClient_allocateWithHeadroom - Checks if there will be enough free heap left
+ *                                           following a memory allocation. If there is
+ *                                           enough heap, it will allocate the memory.
+ */
+extern void*    SimpleStreamClient_allocateWithHeadroom(uint16_t allocSize);
 /*********************************************************************
 *********************************************************************/
 

examples/rtos/CC2640R2_LAUNCHXL/bleapps/simple_serial_socket_server/src/app/simple_serial_socket_server.c

@@ -9,7 +9,7 @@
  Target Device: CC2640R2
 
  ******************************************************************************
- 
+
  Copyright (c) 2018, Texas Instruments Incorporated
  All rights reserved.
 
@@ -139,6 +139,9 @@
 //  UART read buffer size
 #define UART_MAX_READ_SIZE    (256)
 
+// Minimum heap headroom for BLE application
+#define MIN_HEAP_HEADROOM     (4000)
+
 /*********************************************************************
  * TYPEDEFS
  */
@@ -435,7 +438,7 @@ static void uartWriteCallback(UART_Handle handle, void *txBuf, size_t size)
     // Free the last printed buffer
     if (NULL != uartCurrentMsg)
     {
-        free(uartCurrentMsg);
+        ICall_free(uartCurrentMsg);
         uartCurrentMsg = NULL;
     }
 
@@ -491,7 +494,7 @@ static void SimpleStreamServer_incomingDataCB(uint16_t connHandle,
 {
     // Try to allocate and store the data to our UART write queue
     uartMsg_t *newMsg;
-    newMsg = malloc(sizeof(uartMsg_t) + len);
+    newMsg = SimpleStreamServer_allocateWithHeadroom(sizeof(uartMsg_t) + len);
 
     if (newMsg)
     {
@@ -667,6 +670,9 @@ static void SimpleSerialSocketServer_init(void)
   // Initialize Simple data stream service
   SimpleStreamServer_AddService(GATT_ALL_SERVICES);
   SimpleStreamServer_RegisterAppCBs(&SimpleStreamServer_SimpleStreamServerProfileCBs);
+  // Make sure to leave at least MIN_HEAP_HEADROOM of heap
+  // for the BLE stack application to operate.
+  SimpleStreamServer_setHeadroomLimit(MIN_HEAP_HEADROOM);
 
   // Register to connection events
   SimpleSerialSocketServer_RegisterToAllConnectionEvent(FOR_STREAM);
@@ -1027,13 +1033,13 @@ static void SimpleSerialSocketServer_processAppMsg(ssssEvt_t *pMsg)
       }
 
     // Connection event
-	case SSSS_CONN_EVT:
+    case SSSS_CONN_EVT:
       {
         SimpleSerialSocketServer_processConnEvt((Gap_ConnEventRpt_t *)(pMsg->pData));
 
         ICall_free(pMsg->pData);
         break;
-	  }
+      }
 
     default:
       // Do nothing.
@@ -1201,5 +1207,6 @@ static uint8_t SimpleSerialSocketServer_enqueueMsg(uint8_t event, uint8_t state,
 
   return FALSE;
 }
+
 /*********************************************************************
 *********************************************************************/

examples/rtos/CC2640R2_LAUNCHXL/bleapps/simple_serial_socket_server/src/app/simple_stream_profile_server.c

@@ -95,6 +95,8 @@ static SimpleStreamServerCBs_t *pAppCBs = NULL;
 // Data queue to hold the outgoing data
 static List_List streamOutQueue;
 
+static uint16_t heapHeadroom = 0;
+
 /*********************************************************************
 * Profile Attributes - variables
 */
@@ -526,6 +528,57 @@ void SimpleStreamServer_disconnectStream()
     SimpleStreamServer_clearQueue();
 }
 
+/*********************************************************************
+ * @fn      SimpleStreamServer_setHeadroomLimit
+ *
+ * @brief   Sets the limit on how much heap that needs to be available
+ *          following a memory allocation.
+ *
+ * @param   minHeapHeadRoom - Smallest amount of free heap following
+ *          an memory allocation.
+ *
+ * @return  none
+ */
+void SimpleStreamServer_setHeadroomLimit(uint16_t minHeapHeadroom)
+{
+    // Store the minimal heap headroom limit
+    heapHeadroom = minHeapHeadroom;
+}
+
+/*********************************************************************
+ * @fn      SimpleStreamServer_allocateWithHeadroom
+ *
+ * @brief   Checks if there will be enough free heap left following
+ *          a memory allocation. If there is enough heap, it will allocate
+ *          the memory.
+ *
+ * @param   allocSize - number of bytes to be allocated
+ *
+ * @return  none
+ */
+void* SimpleStreamServer_allocateWithHeadroom(uint16_t allocSize)
+{
+    void *allocatedBuffer = NULL;
+    ICall_heapStats_t  stats;
+    ICall_CSState key;
+
+    // Perform this inside a critical section
+    key = ICall_enterCriticalSection();
+
+    // Get the current free heap
+    ICall_getHeapStats(&stats);
+
+    if (((int16_t) allocSize) < ((int16_t)(stats.totalFreeSize - heapHeadroom)))
+    {
+        allocatedBuffer = ICall_malloc(allocSize);
+    }
+
+    // Leave the critical section
+    ICall_leaveCriticalSection(key);
+
+    return allocatedBuffer;
+}
+
 /*********************************************************************
  * @fn      SimpleStreamServer_sendData
  *
@@ -542,12 +595,11 @@ void SimpleStreamServer_disconnectStream()
  */
 bStatus_t SimpleStreamServer_sendData(uint16_t connHandle, void *data, uint16_t len)
 {
-    bStatus_t ret = SUCCESS;
+    bStatus_t ret = bleMemAllocError;
     SimpleStreamNode_t* newNode;
 
-
     // Store the data into the queue
-    newNode = (SimpleStreamNode_t*) ICall_malloc(sizeof(SimpleStreamNode_t) + len);
+    newNode = (SimpleStreamNode_t*) SimpleStreamServer_allocateWithHeadroom(sizeof(SimpleStreamNode_t) + len);
     if (newNode != NULL)
     {
         newNode->connHandle = connHandle;
@@ -567,10 +619,6 @@ bStatus_t SimpleStreamServer_sendData(uint16_t connHandle, void *data, uint16_t
             ICall_free(newNode);
         }
     }
-    else
-    {
-        ret = bleMemAllocError;
-    }
 
     return ret;
 }

examples/rtos/CC2640R2_LAUNCHXL/bleapps/simple_serial_socket_server/src/app/simple_stream_profile_server.h

@@ -117,7 +117,7 @@ typedef struct
  *                                 GATT attributes with the GATT server.
  *
  */
-extern bStatus_t SimpleStreamServer_AddService( uint32_t rspTaskId);
+extern bStatus_t SimpleStreamServer_AddService( uint32_t rspTaskId );
 
 /*
  * SimpleStreamServer_RegisterAppCBs - Registers the application callback function.
@@ -147,6 +147,19 @@ extern bStatus_t SimpleStreamServer_processStream();
  *                                       Clear and free up the existing outgoing stream queue.
  */
 extern void      SimpleStreamServer_disconnectStream();
+
+/*
+ * SimpleStreamServer_setHeadroomLimit - Sets the limit on how much heap that needs to be available
+ *                                       following a memory allocation.
+ */
+extern void     SimpleStreamServer_setHeadroomLimit(uint16_t minHeapHeadroom);
+
+/*
+ * SimpleStreamServer_allocateWithHeadroom - Checks if there will be enough free heap left
+ *                                           following a memory allocation. If there is
+ *                                           enough heap, it will allocate the memory.
+ */
+extern void*    SimpleStreamServer_allocateWithHeadroom(uint16_t allocSize);
 /*********************************************************************
 *********************************************************************/