può un innocuo javascript surriscaldare la CPU?

**alfburt** · 07-01-2008, 23:53

Grazie, siccome stavo già lavorando per accogliere, sperando di averli ben compresi, i vostri suggerimenti, ho pensato di semplificare il tutto togliendo il new e anche la funzione, e creando il div anzichè l'img.
Ora è tutto molto più compatto e spero anche più chiaro, funziona bene però surriscalda la cpu sempre allo stesso modo.

codice:

<html>
<head>
</head>
<body id='box0'>
<script language="JavaScript" type="text/javascript">
<!--
var deltatop = deltaleft = 0;  
var vel_vert = -3; // Velocità verticale iniziale
var vel_hor = 3;   // Velocità orizzontale iniziale
document.write('<div id = "orbitante" style="width: 8px; background: #777; height: 8px; top: 200px; left: 300px; position: absolute"><div></div></div>');
document.write('<div id = "nucleo" style="width: 20px; background: #000; height: 20px; top: 290px; left: 490px; position: absolute"></div>');
traccia = document.getElementById('orbitante')
nucleo_x = 500;
nucleo_y = 300;
dist_base = 7000;
coeff = 100;
movimento();

function movimento()
{ 
  var lt = parseInt(orbitante.style.left);
  var ot = parseInt(orbitante.style.top);
  var d2 = Math.max((nucleo_y - ot)*(nucleo_y-ot)+(nucleo_x-lt)*(nucleo_x-lt),dist_base)
    vel_vert += coeff*(nucleo_y - ot)/d2;
    deltatop += vel_vert;
    nuovtop   = ot + Math.floor(deltatop);    
    orbitante.style.top = nuovtop;
    deltatop = deltatop - Math.floor(deltatop); 
    vel_hor   += coeff*(nucleo_x-lt)/d2;
    deltaleft +=  vel_hor;    
    nuovleft   = lt + Math.floor(deltaleft);
    orbitante.style.left = nuovleft ;
    deltaleft = deltaleft - Math.floor(deltaleft);
//    traccia = document.getElementById('box0').appendChild(document.createElement('div'));
    traccia.style.position = 'absolute';
    traccia.style.width = '8px';
    traccia.style.height = '8px';
    traccia.style.background = '#777'
    traccia.style.left = nuovleft;
    traccia.style.top = nuovtop;
    setTimeout('movimento()',10);
}
//-->
</script>
</body>
</html>

**deleted_110** · 07-01-2008, 23:59

probabilmente qualcosina potrebbe fare mettendo questo

codice:

document.getElementById('box0')

fuori dalla funzione, tipo:

codice:

var contenitore = document.getElementById('box0')

In questo modo non deve ricercarselo ogni volta. Mi pare sia una buona regola generale ma non sara' questo a far rallentare le ventole...

**fcaldera** · 08-01-2008, 00:04

e se invece di un appendChild tu facessi un innerHTML?
Lo stile lo puoi dare direttamente tramite css e se l'elemento contenitore è sempre lo stesso l'osservazione di raven è corretta

**deleted_110** · 08-01-2008, 00:14

peggio ancora... il browser dovrebbe comunque scorrere il DOM per creare l'elemento contenuto in innerHTML. Facendo inoltre lui lo sforzo di interpretare l'HTML e di creare gli oggetti al volo.

Inoltre dovremmo fare l'append dell'innerHTML costringendo js a recuperare una stringa di migliaia di caratteri.

**fcaldera** · 08-01-2008, 00:27

direi che bisogna provare
http://notesweb2.blogspot.com/2007/0...pendchild.html

interessanti anche i commenti corredati al post

Edit: http://www.quirksmode.org/dom/innerhtml.html è un buon riferimento

**alfburt** · 08-01-2008, 01:34

Sì, la chiamata document.getElementById('box0') dovrebbe stare fuori dalla funzione che cicla, non è questo il punto ma effettivamente sarebbe meglio.
Per quanto riguarda innerhtml al posto di appendchild farò qualche prova domani. Dubito però che possa cambiare significativamente qualcosa, perchè ho l'impressione che il sistema entri comunque in crisi in presenza di un numero molto elevato di nodi.
In realtà quello che mi stupisce non è il fatto che il sistema entri in crisi. Mi sembra ovvio che un programma che crea nuovi nodi ad libitum a un certo punto produca una sorta di crisi, in un modo o nell'altro, dato che le risorse non sono infinite.
Quello che trovo inspiegabile e direi anche grave è il fatto che la crisi ricada sulla CPU in un modo così drammatico e prematuro dopo poche migliaia di nodi quando c'è ancora mezzo giga di ram inutilizzata e neanche un byte swappato.
Cosa diavolo sarà impegnata a fare la cpu, da un certo punto in avanti, anzichè allocare semplicemente i nuovi nodi nell'oceano di ram ancora disponibile?
Sicuramente niente di utile, e neppure di ragionevole.
Penserei a un bug di internet explorer, se non fosse che la stessa cosa succede paripari anche su firefox, e (provato adesso colto da un dubbio) su opera.
Mah, mi spiace perchè se le cose stanno così tutta una serie di cose carine che pensavo si potessero fare, a quanto pare non si possono fare.

