Xstreme

http://www.xstreme.it/Per_Toto.zip test per Toto : in che linguaggio sono ?

Una preview.... MEFISTO non ancora attivo (QUINDI SOLO NUMERI PRIMI) ma siamo già al 100 % notare la memoria IN USO per la gestione della miriade di primi.....

mi sono inventato MEFISTO MErsenne Factorial Iteraction STring Operations MFI per gli amici ... e sto lavorano sulle iterazioni MFI in blocchi di 16 milioni di interi a gradini di 32 - 64 - 128 - 256 etc etc, cioè per esempio con un iterazione di 32 MFI l'algo estrarrà (1031130 * 32) di numeri primi, sui primi scoperti eseguirò un ulteriore estrapolazione dei "Mersenne", infine sui Mersenne ne calcolo il fattoriale, il fattoriale servirà ad alimentare varie stringhe di testo, (cioè trasformo numeri in testo), con questi blocchi di stringhe che ci faccio ? beh visto che ci sono gli applico un algo di quicksort.....direi che potrebbe bastare, una volta fatto questo gli applico la verifica dei risultati con tabella statica preinserita nel codice in rigoroso DATA . per settimana prossima dovrei riuscire a rilasciare la versione gamma.

forse mi sono spiegato male io, anzi, è cosi.... su i primi 16 milioni di numeri interi ci sono 1031130 numeri primi quindi ha calcolato l'estrazione di 1031130 numeri primi da 16 milioni di numeri interi in 420 ms ok ?

in teoria ed anche in pratica, il risultato delle operazioni matematiche nude e crude è quello senza display, quando utilizzi il display dei numeri, ci si mette di mezzo anche il processore della scheda grafica (GPU), quindi, tutto quello che succede a livello grafico incide sulla potenza di calcolo effettiva della sola CPU, per concludere quando si finisce qualsiasi tipo di test o di benchmark, che fà uso di interfaccia grafica il risultato è SEMPRE la combinazione di velocità di CPU & GPU, a meno che quando si fanno i calcoli, non si utilizza l'uso di qualsiasi tipo di grafica, con un apposita opzione di scelta, l'inconveniente e che non sai a che punto è il processo di test o benchmark, calcolando che le ultime release di windows fanno pesante uso di grafica testuale e non, (il testo sempre grafica è) puoi ben intuire l'influenza dell GPU sul risultato finale del test.

no caro, quello che fà il tuo processore dopo i miei calcoli sono fatti suoi , io prendo i millisecondi dal timer di windows e li metto in una variabile dall'istante in cui inizia il primo calcolo, alla fine del risultato dell'ultimo calcolo, riprendo i millisecondi dal timer di windows, e faccio la sottrazione.

:AAAAH: 20 secondi ? :AAAAH: cosa hai ...un Vic 20 ? :asd:

scarica la seconda versione, e valuta di persona se li trova davvero tutti :perfido:

http://www.xstreme.it/pcfast2.zip aggiunto timer in millescondi è un pò di grafica postatemi gli screen , grazie

ora ci metto il timer e lo riposto sul mio server, in teroria i cores li sfutta, ma è talmenente ottimizzato il codice, che a momenti fà a meno della cpu

cosi a occhio in quanto tempo ti calcola 16 milioni di numeri primi ? sia con display attivo che senza display, grazie

URGENTE Ciao, ho messo a punto un ALGORITMO impressionante... :clapclap: provare per credere..... http://www.xstreme.it/pcfast.zip io stesso non ci credo..... però funziona....... se mi date l'ok ...implemento....

ah hai xp, pardon Msinfo32.exe

aspetta di vedere la versione gamma che è quasi finita............ ho aggiunto un quicksort non alfanumerico tridimensionale con matrice a 8x8x8 indici, i numeri primi scoperti vengono inseriti nelle caselline di un ipotetico cubo, 3 vettori casuali (x,y,z) richiamano coordinate random all'interno del cubo, una volta svuotate tutte le caselle del cubo la lista non ordinata dei numeri primi scoperti, viene "quicksortata", in ordine crescente, finito il quicksort ho fatto calcolare n fattoriale dell'intera lista, tutto questo non viene fatto alla fine dei conti...ma in REALTIME, cioè mentre ricerca i numeri primi, nei "tempi morti" fa sto lavoretto, noterai anche che dalla versione beta alla gamma la fame di memoria è un pò aumentata, propio per contenere le matrici tridimensionali.

