Build Instructions/fr

From OpenSimulator

(Difference between revisions)
Jump to: navigation, search
(CentOS, Redhat)
(Compilateurs supportés)
(8 intermediate revisions by one user not shown)
Line 1: Line 1:
{{Quicklinks}}
+
 
 +
{{Languages|Build_Instructions}}
  
 
__TOC__
 
__TOC__
Line 8: Line 9:
 
= Compiler =
 
= Compiler =
 
Autant cette page est longue, autant la compilation d'OpenSimulator est rapide. Reportez-vous au fichier BUILDING.txt inclus dans la distribution elle-même pour trouver des instructions simplifiées.
 
Autant cette page est longue, autant la compilation d'OpenSimulator est rapide. Reportez-vous au fichier BUILDING.txt inclus dans la distribution elle-même pour trouver des instructions simplifiées.
== Microsoft Windows ==
 
Les versions OpenSimulator 0,8 et postérieure nécessitent soit :
 
* [http://msdn.microsoft.com/en-us/netframework/cc378097 .NET Framework 4.0] pour Windows ou
 
* [http://www.go-mono.com/mono-downloads/download.html Mono] pour Linux ou Mac.  Mono 2.10.8 est la version minimum.
 
  
===Compilateurs supportés===
+
== Conditions ==
* Visual Studio 2010
+
OpenSimulator 0.9.0.x nécessite soit
* Visual Studio 2008 peut être utilisé jusqu'à OpenSimulator 0.7.6 - le code développé actuellement requiert Visual Studio 2010 ou un compilateur qui peut compiler le code .NET 4.0.
+
* [http://msdn.microsoft.com/en-us/netframework/cc378097 .NET Framework 4.0] sur Windows
Toutes les éditions de Visual Studio devraient fonctionner parfaitement, y compris l'édition libre [http://www.microsoft.com/express/downloads/ Microsoft Visual C# Express].
+
* [https://www.mono-project.com/download/stable/ Mono] sur Linux ou Mac.  Mono 2.10.8 est la version minimale.
 +
Vous pouvez également avoir besoin de l'outil nant.
  
Notez que les versions Visual Studio 2005 et antérieures ne sont plus supportées ([http://www.mail-archive.com/opensim-dev@lists.berlios.de/msg02674.html opensim-dev proposal], [http://www.mail-archive.com/opensim-dev@lists.berlios.de/msg02673.html opensim-dev approved]).
+
OpenSimulator >= 0.9.1 (y compris le master actuel) nécessite
 +
* [http://msdn.microsoft.com/en-us/netframework/cc378097 .NET Framework 4.6] sur Windows
 +
* [https://www.mono-project.com/download/stable/ Mono] sur Linux ou Mac. Mono 5.12 est la version minimum recommandée. <br>
 +
'''Note:''' plutôt que d'utiliser les paquets Mono de votre distribution Linux, qui peuvent manquer de composants requis, veuillez installer à partir du  [https://www.mono-project.com/download/stable/ dépôt officiel de Mono pour votre distribution]. Il est recommandé de compiler avec msbuild.
  
===Compiler dans un IDE===
+
D'autres plateformes peuvent avoir leurs propres distributions mono, ou peuvent avoir besoin de compiler mono.
# Lancez "runprebuild.bat" ou "runprebuild2010.bat" (si vous utilisez Visual Studio 2010 avec le code source de OpenSimulator 0.7.6 ou de versions antérieures).
+
# Ouvrez le fichier "OpenSim.sln" résultant dans un IDE Visual Studio.
+
# Compilez (ou déboguez) -> Build Solution.
+
  
===Compiler en ligne de commande===
+
D'autres bibliothèques utilisées par OpenSimulator peuvent être trouvées dans notre dépôt git opensim-libs :
# Lancez "runprebuild.bat".
+
# Lancez le fichier "compile.bat" résultant ou lancez "nant". L'exécutable OpenSim.exe va être construit avec MSBuild (l'ancien) ou nant (le dernier).
+
  
===Notes complémentaires===
+
git clone git://opensimulator.org/git/opensim-libs
* Vous pouvez lancer OpenSimulator sur Windows 64-bit (Vista, Windows 7 ...),  mais si vous voulez le déboguer dans Visual Studio, vous devrez ajouter OpenSim.32BitLaunch à la solution et le définir comme début de projet. Voir [http://blog.tedd.no/2008/12/05/opensim-in-visual-studio-on-win64/ OpenSimulator in Visual Studio on Win64@Tedds blog] pour plus de details.
+
  
*Pour ceux qui utilisent Cygwin shell, il faudra peut-être corriger les permissions des DLLs en tapant "<tt>chmod 755 *.dll *.exe</tt>" dans le répertoire <tt>bin</tt>.
+
La bibliothèque libOpenMetaVerse utilisée peut être trouvé sur https://bitbucket.org/opensimulator/
  
== Mac OS X ==
+
Vous devrez peut-être les compiler pour votre plate-forme, en particulier les bibliothèques non gérées comme les bibliothèques de code natif Bullet ou ODE.
=== Mac OS X 10.5 et postérieur, Intel ===
+
La seule chose que vous ayez à faire est de télécharger :
+
* Mono SDK depuis [http://www.go-mono.com/mono-downloads/download.html Page de téléchargement de Mono]
+
* Le paquet MonoDevelop depuis [http://monodevelop.com/Download la page de téléchargement de MonoDevelop] 
+
** MonoDevelop est redirigé vers  Xamarin Studio pour les téléchargement de  Mc OS X (ndlr: je ne sais pas si j'ai bien traduit cette phrase)
+
et ensuite les installe. Il n'est pas nécessaire d'installer XCode et MacPort (bien que vous puissiez installer les bibliothèques mono dev  et nant avec MacPort).
+
  
Quand vous lancez nano pour compiler OpenSimulator, l'erreur suivante peut s'afficher : "Unable to locate 'mono' module using pkg-config. Download the Mono development packages" (Impossible de localiser le module 'mono' avec pkg-config. Téléchargez les paquets de développement de Mono). Le rédacteur de l'article anglais suspecte  XCode ou MacPort d'être à l'origine de cette erreur (depuis qu'il les a supprimés cela fonctionne mieux), mais il n'en est pas sur.
+
== Microsoft Windows ==
  
De toute façon, pour gérer le problème, inserrez une ligne dans le fichier du script '''/usr/bin/nant'''  :
+
===Compilateurs supportés===
<pre>
+
* [https://visualstudio.microsoft.com/downloads/ Visual Studio Community 2017]
#!/bin/sh
+
* Ou toute autre version qui supporte la version .Net. Au moins VS2010 pour les versions antérieures à 0.91, VS2015 pour les versions 0.91 et ultérieures.
export PKG_CONFIG_PATH=/Library/Frameworks/Mono.framework/Libraries/pkgconfig    # ajoutez ceci!
+
* OpenSimulator 0.9.2 supporte Microsoft Visual Studio 2019 (runprebuild.bat ln11-18).
exec /Library/Frameworks/Mono.framework/Versions/2.10.2/bin/mono \
+
    /Library/Frameworks/Mono.framework/Versions/2.10.2/share/NAnt/bin/NAnt.exe "$@"
+
</pre>
+
  
Vous pouvez compiler et déboguer OpenSimulator avec l'IDE MonoDevelop après avoir lancé "runprebuild.sh". Ouvrez le fichier de la solution (*.sln) avec l'IDE MonoDevelop et sélectionnez  Build -> Build All à partir du menu.
+
===Compiler dans un IDE===
 +
# Lancez "runprebuild.bat".
 +
# Ouvrez le fichier "OpenSim.sln" résultant dans L'IDE Visual Studio.
 +
# Sélectionnez la configuration Debug ou Release
 +
# Menu Build -> Build Solution.                                   
 +
 
 +
===Compiler en ligne de commande===
 +
# Lancez "runprebuild.bat".
 +
# Lancez le fichier "compile.bat" résultant.
  
===Compilation en ligne de commande (Mono 3.x)===
+
== Linux et autres plates-formes mono ==
* Téléchargez Mono MDK depuis [http://www.mono-project.com/download/ la page de téléchargement de Mono].
+
  
Utilisez xbuild à la place de nant:
+
=== Préparer la compilation ===
<pre>
+
./runprebuild.sh
+
xbuild
+
</pre>
+
  
===Mac OS X 10.4/10.5 sur PowerPC ===
+
Pour créer les différents fichiers du projet, exécuter dans le dossier opensim :
OpenSimulator peut être lancé sur  PowerPC Macs (comme G4, G5). Les instructions qui suivent on été testées sur 10.5.8. Notez que les deux bibliothèques doivent aussi être compilées depuis la source.
+
  
Avertissement: l'application d'OpenSimulator n'a été que brièvement testée en mode autonome. Des problèmes peuvent survenir pour cette version. N' hésitez pas à noter toutes les questions que vous vous posez ici (ou dans une nouvelle page wiki? discussion?).
+
  ./runprebuild.sh
  
Malheureusement, la version d'OpenSimulator utilisée ici doit être compilée avec une version de Mono (2.6.7) et lancée avec une autre version (2.8.2). Cela signifie qu'il faut mettre à niveau Mono après l'avoir compilé, ou avoir deux versions installées en pouvant accéder à l'ancienne version pour la compilation. Les instructions qui suivent proposent d'avoir les deux versions installées.
+
==== Compiler avec Nant ====
  
* Installez Xcode 3.1.4 Developer Tools depuis http://developer.apple.com/. Vous devez avoir un compte développeur Apple libre pour accéder au téléchargement. 3.1.4 est le dernier PowerPC Xcode.
+
Sur certaines versions de mono, en particulier les anciennes versions peuvent nécessiter d'utiliser l'utilisation de nant pour compiler correctement OpenSimulator, dans ce cas il suffit d'exécuter :  
 
+
* (10.4 only) Installez X11 depuis  les installations Optionelles (ou voir si c'est une option personnalisée quand vous installez Xcode). 10.5 installe X11 par défaut (''depuis OS X ou dev tools?'').
+
* Installez Mono 2.6.7 PowerPC Framework depuis : http://www.go-mono.com/mono-downloads/download.html (OS X Framework binaire, ce n'est pas nécessaire de le compiler).
+
* Ensuite, installez Mono 2.8.2 PowerPC framework. Pour que cela fonctionne vous devez installer 2.6.7, PUIS 2.8.2. (l'ancien framework n'est pas supprimé, mais les liens symboliques "Courants" sont mis à jour).
+
* Téléchargez l'archive du code source OpenSimulator 0.7.0.2 : http://dist.opensimulator.org/opensim-0.7.0.2-source.tar.gz.
+
** Vous pouvez utiliser une version plus récente d'OpenSimulator (le référentiel est sur git maintenant).
+
** Si vous utilisez une nouvelle version d'OpenSimulator, vérifiez dans BUILDING.txt qu'il n'y a pas eu de changement dans les instructions de compilation (voir sous "Linux").
+
* Editez ou créez  .profile ou .bash_profile dans votre dossier home OS X, avec les lignes suivantes :
+
# rapel de real PATH
+
export OSIM_HACK_ORIG_PATH=$PATH
+
+
# chemin normal pour lancer OpenSimulator
+
export PATH=$PATH:/Library/Frameworks/Mono.framework/Versions/Current/bin:/usr/local/mysql/bin
+
+
# Seulement pour nant:
+
export PKG_CONFIG_PATH=/Library/Frameworks/Mono.framework/Versions/2.6.7/lib/pkgconfig
+
alias oldpath="export PATH=$OSIM_HACK_ORIG_PATH:/Library/Frameworks/Mono.framework/Versions/2.6.7/bin"
+
 
   
 
   
* Ouvrez un nouveau terminal, et cd vers votre dossier décompressé d'OpenSimulator source (raccourci: tapez "cd " ensuite glissez le dossier dans le terminal). Ensuite entrez ces commandes:
 
oldpath
 
./runprebuild.sh
 
 
  nant
 
  nant
*nant doit mettre environ 10 minutes pour compiler votre OpenSimulator. Si vous y parvenez sans erreur, vous aurez fait la moitié du travail ! (L'auteur avait 234 warnings).
 
*Important : Avant d'oublier, ouvrez un nouveau terminal (nécessaire pour éviter les effets de "oldpath").
 
*Maintenant, nous avons besoin des versions PowerPC de deux bibliothèques. Compilez chacune d'elle et remplacez les fichiers compilés .dylib  dans le dossier opensim/bin.
 
** libode.dylib http://cdnetworks-us-1.dl.sourceforge.net/project/opende/ODE/0.11.1/ode-0.11.1.zip
 
** libopenjpeg-dotnet-2.1.3.0-dotnet-1.dylib (vérifier avec svn :)
 
svn co http://libopenmetaverse.googlecode.com/svn/libopenmetaverse/trunk/openjpeg-dotnet libopenmetaverse-read-only
 
cd libopenmetaverse-read-only
 
** Pour compiler, supprimez le fichier  Makefile, qui concerne Linux, et renommez Makefile.osx simplement Makefile, ensuite lancez la commande : make )
 
** Supprimez les autres versions des deux bibliothèques (mêmes noms et extensions différentes, par exemple "libode-x86_64.so". Deux libode et trois libopenjpeg).
 
* Configurez votre sim: copiez OpenSim.ini.example vers OpenSim.ini et personnalisez-le.
 
* De la même façon copiez et personnalisez StandaloneCommon.ini dans bin/config-include.
 
* Notez que les commentaires disent que le plugin SQLite courant ne fonctionne pas pour OS X. Aussi vous pouvez corriger cela, ou installez MySQL, qui ne demande pas de compilation et qui est relativement simple à configurer :
 
** Depuis http://downloads.mysql.com/archives.php?p=mysql-5.1&v=5.1.40, télécharger MySQL 5.1.40 pour 10.5 PowerPC (installateur, pas 64-bit)
 
** Lancer  l'installateur. (Qui installe vers /usr/local)
 
** Installez MySQL.prefPane dans System Preferences en double cliquant dessus.
 
** Ouvrez le panneau des préférences et lancez le serveur  MySQL.
 
** (Optionel: ) Pour un démarrage sans surveillance, installez MySQLStartupItem ( pour l'auteur ça ne fonctionne pas toujours).
 
** (Recommandé : ) Dans un terminal, utiliser l'installation en une fois de MySQL avec cette commande : mysql_secure_installation
 
** Dans MySQL, créez l'utilisateur  opensim . Donnez-lui tous les privilèges de création.
 
*** Puisque nous sommes sous Mac, vous pouvez utiliser Sequel Pro (donationware) pour faire cela dans une jolie interface graphique. Pour une connexion standard, host: 127.0.0.1 (si vous êtes sur le même Mac).
 
* Vous êtes prêt pour lancer  OpenSimulator. Dans un nouveau terminal, cd vers votre dossier OpenSim-source/bin.
 
mono OpenSim.exe
 
* Si tout se passe bien, vous serez invité à entrer le nom de votre région :"New region name []: "
 
* Reportez-vous à "lancer OpenSimulator pour la première fois" sur la page [[Configuration/fr]] du wiki.
 
* Lorsque votre simulateur sera opérationnel vous aurez l'invite "Region (<nom-de-la-region>) #"
 
  
== Linux ==
+
==== Compiler avec xbuild ====
===Ubuntu===
+
Pour les utilisateur des anciennes distributions d'Ubuntu (7.10, 8.04, 9.10 etc.) '''vous aurez besoin''' de mettre à niveau votre version de mono à au moins 2.4.3 pour OpenSimulator 0.7.6 et 2.10.8 les versions plus récentes d'OpenSimulator. Nous vous recommandons d'installer au moins  Mono 2.10.8 dans tous les cas pour des raisons de performance. Pour ceux qui veulent mettre à niveau leur  Mono, voir [[Update Mono on Ubuntu]].
+
  
Ubuntu Karmic (9.10) comprend les paquets mono 2.4.2.3.
+
Sur les versions mono, vous pouvez simplement utiliser xbuild. (msbuild est recommandé pour la version 0.9.1.0.0+)
  
Ubuntu Lucid (10.04) comprend les paquets mono 2.4.4.
+
  xbuild
  
Ubuntu Maverick (10.10)comprend les paquets mono 2.6.7.
+
xbuild n'est plus recommandé sur mono 5.x, mais fonctionne toujours actuellement (5.12)
  
Ubuntu Natty (11.04) comprend les paquets mono 2.6.7.
+
>>>> L'outil xbuild est obsolète et sera supprimé dans les prochaines mises à jour, utilisez plutôt msbuild <<<<
  
Ubuntu Oneirc (11.10) à Salamander (13.10) comprennent les paquets mono 2.10.8.1.
+
Sur les versions mono plus récentes, la configuration de la version peut donner un certain gain de performance, mais vous perdez certaines capacités de débogage.  
 +
<br>Compiler avec la configuration Release :
  
Ubuntu Trusty (14.04) à Ubuntu Vivid (15.04) comprennent les paquets mono 3.2.8.
+
    xbuild /p:Configuration=Release
====Ubuntu 10.04 et plus récents====
+
Dans ces versions, il suffit d'installer mono-complète - toutes les dépêndances nécessaires seront installées. Ainsi, pour compiler tapez les commandes suivantes dans un terminal :
+
  
sudo apt-get install mono-complete
+
==== Compiler avec msbuild ====
# [[Download/fr|télécharger]] opensim
+
cd opensim
+
./runprebuild.sh
+
xbuild
+
À partir des versions mono 2.6, xbuild a fonctionné relativement bien pour réaliser une compilation complète d'OpenSimulator. Depuis, xbuild est inclus dans le package Ubuntu '''mono-complete''', vous n'avez pas besoin d'installer de paquets supplémentaire si vous n'avez pas de raison particulière d'utiliser nant à la place de xbuild. Il y a simplement deux systèmes de compilation différents qui invoque le même compilateur C# sur la base de deux formats de scripts de build différents.
+
  
Si vous voulez compiler OpenSimulator avec nant, alors vous devez installer le paquet apt-get '''nant''' et l'exécuter :
+
Pour Opensim 0.9.1 vous pouver encore utiliser xbuild mais Mono recommande l'utilisation de msbuild. Pour cela, vous devrez peut-être installer le paquet msbuild en plus de mono-complete. (Actuellement, msbuild est inclus si vous installez mono-complete, sur Ubuntu, à partir des dépôts mono officiels. https://www.mono-project.com/download/stable/#download-lin ).
  
sudo apt-get install nant
+
Utilisez xbuild sur les autres cas en dernier recours.
nant
+
  
à la place de
+
Des améliorations récentes, en particulier sur le runtime JIT, justifient la compilation en configuration Release, mais vous perdez certaines capacités de débogage.
  
xbuild
+
Compiler avec la configuration de débogage :
  
ensuite ./runprebuild.sh
+
  msbuild
  
====Optionnel(pour les développeurs)====
+
Compiler avec la configuration Release :
Pour exécuter la suite de tests de régression, vous devez aussi installer nunit-console, comme ceci :
+
  
sudo apt-get install nunit-console
+
  msbuild /p:Configuration=Release
nant test
+
  
{{anchor|CentOS}}{{anchor|RedHat}}{{anchor|RHEL}}{{anchor|Fedora}}
+
Compiler avec la configuration debug et afin que le fichier détaillé OpenSim.log puisse être lu avec un éditeur de texte :
 +
 
 +
  msbuild /p:Configuration=Debug /fileLogger /flp:logfile=opensim.log /v:d
  
===Debian===
+
Vous pouvez spécifier les valeurs suivantes pour définir le niveau de détail du fichier OpenSim.log :
Debian 4 (Etch) n'est plus supporté par debian.org. Mettez votre système à jour au moins à la version 5 (Lenny) avant de lancer OpenSimulator. Pour plus d'informations , voir  [http://www.debian.org/releases/lenny/i386/release-notes/ch-upgrading.html Upgrades from previous release@debian.org] ou pour une mise à niveau depuis Debian 6 ver Debian 7 la documentation en français [http://www.debian.org/releases/stable/i386/release-notes/index.fr.html Mises à niveau depuis Debian 6.0]
+
   
 +
  q [quiet], m [minimal], n [normal], d [detailed] and diag [diagnostic].
  
Pour Debian 5 (Lenny) ou pour une version plus récente, tapez simplement :
+
== Compilation anticipée (Ahead of Time compilation) (AOT) ==
<pre>
+
sudo aptitude install nant
+
</pre>
+
Avant de lancer  runprebuild.sh et nant. Vous pouvez utiliser  apt-get à la place d'aptitude. Les deux vont installer les dépendances.
+
  
Testé sur Debian 5 "Lenny" ''oldstable'', Debian 6 "Squeeze" ''stable'' et Debian 7 "Wheezy" ''testing''.
+
Comme vous le savez tous, les fichiers *.exe et .dll créés par le processus de compilation ci-dessus ne contiennent pas de code natif pour la machine.<br>
 +
Avec ces fichiers, le code natif requis par l'ordinateur est créé au moment de l'exécution, selon les besoins, dans un processus appelé Just in Time (JIT)(compilation à la volée). <br>
 +
Il est possible de faire une autre niveau de compilation sur ces fichiers pour créer un code natif, qui sera prêt au démarrage du programme. C'est le processus AOT (Ahead of time process).<br>
 +
Comme le JIT se fait à l'exécution, il dispose d'un temps limité pour effectuer des optimisations de code étendues, AOT, en revanche, peut tout faire.<br>
 +
AOT devrait ainsi être plus rapide à charger, économiser la mémoire nécessaire au travail du JIT et réduire la latence due à la génération de code lorsqu'une nouvelle section de code est nécessaire.<br>
 +
De cette façon, AOT contribue à réduire l'énorme écart de performance entre le C# et un langage plus approprié comme le C++, même si le JIT peut effectuer une certaine optimisation en fonction de l'état d'exécution du code, ce que AOT ne peut pas faire. (si vous pensez que c# est aussi rapide qu'un code C++ efficace, mieux vaut fumez autre chose...)<br>
 +
En fait, aussi bien .net que mono utilisent AOT sur leurs composants lors de l'installation<br>
 +
Le JIT sera toujours actif et compilera un autre code au moment de l'exécution. OpenSim et les parties utilisées du framework .net/mono en dépendent.
  
===Fedora===
+
Pour Linux, la version 0.9.2.0 inclut désormais les scripts makeaot.sh et cleanaot.sh pour aider à tester AOT.<br>
Après avoir testé la distribution binaire d'OpenSimulator, vous devrez installer les bibliothèques de développement de mono et nant pour pouvoir compiler la source d'OpenSimulator. Pour cela voir les sections ci-dessous.
+
Lancez makeaot.sh après l'étape de compilation ci-dessus, pour générer les fichiers de code natif. L'option -O=all doit être ajoutée à mono lors de l'exécution de opensim.exe, ex:<br>
====Trouver les bibliothèques de Mono====
+
 
Si vous avez installé les paquets mono depuis le référentiel central de votre distribution [[Dependencies#RedHat|quand vous utilisez la distribution binaire d'OpenSimulator]], tapez simplement :
+
  mono --desktop -O=all OpenSim.exe
<pre>
+
sudo yum install mono-devel
+
</pre>
+
  
Sinon, taper (prérequis [[Dependencies#Installing from Mono Repository|avoir mis à jour le géstionnaire yum pour mono]]) :
+
Le script cleanaot.sh supprime les fichiers binaires utilisés par AOT. Vous devez l'exécuter si vous recompilez le code (pour être protégé même si vous exécutez makeaot).<br>
<pre>
+
<b>N'OUBLIEZ PAS de lancer makeaot.sh ou cleanaot.sh après la recompilation!</b><br>
sudo yum install mono-addon-devel
+
Les fichiers générés sont spécifiques à cette machine. <b>Ne pas copier les fichiers de code natif sur une autre machine, sauf si elle est absolument identique</b><br>
</pre>
+
Les .exe et .dll originaux sont toujours nécessaires<br>
  
Les deux commandes vont installer les dépendances nécessaires.
+
AOT est également possible dans Windows, mais en utilisant différents outils, et ceux-ci ajoutent des choses au dépôt central sur la machine, plus difficile à isoler et à maintenir. voir [https://docs.microsoft.com/en-us/dotnet/framework/tools/ngen-exe-native-image-generator ngen]<br>
  
====Installer NAnt====
+
Les Macs sont.. Les Macs.. Les futurs modèles pourraient totalement interdire le JIT, comme le font les produits mobiles d'Apple. Le Mono AOT sur les Macs actuels pourrait fonctionner comme sur Linux<br>
Lancez "yum info nant" pour trouver la version du paquet nant. Si vous avez trouvé le paquet tapez simplement :
+
<pre>
+
sudo yum install nant
+
</pre>
+
Maintenant, vous pouvez exécuter NAnt.
+
  
Si vous ne trouvez pas le paquet nant dans le gestionnaire yum, ou si vous pensez que la version du paquet est trop récente pour compiler OpenSimulator, installez NAnt depuis [http://nant.sourceforge.net/ le site du projet NAnt]. Consultez le manuel des utilisateurs pour avoir des instructions détaillées. Ainsi, pour la version 0.90, vous devrez créer un script de démarrage comme ceci (attendu que vous avez installé NAnt dans /usr/local/nant) :
+
En pratique, ne vous attendez pas à un chargement plus rapide.
<pre>
+
De plus, comme la compilation est différente, elle peut ajouter de nouveaux problèmes. Donc, testez avec soin.<br>
sudo vi /usr/bin/nant
+
Les problèmes de performance d'Opensim concernent principalement son propre code, les terribles mauvais protocoles de communication, l'utilisation d'un mauvais code .net/mono framework (qualité de la démo dans les mêmes cas), etc.<br>
</pre>
+
Et bien sûr, GC stupide et éternellement brisé. <br>
Ensuite dans ce fichier :
+
''But... well every ns counts..''<br>
<pre>
+
#!/bin/sh
+
exec mono /usr/local/nant/bin/NAnt.exe "$@"
+
</pre>
+
Après cela, rendez le fichier exécutable :
+
<pre>
+
sudo chmod +x /usr/bin/nant
+
</pre>
+
  
===CentOS, Redhat ===
+
= Configuration =
  
==== Installer EPEL Repo ====
+
Voir [[Configuration/fr|Configuration]].
  
<pre>
+
[[Category:French Translations]]
wget http://dl.fedoraproject.org/pub/epel/6/x86_64/epel-release-6-8.noarch.rpm
+
rpm -Uvh epel-release-6-8.noarch.rpm
+
</pre>
+
 
+
==== Paquages nécessaires pour pour Mono et GID+ ====
+
 
+
<pre>
+
yum install bison gettext glib2 freetype fontconfig libpng libpng-devel libX11 \
+
libX11-devel glib2-devel libgdi* libexif glibc-devel urw-fonts \
+
unzip gcc gcc-c++ automake autoconf \
+
libtool make bzip2 wget  pixman-devel \
+
fontconfig-devel freetype-devel libexif-devel \
+
libjpeg-devel libtiff-devel  giflib-devel
+
</pre>
+
 
+
==== Compiler  Mono ====
+
 
+
ps: -j 2 nombre de processeurs (ou core)
+
 
+
<pre>
+
cd /usr/local/src
+
wget http://download.mono-project.com/sources/mono/mono-3.0.4.tar.bz2
+
tar -jxvf mono-3.0.4.tar.bz2
+
cd mono-3.0.4
+
./configure --libdir=/usr/lib64
+
make -j 2
+
make install
+
</pre>
+
 
+
==== Installer GID+ ====
+
ps: -j 2 equal number of processor (or core)
+
 
+
<pre>
+
cd /usr/local/src
+
wget http://download.mono-project.com/sources/libgdiplus/libgdiplus-2.10.9.tar.bz2
+
tar -xvjf libgdiplus-2.10.9.tar.bz2
+
cd libgdiplus-2.10.9
+
./configure
+
make -j2
+
make install
+
</pre>
+
 
+
===openSUSE===
+
===FreeBSD ===
+
 
+
= Configuration =
+

Revision as of 04:08, 19 August 2021


Contents


Cette page couvre la compilation d'OpenSimulator à partir du code source pour plusieurs plateformes. S'il vous plaît, aidez-nous à garder cette page à jour pour au fur et à mesure que le projet progresse. Si vous voulez simplement lancer une instance d'OpenSimulator, téléchargez et lancez la version binaire à la place. Dans la plupart des cas, cette version fonctionne très bien.

Obtenir le code source

Allez à la page de téléchargement pour trouver des instructions et la dernière version du code source. Si vous voulez le code de développement courant,( comme par exemple la branche maître Git) allez à la page Developer_Documentation#Source_Code_Repository_Access.

Compiler

Autant cette page est longue, autant la compilation d'OpenSimulator est rapide. Reportez-vous au fichier BUILDING.txt inclus dans la distribution elle-même pour trouver des instructions simplifiées.

Conditions

OpenSimulator 0.9.0.x nécessite soit

Vous pouvez également avoir besoin de l'outil nant.

OpenSimulator >= 0.9.1 (y compris le master actuel) nécessite

Note: plutôt que d'utiliser les paquets Mono de votre distribution Linux, qui peuvent manquer de composants requis, veuillez installer à partir du dépôt officiel de Mono pour votre distribution. Il est recommandé de compiler avec msbuild.

D'autres plateformes peuvent avoir leurs propres distributions mono, ou peuvent avoir besoin de compiler mono.

D'autres bibliothèques utilisées par OpenSimulator peuvent être trouvées dans notre dépôt git opensim-libs :

git clone git://opensimulator.org/git/opensim-libs

La bibliothèque libOpenMetaVerse utilisée peut être trouvé sur https://bitbucket.org/opensimulator/

Vous devrez peut-être les compiler pour votre plate-forme, en particulier les bibliothèques non gérées comme les bibliothèques de code natif Bullet ou ODE.

Microsoft Windows

Compilateurs supportés

  • Visual Studio Community 2017
  • Ou toute autre version qui supporte la version .Net. Au moins VS2010 pour les versions antérieures à 0.91, VS2015 pour les versions 0.91 et ultérieures.
  • OpenSimulator 0.9.2 supporte Microsoft Visual Studio 2019 (runprebuild.bat ln11-18).

Compiler dans un IDE

  1. Lancez "runprebuild.bat".
  2. Ouvrez le fichier "OpenSim.sln" résultant dans L'IDE Visual Studio.
  3. Sélectionnez la configuration Debug ou Release
  4. Menu Build -> Build Solution.

Compiler en ligne de commande

  1. Lancez "runprebuild.bat".
  2. Lancez le fichier "compile.bat" résultant.

Linux et autres plates-formes mono

Préparer la compilation

Pour créer les différents fichiers du projet, exécuter dans le dossier opensim :

 ./runprebuild.sh

Compiler avec Nant

Sur certaines versions de mono, en particulier les anciennes versions peuvent nécessiter d'utiliser l'utilisation de nant pour compiler correctement OpenSimulator, dans ce cas il suffit d'exécuter :

nant

Compiler avec xbuild

Sur les versions mono, vous pouvez simplement utiliser xbuild. (msbuild est recommandé pour la version 0.9.1.0.0+)

 xbuild

xbuild n'est plus recommandé sur mono 5.x, mais fonctionne toujours actuellement (5.12)

>>>> L'outil xbuild est obsolète et sera supprimé dans les prochaines mises à jour, utilisez plutôt msbuild <<<<

Sur les versions mono plus récentes, la configuration de la version peut donner un certain gain de performance, mais vous perdez certaines capacités de débogage.
Compiler avec la configuration Release :

   xbuild /p:Configuration=Release

Compiler avec msbuild

Pour Opensim 0.9.1 vous pouver encore utiliser xbuild mais Mono recommande l'utilisation de msbuild. Pour cela, vous devrez peut-être installer le paquet msbuild en plus de mono-complete. (Actuellement, msbuild est inclus si vous installez mono-complete, sur Ubuntu, à partir des dépôts mono officiels. https://www.mono-project.com/download/stable/#download-lin ).

Utilisez xbuild sur les autres cas en dernier recours.

Des améliorations récentes, en particulier sur le runtime JIT, justifient la compilation en configuration Release, mais vous perdez certaines capacités de débogage.

Compiler avec la configuration de débogage :

  msbuild

Compiler avec la configuration Release :

  msbuild /p:Configuration=Release

Compiler avec la configuration debug et afin que le fichier détaillé OpenSim.log puisse être lu avec un éditeur de texte :

  msbuild /p:Configuration=Debug /fileLogger /flp:logfile=opensim.log /v:d

Vous pouvez spécifier les valeurs suivantes pour définir le niveau de détail du fichier OpenSim.log :

  q [quiet], m [minimal], n [normal], d [detailed] and diag [diagnostic].

Compilation anticipée (Ahead of Time compilation) (AOT)

Comme vous le savez tous, les fichiers *.exe et .dll créés par le processus de compilation ci-dessus ne contiennent pas de code natif pour la machine.
Avec ces fichiers, le code natif requis par l'ordinateur est créé au moment de l'exécution, selon les besoins, dans un processus appelé Just in Time (JIT)(compilation à la volée).
Il est possible de faire une autre niveau de compilation sur ces fichiers pour créer un code natif, qui sera prêt au démarrage du programme. C'est le processus AOT (Ahead of time process).
Comme le JIT se fait à l'exécution, il dispose d'un temps limité pour effectuer des optimisations de code étendues, AOT, en revanche, peut tout faire.
AOT devrait ainsi être plus rapide à charger, économiser la mémoire nécessaire au travail du JIT et réduire la latence due à la génération de code lorsqu'une nouvelle section de code est nécessaire.
De cette façon, AOT contribue à réduire l'énorme écart de performance entre le C# et un langage plus approprié comme le C++, même si le JIT peut effectuer une certaine optimisation en fonction de l'état d'exécution du code, ce que AOT ne peut pas faire. (si vous pensez que c# est aussi rapide qu'un code C++ efficace, mieux vaut fumez autre chose...)
En fait, aussi bien .net que mono utilisent AOT sur leurs composants lors de l'installation
Le JIT sera toujours actif et compilera un autre code au moment de l'exécution. OpenSim et les parties utilisées du framework .net/mono en dépendent.

Pour Linux, la version 0.9.2.0 inclut désormais les scripts makeaot.sh et cleanaot.sh pour aider à tester AOT.
Lancez makeaot.sh après l'étape de compilation ci-dessus, pour générer les fichiers de code natif. L'option -O=all doit être ajoutée à mono lors de l'exécution de opensim.exe, ex:

 mono --desktop -O=all OpenSim.exe

Le script cleanaot.sh supprime les fichiers binaires utilisés par AOT. Vous devez l'exécuter si vous recompilez le code (pour être protégé même si vous exécutez makeaot).
N'OUBLIEZ PAS de lancer makeaot.sh ou cleanaot.sh après la recompilation!
Les fichiers générés sont spécifiques à cette machine. Ne pas copier les fichiers de code natif sur une autre machine, sauf si elle est absolument identique
Les .exe et .dll originaux sont toujours nécessaires

AOT est également possible dans Windows, mais en utilisant différents outils, et ceux-ci ajoutent des choses au dépôt central sur la machine, plus difficile à isoler et à maintenir. voir ngen

Les Macs sont.. Les Macs.. Les futurs modèles pourraient totalement interdire le JIT, comme le font les produits mobiles d'Apple. Le Mono AOT sur les Macs actuels pourrait fonctionner comme sur Linux

En pratique, ne vous attendez pas à un chargement plus rapide. De plus, comme la compilation est différente, elle peut ajouter de nouveaux problèmes. Donc, testez avec soin.
Les problèmes de performance d'Opensim concernent principalement son propre code, les terribles mauvais protocoles de communication, l'utilisation d'un mauvais code .net/mono framework (qualité de la démo dans les mêmes cas), etc.
Et bien sûr, GC stupide et éternellement brisé.
But... well every ns counts..

Configuration

Voir Configuration.

Personal tools
General
About This Wiki