**pietro09** · 08-01-2008, 12:03

Ho voluto provare perchè lo scritto è molto bello. Per evitare di creare un numero abnorme di nodi div non ho trovato di meglio che fare questo

var n = document.getElementById('box0').getElementsByTagNa me("div").length;
var m = 1000;
//debugger;
if(n > (3+m))
{
document.getElementById('box0').removeChild(docume nt.getElementById('box0').getElementsByTagName("di v")[n-m-1]);
}
else setTimeout('movimento()',10);

In altri termini, blocco il codice quando ho creato m elementi. Dopo non avrebbe più senso perchè vedrei solo un cerchio grigio (e la cpu al 100%)

ps. naturalmente else l'ho messo dopo. L'idea originale era di cancellare i div oltre gli m, ma l'effetto era abbastanza brutto.

:master: e poi un'idea che non ho provato

se mi costruissi una griglia composta da tanti div bianchi, per simulare il movimento non si potrebbero scurire i div di coordinate x, y al tempo t? :master:

**alfburt** · 08-01-2008, 13:12

Ringrazio davvero tutti per l'attenzione.
A dire il vero il punto che mi interessa non è tanto come far girare questo specifico programmino quanto chiarire bene la questione del limite di nodi tollerabile senza rischi di surriscaldamento, su cui a questo punto voglio avere le idee chiarissime, prima di rischiare di mettere in rete una qualsiasi pagina capace di surriscaldare silenziosamente, direi perfino subdolamente, l'hardware del malcapitato navigatore.
Comunque, nel caso specifico, più che bloccare tutto al raggiungimento di un certo numero di nodi, cercherei un modo di rimuovere le tracce di quelli più vecchi o comunque sostituirli con i nuovi e andare avanti lo stesso, anche perchè è vero che con questi parametri si forma ben presto un cerchio grigio, ma basta modificarli leggermente per avere altri effetti abbastanza gradevoli (potenza della legge di gravitazione universale).
Ho provato anche con innerHTML, che mi ha dato una certa soddisfazione perchè mi ha permesso di compattare il codice a un livello che credo ormai massimo.
Però così va peggio di prima, arranca molto più faticosamente, è più lento e surriscalda subito. A meno che non abbia capito male io come si dovrebbe usare innerHTML in questo caso e ci sia un modo migliore.

codice:

<html>
<head>
<style type="text/css">
<!--
.punto 
{
position: absolute;
width: '8px';
height: '8px';
background: '#777'
}
-->
</style>
</head>
<body id='box0'>
<script language="JavaScript" type="text/javascript">
<!--
var deltatop = deltaleft = 0; nuovleft=300; nuovtop=200; vel_vert = -3; vel_hor = 3;
var nucleo_x = 500; nucleo_y = 300; dist_base = 7000; coeff = 100;
var contenitore = document.getElementById('box0');
document.write('<div id = "nucleo" class="punto" style="top: 296px; left: 496px"><div></div></div>');
movimento();

function movimento()
{ 
    var lt = nuovleft; ot = nuovtop;
    var d2 = Math.max((nucleo_y - ot)*(nucleo_y-ot)+(nucleo_x-lt)*(nucleo_x-lt),dist_base)
    vel_vert += coeff*(nucleo_y - ot)/d2;
    deltatop += vel_vert;
    nuovtop   = ot + Math.floor(deltatop);    
    deltatop = deltatop - Math.floor(deltatop); 
    vel_hor   += coeff*(nucleo_x-lt)/d2;
    deltaleft +=  vel_hor;    
    nuovleft   = lt + Math.floor(deltaleft);
    deltaleft = deltaleft - Math.floor(deltaleft);
    contenitore.innerHTML += '<div class = "punto" style = "left: '+nuovleft + 'px; top: '+ nuovtop +'px"></div>'
    setTimeout('movimento()',10);
}
//-->
</script>
</body>
</html>

**deleted_110** · 08-01-2008, 15:14

Originariamente inviato da alfburt
A dire il vero il punto che mi interessa non è tanto come far girare questo specifico programmino quanto chiarire bene la questione del limite di nodi tollerabile senza rischi di surriscaldamento, su cui a questo punto voglio avere le idee chiarissime, prima di rischiare di mettere in rete una qualsiasi pagina capace di surriscaldare silenziosamente, direi perfino subdolamente, l'hardware del malcapitato navigatore.

