Newsgroup: it.comp.lang.c++
Titolo: Settare un delay

Mi rendo conto che e' una domanda veramente stupida, ma non riesco a
trovare la risposta.
Come faccio a fare in modo che l'esecuzione del programma resti in 
stallo per un certo tempo fissato da me?
-- 
  _  _  >>Now at work<<  _     || ICQ number.................Non lo uso
 | \| |___ _____ ___ ___|_|___ || Home-Page ................Non ce l'ho
 | .` | -_|     | -_|_ -| |_ -||| E-Mail................Non l'avrai mai
 |_|\_|___|_|_|_|___|___|_|___||| Un Nemesis che ha pochi e-contatti ;)

 trovare la risposta.
in c++ standard, a basse risoluzioni (diciamo secondi o poco meno) puoi 
usare clock o time, altrimenti dipende dal sistema operativo (ad 
esempio usleep su unix, i timer multimediali, le varie timed wait su OS 
multithreading, etc etc)

 stallo per un certo tempo fissato da me?
Mi spiace dovertelo dire, ma a meno che tu non abbia un sistema
"hard real time"  il problema da te proposto non ammette soluzione.
Ciao.
Gaetano.
-- 
Posted from 
dell-01.mm.eutelsat.org
 [194.214.173.17] 
via Mailgate.ORG Server - 
http://www.Mailgate.ORG

 usare clock o time,  
Ma in che libreria sono, io non riesco a trovarle.


 "hard real time"  il problema da te proposto non ammette soluzione.
Ma io non ho bisogno di una cosa precisa, a me va bene anche un
approssimazione di 1sec .


 approssimazione di 1sec .
Non sto parlando di precisione al millisecondo, sto parlando di tempi
macroscopici tipo:  "la tua applicazione dopo una sleep non verra MAI
rieseguita".
Se devi fare un giochino in cui se l'applicazione non viene piu' rieseguita
allora c'e' la "sleep" (comunque dipende dalla piattaforma) se invece
devi far dipendere il guadagno o la vita di qualcuno dal tuo codice
che viene rieseguito circa ogni secondo allora..... le cose cambiano.
In questo caso si usano dei meccanismi (anche per sistemi non HRT)
tipo NMI ( da questo punto di vista la piattaforma DOS non e' 
da buttar via, vedi a tal proposito su uno degli ultimi DrDobs un
articolo RealTime su piattaforma DOS).
Ciao


----- Original Message -----
From: "Aloha" <aha...@laugh.doh>
Newsgroups: it.comp.lang.c++
Sent: Tuesday, October 09, 2001 3:54 PM
Subject: Re: Settare un delay

Su Lose32:
The Sleep function suspends the execution of the current thread for the
specified interval.
To enter an alertable wait state, use the SleepEx function.
VOID Sleep(
  DWORD dwMilliseconds   // sleep time
);


 Su Lose32:
Linux Operating System Enhanched 32?
8-PPPPPP
-- 
Luc.

 rieseguita".
mi spieghi questa frase?
mi sembra di aver capito che una cosa come
while(condition){
   sleep(1);
   do_things();
}
non va bene...
ma probabilmente ho capito male

 Ma in che libreria sono, io non riesco a trovarle.
#include <ctime>
ma occhio che su sistemi multithreading molto occupati, o se sei 
sfigato, aspettare un secondo puo' essere una cosa lunga :)
Nel caso ti servisse il real time, direi di passare a librerie/sistemi 
operativi appositi

 non va bene...
esatto se durante la sleep il sistema operativo si ritrova
a gestire delle NMI o a schedulare nuovi processi a piu' alta
priorita' il tuo processo subisce "starvation".
Ovviamente ci sono dei meccanismi che aumentano la priorita'
dei processi in attesa di essere eseguiti ma comunque non ti salva
nessuno dalle NMI.
E' strano a dirsi ma l'unico sistema hard realtime garantito e' un sistema
mono processo ( questo non vuol dire che non puoi far girare processi
contemporaneamente, ma semplicemente devi dire all'unico processo che
il sistema operativo "vede":  <<schedulami ogni 10 secondi il processo A e
ogni
20 secondi il processo B>> e varie segate tipo questa... )


 "hard real time"  il problema da te proposto non ammette soluzione.
Questa me la devi spiegare!
A meno che quello che si voglia e' una pausa di ESATTAMENTE un tempo X (in questo caso servono sistemi operativi real time e codice apposito), persino in C++ standard puoi far si che il tuo programma non faccia nulla per un certo periodo (in una riga):
for ( std::clock_t t_out=std::clock()+DELAY; t_out < std::clock(); );
Inoltre su quasi tutti i sistemi esiste una funzione che dal punto di vista del tuo processo esegue una semplice attesa ma che dal punto di vista del sistema è molto più efficiente perchè il tuo processo invece che eseguire un ciclo di attesa semplicemente si ferma per un dato tempo (e lascia la CPU a disposizione di altri processi).
-- 
Andrea Ferro
---------
Brainbench C++ Master. Scored higher than 97% of previous takers
Scores: Overall 4.46, Conceptual 5.0, Problem-Solving 5.0
More info 
http://www.brainbench.com/transcript.jsp?pid=2522556

 allora c'e' la "sleep" (comunque dipende dalla piattaforma) se invece
Azz. Buonissima! Chi è il tuo pusher?


 E' strano a dirsi ma l'unico sistema hard realtime garantito e' un sistema
Non stavamo parlando di sistemi HRT. Stavamo parlando di un programma che gira probabilmente su un PC con un sistema operativo comune. 
Anzi: per essere IT stavamo parlando di come fare la cosa in maniera portabile!!


--=20
Di nuovo problemi con OE?
-- 
Marco Barisione (ICQ 84277092)
Su it.news.gruppi si sta discutendo della creazione di it.comp.lang
dove si parlerà dei linguaggi senza un proprio newsgroup e dei
confronti fra i diversi linguaggi.
Se sei interessato unisciti alla discussione.

 for ( std::clock_t t_out=std::clock()+DELAY; t_out < std::clock(); );
Ripeto: Forse.
Oddio ora faccio il Cristiano della situazione, ok ok sto calcando la mano,
ma il post originale era:
"Come faccio a fare in modo che l'esecuzione del programma resti in stallo
per un certo tempo fissato da me?"
senza stare a cercare il pelo nell'uovo siete o no daccordo che posti in
questi termini il problema
non ammette soluzione ?
P.S: Ogni volta che ho dovuto interrompere l'esecuzione di un processo per
circa X secondi ho usato
        per Linux (con il GCC) la
                    unsigned int sleep (unsigned int __seconds);        //Si
ferma per il num di secondi (a meno che non arrivi un signal)
                e per scendere sotto il secondo esiste la:
                     int usleep (__useconds_t __useconds);              //Si
ferma per il numero di micro secondi (a meno che non arrivi un signal)
                il valore di ritorno di entrambe da l'effettivo tempo di
pausa.
      per Windowze (VC++) :
                   VOID Sleep(  DWORD dwMilliseconds );
            e se volessi essere svegliato prematuramente:
                   DWORD SleepEx(  DWORD dwMilliseconds,  BOOL bAlertable );
            il valore di ritorno di quest'ultima ti dice effetticamente
quanto tempo hai aspettato.
PSS.: Notare come alla M$ abbiano avuto la non cattiva idea di fare una
define per VOID  e una per
           BOOL (che non e' un bool ma un int )  :-(
PSSS: Ho cambiato pusher da poco.
PSSSS: E non me ne fate passare una.......
Ciao


 Di nuovo problemi con OE?
Io pero' l'originale di Andrea lo leggo correttamente.
Ciao,
Nicola

 In un sistema comune come un PC è piuttosto difficile che....
Andrea, dovresti settare il numero massimo di colonne con il
tuo newsreader, altrimenti mi costringi ad usare un secondo
monitor e la scheda dualhead.
-- 
Posted from  [80.105.34.80] 




Marco Barisione usa Free Agent, che, come è noto, non riconosce il
quoted-printable
Max

 In un sistema comune come un PC è piuttosto difficile che ci sia un NMI
Io non parlavo esattamente delle interruzioni che arrivano sul piedino NMI
della famiglia dei processori X86 ma anche delle interruzioni non
mascherate.
Ciao
Gaetano.
PS: Chiuso qui.


 wrote in message news:Pine.LNX.4.10.101101...@c64.comm2000.it...

Meno male, stavo per collassare. Non ho cambiato nulla nell'encoding internazionale e per quanto OL non sia il massimo, dubito che cambi i settaggi da solo!
Ora resta da vedere quale settaggio per il MIME. Fra None, Quoted Printable e Base64. Avevo settato il Quoted Printable perchè mi sembrava piu' generale e meglio supportato.
Ditemelo voi!


 monitor e la scheda dualhead.
Ok. Capito. Il MIME non e' molto supportato!
Torno a MIME None e wrap a 80 colonne!


 mascherate.
NMI sta per interruzioni non mascherabili. Ovvero quelle che arrivano al piedino
NMI del processore. Le interruzioni mascherabili sono gli interrupt HW che in
architettura PC si chiamano IRQ. E queste arrivano piuttosto spesso e sono
sempre gestite dal sistema operativo. Non vedo come potrebbero portare il tuo
programmino alla starvation. Gli IRQ di fatto portano all'esecuzione di codice
privilegiato (che in linea di massima fa parte del SO o al massimo di un device
driver) e che è sempre scritto in modo tale da essere eseguibile in tempi
brevissimi. Se così non fosse, ancora una volta, si impallerebbe il sistema, non
un applicativo.


 un applicativo.
Nemmeno io.
Ciao
Gaetano.
ps: PC sta per Personal Computer? Quindi anche Palmari, Machintosh,
     O2, etc etc.


      O2, etc etc.
PC sta per personal computer. Ma si intende con questo quello che una volta
veniva chiamato PC-IBM-o-compatibile.
In altre parole si parla di una architettura ben precisa che corrisponde ad uno
standard industriale (che è in evoluzione) e che si basa su processori Intel
I palmari, i Mac etc. non sono considerati PC.


Torno a MIME None e wrap a 80 colonne!
72
-- 
+---- | Un OS per domarli, Un OS per trovarli,             |  -o)
+---+ | Un OS per ghermirli e nel buio incatenarli         |  /\\
 O  | | Nella terra di Redmond, ove l'ombra cupa scende... | _\_V
                    raffaele punto salmaso presso libero punto it

Ora resta da vedere quale settaggio per il MIME. Fra None, Quoted Printable e Base64. Avevo settato il Quoted Printable perchč mi sembrava piu' generale e meglio supportato.
us-ascii no?
al massimo ISO-8859-1, anche se non e' il massimo


 al massimo ISO-8859-1, anche se non e' il massimo
Stai facendo confusione fra l'encoding dei caratteri e il Mime. L'encoding dei
caratteri l'ho settato su ISO perchč se lo metto us-ascii non funzionano gli
accenti. Il Mime lo avevo settato Quoted Printable, ma pare che dia vari
problemi a varie persone per cui sono ora tornato a None.


 72
Giusto, dimenticavo. Provvedo.
