added files and run log for nrun =1 aoc 16.1 on celebdil

.gitignore

+# Ignore PDBs for a moment
+PDBs/*
+
+# ===================
+# C gitignore
+# https://github.com/github/gitignore/blob/master/C.gitignore
+# ===================
+# Object files
+*.o
+*.ko
+*.obj
+*.elf
+
+# Precompiled Headers
+*.gch
+*.pch
+
+# Libraries
+*.lib
+*.a
+*.la
+*.lo
+
+# Shared objects (inc. Windows DLLs)
+*.dll
+*.so
+*.so.*
+*.dylib
+
+# Executables
+*.exe
+*.out
+*.app
+*.i*86
+*.x86_64
+*.hex
+
+# Debug files
+*.dSYM/
+*.su
+
+# ===================
+# C++ gitignore
+# https://github.com/github/gitignore/blob/master/C%2B%2B.gitignore
+# ===================
+
+# Compiled Object files
+*.slo
+*.lo
+*.o
+*.obj
+
+# Precompiled Headers
+*.gch
+*.pch
+
+# Compiled Dynamic libraries
+*.so
+*.dylib
+*.dll
+
+# Fortran module files
+*.mod
+*.smod
+
+# Compiled Static libraries
+*.lai
+*.la
+*.a
+*.lib
+
+# Executables
+*.exe
+*.out
+*.app
+

README.md

+Version compiled with Intel Altera Tools 16.1
+
+ofdock_datapar_xl: data parallel version for altera taken from feanor
+		   Machine: feanor
+		   Path: /home/wimi/lvs/altera/ofdock_altera/ofdock
+
+ofdock_taskpar_xl: task parallel version for altera

common/inc/AOCLUtils/aocl_utils.h

+// Copyright (C) 2013-2016 Altera Corporation, San Jose, California, USA. All rights reserved.
+// Permission is hereby granted, free of charge, to any person obtaining a copy of this
+// software and associated documentation files (the "Software"), to deal in the Software
+// without restriction, including without limitation the rights to use, copy, modify, merge,
+// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to
+// whom the Software is furnished to do so, subject to the following conditions:
+// The above copyright notice and this permission notice shall be included in all copies or
+// substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+// 
+// This agreement shall be governed in all respects by the laws of the State of California and
+// by the laws of the United States of America.
+
+// Main include file for AOCLUtils. Includes all other utility header files.
+
+#ifndef AOCL_UTILS_H
+#define AOCL_UTILS_H
+
+#include "AOCLUtils/opencl.h"
+#include "AOCLUtils/scoped_ptrs.h"
+#include "AOCLUtils/options.h"
+
+#endif
+

common/inc/AOCLUtils/opencl.h

+// Copyright (C) 2013-2016 Altera Corporation, San Jose, California, USA. All rights reserved.
+// Permission is hereby granted, free of charge, to any person obtaining a copy of this
+// software and associated documentation files (the "Software"), to deal in the Software
+// without restriction, including without limitation the rights to use, copy, modify, merge,
+// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to
+// whom the Software is furnished to do so, subject to the following conditions:
+// The above copyright notice and this permission notice shall be included in all copies or
+// substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+// 
+// This agreement shall be governed in all respects by the laws of the State of California and
+// by the laws of the United States of America.
+
+// OpenCL utility functions.
+
+#ifndef AOCL_UTILS_OPENCL_H
+#define AOCL_UTILS_OPENCL_H
+
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string>
+
+#include "CL/opencl.h"
+
+// This is assumed to be externally provided by the application.
+extern void cleanup();
+
+namespace aocl_utils {
+
+// Host allocation functions
+void *alignedMalloc(size_t size);
+void alignedFree(void *ptr);
+
+// Error functions
+void printError(cl_int error);
+void _checkError(int line,
+								 const char *file,
+								 cl_int error,
+                 const char *msg,
+                 ...); // does not return
+#define checkError(status, ...) _checkError(__LINE__, __FILE__, status, __VA_ARGS__)
+
+// Sets the current working directory to the same directory that contains
+// this executable. Returns true on success.
+bool setCwdToExeDir();
+
+// Find a platform that contains the search string in its name (case-insensitive match).
+// Returns NULL if no match is found.
+cl_platform_id findPlatform(const char *platform_name_search);
+
+// Returns the name of the platform.
+std::string getPlatformName(cl_platform_id pid);
+
+// Returns the name of the device.
+std::string getDeviceName(cl_device_id did);
+
+// Returns an array of device ids for the given platform and the
+// device type.
+// Return value must be freed with delete[].
+cl_device_id *getDevices(cl_platform_id pid, cl_device_type dev_type, cl_uint *num_devices);
+
+// Create a OpenCL program from a binary file.
+// The program is created for all given devices associated with the context. The same
+// binary is used for all devices.
+cl_program createProgramFromBinary(cl_context context, const char *binary_file_name, const cl_device_id *devices, unsigned num_devices);
+
+// Load binary file.
+// Return value must be freed with delete[].
+unsigned char *loadBinaryFile(const char *file_name, size_t *size);
+
+// Checks if a file exists.
+bool fileExists(const char *file_name);
+
+// Returns the path to the AOCX file to use for the given device.
+// This is special handling for examples for the Intel(R) FPGA SDK for OpenCL(TM).
+// It uses the device name to get the board name and then looks for a
+// corresponding AOCX file. Specifically, it gets the device name and
+// extracts the board name assuming the device name has the following format:
+//  <board> : ...
+//
+// Then the AOCX file is <prefix>_<version>_<board>.aocx. If this
+// file does not exist, then the file name defaults to <prefix>.aocx.
+std::string getBoardBinaryFile(const char *prefix, cl_device_id device);
+
+// Returns the time from a high-resolution timer in seconds. This value
+// can be used with a value returned previously to measure a high-resolution
+// time difference.
+double getCurrentTimestamp();
+
+// Returns the difference between the CL_PROFILING_COMMAND_END and
+// CL_PROFILING_COMMAND_START values of a cl_event object.
+// This requires that the command queue associated with the event be created
+// with the CL_QUEUE_PROFILING_ENABLE property.
+//
+// The return value is in nanoseconds.
+cl_ulong getStartEndTime(cl_event event);
+
+// Returns the maximum time span for the given set of events.
+// The time span starts at the earliest event start time.
+// The time span ends at the latest event end time.
+cl_ulong getStartEndTime(cl_event *events, unsigned num_events);
+
+// Wait for the specified number of milliseconds.
+void waitMilliseconds(unsigned ms);
+
+// OpenCL context callback function that simply prints the error information
+// to stdout (via printf).
+void oclContextCallback(const char *errinfo, const void *, size_t, void *);
+
+} // ns aocl_utils
+
+#endif
+

common/inc/AOCLUtils/options.h

+// Copyright (C) 2013-2016 Altera Corporation, San Jose, California, USA. All rights reserved.
+// Permission is hereby granted, free of charge, to any person obtaining a copy of this
+// software and associated documentation files (the "Software"), to deal in the Software
+// without restriction, including without limitation the rights to use, copy, modify, merge,
+// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to
+// whom the Software is furnished to do so, subject to the following conditions:
+// The above copyright notice and this permission notice shall be included in all copies or
+// substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+// 
+// This agreement shall be governed in all respects by the laws of the State of California and
+// by the laws of the United States of America.
+
+// Declares a utility class used to parse command-line options.
+
+#ifndef AOCL_UTILS_OPTIONS_H
+#define AOCL_UTILS_OPTIONS_H
+
+#include <map>
+#include <sstream>
+#include <string>
+#include <vector>
+
+namespace aocl_utils {
+
+class Options {
+public:
+  typedef std::vector<std::string> StringVec;
+
+  Options();
+  Options(int num, char *argv[]);
+
+  bool has(const std::string &name) const;
+  std::string &get(const std::string &name); // will create an empty option if it does not exist
+  const std::string &get(const std::string &name) const; // error if option does not exist
+
+  void set(const std::string &name, const std::string &value) { get(name) = value; }
+
+  // Command line options must be of the following form:
+  //  [-]-name (indicates option exists)
+  //  [-]-name=value
+  //
+  // This function assumes that the values are from main(int, char *).
+  // This means that the argv[0] is skipped.
+  void addFromCommandLine(int num, char *argv[]);
+
+  // This templated function converts the option value to the given type.
+  // An assert is raised if the conversion fails.
+  template<typename T>
+  T get(const std::string &name) const;
+
+  template<typename T>
+  void set(const std::string &name, const T &value);
+
+  // Non-options are arguments processed in addFromCommandLine
+  // that were not recognized as options.
+  const StringVec &getNonOptions() const { return m_nonoptions; }
+  size_t getNonOptionCount() const { return m_nonoptions.size(); }
+  const std::string &getNonOption(size_t i) const { return m_nonoptions[i]; }
+
+private:
+  typedef std::map<std::string, std::string> OptionMap;
+
+  // Displays an error message indicating that a nameless option
+  // was provided.
+  void errorNameless() const;
+
+  // Displays an error message indicating that the given option
+  // has the wrong type and then exits with an error code.
+  void errorWrongType(const std::string &name) const;
+
+  // Displays an error message indicating that the given option
+  // does not exist and then exits with an error code.
+  void errorNonExistent(const std::string &name) const;
+
+  OptionMap m_options;
+  StringVec m_nonoptions;
+
+  Options(const Options &); // not implemented
+  void operator =(const Options &); // not implemented
+};
+
+template<typename T>
+T Options::get(const std::string &name) const {
+  std::stringstream ss;
+  ss << get(name);
+
+  T v;
+  ss >> v;
+  if(ss.fail() || !ss.eof()) {
+    // Failed to parse or did not consume the whole string value.
+    errorWrongType(name);
+  }
+  return v;
+}
+
+// Specialization for bool. 
+template<>
+inline bool Options::get<bool>(const std::string &name) const {
+  if(has(name)) {
+    const std::string &v = get(name);
+    if(v == "1") {
+      return true;
+    }
+  }
+  return false;
+}
+
+// Specialization for std::string. Simply returns the option string.
+// Requires specialization because using stringstream to read the string
+// will stop at the first whitespace character (which is wrong).
+template<>
+inline std::string Options::get<std::string>(const std::string &name) const {
+  return get(name);
+}
+
+// This assumes the type T can be serialized to a string and back (when get
+// is called).
+template<typename T>
+void Options::set(const std::string &name, const T &value) {
+  std::stringstream ss;
+  ss << value;
+  set(name, ss.str());
+}
+
+} // ns aocl_utils
+
+#endif
+

common/inc/AOCLUtils/scoped_ptrs.h

+// Copyright (C) 2013-2016 Altera Corporation, San Jose, California, USA. All rights reserved.
+// Permission is hereby granted, free of charge, to any person obtaining a copy of this
+// software and associated documentation files (the "Software"), to deal in the Software
+// without restriction, including without limitation the rights to use, copy, modify, merge,
+// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to
+// whom the Software is furnished to do so, subject to the following conditions:
+// The above copyright notice and this permission notice shall be included in all copies or
+// substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+// 
+// This agreement shall be governed in all respects by the laws of the State of California and
+// by the laws of the United States of America.
+
+// Scoped pointer definitions.
+
+#ifndef AOCL_UTILS_SCOPED_PTRS_H
+#define AOCL_UTILS_SCOPED_PTRS_H
+
+namespace aocl_utils {
+
+// Interface is essentially the combination of std::auto_ptr and boost's smart pointers,
+// along with some small extensions (auto conversion to T*).
+
+// scoped_ptr: assumes pointer was allocated with operator new; destroys with operator delete
+template<typename T>
+class scoped_ptr {
+public:
+  typedef scoped_ptr<T> this_type;
+
+  scoped_ptr() : m_ptr(NULL) {}
+  scoped_ptr(T *ptr) : m_ptr(ptr) {}
+  ~scoped_ptr() { reset(); }
+
+  T *get() const { return m_ptr; }
+  operator T *() const { return m_ptr; }
+  T *operator ->() const { return m_ptr; }
+  T &operator *() const { return *m_ptr; }
+
+  this_type &operator =(T *ptr) { reset(ptr); return *this; }
+
+  void reset(T *ptr = NULL) { delete m_ptr; m_ptr = ptr; }
+  T *release() { T *ptr = m_ptr; m_ptr = NULL; return ptr; }
+
+private:
+  T *m_ptr;
+
+  // noncopyable
+  scoped_ptr(const this_type &);
+  this_type &operator =(const this_type &);
+};
+
+// scoped_array: assumes pointer was allocated with operator new[]; destroys with operator delete[]
+// Also supports allocation/reset with a number, which is the number of
+// elements of type T.
+template<typename T>
+class scoped_array {
+public:
+  typedef scoped_array<T> this_type;
+
+  scoped_array() : m_ptr(NULL) {}
+  scoped_array(T *ptr) : m_ptr(NULL) { reset(ptr); }
+  explicit scoped_array(size_t n) : m_ptr(NULL) { reset(n); }
+  ~scoped_array() { reset(); }
+
+  T *get() const { return m_ptr; }
+  operator T *() const { return m_ptr; }
+  T *operator ->() const { return m_ptr; }
+  T &operator *() const { return *m_ptr; }
+  T &operator [](int index) const { return m_ptr[index]; }
+
+  this_type &operator =(T *ptr) { reset(ptr); return *this; }
+
+  void reset(T *ptr = NULL) { delete[] m_ptr; m_ptr = ptr; }
+  void reset(size_t n) { reset(new T[n]); }
+  T *release() { T *ptr = m_ptr; m_ptr = NULL; return ptr; }
+
+private:
+  T *m_ptr;
+
+  // noncopyable
+  scoped_array(const this_type &);
+  this_type &operator =(const this_type &);
+};
+
+// scoped_aligned_ptr: assumes pointer was allocated with alignedMalloc; destroys with alignedFree
+// Also supports allocation/reset with a number, which is the number of
+// elements of type T
+template<typename T>
+class scoped_aligned_ptr {
+public:
+  typedef scoped_aligned_ptr<T> this_type;
+
+  scoped_aligned_ptr() : m_ptr(NULL) {}
+  scoped_aligned_ptr(T *ptr) : m_ptr(NULL) { reset(ptr); }
+  explicit scoped_aligned_ptr(size_t n) : m_ptr(NULL) { reset(n); }
+  ~scoped_aligned_ptr() { reset(); }
+
+  T *get() const { return m_ptr; }
+  operator T *() const { return m_ptr; }
+  T *operator ->() const { return m_ptr; }
+  T &operator *() const { return *m_ptr; }
+  T &operator [](int index) const { return m_ptr[index]; }
+
+  this_type &operator =(T *ptr) { reset(ptr); return *this; }
+
+  void reset(T *ptr = NULL) { if(m_ptr) alignedFree(m_ptr); m_ptr = ptr; }
+  void reset(size_t n) { reset((T*) alignedMalloc(sizeof(T) * n)); }
+  T *release() { T *ptr = m_ptr; m_ptr = NULL; return ptr; }
+
+private:
+  T *m_ptr;
+
+  // noncopyable
+  scoped_aligned_ptr(const this_type &);
+  this_type &operator =(const this_type &);
+};
+
+#if USE_SVM_API == 1
+// scoped_SVM_aligned_ptr: assumes pointer was allocated with clSVMAlloc; destroys with clSVMFree
+// Also supports allocation/reset with a number, which is the number of
+// elements of type T
+template<typename T>
+class scoped_SVM_aligned_ptr {
+public:
+	typedef scoped_SVM_aligned_ptr<T> this_type;
+
+	scoped_SVM_aligned_ptr() : m_ptr(NULL) {}
+	scoped_SVM_aligned_ptr(T *ptr) : m_ptr(NULL) { reset(ptr); }
+	explicit scoped_SVM_aligned_ptr(cl_context ctx, size_t n) : m_ptr(NULL) { reset(ctx, n); }
+	~scoped_SVM_aligned_ptr() { reset(); }
+
+	T *get() const { return m_ptr; }
+	operator T *() const { return m_ptr; }
+	T *operator ->() const { return m_ptr; }
+	T &operator *() const { return *m_ptr; }
+	T &operator [](int index) const { return m_ptr[index]; }
+
+	this_type &operator =(T *ptr) { reset(ptr); return *this; }
+
+	void reset(T *ptr = NULL) { if (m_ptr) clSVMFree(m_ctx, m_ptr); m_ptr = ptr; }
+	void reset(cl_context ctx, size_t n) { reset((T*)clSVMAlloc(ctx, 0, sizeof(T) * n, 0)); m_ctx = ctx; }
+	T *release() { T *ptr = m_ptr; m_ptr = NULL; return ptr; }
+
+private:
+	T *m_ptr;
+	cl_context m_ctx;
+
+	// noncopyable
+	scoped_SVM_aligned_ptr(const this_type &);
+	this_type &operator =(const this_type &);
+};
+#endif /* USE_SVM_API == 1 */
+
+} // ns aocl_utils
+
+#endif
+

