Comment faire pour obtenir l'utilisation de l'uc par thread sur windows (win32)

Vous devez utiliser ces fonctions pour obtenir l'utilisation de l'uc par des threads et processus.

GetThreadTimes (Extrait des informations de synchronisation pour le thread spécifié.)

GetProcessTimes (Extrait des informations de synchronisation pour le processus spécifié.)

Fonction getsystemtime (Extrait le système actuel de la date et de l'heure. Le système de temps est exprimé en Temps Universel Coordonné UTC)

Ici un excellent article du Dr Dobb's Win32 Mesure De La Performance Des Options

Bye.

Est important de savoir que, dans certaines situations, le temps d'exécution d'un thread peut être sans valeur.
Le temps d'exécution de chaque thread sont mises à jour toutes les 15 millisecondes généralement pour les systèmes multi-core, de sorte que si un thread termine son travail avant ce temps, le moteur d'exécution seront remis à zéro.
Plus de détails peuvent être obtenus sur le lien:
GetThreadTimes fonction et j'ai été surpris par le résultat!

Pourquoi GetThreadTimes est faux

À L'Aide De "GetThreadTimes"? Si vous mesurez le temps entre les appels à "GetThreadTimes" et le magasin de la précédente utilisateur et/ou le noyau fois, alors vous savez combien de temps le fil depuis votre dernière vérification. Vous savez aussi combien de temps s'est écoulé dans le temps, et ainsi vous pouvez savoir combien de temps PROCESSEUR utilisé. Il serait préférable (pour la résolution du timer raisons pour cela, vérifiez toutes les secondes et le travail de son utilisation moyenne du PROCESSEUR au cours de cette seconde.

Cet exemple utilise GetProcessTimes() mais peut facilement être modifié pour utiliser GetThreadTimes().

ISO C clock() est CENSÉ vous donner écoulé CPU-secondes lorsqu'il est divisé par CLOCKS_PER_SEC. Cependant Visual Studio 2019 page web dit:

La fonction horloge indique combien l'horloge murale de temps a passé depuis la
CRT d'initialisation au cours du processus de démarrage. Notez que cette fonction n'
pas strictement conforme à la norme ISO C, qui spécifie le net de temps PROCESSEUR que l'
valeur de retour.

Donc, ici, c'est un stand-in que j'ai fait. Sur Windows 7/Visual Studio 2017, CLOCKS_PER_SEC est de 1000 et GetProcessTimes() seulement a une précision à la milliseconde, donc pas de précision est perdu retour clock_t au lieu de double, dire.

clock_t AKClock() {
#ifdef WIN32
  FILETIME  ftimeCreate, ftimeExit, ftimeKernel, ftimeUser;
  SYSTEMTIME stimeKernel, stimeUser;

  if ( ! GetProcessTimes( GetCurrentProcess(), &ftimeCreate, &ftimeExit,
                          &ftimeKernel, &ftimeUser )        ||
       ! FileTimeToSystemTime( &ftimeKernel, &stimeKernel ) ||
       ! FileTimeToSystemTime( &ftimeUser,   &stimeUser   )     ) {
      char szError[ 1024 ];
      MyLoggingFunction( "AKClock() failed; returning -1: %s",
                         AKGetLastError( szError, sizeof( szError ) ) );
      return (clock_t) -1.0;
  }

  return (clock_t)
         ( ( stimeKernel.wHour         * 3600.0 +
             stimeKernel.wMinute       *   60.0 +
             stimeKernel.wSecond                +
             stimeKernel.wMilliseconds / 1000.0 +
             stimeUser.wHour           * 3600.0 +
             stimeUser.wMinute         *   60.0 +
             stimeUser.wSecond                  +
             stimeUser.wMilliseconds   / 1000.0   ) * CLOCKS_PER_SEC );
#else
    return clock();
#endif
}

Et pour être complet, voici AKGetLastError():

void AKstrncpy( char *pszDest, const char *pszSrc, const size_t sDest ) {

  strncpy( pszDest, pszSrc, sDest );
  pszDest[ sDest - 1 ] = '
void AKstrncpy( char *pszDest, const char *pszSrc, const size_t sDest ) {
strncpy( pszDest, pszSrc, sDest );
pszDest[ sDest - 1 ] = '\0';
}
char* AKGetLastError( char* szBuf, int iBufSize ) {
DWORD  errorMessageID = GetLastError();
char*  pszError = NULL;
size_t sizeBuf;
if( errorMessageID == 0 ) {
AKstrncpy( szBuf, "(no error)", iBufSize );
return szBuf;
}
sizeBuf = FormatMessageA(
FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM |
FORMAT_MESSAGE_IGNORE_INSERTS,
NULL, errorMessageID, MAKELANGID( LANG_NEUTRAL, SUBLANG_DEFAULT ),
(LPSTR) &pszError, 0, NULL );
AKstrncpy( szBuf, pszError, iBufSize );
LocalFree( pszError );
int iLen = strlen( szBuf );
if ( strcmp( szBuf + iLen - 2, "\r\n" ) == 0 )
szBuf[ iLen - 2 ] = '\0';
return szBuf;
}
';
}

char* AKGetLastError( char* szBuf, int iBufSize ) {

  DWORD  errorMessageID = GetLastError();
  char*  pszError = NULL;
  size_t sizeBuf;

  if( errorMessageID == 0 ) {
      AKstrncpy( szBuf, "(no error)", iBufSize );
      return szBuf;
  }

  sizeBuf = FormatMessageA(
            FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM |
            FORMAT_MESSAGE_IGNORE_INSERTS,
            NULL, errorMessageID, MAKELANGID( LANG_NEUTRAL, SUBLANG_DEFAULT ),
            (LPSTR) &pszError, 0, NULL );

  AKstrncpy( szBuf, pszError, iBufSize );

  LocalFree( pszError );

  int iLen = strlen( szBuf );
  if ( strcmp( szBuf + iLen - 2, "\r\n" ) == 0 )
      szBuf[ iLen - 2 ] = '
void AKstrncpy( char *pszDest, const char *pszSrc, const size_t sDest ) {
strncpy( pszDest, pszSrc, sDest );
pszDest[ sDest - 1 ] = '\0';
}
char* AKGetLastError( char* szBuf, int iBufSize ) {
DWORD  errorMessageID = GetLastError();
char*  pszError = NULL;
size_t sizeBuf;
if( errorMessageID == 0 ) {
AKstrncpy( szBuf, "(no error)", iBufSize );
return szBuf;
}
sizeBuf = FormatMessageA(
FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM |
FORMAT_MESSAGE_IGNORE_INSERTS,
NULL, errorMessageID, MAKELANGID( LANG_NEUTRAL, SUBLANG_DEFAULT ),
(LPSTR) &pszError, 0, NULL );
AKstrncpy( szBuf, pszError, iBufSize );
LocalFree( pszError );
int iLen = strlen( szBuf );
if ( strcmp( szBuf + iLen - 2, "\r\n" ) == 0 )
szBuf[ iLen - 2 ] = '\0';
return szBuf;
}
';

  return szBuf;
}