float dotp(float a[], float b[])
{
  int i;
  float sum0, sum1, sum;
  sum0 = 0;
  sum1 = 0;
  for(i=0; i<100; i+=2){
    sum0 += a[i] * b[i];
    sum1 += a[i + 1] * b[i + 1];
  }
  sum = sum0 + sum1;
  return(sum);
}

        .cproc a, b

        .reg sum, sum0, sum1, a, b
        .reg ai1:ai, bi1:bi, pi, pi1

        MVK 50,cntr         ; cntr = 100/2
        ZERO sum0           ; multiply result = 0
        ZERO sum1           ; multiply result = 0
LOOP:   .trip 50
        LDDW *a++,ai1:ai    ; load ai & ai+1 from memory
        LDDW *b++,bi1:bi    ; load bi & bi+1 from memory
        MPYSP ai,bi,pi      ; ai * bi
        MPYSP ai1,bi1,pi1   ; ai+1 * bi+1
        ADDSP pi,sum0,sum0  ; sum0 += (ai * bi)
        ADDSP pi1,sum1,sum1 ; sum1 += (ai+1 * bi+1)
 [cntr] SUB cntr,1,cntr     ; decrement loop counter
 [cntr] B LOOP              ; branch to loop
        ADDSP sum,sum1,sum0 ; compute final result
        .return sum
        .endproc

All instructions executing in parallel constitute an execute packet. An execute packet can contain up to eight instructions.

        LDW   .D1   *A4++,A2 ; load ai & ai+1 from memory
||      LDW   .D2   *B4++,B2 ; load bi & bi+1 from memory
||      MVK   .S1   50,A1    ; set up loop counter
||      ZERO  .L1   A7       ; zero out sum0 accumulator
||      ZERO  .L2   B7       ; zero out sum1 accumulator
   [A1] SUB   .S1   A1,1,A1  ; decrement loop counter
||      LDW   .D1   *A4++,A2 ;* load ai & ai+1 from memory
||      LDW   .D2   *B4++,B2 ;* load bi & bi+1 from memory
   [A1] SUB   .S1   A1,1,A1  ;* decrement loop counter
|| [A1] B     .S2   LOOP     ; branch to loop
||      LDW   .D1   *A4++,A2 ;** load ai & ai+1 from memory
||      LDW   .D2   *B4++,B2 ;** load bi & bi+1 from memory

   [A1] SUB   .S1   A1,1,A1  ;** decrement loop counter
|| [A1] B     .S2   LOOP     ;* branch to loop
||      LDW   .D1   *A4++,A2 ;*** load ai & ai+1 from memory
||      LDW   .D2   *B4++,B2 ;*** load bi & bi+1 from memory
   [A1] SUB   .S1   A1,1,A1  ;*** decrement loop counter
|| [A1] B     .S2   LOOP     ;** branch to loop
||      LDW   .D1   *A4++,A2 ;**** load ai & ai+1 from memory
||      LDW   .D2   *B4++,B2 ;**** load bi & bi+1 from memory
        MPY   .M1X  A2,B2,A6 ; ai * bi
||      MPYH  .M2X  A2,B2,B6 ; ai+1 * bi+1
||[A1]  SUB   .S1   A1,1,A1  ;**** decrement loop counter
||[A1]  B     .S2   LOOP     ;*** branch to loop
||      LDW   .D1   *A4++,A2 ;***** ld ai & ai+1 from memory
||      LDW   .D2   *B4++,B2 ;***** ld bi & bi+1 from memory
        MPY   .M1X  A2,B2,A6 ;* ai * bi
||      MPYH  .M2X  A2,B2,B6 ;* ai+1 * bi+1
||[A1]  SUB   .S1   A1,1,A1  ;***** decrement loop counter
||[A1]  B     .S2   LOOP     ;**** branch to loop
||      LDW   .D1   *A4++,A2 ;****** ld ai & ai+1 from memory
||      LDW   .D2   *B4++,B2 ;****** ld bi & bi+1 from memory
LOOP:
        ADD   .L1   A6,A7,A7 ; sum0 += (ai * bi)