common/readme.css

+/*
+Copyright (C) 2013-2016 Altera Corporation, San Jose, California, USA. All rights reserved.
+Permission is hereby granted, free of charge, to any person obtaining a copy of this
+software and associated documentation files (the "Software"), to deal in the Software
+without restriction, including without limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to
+whom the Software is furnished to do so, subject to the following conditions:
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+This agreement shall be governed in all respects by the laws of the State of California and
+by the laws of the United States of America.
+*/
+
+body {
+  margin: 0 1em 1em 1em;
+  font-family: sans-serif;
+}
+ul {
+  list-style-type: square;
+}
+pre, code, kbd, samp, tt {
+  font-family: monospace, sans-serif;
+  font-size: 1em;
+}
+
+h1 {
+  font-size: 200%;
+  color: #fff;
+  background-color: #0067a6;
+  margin: 0 -0.5em;
+  padding: 0.25em 0.5em;
+}
+h1 .preheading {
+  font-size: 40%;
+  font-weight: normal;
+}
+h2 {
+  font-size: 125%;
+  background-color: #bae5ff;
+  margin: 1.5em -0.8em 0 -0.8em;
+  padding: 0.2em 0.8em;
+}
+h3 {
+  margin-top: 1.5em;
+  font-size: 100%;
+  border-bottom: 1px dotted #000;
+}
+
+table {
+  border: 2px solid #0067a6;
+  border-collapse: collapse;
+}
+th {
+  border-bottom: 1px solid #0067a6;
+  border-left: 1px dotted #0067a6;
+  border-right: 1px dotted #0067a6;
+  background-color: #bae5ff;
+  padding: 0.3em;
+  font-size: 90%;
+}
+td {
+  padding: 0.3em;
+  border: 1px dotted #0067a6;
+}
+
+table.reqs {
+  margin: 0 auto;
+}
+table.reqs td {
+  white-space: nowrap;
+  text-align: center;
+}
+table.reqs td:first-child,
+table.reqs tr:first-child th:first-child {
+  text-align: left;
+}
+table.reqs td.req {
+  background-color: #b3ef71;
+  font-size: 150%;
+  padding: 0 0.3em;
+}
+table.reqs td.req .either {
+  font-size: 50%;
+}
+table.reqs td.unsupported {
+  white-space: normal;
+  background-color: #ccc;
+  max-width: 20em;
+}
+table.reqs a.note {
+  text-decoration: none;
+}
+ol.req-notes > li {
+  margin-bottom: 0.75em;
+}
+
+table.history {
+  margin: 0 auto;
+}
+table.history td {
+  text-align: center;
+  vertical-align: top;
+}
+table.history .changes {
+  text-align: left;
+}
+table.history tbody tr:first-child td {
+  background-color: #b3ef71;
+}
+table.history ul {
+  margin: 0;
+  padding-left: 1em;
+}
+
+table.pkg-contents {
+  margin: 0 auto;
+}
+table.pkg-contents th,
+table.pkg-contents td {
+  text-align: left;
+  vertical-align: top;
+}
+table.pkg-contents td.path {
+  font-family: monospace, sans-serif;
+  font-size: 1em;
+}