Feature/jenkins

Jenkinsfile

@@ -0,0 +1,72 @@
+@Library('xmos_jenkins_shared_library@v0.28.0') _
+
+def runningOn(machine) {
+ println "Stage running on:"
+ println machine
+}
+
+getApproval()
+
+pipeline {
+ agent {
+ label 'linux&&x86_64'
+ }
+
+ options {
+ skipDefaultCheckout()
+ timestamps()
+ buildDiscarder(xmosDiscardBuildSettings(onlyArtifacts=true))
+ }
+
+ parameters {
+ string(
+ name: 'TOOLS_VERSION',
+ defaultValue: '15.2.1',
+ description: 'The XTC tools version'
+ )
+ } // parameters
+
+ environment {
+ XMOSDOC_VERSION = "v5.1.1"
+ } // environment
+
+ stages {
+ stage('Setup') {
+ steps {
+ runningOn(env.NODE_NAME)
+ dir("fwk_io") {
+ checkout scm
+ sh 'git submodule update --init --recursive'
+ }
+ createVenv("fwk_io/test/requirements.txt")
+ dir("fwk_io/test") {
+ // build everything
+ withVenv {
+ withTools(params.TOOLS_VERSION) {
+ sh "pip install -Ur requirements.txt"
+ }
+ }
+ }
+ } //steps
+ } // stage
+
+ stage('Build HIL tests') {
+ steps {
+ dir("fwk_io/test") {
+ // build everything
+ withVenv {
+ withTools(params.TOOLS_VERSION) {
+ sh "sh ./build_hil_tests.sh"
+ }
+ }
+ }
+ } // steps
+ post {
+ cleanup {
+ xcoreCleanSandbox()
+ }
+ } // post
+ } // stage
+ } // stages
+}
+

test/build_hil_tests.sh

@@ -1,9 +1,9 @@
-#!/bin/bash
+#!/bin/sh
 set -e
 
 FRAMEWORK_IO_ROOT=`git rev-parse --show-toplevel`
 
-source ${FRAMEWORK_IO_ROOT}/tools/ci/helper_functions.sh
+. ${FRAMEWORK_IO_ROOT}/tools/ci/helper_functions.sh
 
 # perform builds
 ## TODO replace with build and running tests

test/build_lib_i2s_tests.sh