||      ADD   .L2   B6,B7,B7 ; sum1 += (ai+1 * bi+1)
||      MPY   .M1X  A2,B2,A6 ;** ai * bi
||      MPYH  .M2X  A2,B2,B6 ;** ai+1 * bi+1
||[A1]  SUB   .S1   A1,1,A1  ;****** decrement loop counter
||[A1]  B     .S2   LOOP     ;***** branch to loop
||      LDW   .D1   *A4++,A2 ;******* ld ai & ai+1 fm memory
||      LDW   .D2   *B4++,B2 ;******* ld bi & bi+1 fm memory
; Branch occurs here
        ADD   .L1X  A7,B7,A4 ; sum = sum0 + sum1

В комплект компьютера входят системный блок, 23-дюймовый монитор, клавиатура и мышь. На ПК предустановлена операционная система «Эльбрус», разработанная на базе Linux.

Четырёхядерный процессор «Эльбрус-401» модификации Б имеет частоту 750 МГц, объём оперативной памяти в ПК — 24 ГБ, дисковой памяти — 1,2 ТБ (жёсткий диск на 1000 ГБ плюс SSD на 120 ГБ). В такой комплектации компьютер стоит 199 тысяч рублей.

В компании утверждают, что завершили подготовку к циклу серийного производства и готовы выполнить заказ на несколько сотен тысяч таких компьютеров.

V>>Я лишь хочу поинтересоваться источником твоего вдохновения.

Судя по реальным бенчмаркам, они таки тянут очень неплохо, и далеко не факт, что ядра эльбруса чем-то лучше.

LVV>>>>>Неужели доживу — куплю НАШ компьютер ?!

ампутировав человеку нравственные ориентиры, отучив его думать о Справедливости, американская масонерия повредила то, что изначально не хотела повреждать: связное и последовательное, продуктивное с точки зрения технического результата мышление.

VLIW можно считать логическим продолжением идеологии RISC

Согласно документации Apple, AltiVec в реализации на процессорах G4 и G5 может выполнять восемь 32-битных FLOPS за цикл,

  while (do1 || do2 || do3) {
    if (do1) { if (++cnt1 == lim1) { do1 = work1(); } else { delay_some(); } }
    if (do2) { if (++cnt2 == lim2) { do2 = work2(); } else { delay_some(); } }
    if (do3) { if (++cnt3 == lim3) { do3 = work3(); } else { delay_some(); } }
  }

V>Тут наоборот — похоже, что я не могу простейший алгоритм объяснить.

V>>>Любой, с длиной конвейера больше 2-х, вестимо.

N>>Хотя им это не нужно — они же поллят и получают ту же проблему с конвейером и без прерываний

V>Такие программисты и пишут. Ну разве что у них обязательно наблюдается такая особенность как внимательность к мелочам, в отличие от разработчиков цепочек if-ов для обслуживания протокола SIP, например.

N>  while (do1 || do2 || do3) {
N>    if (do1) { if (++cnt1 == lim1) { do1 = work1(); } else { delay_some(); } }
N>    if (do2) { if (++cnt2 == lim2) { do2 = work2(); } else { delay_some(); } }
N>    if (do3) { if (++cnt3 == lim3) { do3 = work3(); } else { delay_some(); } }
N>  }
N>

unsigned step1;
unsigned step2;

unsigned acc1=0;
unsigned acc2=0;

while(true) {  
    acc1 += step1;
    acc2 += step2;
    byte result = ((acc1 & 0x80000000) >> 30) | ((acc2 & 0x80000000) >> 31);
    outp(some_port, result);

    calc_next_values_of_step1_and_step2();
}

unsigned steps1[];
unsigned index1 = 0;
unsigned steps2[];
unsigned index2 = 0;

void calc_next_values_of_step1_and_step2() {
    index1 += ((acc1 & 0x80000000) >> 31);
    step1 = steps1[index1];

    index2 += ((acc2 & 0x80000000) >> 31);
    step2 = steps2[index2];
}

unsigned phase = 0;
const unsigned delta = ulong64_t(MAX_UINT32)*freq/sample_rate;

unsigned sin_gen_next() {
    return fixed_point_sin(phase+=delta);
}

LVV>>Неужели доживу — куплю НАШ компьютер ?!

По данным государственной корпорации Ростех, "8-ядерный русский процессор производится по технологии 28 нм.
По сравнению с «Эльбрус-4С», пиковая производительность нового процессора выше в 3-5 раз,
пропускная способность каналов ввода-вывода — в 8 раз

Неужели доживу — куплю НАШ компьютер ?!