как ускорить

[AlexVI]

Есть вот такой код:

for (i=0; i<N; i++) // длина массива может принимать значения 720 и больше
{
      llrp1[i]=Buf[i]+128; // значения флоат
      for (j=0; j<code_node[i].size; j++) //может принимать size = от 11 до 36
      {
         code_node[i].pi1[j] = llrp1[i];
      }
}

Buf - массив (длиной допустим 4000 символов)
code_node[i] - предаставляет из себя структуру с переменными size;index;pi1;
подскажите как можно ускорить этот код

[Stilet]

А почему ты решил что этот код работает медленно?

[Bugrimov]

AlexVI может вы имели в виду оптимизировать код? Тогда чем вас это не устраивает... ?

[AlexVI]

хотелось ускорить или оптимизировать мне нужны любые идеи какие есть. У самого уже закончились. Просто это только часть всего кода (это код декодера LLR BP). Начал с этой части кода.

Может как то лучше и быстрее реализовать через регистры или ассембл вставками или массив переделать в стандартный вектор C++ что позволит быстрее работать с этим вектором......

сам код следующий:

сам код следующий:

#define MAX_RANDOM     LONG_MAX   // Maximum value of random() 
#define NODES             16384   // Maximum of number of code/check nodes
#define J                    17   // Maximum number of checks per code bit
#define K                    17   // Maximum number of code bits per check

int max_size_M;
int max_size_N;

int n;                            // length
int k;                            // dimension
int nk;                           // redundancy
float  rate;                      // code rate

int M,N;                          // Size of parity-check matrix

// ---------------
// NODE STRUCTURES
// ---------------

struct parent_node {
    int size;
    int index[J];                     // indexes of children
    float pi1[J], pi0[J];             // messages "pi" to children
    };

struct child_node {
    int size;
    int index[K];                     // indexes of parents 
    float lambda1[K], lambda0[K];     // messages "lambda" to parents
    };

struct parent_node code_node[NODES];
struct child_node check_node[NODES];

double init_snr, final_snr, snr_increment;
double sim, num_sim, ber, amp;
long seed;
int error;
int data[NODES], codeword[NODES];
int data_int;
double snr, snr_rms;
float  transmited[NODES], received[NODES];
int hard[NODES], decoded[NODES];
int i,j, iter, max_iter;



void log_belprop()
{
int i,j,l,iter;
int m,aux;
float alpha;
float delt;
int sign;
float llrp1[NODES];                       // Prior probabilities (channel)
float q0[NODES], q1[NODES];               // Pseudo-posterior probabilities

  // -------------------
  // ***** STEP 0 *****
  // INITIALIZATION STEP
  // -------------------

  // Prior log-likelihood ratios (channel metrics)

  for (i=0;i<N;i++)
    {
    // LOOK-UP TABLE (LUT)
    llrp1[i] = received[i]*snr_rms;
    }

  // For every (m,l) such that there is a link between parents and
  // children, qm0[i][j] and qm1[i][j] are initialized to pl[j].
  // Notation: pi (Pearl) = q (MacKay)

  for (i=0; i<N; i++)                         // run over code nodes
    {

    for (j=0; j<code_node[i].size; j++)       // run over check nodes
      {

      code_node[i].pi1[j] = llrp1[i];

      }
    }

  iter = 0;                  // Counter of iterations

  do {

  // ---------------------------------------
  //         ***** STEP 1 *****
  // HORIZONTAL STEP = BOTTOM-UP PROPAGATION
  // ---------------------------------------
  //
  // MacKay:
  // Run through the checks m and compute, for each n in N(m) the
  // probabilitiy of a check symbol when code symbol is 0 (or 1)
  // given that the other code symbols have distribution qm0, qm1
  //
  // Pearl:
  // Node x_m computes new "lambda" messages to be sent to its parents
  // u_1, u_2, ..., u_K

  for (i=0; i<M; i++)
    for (j=0; j<check_node[i].size; j++)
      {
      delt = 0.0;
      sign = 0;                           // Keep track of sign of delt

      for (l=0; l<check_node[i].size; l++)
        {
        aux = check_node[i].index[l];

        if (aux != check_node[i].index[j])
          {
          // --------------------------------------------------------
          //  Compute the index "m" of the message from parent node
          // --------------------------------------------------------
          m = 0;
          while (  ( (code_node[aux-1].index[m]-1) != i )
                          && ( m < code_node[aux-1].size)  ) m++;

          if (code_node[aux-1].pi1[m] < 0.0) sign ^= 1;
          delt += F(fabs(code_node[aux-1].pi1[m]));

          }
        }
      if (sign == 0)
        check_node[i].lambda1[j] = F(delt);
      else
	check_node[i].lambda1[j] = -F(delt);

      // Normalization
      if (check_node[i].lambda1[j] < -30.0)
        check_node[i].lambda1[j] = -30.0;

      }

  // Increment the number of iterations, and check if maximum reached

  iter++;

  } while (iter < max_iter);

}

