context(const property_list &props, const ref_vector<device> &devs);
context(const context &ctx) = delete;
+ context &
+ operator=(const context &ctx) = delete;
bool has_device(device &dev) const;
throw error(CL_INVALID_DEVICE);
}
-device::device(device &&dev) :
- platform(dev.platform), pipe(dev.pipe), ldev(dev.ldev) {
- dev.pipe = NULL;
- dev.ldev = NULL;
-}
-
device::~device() {
if (pipe)
pipe->destroy(pipe);
pipe_loader_release(&ldev, 1);
}
-device &
-device::operator=(device dev) {
- assert(&platform == &dev.platform);
-
- std::swap(pipe, dev.pipe);
- std::swap(ldev, dev.ldev);
-
- return *this;
-}
-
bool
device::operator==(const device &dev) const {
return this == &dev;
class device : public ref_counter, public _cl_device_id {
public:
device(clover::platform &platform, pipe_loader_device *ldev);
- device(device &&dev);
- device(const device &dev) = delete;
~device();
- device &operator=(device dev);
+ device(const device &dev) = delete;
+ device &
+ operator=(const device &dev) = delete;
bool
operator==(const device &dev) const;
action action_ok, action action_fail);
virtual ~event();
+ event(const event &ev) = delete;
+ event &
+ operator=(const event &ev) = delete;
+
void trigger();
void abort(cl_int status);
bool signalled() const;
exec_context(kernel &kern);
~exec_context();
+ exec_context(const exec_context &) = delete;
+ exec_context &
+ operator=(const exec_context &) = delete;
+
void *bind(command_queue *q);
void unbind();
public:
argument();
+ argument(const argument &arg) = delete;
+ argument &
+ operator=(const argument &arg) = delete;
+
/// \a true if the argument has been set.
bool set() const;
const std::string &name,
const std::vector<module::argument> &margs);
+ kernel(const kernel &kern) = delete;
+ kernel &
+ operator=(const kernel &kern) = delete;
+
void launch(command_queue &q,
const std::vector<size_t> &grid_offset,
const std::vector<size_t> &grid_size,
protected:
memory_obj(context &ctx, cl_mem_flags flags,
size_t size, void *host_ptr);
+
memory_obj(const memory_obj &obj) = delete;
+ memory_obj &
+ operator=(const memory_obj &obj) = delete;
public:
virtual ~memory_obj();
public:
platform();
+ platform(const platform &platform) = delete;
+ platform &
+ operator=(const platform &platform) = delete;
+
protected:
std::vector<ref_ptr<device>> devs;
};
const ref_vector<device> &devs,
const std::vector<module> &binaries);
+ program(const program &prog) = delete;
+ program &
+ operator=(const program &prog) = delete;
+
void build(const ref_vector<device> &devs, const char *opts);
const std::string &source() const;
public:
command_queue(context &ctx, device &dev,
cl_command_queue_properties props);
- command_queue(const command_queue &q) = delete;
~command_queue();
+ command_queue(const command_queue &q) = delete;
+ command_queue &
+ operator=(const command_queue &q) = delete;
+
void flush();
cl_command_queue_properties props() const;
#include <list>
-#include "core/object.hpp"
#include "core/memory.hpp"
#include "util/algebra.hpp"
#include "pipe/p_state.h"
public:
typedef std::array<size_t, 3> vector;
- resource(const resource &r) = delete;
virtual ~resource();
+ resource(const resource &r) = delete;
+ resource &
+ operator=(const resource &r) = delete;
+
void copy(command_queue &q, const vector &origin, const vector ®ion,
resource &src_resource, const vector &src_origin);
cl_addressing_mode addr_mode,
cl_filter_mode filter_mode);
+ sampler(const sampler &s) = delete;
+ sampler &
+ operator=(const sampler &s) = delete;
+
bool norm_mode();
cl_addressing_mode addr_mode();
cl_filter_mode filter_mode();