From 733373a049d8a06fab00628bcae585550fac6d07 Mon Sep 17 00:00:00 2001 From: Rodrigo Garcia Date: Thu, 3 Oct 2024 03:37:44 -0300 Subject: [PATCH 1/5] Update FreeRTOS Symbols in OThreadCLI (#10412) * Update OThreadCLI.cpp * feat(openthread): change FreeRTOS names and types * feat(openthread): change FreeRTOS names and types QueueHandle_t instead of xQueueHandle --- libraries/OpenThread/README.md | 2 +- libraries/OpenThread/src/OThreadCLI.cpp | 6 +++--- libraries/OpenThread/src/OThreadCLI.h | 2 +- 3 files changed, 5 insertions(+), 5 deletions(-) diff --git a/libraries/OpenThread/README.md b/libraries/OpenThread/README.md index f8ea94f1c..cd9deb9eb 100644 --- a/libraries/OpenThread/README.md +++ b/libraries/OpenThread/README.md @@ -19,7 +19,7 @@ Below are the details of the class: ```cpp class OpenThreadCLI : public Stream { private: - static size_t setBuffer(xQueueHandle &queue, size_t len); + static size_t setBuffer(QueueHandle_t &queue, size_t len); bool otStarted = false; public: diff --git a/libraries/OpenThread/src/OThreadCLI.cpp b/libraries/OpenThread/src/OThreadCLI.cpp index cb29584c1..9190f09bc 100644 --- a/libraries/OpenThread/src/OThreadCLI.cpp +++ b/libraries/OpenThread/src/OThreadCLI.cpp @@ -21,8 +21,8 @@ static TaskHandle_t s_cli_task = NULL; static TaskHandle_t s_console_cli_task = NULL; -static xQueueHandle rx_queue = NULL; -static xQueueHandle tx_queue = NULL; +static QueueHandle_t rx_queue = NULL; +static QueueHandle_t tx_queue = NULL; static esp_openthread_platform_config_t ot_native_config; static TaskHandle_t s_ot_task = NULL; @@ -389,7 +389,7 @@ size_t OpenThreadCLI::write(uint8_t c) { return 1; } -size_t OpenThreadCLI::setBuffer(xQueueHandle &queue, size_t queue_len) { +size_t OpenThreadCLI::setBuffer(QueueHandle_t &queue, size_t queue_len) { if (queue) { vQueueDelete(queue); queue = NULL; diff --git a/libraries/OpenThread/src/OThreadCLI.h b/libraries/OpenThread/src/OThreadCLI.h index 3d18589a0..689b4a567 100644 --- a/libraries/OpenThread/src/OThreadCLI.h +++ b/libraries/OpenThread/src/OThreadCLI.h @@ -22,7 +22,7 @@ typedef std::function OnReceiveCb_t; class OpenThreadCLI : public Stream { private: - static size_t setBuffer(xQueueHandle &queue, size_t len); + static size_t setBuffer(QueueHandle_t &queue, size_t len); bool otStarted = false; public: From 5d873c0787fa96675f74b68d16b9b8a3a2a048ea Mon Sep 17 00:00:00 2001 From: sivar2311 Date: Fri, 4 Oct 2024 12:49:55 +0200 Subject: [PATCH 2/5] Add conditional compilation for second I2C interface based on SOC_I2C_NUM (#10408) The ESP32, ESP32-S and ESP32-H series have two I2C interfaces, while the ESP32-C series has only one. --- libraries/Wire/src/Wire.cpp | 2 ++ libraries/Wire/src/Wire.h | 2 ++ 2 files changed, 4 insertions(+) diff --git a/libraries/Wire/src/Wire.cpp b/libraries/Wire/src/Wire.cpp index 047795f94..8ac0c2559 100644 --- a/libraries/Wire/src/Wire.cpp +++ b/libraries/Wire/src/Wire.cpp @@ -646,6 +646,8 @@ void TwoWire::onRequestService(uint8_t num, void *arg) { #endif /* SOC_I2C_SUPPORT_SLAVE */ TwoWire Wire = TwoWire(0); +#if SOC_I2C_NUM > 1 TwoWire Wire1 = TwoWire(1); +#endif /* SOC_I2C_NUM */ #endif /* SOC_I2C_SUPPORTED */ diff --git a/libraries/Wire/src/Wire.h b/libraries/Wire/src/Wire.h index fcf94313d..cf720d482 100644 --- a/libraries/Wire/src/Wire.h +++ b/libraries/Wire/src/Wire.h @@ -144,7 +144,9 @@ public: }; extern TwoWire Wire; +#if SOC_I2C_NUM > 1 extern TwoWire Wire1; +#endif /* SOC_I2C_NUM */ #endif /* SOC_I2C_SUPPORTED */ #endif /* TwoWire_h */ From 13511a6b6559634ff77550ed0719114183b8d910 Mon Sep 17 00:00:00 2001 From: Lucas Saavedra Vaz <32426024+lucasssvaz@users.noreply.github.com> Date: Fri, 4 Oct 2024 07:51:47 -0300 Subject: [PATCH 3/5] ci(tests): Add linpack FPU tests (#10389) * ci(tests): Add linpack FPU tests * fix(linpack): Change prints to log_d * fix(linpack): Fix number of runs check * ci(pre-commit): Apply automatic fixes * fix(spelling): Correct spelling mistakes --------- Co-authored-by: pre-commit-ci-lite[bot] <117423508+pre-commit-ci-lite[bot]@users.noreply.github.com> --- tests/performance/linpack_double/ci.json | 6 + .../linpack_double/linpack_double.ino | 1094 +++++++++++++++++ .../linpack_double/test_linpack_double.py | 61 + tests/performance/linpack_float/ci.json | 6 + .../linpack_float/linpack_float.ino | 1094 +++++++++++++++++ .../linpack_float/test_linpack_float.py | 61 + 6 files changed, 2322 insertions(+) create mode 100644 tests/performance/linpack_double/ci.json create mode 100644 tests/performance/linpack_double/linpack_double.ino create mode 100644 tests/performance/linpack_double/test_linpack_double.py create mode 100644 tests/performance/linpack_float/ci.json create mode 100644 tests/performance/linpack_float/linpack_float.ino create mode 100644 tests/performance/linpack_float/test_linpack_float.py diff --git a/tests/performance/linpack_double/ci.json b/tests/performance/linpack_double/ci.json new file mode 100644 index 000000000..accee2b21 --- /dev/null +++ b/tests/performance/linpack_double/ci.json @@ -0,0 +1,6 @@ +{ + "platforms": { + "qemu": false, + "wokwi": false + } +} diff --git a/tests/performance/linpack_double/linpack_double.ino b/tests/performance/linpack_double/linpack_double.ino new file mode 100644 index 000000000..5148b6ef5 --- /dev/null +++ b/tests/performance/linpack_double/linpack_double.ino @@ -0,0 +1,1094 @@ +/* + Linpack test for Arduino and ESP32. + Based on https://github.com/VioletGiraffe/EmbeddedLinpack + Created by Violet Giraffe, 2018 + Adapted by Lucas Saavedra Vaz, 2024 +*/ + +#include +#include + +// Number of runs to average +#define N_RUNS 1000 + +using floating_point_t = double; +bool type_float; + +floating_point_t benchmark(void); +floating_point_t cpu_time(void); +void daxpy(int n, floating_point_t da, floating_point_t dx[], int incx, floating_point_t dy[], int incy); +floating_point_t ddot(int n, floating_point_t dx[], int incx, floating_point_t dy[], int incy); +int dgefa(floating_point_t a[], int lda, int n, int ipvt[]); +void dgesl(floating_point_t a[], int lda, int n, int ipvt[], floating_point_t b[], int job); +void dscal(int n, floating_point_t sa, floating_point_t x[], int incx); +int idamax(int n, floating_point_t dx[], int incx); +floating_point_t r8_abs(floating_point_t x); +floating_point_t r8_epsilon(void); +floating_point_t r8_max(floating_point_t x, floating_point_t y); +floating_point_t r8_random(int iseed[4]); +void r8mat_gen(int lda, int n, floating_point_t *a); + +void setup() { + Serial.begin(115200); + while (!Serial) { + delay(10); + } + + String data_type; + + if (sizeof(floating_point_t) == sizeof(float)) { + data_type = "float"; + type_float = true; + } else if (sizeof(floating_point_t) == sizeof(double)) { + data_type = "double"; + type_float = false; + } else { + data_type = "unknown"; + log_e("Unknown data type size. Aborting."); + while (1); + } + + log_d("Starting Linpack %s test", data_type.c_str()); + Serial.printf("Runs: %d\n", N_RUNS); + Serial.printf("Type: %s\n", data_type.c_str()); + Serial.flush(); + int i = 0; + + floating_point_t minMflops = 1000000000.0, maxMflops = 0.0, avgMflops = 0.0; + for (i = 0; i < N_RUNS; ++i) { + Serial.printf("Run %d\n", i); + const auto mflops = benchmark(); + avgMflops += mflops; + minMflops = fmin(mflops, minMflops); + maxMflops = fmax(mflops, maxMflops); + Serial.flush(); + } + + avgMflops /= N_RUNS; + Serial.println(String("Runs completed: ") + i); + Serial.println(String("Average MFLOPS: ") + avgMflops); + Serial.println(String("Min MFLOPS: ") + minMflops); + Serial.println(String("Max MFLOPS: ") + maxMflops); + Serial.flush(); +} + +void loop() { + vTaskDelete(NULL); +} + +/******************************************************************************/ + +floating_point_t benchmark(void) + +/******************************************************************************/ +/* + Purpose: + + MAIN is the main program for LINPACK_BENCH. + + Discussion: + + LINPACK_BENCH drives the floating_point_t precision LINPACK benchmark program. + + Modified: + + 25 July 2008 + + Parameters: + + N is the problem size. +*/ +{ +#define N 8 +#define LDA (N + 1) + + static floating_point_t a[N * LDA]; + static floating_point_t a_max; + static floating_point_t b[N]; + static floating_point_t b_max; + const floating_point_t cray = 0.056; + static floating_point_t eps; + int i; + int info; + static int ipvt[N]; + int j; + int job; + floating_point_t ops; + static floating_point_t resid[N]; + floating_point_t resid_max; + [[maybe_unused]] + floating_point_t residn; + static floating_point_t rhs[N]; + floating_point_t t1; + floating_point_t t2; + static floating_point_t time[6]; + floating_point_t total; + floating_point_t x[N]; + + log_d("LINPACK_BENCH"); + log_d(" C version"); + log_d(" The LINPACK benchmark."); + log_d(" Language: C"); + if (!type_float) { + log_d(" Datatype: Double precision real"); + } else if (type_float) { + log_d(" Datatype: Single precision real"); + } else { + log_d(" Datatype: unknown"); + } + log_d(" Matrix order N = %d", N); + log_d(" Leading matrix dimension LDA = %d", LDA); + + ops = (floating_point_t)(2L * N * N * N) / 3.0 + 2.0 * (floating_point_t)((long)N * N); + + /* + Allocate space for arrays. +*/ + r8mat_gen(LDA, N, a); + + a_max = 0.0; + for (j = 0; j < N; j++) { + for (i = 0; i < N; i++) { + a_max = r8_max(a_max, a[i + j * LDA]); + } + } + + for (i = 0; i < N; i++) { + x[i] = 1.0; + } + + for (i = 0; i < N; i++) { + b[i] = 0.0; + for (j = 0; j < N; j++) { + b[i] = b[i] + a[i + j * LDA] * x[j]; + } + } + t1 = cpu_time(); + + info = dgefa(a, LDA, N, ipvt); + + if (info != 0) { + log_d("LINPACK_BENCH - Fatal error!"); + log_d(" The matrix A is apparently singular."); + log_d(" Abnormal end of execution."); + return 1; + } + + t2 = cpu_time(); + time[0] = t2 - t1; + + t1 = cpu_time(); + + job = 0; + dgesl(a, LDA, N, ipvt, b, job); + + t2 = cpu_time(); + time[1] = t2 - t1; + + total = time[0] + time[1]; + + /* + Compute a residual to verify results. +*/ + r8mat_gen(LDA, N, a); + + for (i = 0; i < N; i++) { + x[i] = 1.0; + } + + for (i = 0; i < N; i++) { + rhs[i] = 0.0; + for (j = 0; j < N; j++) { + rhs[i] = rhs[i] + a[i + j * LDA] * x[j]; + } + } + + for (i = 0; i < N; i++) { + resid[i] = -rhs[i]; + for (j = 0; j < N; j++) { + resid[i] = resid[i] + a[i + j * LDA] * b[j]; + } + } + + resid_max = 0.0; + for (i = 0; i < N; i++) { + resid_max = r8_max(resid_max, r8_abs(resid[i])); + } + + b_max = 0.0; + for (i = 0; i < N; i++) { + b_max = r8_max(b_max, r8_abs(b[i])); + } + + eps = r8_epsilon(); + + residn = resid_max / (floating_point_t)N / a_max / b_max / eps; + + time[2] = total; + if (0.0 < total) { + time[3] = ops / (1.0E+06 * total); + } else { + time[3] = -1.0; + } + time[4] = 2.0 / time[3]; + time[5] = total / cray; + + log_d(""); + log_d(" Norm. Resid Resid MACHEP X[1] X[N]"); + log_d(" %14f %14f %14e %14f %14f", residn, resid_max, eps, b[0], b[N - 1]); + log_d(""); + log_d(" Factor Solve Total MFLOPS Unit Cray-Ratio"); + log_d(" %9f %9f %9f %9f %9f %9f", time[0], time[1], time[2], time[3], time[4], time[5]); + + /* + Terminate. +*/ + log_d(""); + log_d("LINPACK_BENCH"); + log_d(" Normal end of execution."); + log_d(""); + + return time[3]; +#undef LDA +#undef N +} +/******************************************************************************/ + +floating_point_t cpu_time(void) + +/******************************************************************************/ +/* + Purpose: + + CPU_TIME returns the current reading on the CPU clock. + + Discussion: + + The CPU time measurements available through this routine are often + not very accurate. In some cases, the accuracy is no better than + a hundredth of a second. + + Licensing: + + This code is distributed under the GNU LGPL license. + + Modified: + + 06 June 2005 + + Author: + + John Burkardt + + Parameters: + + Output, floating_point_t CPU_TIME, the current reading of the CPU clock, in seconds. +*/ +{ + floating_point_t value; + + value = (floating_point_t)micros() / (floating_point_t)1000000; + + return value; +} +/******************************************************************************/ + +void daxpy(int n, floating_point_t da, floating_point_t dx[], int incx, floating_point_t dy[], int incy) + +/******************************************************************************/ +/* + Purpose: + + DAXPY computes constant times a vector plus a vector. + + Discussion: + + This routine uses unrolled loops for increments equal to one. + + Modified: + + 30 March 2007 + + Author: + + FORTRAN77 original by Jack Dongarra, Cleve Moler, Jim Bunch, Pete Stewart. + C version by John Burkardt + + Reference: + + Jack Dongarra, Cleve Moler, Jim Bunch, Pete Stewart, + LINPACK User's Guide, + SIAM, 1979. + + Charles Lawson, Richard Hanson, David Kincaid, Fred Krogh, + Basic Linear Algebra Subprograms for Fortran Usage, + Algorithm 539, + ACM Transactions on Mathematical Software, + Volume 5, Number 3, September 1979, pages 308-323. + + Parameters: + + Input, int N, the number of elements in DX and DY. + + Input, floating_point_t DA, the multiplier of DX. + + Input, floating_point_t DX[*], the first vector. + + Input, int INCX, the increment between successive entries of DX. + + Input/output, floating_point_t DY[*], the second vector. + On output, DY[*] has been replaced by DY[*] + DA * DX[*]. + + Input, int INCY, the increment between successive entries of DY. +*/ +{ + int i; + int ix; + int iy; + int m; + + if (n <= 0) { + return; + } + + if (da == 0.0) { + return; + } + /* + Code for unequal increments or equal increments + not equal to 1. +*/ + if (incx != 1 || incy != 1) { + if (0 <= incx) { + ix = 0; + } else { + ix = (-n + 1) * incx; + } + + if (0 <= incy) { + iy = 0; + } else { + iy = (-n + 1) * incy; + } + + for (i = 0; i < n; i++) { + dy[iy] = dy[iy] + da * dx[ix]; + ix = ix + incx; + iy = iy + incy; + } + } + /* + Code for both increments equal to 1. +*/ + else { + m = n % 4; + + for (i = 0; i < m; i++) { + dy[i] = dy[i] + da * dx[i]; + } + + for (i = m; i < n; i = i + 4) { + dy[i] = dy[i] + da * dx[i]; + dy[i + 1] = dy[i + 1] + da * dx[i + 1]; + dy[i + 2] = dy[i + 2] + da * dx[i + 2]; + dy[i + 3] = dy[i + 3] + da * dx[i + 3]; + } + } + return; +} +/******************************************************************************/ + +floating_point_t ddot(int n, floating_point_t dx[], int incx, floating_point_t dy[], int incy) + +/******************************************************************************/ +/* + Purpose: + + DDOT forms the dot product of two vectors. + + Discussion: + + This routine uses unrolled loops for increments equal to one. + + Modified: + + 30 March 2007 + + Author: + + FORTRAN77 original by Jack Dongarra, Cleve Moler, Jim Bunch, Pete Stewart. + C version by John Burkardt + + Reference: + + Jack Dongarra, Cleve Moler, Jim Bunch, Pete Stewart, + LINPACK User's Guide, + SIAM, 1979. + + Charles Lawson, Richard Hanson, David Kincaid, Fred Krogh, + Basic Linear Algebra Subprograms for Fortran Usage, + Algorithm 539, + ACM Transactions on Mathematical Software, + Volume 5, Number 3, September 1979, pages 308-323. + + Parameters: + + Input, int N, the number of entries in the vectors. + + Input, floating_point_t DX[*], the first vector. + + Input, int INCX, the increment between successive entries in DX. + + Input, floating_point_t DY[*], the second vector. + + Input, int INCY, the increment between successive entries in DY. + + Output, floating_point_t DDOT, the sum of the product of the corresponding + entries of DX and DY. +*/ +{ + floating_point_t dtemp; + int i; + int ix; + int iy; + int m; + + dtemp = 0.0; + + if (n <= 0) { + return dtemp; + } + /* + Code for unequal increments or equal increments + not equal to 1. +*/ + if (incx != 1 || incy != 1) { + if (0 <= incx) { + ix = 0; + } else { + ix = (-n + 1) * incx; + } + + if (0 <= incy) { + iy = 0; + } else { + iy = (-n + 1) * incy; + } + + for (i = 0; i < n; i++) { + dtemp = dtemp + dx[ix] * dy[iy]; + ix = ix + incx; + iy = iy + incy; + } + } + /* + Code for both increments equal to 1. +*/ + else { + m = n % 5; + + for (i = 0; i < m; i++) { + dtemp = dtemp + dx[i] * dy[i]; + } + + for (i = m; i < n; i = i + 5) { + dtemp = dtemp + dx[i] * dy[i] + dx[i + 1] * dy[i + 1] + dx[i + 2] * dy[i + 2] + dx[i + 3] * dy[i + 3] + dx[i + 4] * dy[i + 4]; + } + } + return dtemp; +} +/******************************************************************************/ + +int dgefa(floating_point_t a[], int lda, int n, int ipvt[]) + +/******************************************************************************/ +/* + Purpose: + + DGEFA factors a real general matrix. + + Modified: + + 16 May 2005 + + Author: + + C version by John Burkardt. + + Reference: + + Jack Dongarra, Cleve Moler, Jim Bunch and Pete Stewart, + LINPACK User's Guide, + SIAM, (Society for Industrial and Applied Mathematics), + 3600 University City Science Center, + Philadelphia, PA, 19104-2688. + ISBN 0-89871-172-X + + Parameters: + + Input/output, floating_point_t A[LDA*N]. + On input, the matrix to be factored. + On output, an upper triangular matrix and the multipliers used to obtain + it. The factorization can be written A=L*U, where L is a product of + permutation and unit lower triangular matrices, and U is upper triangular. + + Input, int LDA, the leading dimension of A. + + Input, int N, the order of the matrix A. + + Output, int IPVT[N], the pivot indices. + + Output, int DGEFA, singularity indicator. + 0, normal value. + K, if U(K,K) == 0. This is not an error condition for this subroutine, + but it does indicate that DGESL or DGEDI will divide by zero if called. + Use RCOND in DGECO for a reliable indication of singularity. +*/ +{ + int info; + int j; + int k; + int l; + floating_point_t t; + /* + Gaussian elimination with partial pivoting. +*/ + info = 0; + + for (k = 1; k <= n - 1; k++) { + /* + Find L = pivot index. +*/ + l = idamax(n - k + 1, a + (k - 1) + (k - 1) * lda, 1) + k - 1; + ipvt[k - 1] = l; + /* + Zero pivot implies this column already triangularized. +*/ + if (a[l - 1 + (k - 1) * lda] == 0.0) { + info = k; + continue; + } + /* + Interchange if necessary. +*/ + if (l != k) { + t = a[l - 1 + (k - 1) * lda]; + a[l - 1 + (k - 1) * lda] = a[k - 1 + (k - 1) * lda]; + a[k - 1 + (k - 1) * lda] = t; + } + /* + Compute multipliers. +*/ + t = -1.0 / a[k - 1 + (k - 1) * lda]; + + dscal(n - k, t, a + k + (k - 1) * lda, 1); + /* + Row elimination with column indexing. +*/ + for (j = k + 1; j <= n; j++) { + t = a[l - 1 + (j - 1) * lda]; + if (l != k) { + a[l - 1 + (j - 1) * lda] = a[k - 1 + (j - 1) * lda]; + a[k - 1 + (j - 1) * lda] = t; + } + daxpy(n - k, t, a + k + (k - 1) * lda, 1, a + k + (j - 1) * lda, 1); + } + } + + ipvt[n - 1] = n; + + if (a[n - 1 + (n - 1) * lda] == 0.0) { + info = n; + } + + return info; +} +/******************************************************************************/ + +void dgesl(floating_point_t a[], int lda, int n, int ipvt[], floating_point_t b[], int job) + +/******************************************************************************/ +/* + Purpose: + + DGESL solves a real general linear system A * X = B. + + Discussion: + + DGESL can solve either of the systems A * X = B or A' * X = B. + + The system matrix must have been factored by DGECO or DGEFA. + + A division by zero will occur if the input factor contains a + zero on the diagonal. Technically this indicates singularity + but it is often caused by improper arguments or improper + setting of LDA. It will not occur if the subroutines are + called correctly and if DGECO has set 0.0 < RCOND + or DGEFA has set INFO == 0. + + Modified: + + 16 May 2005 + + Author: + + C version by John Burkardt. + + Reference: + + Jack Dongarra, Cleve Moler, Jim Bunch and Pete Stewart, + LINPACK User's Guide, + SIAM, (Society for Industrial and Applied Mathematics), + 3600 University City Science Center, + Philadelphia, PA, 19104-2688. + ISBN 0-89871-172-X + + Parameters: + + Input, floating_point_t A[LDA*N], the output from DGECO or DGEFA. + + Input, int LDA, the leading dimension of A. + + Input, int N, the order of the matrix A. + + Input, int IPVT[N], the pivot vector from DGECO or DGEFA. + + Input/output, floating_point_t B[N]. + On input, the right hand side vector. + On output, the solution vector. + + Input, int JOB. + 0, solve A * X = B; + nonzero, solve A' * X = B. +*/ +{ + int k; + int l; + floating_point_t t; + /* + Solve A * X = B. +*/ + if (job == 0) { + for (k = 1; k <= n - 1; k++) { + l = ipvt[k - 1]; + t = b[l - 1]; + + if (l != k) { + b[l - 1] = b[k - 1]; + b[k - 1] = t; + } + + daxpy(n - k, t, a + k + (k - 1) * lda, 1, b + k, 1); + } + + for (k = n; 1 <= k; k--) { + b[k - 1] = b[k - 1] / a[k - 1 + (k - 1) * lda]; + t = -b[k - 1]; + daxpy(k - 1, t, a + 0 + (k - 1) * lda, 1, b, 1); + } + } + /* + Solve A' * X = B. +*/ + else { + for (k = 1; k <= n; k++) { + t = ddot(k - 1, a + 0 + (k - 1) * lda, 1, b, 1); + b[k - 1] = (b[k - 1] - t) / a[k - 1 + (k - 1) * lda]; + } + + for (k = n - 1; 1 <= k; k--) { + b[k - 1] = b[k - 1] + ddot(n - k, a + k + (k - 1) * lda, 1, b + k, 1); + l = ipvt[k - 1]; + + if (l != k) { + t = b[l - 1]; + b[l - 1] = b[k - 1]; + b[k - 1] = t; + } + } + } + return; +} +/******************************************************************************/ + +void dscal(int n, floating_point_t sa, floating_point_t x[], int incx) + +/******************************************************************************/ +/* + Purpose: + + DSCAL scales a vector by a constant. + + Modified: + + 30 March 2007 + + Author: + + FORTRAN77 original by Jack Dongarra, Cleve Moler, Jim Bunch, Pete Stewart. + C version by John Burkardt + + Reference: + + Jack Dongarra, Cleve Moler, Jim Bunch, Pete Stewart, + LINPACK User's Guide, + SIAM, 1979. + + Charles Lawson, Richard Hanson, David Kincaid, Fred Krogh, + Basic Linear Algebra Subprograms for Fortran Usage, + Algorithm 539, + ACM Transactions on Mathematical Software, + Volume 5, Number 3, September 1979, pages 308-323. + + Parameters: + + Input, int N, the number of entries in the vector. + + Input, floating_point_t SA, the multiplier. + + Input/output, floating_point_t X[*], the vector to be scaled. + + Input, int INCX, the increment between successive entries of X. +*/ +{ + int i; + int ix; + int m; + + if (n <= 0) { + } else if (incx == 1) { + m = n % 5; + + for (i = 0; i < m; i++) { + x[i] = sa * x[i]; + } + + for (i = m; i < n; i = i + 5) { + x[i] = sa * x[i]; + x[i + 1] = sa * x[i + 1]; + x[i + 2] = sa * x[i + 2]; + x[i + 3] = sa * x[i + 3]; + x[i + 4] = sa * x[i + 4]; + } + } else { + if (0 <= incx) { + ix = 0; + } else { + ix = (-n + 1) * incx; + } + + for (i = 0; i < n; i++) { + x[ix] = sa * x[ix]; + ix = ix + incx; + } + } + return; +} +/******************************************************************************/ + +int idamax(int n, floating_point_t dx[], int incx) + +/******************************************************************************/ +/* + Purpose: + + IDAMAX finds the index of the vector element of maximum absolute value. + + Discussion: + + WARNING: This index is a 1-based index, not a 0-based index! + + Modified: + + 30 March 2007 + + Author: + + FORTRAN77 original by Jack Dongarra, Cleve Moler, Jim Bunch, Pete Stewart. + C version by John Burkardt + + Reference: + + Jack Dongarra, Cleve Moler, Jim Bunch, Pete Stewart, + LINPACK User's Guide, + SIAM, 1979. + + Charles Lawson, Richard Hanson, David Kincaid, Fred Krogh, + Basic Linear Algebra Subprograms for Fortran Usage, + Algorithm 539, + ACM Transactions on Mathematical Software, + Volume 5, Number 3, September 1979, pages 308-323. + + Parameters: + + Input, int N, the number of entries in the vector. + + Input, floating_point_t X[*], the vector to be examined. + + Input, int INCX, the increment between successive entries of SX. + + Output, int IDAMAX, the index of the element of maximum + absolute value. +*/ +{ + floating_point_t dmax; + int i; + int ix; + int value; + + value = 0; + + if (n < 1 || incx <= 0) { + return value; + } + + value = 1; + + if (n == 1) { + return value; + } + + if (incx == 1) { + dmax = r8_abs(dx[0]); + + for (i = 1; i < n; i++) { + if (dmax < r8_abs(dx[i])) { + value = i + 1; + dmax = r8_abs(dx[i]); + } + } + } else { + ix = 0; + dmax = r8_abs(dx[0]); + ix = ix + incx; + + for (i = 1; i < n; i++) { + if (dmax < r8_abs(dx[ix])) { + value = i + 1; + dmax = r8_abs(dx[ix]); + } + ix = ix + incx; + } + } + + return value; +} +/******************************************************************************/ + +floating_point_t r8_abs(floating_point_t x) + +/******************************************************************************/ +/* + Purpose: + + R8_ABS returns the absolute value of a R8. + + Modified: + + 02 April 2005 + + Author: + + John Burkardt + + Parameters: + + Input, floating_point_t X, the quantity whose absolute value is desired. + + Output, floating_point_t R8_ABS, the absolute value of X. +*/ +{ + floating_point_t value; + + if (0.0 <= x) { + value = x; + } else { + value = -x; + } + return value; +} +/******************************************************************************/ + +floating_point_t r8_epsilon(void) + +/******************************************************************************/ +/* + Purpose: + + R8_EPSILON returns the R8 round off unit. + + Discussion: + + R8_EPSILON is a number R which is a power of 2 with the property that, + to the precision of the computer's arithmetic, + 1 < 1 + R + but + 1 = ( 1 + R / 2 ) + + Licensing: + + This code is distributed under the GNU LGPL license. + + Modified: + + 08 May 2006 + + Author: + + John Burkardt + + Parameters: + + Output, floating_point_t R8_EPSILON, the floating_point_t precision round-off unit. +*/ +{ + floating_point_t r; + + r = 1.0; + + while (1.0 < (floating_point_t)(1.0 + r)) { + r = r / 2.0; + } + r = 2.0 * r; + + return r; +} +/******************************************************************************/ + +floating_point_t r8_max(floating_point_t x, floating_point_t y) + +/******************************************************************************/ +/* + Purpose: + + R8_MAX returns the maximum of two R8's. + + Modified: + + 18 August 2004 + + Author: + + John Burkardt + + Parameters: + + Input, floating_point_t X, Y, the quantities to compare. + + Output, floating_point_t R8_MAX, the maximum of X and Y. +*/ +{ + floating_point_t value; + + if (y < x) { + value = x; + } else { + value = y; + } + return value; +} +/******************************************************************************/ + +floating_point_t r8_random(int iseed[4]) + +/******************************************************************************/ +/* + Purpose: + + R8_RANDOM returns a uniformly distributed random number between 0 and 1. + + Discussion: + + This routine uses a multiplicative congruential method with modulus + 2**48 and multiplier 33952834046453 (see G.S.Fishman, + 'Multiplicative congruential random number generators with modulus + 2**b: an exhaustive analysis for b = 32 and a partial analysis for + b = 48', Math. Comp. 189, pp 331-344, 1990). + + 48-bit integers are stored in 4 integer array elements with 12 bits + per element. Hence the routine is portable across machines with + integers of 32 bits or more. + + Parameters: + + Input/output, integer ISEED(4). + On entry, the seed of the random number generator; the array + elements must be between 0 and 4095, and ISEED(4) must be odd. + On exit, the seed is updated. + + Output, floating_point_t R8_RANDOM, the next pseudorandom number. +*/ +{ + int ipw2 = 4096; + int it1; + int it2; + int it3; + int it4; + int m1 = 494; + int m2 = 322; + int m3 = 2508; + int m4 = 2549; + floating_point_t r = 1.0 / 4096.0; + floating_point_t value; + /* + Multiply the seed by the multiplier modulo 2**48. +*/ + it4 = iseed[3] * m4; + it3 = it4 / ipw2; + it4 = it4 - ipw2 * it3; + it3 = it3 + iseed[2] * m4 + iseed[3] * m3; + it2 = it3 / ipw2; + it3 = it3 - ipw2 * it2; + it2 = it2 + iseed[1] * m4 + iseed[2] * m3 + iseed[3] * m2; + it1 = it2 / ipw2; + it2 = it2 - ipw2 * it1; + it1 = it1 + iseed[0] * m4 + iseed[1] * m3 + iseed[2] * m2 + iseed[3] * m1; + it1 = (it1 % ipw2); + /* + Return updated seed +*/ + iseed[0] = it1; + iseed[1] = it2; + iseed[2] = it3; + iseed[3] = it4; + /* + Convert 48-bit integer to a real number in the interval (0,1) +*/ + value = r * ((floating_point_t)(it1) + r * ((floating_point_t)(it2) + r * ((floating_point_t)(it3) + r * ((floating_point_t)(it4))))); + + return value; +} +/******************************************************************************/ + +void r8mat_gen(int lda, int n, floating_point_t *a) + +/******************************************************************************/ +/* + Purpose: + + R8MAT_GEN generates a random R8MAT. + + Modified: + + 06 June 2005 + + Parameters: + + Input, integer LDA, the leading dimension of the matrix. + + Input, integer N, the order of the matrix. + + Output, floating_point_t R8MAT_GEN[LDA*N], the N by N matrix. +*/ +{ + int i; + int init[4] = {1, 2, 3, 1325}; + int j; + + for (j = 1; j <= n; j++) { + for (i = 1; i <= n; i++) { + a[i - 1 + (j - 1) * lda] = r8_random(init) - 0.5; + } + } +} +/******************************************************************************/ diff --git a/tests/performance/linpack_double/test_linpack_double.py b/tests/performance/linpack_double/test_linpack_double.py new file mode 100644 index 000000000..0a6e2f90e --- /dev/null +++ b/tests/performance/linpack_double/test_linpack_double.py @@ -0,0 +1,61 @@ +import json +import logging +import os + + +def test_linpack_double(dut, request): + LOGGER = logging.getLogger(__name__) + + # Match "Runs: %d" + res = dut.expect(r"Runs: (\d+)", timeout=60) + runs = int(res.group(0).decode("utf-8").split(" ")[1]) + LOGGER.info("Number of runs: {}".format(runs)) + assert runs > 0, "Invalid number of runs" + + # Match "Type: %s" + res = dut.expect(r"Type: (\w+)", timeout=60) + data_type = res.group(0).decode("utf-8").split(" ")[1] + LOGGER.info("Data type: {}".format(data_type)) + assert data_type == "double", "Invalid data type" + + # Match "Runs completed: %d" + res = dut.expect(r"Runs completed: (\d+)", timeout=120) + runs_completed = int(res.group(0).decode("utf-8").split(" ")[2]) + LOGGER.info("Runs completed: {}".format(runs_completed)) + assert runs_completed == runs, "Invalid number of runs completed" + + # Match "Average MFLOPS: %f" + res = dut.expect(r"Average MFLOPS: (\d+\.\d+)", timeout=120) + avg_score = float(res.group(0).decode("utf-8").split(" ")[2]) + LOGGER.info("Average MFLOPS: {}".format(avg_score)) + assert avg_score > 0, "Invalid average MFLOPS" + + # Match "Min MFLOPS: %f" + res = dut.expect(r"Min MFLOPS: (\d+\.\d+)", timeout=120) + min_score = float(res.group(0).decode("utf-8").split(" ")[2]) + LOGGER.info("Min MFLOPS: {}".format(min_score)) + assert min_score > 0 and min_score < 1000000000.0, "Invalid min MFLOPS" + + # Match "Max MFLOPS: %f" + res = dut.expect(r"Max MFLOPS: (\d+\.\d+)", timeout=120) + max_score = float(res.group(0).decode("utf-8").split(" ")[2]) + LOGGER.info("Max MFLOPS: {}".format(max_score)) + assert max_score > 0, "Invalid max MFLOPS" + + # Create JSON with results and write it to file + # Always create a JSON with this format (so it can be merged later on): + # { TEST_NAME_STR: TEST_RESULTS_DICT } + results = {"linpack_double": {"runs": runs, "avg_score": avg_score, "min_score": min_score, "max_score": max_score}} + + current_folder = os.path.dirname(request.path) + file_index = 0 + report_file = os.path.join(current_folder, "result_linpack_double" + str(file_index) + ".json") + while os.path.exists(report_file): + report_file = report_file.replace(str(file_index) + ".json", str(file_index + 1) + ".json") + file_index += 1 + + with open(report_file, "w") as f: + try: + f.write(json.dumps(results)) + except Exception as e: + LOGGER.warning("Failed to write results to file: {}".format(e)) diff --git a/tests/performance/linpack_float/ci.json b/tests/performance/linpack_float/ci.json new file mode 100644 index 000000000..accee2b21 --- /dev/null +++ b/tests/performance/linpack_float/ci.json @@ -0,0 +1,6 @@ +{ + "platforms": { + "qemu": false, + "wokwi": false + } +} diff --git a/tests/performance/linpack_float/linpack_float.ino b/tests/performance/linpack_float/linpack_float.ino new file mode 100644 index 000000000..24dd9e7c4 --- /dev/null +++ b/tests/performance/linpack_float/linpack_float.ino @@ -0,0 +1,1094 @@ +/* + Linpack test for Arduino and ESP32. + Based on https://github.com/VioletGiraffe/EmbeddedLinpack + Created by Violet Giraffe, 2018 + Adapted by Lucas Saavedra Vaz, 2024 +*/ + +#include +#include + +// Number of runs to average +#define N_RUNS 1000 + +using floating_point_t = float; +bool type_float; + +floating_point_t benchmark(void); +floating_point_t cpu_time(void); +void daxpy(int n, floating_point_t da, floating_point_t dx[], int incx, floating_point_t dy[], int incy); +floating_point_t ddot(int n, floating_point_t dx[], int incx, floating_point_t dy[], int incy); +int dgefa(floating_point_t a[], int lda, int n, int ipvt[]); +void dgesl(floating_point_t a[], int lda, int n, int ipvt[], floating_point_t b[], int job); +void dscal(int n, floating_point_t sa, floating_point_t x[], int incx); +int idamax(int n, floating_point_t dx[], int incx); +floating_point_t r8_abs(floating_point_t x); +floating_point_t r8_epsilon(void); +floating_point_t r8_max(floating_point_t x, floating_point_t y); +floating_point_t r8_random(int iseed[4]); +void r8mat_gen(int lda, int n, floating_point_t *a); + +void setup() { + Serial.begin(115200); + while (!Serial) { + delay(10); + } + + String data_type; + + if (sizeof(floating_point_t) == sizeof(float)) { + data_type = "float"; + type_float = true; + } else if (sizeof(floating_point_t) == sizeof(double)) { + data_type = "double"; + type_float = false; + } else { + data_type = "unknown"; + log_e("Unknown data type size. Aborting."); + while (1); + } + + log_d("Starting Linpack %s test", data_type.c_str()); + Serial.printf("Runs: %d\n", N_RUNS); + Serial.printf("Type: %s\n", data_type.c_str()); + Serial.flush(); + int i = 0; + + floating_point_t minMflops = 1000000000.0, maxMflops = 0.0, avgMflops = 0.0; + for (i = 0; i < N_RUNS; ++i) { + Serial.printf("Run %d\n", i); + const auto mflops = benchmark(); + avgMflops += mflops; + minMflops = fmin(mflops, minMflops); + maxMflops = fmax(mflops, maxMflops); + Serial.flush(); + } + + avgMflops /= N_RUNS; + Serial.println(String("Runs completed: ") + i); + Serial.println(String("Average MFLOPS: ") + avgMflops); + Serial.println(String("Min MFLOPS: ") + minMflops); + Serial.println(String("Max MFLOPS: ") + maxMflops); + Serial.flush(); +} + +void loop() { + vTaskDelete(NULL); +} + +/******************************************************************************/ + +floating_point_t benchmark(void) + +/******************************************************************************/ +/* + Purpose: + + MAIN is the main program for LINPACK_BENCH. + + Discussion: + + LINPACK_BENCH drives the floating_point_t precision LINPACK benchmark program. + + Modified: + + 25 July 2008 + + Parameters: + + N is the problem size. +*/ +{ +#define N 8 +#define LDA (N + 1) + + static floating_point_t a[N * LDA]; + static floating_point_t a_max; + static floating_point_t b[N]; + static floating_point_t b_max; + const floating_point_t cray = 0.056; + static floating_point_t eps; + int i; + int info; + static int ipvt[N]; + int j; + int job; + floating_point_t ops; + static floating_point_t resid[N]; + floating_point_t resid_max; + [[maybe_unused]] + floating_point_t residn; + static floating_point_t rhs[N]; + floating_point_t t1; + floating_point_t t2; + static floating_point_t time[6]; + floating_point_t total; + floating_point_t x[N]; + + log_d("LINPACK_BENCH"); + log_d(" C version"); + log_d(" The LINPACK benchmark."); + log_d(" Language: C"); + if (!type_float) { + log_d(" Datatype: Double precision real"); + } else if (type_float) { + log_d(" Datatype: Single precision real"); + } else { + log_d(" Datatype: unknown"); + } + log_d(" Matrix order N = %d", N); + log_d(" Leading matrix dimension LDA = %d", LDA); + + ops = (floating_point_t)(2L * N * N * N) / 3.0 + 2.0 * (floating_point_t)((long)N * N); + + /* + Allocate space for arrays. +*/ + r8mat_gen(LDA, N, a); + + a_max = 0.0; + for (j = 0; j < N; j++) { + for (i = 0; i < N; i++) { + a_max = r8_max(a_max, a[i + j * LDA]); + } + } + + for (i = 0; i < N; i++) { + x[i] = 1.0; + } + + for (i = 0; i < N; i++) { + b[i] = 0.0; + for (j = 0; j < N; j++) { + b[i] = b[i] + a[i + j * LDA] * x[j]; + } + } + t1 = cpu_time(); + + info = dgefa(a, LDA, N, ipvt); + + if (info != 0) { + log_d("LINPACK_BENCH - Fatal error!"); + log_d(" The matrix A is apparently singular."); + log_d(" Abnormal end of execution."); + return 1; + } + + t2 = cpu_time(); + time[0] = t2 - t1; + + t1 = cpu_time(); + + job = 0; + dgesl(a, LDA, N, ipvt, b, job); + + t2 = cpu_time(); + time[1] = t2 - t1; + + total = time[0] + time[1]; + + /* + Compute a residual to verify results. +*/ + r8mat_gen(LDA, N, a); + + for (i = 0; i < N; i++) { + x[i] = 1.0; + } + + for (i = 0; i < N; i++) { + rhs[i] = 0.0; + for (j = 0; j < N; j++) { + rhs[i] = rhs[i] + a[i + j * LDA] * x[j]; + } + } + + for (i = 0; i < N; i++) { + resid[i] = -rhs[i]; + for (j = 0; j < N; j++) { + resid[i] = resid[i] + a[i + j * LDA] * b[j]; + } + } + + resid_max = 0.0; + for (i = 0; i < N; i++) { + resid_max = r8_max(resid_max, r8_abs(resid[i])); + } + + b_max = 0.0; + for (i = 0; i < N; i++) { + b_max = r8_max(b_max, r8_abs(b[i])); + } + + eps = r8_epsilon(); + + residn = resid_max / (floating_point_t)N / a_max / b_max / eps; + + time[2] = total; + if (0.0 < total) { + time[3] = ops / (1.0E+06 * total); + } else { + time[3] = -1.0; + } + time[4] = 2.0 / time[3]; + time[5] = total / cray; + + log_d(""); + log_d(" Norm. Resid Resid MACHEP X[1] X[N]"); + log_d(" %14f %14f %14e %14f %14f", residn, resid_max, eps, b[0], b[N - 1]); + log_d(""); + log_d(" Factor Solve Total MFLOPS Unit Cray-Ratio"); + log_d(" %9f %9f %9f %9f %9f %9f", time[0], time[1], time[2], time[3], time[4], time[5]); + + /* + Terminate. +*/ + log_d(""); + log_d("LINPACK_BENCH"); + log_d(" Normal end of execution."); + log_d(""); + + return time[3]; +#undef LDA +#undef N +} +/******************************************************************************/ + +floating_point_t cpu_time(void) + +/******************************************************************************/ +/* + Purpose: + + CPU_TIME returns the current reading on the CPU clock. + + Discussion: + + The CPU time measurements available through this routine are often + not very accurate. In some cases, the accuracy is no better than + a hundredth of a second. + + Licensing: + + This code is distributed under the GNU LGPL license. + + Modified: + + 06 June 2005 + + Author: + + John Burkardt + + Parameters: + + Output, floating_point_t CPU_TIME, the current reading of the CPU clock, in seconds. +*/ +{ + floating_point_t value; + + value = (floating_point_t)micros() / (floating_point_t)1000000; + + return value; +} +/******************************************************************************/ + +void daxpy(int n, floating_point_t da, floating_point_t dx[], int incx, floating_point_t dy[], int incy) + +/******************************************************************************/ +/* + Purpose: + + DAXPY computes constant times a vector plus a vector. + + Discussion: + + This routine uses unrolled loops for increments equal to one. + + Modified: + + 30 March 2007 + + Author: + + FORTRAN77 original by Jack Dongarra, Cleve Moler, Jim Bunch, Pete Stewart. + C version by John Burkardt + + Reference: + + Jack Dongarra, Cleve Moler, Jim Bunch, Pete Stewart, + LINPACK User's Guide, + SIAM, 1979. + + Charles Lawson, Richard Hanson, David Kincaid, Fred Krogh, + Basic Linear Algebra Subprograms for Fortran Usage, + Algorithm 539, + ACM Transactions on Mathematical Software, + Volume 5, Number 3, September 1979, pages 308-323. + + Parameters: + + Input, int N, the number of elements in DX and DY. + + Input, floating_point_t DA, the multiplier of DX. + + Input, floating_point_t DX[*], the first vector. + + Input, int INCX, the increment between successive entries of DX. + + Input/output, floating_point_t DY[*], the second vector. + On output, DY[*] has been replaced by DY[*] + DA * DX[*]. + + Input, int INCY, the increment between successive entries of DY. +*/ +{ + int i; + int ix; + int iy; + int m; + + if (n <= 0) { + return; + } + + if (da == 0.0) { + return; + } + /* + Code for unequal increments or equal increments + not equal to 1. +*/ + if (incx != 1 || incy != 1) { + if (0 <= incx) { + ix = 0; + } else { + ix = (-n + 1) * incx; + } + + if (0 <= incy) { + iy = 0; + } else { + iy = (-n + 1) * incy; + } + + for (i = 0; i < n; i++) { + dy[iy] = dy[iy] + da * dx[ix]; + ix = ix + incx; + iy = iy + incy; + } + } + /* + Code for both increments equal to 1. +*/ + else { + m = n % 4; + + for (i = 0; i < m; i++) { + dy[i] = dy[i] + da * dx[i]; + } + + for (i = m; i < n; i = i + 4) { + dy[i] = dy[i] + da * dx[i]; + dy[i + 1] = dy[i + 1] + da * dx[i + 1]; + dy[i + 2] = dy[i + 2] + da * dx[i + 2]; + dy[i + 3] = dy[i + 3] + da * dx[i + 3]; + } + } + return; +} +/******************************************************************************/ + +floating_point_t ddot(int n, floating_point_t dx[], int incx, floating_point_t dy[], int incy) + +/******************************************************************************/ +/* + Purpose: + + DDOT forms the dot product of two vectors. + + Discussion: + + This routine uses unrolled loops for increments equal to one. + + Modified: + + 30 March 2007 + + Author: + + FORTRAN77 original by Jack Dongarra, Cleve Moler, Jim Bunch, Pete Stewart. + C version by John Burkardt + + Reference: + + Jack Dongarra, Cleve Moler, Jim Bunch, Pete Stewart, + LINPACK User's Guide, + SIAM, 1979. + + Charles Lawson, Richard Hanson, David Kincaid, Fred Krogh, + Basic Linear Algebra Subprograms for Fortran Usage, + Algorithm 539, + ACM Transactions on Mathematical Software, + Volume 5, Number 3, September 1979, pages 308-323. + + Parameters: + + Input, int N, the number of entries in the vectors. + + Input, floating_point_t DX[*], the first vector. + + Input, int INCX, the increment between successive entries in DX. + + Input, floating_point_t DY[*], the second vector. + + Input, int INCY, the increment between successive entries in DY. + + Output, floating_point_t DDOT, the sum of the product of the corresponding + entries of DX and DY. +*/ +{ + floating_point_t dtemp; + int i; + int ix; + int iy; + int m; + + dtemp = 0.0; + + if (n <= 0) { + return dtemp; + } + /* + Code for unequal increments or equal increments + not equal to 1. +*/ + if (incx != 1 || incy != 1) { + if (0 <= incx) { + ix = 0; + } else { + ix = (-n + 1) * incx; + } + + if (0 <= incy) { + iy = 0; + } else { + iy = (-n + 1) * incy; + } + + for (i = 0; i < n; i++) { + dtemp = dtemp + dx[ix] * dy[iy]; + ix = ix + incx; + iy = iy + incy; + } + } + /* + Code for both increments equal to 1. +*/ + else { + m = n % 5; + + for (i = 0; i < m; i++) { + dtemp = dtemp + dx[i] * dy[i]; + } + + for (i = m; i < n; i = i + 5) { + dtemp = dtemp + dx[i] * dy[i] + dx[i + 1] * dy[i + 1] + dx[i + 2] * dy[i + 2] + dx[i + 3] * dy[i + 3] + dx[i + 4] * dy[i + 4]; + } + } + return dtemp; +} +/******************************************************************************/ + +int dgefa(floating_point_t a[], int lda, int n, int ipvt[]) + +/******************************************************************************/ +/* + Purpose: + + DGEFA factors a real general matrix. + + Modified: + + 16 May 2005 + + Author: + + C version by John Burkardt. + + Reference: + + Jack Dongarra, Cleve Moler, Jim Bunch and Pete Stewart, + LINPACK User's Guide, + SIAM, (Society for Industrial and Applied Mathematics), + 3600 University City Science Center, + Philadelphia, PA, 19104-2688. + ISBN 0-89871-172-X + + Parameters: + + Input/output, floating_point_t A[LDA*N]. + On input, the matrix to be factored. + On output, an upper triangular matrix and the multipliers used to obtain + it. The factorization can be written A=L*U, where L is a product of + permutation and unit lower triangular matrices, and U is upper triangular. + + Input, int LDA, the leading dimension of A. + + Input, int N, the order of the matrix A. + + Output, int IPVT[N], the pivot indices. + + Output, int DGEFA, singularity indicator. + 0, normal value. + K, if U(K,K) == 0. This is not an error condition for this subroutine, + but it does indicate that DGESL or DGEDI will divide by zero if called. + Use RCOND in DGECO for a reliable indication of singularity. +*/ +{ + int info; + int j; + int k; + int l; + floating_point_t t; + /* + Gaussian elimination with partial pivoting. +*/ + info = 0; + + for (k = 1; k <= n - 1; k++) { + /* + Find L = pivot index. +*/ + l = idamax(n - k + 1, a + (k - 1) + (k - 1) * lda, 1) + k - 1; + ipvt[k - 1] = l; + /* + Zero pivot implies this column already triangularized. +*/ + if (a[l - 1 + (k - 1) * lda] == 0.0) { + info = k; + continue; + } + /* + Interchange if necessary. +*/ + if (l != k) { + t = a[l - 1 + (k - 1) * lda]; + a[l - 1 + (k - 1) * lda] = a[k - 1 + (k - 1) * lda]; + a[k - 1 + (k - 1) * lda] = t; + } + /* + Compute multipliers. +*/ + t = -1.0 / a[k - 1 + (k - 1) * lda]; + + dscal(n - k, t, a + k + (k - 1) * lda, 1); + /* + Row elimination with column indexing. +*/ + for (j = k + 1; j <= n; j++) { + t = a[l - 1 + (j - 1) * lda]; + if (l != k) { + a[l - 1 + (j - 1) * lda] = a[k - 1 + (j - 1) * lda]; + a[k - 1 + (j - 1) * lda] = t; + } + daxpy(n - k, t, a + k + (k - 1) * lda, 1, a + k + (j - 1) * lda, 1); + } + } + + ipvt[n - 1] = n; + + if (a[n - 1 + (n - 1) * lda] == 0.0) { + info = n; + } + + return info; +} +/******************************************************************************/ + +void dgesl(floating_point_t a[], int lda, int n, int ipvt[], floating_point_t b[], int job) + +/******************************************************************************/ +/* + Purpose: + + DGESL solves a real general linear system A * X = B. + + Discussion: + + DGESL can solve either of the systems A * X = B or A' * X = B. + + The system matrix must have been factored by DGECO or DGEFA. + + A division by zero will occur if the input factor contains a + zero on the diagonal. Technically this indicates singularity + but it is often caused by improper arguments or improper + setting of LDA. It will not occur if the subroutines are + called correctly and if DGECO has set 0.0 < RCOND + or DGEFA has set INFO == 0. + + Modified: + + 16 May 2005 + + Author: + + C version by John Burkardt. + + Reference: + + Jack Dongarra, Cleve Moler, Jim Bunch and Pete Stewart, + LINPACK User's Guide, + SIAM, (Society for Industrial and Applied Mathematics), + 3600 University City Science Center, + Philadelphia, PA, 19104-2688. + ISBN 0-89871-172-X + + Parameters: + + Input, floating_point_t A[LDA*N], the output from DGECO or DGEFA. + + Input, int LDA, the leading dimension of A. + + Input, int N, the order of the matrix A. + + Input, int IPVT[N], the pivot vector from DGECO or DGEFA. + + Input/output, floating_point_t B[N]. + On input, the right hand side vector. + On output, the solution vector. + + Input, int JOB. + 0, solve A * X = B; + nonzero, solve A' * X = B. +*/ +{ + int k; + int l; + floating_point_t t; + /* + Solve A * X = B. +*/ + if (job == 0) { + for (k = 1; k <= n - 1; k++) { + l = ipvt[k - 1]; + t = b[l - 1]; + + if (l != k) { + b[l - 1] = b[k - 1]; + b[k - 1] = t; + } + + daxpy(n - k, t, a + k + (k - 1) * lda, 1, b + k, 1); + } + + for (k = n; 1 <= k; k--) { + b[k - 1] = b[k - 1] / a[k - 1 + (k - 1) * lda]; + t = -b[k - 1]; + daxpy(k - 1, t, a + 0 + (k - 1) * lda, 1, b, 1); + } + } + /* + Solve A' * X = B. +*/ + else { + for (k = 1; k <= n; k++) { + t = ddot(k - 1, a + 0 + (k - 1) * lda, 1, b, 1); + b[k - 1] = (b[k - 1] - t) / a[k - 1 + (k - 1) * lda]; + } + + for (k = n - 1; 1 <= k; k--) { + b[k - 1] = b[k - 1] + ddot(n - k, a + k + (k - 1) * lda, 1, b + k, 1); + l = ipvt[k - 1]; + + if (l != k) { + t = b[l - 1]; + b[l - 1] = b[k - 1]; + b[k - 1] = t; + } + } + } + return; +} +/******************************************************************************/ + +void dscal(int n, floating_point_t sa, floating_point_t x[], int incx) + +/******************************************************************************/ +/* + Purpose: + + DSCAL scales a vector by a constant. + + Modified: + + 30 March 2007 + + Author: + + FORTRAN77 original by Jack Dongarra, Cleve Moler, Jim Bunch, Pete Stewart. + C version by John Burkardt + + Reference: + + Jack Dongarra, Cleve Moler, Jim Bunch, Pete Stewart, + LINPACK User's Guide, + SIAM, 1979. + + Charles Lawson, Richard Hanson, David Kincaid, Fred Krogh, + Basic Linear Algebra Subprograms for Fortran Usage, + Algorithm 539, + ACM Transactions on Mathematical Software, + Volume 5, Number 3, September 1979, pages 308-323. + + Parameters: + + Input, int N, the number of entries in the vector. + + Input, floating_point_t SA, the multiplier. + + Input/output, floating_point_t X[*], the vector to be scaled. + + Input, int INCX, the increment between successive entries of X. +*/ +{ + int i; + int ix; + int m; + + if (n <= 0) { + } else if (incx == 1) { + m = n % 5; + + for (i = 0; i < m; i++) { + x[i] = sa * x[i]; + } + + for (i = m; i < n; i = i + 5) { + x[i] = sa * x[i]; + x[i + 1] = sa * x[i + 1]; + x[i + 2] = sa * x[i + 2]; + x[i + 3] = sa * x[i + 3]; + x[i + 4] = sa * x[i + 4]; + } + } else { + if (0 <= incx) { + ix = 0; + } else { + ix = (-n + 1) * incx; + } + + for (i = 0; i < n; i++) { + x[ix] = sa * x[ix]; + ix = ix + incx; + } + } + return; +} +/******************************************************************************/ + +int idamax(int n, floating_point_t dx[], int incx) + +/******************************************************************************/ +/* + Purpose: + + IDAMAX finds the index of the vector element of maximum absolute value. + + Discussion: + + WARNING: This index is a 1-based index, not a 0-based index! + + Modified: + + 30 March 2007 + + Author: + + FORTRAN77 original by Jack Dongarra, Cleve Moler, Jim Bunch, Pete Stewart. + C version by John Burkardt + + Reference: + + Jack Dongarra, Cleve Moler, Jim Bunch, Pete Stewart, + LINPACK User's Guide, + SIAM, 1979. + + Charles Lawson, Richard Hanson, David Kincaid, Fred Krogh, + Basic Linear Algebra Subprograms for Fortran Usage, + Algorithm 539, + ACM Transactions on Mathematical Software, + Volume 5, Number 3, September 1979, pages 308-323. + + Parameters: + + Input, int N, the number of entries in the vector. + + Input, floating_point_t X[*], the vector to be examined. + + Input, int INCX, the increment between successive entries of SX. + + Output, int IDAMAX, the index of the element of maximum + absolute value. +*/ +{ + floating_point_t dmax; + int i; + int ix; + int value; + + value = 0; + + if (n < 1 || incx <= 0) { + return value; + } + + value = 1; + + if (n == 1) { + return value; + } + + if (incx == 1) { + dmax = r8_abs(dx[0]); + + for (i = 1; i < n; i++) { + if (dmax < r8_abs(dx[i])) { + value = i + 1; + dmax = r8_abs(dx[i]); + } + } + } else { + ix = 0; + dmax = r8_abs(dx[0]); + ix = ix + incx; + + for (i = 1; i < n; i++) { + if (dmax < r8_abs(dx[ix])) { + value = i + 1; + dmax = r8_abs(dx[ix]); + } + ix = ix + incx; + } + } + + return value; +} +/******************************************************************************/ + +floating_point_t r8_abs(floating_point_t x) + +/******************************************************************************/ +/* + Purpose: + + R8_ABS returns the absolute value of a R8. + + Modified: + + 02 April 2005 + + Author: + + John Burkardt + + Parameters: + + Input, floating_point_t X, the quantity whose absolute value is desired. + + Output, floating_point_t R8_ABS, the absolute value of X. +*/ +{ + floating_point_t value; + + if (0.0 <= x) { + value = x; + } else { + value = -x; + } + return value; +} +/******************************************************************************/ + +floating_point_t r8_epsilon(void) + +/******************************************************************************/ +/* + Purpose: + + R8_EPSILON returns the R8 round off unit. + + Discussion: + + R8_EPSILON is a number R which is a power of 2 with the property that, + to the precision of the computer's arithmetic, + 1 < 1 + R + but + 1 = ( 1 + R / 2 ) + + Licensing: + + This code is distributed under the GNU LGPL license. + + Modified: + + 08 May 2006 + + Author: + + John Burkardt + + Parameters: + + Output, floating_point_t R8_EPSILON, the floating_point_t precision round-off unit. +*/ +{ + floating_point_t r; + + r = 1.0; + + while (1.0 < (floating_point_t)(1.0 + r)) { + r = r / 2.0; + } + r = 2.0 * r; + + return r; +} +/******************************************************************************/ + +floating_point_t r8_max(floating_point_t x, floating_point_t y) + +/******************************************************************************/ +/* + Purpose: + + R8_MAX returns the maximum of two R8's. + + Modified: + + 18 August 2004 + + Author: + + John Burkardt + + Parameters: + + Input, floating_point_t X, Y, the quantities to compare. + + Output, floating_point_t R8_MAX, the maximum of X and Y. +*/ +{ + floating_point_t value; + + if (y < x) { + value = x; + } else { + value = y; + } + return value; +} +/******************************************************************************/ + +floating_point_t r8_random(int iseed[4]) + +/******************************************************************************/ +/* + Purpose: + + R8_RANDOM returns a uniformly distributed random number between 0 and 1. + + Discussion: + + This routine uses a multiplicative congruential method with modulus + 2**48 and multiplier 33952834046453 (see G.S.Fishman, + 'Multiplicative congruential random number generators with modulus + 2**b: an exhaustive analysis for b = 32 and a partial analysis for + b = 48', Math. Comp. 189, pp 331-344, 1990). + + 48-bit integers are stored in 4 integer array elements with 12 bits + per element. Hence the routine is portable across machines with + integers of 32 bits or more. + + Parameters: + + Input/output, integer ISEED(4). + On entry, the seed of the random number generator; the array + elements must be between 0 and 4095, and ISEED(4) must be odd. + On exit, the seed is updated. + + Output, floating_point_t R8_RANDOM, the next pseudorandom number. +*/ +{ + int ipw2 = 4096; + int it1; + int it2; + int it3; + int it4; + int m1 = 494; + int m2 = 322; + int m3 = 2508; + int m4 = 2549; + floating_point_t r = 1.0 / 4096.0; + floating_point_t value; + /* + Multiply the seed by the multiplier modulo 2**48. +*/ + it4 = iseed[3] * m4; + it3 = it4 / ipw2; + it4 = it4 - ipw2 * it3; + it3 = it3 + iseed[2] * m4 + iseed[3] * m3; + it2 = it3 / ipw2; + it3 = it3 - ipw2 * it2; + it2 = it2 + iseed[1] * m4 + iseed[2] * m3 + iseed[3] * m2; + it1 = it2 / ipw2; + it2 = it2 - ipw2 * it1; + it1 = it1 + iseed[0] * m4 + iseed[1] * m3 + iseed[2] * m2 + iseed[3] * m1; + it1 = (it1 % ipw2); + /* + Return updated seed +*/ + iseed[0] = it1; + iseed[1] = it2; + iseed[2] = it3; + iseed[3] = it4; + /* + Convert 48-bit integer to a real number in the interval (0,1) +*/ + value = r * ((floating_point_t)(it1) + r * ((floating_point_t)(it2) + r * ((floating_point_t)(it3) + r * ((floating_point_t)(it4))))); + + return value; +} +/******************************************************************************/ + +void r8mat_gen(int lda, int n, floating_point_t *a) + +/******************************************************************************/ +/* + Purpose: + + R8MAT_GEN generates a random R8MAT. + + Modified: + + 06 June 2005 + + Parameters: + + Input, integer LDA, the leading dimension of the matrix. + + Input, integer N, the order of the matrix. + + Output, floating_point_t R8MAT_GEN[LDA*N], the N by N matrix. +*/ +{ + int i; + int init[4] = {1, 2, 3, 1325}; + int j; + + for (j = 1; j <= n; j++) { + for (i = 1; i <= n; i++) { + a[i - 1 + (j - 1) * lda] = r8_random(init) - 0.5; + } + } +} +/******************************************************************************/ diff --git a/tests/performance/linpack_float/test_linpack_float.py b/tests/performance/linpack_float/test_linpack_float.py new file mode 100644 index 000000000..d11f6c741 --- /dev/null +++ b/tests/performance/linpack_float/test_linpack_float.py @@ -0,0 +1,61 @@ +import json +import logging +import os + + +def test_linpack_float(dut, request): + LOGGER = logging.getLogger(__name__) + + # Match "Runs: %d" + res = dut.expect(r"Runs: (\d+)", timeout=60) + runs = int(res.group(0).decode("utf-8").split(" ")[1]) + LOGGER.info("Number of runs: {}".format(runs)) + assert runs > 0, "Invalid number of runs" + + # Match "Type: %s" + res = dut.expect(r"Type: (\w+)", timeout=60) + data_type = res.group(0).decode("utf-8").split(" ")[1] + LOGGER.info("Data type: {}".format(data_type)) + assert data_type == "float", "Invalid data type" + + # Match "Runs completed: %d" + res = dut.expect(r"Runs completed: (\d+)", timeout=120) + runs_completed = int(res.group(0).decode("utf-8").split(" ")[2]) + LOGGER.info("Runs completed: {}".format(runs_completed)) + assert runs_completed == runs, "Invalid number of runs completed" + + # Match "Average MFLOPS: %f" + res = dut.expect(r"Average MFLOPS: (\d+\.\d+)", timeout=120) + avg_score = float(res.group(0).decode("utf-8").split(" ")[2]) + LOGGER.info("Average MFLOPS: {}".format(avg_score)) + assert avg_score > 0, "Invalid average MFLOPS" + + # Match "Min MFLOPS: %f" + res = dut.expect(r"Min MFLOPS: (\d+\.\d+)", timeout=120) + min_score = float(res.group(0).decode("utf-8").split(" ")[2]) + LOGGER.info("Min MFLOPS: {}".format(min_score)) + assert min_score > 0 and min_score < 1000000000.0, "Invalid min MFLOPS" + + # Match "Max MFLOPS: %f" + res = dut.expect(r"Max MFLOPS: (\d+\.\d+)", timeout=120) + max_score = float(res.group(0).decode("utf-8").split(" ")[2]) + LOGGER.info("Max MFLOPS: {}".format(max_score)) + assert max_score > 0, "Invalid max MFLOPS" + + # Create JSON with results and write it to file + # Always create a JSON with this format (so it can be merged later on): + # { TEST_NAME_STR: TEST_RESULTS_DICT } + results = {"linpack_float": {"runs": runs, "avg_score": avg_score, "min_score": min_score, "max_score": max_score}} + + current_folder = os.path.dirname(request.path) + file_index = 0 + report_file = os.path.join(current_folder, "result_linpack_float" + str(file_index) + ".json") + while os.path.exists(report_file): + report_file = report_file.replace(str(file_index) + ".json", str(file_index + 1) + ".json") + file_index += 1 + + with open(report_file, "w") as f: + try: + f.write(json.dumps(results)) + except Exception as e: + LOGGER.warning("Failed to write results to file: {}".format(e)) From 5fd7826d9f2847041a1fe5391612f41e6410743e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jan=20Proch=C3=A1zka?= <90197375+P-R-O-C-H-Y@users.noreply.github.com> Date: Fri, 4 Oct 2024 12:52:07 +0200 Subject: [PATCH 4/5] fix(boards): Remove partition scheme from FlashSize (#10400) --- boards.txt | 122 ----------------------------------------------------- 1 file changed, 122 deletions(-) diff --git a/boards.txt b/boards.txt index c785e4d80..c73d81b6f 100644 --- a/boards.txt +++ b/boards.txt @@ -123,7 +123,6 @@ esp32c2.menu.FlashFreq.30.build.flash_freq=30m esp32c2.menu.FlashSize.2M=2MB (16Mb) esp32c2.menu.FlashSize.2M.build.flash_size=2MB -esp32c2.menu.FlashSize.2M.build.partitions=minimal esp32c2.menu.FlashSize.4M=4MB (32Mb) esp32c2.menu.FlashSize.4M.build.flash_size=4MB @@ -293,10 +292,8 @@ esp32h2.menu.FlashSize.4M=4MB (32Mb) esp32h2.menu.FlashSize.4M.build.flash_size=4MB esp32h2.menu.FlashSize.8M=8MB (64Mb) esp32h2.menu.FlashSize.8M.build.flash_size=8MB -esp32h2.menu.FlashSize.8M.build.partitions=default_8MB esp32h2.menu.FlashSize.2M=2MB (16Mb) esp32h2.menu.FlashSize.2M.build.flash_size=2MB -esp32h2.menu.FlashSize.2M.build.partitions=minimal esp32h2.menu.FlashSize.16M=16MB (128Mb) esp32h2.menu.FlashSize.16M.build.flash_size=16MB @@ -487,10 +484,8 @@ esp32c6.menu.FlashSize.4M=4MB (32Mb) esp32c6.menu.FlashSize.4M.build.flash_size=4MB esp32c6.menu.FlashSize.8M=8MB (64Mb) esp32c6.menu.FlashSize.8M.build.flash_size=8MB -esp32c6.menu.FlashSize.8M.build.partitions=default_8MB esp32c6.menu.FlashSize.2M=2MB (16Mb) esp32c6.menu.FlashSize.2M.build.flash_size=2MB -esp32c6.menu.FlashSize.2M.build.partitions=minimal esp32c6.menu.FlashSize.16M=16MB (128Mb) esp32c6.menu.FlashSize.16M.build.flash_size=16MB @@ -634,12 +629,10 @@ esp32s3.menu.FlashSize.4M=4MB (32Mb) esp32s3.menu.FlashSize.4M.build.flash_size=4MB esp32s3.menu.FlashSize.8M=8MB (64Mb) esp32s3.menu.FlashSize.8M.build.flash_size=8MB -esp32s3.menu.FlashSize.8M.build.partitions=default_8MB esp32s3.menu.FlashSize.16M=16MB (128Mb) esp32s3.menu.FlashSize.16M.build.flash_size=16MB esp32s3.menu.FlashSize.32M=32MB (256Mb) esp32s3.menu.FlashSize.32M.build.flash_size=32MB -esp32s3.menu.FlashSize.32M.build.partitions=app5M_fat24M_32MB esp32s3.menu.LoopCore.1=Core 1 esp32s3.menu.LoopCore.1.build.loop_core=-DARDUINO_RUNNING_CORE=1 @@ -928,10 +921,8 @@ esp32c3.menu.FlashSize.4M=4MB (32Mb) esp32c3.menu.FlashSize.4M.build.flash_size=4MB esp32c3.menu.FlashSize.8M=8MB (64Mb) esp32c3.menu.FlashSize.8M.build.flash_size=8MB -esp32c3.menu.FlashSize.8M.build.partitions=default_8MB esp32c3.menu.FlashSize.2M=2MB (16Mb) esp32c3.menu.FlashSize.2M.build.flash_size=2MB -esp32c3.menu.FlashSize.2M.build.partitions=minimal esp32c3.menu.FlashSize.16M=16MB (128Mb) esp32c3.menu.FlashSize.16M.build.flash_size=16MB @@ -1137,10 +1128,8 @@ esp32s2.menu.FlashSize.4M=4MB (32Mb) esp32s2.menu.FlashSize.4M.build.flash_size=4MB esp32s2.menu.FlashSize.8M=8MB (64Mb) esp32s2.menu.FlashSize.8M.build.flash_size=8MB -esp32s2.menu.FlashSize.8M.build.partitions=default_8MB esp32s2.menu.FlashSize.2M=2MB (16Mb) esp32s2.menu.FlashSize.2M.build.flash_size=2MB -esp32s2.menu.FlashSize.2M.build.partitions=minimal esp32s2.menu.FlashSize.16M=16MB (128Mb) esp32s2.menu.FlashSize.16M.build.flash_size=16MB @@ -1323,10 +1312,8 @@ esp32.menu.FlashSize.4M=4MB (32Mb) esp32.menu.FlashSize.4M.build.flash_size=4MB esp32.menu.FlashSize.8M=8MB (64Mb) esp32.menu.FlashSize.8M.build.flash_size=8MB -esp32.menu.FlashSize.8M.build.partitions=default_8MB esp32.menu.FlashSize.2M=2MB (16Mb) esp32.menu.FlashSize.2M.build.flash_size=2MB -esp32.menu.FlashSize.2M.build.partitions=minimal esp32.menu.FlashSize.16M=16MB (128Mb) esp32.menu.FlashSize.16M.build.flash_size=16MB @@ -1499,7 +1486,6 @@ esp32da.menu.FlashSize.4M=4MB (32Mb) esp32da.menu.FlashSize.4M.build.flash_size=4MB esp32da.menu.FlashSize.8M=8MB (64Mb) esp32da.menu.FlashSize.8M.build.flash_size=8MB -esp32da.menu.FlashSize.8M.build.partitions=default_8MB esp32da.menu.FlashSize.16M=16MB (128Mb) esp32da.menu.FlashSize.16M.build.flash_size=16MB @@ -1841,12 +1827,10 @@ esp32s3-octal.menu.FlashSize.4M=4MB (32Mb) esp32s3-octal.menu.FlashSize.4M.build.flash_size=4MB esp32s3-octal.menu.FlashSize.8M=8MB (64Mb) esp32s3-octal.menu.FlashSize.8M.build.flash_size=8MB -esp32s3-octal.menu.FlashSize.8M.build.partitions=default_8MB esp32s3-octal.menu.FlashSize.16M=16MB (128Mb) esp32s3-octal.menu.FlashSize.16M.build.flash_size=16MB esp32s3-octal.menu.FlashSize.32M=32MB (256Mb) esp32s3-octal.menu.FlashSize.32M.build.flash_size=32MB -esp32s3-octal.menu.FlashSize.32M.build.partitions=app5M_fat24M_32MB esp32s3-octal.menu.LoopCore.1=Core 1 esp32s3-octal.menu.LoopCore.1.build.loop_core=-DARDUINO_RUNNING_CORE=1 @@ -2367,7 +2351,6 @@ esp32s2usb.menu.FlashSize.4M=4MB (32Mb) esp32s2usb.menu.FlashSize.4M.build.flash_size=4MB esp32s2usb.menu.FlashSize.8M=8MB (64Mb) esp32s2usb.menu.FlashSize.8M.build.flash_size=8MB -esp32s2usb.menu.FlashSize.8M.build.partitions=default_8MB esp32s2usb.menu.FlashSize.16M=16MB (128Mb) esp32s2usb.menu.FlashSize.16M.build.flash_size=16MB @@ -2461,13 +2444,10 @@ esp32wroverkit.menu.FlashSize.4M=4MB (32Mb) esp32wroverkit.menu.FlashSize.4M.build.flash_size=4MB esp32wroverkit.menu.FlashSize.8M=8MB (64Mb) esp32wroverkit.menu.FlashSize.8M.build.flash_size=8MB -esp32wroverkit.menu.FlashSize.8M.build.partitions=default_8MB esp32wroverkit.menu.FlashSize.2M=2MB (16Mb) esp32wroverkit.menu.FlashSize.2M.build.flash_size=2MB -esp32wroverkit.menu.FlashSize.2M.build.partitions=minimal esp32wroverkit.menu.FlashSize.16M=16MB (128Mb) esp32wroverkit.menu.FlashSize.16M.build.flash_size=16MB -esp32wroverkit.menu.FlashSize.16M.build.partitions=default_16MB esp32wroverkit.menu.PSRAM.enabled=Enabled esp32wroverkit.menu.PSRAM.enabled.build.defines=-DBOARD_HAS_PSRAM -mfix-esp32-psram-cache-issue -mfix-esp32-psram-cache-strategy=memw @@ -3069,10 +3049,8 @@ um_feathers2.menu.FlashSize.4M=4MB (32Mb) um_feathers2.menu.FlashSize.4M.build.flash_size=4MB um_feathers2.menu.FlashSize.8M=8MB (64Mb) um_feathers2.menu.FlashSize.8M.build.flash_size=8MB -um_feathers2.menu.FlashSize.8M.build.partitions=default_8MB um_feathers2.menu.FlashSize.2M=2MB (16Mb) um_feathers2.menu.FlashSize.2M.build.flash_size=2MB -um_feathers2.menu.FlashSize.2M.build.partitions=minimal um_feathers2.menu.UploadSpeed.921600=921600 um_feathers2.menu.UploadSpeed.921600.upload.speed=921600 @@ -3211,7 +3189,6 @@ um_feathers2neo.menu.FlashSize.4M=4MB (32Mb) um_feathers2neo.menu.FlashSize.4M.build.flash_size=4MB um_feathers2neo.menu.FlashSize.2M=2MB (16Mb) um_feathers2neo.menu.FlashSize.2M.build.flash_size=2MB -um_feathers2neo.menu.FlashSize.2M.build.partitions=minimal um_feathers2neo.menu.UploadSpeed.921600=921600 um_feathers2neo.menu.UploadSpeed.921600.upload.speed=921600 @@ -4246,7 +4223,6 @@ um_tinyc6.menu.FlashFreq.40.build.flash_freq=40m um_tinyc6.menu.FlashSize.8M=8MB (64Mb) um_tinyc6.menu.FlashSize.8M.build.flash_size=8MB -um_tinyc6.menu.FlashSize.8M.build.partitions=default_8MB um_tinyc6.menu.UploadSpeed.921600=921600 um_tinyc6.menu.UploadSpeed.921600.upload.speed=921600 @@ -4400,7 +4376,6 @@ um_tinys2.menu.FlashSize.4M=4MB (32Mb) um_tinys2.menu.FlashSize.4M.build.flash_size=4MB um_tinys2.menu.FlashSize.2M=2MB (16Mb) um_tinys2.menu.FlashSize.2M.build.flash_size=2MB -um_tinys2.menu.FlashSize.2M.build.partitions=minimal um_tinys2.menu.UploadSpeed.921600=921600 um_tinys2.menu.UploadSpeed.921600.upload.speed=921600 @@ -5669,10 +5644,8 @@ micros2.menu.FlashSize.4M=4MB (32Mb) micros2.menu.FlashSize.4M.build.flash_size=4MB micros2.menu.FlashSize.8M=8MB (64Mb) micros2.menu.FlashSize.8M.build.flash_size=8MB -micros2.menu.FlashSize.8M.build.partitions=default_8MB micros2.menu.FlashSize.2M=2MB (16Mb) micros2.menu.FlashSize.2M.build.flash_size=2MB -micros2.menu.FlashSize.2M.build.partitions=minimal micros2.menu.UploadSpeed.921600=921600 micros2.menu.UploadSpeed.921600.upload.speed=921600 @@ -6003,10 +5976,8 @@ ttgo-t1.menu.FlashSize.4M=4MB (32Mb) ttgo-t1.menu.FlashSize.4M.build.flash_size=4MB ttgo-t1.menu.FlashSize.2M=2MB (16Mb) ttgo-t1.menu.FlashSize.2M.build.flash_size=2MB -ttgo-t1.menu.FlashSize.2M.build.partitions=minimal ttgo-t1.menu.FlashSize.16M=16MB (128Mb) ttgo-t1.menu.FlashSize.16M.build.flash_size=16MB -ttgo-t1.menu.FlashSize.16M.build.partitions=ffat ttgo-t1.menu.UploadSpeed.921600=921600 ttgo-t1.menu.UploadSpeed.921600.upload.speed=921600 @@ -6463,7 +6434,6 @@ cw02.menu.FlashSize.4M=4MB (32Mb) cw02.menu.FlashSize.4M.build.flash_size=4MB cw02.menu.FlashSize.2M=2MB (16Mb) cw02.menu.FlashSize.2M.build.flash_size=2MB -cw02.menu.FlashSize.2M.build.partitions=minimal cw02.menu.UploadSpeed.921600=921600 cw02.menu.UploadSpeed.921600.upload.speed=921600 @@ -6864,10 +6834,8 @@ sparkfun_esp32s2_thing_plus.menu.FlashSize.4M=4MB (32Mb) sparkfun_esp32s2_thing_plus.menu.FlashSize.4M.build.flash_size=4MB sparkfun_esp32s2_thing_plus.menu.FlashSize.8M=8MB (64Mb) sparkfun_esp32s2_thing_plus.menu.FlashSize.8M.build.flash_size=8MB -sparkfun_esp32s2_thing_plus.menu.FlashSize.8M.build.partitions=default_8MB sparkfun_esp32s2_thing_plus.menu.FlashSize.2M=2MB (16Mb) sparkfun_esp32s2_thing_plus.menu.FlashSize.2M.build.flash_size=2MB -sparkfun_esp32s2_thing_plus.menu.FlashSize.2M.build.partitions=minimal sparkfun_esp32s2_thing_plus.menu.FlashSize.16M=16MB (128Mb) sparkfun_esp32s2_thing_plus.menu.FlashSize.16M.build.flash_size=16MB @@ -7256,10 +7224,8 @@ sparkfun_esp32c6_thing_plus.menu.FlashSize.4M=4MB (32Mb) sparkfun_esp32c6_thing_plus.menu.FlashSize.4M.build.flash_size=4MB sparkfun_esp32c6_thing_plus.menu.FlashSize.8M=8MB (64Mb) sparkfun_esp32c6_thing_plus.menu.FlashSize.8M.build.flash_size=8MB -sparkfun_esp32c6_thing_plus.menu.FlashSize.8M.build.partitions=default_8MB sparkfun_esp32c6_thing_plus.menu.FlashSize.2M=2MB (16Mb) sparkfun_esp32c6_thing_plus.menu.FlashSize.2M.build.flash_size=2MB -sparkfun_esp32c6_thing_plus.menu.FlashSize.2M.build.partitions=minimal sparkfun_esp32c6_thing_plus.menu.FlashSize.16M=16MB (128Mb) sparkfun_esp32c6_thing_plus.menu.FlashSize.16M.build.flash_size=16MB @@ -7417,10 +7383,8 @@ esp32micromod.menu.FlashSize.4M=4MB (32Mb) esp32micromod.menu.FlashSize.4M.build.flash_size=4MB esp32micromod.menu.FlashSize.8M=8MB (64Mb) esp32micromod.menu.FlashSize.8M.build.flash_size=8MB -esp32micromod.menu.FlashSize.8M.build.partitions=default_8MB esp32micromod.menu.FlashSize.2M=2MB (16Mb) esp32micromod.menu.FlashSize.2M.build.flash_size=2MB -esp32micromod.menu.FlashSize.2M.build.partitions=minimal esp32micromod.menu.FlashSize.16M=16MB (128Mb) esp32micromod.menu.FlashSize.16M.build.flash_size=16MB @@ -7670,10 +7634,8 @@ sparkfun_esp32_iot_redboard.menu.FlashSize.4M=4MB (32Mb) sparkfun_esp32_iot_redboard.menu.FlashSize.4M.build.flash_size=4MB sparkfun_esp32_iot_redboard.menu.FlashSize.8M=8MB (64Mb) sparkfun_esp32_iot_redboard.menu.FlashSize.8M.build.flash_size=8MB -sparkfun_esp32_iot_redboard.menu.FlashSize.8M.build.partitions=default_8MB sparkfun_esp32_iot_redboard.menu.FlashSize.2M=2MB (16Mb) sparkfun_esp32_iot_redboard.menu.FlashSize.2M.build.flash_size=2MB -sparkfun_esp32_iot_redboard.menu.FlashSize.2M.build.partitions=minimal sparkfun_esp32_iot_redboard.menu.FlashSize.16M=16MB (128Mb) sparkfun_esp32_iot_redboard.menu.FlashSize.16M.build.flash_size=16MB @@ -7855,10 +7817,8 @@ sparkfun_esp32c6_qwiic_pocket.menu.FlashSize.4M=4MB (32Mb) sparkfun_esp32c6_qwiic_pocket.menu.FlashSize.4M.build.flash_size=4MB sparkfun_esp32c6_qwiic_pocket.menu.FlashSize.8M=8MB (64Mb) sparkfun_esp32c6_qwiic_pocket.menu.FlashSize.8M.build.flash_size=8MB -sparkfun_esp32c6_qwiic_pocket.menu.FlashSize.8M.build.partitions=default_8MB sparkfun_esp32c6_qwiic_pocket.menu.FlashSize.2M=2MB (16Mb) sparkfun_esp32c6_qwiic_pocket.menu.FlashSize.2M.build.flash_size=2MB -sparkfun_esp32c6_qwiic_pocket.menu.FlashSize.2M.build.partitions=minimal sparkfun_esp32c6_qwiic_pocket.menu.FlashSize.16M=16MB (128Mb) sparkfun_esp32c6_qwiic_pocket.menu.FlashSize.16M.build.flash_size=16MB @@ -8111,13 +8071,10 @@ nina_w10.menu.UploadSpeed.512000.upload.speed=512000 nina_w10.menu.FlashSize.2M=2MB (16Mb, NINA-W101/W102) nina_w10.menu.FlashSize.2M.build.flash_size=2MB -nina_w10.menu.FlashSize.2M.build.partitions=minimal nina_w10.menu.FlashSize.4M=4MB (32Mb, NINA-W106-00B) nina_w10.menu.FlashSize.4M.build.flash_size=4MB -nina_w10.menu.FlashSize.4M.build.partitions=default nina_w10.menu.FlashSize.8M=8MB (64Mb, NINA-W106-10B) nina_w10.menu.FlashSize.8M.build.flash_size=8MB -nina_w10.menu.FlashSize.8M.build.partitions=default_8MB nina_w10.menu.FlashFreq.80=80MHz nina_w10.menu.FlashFreq.80.build.flash_freq=80m @@ -8287,7 +8244,6 @@ nora_w10.menu.FlashSize.4M=4MB (32Mb) nora_w10.menu.FlashSize.4M.build.flash_size=4MB nora_w10.menu.FlashSize.8M=8MB (64Mb) nora_w10.menu.FlashSize.8M.build.flash_size=8MB -nora_w10.menu.FlashSize.8M.build.partitions=default_8MB #nora_w10.menu.FlashSize.16M=16MB (128Mb) #nora_w10.menu.FlashSize.16M.build.flash_size=16MB #nora_w10.menu.FlashSize.32M=32MB (256Mb) @@ -11261,10 +11217,8 @@ dfrobot_firebeetle2_esp32e.menu.FlashSize.4M=4MB (32Mb) dfrobot_firebeetle2_esp32e.menu.FlashSize.4M.build.flash_size=4MB dfrobot_firebeetle2_esp32e.menu.FlashSize.8M=8MB (64Mb) dfrobot_firebeetle2_esp32e.menu.FlashSize.8M.build.flash_size=8MB -dfrobot_firebeetle2_esp32e.menu.FlashSize.8M.build.partitions=default_8MB dfrobot_firebeetle2_esp32e.menu.FlashSize.2M=2MB (16Mb) dfrobot_firebeetle2_esp32e.menu.FlashSize.2M.build.flash_size=2MB -dfrobot_firebeetle2_esp32e.menu.FlashSize.2M.build.partitions=minimal dfrobot_firebeetle2_esp32e.menu.FlashSize.16M=16MB (128Mb) dfrobot_firebeetle2_esp32e.menu.FlashSize.16M.build.flash_size=16MB @@ -11398,7 +11352,6 @@ dfrobot_firebeetle2_esp32s3.menu.FlashSize.4M=4MB (32Mb) dfrobot_firebeetle2_esp32s3.menu.FlashSize.4M.build.flash_size=4MB dfrobot_firebeetle2_esp32s3.menu.FlashSize.8M=8MB (64Mb) dfrobot_firebeetle2_esp32s3.menu.FlashSize.8M.build.flash_size=8MB -dfrobot_firebeetle2_esp32s3.menu.FlashSize.8M.build.partitions=default_8MB dfrobot_firebeetle2_esp32s3.menu.FlashSize.16M=16MB (128Mb) dfrobot_firebeetle2_esp32s3.menu.FlashSize.16M.build.flash_size=16MB #dfrobot_firebeetle2_esp32s3.menu.FlashSize.32M=32MB (256Mb) @@ -16564,7 +16517,6 @@ nologo_esp32s3_pico.menu.FlashMode.opi.build.flash_freq=80m nologo_esp32s3_pico.menu.FlashSize.8M=8MB (64Mb) nologo_esp32s3_pico.menu.FlashSize.8M.build.flash_size=8MB -nologo_esp32s3_pico.menu.FlashSize.8M.build.partitions=default_8MB nologo_esp32s3_pico.menu.FlashSize.16M=16MB (128Mb) nologo_esp32s3_pico.menu.FlashSize.16M.build.flash_size=16MB @@ -17826,10 +17778,8 @@ esp32s2-devkitlipo.menu.FlashSize.4M=4MB (32Mb) esp32s2-devkitlipo.menu.FlashSize.4M.build.flash_size=4MB esp32s2-devkitlipo.menu.FlashSize.8M=8MB (64Mb) esp32s2-devkitlipo.menu.FlashSize.8M.build.flash_size=8MB -esp32s2-devkitlipo.menu.FlashSize.8M.build.partitions=default_8MB esp32s2-devkitlipo.menu.FlashSize.2M=2MB (16Mb) esp32s2-devkitlipo.menu.FlashSize.2M.build.flash_size=2MB -esp32s2-devkitlipo.menu.FlashSize.2M.build.partitions=minimal esp32s2-devkitlipo.menu.FlashSize.16M=16MB (128Mb) esp32s2-devkitlipo.menu.FlashSize.16M.build.flash_size=16MB @@ -18023,10 +17973,8 @@ esp32s2-devkitlipo-usb.menu.FlashSize.4M=4MB (32Mb) esp32s2-devkitlipo-usb.menu.FlashSize.4M.build.flash_size=4MB esp32s2-devkitlipo-usb.menu.FlashSize.8M=8MB (64Mb) esp32s2-devkitlipo-usb.menu.FlashSize.8M.build.flash_size=8MB -esp32s2-devkitlipo-usb.menu.FlashSize.8M.build.partitions=default_8MB esp32s2-devkitlipo-usb.menu.FlashSize.2M=2MB (16Mb) esp32s2-devkitlipo-usb.menu.FlashSize.2M.build.flash_size=2MB -esp32s2-devkitlipo-usb.menu.FlashSize.2M.build.partitions=minimal esp32s2-devkitlipo-usb.menu.FlashSize.16M=16MB (128Mb) esp32s2-devkitlipo-usb.menu.FlashSize.16M.build.flash_size=16MB @@ -18157,12 +18105,10 @@ esp32s3-devkitlipo.menu.FlashSize.4M=4MB (32Mb) esp32s3-devkitlipo.menu.FlashSize.4M.build.flash_size=4MB esp32s3-devkitlipo.menu.FlashSize.8M=8MB (64Mb) esp32s3-devkitlipo.menu.FlashSize.8M.build.flash_size=8MB -esp32s3-devkitlipo.menu.FlashSize.8M.build.partitions=default_8MB esp32s3-devkitlipo.menu.FlashSize.16M=16MB (128Mb) esp32s3-devkitlipo.menu.FlashSize.16M.build.flash_size=16MB esp32s3-devkitlipo.menu.FlashSize.32M=32MB (256Mb) esp32s3-devkitlipo.menu.FlashSize.32M.build.flash_size=32MB -esp32s3-devkitlipo.menu.FlashSize.32M.build.partitions=app5M_fat24M_32MB esp32s3-devkitlipo.menu.LoopCore.1=Core 1 esp32s3-devkitlipo.menu.LoopCore.1.build.loop_core=-DARDUINO_RUNNING_CORE=1 @@ -18438,10 +18384,8 @@ esp32c3-devkitlipo.menu.FlashSize.4M=4MB (32Mb) esp32c3-devkitlipo.menu.FlashSize.4M.build.flash_size=4MB esp32c3-devkitlipo.menu.FlashSize.8M=8MB (64Mb) esp32c3-devkitlipo.menu.FlashSize.8M.build.flash_size=8MB -esp32c3-devkitlipo.menu.FlashSize.8M.build.partitions=default_8MB esp32c3-devkitlipo.menu.FlashSize.2M=2MB (16Mb) esp32c3-devkitlipo.menu.FlashSize.2M.build.flash_size=2MB -esp32c3-devkitlipo.menu.FlashSize.2M.build.partitions=minimal esp32c3-devkitlipo.menu.FlashSize.16M=16MB (128Mb) esp32c3-devkitlipo.menu.FlashSize.16M.build.flash_size=16MB @@ -18613,10 +18557,8 @@ esp32c6-evb.menu.FlashSize.4M=4MB (32Mb) esp32c6-evb.menu.FlashSize.4M.build.flash_size=4MB esp32c6-evb.menu.FlashSize.8M=8MB (64Mb) esp32c6-evb.menu.FlashSize.8M.build.flash_size=8MB -esp32c6-evb.menu.FlashSize.8M.build.partitions=default_8MB esp32c6-evb.menu.FlashSize.2M=2MB (16Mb) esp32c6-evb.menu.FlashSize.2M.build.flash_size=2MB -esp32c6-evb.menu.FlashSize.2M.build.partitions=minimal esp32c6-evb.menu.FlashSize.16M=16MB (128Mb) esp32c6-evb.menu.FlashSize.16M.build.flash_size=16MB @@ -18795,10 +18737,8 @@ esp32h2-devkitlipo.menu.FlashSize.4M=4MB (32Mb) esp32h2-devkitlipo.menu.FlashSize.4M.build.flash_size=4MB esp32h2-devkitlipo.menu.FlashSize.8M=8MB (64Mb) esp32h2-devkitlipo.menu.FlashSize.8M.build.flash_size=8MB -esp32h2-devkitlipo.menu.FlashSize.8M.build.partitions=default_8MB esp32h2-devkitlipo.menu.FlashSize.2M=2MB (16Mb) esp32h2-devkitlipo.menu.FlashSize.2M.build.flash_size=2MB -esp32h2-devkitlipo.menu.FlashSize.2M.build.partitions=minimal esp32h2-devkitlipo.menu.FlashSize.16M=16MB (128Mb) esp32h2-devkitlipo.menu.FlashSize.16M.build.flash_size=16MB @@ -18984,10 +18924,8 @@ esp32-sbc-fabgl.menu.FlashSize.4M=4MB (32Mb) esp32-sbc-fabgl.menu.FlashSize.4M.build.flash_size=4MB esp32-sbc-fabgl.menu.FlashSize.8M=8MB (64Mb) esp32-sbc-fabgl.menu.FlashSize.8M.build.flash_size=8MB -esp32-sbc-fabgl.menu.FlashSize.8M.build.partitions=default_8MB esp32-sbc-fabgl.menu.FlashSize.2M=2MB (16Mb) esp32-sbc-fabgl.menu.FlashSize.2M.build.flash_size=2MB -esp32-sbc-fabgl.menu.FlashSize.2M.build.partitions=minimal esp32-sbc-fabgl.menu.FlashSize.16M=16MB (128Mb) esp32-sbc-fabgl.menu.FlashSize.16M.build.flash_size=16MB @@ -20686,7 +20624,6 @@ m5stack_atoms3.menu.FlashMode.opi.build.flash_freq=80m m5stack_atoms3.menu.FlashSize.8M=8MB (64Mb) m5stack_atoms3.menu.FlashSize.8M.build.flash_size=8MB -m5stack_atoms3.menu.FlashSize.8M.build.partitions=default_8MB m5stack_atoms3.menu.LoopCore.1=Core 1 m5stack_atoms3.menu.LoopCore.1.build.loop_core=-DARDUINO_RUNNING_CORE=1 @@ -20920,7 +20857,6 @@ m5stack_cores3.menu.FlashSize.16M=16MB (128Mb) m5stack_cores3.menu.FlashSize.16M.build.flash_size=16MB m5stack_cores3.menu.FlashSize.32M=32MB (256Mb) m5stack_cores3.menu.FlashSize.32M.build.flash_size=32MB -m5stack_cores3.menu.FlashSize.32M.build.partitions=app5M_fat24M_32MB m5stack_cores3.menu.LoopCore.1=Core 1 m5stack_cores3.menu.LoopCore.1.build.loop_core=-DARDUINO_RUNNING_CORE=1 @@ -21463,7 +21399,6 @@ m5stack_unit_cams3.menu.FlashSize.16M=16MB (128Mb) m5stack_unit_cams3.menu.FlashSize.16M.build.flash_size=16MB m5stack_unit_cams3.menu.FlashSize.32M=32MB (256Mb) m5stack_unit_cams3.menu.FlashSize.32M.build.flash_size=32MB -m5stack_unit_cams3.menu.FlashSize.32M.build.partitions=app5M_fat24M_32MB m5stack_unit_cams3.menu.LoopCore.1=Core 1 m5stack_unit_cams3.menu.LoopCore.1.build.loop_core=-DARDUINO_RUNNING_CORE=1 @@ -22475,12 +22410,10 @@ m5stack_stamp_s3.menu.FlashSize.4M=4MB (32Mb) m5stack_stamp_s3.menu.FlashSize.4M.build.flash_size=4MB m5stack_stamp_s3.menu.FlashSize.8M=8MB (64Mb) m5stack_stamp_s3.menu.FlashSize.8M.build.flash_size=8MB -m5stack_stamp_s3.menu.FlashSize.8M.build.partitions=default_8MB m5stack_stamp_s3.menu.FlashSize.16M=16MB (128Mb) m5stack_stamp_s3.menu.FlashSize.16M.build.flash_size=16MB m5stack_stamp_s3.menu.FlashSize.32M=32MB (256Mb) m5stack_stamp_s3.menu.FlashSize.32M.build.flash_size=32MB -m5stack_stamp_s3.menu.FlashSize.32M.build.partitions=app5M_fat24M_32MB m5stack_stamp_s3.menu.LoopCore.1=Core 1 m5stack_stamp_s3.menu.LoopCore.1.build.loop_core=-DARDUINO_RUNNING_CORE=1 @@ -22714,12 +22647,10 @@ m5stack_capsule.menu.FlashSize.4M=4MB (32Mb) m5stack_capsule.menu.FlashSize.4M.build.flash_size=4MB m5stack_capsule.menu.FlashSize.8M=8MB (64Mb) m5stack_capsule.menu.FlashSize.8M.build.flash_size=8MB -m5stack_capsule.menu.FlashSize.8M.build.partitions=default_8MB m5stack_capsule.menu.FlashSize.16M=16MB (128Mb) m5stack_capsule.menu.FlashSize.16M.build.flash_size=16MB m5stack_capsule.menu.FlashSize.32M=32MB (256Mb) m5stack_capsule.menu.FlashSize.32M.build.flash_size=32MB -m5stack_capsule.menu.FlashSize.32M.build.partitions=app5M_fat24M_32MB m5stack_capsule.menu.LoopCore.1=Core 1 m5stack_capsule.menu.LoopCore.1.build.loop_core=-DARDUINO_RUNNING_CORE=1 @@ -22956,12 +22887,10 @@ m5stack_cardputer.menu.FlashSize.4M=4MB (32Mb) m5stack_cardputer.menu.FlashSize.4M.build.flash_size=4MB m5stack_cardputer.menu.FlashSize.8M=8MB (64Mb) m5stack_cardputer.menu.FlashSize.8M.build.flash_size=8MB -m5stack_cardputer.menu.FlashSize.8M.build.partitions=default_8MB m5stack_cardputer.menu.FlashSize.16M=16MB (128Mb) m5stack_cardputer.menu.FlashSize.16M.build.flash_size=16MB m5stack_cardputer.menu.FlashSize.32M=32MB (256Mb) m5stack_cardputer.menu.FlashSize.32M.build.flash_size=32MB -m5stack_cardputer.menu.FlashSize.32M.build.partitions=app5M_fat24M_32MB m5stack_cardputer.menu.LoopCore.1=Core 1 m5stack_cardputer.menu.LoopCore.1.build.loop_core=-DARDUINO_RUNNING_CORE=1 @@ -23195,12 +23124,10 @@ m5stack_dial.menu.FlashSize.4M=4MB (32Mb) m5stack_dial.menu.FlashSize.4M.build.flash_size=4MB m5stack_dial.menu.FlashSize.8M=8MB (64Mb) m5stack_dial.menu.FlashSize.8M.build.flash_size=8MB -m5stack_dial.menu.FlashSize.8M.build.partitions=default_8MB m5stack_dial.menu.FlashSize.16M=16MB (128Mb) m5stack_dial.menu.FlashSize.16M.build.flash_size=16MB m5stack_dial.menu.FlashSize.32M=32MB (256Mb) m5stack_dial.menu.FlashSize.32M.build.flash_size=32MB -m5stack_dial.menu.FlashSize.32M.build.partitions=app5M_fat24M_32MB m5stack_dial.menu.LoopCore.1=Core 1 m5stack_dial.menu.LoopCore.1.build.loop_core=-DARDUINO_RUNNING_CORE=1 @@ -23434,12 +23361,10 @@ m5stack_dinmeter.menu.FlashSize.4M=4MB (32Mb) m5stack_dinmeter.menu.FlashSize.4M.build.flash_size=4MB m5stack_dinmeter.menu.FlashSize.8M=8MB (64Mb) m5stack_dinmeter.menu.FlashSize.8M.build.flash_size=8MB -m5stack_dinmeter.menu.FlashSize.8M.build.partitions=default_8MB m5stack_dinmeter.menu.FlashSize.16M=16MB (128Mb) m5stack_dinmeter.menu.FlashSize.16M.build.flash_size=16MB m5stack_dinmeter.menu.FlashSize.32M=32MB (256Mb) m5stack_dinmeter.menu.FlashSize.32M.build.flash_size=32MB -m5stack_dinmeter.menu.FlashSize.32M.build.partitions=app5M_fat24M_32MB m5stack_dinmeter.menu.LoopCore.1=Core 1 m5stack_dinmeter.menu.LoopCore.1.build.loop_core=-DARDUINO_RUNNING_CORE=1 @@ -26516,7 +26441,6 @@ espectro32.menu.FlashSize.4M=4MB (32Mb) espectro32.menu.FlashSize.4M.build.flash_size=4MB espectro32.menu.FlashSize.2M=2MB (16Mb) espectro32.menu.FlashSize.2M.build.flash_size=2MB -espectro32.menu.FlashSize.2M.build.partitions=minimal espectro32.menu.UploadSpeed.921600=921600 espectro32.menu.UploadSpeed.921600.upload.speed=921600 @@ -26745,10 +26669,8 @@ alksesp32.menu.FlashSize.4M=4MB (32Mb) alksesp32.menu.FlashSize.4M.build.flash_size=4MB alksesp32.menu.FlashSize.2M=2MB (16Mb) alksesp32.menu.FlashSize.2M.build.flash_size=2MB -alksesp32.menu.FlashSize.2M.build.partitions=minimal alksesp32.menu.FlashSize.16M=16MB (128Mb) alksesp32.menu.FlashSize.16M.build.flash_size=16MB -alksesp32.menu.FlashSize.16M.build.partitions=ffat alksesp32.menu.UploadSpeed.921600=921600 alksesp32.menu.UploadSpeed.921600.upload.speed=921600 @@ -27265,7 +27187,6 @@ bpi_leaf_s3.menu.FlashMode.opi.build.flash_freq=80m bpi_leaf_s3.menu.FlashSize.8M=8MB (64Mb) bpi_leaf_s3.menu.FlashSize.8M.build.flash_size=8MB -bpi_leaf_s3.menu.FlashSize.8M.build.partitions=default_8MB bpi_leaf_s3.menu.FlashSize.4M=4MB (32Mb) bpi_leaf_s3.menu.FlashSize.4M.build.flash_size=4MB bpi_leaf_s3.menu.FlashSize.16M=16MB (128Mb) @@ -28222,7 +28143,6 @@ frogboard.menu.FlashSize.4M=4MB (32Mb) frogboard.menu.FlashSize.4M.build.flash_size=4MB frogboard.menu.FlashSize.2M=2MB (16Mb) frogboard.menu.FlashSize.2M.build.flash_size=2MB -frogboard.menu.FlashSize.2M.build.partitions=minimal frogboard.menu.UploadSpeed.921600=921600 frogboard.menu.UploadSpeed.921600.upload.speed=921600 @@ -28819,10 +28739,8 @@ vintlabs-devkit-v1.menu.FlashSize.4M=4MB (32Mb) vintlabs-devkit-v1.menu.FlashSize.4M.build.flash_size=4MB vintlabs-devkit-v1.menu.FlashSize.8M=8MB (64Mb) vintlabs-devkit-v1.menu.FlashSize.8M.build.flash_size=8MB -vintlabs-devkit-v1.menu.FlashSize.8M.build.partitions=default_8MB vintlabs-devkit-v1.menu.FlashSize.2M=2MB (16Mb) vintlabs-devkit-v1.menu.FlashSize.2M.build.flash_size=2MB -vintlabs-devkit-v1.menu.FlashSize.2M.build.partitions=minimal vintlabs-devkit-v1.menu.FlashSize.16M=16MB (128Mb) vintlabs-devkit-v1.menu.FlashSize.16M.build.flash_size=16MB @@ -29023,10 +28941,8 @@ mgbot-iotik32a.menu.FlashSize.4M=4MB (32Mb) mgbot-iotik32a.menu.FlashSize.4M.build.flash_size=4MB mgbot-iotik32a.menu.FlashSize.8M=8MB (64Mb) mgbot-iotik32a.menu.FlashSize.8M.build.flash_size=8MB -mgbot-iotik32a.menu.FlashSize.8M.build.partitions=default_8MB mgbot-iotik32a.menu.FlashSize.2M=2MB (16Mb) mgbot-iotik32a.menu.FlashSize.2M.build.flash_size=2MB -mgbot-iotik32a.menu.FlashSize.2M.build.partitions=minimal mgbot-iotik32a.menu.FlashSize.16M=16MB (128Mb) mgbot-iotik32a.menu.FlashSize.16M.build.flash_size=16MB @@ -29172,10 +29088,8 @@ mgbot-iotik32b.menu.FlashSize.4M=4MB (32Mb) mgbot-iotik32b.menu.FlashSize.4M.build.flash_size=4MB mgbot-iotik32b.menu.FlashSize.8M=8MB (64Mb) mgbot-iotik32b.menu.FlashSize.8M.build.flash_size=8MB -mgbot-iotik32b.menu.FlashSize.8M.build.partitions=default_8MB mgbot-iotik32b.menu.FlashSize.2M=2MB (16Mb) mgbot-iotik32b.menu.FlashSize.2M.build.flash_size=2MB -mgbot-iotik32b.menu.FlashSize.2M.build.partitions=minimal mgbot-iotik32b.menu.FlashSize.16M=16MB (128Mb) mgbot-iotik32b.menu.FlashSize.16M.build.flash_size=16MB @@ -29911,10 +29825,8 @@ wifiduino32c3.menu.FlashSize.4M=4MB (32Mb) wifiduino32c3.menu.FlashSize.4M.build.flash_size=4MB wifiduino32c3.menu.FlashSize.8M=8MB (64Mb) wifiduino32c3.menu.FlashSize.8M.build.flash_size=8MB -wifiduino32c3.menu.FlashSize.8M.build.partitions=default_8MB wifiduino32c3.menu.FlashSize.2M=2MB (16Mb) wifiduino32c3.menu.FlashSize.2M.build.flash_size=2MB -wifiduino32c3.menu.FlashSize.2M.build.partitions=minimal wifiduino32c3.menu.FlashSize.16M=16MB (128Mb) wifiduino32c3.menu.FlashSize.16M.build.flash_size=16MB @@ -30032,7 +29944,6 @@ wifiduino32s3.menu.FlashSize.4M=4MB (32Mb) wifiduino32s3.menu.FlashSize.4M.build.flash_size=4MB wifiduino32s3.menu.FlashSize.8M=8MB (64Mb) wifiduino32s3.menu.FlashSize.8M.build.flash_size=8MB -wifiduino32s3.menu.FlashSize.8M.build.partitions=default_8MB wifiduino32s3.menu.FlashSize.16M=16MB (128Mb) wifiduino32s3.menu.FlashSize.16M.build.flash_size=16MB #wifiduino32s3.menu.FlashSize.32M=32MB (256Mb) @@ -31364,10 +31275,8 @@ kb32.menu.FlashSize.4M=4MB (32Mb) kb32.menu.FlashSize.4M.build.flash_size=4MB kb32.menu.FlashSize.8M=8MB (64Mb) kb32.menu.FlashSize.8M.build.flash_size=8MB -kb32.menu.FlashSize.8M.build.partitions=default_8MB kb32.menu.FlashSize.2M=2MB (16Mb) kb32.menu.FlashSize.2M.build.flash_size=2MB -kb32.menu.FlashSize.2M.build.partitions=minimal kb32.menu.FlashSize.16M=16MB (128Mb) kb32.menu.FlashSize.16M.build.flash_size=16MB @@ -31544,10 +31453,8 @@ deneyapkart.menu.FlashSize.4M=4MB (32Mb) deneyapkart.menu.FlashSize.4M.build.flash_size=4MB deneyapkart.menu.FlashSize.8M=8MB (64Mb) deneyapkart.menu.FlashSize.8M.build.flash_size=8MB -deneyapkart.menu.FlashSize.8M.build.partitions=default_8MB deneyapkart.menu.FlashSize.2M=2MB (16Mb) deneyapkart.menu.FlashSize.2M.build.flash_size=2MB -deneyapkart.menu.FlashSize.2M.build.partitions=minimal deneyapkart.menu.FlashSize.16M=16MB (128Mb) deneyapkart.menu.FlashSize.16M.build.flash_size=16MB @@ -31724,10 +31631,8 @@ deneyapkart1A.menu.FlashSize.4M=4MB (32Mb) deneyapkart1A.menu.FlashSize.4M.build.flash_size=4MB deneyapkart1A.menu.FlashSize.8M=8MB (64Mb) deneyapkart1A.menu.FlashSize.8M.build.flash_size=8MB -deneyapkart1A.menu.FlashSize.8M.build.partitions=default_8MB deneyapkart1A.menu.FlashSize.2M=2MB (16Mb) deneyapkart1A.menu.FlashSize.2M.build.flash_size=2MB -deneyapkart1A.menu.FlashSize.2M.build.partitions=minimal deneyapkart1A.menu.FlashSize.16M=16MB (128Mb) deneyapkart1A.menu.FlashSize.16M.build.flash_size=16MB @@ -31871,7 +31776,6 @@ deneyapkart1Av2.menu.FlashSize.4M=4MB (32Mb) deneyapkart1Av2.menu.FlashSize.4M.build.flash_size=4MB deneyapkart1Av2.menu.FlashSize.8M=8MB (64Mb) deneyapkart1Av2.menu.FlashSize.8M.build.flash_size=8MB -deneyapkart1Av2.menu.FlashSize.8M.build.partitions=default_8MB deneyapkart1Av2.menu.FlashSize.16M=16MB (128Mb) deneyapkart1Av2.menu.FlashSize.16M.build.flash_size=16MB #deneyapkart1Av2.menu.FlashSize.32M=32MB (256Mb) @@ -32155,10 +32059,8 @@ deneyapmini.menu.FlashSize.4M=4MB (32Mb) deneyapmini.menu.FlashSize.4M.build.flash_size=4MB deneyapmini.menu.FlashSize.8M=8MB (64Mb) deneyapmini.menu.FlashSize.8M.build.flash_size=8MB -deneyapmini.menu.FlashSize.8M.build.partitions=default_8MB deneyapmini.menu.FlashSize.2M=2MB (16Mb) deneyapmini.menu.FlashSize.2M.build.flash_size=2MB -deneyapmini.menu.FlashSize.2M.build.partitions=minimal deneyapmini.menu.FlashSize.16M=16MB (128Mb) deneyapmini.menu.FlashSize.16M.build.flash_size=16MB @@ -32347,10 +32249,8 @@ deneyapminiv2.menu.FlashSize.4M=4MB (32Mb) deneyapminiv2.menu.FlashSize.4M.build.flash_size=4MB deneyapminiv2.menu.FlashSize.8M=8MB (64Mb) deneyapminiv2.menu.FlashSize.8M.build.flash_size=8MB -deneyapminiv2.menu.FlashSize.8M.build.partitions=default_8MB deneyapminiv2.menu.FlashSize.2M=2MB (16Mb) deneyapminiv2.menu.FlashSize.2M.build.flash_size=2MB -deneyapminiv2.menu.FlashSize.2M.build.partitions=minimal deneyapminiv2.menu.FlashSize.16M=16MB (128Mb) deneyapminiv2.menu.FlashSize.16M.build.flash_size=16MB @@ -32516,10 +32416,8 @@ deneyapkartg.menu.FlashSize.4M=4MB (32Mb) deneyapkartg.menu.FlashSize.4M.build.flash_size=4MB deneyapkartg.menu.FlashSize.8M=8MB (64Mb) deneyapkartg.menu.FlashSize.8M.build.flash_size=8MB -deneyapkartg.menu.FlashSize.8M.build.partitions=default_8MB deneyapkartg.menu.FlashSize.2M=2MB (16Mb) deneyapkartg.menu.FlashSize.2M.build.flash_size=2MB -deneyapkartg.menu.FlashSize.2M.build.partitions=minimal deneyapkartg.menu.FlashSize.16M=16MB (128Mb) deneyapkartg.menu.FlashSize.16M.build.flash_size=16MB @@ -32823,10 +32721,8 @@ atmegazero_esp32s2.menu.FlashSize.4M=4MB (32Mb) atmegazero_esp32s2.menu.FlashSize.4M.build.flash_size=4MB atmegazero_esp32s2.menu.FlashSize.8M=8MB (64Mb) atmegazero_esp32s2.menu.FlashSize.8M.build.flash_size=8MB -atmegazero_esp32s2.menu.FlashSize.8M.build.partitions=default_8MB atmegazero_esp32s2.menu.FlashSize.2M=2MB (16Mb) atmegazero_esp32s2.menu.FlashSize.2M.build.flash_size=2MB -atmegazero_esp32s2.menu.FlashSize.2M.build.partitions=minimal atmegazero_esp32s2.menu.FlashSize.16M=16MB (128Mb) atmegazero_esp32s2.menu.FlashSize.16M.build.flash_size=16MB @@ -32915,7 +32811,6 @@ franzininho_wifi_esp32s2.menu.FlashSize.4M=4MB (32Mb) franzininho_wifi_esp32s2.menu.FlashSize.4M.build.flash_size=4MB franzininho_wifi_esp32s2.menu.FlashSize.8M=8MB (64Mb) franzininho_wifi_esp32s2.menu.FlashSize.8M.build.flash_size=8MB -franzininho_wifi_esp32s2.menu.FlashSize.8M.build.partitions=default_8MB franzininho_wifi_esp32s2.menu.FlashSize.16M=16MB (128Mb) franzininho_wifi_esp32s2.menu.FlashSize.16M.build.flash_size=16MB @@ -33023,7 +32918,6 @@ franzininho_wifi_msc_esp32s2.menu.FlashSize.4M=4MB (32Mb) franzininho_wifi_msc_esp32s2.menu.FlashSize.4M.build.flash_size=4MB franzininho_wifi_msc_esp32s2.menu.FlashSize.8M=8MB (64Mb) franzininho_wifi_msc_esp32s2.menu.FlashSize.8M.build.flash_size=8MB -franzininho_wifi_msc_esp32s2.menu.FlashSize.8M.build.partitions=default_8MB franzininho_wifi_msc_esp32s2.menu.FlashSize.16M=16MB (128Mb) franzininho_wifi_msc_esp32s2.menu.FlashSize.16M.build.flash_size=16MB @@ -33160,7 +33054,6 @@ tamc_termod_s3.menu.FlashSize.4M=4MB (32Mb) tamc_termod_s3.menu.FlashSize.4M.build.flash_size=4MB tamc_termod_s3.menu.FlashSize.8M=8MB (64Mb) tamc_termod_s3.menu.FlashSize.8M.build.flash_size=8MB -tamc_termod_s3.menu.FlashSize.8M.build.partitions=default_8MB tamc_termod_s3.menu.FlashSize.16M=16MB (128Mb) tamc_termod_s3.menu.FlashSize.16M.build.flash_size=16MB @@ -33622,7 +33515,6 @@ lionbit.menu.FlashFreq.40.build.flash_freq=40m lionbit.menu.FlashSize.4M=4MB (32Mb) lionbit.menu.FlashSize.4M.build.flash_size=4MB -lionbit.menu.FlashSize.4M.build.partitions=default @@ -33970,10 +33862,8 @@ XIAO_ESP32C3.menu.FlashSize.4M=4MB (32Mb) XIAO_ESP32C3.menu.FlashSize.4M.build.flash_size=4MB XIAO_ESP32C3.menu.FlashSize.8M=8MB (64Mb) XIAO_ESP32C3.menu.FlashSize.8M.build.flash_size=8MB -XIAO_ESP32C3.menu.FlashSize.8M.build.partitions=default_8MB XIAO_ESP32C3.menu.FlashSize.2M=2MB (16Mb) XIAO_ESP32C3.menu.FlashSize.2M.build.flash_size=2MB -XIAO_ESP32C3.menu.FlashSize.2M.build.partitions=minimal XIAO_ESP32C3.menu.FlashSize.16M=16MB (128Mb) XIAO_ESP32C3.menu.FlashSize.16M.build.flash_size=16MB @@ -34246,7 +34136,6 @@ XIAO_ESP32S3.menu.FlashMode.dio.build.flash_freq=80m XIAO_ESP32S3.menu.FlashSize.8M=8MB (64Mb) XIAO_ESP32S3.menu.FlashSize.8M.build.flash_size=8MB -XIAO_ESP32S3.menu.FlashSize.8M.build.partitions=default_8MB XIAO_ESP32S3.menu.LoopCore.1=Core 1 XIAO_ESP32S3.menu.LoopCore.1.build.loop_core=-DARDUINO_RUNNING_CORE=1 @@ -34669,10 +34558,8 @@ department_of_alchemy_minimain_esp32s2.menu.FlashSize.4M=4MB (32Mb) department_of_alchemy_minimain_esp32s2.menu.FlashSize.4M.build.flash_size=4MB department_of_alchemy_minimain_esp32s2.menu.FlashSize.8M=8MB (64Mb) department_of_alchemy_minimain_esp32s2.menu.FlashSize.8M.build.flash_size=8MB -department_of_alchemy_minimain_esp32s2.menu.FlashSize.8M.build.partitions=default_8MB department_of_alchemy_minimain_esp32s2.menu.FlashSize.2M=2MB (16Mb) department_of_alchemy_minimain_esp32s2.menu.FlashSize.2M.build.flash_size=2MB -department_of_alchemy_minimain_esp32s2.menu.FlashSize.2M.build.partitions=minimal department_of_alchemy_minimain_esp32s2.menu.FlashSize.16M=16MB (128Mb) department_of_alchemy_minimain_esp32s2.menu.FlashSize.16M.build.flash_size=16MB @@ -36413,10 +36300,8 @@ VALTRACK_V4_VTS_ESP32_C3.menu.FlashSize.4M=4MB (32Mb) VALTRACK_V4_VTS_ESP32_C3.menu.FlashSize.4M.build.flash_size=4MB VALTRACK_V4_VTS_ESP32_C3.menu.FlashSize.8M=8MB (64Mb) VALTRACK_V4_VTS_ESP32_C3.menu.FlashSize.8M.build.flash_size=8MB -VALTRACK_V4_VTS_ESP32_C3.menu.FlashSize.8M.build.partitions=default_8MB VALTRACK_V4_VTS_ESP32_C3.menu.FlashSize.2M=2MB (16Mb) VALTRACK_V4_VTS_ESP32_C3.menu.FlashSize.2M.build.flash_size=2MB -VALTRACK_V4_VTS_ESP32_C3.menu.FlashSize.2M.build.partitions=minimal VALTRACK_V4_VTS_ESP32_C3.menu.FlashSize.16M=16MB (128Mb) VALTRACK_V4_VTS_ESP32_C3.menu.FlashSize.16M.build.flash_size=16MB @@ -36566,10 +36451,8 @@ VALTRACK_V4_MFW_ESP32_C3.menu.FlashSize.4M=4MB (32Mb) VALTRACK_V4_MFW_ESP32_C3.menu.FlashSize.4M.build.flash_size=4MB VALTRACK_V4_MFW_ESP32_C3.menu.FlashSize.8M=8MB (64Mb) VALTRACK_V4_MFW_ESP32_C3.menu.FlashSize.8M.build.flash_size=8MB -VALTRACK_V4_MFW_ESP32_C3.menu.FlashSize.8M.build.partitions=default_8MB VALTRACK_V4_MFW_ESP32_C3.menu.FlashSize.2M=2MB (16Mb) VALTRACK_V4_MFW_ESP32_C3.menu.FlashSize.2M.build.flash_size=2MB -VALTRACK_V4_MFW_ESP32_C3.menu.FlashSize.2M.build.partitions=minimal VALTRACK_V4_MFW_ESP32_C3.menu.FlashSize.16M=16MB (128Mb) VALTRACK_V4_MFW_ESP32_C3.menu.FlashSize.16M.build.flash_size=16MB @@ -36687,7 +36570,6 @@ Edgebox-ESP-100.menu.FlashSize.4M=4MB (32Mb) Edgebox-ESP-100.menu.FlashSize.4M.build.flash_size=4MB Edgebox-ESP-100.menu.FlashSize.8M=8MB (64Mb) Edgebox-ESP-100.menu.FlashSize.8M.build.flash_size=8MB -Edgebox-ESP-100.menu.FlashSize.8M.build.partitions=default_8MB Edgebox-ESP-100.menu.FlashSize.16M=16MB (128Mb) Edgebox-ESP-100.menu.FlashSize.16M.build.flash_size=16MB #Edgebox-ESP-100.menu.FlashSize.32M=32MB (256Mb) @@ -37060,7 +36942,6 @@ nebulas3.menu.FlashSize.4M=4MB (32Mb) nebulas3.menu.FlashSize.4M.build.flash_size=4MB nebulas3.menu.FlashSize.8M=8MB (64Mb) nebulas3.menu.FlashSize.8M.build.flash_size=8MB -nebulas3.menu.FlashSize.8M.build.partitions=default_8MB nebulas3.menu.FlashSize.16M=16MB (128Mb) nebulas3.menu.FlashSize.16M.build.flash_size=16MB @@ -37285,7 +37166,6 @@ lionbits3.menu.FlashSize.4M=4MB (32Mb) lionbits3.menu.FlashSize.4M.build.flash_size=4MB lionbits3.menu.FlashSize.8M=8MB (64Mb) lionbits3.menu.FlashSize.8M.build.flash_size=8MB -lionbits3.menu.FlashSize.8M.build.partitions=default_8MB lionbits3.menu.FlashSize.16M=16MB (128Mb) lionbits3.menu.FlashSize.16M.build.flash_size=16MB #lionbits3.menu.FlashSize.32M=32MB (256Mb) @@ -39314,7 +39194,6 @@ epulse_feather_c6.menu.FlashSize.4M=4MB (32Mb) epulse_feather_c6.menu.FlashSize.4M.build.flash_size=4MB epulse_feather_c6.menu.FlashSize.2M=2MB (16Mb) epulse_feather_c6.menu.FlashSize.2M.build.flash_size=2MB -epulse_feather_c6.menu.FlashSize.2M.build.partitions=minimal epulse_feather_c6.menu.UploadSpeed.921600=921600 epulse_feather_c6.menu.UploadSpeed.921600.upload.speed=921600 @@ -39457,7 +39336,6 @@ Geekble_ESP32C3.menu.FlashSize.4M=4MB (Default) Geekble_ESP32C3.menu.FlashSize.4M.build.flash_size=4MB Geekble_ESP32C3.menu.FlashSize.2M=2MB Geekble_ESP32C3.menu.FlashSize.2M.build.flash_size=2MB -Geekble_ESP32C3.menu.FlashSize.2M.build.partitions=minimal Geekble_ESP32C3.menu.UploadSpeed.921600=921600 (Default) Geekble_ESP32C3.menu.UploadSpeed.921600.upload.speed=921600 From 8ce5f775fe928dc4541b0fecaf710de58aa3d198 Mon Sep 17 00:00:00 2001 From: Lucas Saavedra Vaz <32426024+lucasssvaz@users.noreply.github.com> Date: Fri, 4 Oct 2024 10:57:08 -0300 Subject: [PATCH 5/5] ci(compilation): Use default partition and add append to FQBN option (#10392) * ci(partitions): Use default partition for compilation in CI * fix(ci): Fix paths for sdkconfig * Fix build of camera web server * fix(ci): Fix test requirements check * ci(append): Add option to append to all FQBNs * fix(json): Fix JSON files to compile examples * fix(example): Use requires instead of target in ci.json fix(zigbee): Improve JSON files Co-authored-by: Jan Prochazka <90197375+P-R-O-C-H-Y@users.noreply.github.com> * fix(regex): Trim argument before grep * docs(ci): Add documentation about FQBNs in CI * fix(json): Remove redundant FQBNs * fix(json): Skip requirements if libs are not installed * fix(partitions): Use rainmaker specific partitions --------- Co-authored-by: me-no-dev Co-authored-by: Jan Prochazka <90197375+P-R-O-C-H-Y@users.noreply.github.com> --- .github/scripts/install-platformio-esp32.sh | 8 ++- .github/scripts/sketch_utils.sh | 60 ++++++++++++------- .github/scripts/tests_run.sh | 31 ++++++---- .github/workflows/tests_build.yml | 3 + .github/workflows/tests_hw.yml | 4 -- docs/en/contributing.rst | 46 +++++++++++++- .../examples/Camera/CameraWebServer/ci.json | 15 +++++ .../Camera/CameraWebServer/partitions.csv | 5 +- .../RainMaker/examples/RMakerCustom/ci.json | 3 +- .../examples/RMakerCustomAirCooler/ci.json | 3 +- .../examples/RMakerSonoffDualR3/ci.json | 3 +- .../RainMaker/examples/RMakerSwitch/ci.json | 3 +- libraries/WiFiProv/examples/WiFiProv/ci.json | 1 + .../Zigbee_Color_Dimmable_Light/ci.json | 18 ++---- .../Zigbee_Color_Dimmer_Switch/ci.json | 18 ++---- .../examples/Zigbee_On_Off_Light/ci.json | 18 ++---- .../examples/Zigbee_On_Off_Switch/ci.json | 18 ++---- .../examples/Zigbee_Scan_Networks/ci.json | 18 ++---- .../Zigbee_Temperature_Sensor/ci.json | 18 ++---- .../Zigbee/examples/Zigbee_Thermostat/ci.json | 18 ++---- platform.txt | 4 ++ 21 files changed, 168 insertions(+), 147 deletions(-) diff --git a/.github/scripts/install-platformio-esp32.sh b/.github/scripts/install-platformio-esp32.sh index 393c9f3a7..a9aab496e 100755 --- a/.github/scripts/install-platformio-esp32.sh +++ b/.github/scripts/install-platformio-esp32.sh @@ -6,7 +6,7 @@ PLATFORMIO_ESP32_URL="https://github.com/platformio/platform-espressif32.git" TOOLCHAIN_VERSION="12.2.0+20230208" ESPTOOLPY_VERSION="~1.40501.0" ESPRESSIF_ORGANIZATION_NAME="espressif" -LIBS_DIR="tools/esp32-arduino-libs" +SDKCONFIG_DIR="$PLATFORMIO_ESP32_PATH/tools/esp32-arduino-libs" echo "Installing Python Wheel ..." pip install wheel > /dev/null 2>&1 @@ -100,7 +100,8 @@ function count_sketches(){ # count_sketches requirements=$(jq -r '.requires[]? // empty' $sketchdir/ci.json) if [[ "$requirements" != "null" ]] || [[ "$requirements" != "" ]]; then for requirement in $requirements; do - found_line=$(grep -E "^$requirement" $LIBS_DIR/esp32/sdkconfig) + requirement=$(echo $requirement | xargs) + found_line=$(grep -E "^$requirement" "$SDKCONFIG_DIR/esp32/sdkconfig") if [[ "$found_line" == "" ]]; then continue 2 fi @@ -190,7 +191,8 @@ function build_pio_sketches(){ # build_pio_sketches [extra-options] while [ ! -z "$1" ]; do @@ -83,14 +89,21 @@ function build_sketch(){ # build_sketch [ex len=1 + if [ -f $sketchdir/ci.json ]; then + fqbn_append=`jq -r '.fqbn_append' $sketchdir/ci.json` + if [ $fqbn_append == "null" ]; then + fqbn_append="" + fi + fi + # Default FQBN options if none were passed in the command line. - esp32_opts="PSRAM=enabled,PartitionScheme=huge_app,FlashMode=dio" - esp32s2_opts="PSRAM=enabled,PartitionScheme=huge_app,FlashMode=dio" - esp32s3_opts="PSRAM=opi,USBMode=default,PartitionScheme=huge_app,FlashMode=dio" - esp32c3_opts="PartitionScheme=huge_app,FlashMode=dio" - esp32c6_opts="PartitionScheme=huge_app,FlashMode=dio" - esp32h2_opts="PartitionScheme=huge_app,FlashMode=dio" + esp32_opts="PSRAM=enabled,FlashMode=dio${fqbn_append:+,$fqbn_append}" + esp32s2_opts="PSRAM=enabled,FlashMode=dio${fqbn_append:+,$fqbn_append}" + esp32s3_opts="PSRAM=opi,USBMode=default,FlashMode=dio${fqbn_append:+,$fqbn_append}" + esp32c3_opts="FlashMode=dio${fqbn_append:+,$fqbn_append}" + esp32c6_opts="FlashMode=dio${fqbn_append:+,$fqbn_append}" + esp32h2_opts="FlashMode=dio${fqbn_append:+,$fqbn_append}" # Select the common part of the FQBN based on the target. The rest will be # appended depending on the passed options. @@ -154,7 +167,8 @@ function build_sketch(){ # build_sketch [ex requirements=$(jq -r '.requires[]? // empty' $sketchdir/ci.json) if [[ "$requirements" != "null" ]] || [[ "$requirements" != "" ]]; then for requirement in $requirements; do - found_line=$(grep -E "^$requirement" $LIBS_DIR/$target/sdkconfig) + requirement=$(echo $requirement | xargs) + found_line=$(grep -E "^$requirement" "$SDKCONFIG_DIR/$target/sdkconfig") if [[ "$found_line" == "" ]]; then echo "Target $target does not meet the requirement $requirement for $sketchname. Skipping." exit 0 @@ -270,10 +284,11 @@ function build_sketch(){ # build_sketch [ex unset options } -function count_sketches(){ # count_sketches [target] [file] +function count_sketches(){ # count_sketches [target] [file] [ignore-requirements] local path=$1 local target=$2 - local file=$3 + local ignore_requirements=$3 + local file=$4 if [ $# -lt 1 ]; then echo "ERROR: Illegal number of parameters" @@ -286,7 +301,7 @@ function count_sketches(){ # count_sketches [target] [file] return 0 fi - if [ -n "$file" ]; then + if [ -f "$file" ]; then local sketches=$(cat $file) else local sketches=$(find $path -name *.ino | sort) @@ -306,15 +321,18 @@ function count_sketches(){ # count_sketches [target] [file] continue fi - # Check if the sketch requires any configuration options - requirements=$(jq -r '.requires[]? // empty' $sketchdir/ci.json) - if [[ "$requirements" != "null" ]] || [[ "$requirements" != "" ]]; then - for requirement in $requirements; do - found_line=$(grep -E "^$requirement" $LIBS_DIR/$target/sdkconfig) - if [[ "$found_line" == "" ]]; then - continue 2 - fi - done + if [ "$ignore_requirements" != "1" ]; then + # Check if the sketch requires any configuration options + requirements=$(jq -r '.requires[]? // empty' $sketchdir/ci.json) + if [[ "$requirements" != "null" ]] || [[ "$requirements" != "" ]]; then + for requirement in $requirements; do + requirement=$(echo $requirement | xargs) + found_line=$(grep -E "^$requirement" $SDKCONFIG_DIR/$target/sdkconfig) + if [[ "$found_line" == "" ]]; then + continue 2 + fi + done + fi fi fi echo $sketch >> sketches.txt @@ -392,7 +410,7 @@ function build_sketches(){ # build_sketches `_ - are used if this field is not specified. + are used if this field is not specified. This overrides the default FQBNs and the ``fqbn_append`` field. The ``wifi`` test suite is a good example of how to use the ``ci.json`` file: diff --git a/libraries/ESP32/examples/Camera/CameraWebServer/ci.json b/libraries/ESP32/examples/Camera/CameraWebServer/ci.json index 7e0f3c899..35c3056dd 100644 --- a/libraries/ESP32/examples/Camera/CameraWebServer/ci.json +++ b/libraries/ESP32/examples/Camera/CameraWebServer/ci.json @@ -1,4 +1,19 @@ { + "fqbn": { + "esp32": [ + "espressif:esp32:esp32:PSRAM=enabled,PartitionScheme=custom,FlashMode=dio", + "espressif:esp32:esp32:PSRAM=disabled,PartitionScheme=custom,FlashMode=dio" + ], + "esp32s2": [ + "espressif:esp32:esp32s2:PSRAM=enabled,PartitionScheme=custom,FlashMode=dio", + "espressif:esp32:esp32s2:PSRAM=disabled,PartitionScheme=custom,FlashMode=dio" + ], + "esp32s3": [ + "espressif:esp32:esp32s3:PSRAM=opi,USBMode=default,PartitionScheme=custom,FlashMode=qio", + "espressif:esp32:esp32s3:PSRAM=enabled,USBMode=default,PartitionScheme=custom,FlashMode=qio", + "espressif:esp32:esp32s3:PSRAM=disabled,USBMode=default,PartitionScheme=custom,FlashMode=qio" + ] + }, "requires": [ "CONFIG_CAMERA_TASK_STACK_SIZE=[0-9]+" ] diff --git a/libraries/ESP32/examples/Camera/CameraWebServer/partitions.csv b/libraries/ESP32/examples/Camera/CameraWebServer/partitions.csv index 4f76ca6d7..b9f18c465 100644 --- a/libraries/ESP32/examples/Camera/CameraWebServer/partitions.csv +++ b/libraries/ESP32/examples/Camera/CameraWebServer/partitions.csv @@ -1,5 +1,6 @@ # Name, Type, SubType, Offset, Size, Flags nvs, data, nvs, 0x9000, 0x5000, otadata, data, ota, 0xe000, 0x2000, -app0, app, ota_0, 0x10000, 0x3d0000, -fr, data, , 0x3e0000, 0x20000, +app0, app, ota_0, 0x10000, 0x3c0000, +fr, data, , 0x3d0000, 0x20000, +coredump, data, coredump,0x3f0000, 0x10000, diff --git a/libraries/RainMaker/examples/RMakerCustom/ci.json b/libraries/RainMaker/examples/RMakerCustom/ci.json index de4e92436..833a13f08 100644 --- a/libraries/RainMaker/examples/RMakerCustom/ci.json +++ b/libraries/RainMaker/examples/RMakerCustom/ci.json @@ -1,6 +1,7 @@ { + "fqbn_append": "PartitionScheme=rainmaker_4MB", "requires": [ "CONFIG_SOC_WIFI_SUPPORTED=y", - "CONFIG_ESP_RMAKER_WORK_QUEUE_TASK_STACK" + "CONFIG_ESP_RMAKER_WORK_QUEUE_TASK_STACK=[1-9][0-9]*" ] } diff --git a/libraries/RainMaker/examples/RMakerCustomAirCooler/ci.json b/libraries/RainMaker/examples/RMakerCustomAirCooler/ci.json index de4e92436..833a13f08 100644 --- a/libraries/RainMaker/examples/RMakerCustomAirCooler/ci.json +++ b/libraries/RainMaker/examples/RMakerCustomAirCooler/ci.json @@ -1,6 +1,7 @@ { + "fqbn_append": "PartitionScheme=rainmaker_4MB", "requires": [ "CONFIG_SOC_WIFI_SUPPORTED=y", - "CONFIG_ESP_RMAKER_WORK_QUEUE_TASK_STACK" + "CONFIG_ESP_RMAKER_WORK_QUEUE_TASK_STACK=[1-9][0-9]*" ] } diff --git a/libraries/RainMaker/examples/RMakerSonoffDualR3/ci.json b/libraries/RainMaker/examples/RMakerSonoffDualR3/ci.json index de4e92436..833a13f08 100644 --- a/libraries/RainMaker/examples/RMakerSonoffDualR3/ci.json +++ b/libraries/RainMaker/examples/RMakerSonoffDualR3/ci.json @@ -1,6 +1,7 @@ { + "fqbn_append": "PartitionScheme=rainmaker_4MB", "requires": [ "CONFIG_SOC_WIFI_SUPPORTED=y", - "CONFIG_ESP_RMAKER_WORK_QUEUE_TASK_STACK" + "CONFIG_ESP_RMAKER_WORK_QUEUE_TASK_STACK=[1-9][0-9]*" ] } diff --git a/libraries/RainMaker/examples/RMakerSwitch/ci.json b/libraries/RainMaker/examples/RMakerSwitch/ci.json index de4e92436..833a13f08 100644 --- a/libraries/RainMaker/examples/RMakerSwitch/ci.json +++ b/libraries/RainMaker/examples/RMakerSwitch/ci.json @@ -1,6 +1,7 @@ { + "fqbn_append": "PartitionScheme=rainmaker_4MB", "requires": [ "CONFIG_SOC_WIFI_SUPPORTED=y", - "CONFIG_ESP_RMAKER_WORK_QUEUE_TASK_STACK" + "CONFIG_ESP_RMAKER_WORK_QUEUE_TASK_STACK=[1-9][0-9]*" ] } diff --git a/libraries/WiFiProv/examples/WiFiProv/ci.json b/libraries/WiFiProv/examples/WiFiProv/ci.json index 36babb827..04eb62b97 100644 --- a/libraries/WiFiProv/examples/WiFiProv/ci.json +++ b/libraries/WiFiProv/examples/WiFiProv/ci.json @@ -1,4 +1,5 @@ { + "fqbn_append": "PartitionScheme=huge_app", "requires": [ "CONFIG_SOC_WIFI_SUPPORTED=y" ] diff --git a/libraries/Zigbee/examples/Zigbee_Color_Dimmable_Light/ci.json b/libraries/Zigbee/examples/Zigbee_Color_Dimmable_Light/ci.json index 3aaf44eb3..7b7ccef8e 100644 --- a/libraries/Zigbee/examples/Zigbee_Color_Dimmable_Light/ci.json +++ b/libraries/Zigbee/examples/Zigbee_Color_Dimmable_Light/ci.json @@ -1,16 +1,6 @@ { - "fqbn": { - "esp32c6": [ - "espressif:esp32:esp32c6:PartitionScheme=zigbee,ZigbeeMode=ed" - ], - "esp32h2": [ - "espressif:esp32:esp32h2:PartitionScheme=zigbee,ZigbeeMode=ed" - ] - }, - "targets": { - "esp32": false, - "esp32c3": false, - "esp32s2": false, - "esp32s3": false - } + "fqbn_append": "PartitionScheme=zigbee,ZigbeeMode=ed", + "requires": [ + "CONFIG_SOC_IEEE802154_SUPPORTED=y" + ] } diff --git a/libraries/Zigbee/examples/Zigbee_Color_Dimmer_Switch/ci.json b/libraries/Zigbee/examples/Zigbee_Color_Dimmer_Switch/ci.json index c916121b9..e79a477da 100644 --- a/libraries/Zigbee/examples/Zigbee_Color_Dimmer_Switch/ci.json +++ b/libraries/Zigbee/examples/Zigbee_Color_Dimmer_Switch/ci.json @@ -1,16 +1,6 @@ { - "fqbn": { - "esp32c6": [ - "espressif:esp32:esp32c6:PartitionScheme=zigbee_zczr,ZigbeeMode=zczr" - ], - "esp32h2": [ - "espressif:esp32:esp32h2:PartitionScheme=zigbee_zczr,ZigbeeMode=zczr" - ] - }, - "targets": { - "esp32": false, - "esp32c3": false, - "esp32s2": false, - "esp32s3": false - } + "fqbn_append": "PartitionScheme=zigbee_zczr,ZigbeeMode=zczr", + "requires": [ + "CONFIG_SOC_IEEE802154_SUPPORTED=y" + ] } diff --git a/libraries/Zigbee/examples/Zigbee_On_Off_Light/ci.json b/libraries/Zigbee/examples/Zigbee_On_Off_Light/ci.json index 3aaf44eb3..7b7ccef8e 100644 --- a/libraries/Zigbee/examples/Zigbee_On_Off_Light/ci.json +++ b/libraries/Zigbee/examples/Zigbee_On_Off_Light/ci.json @@ -1,16 +1,6 @@ { - "fqbn": { - "esp32c6": [ - "espressif:esp32:esp32c6:PartitionScheme=zigbee,ZigbeeMode=ed" - ], - "esp32h2": [ - "espressif:esp32:esp32h2:PartitionScheme=zigbee,ZigbeeMode=ed" - ] - }, - "targets": { - "esp32": false, - "esp32c3": false, - "esp32s2": false, - "esp32s3": false - } + "fqbn_append": "PartitionScheme=zigbee,ZigbeeMode=ed", + "requires": [ + "CONFIG_SOC_IEEE802154_SUPPORTED=y" + ] } diff --git a/libraries/Zigbee/examples/Zigbee_On_Off_Switch/ci.json b/libraries/Zigbee/examples/Zigbee_On_Off_Switch/ci.json index c916121b9..e79a477da 100644 --- a/libraries/Zigbee/examples/Zigbee_On_Off_Switch/ci.json +++ b/libraries/Zigbee/examples/Zigbee_On_Off_Switch/ci.json @@ -1,16 +1,6 @@ { - "fqbn": { - "esp32c6": [ - "espressif:esp32:esp32c6:PartitionScheme=zigbee_zczr,ZigbeeMode=zczr" - ], - "esp32h2": [ - "espressif:esp32:esp32h2:PartitionScheme=zigbee_zczr,ZigbeeMode=zczr" - ] - }, - "targets": { - "esp32": false, - "esp32c3": false, - "esp32s2": false, - "esp32s3": false - } + "fqbn_append": "PartitionScheme=zigbee_zczr,ZigbeeMode=zczr", + "requires": [ + "CONFIG_SOC_IEEE802154_SUPPORTED=y" + ] } diff --git a/libraries/Zigbee/examples/Zigbee_Scan_Networks/ci.json b/libraries/Zigbee/examples/Zigbee_Scan_Networks/ci.json index 3aaf44eb3..7b7ccef8e 100644 --- a/libraries/Zigbee/examples/Zigbee_Scan_Networks/ci.json +++ b/libraries/Zigbee/examples/Zigbee_Scan_Networks/ci.json @@ -1,16 +1,6 @@ { - "fqbn": { - "esp32c6": [ - "espressif:esp32:esp32c6:PartitionScheme=zigbee,ZigbeeMode=ed" - ], - "esp32h2": [ - "espressif:esp32:esp32h2:PartitionScheme=zigbee,ZigbeeMode=ed" - ] - }, - "targets": { - "esp32": false, - "esp32c3": false, - "esp32s2": false, - "esp32s3": false - } + "fqbn_append": "PartitionScheme=zigbee,ZigbeeMode=ed", + "requires": [ + "CONFIG_SOC_IEEE802154_SUPPORTED=y" + ] } diff --git a/libraries/Zigbee/examples/Zigbee_Temperature_Sensor/ci.json b/libraries/Zigbee/examples/Zigbee_Temperature_Sensor/ci.json index 3aaf44eb3..7b7ccef8e 100644 --- a/libraries/Zigbee/examples/Zigbee_Temperature_Sensor/ci.json +++ b/libraries/Zigbee/examples/Zigbee_Temperature_Sensor/ci.json @@ -1,16 +1,6 @@ { - "fqbn": { - "esp32c6": [ - "espressif:esp32:esp32c6:PartitionScheme=zigbee,ZigbeeMode=ed" - ], - "esp32h2": [ - "espressif:esp32:esp32h2:PartitionScheme=zigbee,ZigbeeMode=ed" - ] - }, - "targets": { - "esp32": false, - "esp32c3": false, - "esp32s2": false, - "esp32s3": false - } + "fqbn_append": "PartitionScheme=zigbee,ZigbeeMode=ed", + "requires": [ + "CONFIG_SOC_IEEE802154_SUPPORTED=y" + ] } diff --git a/libraries/Zigbee/examples/Zigbee_Thermostat/ci.json b/libraries/Zigbee/examples/Zigbee_Thermostat/ci.json index c916121b9..e79a477da 100644 --- a/libraries/Zigbee/examples/Zigbee_Thermostat/ci.json +++ b/libraries/Zigbee/examples/Zigbee_Thermostat/ci.json @@ -1,16 +1,6 @@ { - "fqbn": { - "esp32c6": [ - "espressif:esp32:esp32c6:PartitionScheme=zigbee_zczr,ZigbeeMode=zczr" - ], - "esp32h2": [ - "espressif:esp32:esp32h2:PartitionScheme=zigbee_zczr,ZigbeeMode=zczr" - ] - }, - "targets": { - "esp32": false, - "esp32c3": false, - "esp32s2": false, - "esp32s3": false - } + "fqbn_append": "PartitionScheme=zigbee_zczr,ZigbeeMode=zczr", + "requires": [ + "CONFIG_SOC_IEEE802154_SUPPORTED=y" + ] } diff --git a/platform.txt b/platform.txt index 873e27b0e..a1574e2f7 100644 --- a/platform.txt +++ b/platform.txt @@ -143,6 +143,10 @@ recipe.hooks.prebuild.7.pattern.windows=cmd /c type nul > "{file_opts.path}" recipe.hooks.core.prebuild.1.pattern.windows=cmd /c echo "-DARDUINO_CORE_BUILD" > "{file_opts.path}" recipe.hooks.core.postbuild.1.pattern.windows=cmd /c type nul > "{file_opts.path}" +# Copy sdkconfig to build folder +recipe.hooks.prebuild.8.pattern=/usr/bin/env bash -c "cp -f "{runtime.platform.path}"/tools/esp32-arduino-libs/{build.mcu}/sdkconfig "{build.path}"/sdkconfig" +recipe.hooks.prebuild.8.pattern.windows=cmd /c COPY /y "{runtime.platform.path}\tools\esp32-arduino-libs\{build.mcu}\sdkconfig" "{build.path}\sdkconfig" + ## Compile c files recipe.c.o.pattern="{compiler.path}{compiler.c.cmd}" {compiler.c.extra_flags} {compiler.c.flags} -DF_CPU={build.f_cpu} -DARDUINO={runtime.ide.version} -DARDUINO_{build.board} -DARDUINO_ARCH_{build.arch} -DARDUINO_BOARD="{build.board}" -DARDUINO_VARIANT="{build.variant}" -DARDUINO_PARTITION_{build.partitions} {build.extra_flags} {compiler.cpreprocessor.flags} {includes} "@{build.opt.path}" "@{file_opts.path}" "{source_file}" -o "{object_file}"