Skip to content
GitLab
Commit 0f29771b authored by Leonardo Solis's avatar Leonardo Solis
Browse files

#31, removed not anymore needed common folder (AOCLUtils) + their refs 

compiles but same errors as commit c15a9736


Former-commit-id: da08a6a0
parent 03926704
Hide whitespace changes
Inline Side-by-side
common/inc/AOCLUtils/aocl_utils.h deleted 100644 → 0
View file @ 03926704
// 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 deleted 100644 → 0
View file @ 03926704
// 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 deleted 100644 → 0
View file @ 03926704
// 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 deleted 100644 → 0
View file @ 03926704
// 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 deleted 100644 → 0
View file @ 03926704
/*
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;
}
table.pkg-contents tr.highlight td {
background-color: #ffc;
font-weight: bold;
color: #000;
}
table.pkg-contents td p:first-child {
margin-top: 0;
}
table.pkg-contents td p:last-child {
margin-bottom: 0;
}
table.parameters {
margin-left: 3em;
margin-right: 3em;
font-family: monospace, sans-serif;
font-size: 1em;
}
table.parameters th,
table.parameters td {
font-family: sans-serif;