[AlexVI]

Сообщение от AlexVI

Есть вот такой код:

for (i=0; i<N; i++) // длина массива может принимать значения 720 и больше
{
      llrp1[i]=Buf[i]+128; // значения флоат
      for (j=0; j<code_node[i].size; j++) //может принимать size = от 11 до 36
      {
         code_node[i].pi1[j] = llrp1[i];
      }
}

Buf - массив (длиной допустим 4000 символов)
code_node[i] - предаставляет из себя структуру с переменными size;index;pi1;
подскажите как можно ускорить этот код

ребята варианты есть очень надо

[Smitt&Wesson]

Применяйте вместо for - while, вроде как быстрее работает. И ещё, проход цикла делайте с "хвоста". Тоже немного быстрее выполняется.

[waleri]

Сообщение от Smitt&Wesson

Применяйте вместо for - while, вроде как быстрее работает. И ещё, проход цикла делайте с "хвоста". Тоже немного быстрее выполняется.

Надеюсь, это шутка?

[AlexVI]

шутка однозначно но все равно спасибо...

[Zenon]

1. Вы каждое значение llrp1[i] используете только 1 раз, так что не надо их хранить в массиве и потом каждый раз доставать. И сам массив не нужен.
2. Можно попробовать не вычислять каждый раз code_node[i].pi[j], и code_node[i].size (а вдруг компилятор не догадается соптимизировать):

for (i=0; i<N; i++) // длина массива может принимать значения 720 и больше
{
      float v= Buf[i]+128; // значения флоат
      parent_node *pn= code_node + i;
      float *p= pn->pi1;
      float *pEnd= p + pn->size;
      for (; p < pEnd; ++p) //может принимать size = от 11 до 36
          *p= v; 
}

[AlexVI]

Сообщение от Zenon

1. Вы каждое значение llrp1[i] используете только 1 раз, так что не надо их хранить в массиве и потом каждый раз доставать. И сам массив не нужен.
2. Можно попробовать не вычислять каждый раз code_node[i].pi[j], и code_node[i].size (а вдруг компилятор не догадается соптимизировать):

for (i=0; i<N; i++) // длина массива может принимать значения 720 и больше
{
      float v= Buf[i]+128; // значения флоат
      parent_node *pn= code_node + i;
      float *p= pn->pi1;
      float *pEnd= p + pn->size;
      for (; p < pEnd; ++p) //может принимать size = от 11 до 36
          *p= v; 
}

Уточню:
code_node[i] - это i-ый кодовый узел всего их допустим 4080
каждый кодовый узел связан с проверочными узлами check_node[i](всего их допустим 720). и code_node[i].size - это количество проверочных узлов связанных с данным кодовым и наоборот для check_node[i]. Значения или скажем номера этих проверочных узлов хранятся в code_node[i]->index[j].

Изначально все структуры
struct parent_node {
int size; // известно
int index[J]; // известно // indexes of children
float pi1[J]; // messages "pi" to children // ВЫЧИСЛЯЕМ !!!
};

struct child_node {
int size; // известно
int index[K]; // indexes of parents // известно
float lambda1[K]; // messages "lambda" t/ ВЫЧИСЛЯЕМ !!!
};

struct parent_node code_node[NODES];
struct child_node check_node[NODES];