Prime Cores V1.0 Freeware

Totocellux · February 10, 2010

molto molto interessante

Quindi immagino che in definitiva ti dovresti poter avvantaggiare dell'utilizzo (quindi del significato) dei valori NaNs (signalling) per aumentare numericamente i FP senza peraltro rallentare l'elaborazione riguardante gli interi ?!

dimmi se sbaglio.

Xstreme · February 11, 2010

.....

Xstreme · February 11, 2010

molto molto interessante

Quindi immagino che in definitiva ti dovresti poter avvantaggiare dell'utilizzo (quindi del significato) dei valori NaNs (signalling) per aumentare numericamente i FP senza peraltro rallentare l'elaborazione riguardante gli interi ?!

dimmi se sbaglio.

io credo sia cosi, ma lo ho chiesto a lui propnendogli questo:

binary splitting method

Easy programs for constants computation

a domani

Totocellux · February 11, 2010

a domani

comunque sto tizio non è normale:

2 x Xeon X5482 Harpertown, 64GB di memoria e 4 dischi da 1TB solo come area di appoggio dell'elaborazione, gestiti singolarmente e indipendentemente dal suo programma, e diventano loro il collo di bottiglia ???!!

'sti americani so' troppo forti

Xstreme · February 11, 2010

a domani

comunque sto tizio non è normale:

2 x Xeon X5482 Harpertown, 64GB di memoria e 4 dischi da 1TB solo come area di appoggio dell'elaborazione, gestiti singolarmente e indipendentemente dal suo programma, e diventano loro il collo di bottiglia ???!!

'sti americani so' troppo forti

io lavorando su primecores sono molto limitato con il mio sistema,

devi contare che quando programmi a 48 cores ti servono risorse

come per 48 PC mono-core, per memorizzare una matrice con solo

2 miliardi di interi servono ben 8000000000 byte....e ti mancano

altri 47 cores

One1ros · February 11, 2010

ok
hai letto il readme nella patch 3.1.1 ?

sei conforme ?

Ho il .NET ma avevo il sistema incasinato, oggi non ha problemi.

Ho fatto l'upload di piu' test sempre nella stessa condizione con e6400 su XP pro sp3 e si puo' notare che i risultati si attestano intorno al 23.37s ma si trova anche un 23.41 e un 23.31, quindi mi chiedo quale sia la varianza di tali risultati...

Totocellux · February 11, 2010

io lavorando su primecores sono molto limitato con il mio sistema,
devi contare che quando programmi a 48 cores ti servono risorse

come per 48 PC mono-core, per memorizzare una matrice con solo

2 miliardi di interi servono ben 8000000000 byte....e ti mancano

altri 47 cores

non ho dubbi su questo calcolo: proprio venendo al discorso della tua limitazione, mi riferivo al fatto che lui abbia di per sé una conf davvero invidiabile e costosa e ..... riesca nonostante ciò a lamentarsene

Tornando al discorso matematico, ovviamente hai già idea di come applicare al problema precedente l'utilità del metodo dello splitting binario!?!

gear667 · February 11, 2010

grazie 1000

quello che mi servirebbe sarebbe un bel test con SixView,

per vedere se compara in modo corretto i test caricati

da diverse macchine

in teoria se io divido il tempo impiegato per il numero di cores

dovrei avere un risultato che indifferentemente dal livello del

test e dalla cpu impiegata (cores) mi dia un indice di velocità

univoco a visualizzi in modo preciso il sistema più veloce

caricato in SixView,

spero di essermi spiegato come si deve

intendi questo?

i risultati vengono visualizzati correttamente come i dati della configurazione

del pc

Xstreme · February 11, 2010

Ho il .NET ma avevo il sistema incasinato, oggi non ha problemi.

Ho fatto l'upload di piu' test sempre nella stessa condizione con e6400 su XP pro sp3 e si puo' notare che i risultati si attestano intorno al 23.37s ma si trova anche un 23.41 e un 23.31, quindi mi chiedo quale sia la varianza di tali risultati...

23 secondi ,

dopo la virgola > 50 = 23 secondi e mezzo

dopo la virgola

nel tuo caso la varianza è di 10 centesimi di secondo,

considerato che putroppo windows ha i suoi tempi...

e il multitasking ....è un ignoto... di più nun pozzo fà

Xstreme · February 11, 2010

intendi questo?

i risultati vengono visualizzati correttamente come i dati della configurazione

del pc

