CUDA incompatibile con la mia versione gcc


102

Ho problemi a compilare alcuni degli esempi forniti con CUDA SDK. Ho installato il driver per sviluppatori (versione 270.41.19) e il toolkit CUDA, quindi finalmente l'SDK (entrambe le versioni 4.0.17).

Inizialmente non si compilava affatto dando:

error -- unsupported GNU version! gcc 4.5 and up are not supported!

Ho trovato la riga responsabile in 81: /usr/local/cuda/include/host_config.h e l'ho cambiata in:

//#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ > 4)
#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ > 6)

da quel momento in poi ho avuto solo alcuni degli esempi da compilare, si ferma con:

In file included from /usr/include/c++/4.6/x86_64-linux-gnu/bits/gthr.h:162:0,
             from /usr/include/c++/4.6/ext/atomicity.h:34,
             from /usr/include/c++/4.6/bits/ios_base.h:41,
             from /usr/include/c++/4.6/ios:43,
             from /usr/include/c++/4.6/ostream:40,
             from /usr/include/c++/4.6/iterator:64,
             from /usr/local/cuda/include/thrust/iterator/iterator_categories.h:38,
             from /usr/local/cuda/include/thrust/device_ptr.h:26,
             from /usr/local/cuda/include/thrust/device_malloc_allocator.h:27,
             from /usr/local/cuda/include/thrust/device_vector.h:26,
             from lineOfSight.cu:37:
