¿Alguien ha instalado con éxito CUDA 7.5 en Ubuntu 14.04.3 LTS x86_64?

12

Mi estación de trabajo tiene dos GPU (Quadro K5200 y Quadro K2200) con el último controlador NVIDIA instalado (Versión: 352.41). Después de descargar el archivo cuda-repo-ubuntu1404-7-5-local_7.5-18_amd64.debde Descargas de CUDA 7.5 , intento instalarlo, pero el resultado es el siguiente:

root@P700-Bruce:/home/bruce/Downloads# sudo apt-get install cuda
Reading package lists... Done
Building dependency tree       
Reading state information... Done
Some packages could not be installed. This may mean that you have
requested an impossible situation or if you are using the unstable
distribution that some required packages have not yet been created
or been moved out of Incoming.
The following information may help to resolve the situation:

The following packages have unmet dependencies:
 cuda : Depends: cuda-7-5 (= 7.5-18) but it is not going to be installed
 unity-control-center : Depends: libcheese-gtk23 (>= 3.4.0) but it is not going to be installed
                        Depends: libcheese7 (>= 3.0.1) but it is not going to be installed
E: Error, pkgProblemResolver::Resolve generated breaks, this may be caused by held packages.

He intentado la solución:

  1. sudo apt-get remove nvidia-cuda-* # eliminar viejos paquetes de nvidia-cuda
  2. Instalar dependencias insatisfechas:

    root@P700-Bruce:/home/bruce/Downloads# apt-get install cuda-7-5
    Reading package lists... Done
    Building dependency tree       
    Reading state information... Done
    Some packages could not be installed. This may mean that you have
    requested an impossible situation or if you are using the unstable
    distribution that some required packages have not yet been created
    or been moved out of Incoming.
    The following information may help to resolve the situation:
    
    The following packages have unmet dependencies:
     cuda-7-5 : Depends: cuda-toolkit-7-5 (= 7.5-18) but it is not going to be installed
                Depends: cuda-runtime-7-5 (= 7.5-18) but it is not going to be installed
     unity-control-center : Depends: libcheese-gtk23 (>= 3.4.0) but it is not going to be installed
                            Depends: libcheese7 (>= 3.0.1) but it is not going to be installed
    E: Error, pkgProblemResolver::Resolve generated breaks, this may be caused by held packages.
    
    root@P700-Bruce:/home/bruce/Downloads# apt-get install cuda-toolkit-7-5
    Reading package lists... Done
    Building dependency tree       
    Reading state information... Done
    Some packages could not be installed. This may mean that you have
    requested an impossible situation or if you are using the unstable
    distribution that some required packages have not yet been created
    or been moved out of Incoming.
    The following information may help to resolve the situation:
    
    The following packages have unmet dependencies:
     cuda-toolkit-7-5 : Depends: cuda-core-7-5 (= 7.5-18) but it is not going to be installed
                        Depends: cuda-command-line-tools-7-5 (= 7.5-18) but it is not going to be installed
                        Depends: cuda-samples-7-5 (= 7.5-18) but it is not going to be installed
                        Depends: cuda-documentation-7-5 (= 7.5-18) but it is not going to be installed
                        Depends: cuda-visual-tools-7-5 (= 7.5-18) but it is not going to be installed
     unity-control-center : Depends: libcheese-gtk23 (>= 3.4.0) but it is not going to be installed
                            Depends: libcheese7 (>= 3.0.1) but it is not going to be installed
    E: Error, pkgProblemResolver::Resolve generated breaks, this may be caused by held packages.
    
  3. Instalar y usar aptitude

Mi sistema operativo Ubuntu14.04 acaba de instalarse y realicé las actualizaciones de software e instalé el último controlador de Nvidia.

¿Me puedes ayudar? ¡Gracias por adelantado!

Bruce Yo
fuente

Respuestas:

8

La instalación de CUDA es un poco complicada. He seguido los siguientes pasos y me funciona. Puede consultar este enlace también.