come vedi la tua velocita non cambia nella visual bar..quindi dovrebbe essere ok....

One1ros · February 11, 2010

23 secondi ,
dopo la virgola > 50 = 23 secondi e mezzo

dopo la virgola

nel tuo caso la varianza è di 10 centesimi di secondo,

considerato che putroppo windows ha i suoi tempi...

e il multitasking ....è un ignoto... di più nun pozzo fà

Ovviamente, infatti volevo solo sapere se avevi stimato tali valori.

Ottimo lavoro :n2mu: Sono veramente impressionato dalla tua competenza.

Xstreme · February 11, 2010

non ho dubbi su questo calcolo: proprio venendo al discorso della tua limitazione, mi riferivo al fatto che lui abbia di per sé una conf davvero invidiabile e costosa e ..... riesca nonostante ciò a lamentarsene

Tornando al discorso matematico, ovviamente hai già idea di come applicare al problema precedente l'utilità del metodo dello splitting binario!?!

 
#include 
#include "general.h"
#include "Complex.h"
#include "BigInt.h"
real MaxError;
real *LongNum1=NULL, *LongNum2=NULL;
extern void RealFFT(real*, ulong, int);

void FastMulInit(ulong Len) {
ulong MaxLen;
if ((Len & -Len) == Len)
 MaxLen = Len;
else {
 MaxLen = 2;
 do MaxLen*=2; while (MaxLen  C.SizeMax ) Len=C.SizeMax;
MaxError = 0;
for (x = 0; x  MaxError)
  MaxError = PyramidError;
 Carry = floor(Pyramid / BASE);
 c[x] = (short)(Pyramid - Carry * BASE);
}
do { x--; } while (c[x]==0); 
C.Size = x+1;
}