/usr/include/c++/4.6/x86_64-linux-gnu/bits/gthr-default.h:251:1: error: pasting         "__gthrw_" and "/* Android's C library does not provide pthread_cancel, check for
`pthread_create' instead.  */" does not give a valid preprocessing token
make[1]: *** [obj/x86_64/release/lineOfSight.cu.o] Error 1

Poiché alcuni degli esempi vengono compilati, ritengo che questo non sia un problema di driver, ma piuttosto deve avere qualcosa a che fare con una versione di gcc non supportata. Il downgrade non è un'opzione in quanto gcc4.6 ha un intero sistema come dipendenza a questo punto ...


4
Per i futuri lettori: assicurati di utilizzare l'ultima versione di CUDA (a meno che tu non debba assolutamente usarne una prima). NVIDIA aumenta la versione del compilatore massima supportata con quasi tutte le versioni.
einpoklum

Questo può essere utile per le persone con CUDA 10 e ottenendo l'errore di un troppo elevato una versione GNU catena del compilatore: stackoverflow.com/questions/53344283/...
Douglas Daseeco

Risposte:


114

Come già sottolineato, nvcc dipende da gcc 4.4. È possibile configurare nvcc per utilizzare la versione corretta di gcc senza passare alcun parametro del compilatore aggiungendo softlink alla directory bin creata con l'installazione di nvcc.

La directory binaria predefinita di cuda (l'impostazione predefinita di installazione) è / usr / local / cuda / bin, è sufficiente aggiungere un softlink alla versione corretta di gcc da questa directory:

sudo ln -s /usr/bin/gcc-4.4 /usr/local/cuda/bin/gcc


2
Anche il comando "update-alternatives" può essere d'aiuto, specialmente durante l'installazione di CUDA 5.0
phoad

4
Ho anche dovuto aggiungere un collegamento simbolico alla versione corretta di g ++.
Auron

17
Ho anche dovuto collegarmi a g ++. In caso contrario, semplici nvccinvocazioni funzionano, ma dicono, applicando makeai campioni CUDA, porta presto in invocazioni a partire da: nvcc -ccbin g++. Per me ho usato sudo ln -s /usr/bin/gcc-4.9 /usr/local/cuda/bin/gcce sudo ln -s /usr/bin/g++-4.9 /usr/local/cuda/bin/g++.
user2023370

8
Se compili con cmake .. && makepuoi provare cmake -D CUDA_NVCC_FLAGS="-ccbin gcc-4.4" .. && make . Se usi plain Makefilepuoi provare make CXX=g++-4.4 CC=gcc-4.4 .
patryk.beza

1
quando provo questo comando, dice "File esiste" e non esegue il collegamento. Qualsiasi aiuto ?
Sentient07

59

gcc 4.5 e 4.6 non sono supportati con CUDA - il codice non verrà compilato e il resto della toolchain, incluso cuda-gdb, non funzionerà correttamente. Non puoi usarli e la restrizione non è negoziabile.

La tua unica soluzione è installare una versione di gcc 4.4 come secondo compilatore (la maggior parte delle distribuzioni lo consente). C'è un'opzione per nvcc --compiler-bindirche può essere usata per puntare a un compilatore alternativo. Creare una directory locale e quindi creare collegamenti simbolici agli eseguibili della versione gcc supportati. Passa quella directory locale a nvcc tramite l' --compiler-bindiropzione e dovresti essere in grado di compilare il codice CUDA senza influire sul resto del tuo sistema.


MODIFICA :

Nota che questa domanda e risposta riguardano CUDA 4.

Da quando è stato scritto, NVIDIA ha continuato ad espandere il supporto per le versioni successive di gcc nella versione più recente della toolchain CUDA

  • A partire dalla versione CUDA 4.1, gcc 4.5 è ora supportato. gcc 4.6 e 4.7 non sono supportati.
  • A partire dalla versione CUDA 5.0, gcc 4.6 è ora supportato. gcc 4.7 non è supportato.
  • A partire dalla versione CUDA 6.0, gcc 4.7 è ora supportato.
  • A partire dalla versione CUDA 7.0, gcc 4.8 è completamente supportato, con supporto 4.9 su Ubuntu 14.04 e Fedora 21.
  • A partire dalla versione CUDA 7.5, gcc 4.8 è completamente supportato, con supporto 4.9 su Ubuntu 14.04 e Fedora 21.
  • A partire dalla versione CUDA 8, gcc 5.3 è completamente supportato su Ubuntu 16.06 e Fedora 23.
  • A partire dalla versione CUDA 9, gcc 6 è completamente supportato su Ubuntu 16.04, Ubuntu 17.04 e Fedora 25.
  • La versione CUDA 9.2 aggiunge il supporto per gcc 7
  • La versione CUDA 10.1 aggiunge il supporto per gcc 8

Al momento (a partire da CUDA 10.1) non c'è supporto per gcc 9 in CUDA.

Si noti che NVIDIA ha recentemente aggiunto una tabella molto utile qui che contiene il compilatore supportato e la matrice del sistema operativo per l'attuale versione CUDA.


Qualche idea su cosa viene utilizzato per CUDA 7.5?
GuySoft

2
Uso CUDA 7.5 con gcc 4.9.3su SLES 11 SP3 senza alcun problema.
Peter VARGA

3
Che cosa? Come si suppone che un codice non venga compilato con versioni superiori (tranne ovviamente per le limitazioni hardcoded) ? L'unica cosa a cui riesco a pensare è che poiché alcune versioni c'è C11 / C ++ 11 sono abilitate per impostazione predefinita, ma se questo sta causando un problema con un vecchio codice, potrebbe essere facile aggirare il problema con un interruttore della riga di comando.
Hi-Angel,

2
Seconding @ Hi-Angel. #talonmies cosa significa "la restrizione non è negoziabile"? Le versioni più recenti di gcc e gdb supportano le intestazioni binarie più vecchie per i file oggetto, poiché "sempre" (più o meno) hanno, non c'è motivo per cui le versioni più recenti di gcc non dovrebbero funzionare. Soluzioni di collegamento simbolico a parte, qualsiasi altro problema è molto probabilmente l'impostazione del flag di versione del preprocessore ac, e se il test della versione gcc è "hardcoded" in qualche intestazione cuda come parte di una definizione o di una macro, è abbastanza facile da risolvere. L'eccezione potrebbe essere il compilatore stesso della gpu cuda.
Beracah

1
Questa non è una domanda sulla compatibilità binaria. La toolchain CUDA richiede che nvcc e il parser front-end GPU possano intercettare e sovraccaricare vari compilatori e intestazioni interne libc / libc ++ per compilare sia il codice host che quello del dispositivo e integrarli insieme. Il parser CUDA deve essere in grado di analizzare correttamente le intestazioni interne di gcc, tra le altre cose. Le versioni di gcc non testate possono fallire, indipendentemente dalle protezioni del preprocessore integrate nelle intestazioni NVIDIA. Puoi credermi (come qualcuno che ha hackerato la toolchain CUDA per quasi 10 anni) o no. A questo punto non lo faccio davvero
talonmies

57
  1. Controlla la versione GCC massima supportata per la tua versione CUDA:

     | CUDA version | max supported GCC version |
     |--------------|---------------------------|
     |      11      |             9             |
     |  10.1, 10.2  |             8             |
     |   9.2, 10.0  |             7             |
     |   9.0, 9.1   |             6             |
     |       8      |            5.3            |
     |       7      |            4.9            |
     |    5.5, 6    |            4.8            |
     |    4.2, 5    |            4.6            |
     |      4.1     |            4.5            |
     |      4.0     |            4.4            |
  2. Imposta una variabile env per quella versione di GCC. Ad esempio, per CUDA 10.2:

     MAX_GCC_VERSION=8
  3. Assicurati di avere quella versione installata:

     sudo apt install gcc-$MAX_GCC_VERSION g++-$MAX_GCC_VERSION
  4. Aggiungi collegamenti simbolici nelle cartelle CUDA:

     sudo ln -s /usr/bin/gcc-$MAX_GCC_VERSION /usr/local/cuda/bin/gcc 
     sudo ln -s /usr/bin/g++-$MAX_GCC_VERSION /usr/local/cuda/bin/g++

    (o sostituire /usr/local/cudacon il percorso di installazione CUDA, se non è presente)

Vedi questa sintesi di GitHub per ulteriori informazioni sulla tabella di compatibilità CUDA-GCC .


3
Mi ha salvato la vita lol configurazione da incubo !!!! grazie. L'ho applicato a cuda 10 con i collegamenti di sistema gcc e g ++ 7. Per chiunque si imbatta in questo.
thekevshow

Devo creare da solo le cartelle /usr/bin/gcce /usr/bin/g++o /usr/local/cuda/bin/gcc?
Josh Desmond

@JoshDesmond il collegamento simbolico per i file che hai menzionato viene creato nel passaggio 4.
bryant1410

@ bryant1410 Quando ho eseguito i comandi nel passaggio quattro, ricordo di aver ricevuto un errore del tipo "Errore: directory / usr / local / cuda / bin / gcc non esiste, interruzione" o qualcosa di simile. Mi sto rendendo conto ora, (dopo aver letto i dettagli della domanda), che la tua risposta presuppone uno step 0 menzionato da OP: "Ho installato il toolkit CUDA, poi finalmente l'SDK". Stavo cercando di eseguire l'installazione con la cuda_10.2.89_440.33.01_linux.runprocedura guidata di NVIDIA , che semplicemente non è riuscita in fase di esecuzione con un reclamo sulla compatibilità di gcc. Ho finito per decidere di disinstallare gcc 9: P
Josh Desmond

1
Se hai installato NVCC con [ana | mini] conda (pacchetto conda-forge cudatoolkit-dev), devi collegare all'interno del tuo env like ln -s /usr/bin/gcc-8 /home/user/miniconda3/envs/your_env/bin/gcceln -s /usr/bin/g++-8 /home/user/miniconda3/envs/your_env/bin/g++
Diego Ferri

25

La soluzione di Gearoid Murphy funziona meglio per me poiché sulla mia distribuzione (Ubuntu 11.10), gcc-4.4 e gcc-4.6 sono nella stessa directory, quindi --compiler-bindir non è di aiuto. L'unico avvertimento è che ho anche dovuto installare g ++ - 4.4 e collegarlo anche simbolicamente:

sudo ln -s /usr/bin/gcc-4.4 /usr/local/cuda/bin/gcc
sudo ln -s /usr/bin/g++-4.4 /usr/local/cuda/bin/g++

11

Per CUDA7.5 funzionano queste linee:

sudo ln -s /usr/bin/gcc-4.9 /usr/local/cuda/bin/gcc 
sudo ln -s /usr/bin/g++-4.9 /usr/local/cuda/bin/g++

9

Scopri come utilizzare "update-alternatives" per aggirare questo problema:

... Se installi gcc 4.6 puoi anche usare il comando update-alternatives per consentire un facile passaggio tra le versioni. Questo può essere configurato con:

sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-4.6 60 --slave /usr/bin/g++ g++ /usr/bin/g++-4.6 
sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-4.7 40 --slave /usr/bin/g++ g++ /usr/bin/g++-4.7 
sudo update-alternatives --config gcc

6

Se usando cmakeper me nessuno degli hack per modificare i file e il collegamento ha funzionato, ho compilato usando i flag che specificano la versione gcc / g ++.
cmake -DCMAKE_C_COMPILER=gcc-6 -DCMAKE_CXX_COMPILER=g++-6 ..

Ha funzionato come un fascino.


haha stavo per provare a collegare la tua risposta dall'altra domanda qui perché pensavo che fosse necessario metterla in questo thread. Buon lavoro di nuovo! Grazie
MikeDoho

Uno dovrebbe astenersi dal pubblicare risposte duplicate su SO, ma non avevo altra scelta. :)
markroxor

5

Sulla maggior parte delle distribuzioni hai la possibilità di installare un'altra versione di gcc e g ++ accanto a un compilatore più recente come gcc-4.7. Inoltre la maggior parte dei sistemi di compilazione conosce le variabili di ambiente CCe CXX, che consentono di specificare rispettivamente altri compilatori C e C ++. Quindi suggerisco qualcosa come:

CC=gcc-4.4 CXX=g++-4.4 cmake path/to/your/CMakeLists.txt

Per i Makefile dovrebbe esserci un modo simile. Non consiglio di impostare collegamenti simbolici personalizzati in / usr / local a meno che tu non sappia cosa stai facendo.


3

Questo funziona per fedora 23. I repository compat gcc saranno leggermente diversi in base alla tua versione di fedora.

Se installi i seguenti repository:

sudo yum install compat-gcc-34-c++-3.4.6-37.fc23.x86_64 compat-gcc-34-3.4.6-37.fc23.x86_64 

Ora crea i collegamenti software come menzionato sopra supponendo che la tua cartella cuda bin sia in /usr/local/cuda/

sudo ln -s /usr/bin/gcc-34 /usr/local/cuda/bin/gcc
sudo ln -s /usr/bin/g++-34 /usr/local/cuda/bin/g++

Ora dovresti essere in grado di compilare con nvccsenza l'errore di versione di gcc.


2

La soluzione di Gearoid Murphy funziona a meraviglia. Per me avevo due directory per cuda -

/usr/local/cuda 
/usr/local/cuda-5.0

I collegamenti software dovevano essere aggiunti solo alla directory menzionata di seguito -

/usr/local/cuda 

Inoltre, come menzionato da SchighSchagh, erano richiesti sia i soft link g ++ che gcc.


2

Un altro modo per configurare nvcc per utilizzare una versione specifica di gcc (gcc-4.4, per esempio), è modificare nvcc.profile e alterare PATH per includere il percorso del gcc che si desidera utilizzare per primo.

Ad esempio (gcc-4.4.6 installato in / opt):

PATH += /opt/gcc-4.4.6/lib/gcc/x86_64-unknown-linux-gnu/4.4.6:/opt/gcc-4.4.6/bin:$(TOP)/open64/bin:$(TOP)/share/cuda/nvvm:$(_HERE_):

La posizione di nvcc.profile varia, ma dovrebbe essere nella stessa directory dell'eseguibile nvcc stesso.

Questo è un po 'un trucco, poiché nvcc.profile non è inteso per la configurazione dell'utente come da manuale di nvcc, ma era la soluzione che ha funzionato meglio per me.


Suggerisco di farlo, ma puntando il percorso a una directory con g ++ collegato simbolicamente alla versione di gcc corretta (particolarmente utile se la tua distribuzione fornisce una versione di gcc supportata). Ad esempio:mkdir /usr/local/bin/cuda-hack && ln -s /usr/bin/g++-5 /usr/local/bin/cuda-hack
Sami Liedes


2

Per le persone come me che si confondono durante l'utilizzo cmake, lo FindCUDA.cmakescript sovrascrive alcune delle cose da nvcc.profile. Puoi specificare il filenvcc compilatore host impostando CUDA_HOST_COMPILERcome per http://public.kitware.com/Bug/view.php?id=13674 .


cmake .. -DCMAKE_INSTALL_PREFIX=/InstallPos_GPU/ -DCMAKE_C_COMPILER="/gcc-8.3.0/bin/gcc" -DCMAKE_CXX_COMPILER="/gcc-8.3.0/bin/g++" -DGMX_GPU=ON -DCUDA_TOOLKIT_ROOT_DIR=/cuda-7.5/ -D NVCCFLAGS=" -ccbin /cuda-7.5/bin/" -DCUDA_HOST_COMPILER=/cuda-7.5/bin/gccHo installato con successo i gromac con supporto GPU.
pengchy

2

Ho dovuto installare le versioni precedenti di gcc, g ++.

    sudo apt-get install gcc-4.4
    sudo apt-get install g++-4.4

Controlla che gcc-4.4 sia in / usr / bin / e lo stesso per g ++ Quindi potrei usare la soluzione sopra:

    sudo ln -s /usr/bin/gcc-4.4 /opt/cuda/bin/gcc
    sudo ln -s /usr/bin/g++-4.4 /opt/cuda/bin/g++

Quando provo questo comando, dice "File esistente" e non esegue il collegamento. Qualsiasi aiuto ?
Sentient07

Temo di essere troppo lontano dal pensarci per sapere cosa dire. Si spera che altri possano aiutare.
travellingbones

2

In $CUDA_HOME/include/host_config.h, trova linee come queste (possono variare leggermente tra le diverse versioni di CUDA):

//...
#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ > 9)

#error -- unsupported GNU version! gcc versions later than 4.9 are not supported!

#endif [> __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ > 9) <]
//...

Rimuovili o modificali in base alle tue condizioni.

Nota che questo metodo è potenzialmente pericoloso e potrebbe danneggiare la tua build. Ad esempio, gcc 5 utilizza C ++ 11 come impostazione predefinita, tuttavia questo non è il caso di nvcc a partire da CUDA 7.5. Una soluzione alternativa è aggiungere

--Xcompiler="--std=c++98" per CUDA <= 6.5

o

--std=c++11 per CUDA> = 7.0.


dove aggiungiamo l' --std=c++opzione?
asgs

1

Se si verifica questo errore, leggere il file di registro:

$ cat /var/log/cuda-installer.log 
[INFO]: Driver installation detected by command: apt list --installed | grep -e nvidia-driver-[0-9][0-9][0-9] -e nvidia-[0-9][0-9][0-9]
[INFO]: Cleaning up window
[INFO]: Complete
[INFO]: Checking compiler version...
[INFO]: gcc location: /usr/bin/gcc

[INFO]: gcc version: gcc version 9.2.1 20191008 (Ubuntu 9.2.1-9ubuntu2) 

[ERROR]: unsupported compiler version: 9.2.1. Use --override to override this check.

Segui semplicemente il suggerimento nel file di registro:

sudo sh cuda_<version>_linux.run --override

Lavoro fatto :)

Ho appena installato CUDA 10.2 con gcc 9.2 su Kubuntu 19.10 usando l' --overrideopzione.


0

Per compilare gli esempi CUDA 8.0 su Ubuntu 16.10, ho fatto:

sudo apt-get install gcc-5 g++-5
cd /path/to/NVIDIA_CUDA-8.0_Samples
# Find the path to the library (this should be in NVIDIA's Makefiles)
LIBLOC=`find /usr/lib -name "libnvcuvid.so.*" | head -n1 | perl -pe 's[/usr/lib/(nvidia-\d+)/.*][$1]'`
# Substitute that path into the makefiles for the hard-coded, incorrect one
find . -name "*.mk" | xargs perl -pi -e "s/nvidia-\d+/$LIBLOC/g"
# Make using the supported compiler
HOST_COMPILER=g++-5 make

Questo ha il vantaggio di non modificare l'intero sistema o creare collegamenti simbolici solo ai binari (ciò potrebbe causare problemi di collegamento delle librerie).


0

Questo ha risolto il mio problema:

sudo rm /usr/local/cuda/bin/gcc
sudo rm /usr/local/cuda/bin/g++
sudo apt install gcc-4.4 g++-4.4
sudo ln -s /usr/bin/gcc-4.4 /usr/local/cuda/bin/gcc
sudo ln -s /usr/bin/g++-4.4 /usr/local/cuda/bin/g++

0

Per CUDA 6.5 (e apparentemente 7.0 e 7.5), ho creato una versione del pacchetto gcc 4.8.5 RPM (sotto Fedora Core 30) che consente di installare quella versione di gcc insieme all'attuale GCC del tuo sistema.

Puoi trovare tutte queste informazioni qui .


0

Nel mio caso, avevo CUDA già installato dalla versione di Ubuntu e cmake avrebbe rilevato quello invece della versione appena installata utilizzando NVidia SDK Manager.

Ho corso dpkg -l | grep cuda e potuto vedere entrambe le versioni.

Quello che dovevo fare è disinstallare il vecchio CUDA (versione 9.1 nel mio caso) e lasciare da sola la nuova versione (versione 10.2). Ho usato il comando di eliminazione in questo modo:

sudo apt-get purge libcudart9.1 nvidia-cuda-dev nvidia-cuda-doc \
                                nvidia-cuda-gdb nvidia-cuda-toolkit

Verifica che i nomi dei pacchetti corrispondano alla versione che desideri rimuovere dall'installazione.

Ho dovuto eseguire di nuovo cmakeda una BUILDdirectory vuota per reindirizzare tutte le #includelibrerie e alla versione SDK (poiché i vecchi percorsi erano cotti nell'ambiente di compilazione esistente).


-1

Questo accade perché la tua attuale versione di CUDA non supporta la tua attuale versione di GCC. Devi fare quanto segue:

  1. Trova la versione GCC supportata (nel mio caso 5 per CUDA 9)

    • CUDA 4.1: GCC 4.5
    • CUDA 5.0: GCC 4.6
    • CUDA 6.0: GCC 4.7
    • CUDA 7.0: GCC 4.8
    • CUDA 7.5: GCC 4.8
    • CUDA 8: GCC 5.3
    • CUDA 9: GCC 5.5
    • CUDA 9.2: GCC 7
    • CUDA 10.1: GCC 8
  2. Installa la versione GCC supportata

    sudo apt-get install gcc-5
    sudo apt-get install g++-5
  3. Modificare i collegamenti software per GCC nella /usr/bindirectory

    cd /usr/bin
    sudo rm gcc
    sudo rm g++
    sudo ln -s /usr/bin/gcc-5 gcc
    sudo ln -s /usr/bin/g++-5 g++
  4. Modificare i collegamenti software per GCC nella /usr/local/cuda-9.0/bindirectory

    cd /usr/local/cuda-9.0/bin
    sudo rm gcc
    sudo rm g++
    sudo ln -s /usr/bin/gcc-5 gcc
    sudo ln -s /usr/bin/g++-5 g++
  5. Aggiungi -DCUDA_HOST_COMPILER=/usr/bin/gcc-5al tuo setup.pyfile, usato per la compilazione

    if torch.cuda.is_available() and CUDA_HOME is not None:
        extension = CUDAExtension
        sources += source_cuda
        define_macros += [("WITH_CUDA", None)]
        extra_compile_args["nvcc"] = [
            "-DCUDA_HAS_FP16=1",
            "-D__CUDA_NO_HALF_OPERATORS__",
            "-D__CUDA_NO_HALF_CONVERSIONS__",
            "-D__CUDA_NO_HALF2_OPERATORS__",
            "-DCUDA_HOST_COMPILER=/usr/bin/gcc-5"
        ]
  6. Rimuovi la vecchia directory di build

    rm -rd build/
  7. Compilare di nuovo impostando CUDAHOSTCXX=/usr/bin/gcc-5

    CUDAHOSTCXX=/usr/bin/gcc-5 python setup.py build develop

Nota: se continui a ricevere l' gcc: error trying to exec 'cc1plus': execvp: no such file or directoryerrore dopo aver seguito questi passaggi, prova a reinstallare GCC in questo modo e quindi a compilare di nuovo:

sudo apt-get install --reinstall gcc-5
sudo apt-get install --reinstall g++-5

Crediti: https://github.com/facebookresearch/maskrcnn-benchmark/issues/25#issuecomment-433382510

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.