@@ -9,18 +9,6 @@ source ${FRAMEWORK_IO_ROOT}/tools/ci/helper_functions.sh
 
 # row format is: "make_target BOARD toolchain"
 declare -a applications=(
- "test_hil_backpressure_test_32_768000_4_5_5"
- "test_hil_backpressure_test_32_768000_4_0_10"
- "test_hil_backpressure_test_32_768000_4_10_0"
- "test_hil_backpressure_test_32_768000_3_5_5"
- "test_hil_backpressure_test_32_768000_3_0_10"
- "test_hil_backpressure_test_32_768000_3_10_0"
- "test_hil_backpressure_test_32_768000_2_5_5"
- "test_hil_backpressure_test_32_768000_2_0_10"
- "test_hil_backpressure_test_32_768000_2_10_0"
- "test_hil_backpressure_test_32_768000_1_5_5"
- "test_hil_backpressure_test_32_768000_1_0_10"
- "test_hil_backpressure_test_32_768000_1_10_0"
  "test_hil_backpressure_test_32_384000_4_5_5"
  "test_hil_backpressure_test_32_384000_4_0_10"
  "test_hil_backpressure_test_32_384000_4_10_0"
@@ -81,18 +69,6 @@ declare -a applications=(
  "test_hil_i2s_slave_test_32_1_4_0_inv"
  "test_hil_i2s_slave_test_32_1_0_4_inv"
  "test_hil_i2s_slave_test_32_1_2_2_inv"
- "test_hil_backpressure_test_16_768000_4_5_5"
- "test_hil_backpressure_test_16_768000_4_0_10"
- "test_hil_backpressure_test_16_768000_4_10_0"
- "test_hil_backpressure_test_16_768000_3_5_5"
- "test_hil_backpressure_test_16_768000_3_0_10"
- "test_hil_backpressure_test_16_768000_3_10_0"
- "test_hil_backpressure_test_16_768000_2_5_5"
- "test_hil_backpressure_test_16_768000_2_0_10"
- "test_hil_backpressure_test_16_768000_2_10_0"
- "test_hil_backpressure_test_16_768000_1_5_5"
- "test_hil_backpressure_test_16_768000_1_0_10"
- "test_hil_backpressure_test_16_768000_1_10_0"
  "test_hil_backpressure_test_16_384000_4_5_5"
  "test_hil_backpressure_test_16_384000_4_0_10"
  "test_hil_backpressure_test_16_384000_4_10_0"

test/lib_i2s/backpressure_test/backpressure_test.cmake

@@ -24,7 +24,7 @@ set(APP_LINK_OPTIONS
 # Tile Targets
 #**********************
 if(NOT DEFINED ENV{SAMPLE_RATES})
- set(SAMPLE_RATES 768000 384000 192000)
+ set(SAMPLE_RATES 384000 192000)
 else()
  set(SAMPLE_RATES $ENV{SAMPLE_RATES})
 endif()

test/lib_i2s/backpressure_test/src/main.c

@@ -14,7 +14,7 @@
 #define BURN_THREADS 6
 #endif
 #ifndef SAMPLE_FREQUENCY
-#define SAMPLE_FREQUENCY 768000
+#define SAMPLE_FREQUENCY 192000
 #endif
 #ifndef TEST_LEN
 #define TEST_LEN 1000
@@ -44,6 +44,127 @@
 
 #define SETSR(c) asm volatile("setsr %0" : : "n"(c));
 
+enum {
+ SAMPLE_RATE_192000,
+ SAMPLE_RATE_384000,
+ NUM_SAMPLE_RATES
+}e_sample_rates;
+
+enum {
+ BITDEPTH_16,
+ BITDEPTH_32,
+ NUM_BIT_DEPTHS
+}e_bit_depth;
+
+enum {
+ NUM_I2S_LINES_1,
+ NUM_I2S_LINES_2,
+ NUM_I2S_LINES_3,
+ NUM_I2S_LINES_4,
+}e_channel_config;
+
+static int acceptable_receive_delay = 0, acceptable_send_delay = 0;
+static int acceptable_delay_ticks[NUM_SAMPLE_RATES][NUM_I2S_LINES_4+1][NUM_BIT_DEPTHS];
+
+static inline void populate_acceptable_delay_ticks()
+{
+ // These numbers are logged by running the test and logging the delay at the last passing iteration
+ // before the backpressure test starts failing. So, on top of the bare minimum code in the i2s_send()
+ // and i2s_receive() functions in this file plus their calling overheads, we have acceptable_delay_ticks number
+ // of cycles per send and receive callback function call to add any extra processing.
+
+ // 192 KHz
+ acceptable_delay_ticks[SAMPLE_RATE_192000][NUM_I2S_LINES_1][BITDEPTH_16] = 170;
+ acceptable_delay_ticks[SAMPLE_RATE_192000][NUM_I2S_LINES_1][BITDEPTH_32] = 185;
+ acceptable_delay_ticks[SAMPLE_RATE_192000][NUM_I2S_LINES_2][BITDEPTH_16] = 140;
+ acceptable_delay_ticks[SAMPLE_RATE_192000][NUM_I2S_LINES_2][BITDEPTH_32] = 155;
+ acceptable_delay_ticks[SAMPLE_RATE_192000][NUM_I2S_LINES_3][BITDEPTH_16] = 105;
+ acceptable_delay_ticks[SAMPLE_RATE_192000][NUM_I2S_LINES_3][BITDEPTH_32] = 125;
+ acceptable_delay_ticks[SAMPLE_RATE_192000][NUM_I2S_LINES_4][BITDEPTH_16] = 70;
+ acceptable_delay_ticks[SAMPLE_RATE_192000][NUM_I2S_LINES_4][BITDEPTH_32] = 90;
+
+ // 384 KHz
+ acceptable_delay_ticks[SAMPLE_RATE_384000][NUM_I2S_LINES_1][BITDEPTH_16] = 50;
+ acceptable_delay_ticks[SAMPLE_RATE_384000][NUM_I2S_LINES_1][BITDEPTH_32] = 55;
+ acceptable_delay_ticks[SAMPLE_RATE_384000][NUM_I2S_LINES_2][BITDEPTH_16] = 15;
+ acceptable_delay_ticks[SAMPLE_RATE_384000][NUM_I2S_LINES_2][BITDEPTH_32] = 25;
+ // For 384 KHz, we have non-zero backpressure only up to 2 channels
+ acceptable_delay_ticks[SAMPLE_RATE_384000][NUM_I2S_LINES_3][BITDEPTH_16] = 0;
+ acceptable_delay_ticks[SAMPLE_RATE_384000][NUM_I2S_LINES_3][BITDEPTH_32] = 0;
+ acceptable_delay_ticks[SAMPLE_RATE_384000][NUM_I2S_LINES_4][BITDEPTH_16] = 0;
+ acceptable_delay_ticks[SAMPLE_RATE_384000][NUM_I2S_LINES_4][BITDEPTH_32] = 0;
+}
+
+void get_acceptable_delay()
+{
+ int sample_rate;
+ if(SAMPLE_FREQUENCY == 192000)
+ {
+ sample_rate = SAMPLE_RATE_192000;
+ }
+ else if(SAMPLE_FREQUENCY == 384000)
+ {
+ sample_rate = SAMPLE_RATE_384000;
+ }
+ else
+ {
+ printf("ERROR: Invalid sample rate %d\n", SAMPLE_FREQUENCY);
+ _Exit(1);
+ }
+
+ int bit_depth;
+ if(DATA_BITS == 16)
+ {
+ bit_depth = BITDEPTH_16;
+ }
+ else if(DATA_BITS == 32)
+ {
+ bit_depth = BITDEPTH_32;
+ }
+ else
+ {
+ printf("ERROR: Invalid bit_depth %d\n", DATA_BITS);
+ _Exit(1);
+ }
+ if((NUM_I2S_LINES < 1) || (NUM_I2S_LINES > 4))
+ {
+ printf("ERROR: Invalid NUM_I2S_LINES %d\n", NUM_I2S_LINES);
+ _Exit(1);
+ }
+ int delay = acceptable_delay_ticks[sample_rate][NUM_I2S_LINES-1][bit_depth];
+
+ if(delay <= 0)
+ {
+ printf("ERROR: Invalid delay %d. Check if testing an unsupported configuration\n", delay);
+ _Exit(1);
+ }
+
+ // get the send and receive delay based on the
+ if((RECEIVE_DELAY_INCREMENT == 5) && (SEND_DELAY_INCREMENT == 5))
+ {
+ // Backpressure passes at delay, so add another increment number of ticks to get to the first fail instance
+ acceptable_receive_delay = delay + 5;
+ acceptable_send_delay = delay + 5;
+ }
+ else if((RECEIVE_DELAY_INCREMENT == 0) && (SEND_DELAY_INCREMENT == 10))
+ {
+ // Backpressure passes at 2*delay, so add another increment number of ticks to get to the first fail instance
+ acceptable_receive_delay = 0;
+ acceptable_send_delay = 2*delay + 10;
+ }
+ else if((RECEIVE_DELAY_INCREMENT == 10) && (SEND_DELAY_INCREMENT == 0))
+ {
+ // Backpressure passes at 2*delay, so add another increment number of ticks to get to the first fail instance
+ acceptable_receive_delay = 2*delay + 10;
+ acceptable_send_delay = 0;
+ }
+ else
+ {
+ printf("ERROR: Unsupported receive (%d) and send (%d) delay increment combination\n", RECEIVE_DELAY_INCREMENT, SEND_DELAY_INCREMENT);
+ _Exit(1);
+ }
+}
+
 /* Ports and clocks used by the application */
 port_t p_lrclk = XS1_PORT_1G;
 port_t p_bclk = XS1_PORT_1H;
@@ -54,8 +175,9 @@ port_t p_din [4] = {XS1_PORT_1I, XS1_PORT_1J, XS1_PORT_1K, XS1_PORT_1L};
 xclock_t mclk = XS1_CLKBLK_1;
 xclock_t bclk = XS1_CLKBLK_2;
 
-static volatile int receive_delay = 5000;
+static volatile int receive_delay = 0;
 static volatile int send_delay = 0;
+static volatile int32_t receive_data_store[8];
 
 void i2s_init(void *app_data, i2s_config_t *i2s_config)
 {
@@ -75,6 +197,9 @@ void i2s_send(void *app_data, size_t n, int32_t *send_data)
 
 void i2s_receive(void *app_data, size_t n, int32_t *receive_data)
 {
+ for (size_t c = 0; c < n; c++) {
+ receive_data_store[c] = receive_data[c];
+ }
  if (receive_delay) {
  delay_ticks(receive_delay);
  }
@@ -85,11 +210,6 @@ i2s_restart_t i2s_restart_check(void *app_data)
  return I2S_NO_RESTART;
 }
 
-#if DATA_BITS == 32
-#define OVERHEAD_TICKS 185 // Some of the period needs to be allowed for the callbacks
-#else
-#define OVERHEAD_TICKS 185 // Non-32b data widths take longer to process
-#endif
 #define JITTER 1 //Allow for rounding so does not break when diff = period + 1
 #define N_CYCLES_AT_DELAY 1 //How many LR clock cycles to measure at each backpressure delay value
 #define DIFF_WRAP_16(new, old) (new > old ? new - old : new + 0x10000 - old)
@@ -121,28 +241,40 @@ void test_lr_period() {
  port_set_trigger_in_equal(p_lr_test, 0);
  (void) port_in(p_lr_test);
  counter++;
- if (counter == N_CYCLES_AT_DELAY) {
- receive_delay += RECEIVE_DELAY_INCREMENT;
- send_delay += SEND_DELAY_INCREMENT;
- if ((receive_delay + send_delay) > (period - OVERHEAD_TICKS)) {
- printf("PASS\n");
- _Exit(0);
- }
- counter = 0;
- }
+
  port_set_trigger_in_equal(p_lr_test, 1);
  (void) port_in(p_lr_test);
  time = port_get_trigger_time(p_lr_test);
 
  int diff = DIFF_WRAP_16(time, time_old);
  if (diff > (period + JITTER)) {
- printf("Backpressure breaks at receive delay ticks=%d, send delay ticks=%d\n",
- receive_delay, send_delay);
- printf("actual diff: %d, maximum (period + Jitter): %d\n",
- diff, (period + JITTER));
- _Exit(1);
+ // The delay we're able to add in the i2s_receive() function should be acceptable_receive_delay ticks or more
+ if(receive_delay < acceptable_receive_delay)
+ {
+ printf("Backpressure breaks at receive delay ticks = %d, acceptable receive delay = %d\n",
+ receive_delay, acceptable_receive_delay);
+ printf("actual diff: %d, maximum (period + Jitter): %d\n", diff, (period + JITTER));
+ _Exit(1);
+ }
+
+ // The delay we're able to add in the i2s_send() function should be acceptable_send_delay ticks or more
+ if(send_delay < acceptable_send_delay)
+ {
+ printf("Backpressure breaks at send delay ticks = %d, acceptable send delay = %d\n",
+ send_delay, acceptable_send_delay);
+ printf("actual diff: %d, maximum (period + Jitter): %d\n", diff, (period + JITTER));
+ _Exit(1);
+ }
+ printf("PASS\n");
+ _Exit(0);
+ }
+
+ if (counter == N_CYCLES_AT_DELAY) {
+ receive_delay += RECEIVE_DELAY_INCREMENT;
+ send_delay += SEND_DELAY_INCREMENT;
+ counter = 0;
  }
- time_old = time;
+  time_old = time;
  }
 }
 
@@ -153,6 +285,9 @@ void burn(void) {
 }
 
 int main() {
+ populate_acceptable_delay_ticks();
+ get_acceptable_delay();
+
  i2s_callback_group_t i_i2s = {
  .init = (i2s_init_t) i2s_init,
  .restart_check = (i2s_restart_check_t) i2s_restart_check,

test/lib_i2s/test_backpressure.py

@@ -5,7 +5,7 @@
 import subprocess
 from pathlib import Path
 
-sample_rate_args = {"768kbps": 768000, "384kbps": 384000, "192kbps": 192000}
+sample_rate_args = {"384kbps": 384000, "192kbps": 192000}
 
 num_channels_args = {"1ch": 1, "2ch": 2, "3ch": 3, "4ch": 4}
 
@@ -17,7 +17,12 @@
 
 bitdepth_args = {"16b": 16, "32b": 32}
 
+# 384000 has a non-zero backpressure only upto 2 channels
+def uncollect_if(bitdepth, sample_rate, num_channels, receive_increment, send_increment):
+ if sample_rate == 384000 and num_channels > 2:
+ return True
 
+@pytest.mark.uncollect_if(func=uncollect_if)
 @pytest.mark.parametrize("bitdepth", bitdepth_args.values(), ids=bitdepth_args.keys())
 @pytest.mark.parametrize(
  "sample_rate", sample_rate_args.values(), ids=sample_rate_args.keys()
@@ -41,9 +46,6 @@ def test_i2s_backpressure(
  send_increment,
  bitdepth,
 ):
- if (num_channels != 4) and not nightly:
- pytest.skip("Only run 4 channel tests unless it is a nightly")
-
  id_string = (
  f"{bitdepth}_{sample_rate}_{num_channels}_{receive_increment}_{send_increment}"
  )