Auf meiner Workstation sind zwei GPUs (Quadro K5200 und Quadro K2200) mit dem neuesten NVIDIA-Treiber installiert (Version: 352.41). Nachdem ich die Datei cuda-repo-ubuntu1404-7-5-local_7.5-18_amd64.debvon CUDA 7.5 Downloads heruntergeladen habe , versuche ich sie zu installieren, aber das Ergebnis ist wie folgt:

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.

Ich habe die Lösung ausprobiert:

1. sudo apt-get remove nvidia-cuda-* # Alte nvidia-cuda-Pakete entfernen

2. Installieren Sie nicht erfüllte Abhängigkeiten:

   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. Installieren und verwenden Sie aptitude

Mein Ubuntu14.04-Betriebssystem ist gerade installiert und hat die Software-Updates vorgenommen und den neuesten Nvidia-Treiber installiert.

Können Sie uns helfen? Danke im Voraus!

Die Installation von CUDA ist etwas knifflig. Ich habe die folgenden Schritte befolgt und es funktioniert für mich. Sie können auch auf diesen Link verweisen .

Bestätigung der Umgebung:

1. lspci | grep -i nvidia (Vergewissern Sie sich, dass die Informationen der NVIDIA-Karte angezeigt werden.)

2. uname -m (stellen Sie sicher, dass es ein x86_64 ist)

3. gcc --version (stellen Sie sicher, dass es installiert ist)

Installation von CUDA -

1. Laden Sie die cuda_7.5.18_linux.runDatei von https://developer.nvidia.com/cuda-downloads herunter

2. Führen Sie die folgenden Befehle aus:

   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. Computer neu starten

4. Drücken Sie im Anmeldebildschirm Ctrl+ Alt+ F1und melden Sie sich bei Ihrem Benutzer an.

5. Wechseln Sie in das Verzeichnis, in dem Sie den CUDA-Treiber haben, und führen Sie ihn aus

   chmod a+x .
   sudo service lightdm stop
   sudo bash cuda-7.5.18_linux.run --no-opengl-libs
   

6. Während der Installation:

   • Akzeptieren Sie die EULA-Bedingungen
   • Sagen Sie JA, um den NVIDIA-Treiber zu installieren
   • Sagen Sie JA, um CUDA Toolkit + Driver zu installieren
   • Sagen Sie JA, um CUDA-Beispiele zu installieren
   • Sagen Sie NEIN, wenn Sie Xserver-Konfigurationen mit Nvidia neu erstellen möchten

7. Überprüfen Sie, ob /dev/nvidia*Dateien vorhanden sind. Wenn dies nicht der Fall ist, gehen Sie wie folgt vor

   sudo modprobe nvidia
   

8. Legen Sie Umgebungspfadvariablen fest

   export PATH=/usr/local/cuda-7.5/bin:$PATH
   export LD_LIBRARY_PATH=/usr/local/cuda-7.5/lib64:$LD_LIBRARY_PATH
   

