Merge branch 'add_arrayHandle'

CMake/CheckCXX11Features.cmake

@@ -0,0 +1,142 @@
+# - Check which parts of the C++11 standard the compiler supports
+#
+# When found it will set the following variables
+#
+#  CXX11_COMPILER_FLAGS         - the compiler flags needed to get C++11 features
+#
+#  HAS_CXX11_AUTO               - auto keyword
+#  HAS_CXX11_AUTO_RET_TYPE      - function declaration with deduced return types
+#  HAS_CXX11_CLASS_OVERRIDE     - override and final keywords for classes and methods
+#  HAS_CXX11_CONSTEXPR          - constexpr keyword
+#  HAS_CXX11_CSTDINT_H          - cstdint header
+#  HAS_CXX11_DECLTYPE           - decltype keyword
+#  HAS_CXX11_FUNC               - __func__ preprocessor constant
+#  HAS_CXX11_INITIALIZER_LIST   - initializer list
+#  HAS_CXX11_LAMBDA             - lambdas
+#  HAS_CXX11_LIB_REGEX          - regex library
+#  HAS_CXX11_LONG_LONG          - long long signed & unsigned types
+#  HAS_CXX11_NULLPTR            - nullptr
+#  HAS_CXX11_RVALUE_REFERENCES  - rvalue references
+#  HAS_CXX11_SIZEOF_MEMBER      - sizeof() non-static members
+#  HAS_CXX11_STATIC_ASSERT      - static_assert()
+#  HAS_CXX11_VARIADIC_TEMPLATES - variadic templates
+
+#=============================================================================
+# Copyright 2011,2012 Rolf Eike Beer <eike@sf-mail.de>
+# Copyright 2012 Andreas Weis
+#
+# Distributed under the OSI-approved BSD License (the "License");
+# see accompanying file Copyright.txt for details.
+#
+# This software is distributed WITHOUT ANY WARRANTY; without even the
+# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+# See the License for more information.
+#=============================================================================
+# (To distribute this file outside of CMake, substitute the full
+#  License text for the above reference.)
+
+#
+# Each feature may have up to 3 checks, every one of them in it's own file
+# FEATURE.cpp              - example that must build and return 0 when run
+# FEATURE_fail.cpp         - example that must build, but may not return 0 when run
+# FEATURE_fail_compile.cpp - example that must fail compilation
+#
+# The first one is mandatory, the latter 2 are optional and do not depend on
+# each other (i.e. only one may be present).
+#
+
+if (NOT CMAKE_CXX_COMPILER_LOADED)
+    message(FATAL_ERROR "CheckCXX11Features modules only works if language CXX is enabled")
+endif ()
+
+cmake_minimum_required(VERSION 2.8.3)
+
+#
+### Check for needed compiler flags
+#
+include(CheckCXXCompilerFlag)
+check_cxx_compiler_flag("-std=c++11" _HAS_CXX11_FLAG)
+if (NOT _HAS_CXX11_FLAG)
+    check_cxx_compiler_flag("-std=c++0x" _HAS_CXX0X_FLAG)
+endif ()
+
+if (_HAS_CXX11_FLAG)
+    set(CXX11_COMPILER_FLAGS "-std=c++11")
+elseif (_HAS_CXX0X_FLAG)
+    set(CXX11_COMPILER_FLAGS "-std=c++0x")
+endif ()
+
+function(cxx11_check_feature FEATURE_NAME RESULT_VAR)
+    if (NOT DEFINED ${RESULT_VAR})
+        set(_bindir "${CMAKE_CURRENT_BINARY_DIR}/cxx11_${FEATURE_NAME}")
+
+        set(_SRCFILE_BASE ${CMAKE_CURRENT_LIST_DIR}/CheckCXX11Features/cxx11-test-${FEATURE_NAME})
+        set(_LOG_NAME "\"${FEATURE_NAME}\"")
+        message(STATUS "Checking C++11 support for ${_LOG_NAME}")
+
+        set(_SRCFILE "${_SRCFILE_BASE}.cpp")
+        set(_SRCFILE_FAIL "${_SRCFILE_BASE}_fail.cpp")
+        set(_SRCFILE_FAIL_COMPILE "${_SRCFILE_BASE}_fail_compile.cpp")
+
+        if (CROSS_COMPILING)
+            try_compile(${RESULT_VAR} "${_bindir}" "${_SRCFILE}"
+                        COMPILE_DEFINITIONS "${CXX11_COMPILER_FLAGS}")
+            if (${RESULT_VAR} AND EXISTS ${_SRCFILE_FAIL})
+                try_compile(${RESULT_VAR} "${_bindir}_fail" "${_SRCFILE_FAIL}"
+                            COMPILE_DEFINITIONS "${CXX11_COMPILER_FLAGS}")
+            endif (${RESULT_VAR} AND EXISTS ${_SRCFILE_FAIL})
+        else (CROSS_COMPILING)
+            try_run(_RUN_RESULT_VAR _COMPILE_RESULT_VAR
+                    "${_bindir}" "${_SRCFILE}"
+                    COMPILE_DEFINITIONS "${CXX11_COMPILER_FLAGS}")
+            if (_COMPILE_RESULT_VAR AND NOT _RUN_RESULT_VAR)
+                set(${RESULT_VAR} TRUE)
+            else (_COMPILE_RESULT_VAR AND NOT _RUN_RESULT_VAR)
+                set(${RESULT_VAR} FALSE)
+            endif (_COMPILE_RESULT_VAR AND NOT _RUN_RESULT_VAR)
+            if (${RESULT_VAR} AND EXISTS ${_SRCFILE_FAIL})
+                try_run(_RUN_RESULT_VAR _COMPILE_RESULT_VAR
+                        "${_bindir}_fail" "${_SRCFILE_FAIL}"
+                         COMPILE_DEFINITIONS "${CXX11_COMPILER_FLAGS}")
+                if (_COMPILE_RESULT_VAR AND _RUN_RESULT_VAR)
+                    set(${RESULT_VAR} TRUE)
+                else (_COMPILE_RESULT_VAR AND _RUN_RESULT_VAR)
+                    set(${RESULT_VAR} FALSE)
+                endif (_COMPILE_RESULT_VAR AND _RUN_RESULT_VAR)
+            endif (${RESULT_VAR} AND EXISTS ${_SRCFILE_FAIL})
+        endif (CROSS_COMPILING)
+        if (${RESULT_VAR} AND EXISTS ${_SRCFILE_FAIL_COMPILE})
+            try_compile(_TMP_RESULT "${_bindir}_fail_compile" "${_SRCFILE_FAIL_COMPILE}"
+                        COMPILE_DEFINITIONS "${CXX11_COMPILER_FLAGS}")
+            if (_TMP_RESULT)
+                set(${RESULT_VAR} FALSE)
+            else (_TMP_RESULT)
+                set(${RESULT_VAR} TRUE)
+            endif (_TMP_RESULT)
+        endif (${RESULT_VAR} AND EXISTS ${_SRCFILE_FAIL_COMPILE})
+
+        if (${RESULT_VAR})
+            message(STATUS "Checking C++11 support for ${_LOG_NAME}: works")
+        else (${RESULT_VAR})
+            message(STATUS "Checking C++11 support for ${_LOG_NAME}: not supported")
+        endif (${RESULT_VAR})
+        set(${RESULT_VAR} ${${RESULT_VAR}} CACHE INTERNAL "C++11 support for ${_LOG_NAME}")
+    endif (NOT DEFINED ${RESULT_VAR})
+endfunction(cxx11_check_feature)
+
+cxx11_check_feature("__func__" HAS_CXX11_FUNC)
+cxx11_check_feature("auto" HAS_CXX11_AUTO)
+cxx11_check_feature("auto_ret_type" HAS_CXX11_AUTO_RET_TYPE)
+cxx11_check_feature("class_override_final" HAS_CXX11_CLASS_OVERRIDE)
+cxx11_check_feature("constexpr" HAS_CXX11_CONSTEXPR)
+cxx11_check_feature("cstdint" HAS_CXX11_CSTDINT_H)
+cxx11_check_feature("decltype" HAS_CXX11_DECLTYPE)
+cxx11_check_feature("initializer_list" HAS_CXX11_INITIALIZER_LIST)
+cxx11_check_feature("lambda" HAS_CXX11_LAMBDA)
+cxx11_check_feature("long_long" HAS_CXX11_LONG_LONG)
+cxx11_check_feature("nullptr" HAS_CXX11_NULLPTR)
+cxx11_check_feature("regex" HAS_CXX11_LIB_REGEX)
+cxx11_check_feature("rvalue-references" HAS_CXX11_RVALUE_REFERENCES)
+cxx11_check_feature("sizeof_member" HAS_CXX11_SIZEOF_MEMBER)
+cxx11_check_feature("static_assert" HAS_CXX11_STATIC_ASSERT)
+cxx11_check_feature("variadic_templates" HAS_CXX11_VARIADIC_TEMPLATES)

CMake/CheckCXX11Features/cxx11-test-__func__.cpp

@@ -0,0 +1,8 @@
+int main(void)
+{
+	if (!__func__)
+		return 1;
+	if (!(*__func__))
+		return 1;
+	return 0;
+}

CMake/CheckCXX11Features/cxx11-test-auto.cpp

@@ -0,0 +1,12 @@
+
+int main()
+{
+	auto i = 5;
+	auto f = 3.14159f;
+	auto d = 3.14159;
+	bool ret = (
+		(sizeof(f) < sizeof(d)) &&
+		(sizeof(i) == sizeof(int))
+	);
+	return ret ? 0 : 1;
+}

CMake/CheckCXX11Features/cxx11-test-auto_fail_compile.cpp

@@ -0,0 +1,7 @@
+int main(void)
+{
+	// must fail because there is no initializer
+	auto i;
+
+	return 0;
+}

CMake/CheckCXX11Features/cxx11-test-auto_ret_type.cpp

@@ -0,0 +1,8 @@
+auto foo(int i) -> int {
+	return i - 1;
+}
+
+int main()
+{
+	return foo(1);
+}

CMake/CheckCXX11Features/cxx11-test-class_override_final.cpp

@@ -0,0 +1,21 @@
+class base {
+public:
+    virtual int foo(int a)
+     { return 4 + a; }
+    int bar(int a) final
+     { return a - 2; }
+};
+
+class sub final : public base {
+public:
+    virtual int foo(int a) override
+     { return 8 + 2 * a; };
+};
+
+int main(void)
+{
+    base b;
+    sub s;
+
+    return (b.foo(2) * 2 == s.foo(2)) ? 0 : 1;
+}

CMake/CheckCXX11Features/cxx11-test-class_override_final_fail_compile.cpp

@@ -0,0 +1,25 @@
+class base {
+public:
+    virtual int foo(int a)
+     { return 4 + a; }
+    virtual int bar(int a) final
+     { return a - 2; }
+};
+
+class sub final : public base {
+public:
+    virtual int foo(int a) override
+     { return 8 + 2 * a; };
+    virtual int bar(int a)
+     { return a; }
+};
+
+class impossible : public sub { };
+
+int main(void)
+{
+    base b;
+    sub s;
+
+    return 1;
+}

CMake/CheckCXX11Features/cxx11-test-constexpr.cpp

@@ -0,0 +1,19 @@
+constexpr int square(int x)
+{
+	return x*x;
+}
+
+constexpr int the_answer()
+{
+	return 42;
+}
+
+int main()
+{
+	int test_arr[square(3)];
+	bool ret = (
+		(square(the_answer()) == 1764) &&
+		(sizeof(test_arr)/sizeof(test_arr[0]) == 9)
+	);
+	return ret ? 0 : 1;
+}

CMake/CheckCXX11Features/cxx11-test-cstdint.cpp

@@ -0,0 +1,11 @@
+#include <cstdint>
+
+int main()
+{
+	bool test =
+		(sizeof(int8_t) == 1) &&
+		(sizeof(int16_t) == 2) &&
+		(sizeof(int32_t) == 4) &&
+		(sizeof(int64_t) == 8);
+	return test ? 0 : 1;
+}

CMake/CheckCXX11Features/cxx11-test-decltype.cpp

@@ -0,0 +1,10 @@
+bool check_size(int i)
+{
+	return sizeof(int) == sizeof(decltype(i));
+}
+
+int main()
+{
+	bool ret = check_size(42);
+	return ret ? 0 : 1;
+}

CMake/CheckCXX11Features/cxx11-test-initializer_list.cpp

@@ -0,0 +1,27 @@
+#include <vector>
+
+class seq {
+public:
+    seq(std::initializer_list<int> list);
+
+    int length() const;
+private:
+    std::vector<int> m_v;
+};
+
+seq::seq(std::initializer_list<int> list)
+    : m_v(list)
+{
+}
+
+int seq::length() const
+{
+    return m_v.size();
+}
+
+int main(void)
+{
+    seq a = {18, 20, 2, 0, 4, 7};
+
+    return (a.length() == 6) ? 0 : 1;
+}

CMake/CheckCXX11Features/cxx11-test-lambda.cpp

@@ -0,0 +1,5 @@
+int main()
+{
+	int ret = 0;
+	return ([&ret]() -> int { return ret; })();
+}

CMake/CheckCXX11Features/cxx11-test-long_long.cpp

@@ -0,0 +1,7 @@
+int main(void)
+{
+	long long l;
+	unsigned long long ul;
+
+	return ((sizeof(l) >= 8) && (sizeof(ul) >= 8)) ? 0 : 1;
+}

CMake/CheckCXX11Features/cxx11-test-nullptr.cpp

@@ -0,0 +1,6 @@
+int main(void)
+{
+	void *v = nullptr;
+
+	return v ? 1 : 0;
+}

CMake/CheckCXX11Features/cxx11-test-nullptr_fail_compile.cpp

@@ -0,0 +1,6 @@
+int main(void)
+{
+	int i = nullptr;
+
+	return 1;
+}

CMake/CheckCXX11Features/cxx11-test-regex.cpp

@@ -0,0 +1,26 @@
+#include <algorithm>
+#include <regex>
+
+int parse_line(std::string const& line)
+{
+	std::string tmp;
+	if(std::regex_search(line, std::regex("(\\s)+(-)?(\\d)+//(-)?(\\d)+(\\s)+"))) {
+		tmp = std::regex_replace(line, std::regex("(-)?(\\d)+//(-)?(\\d)+"), std::string("V"));
+	} else if(std::regex_search(line, std::regex("(\\s)+(-)?(\\d)+/(-)?(\\d)+(\\s)+"))) {
+		tmp = std::regex_replace(line, std::regex("(-)?(\\d)+/(-)?(\\d)+"), std::string("V"));
+	} else if(std::regex_search(line, std::regex("(\\s)+(-)?(\\d)+/(-)?(\\d)+/(-)?(\\d)+(\\s)+"))) {
+		tmp = std::regex_replace(line, std::regex("(-)?(\\d)+/(-)?(\\d)+/(-)?(\\d)+"), std::string("V"));
+	} else {
+		tmp = std::regex_replace(line, std::regex("(-)?(\\d)+"), std::string("V"));
+	}
+	return static_cast<int>(std::count(tmp.begin(), tmp.end(), 'V'));
+}
+
+int main()
+{
+	bool test = (parse_line("f 7/7/7 -3/3/-3 2/-2/2") == 3) &&
+				(parse_line("f 7//7 3//-3 -2//2") == 3) &&
+				(parse_line("f 7/7 3/-3 -2/2") == 3) &&
+				(parse_line("f 7 3 -2") == 3);
+	return test ? 0 : 1;
+}

CMake/CheckCXX11Features/cxx11-test-rvalue-references.cpp

@@ -0,0 +1,57 @@
+#include <cassert>
+
+class rvmove {
+public:
+   void *ptr;
+   char *array;
+
+   rvmove()
+    : ptr(0),
+    array(new char[10])
+   {
+     ptr = this;
+   }
+
+   rvmove(rvmove &&other)
+    : ptr(other.ptr),
+    array(other.array)
+   {
+    other.array = 0;
+    other.ptr = 0;
+   }
+
+   ~rvmove()
+   {
+    assert(((ptr != 0) && (array != 0)) || ((ptr == 0) && (array == 0)));
+    delete[] array;
+   }
+
+   rvmove &operator=(rvmove &&other)
+   {
+     delete[] array;
+     ptr = other.ptr;
+     array = other.array;
+     other.array = 0;
+     other.ptr = 0;
+     return *this;
+   }
+
+   static rvmove create()
+   {
+     return rvmove();
+   }
+private:
+  rvmove(const rvmove &);
+  rvmove &operator=(const rvmove &);
+};
+
+int main()
+{
+  rvmove mine;
+  if (mine.ptr != &mine)
+    return 1;
+  mine = rvmove::create();
+  if (mine.ptr == &mine)
+    return 1;
+  return 0;
+}

CMake/CheckCXX11Features/cxx11-test-sizeof_member.cpp

@@ -0,0 +1,14 @@
+struct foo {
+	char bar;
+	int baz;
+};
+
+int main(void)
+{
+	bool ret = (
+		(sizeof(foo::bar) == 1) &&
+		(sizeof(foo::baz) >= sizeof(foo::bar)) &&
+		(sizeof(foo) >= sizeof(foo::bar) + sizeof(foo::baz))
+	);
+	return ret ? 0 : 1;
+}

CMake/CheckCXX11Features/cxx11-test-sizeof_member_fail.cpp

@@ -0,0 +1,9 @@
+struct foo {
+	int baz;
+	double bar;
+};
+
+int main(void)
+{
+	return (sizeof(foo::bar) == 4) ? 0 : 1;
+}

CMake/CheckCXX11Features/cxx11-test-static_assert.cpp

@@ -0,0 +1,5 @@
+int main(void)
+{
+	static_assert(0 < 1, "your ordering of integers is screwed");
+	return 0;
+}

CMake/CheckCXX11Features/cxx11-test-static_assert_fail_compile.cpp

@@ -0,0 +1,5 @@
+int main(void)
+{
+	static_assert(1 < 0, "your ordering of integers is screwed");
+	return 0;
+}

CMake/CheckCXX11Features/cxx11-test-variadic_templates.cpp

@@ -0,0 +1,23 @@
+int Accumulate()
+{
+	return 0;
+}
+
+template<typename T, typename... Ts>
+int Accumulate(T v, Ts... vs)
+{
+	return v + Accumulate(vs...);
+}
+
+template<int... Is>
+int CountElements()
+{
+	return sizeof...(Is);
+}
+
+int main()
+{
+	int acc = Accumulate(1, 2, 3, 4, -5);
+	int count = CountElements<1,2,3,4,5>();
+	return ((acc == 5) && (count == 5)) ? 0 : 1;
+}

CMake/FindBoostHeaders.cmake

@@ -0,0 +1,438 @@
+#
+# - Finds the Boost headers only
+# Use this module by invoking find_package with the form:
+#  find_package(Boost
+#    [version] [EXACT]      # Minimum or EXACT version e.g. 1.36.0
+#    [REQUIRED]             # Fail with error if Boost is not found
+#    )
+#
+# This module finds boost headers the search for the boost headers results
+# reported in variables:
+#
+#  Boost_FOUND            - True if headers and requested libraries were found
+#  Boost_INCLUDE_DIRS     - Boost include directories
+#  Boost_VERSION          - BOOST_VERSION value from boost/version.hpp
+#  Boost_MAJOR_VERSION    - Boost major version number (X in X.y.z)
+#  Boost_MINOR_VERSION    - Boost minor version number (Y in x.Y.z)
+#  Boost_SUBMINOR_VERSION - Boost subminor version number (Z in x.y.Z)
+#
+# This module reads hints about search locations from variables:
+#  BOOST_INCLUDEDIR       - Preferred include directory e.g. <prefix>/include
+#  Boost_NO_SYSTEM_PATHS  - Set to ON to disable searching in locations not
+#                           specified by these hint variables. Default is OFF.
+#  Boost_ADDITIONAL_VERSIONS
+#                         - List of Boost versions not known to this module
+#                           (Boost install locations may contain the version)
+# and saves search results persistently in CMake cache entries:
+#  Boost_INCLUDE_DIR         - Directory containing Boost headers
+#
+# Users may set these hints or results as cache entries.  Projects should
+# not read these entries directly but instead use the above result variables.
+# Note that some hint names start in upper-case "BOOST".  One may specify
+# these as environment variables if they are not specified as CMake variables
+# or cache entries.
+#
+# This module first searches for the Boost header files using the above hint
+# variables  and saves the result in
+# Boost_INCLUDE_DIR.
+#
+#
+#=============================================================================
+# Copyright 2006-2012 Kitware, Inc.
+# Copyright 2006-2008 Andreas Schneider <mail@cynapses.org>
+# Copyright 2007      Wengo
+# Copyright 2007      Mike Jackson
+# Copyright 2008      Andreas Pakulat <apaku@gmx.de>
+# Copyright 2008-2012 Philip Lowman <philip@yhbt.com>
+#
+# CMake - Cross Platform Makefile Generator
+# Copyright 2000-2011 Kitware, Inc., Insight Software Consortium
+# All rights reserved.
+
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+#
+# * Redistributions of source code must retain the above copyright
+#   notice, this list of conditions and the following disclaimer.
+#
+# * Redistributions in binary form must reproduce the above copyright
+#   notice, this list of conditions and the following disclaimer in the
+#   documentation and/or other materials provided with the distribution.
+#
+# * Neither the names of Kitware, Inc., the Insight Software Consortium,
+#   nor the names of their contributors may be used to endorse or promote
+#   products derived from this software without specific prior written
+#   permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+# ------------------------------------------------------------------------------
+#
+# The above copyright and license notice applies to distributions of
+# CMake in source and binary form.  Some source files contain additional
+# notices of original copyright by their contributors; see each source
+# for details.  Third-party software packages supplied with CMake under
+# compatible licenses provide their own copyright notices documented in
+# corresponding subdirectories.
+#
+# ------------------------------------------------------------------------------
+#
+# CMake was initially developed by Kitware with the following sponsorship:
+#
+#  * National Library of Medicine at the National Institutes of Health
+#    as part of the Insight Segmentation and Registration Toolkit (ITK).
+#
+#  * US National Labs (Los Alamos, Livermore, Sandia) ASC Parallel
+#    Visualization Initiative.
+#
+#  * National Alliance for Medical Image Computing (NAMIC) is funded by the
+#    National Institutes of Health through the NIH Roadmap for Medical Research,
+#    Grant U54 EB005149.
+#
+#  * Kitware, Inc.
+#
+#
+#
+
+#-------------------------------------------------------------------------------
+#  FindBoost functions & macros
+#
+macro(_Boost_CHANGE_DETECT changed_var)
+  set(${changed_var} 0)
+  foreach(v ${ARGN})
+    if(DEFINED _Boost_COMPONENTS_SEARCHED)
+      if(${v})
+        if(_${v}_LAST)
+          string(COMPARE NOTEQUAL "${${v}}" "${_${v}_LAST}" _${v}_CHANGED)
+        else()
+          set(_${v}_CHANGED 1)
+        endif()
+      elseif(_${v}_LAST)
+        set(_${v}_CHANGED 1)
+      endif()
+      if(_${v}_CHANGED)
+        set(${changed_var} 1)
+      endif()
+    else()
+      set(_${v}_CHANGED 0)
+    endif()
+  endforeach()
+endmacro()
+
+#
+# Make sure the spelling of boost options is correct
+#
+function(_Boost_CHECK_SPELLING _var)
+  if(${_var})
+    string(TOUPPER ${_var} _var_UC)
+    message(FATAL_ERROR "ERROR: ${_var} is not the correct spelling.  The proper spelling is ${_var_UC}.")
+  endif()
+endfunction()
+
+#
+# End functions/macros
+#
+#-------------------------------------------------------------------------------
+
+#-------------------------------------------------------------------------------
+# main.
+#-------------------------------------------------------------------------------
+
+# Check the version of Boost against the requested version.
+if(Boost_FIND_VERSION AND NOT Boost_FIND_VERSION_MINOR)
+  message(SEND_ERROR "When requesting a specific version of Boost, you must provide at least the major and minor version numbers, e.g., 1.34")
+endif()
+
+if(Boost_FIND_VERSION_EXACT)
+  # The version may appear in a directory with or without the patch
+  # level, even when the patch level is non-zero.
+  set(_boost_TEST_VERSIONS
+    "${Boost_FIND_VERSION_MAJOR}.${Boost_FIND_VERSION_MINOR}.${Boost_FIND_VERSION_PATCH}"
+    "${Boost_FIND_VERSION_MAJOR}.${Boost_FIND_VERSION_MINOR}")
+else()
+  # The user has not requested an exact version.  Among known
+  # versions, find those that are acceptable to the user request.
+  set(_Boost_KNOWN_VERSIONS ${Boost_ADDITIONAL_VERSIONS}
+    "1.56.0" "1.56" "1.55.0" "1.55" "1.54.0" "1.54"
+    "1.53.0" "1.53" "1.52.0" "1.52" "1.51.0" "1.51"
+    "1.50.0" "1.50" "1.49.0" "1.49" "1.48.0" "1.48" "1.47.0" "1.47" "1.46.1"
+    "1.46.0" "1.46" "1.45.0" "1.45" "1.44.0" "1.44" "1.43.0" "1.43" "1.42.0" "1.42"
+    "1.41.0" "1.41" "1.40.0" "1.40" "1.39.0" "1.39" "1.38.0" "1.38" "1.37.0" "1.37"
+    "1.36.1" "1.36.0" "1.36" "1.35.1" "1.35.0" "1.35" "1.34.1" "1.34.0"
+    "1.34" "1.33.1" "1.33.0" "1.33")
+  set(_boost_TEST_VERSIONS)
+  if(Boost_FIND_VERSION)
+    set(_Boost_FIND_VERSION_SHORT "${Boost_FIND_VERSION_MAJOR}.${Boost_FIND_VERSION_MINOR}")
+    # Select acceptable versions.
+    foreach(version ${_Boost_KNOWN_VERSIONS})
+      if(NOT "${version}" VERSION_LESS "${Boost_FIND_VERSION}")
+        # This version is high enough.
+        list(APPEND _boost_TEST_VERSIONS "${version}")
+      elseif("${version}.99" VERSION_EQUAL "${_Boost_FIND_VERSION_SHORT}.99")
+        # This version is a short-form for the requested version with
+        # the patch level dropped.
+        list(APPEND _boost_TEST_VERSIONS "${version}")
+      endif()
+    endforeach()
+  else()
+    # Any version is acceptable.
+    set(_boost_TEST_VERSIONS "${_Boost_KNOWN_VERSIONS}")
+  endif()
+endif()
+
+# The reason that we failed to find Boost. This will be set to a
+# user-friendly message when we fail to find some necessary piece of
+# Boost.
+set(Boost_ERROR_REASON)
+
+if(Boost_DEBUG)
+  # Output some of their choices
+  message(STATUS "[ ${CMAKE_CURRENT_LIST_FILE}:${CMAKE_CURRENT_LIST_LINE} ] "
+                 "_boost_TEST_VERSIONS = ${_boost_TEST_VERSIONS}")
+  message(STATUS "[ ${CMAKE_CURRENT_LIST_FILE}:${CMAKE_CURRENT_LIST_LINE} ] "
+                 "Boost_ADDITIONAL_VERSIONS = ${Boost_ADDITIONAL_VERSIONS}")
+  message(STATUS "[ ${CMAKE_CURRENT_LIST_FILE}:${CMAKE_CURRENT_LIST_LINE} ] "
+                 "Boost_NO_SYSTEM_PATHS = ${Boost_NO_SYSTEM_PATHS}")
+endif()
+
+_Boost_CHECK_SPELLING(Boost_INCLUDEDIR)
+
+# Collect environment variable inputs as hints.  Do not consider changes.
+foreach(v BOOST_INCLUDEDIR)
+  set(_env $ENV{${v}})
+  if(_env)
+    file(TO_CMAKE_PATH "${_env}" _ENV_${v})
+  else()
+    set(_ENV_${v} "")
+  endif()
+endforeach()
+
+# Collect inputs and cached results.  Detect changes since the last run.
+set(_Boost_VARS_DIR
+  Boost_NO_SYSTEM_PATHS
+  )
+
+if(Boost_DEBUG)
+  message(STATUS "[ ${CMAKE_CURRENT_LIST_FILE}:${CMAKE_CURRENT_LIST_LINE} ] "
+                 "Declared as CMake or Environmental Variables:")
+  message(STATUS "[ ${CMAKE_CURRENT_LIST_FILE}:${CMAKE_CURRENT_LIST_LINE} ] "
+                 "  BOOST_INCLUDEDIR = ${BOOST_INCLUDEDIR}")
+  message(STATUS "[ ${CMAKE_CURRENT_LIST_FILE}:${CMAKE_CURRENT_LIST_LINE} ] "
+                 "_boost_TEST_VERSIONS = ${_boost_TEST_VERSIONS}")
+endif()
+
+# ------------------------------------------------------------------------
+#  Search for Boost include DIR
+# ------------------------------------------------------------------------
+
+set(_Boost_VARS_INC BOOST_INCLUDEDIR Boost_INCLUDE_DIR Boost_ADDITIONAL_VERSIONS)
+_Boost_CHANGE_DETECT(_Boost_CHANGE_INCDIR ${_Boost_VARS_DIR} ${_Boost_VARS_INC})
+# Clear Boost_INCLUDE_DIR if it did not change but other input affecting the
+# location did.  We will find a new one based on the new inputs.
+if(_Boost_CHANGE_INCDIR AND NOT _Boost_INCLUDE_DIR_CHANGED)
+  unset(Boost_INCLUDE_DIR CACHE)
+endif()
+
+if(NOT Boost_INCLUDE_DIR)
+  set(_boost_INCLUDE_SEARCH_DIRS "")
+  if(BOOST_INCLUDEDIR)
+    list(APPEND _boost_INCLUDE_SEARCH_DIRS ${BOOST_INCLUDEDIR})
+  elseif(_ENV_BOOST_INCLUDEDIR)
+    list(APPEND _boost_INCLUDE_SEARCH_DIRS ${_ENV_BOOST_INCLUDEDIR})
+  endif()
+
+  if( Boost_NO_SYSTEM_PATHS)
+    list(APPEND _boost_INCLUDE_SEARCH_DIRS NO_CMAKE_SYSTEM_PATH)
+  else()
+    list(APPEND _boost_INCLUDE_SEARCH_DIRS PATHS
+      C:/boost/include
+      C:/boost
+      /sw/local/include
+      )
+  endif()
+
+  # Try to find Boost by stepping backwards through the Boost versions
+  # we know about.
+  # Build a list of path suffixes for each version.
+  set(_boost_PATH_SUFFIXES)
+  foreach(_boost_VER ${_boost_TEST_VERSIONS})
+    # Add in a path suffix, based on the required version, ideally
+    # we could read this from version.hpp, but for that to work we'd
+    # need to know the include dir already
+    set(_boost_BOOSTIFIED_VERSION)
+
+    # Transform 1.35 => 1_35 and 1.36.0 => 1_36_0
+    if(_boost_VER MATCHES "[0-9]+\\.[0-9]+\\.[0-9]+")
+        string(REGEX REPLACE "([0-9]+)\\.([0-9]+)\\.([0-9]+)" "\\1_\\2_\\3"
+          _boost_BOOSTIFIED_VERSION ${_boost_VER})
+    elseif(_boost_VER MATCHES "[0-9]+\\.[0-9]+")
+        string(REGEX REPLACE "([0-9]+)\\.([0-9]+)" "\\1_\\2"
+          _boost_BOOSTIFIED_VERSION ${_boost_VER})
+    endif()
+
+    list(APPEND _boost_PATH_SUFFIXES
+      "boost-${_boost_BOOSTIFIED_VERSION}"
+      "boost_${_boost_BOOSTIFIED_VERSION}"
+      "boost/boost-${_boost_BOOSTIFIED_VERSION}"
+      "boost/boost_${_boost_BOOSTIFIED_VERSION}"
+      )
+
+  endforeach()
+
+  if(Boost_DEBUG)
+    message(STATUS "[ ${CMAKE_CURRENT_LIST_FILE}:${CMAKE_CURRENT_LIST_LINE} ] "
+                   "Include debugging info:")
+    message(STATUS "[ ${CMAKE_CURRENT_LIST_FILE}:${CMAKE_CURRENT_LIST_LINE} ] "
+                   "  _boost_INCLUDE_SEARCH_DIRS = ${_boost_INCLUDE_SEARCH_DIRS}")
+    message(STATUS "[ ${CMAKE_CURRENT_LIST_FILE}:${CMAKE_CURRENT_LIST_LINE} ] "
+                   "  _boost_PATH_SUFFIXES = ${_boost_PATH_SUFFIXES}")
+  endif()
+
+  # Look for a standard boost header file.
+  find_path(Boost_INCLUDE_DIR
+    NAMES         boost/config.hpp
+    HINTS         ${_boost_INCLUDE_SEARCH_DIRS}
+    PATH_SUFFIXES ${_boost_PATH_SUFFIXES}
+    )
+endif()
+
+# ------------------------------------------------------------------------
+#  Extract version information from version.hpp
+# ------------------------------------------------------------------------
+
+# Set Boost_FOUND based only on header location and version.
+# It will be updated below for component libraries.
+if(Boost_INCLUDE_DIR)
+  if(Boost_DEBUG)
+    message(STATUS "[ ${CMAKE_CURRENT_LIST_FILE}:${CMAKE_CURRENT_LIST_LINE} ] "
+                   "location of version.hpp: ${Boost_INCLUDE_DIR}/boost/version.hpp")
+  endif()
+
+  # Extract Boost_VERSION and Boost_LIB_VERSION from version.hpp
+  set(Boost_VERSION 0)
+  set(Boost_LIB_VERSION "")
+  file(STRINGS "${Boost_INCLUDE_DIR}/boost/version.hpp" _boost_VERSION_HPP_CONTENTS REGEX "#define BOOST_(LIB_)?VERSION ")
+  set(_Boost_VERSION_REGEX "([0-9]+)")
+  set(_Boost_LIB_VERSION_REGEX "\"([0-9_]+)\"")
+  foreach(v VERSION LIB_VERSION)
+    if("${_boost_VERSION_HPP_CONTENTS}" MATCHES ".*#define BOOST_${v} ${_Boost_${v}_REGEX}.*")
+      set(Boost_${v} "${CMAKE_MATCH_1}")
+    endif()
+  endforeach()
+  unset(_boost_VERSION_HPP_CONTENTS)
+
+  math(EXPR Boost_MAJOR_VERSION "${Boost_VERSION} / 100000")
+  math(EXPR Boost_MINOR_VERSION "${Boost_VERSION} / 100 % 1000")
+  math(EXPR Boost_SUBMINOR_VERSION "${Boost_VERSION} % 100")
+
+  set(Boost_ERROR_REASON
+    "${Boost_ERROR_REASON}Boost version: ${Boost_MAJOR_VERSION}.${Boost_MINOR_VERSION}.${Boost_SUBMINOR_VERSION}\nBoost include path: ${Boost_INCLUDE_DIR}")
+  if(Boost_DEBUG)
+    message(STATUS "[ ${CMAKE_CURRENT_LIST_FILE}:${CMAKE_CURRENT_LIST_LINE} ] "
+                   "version.hpp reveals boost "
+                   "${Boost_MAJOR_VERSION}.${Boost_MINOR_VERSION}.${Boost_SUBMINOR_VERSION}")
+  endif()
+
+  if(Boost_FIND_VERSION)
+    # Set Boost_FOUND based on requested version.
+    set(_Boost_VERSION "${Boost_MAJOR_VERSION}.${Boost_MINOR_VERSION}.${Boost_SUBMINOR_VERSION}")
+    if("${_Boost_VERSION}" VERSION_LESS "${Boost_FIND_VERSION}")
+      set(Boost_FOUND 0)
+      set(_Boost_VERSION_AGE "old")
+    elseif(Boost_FIND_VERSION_EXACT AND
+        NOT "${_Boost_VERSION}" VERSION_EQUAL "${Boost_FIND_VERSION}")
+      set(Boost_FOUND 0)
+      set(_Boost_VERSION_AGE "new")
+    else()
+      set(Boost_FOUND 1)
+    endif()
+    if(NOT Boost_FOUND)
+      # State that we found a version of Boost that is too new or too old.
+      set(Boost_ERROR_REASON
+        "${Boost_ERROR_REASON}\nDetected version of Boost is too ${_Boost_VERSION_AGE}. Requested version was ${Boost_FIND_VERSION_MAJOR}.${Boost_FIND_VERSION_MINOR}")
+      if (Boost_FIND_VERSION_PATCH)
+        set(Boost_ERROR_REASON
+          "${Boost_ERROR_REASON}.${Boost_FIND_VERSION_PATCH}")
+      endif ()
+      if (NOT Boost_FIND_VERSION_EXACT)
+        set(Boost_ERROR_REASON "${Boost_ERROR_REASON} (or newer)")
+      endif ()
+      set(Boost_ERROR_REASON "${Boost_ERROR_REASON}.")
+    endif ()
+  else()
+    # Caller will accept any Boost version.
+    set(Boost_FOUND 1)
+  endif()
+else()
+  set(Boost_FOUND 0)
+  set(Boost_ERROR_REASON
+    "${Boost_ERROR_REASON}Unable to find the Boost header files. Please set BOOST_INCLUDEDIR to the directory containing Boost's headers.")
+endif()
+
+set(Boost_INCLUDE_DIRS ${Boost_INCLUDE_DIR})
+set(Boost_LIBRARY_DIRS ${Boost_LIBRARY_DIR})
+
+# ------------------------------------------------------------------------
+#  Notification to end user about what was found
+# ------------------------------------------------------------------------
+
+if(Boost_FOUND)
+  if(NOT Boost_FIND_QUIETLY)
+    message(STATUS "Boost version: ${Boost_MAJOR_VERSION}.${Boost_MINOR_VERSION}.${Boost_SUBMINOR_VERSION}")
+  endif()
+else()
+  if(Boost_FIND_REQUIRED)
+    message(SEND_ERROR "Unable to find the requested Boost libraries.\n${Boost_ERROR_REASON}")
+  else()
+    if(NOT Boost_FIND_QUIETLY)
+      # we opt not to automatically output Boost_ERROR_REASON here as
+      # it could be quite lengthy and somewhat imposing in its requests
+      # Since Boost is not always a required dependency we'll leave this
+      # up to the end-user.
+      if(Boost_DEBUG OR Boost_DETAILED_FAILURE_MSG)
+        message(STATUS "Could NOT find Boost\n${Boost_ERROR_REASON}")
+      else()
+        message(STATUS "Could NOT find Boost")
+      endif()
+    endif()
+  endif()
+endif()
+
+# Configure display of cache entries in GUI.
+foreach(v ${_Boost_VARS_INC} ${_Boost_VARS_LIB})
+  get_property(_type CACHE ${v} PROPERTY TYPE)
+  if(_type)
+    set_property(CACHE ${v} PROPERTY ADVANCED 1)
+    if("x${_type}" STREQUAL "xUNINITIALIZED")
+      if("x${v}" STREQUAL "xBoost_ADDITIONAL_VERSIONS")
+        set_property(CACHE ${v} PROPERTY TYPE STRING)
+      else()
+        set_property(CACHE ${v} PROPERTY TYPE PATH)
+      endif()
+    endif()
+  endif()
+endforeach()
+
+# Record last used values of input variables so we can
+# detect on the next run if the user changed them.
+foreach(v
+    ${_Boost_VARS_INC} ${_Boost_VARS_LIB}
+    ${_Boost_VARS_DIR} ${_Boost_VARS_NAME}
+    )
+  if(DEFINED ${v})
+    set(_${v}_LAST "${${v}}" CACHE INTERNAL "Last used ${v} value.")
+  else()
+    unset(_${v}_LAST CACHE)
+  endif()
+endforeach()

CMake/TestBuild.cxx.in

@@ -0,0 +1,13 @@
+//mark that we are including headers as test for completeness.
+//This is used by headers that include thrust to properly define a proper
+//device backend / system
+#define VTKM_TEST_HEADER_BUILD
+
+#define BOOST_SP_DISABLE_THREADS
+
+#include <@dir_prefix@/@header@>
+
+int Test_Build_For_@headername@()
+{
+  return 0;
+}

CMake/VtkmCheckCopyright.cmake

@@ -0,0 +1,245 @@
+##============================================================================
+##  Copyright (c) Kitware, Inc.
+##  All rights reserved.
+##  See LICENSE.txt for details.
+##  This software is distributed WITHOUT ANY WARRANTY; without even
+##  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+##  PURPOSE.  See the above copyright notice for more information.
+##
+##  Copyright 2014 Sandia Corporation.
+##  Copyright 2014 UT-Battelle, LLC.
+##  Copyright 2014. Los Alamos National Security
+##
+##  Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+##  the U.S. Government retains certain rights in this software.
+##
+##  Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
+##  Laboratory (LANL), the U.S. Government retains certain rights in
+##  this software.
+##============================================================================
+
+## This CMake script checks source files for the appropriate VTKM copyright
+## statement, which is stored in VTKm_SOURCE_DIR/CMake/VTKmCopyrightStatement.txt.
+## To run this script, execute CMake as follows:
+##
+## cmake -DVTKm_SOURCE_DIR=<VTKm_SOURCE_DIR> -P <VTKm_SOURCE_DIR>/CMake/VTKMCheckCopyright.cmake
+##
+
+cmake_minimum_required(VERSION 2.8)
+
+set(FILES_TO_CHECK
+  *.txt
+  *.cmake
+  *.h
+  *.h.in
+  *.cxx
+  *.cu
+  )
+
+set(EXCEPTIONS
+  LICENSE.txt
+  README.txt
+  )
+
+if (NOT VTKm_SOURCE_DIR)
+  message(SEND_ERROR "VTKm_SOURCE_DIR not defined.")
+endif (NOT VTKm_SOURCE_DIR)
+
+set(copyright_file ${VTKm_SOURCE_DIR}/CMake/VTKMCopyrightStatement.txt)
+
+if (NOT EXISTS ${copyright_file})
+  message(SEND_ERROR "Cannot find VTKMCopyrightStatement.txt.")
+endif (NOT EXISTS ${copyright_file})
+
+set(license_file ${VTKm_SOURCE_DIR}/LICENSE.txt)
+
+if (NOT EXISTS ${license_file})
+  message(SEND_ERROR "Cannot find LICENSE.txt.")
+endif (NOT EXISTS ${license_file})
+
+# Get a list of third party files (with different copyrights) from the
+# license file.
+file(STRINGS ${license_file} license_lines)
+list(FIND
+  license_lines
+  "- - - - - - - - - - - - - - - - - - - - - - - - do not remove this line"
+  separator_index
+  )
+math(EXPR begin_index "${separator_index} + 1")
+list(LENGTH license_lines license_file_length)
+math(EXPR end_index "${license_file_length} - 1")
+foreach (index RANGE ${begin_index} ${end_index})
+  list(GET license_lines ${index} tpl_file)
+  set(EXCEPTIONS ${EXCEPTIONS} ${tpl_file})
+endforeach(index)
+message("${EXCEPTIONS}")
+
+# Gets the current year (if possible).
+function (get_year var)
+  if (UNIX)
+    execute_process(COMMAND "date" "+%Y" OUTPUT_VARIABLE result)
+    string(REGEX REPLACE "(....).*" "\\1" result "${result}")
+  elseif (WIN32)
+    execute_process(COMMAND "date" "/T" OUTPUT_VARIABLE result)
+    string(REGEX REPLACE ".*../../(....).*" "\\1" result "${result}")
+  else (UNIX)
+    message("Don't know how to get date.")
+    set(result "20XX")
+  endif (UNIX)
+  set(${var} "${result}" PARENT_SCOPE)
+endfunction (get_year)
+
+set(copyright_file_year 2011)
+get_year(current_year)
+
+# Escapes ';' characters (list delimiters) and splits the given string into
+# a list of its lines without newlines.
+function (list_of_lines var string)
+  string(REGEX REPLACE ";" "\\\\;" conditioned_string "${string}")
+  string(REGEX REPLACE "\n" ";" conditioned_string "${conditioned_string}")
+  set(${var} "${conditioned_string}" PARENT_SCOPE)
+endfunction (list_of_lines)
+
+# Read in copyright statement file.
+file(READ ${copyright_file} COPYRIGHT_STATEMENT)
+
+# Remove trailing whitespace and ending lines.  They are sometimes hard to
+# see or remove in editors.
+string(REGEX REPLACE "[ \t]*\n" "\n" COPYRIGHT_STATEMENT "${COPYRIGHT_STATEMENT}")
+string(REGEX REPLACE "\n+$" "" COPYRIGHT_STATEMENT "${COPYRIGHT_STATEMENT}")
+
+# Get a list of lines in the copyright statement.
+list_of_lines(COPYRIGHT_LINE_LIST "${COPYRIGHT_STATEMENT}")
+
+# Comment regular expression characters that we want to match literally.
+string(REPLACE "." "\\." COPYRIGHT_LINE_LIST "${COPYRIGHT_LINE_LIST}")
+string(REPLACE "(" "\\(" COPYRIGHT_LINE_LIST "${COPYRIGHT_LINE_LIST}")
+string(REPLACE ")" "\\)" COPYRIGHT_LINE_LIST "${COPYRIGHT_LINE_LIST}")
+
+# Introduce regular expression for years we want to be generic.
+string(REPLACE
+  "${copyright_file_year}"
+  "20[0-9][0-9]"
+  COPYRIGHT_LINE_LIST
+  "${COPYRIGHT_LINE_LIST}"
+  )
+
+# Replace year in COPYRIGHT_STATEMENT with current year.
+string(REPLACE
+  "${copyright_file_year}"
+  "${current_year}"
+  COPYRIGHT_STATEMENT
+  "${COPYRIGHT_STATEMENT}"
+  )
+
+# Print an error concerning the missing copyright in the given file.
+function(missing_copyright filename comment_prefix)
+  message("${filename} does not have the appropriate copyright statement:\n")
+
+  # Condition the copyright statement
+  string(REPLACE
+    "\n"
+    "\n${comment_prefix}  "
+    comment_copyright
+    "${COPYRIGHT_STATEMENT}"
+    )
+  set(comment_copyright "${comment_prefix}  ${comment_copyright}")
+  string(REPLACE
+    "\n${comment_prefix}  \n"
+    "\n${comment_prefix}\n"
+    comment_copyright
+    "${comment_copyright}"
+    )
+
+  message("${comment_prefix}=============================================================================")
+  message("${comment_prefix}")
+  message("${comment_copyright}")
+  message("${comment_prefix}")
+  message("${comment_prefix}=============================================================================\n")
+  message(SEND_ERROR
+    "Please add the previous statement to the beginning of ${filename}"
+    )
+endfunction(missing_copyright)
+
+# Get an appropriate beginning line comment for the given filename.
+function(get_comment_prefix var filename)
+  get_filename_component(base "${filename}" NAME_WE)
+  get_filename_component(extension "${filename}" EXT)
+  if (extension STREQUAL ".cmake")
+    set(${var} "##" PARENT_SCOPE)
+  elseif (base STREQUAL "CMakeLists" AND extension STREQUAL ".txt")
+    set(${var} "##" PARENT_SCOPE)
+  elseif (extension STREQUAL ".txt")
+    set(${var} "" PARENT_SCOPE)
+  elseif (extension STREQUAL ".h" OR extension STREQUAL ".h.in" OR extension STREQUAL ".cxx" OR extension STREQUAL ".cu")
+    set(${var} "//" PARENT_SCOPE)
+  elseif (extension STREQUAL ".worklet")
+    set(${var} "//" PARENT_SCOPE)
+  else (extension STREQUAL ".cmake")
+    message(SEND_ERROR "Could not identify file type of ${filename}.")
+  endif (extension STREQUAL ".cmake")
+endfunction(get_comment_prefix)
+
+# Check the given file for the appropriate copyright statement.
+function(check_copyright filename)
+
+  get_comment_prefix(comment_prefix "${filename}")
+
+  # Read in the first 2000 characters of the file and split into lines.
+  # This is roughly equivalent to the file STRINGS command except that we
+  # also escape semicolons (list separators) in the input, which the file
+  # STRINGS command does not currently do.
+  file(READ "${filename}" header_contents LIMIT 2000)
+  list_of_lines(header_lines "${header_contents}")
+
+  # Check each copyright line.
+  foreach (copyright_line IN LISTS COPYRIGHT_LINE_LIST)
+    set(match)
+    # My original algorithm tried to check the order by removing items from
+    # header_lines as they were encountered.  Unfortunately, CMake 2.8's
+    # list REMOVE_AT command removed the escaping on the ; in one of the
+    # header_line's items and cause the compare to fail.
+    foreach (header_line IN LISTS header_lines)
+      if (copyright_line)
+        string(REGEX MATCH
+          "^${comment_prefix}[ \t]*${copyright_line}[ \t]*$"
+          match
+          "${header_line}"
+          )
+      else (copyright_line)
+        if (NOT header_line)
+          set(match TRUE)
+        endif (NOT header_line)
+      endif (copyright_line)
+      if (match)
+        break()
+      endif (match)
+    endforeach (header_line)
+    if (NOT match)
+      message(STATUS "Could not find match for `${copyright_line}'")
+      missing_copyright("${filename}" "${comment_prefix}")
+    endif (NOT match)
+  endforeach (copyright_line)
+endfunction(check_copyright)
+
+foreach (glob_expression ${FILES_TO_CHECK})
+  file(GLOB_RECURSE file_list
+    RELATIVE "${VTKm_SOURCE_DIR}"
+    "${VTKm_SOURCE_DIR}/${glob_expression}"
+    )
+
+  foreach (file ${file_list})
+    set(skip)
+    foreach(exception ${EXCEPTIONS})
+      if(file MATCHES "^${exception}(/.*)?$")
+        # This file is an exception
+        set(skip TRUE)
+      endif(file MATCHES "^${exception}(/.*)?$")
+    endforeach(exception)
+
+    if (NOT skip)
+      message("Checking ${file}")
+      check_copyright("${VTKm_SOURCE_DIR}/${file}")
+    endif (NOT skip)
+  endforeach (file)
+endforeach (glob_expression)

CMake/VtkmCompilerExtras.cmake

@@ -0,0 +1,56 @@
+##============================================================================
+##  Copyright (c) Kitware, Inc.
+##  All rights reserved.
+##  See LICENSE.txt for details.
+##  This software is distributed WITHOUT ANY WARRANTY; without even
+##  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+##  PURPOSE.  See the above copyright notice for more information.
+##
+##  Copyright 2014 Sandia Corporation.
+##  Copyright 2014 UT-Battelle, LLC.
+##  Copyright 2014. Los Alamos National Security
+##
+##  Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+##  the U.S. Government retains certain rights in this software.
+##
+##  Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
+##  Laboratory (LANL), the U.S. Government retains certain rights in
+##  this software.
+##============================================================================
+
+if(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
+  set(CMAKE_COMPILER_IS_CLANGXX 1)
+endif()
+
+if(CMAKE_COMPILER_IS_GNUCXX OR CMAKE_COMPILER_IS_CLANGXX)
+
+  include(CheckCXXCompilerFlag)
+
+  # Standard warning flags we should always have
+  set(CMAKE_CXX_FLAGS_WARN " -Wall")
+  set(CMAKE_CXX_FLAGS_RELWITHDEBINFO
+    "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} ${CMAKE_CXX_FLAGS_WARN}")
+  set(CMAKE_CXX_FLAGS_DEBUG
+    "${CMAKE_CXX_FLAGS_DEBUG} ${CMAKE_CXX_FLAGS_WARN}")
+
+  # Addtional warnings for GCC
+  set(CMAKE_CXX_FLAGS_WARN_EXTRA "-Wno-long-long -Wcast-align -Wchar-subscripts -Wextra -Wpointer-arith -Wformat -Wformat-security -Wshadow -Wunused-parameter -fno-common")
+  if (VTKM_FORCE_ANSI)
+    set(CMAKE_CXX_FLAGS_WARN_EXTRA "-ansi ${CMAKE_CXX_FLAGS_WARN_EXTRA}")
+  endif()
+
+  # Set up the debug CXX_FLAGS for extra warnings
+  option(VTKM_EXTRA_COMPILER_WARNINGS "Add compiler flags to do stricter checking when building debug." ON)
+  # We used to add the compiler flags globally, but this caused problems with
+  # the CUDA compiler (and its lack of support for GCC pragmas).  Instead,
+  # the vtkm_declare_headers and vtkm_unit_tests CMake functions add these flags
+  # to their compiles.  As long as the unit tests have good coverage, this
+  # should catch all problems.
+  if(VTKM_EXTRA_COMPILER_WARNINGS)
+    set(CMAKE_CXX_FLAGS_RELWITHDEBINFO
+      "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} ${CMAKE_CXX_FLAGS_WARN_EXTRA}")
+    set(CMAKE_CXX_FLAGS_DEBUG
+      "${CMAKE_CXX_FLAGS_DEBUG} ${CMAKE_CXX_FLAGS_WARN_EXTRA}")
+  endif()
+endif()
+

CMake/VtkmConfig.cmake.in

@@ -0,0 +1,40 @@
+##============================================================================
+##  Copyright (c) Kitware, Inc.
+##  All rights reserved.
+##  See LICENSE.txt for details.
+##  This software is distributed WITHOUT ANY WARRANTY; without even
+##  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+##  PURPOSE.  See the above copyright notice for more information.
+##
+##  Copyright 2014 Sandia Corporation.
+##  Copyright 2014 UT-Battelle, LLC.
+##  Copyright 2014. Los Alamos National Security
+##
+##  Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+##  the U.S. Government retains certain rights in this software.
+##
+##  Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
+##  Laboratory (LANL), the U.S. Government retains certain rights in
+##  this software.
+##============================================================================
+
+# This file should be installed in the include directory.
+# Find the root directory.
+get_filename_component(_dir "${CMAKE_CURRENT_LIST_FILE}" PATH)
+get_filename_component(_install_dir "${_dir}/.." ABSOLUTE)
+
+# The VTKm include file directories.
+set(VTKm_INCLUDE_DIRS "@VTKm_INCLUDE_DIRS_CONFIG@")
+
+# The VTKm version number
+set(VTKm_MAJOR_VERSION "@VTKm_MAJOR_VERSION@")
+set(VTKm_MINOR_VERSION "@VTKm_MINOR_VERSION@")
+set(VTKm_PATCH_VERSION "@VTKm_PATCH_VERSION@")
+
+set(VTKm_REQUIRED_BOOST_VERSION "@VTKm_REQUIRED_BOOST_VERSION@")
+
+set(VTKm_CMAKE_MODULE_PATH "@VTKm_CMAKE_MODULE_PATH_CONFIG@")
+
+# VTKm requires some CMake Find modules not included with CMake, so
+# include the CMake modules distributed with VTKm.
+set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${VTKm_CMAKE_MODULE_PATH})

CMake/VtkmConfigVersion.cmake.in

@@ -0,0 +1,10 @@
+set(PACKAGE_VERSION "@VTKm_VERSION@")
+
+if("${PACKAGE_VERSION}" VERSION_LESS "${PACKAGE_FIND_VERSION}")
+  set(PACKAGE_VERSION_COMPATIBLE FALSE)
+else()
+  set(PACKAGE_VERSION_COMPATIBLE TRUE)
+  if ("${PACKAGE_VERSION}" STREQUAL "${PACKAGE_FIND_VERSION}")
+    set(PACKAGE_VERSION_EXACT TRUE)
+  endif()
+endif()

CMake/VtkmCopyrightStatement.txt

@@ -0,0 +1,17 @@
+Copyright (c) Kitware, Inc.
+All rights reserved.
+See LICENSE.txt for details.
+
+This software is distributed WITHOUT ANY WARRANTY; without even
+the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+PURPOSE.  See the above copyright notice for more information.
+
+Copyright 2014 Sandia Corporation.
+Copyright 2014 UT-Battelle, LLC.
+Copyright 2014. Los Alamos National Security
+
+Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+the U.S. Government retains certain rights in this software.
+Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
+Laboratory (LANL), the U.S. Government retains certain rights in
+this software.

CMake/VtkmMacros.cmake

@@ -0,0 +1,343 @@
+##============================================================================
+##  Copyright (c) Kitware, Inc.
+##  All rights reserved.
+##  See LICENSE.txt for details.
+##  This software is distributed WITHOUT ANY WARRANTY; without even
+##  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+##  PURPOSE.  See the above copyright notice for more information.
+##
+##  Copyright 2014 Sandia Corporation.
+##  Copyright 2014 UT-Battelle, LLC.
+##  Copyright 2014. Los Alamos National Security
+##
+##  Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+##  the U.S. Government retains certain rights in this software.
+##
+##  Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
+##  Laboratory (LANL), the U.S. Government retains certain rights in
+##  this software.
+##============================================================================
+
+include(CMakeParseArguments)
+
+# Utility to build a kit name from the current directory.
+function(vtkm_get_kit_name kitvar)
+  # Will this always work?  It should if ${CMAKE_CURRENT_SOURCE_DIR} is
+  # built from ${VTKm_SOURCE_DIR}.
+  string(REPLACE "${VTKm_SOURCE_DIR}/" "" dir_prefix ${CMAKE_CURRENT_SOURCE_DIR})
+  string(REPLACE "/" "_" kit "${dir_prefix}")
+  set(${kitvar} "${kit}" PARENT_SCOPE)
+  # Optional second argument to get dir_prefix.
+  if (${ARGC} GREATER 1)
+    set(${ARGV1} "${dir_prefix}" PARENT_SCOPE)
+  endif (${ARGC} GREATER 1)
+endfunction(vtkm_get_kit_name)
+
+# Builds a source file and an executable that does nothing other than
+# compile the given header files.
+function(vtkm_add_header_build_test name dir_prefix use_cuda)
+  set(hfiles ${ARGN})
+  if (use_cuda)
+    set(suffix ".cu")
+  else (use_cuda)
+    set(suffix ".cxx")
+  endif (use_cuda)
+  set(cxxfiles)
+  foreach (header ${ARGN})
+    get_source_file_property(cant_be_tested ${header} VTKm_CANT_BE_HEADER_TESTED)
+
+    if( NOT cant_be_tested )
+      string(REPLACE "${CMAKE_CURRENT_BINARY_DIR}" "" header "${header}")
+      get_filename_component(headername ${header} NAME_WE)
+      set(src ${CMAKE_CURRENT_BINARY_DIR}/testing/TestBuild_${name}_${headername}${suffix})
+      configure_file(${VTKm_SOURCE_DIR}/CMake/TestBuild.cxx.in ${src} @ONLY)
+      list(APPEND cxxfiles ${src})
+    endif()
+
+  endforeach (header)
+
+  #only attempt to add a test build executable if we have any headers to
+  #test. this might not happen when everything depends on thrust.
+  list(LENGTH cxxfiles cxxfiles_len)
+  if (use_cuda AND ${cxxfiles_len} GREATER 0)
+    cuda_add_library(TestBuild_${name} ${cxxfiles} ${hfiles})
+  elseif (${cxxfiles_len} GREATER 0)
+    add_library(TestBuild_${name} ${cxxfiles} ${hfiles})
+    if(VTKm_EXTRA_COMPILER_WARNINGS)
+      set_target_properties(TestBuild_${name}
+        PROPERTIES COMPILE_FLAGS ${CMAKE_CXX_FLAGS_WARN_EXTRA})
+    endif(VTKm_EXTRA_COMPILER_WARNINGS)
+  endif ()
+  set_source_files_properties(${hfiles}
+    PROPERTIES HEADER_FILE_ONLY TRUE
+    )
+endfunction(vtkm_add_header_build_test)
+
+function(vtkm_install_headers dir_prefix)
+  set(hfiles ${ARGN})
+  install(FILES ${hfiles}
+    DESTINATION ${VTKm_INSTALL_INCLUDE_DIR}/${dir_prefix}
+    )
+endfunction(vtkm_install_headers)
+
+# Declare a list of headers that require thrust to be enabled
+# for them to header tested. In cases of thrust version 1.5 or less
+# we have to make sure openMP is enabled, otherwise we are okay
+function(vtkm_requires_thrust_to_test)
+  #determine the state of thrust and testing
+  set(cant_be_tested FALSE)
+    if(NOT VTKm_ENABLE_THRUST)
+      #mark as not valid
+      set(cant_be_tested TRUE)
+    elseif(NOT VTKm_ENABLE_OPENMP)
+      #mark also as not valid
+      set(cant_be_tested TRUE)
+    endif()
+
+  foreach(header ${ARGN})
+    #set a property on the file that marks if we can header test it
+    set_source_files_properties( ${header}
+        PROPERTIES VTKm_CANT_BE_HEADER_TESTED ${cant_be_tested} )
+
+  endforeach(header)
+
+endfunction(vtkm_requires_thrust_to_test)
+
+# Declare a list of header files.  Will make sure the header files get
+# compiled and show up in an IDE.
+function(vtkm_declare_headers)
+  set(options CUDA)
+  set(oneValueArgs)
+  set(multiValueArgs)
+  cmake_parse_arguments(VTKm_DH "${options}"
+    "${oneValueArgs}" "${multiValueArgs}"
+    ${ARGN}
+    )
+  set(hfiles ${VTKm_DH_UNPARSED_ARGUMENTS})
+  vtkm_get_kit_name(name dir_prefix)
+
+  #only do header testing if enable testing is turned on
+  if (VTKm_ENABLE_TESTING)
+    vtkm_add_header_build_test(
+      "${name}" "${dir_prefix}" "${VTKm_DH_CUDA}" ${hfiles})
+  endif()
+  #always install headers
+  vtkm_install_headers("${dir_prefix}" ${hfiles})
+endfunction(vtkm_declare_headers)
+
+# Declare a list of worklet files.
+function(vtkm_declare_worklets)
+  # Currently worklets are just really header files.
+  vtkm_declare_headers(${ARGN})
+endfunction(vtkm_declare_worklets)
+
+# Declare unit tests, which should be in the same directory as a kit
+# (package, module, whatever you call it).  Usage:
+#
+# vtkm_unit_tests(
+#   SOURCES <source_list>
+#   LIBRARIES <dependent_library_list>
+#   )
+function(vtkm_unit_tests)
+  set(options CUDA)
+  set(oneValueArgs)
+  set(multiValueArgs SOURCES LIBRARIES)
+  cmake_parse_arguments(VTKm_UT
+    "${options}" "${oneValueArgs}" "${multiValueArgs}"
+    ${ARGN}
+    )
+
+  #set up what we possibly need to link too.
+  list(APPEND VTKm_UT_LIBRARIES ${TBB_LIBRARIES})
+  #set up storage for the include dirs
+  set(VTKm_UT_INCLUDE_DIRS )
+
+  if(VTKm_ENABLE_OPENGL_INTEROP)
+    list(APPEND VTKm_UT_INCLUDE_DIRS ${OPENGL_INCLUDE_DIR} ${GLEW_INCLUDE_DIR} )
+    list(APPEND VTKm_UT_LIBRARIES ${OPENGL_LIBRARIES} ${GLEW_LIBRARIES} )
+  endif()
+
+  if(VTKm_ENABLE_OPENGL_TESTS)
+    list(APPEND VTKm_UT_INCLUDE_DIRS ${GLUT_INCLUDE_DIR} )
+    list(APPEND VTKm_UT_LIBRARIES ${GLUT_LIBRARIES}  )
+  endif()
+
+  if (VTKm_ENABLE_TESTING)
+    vtkm_get_kit_name(kit)
+    #we use UnitTests_kit_ so that it is an unique key to exclude from coverage
+    set(test_prog UnitTests_kit_${kit})
+    create_test_sourcelist(TestSources ${test_prog}.cxx ${VTKm_UT_SOURCES})
+    if (VTKm_UT_CUDA)
+      cuda_add_executable(${test_prog} ${TestSources})
+    else (VTKm_UT_CUDA)
+      add_executable(${test_prog} ${TestSources})
+      if(VTKm_EXTRA_COMPILER_WARNINGS)
+        set_target_properties(${test_prog}
+          PROPERTIES COMPILE_FLAGS ${CMAKE_CXX_FLAGS_WARN_EXTRA})
+      endif(VTKm_EXTRA_COMPILER_WARNINGS)
+    endif (VTKm_UT_CUDA)
+
+    #do it as a property value so we don't pollute the include_directories
+    #for any other targets
+    set_property(TARGET ${test_prog} APPEND PROPERTY
+        INCLUDE_DIRECTORIES ${VTKm_UT_INCLUDE_DIRS} )
+
+    target_link_libraries(${test_prog} ${VTKm_UT_LIBRARIES})
+
+
+    foreach (test ${VTKm_UT_SOURCES})
+      get_filename_component(tname ${test} NAME_WE)
+      add_test(NAME ${tname}
+        COMMAND ${test_prog} ${tname}
+        )
+    endforeach (test)
+  endif (VTKm_ENABLE_TESTING)
+endfunction(vtkm_unit_tests)
+
+# Save the worklets to test with each device adapter
+# Usage:
+#
+# vtkm_save_worklet_unit_tests( sources )
+#
+# notes: will save the sources absolute path as the
+# vtkm_source_worklet_unit_tests global property
+function(vtkm_save_worklet_unit_tests )
+
+  #create the test driver when we are called, since
+  #the test driver expect the test files to be in the same
+  #directory as the test driver
+  create_test_sourcelist(test_sources WorkletTestDriver.cxx ${ARGN})
+
+  #store the absolute path for the test drive and all the test
+  #files
+  set(driver ${CMAKE_CURRENT_BINARY_DIR}/WorkletTestDriver.cxx)
+  set(cxx_sources)
+  set(cu_sources)
+
+  #we need to store the absolute source for the file so that
+  #we can properly compile it into the test driver. At
+  #the same time we want to configure each file into the build
+  #directory as a .cu file so that we can compile it with cuda
+  #if needed
+  foreach(fname ${ARGN})
+    set(absPath)
+
+    get_filename_component(absPath ${fname} ABSOLUTE)
+    get_filename_component(file_name_only ${fname} NAME_WE)
+
+    set(cuda_file_name "${CMAKE_CURRENT_BINARY_DIR}/${file_name_only}.cu")
+    configure_file("${absPath}"
+                   "${cuda_file_name}"
+                   COPYONLY)
+    list(APPEND cxx_sources ${absPath})
+    list(APPEND cu_sources ${cuda_file_name})
+  endforeach()
+
+  #we create a property that holds all the worklets to test,
+  #but don't actually attempt to create a unit test with the yet.
+  #That is done by each device adapter
+  set_property( GLOBAL APPEND
+                PROPERTY vtkm_worklet_unit_tests_sources ${cxx_sources})
+  set_property( GLOBAL APPEND
+                PROPERTY vtkm_worklet_unit_tests_cu_sources ${cu_sources})
+  set_property( GLOBAL APPEND
+                PROPERTY vtkm_worklet_unit_tests_drivers ${driver})
+
+endfunction(vtkm_save_worklet_unit_tests)
+
+# Call each worklet test for the given device adapter
+# Usage:
+#
+# vtkm_worklet_unit_tests( device_adapter )
+#
+# notes: will look for the vtkm_source_worklet_unit_tests global
+# property to find what are the worklet unit tests that need to be
+# compiled for the give device adapter
+function(vtkm_worklet_unit_tests device_adapter)
+
+  set(unit_test_srcs)
+  get_property(unit_test_srcs GLOBAL
+               PROPERTY vtkm_worklet_unit_tests_sources )
+
+  set(unit_test_drivers)
+  get_property(unit_test_drivers GLOBAL
+               PROPERTY vtkm_worklet_unit_tests_drivers )
+
+  #detect if we are generating a .cu files
+  set(is_cuda FALSE)
+  set(old_nvcc_flags ${CUDA_NVCC_FLAGS})
+  if("${device_adapter}" STREQUAL "VTKm_DEVICE_ADAPTER_CUDA")
+    set(is_cuda TRUE)
+    #if we are generating cu files need to setup three things.
+    #1. us the configured .cu files
+    #2. Set BOOST_SP_DISABLE_THREADS to disable threading warnings
+    #3. Disable unused function warnings
+    #the FindCUDA module and helper methods don't read target level
+    #properties so we have to modify CUDA_NVCC_FLAGS  instead of using
+    # target and source level COMPILE_FLAGS and COMPILE_DEFINITIONS
+    #
+    get_property(unit_test_srcs GLOBAL PROPERTY vtkm_worklet_unit_tests_cu_sources )
+    list(APPEND CUDA_NVCC_FLAGS -DBOOST_SP_DISABLE_THREADS)
+    list(APPEND CUDA_NVCC_FLAGS "-w")
+  endif()
+
+  if(VTKm_ENABLE_TESTING)
+    vtkm_get_kit_name(kit)
+    set(test_prog WorkletTests_${kit})
+
+    if(is_cuda)
+      cuda_add_executable(${test_prog} ${unit_test_drivers} ${unit_test_srcs})
+    else()
+      add_executable(${test_prog} ${unit_test_drivers} ${unit_test_srcs})
+    endif()
+
+    #add a test for each worklet test file. We will inject the device
+    #adapter type into the test name so that it is easier to see what
+    #exact device a test is failing on.
+
+    string(REPLACE "VTKm_DEVICE_ADAPTER_" "" device_type ${device_adapter})
+
+    foreach (test ${unit_test_srcs})
+      get_filename_component(tname ${test} NAME_WE)
+      add_test(NAME "${tname}${device_type}"
+        COMMAND ${test_prog} ${tname}
+        )
+    endforeach (test)
+
+    #increase warning level if needed, we are going to skip cuda here
+    #to remove all the false positive unused function warnings that cuda
+    #generates
+    if(VTKm_EXTRA_COMPILER_WARNINGS)
+      set_property(TARGET ${test_prog}
+            APPEND PROPERTY COMPILE_FLAGS ${CMAKE_CXX_FLAGS_WARN_EXTRA} )
+    endif()
+
+    #set the device adapter on the executable
+    set_property(TARGET ${test_prog}
+             APPEND
+             PROPERTY COMPILE_DEFINITIONS VTKm_DEVICE_ADAPTER=${device_adapter})
+  endif()
+
+  set(CUDA_NVCC_FLAGS ${old_nvcc_flags})
+endfunction(vtkm_worklet_unit_tests)
+
+# The Thrust project is not as careful as the VTKm project in avoiding warnings
+# on shadow variables and unused arguments.  With a real GCC compiler, you
+# can disable these warnings inline, but with something like nvcc, those
+# pragmas cause errors.  Thus, this macro will disable the compiler warnings.
+macro(vtkm_disable_troublesome_thrust_warnings)
+  vtkm_disable_troublesome_thrust_warnings_var(CMAKE_CXX_FLAGS_DEBUG)
+  vtkm_disable_troublesome_thrust_warnings_var(CMAKE_CXX_FLAGS_MINSIZEREL)
+  vtkm_disable_troublesome_thrust_warnings_var(CMAKE_CXX_FLAGS_RELEASE)
+  vtkm_disable_troublesome_thrust_warnings_var(CMAKE_CXX_FLAGS_RELWITHDEBINFO)
+endmacro(vtkm_disable_troublesome_thrust_warnings)
+
+macro(vtkm_disable_troublesome_thrust_warnings_var flags_var)
+  set(old_flags "${${flags_var}}")
+  string(REPLACE "-Wshadow" "" new_flags "${old_flags}")
+  string(REPLACE "-Wunused-parameter" "" new_flags "${new_flags}")
+  string(REPLACE "-Wunused" "" new_flags "${new_flags}")
+  string(REPLACE "-Wextra" "" new_flags "${new_flags}")
+  string(REPLACE "-Wall" "" new_flags "${new_flags}")
+  set(${flags_var} "${new_flags}")
+endmacro(vtkm_disable_troublesome_thrust_warnings_var)

CMakeLists.txt

@@ -0,0 +1,156 @@
+##============================================================================
+##  Copyright (c) Kitware, Inc.
+##  All rights reserved.
+##  See LICENSE.txt for details.
+##  This software is distributed WITHOUT ANY WARRANTY; without even
+##  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+##  PURPOSE.  See the above copyright notice for more information.
+##
+##  Copyright 2014 Sandia Corporation.
+##  Copyright 2014 UT-Battelle, LLC.
+##  Copyright 2014. Los Alamos National Security
+##
+##  Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+##  the U.S. Government retains certain rights in this software.
+##
+##  Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
+##  Laboratory (LANL), the U.S. Government retains certain rights in
+##  this software.
+##============================================================================
+
+cmake_minimum_required(VERSION 2.8.10)
+project (VTKm)
+
+set(VTKm_MAJOR_VERSION 0)
+set(VTKm_MINOR_VERSION 1)
+set(VTKm_PATCH_VERSION 0)
+set(VTKm_VERSION "${VTKm_MAJOR_VERSION}.${VTKm_MINOR_VERSION}.${VTKm_PATCH_VERSION}")
+
+set(VTKm_INSTALL_INCLUDE_DIR "include")
+set(VTKm_INSTALL_CONFIG_DIR "include")
+set(VTKm_INSTALL_CMAKE_MODULE_DIR "share/vtkm/cmake")
+
+set(VTKm_REQUIRED_BOOST_VERSION 1.48.0)
+
+# include some vtkm-specific cmake code.
+include(CMake/VTKmMacros.cmake)
+
+set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${VTKm_SOURCE_DIR}/CMake)
+
+#-----------------------------------------------------------------------------
+# Check for Cxx11 support.
+option(VTKm_FORCE_ANSI
+ "Turn off compiling any features not compatible with ISO-C++98 (ANSI)." OFF)
+if (NOT VTKm_FORCE_ANSI)
+  include(CMake/CheckCXX11Features.cmake)
+else (NOT VTKm_FORCE_ANSI)
+  set(VTKm_NO_VARIADIC_TEMPLATE TRUE)
+endif ()
+
+#-----------------------------------------------------------------------------
+# Add supplemental compiler warnings, and GCC visibility support.
+include(CMake/VTKmCompilerExtras.cmake)
+
+#-----------------------------------------------------------------------------
+# Configurable Options
+option(VTKm_ENABLE_TESTING "Enable VTKm Testing" ON)
+
+option(VTKm_USE_DOUBLE_PRECISION
+  "Use double precision for floating point calculations"
+  OFF
+  )
+option(VTKm_USE_64BIT_IDS "Use 64-bit indices." OFF)
+
+if (VTKm_ENABLE_TESTING)
+  enable_testing()
+  include(CTest)
+endif()
+
+#-----------------------------------------------------------------------------
+
+## Set the directory where the binaries will be stored
+set( EXECUTABLE_OUTPUT_PATH
+  ${PROJECT_BINARY_DIR}/bin
+  CACHE PATH
+  "Directory where all executable will be stored"
+)
+
+## Set the directory where the libraries will be stored
+set( LIBRARY_OUTPUT_PATH
+  ${PROJECT_BINARY_DIR}/libs
+  CACHE PATH
+  "Directory where all the libraries will be stored"
+)
+mark_as_advanced(
+  EXECUTABLE_OUTPUT_PATH
+  LIBRARY_OUTPUT_PATH)
+
+include_directories(
+  ${CMAKE_CURRENT_BINARY_DIR}
+  ${CMAKE_CURRENT_SOURCE_DIR}
+  )
+
+#-----------------------------------------------------------------------------
+# Add test to check for copyright statement on all source files.
+if (VTKm_ENABLE_TESTING)
+  add_test(NAME CopyrightStatement
+    COMMAND ${CMAKE_COMMAND} "-DVTKm_SOURCE_DIR=${VTKm_SOURCE_DIR}" -P "${VTKm_SOURCE_DIR}/CMake/VTKmCheckCopyright.cmake"
+    )
+endif (VTKm_ENABLE_TESTING)
+
+#-----------------------------------------------------------------------------
+# Check basic type sizes.
+include(CheckTypeSize)
+
+check_type_size(float VTKm_SIZE_FLOAT BUILTIN_TYPES_ONLY)
+check_type_size(double VTKm_SIZE_DOUBLE BUILTIN_TYPES_ONLY)
+check_type_size(int VTKm_SIZE_INT BUILTIN_TYPES_ONLY)
+check_type_size(long VTKm_SIZE_LONG BUILTIN_TYPES_ONLY)
+check_type_size("long long" VTKm_SIZE_LONG_LONG BUILTIN_TYPES_ONLY)
+
+#-----------------------------------------------------------------------------
+# Build the configure file.
+configure_file(${CMAKE_CURRENT_SOURCE_DIR}/vtkm/internal/Configure.h.in
+  ${CMAKE_CURRENT_BINARY_DIR}/vtkm/internal/Configure.h
+  @ONLY)
+vtkm_install_headers(
+  vtkm/internal ${CMAKE_CURRENT_BINARY_DIR}/vtkm/internal/Configure.h)
+
+
+# List of Boost features used:
+# * Smart Ptr
+# * Meta programming language
+find_package(BoostHeaders ${VTKm_REQUIRED_BOOST_VERSION} REQUIRED)
+
+#-----------------------------------------------------------------------------
+# Add subdirectories
+add_subdirectory(vtkm)
+
+# Install the readme and license files.
+install(FILES ${VTKm_SOURCE_DIR}/README.md
+  DESTINATION ${VTKm_INSTALL_CONFIG_DIR}
+  RENAME VTKmREADME.md
+  )
+install(FILES ${VTKm_SOURCE_DIR}/LICENSE.txt
+  DESTINATION ${VTKm_INSTALL_CONFIG_DIR}
+  RENAME VTKmLICENSE.txt
+  )
+
+# Install helper configure files.
+install(
+  FILES
+    ${VTKm_SOURCE_DIR}/CMake/FindBoostHeaders.cmake
+  DESTINATION ${VTKm_INSTALL_CMAKE_MODULE_DIR}
+  )
+
+# Enable CPack packaging
+set(CPACK_PACKAGE_DESCRIPTION_FILE ${VTKm_SOURCE_DIR}/README.md)
+set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "The VTKm Toolkit")
+set(CPACK_PACKAGE_NAME "VTKm")
+set(CPACK_PACKAGE_VERSION_MAJOR ${VTKm_MAJOR_VERSION})
+set(CPACK_PACKAGE_VERSION_MINOR ${VTKm_MINOR_VERSION})
+set(CPACK_PACKAGE_VERSION_PATCH ${VTKm_PATCH_VERSION})
+set(CPACK_PACKAGE_FILE_NAME "VTKm-${VTKm_VERSION}")
+set(CPACK_RESOURCE_FILE_LICENSE ${VTKm_SOURCE_DIR}/LICENSE.txt)
+set(CPACK_RESOURCE_FILE_README ${VTKm_SOURCE_DIR}/README.md)
+include(CPack)

LICENSE.txt

@@ -0,0 +1,75 @@
+VTKm License Version 1.0
+========================================================================
+
+Copyright (c) 2014,
+Sandia Corporation, Los Alamos National Security, LLC.,
+UT-Battelle, LLC., Kitware Inc., University of California Davis
+All rights reserved.
+
+Sandia National Laboratories, New Mexico
+PO Box 5800
+Albuquerque, NM 87185
+USA
+
+UT-Battelle
+1 Bethel Valley Rd
+Oak Ridge, TN 37830
+
+Los Alamos National Security, LLC
+105 Central Park Square
+Los Alamos, NM 87544
+
+Kitware Inc.
+28 Corporate Drive
+Clifton Park, NY 12065
+USA
+
+University of California, Davis
+One Shields Avenue
+Davis, CA 95616
+USA
+
+Under the terms of Contract DE-AC04-94AL85000, there is a
+non-exclusive license for use of this work by or on behalf of the
+U.S. Government.
+
+Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
+Laboratory (LANL), the U.S. Government retains certain rights in
+this software.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+ * Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+
+ * Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the
+   distribution.
+
+ * Neither the name of Kitware nor the names of any contributors may
+   be used to endorse or promote products derived from this software
+   without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+========================================================================
+
+The following files and directories come from third parties. Check the
+contents of these for details on the specifics of their respective
+licenses.
+- - - - - - - - - - - - - - - - - - - - - - - - do not remove this line
+CMake/CheckCXX11Features.cmake
+CMake/FindBoostHeaders.cmake
+vtkm/testing/OptionParser.h

docs/PosterPresentation.md

@@ -0,0 +1,28 @@
+Poster & Presentation:
+
+Things that we want to do.
+Things that we are going to do.
+What would we call it?
+
+dynamic vs templates interfacing.
+The pull between insitu and general purpose library, where we want
+high performance
+
+foundation / groundwork / experimental work
+
+What are the different layers that each project fills
+
+[dax]             -         [eavl]
+
+[filter]          -         []
+
+[worklet]         -
+
+Todo:
+
+1. Dynamic Arrays with tuple(s)
+
+2. Sum of a cell set.
+
+3. [Rob] Create the basic layout with and get the basic concrete array handle
+        to compile with nothing else.

vtkm/CMakeLists.txt

@@ -0,0 +1,38 @@
+##============================================================================
+##  Copyright (c) Kitware, Inc.
+##  All rights reserved.
+##  See LICENSE.txt for details.
+##  This software is distributed WITHOUT ANY WARRANTY; without even
+##  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+##  PURPOSE.  See the above copyright notice for more information.
+##
+##  Copyright 2014 Sandia Corporation.
+##  Copyright 2014 UT-Battelle, LLC.
+##  Copyright 2014. Los Alamos National Security
+##
+##  Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+##  the U.S. Government retains certain rights in this software.
+##
+##  Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
+##  Laboratory (LANL), the U.S. Government retains certain rights in
+##  this software.
+##============================================================================
+
+include_directories(${Boost_INCLUDE_DIRS})
+
+set(headers
+  Types.h
+  TypeTraits.h
+  VectorTraits.h
+  )
+
+vtkm_declare_headers(${headers})
+
+#-----------------------------------------------------------------------------
+#first add all the components vtkm that are shared between control and exec
+add_subdirectory(testing)
+add_subdirectory(internal)
+
+#-----------------------------------------------------------------------------
+#add the control and exec folders
+add_subdirectory(cont)

vtkm/TypeTraits.h

@@ -0,0 +1,145 @@
+//============================================================================
+//  Copyright (c) Kitware, Inc.
+//  All rights reserved.
+//  See LICENSE.txt for details.
+//  This software is distributed WITHOUT ANY WARRANTY; without even
+//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+//  PURPOSE.  See the above copyright notice for more information.
+//
+//  Copyright 2014 Sandia Corporation.
+//  Copyright 2014 UT-Battelle, LLC.
+//  Copyright 2014. Los Alamos National Security
+//
+//  Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//  the U.S. Government retains certain rights in this software.
+//
+//  Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
+//  Laboratory (LANL), the U.S. Government retains certain rights in
+//  this software.
+//============================================================================
+#ifndef vtkm_TypeTraits_h
+#define vtkm_TypeTraits_h
+
+#include <vtkm/Types.h>
+
+namespace vtkm {
+
+/// Tag used to identify types that store real (floating-point) numbers. A
+/// TypeTraits class will typedef this class to NumericTag if it stores real
+/// numbers (or vectors of real numbers).
+///
+struct TypeTraitsRealTag {};
+
+/// Tag used to identify types that store integer numbers. A TypeTraits class
+/// will typedef this class to NumericTag if it stores integer numbers (or
+/// vectors of integers).
+///
+struct TypeTraitsIntegerTag {};
+
+/// Tag used to identify 0 dimensional types (scalars). Scalars can also be
+/// treated like vectors when used with VectorTraits. A TypeTraits class will
+/// typedef this class to DimensionalityTag.
+///
+struct TypeTraitsScalarTag {};
+
+/// Tag used to identify 1 dimensional types (vectors). A TypeTraits class will
+/// typedef this class to DimensionalityTag.
+///
+struct TypeTraitsVectorTag {};
+
+template<typename T> struct TypeTraits;
+
+#ifdef VTKM_DOXYGEN_ONLY
+
+/// The TypeTraits class provides helpful compile-time information about the
+/// basic types used in VTKm (and a few others for convienience). The majority
+/// of TypeTraits contents are typedefs to tags that can be used to easily
+/// override behavior of called functions.
+///
+template<typename T>
+class TypeTraits {
+  typedef int tag_type; // Shut up, test compile.
+public:
+
+  /// \brief A tag to determing whether the type is integer or real.
+  ///
+  /// This tag is either TypeTraitsRealTag or TypeTraitsIntegerTag.
+  typedef tag_type NumericTag;
+
+  /// \brief A tag to determine whether the type has multiple components.
+  ///
+  /// This tag is either TypeTraitsScalarTag or TypeTraitsVectorTag. Scalars can
+  /// also be treated as vectors.
+  typedef tag_type DimensionalityTag;
+};
+
+#endif //VTKM_DOXYGEN_ONLY
+
+// Const types should have the same traits as their non-const counterparts.
+//
+template<typename T>
+struct TypeTraits<const T> : TypeTraits<T>
+{  };
+
+#define VTKM_BASIC_REAL_TYPE(T) \
+template<> struct TypeTraits<T> { \
+  typedef TypeTraitsRealTag NumericTag; \
+  typedef TypeTraitsScalarTag DimensionalityTag; \
+}
+
+#define VTKM_BASIC_INTEGER_TYPE(T) \
+template<> struct TypeTraits<T> { \
+  typedef TypeTraitsIntegerTag NumericTag; \
+  typedef TypeTraitsScalarTag DimensionalityTag; \
+}
+
+/// Traits for basic C++ types.
+///
+
+VTKM_BASIC_REAL_TYPE(float);
+VTKM_BASIC_REAL_TYPE(double);
+VTKM_BASIC_INTEGER_TYPE(char);
+VTKM_BASIC_INTEGER_TYPE(unsigned char);
+VTKM_BASIC_INTEGER_TYPE(short);
+VTKM_BASIC_INTEGER_TYPE(unsigned short);
+VTKM_BASIC_INTEGER_TYPE(int);
+VTKM_BASIC_INTEGER_TYPE(unsigned int);
+#if VTKM_SIZE_LONG == 8
+VTKM_BASIC_INTEGER_TYPE(long);
+VTKM_BASIC_INTEGER_TYPE(unsigned long);
+#elif VTKM_SIZE_LONG_LONG == 8
+VTKM_BASIC_INTEGER_TYPE(long long);
+VTKM_BASIC_INTEGER_TYPE(unsigned long long);
+#else
+#error No implementation for 64-bit integer traits.
+#endif
+
+#undef VTKM_BASIC_REAL_TYPE
+#undef VTKM_BASIC_INTEGER_TYPE
+
+#define VTKM_VECTOR_TYPE(T, NTag) \
+template<> struct TypeTraits<T> { \
+  typedef NTag NumericTag; \
+  typedef TypeTraitsVectorTag DimensionalityTag; \
+}
+
+/// Traits for vector types.
+///
+
+VTKM_VECTOR_TYPE(vtkm::Id3, TypeTraitsIntegerTag);
+VTKM_VECTOR_TYPE(vtkm::Vector2, TypeTraitsRealTag);
+VTKM_VECTOR_TYPE(vtkm::Vector3, TypeTraitsRealTag);
+VTKM_VECTOR_TYPE(vtkm::Vector4, TypeTraitsRealTag);
+
+#undef VTKM_VECTOR_TYPE
+
+/// Traits for tuples.
+///
+template<typename T, int Size> struct TypeTraits<vtkm::Tuple<T, Size> > {
+  typedef typename TypeTraits<T>::NumericTag NumericTag;
+  typedef TypeTraitsVectorTag DimensionalityTag;
+};
+
+} // namespace vtkm
+
+#endif //vtkm_TypeTraits_h

vtkm/Types.h

@@ -0,0 +1,704 @@
+//============================================================================
+//  Copyright (c) Kitware, Inc.
+//  All rights reserved.
+//  See LICENSE.txt for details.
+//  This software is distributed WITHOUT ANY WARRANTY; without even
+//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+//  PURPOSE.  See the above copyright notice for more information.
+//
+//  Copyright 2014 Sandia Corporation.
+//  Copyright 2014 UT-Battelle, LLC.
+//  Copyright 2014. Los Alamos National Security
+//
+//  Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//  the U.S. Government retains certain rights in this software.
+//
+//  Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
+//  Laboratory (LANL), the U.S. Government retains certain rights in
+//  this software.
+//============================================================================
+#ifndef vtkm_Types_h
+#define vtkm_Types_h
+
+#include <vtkm/internal/Configure.h>
+#include <vtkm/internal/ExportMacros.h>
+
+/*!
+ * \namespace vtkm
+ * \brief VTKm Toolkit.
+ *
+ * vtkm is the namespace for the VTKm Toolkit. It contains other sub namespaces,
+ * as well as basic data types and functions callable from all components in VTKm
+ * toolkit.
+ *
+ * \namespace vtkm::cont
+ * \brief VTKm Control Environment.
+ *
+ * vtkm::cont defines the publicly accessible API for the VTKm Control
+ * Environment. Users of the VTKm Toolkit can use this namespace to access the
+ * Control Environment.
+ *
+ * \namespace vtkm::cuda
+ * \brief CUDA implementation.
+ *
+ * vtkm::cuda includes the code to implement the VTKm for CUDA-based platforms.
+ *
+ * \namespace vtkm::cuda::cont
+ * \brief CUDA implementation for Control Environment.
+ *
+ * vtkm::cuda::cont includes the code to implement the VTKm Control Environment
+ * for CUDA-based platforms.
+ *
+ * \namespace vtkm::cuda::exec
+ * \brief CUDA implementation for Execution Environment.
+ *
+ * vtkm::cuda::exec includes the code to implement the VTKm Execution Environment
+ * for CUDA-based platforms.
+ *
+ * \namespace vtkm::exec
+ * \brief VTKm Execution Environment.
+ *
+ * vtkm::exec defines the publicly accessible API for the VTKm Execution
+ * Environment. Worklets typically use classes/apis defined within this
+ * namespace alone.
+ *
+ * \namespace vtkm::internal
+ * \brief VTKm Internal Environment
+ *
+ * vtkm::internal defines API which is internal and subject to frequent
+ * change. This should not be used for projects using VTKm. Instead it servers
+ * are a reference for the developers of VTKm.
+ *
+ * \namespace vtkm::math
+ * \brief Utility math functions
+ *
+ * vtkm::math defines the publicly accessible API for Utility Math functions.
+ *
+ * \namespace vtkm::testing
+ * \brief Internal testing classes
+ *
+ */
+
+namespace vtkm
+{
+//*****************************************************************************
+// Typedefs for basic types.
+//*****************************************************************************
+
+/// Alignment requirements are prescribed by CUDA on device (Table B-1 in NVIDIA
+/// CUDA C Programming Guide 4.0)
+
+namespace internal {
+
+#if VTKM_SIZE_INT == 4
+typedef int Int32Type;
+typedef unsigned int UInt32Type;
+#else
+#error Could not find a 32-bit integer.
+#endif
+
+#if VTKM_SIZE_LONG == 8
+typedef long Int64Type;
+typedef unsigned long UInt64Type;
+#elif VTKM_SIZE_LONG_LONG == 8
+typedef long long Int64Type;
+typedef unsigned long long UInt64Type;
+#else
+#error Could not find a 64-bit integer.
+#endif
+
+//-----------------------------------------------------------------------------
+
+template<int Size>
+struct equals
+{
+  template<typename T>
+  VTKM_EXEC_CONT_EXPORT bool operator()(const T& a, const T& b) const
+  {
+    return equals<Size-1>()(a,b) && a[Size-1] == b[Size-1];
+  }
+};
+
+template<>
+struct equals<1>
+{
+  template<typename T>
+  VTKM_EXEC_CONT_EXPORT bool operator()(const T& a, const T& b) const
+  {
+    return a[0] == b[0];
+  }
+};
+
+template<>
+struct equals<2>
+{
+  template<typename T>
+  VTKM_EXEC_CONT_EXPORT bool operator()(const T& a, const T& b) const
+  {
+    return a[0] == b[0] && a[1] == b[1];
+  }
+};
+
+template<>
+struct equals<3>
+{
+  template<typename T>
+  VTKM_EXEC_CONT_EXPORT bool operator()(const T& a, const T& b) const
+  {
+    return a[0] == b[0] && a[1] == b[1] && a[2] == b[2];
+  }
+};
+
+template<int Size>
+struct assign_scalar_to_vector
+{
+  template<typename VectorType, typename ComponentType>
+  VTKM_EXEC_CONT_EXPORT
+  void operator()(VectorType &dest, const ComponentType &src)
+  {
+    assign_scalar_to_vector<Size-1>()(dest, src);
+    dest[Size-1] = src;
+  }
+};
+
+template<>
+struct assign_scalar_to_vector<1>
+{
+  template<typename VectorType, typename ComponentType>
+  VTKM_EXEC_CONT_EXPORT
+  void operator()(VectorType &dest, const ComponentType &src)
+  {
+    dest[0] = src;
+  }
+};
+
+template<>
+struct assign_scalar_to_vector<2>
+{
+  template<typename VectorType, typename ComponentType>
+  VTKM_EXEC_CONT_EXPORT
+  void operator()(VectorType &dest, const ComponentType &src)
+  {
+    dest[0] = src; dest[1] = src;
+  }
+};
+
+template<>
+struct assign_scalar_to_vector<3>
+{
+  template<typename VectorType, typename ComponentType>
+  VTKM_EXEC_CONT_EXPORT
+  void operator()(VectorType &dest, const ComponentType &src)
+  {
+    dest[0] = src; dest[1] = src; dest[2] = src;
+  }
+};
+
+template<int Size>
+struct copy_vector
+{
+  template<typename T1, typename T2>
+  VTKM_EXEC_CONT_EXPORT void operator()(T1 &dest, const T2 &src)
+  {
+    copy_vector<Size-1>()(dest, src);
+    dest[Size-1] = src[Size-1];
+  }
+};
+
+template<>
+struct copy_vector<1>
+{
+  template<typename T1, typename T2>
+  VTKM_EXEC_CONT_EXPORT void operator()(T1 &dest, const T2 &src)
+  {
+    dest[0] = src[0];
+  }
+};
+
+template<>
+struct copy_vector<2>
+{
+  template<typename T1, typename T2>
+  VTKM_EXEC_CONT_EXPORT void operator()(T1 &dest, const T2 &src)
+  {
+    dest[0] = src[0]; dest[1] = src[1];
+  }
+};
+
+template<>
+struct copy_vector<3>
+{
+  template<typename T1, typename T2>
+  VTKM_EXEC_CONT_EXPORT void operator()(T1 &dest, const T2 &src)
+  {
+    dest[0] = src[0]; dest[1] = src[1]; dest[2] = src[2];
+  }
+};
+
+
+} // namespace internal
+
+//-----------------------------------------------------------------------------
+
+#if VTKM_SIZE_ID == 4
+
+/// Represents an ID.
+typedef internal::Int32Type Id __attribute__ ((aligned(VTKM_SIZE_ID)));
+
+#elif VTKM_SIZE_ID == 8
+
+/// Represents an ID.
+typedef internal::Int64Type Id __attribute__ ((aligned(VTKM_SIZE_ID)));
+
+#else
+#error Unknown Id Size
+#endif
+
+#ifdef VTKM_USE_DOUBLE_PRECISION
+
+/// Scalar corresponds to a floating point number.
+typedef double Scalar __attribute__ ((aligned(VTKM_SIZE_SCALAR)));
+
+#else //VTKM_USE_DOUBLE_PRECISION
+
+/// Scalar corresponds to a floating point number.
+typedef float Scalar __attribute__ ((aligned(VTKM_SIZE_SCALAR)));
+
+#endif //VTKM_USE_DOUBLE_PRECISION
+
+//-----------------------------------------------------------------------------
+
+/// Tuple corresponds to a Size-tuple of type T
+template<typename T, int Size>
+class Tuple {
+public:
+  typedef T ComponentType;
+  static const int NUM_COMPONENTS=Size;
+
+  VTKM_EXEC_CONT_EXPORT Tuple(){}
+  VTKM_EXEC_CONT_EXPORT explicit Tuple(const ComponentType& value)
+    {
+    for(int i=0; i < NUM_COMPONENTS;++i)
+      {
+      this->Components[i]=value;
+      }
+    }
+  VTKM_EXEC_CONT_EXPORT explicit Tuple(const ComponentType* values)
+    {
+    for(int i=0; i < NUM_COMPONENTS;++i)
+      {
+      this->Components[i]=values[i];
+      }
+    }
+  VTKM_EXEC_CONT_EXPORT
+  Tuple(const Tuple<ComponentType, Size> &src)
+  {
+    for (int i = 0; i < NUM_COMPONENTS; i++)
+      {
+      this->Components[i] = src[i];
+      }
+  }
+
+  VTKM_EXEC_CONT_EXPORT
+  Tuple<ComponentType, Size> &operator=(const Tuple<ComponentType, Size> &src)
+  {
+    for (int i = 0; i < NUM_COMPONENTS; i++)
+      {
+      this->Components[i] = src[i];
+      }
+    return *this;
+  }
+
+  VTKM_EXEC_CONT_EXPORT const ComponentType &operator[](int idx) const {
+    return this->Components[idx];
+  }
+  VTKM_EXEC_CONT_EXPORT ComponentType &operator[](int idx) {
+    return this->Components[idx];
+  }
+
+  VTKM_EXEC_CONT_EXPORT
+  bool operator==(const Tuple<T,NUM_COMPONENTS> &other) const
+  {
+    bool same = true;
+    for (int componentIndex=0; componentIndex<NUM_COMPONENTS; componentIndex++)
+      {
+      same &= (this->Components[componentIndex] == other[componentIndex]);
+      }
+    return same;
+  }
+
+  VTKM_EXEC_CONT_EXPORT
+  bool operator<(const Tuple<T,NUM_COMPONENTS> &other) const
+  {
+    for(vtkm::Id i=0; i < NUM_COMPONENTS; ++i)
+      {
+      //ignore equals as that represents check next value
+      if(this->Components[i] < other[i])
+        return true;
+      else if(other[i] < this->Components[i])
+        return false;
+      } //if all same we are not less
+      return false;
+  }
+
+  VTKM_EXEC_CONT_EXPORT
+  bool operator!=(const Tuple<T,NUM_COMPONENTS> &other) const
+  {
+    return !(this->operator==(other));
+  }
+
+protected:
+  ComponentType Components[NUM_COMPONENTS];
+};
+
+//-----------------------------------------------------------------------------
+// Specializations for common tuple sizes (with special names).
+
+template<typename T>
+class Tuple<T,2>{
+public:
+  typedef T ComponentType;
+  static const int NUM_COMPONENTS = 2;
+
+  VTKM_EXEC_CONT_EXPORT Tuple(){}
+  VTKM_EXEC_CONT_EXPORT explicit Tuple(const ComponentType& value)
+  {
+    internal::assign_scalar_to_vector<NUM_COMPONENTS>()(this->Components,value);
+  }
+  VTKM_EXEC_CONT_EXPORT explicit Tuple(const ComponentType* values)
+  {
+    internal::copy_vector<NUM_COMPONENTS>()(this->Components, values);
+  }
+  VTKM_EXEC_CONT_EXPORT Tuple(ComponentType x, ComponentType y) {
+    this->Components[0] = x;
+    this->Components[1] = y;
+  }
+  VTKM_EXEC_CONT_EXPORT
+  Tuple(const Tuple<ComponentType, NUM_COMPONENTS> &src)
+  {
+    internal::copy_vector<NUM_COMPONENTS>()(this->Components, src.Components);
+  }
+
+  VTKM_EXEC_CONT_EXPORT
+  Tuple<ComponentType, NUM_COMPONENTS> &
+  operator=(const Tuple<ComponentType, NUM_COMPONENTS> &src)
+  {
+    internal::copy_vector<NUM_COMPONENTS>()(this->Components, src.Components);
+    return *this;
+  }
+
+  VTKM_EXEC_CONT_EXPORT const ComponentType &operator[](int idx) const {
+    return this->Components[idx];
+  }
+  VTKM_EXEC_CONT_EXPORT ComponentType &operator[](int idx) {
+    return this->Components[idx];
+  }
+
+  VTKM_EXEC_CONT_EXPORT
+  bool operator==(const Tuple<T,NUM_COMPONENTS> &other) const
+  {
+    return internal::equals<NUM_COMPONENTS>()(*this, other);
+  }
+  VTKM_EXEC_CONT_EXPORT
+  bool operator!=(const Tuple<T,NUM_COMPONENTS> &other) const
+  {
+    return !(this->operator==(other));
+  }
+
+  VTKM_EXEC_CONT_EXPORT
+  bool operator<(const Tuple<T,NUM_COMPONENTS> &other) const
+  {
+  return( (this->Components[0] < other[0])  ||
+         (!(other[0] < this->Components[0]) && (this->Components[1] < other[1]))
+        );
+  }
+
+protected:
+  ComponentType Components[NUM_COMPONENTS];
+};
+
+/// Vector2 corresponds to a 2-tuple
+typedef vtkm::Tuple<vtkm::Scalar,2>
+    Vector2 __attribute__ ((aligned(VTKM_ALIGNMENT_TWO_SCALAR)));
+
+
+/// Id2 corresponds to a 2-dimensional index
+typedef vtkm::Tuple<vtkm::Id,2> Id2 __attribute__ ((aligned(VTKM_SIZE_ID)));
+
+template<typename T>
+class Tuple<T,3>{
+public:
+  typedef T ComponentType;
+  static const int NUM_COMPONENTS = 3;
+
+  VTKM_EXEC_CONT_EXPORT Tuple(){}
+  VTKM_EXEC_CONT_EXPORT explicit Tuple(const ComponentType& value)
+  {
+    internal::assign_scalar_to_vector<NUM_COMPONENTS>()(this->Components,value);
+  }
+  VTKM_EXEC_CONT_EXPORT explicit Tuple(const ComponentType* values)
+  {
+    internal::copy_vector<NUM_COMPONENTS>()(this->Components, values);
+  }
+  VTKM_EXEC_CONT_EXPORT
+  Tuple(ComponentType x, ComponentType y, ComponentType z) {
+    this->Components[0] = x;
+    this->Components[1] = y;
+    this->Components[2] = z;
+  }
+  VTKM_EXEC_CONT_EXPORT
+  Tuple(const Tuple<ComponentType, NUM_COMPONENTS> &src)
+  {
+    internal::copy_vector<NUM_COMPONENTS>()(this->Components, src.Components);
+  }
+
+  VTKM_EXEC_CONT_EXPORT
+  Tuple<ComponentType, NUM_COMPONENTS> &
+  operator=(const Tuple<ComponentType, NUM_COMPONENTS> &src)
+  {
+    internal::copy_vector<NUM_COMPONENTS>()(this->Components, src.Components);
+    return *this;
+  }
+
+  VTKM_EXEC_CONT_EXPORT const ComponentType &operator[](int idx) const {
+    return this->Components[idx];
+  }
+  VTKM_EXEC_CONT_EXPORT ComponentType &operator[](int idx) {
+    return this->Components[idx];
+  }
+
+  VTKM_EXEC_CONT_EXPORT
+  bool operator==(const Tuple<T,NUM_COMPONENTS> &other) const
+  {
+    return internal::equals<NUM_COMPONENTS>()(*this, other);
+  }
+  VTKM_EXEC_CONT_EXPORT
+  bool operator!=(const Tuple<T,NUM_COMPONENTS> &other) const
+  {
+    return !(this->operator==(other));
+  }
+
+  VTKM_EXEC_CONT_EXPORT
+  bool operator<(const Tuple<T,NUM_COMPONENTS> &other) const
+  {
+  return((this->Components[0] < other[0])    ||
+         ( !(other[0] < this->Components[0]) &&
+          (this->Components[1] < other[1]))  ||
+         ( !(other[0] < this->Components[0]) &&
+           !(other[1] < this->Components[1]) &&
+            (this->Components[2] < other[2]) ) );
+  }
+
+protected:
+  ComponentType Components[NUM_COMPONENTS];
+};
+
+/// Vector3 corresponds to a 3-tuple
+typedef vtkm::Tuple<vtkm::Scalar,3>
+    Vector3 __attribute__ ((aligned(VTKM_SIZE_SCALAR)));
+
+template<typename T>
+class Tuple<T,4>{
+public:
+  typedef T ComponentType;
+  static const int NUM_COMPONENTS = 4;
+
+  VTKM_EXEC_CONT_EXPORT Tuple(){}
+  VTKM_EXEC_CONT_EXPORT explicit Tuple(const ComponentType& value)
+  {
+    internal::assign_scalar_to_vector<NUM_COMPONENTS>()(this->Components,value);
+  }
+  VTKM_EXEC_CONT_EXPORT explicit Tuple(const ComponentType* values)
+  {
+    internal::copy_vector<NUM_COMPONENTS>()(this->Components, values);
+  }
+  VTKM_EXEC_CONT_EXPORT
+  Tuple(ComponentType x, ComponentType y, ComponentType z, ComponentType w) {
+    this->Components[0] = x;
+    this->Components[1] = y;
+    this->Components[2] = z;
+    this->Components[3] = w;
+  }
+  VTKM_EXEC_CONT_EXPORT
+  Tuple(const Tuple<ComponentType, NUM_COMPONENTS> &src)
+  {
+    internal::copy_vector<NUM_COMPONENTS>()(this->Components, src.Components);
+  }
+
+  VTKM_EXEC_CONT_EXPORT
+  Tuple<ComponentType, NUM_COMPONENTS> &
+  operator=(const Tuple<ComponentType, NUM_COMPONENTS> &src)
+  {
+    internal::copy_vector<NUM_COMPONENTS>()(this->Components, src.Components);
+    return *this;
+  }
+
+  VTKM_EXEC_CONT_EXPORT const ComponentType &operator[](int idx) const {
+    return this->Components[idx];
+  }
+  VTKM_EXEC_CONT_EXPORT ComponentType &operator[](int idx) {
+    return this->Components[idx];
+  }
+
+  VTKM_EXEC_CONT_EXPORT
+  bool operator==(const Tuple<T,NUM_COMPONENTS> &other) const
+  {
+    return internal::equals<NUM_COMPONENTS>()(*this, other);
+  }
+  VTKM_EXEC_CONT_EXPORT
+  bool operator!=(const Tuple<T,NUM_COMPONENTS> &other) const
+  {
+    return !(this->operator==(other));
+  }
+
+  VTKM_EXEC_CONT_EXPORT
+  bool operator<(const Tuple<T,NUM_COMPONENTS> &other) const
+  {
+  return((this->Components[0] < other[0])       ||
+         ( !(other[0] < this->Components[0])    &&
+               this->Components[1] < other[1])  ||
+         ( !(other[0] < this->Components[0])    &&
+           !(other[1] < this->Components[1])    &&
+           (this->Components[2] < other[2]) )   ||
+         ( !(other[0] < this->Components[0])    &&
+           !(other[1] < this->Components[1])    &&
+           !(other[2] < this->Components[2])    &&
+           (this->Components[3] < other[3])) );
+  }
+
+protected:
+  ComponentType Components[NUM_COMPONENTS];
+};
+
+/// Vector4 corresponds to a 4-tuple
+typedef vtkm::Tuple<vtkm::Scalar,4>
+    Vector4 __attribute__ ((aligned(VTKM_ALIGNMENT_FOUR_SCALAR)));
+
+
+/// Id3 corresponds to a 3-dimensional index for 3d arrays.  Note that
+/// the precision of each index may be less than vtkm::Id.
+typedef vtkm::Tuple<vtkm::Id,3> Id3 __attribute__ ((aligned(VTKM_SIZE_ID)));
+
+/// Initializes and returns a Vector2.
+VTKM_EXEC_CONT_EXPORT vtkm::Vector2 make_Vector2(vtkm::Scalar x,
+                                               vtkm::Scalar y)
+{
+  return vtkm::Vector2(x, y);
+}
+
+/// Initializes and returns a Vector3.
+VTKM_EXEC_CONT_EXPORT vtkm::Vector3 make_Vector3(vtkm::Scalar x,
+                                               vtkm::Scalar y,
+                                               vtkm::Scalar z)
+{
+  return vtkm::Vector3(x, y, z);
+}
+
+/// Initializes and returns a Vector4.
+VTKM_EXEC_CONT_EXPORT vtkm::Vector4 make_Vector4(vtkm::Scalar x,
+                                               vtkm::Scalar y,
+                                               vtkm::Scalar z,
+                                               vtkm::Scalar w)
+{
+  return vtkm::Vector4(x, y, z, w);
+}
+
+/// Initializes and returns an Id3
+VTKM_EXEC_CONT_EXPORT vtkm::Id3 make_Id3(vtkm::Id x, vtkm::Id y, vtkm::Id z)
+{
+  return vtkm::Id3(x, y, z);
+}
+
+template<typename T, int Size>
+VTKM_EXEC_CONT_EXPORT T dot(const vtkm::Tuple<T,Size> &a,
+                           const vtkm::Tuple<T,Size> &b)
+{
+  T result = a[0]*b[0];
+  for (int componentIndex = 1; componentIndex < Size; componentIndex++)
+    {
+    result += a[componentIndex]*b[componentIndex];
+    }
+  return result;
+}
+
+VTKM_EXEC_CONT_EXPORT vtkm::Id dot(vtkm::Id a, vtkm::Id b)
+{
+  return a * b;
+}
+
+VTKM_EXEC_CONT_EXPORT vtkm::Scalar dot(vtkm::Scalar a, vtkm::Scalar b)
+{
+  return a * b;
+}
+
+} // End of namespace vtkm
+
+template<typename T, int Size>
+VTKM_EXEC_CONT_EXPORT vtkm::Tuple<T,Size> operator+(const vtkm::Tuple<T,Size> &a,
+                                                  const vtkm::Tuple<T,Size> &b)
+{
+  vtkm::Tuple<T,Size> result;
+  for (int componentIndex = 0; componentIndex < Size; componentIndex++)
+    {
+    result[componentIndex] = a[componentIndex] + b[componentIndex];
+    }
+  return result;
+}
+template<typename T, int Size>
+VTKM_EXEC_CONT_EXPORT vtkm::Tuple<T,Size> operator-(const vtkm::Tuple<T,Size> &a,
+                                                  const vtkm::Tuple<T,Size> &b)
+{
+  vtkm::Tuple<T,Size> result;
+  for (int componentIndex = 0; componentIndex < Size; componentIndex++)
+    {
+    result[componentIndex] = a[componentIndex] - b[componentIndex];
+    }
+  return result;
+}
+template<typename T, int Size>
+VTKM_EXEC_CONT_EXPORT vtkm::Tuple<T,Size> operator*(const vtkm::Tuple<T,Size> &a,
+                                                  const vtkm::Tuple<T,Size> &b)
+{
+  vtkm::Tuple<T,Size> result;
+  for (int componentIndex = 0; componentIndex < Size; componentIndex++)
+    {
+    result[componentIndex] = a[componentIndex] * b[componentIndex];
+    }
+  return result;
+}
+template<typename T, int Size>
+VTKM_EXEC_CONT_EXPORT vtkm::Tuple<T,Size> operator/(const vtkm::Tuple<T,Size> &a,
+                                                  const vtkm::Tuple<T,Size> &b)
+{
+  vtkm::Tuple<T,Size> result;
+  for (int componentIndex = 0; componentIndex < Size; componentIndex++)
+    {
+    result[componentIndex] = a[componentIndex] / b[componentIndex];
+    }
+  return result;
+}
+
+template<typename Ta, typename Tb, int Size>
+VTKM_EXEC_CONT_EXPORT vtkm::Tuple<Ta,Size> operator*(const vtkm::Tuple<Ta,Size> &a,
+                                                   const Tb &b)
+{
+  vtkm::Tuple<Ta,Size> result;
+  for (int componentIndex = 0; componentIndex < Size; componentIndex++)
+    {
+    result[componentIndex] = a[componentIndex] * b;
+    }
+  return result;
+}
+template<typename Ta, typename Tb, int Size>
+VTKM_EXEC_CONT_EXPORT vtkm::Tuple<Tb,Size> operator*(const Ta &a,
+                                                   const vtkm::Tuple<Tb,Size> &b)
+{
+  vtkm::Tuple<Tb,Size> result;
+  for (int componentIndex = 0; componentIndex < Size; componentIndex++)
+    {
+    result[componentIndex] = a * b[componentIndex];
+    }
+  return result;
+}
+
+#endif //vtkm_Types_h

vtkm/VectorTraits.h

@@ -0,0 +1,222 @@
+//============================================================================
+//  Copyright (c) Kitware, Inc.
+//  All rights reserved.
+//  See LICENSE.txt for details.
+//  This software is distributed WITHOUT ANY WARRANTY; without even
+//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+//  PURPOSE.  See the above copyright notice for more information.
+//
+//  Copyright 2014 Sandia Corporation.
+//  Copyright 2014 UT-Battelle, LLC.
+//  Copyright 2014. Los Alamos National Security
+//
+//  Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//  the U.S. Government retains certain rights in this software.
+//
+//  Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
+//  Laboratory (LANL), the U.S. Government retains certain rights in
+//  this software.
+//============================================================================
+#ifndef vtkm_VectorTraits_h
+#define vtkm_VectorTraits_h
+
+#include <vtkm/Types.h>
+
+#include <boost/type_traits/remove_const.hpp>
+
+namespace vtkm {
+
+/// A tag for vectors that are "true" vectors (i.e. have more than one
+/// component).
+///
+struct VectorTraitsTagMultipleComponents { };
+
+/// A tag for vectors that a really just scalars (i.e. have only one component)
+///
+struct VectorTraitsTagSingleComponent { };
+
+namespace internal {
+
+template<int numComponents>
+struct VectorTraitsMultipleComponentChooser {
+  typedef VectorTraitsTagMultipleComponents Type;
+};
+
+template<>
+struct VectorTraitsMultipleComponentChooser<1> {
+  typedef VectorTraitsTagSingleComponent Type;
+};
+
+} // namespace detail
+
+/// The VectorTraits class gives several static members that define how
+/// to use a given type as a vector.
+///
+template<class VectorType>
+struct VectorTraits
+#ifdef VTKM_DOXYGEN_ONLY
+{
+  /// Type of the components in the vector.
+  ///
+  typedef typename VectorType::ComponentType ComponentType;
+
+  /// Number of components in the vector.
+  ///
+  static const int NUM_COMPONENTS = VectorType::NUM_COMPONENTS;
+
+  /// A tag specifying whether this vector has multiple components (i.e. is a
+  /// "real" vector). This tag can be useful for creating specialized functions
+  /// when a vector is really just a scalar.
+  ///
+  typedef typename internal::VectorTraitsMultipleComponentChooser<
+      NUM_COMPONENTS>::Type HasMultipleComponents;
+
+  /// Returns the value in a given component of the vector.
+  ///
+  VTKM_EXEC_CONT_EXPORT static const ComponentType &GetComponent(
+      const typename boost::remove_const<VectorType>::type &vector,
+      int component);
+  VTKM_EXEC_CONT_EXPORT static ComponentType &GetComponent(
+      typename boost::remove_const<VectorType>::type &vector,
+      int component);
+
+  /// Changes the value in a given component of the vector.
+  ///
+  VTKM_EXEC_CONT_EXPORT static void SetComponent(VectorType &vector,
+                                                int component,
+                                                ComponentType value);
+
+  /// Converts whatever type this vector is into the standard VTKm Tuple.
+  ///
+  VTKM_EXEC_CONT_EXPORT
+  static vtkm::Tuple<ComponentType,NUM_COMPONENTS>
+  ToTuple(const VectorType &vector);
+};
+#else // VTKM_DOXYGEN_ONLY
+    ;
+#endif // VTKM_DOXYGEN_ONLY
+
+// This partial specialization allows you to define a non-const version of
+// VectorTraits and have it still work for const version.
+//
+template<typename T>
+struct VectorTraits<const T> : VectorTraits<T>
+{  };
+
+template<typename T, int Size>
+struct VectorTraits<vtkm::Tuple<T,Size> >
+{
+  typedef vtkm::Tuple<T,Size> VectorType;
+
+  /// Type of the components in the vector.
+  ///
+  typedef typename VectorType::ComponentType ComponentType;
+
+  /// Number of components in the vector.
+  ///
+  static const int NUM_COMPONENTS = VectorType::NUM_COMPONENTS;
+
+  /// A tag specifying whether this vector has multiple components (i.e. is a
+  /// "real" vector). This tag can be useful for creating specialized functions
+  /// when a vector is really just a scalar.
+  ///
+  typedef typename internal::VectorTraitsMultipleComponentChooser<
+      NUM_COMPONENTS>::Type HasMultipleComponents;
+
+  /// Returns the value in a given component of the vector.
+  ///
+  VTKM_EXEC_CONT_EXPORT
+  static const ComponentType &GetComponent(const VectorType &vector,
+                                           int component)
+  {
+    return vector[component];
+  }
+  VTKM_EXEC_CONT_EXPORT
+  static ComponentType &GetComponent(VectorType &vector, int component) {
+    return vector[component];
+  }
+
+  /// Changes the value in a given component of the vector.
+  ///
+  VTKM_EXEC_CONT_EXPORT static void SetComponent(VectorType &vector,
+                                                int component,
+                                                ComponentType value) {
+    vector[component] = value;
+  }
+
+  /// Converts whatever type this vector is into the standard VTKm Tuple.
+  ///
+  VTKM_EXEC_CONT_EXPORT
+  static vtkm::Tuple<ComponentType,NUM_COMPONENTS>
+  ToTuple(const VectorType &vector)
+  {
+    return vector;
+  }
+};
+
+namespace internal {
+/// Used for overriding VectorTraits for basic scalar types.
+///
+template<typename ScalarType>
+struct VectorTraitsBasic {
+  typedef ScalarType ComponentType;
+  static const int NUM_COMPONENTS = 1;
+  typedef VectorTraitsTagSingleComponent HasMultipleComponents;
+
+  VTKM_EXEC_CONT_EXPORT static const ComponentType &GetComponent(
+      const ScalarType &vector,
+      int) {
+    return vector;
+  }
+  VTKM_EXEC_CONT_EXPORT
+  static ComponentType &GetComponent(ScalarType &vector, int) {
+    return vector;
+  }
+
+  VTKM_EXEC_CONT_EXPORT static void SetComponent(ScalarType &vector,
+                                                int,
+                                                ComponentType value) {
+    vector = value;
+  }
+
+  VTKM_EXEC_CONT_EXPORT
+  static vtkm::Tuple<ScalarType,1> ToTuple(const ScalarType &vector)
+  {
+    return vtkm::Tuple<ScalarType,1>(vector);
+  }
+};
+}
+
+#define VTKM_BASIC_TYPE_VECTOR(type) \
+  template<> \
+  struct VectorTraits<type> \
+      : public vtkm::internal::VectorTraitsBasic<type> { };/* \
+  template<> \
+  struct VectorTraits<const type> \
+      : public vtkm::internal::VectorTraitsBasic<type> { }*/
+
+/// Allows you to treat basic types as if they were vectors.
+
+VTKM_BASIC_TYPE_VECTOR(float);
+VTKM_BASIC_TYPE_VECTOR(double);
+VTKM_BASIC_TYPE_VECTOR(char);
+VTKM_BASIC_TYPE_VECTOR(unsigned char);
+VTKM_BASIC_TYPE_VECTOR(short);
+VTKM_BASIC_TYPE_VECTOR(unsigned short);
+VTKM_BASIC_TYPE_VECTOR(int);
+VTKM_BASIC_TYPE_VECTOR(unsigned int);
+#if VTKM_SIZE_LONG == 8
+VTKM_BASIC_TYPE_VECTOR(long);
+VTKM_BASIC_TYPE_VECTOR(unsigned long);
+#elif VTKM_SIZE_LONG_LONG == 8
+VTKM_BASIC_TYPE_VECTOR(long long);
+VTKM_BASIC_TYPE_VECTOR(unsigned long long);
+#else
+#error No implementation for 64-bit vector traits.
+#endif
+
+#undef VTKM_BASIC_TYPE_VECTOR
+
+}
+
+#endif //vtkm_VectorTraits_h

vtkm/cont/ArrayContainerControl.h

@@ -0,0 +1,168 @@
+//============================================================================
+//  Copyright (c) Kitware, Inc.
+//  All rights reserved.
+//  See LICENSE.txt for details.
+//  This software is distributed WITHOUT ANY WARRANTY; without even
+//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+//  PURPOSE.  See the above copyright notice for more information.
+//
+//  Copyright 2014 Sandia Corporation.
+//  Copyright 2014 UT-Battelle, LLC.
+//  Copyright 2014. Los Alamos National Security
+//
+//  Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//  the U.S. Government retains certain rights in this software.
+//
+//  Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
+//  Laboratory (LANL), the U.S. Government retains certain rights in
+//  this software.
+//============================================================================
+#ifndef vtkm_cont__ArrayContainerControl_h
+#define vtkm_cont__ArrayContainerControl_h
+
+#define VTKM_ARRAY_CONTAINER_CONTROL_ERROR      -1
+#define VTKM_ARRAY_CONTAINER_CONTROL_UNDEFINED   0
+#define VTKM_ARRAY_CONTAINER_CONTROL_BASIC       1
+
+#ifndef VTKM_ARRAY_CONTAINER_CONTROL
+#define VTKM_ARRAY_CONTAINER_CONTROL VTKM_ARRAY_CONTAINER_CONTROL_BASIC
+#endif
+
+namespace vtkm {
+namespace cont {
+
+#ifdef VTKM_DOXYGEN_ONLY
+/// \brief A tag specifying client memory allocation.
+///
+/// An ArrayContainerControl tag specifies how an ArrayHandle allocates and
+/// frees memory. The tag ArrayContainerControlTag___ does not actually exist.
+/// Rather, this documentation is provided to describe how array containers are
+/// specified. Loading the vtkm/cont/ArrayContainerControl.h header will set a
+/// default array container. You can specify the default array container by
+/// first setting the VTKM_ARRAY_CONTAINER_CONTROL macro.  Currently it can only
+/// be set to VTKM_ARRAY_CONTAINER_CONTROL_BASIC.
+///
+/// User code external to VTKm is free to make its own ArrayContainerControlTag.
+/// This is a good way to get VTKm to read data directly in and out of arrays
+/// from other libraries. However, care should be taken when creating an
+/// ArrayContainerControl. One particular problem that is likely is a container
+/// that "constructs" all the items in the array. If done incorrectly, then
+/// memory of the array can be incorrectly bound to the wrong process. If you
+/// do provide your own ArrayContainerControlTag, please be diligent in
+/// comparing its performance to the ArrayContainerControlTagBasic.
+///
+/// To implement your own ArrayContainerControlTag, you first must create a tag
+/// class (an empty struct) defining your tag (i.e. struct
+/// ArrayContainerControlTagMyAlloc { };). Then provide a partial template
+/// specialization of vtkm::cont::internal::ArrayContainerControl for your new
+/// tag.
+///
+struct ArrayContainerControlTag___ {  };
+#endif // VTKM_DOXYGEN_ONLY
+
+namespace internal {
+
+/// This templated class must be partially specialized for each
+/// ArrayContainerControlTag created, which will define the implementation for
+/// that tag.
+///
+template<typename T, class ArrayContainerControlTag>
+class ArrayContainerControl
+#ifdef VTKM_DOXYGEN_ONLY
+{
+public:
+
+  /// The type of each item in the array.
+  ///
+  typedef T ValueType;
+
+  /// \brief The type of portal objects for the array.
+  ///
+  /// The actual portal object can take any form. This is a simple example of a
+  /// portal to a C array.
+  ///
+  typedef ::vtkm::cont::internal::ArrayPortalFromIterators<ValueType*> PortalType;
+
+  /// \brief The type of portal objects (const version) for the array.
+  ///
+  /// The actual portal object can take any form. This is a simple example of a
+  /// portal to a C array.
+  ///
+  typedef ::vtkm::cont::internal::ArrayPortalFromIterators<const ValueType*> PortalConstType;
+
+  /// Returns a portal to the array.
+  ///
+  VTKM_CONT_EXPORT
+  PortalType GetPortal();
+
+  /// Returns a portal to the array with immutable values.
+  ///
+  VTKM_CONT_EXPORT
+  PortalConstType GetPortalConst() const;
+
+  /// Retuns the number of entries allocated in the array.
+  VTKM_CONT_EXPORT
+  vtkm::Id GetNumberOfValues() const;
+
+  /// \brief Allocates an array large enough to hold the given number of values.
+  ///
+  /// The allocation may be done on an already existing array, but can wipe out
+  /// any data already in the array. This method can throw
+  /// ErrorControlOutOfMemory if the array cannot be allocated.
+  ///
+  VTKM_CONT_EXPORT
+  void Allocate(vtkm::Id numberOfValues);
+
+  /// \brief Reduces the size of the array without changing its values.
+  ///
+  /// This method allows you to resize the array without reallocating it. The
+  /// number of entries in the array is changed to \c numberOfValues. The data
+  /// in the array (from indices 0 to \c numberOfValues - 1) are the same, but
+  /// \c numberOfValues must be equal or less than the preexisting size
+  /// (returned from GetNumberOfValues). That is, this method can only be used
+  /// to shorten the array, not lengthen.
+  VTKM_CONT_EXPORT
+  void Shrink(vtkm::Id numberOfValues);
+
+  /// \brief Frees any resources (i.e. memory) stored in this array.
+  ///
+  /// After calling this method GetNumberOfValues will return 0 and
+  /// GetIteratorBegin and GetIteratorEnd will return the same iterator. The
+  /// resources should also be released when the ArrayContainerControl class is
+  /// destroyed.
+  VTKM_CONT_EXPORT
+  void ReleaseResources();
+};
+#else // VTKM_DOXYGEN_ONLY
+;
+#endif // VTKM_DOXYGEN_ONLY
+
+} // namespace internal
+
+}
+} // namespace vtkm::cont
+
+// This is put at the bottom of the header so that the ArrayContainerControl
+// template is declared before any implementations are called.
+
+#if VTKM_ARRAY_CONTAINER_CONTROL == VTKM_ARRAY_CONTAINER_CONTROL_BASIC
+
+#include <vtkm/cont/ArrayContainerControlBasic.h>
+#define VTKM_DEFAULT_ARRAY_CONTAINER_CONTROL_TAG \
+  ::vtkm::cont::ArrayContainerControlTagBasic
+
+#elif VTKM_ARRAY_CONTAINER_CONTROL == VTKM_ARRAY_CONTAINER_CONTROL_ERROR
+
+#include <vtkm/cont/internal/ArrayContainerControlError.h>
+#define VTKM_DEFAULT_ARRAY_CONTAINER_CONTROL_TAG \
+  ::vtkm::cont::internal::ArrayContainerControlTagError
+
+#elif (VTKM_ARRAY_CONTAINER_CONTROL == VTKM_ARRAY_CONTAINER_CONTROL_UNDEFINED) || !defined(VTKM_ARRAY_CONTAINER_CONTROL)
+
+#ifndef VTKM_DEFAULT_ARRAY_CONTAINER_CONTROL_TAG
+#warning If array container for control is undefined, VTKM_DEFAULT_ARRAY_CONTAINER_CONTROL_TAG must be defined.
+#endif
+
+#endif
+
+#endif //vtkm_cont__ArrayContainerControl_h

vtkm/cont/ArrayContainerControlBasic.h

@@ -0,0 +1,184 @@
+//============================================================================
+//  Copyright (c) Kitware, Inc.
+//  All rights reserved.
+//  See LICENSE.txt for details.
+//  This software is distributed WITHOUT ANY WARRANTY; without even
+//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+//  PURPOSE.  See the above copyright notice for more information.
+//
+//  Copyright 2014 Sandia Corporation.
+//  Copyright 2014 UT-Battelle, LLC.
+//  Copyright 2014. Los Alamos National Security
+//
+//  Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//  the U.S. Government retains certain rights in this software.
+//
+//  Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
+//  Laboratory (LANL), the U.S. Government retains certain rights in
+//  this software.
+//============================================================================
+#ifndef vtkm_cont__ArrayContainerControlBasic_h
+#define vtkm_cont__ArrayContainerControlBasic_h
+
+#include <vtkm/Types.h>
+#include <vtkm/cont/ArrayContainerControl.h>
+#include <vtkm/cont/Assert.h>
+#include <vtkm/cont/ErrorControlBadValue.h>
+#include <vtkm/cont/ErrorControlOutOfMemory.h>
+#include <vtkm/cont/internal/ArrayPortalFromIterators.h>
+
+namespace vtkm {
+namespace cont {
+
+/// A tag for the basic implementation of an ArrayContainerControl object.
+struct ArrayContainerControlTagBasic {  };
+
+namespace internal {
+
+/// A basic implementation of an ArrayContainerControl object.
+///
+/// \todo This container does \em not construct the values within the array.
+/// Thus, it is important to not use this class with any type that will fail if
+/// not constructed. These are things like basic types (int, float, etc.) and
+/// the VTKm Tuple classes.  In the future it would be nice to have a compile
+/// time check to enforce this.
+///
+template <typename ValueT>
+class ArrayContainerControl<ValueT, vtkm::cont::ArrayContainerControlTagBasic>
+{
+public:
+  typedef ValueT ValueType;
+  typedef vtkm::cont::internal::ArrayPortalFromIterators<ValueType*> PortalType;
+  typedef vtkm::cont::internal::ArrayPortalFromIterators<const ValueType*> PortalConstType;
+
+private:
+  /// The original design of this class provided an allocator as a template
+  /// parameters. That messed things up, though, because other templated
+  /// classes assume that the \c ArrayContainerControl has one template
+  /// parameter. There are other ways to allow you to specify the allocator,
+  /// but it is uncertain whether that would ever be useful. So, instead of
+  /// jumping through hoops implementing them, just fix the allocator for now.
+  ///
+  typedef std::allocator<ValueType> AllocatorType;
+
+public:
+
+  ArrayContainerControl() : Array(NULL), NumberOfValues(0), AllocatedSize(0) { }
+
+  ~ArrayContainerControl()
+  {
+    this->ReleaseResources();
+  }
+
+  void ReleaseResources()
+  {
+    if (this->NumberOfValues > 0)
+      {
+      VTKM_ASSERT_CONT(this->Array != NULL);
+      AllocatorType allocator;
+      allocator.deallocate(this->Array, this->AllocatedSize);
+      this->Array = NULL;
+      this->NumberOfValues = 0;
+      this->AllocatedSize = 0;
+      }
+    else
+      {
+      VTKM_ASSERT_CONT(this->Array == NULL);
+      }
+  }
+
+  void Allocate(vtkm::Id numberOfValues)
+  {
+    if (numberOfValues <= this->AllocatedSize)
+      {
+      this->NumberOfValues = numberOfValues;
+      return;
+      }
+
+    this->ReleaseResources();
+    try
+      {
+      if (numberOfValues > 0)
+        {
+        AllocatorType allocator;
+        this->Array = allocator.allocate(numberOfValues);
+        this->AllocatedSize  = numberOfValues;
+        this->NumberOfValues = numberOfValues;
+        }
+      else
+        {
+        // ReleaseResources should have already set AllocatedSize to 0.
+        VTKM_ASSERT_CONT(this->AllocatedSize == 0);
+        }
+      }
+    catch (std::bad_alloc err)
+      {
+      // Make sureour state is OK.
+      this->Array = NULL;
+      this->NumberOfValues = 0;
+      this->AllocatedSize = 0;
+      throw vtkm::cont::ErrorControlOutOfMemory(
+            "Could not allocate basic control array.");
+      }
+  }
+
+  vtkm::Id GetNumberOfValues() const
+  {
+    return this->NumberOfValues;
+  }
+
+  void Shrink(vtkm::Id numberOfValues)
+  {
+    if (numberOfValues > this->GetNumberOfValues())
+      {
+      throw vtkm::cont::ErrorControlBadValue(
+            "Shrink method cannot be used to grow array.");
+      }
+
+    this->NumberOfValues = numberOfValues;
+  }
+
+  PortalType GetPortal()
+  {
+    return PortalType(this->Array, this->Array + this->NumberOfValues);
+  }
+
+  PortalConstType GetPortalConst() const
+  {
+    return PortalConstType(this->Array, this->Array + this->NumberOfValues);
+  }
+
+  /// \brief Take the reference away from this object.
+  ///
+  /// This method returns the pointer to the array held by this array. It then
+  /// clears the internal array pointer to NULL, thereby ensuring that the
+  /// ArrayContainerControl will never deallocate the array. This is
+  /// helpful for taking a reference for an array created internally by VTKm and
+  /// not having to keep a VTKm object around. Obviously the caller becomes
+  /// responsible for destroying the memory.
+  ///
+  ValueType *StealArray()
+  {
+    ValueType *saveArray =  this->Array;
+    this->Array = NULL;
+    this->NumberOfValues = 0;
+    this->AllocatedSize = 0;
+    return saveArray;
+  }
+
+private:
+  // Not implemented.
+  ArrayContainerControl(const ArrayContainerControl<ValueType, ArrayContainerControlTagBasic> &src);
+  void operator=(const ArrayContainerControl<ValueType, ArrayContainerControlTagBasic> &src);
+
+  ValueType *Array;
+  vtkm::Id NumberOfValues;
+  vtkm::Id AllocatedSize;
+};
+
+} // namespace internal
+
+}
+} // namespace vtkm::cont
+
+#endif //vtkm_cont__ArrayContainerControlBasic_h

vtkm/cont/ArrayContainerControlImplicit.h

@@ -0,0 +1,192 @@
+//============================================================================
+//  Copyright (c) Kitware, Inc.
+//  All rights reserved.
+//  See LICENSE.txt for details.
+//  This software is distributed WITHOUT ANY WARRANTY; without even
+//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+//  PURPOSE.  See the above copyright notice for more information.
+//
+//  Copyright 2014 Sandia Corporation.
+//  Copyright 2014 UT-Battelle, LLC.
+//  Copyright 2014. Los Alamos National Security
+//
+//  Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//  the U.S. Government retains certain rights in this software.
+//
+//  Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
+//  Laboratory (LANL), the U.S. Government retains certain rights in
+//  this software.
+//============================================================================
+#ifndef vtkm_cont_ArrayContainerControlImplicit
+#define vtkm_cont_ArrayContainerControlImplicit
+
+#include <vtkm/Types.h>
+
+#include <vtkm/cont/ArrayContainerControl.h>
+#include <vtkm/cont/Assert.h>
+#include <vtkm/cont/ErrorControlBadValue.h>
+#include <vtkm/cont/internal/ArrayTransfer.h>
+
+namespace vtkm {
+namespace cont {
+
+/// \brief An implementation for read-only implicit arrays.
+///
+/// It is sometimes the case that you want VTKm to operate on an array of
+/// implicit values. That is, rather than store the data in an actual array, it
+/// is gerenated on the fly by a function. This is handled in VTKm by creating
+/// an ArrayHandle in VTKm with an ArrayContainerControlTagImplicit type of
+/// ArrayContainerControl. This tag itself is templated to specify an
+/// ArrayPortal that generates the desired values. An ArrayHandle created with
+/// this tag will raise an error on any operation that tries to modify it.
+///
+/// \todo The ArrayHandle currently copies the array in cases where the control
+/// and environment do not share memory. This is wasteful and should be fixed.
+///
+template<class ArrayPortalType>
+struct ArrayContainerControlTagImplicit {
+  typedef ArrayPortalType PortalType;
+};
+
+namespace internal {
+
+template<class ArrayPortalType>
+class ArrayContainerControl<
+    typename ArrayPortalType::ValueType,
+    ArrayContainerControlTagImplicit<ArrayPortalType> >
+{
+public:
+  typedef typename ArrayPortalType::ValueType ValueType;
+  typedef ArrayPortalType PortalConstType;
+
+  // This is meant to be invalid. Because implicit arrays are read only, you
+  // should only be able to use the const version.
+  struct PortalType {
+    typedef void *ValueType;
+    typedef void *IteratorType;
+  };
+
+  // All these methods do nothing but raise errors.
+  PortalType GetPortal() {
+    throw vtkm::cont::ErrorControlBadValue("Implicit arrays are read-only.");
+  }
+  PortalConstType GetPortalConst() const {
+    // This does not work because the ArrayHandle holds the constant
+    // ArrayPortal, not the container.
+    throw vtkm::cont::ErrorControlBadValue(
+          "Implicit container does not store array portal.  "
+          "Perhaps you did not set the ArrayPortal when "
+          "constructing the ArrayHandle.");
+  }
+  vtkm::Id GetNumberOfValues() const {
+    // This does not work because the ArrayHandle holds the constant
+    // ArrayPortal, not the container.
+    throw vtkm::cont::ErrorControlBadValue(
+          "Implicit container does not store array portal.  "
+          "Perhaps you did not set the ArrayPortal when "
+          "constructing the ArrayHandle.");
+  }
+  void Allocate(vtkm::Id vtkmNotUsed(numberOfValues)) {
+    throw vtkm::cont::ErrorControlBadValue("Implicit arrays are read-only.");
+  }
+  void Shrink(vtkm::Id vtkmNotUsed(numberOfValues)) {
+    throw vtkm::cont::ErrorControlBadValue("Implicit arrays are read-only.");
+  }
+  void ReleaseResources() {
+    throw vtkm::cont::ErrorControlBadValue("Implicit arrays are read-only.");
+  }
+};
+
+template<typename T, class ArrayPortalType, class DeviceAdapterTag>
+class ArrayTransfer<
+    T, ArrayContainerControlTagImplicit<ArrayPortalType>, DeviceAdapterTag>
+{
+private:
+  typedef ArrayContainerControlTagImplicit<ArrayPortalType>
+      ArrayContainerControlTag;
+  typedef vtkm::cont::internal::ArrayContainerControl<T,ArrayContainerControlTag>
+      ContainerType;
+
+public:
+  typedef T ValueType;
+
+  typedef typename ContainerType::PortalType PortalControl;
+  typedef typename ContainerType::PortalConstType PortalConstControl;
+  typedef PortalControl PortalExecution;
+  typedef PortalConstControl PortalConstExecution;
+
+  ArrayTransfer() : PortalValid(false) {  }
+
+  VTKM_CONT_EXPORT vtkm::Id GetNumberOfValues() const {
+    VTKM_ASSERT_CONT(this->PortalValid);
+    return this->Portal.GetNumberOfValues();
+  }
+
+  VTKM_CONT_EXPORT void LoadDataForInput(PortalConstControl portal) {
+    this->Portal = portal;
+    this->PortalValid = true;
+  }
+
+  VTKM_CONT_EXPORT void LoadDataForInput(const ContainerType &controlArray) {
+    this->LoadDataForInput(controlArray.GetPortalConst());
+  }
+
+  VTKM_CONT_EXPORT
+  void LoadDataForInPlace(ContainerType &vtkmNotUsed(controlArray))
+  {
+    throw vtkm::cont::ErrorControlBadValue(
+          "Implicit arrays cannot be used for output or in place.");
+  }
+
+  VTKM_CONT_EXPORT void AllocateArrayForOutput(
+      ContainerType &vtkmNotUsed(controlArray),
+      vtkm::Id vtkmNotUsed(numberOfValues))
+  {
+    throw vtkm::cont::ErrorControlBadValue(
+          "Implicit arrays cannot be used for output.");
+  }
+  VTKM_CONT_EXPORT void RetrieveOutputData(
+      ContainerType &vtkmNotUsed(controlArray)) const
+  {
+    throw vtkm::cont::ErrorControlBadValue(
+          "Implicit arrays cannot be used for output.");
+  }
+
+  template <class IteratorTypeControl>
+  VTKM_CONT_EXPORT void CopyInto(IteratorTypeControl dest) const
+  {
+    VTKM_ASSERT_CONT(this->PortalValid);
+    std::copy(this->Portal.GetIteratorBegin(),
+              this->Portal.GetIteratorEnd(),
+              dest);
+  }
+
+  VTKM_CONT_EXPORT void Shrink(vtkm::Id vtkmNotUsed(numberOfValues))
+  {
+    throw vtkm::cont::ErrorControlBadValue("Implicit arrays cannot be resized.");
+  }
+
+  VTKM_CONT_EXPORT PortalExecution GetPortalExecution()
+  {
+    throw vtkm::cont::ErrorControlBadValue(
+          "Implicit arrays are read-only.  (Get the const portal.)");
+  }
+  VTKM_CONT_EXPORT PortalConstExecution GetPortalConstExecution() const
+  {
+    VTKM_ASSERT_CONT(this->PortalValid);
+    return this->Portal;
+  }
+
+  VTKM_CONT_EXPORT void ReleaseResources() {  }
+
+private:
+  PortalConstExecution Portal;
+  bool PortalValid;
+};
+
+} // namespace internal
+
+}
+} // namespace vtkm::cont
+
+#endif //vtkm_cont_ArrayContainerControlImplicit

vtkm/cont/ArrayHandle.h

@@ -0,0 +1,537 @@
+//============================================================================
+//  Copyright (c) Kitware, Inc.
+//  All rights reserved.
+//  See LICENSE.txt for details.
+//  This software is distributed WITHOUT ANY WARRANTY; without even
+//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+//  PURPOSE.  See the above copyright notice for more information.
+//
+//  Copyright 2014 Sandia Corporation.
+//  Copyright 2014 UT-Battelle, LLC.
+//  Copyright 2014. Los Alamos National Security
+//
+//  Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//  the U.S. Government retains certain rights in this software.
+//
+//  Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
+//  Laboratory (LANL), the U.S. Government retains certain rights in
+//  this software.
+//============================================================================
+#ifndef vtkm_cont_ArrayHandle_h
+#define vtkm_cont_ArrayHandle_h
+
+#include <vtkm/Types.h>
+
+#include <vtkm/cont/ArrayContainerControl.h>
+#include <vtkm/cont/Assert.h>
+#include <vtkm/cont/ErrorControlBadValue.h>
+#include <vtkm/cont/internal/ArrayHandleExecutionManager.h>
+#include <vtkm/cont/internal/ArrayTransfer.h>
+#include <vtkm/cont/internal/DeviceAdapterTag.h>
+
+#include <boost/concept_check.hpp>
+#include <boost/smart_ptr/scoped_ptr.hpp>
+#include <boost/smart_ptr/shared_ptr.hpp>
+
+#include <vector>
+
+namespace vtkm {
+namespace cont {
+
+// Forward declaration
+namespace internal { class ArrayHandleAccess; }
+
+/// \brief Manages an array-worth of data.
+///
+/// \c ArrayHandle manages as array of data that can be manipulated by VTKm
+/// algorithms. The \c ArrayHandle may have up to two copies of the array, one
+/// for the control environment and one for the execution environment, although
+/// depending on the device and how the array is being used, the \c ArrayHandle
+/// will only have one copy when possible.
+///
+/// An ArrayHandle can be constructed one of two ways. Its default construction
+/// creates an empty, unallocated array that can later be allocated and filled
+/// either by the user or a VTKm algorithm. The \c ArrayHandle can also be
+/// constructed with iterators to a user's array. In this case the \c
+/// ArrayHandle will keep a reference to this array but may drop it if the
+/// array is reallocated.
+///
+/// \c ArrayHandle behaves like a shared smart pointer in that when it is copied
+/// each copy holds a reference to the same array.  These copies are reference
+/// counted so that when all copies of the \c ArrayHandle are destroyed, any
+/// allocated memory is released.
+///
+template<
+    typename T,
+    typename ArrayContainerControlTag_ = VTKM_DEFAULT_ARRAY_CONTAINER_CONTROL_TAG>
+class ArrayHandle
+{
+private:
+  typedef vtkm::cont::internal
+      ::ArrayContainerControl<T,ArrayContainerControlTag_>
+      ArrayContainerControlType;
+  typedef vtkm::cont::internal
+      ::ArrayHandleExecutionManagerBase<T,ArrayContainerControlTag_>
+      ExecutionManagerType;
+public:
+  typedef T ValueType;
+  typedef ArrayContainerControlTag_ ArrayContainerControlTag;
+  typedef typename ArrayContainerControlType::PortalType PortalControl;
+  typedef typename ArrayContainerControlType::PortalConstType
+      PortalConstControl;
+  template <typename DeviceAdapterTag>
+  struct ExecutionTypes {
+    typedef typename ExecutionManagerType
+        ::template ExecutionTypes<DeviceAdapterTag>::Portal Portal;
+    typedef typename ExecutionManagerType
+        ::template ExecutionTypes<DeviceAdapterTag>::PortalConst PortalConst;
+  };
+
+  /// Constructs an empty ArrayHandle. Typically used for output or
+  /// intermediate arrays that will be filled by a VTKm algorithm.
+  ///
+  VTKM_CONT_EXPORT ArrayHandle() : Internals(new InternalStruct)
+  {
+    this->Internals->UserPortalValid = false;
+    this->Internals->ControlArrayValid = false;
+    this->Internals->ExecutionArrayValid = false;
+  }
+
+  /// Constructs an ArrayHandle pointing to the data in the given array portal.
+  ///
+  VTKM_CONT_EXPORT ArrayHandle(PortalConstControl userData)
+    : Internals(new InternalStruct)
+  {
+    this->Internals->UserPortal = userData;
+    this->Internals->UserPortalValid = true;
+
+    this->Internals->ControlArrayValid = false;
+    this->Internals->ExecutionArrayValid = false;
+  }
+
+  /// Get the array portal of the control array.
+  ///
+  VTKM_CONT_EXPORT PortalControl GetPortalControl()
+  {
+    this->SyncControlArray();
+    if (this->Internals->UserPortalValid)
+      {
+      throw vtkm::cont::ErrorControlBadValue(
+            "ArrayHandle has a read-only control portal.");
+      }
+    else if (this->Internals->ControlArrayValid)
+      {
+      // If the user writes into the iterator we return, then the execution
+      // array will become invalid. Play it safe and release the execution
+      // resources. (Use the const version to preserve the execution array.)
+      this->ReleaseResourcesExecution();
+      return this->Internals->ControlArray.GetPortal();
+      }
+    else
+      {
+      throw vtkm::cont::ErrorControlBadValue("ArrayHandle contains no data.");
+      }
+  }
+
+  /// Get the array portal of the control array.
+  ///
+  VTKM_CONT_EXPORT PortalConstControl GetPortalConstControl() const
+  {
+    this->SyncControlArray();
+    if (this->Internals->UserPortalValid)
+      {
+      return this->Internals->UserPortal;
+      }
+    else if (this->Internals->ControlArrayValid)
+      {
+      return this->Internals->ControlArray.GetPortalConst();
+      }
+    else
+      {
+      throw vtkm::cont::ErrorControlBadValue("ArrayHandle contains no data.");
+      }
+  }
+
+  /// Returns the number of entries in the array.
+  ///
+  VTKM_CONT_EXPORT vtkm::Id GetNumberOfValues() const
+  {
+    if (this->Internals->UserPortalValid)
+      {
+      return this->Internals->UserPortal.GetNumberOfValues();
+      }
+    else if (this->Internals->ControlArrayValid)
+      {
+      return this->Internals->ControlArray.GetNumberOfValues();
+      }
+    else if (this->Internals->ExecutionArrayValid)
+      {
+      return
+          this->Internals->ExecutionArray->GetNumberOfValues();
+      }
+    else
+      {
+      return 0;
+      }
+  }
+
+  /// \brief Reduces the size of the array without changing its values.
+  ///
+  /// This method allows you to resize the array without reallocating it. The
+  /// number of entries in the array is changed to \c numberOfValues. The data
+  /// in the array (from indices 0 to \c numberOfValues - 1) are the same, but
+  /// \c numberOfValues must be equal or less than the preexisting size
+  /// (returned from GetNumberOfValues). That is, this method can only be used
+  /// to shorten the array, not lengthen.
+  void Shrink(vtkm::Id numberOfValues)
+  {
+    vtkm::Id originalNumberOfValues = this->GetNumberOfValues();
+
+    if (numberOfValues < originalNumberOfValues)
+      {
+      if (this->Internals->UserPortalValid)
+        {
+        throw vtkm::cont::ErrorControlBadValue(
+              "ArrayHandle has a read-only control portal.");
+        }
+      if (this->Internals->ControlArrayValid)
+        {
+        this->Internals->ControlArray.Shrink(numberOfValues);
+        }
+      if (this->Internals->ExecutionArrayValid)
+        {
+        this->Internals->ExecutionArray->Shrink(numberOfValues);
+        }
+      }
+    else if (numberOfValues == originalNumberOfValues)
+      {
+      // Nothing to do.
+      }
+    else // numberOfValues > originalNumberOfValues
+      {
+      throw vtkm::cont::ErrorControlBadValue(
+            "ArrayHandle::Shrink cannot be used to grow array.");
+      }
+
+    VTKM_ASSERT_CONT(this->GetNumberOfValues() == numberOfValues);
+  }
+
+  /// Releases any resources being used in the execution environment (that are
+  /// not being shared by the control environment).
+  ///
+  VTKM_CONT_EXPORT void ReleaseResourcesExecution()
+  {
+    if (this->Internals->ExecutionArrayValid)
+      {
+      this->Internals->ExecutionArray->ReleaseResources();
+      this->Internals->ExecutionArrayValid = false;
+      }
+  }
+
+  /// Releases all resources in both the control and execution environments.
+  ///
+  VTKM_CONT_EXPORT void ReleaseResources()
+  {
+    this->ReleaseResourcesExecution();
+
+    // Forget about any user iterators.
+    this->Internals->UserPortalValid = false;
+
+    if (this->Internals->ControlArrayValid)
+      {
+      this->Internals->ControlArray.ReleaseResources();
+      this->Internals->ControlArrayValid = false;
+      }
+  }
+
+  /// Prepares this array to be used as an input to an operation in the
+  /// execution environment. If necessary, copies data to the execution
+  /// environment. Can throw an exception if this array does not yet contain
+  /// any data. Returns a portal that can be used in code running in the
+  /// execution environment.
+  ///
+  template<typename DeviceAdapterTag>
+  VTKM_CONT_EXPORT
+  typename ExecutionTypes<DeviceAdapterTag>::PortalConst
+  PrepareForInput(DeviceAdapterTag) const
+  {
+    VTKM_IS_DEVICE_ADAPTER_TAG(DeviceAdapterTag);
+
+    if (this->Internals->ExecutionArrayValid)
+      {
+      // Nothing to do, data already loaded.
+      }
+    else if (this->Internals->UserPortalValid)
+      {
+      VTKM_ASSERT_CONT(!this->Internals->ControlArrayValid);
+      this->PrepareForDevice(DeviceAdapterTag());
+      this->Internals->ExecutionArray->LoadDataForInput(
+            this->Internals->UserPortal);
+      this->Internals->ExecutionArrayValid = true;
+      }
+    else if (this->Internals->ControlArrayValid)
+      {
+      this->PrepareForDevice(DeviceAdapterTag());
+      this->Internals->ExecutionArray->LoadDataForInput(
+            this->Internals->ControlArray);
+      this->Internals->ExecutionArrayValid = true;
+      }
+    else
+      {
+      throw vtkm::cont::ErrorControlBadValue(
+            "ArrayHandle has no data when PrepareForInput called.");
+      }
+    return this->Internals->ExecutionArray->GetPortalConstExecution(
+          DeviceAdapterTag());
+  }
+
+  /// Prepares (allocates) this array to be used as an output from an operation
+  /// in the execution environment. The internal state of this class is set to
+  /// have valid data in the execution array with the assumption that the array
+  /// will be filled soon (i.e. before any other methods of this object are
+  /// called). Returns a portal that can be used in code running in the
+  /// execution environment.
+  ///
+  template<typename DeviceAdapterTag>
+  VTKM_CONT_EXPORT
+  typename ExecutionTypes<DeviceAdapterTag>::Portal
+  PrepareForOutput(vtkm::Id numberOfValues, DeviceAdapterTag)
+  {
+    VTKM_IS_DEVICE_ADAPTER_TAG(DeviceAdapterTag);
+
+    // Invalidate any control arrays.
+    // Should the control array resource be released? Probably not a good
+    // idea when shared with execution.
+    this->Internals->UserPortalValid = false;
+    this->Internals->ControlArrayValid = false;
+
+    this->PrepareForDevice(DeviceAdapterTag());
+    this->Internals->ExecutionArray->AllocateArrayForOutput(
+          this->Internals->ControlArray, numberOfValues);
+
+    // We are assuming that the calling code will fill the array using the
+    // iterators we are returning, so go ahead and mark the execution array as
+    // having valid data. (A previous version of this class had a separate call
+    // to mark the array as filled, but that was onerous to call at the the
+    // right time and rather pointless since it is basically always the case
+    // that the array is going to be filled before anything else. In this
+    // implementation the only access to the array is through the iterators
+    // returned from this method, so you would have to work to invalidate this
+    // assumption anyway.)
+    this->Internals->ExecutionArrayValid = true;
+
+    return this->Internals->ExecutionArray->GetPortalExecution(DeviceAdapterTag());
+  }
+
+  /// Prepares this array to be used in an in-place operation (both as input
+  /// and output) in the execution environment. If necessary, copies data to
+  /// the execution environment. Can throw an exception if this array does not
+  /// yet contain any data. Returns a portal that can be used in code running
+  /// in the execution environment.
+  ///
+  template<typename DeviceAdapterTag>
+  VTKM_CONT_EXPORT
+  typename ExecutionTypes<DeviceAdapterTag>::Portal
+  PrepareForInPlace(DeviceAdapterTag)
+  {
+    VTKM_IS_DEVICE_ADAPTER_TAG(DeviceAdapterTag);
+
+    if (this->Internals->UserPortalValid)
+      {
+      throw vtkm::cont::ErrorControlBadValue(
+            "In place execution cannot be used with an ArrayHandle that has "
+            "user arrays because this might write data back into user space "
+            "unexpectedly.  Copy the data to a new array first.");
+      }
+
+    // This code is similar to PrepareForInput except that we have to give a
+    // writable portal instead of the const portal to the execution array
+    // manager so that the data can (potentially) be written to.
+    if (this->Internals->ExecutionArrayValid)
+      {
+      // Nothing to do, data already loaded.
+      }
+    else if (this->Internals->ControlArrayValid)
+      {
+      this->PrepareForDevice(DeviceAdapterTag());
+      this->Internals->ExecutionArray->LoadDataForInPlace(
+            this->Internals->ControlArray);
+      this->Internals->ExecutionArrayValid = true;
+      }
+    else
+      {
+      throw vtkm::cont::ErrorControlBadValue(
+            "ArrayHandle has no data when PrepareForInput called.");
+      }
+
+    // Invalidate any control arrays since their data will become invalid when
+    // the execution data is overwritten. Don't actually release the control
+    // array. It may be shared as the execution array.
+    this->Internals->ControlArrayValid = false;
+
+    return this->Internals->ExecutionArray->GetPortalExecution(DeviceAdapterTag());
+  }
+
+// protected:
+  /// Special constructor for subclass specializations that need to set the
+  /// initial state of the control array. When this constructor is used, it
+  /// is assumed that the control array is valid.
+  ///
+  ArrayHandle(const ArrayContainerControlType &container)
+    : Internals(new InternalStruct)
+  {
+    this->Internals->UserPortalValid = false;
+    this->Internals->ControlArray = container;
+    this->Internals->ControlArrayValid = true;
+    this->Internals->ExecutionArrayValid = false;
+  }
+
+// private:
+  struct InternalStruct {
+    PortalConstControl UserPortal;
+    bool UserPortalValid;
+
+    ArrayContainerControlType ControlArray;
+    bool ControlArrayValid;
+
+    boost::scoped_ptr<
+      vtkm::cont::internal::ArrayHandleExecutionManagerBase<
+        ValueType,ArrayContainerControlTag> > ExecutionArray;
+    bool ExecutionArrayValid;
+  };
+
+   ArrayHandle(boost::shared_ptr<InternalStruct> i)
+    : Internals(i)
+  { }
+
+  /// Gets this array handle ready to interact with the given device. If the
+  /// array handle has already interacted with this device, then this method
+  /// does nothing. Although the internal state of this class can change, the
+  /// method is declared const because logically the data does not.
+  ///
+  template<typename DeviceAdapterTag>
+  VTKM_CONT_EXPORT
+  void PrepareForDevice(DeviceAdapterTag) const
+  {
+    if (this->Internals->ExecutionArray != NULL)
+      {
+      if (this->Internals->ExecutionArray->IsDeviceAdapter(DeviceAdapterTag()))
+        {
+        // Already have manager for correct device adapter. Nothing to do.
+        return;
+        }
+      else
+        {
+        // Have the wrong manager. Delete the old one and create a new one
+        // of the right type. (BTW, it would be possible for the array handle
+        // to hold references to execution arrays on multiple devices. However,
+        // there is not a clear use case for that yet and it is unclear what
+        // the behavior of "dirty" arrays should be, so it is not currently
+        // implemented.)
+        this->SyncControlArray();
+        // Need to change some state that does not change the logical state from
+        // an external point of view.
+        InternalStruct *internals
+            = const_cast<InternalStruct*>(this->Internals.get());
+        internals->ExecutionArray.reset();
+        internals->ExecutionArrayValid = false;
+        }
+      }
+
+    VTKM_ASSERT_CONT(this->Internals->ExecutionArray == NULL);
+    VTKM_ASSERT_CONT(this->Internals->ExecutionArrayValid == false);
+    // Need to change some state that does not change the logical state from
+    // an external point of view.
+    InternalStruct *internals
+        = const_cast<InternalStruct*>(this->Internals.get());
+    internals->ExecutionArray.reset(
+          new vtkm::cont::internal::ArrayHandleExecutionManager<
+            T, ArrayContainerControlTag, DeviceAdapterTag>);
+  }
+
+  /// Synchronizes the control array with the execution array. If either the
+  /// user array or control array is already valid, this method does nothing
+  /// (because the data is already available in the control environment).
+  /// Although the internal state of this class can change, the method is
+  /// declared const because logically the data does not.
+  ///
+  VTKM_CONT_EXPORT void SyncControlArray() const
+  {
+    if (   !this->Internals->UserPortalValid
+        && !this->Internals->ControlArrayValid)
+      {
+      // Need to change some state that does not change the logical state from
+      // an external point of view.
+      InternalStruct *internals
+          = const_cast<InternalStruct*>(this->Internals.get());
+      internals->ExecutionArray->RetrieveOutputData(internals->ControlArray);
+      internals->ControlArrayValid = true;
+      }
+    else
+      {
+      // It should never be the case that both the user and control array are
+      // valid.
+      VTKM_ASSERT_CONT(!this->Internals->UserPortalValid
+                      || !this->Internals->ControlArrayValid);
+      // Nothing to do.
+      }
+  }
+
+  boost::shared_ptr<InternalStruct> Internals;
+};
+
+/// A convenience function for creating an ArrayHandle from a standard C
+/// array.  Unless properly specialized, this only works with container types
+/// that use an array portal that accepts a pair of pointers to signify the
+/// beginning and end of the array.
+///
+template<typename T, typename ArrayContainerControlTag>
+VTKM_CONT_EXPORT
+vtkm::cont::ArrayHandle<T, ArrayContainerControlTag>
+make_ArrayHandle(const T *array,
+                 vtkm::Id length,
+                 ArrayContainerControlTag)
+{
+  typedef vtkm::cont::ArrayHandle<T, ArrayContainerControlTag> ArrayHandleType;
+  typedef typename ArrayHandleType::PortalConstControl PortalType;
+  return ArrayHandleType(PortalType(array, array+length));
+}
+template<typename T>
+VTKM_CONT_EXPORT
+vtkm::cont::ArrayHandle<T, VTKM_DEFAULT_ARRAY_CONTAINER_CONTROL_TAG>
+make_ArrayHandle(const T *array, vtkm::Id length)
+{
+  return make_ArrayHandle(array,
+                          length,
+                          VTKM_DEFAULT_ARRAY_CONTAINER_CONTROL_TAG());
+}
+
+/// A convenience function for creating an ArrayHandle from an std::vector.
+/// Unless properly specialized, this only works with container types that use
+/// an array portal that accepts a pair of pointers to signify the beginning
+/// and end of the array.
+///
+template<typename T,
+         typename Allocator,
+         typename ArrayContainerControlTag>
+VTKM_CONT_EXPORT
+vtkm::cont::ArrayHandle<T, ArrayContainerControlTag>
+make_ArrayHandle(const std::vector<T,Allocator> &array,
+                 ArrayContainerControlTag)
+{
+  typedef vtkm::cont::ArrayHandle<T, ArrayContainerControlTag> ArrayHandleType;
+  typedef typename ArrayHandleType::PortalConstControl PortalType;
+  return ArrayHandleType(PortalType(&array.front(), &array.back() + 1));
+}
+template<typename T, typename Allocator>
+VTKM_CONT_EXPORT
+vtkm::cont::ArrayHandle<T, VTKM_DEFAULT_ARRAY_CONTAINER_CONTROL_TAG>
+make_ArrayHandle(const std::vector<T,Allocator> &array)
+{
+  return make_ArrayHandle(array, VTKM_DEFAULT_ARRAY_CONTAINER_CONTROL_TAG());
+}
+
+}
+}
+
+#endif //vtkm_cont_ArrayHandle_h

vtkm/cont/ArrayPortal.h

@@ -0,0 +1,107 @@
+//============================================================================
+//  Copyright (c) Kitware, Inc.
+//  All rights reserved.
+//  See LICENSE.txt for details.
+//  This software is distributed WITHOUT ANY WARRANTY; without even
+//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+//  PURPOSE.  See the above copyright notice for more information.
+//
+//  Copyright 2014 Sandia Corporation.
+//  Copyright 2014 UT-Battelle, LLC.
+//  Copyright 2014. Los Alamos National Security
+//
+//  Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//  the U.S. Government retains certain rights in this software.
+//
+//  Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
+//  Laboratory (LANL), the U.S. Government retains certain rights in
+//  this software.
+//============================================================================
+#ifndef vtkm_cont_ArrayPortal_h
+#define vtkm_cont_ArrayPortal_h
+
+#include <vtkm/Types.h>
+
+namespace vtkm {
+namespace cont {
+
+#ifdef VTKM_DOXYGEN_ONLY
+
+/// \brief A class that points to and access and array of data.
+///
+/// The ArrayPortal class itself does not exist; this code is provided for
+/// documentation purposes only.
+///
+/// An ArrayPortal object acts like a pointer to a random-access container
+/// (that is, an array) and also lets you set and get values in that array. In
+/// many respects an ArrayPortal is similar in concept to that of iterators but
+/// with a much simpler interface and no internal concept of position.
+/// Otherwise, ArrayPortal objects may be passed and copied around so that
+/// multiple entities may be accessing the same array.
+///
+/// An ArrayPortal differs from an ArrayHandle in that the ArrayPortal is a
+/// much lighterweight object and that it does not manage things like
+/// allocation and control/execution sharing. An ArrayPortal also differs from
+/// an ArrayContainer in that it does not actually contain the data but rather
+/// points to it. In this way the ArrayPortal can be copied and passed and
+/// still point to the same data.
+///
+/// Most VTKm users generally do not need to do much or anything with
+/// ArrayPortal objects. It is mostly an internal mechanism. However, an
+/// ArrayPortal can be used to pass constant input data to an ArrayHandle.
+///
+/// Although this documentation is given for the control environment, there are
+/// instances of an identical concept in the execution environment, although
+/// some features are missing there.
+///
+template<typename T>
+class ArrayPortal
+{
+public:
+  /// The type of each value in the array.
+  ///
+  typedef T ValueType;
+
+  /// The total number of values in the array. They are index from 0 to
+  /// GetNumberOfValues()-1.
+  ///
+  VTKM_CONT_EXPORT
+  vtkm::Id GetNumberOfValues() const;
+
+  /// Gets a value from the array.
+  ///
+  VTKM_CONT_EXPORT
+  ValueType Get(vtkm::Id index) const;
+
+  /// Sets a value in the array. This function may not exist for an ArrayPortal
+  /// pointing to a const array.
+  ///
+  VTKM_CONT_EXPORT
+  void Set(vtkm::Id index, const ValueType &value) const;
+
+  /// An iterator type that can be used as an alternate way to access the data.
+  /// If the container being pointed to has a natural iterator that can be
+  /// used, then use that. Otherwise, use IteratorForArrayPortal. Iterators are
+  /// not necessary for array portals in the execution environment.
+  ///
+  typedef ValueType *IteratorType;
+
+  /// Returns an iterator to the beginning of the array. Iterators are not
+  /// necessary for array portals in the execution environment.
+  ///
+  VTKM_CONT_EXPORT
+  IteratorType GetIteratorBegin() const;
+
+  /// Returns an iterator to the end of the array. Iterators are not necessary
+  /// for array portals in the execution environment.
+  ///
+  VTKM_CONT_EXPORT
+  IteratorType GetIteratorEnd() const;
+};
+
+#endif // VTKM_DOXYGEN_ONLY
+
+}
+} // namespace vtkm::cont
+
+#endif //vtkm_cont_ArrayPortal_h

vtkm/cont/Assert.h

@@ -0,0 +1,64 @@
+//============================================================================
+//  Copyright (c) Kitware, Inc.
+//  All rights reserved.
+//  See LICENSE.txt for details.
+//  This software is distributed WITHOUT ANY WARRANTY; without even
+//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+//  PURPOSE.  See the above copyright notice for more information.
+//
+//  Copyright 2014 Sandia Corporation.
+//  Copyright 2014 UT-Battelle, LLC.
+//  Copyright 2014. Los Alamos National Security
+//
+//  Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//  the U.S. Government retains certain rights in this software.
+//
+//  Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
+//  Laboratory (LANL), the U.S. Government retains certain rights in
+//  this software.
+//============================================================================
+#ifndef vtkm_cont_Assert_h
+#define vtkm_cont_Assert_h
+
+#include <vtkm/cont/ErrorControlAssert.h>
+
+// Stringify macros for VTKM_ASSERT_CONT
+#define __VTKM_ASSERT_CONT_STRINGIFY_2ND(s) #s
+#define __VTKM_ASSERT_CONT_STRINGIFY(s) __VTKM_ASSERT_CONT_STRINGIFY_2ND(s)
+
+/// \def VTKM_ASSERT_CONT(condition)
+///
+/// Asserts that \a condition resolves to true.  If \a condition is false,
+/// then an error is raised.  This macro is meant to work in the VTKm control
+/// environment and throws an ErrorControlAssert object on failure.
+
+#ifndef NDEBUG
+#define VTKM_ASSERT_CONT(condition) \
+  if (!(condition)) \
+    ::vtkm::cont::Assert(condition, __FILE__, __LINE__, #condition)
+#else
+#define VTKM_ASSERT_CONT(condition)
+#endif
+
+namespace vtkm {
+namespace cont {
+
+VTKM_CONT_EXPORT void Assert(bool condition,
+                            const std::string &file,
+                            vtkm::Id line,
+                            const std::string &message)
+{
+  if (condition)
+    {
+    // Do nothing.
+    }
+  else
+    {
+    throw vtkm::cont::ErrorControlAssert(file, line, message);
+    }
+}
+
+}
+} // namespace vtkm::cont
+
+#endif //vtkm_cont_Assert_h

vtkm/cont/CMakeLists.txt

@@ -0,0 +1,46 @@
+##============================================================================
+##  Copyright (c) Kitware, Inc.
+##  All rights reserved.
+##  See LICENSE.txt for details.
+##  This software is distributed WITHOUT ANY WARRANTY; without even
+##  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+##  PURPOSE.  See the above copyright notice for more information.
+##
+##  Copyright 2014 Sandia Corporation.
+##  Copyright 2014 UT-Battelle, LLC.
+##  Copyright 2014. Los Alamos National Security
+##
+##  Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+##  the U.S. Government retains certain rights in this software.
+##
+##  Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
+##  Laboratory (LANL), the U.S. Government retains certain rights in
+##  this software.
+##============================================================================
+
+include_directories(${Boost_INCLUDE_DIRS})
+
+set(headers
+  ArrayContainerControl.h
+  ArrayContainerControlBasic.h
+  ArrayContainerControlImplicit.h
+  ArrayHandle.h
+  ArrayPortal.h
+  Assert.h
+  Error.h
+  ErrorControl.h
+  ErrorControlAssert.h
+  ErrorControlBadValue.h
+  ErrorControlInternal.h
+  ErrorControlOutOfMemory.h
+  ErrorExecution.h
+  )
+
+#-----------------------------------------------------------------------------
+add_subdirectory(internal)
+
+vtkm_declare_headers(${impl_headers} ${headers})
+
+
+#-----------------------------------------------------------------------------
+add_subdirectory(testing)

vtkm/cont/Error.h

@@ -0,0 +1,54 @@
+//============================================================================
+//  Copyright (c) Kitware, Inc.
+//  All rights reserved.
+//  See LICENSE.txt for details.
+//  This software is distributed WITHOUT ANY WARRANTY; without even
+//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+//  PURPOSE.  See the above copyright notice for more information.
+//
+//  Copyright 2014 Sandia Corporation.
+//  Copyright 2014 UT-Battelle, LLC.
+//  Copyright 2014. Los Alamos National Security
+//
+//  Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//  the U.S. Government retains certain rights in this software.
+//
+//  Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
+//  Laboratory (LANL), the U.S. Government retains certain rights in
+//  this software.
+//============================================================================
+#ifndef vtkm_cont_Error_h
+#define vtkm_cont_Error_h
+
+// Note that this class and (most likely) all of its subclasses are not
+// templated.  If there is any reason to create a VTKm control library,
+// this class and its subclasses should probably go there.
+
+#include <string>
+
+namespace vtkm {
+namespace cont {
+
+/// The superclass of all exceptions thrown by any VTKm function or method.
+///
+class Error
+{
+public:
+  const std::string &GetMessage() const { return this->Message; }
+
+protected:
+  Error() { }
+  Error(const std::string message) : Message(message) { }
+
+  void SetMessage(const std::string &message) {
+    this->Message = message;
+  }
+
+private:
+  std::string Message;
+};
+
+}
+} // namespace vtkm::cont
+
+#endif //vtkm_cont_Error_h

vtkm/cont/ErrorControl.h

@@ -0,0 +1,41 @@
+//============================================================================
+//  Copyright (c) Kitware, Inc.
+//  All rights reserved.
+//  See LICENSE.txt for details.
+//  This software is distributed WITHOUT ANY WARRANTY; without even
+//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+//  PURPOSE.  See the above copyright notice for more information.
+//
+//  Copyright 2014 Sandia Corporation.
+//  Copyright 2014 UT-Battelle, LLC.
+//  Copyright 2014. Los Alamos National Security
+//
+//  Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//  the U.S. Government retains certain rights in this software.
+//
+//  Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
+//  Laboratory (LANL), the U.S. Government retains certain rights in
+//  this software.
+//============================================================================
+#ifndef vtkm_cont_ErrorControl_h
+#define vtkm_cont_ErrorControl_h
+
+#include <vtkm/cont/Error.h>
+
+namespace vtkm {
+namespace cont {
+
+/// The superclass of all exceptions thrown from within the VTKm control
+/// environment.
+///
+class ErrorControl : public vtkm::cont::Error
+{
+protected:
+  ErrorControl() { }
+  ErrorControl(const std::string message) : Error(message) { }
+};
+
+}
+} // namespace vtkm::cont
+
+#endif //vtkm_cont_ErrorControl_h

vtkm/cont/ErrorControlAssert.h

@@ -0,0 +1,56 @@
+//============================================================================
+//  Copyright (c) Kitware, Inc.
+//  All rights reserved.
+//  See LICENSE.txt for details.
+//  This software is distributed WITHOUT ANY WARRANTY; without even
+//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+//  PURPOSE.  See the above copyright notice for more information.
+//
+//  Copyright 2014 Sandia Corporation.
+//  Copyright 2014 UT-Battelle, LLC.
+//  Copyright 2014. Los Alamos National Security
+//
+//  Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//  the U.S. Government retains certain rights in this software.
+//
+//  Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
+//  Laboratory (LANL), the U.S. Government retains certain rights in
+//  this software.
+//============================================================================
+#ifndef vtkm_cont_ErrorControlAssert_h
+#define vtkm_cont_ErrorControlAssert_h
+
+#include <vtkm/Types.h>
+#include <vtkm/cont/ErrorControl.h>
+
+#include <sstream>
+
+namespace vtkm {
+namespace cont {
+
+/// This error is thrown whenever VTKM_ASSERT_CONT fails.
+///
+class ErrorControlAssert : public vtkm::cont::ErrorControl
+{
+public:
+  ErrorControlAssert(const std::string &file,
+                     vtkm::Id line,
+                     const std::string &condition)
+    : ErrorControl(), File(file), Line(line), Condition(condition)
+  {
+    std::stringstream message;
+    message << this->File << ":" << this->Line
+            << ": Assert Failed (" << this->Condition << ")";
+    this->SetMessage(message.str());
+  }
+
+private:
+  std::string File;
+  vtkm::Id Line;
+  std::string Condition;
+};
+
+}
+}
+
+#endif //vtkm_cont_ErrorControlAssert_h

vtkm/cont/ErrorControlBadValue.h

@@ -0,0 +1,41 @@
+//============================================================================
+//  Copyright (c) Kitware, Inc.
+//  All rights reserved.
+//  See LICENSE.txt for details.
+//  This software is distributed WITHOUT ANY WARRANTY; without even
+//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+//  PURPOSE.  See the above copyright notice for more information.
+//
+//  Copyright 2014 Sandia Corporation.
+//  Copyright 2014 UT-Battelle, LLC.
+//  Copyright 2014. Los Alamos National Security
+//
+//  Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//  the U.S. Government retains certain rights in this software.
+//
+//  Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
+//  Laboratory (LANL), the U.S. Government retains certain rights in
+//  this software.
+//============================================================================
+#ifndef vtkm_cont_ErrorControlBadValue_h
+#define vtkm_cont_ErrorControlBadValue_h
+
+#include <vtkm/cont/ErrorControl.h>
+
+namespace vtkm {
+namespace cont {
+
+/// This class is thrown when a VTKm function or method encounters an invalid
+/// value that inhibits progress.
+///
+class ErrorControlBadValue : public ErrorControl
+{
+public:
+  ErrorControlBadValue(const std::string &message)
+    : ErrorControl(message) { }
+};
+
+}
+} // namespace vtkm::cont
+
+#endif //vtkm_cont_ErrorControlBadValue_h

vtkm/cont/ErrorControlInternal.h

@@ -0,0 +1,42 @@
+//============================================================================
+//  Copyright (c) Kitware, Inc.
+//  All rights reserved.
+//  See LICENSE.txt for details.
+//  This software is distributed WITHOUT ANY WARRANTY; without even
+//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+//  PURPOSE.  See the above copyright notice for more information.
+//
+//  Copyright 2014 Sandia Corporation.
+//  Copyright 2014 UT-Battelle, LLC.
+//  Copyright 2014. Los Alamos National Security
+//
+//  Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//  the U.S. Government retains certain rights in this software.
+//
+//  Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
+//  Laboratory (LANL), the U.S. Government retains certain rights in
+//  this software.
+//============================================================================
+#ifndef vtkm_cont_ErrorControlInternal_h
+#define vtkm_cont_ErrorControlInternal_h
+
+#include <vtkm/cont/ErrorControl.h>
+
+namespace vtkm {
+namespace cont {
+
+/// This class is thrown when VTKm detects an internal state that should never
+/// be reached. This error usually indicates a bug in vtkm or, at best, VTKm
+/// failed to detect an invalid input it should have.
+///
+class ErrorControlInternal : public ErrorControl
+{
+public:
+  ErrorControlInternal(const std::string &message)
+    : ErrorControl(message) { }
+};
+
+}
+} // namespace vtkm::cont
+
+#endif //vtkm_cont_ErrorControlInternal_h

vtkm/cont/ErrorControlOutOfMemory.h

@@ -0,0 +1,41 @@
+//============================================================================
+//  Copyright (c) Kitware, Inc.
+//  All rights reserved.
+//  See LICENSE.txt for details.
+//  This software is distributed WITHOUT ANY WARRANTY; without even
+//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+//  PURPOSE.  See the above copyright notice for more information.
+//
+//  Copyright 2014 Sandia Corporation.
+//  Copyright 2014 UT-Battelle, LLC.
+//  Copyright 2014. Los Alamos National Security
+//
+//  Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//  the U.S. Government retains certain rights in this software.
+//
+//  Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
+//  Laboratory (LANL), the U.S. Government retains certain rights in
+//  this software.
+//============================================================================
+#ifndef vtkm_cont_ErrorControlOutOfMemory_h
+#define vtkm_cont_ErrorControlOutOfMemory_h
+
+#include <vtkm/cont/ErrorControl.h>
+
+namespace vtkm {
+namespace cont {
+
+/// This class is thrown when a vtkm function or method tries to allocate an
+/// array and fails.
+///
+class ErrorControlOutOfMemory : public ErrorControl
+{
+public:
+  ErrorControlOutOfMemory(const std::string &message)
+    : ErrorControl(message) { }
+};
+
+}
+} // namespace vtkm::cont
+
+#endif //vtkm_cont_ErrorControlOutOfMemory_h

vtkm/cont/ErrorExecution.h

@@ -0,0 +1,41 @@
+//============================================================================
+//  Copyright (c) Kitware, Inc.
+//  All rights reserved.
+//  See LICENSE.txt for details.
+//  This software is distributed WITHOUT ANY WARRANTY; without even
+//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+//  PURPOSE.  See the above copyright notice for more information.
+//
+//  Copyright 2014 Sandia Corporation.
+//  Copyright 2014 UT-Battelle, LLC.
+//  Copyright 2014. Los Alamos National Security
+//
+//  Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//  the U.S. Government retains certain rights in this software.
+//
+//  Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
+//  Laboratory (LANL), the U.S. Government retains certain rights in
+//  this software.
+//============================================================================
+#ifndef vtkm_cont_ErrorExecution_h
+#define vtkm_cont_ErrorExecution_h
+
+#include <vtkm/cont/Error.h>
+
+namespace vtkm {
+namespace cont {
+
+/// This class is thrown in the control environment whenever an error occurs in
+/// the execution environment.
+///
+class ErrorExecution : public vtkm::cont::Error
+{
+public:
+  ErrorExecution(const std::string message)
+    : Error(message) { }
+};
+
+}
+}  // namespace vtkm::cont
+
+#endif //vtkm_cont_ErrorExecution_h

vtkm/cont/internal/ArrayContainerControlError.h

@@ -0,0 +1,42 @@
+//============================================================================
+//  Copyright (c) Kitware, Inc.
+//  All rights reserved.
+//  See LICENSE.txt for details.
+//  This software is distributed WITHOUT ANY WARRANTY; without even
+//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+//  PURPOSE.  See the above copyright notice for more information.
+//
+//  Copyright 2014 Sandia Corporation.
+//  Copyright 2014 UT-Battelle, LLC.
+//  Copyright 2014. Los Alamos National Security
+//
+//  Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//  the U.S. Government retains certain rights in this software.
+//
+//  Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
+//  Laboratory (LANL), the U.S. Government retains certain rights in
+//  this software.
+//============================================================================
+#ifndef vtkm_cont_internal_ArrayContainerControlError_h
+#define vtkm_cont_internal_ArrayContainerControlError_h
+
+
+namespace vtkm {
+namespace cont {
+namespace internal {
+
+/// This is an invalid ArrayContainerControl. The point of this class is to
+/// include the header file to make this invalid class the default
+/// ArrayContainerControl. From that point, you have to specify an appropriate
+/// ArrayContainerControl or else get a compile error.
+///
+struct ArrayContainerControlTagError
+{
+  // Not implemented.
+};
+
+}
+}
+} // namespace vtkm::cont::internal
+
+#endif //vtkm_cont_internal_ArrayContainerControlError_h

vtkm/cont/internal/ArrayHandleExecutionManager.h

@@ -0,0 +1,286 @@
+//============================================================================
+//  Copyright (c) Kitware, Inc.
+//  All rights reserved.
+//  See LICENSE.txt for details.
+//  This software is distributed WITHOUT ANY WARRANTY; without even
+//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+//  PURPOSE.  See the above copyright notice for more information.
+//
+//  Copyright 2014 Sandia Corporation.
+//  Copyright 2014 UT-Battelle, LLC.
+//  Copyright 2014. Los Alamos National Security
+//
+//  Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//  the U.S. Government retains certain rights in this software.
+//
+//  Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
+//  Laboratory (LANL), the U.S. Government retains certain rights in
+//  this software.
+//============================================================================
+#ifndef vtkm_cont_exec_ArrayHandleExecutionManager_h
+#define vtkm_cont_exec_ArrayHandleExecutionManager_h
+
+#include <vtkm/cont/ArrayContainerControl.h>
+#include <vtkm/cont/ErrorControlInternal.h>
+#include <vtkm/cont/internal/ArrayTransfer.h>
+
+namespace vtkm {
+namespace cont {
+namespace internal {
+
+/// The common base for ArrayHandleExecutionManager. This is the interface
+/// used when the type of the device is not known at run time.
+///
+template<typename T, typename Container>
+class ArrayHandleExecutionManagerBase
+{
+private:
+  typedef vtkm::cont::internal::ArrayContainerControl<T,Container>
+      ContainerType;
+
+public:
+  template <typename DeviceAdapter>
+  struct ExecutionTypes {
+  private:
+    typedef vtkm::cont::internal::ArrayTransfer<T,Container,DeviceAdapter>
+        ArrayTransferType;
+  public:
+    typedef typename ArrayTransferType::PortalExecution Portal;
+    typedef typename ArrayTransferType::PortalConstExecution PortalConst;
+  };
+
+  /// The type of value held in the array (vtkm::Scalar, vtkm::Vector3, etc.)
+  ///
+  typedef T ValueType;
+
+  /// An array portal that can be used in the control environment.
+  ///
+  typedef typename ContainerType::PortalType PortalControl;
+  typedef typename ContainerType::PortalConstType PortalConstControl;
+
+  VTKM_CONT_EXPORT
+  virtual ~ArrayHandleExecutionManagerBase() {  }
+
+  /// Returns the number of values stored in the array.  Results are undefined
+  /// if data has not been loaded or allocated.
+  ///
+  virtual vtkm::Id GetNumberOfValues() const = 0;
+
+  /// Allocates a large enough array in the execution environment and copies
+  /// the given data to that array. The allocated array can later be accessed
+  /// via the GetPortalConstExecution method. If control and execution share
+  /// arrays, then this method may save the iterators to be returned in the \c
+  /// GetPortalConst methods.
+  ///
+  virtual void LoadDataForInput(PortalConstControl portal) = 0;
+
+  /// Allocates a large enough array in the execution environment and copies
+  /// the given data to that array. The allocated array can later be accessed
+  /// via the GetPortalConstExecution method. If control and execution share
+  /// arrays, then this method may save the iterators to be returned in the \c
+  /// GetPortalConst methods.
+  ///
+  virtual void LoadDataForInput(const ContainerType &controlArray) = 0;
+
+  /// Allocates a large enough array in the execution environment and copies
+  /// the given data to that array. The allocated array can later be accessed
+  /// via the GetPortalExection method. If control and execution share arrays,
+  /// then this method may save the iterators of the container to be returned
+  /// in the \c GetPortal* methods.
+  ///
+  virtual void LoadDataForInPlace(ContainerType &controlArray) = 0;
+
+  /// Allocates an array in the execution environment of the specified size.
+  /// If control and execution share arrays, then this class can allocate
+  /// data using the given ArrayContainerExecution and remember its iterators
+  /// so that it can be used directly in the execution environment.
+  ///
+  virtual void AllocateArrayForOutput(ContainerType &controlArray,
+                                      vtkm::Id numberOfValues) = 0;
+
+  /// Allocates data in the given ArrayContainerControl and copies data held
+  /// in the execution environment (managed by this class) into the control
+  /// array. If control and execution share arrays, this can be no operation.
+  /// This method should only be called after AllocateArrayForOutput is
+  /// called.
+  ///
+  virtual void RetrieveOutputData(ContainerType &controlArray) const = 0;
+
+  /// \brief Reduces the size of the array without changing its values.
+  ///
+  /// This method allows you to resize the array without reallocating it. The
+  /// number of entries in the array is changed to \c numberOfValues. The data
+  /// in the array (from indices 0 to \c numberOfValues - 1) are the same, but
+  /// \c numberOfValues must be equal or less than the preexisting size
+  /// (returned from GetNumberOfValues). That is, this method can only be used
+  /// to shorten the array, not lengthen.
+  ///
+  virtual void Shrink(vtkm::Id numberOfValues) = 0;
+
+  /// Returns an array portal that can be used in the execution environment.
+  /// This portal was defined in either LoadDataForInput or
+  /// AllocateArrayForOutput. If control and environment share memory space,
+  /// this class may return the iterator from the \c controlArray.
+  ///
+  template<typename DeviceAdapter>
+  VTKM_CONT_EXPORT
+  typename ExecutionTypes<DeviceAdapter>::Portal
+  GetPortalExecution(DeviceAdapter device)
+  {
+    this->VerifyDeviceAdapter(device);
+
+    typename ExecutionTypes<DeviceAdapter>::Portal portal;
+    this->GetPortalExecutionImpl(&portal);
+    return portal;
+  }
+
+  /// Const version of GetPortal.
+  ///
+  template<typename DeviceAdapter>
+  VTKM_CONT_EXPORT
+  typename ExecutionTypes<DeviceAdapter>::PortalConst
+  GetPortalConstExecution(DeviceAdapter device) const
+  {
+    this->VerifyDeviceAdapter(device);
+
+    typename ExecutionTypes<DeviceAdapter>::PortalConst portal;
+    this->GetPortalConstExecutionImpl(&portal);
+    return portal;
+  }
+
+  /// Frees any resources (i.e. memory) allocated for the exeuction
+  /// environment, if any.
+  ///
+  virtual void ReleaseResources() = 0;
+
+  template<typename DeviceAdapter>
+  VTKM_CONT_EXPORT
+  bool IsDeviceAdapter(DeviceAdapter) const
+  {
+    return this->IsDeviceAdapterImpl(
+          vtkm::cont::internal::DeviceAdapterTraits<DeviceAdapter>::GetId());
+  }
+
+protected:
+  virtual void GetPortalExecutionImpl(void *portalExecution) = 0;
+
+  virtual void GetPortalConstExecutionImpl(
+      void *portalConstExecution) const = 0;
+
+  virtual bool IsDeviceAdapterImpl(
+      const vtkm::cont::internal::DeviceAdapterId &id) const = 0;
+
+private:
+  template<typename DeviceAdapter>
+  VTKM_CONT_EXPORT
+  void VerifyDeviceAdapter(DeviceAdapter device) const
+  {
+    if (!this->IsDeviceAdapter(device))
+      {
+      throw vtkm::cont::ErrorControlInternal("Device Adapter Mismatch");
+      }
+  }
+};
+
+/// \brief Used by ArrayHandle to manage execution arrays
+///
+/// This is an internal class used by ArrayHandle to manage execution arrays.
+/// This class uses virtual method polymorphism to allocate and transfer data
+/// in the execution environment. This virtual method polymorphism allows the
+/// ArrayHandle to change its device at run time.
+///
+template<typename T,
+         typename Container,
+         typename DeviceAdapter>
+class ArrayHandleExecutionManager
+    : public ArrayHandleExecutionManagerBase<T, Container>
+{
+  typedef ArrayHandleExecutionManagerBase<T, Container> Superclass;
+  typedef vtkm::cont::internal::ArrayTransfer<T,Container,DeviceAdapter>
+      ArrayTransferType;
+  typedef vtkm::cont::internal::ArrayContainerControl<T,Container> ContainerType;
+
+public:
+  typedef typename ArrayTransferType::PortalControl PortalControl;
+  typedef typename ArrayTransferType::PortalConstControl PortalConstControl;
+
+  VTKM_CONT_EXPORT
+  vtkm::Id GetNumberOfValues() const
+  {
+    return this->Transfer.GetNumberOfValues();
+  }
+
+  VTKM_CONT_EXPORT
+  void LoadDataForInput(PortalConstControl portal)
+  {
+    this->Transfer.LoadDataForInput(portal);
+  }
+
+  VTKM_CONT_EXPORT
+  void LoadDataForInput(const ContainerType &controlArray)
+  {
+    this->Transfer.LoadDataForInput(controlArray);
+  }
+
+  VTKM_CONT_EXPORT
+  void LoadDataForInPlace(ContainerType &controlArray)
+  {
+    this->Transfer.LoadDataForInPlace(controlArray);
+  }
+
+  VTKM_CONT_EXPORT
+  void AllocateArrayForOutput(ContainerType &controlArray, Id numberOfValues)
+  {
+    this->Transfer.AllocateArrayForOutput(controlArray, numberOfValues);
+  }
+
+  VTKM_CONT_EXPORT
+  void RetrieveOutputData(ContainerType &controlArray) const
+  {
+    this->Transfer.RetrieveOutputData(controlArray);
+  }
+
+  VTKM_CONT_EXPORT
+  void Shrink(Id numberOfValues)
+  {
+    this->Transfer.Shrink(numberOfValues);
+  }
+
+  VTKM_CONT_EXPORT
+  void ReleaseResources()
+  {
+    this->Transfer.ReleaseResources();
+  }
+
+protected:
+  VTKM_CONT_EXPORT
+  void GetPortalExecutionImpl(void *portalExecutionVoid)
+  {
+    typedef typename ArrayTransferType::PortalExecution PortalType;
+    PortalType portalExecution = this->Transfer.GetPortalExecution();
+    *reinterpret_cast<PortalType *>(portalExecutionVoid) = portalExecution;
+  }
+
+  VTKM_CONT_EXPORT
+  void GetPortalConstExecutionImpl(void *portalExecutionVoid) const
+  {
+    typedef typename ArrayTransferType::PortalConstExecution PortalType;
+    PortalType portalExecution = this->Transfer.GetPortalConstExecution();
+    *reinterpret_cast<PortalType *>(portalExecutionVoid) = portalExecution;
+  }
+
+  VTKM_CONT_EXPORT
+  bool IsDeviceAdapterImpl(const DeviceAdapterId &id) const
+  {
+    return id == vtkm::cont::internal::DeviceAdapterTraits<DeviceAdapter>::GetId();
+  }
+
+private:
+  ArrayTransferType Transfer;
+};
+
+}
+}
+} // namespace vtkm::cont::internal
+
+#endif //vtkm_cont_exec_ArrayHandleExecutionManager_h

vtkm/cont/internal/ArrayManagerExecution.h

@@ -0,0 +1,172 @@
+//============================================================================
+//  Copyright (c) Kitware, Inc.
+//  All rights reserved.
+//  See LICENSE.txt for details.
+//  This software is distributed WITHOUT ANY WARRANTY; without even
+//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+//  PURPOSE.  See the above copyright notice for more information.
+//
+//  Copyright 2014 Sandia Corporation.
+//  Copyright 2014 UT-Battelle, LLC.
+//  Copyright 2014. Los Alamos National Security
+//
+//  Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//  the U.S. Government retains certain rights in this software.
+//
+//  Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
+//  Laboratory (LANL), the U.S. Government retains certain rights in
+//  this software.
+//============================================================================
+#ifndef vtkm_cont_internal_ArrayManagerExecution_h
+#define vtkm_cont_internal_ArrayManagerExecution_h
+
+#include <vtkm/cont/internal/DeviceAdapterTag.h>
+
+namespace vtkm {
+namespace cont {
+namespace internal {
+
+/// \brief Class that manages data in the execution environment.
+///
+/// This templated class must be partially specialized for each
+/// DeviceAdapterTag crated, which will define the implementation for that tag.
+///
+/// This is a class that is responsible for allocating data in the execution
+/// environment and copying data back and forth between control and
+/// execution. It is also expected that this class will automatically release
+/// any resources in its destructor.
+///
+/// This class typically takes on one of two forms. If the control and
+/// execution environments have seperate memory spaces, then this class
+/// behaves how you would expect. It allocates/deallocates arrays and copies
+/// data. However, if the control and execution environments share the same
+/// memory space, this class should delegate all its operations to the
+/// ArrayContainerControl. The latter can probably be implemented with a
+/// trivial subclass of
+/// vtkm::cont::internal::ArrayManagerExecutionShareWithControl.
+///
+template<typename T, class ArrayContainerControlTag, class DeviceAdapterTag>
+class ArrayManagerExecution
+#ifdef VTKM_DOXYGEN_ONLY
+{
+private:
+  typedef vtkm::cont::internal::ArrayContainerControl<T,ArrayContainerControlTag>
+      ContainerType;
+
+public:
+  /// The type of value held in the array (vtkm::Scalar, vtkm::Vector3, etc.)
+  ///
+  typedef T ValueType;
+
+  /// An array portal that can be used in the execution environment to access
+  /// portions of the arrays. This example defines the portal with a pointer,
+  /// but any portal with methods that can be called and data that can be
+  /// accessed from the execution environment can be used.
+  ///
+  typedef vtkm::exec::internal::ArrayPortalFromIterators<ValueType*> PortalType;
+
+  /// Const version of PortalType.  You must be able to cast PortalType to
+  /// PortalConstType.
+  ///
+  typedef vtkm::exec::internal::ArrayPortalFromIterators<const ValueType*>
+      PortalConstType;
+
+  /// Returns the number of values stored in the array.  Results are undefined
+  /// if data has not been loaded or allocated.
+  ///
+  VTKM_CONT_EXPORT vtkm::Id GetNumberOfValues() const;
+
+  /// Allocates a large enough array in the execution environment and copies
+  /// the given data to that array. The allocated array can later be accessed
+  /// via the GetPortalConst method. If control and execution share arrays,
+  /// then this method may save the iterators to be returned in the \c
+  /// GetPortalConst method.
+  ///
+  VTKM_CONT_EXPORT void LoadDataForInput(
+      typename ContainerType::PortalConstType portal);
+
+  /// Allocates a large enough array in the execution environment and copies
+  /// the given data to that array. The allocated array can later be accessed
+  /// via the GetPortal method. If control and execution share arrays, then
+  /// this method may save the iterators of the container to be returned in the
+  /// \c GetPortal* methods.
+  ///
+  VTKM_CONT_EXPORT void LoadDataForInPlace(PortalType portal);
+
+  /// Allocates an array in the execution environment of the specified size.
+  /// If control and execution share arrays, then this class can allocate
+  /// data using the given ArrayContainerExecution and remember its iterators
+  /// so that it can be used directly in the execution environment.
+  ///
+  VTKM_CONT_EXPORT void AllocateArrayForOutput(ContainerType &controlArray,
+                                              vtkm::Id numberOfValues);
+
+  /// Allocates data in the given ArrayContainerControl and copies data held
+  /// in the execution environment (managed by this class) into the control
+  /// array. If control and execution share arrays, this can be no operation.
+  /// This method should only be called after AllocateArrayForOutput is
+  /// called.
+  ///
+  VTKM_CONT_EXPORT void RetrieveOutputData(ContainerType &controlArray) const;
+
+  /// Similar to RetrieveOutputData except that instead of writing to the
+  /// controlArray itself, it writes to the given control environment
+  /// iterator. This allows the user to retrieve data without necessarily
+  /// allocating an array in the ArrayContainerControl (assuming that control
+  /// and exeuction have seperate memory spaces).
+  ///
+  template <class IteratorTypeControl>
+  VTKM_CONT_EXPORT void CopyInto(IteratorTypeControl dest) const;
+
+  /// \brief Reduces the size of the array without changing its values.
+  ///
+  /// This method allows you to resize the array without reallocating it. The
+  /// number of entries in the array is changed to \c numberOfValues. The data
+  /// in the array (from indices 0 to \c numberOfValues - 1) are the same, but
+  /// \c numberOfValues must be equal or less than the preexisting size
+  /// (returned from GetNumberOfValues). That is, this method can only be used
+  /// to shorten the array, not lengthen.
+  ///
+  VTKM_CONT_EXPORT void Shrink(vtkm::Id numberOfValues);
+
+  /// Returns an array portal that can be used in the execution environment.
+  /// This portal was defined in either LoadDataForInput or
+  /// AllocateArrayForOutput. If control and environment share memory space,
+  /// this class may return the iterator from the \c controlArray.
+  ///
+  VTKM_CONT_EXPORT PortalType GetPortal();
+
+  /// Const version of GetPortal.
+  ///
+  VTKM_CONT_EXPORT PortalConstType GetPortalConst() const;
+
+  /// Frees any resources (i.e. memory) allocated for the exeuction
+  /// environment, if any.
+  ///
+  VTKM_CONT_EXPORT void ReleaseResources();
+};
+#else // VTKM_DOXGEN_ONLY
+;
+#endif // VTKM_DOXYGEN_ONLY
+
+}
+}
+} // namespace vtkm::cont::internal
+
+
+//-----------------------------------------------------------------------------
+// These includes are intentionally placed here after the declaration of the
+// ArrayManagerExecution template prototype, which all the implementations
+// need.
+
+#if VTKM_DEVICE_ADAPTER == VTKM_DEVICE_ADAPTER_SERIAL
+#include <vtkm/cont/internal/ArrayManagerExecutionSerial.h>
+// #elif VTKM_DEVICE_ADAPTER == VTKM_DEVICE_ADAPTER_CUDA
+// #include <vtkm/cuda/cont/internal/ArrayManagerExecutionCuda.h>
+// #elif VTKM_DEVICE_ADAPTER == VTKM_DEVICE_ADAPTER_OPENMP
+// #include <vtkm/openmp/cont/internal/ArrayManagerExecutionOpenMP.h>
+// #elif VTKM_DEVICE_ADAPTER == VTKM_DEVICE_ADAPTER_TBB
+// #include <vtkm/tbb/cont/internal/ArrayManagerExecutionTBB.h>
+#endif
+
+#endif //vtkm_cont_internal_ArrayManagerExecution_h

vtkm/cont/internal/ArrayManagerExecutionSerial.h

@@ -0,0 +1,49 @@
+//============================================================================
+//  Copyright (c) Kitware, Inc.
+//  All rights reserved.
+//  See LICENSE.txt for details.
+//  This software is distributed WITHOUT ANY WARRANTY; without even
+//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+//  PURPOSE.  See the above copyright notice for more information.
+//
+//  Copyright 2014 Sandia Corporation.
+//  Copyright 2014 UT-Battelle, LLC.
+//  Copyright 2014. Los Alamos National Security
+//
+//  Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//  the U.S. Government retains certain rights in this software.
+//
+//  Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
+//  Laboratory (LANL), the U.S. Government retains certain rights in
+//  this software.
+//============================================================================
+#ifndef vtkm_cont_internal_ArrayManagerExecutionSerial_h
+#define vtkm_cont_internal_ArrayManagerExecutionSerial_h
+
+#include <vtkm/cont/internal/ArrayManagerExecution.h>
+#include <vtkm/cont/internal/ArrayManagerExecutionShareWithControl.h>
+#include <vtkm/cont/internal/DeviceAdapterTagSerial.h>
+
+namespace vtkm {
+namespace cont {
+namespace internal {
+
+template <typename T, class ArrayContainerControlTag>
+class ArrayManagerExecution
+    <T, ArrayContainerControlTag, vtkm::cont::DeviceAdapterTagSerial>
+    : public vtkm::cont::internal::ArrayManagerExecutionShareWithControl
+          <T, ArrayContainerControlTag>
+{
+public:
+  typedef vtkm::cont::internal::ArrayManagerExecutionShareWithControl
+      <T, ArrayContainerControlTag> Superclass;
+  typedef typename Superclass::ValueType ValueType;
+  typedef typename Superclass::PortalType PortalType;
+  typedef typename Superclass::PortalConstType PortalConstType;
+};
+
+}
+}
+} // namespace vtkm::cont::internal
+
+#endif //vtkm_cont_internal_ArrayManagerExecutionSerial_h

vtkm/cont/internal/ArrayManagerExecutionShareWithControl.h

@@ -0,0 +1,176 @@
+//============================================================================
+//  Copyright (c) Kitware, Inc.
+//  All rights reserved.
+//  See LICENSE.txt for details.
+//  This software is distributed WITHOUT ANY WARRANTY; without even
+//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+//  PURPOSE.  See the above copyright notice for more information.
+//
+//  Copyright 2014 Sandia Corporation.
+//  Copyright 2014 UT-Battelle, LLC.
+//  Copyright 2014. Los Alamos National Security
+//
+//  Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//  the U.S. Government retains certain rights in this software.
+//
+//  Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
+//  Laboratory (LANL), the U.S. Government retains certain rights in
+//  this software.
+//============================================================================
+#ifndef vtkm_cont_internal_ArrayManagerExecutionShareWithControl_h
+#define vtkm_cont_internal_ArrayManagerExecutionShareWithControl_h
+
+#include <vtkm/Types.h>
+
+#include <vtkm/cont/Assert.h>
+#include <vtkm/cont/ArrayContainerControl.h>
+#include <vtkm/cont/internal/ArrayPortalShrink.h>
+
+#include <algorithm>
+
+namespace vtkm {
+namespace cont {
+namespace internal {
+
+/// \c ArrayManagerExecutionShareWithControl provides an implementation for a
+/// \c ArrayManagerExecution class for a device adapter when the execution
+/// and control environments share memory. This class basically defers all its
+/// calls to an \c ArrayContainerControl class and uses the array allocated
+/// there.
+///
+template<typename T, class ArrayContainerControlTag>
+class ArrayManagerExecutionShareWithControl
+{
+public:
+  typedef T ValueType;
+  typedef vtkm::cont::internal
+      ::ArrayContainerControl<ValueType, ArrayContainerControlTag>
+      ContainerType;
+  typedef vtkm::cont::internal::ArrayPortalShrink<
+      typename ContainerType::PortalType> PortalType;
+  typedef vtkm::cont::internal::ArrayPortalShrink<
+      typename ContainerType::PortalConstType> PortalConstType;
+
+  VTKM_CONT_EXPORT ArrayManagerExecutionShareWithControl()
+    : PortalValid(false), ConstPortalValid(false) { }
+
+  /// Returns the size of the saved portal.
+  ///
+  VTKM_CONT_EXPORT vtkm::Id GetNumberOfValues() const {
+    VTKM_ASSERT_CONT(this->ConstPortalValid);
+    return this->ConstPortal.GetNumberOfValues();
+  }
+
+  /// Saves the given iterators to be returned later.
+  ///
+  VTKM_CONT_EXPORT void LoadDataForInput(PortalConstType portal)
+  {
+    this->ConstPortal = portal;
+    this->ConstPortalValid = true;
+
+    // Non-const versions not defined.
+    this->PortalValid = false;
+  }
+
+  /// Saves the given iterators to be returned later.
+  ///
+  VTKM_CONT_EXPORT void LoadDataForInPlace(PortalType portal)
+  {
+    // This only works if there is a valid cast from non-const to const
+    // iterator.
+    this->LoadDataForInput(portal);
+
+    this->Portal = portal;
+    this->PortalValid = true;
+  }
+
+  /// Actually just allocates memory in the given \p controlArray.
+  ///
+  VTKM_CONT_EXPORT void AllocateArrayForOutput(ContainerType &controlArray,
+                                              vtkm::Id numberOfValues)
+  {
+    controlArray.Allocate(numberOfValues);
+
+    this->Portal = controlArray.GetPortal();
+    this->PortalValid = true;
+
+    this->ConstPortal = controlArray.GetPortalConst();
+    this->ConstPortalValid = true;
+  }
+
+  /// This method is a no-op (except for a few checks). Any data written to
+  /// this class's iterators should already be written to the given \c
+  /// controlArray (under correct operation).
+  ///
+  VTKM_CONT_EXPORT void RetrieveOutputData(ContainerType &controlArray) const
+  {
+    VTKM_ASSERT_CONT(this->ConstPortalValid);
+    VTKM_ASSERT_CONT(controlArray.GetPortalConst().GetIteratorBegin() ==
+                    this->ConstPortal.GetIteratorBegin());
+    controlArray.Shrink(this->ConstPortal.GetNumberOfValues());
+  }
+
+  /// This methods copies data from the execution array into the given
+  /// iterator.
+  ///
+  template <class IteratorTypeControl>
+  VTKM_CONT_EXPORT void CopyInto(IteratorTypeControl dest) const
+  {
+    VTKM_ASSERT_CONT(this->ConstPortalValid);
+    std::copy(this->ConstPortal.GetIteratorBegin(),
+              this->ConstPortal.GetIteratorEnd(),
+              dest);
+  }
+
+  /// Adjusts saved end iterators to resize array.
+  ///
+  VTKM_CONT_EXPORT void Shrink(vtkm::Id numberOfValues)
+  {
+    VTKM_ASSERT_CONT(this->ConstPortalValid);
+    this->ConstPortal.Shrink(numberOfValues);
+
+    if (this->PortalValid)
+      {
+      this->Portal.Shrink(numberOfValues);
+      }
+  }
+
+  /// Returns the portal previously saved from an \c ArrayContainerControl.
+  ///
+  VTKM_CONT_EXPORT PortalType GetPortal()
+  {
+    VTKM_ASSERT_CONT(this->PortalValid);
+    return this->Portal;
+  }
+
+  /// Const version of GetPortal.
+  ///
+  VTKM_CONT_EXPORT PortalConstType GetPortalConst() const
+  {
+    VTKM_ASSERT_CONT(this->ConstPortalValid);
+    return this->ConstPortal;
+  }
+
+  /// A no-op.
+  ///
+  VTKM_CONT_EXPORT void ReleaseResources() { }
+
+private:
+  // Not implemented.
+  ArrayManagerExecutionShareWithControl(
+      ArrayManagerExecutionShareWithControl<T, ArrayContainerControlTag> &);
+  void operator=(
+      ArrayManagerExecutionShareWithControl<T, ArrayContainerControlTag> &);
+
+  PortalType Portal;
+  bool PortalValid;
+
+  PortalConstType ConstPortal;
+  bool ConstPortalValid;
+};
+
+}
+}
+} // namespace vtkm::cont::internal
+
+#endif //vtkm_cont_internal_ArrayManagerExecutionShareWithControl_h

vtkm/cont/internal/ArrayPortalFromIterators.h

@@ -0,0 +1,101 @@
+//============================================================================
+//  Copyright (c) Kitware, Inc.
+//  All rights reserved.
+//  See LICENSE.txt for details.
+//  This software is distributed WITHOUT ANY WARRANTY; without even
+//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+//  PURPOSE.  See the above copyright notice for more information.
+//
+//  Copyright 2014 Sandia Corporation.
+//  Copyright 2014 UT-Battelle, LLC.
+//  Copyright 2014. Los Alamos National Security
+//
+//  Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//  the U.S. Government retains certain rights in this software.
+//
+//  Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
+//  Laboratory (LANL), the U.S. Government retains certain rights in
+//  this software.
+//============================================================================
+#ifndef vtkm_cont_internal_ArrayPortalFromIterators_h
+#define vtkm_cont_internal_ArrayPortalFromIterators_h
+
+#include <vtkm/Types.h>
+#include <vtkm/cont/ArrayPortal.h>
+#include <vtkm/cont/Assert.h>
+
+#include <iterator>
+
+namespace vtkm {
+namespace cont {
+namespace internal {
+
+/// This templated implementation of an ArrayPortal allows you to adapt a pair
+/// of begin/end iterators to an ArrayPortal interface.
+///
+template<class IteratorT>
+class ArrayPortalFromIterators
+{
+public:
+  typedef IteratorT IteratorType;
+  typedef typename std::iterator_traits<IteratorType>::value_type ValueType;
+
+  VTKM_CONT_EXPORT ArrayPortalFromIterators() {  }
+
+  VTKM_CONT_EXPORT
+  ArrayPortalFromIterators(IteratorType begin, IteratorType end)
+    : BeginIterator(begin), EndIterator(end)
+  {
+    VTKM_ASSERT_CONT(this->GetNumberOfValues() >= 0);
+  }
+
+  /// Copy constructor for any other ArrayPortalFromIterators with an iterator
+  /// type that can be copied to this iterator type. This allows us to do any
+  /// type casting that the iterators do (like the non-const to const cast).
+  ///
+  template<class OtherIteratorT>
+  VTKM_CONT_EXPORT
+  ArrayPortalFromIterators(const ArrayPortalFromIterators<OtherIteratorT> &src)
+    : BeginIterator(src.GetIteratorBegin()),
+      EndIterator(src.GetIteratorEnd())
+  {  }
+
+  VTKM_CONT_EXPORT
+  vtkm::Id GetNumberOfValues() const {
+    return std::distance(this->BeginIterator, this->EndIterator);
+  }
+
+  VTKM_CONT_EXPORT
+  ValueType Get(vtkm::Id index) const {
+    return *this->IteratorAt(index);
+  }
+
+  VTKM_CONT_EXPORT
+  void Set(vtkm::Id index, ValueType value) const {
+    *this->IteratorAt(index) = value;
+  }
+
+  VTKM_CONT_EXPORT
+  IteratorType GetIteratorBegin() const { return this->BeginIterator; }
+
+  VTKM_CONT_EXPORT
+  IteratorType GetIteratorEnd() const { return this->EndIterator; }
+
+private:
+  IteratorType BeginIterator;
+  IteratorType EndIterator;
+
+  VTKM_CONT_EXPORT
+  IteratorType IteratorAt(vtkm::Id index) const {
+    VTKM_ASSERT_CONT(index >= 0);
+    VTKM_ASSERT_CONT(index < this->GetNumberOfValues());
+
+    return this->BeginIterator + index;
+  }
+};
+
+}
+}
+} // namespace vtkm::cont::internal
+
+#endif //vtkm_cont_internal_ArrayPortalFromIterators_h

vtkm/cont/internal/ArrayPortalShrink.h

@@ -0,0 +1,121 @@
+//============================================================================
+//  Copyright (c) Kitware, Inc.
+//  All rights reserved.
+//  See LICENSE.txt for details.
+//  This software is distributed WITHOUT ANY WARRANTY; without even
+//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+//  PURPOSE.  See the above copyright notice for more information.
+//
+//  Copyright 2014 Sandia Corporation.
+//  Copyright 2014 UT-Battelle, LLC.
+//  Copyright 2014. Los Alamos National Security
+//
+//  Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//  the U.S. Government retains certain rights in this software.
+//
+//  Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
+//  Laboratory (LANL), the U.S. Government retains certain rights in
+//  this software.
+//============================================================================
+#ifndef vtkm_cont_internal_ArrayPortalShrink_h
+#define vtkm_cont_internal_ArrayPortalShrink_h
+
+#include <vtkm/Types.h>
+#include <vtkm/cont/ArrayPortal.h>
+#include <vtkm/cont/Assert.h>
+
+namespace vtkm {
+namespace cont {
+namespace internal {
+
+/// This ArrayPortal adapter is a utility that allows you to shrink the
+/// (reported) array size without actually modifying the underlying allocation.
+///
+template<class PortalT>
+class ArrayPortalShrink
+{
+public:
+  typedef PortalT DelegatePortalType;
+
+  typedef typename DelegatePortalType::ValueType ValueType;
+  typedef typename DelegatePortalType::IteratorType IteratorType;
+
+  VTKM_CONT_EXPORT ArrayPortalShrink() : NumberOfValues(0) {  }
+
+  VTKM_CONT_EXPORT ArrayPortalShrink(const DelegatePortalType &delegatePortal)
+    : DelegatePortal(delegatePortal),
+      NumberOfValues(delegatePortal.GetNumberOfValues())
+  {  }
+
+  VTKM_CONT_EXPORT ArrayPortalShrink(const DelegatePortalType &delegatePortal,
+                                    vtkm::Id numberOfValues)
+    : DelegatePortal(delegatePortal), NumberOfValues(numberOfValues)
+  {
+    VTKM_ASSERT_CONT(numberOfValues <= delegatePortal.GetNumberOfValues());
+  }
+
+  /// Copy constructor for any other ArrayPortalShrink with a delegate type
+  /// that can be copied to this type. This allows us to do any type casting
+  /// the delegates can do (like the non-const to const cast).
+  ///
+  template<class OtherDelegateType>
+  VTKM_CONT_EXPORT
+  ArrayPortalShrink(const ArrayPortalShrink<OtherDelegateType> &src)
+    : DelegatePortal(src.GetDelegatePortal()),
+      NumberOfValues(src.GetNumberOfValues())
+  {  }
+
+  VTKM_CONT_EXPORT
+  vtkm::Id GetNumberOfValues() const { return this->NumberOfValues; }
+
+  VTKM_CONT_EXPORT
+  ValueType Get(vtkm::Id index) const {
+    VTKM_ASSERT_CONT(index >= 0);
+    VTKM_ASSERT_CONT(index < this->GetNumberOfValues());
+    return this->DelegatePortal.Get(index);
+  }
+
+  VTKM_CONT_EXPORT
+  void Set(vtkm::Id index, ValueType value) const {
+    VTKM_ASSERT_CONT(index >= 0);
+    VTKM_ASSERT_CONT(index < this->GetNumberOfValues());
+    this->DelegatePortal.Set(index, value);
+  }
+
+  VTKM_CONT_EXPORT
+  IteratorType GetIteratorBegin() const {
+    return this->DelegatePortal.GetIteratorBegin();
+  }
+
+  VTKM_CONT_EXPORT
+  IteratorType GetIteratorEnd() const {
+    IteratorType iterator = this->DelegatePortal.GetIteratorBegin();
+    std::advance(iterator, this->GetNumberOfValues());
+    return iterator;
+  }
+
+  /// Special method in this ArrayPortal that allows you to shrink the
+  /// (exposed) array.
+  ///
+  VTKM_CONT_EXPORT
+  void Shrink(vtkm::Id numberOfValues) {
+    VTKM_ASSERT_CONT(numberOfValues < this->GetNumberOfValues());
+    this->NumberOfValues = numberOfValues;
+  }
+
+  /// Get a copy of the delegate portal. Although safe, this is probably only
+  /// useful internally. (It is exposed as public for the templated copy
+  /// constructor.)
+  ///
+  DelegatePortalType GetDelegatePortal() const { return this->DelegatePortal; }
+
+private:
+  DelegatePortalType DelegatePortal;
+  vtkm::Id NumberOfValues;
+};
+
+}
+}
+} // namespace vtkm::cont::internal
+
+#endif //vtkm_cont_internal_ArrayPortalShrink_h

vtkm/cont/internal/ArrayTransfer.h

@@ -0,0 +1,193 @@
+//============================================================================
+//  Copyright (c) Kitware, Inc.
+//  All rights reserved.
+//  See LICENSE.txt for details.
+//  This software is distributed WITHOUT ANY WARRANTY; without even
+//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+//  PURPOSE.  See the above copyright notice for more information.
+//
+//  Copyright 2014 Sandia Corporation.
+//  Copyright 2014 UT-Battelle, LLC.
+//  Copyright 2014. Los Alamos National Security
+//
+//  Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//  the U.S. Government retains certain rights in this software.
+//
+//  Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
+//  Laboratory (LANL), the U.S. Government retains certain rights in
+//  this software.
+//============================================================================
+#ifndef vtkm_cont_internal_ArrayTransfer_h
+#define vtkm_cont_internal_ArrayTransfer_h
+
+#include <vtkm/cont/ArrayContainerControl.h>
+#include <vtkm/cont/internal/ArrayManagerExecution.h>
+
+namespace vtkm {
+namespace cont {
+namespace internal {
+
+/// \brief Class that manages the transfer of data between control and execution.
+///
+/// This templated class provides a mechanism (used by the ArrayHandle) to
+/// transfer data from the control environment to the execution environment and
+/// back. The interface for ArrayTransfer is nearly identical to that of
+/// ArrayManagerExecution and the default implementation simply delegates all
+/// calls to that class.
+///
+/// The primary motivation for having a separate class is that the
+/// ArrayManagerExecution is meant to be specialized for each device adapter
+/// whee as the ArrayTransfer is meant to be specialized for each array
+/// container (or specific combination of container and device adapter). Thus,
+/// transfers for most containers will be delegated through the
+/// ArrayManagerExecution, but some containers, like implicit containers, will
+/// be specialized to transfer through a different path.
+///
+template<typename T, class ArrayContainerControlTag, class DeviceAdapterTag>
+class ArrayTransfer
+{
+private:
+  typedef vtkm::cont::internal::ArrayContainerControl<T,ArrayContainerControlTag>
+      ContainerType;
+  typedef vtkm::cont::internal::ArrayManagerExecution<
+      T,ArrayContainerControlTag,DeviceAdapterTag> ArrayManagerType;
+
+public:
+  /// The type of value held in the array (vtkm::Scalar, vtkm::Vector3, etc.)
+  ///
+  typedef T ValueType;
+
+  /// An array portal that can be used in the control environment.
+  ///
+  typedef typename ContainerType::PortalType PortalControl;
+  typedef typename ContainerType::PortalConstType PortalConstControl;
+
+  /// An array portal that can be used in the execution environment.
+  ///
+  typedef typename ArrayManagerType::PortalType PortalExecution;
+  typedef typename ArrayManagerType::PortalConstType PortalConstExecution;
+
+
+  /// Returns the number of values stored in the array.  Results are undefined
+  /// if data has not been loaded or allocated.
+  ///
+  VTKM_CONT_EXPORT vtkm::Id GetNumberOfValues() const
+  {
+    return this->ArrayManager.GetNumberOfValues();
+  }
+
+  /// Allocates a large enough array in the execution environment and copies
+  /// the given data to that array. The allocated array can later be accessed
+  /// via the GetPortalConstExecution method. If control and execution share
+  /// arrays, then this method may save the iterators to be returned in the \c
+  /// GetPortalConst methods.
+  ///
+  VTKM_CONT_EXPORT void LoadDataForInput(PortalConstControl portal)
+  {
+    this->ArrayManager.LoadDataForInput(portal);
+  }
+
+  /// Allocates a large enough array in the execution environment and copies
+  /// the given data to that array. The allocated array can later be accessed
+  /// via the GetPortalConstExecution method. If control and execution share
+  /// arrays, then this method may save the iterators to be returned in the \c
+  /// GetPortalConst methods.
+  ///
+  VTKM_CONT_EXPORT void LoadDataForInput(const ContainerType &controlArray)
+  {
+    this->ArrayManager.LoadDataForInput(controlArray.GetPortalConst());
+  }
+
+  /// Allocates a large enough array in the execution environment and copies
+  /// the given data to that array. The allocated array can later be accessed
+  /// via the GetPortalExection method. If control and execution share arrays,
+  /// then this method may save the iterators of the container to be returned
+  /// in the \c GetPortal* methods.
+  ///
+  VTKM_CONT_EXPORT void LoadDataForInPlace(ContainerType &controlArray)
+  {
+    this->ArrayManager.LoadDataForInPlace(controlArray.GetPortal());
+  }
+
+  /// Allocates an array in the execution environment of the specified size.
+  /// If control and execution share arrays, then this class can allocate
+  /// data using the given ArrayContainerExecution and remember its iterators
+  /// so that it can be used directly in the execution environment.
+  ///
+  VTKM_CONT_EXPORT void AllocateArrayForOutput(ContainerType &controlArray,
+                                              vtkm::Id numberOfValues)
+  {
+    this->ArrayManager.AllocateArrayForOutput(controlArray, numberOfValues);
+  }
+
+  /// Allocates data in the given ArrayContainerControl and copies data held
+  /// in the execution environment (managed by this class) into the control
+  /// array. If control and execution share arrays, this can be no operation.
+  /// This method should only be called after AllocateArrayForOutput is
+  /// called.
+  ///
+  VTKM_CONT_EXPORT void RetrieveOutputData(ContainerType &controlArray) const
+  {
+    this->ArrayManager.RetrieveOutputData(controlArray);
+  }
+
+  /// Similar to RetrieveOutputData except that instead of writing to the
+  /// controlArray itself, it writes to the given control environment
+  /// iterator. This allows the user to retrieve data without necessarily
+  /// allocating an array in the ArrayContainerControl (assuming that control
+  /// and exeuction have seperate memory spaces).
+  ///
+  template <class IteratorTypeControl>
+  VTKM_CONT_EXPORT void CopyInto(IteratorTypeControl dest) const
+  {
+    this->ArrayManager.CopyInto(dest);
+  }
+
+  /// \brief Reduces the size of the array without changing its values.
+  ///
+  /// This method allows you to resize the array without reallocating it. The
+  /// number of entries in the array is changed to \c numberOfValues. The data
+  /// in the array (from indices 0 to \c numberOfValues - 1) are the same, but
+  /// \c numberOfValues must be equal or less than the preexisting size
+  /// (returned from GetNumberOfValues). That is, this method can only be used
+  /// to shorten the array, not lengthen.
+  ///
+  VTKM_CONT_EXPORT void Shrink(vtkm::Id numberOfValues)
+  {
+    this->ArrayManager.Shrink(numberOfValues);
+  }
+
+  /// Returns an array portal that can be used in the execution environment.
+  /// This portal was defined in either LoadDataForInput or
+  /// AllocateArrayForOutput. If control and environment share memory space,
+  /// this class may return the iterator from the \c controlArray.
+  ///
+  VTKM_CONT_EXPORT PortalExecution GetPortalExecution()
+  {
+    return this->ArrayManager.GetPortal();
+  }
+
+  /// Const version of GetPortal.
+  ///
+  VTKM_CONT_EXPORT PortalConstExecution GetPortalConstExecution() const
+  {
+    return this->ArrayManager.GetPortalConst();
+  }
+
+  /// Frees any resources (i.e. memory) allocated for the exeuction
+  /// environment, if any.
+  ///
+  VTKM_CONT_EXPORT void ReleaseResources()
+  {
+    this->ArrayManager.ReleaseResources();
+  }
+
+private:
+  ArrayManagerType ArrayManager;
+};
+
+}
+}
+} // namespace vtkm::cont::internal
+
+#endif //vtkm_cont_internal_ArrayTransfer_h

vtkm/cont/internal/CMakeLists.txt

@@ -0,0 +1,38 @@
+##============================================================================
+##  Copyright (c) Kitware, Inc.
+##  All rights reserved.
+##  See LICENSE.txt for details.
+##  This software is distributed WITHOUT ANY WARRANTY; without even
+##  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+##  PURPOSE.  See the above copyright notice for more information.
+##
+##  Copyright 2014 Sandia Corporation.
+##  Copyright 2014 UT-Battelle, LLC.
+##  Copyright 2014. Los Alamos National Security
+##
+##  Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+##  the U.S. Government retains certain rights in this software.
+##
+##  Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
+##  Laboratory (LANL), the U.S. Government retains certain rights in
+##  this software.
+##============================================================================
+
+set(headers
+  ArrayHandleExecutionManager.h
+  ArrayManagerExecution.h
+  ArrayManagerExecutionSerial.h
+  ArrayManagerExecutionShareWithControl.h
+  ArrayPortalFromIterators.h
+  ArrayPortalShrink.h
+  ArrayTransfer.h
+  )
+
+vtkm_declare_headers(${headers})
+
+# These source files are actually compiled in the parent directory.
+# They are in a separate directory to highlight which objects are
+# internal and which are part of the external interface.
+#add_custom_target(vtkmContInternal ALL DEPENDS vtkmCont)
+
+add_subdirectory(testing)

vtkm/cont/internal/DeviceAdapterTag.h

@@ -0,0 +1,107 @@
+//============================================================================
+//  Copyright (c) Kitware, Inc.
+//  All rights reserved.
+//  See LICENSE.txt for details.
+//  This software is distributed WITHOUT ANY WARRANTY; without even
+//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+//  PURPOSE.  See the above copyright notice for more information.
+//
+//  Copyright 2014 Sandia Corporation.
+//  Copyright 2014 UT-Battelle, LLC.
+//  Copyright 2014. Los Alamos National Security
+//
+//  Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//  the U.S. Government retains certain rights in this software.
+//
+//  Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
+//  Laboratory (LANL), the U.S. Government retains certain rights in
+//  this software.
+//============================================================================
+#ifndef vtkm_cont_internal_DeviceAdapterTag_h
+#define vtkm_cont_internal_DeviceAdapterTag_h
+
+#include <vtkm/internal/Configure.h>
+#include <vtkm/internal/ExportMacros.h>
+
+#include <string>
+
+#include <boost/static_assert.hpp>
+
+#define VTKM_DEVICE_ADAPTER_ERROR     -1
+#define VTKM_DEVICE_ADAPTER_UNDEFINED  0
+#define VTKM_DEVICE_ADAPTER_SERIAL     1
+
+#ifndef VTKM_DEVICE_ADAPTER
+#define VTKM_DEVICE_ADAPTER VTKM_DEVICE_ADAPTER_SERIAL
+#endif // VTKM_DEVICE_ADAPTER
+
+namespace vtkm {
+namespace cont {
+namespace internal {
+
+typedef std::string DeviceAdapterId;
+
+template<typename DeviceAdapter>
+struct DeviceAdapterTraits;
+
+template<typename DeviceAdapter>
+struct DeviceAdapterTagCheck
+{
+  static const bool Valid = false;
+};
+
+}
+}
+}
+
+/// Creates a tag named vtkm::cont::DeviceAdapterTagName and associated MPL
+/// structures to use this tag. Always use this macro (in the base namespace)
+/// when creating a device adapter.
+#define VTKM_CREATE_DEVICE_ADAPTER(Name) \
+  namespace vtkm { \
+  namespace cont { \
+  struct DeviceAdapterTag##Name {  }; \
+  namespace internal { \
+  template<> \
+  struct DeviceAdapterTraits<vtkm::cont::DeviceAdapterTag##Name> { \
+    static DeviceAdapterId GetId() { \
+      return DeviceAdapterId(#Name); \
+    } \
+  }; \
+  template<> \
+  struct DeviceAdapterTagCheck<vtkm::cont::DeviceAdapterTag##Name> { \
+    static const bool Valid = true; \
+  }; \
+  } \
+  } \
+  }
+
+/// Checks that the argument is a proper device adapter tag. This is a handy
+/// concept check for functions and classes to make sure that a template
+/// argument is actually a device adapter tag. (You can get weird errors
+/// elsewhere in the code when a mistake is made.)
+#define VTKM_IS_DEVICE_ADAPTER_TAG(tag) \
+  BOOST_STATIC_ASSERT_MSG( \
+      ::vtkm::cont::internal::DeviceAdapterTagCheck<tag>::Valid, \
+      "Provided type is not a valid VTKm device adapter tag.")
+
+//-----------------------------------------------------------------------------
+#if VTKM_DEVICE_ADAPTER == VTKM_DEVICE_ADAPTER_SERIAL
+
+#include <vtkm/cont/internal/DeviceAdapterTagSerial.h>
+#define VTKM_DEFAULT_DEVICE_ADAPTER_TAG ::vtkm::cont::DeviceAdapterTagSerial
+
+#elif (VTKM_DEVICE_ADAPTER == VTKM_DEVICE_ADAPTER_UNDEFINED) || !defined(VTKM_DEVICE_ADAPTER)
+
+#ifndef VTKM_DEFAULT_DEVICE_ADAPTER_TAG
+#warning If device adapter is undefined, VTKM_DEFAULT_DEVICE_ADAPTER_TAG must be defined.
+#endif
+
+#else
+
+#warning Unrecognized device adapter given.
+
+#endif
+
+
+#endif //vtkm_cont_internal_DeviceAdapterTag_h

vtkm/cont/internal/DeviceAdapterTagSerial.h

@@ -0,0 +1,27 @@
+//============================================================================
+//  Copyright (c) Kitware, Inc.
+//  All rights reserved.
+//  See LICENSE.txt for details.
+//  This software is distributed WITHOUT ANY WARRANTY; without even
+//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+//  PURPOSE.  See the above copyright notice for more information.
+//
+//  Copyright 2014 Sandia Corporation.
+//  Copyright 2014 UT-Battelle, LLC.
+//  Copyright 2014. Los Alamos National Security
+//
+//  Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//  the U.S. Government retains certain rights in this software.
+//
+//  Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
+//  Laboratory (LANL), the U.S. Government retains certain rights in
+//  this software.
+//============================================================================
+#ifndef vtkm_cont_internal_DeviceAdapterTagSerial_h
+#define vtkm_cont_internal_DeviceAdapterTagSerial_h
+
+#include <vtkm/cont/internal/DeviceAdapterTag.h>
+
+VTKM_CREATE_DEVICE_ADAPTER(Serial);
+
+#endif //vtkm_cont_internal_DeviceAdapterTagSerial_h

vtkm/cont/internal/IteratorFromArrayPortal.h

@@ -0,0 +1,187 @@
+//============================================================================
+//  Copyright (c) Kitware, Inc.
+//  All rights reserved.
+//  See LICENSE.txt for details.
+//  This software is distributed WITHOUT ANY WARRANTY; without even
+//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+//  PURPOSE.  See the above copyright notice for more information.
+//
+//  Copyright 2014 Sandia Corporation.
+//  Copyright 2014 UT-Battelle, LLC.
+//  Copyright 2014. Los Alamos National Security
+//
+//  Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//  the U.S. Government retains certain rights in this software.
+//
+//  Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
+//  Laboratory (LANL), the U.S. Government retains certain rights in
+//  this software.
+//============================================================================
+#ifndef vtkm_cont_internal_IteratorFromArrayPortal_h
+#define vtkm_cont_internal_IteratorFromArrayPortal_h
+
+#include <vtkm/cont/ArrayPortal.h>
+
+#include <vtkm/cont/Assert.h>
+
+#include <boost/iterator/iterator_facade.hpp>
+
+namespace vtkm {
+namespace cont {
+namespace internal {
+namespace detail {
+
+template<class ArrayPortalType>
+struct IteratorFromArrayPortalValue {
+  typedef typename ArrayPortalType::ValueType ValueType;
+
+  VTKM_CONT_EXPORT
+  IteratorFromArrayPortalValue(const ArrayPortalType &portal, vtkm::Id index)
+    : Portal(portal), Index(index) {  }
+
+  VTKM_CONT_EXPORT
+  void Swap( IteratorFromArrayPortalValue<ArrayPortalType> &rhs ) throw()
+  {
+    //we need use the explicit type not a proxy temp object
+    //A proxy temp object would point to the same underlying data structure
+    //and would not hold the old value of *this once *this was set to rhs.
+    const ValueType aValue = *this;
+    *this = rhs;
+    rhs = aValue;
+  }
+
+  VTKM_CONT_EXPORT
+  IteratorFromArrayPortalValue<ArrayPortalType> &operator=(
+      const IteratorFromArrayPortalValue<ArrayPortalType> &rhs)
+  {
+    this->Portal.Set(this->Index, rhs.Portal.Get(rhs.Index));
+    return *this;
+  }
+
+  VTKM_CONT_EXPORT
+  ValueType operator=(ValueType value) {
+    this->Portal.Set(this->Index, value);
+    return value;
+  }
+
+  VTKM_CONT_EXPORT
+  operator ValueType(void) const {
+    return this->Portal.Get(this->Index);
+  }
+
+  const ArrayPortalType& Portal;
+  vtkm::Id Index;
+};
+
+} // namespace detail
+
+template<class ArrayPortalType>
+class IteratorFromArrayPortal : public
+    boost::iterator_facade<
+      IteratorFromArrayPortal<ArrayPortalType>,
+      typename ArrayPortalType::ValueType,
+      boost::random_access_traversal_tag,
+      detail::IteratorFromArrayPortalValue<ArrayPortalType>,
+      vtkm::Id>
+{
+public:
+  IteratorFromArrayPortal()
+    : Portal(), Index(0) { }
+
+  explicit IteratorFromArrayPortal(const ArrayPortalType &portal,
+                                   vtkm::Id index = 0)
+    : Portal(portal), Index(index) {  }
+
+  VTKM_CONT_EXPORT
+  detail::IteratorFromArrayPortalValue<ArrayPortalType>
+  operator[](int idx) const
+  {
+  return detail::IteratorFromArrayPortalValue<ArrayPortalType>(this->Portal,
+                                                               idx);
+  }
+
+private:
+  ArrayPortalType Portal;
+  vtkm::Id Index;
+
+  // Implementation for boost iterator_facade
+  friend class boost::iterator_core_access;
+
+  VTKM_CONT_EXPORT
+  detail::IteratorFromArrayPortalValue<ArrayPortalType> dereference() const {
+    return detail::IteratorFromArrayPortalValue<ArrayPortalType>(this->Portal,
+                                                                 this->Index);
+  }
+
+  VTKM_CONT_EXPORT
+  bool equal(const IteratorFromArrayPortal<ArrayPortalType> &other) const {
+    // Technically, we should probably check that the portals are the same,
+    // but the portal interface does not specify an equal operator.  It is
+    // by its nature undefined what happens when comparing iterators from
+    // different portals anyway.
+    return (this->Index == other.Index);
+  }
+
+  VTKM_CONT_EXPORT
+  void increment() {
+    this->Index++;
+    VTKM_ASSERT_CONT(this->Index >= 0);
+    VTKM_ASSERT_CONT(this->Index <= this->Portal.GetNumberOfValues());
+  }
+
+  VTKM_CONT_EXPORT
+  void decrement() {
+    this->Index--;
+    VTKM_ASSERT_CONT(this->Index >= 0);
+    VTKM_ASSERT_CONT(this->Index <= this->Portal.GetNumberOfValues());
+  }
+
+  VTKM_CONT_EXPORT
+  void advance(vtkm::Id delta) {
+    this->Index += delta;
+    VTKM_ASSERT_CONT(this->Index >= 0);
+    VTKM_ASSERT_CONT(this->Index <= this->Portal.GetNumberOfValues());
+  }
+
+  VTKM_CONT_EXPORT
+  vtkm::Id
+  distance_to(const IteratorFromArrayPortal<ArrayPortalType> &other) const {
+    // Technically, we should probably check that the portals are the same,
+    // but the portal interface does not specify an equal operator.  It is
+    // by its nature undefined what happens when comparing iterators from
+    // different portals anyway.
+    return other.Index - this->Index;
+  }
+};
+
+template<class ArrayPortalType>
+IteratorFromArrayPortal<ArrayPortalType> make_IteratorBegin(
+    const ArrayPortalType &portal)
+{
+  return IteratorFromArrayPortal<ArrayPortalType>(portal, 0);
+}
+
+template<class ArrayPortalType>
+IteratorFromArrayPortal<ArrayPortalType> make_IteratorEnd(
+    const ArrayPortalType &portal)
+{
+  return IteratorFromArrayPortal<ArrayPortalType>(portal,
+                                                  portal.GetNumberOfValues());
+}
+
+
+//implementat a custom swap function, since the std::swap won't work
+//since we return RValues instead of Lvalues
+template<typename T>
+  void swap( vtkm::cont::internal::detail::IteratorFromArrayPortalValue<T> a,
+             vtkm::cont::internal::detail::IteratorFromArrayPortalValue<T> b)
+  {
+    a.Swap(b);
+  }
+
+
+}
+}
+} // namespace vtkm::cont::internal
+
+#endif //vtkm_cont_internal_IteratorFromArrayPortal_h

vtkm/cont/internal/testing/CMakeLists.txt

@@ -0,0 +1,27 @@
+##============================================================================
+##  Copyright (c) Kitware, Inc.
+##  All rights reserved.
+##  See LICENSE.txt for details.
+##  This software is distributed WITHOUT ANY WARRANTY; without even
+##  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+##  PURPOSE.  See the above copyright notice for more information.
+##
+##  Copyright 2014 Sandia Corporation.
+##  Copyright 2014 UT-Battelle, LLC.
+##  Copyright 2014. Los Alamos National Security
+##
+##  Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+##  the U.S. Government retains certain rights in this software.
+##
+##  Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
+##  Laboratory (LANL), the U.S. Government retains certain rights in
+##  this software.
+##============================================================================
+
+
+set(unit_tests
+  UnitTestArrayManagerExecutionShareWithControl.cxx
+  UnitTestArrayPortalFromIterators.cxx
+  # UnitTestIteratorFromArrayPortal.cxx
+  )
+vtkm_unit_tests(SOURCES ${unit_tests})

vtkm/cont/internal/testing/UnitTestArrayManagerExecutionShareWithControl.cxx

@@ -0,0 +1,177 @@
+//============================================================================
+//  Copyright (c) Kitware, Inc.
+//  All rights reserved.
+//  See LICENSE.txt for details.
+//  This software is distributed WITHOUT ANY WARRANTY; without even
+//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+//  PURPOSE.  See the above copyright notice for more information.
+//
+//  Copyright 2014 Sandia Corporation.
+//  Copyright 2014 UT-Battelle, LLC.
+//  Copyright 2014. Los Alamos National Security
+//
+//  Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//  the U.S. Government retains certain rights in this software.
+//
+//  Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
+//  Laboratory (LANL), the U.S. Government retains certain rights in
+//  this software.
+//============================================================================
+
+#include <vtkm/cont/internal/ArrayManagerExecutionShareWithControl.h>
+
+#include <vtkm/cont/ArrayContainerControlBasic.h>
+#include <vtkm/cont/testing/Testing.h>
+
+#include <algorithm>
+#include <vector>
+
+namespace {
+
+const vtkm::Id ARRAY_SIZE = 10;
+
+template <typename T>
+struct TemplatedTests
+{
+  typedef vtkm::cont::internal::ArrayManagerExecutionShareWithControl
+      <T, vtkm::cont::ArrayContainerControlTagBasic>
+      ArrayManagerType;
+  typedef typename ArrayManagerType::ValueType ValueType;
+  typedef vtkm::cont::internal::ArrayContainerControl<
+      T, vtkm::cont::ArrayContainerControlTagBasic> ArrayContainerType;
+
+  void SetContainer(ArrayContainerType &array, ValueType value)
+  {
+    std::fill(array.GetPortal().GetIteratorBegin(),
+              array.GetPortal().GetIteratorEnd(),
+              value);
+  }
+
+  template <class IteratorType>
+  bool CheckArray(IteratorType begin, IteratorType end, ValueType value)
+  {
+    for (IteratorType iter = begin; iter != end; iter++)
+      {
+      if (!test_equal(*iter, value)) return false;
+      }
+    return true;
+  }
+
+  bool CheckContainer(ArrayContainerType &array, ValueType value)
+  {
+    return CheckArray(array.GetPortalConst().GetIteratorBegin(),
+                      array.GetPortalConst().GetIteratorEnd(),
+                      value);
+  }
+
+  void InputData()
+  {
+    const ValueType INPUT_VALUE(4145);
+
+    ArrayContainerType controlArray;
+    controlArray.Allocate(ARRAY_SIZE);
+    SetContainer(controlArray, INPUT_VALUE);
+
+    ArrayManagerType executionArray;
+    executionArray.LoadDataForInput(controlArray.GetPortalConst());
+
+    // Although the ArrayManagerExecutionShareWithControl class wraps the
+    // control array portal in a different array portal, it should still
+    // give the same iterator (to avoid any unnecessary indirection).
+    VTKM_TEST_ASSERT(
+          controlArray.GetPortalConst().GetIteratorBegin() ==
+          executionArray.GetPortalConst().GetIteratorBegin(),
+          "Execution array manager not holding control array iterators.");
+
+    std::vector<ValueType> copyBack(ARRAY_SIZE);
+    executionArray.CopyInto(copyBack.begin());
+
+    VTKM_TEST_ASSERT(CheckArray(copyBack.begin(), copyBack.end(), INPUT_VALUE),
+                    "Did not get correct array back.");
+  }
+
+  void InPlaceData()
+  {
+    const ValueType INPUT_VALUE(2350);
+
+    ArrayContainerType controlArray;
+    controlArray.Allocate(ARRAY_SIZE);
+    SetContainer(controlArray, INPUT_VALUE);
+
+    ArrayManagerType executionArray;
+    executionArray.LoadDataForInPlace(controlArray.GetPortal());
+
+    // Although the ArrayManagerExecutionShareWithControl class wraps the
+    // control array portal in a different array portal, it should still
+    // give the same iterator (to avoid any unnecessary indirection).
+    VTKM_TEST_ASSERT(
+          controlArray.GetPortal().GetIteratorBegin() ==
+          executionArray.GetPortal().GetIteratorBegin(),
+          "Execution array manager not holding control array iterators.");
+    VTKM_TEST_ASSERT(
+          controlArray.GetPortalConst().GetIteratorBegin() ==
+          executionArray.GetPortalConst().GetIteratorBegin(),
+          "Execution array manager not holding control array iterators.");
+
+    std::vector<ValueType> copyBack(ARRAY_SIZE);
+    executionArray.CopyInto(copyBack.begin());
+
+    VTKM_TEST_ASSERT(CheckArray(copyBack.begin(), copyBack.end(), INPUT_VALUE),
+                    "Did not get correct array back.");
+  }
+
+  void OutputData()
+  {
+    const ValueType OUTPUT_VALUE(6712);
+
+    ArrayContainerType controlArray;
+
+    ArrayManagerType executionArray;
+    executionArray.AllocateArrayForOutput(controlArray, ARRAY_SIZE);
+
+    std::fill(executionArray.GetPortal().GetIteratorBegin(),
+              executionArray.GetPortal().GetIteratorEnd(),
+              OUTPUT_VALUE);
+
+    std::vector<ValueType> copyBack(ARRAY_SIZE);
+    executionArray.CopyInto(copyBack.begin());
+
+    VTKM_TEST_ASSERT(CheckArray(copyBack.begin(), copyBack.end(), OUTPUT_VALUE),
+                    "Did not get correct array back.");
+
+    executionArray.RetrieveOutputData(controlArray);
+
+    VTKM_TEST_ASSERT(CheckContainer(controlArray, OUTPUT_VALUE),
+                    "Did not get the right value in the control container.");
+  }
+
+  void operator()() {
+
+    InputData();
+    InPlaceData();
+    OutputData();
+
+  }
+};
+
+struct TestFunctor
+{
+  template <typename T>
+  void operator()(T)
+  {
+    TemplatedTests<T> tests;
+    tests();
+  }
+};
+
+void TestArrayManagerShare()
+{
+  vtkm::testing::Testing::TryAllTypes(TestFunctor());
+}
+
+} // Anonymous namespace
+
+int UnitTestArrayManagerExecutionShareWithControl(int, char *[])
+{
+  return vtkm::cont::testing::Testing::Run(TestArrayManagerShare);
+}

vtkm/cont/internal/testing/UnitTestArrayPortalFromIterators.cxx

@@ -0,0 +1,135 @@
+//============================================================================
+//  Copyright (c) Kitware, Inc.
+//  All rights reserved.
+//  See LICENSE.txt for details.
+//  This software is distributed WITHOUT ANY WARRANTY; without even
+//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+//  PURPOSE.  See the above copyright notice for more information.
+//
+//  Copyright 2014 Sandia Corporation.
+//  Copyright 2014 UT-Battelle, LLC.
+//  Copyright 2014. Los Alamos National Security
+//
+//  Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//  the U.S. Government retains certain rights in this software.
+//
+//  Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
+//  Laboratory (LANL), the U.S. Government retains certain rights in
+//  this software.
+//============================================================================
+
+#include <vtkm/cont/internal/ArrayPortalFromIterators.h>
+
+#include <vtkm/cont/testing/Testing.h>
+#include <vtkm/VectorTraits.h>
+
+namespace {
+
+template<typename T>
+struct TemplatedTests
+{
+  static const vtkm::Id ARRAY_SIZE = 10;
+
+  typedef T ValueType;
+  typedef typename vtkm::VectorTraits<ValueType>::ComponentType ComponentType;
+
+  ValueType ExpectedValue(vtkm::Id index, ComponentType value) {
+    return ValueType(index + value);
+  }
+
+  template<class IteratorType>
+  void FillIterator(IteratorType begin, IteratorType end, ComponentType value) {
+    vtkm::Id index = 0;
+    for (IteratorType iter = begin; iter != end; iter++)
+      {
+      *iter = ExpectedValue(index, value);
+      index++;
+      }
+  }
+
+  template<class IteratorType>
+  bool CheckIterator(IteratorType begin,
+                     IteratorType end,
+                     ComponentType value) {
+    vtkm::Id index = 0;
+    for (IteratorType iter = begin; iter != end; iter++)
+      {
+      if (*iter != ExpectedValue(index, value)) return false;
+      index++;
+      }
+    return true;
+  }
+
+  void operator()()
+  {
+    ValueType array[ARRAY_SIZE];
+
+    static const ComponentType ORIGINAL_VALUE = 239;
+    FillIterator(array, array+ARRAY_SIZE, ORIGINAL_VALUE);
+
+    ::vtkm::cont::internal::ArrayPortalFromIterators<ValueType *>
+        portal(array, array+ARRAY_SIZE);
+    ::vtkm::cont::internal::ArrayPortalFromIterators<const ValueType *>
+        const_portal(array, array+ARRAY_SIZE);
+
+    VTKM_TEST_ASSERT(portal.GetNumberOfValues() == ARRAY_SIZE,
+                    "Portal array size wrong.");
+    VTKM_TEST_ASSERT(const_portal.GetNumberOfValues() == ARRAY_SIZE,
+                    "Const portal array size wrong.");
+
+    std::cout << "  Check inital value." << std::endl;
+    VTKM_TEST_ASSERT(CheckIterator(portal.GetIteratorBegin(),
+                                  portal.GetIteratorEnd(),
+                                  ORIGINAL_VALUE),
+                    "Portal iterator has bad value.");
+    VTKM_TEST_ASSERT(CheckIterator(const_portal.GetIteratorBegin(),
+                                  const_portal.GetIteratorEnd(),
+                                  ORIGINAL_VALUE),
+                    "Const portal iterator has bad value.");
+
+    static const ComponentType SET_VALUE = 562;
+
+    std::cout << "  Check get/set methods." << std::endl;
+    for (vtkm::Id index = 0; index < ARRAY_SIZE; index++)
+      {
+      VTKM_TEST_ASSERT(portal.Get(index)
+                      == ExpectedValue(index, ORIGINAL_VALUE),
+                      "Bad portal value.");
+      VTKM_TEST_ASSERT(const_portal.Get(index)
+                      == ExpectedValue(index, ORIGINAL_VALUE),
+                      "Bad const portal value.");
+
+      portal.Set(index, ExpectedValue(index, SET_VALUE));
+      }
+
+    std::cout << "  Make sure set has correct value." << std::endl;
+    VTKM_TEST_ASSERT(CheckIterator(portal.GetIteratorBegin(),
+                                  portal.GetIteratorEnd(),
+                                  SET_VALUE),
+                    "Portal iterator has bad value.");
+    VTKM_TEST_ASSERT(CheckIterator(array, array+ARRAY_SIZE, SET_VALUE),
+                    "Array has bad value.");
+  }
+};
+
+struct TestFunctor
+{
+  template<typename T>
+  void operator()(T)
+  {
+    TemplatedTests<T> tests;
+    tests();
+  }
+};
+
+void TestArrayPortalFromIterators()
+{
+  vtkm::testing::Testing::TryAllTypes(TestFunctor());
+}
+
+} // Anonymous namespace
+
+int UnitTestArrayPortalFromIterators(int, char *[])
+{
+  return vtkm::cont::testing::Testing::Run(TestArrayPortalFromIterators);
+}

vtkm/cont/internal/testing/UnitTestIteratorFromArrayPortal.cxx

@@ -0,0 +1,162 @@
+//============================================================================
+//  Copyright (c) Kitware, Inc.
+//  All rights reserved.
+//  See LICENSE.txt for details.
+//  This software is distributed WITHOUT ANY WARRANTY; without even
+//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+//  PURPOSE.  See the above copyright notice for more information.
+//
+//  Copyright 2014 Sandia Corporation.
+//  Copyright 2014 UT-Battelle, LLC.
+//  Copyright 2014. Los Alamos National Security
+//
+//  Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//  the U.S. Government retains certain rights in this software.
+//
+//  Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
+//  Laboratory (LANL), the U.S. Government retains certain rights in
+//  this software.
+//============================================================================
+
+#include <vtkm/cont/internal/IteratorFromArrayPortal.h>
+
+#include <vtkm/VectorTraits.h>
+#include <vtkm/cont/internal/ArrayPortalFromIterators.h>
+
+#include <vtkm/cont/testing/Testing.h>
+
+namespace {
+
+template<typename T>
+struct TemplatedTests
+{
+  static const vtkm::Id ARRAY_SIZE = 10;
+
+  typedef T ValueType;
+  typedef typename vtkm::VectorTraits<ValueType>::ComponentType ComponentType;
+
+  ValueType ExpectedValue(vtkm::Id index, ComponentType value) {
+    return ValueType(index + value);
+  }
+
+  template<class IteratorType>
+  void FillIterator(IteratorType begin, IteratorType end, ComponentType value) {
+    vtkm::Id index = 0;
+    for (IteratorType iter = begin; iter != end; iter++)
+      {
+      *iter = ExpectedValue(index, value);
+      index++;
+      }
+  }
+
+  template<class IteratorType>
+  bool CheckIterator(IteratorType begin,
+                     IteratorType end,
+                     ComponentType value) {
+    vtkm::Id index = 0;
+    for (IteratorType iter = begin; iter != end; iter++)
+      {
+      if (ValueType(*iter) != ExpectedValue(index, value)) return false;
+      index++;
+      }
+    return true;
+  }
+
+  ComponentType ORIGINAL_VALUE() { return 239; }
+
+  template<class ArrayPortalType>
+  void TestIteratorRead(ArrayPortalType portal)
+  {
+    typedef vtkm::cont::internal::IteratorFromArrayPortal<ArrayPortalType> IteratorType;
+
+    IteratorType begin = vtkm::cont::internal::make_IteratorBegin(portal);
+    IteratorType end = vtkm::cont::internal::make_IteratorEnd(portal);
+    VTKM_TEST_ASSERT(std::distance(begin, end) == ARRAY_SIZE,
+                    "Distance between begin and end incorrect.");
+
+    std::cout << "    Check forward iteration." << std::endl;
+    VTKM_TEST_ASSERT(CheckIterator(begin, end, ORIGINAL_VALUE()),
+                    "Forward iteration wrong");
+
+    std::cout << "    Check backward iteration." << std::endl;
+    IteratorType middle = end;
+    for (vtkm::Id index = portal.GetNumberOfValues()-1; index >= 0; index--)
+      {
+      middle--;
+      ValueType value = *middle;
+      VTKM_TEST_ASSERT(value == ExpectedValue(index, ORIGINAL_VALUE()),
+                      "Backward iteration wrong");
+      }
+
+    std::cout << "    Check advance" << std::endl;
+    middle = begin + ARRAY_SIZE/2;
+    VTKM_TEST_ASSERT(std::distance(begin, middle) == ARRAY_SIZE/2,
+                    "Bad distance to middle.");
+    VTKM_TEST_ASSERT(
+          ValueType(*middle) == ExpectedValue(ARRAY_SIZE/2, ORIGINAL_VALUE()),
+          "Bad value at middle.");
+  }
+
+  template<class ArrayPortalType>
+  void TestIteratorWrite(ArrayPortalType portal)
+  {
+    typedef vtkm::cont::internal::IteratorFromArrayPortal<ArrayPortalType> IteratorType;
+
+    IteratorType begin = vtkm::cont::internal::make_IteratorBegin(portal);
+    IteratorType end = vtkm::cont::internal::make_IteratorEnd(portal);
+
+    static const ComponentType WRITE_VALUE = 873;
+
+    std::cout << "    Write values to iterator." << std::endl;
+    FillIterator(begin, end, WRITE_VALUE);
+
+    std::cout << "    Check values in portal." << std::endl;
+    VTKM_TEST_ASSERT(CheckIterator(portal.GetIteratorBegin(),
+                                  portal.GetIteratorEnd(),
+                                  WRITE_VALUE),
+                    "Did not get correct values when writing to iterator.");
+  }
+
+  void operator()()
+  {
+    ValueType array[ARRAY_SIZE];
+
+    FillIterator(array, array+ARRAY_SIZE, ORIGINAL_VALUE());
+
+    ::vtkm::cont::internal::ArrayPortalFromIterators<ValueType *>
+        portal(array, array+ARRAY_SIZE);
+    ::vtkm::cont::internal::ArrayPortalFromIterators<const ValueType *>
+        const_portal(array, array+ARRAY_SIZE);
+
+    std::cout << "  Test read from iterator." << std::endl;
+    TestIteratorRead(portal);
+
+    std::cout << "  Test read from const iterator." << std::endl;
+    TestIteratorRead(const_portal);
+
+    std::cout << "  Test write to iterator." << std::endl;
+    TestIteratorWrite(portal);
+  }
+};
+
+struct TestFunctor
+{
+  template<typename T>
+  void operator()(T)
+  {
+    TemplatedTests<T> tests;
+    tests();
+  }
+};
+
+void TestArrayIteratorFromArrayPortal()
+{
+  vtkm::testing::Testing::TryAllTypes(TestFunctor());
+}
+
+} // Anonymous namespace
+
+int UnitTestIteratorFromArrayPortal(int, char *[])
+{
+  return vtkm::cont::testing::Testing::Run(TestArrayIteratorFromArrayPortal);
+}

vtkm/cont/testing/CMakeLists.txt

@@ -0,0 +1,35 @@
+##============================================================================
+##  Copyright (c) Kitware, Inc.
+##  All rights reserved.
+##  See LICENSE.txt for details.
+##  This software is distributed WITHOUT ANY WARRANTY; without even
+##  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+##  PURPOSE.  See the above copyright notice for more information.
+##
+##  Copyright 2014 Sandia Corporation.
+##  Copyright 2014 UT-Battelle, LLC.
+##  Copyright 2014. Los Alamos National Security
+##
+##  Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+##  the U.S. Government retains certain rights in this software.
+##
+##  Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
+##  Laboratory (LANL), the U.S. Government retains certain rights in
+##  this software.
+##============================================================================
+
+set(headers
+  Testing.h
+  )
+
+vtkm_declare_headers(${headers})
+
+set(unit_tests
+  UnitTestArrayContainerControlBasic.cxx
+  UnitTestArrayContainerControlImplicit.cxx
+  UnitTestArrayHandle.cxx
+  UnitTestContTesting.cxx
+  )
+
+vtkm_unit_tests(SOURCES ${unit_tests})
+

vtkm/cont/testing/Testing.h

@@ -0,0 +1,67 @@
+//============================================================================
+//  Copyright (c) Kitware, Inc.
+//  All rights reserved.
+//  See LICENSE.txt for details.
+//  This software is distributed WITHOUT ANY WARRANTY; without even
+//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+//  PURPOSE.  See the above copyright notice for more information.
+//
+//  Copyright 2014 Sandia Corporation.
+//  Copyright 2014 UT-Battelle, LLC.
+//  Copyright 2014. Los Alamos National Security
+//
+//  Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//  the U.S. Government retains certain rights in this software.
+//
+//  Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
+//  Laboratory (LANL), the U.S. Government retains certain rights in
+//  this software.
+//============================================================================
+#ifndef vtkm_cont_testing_Testing_h
+#define vtkm_cont_testing_Testing_h
+
+#include <vtkm/cont/Error.h>
+
+#include <vtkm/testing/Testing.h>
+
+namespace vtkm {
+namespace cont {
+namespace testing {
+
+struct Testing
+{
+public:
+  template<class Func>
+  static VTKM_CONT_EXPORT int Run(Func function)
+  {
+    try
+      {
+      function();
+      }
+    catch (vtkm::testing::Testing::TestFailure error)
+      {
+      std::cout << "***** Test failed @ "
+                << error.GetFile() << ":" << error.GetLine() << std::endl
+                << error.GetMessage() << std::endl;
+      return 1;
+      }
+    catch (vtkm::cont::Error error)
+      {
+      std::cout << "***** Uncaught VTKm exception thrown." << std::endl
+                << error.GetMessage() << std::endl;
+      return 1;
+      }
+    catch (...)
+      {
+      std::cout << "***** Unidentified exception thrown." << std::endl;
+      return 1;
+      }
+    return 0;
+  }
+};
+
+}
+}
+} // namespace vtkm::cont::testing
+
+#endif //vtkm_cont_internal_Testing_h

vtkm/cont/testing/UnitTestArrayContainerControlBasic.cxx

@@ -0,0 +1,168 @@
+//============================================================================
+//  Copyright (c) Kitware, Inc.
+//  All rights reserved.
+//  See LICENSE.txt for details.
+//  This software is distributed WITHOUT ANY WARRANTY; without even
+//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+//  PURPOSE.  See the above copyright notice for more information.
+//
+//  Copyright 2014 Sandia Corporation.
+//  Copyright 2014 UT-Battelle, LLC.
+//  Copyright 2014. Los Alamos National Security
+//
+//  Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//  the U.S. Government retains certain rights in this software.
+//
+//  Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
+//  Laboratory (LANL), the U.S. Government retains certain rights in
+//  this software.
+//============================================================================
+
+#define VTKM_ARRAY_CONTAINER_CONTROL VTKM_ARRAY_CONTAINER_CONTROL_ERROR
+
+#include <vtkm/cont/ArrayContainerControlBasic.h>
+
+#include <vtkm/cont/testing/Testing.h>
+#include <vtkm/VectorTraits.h>
+
+namespace
+{
+
+const vtkm::Id ARRAY_SIZE = 10;
+
+template <typename T>
+struct TemplatedTests
+{
+  typedef vtkm::cont::internal::ArrayContainerControl<
+      T, vtkm::cont::ArrayContainerControlTagBasic> ArrayContainerType;
+  typedef typename ArrayContainerType::ValueType ValueType;
+  typedef typename ArrayContainerType::PortalType PortalType;
+  typedef typename PortalType::IteratorType IteratorType;
+
+  void SetContainer(ArrayContainerType &array, ValueType value)
+  {
+    for (IteratorType iter = array.GetPortal().GetIteratorBegin();
+         iter != array.GetPortal().GetIteratorEnd();
+         iter ++)
+      {
+      *iter = value;
+      }
+  }
+
+  bool CheckContainer(ArrayContainerType &array, ValueType value)
+  {
+    for (IteratorType iter = array.GetPortal().GetIteratorBegin();
+         iter != array.GetPortal().GetIteratorEnd();
+         iter ++)
+      {
+      if (!test_equal(*iter, value)) return false;
+      }
+    return true;
+  }
+
+  typename vtkm::VectorTraits<ValueType>::ComponentType STOLEN_ARRAY_VALUE() {
+    return 4529;
+  }
+
+  /// Returned value should later be passed to StealArray2.  It is best to
+  /// put as much between the two test parts to maximize the chance of a
+  /// deallocated array being overridden (and thus detected).
+  ValueType *StealArray1()
+  {
+    ValueType *stolenArray;
+
+    ValueType stolenArrayValue = ValueType(STOLEN_ARRAY_VALUE());
+
+    ArrayContainerType stealMyArray;
+    stealMyArray.Allocate(ARRAY_SIZE);
+    SetContainer(stealMyArray, stolenArrayValue);
+
+    VTKM_TEST_ASSERT(stealMyArray.GetNumberOfValues() == ARRAY_SIZE,
+                    "Array not properly allocated.");
+    // This call steals the array and prevents deallocation.
+    stolenArray = stealMyArray.StealArray();
+    VTKM_TEST_ASSERT(stealMyArray.GetNumberOfValues() == 0,
+                    "StealArray did not let go of array.");
+
+    return stolenArray;
+  }
+  void StealArray2(ValueType *stolenArray)
+  {
+    ValueType stolenArrayValue = ValueType(STOLEN_ARRAY_VALUE());
+
+    for (vtkm::Id index = 0; index < ARRAY_SIZE; index++)
+      {
+      VTKM_TEST_ASSERT(test_equal(stolenArray[index], stolenArrayValue),
+                      "Stolen array did not retain values.");
+      }
+    delete[] stolenArray;
+  }
+
+  void BasicAllocation()
+  {
+    ArrayContainerType arrayContainer;
+    VTKM_TEST_ASSERT(arrayContainer.GetNumberOfValues() == 0,
+                    "New array container not zero sized.");
+
+    arrayContainer.Allocate(ARRAY_SIZE);
+    VTKM_TEST_ASSERT(arrayContainer.GetNumberOfValues() == ARRAY_SIZE,
+                    "Array not properly allocated.");
+
+    const ValueType BASIC_ALLOC_VALUE = ValueType(548);
+    SetContainer(arrayContainer, BASIC_ALLOC_VALUE);
+    VTKM_TEST_ASSERT(CheckContainer(arrayContainer, BASIC_ALLOC_VALUE),
+                    "Array not holding value.");
+
+    arrayContainer.Allocate(ARRAY_SIZE * 2);
+    VTKM_TEST_ASSERT(arrayContainer.GetNumberOfValues() == ARRAY_SIZE * 2,
+                    "Array not reallocated correctly.");
+
+    arrayContainer.Shrink(ARRAY_SIZE);
+    VTKM_TEST_ASSERT(arrayContainer.GetNumberOfValues() == ARRAY_SIZE,
+                    "Array Shrnk failed to resize.");
+
+    arrayContainer.ReleaseResources();
+    VTKM_TEST_ASSERT(arrayContainer.GetNumberOfValues() == 0,
+                    "Array not released correctly.");
+
+    try
+      {
+      arrayContainer.Shrink(ARRAY_SIZE);
+      VTKM_TEST_ASSERT(true==false,
+                      "Array shrink do a larger size was possible. This can't be allowed.");
+      }
+    catch(vtkm::cont::ErrorControlBadValue){}
+  }
+
+  void operator()()
+  {
+    ValueType *stolenArray = StealArray1();
+
+    BasicAllocation();
+
+    StealArray2(stolenArray);
+  }
+};
+
+struct TestFunctor
+{
+  template <typename T>
+  void operator()(T)
+  {
+    TemplatedTests<T> tests;
+    tests();
+
+  }
+};
+
+void TestArrayContainerControlBasic()
+{
+  vtkm::testing::Testing::TryAllTypes(TestFunctor());
+}
+
+} // Anonymous namespace
+
+int UnitTestArrayContainerControlBasic(int, char *[])
+{
+  return vtkm::cont::testing::Testing::Run(TestArrayContainerControlBasic);
+}

vtkm/cont/testing/UnitTestArrayContainerControlImplicit.cxx

@@ -0,0 +1,157 @@
+//============================================================================
+//  Copyright (c) Kitware, Inc.
+//  All rights reserved.
+//  See LICENSE.txt for details.
+//  This software is distributed WITHOUT ANY WARRANTY; without even
+//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+//  PURPOSE.  See the above copyright notice for more information.
+//
+//  Copyright 2014 Sandia Corporation.
+//  Copyright 2014 UT-Battelle, LLC.
+//  Copyright 2014. Los Alamos National Security
+//
+//  Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//  the U.S. Government retains certain rights in this software.
+//
+//  Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
+//  Laboratory (LANL), the U.S. Government retains certain rights in
+//  this software.
+//============================================================================
+
+#define VTKM_ARRAY_CONTAINER_CONTROL VTKM_ARRAY_CONTAINER_CONTROL_ERROR
+
+#include <vtkm/Types.h>
+#include <vtkm/cont/ArrayContainerControlImplicit.h>
+#include <vtkm/cont/ArrayHandle.h>
+#include <vtkm/cont/internal/IteratorFromArrayPortal.h>
+#include <vtkm/cont/testing/Testing.h>
+
+#include <vtkm/VectorTraits.h>
+
+namespace
+{
+
+template <typename T>
+struct TestImplicitContainer
+{
+  typedef T ValueType;
+  ValueType Temp;
+  typedef vtkm::cont::internal::IteratorFromArrayPortal<
+      TestImplicitContainer<T> > IteratorType;
+
+
+  VTKM_EXEC_CONT_EXPORT
+  TestImplicitContainer(): Temp(1) {  }
+
+  VTKM_EXEC_CONT_EXPORT
+  vtkm::Id GetNumberOfValues() const
+  {
+    return 1;
+  }
+
+  VTKM_EXEC_CONT_EXPORT
+  ValueType Get(vtkm::Id vtkmNotUsed(index)) const
+  {
+  return Temp;
+  }
+
+  VTKM_CONT_EXPORT
+  IteratorType GetIteratorBegin() const {
+    return IteratorType(*this);
+  }
+
+  VTKM_CONT_EXPORT
+  IteratorType GetIteratorEnd() const {
+    return IteratorType(*this, this->GetNumberOfValues());
+  }
+
+};
+
+const vtkm::Id ARRAY_SIZE = 1;
+
+
+template <typename T>
+struct TemplatedTests
+{
+  typedef vtkm::cont::ArrayContainerControlTagImplicit<
+      TestImplicitContainer<T> > ContainerTagType;
+  typedef vtkm::cont::internal::ArrayContainerControl<
+      T,  ContainerTagType > ArrayContainerType;
+
+  typedef typename ArrayContainerType::ValueType ValueType;
+  typedef typename ArrayContainerType::PortalType PortalType;
+  typedef typename PortalType::IteratorType IteratorType;
+
+  void BasicAllocation()
+  {
+    ArrayContainerType arrayContainer;
+
+    try{ arrayContainer.GetNumberOfValues();
+      VTKM_TEST_ASSERT(false == true,
+                      "Implicit Container GetNumberOfValues method didn't throw error.");
+      }
+    catch(vtkm::cont::ErrorControlBadValue e){}
+
+    try{ arrayContainer.Allocate(ARRAY_SIZE);
+      VTKM_TEST_ASSERT(false == true,
+                    "Implicit Container Allocate method didn't throw error.");
+      }
+    catch(vtkm::cont::ErrorControlBadValue e){}
+
+    try
+      {
+      arrayContainer.Shrink(ARRAY_SIZE);
+      VTKM_TEST_ASSERT(true==false,
+                      "Array shrink do a larger size was possible. This can't be allowed.");
+      }
+    catch(vtkm::cont::ErrorControlBadValue){}
+
+    try
+      {
+      arrayContainer.ReleaseResources();
+      VTKM_TEST_ASSERT(true==false,
+                      "Can't Release an implicit array");
+      }
+    catch(vtkm::cont::ErrorControlBadValue){}
+  }
+
+  void BasicAccess()
+    {
+    TestImplicitContainer<T> portal;
+    vtkm::cont::ArrayHandle<T,ContainerTagType> implictHandle(portal);
+    VTKM_TEST_ASSERT(implictHandle.GetNumberOfValues() == 1,
+                    "handle should have size 1");
+    VTKM_TEST_ASSERT(implictHandle.GetPortalConstControl().Get(0) == T(1),
+                    "portals first values should be 1");
+    ;
+    }
+
+  void operator()()
+  {
+    BasicAllocation();
+    BasicAccess();
+  }
+};
+
+struct TestFunctor
+{
+  template <typename T>
+  void operator()(T)
+  {
+    TemplatedTests<T> tests;
+    tests();
+
+  }
+};
+
+void TestArrayContainerControlBasic()
+{
+  vtkm::testing::Testing::TryAllTypes(TestFunctor());
+}
+
+} // Anonymous namespace
+
+int UnitTestArrayContainerControlImplicit(int, char *[])
+{
+  return vtkm::cont::testing::Testing::Run(TestArrayContainerControlBasic);
+}

vtkm/cont/testing/UnitTestArrayHandle.cxx

@@ -0,0 +1,164 @@
+//============================================================================
+//  Copyright (c) Kitware, Inc.
+//  All rights reserved.
+//  See LICENSE.txt for details.
+//  This software is distributed WITHOUT ANY WARRANTY; without even
+//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+//  PURPOSE.  See the above copyright notice for more information.
+//
+//  Copyright 2014 Sandia Corporation.
+//  Copyright 2014 UT-Battelle, LLC.
+//  Copyright 2014. Los Alamos National Security
+//
+//  Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//  the U.S. Government retains certain rights in this software.
+//
+//  Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
+//  Laboratory (LANL), the U.S. Government retains certain rights in
+//  this software.
+//============================================================================
+
+//This sets up the ArrayHandle semantics to allocate pointers and share memory
+//between control and execution.
+#define VTKM_ARRAY_CONTAINER_CONTROL VTKM_ARRAY_CONTAINER_CONTROL_BASIC
+#define VTKM_DEVICE_ADAPTER VTKM_DEVICE_ADAPTER_SERIAL
+
+#include <vtkm/cont/ArrayHandle.h>
+
+#include <vtkm/cont/testing/Testing.h>
+
+#include <algorithm>
+
+namespace
+{
+const vtkm::Id ARRAY_SIZE = 10;
+
+vtkm::Scalar TestValue(vtkm::Id index)
+{
+  return static_cast<vtkm::Scalar>(10.0*index + 0.01*(index+1));
+}
+
+template<class IteratorType>
+bool CheckValues(IteratorType begin, IteratorType end)
+{
+  vtkm::Id index = 0;
+  for (IteratorType iter = begin; iter != end; iter++)
+    {
+    if (!test_equal(*iter, TestValue(index))) return false;
+    index++;
+    }
+  return true;
+}
+
+template<typename T>
+bool CheckValues(const vtkm::cont::ArrayHandle<T> &handle)
+{
+  return CheckValues(handle.GetPortalConstControl().GetIteratorBegin(),
+                     handle.GetPortalConstControl().GetIteratorEnd());
+}
+
+void TestArrayHandle()
+{
+  std::cout << "Create array handle." << std::endl;
+  vtkm::Scalar array[ARRAY_SIZE];
+  for (vtkm::Id index = 0; index < ARRAY_SIZE; index++)
+    {
+    array[index] = TestValue(index);
+    }
+
+  vtkm::cont::ArrayHandle<vtkm::Scalar>::PortalControl arrayPortal(
+        &array[0], &array[ARRAY_SIZE]);
+
+  vtkm::cont::ArrayHandle<vtkm::Scalar>
+      arrayHandle(arrayPortal);
+
+  VTKM_TEST_ASSERT(arrayHandle.GetNumberOfValues() == ARRAY_SIZE,
+                  "ArrayHandle has wrong number of entries.");
+
+  std::cout << "Check basic array." << std::endl;
+  VTKM_TEST_ASSERT(CheckValues(arrayHandle),
+                  "Array values not set correctly.");
+
+  std::cout << "Check out execution array behavior." << std::endl;
+  {
+  vtkm::cont::ArrayHandle<vtkm::Scalar>::
+      ExecutionTypes<VTKM_DEFAULT_DEVICE_ADAPTER_TAG>::PortalConst
+      executionPortal;
+  executionPortal =
+      arrayHandle.PrepareForInput(VTKM_DEFAULT_DEVICE_ADAPTER_TAG());
+  VTKM_TEST_ASSERT(CheckValues(executionPortal.GetIteratorBegin(),
+                              executionPortal.GetIteratorEnd()),
+                  "Array not copied to execution correctly.");
+  }
+
+  {
+  bool gotException = false;
+  try
+    {
+    arrayHandle.PrepareForInPlace(VTKM_DEFAULT_DEVICE_ADAPTER_TAG());
+    }
+  catch (vtkm::cont::Error &error)
+    {
+    std::cout << "Got expected error: " << error.GetMessage() << std::endl;
+    gotException = true;
+    }
+  VTKM_TEST_ASSERT(gotException,
+                  "PrepareForInPlace did not fail for const array.");
+  }
+
+  {
+  vtkm::cont::ArrayHandle<vtkm::Scalar>::
+      ExecutionTypes<VTKM_DEFAULT_DEVICE_ADAPTER_TAG>::Portal executionPortal;
+  executionPortal =
+      arrayHandle.PrepareForOutput(ARRAY_SIZE*2,
+                                   VTKM_DEFAULT_DEVICE_ADAPTER_TAG());
+  vtkm::Id index = 0;
+  for (vtkm::Scalar *iter = executionPortal.GetIteratorBegin();
+       iter != executionPortal.GetIteratorEnd();
+       iter++)
+    {
+    *iter = TestValue(index);
+    index++;
+    }
+  }
+  VTKM_TEST_ASSERT(arrayHandle.GetNumberOfValues() == ARRAY_SIZE*2,
+                  "Array not allocated correctly.");
+  VTKM_TEST_ASSERT(CheckValues(arrayHandle),
+                  "Array values not retrieved from execution.");
+
+  std::cout << "Try shrinking the array." << std::endl;
+  arrayHandle.Shrink(ARRAY_SIZE);
+  VTKM_TEST_ASSERT(arrayHandle.GetNumberOfValues() == ARRAY_SIZE,
+                  "Array size did not shrink correctly.");
+  VTKM_TEST_ASSERT(CheckValues(arrayHandle),
+                  "Array values not retrieved from execution.");
+
+  std::cout << "Try in place operation." << std::endl;
+  {
+  vtkm::cont::ArrayHandle<vtkm::Scalar>::
+      ExecutionTypes<VTKM_DEFAULT_DEVICE_ADAPTER_TAG>::Portal executionPortal;
+  executionPortal =
+      arrayHandle.PrepareForInPlace(VTKM_DEFAULT_DEVICE_ADAPTER_TAG());
+  for (vtkm::Scalar *iter = executionPortal.GetIteratorBegin();
+       iter != executionPortal.GetIteratorEnd();
+       iter++)
+    {
+    *iter += 1;
+    }
+  }
+  vtkm::cont::ArrayHandle<vtkm::Scalar>::PortalConstControl controlPortal =
+      arrayHandle.GetPortalConstControl();
+  for (vtkm::Id index = 0; index < ARRAY_SIZE; index++)
+    {
+    VTKM_TEST_ASSERT(test_equal(controlPortal.Get(index), TestValue(index) + 1),
+                    "Did not get result from in place operation.");
+    }
+}
+
+}
+
+
+int UnitTestArrayHandle(int, char *[])
+{
+  return vtkm::cont::testing::Testing::Run(TestArrayHandle);
+}

vtkm/cont/testing/UnitTestContTesting.cxx

@@ -0,0 +1,85 @@
+//============================================================================
+//  Copyright (c) Kitware, Inc.
+//  All rights reserved.
+//  See LICENSE.txt for details.
+//  This software is distributed WITHOUT ANY WARRANTY; without even
+//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+//  PURPOSE.  See the above copyright notice for more information.
+//
+//  Copyright 2014 Sandia Corporation.
+//  Copyright 2014 UT-Battelle, LLC.
+//  Copyright 2014. Los Alamos National Security
+//
+//  Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//  the U.S. Government retains certain rights in this software.
+//
+//  Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
+//  Laboratory (LANL), the U.S. Government retains certain rights in
+//  this software.
+//============================================================================
+
+// This meta-test makes sure that the testing environment is properly reporting
+// errors.
+
+#include <vtkm/cont/Assert.h>
+
+#include <vtkm/cont/testing/Testing.h>
+
+namespace {
+
+void TestFail()
+{
+  VTKM_TEST_FAIL("I expect this error.");
+}
+
+void BadTestAssert()
+{
+  VTKM_TEST_ASSERT(0 == 1, "I expect this error.");
+}
+
+void BadAssert()
+{
+  VTKM_ASSERT_CONT(0 == 1);
+}
+
+void GoodAssert()
+{
+  VTKM_TEST_ASSERT(1 == 1, "Always true.");
+  VTKM_ASSERT_CONT(1 == 1);
+}
+
+} // anonymous namespace
+
+int UnitTestContTesting(int, char *[])
+{
+  std::cout << "-------\nThis call should fail." << std::endl;
+  if (vtkm::cont::testing::Testing::Run(TestFail) == 0)
+    {
+    std::cout << "Did not get expected fail!" << std::endl;
+    return 1;
+    }
+  std::cout << "-------\nThis call should fail." << std::endl;
+  if (vtkm::cont::testing::Testing::Run(BadTestAssert) == 0)
+    {
+    std::cout << "Did not get expected fail!" << std::endl;
+    return 1;
+    }
+
+//VTKM_ASSERT_CONT only is a valid call when you are building with debug
+#ifndef NDEBUG
+  int expectedResult=0;
+#else
+  int expectedResult=1;
+#endif
+
+  std::cout << "-------\nThis call should fail on debug builds." << std::endl;
+  if (vtkm::cont::testing::Testing::Run(BadAssert) == expectedResult)
+    {
+    std::cout << "Did not get expected fail!" << std::endl;
+    return 1;
+    }
+
+  std::cout << "-------\nThis call should pass." << std::endl;
+  // This is what your main function typically looks like.
+  return vtkm::cont::testing::Testing::Run(GoodAssert);
+}

vtkm/internal/CMakeLists.txt

@@ -0,0 +1,30 @@
+##============================================================================
+##  Copyright (c) Kitware, Inc.
+##  All rights reserved.
+##  See LICENSE.txt for details.
+##  This software is distributed WITHOUT ANY WARRANTY; without even
+##  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+##  PURPOSE.  See the above copyright notice for more information.
+##
+##  Copyright 2014 Sandia Corporation.
+##  Copyright 2014 UT-Battelle, LLC.
+##  Copyright 2014. Los Alamos National Security
+##
+##  Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+##  the U.S. Government retains certain rights in this software.
+##
+##  Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
+##  Laboratory (LANL), the U.S. Government retains certain rights in
+##  this software.
+##============================================================================
+
+set(headers
+  ConfigureFor32.h
+  ConfigureFor64.h
+  ExportMacros.h
+  )
+
+vtkm_declare_headers(${headers})
+
+add_subdirectory(testing)
+

vtkm/internal/Configure.h.in

@@ -0,0 +1,94 @@
+//============================================================================
+//  Copyright (c) Kitware, Inc.
+//  All rights reserved.
+//  See LICENSE.txt for details.
+//  This software is distributed WITHOUT ANY WARRANTY; without even
+//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+//  PURPOSE.  See the above copyright notice for more information.
+//
+//  Copyright 2014 Sandia Corporation.
+//  Copyright 2014 UT-Battelle, LLC.
+//  Copyright 2014. Los Alamos National Security
+//
+//  Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//  the U.S. Government retains certain rights in this software.
+//
+//  Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
+//  Laboratory (LANL), the U.S. Government retains certain rights in
+//  this software.
+//============================================================================
+#ifndef vtkm_internal_Configure_h
+#define vtkm_internal_Configure_h
+
+
+#if !defined(VTKM_USE_DOUBLE_PRECISION) && !defined(VTKM_NO_DOUBLE_PRECISION)
+#cmakedefine VTKM_USE_DOUBLE_PRECISION
+#endif
+
+#if defined(VTKM_USE_DOUBLE_PRECISION) && defined(VTKM_NO_DOUBLE_PRECISION)
+# error Both VTKM_USE_DOUBLE_PRECISION and VTKM_NO_DOUBLE_PRECISION defined.  Do not know what to do.
+#endif
+
+#if !defined(VTKM_USE_64BIT_IDS) && !defined(VTKM_NO_64BIT_IDS)
+#cmakedefine VTKM_USE_64BIT_IDS
+#endif
+
+#if defined(VTKM_USE_64BIT_IDS) && defined(VTKM_NO_64BIT_IDS)
+# error Both VTKM_USE_64BIT_IDS and VTKM_NO_64BIT_IDS defined.  Do not know what to do.
+#endif
+
+#define VTKM_SIZE_FLOAT @VTKm_SIZE_FLOAT@
+#define VTKM_SIZE_DOUBLE @VTKm_SIZE_DOUBLE@
+#define VTKM_SIZE_INT @VTKm_SIZE_INT@
+#define VTKM_SIZE_LONG @VTKm_SIZE_LONG@
+#define VTKM_SIZE_LONG_LONG @VTKm_SIZE_LONG_LONG@
+
+#ifdef VTKM_USE_DOUBLE_PRECISION
+# ifndef VTKM_SIZE_SCALAR
+#  define VTKM_SIZE_SCALAR VTKM_SIZE_DOUBLE
+# endif
+# ifndef VTKM_ALIGNMENT_TWO_SCALAR
+#  define VTKM_ALIGNMENT_TWO_SCALAR 16
+# endif
+# ifndef VTKM_ALIGNMENT_FOUR_SCALAR
+#  define VTKM_ALIGNMENT_FOUR_SCALAR 8
+# endif
+#else
+# ifndef VTKM_SIZE_SCALAR
+#  define VTKM_SIZE_SCALAR VTKM_SIZE_FLOAT
+#  define VTKM_ALIGNMENT_SCALAR VTKM_SIZE_SCALAR
+# endif
+# ifndef VTKM_ALIGNMENT_TWO_SCALAR
+#  define VTKM_ALIGNMENT_TWO_SCALAR 8
+# endif
+# ifndef VTKM_ALIGNMENT_FOUR_SCALAR
+#  define VTKM_ALIGNMENT_FOUR_SCALAR 16
+# endif
+#endif
+
+#ifdef VTKM_USE_64BIT_IDS
+# ifndef VTKM_SIZE_ID
+#  define VTKM_SIZE_ID 8
+# endif
+#else
+# ifndef VTKM_SIZE_ID
+#  define VTKM_SIZE_ID 4
+# endif
+#endif
+
+// Determine whether we will use variadic templates (a new feature in C++11).
+// Currently have VARIADIC_TEMPLATE support off.
+#cmakedefine VTKM_NO_VARIADIC_TEMPLATE
+#if !defined(VTKM_USE_VARIADIC_TEMPLATE) && !defined(VTKM_NO_VARIADIC_TEMPLATE)
+// Currently using Boost to determine support.
+# include <boost/config.hpp>
+# if defined(BOOST_HAS_VARIADIC_TMPL)
+#  define VTKM_USE_VARIADIC_TEMPLATE 1
+# endif
+#endif
+
+#if defined(VTKM_USE_VARIADIC_TEMPLATE) && defined(VTKM_NO_VARIADIC_TEMPLATE)
+# error Both VTKM_USE_VARIADIC_TEMPLATE and VTKM_NO_VARIADIC_TEMPLATE defined.  Do not know what to do.
+#endif
+
+#endif //vtkm_internal_Configure_h

vtkm/internal/ConfigureFor32.h

@@ -0,0 +1,37 @@
+//============================================================================
+//  Copyright (c) Kitware, Inc.
+//  All rights reserved.
+//  See LICENSE.txt for details.
+//  This software is distributed WITHOUT ANY WARRANTY; without even
+//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+//  PURPOSE.  See the above copyright notice for more information.
+//
+//  Copyright 2014 Sandia Corporation.
+//  Copyright 2014 UT-Battelle, LLC.
+//  Copyright 2014. Los Alamos National Security
+//
+//  Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//  the U.S. Government retains certain rights in this software.
+//
+//  Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
+//  Laboratory (LANL), the U.S. Government retains certain rights in
+//  this software.
+//============================================================================
+//This header can be used by external application that are consuming VTKm
+//to define if VTKm should be set to use 32bit data types. If you need to
+//customize more of the vtkm type system, or what Device Adapters
+//need to be included look at vtkm/internal/Configure.h for all defines that
+//you can over-ride.
+#ifdef vtkm_internal_Configure_h
+# error Incorrect header order. Include this header before any other VTKm headers.
+#endif
+
+#ifndef vtkm_internal_Configure32_h
+#define vtkm_internal_Configure32_h
+
+#define VTKM_NO_DOUBLE_PRECISION
+#define VTKM_NO_64BIT_IDS
+
+#include <vtkm/internal/Configure.h>
+
+#endif

vtkm/internal/ConfigureFor64.h

@@ -0,0 +1,37 @@
+//============================================================================
+//  Copyright (c) Kitware, Inc.
+//  All rights reserved.
+//  See LICENSE.txt for details.
+//  This software is distributed WITHOUT ANY WARRANTY; without even
+//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+//  PURPOSE.  See the above copyright notice for more information.
+//
+//  Copyright 2014 Sandia Corporation.
+//  Copyright 2014 UT-Battelle, LLC.
+//  Copyright 2014. Los Alamos National Security
+//
+//  Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//  the U.S. Government retains certain rights in this software.
+//
+//  Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
+//  Laboratory (LANL), the U.S. Government retains certain rights in
+//  this software.
+//============================================================================
+//This header can be used by external application that are consuming VTKm
+//to define if VTKm should be set to use 64bit data types. If you need to
+//customize more of the vtkm type system, or what Device Adapters
+//need to be included look at vtkm/internal/Configure.h for all defines that
+//you can over-ride.
+#ifdef vtkm_internal_Configure_h
+# error Incorrect header order. Include this header before any other VTKm headers.
+#endif
+
+#ifndef vtkm_internal_Configure32_h
+#define vtkm_internal_Configure32_h
+
+#define VTKM_USE_DOUBLE_PRECISION
+#define VTKM_USE_64BIT_IDS
+
+#include <vtkm/internal/Configure.h>
+
+#endif

vtkm/internal/ExportMacros.h

@@ -0,0 +1,78 @@
+//============================================================================
+//  Copyright (c) Kitware, Inc.
+//  All rights reserved.
+//  See LICENSE.txt for details.
+//  This software is distributed WITHOUT ANY WARRANTY; without even
+//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+//  PURPOSE.  See the above copyright notice for more information.
+//
+//  Copyright 2014 Sandia Corporation.
+//  Copyright 2014 UT-Battelle, LLC.
+//  Copyright 2014. Los Alamos National Security
+//
+//  Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//  the U.S. Government retains certain rights in this software.
+//
+//  Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
+//  Laboratory (LANL), the U.S. Government retains certain rights in
+//  this software.
+//============================================================================
+#ifndef vtkm_internal__ExportMacros_h
+#define vtkm_internal__ExportMacros_h
+
+/*!
+  * Export macros for various parts of the VTKm library.
+  */
+
+#ifdef __CUDACC__
+#define VTKM_CUDA
+#endif
+
+#ifdef _OPENMP
+#define VTKM_OPENMP
+#endif
+
+#ifdef VTKM_CUDA
+#define VTKM_EXEC_EXPORT inline __device__
+#define VTKM_EXEC_CONT_EXPORT inline __device__ __host__
+#define VTKM_EXEC_CONSTANT_EXPORT __device__ __constant__
+#else
+#define VTKM_EXEC_EXPORT inline
+#define VTKM_EXEC_CONT_EXPORT inline
+#define VTKM_EXEC_CONSTANT_EXPORT
+#endif
+
+#define VTKM_CONT_EXPORT inline
+
+/// Simple macro to identify a parameter as unused. This allows you to name a
+/// parameter that is not used. There are several instances where you might
+/// want to do this. For example, when using a parameter to overload or
+/// template a function but do not actually use the parameter. Another example
+/// is providing a specialization that does not need that parameter.
+#define vtkmNotUsed(parameter_name)
+
+
+// Check boost support under CUDA
+#ifdef VTKM_CUDA
+#if !defined(BOOST_SP_DISABLE_THREADS) && !defined(BOOST_SP_USE_SPINLOCK) && !defined(BOOST_SP_USE_PTHREADS)
+#warning -------------------------------------------------------------------
+#warning The CUDA compiler (nvcc) has trouble with some of the optimizations
+#warning boost uses for thread saftey.  To get around this, please define
+#warning one of the following macros to specify the thread handling boost
+#warning should use:
+#warning
+#warning   BOOST_SP_DISABLE_THREADS
+#warning   BOOST_SP_USE_SPINLOCK
+#warning   BOOST_SP_USE_PTHREADS
+#warning
+#warning Failure to define one of these for a CUDA build will probably cause
+#warning other annoying warnings and might even cause incorrect code.  Note
+#warning that specifying BOOST_SP_DISABLE_THREADS does not preclude using
+#warning VTKm with a threaded device (like OpenMP).  Specifying one of these
+#warning modes for boost does not effect the scheduling in VTKm.
+#warning -------------------------------------------------------------------
+
+#endif
+#endif
+
+#endif //vtkm_internal__ExportMacros_h

vtkm/internal/testing/CMakeLists.txt

@@ -0,0 +1,25 @@
+##============================================================================
+##  Copyright (c) Kitware, Inc.
+##  All rights reserved.
+##  See LICENSE.txt for details.
+##  This software is distributed WITHOUT ANY WARRANTY; without even
+##  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+##  PURPOSE.  See the above copyright notice for more information.
+##
+##  Copyright 2014 Sandia Corporation.
+##  Copyright 2014 UT-Battelle, LLC.
+##  Copyright 2014. Los Alamos National Security
+##
+##  Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+##  the U.S. Government retains certain rights in this software.
+##
+##  Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
+##  Laboratory (LANL), the U.S. Government retains certain rights in
+##  this software.
+##============================================================================
+
+set(unit_tests
+  UnitTestConfigureFor32.cxx
+  UnitTestConfigureFor64.cxx
+  )
+vtkm_unit_tests(SOURCES ${unit_tests})

vtkm/internal/testing/UnitTestConfigureFor32.cxx

@@ -0,0 +1,57 @@
+//============================================================================
+//  Copyright (c) Kitware, Inc.
+//  All rights reserved.
+//  See LICENSE.txt for details.
+//  This software is distributed WITHOUT ANY WARRANTY; without even
+//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+//  PURPOSE.  See the above copyright notice for more information.
+//
+//  Copyright 2014 Sandia Corporation.
+//  Copyright 2014 UT-Battelle, LLC.
+//  Copyright 2014. Los Alamos National Security
+//
+//  Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//  the U.S. Government retains certain rights in this software.
+//
+//  Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
+//  Laboratory (LANL), the U.S. Government retains certain rights in
+//  this software.
+//============================================================================
+
+#include <vtkm/internal/ConfigureFor32.h>
+
+#include <vtkm/Types.h>
+
+#include <vtkm/testing/Testing.h>
+
+// Size of 32 bits.
+#define EXPECTED_SIZE 4
+
+#if VTKM_SIZE_ID != EXPECTED_SIZE
+#error VTKM_SIZE_ID an unexpected size.
+#endif
+
+#if VTKM_SIZE_SCALAR != EXPECTED_SIZE
+#error VTKM_SIZE_SCALAR an unexpected size.
+#endif
+
+namespace {
+
+void TestTypeSizes()
+{
+  VTKM_TEST_ASSERT(VTKM_SIZE_ID == EXPECTED_SIZE,
+                  "VTKM_SIZE_ID an unexpected size.");
+  VTKM_TEST_ASSERT(sizeof(vtkm::Id) == EXPECTED_SIZE,
+                  "vtkm::Id an unexpected size.");
+  VTKM_TEST_ASSERT(VTKM_SIZE_SCALAR == EXPECTED_SIZE,
+                  "VTKM_SIZE_SCALAR an unexpected size.");
+  VTKM_TEST_ASSERT(sizeof(vtkm::Scalar) == EXPECTED_SIZE,
+                  "vtkm::Scalar an unexpected size.");
+}
+
+}
+
+int UnitTestConfigureFor32(int, char *[])
+{
+  return vtkm::testing::Testing::Run(TestTypeSizes);
+}

vtkm/internal/testing/UnitTestConfigureFor64.cxx

@@ -0,0 +1,57 @@
+//============================================================================
+//  Copyright (c) Kitware, Inc.
+//  All rights reserved.
+//  See LICENSE.txt for details.
+//  This software is distributed WITHOUT ANY WARRANTY; without even
+//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+//  PURPOSE.  See the above copyright notice for more information.
+//
+//  Copyright 2014 Sandia Corporation.
+//  Copyright 2014 UT-Battelle, LLC.
+//  Copyright 2014. Los Alamos National Security
+//
+//  Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//  the U.S. Government retains certain rights in this software.
+//
+//  Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
+//  Laboratory (LANL), the U.S. Government retains certain rights in
+//  this software.
+//============================================================================
+
+#include <vtkm/internal/ConfigureFor64.h>
+
+#include <vtkm/Types.h>
+
+#include <vtkm/testing/Testing.h>
+
+// Size of 64 bits.
+#define EXPECTED_SIZE 8
+
+#if VTKM_SIZE_ID != EXPECTED_SIZE
+#error VTKM_SIZE_ID an unexpected size.
+#endif
+
+#if VTKM_SIZE_SCALAR != EXPECTED_SIZE
+#error VTKM_SIZE_SCALAR an unexpected size.
+#endif
+
+namespace {
+
+void TestTypeSizes()
+{
+  VTKM_TEST_ASSERT(VTKM_SIZE_ID == EXPECTED_SIZE,
+                  "VTKM_SIZE_ID an unexpected size.");
+  VTKM_TEST_ASSERT(sizeof(vtkm::Id) == EXPECTED_SIZE,
+                  "vtkm::Id an unexpected size.");
+  VTKM_TEST_ASSERT(VTKM_SIZE_SCALAR == EXPECTED_SIZE,
+                  "VTKM_SIZE_SCALAR an unexpected size.");
+  VTKM_TEST_ASSERT(sizeof(vtkm::Scalar) == EXPECTED_SIZE,
+                  "vtkm::Scalar an unexpected size.");
+}
+
+}
+
+int UnitTestConfigureFor64(int, char *[])
+{
+  return vtkm::testing::Testing::Run(TestTypeSizes);
+}

vtkm/testing/CMakeLists.txt

@@ -0,0 +1,34 @@
+##============================================================================
+##  Copyright (c) Kitware, Inc.
+##  All rights reserved.
+##  See LICENSE.txt for details.
+##  This software is distributed WITHOUT ANY WARRANTY; without even
+##  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+##  PURPOSE.  See the above copyright notice for more information.
+##
+##  Copyright 2014 Sandia Corporation.
+##  Copyright 2014 UT-Battelle, LLC.
+##  Copyright 2014. Los Alamos National Security
+##
+##  Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+##  the U.S. Government retains certain rights in this software.
+##
+##  Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
+##  Laboratory (LANL), the U.S. Government retains certain rights in
+##  this software.
+##============================================================================
+
+set(headers
+  Testing.h
+  OptionParser.h
+  )
+
+VTKM_declare_headers(${headers})
+
+set(unit_tests
+  UnitTestTesting.cxx
+  UnitTestTypes.cxx
+  UnitTestTypeTraits.cxx
+  )
+
+VTKM_unit_tests(SOURCES ${unit_tests})

vtkm/testing/Testing.h

@@ -0,0 +1,329 @@
+//============================================================================
+//  Copyright (c) Kitware, Inc.
+//  All rights reserved.
+//  See LICENSE.txt for details.
+//  This software is distributed WITHOUT ANY WARRANTY; without even
+//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+//  PURPOSE.  See the above copyright notice for more information.
+//
+//  Copyright 2014 Sandia Corporation.
+//  Copyright 2014 UT-Battelle, LLC.
+//  Copyright 2014. Los Alamos National Security
+//
+//  Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//  the U.S. Government retains certain rights in this software.
+//
+//  Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
+//  Laboratory (LANL), the U.S. Government retains certain rights in
+//  this software.
+//============================================================================
+#ifndef vtkm_testing_Testing_h
+#define vtkm_testing_Testing_h
+
+#include <vtkm/Types.h>
+#include <vtkm/TypeTraits.h>
+#include <vtkm/VectorTraits.h>
+
+#include <iostream>
+#include <sstream>
+#include <string>
+
+#include <math.h>
+
+// Try to enforce using the correct testing version. (Those that include the
+// control environment have more possible exceptions.) This is not guaranteed
+// to work. To make it more likely, place the Testing.h include last.
+#ifdef vtkm_cont_Error_h
+#ifndef vtkm_cont_testing_Testing_h
+#error Use vtkm::cont::testing::Testing instead of vtkm::testing::Testing.
+#else
+#define VTKM_TESTING_IN_CONT
+#endif
+#endif
+
+/// \def VTKM_TEST_ASSERT(condition, message)
+///
+/// Asserts a condition for a test to pass. A passing condition is when \a
+/// condition resolves to true. If \a condition is false, then the test is
+/// aborted and failure is returned.
+
+#define VTKM_TEST_ASSERT(condition, message) \
+  ::vtkm::testing::Testing::Assert( \
+      condition, __FILE__, __LINE__, message, #condition)
+
+/// \def VTKM_TEST_FAIL(message)
+///
+/// Causes a test to fail with the given \a message.
+
+#define VTKM_TEST_FAIL(message) \
+  throw ::vtkm::testing::Testing::TestFailure(__FILE__, __LINE__, message)
+
+namespace vtkm {
+namespace testing {
+
+struct Testing
+{
+public:
+  class TestFailure
+  {
+  public:
+    VTKM_CONT_EXPORT TestFailure(const std::string &file,
+                                vtkm::Id line,
+                                const std::string &message)
+      : File(file), Line(line), Message(message) { }
+
+    VTKM_CONT_EXPORT TestFailure(const std::string &file,
+                                vtkm::Id line,
+                                const std::string &message,
+                                const std::string &condition)
+      : File(file), Line(line)
+    {
+      this->Message.append(message);
+      this->Message.append(" (");
+      this->Message.append(condition);
+      this->Message.append(")");
+    }
+
+    VTKM_CONT_EXPORT const std::string &GetFile() const { return this->File; }
+    VTKM_CONT_EXPORT vtkm::Id GetLine() const { return this->Line; }
+    VTKM_CONT_EXPORT const std::string &GetMessage() const {
+      return this->Message;
+    }
+  private:
+    std::string File;
+    vtkm::Id Line;
+    std::string Message;
+  };
+
+  static VTKM_CONT_EXPORT void Assert(bool condition,
+                                     const std::string &file,
+                                     vtkm::Id line,
+                                     const std::string &message,
+                                     const std::string &conditionString)
+  {
+    if (condition)
+      {
+      // Do nothing.
+      }
+    else
+      {
+      throw TestFailure(file, line, message, conditionString);
+      }
+  }
+
+#ifndef VTKM_TESTING_IN_CONT
+  /// Calls the test function \a function with no arguments. Catches any errors
+  /// generated by VTKM_TEST_ASSERT or VTKM_TEST_FAIL, reports the error, and
+  /// returns "1" (a failure status for a program's main). Returns "0" (a
+  /// success status for a program's main).
+  ///
+  /// The intention is to implement a test's main function with this. For
+  /// example, the implementation of UnitTestFoo might look something like
+  /// this.
+  ///
+  /// \code
+  /// #include <vtkm/testing/Testing.h>
+  ///
+  /// namespace {
+  ///
+  /// void TestFoo()
+  /// {
+  ///    // Do actual test, which checks in VTKM_TEST_ASSERT or VTKM_TEST_FAIL.
+  /// }
+  ///
+  /// } // anonymous namespace
+  ///
+  /// int UnitTestFoo(int, char *[])
+  /// {
+  ///   return vtkm::testing::Testing::Run(TestFoo);
+  /// }
+  /// \endcode
+  ///
+  template<class Func>
+  static VTKM_CONT_EXPORT int Run(Func function)
+  {
+    try
+      {
+      function();
+      }
+    catch (TestFailure error)
+      {
+      std::cout << "***** Test failed @ "
+                << error.GetFile() << ":" << error.GetLine() << std::endl
+                << error.GetMessage() << std::endl;
+      return 1;
+      }
+    catch (...)
+      {
+      std::cout << "***** Unidentified exception thrown." << std::endl;
+      return 1;
+      }
+    return 0;
+  }
+#endif
+
+  /// Check functors to be used with the TryAllTypes method.
+  ///
+  struct TypeCheckAlwaysTrue {
+    template <typename T, class Functor>
+    void operator()(T t, Functor function) const { function(t); }
+  };
+  struct TypeCheckInteger {
+    template <typename T, class Functor>
+    void operator()(T t, Functor function) const {
+      this->DoInteger(typename vtkm::TypeTraits<T>::NumericTag(), t, function);
+    }
+  private:
+    template <class Tag, typename T, class Functor>
+    void DoInteger(Tag, T, const Functor&) const {  }
+    template <typename T, class Functor>
+    void DoInteger(vtkm::TypeTraitsIntegerTag, T t, Functor function) const {
+      function(t);
+    }
+  };
+  struct TypeCheckReal {
+    template <typename T, class Functor>
+    void operator()(T t, Functor function) const {
+      this->DoReal(typename vtkm::TypeTraits<T>::NumericTag(), t, function);
+    }
+  private:
+    template <class Tag, typename T, class Functor>
+    void DoReal(Tag, T, const Functor&) const {  }
+    template <typename T, class Functor>
+    void DoReal(vtkm::TypeTraitsRealTag, T t, Functor function) const {
+      function(t);
+    }
+  };
+  struct TypeCheckScalar {
+    template <typename T, class Functor>
+    void operator()(T t, Functor func) const {
+      this->DoScalar(typename vtkm::TypeTraits<T>::DimensionalityTag(), t, func);
+    }
+  private:
+    template <class Tag, typename T, class Functor>
+    void DoScalar(Tag, const T &, const Functor &) const {  }
+    template <typename T, class Functor>
+    void DoScalar(vtkm::TypeTraitsScalarTag, T t, Functor function) const {
+      function(t);
+    }
+  };
+  struct TypeCheckVector {
+    template <typename T, class Functor>
+    void operator()(T t, Functor func) const {
+      this->DoVector(typename vtkm::TypeTraits<T>::DimensionalityTag(), t, func);
+    }
+  private:
+    template <class Tag, typename T, class Functor>
+    void DoVector(Tag, const T &, const Functor &) const {  }
+    template <typename T, class Functor>
+    void DoVector(vtkm::TypeTraitsVectorTag, T t, Functor function) const {
+      function(t);
+    }
+  };
+
+  template<class FunctionType>
+  struct InternalPrintOnInvoke {
+    InternalPrintOnInvoke(FunctionType function, std::string toprint)
+      : Function(function), ToPrint(toprint) { }
+    template <typename T> void operator()(T t) {
+      std::cout << this->ToPrint << std::endl;
+      this->Function(t);
+    }
+  private:
+    FunctionType Function;
+    std::string ToPrint;
+  };
+
+  /// Runs templated \p function on all the basic types defined in VTKm. This is
+  /// helpful to test templated functions that should work on all types. If the
+  /// function is supposed to work on some subset of types, then \p check can
+  /// be set to restrict the types used. This Testing class contains several
+  /// helpful check functors.
+  ///
+  template<class FunctionType, class CheckType>
+  static void TryAllTypes(FunctionType function, CheckType check)
+  {
+    vtkm::Id id = 0;
+    check(id, InternalPrintOnInvoke<FunctionType>(
+            function, "*** vtkm::Id ***************"));
+
+    vtkm::Id3 id3 = vtkm::make_Id3(0, 0, 0);
+    check(id3, InternalPrintOnInvoke<FunctionType>(
+            function, "*** vtkm::Id3 **************"));
+
+    vtkm::Scalar scalar = 0.0;
+    check(scalar, InternalPrintOnInvoke<FunctionType>(
+            function, "*** vtkm::Scalar ***********"));
+
+    vtkm::Vector2 vector2 = vtkm::make_Vector2(0.0, 0.0);
+    check(vector2, InternalPrintOnInvoke<FunctionType>(
+            function, "*** vtkm::Vector2 **********"));
+
+    vtkm::Vector3 vector3 = vtkm::make_Vector3(0.0, 0.0, 0.0);
+    check(vector3, InternalPrintOnInvoke<FunctionType>(
+            function, "*** vtkm::Vector3 **********"));
+
+    vtkm::Vector4 vector4 = vtkm::make_Vector4(0.0, 0.0, 0.0, 0.0);
+    check(vector4, InternalPrintOnInvoke<FunctionType>(
+            function, "*** vtkm::Vector4 **********"));
+  }
+  template<class FunctionType>
+  static void TryAllTypes(FunctionType function)
+  {
+    TryAllTypes(function, TypeCheckAlwaysTrue());
+  }
+
+};
+
+}
+} // namespace vtkm::internal
+
+/// Helper function to test two quanitites for equality accounting for slight
+/// variance due to floating point numerical inaccuracies.
+///
+template<typename VectorType>
+VTKM_EXEC_CONT_EXPORT bool test_equal(VectorType vector1,
+                                      VectorType vector2,
+                                      vtkm::Scalar tolerance = 0.0001)
+{
+  typedef typename vtkm::VectorTraits<VectorType> Traits;
+  for (int component = 0; component < Traits::NUM_COMPONENTS; component++)
+    {
+    vtkm::Scalar value1 = Traits::GetComponent(vector1, component);
+    vtkm::Scalar value2 = Traits::GetComponent(vector2, component);
+    if ((fabs(value1) < 2*tolerance) && (fabs(value2) < 2*tolerance))
+      {
+      continue;
+      }
+    vtkm::Scalar ratio = value1/value2;
+    if ((ratio > vtkm::Scalar(1.0) - tolerance)
+        && (ratio < vtkm::Scalar(1.0) + tolerance))
+      {
+      // This component is OK. The condition is checked in this way to
+      // correctly handle non-finites that fail all comparisons. Thus, if a
+      // non-finite is encountered, this condition will fail and false will be
+      // returned.
+      }
+    else
+      {
+      return false;
+      }
+    }
+  return true;
+}
+
+/// Helper function for printing out vectors during testing.
+///
+template<typename T, int Size>
+VTKM_EXEC_CONT_EXPORT
+std::ostream &operator<<(std::ostream &stream, const vtkm::Tuple<T,Size> &tuple)
+{
+  stream << "[";
+  for (int component = 0; component < Size-1; component++)
+    {
+    stream << tuple[component] << ",";
+    }
+  return stream << tuple[Size-1] << "]";
+}
+
+#endif //vtkm_testing_Testing_h

vtkm/testing/UnitTestTesting.cxx

@@ -0,0 +1,78 @@
+//============================================================================
+//  Copyright (c) Kitware, Inc.
+//  All rights reserved.
+//  See LICENSE.txt for details.
+//  This software is distributed WITHOUT ANY WARRANTY; without even
+//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+//  PURPOSE.  See the above copyright notice for more information.
+//
+//  Copyright 2014 Sandia Corporation.
+//  Copyright 2014 UT-Battelle, LLC.
+//  Copyright 2014. Los Alamos National Security
+//
+//  Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//  the U.S. Government retains certain rights in this software.
+//
+//  Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
+//  Laboratory (LANL), the U.S. Government retains certain rights in
+//  this software.
+//============================================================================
+
+// This meta-test makes sure that the testing environment is properly reporting
+// errors.
+
+#include <vtkm/testing/Testing.h>
+
+namespace {
+
+void Fail()
+{
+  VTKM_TEST_FAIL("I expect this error.");
+}
+
+void BadAssert()
+{
+  VTKM_TEST_ASSERT(0 == 1, "I expect this error.");
+}
+
+void GoodAssert()
+{
+  VTKM_TEST_ASSERT(1 == 1, "Always true.");
+}
+
+void TestTestEqual()
+{
+  VTKM_TEST_ASSERT(test_equal(vtkm::Scalar(2.0), vtkm::Scalar(1.9999999)),
+                  "These should be close enough.");
+  VTKM_TEST_ASSERT(!test_equal(vtkm::Scalar(2.0), vtkm::Scalar(1.999)),
+                  "These should not be close enough.");
+}
+
+// All tests that should not raise a failure.
+void CleanTests()
+{
+  GoodAssert();
+  TestTestEqual();
+}
+
+} // anonymous namespace
+
+int UnitTestTesting(int, char *[])
+{
+  std::cout << "This call should fail." << std::endl;
+  if (vtkm::testing::Testing::Run(Fail) == 0)
+    {
+    std::cout << "Did not get expected fail!" << std::endl;
+    return 1;
+    }
+  std::cout << "This call should fail." << std::endl;
+  if (vtkm::testing::Testing::Run(BadAssert) == 0)
+    {
+    std::cout << "Did not get expected fail!" << std::endl;
+    return 1;
+    }
+
+  std::cout << "This call should pass." << std::endl;
+  // This is what your main function typically looks like.
+  return vtkm::testing::Testing::Run(CleanTests);
+}

vtkm/testing/UnitTestTypeTraits.cxx

@@ -0,0 +1,83 @@
+//============================================================================
+//  Copyright (c) Kitware, Inc.
+//  All rights reserved.
+//  See LICENSE.txt for details.
+//  This software is distributed WITHOUT ANY WARRANTY; without even
+//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+//  PURPOSE.  See the above copyright notice for more information.
+//
+//  Copyright 2014 Sandia Corporation.
+//  Copyright 2014 UT-Battelle, LLC.
+//  Copyright 2014. Los Alamos National Security
+//
+//  Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//  the U.S. Government retains certain rights in this software.
+//
+//  Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
+//  Laboratory (LANL), the U.S. Government retains certain rights in
+//  this software.
+//============================================================================
+
+#include <vtkm/TypeTraits.h>
+
+#include <vtkm/VectorTraits.h>
+
+#include <vtkm/testing/Testing.h>
+
+namespace {
+
+struct TypeTraitTest
+{
+  template <typename T> void operator()(T t) {
+    // If you get compiler errors here, it could be a TypeTraits instance
+    // has missing or malformed tags.
+    this->TestDimensionality(t, typename vtkm::TypeTraits<T>::DimensionalityTag());
+    this->TestNumeric(t, typename vtkm::TypeTraits<T>::NumericTag());
+  }
+private:
+
+  template <typename T>
+  void TestDimensionality(T, vtkm::TypeTraitsScalarTag) {
+    std::cout << "  scalar" << std::endl;
+    VTKM_TEST_ASSERT(vtkm::VectorTraits<T>::NUM_COMPONENTS == 1,
+                    "Scalar type does not have one component.");
+  }
+  template <typename T>
+  void TestDimensionality(T, vtkm::TypeTraitsVectorTag) {
+    std::cout << "  vector" << std::endl;
+    VTKM_TEST_ASSERT(vtkm::VectorTraits<T>::NUM_COMPONENTS > 1,
+                    "Vector type does not have multiple components.");
+  }
+
+  template <typename T>
+  void TestNumeric(T, vtkm::TypeTraitsIntegerTag) {
+    std::cout << "  integer" << std::endl;
+    typedef typename vtkm::VectorTraits<T>::ComponentType VT;
+    VT value = VT(2.001);
+    VTKM_TEST_ASSERT(value == 2, "Integer does not round to integer.");
+  }
+  template <typename T>
+  void TestNumeric(T, vtkm::TypeTraitsRealTag) {
+    std::cout << "  real" << std::endl;
+    typedef typename vtkm::VectorTraits<T>::ComponentType VT;
+    VT value = VT(2.001);
+    VTKM_TEST_ASSERT(test_equal(float(value), float(2.001)),
+                    "Real does not hold floaing point number.");
+  }
+};
+
+static void TestTypeTraits()
+{
+  TypeTraitTest test;
+  vtkm::testing::Testing::TryAllTypes(test);
+  std::cout << "vtkm::Tuple<vtkm::Scalar, 5>" << std::endl;
+  test(vtkm::Tuple<vtkm::Scalar, 5>());
+}
+
+} // anonymous namespace
+
+//-----------------------------------------------------------------------------
+int UnitTestTypeTraits(int, char *[])
+{
+  return vtkm::testing::Testing::Run(TestTypeTraits);
+}

vtkm/testing/UnitTestTypes.cxx

@@ -0,0 +1,495 @@
+//============================================================================
+//  Copyright (c) Kitware, Inc.
+//  All rights reserved.
+//  See LICENSE.txt for details.
+//  This software is distributed WITHOUT ANY WARRANTY; without even
+//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+//  PURPOSE.  See the above copyright notice for more information.
+//
+//  Copyright 2014 Sandia Corporation.
+//  Copyright 2014 UT-Battelle, LLC.
+//  Copyright 2014. Los Alamos National Security
+//
+//  Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//  the U.S. Government retains certain rights in this software.
+//
+//  Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
+//  Laboratory (LANL), the U.S. Government retains certain rights in
+//  this software.
+//============================================================================
+
+//============================================================================
+//  Copyright (c) Kitware, Inc.
+//  All rights reserved.
+//  See LICENSE.txt for details.
+//  This software is distributed WITHOUT ANY WARRANTY; without even
+//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+//  PURPOSE.  See the above copyright notice for more information.
+//
+//  Copyright 2014 Sandia Corporation.
+//  Copyright 2014 UT-Battelle, LLC.
+//  Copyright 2014. Los Alamos National Security
+//
+//  Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//  the U.S. Government retains certain rights in this software.
+//
+//  Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
+//  Laboratory (LANL), the U.S. Government retains certain rights in
+//  this software.
+//============================================================================
+
+#include <vtkm/Types.h>
+
+#include <vtkm/testing/Testing.h>
+
+namespace {
+
+//general type test
+template <typename T> void TypeTest()
+{
+  //grab the number of elements of T
+  T a, b, c;
+  typename T::ComponentType s(5);
+
+  for(int i=0; i < T::NUM_COMPONENTS; ++i)
+    {
+    a[i]=typename T::ComponentType((i+1)*2);
+    b[i]=typename T::ComponentType(i+1);
+    c[i]=typename T::ComponentType((i+1)*2);
+    }
+
+  //verify prefix and postfix increment and decrement
+  ++c[T::NUM_COMPONENTS-1];
+  c[T::NUM_COMPONENTS-1]++;
+  --c[T::NUM_COMPONENTS-1];
+  c[T::NUM_COMPONENTS-1]--;
+
+  //make c nearly like a to verify == and != are correct.
+  c[T::NUM_COMPONENTS-1]=(c[T::NUM_COMPONENTS-1]-1);
+
+  T plus = a + b;
+  T correct_plus;
+  for(int i=0; i < T::NUM_COMPONENTS; ++i)
+    { correct_plus[i] = a[i] + b[i]; }
+  VTKM_TEST_ASSERT(test_equal(plus, correct_plus),"Tuples not added correctly.");
+
+  T minus = a - b;
+  T correct_minus;
+  for(int i=0; i < T::NUM_COMPONENTS; ++i)
+    { correct_minus[i] = a[i] - b[i]; }
+  VTKM_TEST_ASSERT(test_equal(minus, correct_minus),"Tuples not subtracted correctly.");
+
+
+  T mult = a * b;
+  T correct_mult;
+  for(int i=0; i < T::NUM_COMPONENTS; ++i)
+    { correct_mult[i] = a[i] * b[i]; }
+  VTKM_TEST_ASSERT(test_equal(mult, correct_mult),"Tuples not multiplied correctly.");
+
+  T div = a / b;
+  T correct_div;
+  for(int i=0; i < T::NUM_COMPONENTS; ++i)
+    { correct_div[i] = a[i] / b[i]; }
+  VTKM_TEST_ASSERT(test_equal(div,correct_div),"Tuples not divided correctly.");
+
+  mult = s * a;
+  for(int i=0; i < T::NUM_COMPONENTS; ++i)
+    { correct_mult[i] = s * a[i]; }
+  VTKM_TEST_ASSERT(test_equal(mult, correct_mult),
+                  "Scalar and Tuple did not multiply correctly.");
+
+  mult = a * s;
+  VTKM_TEST_ASSERT(test_equal(mult, correct_mult),
+                  "Tuple and Scalar to not multiply correctly.");
+
+  typename T::ComponentType d = vtkm::dot(a, b);
+  typename T::ComponentType correct_d = 0;
+  for(int i=0; i < T::NUM_COMPONENTS; ++i)
+    {correct_d += a[i] * b[i]; }
+  VTKM_TEST_ASSERT(test_equal(d, correct_d), "dot(Tuple) wrong");
+
+  VTKM_TEST_ASSERT(!(a < b), "operator< wrong");
+  VTKM_TEST_ASSERT((b < a),  "operator< wrong");
+  VTKM_TEST_ASSERT(!(a < a),  "operator< wrong");
+  VTKM_TEST_ASSERT((a < plus),  "operator< wrong");
+  VTKM_TEST_ASSERT((minus < plus),  "operator< wrong");
+  VTKM_TEST_ASSERT((c < a),  "operator< wrong");
+
+  VTKM_TEST_ASSERT(!(a == b), "operator== wrong");
+  VTKM_TEST_ASSERT((a == a),  "operator== wrong");
+
+  VTKM_TEST_ASSERT((a != b),  "operator!= wrong");
+  VTKM_TEST_ASSERT(!(a != a), "operator!= wrong");
+
+  //test against a tuple that shares some values
+  VTKM_TEST_ASSERT( !(c == a), "operator == wrong");
+  VTKM_TEST_ASSERT( !(a == c), "operator == wrong");
+
+  VTKM_TEST_ASSERT( (c != a), "operator != wrong");
+  VTKM_TEST_ASSERT( (a != c), "operator != wrong");
+}
+
+template<> void TypeTest<vtkm::Vector2>()
+{
+  vtkm::Vector2 a = vtkm::make_Vector2(2, 4);
+  vtkm::Vector2 b = vtkm::make_Vector2(1, 2);
+  vtkm::Scalar s = 5;
+
+  vtkm::Vector2 plus = a + b;
+  VTKM_TEST_ASSERT(test_equal(plus, vtkm::make_Vector2(3, 6)),
+                  "Vectors do not add correctly.");
+
+  vtkm::Vector2 minus = a - b;
+  VTKM_TEST_ASSERT(test_equal(minus, vtkm::make_Vector2(1, 2)),
+                  "Vectors to not subtract correctly.");
+
+  vtkm::Vector2 mult = a * b;
+  VTKM_TEST_ASSERT(test_equal(mult, vtkm::make_Vector2(2, 8)),
+                  "Vectors to not multiply correctly.");
+
+  vtkm::Vector2 div = a / b;
+  VTKM_TEST_ASSERT(test_equal(div, vtkm::make_Vector2(2, 2)),
+                  "Vectors to not divide correctly.");
+
+  mult = s * a;
+  VTKM_TEST_ASSERT(test_equal(mult, vtkm::make_Vector2(10, 20)),
+                  "Vector and scalar to not multiply correctly.");
+
+  mult = a * s;
+  VTKM_TEST_ASSERT(test_equal(mult, vtkm::make_Vector2(10, 20)),
+                  "Vector and scalar to not multiply correctly.");
+
+  vtkm::Scalar d = vtkm::dot(a, b);
+  VTKM_TEST_ASSERT(test_equal(d, vtkm::Scalar(10)), "dot(Vector2) wrong");
+
+  VTKM_TEST_ASSERT(!(a < b), "operator< wrong");
+  VTKM_TEST_ASSERT((b < a),  "operator< wrong");
+  VTKM_TEST_ASSERT(!(a < a),  "operator< wrong");
+  VTKM_TEST_ASSERT((a < plus),  "operator< wrong");
+  VTKM_TEST_ASSERT((minus < plus),  "operator< wrong");
+
+  VTKM_TEST_ASSERT(!(a == b), "operator== wrong");
+  VTKM_TEST_ASSERT((a == a),  "operator== wrong");
+
+  VTKM_TEST_ASSERT((a != b),  "operator!= wrong");
+  VTKM_TEST_ASSERT(!(a != a), "operator!= wrong");
+
+  //test against a tuple that shares some values
+  const vtkm::Vector2 c = vtkm::make_Vector2(2,3);
+  VTKM_TEST_ASSERT((c < a),  "operator< wrong");
+
+  VTKM_TEST_ASSERT( !(c == a), "operator == wrong");
+  VTKM_TEST_ASSERT( !(a == c), "operator == wrong");
+
+  VTKM_TEST_ASSERT( (c != a), "operator != wrong");
+  VTKM_TEST_ASSERT( (a != c), "operator != wrong");
+}
+
+template<> void TypeTest<vtkm::Vector3>()
+{
+  vtkm::Vector3 a = vtkm::make_Vector3(2, 4, 6);
+  vtkm::Vector3 b = vtkm::make_Vector3(1, 2, 3);
+  vtkm::Scalar s = 5;
+
+  vtkm::Vector3 plus = a + b;
+  VTKM_TEST_ASSERT(test_equal(plus, vtkm::make_Vector3(3, 6, 9)),
+                  "Vectors do not add correctly.");
+
+  vtkm::Vector3 minus = a - b;
+  VTKM_TEST_ASSERT(test_equal(minus, vtkm::make_Vector3(1, 2, 3)),
+                  "Vectors to not subtract correctly.");
+
+  vtkm::Vector3 mult = a * b;
+  VTKM_TEST_ASSERT(test_equal(mult, vtkm::make_Vector3(2, 8, 18)),
+                  "Vectors to not multiply correctly.");
+
+  vtkm::Vector3 div = a / b;
+  VTKM_TEST_ASSERT(test_equal(div, vtkm::make_Vector3(2, 2, 2)),
+                  "Vectors to not divide correctly.");
+
+  mult = s * a;
+  VTKM_TEST_ASSERT(test_equal(mult, vtkm::make_Vector3(10, 20, 30)),
+                  "Vector and scalar to not multiply correctly.");
+
+  mult = a * s;
+  VTKM_TEST_ASSERT(test_equal(mult, vtkm::make_Vector3(10, 20, 30)),
+                  "Vector and scalar to not multiply correctly.");
+
+  vtkm::Scalar d = vtkm::dot(a, b);
+  VTKM_TEST_ASSERT(test_equal(d, vtkm::Scalar(28)), "dot(Vector3) wrong");
+
+  VTKM_TEST_ASSERT(!(a < b), "operator< wrong");
+  VTKM_TEST_ASSERT((b < a),  "operator< wrong");
+  VTKM_TEST_ASSERT(!(a < a),  "operator< wrong");
+  VTKM_TEST_ASSERT((a < plus),  "operator< wrong");
+  VTKM_TEST_ASSERT((minus < plus),  "operator< wrong");
+
+  VTKM_TEST_ASSERT(!(a == b), "operator== wrong");
+  VTKM_TEST_ASSERT((a == a),  "operator== wrong");
+
+  VTKM_TEST_ASSERT((a != b),  "operator!= wrong");
+  VTKM_TEST_ASSERT(!(a != a), "operator!= wrong");
+
+  //test against a tuple that shares some values
+  const vtkm::Vector3 c = vtkm::make_Vector3(2,4,5);
+  VTKM_TEST_ASSERT((c < a),  "operator< wrong");
+
+  VTKM_TEST_ASSERT( !(c == a), "operator == wrong");
+  VTKM_TEST_ASSERT( !(a == c), "operator == wrong");
+
+  VTKM_TEST_ASSERT( (c != a), "operator != wrong");
+  VTKM_TEST_ASSERT( (a != c), "operator != wrong");
+}
+
+template<> void TypeTest<vtkm::Vector4>()
+{
+  vtkm::Vector4 a = vtkm::make_Vector4(2, 4, 6, 8);
+  vtkm::Vector4 b = vtkm::make_Vector4(1, 2, 3, 4);
+  vtkm::Scalar s = 5;
+
+  vtkm::Vector4 plus = a + b;
+  VTKM_TEST_ASSERT(test_equal(plus, vtkm::make_Vector4(3, 6, 9, 12)),
+                  "Vectors do not add correctly.");
+
+  vtkm::Vector4 minus = a - b;
+  VTKM_TEST_ASSERT(test_equal(minus, vtkm::make_Vector4(1, 2, 3, 4)),
+                  "Vectors to not subtract correctly.");
+
+  vtkm::Vector4 mult = a * b;
+  VTKM_TEST_ASSERT(test_equal(mult, vtkm::make_Vector4(2, 8, 18, 32)),
+                  "Vectors to not multiply correctly.");
+
+  vtkm::Vector4 div = a / b;
+  VTKM_TEST_ASSERT(test_equal(div, vtkm::make_Vector4(2, 2, 2, 2)),
+                  "Vectors to not divide correctly.");
+
+  mult = s * a;
+  VTKM_TEST_ASSERT(test_equal(mult, vtkm::make_Vector4(10, 20, 30, 40)),
+                  "Vector and scalar to not multiply correctly.");
+
+  mult = a * s;
+  VTKM_TEST_ASSERT(test_equal(mult, vtkm::make_Vector4(10, 20, 30, 40)),
+                  "Vector and scalar to not multiply correctly.");
+
+  vtkm::Scalar d = vtkm::dot(a, b);
+  VTKM_TEST_ASSERT(test_equal(d, vtkm::Scalar(60)), "dot(Vector4) wrong");
+
+
+  VTKM_TEST_ASSERT(!(a < b), "operator< wrong");
+  VTKM_TEST_ASSERT((b < a),  "operator< wrong");
+  VTKM_TEST_ASSERT(!(a < a),  "operator< wrong");
+  VTKM_TEST_ASSERT((a < plus),  "operator< wrong");
+  VTKM_TEST_ASSERT((minus < plus),  "operator< wrong");
+
+  VTKM_TEST_ASSERT(!(a == b), "operator== wrong");
+  VTKM_TEST_ASSERT((a == a),  "operator== wrong");
+
+  VTKM_TEST_ASSERT((a != b),  "operator!= wrong");
+  VTKM_TEST_ASSERT(!(a != a), "operator!= wrong");
+
+  //test against a tuple that shares some values
+  const vtkm::Vector4 c = vtkm::make_Vector4(2,4,6,7);
+  VTKM_TEST_ASSERT((c < a),  "operator< wrong");
+
+  VTKM_TEST_ASSERT( !(c == a), "operator == wrong");
+  VTKM_TEST_ASSERT( !(a == c), "operator == wrong");
+
+  VTKM_TEST_ASSERT( (c != a), "operator != wrong");
+  VTKM_TEST_ASSERT( (a != c), "operator != wrong");
+}
+
+template<> void TypeTest<vtkm::Id3>()
+{
+  vtkm::Id3 a = vtkm::make_Id3(2, 4, 6);
+  vtkm::Id3 b = vtkm::make_Id3(1, 2, 3);
+  vtkm::Id s = 5;
+
+  vtkm::Id3 plus = a + b;
+  if ((plus[0] != 3) || (plus[1] != 6) || (plus[2] != 9))
+    {
+    VTKM_TEST_FAIL("Vectors do not add correctly.");
+    }
+
+  vtkm::Id3 minus = a - b;
+  if ((minus[0] != 1) || (minus[1] != 2) || (minus[2] != 3))
+    {
+    VTKM_TEST_FAIL("Vectors to not subtract correctly.");
+    }
+
+  vtkm::Id3 mult = a * b;
+  if ((mult[0] != 2) || (mult[1] != 8) || (mult[2] != 18))
+    {
+    VTKM_TEST_FAIL("Vectors to not multiply correctly.");
+    }
+
+  vtkm::Id3 div = a / b;
+  if ((div[0] != 2) || (div[1] != 2) || (div[2] != 2))
+    {
+    VTKM_TEST_FAIL("Vectors to not divide correctly.");
+    }
+
+  mult = s * a;
+  if ((mult[0] != 10) || (mult[1] != 20) || (mult[2] != 30))
+    {
+    VTKM_TEST_FAIL("Vector and scalar to not multiply correctly.");
+    }
+
+  mult = a * s;
+  if ((mult[0] != 10) || (mult[1] != 20) || (mult[2] != 30))
+    {
+    VTKM_TEST_FAIL("Vector and scalar to not multiply correctly.");
+    }
+
+  if (vtkm::dot(a, b) != 28)
+    {
+    VTKM_TEST_FAIL("dot(Id3) wrong");
+    }
+
+  VTKM_TEST_ASSERT(!(a < b), "operator< wrong");
+  VTKM_TEST_ASSERT((b < a),  "operator< wrong");
+  VTKM_TEST_ASSERT(!(a < a),  "operator< wrong");
+  VTKM_TEST_ASSERT((a < plus),  "operator< wrong");
+  VTKM_TEST_ASSERT((minus < plus),  "operator< wrong");
+
+  if (a == b)
+    {
+    VTKM_TEST_FAIL("operator== wrong");
+    }
+  if (!(a == a))
+    {
+    VTKM_TEST_FAIL("operator== wrong");
+    }
+
+  if (!(a != b))
+    {
+    VTKM_TEST_FAIL("operator!= wrong");
+    }
+  if (a != a)
+    {
+    VTKM_TEST_FAIL("operator!= wrong");
+    }
+
+  //test against a tuple that shares some values
+  const vtkm::Id3 c = vtkm::make_Id3(2,4,5);
+  VTKM_TEST_ASSERT((c < a),  "operator< wrong");
+
+  if (c == a) { VTKM_TEST_FAIL("operator== wrong"); }
+  if (a == c) { VTKM_TEST_FAIL("operator== wrong"); }
+
+  if (!(c != a)) { VTKM_TEST_FAIL("operator!= wrong"); }
+  if (!(a != c)) { VTKM_TEST_FAIL("operator!= wrong"); }
+}
+
+template<> void TypeTest<vtkm::Scalar>()
+{
+  vtkm::Scalar a = 4;
+  vtkm::Scalar b = 2;
+
+  vtkm::Scalar plus = a + b;
+  if (plus != 6)
+    {
+    VTKM_TEST_FAIL("Scalars do not add correctly.");
+    }
+
+  vtkm::Scalar minus = a - b;
+  if (minus != 2)
+    {
+    VTKM_TEST_FAIL("Scalars to not subtract correctly.");
+    }
+
+  vtkm::Scalar mult = a * b;
+  if (mult != 8)
+    {
+    VTKM_TEST_FAIL("Scalars to not multiply correctly.");
+    }
+
+  vtkm::Scalar div = a / b;
+  if (div != 2)
+    {
+    VTKM_TEST_FAIL("Scalars to not divide correctly.");
+    }
+
+  if (a == b)
+    {
+    VTKM_TEST_FAIL("operator== wrong");
+    }
+  if (!(a != b))
+    {
+    VTKM_TEST_FAIL("operator!= wrong");
+    }
+
+  if (vtkm::dot(a, b) != 8)
+    {
+    VTKM_TEST_FAIL("dot(Scalar) wrong");
+    }
+}
+
+template<> void TypeTest<vtkm::Id>()
+{
+  vtkm::Id a = 4;
+  vtkm::Id b = 2;
+
+  vtkm::Id plus = a + b;
+  if (plus != 6)
+    {
+    VTKM_TEST_FAIL("Scalars do not add correctly.");
+    }
+
+  vtkm::Id minus = a - b;
+  if (minus != 2)
+    {
+    VTKM_TEST_FAIL("Scalars to not subtract correctly.");
+    }
+
+  vtkm::Id mult = a * b;
+  if (mult != 8)
+    {
+    VTKM_TEST_FAIL("Scalars to not multiply correctly.");
+    }
+
+  vtkm::Id div = a / b;
+  if (div != 2)
+    {
+    VTKM_TEST_FAIL("Scalars to not divide correctly.");
+    }
+
+  if (a == b)
+    {
+    VTKM_TEST_FAIL("operator== wrong");
+    }
+  if (!(a != b))
+    {
+    VTKM_TEST_FAIL("operator!= wrong");
+    }
+
+  if (vtkm::dot(a, b) != 8)
+    {
+    VTKM_TEST_FAIL("dot(Id) wrong");
+    }
+}
+
+struct TypeTestFunctor
+{
+  template <typename T> void operator()(const T&) const {
+    TypeTest<T>();
+  }
+};
+
+void TestTypes()
+{
+  vtkm::testing::Testing::TryAllTypes(TypeTestFunctor());
+
+  //try with some custom tuple types
+  TypeTestFunctor()( vtkm::Tuple<vtkm::Scalar,6>() );
+  TypeTestFunctor()( vtkm::Tuple<vtkm::Id,4>() );
+  TypeTestFunctor()( vtkm::Tuple<unsigned char,4>() );
+  TypeTestFunctor()( vtkm::Tuple<vtkm::Id,1>() );
+  TypeTestFunctor()( vtkm::Tuple<vtkm::Scalar,1>() );
+}
+
+} // anonymous namespace
+
+int UnitTestTypes(int, char *[])
+{
+  return vtkm::testing::Testing::Run(TestTypes);
+}