Quadrotor

////////////////////////////////////////////////////////////////////////////

//    File:        MultiThreadSIFT.cpp

//    Author:      Changchang Wu

//    Description : An example to show how to use SiftGPU in multi-threading

//                  with each thread using different GPU device.

//                  The same idea also applies to SiftMatchGPU.

//

//

//    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::vector;

using std::iostream;

#include <time.h>

#ifdef _WIN32

    #include <windows.h>

    //define this to get dll import definition for win32

    #define SIFTGPU_DLL

    #ifdef _DEBUG 

        #pragma comment(lib, "../../lib/siftgpu_d.lib")

    #else

        #pragma comment(lib, "../../lib/siftgpu.lib")

    #endif

    #define thread_t HANDLE

#else

    #include <stdio.h>

    #include <pthread.h>

    #define thread_t pthread_t

    pthread_mutex_t global_mutex = PTHREAD_MUTEX_INITIALIZER;

#endif

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

class ScopedMutex

{

#ifdef _WIN32

private:

        HANDLE hmutex;

public:

        ScopedMutex(const char* name) {

                hmutex = CreateMutex(NULL, FALSE, name);

                WaitForSingleObject(hmutex, INFINITE);

        }

        ~ScopedMutex()

        {

                ReleaseMutex(hmutex);

                CloseHandle(hmutex);

        }

#else

public:

        ScopedMutex(const char* name) {

        pthread_mutex_lock(&global_mutex);

        }

        ~ScopedMutex()

        {

                pthread_mutex_unlock(&global_mutex);

        }

#endif

};

class MultiThreadSIFT

{

protected:

    SiftGPU*    _sift;

    const void *  _thread_param;

    int         _device_id;

private:

    void Initialize(int device_id)

    {

        ScopedMutex mutex("siftgpu_initialize");

        printf("#%d: Initialize MultiThreadSIFT...", device_id);

        InitializeSIFT();

        printf("done\n");

        //The initialization part should be protected by a mutex in

        //single-process-multi-thread mode. For now many parameters 

        //are still global static variables. 

    }

public:

    MultiThreadSIFT(int device_id = 0, const void* thread_param = NULL)

    {

        _thread_param = thread_param;

        _device_id = device_id;

    }

    virtual ~MultiThreadSIFT()

    {

        if(_sift) delete _sift;

    }

    thread_t RunThread()

    {

#ifdef _WIN32

        return CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)RunMultiThreadSIFT, this, 0, 0);

#else

        thread_t threadid;

        pthread_create(&threadid, NULL, RunMultiThreadSIFT, this);

        return threadid;

#endif

    }

#ifdef _WIN32

    static DWORD

#else

    static void*

#endif

    RunMultiThreadSIFT(void* mts)

    {

        MultiThreadSIFT* mtsift = (MultiThreadSIFT*) mts;

        mtsift->Initialize(mtsift->_device_id); 

        mtsift->RunTask();

        return 0;

    }

public:

    //Two Functions to overload for specific task

    virtual void RunTask()

    {

    }

    //set parameters and initizlze SIFT

    virtual void InitializeSIFT()

    {

        ////////////////////////////

               char device[2] = {'0' + _device_id, '\0'}; //works for 0-9...use sprintf if you have more than 10

        char * argv[] = {"-fo", "-1",  "-v", "0", "-cuda", device};

        //-nogl was previously required, but now default 

        int argc = sizeof(argv)/sizeof(char*);

        /////////////////////////////////////

        _sift = new SiftGPU;

        _sift->ParseParam(argc, argv);

        //create an OpenGL context for computation, and SiftGPU will be initialized automatically 

        if(_sift->CreateContextGL() != SiftGPU::SIFTGPU_FULL_SUPPORTED)                exit(0);

    }

};

//Multi-threading demo. 

//Each thread will load a file, and repeat the processing 100 times.

class MultiThreadDemo: public MultiThreadSIFT

{

public:

    MultiThreadDemo(int deviceid, const char* filename):  MultiThreadSIFT(deviceid, filename)

    {

    }

    virtual void RunTask()

    {

        printf("#%d, running task\n", _device_id);

        time_t t1, t2;

        t1 = time(NULL);

        for(int i = 0; i < 100; ++i) _sift->RunSIFT();

        t2 = time(NULL); 

        printf("#%d: %dhz\n", _device_id, int(100/(t2-t1)));

    }

    virtual void InitializeSIFT()

    {

        MultiThreadSIFT::InitializeSIFT();

        const char* filename = (const char*) _thread_param;

        _sift->RunSIFT(filename);

        //////////////////////////////////////////////////////////////////////

        //WARNING: the image loader (DeviL) used by SiftGPU is not thread-safe. 

        //This demo will put the file loading part in InitializeSIFT, which

        //is protected by a mutex. In your multi-thread application, you should

        //load the image data outside SiftGPU, and specify the memory data to 

        //SiftGPU directly. 

        /////////////////////////////////////////////////////////////////////

    }

};

//Multi-process demo

//Each process will repeat the processing of a file for 100 times.

class MultiProcessDemo: public MultiThreadSIFT

{

public:

    MultiProcessDemo(int deviceid, const char* filename):  MultiThreadSIFT(deviceid, filename)

    {

    }        

    virtual void RunTask()

    {

        char* filename = (char*) _thread_param;

        time_t t1, t2;

        t1 = time(NULL);

        for(int i = 0; i < 100; ++i) _sift->RunSIFT(filename);

        t2 = time(NULL); 

        printf("Speed on device %d : %dhz\n", _device_id, int(100/(t2-t1)));

    }

    virtual void InitializeSIFT()

    {

                //Although the multi-process demo here uses CUDA, 

                //if multiple GPUs are mapped to multiple monitors/displayes

                //it is possible to use OpenGL (not CUDA)for this. 

        //Also, the mutex protection is not necessary

               char device[2] = {'0' + _device_id, '\0'}; //works for 0-9...use sprintf if you have more than 10

        char * argv[] = {"-fo", "-1",  "-v", "0", "-cuda", device};

        int argc = sizeof(argv)/sizeof(char*);

        /////////////////////////////////////

                //create two server with differ socket ports

        _sift = CreateRemoteSiftGPU(7777 + _device_id, NULL);

        _sift->ParseParam(argc, argv);

        //create an OpenGL context for computation, and SiftGPU will be initialized automatically 

        if(_sift->CreateContextGL() != SiftGPU::SIFTGPU_FULL_SUPPORTED)                exit(0);

    }

};

int main()

{

    //NOTE that SiftGPU must be compiled with CUDA for this demo

    MultiThreadDemo thread1(0, "../data/640-1.jpg");

    MultiThreadDemo thread2(1, "../data/800-1.jpg");

        //Use MultiProcessDemo for multi-process mode

    //MultiProcessDemo thread1(0, "../data/640-1.jpg");

    //MultiProcessDemo thread2(1, "../data/800-1.jpg");

    printf("Starting two threads...\n");

    thread_t t1 = thread1.RunThread();

    thread_t t2 = thread2.RunThread();

#ifdef _WIN32

    HANDLE handles[2] = {t1, t2};

    WaitForMultipleObjects(2, handles, TRUE, INFINITE); 

    ////////////////////////////////////////////////////////////////

    CloseHandle(t1); 

    CloseHandle(t2);

#else   

    pthread_join(t1, NULL);

    pthread_join(t2, NULL);

#endif

    return 1;

}