9. Überprüfen Sie die Treiberversion

   cat /proc/driver/nvidia/version`
   

10. Überprüfen Sie die CUDA-Treiberversion

    nvcc –V
    

11. Schalten Sie das Licht wieder ein

    sudo service lightdm start
    

12. Ctrl+ Alt+ F7Und Anmeldung an das System über GUI

13. Erstellen Sie CUDA-Beispiele, gehen Sie NVIDIA_CUDA-7.5_Samplesüber das Terminal zum Ordner und führen Sie den folgenden Befehl aus:

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

    Beide Tests sollten letztendlich ein 'PASS' im Terminal ausgeben

14. Starten Sie das System neu

Es gibt zwei Möglichkeiten, den passenden CUDA-Treiber zu installieren (für Optimus und andere integrierte Grafik-Chipsätze auf Hybrid-Mainboards) - die hier beschriebene ist die einfachste und die zweite Beschreibung ist umständlicher, aber auch effektiver:

EIN)

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

B)

Die Beschreibung der Methode B ist hier, aber bereits älter (erklärt vom Benutzer dschinn1001) - diese Methode B ist bescheidener und kann riskant, aber nicht schädlich sein. :

Wie kann ich Nvidia Driver GT 520 und Cuda 5.0 in Ubuntu13.04 installieren?

Das Beta-Treiber-Paket für Nvidia zum Herunterladen für Linux ist hier:

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

Methode A ist einfacher, aber nicht klar, wie sie mit xscreensaver interagiert, und Methode B ist älter, aber das Treiberpaket wurde in letzter Zeit ebenfalls aktualisiert. Nach Abschluss von Methode B sollte sie unter der Bedingung, dass xscreensaver vorhanden ist, besser mit xscreensaver funktionieren Eingerichtet. (Ich habe Methode B am 13.10 getestet und dies hat sehr gut funktioniert, auch mit xscreensaver. Und ich denke, der Rest dieses Threads hängt von der Hardware ab.)

Zusätzlich und in Bezug auf Hummeln mit Optimus-Grafik-Chipsätzen sind folgende Anpassungen für Hummeln notwendig:

Einrichten von nVidia Optimus / Bumblebee in 14.04

Klingt nach LP Bug 1428972 .

Benutzer fennytansy hat eine Problemumgehung in Kommentar 10 hinzugefügt :

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

Ich habe CUDA erfolgreich mit der Runfile-Methode installiert. Das Setup ist etwas komplizierter, da Ihr primärer Grafiktreiber auch mit der Runfile-Methode installiert werden muss ( siehe hier ).

Versuchen Sie, nur den Treiber zu installieren . Dies kann mithilfe der runfile-Methode erfolgen. Sie werden zu jedem Teil der Installation aufgefordert und können die GLBibliotheken und Toolkits deaktivieren . Die Einheit Leitstelle wurde gibt mir Fragen sowie mit auf Grund der Notwendigkeit CUDA Probe zu verwenden , libGLU.sostatt libGL.so. Dies ist eine einfache Lösung, wenn Sie Ihre eigenen Lernbeispiele erstellen.

Versuchen Sie, den nvidia-Treiber zu deinstallieren und cuda direkt ohne ihn zu installieren. Auf einem neuen Ubuntu 14.04 habe ich die Anweisungen von der NVIDIA- Website befolgt . Abgesehen von der Überprüfung kompatibler Versionen (gcc, Kernel) lauteten die Anweisungen:

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

Glücklicherweise wurde der richtige nvidia-Treiber als Nebenprodukt der obigen Schritte installiert.

Ich habe einen ganzen Tag lang versucht, mit " ppa: graphics-drivers / ppa " die NVIDIA-Treiber auf Version 352 zu aktualisieren. Alles schlug fehl. Nach einer Installation meldete gpu-manager.log, dass die Treiber installiert wurden, während Xorg.0.log das Gegenteil meldete.

Der Nouveau-Treiber wurde entfernt und auf die schwarze Liste gesetzt: sudo apt-get --purge remove xserver-xorg-video-nouveau cat /etc/modprobe.d/nouveau-nomodeset-jsrobin.conf lbm-nouveau off

Ich habe schließlich aufgegeben und eine reine "NVIDIA ... bin" -Lösung verwendet.

1. Nouveau auf der schwarzen Liste, wie oben gezeigt.
2. hat den nouveau Xserver wie oben beschrieben komplett deinstalliert.
3. Stellen Sie das System-Bios so ein, dass PCIe (die beiden NVIDIA-Karten) als primäre Karte verwendet wird, und deaktivieren Sie die HD4600-Hauptplatinenschnittstelle.
4. Im Wiederherstellungsmodus gestartet, Netzwerk aktiviert und dann in den Konsolenmodus gewechselt.
5. Führen Sie "NVIDIA-Linux-x86_64-352.41.run -uninstall" aus, um sicherzustellen, dass nichts mehr übrig ist.
6. Löschte alle alten Verzeichnisse in / etc, / usr / local, die aussahen wie ein Überbleibsel vergangener cuda- oder nvidia-Installationen.
7. Ran "NVIDIA-Linux-x86_64-352.41.run"
8. Führen Sie "NVIDIA-Linux-x86_64-352.41.run --check" aus, um zu überprüfen, ob alles korrekt war (es war).
9. Führen Sie dann "cuda_7.5.18_linux.run" aus, um die Installation abzuschließen. Die Dinge arbeiten derzeit. Beide Monitore sind in Betrieb und funktionieren. Derzeit wird an der Erstellung der cuda-Beispieldateien gearbeitet. Stellen Sie sicher, dass Sie die "--help" -Flaggen in den NVIDIA-Installationsfächern verwenden. Der Hauptgrund, warum ich mich für die Bin-Route entschieden habe (zusammen mit einer der Alternativen, die nicht funktionieren), ist, dass der "Bin" -Ansatz nach einem "Mesa" -OpenGL-Update einen einfachen Weg zur Wiederherstellung bietet.

Ich habe Ubuntu heute neu gestartet und festgestellt, dass es eine weitere unerfüllte Abhängigkeit gibt libcog15 : Depends: mesa-driver...(ich kann mich nicht an den vollständigen Paketnamen erinnern), also habe ich apt-get installden "Mesa-Treiber" installiert. Danach wurde CUDA 7.5 erfolgreich installiert.

Beachten Sie, dass meine Kernel-Version 3.19.0-28-generisch ist und die gcc-Version Ubuntu 4.8.4-2ubuntu1 ~ 14.04 ist , was in offiziellen CUDA 7.5-Dokumenten nicht zu finden ist . Ich werde prüfen, ob es wirklich funktioniert.

Ich habe versucht, sudo su und apt-get install cuda anstelle von sudo apt-get install cuda. Es funktionierte.

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

Weitere Informationen finden Sie unter: https://github.com/astorfi/Caffe_Deep_Learning/blob/master/Installation/readme.md . Es hängt im Wesentlichen mit der Installation von Caffe zusammen, befasst sich aber auch mit der CUDA-Installation.

-probleme mit lightdm einloggen (login loop)

-Probleme mit dem Treiber istall ("Treiberinstallation fehlgeschlagen: es scheint, dass ein X-Server läuft ...")

Um ein NVidia CUDA Toolkit erfolgreich auf Ubuntu 16.04 64bit zu installieren, musste ich nur Folgendes tun:

1. mache ein liveImage von Ubuntu auf pendrive (8GB Stift ist genug) - ein solcher Versuch wird es tun Nerven , bevor die Installation auf Ihrem Host-Linux-System fehlschlägt !!!
2. Bei Live-Sitzung auf pendrive anmelden ("Ubuntu vor der Installation testen")

3. füge sudo user bei live session hinzu:

   sudo adduser admin (#pass: admin1)

   sudo usermod -aG sudo admin

4. Melden Sie sich von der Live-Sitzung ab, und melden Sie sich als #admin an

5. CUDA Toolkit von der offiziellen NVidia-Website herunterladen (~ 1,5 GB)

6. Ändern Sie die Berechtigungen für die heruntergeladene Installationsdatei (NICHT IN DIESEM SCHRITT INSTALLIEREN!):
   sudo chmod + x cuda_X.X.run

7. zur Konsolenansicht wechseln:

   Strg + Alt + F1 (um die Terminalansicht einzuschalten) Strg + Alt + F7 (um von der Terminalansicht zum Grafikserver zu wechseln)

8. In der Konsolenansicht (Strg + Alt + F1) einloggen:

   login: admin pass: admin1

9. Beenden Sie den grafisch ausgeführten Dienst:

   sudo service lightdm halt

10. Überprüfen Sie, ob der Grafikserver ausgeschaltet ist. Nach dem Umschalten von Strg + Alt + F7 sollte der Monitor schwarz leerstehend sein. Schalten Sie die Konsolenansicht Strg + Alt + F1 wieder ein

11. Installieren Sie CUDA Toolkit mit folgender Konfiguration:

    sudo ./cuda_X.X.run (drücken Sie 'q' für das Überspringen des Lizenzlesens) OpenGL-Bibliothek nicht installieren System X-Konfiguration nicht aktualisieren Andere Optionen geben Ja und Pfade als Standard an

12. Grafikserver einschalten:

    sudo service lightdm starten

13. Melden Sie sich als Benutzer an (wenn Sie sich beim Abmelden der Live-Sitzung automatisch als #ubuntu anmelden):

    login: admin pass: admin1

14. Überprüfen Sie, ob der nvcc-Compiler mit der bereitgestellten einfachen parallelen Vektorsumme bei GPU-Blöcken funktioniert:

    Speichern Sie vecSum.cu und book.h in neuen Dateien, kompilieren Sie sie und führen Sie sie am Terminal aus: /usr/local/cuda-8.0/bin/nvcc vecSum.cu && clear && ./a.out

15. Überprüfen Sie den Konsolendruck - er sollte ungefähr so ​​aussehen: 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. Wenn in der Live-Sitzung von pendrive alles geklappt hat, machen Sie dasselbe auf Ihrem Host-Linux-System

PS Bitte beachten Sie, dass es kein ideales Tutorial ist, aber gut für mich funktioniert!

======= 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__