Confirmación del medio ambiente:

  1. lspci | grep -i nvidia (Confirme que se muestra la información de la placa de NVIDIA)

  2. uname -m (asegúrese de que sea un x86_64)

  3. gcc --version (asegúrese de que esté instalado)

Instalación de CUDA -

  1. Descargue el cuda_7.5.18_linux.runarchivo desde https://developer.nvidia.com/cuda-downloads

  2. Ejecute los siguientes comandos:

    sudo apt-get install build-essential
    echo blacklist nouveau option nouveau modeset=0 |sudo tee -a /etc/modprobe.d/blacklist-nouveau.conf 
    sudo update-initramfs -u
    
  3. Reiniciar la computadora

  4. En la pantalla de inicio de sesión, presione Ctrl+ Alt+ F1e inicie sesión con su usuario.

  5. Vaya al directorio donde tiene el controlador CUDA y ejecute

    chmod a+x .
    sudo service lightdm stop
    sudo bash cuda-7.5.18_linux.run --no-opengl-libs
    
  6. Durante la instalación:

    • Aceptar condiciones de EULA
    • Di SÍ para instalar el controlador NVIDIA
    • Diga SÍ a la instalación de CUDA Toolkit + Driver
    • Diga SÍ a la instalación de muestras de CUDA
    • Di NO al reconstruir las configuraciones de Xserver con Nvidia
  7. Comprueba si /dev/nvidia*existen archivos. Si no lo hacen, haga lo siguiente

    sudo modprobe nvidia
    
  8. Establecer variables de ruta de entorno

    export PATH=/usr/local/cuda-7.5/bin:$PATH
    export LD_LIBRARY_PATH=/usr/local/cuda-7.5/lib64:$LD_LIBRARY_PATH
    
  9. Verifique la versión del controlador

    cat /proc/driver/nvidia/version`
    
  10. Verifique la versión del controlador CUDA

    nvcc –V
    
  11. Encienda nuevamente el lightdm

    sudo service lightdm start
    
  12. Ctrl+ Alt+ F7e inicie sesión en el sistema a través de la GUI

  13. Cree muestras de CUDA, vaya a la NVIDIA_CUDA-7.5_Samplescarpeta a través del terminal, luego ejecute el siguiente comando:

    make
    cd bin/x86_64/linux/release/
    ./deviceQuery
    ./bandwidthTest
    

    Ambas pruebas deberían generar un 'PASS' en la terminal

  14. Reiniciar el sistema

Avik
fuente
¡Muchas gracias! Esto finalmente funciona en mi Asus UX32VD (computadora portátil Optimus con GeForce 620M). Intenté todo y todo. Ayer pude conseguir que nvidia-352 funcionara con Bumblebee, pero después de instalar el kit de herramientas CUDA, no pude ejecutar ninguna de las muestras (como si no tuviera una tarjeta CUDA, y sí, la estaba usando optirun). ¡Otros controladores me generaron bucles de inicio de sesión o negro unity-greeter! No puedo agradecerles lo suficiente
:)
Lo único que tenía que cambiar aquí fue a partir optionde optionsdentro de la sección nouveau lista negra.
TheM00s3
Tengo una computadora de escritorio HP con NVIDIA GeForce GTX 680. Sus instrucciones funcionaron principalmente, excepto que el controlador de la tarjeta gráfica que viene con el archivo de ejecución ( cuda_7.5.18_linux.run) hace lightdmque deje de funcionar después de reiniciar (después de grub, verá una pantalla en negro con un cursor intermitente interminable ) Mi solución fue desinstalar primero ese controlador sudo apt-get purge nvidia-*e instalarlo utilizando el último archivo ejecutado descargado del sitio web oficial de NVIDIA. Y funciona perfectamente. Una solución alternativa sería algo como la solución (A) en askubuntu.com/a/676772/194156
Xin
2

Hay dos formas de instalar el controlador CUDA adecuado (para Optimus y otros conjuntos de chips gráficos integrados en placas base híbridas): la primera descrita aquí es la más fácil y la segunda descripción es más engorrosa pero efectiva también:

UN)

sudo add-apt-repository ppa:graphics-drivers/ppa
sudo apt-get update
sudo apt-get install nvidia-355 nvidia-prime
sudo reboot

SI)

La descripción del método B está aquí, pero ya es más antigua (explicado por el usuario dschinn1001): este método B es más humilde y puede ser arriesgado, pero no dañino. :

¿Cómo puedo instalar Nvidia Driver GT 520 y Cuda 5.0 en Ubuntu13.04?

El paquete de controladores beta para que Nvidia se descargue para Linux está aquí:

http://www.nvidia.de/object/cuda_1_1_beta.html

El método A es más simple, pero no está claro, cómo interactúa con xscreensaver y el método B es más antiguo, pero el paquete de controladores también se actualiza en los últimos tiempos, y una vez que se realiza el método B, debería funcionar mejor con xscreensaver condicionado que xscreensaver está instalado (Probé el método B en 13.10 y funcionó muy bien, incluso con xscreensaver. Y creo que el resto de este hilo depende del hardware).

Además y en referencia al abejorro con los conjuntos de chips Optimus-graphics, estos ajustes para el abejorro también son necesarios:

Cómo configurar nVidia Optimus / Bumblebee en 14.04

dschinn1001
fuente
1

Suena como lp bug 1428972 .

El usuario fennytansy agregó una solución alternativa en el comentario # 10 :

sudo apt-get install libglew-dev libcheese7 libcheese-gtk23 libclutter-gst-2.0-0 libcogl15 libclutter-gtk-1.0-0 libclutter-1.0-0

usuario3813819
fuente
después de ejecutar la pantalla de comando se volvió negra. solo puedo acceder a tty1? ¿Conoces alguna otra solución?
Karesh Arunakirinathan
1

Instalé con éxito CUDA usando el método runfile. Es un poco más complicado de configurar porque su controlador de gráficos principal también debe instalarse utilizando el método runfile ( consulte aquí ).

Intente instalar solo el controlador. Esto se puede hacer utilizando el método runfile. Le indicará cada parte de la instalación y puede deshabilitar las GLbibliotecas y los kits de herramientas. El centro de control de la unidad también me ha estado dando problemas debido a la necesidad de la muestra de CUDA de usar en libGLU.solugar de libGL.so. Esta es una solución fácil al crear sus propios ejemplos de aprendizaje.

asdf
fuente
1

Intente desinstalar el controlador nvidia e instalar directamente cuda sin él. En un Ubuntu 14.04 nuevo, seguí las instrucciones del sitio web de nvidia . Además de verificar versiones compatibles de cosas (gcc, kernel), las instrucciones fueron:

sudo dpkg -i cuda-repo-ubuntu1404_7.5-18_amd64.deb 
sudo apt-get update
sudo apt-get install cuda 

Afortunadamente, se instaló el controlador nvidia correcto como subproducto de los pasos anteriores.

mlysy
fuente
1

Pasé un día completo buscando usar " ppa: graphics-drivers / ppa " para actualizar los controladores de NVIDIA a la versión 352. Todo falló. Después de una instalación, gpu-manager.log informó que los controladores se instalaron mientras que Xorg.0.log informaría lo contrario.

El controlador nouveau había sido eliminado y puesto en la lista negra: sudo apt-get --purge remove xserver-xorg-video-nouveau cat /etc/modprobe.d/nouveau-nomodeset-jsrobin.conf blacklist nouveau options nouveau modeset = 0 alias nouveau off alias lbm-nouveau fuera

Finalmente me di por vencido y usé una solución puramente "NVIDIA ... bin".

  1. Nouveau en la lista negra, como se muestra arriba.
  2. desinstaló completamente el nouveau Xserver como se citó anteriormente.
  3. Configure la BIOS del sistema para que tenga PCIe (las dos tarjetas nvidia) como principal y desactive la interfaz HD4600 de la placa base.
  4. arrancado en modo de recuperación, red activada, luego fue al modo de consola.
  5. Ejecutó "NVIDIA-Linux-x86_64-352.41.run -uninstall" solo para asegurarse de que no quedara nada.
  6. Se eliminó cualquier directorio antiguo en / etc, / usr / local, que parecía un remanente de instalaciones anteriores de cuda o nvidia.
  7. Ejecutó "NVIDIA-Linux-x86_64-352.41.run"
  8. Ejecutó "NVIDIA-Linux-x86_64-352.41.run --check" para verificar que todo estaba correcto (estaba).
  9. Luego ejecutó "cuda_7.5.18_linux.run" para completar la instalación. Las cosas están funcionando actualmente. Ambos monitores están en funcionamiento. Actualmente trabajando en la construcción de los archivos de muestra de Cuda. Asegúrese de utilizar los indicadores "--help" en los contenedores de instalación de NVIDIA. La razón principal por la que decidí ir a la ruta bin (junto con una de las alternativas que no funciona, es que el enfoque "bin" proporciona una ruta fácil para la recuperación después de una actualización OpenGL "mesa". El resultado
usuario225932
fuente
1

Reinicié Ubuntu hoy, y descubrí que hay otra dependencia insatisfecha como libcog15 : Depends: mesa-driver...(no recuerdo el nombre completo del paquete), así que solía apt-get installinstalar el "controlador de mesa". Después de eso, CUDA 7.5 se instaló con éxito.

Tenga en cuenta que mi versión de Kernel es 3.19.0-28-generic y la versión de gcc es Ubuntu 4.8.4-2ubuntu1 ~ 14.04 , que no se encuentra en los documentos oficiales de CUDA 7.5 . Comprobaré si realmente funciona.

Bruce Yo
fuente
1
Por alguna razón, el controlador de mesa en mi computadora causó todo tipo de problemas de unidad al arrancar y causó una falla total de mi sistema. Ten cuidado.
asdf
@Bruce Yo: en general, esto no es solo una cuestión de mesa, sino que depende de los conjuntos de chips de las tarjetas gráficas híbridas nvidia, que son todas diferentes. Deberías considerar mi solución también. : o)
dschinn1001
0

Intenté sudo su y apt-get install cuda en lugar de sudo apt-get install cuda. Funcionó.

 sudo dpkg -i cuda-repo-ubuntu1404_7.5-18_amd64.deb
 sudo apt-get update
 sudo su
 apt-get install cuda
softgearko
fuente
Bienvenido a Ask Ubuntu, me alegro de verte compartiendo conocimientos. Sin embargo, este no es un foro, es un sitio de preguntas y respuestas, consulte este recorrido de ayuda . Duplicar la respuesta de otros (del usuario 661266) no ayuda, podrás votar cuando obtengas suficiente reputación.
user.dz
@Sneetsher Gracias por tu comentario. Intenté 661266 la respuesta del usuario pero no funcionó. Cuando usé "su" en lugar de "sudo", funcionó. No sé por qué exactamente. Sin embargo, funcionó con mi juicio. Creo que vale la pena que alguien pruebe mi solución.
softgearko
0

Consulte: https://github.com/astorfi/Caffe_Deep_Learning/blob/master/Installation/readme.md . Está relacionado con la instalación de Caffe en esencia, pero también aborda la instalación de CUDA.

amirsina torfi
fuente
1
Hola @amirsani_torfi, bienvenido a ask.ubuntu. Tenga en cuenta que, si bien es posible que su enlace proporcione la información necesaria para abordar la pregunta, los enlaces se pueden eliminar en cualquier momento. Sugeriría que en su lugar edite su pregunta para incluir la información importante de ese enlace.
Tshilidzi Mudau
-1

-problemas con inicio de sesión lightdm (bucle de inicio de sesión)

-problemas con el controlador istall ("Error de instalación del controlador: parece que se está ejecutando un servidor X ...")

Para instalar con éxito un kit de herramientas NVidia CUDA en Ubuntu 16.04 de 64 bits, solo tuve que hacer:

  1. cree una imagen en vivo de Ubuntu en pendrive (un lápiz de 8GB es suficiente): ¡tal intento le ahorrará una tonelada de nervios , antes de una instalación fallida en su sistema Linux host!
  2. iniciar sesión en la sesión en vivo en pendrive ("Pruebe Ubuntu, antes de instalar")
  3. agregar usuario de sudo en sesión en vivo:

    sudo adduser admin (#pass: admin1)

    sudo usermod -aG sudo admin

  4. cerrar sesión de sesión en vivo, iniciar sesión como #admin

  5. descargue CUDA Toolkit del sitio oficial de NVidia (~ 1.5GB)
  6. cambiar los privilegios para el archivo de instalación descargado (¡NO INSTALE EN ESTE PASO!):
    sudo chmod + x cuda_X.X.run

  7. cambiar a la vista de consola:

    Ctr + Alt + F1 (para activar la vista de terminal) Ctr + Alt + F7 (para cambiar de la vista de terminal al servidor gráfico)

  8. en la vista de consola (Ctr + Alt + F1) inicie sesión:

    inicio de sesión: admin pass: admin1

  9. detener el servicio de ejecución gráfica:

    sudo service lightdm stop

  10. compruebe si el servidor gráfico está apagado: después de cambiar Ctr + Alt + F7 el monitor debe estar en blanco negro, vuelva a activar la vista de consola Ctr + Alt + F1

  11. instale CUDA Toolkit, con dicha configuración:

    sudo ./cuda_X.X.run (presione 'q' para omitir la lectura de la licencia) no instale la biblioteca OpenGL no actualice la configuración del sistema X otras opciones hacen yes y rutas por defecto

  12. encienda el servidor gráfico:

    servicio sudo lightdm start

  13. inicie sesión como usuario (si inicia sesión automáticamente como #ubuntu en la sesión en vivo, cierre sesión):

    inicio de sesión: admin pass: admin1

  14. verifique cualquier compilador nvcc que funcione con la suma simple de vectores paralelos proporcionada en los bloques GPU

    guarde vecSum.cu y book.h en archivos nuevos, compile y ejecute en la terminal: /usr/local/cuda-8.0/bin/nvcc vecSum.cu && clear && ./a.out

  15. compruebe la impresión de la consola: debe ser similar a: 0.000000 + 0.000000 = 0.000000

    -1.100000 + 0.630000 = -0.000000
    
    -2.200000 + 2.520000 = 0.319985
    
    -3.300000 + 5.670000 = 2.119756
    -4.400000 + 10.080000 = 5.679756
    -5.500000 + 15.750000 = 10.250000
    -6.600000 + 22.680000 = 16.017500
    -7.700000 + 30.870001 = 23.170002
    -8.800000 + 40.320000 = 31.519997
    -9.900000 + 51.029999 = 41.129967
    
  16. si todo salió bien en la sesión en vivo de pendrive, haz lo mismo en tu sistema Linux

PD: Tenga en cuenta que no es un tutorial ideal, ¡pero funciona bien para mí!

======= vecSum.cu =====

#include "book.h"
#define N 50000
///usr/local/cuda-8.0/bin/nvcc vecSum.cu && clear && ./a.out

//"HOST" = CPU
//"Device" = GPU

__global__ void add( float *a, float *b, float *c )
{
    int tid = blockIdx.x;
    if ( tid < N )
        c[ tid ] = a[ tid ] + b[ tid ];
}

int main ( void )
{
    float a[ N ], b[ N ], c[ N ];
    float *dev_a, *dev_b, *dev_c;
    //GPU memory allocation
    HANDLE_ERROR( cudaMalloc( ( void** )&dev_a, N * sizeof( float ) ) );
    HANDLE_ERROR( cudaMalloc( ( void** )&dev_b, N * sizeof( float ) ) );
    HANDLE_ERROR( cudaMalloc( ( void** )&dev_c, N * sizeof( float ) ) );

    //sample input vectors CPU generation
    for ( int i = 0; i < N; i++ )
    {
        a[ i ] = -i * 1.1;
        b[ i ] = i * i * 0.63;
    }

    //copy/load from CPU to GPU data vectors a[], b[] HostToDevice
    HANDLE_ERROR( cudaMemcpy( dev_a, a, N * sizeof( float ), cudaMemcpyHostToDevice ) );
    HANDLE_ERROR( cudaMemcpy( dev_b, b, N * sizeof( float ), cudaMemcpyHostToDevice ) );

    //calculate sum of vectors on GPU
    add<<<N,1>>> ( dev_a, dev_b, dev_c );

    //copy/load result vector from GPU to CPU c[] DeviceToHost
    HANDLE_ERROR( cudaMemcpy( c, dev_c, N * sizeof( float ), cudaMemcpyDeviceToHost ) );

    //printout results
    for ( int i = 0; i < 10; i++ ) printf( "%f + %f = %f\n", a[ i ], b[ i ], c[ i ] );

    //free memory and constructed objects on GPU
    cudaFree( dev_a );
    cudaFree( dev_b );
    cudaFree( dev_c );

    return 0;
}

========= book.h ======

/*
 * Copyright 1993-2010 NVIDIA Corporation.  All rights reserved.
 *
 * NVIDIA Corporation and its licensors retain all intellectual property and
 * proprietary rights in and to this software and related documentation.
 * Any use, reproduction, disclosure, or distribution of this software
 * and related documentation without an express license agreement from
 * NVIDIA Corporation is strictly prohibited.
 *
 * Please refer to the applicable NVIDIA end user license agreement (EULA)
 * associated with this source code for terms and conditions that govern
 * your use of this NVIDIA software.
 *
 */


#ifndef __BOOK_H__
#define __BOOK_H__
#include <stdio.h>

static void HandleError( cudaError_t err,
                         const char *file,
                         int line ) {
    if (err != cudaSuccess) {
        printf( "%s in %s at line %d\n", cudaGetErrorString( err ),
                file, line );
        exit( EXIT_FAILURE );
    }
}
#define HANDLE_ERROR( err ) (HandleError( err, __FILE__, __LINE__ ))


#define HANDLE_NULL( a ) {if (a == NULL) { \
                            printf( "Host memory failed in %s at line %d\n", \
                                    __FILE__, __LINE__ ); \
                            exit( EXIT_FAILURE );}}

template< typename T >
void swap( T& a, T& b ) {
    T t = a;
    a = b;
    b = t;
}


void* big_random_block( int size ) {
    unsigned char *data = (unsigned char*)malloc( size );
    HANDLE_NULL( data );
    for (int i=0; i<size; i++)
        data[i] = rand();

    return data;
}

int* big_random_block_int( int size ) {
    int *data = (int*)malloc( size * sizeof(int) );
    HANDLE_NULL( data );
    for (int i=0; i<size; i++)
        data[i] = rand();

    return data;
}


// a place for common kernels - starts here

__device__ unsigned char value( float n1, float n2, int hue ) {
    if (hue > 360)      hue -= 360;
    else if (hue < 0)   hue += 360;

    if (hue < 60)
        return (unsigned char)(255 * (n1 + (n2-n1)*hue/60));
    if (hue < 180)
        return (unsigned char)(255 * n2);
    if (hue < 240)
        return (unsigned char)(255 * (n1 + (n2-n1)*(240-hue)/60));
    return (unsigned char)(255 * n1);
}

__global__ void float_to_color( unsigned char *optr,
                              const float *outSrc ) {
    // map from threadIdx/BlockIdx to pixel position
    int x = threadIdx.x + blockIdx.x * blockDim.x;
    int y = threadIdx.y + blockIdx.y * blockDim.y;
    int offset = x + y * blockDim.x * gridDim.x;

    float l = outSrc[offset];
    float s = 1;
    int h = (180 + (int)(360.0f * outSrc[offset])) % 360;
    float m1, m2;

    if (l <= 0.5f)
        m2 = l * (1 + s);
    else
        m2 = l + s - l * s;
    m1 = 2 * l - m2;

    optr[offset*4 + 0] = value( m1, m2, h+120 );
    optr[offset*4 + 1] = value( m1, m2, h );
    optr[offset*4 + 2] = value( m1, m2, h -120 );
    optr[offset*4 + 3] = 255;
}

__global__ void float_to_color( uchar4 *optr,
                              const float *outSrc ) {
    // map from threadIdx/BlockIdx to pixel position
    int x = threadIdx.x + blockIdx.x * blockDim.x;
    int y = threadIdx.y + blockIdx.y * blockDim.y;
    int offset = x + y * blockDim.x * gridDim.x;

    float l = outSrc[offset];
    float s = 1;
    int h = (180 + (int)(360.0f * outSrc[offset])) % 360;
    float m1, m2;

    if (l <= 0.5f)
        m2 = l * (1 + s);
    else
        m2 = l + s - l * s;
    m1 = 2 * l - m2;

    optr[offset].x = value( m1, m2, h+120 );
    optr[offset].y = value( m1, m2, h );
    optr[offset].z = value( m1, m2, h -120 );
    optr[offset].w = 255;
}


#if _WIN32
    //Windows threads.
    #include <windows.h>

    typedef HANDLE CUTThread;
    typedef unsigned (WINAPI *CUT_THREADROUTINE)(void *);

    #define CUT_THREADPROC unsigned WINAPI
    #define  CUT_THREADEND return 0

#else
    //POSIX threads.
    #include <pthread.h>

    typedef pthread_t CUTThread;
    typedef void *(*CUT_THREADROUTINE)(void *);

    #define CUT_THREADPROC void
    #define  CUT_THREADEND
#endif

//Create thread.
CUTThread start_thread( CUT_THREADROUTINE, void *data );

//Wait for thread to finish.
void end_thread( CUTThread thread );

//Destroy thread.
void destroy_thread( CUTThread thread );

//Wait for multiple threads.
void wait_for_threads( const CUTThread *threads, int num );

#if _WIN32
    //Create thread
    CUTThread start_thread(CUT_THREADROUTINE func, void *data){
        return CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)func, data, 0, NULL);
    }

    //Wait for thread to finish
    void end_thread(CUTThread thread){
        WaitForSingleObject(thread, INFINITE);
        CloseHandle(thread);
    }

    //Destroy thread
    void destroy_thread( CUTThread thread ){
        TerminateThread(thread, 0);
        CloseHandle(thread);
    }

    //Wait for multiple threads
    void wait_for_threads(const CUTThread * threads, int num){
        WaitForMultipleObjects(num, threads, true, INFINITE);

        for(int i = 0; i < num; i++)
            CloseHandle(threads[i]);
    }

#else
    //Create thread
    CUTThread start_thread(CUT_THREADROUTINE func, void * data){
        pthread_t thread;
        pthread_create(&thread, NULL, func, data);
        return thread;
    }

    //Wait for thread to finish
    void end_thread(CUTThread thread){
        pthread_join(thread, NULL);
    }

    //Destroy thread
    void destroy_thread( CUTThread thread ){
        pthread_cancel(thread);
    }

    //Wait for multiple threads
    void wait_for_threads(const CUTThread * threads, int num){
        for(int i = 0; i < num; i++)
            end_thread( threads[i] );
    }

#endif




#endif  // __BOOK_H__
Piotr Lenarczyk
fuente