void RealFFTScalar(real *LongNum1, const real *LongNum2, ulong Len) {
Complex *CF1=(Complex*)LongNum1;
const Complex *CF2=(Complex*)LongNum2;
LongNum1[0] = LongNum1[0] * LongNum2[0];
LongNum1[1] = LongNum1[1] * LongNum2[1];
for (ulong x = 1; x 


 
questo è un moltiplicatore FFT
 
 
 
 

 
void CarryNormalize(real *Convolution, ulong Len, BigInt &C) {
real inv = 0.5 / Len;
real RawPyramid, Pyramid, PyramidError, Carry = 0;
ulong x;
ushort *c = C.Coef;
if ( Len > C.SizeMax ) Len=C.SizeMax;
MaxError = 0;
for (x = 0; x  MaxError)
  MaxError = PyramidError;
 Carry = floor(Pyramid / BASE);
 c[x] = (short)(Pyramid - Carry * BASE);
}
do { x--; } while (c[x]==0); 
C.Size = x+1;
}


void FHTConvolution(real *LongNum1, const real *LongNum2, ulong Len) {
ulong Step=2, Step2=Step*2;
ulong x,y;
LongNum1[0]   = LongNum1[0] * 2.0 * LongNum2[0];
LongNum1[1]   = LongNum1[1] * 2.0 * LongNum2[1];
while (Step 


 
questa è la routine di splitting binario
o convoluzione, che in base ad una certa
ampiezza mi taglia porzioni di frequenza, 
tipo fare una torta a fette identiche con due coltelli ed entrambe le mani

Edited February 11, 2010 by Xstreme

Totocellux · February 11, 2010

[..........]

 
void CarryNormalize(real *Convolution, ulong Len, BigInt &C) {
[color=Red][b]real inv = 0.5 / Len[/b][/color];
real RawPyramid, Pyramid, PyramidError, Carry = 0;
ulong x;
ushort *c = C.Coef;
if ( Len > C.SizeMax ) Len=C.SizeMax;
MaxError = 0;
for (x = 0; x  MaxError)
  MaxError = PyramidError;
 Carry = floor(Pyramid / BASE);
 c[x] = (short)(Pyramid - Carry * BASE);
}
do { x--; } while (c[x]==0); 
C.Size = x+1;
}


void FHTConvolution(real *LongNum1, const real *LongNum2, ulong Len) {
ulong Step=2, Step2=Step*2;
ulong x,y;
LongNum1[0]   = LongNum1[0] * 2.0 * LongNum2[0];
LongNum1[1]   = LongNum1[1] * 2.0 * LongNum2[1];
while (Step 

questa è la routine di splitting binario
o convoluzione, che in base ad una certa
ampiezza mi taglia porzioni di frequenza, 
tipo fare una torta a fette identiche con due coltelli ed entrambe le mani

immagino che il valore di quel real inv sia dovuto a:

real inv = 1/(len/2)

Ammetto che per seguirti devo accelerare un pò

Quello che non riesco ancora a correlare, è in che modo potrai fare utilizzo dei valori di signalling NaNs, perchè non credo che esista una funzione apposita.

Quindi, constatando che stai proseguendo speditamente, immagino tu abbia già qualcosa in pentola?!

Per conto mio ho scovato qualcosa che potrebbe esserti d'aiuto ...... con parte di codice in assembler (che non guasta mai )

void main()
{
   double a, b, c;
   a*=7;        // Exactly the same as it is now, a is nan.
   enableExceptions();
   c = 6;      // ok, c is initialized now
   c *= 10;
   b *= 10;    // BANG ! Straight into the debugger
   b *= 5;
   disableExceptions();
}
void enableExceptions() {
   version(D_InlineAsm_X86) {
        short cont;
        asm {
            fclex;
            fstcw cont;
            mov AX, cont;
            and AX, 0xFFFE; // enable invalid exception
            mov cont, AX;
            fldcw cont;
        }
    }
}
void disableExceptions() {
   version(D_InlineAsm_X86) {
        short cont;
        asm {
            fclex;
            fstcw cont;
            mov AX, cont;
            or AX, 0x1; // disable invalid exception
            mov cont, AX;
            fldcw cont;
        }
    }
}

Xstreme · February 11, 2010

immagino che il valore di quel real inv sia dovuto a:

real inv = 1/(len/2)

Ammetto che per seguirti devo accelerare un pò

Quello che non riesco ancora a correlare, è in che modo potrai fare utilizzo dei valori di signalling NaNs, perchè non credo che esista una funzione apposita.

Quindi, constatando che stai proseguendo speditamente, immagino tu abbia già qualcosa in pentola?!

Per conto mio ho scovato qualcosa che potrebbe esserti d'aiuto ...... con parte di codice in assembler (che non guasta mai )
void main()
{
   double a, b, c;
   a*=7;        // Exactly the same as it is now, a is nan.
   enableExceptions();
   c = 6;      // ok, c is initialized now
   c *= 10;
   b *= 10;    // BANG ! Straight into the debugger
   b *= 5;
   disableExceptions();
}
void enableExceptions() {
   version(D_InlineAsm_X86) {
        short cont;
        asm {
            fclex;
            fstcw cont;
            mov AX, cont;
            and AX, 0xFFFE; // enable invalid exception
            mov cont, AX;
            fldcw cont;
        }
    }
}
void disableExceptions() {
   version(D_InlineAsm_X86) {
        short cont;
        asm {
            fclex;
            fstcw cont;
            mov AX, cont;
            or AX, 0x1; // disable invalid exception
            mov cont, AX;
            fldcw cont;
        }
    }
}

m,anca il registro BX

senza il registro BX

AX e inutilizzabile

NAN

 
#include 
#include "mex.h"
void 
mexFunction( int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
{
int i, n;
double *pr, *pi;
double inf, nan;

/* Check for proper number of input and output arguments */ 
if (nrhs != 1) {
mexErrMsgTxt("One input argument required.");
} 
if(nlhs > 1){
mexErrMsgTxt("Too many output arguments.");
}

/* Check data type of input argument */
if (!mxIsDouble(prhs[0]) || mxIsComplex(prhs[0])) {
mexErrMsgTxt("Input argument must be of type real double.");
} 

/* Duplicate input array */
plhs[0]=mxDuplicateArray(prhs[0]);

pr = mxGetPr(plhs[0]);
pi = mxGetPi(plhs[0]);
n = mxGetNumberOfElements(plhs[0]);
inf = mxGetInf();
nan=mxGetNaN();
/* Check for 0, in real part of data, if the data is zero, replace
with NaN. Also check for INT_MAX and INT_MIN and replace with
INF/-INF respectively. */
for(i=0; i = INT_MAX){
pr[i]=inf;
}
else if (pr[i]

Edited February 11, 2010 by Xstreme

Totocellux · February 11, 2010

m,anca il registro BX
senza il registro BX

AX e inutilizzabile

[..........]

beh, ma quella dovrebbe essere semplicemente una parte della routine: al momento di ampliarla ed avere la necessità di utilizzare un offset o un indice non mancherebbe certo a te usare proficuamente BX come registro!

Xstreme · February 11, 2010

beh, ma quella dovrebbe essere semplicemente una parte della routine: al momento di ampliarla ed avere la necessità di utilizzare un offset o un indice non mancherebbe certo a te usare proficuamente BX come registro!

certo ,

comunque è un registro implicito,

cioè ax contiene sempre la metà di bx ...o l'inverso ?

non mi ricordo piu !!! ..la vecchiaia....!!!

NOTA:

mettendo più a fuoco....

Quanti lustri ha quel codice ? sembra roba epoca " 1000 spartani"

anche se devo dire che l'idea non e malaccio , anche se ....spartana .... :asd::asd:

Edited February 11, 2010 by Xstreme

Totocellux · February 11, 2010

[...........]

NOTA:

mettendo più a fuoco....

Quanti lustri ha quel codice ? sembra roba epoca " 1000 spartani"

anche se devo dire che l'idea non e malaccio , anche se ....spartana .... :asd::asd:

il concetto di sicuro non è recente, il codice non saprei dirti.

L'ho scovato su:

Dobbs Code Talk

Il tizio non è certamente il primo arrivato nel codificare in assembly: si chiama Walter Bright.

Dico questo perchè mi risulta che in passato abbia coadiuvato la Boeing inerentemente ai progetti degli apparati del controllo di volo di diversi aeroplani :AAAAH:

Considero quasi scontato il fatto che ci si possa ciecamente fidare

Xstreme · February 11, 2010

il concetto di sicuro non è recente, il codice non saprei dirti.

L'ho scovato su:

Dobbs Code Talk

Il tizio non è certamente il primo arrivato nel codificare in assembly: si chiama Walter Bright.

Dico questo perchè mi risulta che in passato abbia coadiuvato la Boeing inerentemente ai progetti degli apparati del controllo di volo di diversi aeroplani :AAAAH:

Considero quasi scontato il fatto che ci si possa ciecamente fidare

ah...lui ?

guarda questo... mi ha sempre fatto morire sto video....

[video=google;-7073020265668105471]http://video.google.com/videoplay?docid=-7073020265668105471&q=walter+bright&total=45&start=0&num=10&so=0&type=search&plindex=0 #

Totocellux · February 11, 2010

ah...lui ?

guarda questo... mi ha sempre fatto morire sto video....

Walter Bright @ NWCPP: Advanced D Programming Language Features#

si, è lui

Xstreme · February 11, 2010

si, è lui

come dicevo...un pò spartano.... ma bravo

se vuoi approfondire l'argomento sul D

reputo questo sito eccellente : (5 stelle)

Useless Software

Totocellux · February 11, 2010

come dicevo...un pò spartano.... ma bravo
[..........]

..... soltanto?!

Comunque, direi che dovresti metterti sotto a lavorare: c'è ancora quel 6.x% di efficienza da racimolare nei confronti dell'uomo dai 4TB di appoggio

Rammenta che lui ha solo il Visual C, mentre hai dalla tua parte il signor Assembly

Xstreme · February 19, 2010

PrimeCores Updates

PrimeCores 2010 V 4.0.0 32Bit Diagnostic Benchmark Beta 2 - Release Date : 02/2010

Developer : Cristoforo Bonissone

In V. 4.0.0 Beta2 math routines has been completely rewritten.

In V. 4.0.0 Beta2 the routines are optimized for 32-bit system. (64Bit incoming soon)

In V. 4.0.0 Beta2 now supports real 8 cores (no longer uses virtual cores) completely user-selectables

In V. 4.0.0 (Final Version) will be reactivates the Save and Publication functions

In V. 4.0.0 (Final Version) will add a screen capture function

In V. 4.0.0 (Final Version) will be reactivates the System Information function

Totocellux · February 19, 2010

molto più snello

Tutto OK

il solito [email protected]

gear667 · February 19, 2010

quoto Totocellux. Se non erro questo è solo un tool per la verifica dei vari core e non un bench vero e proprio, o sbaglio?

Xstreme · February 21, 2010

Ho cercato di inserire tutte le combinazioni possibili, se qualcuno intercetta qualche combinazione

non presente o non corretta, è pregato di segnalarmi in modo esatto la combinazione che manca o

che non funziona come dovuto, grazie

Sign In

Prime Cores V1.0 Freeware

Recommended Posts

Link to comment

Share on other sites

Top Posters In This Topic

Popular Days

Top Posters In This Topic

Popular Days

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Join the conversation