Newsgroup: it.lavoro.informatica
Titolo: java vs c++ - java revision

Il Dottore mi ha suggerito di usare un array builtin nella class Matrix2 
java
Poiche  a chi fa suggerimenti costruttivi non mi tiro certo indietro 
ecco la nuova classe Matrix2
 
package enoquick;
 
public class Matrix2<T>  {
	public Matrix2(int rows,int cols,T init) {
		m_rows=rows;
		m_cols=cols;
		m_vector=new Object[size()];
		for (int i=0;i < size();++i)
			m_vector[i]=init;
	}
	public int rows() { return m_rows;}
	public int cols() { return m_cols;}
	public void scalar(int row,int col,T v) {
		assert row < rows();
		assert col < cols();
		m_vector[index(row,col)]=v;
	}
	public T scalar(int row,int col) {
		assert row < rows();
		assert col < cols();
		return (T) m_vector[index(row,col)];
	}
	public int size() { return m_rows * m_cols;}
	private int index(int r,int c) { return r*m_cols + c;}
	private int m_rows;
	private int m_cols;
	private Object[] m_vector;
}
 
 
Notare che m_vector (che nell'altra versione era una ArrayList ) ora e' 
diventato un Object[]
Purtroppo per limitazioni del linguaggio java non e' possibile un new 
T[<size>]
Posto solo i tempi con 10 rows:
 
java rows:10 threads: 0 sum: 100000000 time: 90ms
c++  rows:10 threads: 0 sum: 100000000 time: 64ms
java rows:10 threads: 1 sum: 100000000 time: 90ms
c++  rows:10 threads: 1 sum: 100000000 time: 54ms
java rows:10 threads: 2 sum: 100000000 time: 61ms
c++  rows:10 threads: 2 sum: 100000000 time: 42ms
java rows:10 threads: 3 sum: 100000000 time: 59ms
c++  rows:10 threads: 3 sum: 100000000 time: 42ms
java rows:10 threads: 4 sum: 100000000 time: 53ms
c++  rows:10 threads: 4 sum: 100000000 time: 41ms
java rows:10 threads: 5 sum: 100000000 time: 48ms
c++  rows:10 threads: 5 sum: 100000000 time: 41ms
java rows:10 threads: 6 sum: 100000000 time: 48ms
c++  rows:10 threads: 6 sum: 100000000 time: 41ms
java rows:10 threads: 7 sum: 100000000 time: 49ms
c++  rows:10 threads: 7 sum: 100000000 time: 41ms
java rows:10 threads: 8 sum: 100000000 time: 48ms
c++  rows:10 threads: 8 sum: 100000000 time: 41ms
java rows:10 threads: 9 sum: 100000000 time: 46ms
c++  rows:10 threads: 9 sum: 100000000 time: 41ms
java rows:10 threads: 10 sum: 100000000 time: 51ms
c++  rows:10 threads: 10 sum: 100000000 time: 41ms
java rows:10 threads: 11 sum: 100000000 time: 59ms
c++  rows:10 threads: 11 sum: 100000000 time: 41ms
java rows:10 threads: 12 sum: 100000000 time: 53ms
c++  rows:10 threads: 12 sum: 100000000 time: 41ms
java rows:10 threads: 13 sum: 100000000 time: 50ms
c++  rows:10 threads: 13 sum: 100000000 time: 41ms
 
Questi i tempi con il vecchio metodo (non rieseguito ma ho solo ripreso 
il log)
java rows:10 threads: 0 sum: 100000000 time: 90ms
c++  rows:10 threads: 0 sum: 100000000 time: 60ms
java rows:10 threads: 1 sum: 100000000 time: 106ms
c++  rows:10 threads: 1 sum: 100000000 time: 53ms
java rows:10 threads: 2 sum: 100000000 time: 78ms
c++  rows:10 threads: 2 sum: 100000000 time: 43ms
java rows:10 threads: 3 sum: 100000000 time: 76ms
c++  rows:10 threads: 3 sum: 100000000 time: 42ms
java rows:10 threads: 4 sum: 100000000 time: 76ms
c++  rows:10 threads: 4 sum: 100000000 time: 41ms
java rows:10 threads: 5 sum: 100000000 time: 66ms
c++  rows:10 threads: 5 sum: 100000000 time: 42ms
java rows:10 threads: 6 sum: 100000000 time: 67ms
c++  rows:10 threads: 6 sum: 100000000 time: 41ms
java rows:10 threads: 7 sum: 100000000 time: 66ms
c++  rows:10 threads: 7 sum: 100000000 time: 41ms
java rows:10 threads: 8 sum: 100000000 time: 67ms
c++  rows:10 threads: 8 sum: 100000000 time: 41ms
java rows:10 threads: 9 sum: 100000000 time: 71ms
c++  rows:10 threads: 9 sum: 100000000 time: 44ms
java rows:10 threads: 10 sum: 100000000 time: 48ms
c++  rows:10 threads: 10 sum: 100000000 time: 42ms
java rows:10 threads: 11 sum: 100000000 time: 65ms
c++  rows:10 threads: 11 sum: 100000000 time: 41ms
java rows:10 threads: 12 sum: 100000000 time: 69ms
c++  rows:10 threads: 12 sum: 100000000 time: 41ms
java rows:10 threads: 13 sum: 100000000 time: 60ms
c++  rows:10 threads: 13 sum: 100000000 time: 41ms

 T[<size>]
 
Evidentemente di quello che ti ho detto, hai capito solo cio' che ti fa 
comodo ovvero alla tua portata.
Ripeto, qualsiasi strumento, un linguaggio non differisce, va usato 
dalla parte del manico.

STUDIA CAPRA
https://docs.oracle.com/javase/tutorial/index.html
 

 
 
non me ne frega una cippa  di java  basta che non infici i benchmark
 

Il 11/05/19 20:29, Dr.UgoGagliardelli ha scritto:

Questo e' quello che ho capito, cosa non avrei capito ?
 


scusa, ma come fai a scrivere un benchmark, se non conosci il linguaggio 
a fondo e "non te ne frega una cippa"?
Che valore puo' avere il tuo benchmark, con queste premesse?

Il 12/05/19 08:30, io ha scritto:

basta che non infici il benchmark
E se ci fossero dei colli di bottiglia nel codice basta farlo notare
Ma non credo proprio che se scrivessi un programmino perfettamente OO il 
risultato del benchmark cambiarebbe
 
 


Cosa te lo dico a fare, se non te ne frega niente?
Da maestro, quale dici di essere, dovresti informarti autonomamente, un 
semplice avviso dovrebbe essere sufficiente per sollecitare la tua 
attenzione.

 con queste premesse? 
 
Come tutto quello che dice e fa: il valore di STOCAZZO.

C.V.D. CAPRA cit.


il risultato e' inficiato in partenza dal fatto che non conosci il 
linguaggio. A che servirebbe farti notare "colli di bottiglia", se non 


Il 12/05/19 08:47, Dr.UgoGagliardelli ha scritto:

Lo avevo gia spiegato, non mi interessa fare un benchmark con java 
perfettamente OO se non inficia sulle prestazioni
 

Il 12/05/19 09:26, io ha scritto:

Forse non hai capito bene
 

Ma dai sarà l'ennesimo che non comprende il maestro esperto e STUCAZZ. STRUNZ!

come del resto a noi non interessa delle TUE STRUNZAT e benchmark COGLIONE

 
 
sei il boss del ng che parla a nome di tutti ?
 

hai rotto er cazzo A COJONE A COJONEEE A C O J O N E E E E

 
Rimane il fatto che non hai la piu' pallida idea dell'impatto sulle 
prestazioni, conseguentemente il tuo benchmark misura l'ignoranza del 
programmatore. Se questo era il tuo scopo, hai centrato l'obiettivo.

Ancora??? Ancora con queste stronzate???BASTA!! COGLIONEEEE!! 

Il 13/05/19 00:40, Dr.UgoGagliardelli ha scritto:

L'idea c'e l'ho eccome,e non inficia sulle prestazioni
 
 

 
 
 
 
java omp e' superiore a c++ (omp ? no tls)
Queste stronzate di voler paragonare due metodi diversi (omp e tls) non 
e' mia ma  tua,presa da un manoscritto che non vale una cippa per quanto 
riguarda i confronti visto che si tratta di due modi diversi di gestire 
i threads
Ora hai visto la superiorita del tuo java caro pirlotto che l'hai menata 
tanto sulla superiorita.
 
 


L'idea che ci siamo fatti è che tu proceda un po' per tentativi, senza cognizione di causa. 
 
Anche in C++, ad esempio scrivi:
    #pragma omp parallel shared(sum)        
                    {
    #pragma omp for
                            for (auto r=size_type(); r < m.rows();++r) {
                                    auto s=calc(r,m);
    #pragma omp atomic update
                                    sum += s;
                            }                                
                    }
 
Quando potresti scrivere banalmente:
    #pragma omp parallel for reduction(+:sum)
        for (auto r=size_type(); r < m.rows(); ++r) 
            sum += calc(r,m);
 
Capisci bene che, con tutta questa inutile verbosità, i dubbi che tu faccia il programmatore C++ di professione siano forti.

 
 
La sua verbosità è dedicata ai pivelli come me. :o)
 