ripeto che nessun algoritmo sui moderni PC puo' arrivare a fare danni sul processore solamente scaldandolo. Guardiamola da un altro punto di vista: i processori di una volta lavoravano sempre a massimo regime dissipando sempre la massima potenza. Ora esiste la gestione dinamica della frequenza che permette di far riposare il processore se non e' richiesto troppa elaborazione.

In caso di bisogno la frequenza aumenta e il processore si scalda ma nei limiti delle specifiche di progettazione (sempre che la ventilazione del PC sia adeguata). Al limite il PC si spegne da solo ma e' eventualita' rara (il mio mediocre portatile e' rimasto per ore acceso nella sua custodia in automobile d'estate... e ancora va)

Ho provato anche con innerHTML, che mi ha dato una certa soddisfazione perchè mi ha permesso di compattare il codice a un livello che credo ormai massimo.
Però così va peggio di prima, arranca molto più faticosamente, è più lento e surriscalda subito. A meno che non abbia capito male io come si dovrebbe usare innerHTML in questo caso e ci sia un modo migliore.

No, mi pare che l'unico modo sia quello. Come dicevo sopra fare l'append di una stringa cosi' lunga, e poi dovere praticamente svuotare il DOM e ricrearlo da capo ad ogni iterazione peggiora le cose.

Un'ultima considerazione: ogni linguaggio ha il suo campo di applicazioni. Javascript non e' nato per questo dipo di cose, anche se volendo si riesce a farle. Non bisogna stupirci se va in crisi quando gli si chiede troppo. E' pensato per gestire eventi generati da utente, che al massimo fa click una volta ogni tanto e puo' anche aspettare 100 millisecondi che il browser metta l'elemento al suo posto.

Ciao

**alfburt** · 08-01-2008, 22:24

Appunto: sempre che la ventilazione del PC sia adeguata.
Vorrei avere la stessa fiducia nell'adeguatezza della ventilazione dei moderni PC.
Nel mio caso poi non parlerei di specifiche di progettazione perchè il pc che uso me lo sono assemblato da solo mettendo insieme i componenti più economici di ogni funzione, la pasta termoconduttiva sulla cpu (sempron 3800) l'ho spalmata io con le mie manine e mi sono anche montato la ventolina e tutto il resto. Eppure, o forse proprio per questo, quando la cpu surriscalda mi preoccupo assai.
Ma l'ammetto è più che altro questione di atteggiamento mentale, forse un filino paranoide.
Mi preme invece di più dire qualcosa sulla natura dei diversi linguaggi.
E' vero che ci sono altri linguaggi più adatti per queste cose, proprio per questo ho scritto un certo numero di programmi in c con librerie openGl e api windows, che una volta compilati, forniscono eseguibili perfettamente funzionanti; il problema è che non girano nel browser.
Ora vorrei renderli visibili sul mio sito, ma senza che sia necessario scaricare un eseguibile, cosa che in genere la gente è molto restia a fare, mentre tutti caricano fiduciosamente qualsiasi pagina web.
Dato che anche il javascript, come tutti i linguaggi di alto livello, è figlio o figliastro del c, ho pensato che non dovrebbe essere difficile trasferire la logica dei programmi dal c al javascript, e in effetti mi trovavo finora abbastanza bene.
Trovo il javascript formidabile sotto tutti gli aspetti e mi sono convinto che non esista programma in c che non possa essere riscritto in javascript, ma a quanto pare si presentano problemi di allocazione insuperabili (a mio parere anche inspiegabili, ingiustificabili inqualificabili addebitabili solo a cattiva progettazione dei browser).
Allora vorrei fare questa semplice domanda a chi ne sa più di me: non c'è un altro sistema per fare quello che voglio fare? (come diceva totò: per andare dove dobbiamo andare, per dove dobbiamo andare?).
Per esempio, se voglio mettere a disposizione in rete un programma mio (già scritto in c, ma facilmente riscrivibile in qualsiasi altro linguaggio) che in base a certi parametri forniti dall'utente traccia una curva connessa frattale non derivabile (curva di Koch generalizzata), ho certamente bisogno di visualizzare qualche migliaio di elementi nelle posizioni video opportunamente calcolate volta per volta.
Dato che a quanto pare in javascript non lo posso fare perchè non è lo strumento adatto, qualcuno ha idea se esiste un altro strumento più adatto per ottenere lo stesso risultato?

Discussione: può un innocuo javascript surriscaldare la CPU?

Strumenti discussione

Ricerca discussione

Visualizza

Permessi di invio