<!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="_static/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>