non mettendo "systeminfo" prima di ">c: il.txt:" viene eseguito il redirect di un log del "nulla" ........ systeminfo >c: il.txt: copia e incolla

dalla console comandi digita esattamente cosi : systeminfo >c: il.txt: e poi mi dovresti postare il file "nil.txt" qui sul forum

mi dai uno screen di cpu z ? thanks

chiedi a TOTO, e lui, quello che si occupa di sicurezza.

ciao XSSI BETA 1 ho rimesso la rilevazione dei dischi che prima crashava, ma ho aggiunto un salto quando trova un errore, non dovrebbe più bloccarsi, lanciatelo, aspettate qualche secondo e dovrebbe aprirsi Notepad con la lista di tutto, a me mi funziona tutto, quindi se salta o non salta gli eventuali errori me lo dovete dire voi http://www.xstreme.it/xssi_beta.zip

MA TU INTENDEVI UNA COSETTA COSI DA NULLA ? /* * Serial Presence Detect (SPD) memory identification */ #include #include #include #include /* Encodings of the size used/total byte for certain memory types */ #define SPDMEM_SPDSIZE_MASK 0x0F /* SPD EEPROM Size */ #define SPDMEM_SPDLEN_128 0x00 /* SPD EEPROM Sizes */ #define SPDMEM_SPDLEN_176 0x10 #define SPDMEM_SPDLEN_256 0x20 #define SPDMEM_SPDLEN_MASK 0x70 /* Bits 4 - 6 */ #define SPDMEM_SPDCRC_116 0x80 /* CRC Bytes covered */ #define SPDMEM_SPDCRC_125 0x00 #define SPDMEM_SPDCRC_MASK 0x80 /* Bit 7 */ /* possible values for the memory type */ #define SPDMEM_MEMTYPE_FPM 0x01 #define SPDMEM_MEMTYPE_EDO 0x02 #define SPDMEM_MEMTYPE_PIPE_NIBBLE 0x03 #define SPDMEM_MEMTYPE_SDRAM 0x04 #define SPDMEM_MEMTYPE_ROM 0x05 #define SPDMEM_MEMTYPE_DDRSGRAM 0x06 #define SPDMEM_MEMTYPE_DDRSDRAM 0x07 #define SPDMEM_MEMTYPE_DDR2SDRAM 0x08 #define SPDMEM_MEMTYPE_FBDIMM 0x09 #define SPDMEM_MEMTYPE_FBDIMM_PROBE 0x0a #define SPDMEM_MEMTYPE_DDR3SDRAM 0x0b #define SPDMEM_MEMTYPE_NONE 0xff #define SPDMEM_MEMTYPE_DIRECT_RAMBUS 0x01 #define SPDMEM_MEMTYPE_RAMBUS 0x11 /* possible values for the supply voltage */ #define SPDMEM_VOLTAGE_TTL_5V 0x00 #define SPDMEM_VOLTAGE_TTL_LV 0x01 #define SPDMEM_VOLTAGE_HSTTL_1_5V 0x02 #define SPDMEM_VOLTAGE_SSTL_3_3V 0x03 #define SPDMEM_VOLTAGE_SSTL_2_5V 0x04 #define SPDMEM_VOLTAGE_SSTL_1_8V 0x05 /* possible values for module configuration */ #define SPDMEM_MODCONFIG_PARITY 0x01 #define SPDMEM_MODCONFIG_ECC 0x02 /* for DDR2, module configuration is a bit-mask field */ #define SPDMEM_MODCONFIG_HAS_DATA_PARITY 0x01 #define SPDMEM_MODCONFIG_HAS_DATA_ECC 0x02 #define SPDMEM_MODCONFIG_HAS_ADDR_CMD_PARITY 0x04 /* possible values for the refresh field */ #define SPDMEM_REFRESH_STD 0x00 #define SPDMEM_REFRESH_QUARTER 0x01 #define SPDMEM_REFRESH_HALF 0x02 #define SPDMEM_REFRESH_TWOX 0x03 #define SPDMEM_REFRESH_FOURX 0x04 #define SPDMEM_REFRESH_EIGHTX 0x05 #define SPDMEM_REFRESH_SELFREFRESH 0x80 /* superset types */ #define SPDMEM_SUPERSET_ESDRAM 0x01 #define SPDMEM_SUPERSET_DDR_ESDRAM 0x02 #define SPDMEM_SUPERSET_EDO_PEM 0x03 #define SPDMEM_SUPERSET_SDR_PEM 0x04 /* FPM and EDO DIMMS */ #define SPDMEM_FPM_ROWS 0x00 #define SPDMEM_FPM_COLS 0x01 #define SPDMEM_FPM_BANKS 0x02 #define SPDMEM_FPM_CONFIG 0x08 #define SPDMEM_FPM_REFRESH 0x09 #define SPDMEM_FPM_SUPERSET 0x0c /* PC66/PC100/PC133 SDRAM */ #define SPDMEM_SDR_ROWS 0x00 #define SPDMEM_SDR_COLS 0x01 #define SPDMEM_SDR_BANKS 0x02 #define SPDMEM_SDR_CYCLE 0x06 #define SPDMEM_SDR_BANKS_PER_CHIP 0x0e #define SPDMEM_SDR_MOD_ATTRIB 0x12 #define SPDMEM_SDR_SUPERSET 0x1d #define SPDMEM_SDR_FREQUENCY 126 #define SPDMEM_SDR_CAS 127 #define SPDMEM_SDR_FREQ_66 0x66 #define SPDMEM_SDR_FREQ_100 0x64 #define SPDMEM_SDR_FREQ_133 0x85 #define SPDMEM_SDR_CAS2 (1 sm_len ia_name, "spd") == 0) return (1); /* dumb, need sanity checks */ if (strcmp(ia->ia_name, "eeprom") != 0) return (0); sc.sc_tag = ia->ia_tag; sc.sc_addr = ia->ia_addr; type = spdmem_read(&sc, 2); /* For older memory types, validate the checksum over 1st 63 bytes */ if (type spd_len) return 0; crc_calc = spdmem_crc16(&sc, spd_crc_cover); crc_spd = spdmem_read(&sc, 127) sm_type]; if (s->sm_data[sPDMEM_SDR_SUPERSET] == SPDMEM_SUPERSET_SDR_PEM) type = spdmem_superset_types[sPDMEM_SUPERSET_SDR_PEM]; if (s->sm_data[sPDMEM_SDR_SUPERSET] == SPDMEM_SUPERSET_ESDRAM) type = spdmem_superset_types[sPDMEM_SUPERSET_ESDRAM]; num_banks = s->sm_data[sPDMEM_SDR_BANKS]; per_chip = s->sm_data[sPDMEM_SDR_BANKS_PER_CHIP]; rows = s->sm_data[sPDMEM_SDR_ROWS] & 0x0f; cols = s->sm_data[sPDMEM_SDR_COLS] & 0x0f; dimm_size = (1 0) { if (dimm_size sm_data[sPDMEM_DDR_MOD_ATTRIB] & SPDMEM_DDR_ATTRIB_REG) printf(" registered"); if (s->sm_data[sPDMEM_FPM_CONFIG] sm_data[sPDMEM_FPM_CONFIG]]); p_clk = 66; if (s->sm_len >= 128) { switch (spdmem_read(sc, SPDMEM_SDR_FREQUENCY)) { case SPDMEM_SDR_FREQ_100: case SPDMEM_SDR_FREQ_133: /* We need to check ns to decide here */ if (s->sm_data[sPDMEM_SDR_CYCLE] sm_len sm_data[sPDMEM_RDR_ROWS_COLS] >> 4; col_bits = s->sm_data[sPDMEM_RDR_ROWS_COLS] & 0x0f; bank_bits = s->sm_data[sPDMEM_RDR_BANK] & 0x07; /* subtracting 13 here is a cheaper way of dividing by 8k later */ rimm_size = 1 sm_data[sPDMEM_RDR_MODULE_TYPE]) { case SPDMEM_RDR_TYPE_RIMM: printf("RIMM"); break; case SPDMEM_RDR_TYPE_SORIMM: printf("SO-RIMM"); break; case SPDMEM_RDR_TYPE_EMBED: printf("Embedded Rambus"); break; case SPDMEM_RDR_TYPE_RIMM32: printf("RIMM32"); break; } } void spdmem_ddr_decode(struct spdmem_softc *sc, struct spdmem *s) { const char *type; int dimm_size, cycle_time, d_clk, p_clk, bits; int i, num_banks, per_chip; uint8_t config, rows, cols, cl; type = spdmem_basic_types[s->sm_type]; if (s->sm_data[sPDMEM_DDR_SUPERSET] == SPDMEM_SUPERSET_DDR_ESDRAM) type = spdmem_superset_types[sPDMEM_SUPERSET_DDR_ESDRAM]; num_banks = s->sm_data[sPDMEM_SDR_BANKS]; per_chip = s->sm_data[sPDMEM_SDR_BANKS_PER_CHIP]; rows = s->sm_data[sPDMEM_SDR_ROWS] & 0x0f; cols = s->sm_data[sPDMEM_SDR_COLS] & 0x0f; dimm_size = (1 0) { if (dimm_size sm_data[sPDMEM_DDR_MOD_ATTRIB] & SPDMEM_DDR_ATTRIB_REG) printf(" registered"); if (s->sm_data[sPDMEM_FPM_CONFIG] sm_data[sPDMEM_FPM_CONFIG]]); /* cycle_time is expressed in units of 0.01 ns */ cycle_time = (s->sm_data[sPDMEM_DDR_CYCLE] >> 4) * 100 + (s->sm_data[sPDMEM_DDR_CYCLE] & 0x0f) * 10; if (cycle_time != 0) { /* * cycle time is scaled by a factor of 100 to avoid using * floating point. Calculate memory speed as the number * of cycles per microsecond. * DDR uses dual-pumped clock */ d_clk = 100 * 1000 * 2; config = s->sm_data[sPDMEM_FPM_CONFIG]; bits = s->sm_data[sPDMEM_DDR_DATAWIDTH] | (s->sm_data[sPDMEM_DDR_DATAWIDTH + 1] = 50) p_clk += 50; p_clk -= p_clk % 100; printf(" PC%d", p_clk); } /* Print CAS latency */ for (i = 6; i >= 0; i--) { if (s->sm_data[sPDMEM_DDR_CAS] & (1 sm_type]; num_ranks = (s->sm_data[sPDMEM_DDR2_RANKS] & 0x7) + 1; density = (s->sm_data[sPDMEM_DDR2_RANK_DENSITY] & 0xf0) | ((s->sm_data[sPDMEM_DDR2_RANK_DENSITY] & 0x0f) 0) { if (dimm_size sm_data[sPDMEM_DDR2_DIMMTYPE] & SPDMEM_DDR2_TYPE_REGMASK) printf(" registered"); if (s->sm_data[sPDMEM_FPM_CONFIG] sm_data[sPDMEM_FPM_CONFIG]]); /* cycle_time is expressed in units of 0.01 ns */ cycle_time = (s->sm_data[sPDMEM_DDR2_CYCLE] >> 4) * 100 + ddr2_cycle_tenths[(s->sm_data[sPDMEM_DDR2_CYCLE] & 0x0f)]; if (cycle_time != 0) { /* * cycle time is scaled by a factor of 100 to avoid using * floating point. Calculate memory speed as the number * of cycles per microsecond. * DDR2 uses quad-pumped clock */ d_clk = 100 * 1000 * 4; config = s->sm_data[sPDMEM_FPM_CONFIG]; bits = s->sm_data[sPDMEM_DDR2_DATAWIDTH]; if ((config & 0x03) != 0) bits -= 8; d_clk /= cycle_time; d_clk = (d_clk + 1) / 2; p_clk = d_clk * bits / 8; p_clk -= p_clk % 100; printf(" PC2-%d", p_clk); } /* Print CAS latency */ for (i = 5; i >= 2; i--) { if (s->sm_data[sPDMEM_DDR_CAS] & (i sm_data[sPDMEM_DDR2_DIMMTYPE]) { case SPDMEM_DDR2_SODIMM: printf(" SO-DIMM"); break; case SPDMEM_DDR2_MICRO_DIMM: printf(" Micro-DIMM"); break; case SPDMEM_DDR2_MINI_RDIMM: case SPDMEM_DDR2_MINI_UDIMM: printf(" Mini-DIMM"); break; } } void spdmem_fbdimm_decode(struct spdmem_softc *sc, struct spdmem *s) { int dimm_size, num_banks, cycle_time, d_clk, p_clk, bits; uint8_t rows, cols, banks, dividend, divisor; /* * FB-DIMM is very much like DDR3 */ banks = s->sm_data[sPDMEM_FBDIMM_ADDR] & SPDMEM_FBDIMM_ADDR_BANKS; cols = (s->sm_data[sPDMEM_FBDIMM_ADDR] & SPDMEM_FBDIMM_ADDR_COL) >> SPDMEM_FBDIMM_ADDR_COL_SHIFT; rows = (s->sm_data[sPDMEM_FBDIMM_ADDR] & SPDMEM_FBDIMM_ADDR_ROW) >> SPDMEM_FBDIMM_ADDR_ROW_SHIFT; dimm_size = rows + 12 + cols + 9 - 20 - 3; num_banks = 1 sm_data[sPDMEM_FBDIMM_MTB_DIVIDEND]; divisor = s->sm_data[sPDMEM_FBDIMM_MTB_DIVISOR]; cycle_time = (1000 * dividend + (divisor / 2)) / divisor; if (cycle_time != 0) { /* * cycle time is scaled by a factor of 1000 to avoid using * floating point. Calculate memory speed as the number * of cycles per microsecond. */ d_clk = 1000 * 1000; /* DDR2 FB-DIMM uses a dual-pumped clock */ d_clk *= 2; bits = 1 sm_data[sPDMEM_FBDIMM_RANKS] & SPDMEM_FBDIMM_RANKS_WIDTH) + 2); p_clk = (d_clk * bits) / 8 / cycle_time; d_clk = ((d_clk + cycle_time / 2) ) / cycle_time; p_clk -= p_clk % 100; printf(" PC2-%d", p_clk); } } void spdmem_ddr3_decode(struct spdmem_softc *sc, struct spdmem *s) { const char *type; int dimm_size, cycle_time, d_clk, p_clk, bits; uint8_t mtype, chipsize, dividend, divisor; uint8_t datawidth, chipwidth, physbanks; type = spdmem_basic_types[s->sm_type]; chipsize = s->sm_data[sPDMEM_DDR3_DENSITY] & SPDMEM_DDR3_DENSITY_CAPMASK; datawidth = s->sm_data[sPDMEM_DDR3_DATAWIDTH] & SPDMEM_DDR3_DATAWIDTH_PRIMASK; chipwidth = s->sm_data[sPDMEM_DDR3_MOD_ORG] & SPDMEM_DDR3_MOD_ORG_CHIPWIDTH_MASK; physbanks = (s->sm_data[sPDMEM_DDR3_MOD_ORG] >> SPDMEM_DDR3_MOD_ORG_BANKS_SHIFT) & SPDMEM_DDR3_MOD_ORG_BANKS_MASK; dimm_size = (chipsize + 28 - 20) - 3 + (datawidth + 3) - (chipwidth + 2); dimm_size = (1 sm_data[sPDMEM_DDR3_MODTYPE]; if (mtype == SPDMEM_DDR3_RDIMM || mtype == SPDMEM_DDR3_MINI_RDIMM) printf(" registered"); if (s->sm_data[sPDMEM_DDR3_DATAWIDTH] & SPDMEM_DDR3_DATAWIDTH_ECCMASK) printf(" ECC"); dividend = s->sm_data[sPDMEM_DDR3_MTB_DIVIDEND]; divisor = s->sm_data[sPDMEM_DDR3_MTB_DIVISOR]; cycle_time = (1000 * dividend + (divisor / 2)) / divisor; cycle_time *= s->sm_data[sPDMEM_DDR3_TCKMIN]; if (cycle_time != 0) { /* * cycle time is scaled by a factor of 1000 to avoid using * floating point. Calculate memory speed as the number * of cycles per microsecond. * DDR3 uses a dual-pumped clock */ d_clk = 1000 * 1000; d_clk *= 2; bits = 1 sm_data[sPDMEM_DDR3_DATAWIDTH] & SPDMEM_DDR3_DATAWIDTH_PRIMASK) + 3); /* * Calculate p_clk first, since for DDR3 we need maximum * significance. DDR3 rating is not rounded to a multiple * of 100. This results in cycle_time of 1.5ns displayed * as p_clk PC3-10666 (d_clk DDR3-1333) */ p_clk = (d_clk * bits) / 8 / cycle_time; p_clk -= (p_clk % 100); d_clk = ((d_clk + cycle_time / 2) ) / cycle_time; printf(" PC3-%d", p_clk); } switch (s->sm_data[sPDMEM_DDR3_MODTYPE]) { case SPDMEM_DDR3_SODIMM: printf(" SO-DIMM"); break; case SPDMEM_DDR3_MICRO_DIMM: printf(" Micro-DIMM"); break; case SPDMEM_DDR3_MINI_RDIMM: case SPDMEM_DDR3_MINI_UDIMM: printf(" Mini-DIMM"); break; } if (s->sm_data[sPDMEM_DDR3_THERMAL] & SPDMEM_DDR3_THERMAL_PRESENT) printf(" with thermal sensor"); } void spdmem_attach(struct device *parent, struct device *self, void *aux) { struct spdmem_softc *sc = (struct spdmem_softc *)self; struct i2c_attach_args *ia = aux; struct spdmem *s = &(sc->sc_spd_data); int i; sc->sc_tag = ia->ia_tag; sc->sc_addr = ia->ia_addr; printf(":"); /* All SPD have at least 64 bytes of data including checksum */ for (i = 0; i sm_len sm_type == SPDMEM_MEMTYPE_DIRECT_RAMBUS) spdmem_rdr_decode(sc, s); else printf(" no decode method for Rambus memory"); } else { switch(s->sm_type) { case SPDMEM_MEMTYPE_EDO: case SPDMEM_MEMTYPE_SDRAM: spdmem_sdram_decode(sc, s); break; case SPDMEM_MEMTYPE_DDRSDRAM: spdmem_ddr_decode(sc, s); break; case SPDMEM_MEMTYPE_DDR2SDRAM: spdmem_ddr2_decode(sc, s); break; case SPDMEM_MEMTYPE_FBDIMM: case SPDMEM_MEMTYPE_FBDIMM_PROBE: spdmem_fbdimm_decode(sc, s); break; case SPDMEM_MEMTYPE_DDR3SDRAM: spdmem_ddr3_decode(sc, s); break; case SPDMEM_MEMTYPE_NONE: printf(" no EEPROM found"); break; default: if (s->sm_type sm_type]); else printf(" unknown memory type %d", s->sm_type); break; } } printf(" "); } uint8_t spdmem_read(struct spdmem_softc *sc, uint8_t reg) { uint8_t val = 0xff; iic_acquire_bus(sc->sc_tag,0); iic_exec(sc->sc_tag, I2C_OP_READ_WITH_STOP, sc->sc_addr, &reg, sizeof reg, &val, sizeof val, 0); iic_release_bus(sc->sc_tag, 0); return val; }

ok ti ringrazio

si

lo scaling ,quello si puo fare facendo dei calcoli adatti, per i timings delle ram mi devo inventare qualcosa in assembler per leggere gli SPD dei moduli, è già da un pò che ci penso

beh, male non farebbe