speed.cpp

Go to the documentation of this file.

//      File:           Speed.cpp
//      Author:         Changchang Wu
//      Description : Evaluate the speed of SiftGPU 
//
//
//
//      Copyright (c) 2007 University of North Carolina at Chapel Hill
//      All Rights Reserved
//
//      Permission to use, copy, modify and distribute this software and its
//      documentation for educational, research and non-profit purposes, without
//      fee, and without a written agreement is hereby granted, provided that the
//      above copyright notice and the following paragraph appear in all copies.
//      
//      The University of North Carolina at Chapel Hill make no representations
//      about the suitability of this software for any purpose. It is provided
//      'as is' without express or implied warranty. 
//
//      Please send BUG REPORTS to ccwu@cs.unc.edu
//


#include <stdlib.h>
#include <vector>
#include <iostream>
using std::cout;

#ifdef _WIN32
        //dll import definition for win32
        #define SIFTGPU_DLL
#endif

//for windows, the default timing uses timeGetTime, you can define TIMING_BY_CLOCK to use clock()
//for other os, the default timing uses gettimeofday, you can define TIMING_BY_CLOCK to use clock()

#if defined(_WIN32)
        #if defined(TIMING_BY_CLOCK)
                #include <time.h>
        #else
                #define WIN32_LEAN_AND_MEAN
                #include <windows.h>
                #include <mmsystem.h>
                #pragma comment(lib, "winmm.lib")
        #endif
#else
        #if defined(TIMING_BY_CLOCK)
                #include <time.h>
        #else
                #include <sys/time.h>
        #endif
#endif


#include "../SiftGPU/SiftGPU.h"

//define the marcro bellow to reload image file everytime
//#define INCLUDE_DISK_READING_TIME

//define the macro below to test speed of multi-process mode
//#define TEST_MULTI_PROCESS_SIFTGPU



#define SIFTGPU_REPEAT 30

// you should specify the input image and the sift parameter to speed.exe
// for example: speed.exe -i 600.pgm  -fo -1
// to test CUDA, you first need to recompile SiftGPU with CUDA capability

int GetMilliSecond(); 

int main(int argc, char * argv[])
{
#ifndef TEST_MULTI_PROCESS_SIFTGPU
        SiftGPU sift;
#else
        ComboSiftGPU* combo = CreateRemoteSiftGPU();
        SiftGPU& sift = (*combo);
#endif
        int num;
        float timing[10], time_all =0, time_start;

        //Parse parameters
        sift.ParseParam(argc - 1, argv + 1);
        sift.SetVerbose(0); 

        std::cout<<"Initialize and warm up...\n";
        //create an OpenGL context for computation
        if(sift.CreateContextGL() ==0) return 0;
        
        if(sift.RunSIFT()==0)   return 0;

        //image is loaded for only once for this experiment
#ifndef TEST_MULTI_PROCESS_SIFTGPU
        std::cout<<"Loading image: " << sift._timing[0]*1000 << "ms, "
                 <<"Tex initialization: "<<sift._timing[1]*1000 << "ms\n\n"
                 <<"Start 2x"<<SIFTGPU_REPEAT<<" repetitions...\n";
#ifdef INCLUDE_DISK_READING_TIME
    char imagepath[MAX_PATH];
    strcpy(imagepath, sift.GetCurrentImagePath()); 
#endif
#endif

        //run one more time to get all texture allocated

        sift.RunSIFT();
        num = sift.GetFeatureNum();


        //use no message output mode to get maximum speed.
        time_start = (float) GetMilliSecond();
        for(int i = 0; i < SIFTGPU_REPEAT; i++)
        {
#ifdef INCLUDE_DISK_READING_TIME
        sift.RunSIFT(imagepath);
#else
                sift.RunSIFT();
#endif
                std::cout <<"+";
        }
        time_all = ((float)GetMilliSecond() - time_start)/1000/SIFTGPU_REPEAT;
        std::cout<<"\n"; 

        //change the timing setting, so that we can get more accurate timing for each steps
        //in this mode, the overal speed will be decreased.
        sift.SetVerbose(-2); //little trick to disable all output but keep the timing
        std::fill(timing, timing + 10, 0.0f);
        for(int k = 0; k < SIFTGPU_REPEAT; k++)
        {
#ifdef INCLUDE_DISK_READING_TIME
        sift.RunSIFT(imagepath);
#else
                sift.RunSIFT();
#endif
                for(int j = 0; j < 10; j++)             timing[j] += sift._timing[j];
                std::cout <<"#";
        }
        for(int j = 0; j < 10; j++)     timing[j] /= SIFTGPU_REPEAT;

        std::cout
                <<"\n\n****************************************\n"
                <<"[Feature Count]:\t" << num << "\n"
                <<"[Average Time]:\t\t" << time_all * 1000.0f << "ms\n"
                <<"[Average Speed]:\t" << 1.0 / time_all << "hz\n"
#ifndef TEST_MULTI_PROCESS_SIFTGPU
#ifdef INCLUDE_DISK_READING_TIME
                <<"[Load Image File]:\t" << timing[0] * 1000.0f << "ms\n"
#endif
                <<"[Build Pyramid]:\t" << timing[2] * 1000.0f << "ms\n"
                <<"[Detection]:\t\t" << timing[3] * 1000.0f << "ms\n"
                <<"[Feature List]:\t\t" << timing[4] * 1000.0f << "ms\n"
                <<"[Orientation]:\t\t" << timing[5] * 1000.0f << "ms\n"
                <<"[MO Feature List]:\t" << timing[6] * 1000.0f << "ms\n"
                <<"[Download Keys]:\t" << timing[7] * 1000.0f << "ms\n"
                <<"[Descriptor]:\t\t" << timing[8] * 1000.0f << "ms\n"
#endif
                <<"****************************************\n";

#ifdef TEST_MULTI_PROCESS_SIFTGPU
        delete combo;
#endif
        return 0;
}



int GetMilliSecond()
{
#if defined(TIMING_BY_CLOCK)
        return clock() * 1000 / CLOCKS_PER_SEC;
#elif defined(_WIN32)
        static int  started = 0;
        static int      tstart;
        //the resolution of teimGetTime will be changed to 1ms inside SiftGPU
        if(started == 0)
        {
                tstart = timeGetTime();
                started = 1;
                return 0;
        }else
        {
                return timeGetTime() - tstart;
        }
#else
        static int    started = 0;
        static struct timeval tstart;
        if(started == 0) 
        {
                gettimeofday(&tstart, NULL);
                started = 1;
                return 0;
        }else
        {       
                struct timeval now;
                gettimeofday(&now, NULL) ;
                return (now.tv_usec - tstart.tv_usec + (now.tv_sec - tstart.tv_sec) * 1000000)/1000;
        }
#endif
}