-- 
The three most dangerous things in the world are a programmer with a 
soldering iron, a hardware type with a program patch and a user with an 
idea.

 
Non mi sembra che le prestazioni siano migliorate,anzi
Capisco solo  che ti vuoi accodare alla schiera dei faziosi e di chi 
critica senza sapere una mazza,fai pure, non e' un mio problema
 
 

 critica senza sapere una mazza,fai pure, non e' un mio problema
 
Più che altro il problema è dei tuoi sottoposti o di chi ti sostituirà: se gli lasci codice scritto in quel modo, si sparano in testa

Il 13/05/19 09:50, Giuspi ha scritto:

Esiste il motivo per cui ho fatto quella scelta e non e' perche non 
conoscevo il metodo proposto da te ma solo per essere uguale a jomp che 
essendo limitato si fa quel che si puo
 


Come fai a dire delle cose del genere? Brancoli e non hai idea di come 
le prestazioni potrebbero essere in mano ad un esperto di entrambi i 
linguaggi.
 

Il 13/05/19 12:55, Dr.UgoGagliardelli ha scritto:

abbastanza semplice
la funzione calc() e' la funziona che calcola la somma di una riga
che metta il codice di contorno in una altra classe non e' che cambia 
qualcosa
 

RRRROTFLLL...

 Non mi sembra che le prestazioni siano migliorate,anzi 
 
A COJONEEEQUICK SEI TROOOPPO QUICK
CURATELA ST'EJACULATIO PRECOX 
A COJONEEEE