Comment compiler une application c++ en mode x64 sur une machine Windows 64 bits ?

Question

J'ai installé les outils de la plateforme Windows SDK 7.1, et j'ai ouvert un terminal nommé Microsoft Windows 7 x64 Debug Build Environment . Maintenant, je veux compiler un C++ application (nommée main.cpp ) en utilisant le cl.exe commande. La commande de compilation est :

    cl main.cpp

Ensuite, il sort main.obj y main.exe fichier. Mais quand j'ai essayé d'exécuter main.exe il s'est écrasé après begin computing dist et avant end computing dist. Je pense que je devrais compiler l'application dans x64 programme. Quelqu'un peut-il me donner des conseils ?

El main.cpp est le suivant :

    #include <cstdio>
    #include <cstdlib>
    #ifdef _MSC_VER
    typedef unsigned __int32 uint32_t;
    typedef unsigned __int64 uint64_t;
    #include <intrin.h>
    #include <windows.h>
    #else
    #include <stdint.h>
    #include <sys/time.h>
    #include <unistd.h>
    #endif

    int main(int argc, char **argv) {

    int nTrn = 10;
    int nTst = 10;
    int nDim = 1; // 64 bit
    printf("allocate memory for feats.\n");
    uint64_t *trn_feat = new uint64_t[nTrn]; // nTrn x nDim
    uint64_t *tst_feat = new uint64_t[nTst]; // nTst x nDim

    printf("initialize the feats.\n");
    for(int i=0; i<nTrn; i++)
        trn_feat[i] = (((uint64_t) rand() <<  0) & 0x000000000000FFFFull) | 
                      (((uint64_t) rand() << 16) & 0x00000000FFFF0000ull) | 
                      (((uint64_t) rand() << 32) & 0x0000FFFF00000000ull) |
                      (((uint64_t) rand() << 48) & 0xFFFF000000000000ull);
    for(int i=0; i<nTst; i++)
        tst_feat[i] = (((uint64_t) rand() <<  0) & 0x000000000000FFFFull) | 
                      (((uint64_t) rand() << 16) & 0x00000000FFFF0000ull) | 
                      (((uint64_t) rand() << 32) & 0x0000FFFF00000000ull) |
                      (((uint64_t) rand() << 48) & 0xFFFF000000000000ull);

    printf("allocate memory for dist matrix.\n");
    uint64_t *dist = new uint64_t[nTrn*nTst];

    #ifdef _MSC_VER
    LARGE_INTEGER StartingTime, EndingTime, ElapsedMicroseconds;
    LARGE_INTEGER Frequency;
    QueryPerformanceFrequency(&Frequency);
    QueryPerformanceCounter(&StartingTime);
    #else
    struct timeval start, end;
    long seconds, useconds;
    double mtime;
    gettimeofday(&start, NULL);
    #endif

    printf("begin computing dist.\n");
    for(int iter=0; iter<100; iter++) {
        for(int i=0; i<nTrn; i++) {
             for(int j=0; j<nTst; j++) {
                 uint64_t n = (trn_feat[i] ^ tst_feat[j]);
    #ifdef _MSC_VER
                 dist[i*nTst + j] = __popcnt64(n);
    #else
                 dist[i*nTst + j] = __builtin_popcountll(n);
    #endif
             }     
        }
    }
    printf("end computing dist.\n");

    #ifdef _MSC_VER
    QueryPerformanceCounter(&EndingTime);
    ElapsedMicroseconds.QuadPart = EndingTime.QuadPart - StartingTime.QuadPart;
    ElapsedMicroseconds.QuadPart *= 1000000;
    ElapsedMicroseconds.QuadPart /= Frequency.QuadPart;
    double mtime = (double)ElapsedMicroseconds.QuadPart;
    printf("Average time: %.6f nanoseconds\n", (1e6*mtime)/100/(nTrn*nTst));
    #else
    gettimeofday(&end, NULL);
    seconds = end.tv_sec - start.tv_sec;
    useconds = end.tv_usec - start.tv_usec;
    mtime = ((seconds) * 1000 + useconds/1000.0) + 0.5;
    printf("Total elapsed time: %.6f milliseconds\n", mtime);
    printf("Average time: %.6f nanoseconds\n", (1e6*mtime)/1000/(nTrn*nTst));
    #endif

    delete[] trn_feat;
    delete[] tst_feat;
    delete[] dist;

    }

Answer 1

La réponse possible est la suivante :

1. installer Visual Studio Community 2015
2. Ouvrez le Visual Studio x64 terminal de la Visual Studio Group
3. cl.exe main.cpp /link /machine:x64

Alors un main.exe est émise.

Pour exécuter le main.exe il y a deux conditions nécessaires :

1. La machine ou l'unité centrale peut supporter le __popcnt64 jeu d'instructions. Pour vérifier si la machine le prend en charge, reportez-vous à __cpuid .
2. Le système d'exploitation Windows est de 64 bits.