Будет много. Это лишь вопрос времени. Главное, что эти расширения документированы и для них есть кодогенерация.

LLVM уже года четыре, как поддерживает RVV.

Но всё же, где в моем коде нахождения медианы Вы обнаружили хоть какую-то зависимость от Cortex-M или RISC-V?
Почему Вы упорно отказываетесь считать этот код универсальным для любого микропроцессора, от i4004 до AMD EPYC 9965?

Возьмем, для пример, STM32

Покажите мне живой мк на RISC-V с RVV )

А я не отказываюсь.

На STM32 свет клином сошелся?

Ну если именно "показать", то вот например:

Именно, что отказываетесь, упорно применяя код на Cortex-M33, игнорируя всё остальное.
Выше, например, Вы захотели увидеть именно MCU и именно RISC-V с поддержкой векторных инструкций.
Как будто этот код нельзя использовать на одноплатниках с тем же Allwinner Xuantie-C906.
Это даже не считая того, что похожий код я сейчас использую на AMD EPIC 9374F.

"Известными сейчас векторными расширениями систем команд, вне зависимости от архитектуры или конкретного процессора, сравнения векторизуется, а вот перестановки (swap) - нет."

Без понятия

Тоже свой алгоритм нахождения медианы... точнее среднего от медиан массива (отсекается по 0, 1 или несколько крайних значений, а из остального находится среднее арифметическое), сам массив при этом не повреждается. Условие - числа в массиве менее половины емкости типа переменной, т.к. старший бит отдаётся под метку... алгоритм разрабатывался для обработки данных с АЦП - там это условие соблюдается.
Фильтр не портит массив, это позволяет, используя колцевой буфер, использовать результаты работы АЦП повторно (это значит, что результаты фильтрации можно получать с частотой опроса АЦП)
К сожалению исходный алгоритм фильтра остался на жетком диске дома... а это я из готового кода "быстрого АмперВольтВаттОмМетра для ЛБП на меге8" выкусил.

Спойлер

Код написан в кодевижене, прошу понять и простить

Код:

unsigned int filtr (unsigned int inp[], unsigned char Length, unsigned char Median){
//inp[]  массив входных данных
//Length длина массива входных данных
//Median количество отбрасываемых крайних элементов с каждой стороны, т.е. мощность медианного фильтра
unsigned int tmp;
unsigned char i,j,k,u;         //счетчики и ограничители
unsigned long summ = 0;        //аккумулятор для суммирования усредняемых элементов массива
k=Length-Median;               //количество итераций поиска
u=k-Median;                    //определяем, сколько элементов нужно усреднять
while (k) {
          tmp=~(1<<15);        //0x7FFF - максимально допустимое для алгоритма число
          i=Length;
          while (i>0)          //в цикле перебираем весь массив - ищем минимальный элемент
              {
              i--;
              if (tmp >= inp[i])
                  {
                  j = i;
                  tmp = inp[i];
                  };
              };
          if (k<=u) summ+=tmp; //складываем в аккумулятор если обработать осталось <= требуемое для усреднения количество элементов
          inp[j]|=(1<<15);     //ставим метку на найденном и обработанном элементе, с ней он уже не будет минимальным
          k--;
          };
//----------
k=Length;                      //убираем все метки
do {inp[--k]&=~(1<<15);}
while (k>0);
//----------
tmp=summ/u;                    //находим среднее арифметическое
return (tmp);                  //и возвращаем его
}

Да, этот код не будет минимальным в вашей гонке, но у него задача и возможности другие - он позволяет быстро обрабатывать и выводить данные с относительно медленного (т.к. там производится серия измерений для уменьшения дискретности и шага отображения) АЦП.
Вроде всё верно выкусил, там просто ещё автокалибровка и автоподстройка 0 и сохранение этих данных в сжатом виде в служебной области массива реализованы... были...

Наверно и для моей задачи (из массива на 12 элементов отбросить по одному крайнему, а остальные усреднить) можно сделать быстрее, если делать фильтр жёстко под эту задачу, но этот код позволяет менять параметры на лету, подбирая фильтрацию под задачу.
Просто после проверки на железе это оказались оптимальные, а нормально работающий код переделывать не захотелось...

ПС не уверен, что я до среднего уровня тут присутствующих дотягиваюсь, т.к. смотрю, все уже на STMах и ESPхах катаются... а я с ними только в среде ардуино дело имел...

Не вижу. Полностью профилирующий код опять ведь не привели.
А я привожу:

Спойлер

Код:

