246643_it-IT

liliconcom

Spazi dei nomi e prestazioni delle funzioni personalizzate

Nel creare una libreria di funzioni personalizzate, ho notato una marcata differenza nelle prestazioni dello stesso codice funzione a seconda che la funzione si trovi nello spazio dei nomi globale o in uno spazio dei nomi definito dall'utente. In almeno un mio caso frustrante, la stessa funzione impiega 7 volte più tempo per essere eseguita quando si trova in uno spazio dei nomi personalizzato, rispetto allo spazio dei nomi globale.

La differenza non ha importanza in molte applicazioni, ma sto usando queste funzioni su tabelle con righe da 500K a 5M; una differenza di questa grandezza fa la differenza tra una funzione che va bene rispetto a una che è inutilizzabile.

Ecco alcune JSL che esemplificano la differenza:

Names Default to Here(1);

Add Custom Functions(
 globaltest = New Custom Function(
  "Global",
  "test123",
  Function({x, y, z},
   {a, b, c},
   a = x;
   b = y;
   c = z;
   Return(c)
  )
 )
);
Add Custom Functions(
 nstest = New Custom Function(
  "other",
  "test123",
  Function({x, y, z},
   {a, b, c},
   a = x;
   b = y;
   c = z;
   Return(c)
  )
 )
);

For(i = 1, i <= 10000, i++,
 foo = ::test123(i, i, i);
);

For(i = 1, i <= 10000, i++,
 foo = other:test123(i, i, i);
);

Sulla mia macchina, :: test123 () viene eseguito in 143 ms, mentre altro: test123 richiede 343 ms. 

Ho alcune funzioni che idealmente mi piacerebbe implementare in uno spazio dei nomi personalizzato o come metodi di classe, ma il sovraccarico associato alla qualifica dello spazio dei nomi rende insostenibile.

Altri lo hanno notato e ci sono tecniche / considerazioni che possono accelerare l'invocazione di funzioni qualificate per lo spazio dei nomi?

Ri: Namespace e prestazioni delle funzioni personalizzate

Spiacenti, guardando nella guida allo scripting p 896 ho trovato alcune osservazioni al riguardo. Avrei dovuto saperlo guardare prima. Il suggerimento più grande sembra essere quello di favorire le espressioni rispetto alle funzioni se la velocità è critica. Inoltre, non avevo realizzato che le dichiarazioni Return () rallentassero le cose. Eventuali altri suggerimenti sarebbero stati grati.

Ri: Namespace e prestazioni delle funzioni personalizzate

return (), break () e continue () hanno tutti lo stesso comportamento. Mentre semplificano la lettura e la manutenzione della JSL, durante l'esecuzione vengono eseguite alcune spese generali. Sono abbastanza sicuro che il profiler JSL li indicherà se sono il punto caldo.

Sì, ho notato che esiste una penalità anche per gli spazi dei nomi, ma sono disposto a usarli per progetti complicati. Per le variabili semplici che si rivelano il punto focale, è possibile utilizzare una strategia di copia e copia come di seguito. (Profilo prima, non ottimizzare il codice che non ti rallenta!)

Quanto segue non fa altro che esercitare lo spazio dei nomi; la maggior parte del codice non vedrebbe così tanta penalità per l'utilizzo di uno spazio dei nomi. @EvanMcCorkle 

test = New Namespace(
 "test"
);

f = Function( {},
 {i, testx},
 test:x = 0;
 If( useLocal, // speed up by copy-in, copy-out
  testx = test:x;
  For( i = 1, i < 1e6, i += 1,
   testx = testx + 1
  );
  test:x = testx;
 , // no speed up
  For( i = 1, i < 1e6, i += 1,
   test:x = test:x + 1
  );
 );
);
useLocal = 0;
t0 = Tick Seconds();
f();
t1 = Tick Seconds();
Show( useLocal, t1 - t0, test:x );//t1 - t0 = 2.76666666666642;
useLocal = 1;
t0 = Tick Seconds();
f();
t1 = Tick Seconds();
Show( useLocal, t1 - t0, test:x );//t1 - t0 = 0.316666666665697;

Ri: Namespace e prestazioni delle funzioni personalizzate

Proverò la strategia in-out !!! Grazie Craige !!!!