removed contrib/docker/Dockerfile for gcc 4.8 for Ubuntu 16.04 - not tested (#648)

updated the contrib/docker/README.md to align with the latest updates

updated formatting for contrib/docker/README.md

renamed INSTALL to INSTALL.md

updated formatting for INSTALL.md

INSTALL → INSTALL.md

@@ -36,6 +36,7 @@ General Instructions
 These instructions assume that your system has been prepared in accordance
 with the above prerequisites.
 
+```
 $ cd ngraph
 $ mkdir build
 $ cd build
@@ -43,3 +44,4 @@ $ cmake .. \
     -DCMAKE_C_COMPILER=<path to C compiler> \
     -DCMAKE_CXX_COMPILER=<path to C++ compiler>
 $ make -j install
+```

contrib/docker/Dockerfile.ngraph.ubuntu1604_gcc48

-# Environment to build and unit-test ngraph
-
-FROM ubuntu:16.04
-
-RUN apt-get update && apt-get install -y \
-        build-essential cmake \
-        git \
-        wget patch diffutils zlib1g-dev libtinfo-dev \
-        doxygen python-pip
-
-RUN which gcc && gcc --version || true
-RUN which cc++ && cc++ --version || true
-
-RUN apt-get install -y gcc-4.8 gcc++-4.8
-
-RUN which gcc && gcc --version || true
-RUN which cc++ && cc++ --version || true
-
-RUN ln -s /usr/bin/gcc-4.8 /usr/bin/gcc || true
-RUN ln -s /usr/bin/cc++-4.8 /usr/bin/cc++ || true
-RUN which gcc && gcc --version || true
-RUN which cc++ && cc++ --version || true
-
-#RUN apt-get clean autoclean && \
-#    apt-get autoremove -y
-RUN pip install --upgrade pip
-
-# need to use sphinx version 1.6 to build docs
-# installing with apt-get install python-sphinx installs sphinx version 1.3.6 only
-# added install for python-pip above and
-# installed sphinx with pip to get the updated version 1.6.5
-# allows for make html build under the doc/source directory as an interim build process
-RUN pip install sphinx
-
-# breathe package required to build documentation
-RUN pip install breathe
-
-WORKDIR /home
-

contrib/docker/README.md

@@ -10,11 +10,11 @@ The `Makefile` provides targets for:
 * Building ngraph and running unit tests in this cloned repo, mounted into the docker image of the _reference-OS_
 * Starting an interactive shell in the _reference-OS_ docker image, with the cloned repo available for manual builds and unit testing
 
-The _make targets_ are designed to handle all aspects of building the _reference-OS_ docker image, running ngraph builds and unit testing in it, and opening up a session in the docker image for interactive use.  You should not need to issue any manual commands (unless you want to).  In addition the `Dockerfile.ngraph_cpu` provides a description of how the _reference-OS_ is built, should you want to build your own server or docker image.
+The _make_ targets are designed to handle all aspects of building the _reference-OS_ docker image, running ngraph builds and unit testing in it, and opening up a session in the docker image for interactive use.  You should not need to issue any manual commands (unless you want to).  In addition the `Dockerfile.ngraph.*` files provide a description of how each _reference-OS_ environment is built, should you want to build your own server or docker image.
 
 ## Prerequisites
 
-In order to use the make targets, you will need to do the following:
+In order to use the _make_ targets, you will need to do the following:
 
 * Have docker installed on your computer with the docker daemon running.
 * These scripts assume that you are able to run the `docker` command without using `sudo`.  You will need to add your account to the `docker` group so this is possible.
@@ -23,13 +23,13 @@ In order to use the make targets, you will need to do the following:
 
 ## Make Targets
 
-The _make targets_ are designed to provide easy commands to run actions using the docker image.  All _make targets_ should be issued on the host OS, and _not_ in a docker image.
+The _make_ targets are designed to provide easy commands to run actions using the docker image.  All _make_ targets should be issued on the host OS, and _not_ in a docker image.
 
-Most make targets are structured in the form `<action>_<compiler>`.  The `<action>` indicates what you want to do (e.g. build, check, install), while the `<compiler>` indicates what you want to build with (i.e. gcc or clang).
+Most _make_ targets are structured in the form `<action>_<compiler>`.  The `<action>` indicates what you want to do (e.g. build, check, install), while the `<compiler>` indicates what you want to build with (i.e. gcc or clang).
 
 * In general, you simply need to run the command **`make check_all`**.  This first makes the `build_docker_ngraph` target as a dependency.  Then it makes the `build_*` and `check_*` targets, which will build ngraph using _cmake_ and _make_ and then run unit testing.  Please keep in mind that `make check_*` targets do not work when your working directory is in an NFS filesystem that uses _root squash_ (see **Notes** section below).
 
-* Two builds are supported: building with `gcc` and `clang`.  Targets are named `*_gcc` and `*_clang` when they refer to building with a specific compiler, and the `*_all` targets are available to build with both compilers.  Output directories are BUILD-GCC and BUILD-CLANG, at the top level.
+* Two builds types are supported: building with `gcc` and `clang`.  Targets are named `*_gcc` and `*_clang` when they refer to building with a specific compiler, and the `*_all` targets are available to build with both compilers.  Output directories are BUILD-GCC and BUILD-CLANG, at the top level.
 
 * You can also run the command **`make shell`** to start an interactive bash shell inside the docker image.  While this is not required for normal builds and unit testing, it allows you to run interactively within the docker image with the cloned repo mounted.  Again, `build_docker_ngraph` is made first as a dependency.  Please keep in mind that `make shell` does not work when your working directory is in an NFS filesystem that uses _root squash_ (see **Notes** section below).
 
@@ -39,6 +39,29 @@ Most make targets are structured in the form `<action>_<compiler>`.  The `<actio
 
 Note that all operations performed inside the the docker image are run as a regular user, using the `run-as-user.sh` script.  This is done to avoid writing root-owned files in mounted filesystems.
 
+## Examples/Hints
+
+* To build an Ubuntu 16.04 docker container, compile with gcc 5.4, and run unit tests:
+
+```
+cd contrib/docker
+make check_gcc
+```
+
+* To build an Ubuntu 16.04 docker container, compile with clang 3.9, and run unit tests:
+
+```
+cd contrib/docker
+make check_clang
+```
+
+* To build a CentOS 7.4 docker container, compile with gcc 4.8.5, and run unit tests:
+
+```
+cd contrib/docker
+make check_gcc OS=centos74 DOCKERFILE=Dockerfile.ngraph.centos74_cmake3
+```
+
 ## Helper Scripts
 
 These helper scripts are included for use in the `Makefile` and automated (Jenkins) jobs.  **These scripts should _not_ be called directly unless you understand what they do.**
@@ -51,10 +74,48 @@ A helper script for Jenkins jobs to clean up old exited docker containers and `n
 
 A helper script to run as a normal user within the docker container.  This is done to avoid writing root-owned files in mounted filesystems.
 
+#### `run_as_ubuntu_user.sh`
+
+Same as `run_as_user.sh`, specifically called for _make_ targets with Ubuntu 16.04 docker containers.
+
+#### `run_as_centos_user.sh`
+
+A helper script to run as a normal user within a CentOS 7.4 docker container.
+
 ## Notes
 
 * The top-level `Makefile` in this cloned repo can be used to build and unit-test ngraph _outside_ of docker.  This directory is only for building and running unit tests for ngraph in the _reference-OS_ docker image.
 
-* Due to limitations in how docker mounts work, `make check_cpu` and `make shell` will fail if you try to run them while in a working directory that is in an NFS-mount that has _root squash_ enabled.  The cause results from the process in the docker container running as root.  When a file or directory is created by root in the mounted directory tree, from within the docker image, the NFS-mount (in the host OS) does not allow a root-created file, leading to a permissions error.  This is dependent on whether the host OS performs "root squash" when mounting NFS filesystems.  The fix to this is easy: run `make check_cpu` and `make shell` from a local filesystem.
+* Due to limitations in how docker mounts work, `make check_*` and `make shell` targets will fail if you try to run them while in a working directory that is in an NFS-mount that has _root squash_ enabled.  The cause results from the process in the docker container running as root.  When a file or directory is created by root in the mounted directory tree, from within the docker image, the NFS-mount (in the host OS) does not allow a root-created file, leading to a permissions error.  This is dependent on whether the host OS performs "root squash" when mounting NFS filesystems.  The fix to this is easy: run `make check_*` and `make shell` from a local filesystem.
+
+* The _make_ targets have been tested with the following docker containers on an Ubuntu 16.04 host OS with docker installed and the docker daemon properly configured.  Some adjustments may be needed to run these on other OSes.
+
+#### Ubuntu 16.04 (default)
+
+```
+Dockerfile: Dockerfile.ngraph
+Reference-OS: Ubuntu 16.04
+BUILD-GCC: gcc 5.4
+BUILD-CLANG: clang 3.9
+pre-built LLVM
+```
+
+#### Ubuntu 16.04
+
+```
+Dockerfile: Dockerfile.ngraph.ubuntu1604
+(same as above)
+separate Dockerfile for ease of reference
+```
+
+#### CentOS 7.4 
+
+```
+Dockerfile: Dockerfile.ngraph.centos74_cmake3
+Reference-OS: Centos 7.4.1708
+BUILD-GCC: gcc 4.8.5
+BUILD-CLANG: not supported
+pre-built cmake3
+LLVM built from source
+```
 
-* These make targets have been tested on Ubuntu 16.04 with docker installed and the docker daemon properly configured.  Some adjustments may be needed to run these on other OSes.