domanda per gli esperti di #define - pagina 9

Nuovo commento
 
Alexandr Andreev:

Questo non funziona sempre.


Questo non è il test corretto perché i corpi dei cicli sono diversi.
Il secondo corpo ha più istruzioni cnt--
Quindi questo non è il mio test corretto.
Con PI penso che sia più corretto.

 
Roman:

Questo non è il test corretto perché i corpi dei cicli sono diversi.
Il secondo corpo ha anche istruzioni cnt--
Questo non è il mio test corretto.
Con PI penso che sia più corretto.

questo è solo il modo di vivere, il test è il più corretto possibile in termini di uso e di senso comune. In qualsiasi ciclo in cui cambiamo la dimensione dell'array stesso, ci sarà esattamente lo stesso codice. Questo esempio è giusto per i soldi.

Ma il PI è lì e i risultati non sono ovviamente a senso unico, controllate.

 
Alexandr Andreev:

Questo è esattamente il modo di vivere, un test che non è corretto in termini di uso e di senso comune.
In qualsiasi ciclo in cui cambiamo la dimensione dell'array stesso, ci sarà esattamente lo stesso codice. Questo esempio è giusto per i soldi.

Ma il PI è lì e i risultati non sono ovviamente in una direzione.

Ma come è corretto?
Se ci sono più istruzioni nel corpo del ciclo, viene eseguito più codice durante l'iterazione, viene incrementata un'istruzione extra.
che aumenta il tempo di esecuzione. È logico.
E quando i corpi sono gli stessi, è già sicuro valutare il riferimento alla condizione del ciclo.

 
Roman:

Come è corretto?
Se ci sono più istruzioni nel corpo del ciclo, viene eseguito più codice durante l'iterazione, viene incrementata un'istruzione extra.
che aumenta il tempo di esecuzione. È logico.
E quando i corpi sono gli stessi, possiamo già stimare con sicurezza la chiamata alla condizione di loop.

))))

Non è corretto secondo tutti i canoni. Hai tra le corse (esegui più spesso, compila più corse - un modo), quindi la differenza di calcolo di un modo è più grande del valore che stai calcolando. La differenza è dovuta ai compiti attuali del sistema. Cioè la quota del valore esaminato è troppo piccola, per aumentarla bisogna aumentare il numero di queste funzioni nel corpo.... e prendere l'operazione più economica. E questa è la moltiplicazione! Non ne ho ancora trovato un altro. Per esempio, il mio esempio usa una divisione - che è molte volte meno del modo in cui viene calcolato pi greco, dove viene usato anche il type ghosting (processo abbastanza costoso).

 
Alexandr Andreev:

))))

Non è corretto per tutti i canoni. Avete tra le corse (eseguite più spesso, compilate più corse - un modo), quindi avete una differenza di calcolo tra le corse per un modo più del valore professato. La differenza è dovuta ai compiti attuali del sistema. Cioè la quota del valore esaminato è troppo piccola, per aumentarla bisogna aumentare il numero di queste funzioni nel corpo.... e prendere l'operazione più economica. E questa è la moltiplicazione! Non ne ho ancora trovato un altro. Per esempio il mio esempio usa una divisione - che è molte volte meno del modo in cui viene calcolato pi greco, dove viene usato anche il type ghosting (processo abbastanza costoso).

Ancora una volta. Non è il corpo del ciclo che viene testato, ma la condizione del ciclo.
I corpi dei cicli devono essere uguali per misurare se la condizione è soddisfatta o no.
Altrimenti, il tempo di misurazione sarà diverso perché i corpi vengono eseguiti con tempi diversi.
Che è quello che abbiamo in questo caso, dato che c'è un'istruzione extra cnt--

  
void OnStart()
  {
   int mas[];
   int mas1[300];
   int mas2[300];
   int mas3[300];
   int mas4[300];
   int mas5[300];
   int mas6[300];
   int z=300;
   int size=1000000000;
   ArrayResize(mas,size);
   int r=0;
   int r1=0;
   int r2=0;
   int random;
   ulong max=100; 
   int t=0;
   int tr=0; 
   MathSrand(10);
    int num_steps=ArraySize(mas);
    double x, pi, sum=0.0;
    double step = 1.0/(double)num_steps;
    
     int v=size;
    ulong t1 = GetMicrosecondCount();
     
    
  // for(ulong z=0; z<max; z++)
     {
      for(int i=0; i<ArraySize(mas); i++)
        {  
        r2+=ArraySize(mas);
        r2<<=3;
        }

     }  
   ulong t2=GetMicrosecondCount();
   //for(ulong z=0; z<max; z++)
   int sizem=ArraySize(mas);
     {
      for(int i=0; i<sizem; i++)
        { 
        r2+=sizem;
        r2<<=3;
        
        }
     }
    
   ulong t3=GetMicrosecondCount();
   Print(t2-t1,"  ",t3-t2," ",r2," ",r1);
// Templ();
  }

In generale, si scopre che l'alternanza tra perdono e spostamento binario (che è una delle operazioni più economiche) influenza anche il calcolo di.... Beh, non c'è differenza, questo è il verdetto
 
Roman:

Ancora una volta. Non è il corpo del ciclo che viene testato, ma la condizione del ciclo.
I corpi dei cicli devono essere gli stessi per misurare se la condizione è soddisfatta.
Altrimenti il tempo di misurazione sarà diverso perché i corpi vengono eseguiti con tempi diversi.
Che abbiamo in questo caso, dato che c'è un'istruzione extra cnt--

In realtà il mio testo era esattamente sul modo con pi

 
Ho paura persino di chiedere di #define
 
Алексей Тарабанов:
Ho paura persino di chiedere di #define

Parliamo ancora della definizione.
Da quanto ho capito, non dà una spinta runtime nell'eseguibile.

 
Roman:

Parliamo ancora della definizione.
Da quanto ho capito, non dà un aumento dell'esecuzione nel file eseguibile.

Ok. Prima la definizione, poi l'eseguibile, poi l'esecuzione dell'eseguibile.

123456789101112
Nuovo commento
Motivazione: