<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"
                      "http://www.w3.org/TR/html4/strict.dtd">
<html>
<head>
  <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
  <title>
    How To Add Your Build Configuration To LLVM Buildbot Infrastructure
  </title>
  <link rel="stylesheet" href="llvm.css" type="text/css">
</head>
<body>

<h1>How To Add Your Build Configuration To LLVM Buildbot Infrastructure</h1>
<ol>
  <li><a href="#introduction">Introduction</a></li>
  <li><a href="#steps">Steps To Add Builder To LLVM Buildbot</a></li>
</ol>
<div class="doc_author">
  <p>Written by <a href="mailto:gkistanova@gmail.com">Galina Kistanova</a></p>
</div>

<!-- *********************************************************************** -->
<h2><a name="introduction">Introduction</a></h2>
<!-- *********************************************************************** -->

<div>

<p>This document contains information about adding a build configuration and
   buildslave to private slave builder to LLVM Buildbot Infrastructure
   <a href="http://lab.llvm.org:8011">http://lab.llvm.org:8011</a></p>

</div>

<!-- *********************************************************************** -->
<h2><a name="steps">Steps To Add Builder To LLVM Buildbot</a></h2>
<!-- *********************************************************************** -->

<div>

<p>Volunteers can provide their build machines to work as build slaves to
   public LLVM Buildbot.</p>

<p>Here are the steps you can follow to do so:</p>

<ol>
  <li><p>Check the existing build configurations to make sure the one you are
      interested in is not covered yet or gets built on your computer much
      faster than on the existing one. We prefer faster builds so developers
      will get feedback sooner after changes get committed.</p></li>

  <li><p>The computer you will be registering with the LLVM buildbot
      infrastructure should have all dependencies installed and you can
      actually build your configuration successfully. Please check what degree
      of parallelism (-j param) would give the fastest build.
      You can build multiple configurations on one computer.</p></li>

  <li><p>Install buildslave (currently we are using buildbot version 0.8.5).
      Depending on the platform, buildslave could be available to download and
      install with your packet manager, or you can download it directly from
      <a href="http://trac.buildbot.net">http://trac.buildbot.net</a> and
      install it manually.</p></li>

  <li><p>Create a designated user account, your buildslave will be running
      under, and set appropriate permissions.</p></li>

  <li><p>Choose the buildslave root directory (all builds will be placed under
      it), buildslave access name and password the build master will be using
      to authenticate your buildslave.</p></li>

  <li><p>Create a buildslave in context of that buildslave account.
      Point it to the <b>lab.llvm.org</b> port <b>9990</b> (see
      <a href="http://buildbot.net/buildbot/docs/current/full.html#creating-a-slave">
      Buildbot documentation, Creating a slave</a>
      for more details) by running the following command:</p>

<div class="doc_code">
<pre>
$ buildslave create-slave <i>buildslave-root-directory</i> \
             lab.llvm.org:9990 \
             <i>buildslave-access-name buildslave-access-password</i>
</pre>
</div></li>

  <li><p>Fill the buildslave description and admin name/e-mail.
      Here is an example of the buildslave description:</p>

<div class="doc_code">
<pre>
Windows 7 x64
Core i7 (2.66GHz), 16GB of RAM

g++.exe (TDM-1 mingw32) 4.4.0
GNU Binutils 2.19.1
cmake version 2.8.4
Microsoft(R) 32-bit C/C++ Optimizing Compiler Version 16.00.40219.01 for 80x86
</pre>
</div></li>

  <li><p>Make sure you can actually start the buildslave successfully. Then set
      up your buildslave to start automatically at the start up time.
      See the buildbot documentation for help.
      You may want to restart your computer to see if it works.</p></li>

  <li><p>Send a patch which adds your build slave and your builder to zorg.</p>
      <ul>
          <li>slaves are added to
              <tt>buildbot/osuosl/master/config/slaves.py</tt></li>
          <li>builders are added to
              <tt>buildbot/osuosl/master/config/builders.py</tt></li>
      </ul></li>

  <li><p>Send the buildslave access name and the access password directly
      to <a href="mailto:gkistanova@gmail.com">Galina Kistanova</a>, and wait
      till she will let you know that your changes are applied and buildmaster
      is reconfigured.</p>

  <li><p>Check the status of your buildslave on the
      <a href="http://lab.llvm.org:8011/waterfall">Waterfall Display</a>
      to make sure it is connected, and
      <a href="http://lab.llvm.org:8011/buildslaves/your-buildslave-name">
      http://lab.llvm.org:8011/buildslaves/&lt;your-buildslave-name&gt;</a>
      to see if administrator contact and slave information are correct.</p>
      </li>

  <li><p>Wait for the first build to succeed and enjoy.</p></li>
</ol>

</div>

<!-- *********************************************************************** -->
<hr>
<address>
  <a href="http://jigsaw.w3.org/css-validator/check/referer"><img
  src="http://jigsaw.w3.org/css-validator/images/vcss-blue" alt="Valid CSS"></a>
  <a href="http://validator.w3.org/check/referer"><img
  src="http://www.w3.org/Icons/valid-html401-blue" alt="Valid HTML 4.01"></a>
  <a href="http://llvm.org/">The LLVM Compiler Infrastructure</a>
  <br>
  Last modified: $Date: 2011-10-31 12:50:0 -0700 (Mon, 31 Oct 2011) $
</address>
</body>
</html>
