Je cherche a creer une DLL ( ici "Compteur.dll" ) avec un process sans fin
qui ne se terminerait qu'en tuant le thread.
Voici mon prototype, mais malheureusement celui ci ne fonctionne pas ,
quelqu'un a t il une idee ?
int __stdcall DllMain (HINSTANCE hinstDLL, DWORD fdwReason, LPVOID
lpvReserved)
{
switch (fdwReason)
{
case DLL_PROCESS_ATTACH:
hinstDLL = LoadLibrary("Compteur.dll"); // je recharge la DLL
if (InitCVIRTE (hinstDLL, 0, 0) == 0)
return 0;
break;
case DLL_PROCESS_DETACH:
if (!CVIRTEHasBeenDetached ())
CloseCVIRTE ();
FreeLibrary(hinstDLL); // je libere la memoire
break;
}
ya une petite erreur, vire les cast float et met long double fTime = 0; dans DLLTimeOff()
Arnaud Debaene
JB wrote:
Bonjour ,
Je cherche a creer une DLL ( ici "Compteur.dll" ) avec un process sans fin qui ne se terminerait qu'en tuant le thread.
"Créer une DLL avec un process sans fin"... Désolé mais je ne comprends rien à ce que ca veut dire.
Bien entendu, ton bout de code ne compile pas et il ne nous permet même pas de déviner ce que cherches à faire. Quand la DLL courante (celle que tu es en train d'écrire) est chargée dans un nouveau processus, tu charges Compteur.dll... et puis quoi? C'est quoi InitCVIRTE et CloseCVIRTE? Et à quoi servent Fonction1 et Fonction2 là dedans?
De toute façon et avant d'aller plus loin, tu n'as pas le droit d'appeler LoadLibrary depuis DllMain, ainsi que c'est spécifié dans MSDN : c'est la meilleure façon de faire un deadlock sur le DLL loading lock.
Si tu nous expliquait plus clairement ce que tu cherches à faire, on pourrait t'aider d'avantage.
Arnaud
JB wrote:
Bonjour ,
Je cherche a creer une DLL ( ici "Compteur.dll" ) avec un process
sans fin qui ne se terminerait qu'en tuant le thread.
"Créer une DLL avec un process sans fin"... Désolé mais je ne comprends rien
à ce que ca veut dire.
Bien entendu, ton bout de code ne compile pas et il ne nous permet même pas
de déviner ce que cherches à faire. Quand la DLL courante (celle que tu es
en train d'écrire) est chargée dans un nouveau processus, tu charges
Compteur.dll... et puis quoi? C'est quoi InitCVIRTE et CloseCVIRTE? Et à
quoi servent Fonction1 et Fonction2 là dedans?
De toute façon et avant d'aller plus loin, tu n'as pas le droit d'appeler
LoadLibrary depuis DllMain, ainsi que c'est spécifié dans MSDN : c'est la
meilleure façon de faire un deadlock sur le DLL loading lock.
Si tu nous expliquait plus clairement ce que tu cherches à faire, on
pourrait t'aider d'avantage.
Je cherche a creer une DLL ( ici "Compteur.dll" ) avec un process sans fin qui ne se terminerait qu'en tuant le thread.
"Créer une DLL avec un process sans fin"... Désolé mais je ne comprends rien à ce que ca veut dire.
Bien entendu, ton bout de code ne compile pas et il ne nous permet même pas de déviner ce que cherches à faire. Quand la DLL courante (celle que tu es en train d'écrire) est chargée dans un nouveau processus, tu charges Compteur.dll... et puis quoi? C'est quoi InitCVIRTE et CloseCVIRTE? Et à quoi servent Fonction1 et Fonction2 là dedans?
De toute façon et avant d'aller plus loin, tu n'as pas le droit d'appeler LoadLibrary depuis DllMain, ainsi que c'est spécifié dans MSDN : c'est la meilleure façon de faire un deadlock sur le DLL loading lock.
Si tu nous expliquait plus clairement ce que tu cherches à faire, on pourrait t'aider d'avantage.
Arnaud
JB
Ok, je vais aller un peu plus loin dans mes explications :
1) J'utilise Labwindows CVI et le sdk Windows fourni. 2) Le but est de creer un compteur ( Timer ) avec une fonction pour l'initialiser et une autre pour me retourner le temps ecoulé entre l'appel 1 et l'appel 2. 3) Cette Dll fonctionne mais comme chaque appel de cette DLL initialise le Timer elle me retourne systematiquement 0. 4) D'ou l'idee de laisser le process tourner jusqu'a l'appel de la 2e fonction comprenant le FreeLibrary.
J'espere avoir été plus precis.
Voici la fonction 1 et 2 :
void __stdcall DLLTimeOn (void) { // test gTempsTest = 0.0; // Commence le comptage gTempsTest = Timer();
}
/*---------------------------------------------------------------------------*/ /* This sample exported function will be available to callers of our DLL. */ /*---------------------------------------------------------------------------*/ double __stdcall DLLTimeOff () {
double secondes;
// Temps total du passage secondes = Timer() - gTempsTest;
return secondes;
}
"Arnaud Debaene" a écrit dans le message de news: 420d17c8$0$19236$
JB wrote:
Bonjour ,
Je cherche a creer une DLL ( ici "Compteur.dll" ) avec un process sans fin qui ne se terminerait qu'en tuant le thread.
"Créer une DLL avec un process sans fin"... Désolé mais je ne comprends rien à ce que ca veut dire.
Bien entendu, ton bout de code ne compile pas et il ne nous permet même pas de déviner ce que cherches à faire. Quand la DLL courante (celle que tu es en train d'écrire) est chargée dans un nouveau processus, tu charges Compteur.dll... et puis quoi? C'est quoi InitCVIRTE et CloseCVIRTE? Et à quoi servent Fonction1 et Fonction2 là dedans?
De toute façon et avant d'aller plus loin, tu n'as pas le droit d'appeler LoadLibrary depuis DllMain, ainsi que c'est spécifié dans MSDN : c'est la meilleure façon de faire un deadlock sur le DLL loading lock.
Si tu nous expliquait plus clairement ce que tu cherches à faire, on pourrait t'aider d'avantage.
Arnaud
Ok, je vais aller un peu plus loin dans mes explications :
1) J'utilise Labwindows CVI et le sdk Windows fourni.
2) Le but est de creer un compteur ( Timer ) avec une fonction pour
l'initialiser et une autre pour me retourner le temps ecoulé entre l'appel 1
et l'appel 2.
3) Cette Dll fonctionne mais comme chaque appel de cette DLL initialise le
Timer elle me retourne systematiquement 0.
4) D'ou l'idee de laisser le process tourner jusqu'a l'appel de la 2e
fonction comprenant le FreeLibrary.
J'espere avoir été plus precis.
Voici la fonction 1 et 2 :
void __stdcall DLLTimeOn (void)
{
// test
gTempsTest = 0.0;
// Commence le comptage
gTempsTest = Timer();
}
/*---------------------------------------------------------------------------*/
/* This sample exported function will be available to callers of our DLL.
*/
/*---------------------------------------------------------------------------*/
double __stdcall DLLTimeOff ()
{
double secondes;
// Temps total du passage
secondes = Timer() - gTempsTest;
return secondes;
}
"Arnaud Debaene" <adebaene@club-internet.fr> a écrit dans le message de
news: 420d17c8$0$19236$626a14ce@news.free.fr...
JB wrote:
Bonjour ,
Je cherche a creer une DLL ( ici "Compteur.dll" ) avec un process
sans fin qui ne se terminerait qu'en tuant le thread.
"Créer une DLL avec un process sans fin"... Désolé mais je ne comprends
rien à ce que ca veut dire.
Bien entendu, ton bout de code ne compile pas et il ne nous permet même
pas de déviner ce que cherches à faire. Quand la DLL courante (celle que
tu es en train d'écrire) est chargée dans un nouveau processus, tu charges
Compteur.dll... et puis quoi? C'est quoi InitCVIRTE et CloseCVIRTE? Et à
quoi servent Fonction1 et Fonction2 là dedans?
De toute façon et avant d'aller plus loin, tu n'as pas le droit d'appeler
LoadLibrary depuis DllMain, ainsi que c'est spécifié dans MSDN : c'est la
meilleure façon de faire un deadlock sur le DLL loading lock.
Si tu nous expliquait plus clairement ce que tu cherches à faire, on
pourrait t'aider d'avantage.
Ok, je vais aller un peu plus loin dans mes explications :
1) J'utilise Labwindows CVI et le sdk Windows fourni. 2) Le but est de creer un compteur ( Timer ) avec une fonction pour l'initialiser et une autre pour me retourner le temps ecoulé entre l'appel 1 et l'appel 2. 3) Cette Dll fonctionne mais comme chaque appel de cette DLL initialise le Timer elle me retourne systematiquement 0. 4) D'ou l'idee de laisser le process tourner jusqu'a l'appel de la 2e fonction comprenant le FreeLibrary.
J'espere avoir été plus precis.
Voici la fonction 1 et 2 :
void __stdcall DLLTimeOn (void) { // test gTempsTest = 0.0; // Commence le comptage gTempsTest = Timer();
}
/*---------------------------------------------------------------------------*/ /* This sample exported function will be available to callers of our DLL. */ /*---------------------------------------------------------------------------*/ double __stdcall DLLTimeOff () {
double secondes;
// Temps total du passage secondes = Timer() - gTempsTest;
return secondes;
}
"Arnaud Debaene" a écrit dans le message de news: 420d17c8$0$19236$
JB wrote:
Bonjour ,
Je cherche a creer une DLL ( ici "Compteur.dll" ) avec un process sans fin qui ne se terminerait qu'en tuant le thread.
"Créer une DLL avec un process sans fin"... Désolé mais je ne comprends rien à ce que ca veut dire.
Bien entendu, ton bout de code ne compile pas et il ne nous permet même pas de déviner ce que cherches à faire. Quand la DLL courante (celle que tu es en train d'écrire) est chargée dans un nouveau processus, tu charges Compteur.dll... et puis quoi? C'est quoi InitCVIRTE et CloseCVIRTE? Et à quoi servent Fonction1 et Fonction2 là dedans?
De toute façon et avant d'aller plus loin, tu n'as pas le droit d'appeler LoadLibrary depuis DllMain, ainsi que c'est spécifié dans MSDN : c'est la meilleure façon de faire un deadlock sur le DLL loading lock.
Si tu nous expliquait plus clairement ce que tu cherches à faire, on pourrait t'aider d'avantage.
Arnaud
Arnaud Debaene
JB wrote:
Ok, je vais aller un peu plus loin dans mes explications :
1) J'utilise Labwindows CVI et le sdk Windows fourni. 2) Le but est de creer un compteur ( Timer ) avec une fonction pour l'initialiser et une autre pour me retourner le temps ecoulé entre l'appel 1 et l'appel 2.
Ok...
3) Cette Dll fonctionne mais comme chaque appel de cette DLL initialise le Timer elle me retourne systematiquement 0.
Un "timer" différent est initialisé pour chaque processus dans lequel est chargé la DLL. C'est çà qui te pose problème? Si c'est le cas, il faut déclarer gTempsTest dans une section "shared", mais tu ve de toute façon te heurter à des problèmes de synchro si tu fais comme çà...
4) D'ou l'idee de laisser le process tourner jusqu'a l'appel de la 2e fonction comprenant le FreeLibrary.
Moi plus rien comprendre là : Tu veux forcer le programme à appeler DllTimeOff avant de décharger la DLL, c'est çà? Quel est l'intérêt?
J'espere avoir été plus precis.
Pas vraiment non ;-) Essaies de nous expliquer ce que tu veux faire, pas comment tu a imaginé le faire : Ca nous permettra de mieux te conseiller. Ton timer, il doit mesurer l'intervalle entr l'appel de 2 fonctions, ok. Elles sont appelées par qui et dans quel contexte ses fonctions? C'est pour faire du benchmarking ou autre chose?
Arnaud
JB wrote:
Ok, je vais aller un peu plus loin dans mes explications :
1) J'utilise Labwindows CVI et le sdk Windows fourni.
2) Le but est de creer un compteur ( Timer ) avec une fonction pour
l'initialiser et une autre pour me retourner le temps ecoulé entre
l'appel 1 et l'appel 2.
Ok...
3) Cette Dll fonctionne mais comme chaque appel de cette DLL
initialise le Timer elle me retourne systematiquement 0.
Un "timer" différent est initialisé pour chaque processus dans lequel est
chargé la DLL. C'est çà qui te pose problème? Si c'est le cas, il faut
déclarer gTempsTest dans une section "shared", mais tu ve de toute façon te
heurter à des problèmes de synchro si tu fais comme çà...
4) D'ou l'idee de laisser le process tourner jusqu'a l'appel de la 2e
fonction comprenant le FreeLibrary.
Moi plus rien comprendre là : Tu veux forcer le programme à appeler
DllTimeOff avant de décharger la DLL, c'est çà? Quel est l'intérêt?
J'espere avoir été plus precis.
Pas vraiment non ;-) Essaies de nous expliquer ce que tu veux faire, pas
comment tu a imaginé le faire : Ca nous permettra de mieux te conseiller.
Ton timer, il doit mesurer l'intervalle entr l'appel de 2 fonctions, ok.
Elles sont appelées par qui et dans quel contexte ses fonctions? C'est pour
faire du benchmarking ou autre chose?
Ok, je vais aller un peu plus loin dans mes explications :
1) J'utilise Labwindows CVI et le sdk Windows fourni. 2) Le but est de creer un compteur ( Timer ) avec une fonction pour l'initialiser et une autre pour me retourner le temps ecoulé entre l'appel 1 et l'appel 2.
Ok...
3) Cette Dll fonctionne mais comme chaque appel de cette DLL initialise le Timer elle me retourne systematiquement 0.
Un "timer" différent est initialisé pour chaque processus dans lequel est chargé la DLL. C'est çà qui te pose problème? Si c'est le cas, il faut déclarer gTempsTest dans une section "shared", mais tu ve de toute façon te heurter à des problèmes de synchro si tu fais comme çà...
4) D'ou l'idee de laisser le process tourner jusqu'a l'appel de la 2e fonction comprenant le FreeLibrary.
Moi plus rien comprendre là : Tu veux forcer le programme à appeler DllTimeOff avant de décharger la DLL, c'est çà? Quel est l'intérêt?
J'espere avoir été plus precis.
Pas vraiment non ;-) Essaies de nous expliquer ce que tu veux faire, pas comment tu a imaginé le faire : Ca nous permettra de mieux te conseiller. Ton timer, il doit mesurer l'intervalle entr l'appel de 2 fonctions, ok. Elles sont appelées par qui et dans quel contexte ses fonctions? C'est pour faire du benchmarking ou autre chose?
Arnaud
JB
Merci pour ces précisions, j'adapterais la syntaxe à mon compilo. Cependant, cette DLL est appelée d'un environnement extérieur qui me sert d'interfacage. Je n'ai pas besoin d'une grande précision ( la demi seconde me suffit ) car l'utilisation finale de cette DLL est de me retourner un temps de test ( Bench ). Le réel problème comme je l'ai énoncé plus haut est de conserver le processus lors des deux appels afin évidemment que le timer fasse son boulot et non pas que la DLL soit chargée et déchargée à chaque appel. Cad : première fonction Timer à 0 et deuxième fonction valeur du timer à cet instant à partir de mon environnement .
@+
"dark poulpo" a écrit dans le message de news: 420df3fa$0$2179$
ya une petite erreur, vire les cast float et met long double fTime = 0; dans DLLTimeOff()
Merci pour ces précisions, j'adapterais la syntaxe à mon compilo.
Cependant, cette DLL est appelée d'un environnement extérieur qui me sert
d'interfacage.
Je n'ai pas besoin d'une grande précision ( la demi seconde me suffit ) car
l'utilisation finale de cette DLL est de me retourner un temps de test (
Bench ).
Le réel problème comme je l'ai énoncé plus haut est de conserver le
processus lors des deux appels afin évidemment que le timer fasse son boulot
et non pas que la DLL soit chargée et déchargée à chaque appel.
Cad : première fonction Timer à 0 et deuxième fonction valeur du timer à cet
instant à partir de mon environnement .
@+
"dark poulpo" <xxxxxx@xxxxxx.fr> a écrit dans le message de news:
420df3fa$0$2179$8fcfb975@news.wanadoo.fr...
ya une petite erreur, vire les cast float et met long double fTime = 0;
dans DLLTimeOff()
Merci pour ces précisions, j'adapterais la syntaxe à mon compilo. Cependant, cette DLL est appelée d'un environnement extérieur qui me sert d'interfacage. Je n'ai pas besoin d'une grande précision ( la demi seconde me suffit ) car l'utilisation finale de cette DLL est de me retourner un temps de test ( Bench ). Le réel problème comme je l'ai énoncé plus haut est de conserver le processus lors des deux appels afin évidemment que le timer fasse son boulot et non pas que la DLL soit chargée et déchargée à chaque appel. Cad : première fonction Timer à 0 et deuxième fonction valeur du timer à cet instant à partir de mon environnement .
@+
"dark poulpo" a écrit dans le message de news: 420df3fa$0$2179$
ya une petite erreur, vire les cast float et met long double fTime = 0; dans DLLTimeOff()
JB
Oui il s'agit de Bench sur un test utilisant des ressources externes au PC. Comment laisser tourner mon Timer entre deux appels sans decharger systematiquement la DLL de la mémoire ( fin du processus attaché ). A savoir que cette DLL est appellée par un environnement externe ( je donne le nom de la DLL et sa fonction exportée à appeller ). Pour commencer j'utilise simplement l'executable suivant ( écrit sous LabWindows ) :
int main (int argc, char *argv[]) { char message[50];
if (InitCVIRTE (0, argv, 0) == 0) return -1;
MessagePopup ("Utilisation Timer", "Pret pour DLLTimeOn dans Compteur.dll"); // appel 1ere fonction initialise Timer
DLLTimeOn (); MessagePopup ("Utilisation Timer", "Pret pour DLLTimeOff dans Compteur.dll");
sprintf (message, "Le temps de test est de %.3f secondes.", DLLTimeOff ()); // appel 2eme fonction renvoie Laps Timer
MessagePopup ("Temps ecoulé", message);
CloseCVIRTE (); return 0; } @+
"Arnaud Debaene" a écrit dans le message de news: 420dfd80$0$10566$
JB wrote:
Ok, je vais aller un peu plus loin dans mes explications :
1) J'utilise Labwindows CVI et le sdk Windows fourni. 2) Le but est de creer un compteur ( Timer ) avec une fonction pour l'initialiser et une autre pour me retourner le temps ecoulé entre l'appel 1 et l'appel 2.
Ok...
3) Cette Dll fonctionne mais comme chaque appel de cette DLL initialise le Timer elle me retourne systematiquement 0.
Un "timer" différent est initialisé pour chaque processus dans lequel est chargé la DLL. C'est çà qui te pose problème? Si c'est le cas, il faut déclarer gTempsTest dans une section "shared", mais tu ve de toute façon te heurter à des problèmes de synchro si tu fais comme çà...
4) D'ou l'idee de laisser le process tourner jusqu'a l'appel de la 2e fonction comprenant le FreeLibrary.
Moi plus rien comprendre là : Tu veux forcer le programme à appeler DllTimeOff avant de décharger la DLL, c'est çà? Quel est l'intérêt?
J'espere avoir été plus precis.
Pas vraiment non ;-) Essaies de nous expliquer ce que tu veux faire, pas comment tu a imaginé le faire : Ca nous permettra de mieux te conseiller. Ton timer, il doit mesurer l'intervalle entr l'appel de 2 fonctions, ok. Elles sont appelées par qui et dans quel contexte ses fonctions? C'est pour faire du benchmarking ou autre chose?
Arnaud
Oui il s'agit de Bench sur un test utilisant des ressources externes au PC.
Comment laisser tourner mon Timer entre deux appels sans decharger
systematiquement la DLL de la mémoire ( fin du processus attaché ).
A savoir que cette DLL est appellée par un environnement externe ( je donne
le nom de la DLL et sa fonction exportée à appeller ).
Pour commencer j'utilise simplement l'executable suivant ( écrit sous
LabWindows ) :
int main (int argc, char *argv[])
{
char message[50];
if (InitCVIRTE (0, argv, 0) == 0)
return -1;
MessagePopup ("Utilisation Timer", "Pret pour DLLTimeOn dans
Compteur.dll"); // appel 1ere fonction initialise Timer
DLLTimeOn ();
MessagePopup ("Utilisation Timer", "Pret pour DLLTimeOff dans
Compteur.dll");
sprintf (message, "Le temps de test est de %.3f secondes.", DLLTimeOff
()); // appel 2eme fonction renvoie Laps Timer
MessagePopup ("Temps ecoulé", message);
CloseCVIRTE ();
return 0;
}
@+
"Arnaud Debaene" <adebaene@club-internet.fr> a écrit dans le message de
news: 420dfd80$0$10566$636a15ce@news.free.fr...
JB wrote:
Ok, je vais aller un peu plus loin dans mes explications :
1) J'utilise Labwindows CVI et le sdk Windows fourni.
2) Le but est de creer un compteur ( Timer ) avec une fonction pour
l'initialiser et une autre pour me retourner le temps ecoulé entre
l'appel 1 et l'appel 2.
Ok...
3) Cette Dll fonctionne mais comme chaque appel de cette DLL
initialise le Timer elle me retourne systematiquement 0.
Un "timer" différent est initialisé pour chaque processus dans lequel est
chargé la DLL. C'est çà qui te pose problème? Si c'est le cas, il faut
déclarer gTempsTest dans une section "shared", mais tu ve de toute façon
te heurter à des problèmes de synchro si tu fais comme çà...
4) D'ou l'idee de laisser le process tourner jusqu'a l'appel de la 2e
fonction comprenant le FreeLibrary.
Moi plus rien comprendre là : Tu veux forcer le programme à appeler
DllTimeOff avant de décharger la DLL, c'est çà? Quel est l'intérêt?
J'espere avoir été plus precis.
Pas vraiment non ;-) Essaies de nous expliquer ce que tu veux faire, pas
comment tu a imaginé le faire : Ca nous permettra de mieux te conseiller.
Ton timer, il doit mesurer l'intervalle entr l'appel de 2 fonctions, ok.
Elles sont appelées par qui et dans quel contexte ses fonctions? C'est
pour faire du benchmarking ou autre chose?
Oui il s'agit de Bench sur un test utilisant des ressources externes au PC. Comment laisser tourner mon Timer entre deux appels sans decharger systematiquement la DLL de la mémoire ( fin du processus attaché ). A savoir que cette DLL est appellée par un environnement externe ( je donne le nom de la DLL et sa fonction exportée à appeller ). Pour commencer j'utilise simplement l'executable suivant ( écrit sous LabWindows ) :
int main (int argc, char *argv[]) { char message[50];
if (InitCVIRTE (0, argv, 0) == 0) return -1;
MessagePopup ("Utilisation Timer", "Pret pour DLLTimeOn dans Compteur.dll"); // appel 1ere fonction initialise Timer
DLLTimeOn (); MessagePopup ("Utilisation Timer", "Pret pour DLLTimeOff dans Compteur.dll");
sprintf (message, "Le temps de test est de %.3f secondes.", DLLTimeOff ()); // appel 2eme fonction renvoie Laps Timer
MessagePopup ("Temps ecoulé", message);
CloseCVIRTE (); return 0; } @+
"Arnaud Debaene" a écrit dans le message de news: 420dfd80$0$10566$
JB wrote:
Ok, je vais aller un peu plus loin dans mes explications :
1) J'utilise Labwindows CVI et le sdk Windows fourni. 2) Le but est de creer un compteur ( Timer ) avec une fonction pour l'initialiser et une autre pour me retourner le temps ecoulé entre l'appel 1 et l'appel 2.
Ok...
3) Cette Dll fonctionne mais comme chaque appel de cette DLL initialise le Timer elle me retourne systematiquement 0.
Un "timer" différent est initialisé pour chaque processus dans lequel est chargé la DLL. C'est çà qui te pose problème? Si c'est le cas, il faut déclarer gTempsTest dans une section "shared", mais tu ve de toute façon te heurter à des problèmes de synchro si tu fais comme çà...
4) D'ou l'idee de laisser le process tourner jusqu'a l'appel de la 2e fonction comprenant le FreeLibrary.
Moi plus rien comprendre là : Tu veux forcer le programme à appeler DllTimeOff avant de décharger la DLL, c'est çà? Quel est l'intérêt?
J'espere avoir été plus precis.
Pas vraiment non ;-) Essaies de nous expliquer ce que tu veux faire, pas comment tu a imaginé le faire : Ca nous permettra de mieux te conseiller. Ton timer, il doit mesurer l'intervalle entr l'appel de 2 fonctions, ok. Elles sont appelées par qui et dans quel contexte ses fonctions? C'est pour faire du benchmarking ou autre chose?
Arnaud
Arnaud Debaene
JB wrote:
Oui il s'agit de Bench sur un test utilisant des ressources externes au PC. Comment laisser tourner mon Timer entre deux appels sans decharger systematiquement la DLL de la mémoire ( fin du processus attaché ). A savoir que cette DLL est appellée par un environnement externe ( je donne le nom de la DLL et sa fonction exportée à appeller ).
Arrête de chercher des solutions compliquées et de toutes façon fausses : A chaque appel de DLLTimeOff, enregistres simplement le compteur courant dans un fichier, et recharges le (si le fichier existe) dans chaque appel à DLLTimeOn. Prévoies une fonction de "réinitialisation" qui efface le fichier.
Arnaud
JB wrote:
Oui il s'agit de Bench sur un test utilisant des ressources externes
au PC. Comment laisser tourner mon Timer entre deux appels sans
decharger systematiquement la DLL de la mémoire ( fin du processus
attaché ). A savoir que cette DLL est appellée par un environnement
externe ( je
donne le nom de la DLL et sa fonction exportée à appeller ).
Arrête de chercher des solutions compliquées et de toutes façon fausses : A
chaque appel de DLLTimeOff, enregistres simplement le compteur courant dans
un fichier, et recharges le (si le fichier existe) dans chaque appel à
DLLTimeOn. Prévoies une fonction de "réinitialisation" qui efface le
fichier.
Oui il s'agit de Bench sur un test utilisant des ressources externes au PC. Comment laisser tourner mon Timer entre deux appels sans decharger systematiquement la DLL de la mémoire ( fin du processus attaché ). A savoir que cette DLL est appellée par un environnement externe ( je donne le nom de la DLL et sa fonction exportée à appeller ).
Arrête de chercher des solutions compliquées et de toutes façon fausses : A chaque appel de DLLTimeOff, enregistres simplement le compteur courant dans un fichier, et recharges le (si le fichier existe) dans chaque appel à DLLTimeOn. Prévoies une fonction de "réinitialisation" qui efface le fichier.
Arnaud
JB
Non, cette solution n'est pas envisageable et de toute façon ne change rien au problème. Le Timer est tué à la fin du premier appel ( dechargement de la DLL ).
1) L'utilisation d'un fichier n'est d' aucune utilité puisque le Timer prend fin à chaque déchargement de la DLL. 2) La solution que je recherche existe car il y a longtemps j'ai vu une utilisation similaire mais impossible de remettre la main dessus !! cad DLLMain puis chargement de la DLL via kernel32 ( LoadLibrary) au premier appel puis FreeLibrary au second appel.
JB
"Arnaud Debaene" a écrit dans le message de news: 420e3b2a$0$19200$
JB wrote:
Oui il s'agit de Bench sur un test utilisant des ressources externes au PC. Comment laisser tourner mon Timer entre deux appels sans decharger systematiquement la DLL de la mémoire ( fin du processus attaché ). A savoir que cette DLL est appellée par un environnement externe ( je donne le nom de la DLL et sa fonction exportée à appeller ).
Arrête de chercher des solutions compliquées et de toutes façon fausses : A chaque appel de DLLTimeOff, enregistres simplement le compteur courant dans un fichier, et recharges le (si le fichier existe) dans chaque appel à DLLTimeOn. Prévoies une fonction de "réinitialisation" qui efface le fichier.
Arnaud
Non, cette solution n'est pas envisageable et de toute façon ne change rien
au problème.
Le Timer est tué à la fin du premier appel ( dechargement de la DLL ).
1) L'utilisation d'un fichier n'est d' aucune utilité puisque le Timer prend
fin à chaque déchargement de la DLL.
2) La solution que je recherche existe car il y a longtemps j'ai vu une
utilisation similaire mais impossible de remettre la main dessus !!
cad DLLMain puis chargement de la DLL via kernel32 ( LoadLibrary) au premier
appel puis FreeLibrary au second appel.
JB
"Arnaud Debaene" <adebaene@club-internet.fr> a écrit dans le message de
news: 420e3b2a$0$19200$626a14ce@news.free.fr...
JB wrote:
Oui il s'agit de Bench sur un test utilisant des ressources externes
au PC. Comment laisser tourner mon Timer entre deux appels sans
decharger systematiquement la DLL de la mémoire ( fin du processus
attaché ). A savoir que cette DLL est appellée par un environnement
externe ( je
donne le nom de la DLL et sa fonction exportée à appeller ).
Arrête de chercher des solutions compliquées et de toutes façon fausses :
A
chaque appel de DLLTimeOff, enregistres simplement le compteur courant
dans
un fichier, et recharges le (si le fichier existe) dans chaque appel à
DLLTimeOn. Prévoies une fonction de "réinitialisation" qui efface le
fichier.
Non, cette solution n'est pas envisageable et de toute façon ne change rien au problème. Le Timer est tué à la fin du premier appel ( dechargement de la DLL ).
1) L'utilisation d'un fichier n'est d' aucune utilité puisque le Timer prend fin à chaque déchargement de la DLL. 2) La solution que je recherche existe car il y a longtemps j'ai vu une utilisation similaire mais impossible de remettre la main dessus !! cad DLLMain puis chargement de la DLL via kernel32 ( LoadLibrary) au premier appel puis FreeLibrary au second appel.
JB
"Arnaud Debaene" a écrit dans le message de news: 420e3b2a$0$19200$
JB wrote:
Oui il s'agit de Bench sur un test utilisant des ressources externes au PC. Comment laisser tourner mon Timer entre deux appels sans decharger systematiquement la DLL de la mémoire ( fin du processus attaché ). A savoir que cette DLL est appellée par un environnement externe ( je donne le nom de la DLL et sa fonction exportée à appeller ).
Arrête de chercher des solutions compliquées et de toutes façon fausses : A chaque appel de DLLTimeOff, enregistres simplement le compteur courant dans un fichier, et recharges le (si le fichier existe) dans chaque appel à DLLTimeOn. Prévoies une fonction de "réinitialisation" qui efface le fichier.
Arnaud
Arnaud Debaene
JB wrote:
Non, cette solution n'est pas envisageable et de toute façon ne change rien au problème. Le Timer est tué à la fin du premier appel ( dechargement de la DLL ).
Et tu ne peux pas t'arranger pour que ton environnement externe garde la DLL chargée aussi longtemps qu'il en a besoin? C'est quoi cet environnement? Un programme qui est relancé comme un processus séparé pour chaque "mesure". Bref, tant que tu ne nous expliquera pas plus clairement ce que tu cherches à faire, on ne pourra pas t'aider...
1) L'utilisation d'un fichier n'est d' aucune utilité puisque le Timer prend fin à chaque déchargement de la DLL.
Je ne comprends toujours pas, désolé...
2) La solution que je recherche existe car il y a longtemps j'ai vu une utilisation similaire mais impossible de remettre la main dessus !! cad DLLMain puis chargement de la DLL via kernel32 ( LoadLibrary) au premier appel puis FreeLibrary au second appel.
On ne *doit pas* appeler LoadLibrary depuis DLLMain,et ca a toujours été ainsi!
Arnaud
JB wrote:
Non, cette solution n'est pas envisageable et de toute façon ne
change rien au problème.
Le Timer est tué à la fin du premier appel ( dechargement de la DLL ).
Et tu ne peux pas t'arranger pour que ton environnement externe garde la DLL
chargée aussi longtemps qu'il en a besoin? C'est quoi cet environnement? Un
programme qui est relancé comme un processus séparé pour chaque "mesure".
Bref, tant que tu ne nous expliquera pas plus clairement ce que tu cherches
à faire, on ne pourra pas t'aider...
1) L'utilisation d'un fichier n'est d' aucune utilité puisque le
Timer prend fin à chaque déchargement de la DLL.
Je ne comprends toujours pas, désolé...
2) La solution que je recherche existe car il y a longtemps j'ai vu
une utilisation similaire mais impossible de remettre la main dessus
!! cad DLLMain puis chargement de la DLL via kernel32 ( LoadLibrary) au
premier appel puis FreeLibrary au second appel.
On ne *doit pas* appeler LoadLibrary depuis DLLMain,et ca a toujours été
ainsi!
Non, cette solution n'est pas envisageable et de toute façon ne change rien au problème. Le Timer est tué à la fin du premier appel ( dechargement de la DLL ).
Et tu ne peux pas t'arranger pour que ton environnement externe garde la DLL chargée aussi longtemps qu'il en a besoin? C'est quoi cet environnement? Un programme qui est relancé comme un processus séparé pour chaque "mesure". Bref, tant que tu ne nous expliquera pas plus clairement ce que tu cherches à faire, on ne pourra pas t'aider...
1) L'utilisation d'un fichier n'est d' aucune utilité puisque le Timer prend fin à chaque déchargement de la DLL.
Je ne comprends toujours pas, désolé...
2) La solution que je recherche existe car il y a longtemps j'ai vu une utilisation similaire mais impossible de remettre la main dessus !! cad DLLMain puis chargement de la DLL via kernel32 ( LoadLibrary) au premier appel puis FreeLibrary au second appel.
On ne *doit pas* appeler LoadLibrary depuis DLLMain,et ca a toujours été ainsi!