#include <algorithm>
#include <cstdint>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#define BUF_SIZE 400000*77
#define MIN(a,b) (((a)<(b))?(a):(b))
#define MAX(a,b) (((a)>(b))?(a):(b))
#define SWAP(a,b,type) {type ttttttttt=a;a=b;b=ttttttttt;}

int median5_adrift(int* arr)
{
   int a = arr[0], b = arr[1], c = arr[2], d = arr[3], e = arr[4];

   if (a > b) std::swap(a, b);
   if (b > c) std::swap(b, c);
   if (c > d) std::swap(c, d);
   if (a > b) std::swap(a, b);
   if (b > c) std::swap(b, c);
   if (c > e) std::swap(c, e);
   if (a > b) std::swap(a, b);
   return (b > c) ? b : c;
}

int median3 (int a, int b, int c) {
  return MAX(MIN(a,b),MIN(c,MAX(a,b)));
}

int median5 (int *v) {
  return median3(
        v[4],
        MAX(MIN(v[0], v[1]), MIN(v[2], v[3])),
        MIN(MAX(v[0], v[1]), MAX(v[2], v[3]))
    );
}

void do_only_mean(int *rand_buf, int *res_buf) {
  for (int i = 0; i < BUF_SIZE - 5; i++) {
    res_buf[i] = median5(rand_buf++);
  }
  return;
}

void adrift_do_only_mean(int *rand_buf, int *res_buf) {
  for (int i = 0; i < BUF_SIZE - 5; i++) {
    res_buf[i] = median5_adrift(rand_buf++);
  }
  return;
}

int main() {
  int *rand_buf = (int*) malloc(BUF_SIZE*sizeof(int));
  int *res_buf = (int*) malloc(BUF_SIZE*sizeof(int));

  srand(time(NULL));
  for ( int i = 0; i < BUF_SIZE; i++) {
    rand_buf[i] = rand();
  }

  clock_t start = clock() ;
  adrift_do_only_mean(rand_buf, res_buf);
  clock_t end = clock() ;
  double adrift_elapsed_time = (end - start) / (double)CLOCKS_PER_SEC;

  start = clock() ;
  do_only_mean(rand_buf, res_buf);
  end = clock() ;
  double mean_elapsed_time = (end - start) / (double)CLOCKS_PER_SEC;

  printf("%f -- %f => %f\n", adrift_elapsed_time, mean_elapsed_time, adrift_elapsed_time / mean_elapsed_time);
}

Без оптимизации мой код выигрывает в 2 раза (gcc ./median.cpp)
1.701809 -- 0.775227 => 2.195240
С оптимизацией в 3.5 раза (gcc -O3 ./median.cpp)
0.116901 -- 0.032853 => 3.558305

На самом деле, это давно известно, что std::swap не векторизуется. Ну хоть убейся. А сравнения - легко и просто.
Если заинлайнить median3(), то median5() будет всего 16 команд.

Спойлер

Код:

   vmovd   (%rdi), %xmm2
   vmovd   4(%rdi), %xmm4
   vmovd   8(%rdi), %xmm0
   vpminsd   %xmm4, %xmm2, %xmm1
   vmovd   12(%rdi), %xmm5
   vpminsd   %xmm5, %xmm0, %xmm3
   vpmaxsd   %xmm4, %xmm2, %xmm2
   vpmaxsd   %xmm5, %xmm0, %xmm0
   vpmaxsd   %xmm1, %xmm3, %xmm3
   vpminsd   %xmm2, %xmm0, %xmm0
   vmovd   16(%rdi), %xmm1
   vpmaxsd   %xmm3, %xmm1, %xmm2
   vpminsd   %xmm3, %xmm1, %xmm1
   vpminsd   %xmm2, %xmm0, %xmm0
   vpmaxsd   %xmm1, %xmm0, %xmm0
   vmovd   %xmm0, %eax
   ret

А портянку median5_adrift() остается на регистрах общего назначения из 34 команд

Спойлер

Код:

   movl   (%rdi), %r8d
   movl   4(%rdi), %edx
   movl   8(%rdi), %eax
   movl   12(%rdi), %ecx
   movl   16(%rdi), %esi
   cmpl   %edx, %r8d
   jg   .L2
   cmpl   %eax, %edx
   jle   .L8
   movl   %edx, %edi
   movl   %r8d, %edx
   movl   %edi, %r8d
.L3:
   cmpl   %r8d, %ecx
   movl   %eax, %edi
   cmovg   %r8d, %ecx
   cmpl   %edx, %eax
   cmovge   %edx, %eax
   cmovge   %edi, %edx
.L4:
   cmpl   %ecx, %edx
   movl   %ecx, %edi
   cmovle   %edx, %ecx
   cmovle   %edi, %edx
   cmpl   %ecx, %eax
   cmovl   %ecx, %eax
   cmpl   %edx, %esi
   cmovle   %esi, %edx
   cmpl   %edx, %eax
   cmovl   %edx, %eax
   ret
   .p2align 4
   .p2align 3
.L2:
   cmpl   %eax, %r8d
   jg   .L3
   cmpl   %ecx, %eax
   cmovle   %eax, %ecx
   movl   %edx, %eax
   movl   %r8d, %edx
   jmp   .L4

Предвидя возражения, что используете легаси архитектуру без поддержки векторизации, предложу подумать, а что будет, когда потребуется сменить МК на более современный. Переписывать код будете?

Добавлено after 32 minutes 29 seconds:

А можно уточнить, в каких системных интеграторах или IT компаниях Вы такое видите?
Вот я не вижу. Если берем стажера после бакалавриата, то в более-менее свободное плавание он допускается только через полгода, не ранее. И все отдают отчет, что в течении этого полугода такой джун - убыточен. Каждая строчка его кода проходит очень жесткий code review и его PR сливается с основной веткой, порой, чуть ли не с десятой попытки. Уж простите, но утверждать PR моя прямая задача, как лида. Поэтому знаю о чем пишу.


Я же выше написал, как используются ИИ в профессиональной разработке. Если и находится разработчик, доверяющий AI, то он или очень быстро перестанет ему доверять, или я с ним расстанусь.


Прежде чем писать код, сначала надо осмыслить постановку, найти в ней ошибки, противоречия и неоднозначности, устранить их все вместе с аналитиком и заказчикам. И именно в этом заключается львиная часть работы разработчика.


Не для этого они выпускаются, а для того, чтобы можно было решать задачи, которые еще лет 10 назад были доступны только суперкомпьютерам, да и то не всем.
А уж кто и как свою дурь и лень при этом проявляет - отдельная тема и явно уже вне данного топика.


Опять видите только осколки вершины айсберга, да и то, выборочно. А ведь, если говорить об МК, то Espressif фактически совершил революцию своими дешевыми МК с WiFi и BLE.


Именно в таком применении - вряд ли кто будет. А вот себе на автоматические раздвижные ворота я бы, возможно, такую разработку поставил. Иногда идешь с тачкой, руки заняты и приходится ставить тачку и лезть в карман за мобилой или брелком, чтобы открыть ворота в пешеходном режиме. А так они будут сами открываться, причем только увидев меня, а не кого-то иного.
Это я к тому, что несмотря на то, что большинство подобных идей нежизнеспособны, именно благодаря их генерации их гор шлака выделяются жемчужины, которых иначе не возникло бы.
Я это только приветствую. Пробуйте, экспериментируйте, изобретайте. Даже если из тысячи попыток только одна окажется удачна - это уже движение вперед.

std::sort

std::nth_element

nth

std::*

std::vector<int>(BUF_SIZE)

Если заинлайнить median3(), то median5() будет всего 16 команд.

std::span

std::array

std::ranges::take_view

safocl,
1) Length>2*Median
да, у меня это на совести программиста, делалось для маленького проекта... действительно, стоит добавить проверку...
2) tmp=~(1<<15);
это борьба с магическими числами..., компилятор всё равно в 0x7FFF сам пересчитает
3) j = i;
да, пожалуй стоит какой то брейкпоинт на это поставить... чтобы в случае чего ошибку сразу видно стало
4) return...
на самом деле у меня в выдоде немного по другому сделано (для увеличения разрядности выходного числа за счет множества измерений), так написал для понятности... но сделано по очереди... сейчас не помню, вроде тогда пару байт флеша я этим сэкономил...

return

-- а это разве не ? и после можно просто

std::sort сортирует массив, а его портить нельзя, потому я грузил сначала в переменные.

Но я потестил, твой вариант медленнее в 4 раза )

Adrift, интересно кто гарантировал такую оптимизацию, почему она невозможна с моим вариантом, если они идентичны абсолютно по расположению в памяти? Откуда вообще информация, что переменные сразу появятся в регистрах без обращения к памяти? -- как раз я считаю будет происходить абсолютно обратное.

и постоянно обращается к памяти.

https://godbolt.org/z/EEYjeM7T6 -- все встало на свои места -- мой код успешно может оптимально инлайниться, а так же сжиматься при использовании...

как раз таки успешный инлайнинг -- вызова именно моей функции нет -- компилятор поместил все нужное в тело вызываемой функции...