def get_OCL_context():
"""
Retrieves the OpenCL context
"""
if not pyopencl:
raise RuntimeError("OpenCL unuseable")
ctx = None
if sys.platform == "darwin":
ctx = pyopencl.Context(properties=get_gl_sharing_context_properties(),
devices=[])
else:
# Some OSs prefer clCreateContextFromType, some prefer
# clCreateContext. Try both and loop.
for platform in pyopencl.get_platforms():
try:
ctx = pyopencl.Context(
properties=[(pyopencl.context_properties.PLATFORM,
platform)] +
get_gl_sharing_context_properties())
except:
for device in platform.get_devices():
try:
ctx = pyopencl.Context(properties=[
(pyopencl.context_properties.PLATFORM, platform)
] + get_gl_sharing_context_properties(),
devices=[device])
except:
ctx = None
else:
break
else:
break
if ctx:
break
return ctx
def _get_context(self, device, gl_sharing):
"""
Get an OpenCL context.
@param device : OpenCL device
@param gl_sharing : Flag to build a OpenGL shared OpenCL context
@return OpenCL context
"""
props = None
if gl_sharing:
from pyopencl.tools import get_gl_sharing_context_properties
import sys
if sys.platform == "darwin":
props = get_gl_sharing_context_properties()
else:
# Some OSs prefer clCreateContextFromType, some prefer
# clCreateContext. Try both.
props = \
[(cl.context_properties.PLATFORM, self.platform)] \
+ get_gl_sharing_context_properties()
ctx = cl.Context(properties=props, devices=[device])
else:
ctx = cl.Context([device])
if __VERBOSE__:
print " Context:"
if not props is None:
print " - properties :", props
return ctx
def get_OCL_context():
"""
Retrieves the OpenCL context
"""
if not pyopencl:
raise RuntimeError("OpenCL unuseable")
ctx = None
if sys.platform == "darwin":
ctx = pyopencl.Context(properties=get_gl_sharing_context_properties(),
devices=[])
else:
# Some OSs prefer clCreateContextFromType, some prefer
# clCreateContext. Try both and loop.
for platform in pyopencl.get_platforms():
try:
ctx = pyopencl.Context(properties=[
(pyopencl.context_properties.PLATFORM, platform)]
+ get_gl_sharing_context_properties())
except:
for device in platform.get_devices():
try:
ctx = pyopencl.Context(properties=[
(pyopencl.context_properties.PLATFORM, platform)]
+ get_gl_sharing_context_properties(),
devices=[device])
except:
ctx = None
else:
break
else:
break
if ctx:
break
return ctx
def __init__(self, filename, *args, **kwargs):
plats = cl.get_platforms()
from pyopencl.tools import get_gl_sharing_context_properties
import sys
if sys.platform == "darwin":
self.ctx = cl.Context(properties=get_gl_sharing_context_properties(), devices=[])
else:
self.ctx = cl.Context(
properties=[(cl.context_properties.PLATFORM, plats[0])] + get_gl_sharing_context_properties(),
devices=None,
)
self.queue = cl.CommandQueue(self.ctx)
self.loadProgram(filename)
self.gl_objects = []
# TODO get these from kwargs
self.kernelargs = None
self.global_size = (0,)
self.local_size = None
self.PreExecute = None
self.PostExecute = None
self.kernelname = filename.split(".")[0]
def clinit():
"""Initialize OpenCL with GL-CL interop.
"""
if sys.platform == "darwin":
print(dir(cl.context_properties))
ctx = cl.Context(properties=get_gl_sharing_context_properties(), devices=[])
else:
# Some OSs prefer clCreateContextFromType, some prefer
# clCreateContext. Try both.
try:
ctx = cl.Context(
properties=[(cl.context_properties.PLATFORM, platform)] + get_gl_sharing_context_properties()
)
except:
ctx = cl.Context(
properties=[(cl.context_properties.PLATFORM, platform)] + get_gl_sharing_context_properties(),
devices=[platform.get_devices()[0]],
)
# plats = cl.get_platforms()
# ctx = cl.Context(properties=[
# (cl.context_properties.PLATFORM, plats[0])]
# + get_gl_sharing_context_properties(), devices = None)
# #[plats[0].get_devices()[DEVICE]])
print(ctx)
queue = cl.CommandQueue(ctx)
return ctx, queue
def openclContext(self, device_index=0):
if not self._cl_ctx:
if device_index:
self._cl_ctx = cl.Context( properties=get_gl_sharing_context_properties(),
devices = [self._devices[device_index]])
else:
self._cl_ctx = cl.Context( properties=get_gl_sharing_context_properties(),
devices = self._devices)
logger.debug("OpenCL context created: %s" % self._cl_ctx)
return self._cl_ctx
def _create_context():
if sys.platform == 'darwin':
props = cl_tools.get_gl_sharing_context_properties()
ctx = cl.Context(properties=props, devices=[])
else:
props = [(cl.context_properties.PLATFORM, cl.get_platforms()[0])]
props += cl_tools.get_gl_sharing_context_properties()
ctx = cl.Context(properties=props)
for i, dev in enumerate(ctx.devices):
log.info('device %d: %s, driver version %s' % (i, dev.version, dev.driver_version))
log.info('device %d: %s by %s' % (i, dev.name, dev.vendor))
return ctx
def __init__(self,
dev_id,
kernel_file="kernels.cl",
workers_exp1=5,
workers_exp2=5,
interop=False):
self.platform = cl.get_platforms()[
dev_id] # Select the platform [dev_id]
print('You ve selected the plateform : %s' % (self.platform.name))
# Create a context with all the devices
self.device = self.platform.get_devices()[
0] # Select the first device on this platform [0]
if (interop):
if sys.platform == "darwin":
self.ctx = cl.Context(
properties=get_gl_sharing_context_properties(), devices=[])
else:
try:
self.ctx = cl.Context(
properties=[(cl.context_properties.PLATFORM,
self.platform)] +
get_gl_sharing_context_properties())
except:
self.ctx = cl.Context(
properties=[
(cl.context_properties.PLATFORM, self.platform)
] + get_gl_sharing_context_properties(),
devices=[self.platform.get_devices()[0]])
else:
self.ctx = cl.Context([self.device])
# Create kernels
self.prg = cl.Program(self.ctx, open(kernel_file).read()).build()
# Create a simple queue
self.queue = cl.CommandQueue(
self.ctx,
self.ctx.devices[0],
properties=cl.command_queue_properties.PROFILING_ENABLE)
if (workers_exp1 == None or workers_exp2 == None):
self.local_size_2D = None
self.local_size_3D = None
self.local_size_inlet = None
else:
val1 = 2**workers_exp1
val2 = 2**workers_exp2
self.local_size_2D = (val1, val2)
self.local_size_3D = (1, val1, val2)
self.local_size_inlet = (val2, )
def __init_cl_stuff(self):
# Figure out platform and device
platform = cl.get_platforms()[0]
if sys.platform == "darwin":
self.context = cl.Context(
properties=get_gl_sharing_context_properties(), devices=[])
else:
# Some OSs prefer clCreateContextFromType, some prefer clCreateContext. Try both.
try:
self.context = cl.Context(
properties=[(cl.context_properties.PLATFORM, platform)] +
get_gl_sharing_context_properties())
except:
self.context = cl.Context(
properties=[(cl.context_properties.PLATFORM, platform)] +
get_gl_sharing_context_properties(),
devices=[platform.get_devices()[0]])
print(Style.BRIGHT + 'DEVICE: \t' + Style.RESET_ALL,
self.context.devices[0])
print(Style.BRIGHT + 'VERSION: \t' + Style.RESET_ALL,
self.context.devices[0].get_info(cl.device_info.VERSION))
# Make OpenCL buffers, one for each OpenGL VBO
self.position_buffer = cl.GLBuffer(self.context,
cl.mem_flags.READ_WRITE,
int(self.position_vbo))
self.color_buffer = cl.GLBuffer(self.context, cl.mem_flags.READ_WRITE,
int(self.color_vbo))
self.lifetime_buffer = cl.GLBuffer(self.context,
cl.mem_flags.READ_WRITE,
int(self.lifetime_vbo))
self.gl_buffers = (self.position_buffer, self.color_buffer,
self.lifetime_buffer)
# Make other OpenCL buffers
self.seed_buffer = cl.Buffer(self.context, cl.mem_flags.READ_WRITE,
self.n_particles * 8) # buffer of ulong
self.velocity_buffer = cl.Buffer(self.context, cl.mem_flags.READ_WRITE,
self.n_particles * 4 *
4) # buffer of float4
# Compile kernel program
try:
program_src = file_to_string(KERNEL_FILENAME)
self.kernel = cl.Program(self.context, program_src).build()
except cl.RuntimeError as e:
raise ParticleSystemException('Error compiling ' +
KERNEL_FILENAME + '\n' + str(e))
# Will need a command queue to run kernel
self.queue = cl.CommandQueue(self.context)
def clinit(self):
plats = cl.get_platforms()
from pyopencl.tools import get_gl_sharing_context_properties
import sys
if sys.platform == "darwin":
self.ctx = cl.Context(properties=get_gl_sharing_context_properties(),
devices=[])
else:
self.ctx = cl.Context(properties=[
(cl.context_properties.PLATFORM, plats[0])]
+ get_gl_sharing_context_properties(), devices=None)
self.queue = cl.CommandQueue(self.ctx)
def _create_context():
if sys.platform == 'darwin':
props = cl_tools.get_gl_sharing_context_properties()
ctx = cl.Context(properties=props, devices=[])
else:
props = [(cl.context_properties.PLATFORM, cl.get_platforms()[0])]
props += cl_tools.get_gl_sharing_context_properties()
ctx = cl.Context(properties=props)
for i, dev in enumerate(ctx.devices):
log.info('device %d: %s, driver version %s' %
(i, dev.version, dev.driver_version))
log.info('device %d: %s by %s' % (i, dev.name, dev.vendor))
return ctx
def openclContext(self, device_index=0):
if not self._cl_ctx:
if device_index:
self._cl_ctx = cl.Context(
properties=get_gl_sharing_context_properties(),
devices=[self._devices[device_index]])
else:
self._cl_ctx = cl.Context(
properties=get_gl_sharing_context_properties(),
devices=self._devices)
logger.debug("OpenCL context created: %s" % self._cl_ctx)
return self._cl_ctx
def clinit(self):
plats = cl.get_platforms()
from pyopencl.tools import get_gl_sharing_context_properties
import sys
if sys.platform == "darwin":
self.ctx = cl.Context(properties=get_gl_sharing_context_properties(),
devices=[])
else:
self.ctx = cl.Context(properties=[
(cl.context_properties.PLATFORM, plats[0])]
+ get_gl_sharing_context_properties(), devices=None)
self.queue = cl.CommandQueue(self.ctx)
def clinit():
"""Initialize OpenCL with GL-CL interop.
"""
plats = cl.get_platforms()
# handling OSX
if sys.platform == "darwin":
ctx = cl.Context(properties=get_gl_sharing_context_properties(),
devices=[])
else:
ctx = cl.Context(properties=[
(cl.context_properties.PLATFORM, plats[0])]
+ get_gl_sharing_context_properties())
queue = cl.CommandQueue(ctx)
return ctx, queue
def clinit():
"""Initialize OpenCL with GL-CL interop.
"""
plats = cl.get_platforms()
# handling OSX
if sys.platform == "darwin":
ctx = cl.Context(properties=get_gl_sharing_context_properties(),
devices=[])
else:
ctx = cl.Context(properties=[
(cl.context_properties.PLATFORM, plats[0])]
+ get_gl_sharing_context_properties())
queue = cl.CommandQueue(ctx)
return ctx, queue
def initCL(self):
platforms = cl.get_platforms()
if sys.platform == "darwin":
self.clContext = cl.Context(properties=get_gl_sharing_context_properties(), devices=[])
else:
try:
self.clContext = cl.Context(properties=[
(cl.context_properties.PLATFORM, platforms)]
+ get_gl_sharing_context_properties())
except:
raise SystemError('Could not create OpenCL context')
self.queue = cl.CommandQueue(self.clContext, properties=cl.command_queue_properties.PROFILING_ENABLE)
def __init__(self, gpuOnly=True, sharedGlContext=False, hidePlatformDetails=False):
super(BaseCalculator, self).__init__()
self.platform = cl.get_platforms()[0]
self.devices = self.platform.get_devices()
if not hidePlatformDetails:
for platform in cl.get_platforms():
for device in platform.get_devices():
print("===============================================================")
print("Platform name:", platform.name)
print("Platform profile:", platform.profile)
print("Platform vendor:", platform.vendor)
print("Platform version:", platform.version)
print("---------------------------------------------------------------")
print("Device name:", device.name)
print("Device type:", cl.device_type.to_string(device.type))
print("Device memory: ", device.global_mem_size//1024//1024, 'MB')
print("Device max clock speed:", device.max_clock_frequency, 'MHz')
print("Device compute units:", device.max_compute_units)
print("Device max work group size:", device.max_work_group_size)
print("Device max work item sizes:", device.max_work_item_sizes)
properties = None
if sharedGlContext:
assert cl.have_gl()
properties = get_gl_sharing_context_properties()
devices = self.devices
if gpuOnly and len(self.devices) > 1:
devices = [self.devices[1]]
self.context = cl.Context(properties=properties, devices=devices)
self.queue = None
def setup(self):
self.platform = cl.get_platforms()[0]
if self.opengl:
self.context = cl.Context(
properties=[(cl.context_properties.PLATFORM, self.platform)] + get_gl_sharing_context_properties())
else:
self.context = cl.Context(
properties=[(cl.context_properties.PLATFORM, self.platform)])
self.queue = cl.CommandQueue(self.context)
self.program = cl.Program(self.context, self.kernel_src).build(
'-cl-single-precision-constant -cl-opt-disable')
self.cl_particle_velocity_a = cl.Buffer(self.context, mf.COPY_HOST_PTR, hostbuf=self.np_particle_velocity)
self.cl_particle_velocity_b = cl.Buffer(self.context, mf.COPY_HOST_PTR, hostbuf=self.np_particle_velocity)
if self.opengl:
self.gl_particle_position_a = vbo.VBO(data=self.np_particle_position, usage=gl.GL_DYNAMIC_DRAW, target=gl.GL_ARRAY_BUFFER)
self.gl_particle_position_a.bind()
self.gl_particle_position_b = vbo.VBO(data=self.np_particle_position, usage=gl.GL_DYNAMIC_DRAW, target=gl.GL_ARRAY_BUFFER)
self.gl_particle_position_b.bind()
self.cl_particle_position_a = cl.GLBuffer(self.context, mf.READ_WRITE, int(self.gl_particle_position_a))
self.cl_particle_position_b = cl.GLBuffer(self.context, mf.READ_WRITE, int(self.gl_particle_position_b))
else:
self.cl_particle_position_a = cl.Buffer(self.context, mf.COPY_HOST_PTR, hostbuf=self.np_particle_position)
self.cl_particle_position_b = cl.Buffer(self.context, mf.COPY_HOST_PTR, hostbuf=self.np_particle_position)
self.cl_last_collide = cl.Buffer(self.context, mf.COPY_HOST_PTR, hostbuf=self.np_last_collide)
self.cl_particle_velocity_norms = cl.Buffer(self.context, mf.COPY_HOST_PTR, hostbuf=self.np_particle_velocity_norms)
def create_gpu_driver(cls):
platform = cl.get_platforms()[0]
devices = platform.get_devices()
gpu_device = devices[1]
properties = get_gl_sharing_context_properties()
context = cl.Context( devices=[gpu_device])
return cls(cl.CommandQueue(context))
def initialize(self, *args, **kwargs): plats = cl.get_platforms() card_dex = len(plats) - 1 if sys.platform == "darwin": self.ctx = cl.Context(properties=\ get_gl_sharing_context_properties(), devices=[]) else: props = [(cl.context_properties.PLATFORM,plats[card_dex])]+\ get_gl_sharing_context_properties() try: self.ctx = cl.Context(properties=props, devices=None) except TypeError: print 'no GPU contexts will work properly...'; return self.queue = cl.CommandQueue(self.ctx) self.verify_cl_extension(*args, **kwargs) print 'initialized gpu worker using:', self.gpu_cl_extension_key print 'using:', plats[card_dex], 'given:', plats, 'as options'
def clinit():
"""Initialize OpenCL with GL-CL interop.
"""
plats = cl.get_platforms()
ctx = cl.Context(properties=[(cl.context_properties.PLATFORM, plats[0])] +
get_gl_sharing_context_properties(),
devices=[plats[0].get_devices()[DEVICE]])
queue = cl.CommandQueue(ctx)
return ctx, queue
def clinit():
"""Initialize OpenCL with GL-CL interop.
"""
plats = cl.get_platforms()
ctx = cl.Context(properties=[
(cl.context_properties.PLATFORM, plats[0])]
+ get_gl_sharing_context_properties(), devices =
[plats[0].get_devices()[DEVICE]])
queue = cl.CommandQueue(ctx)
return ctx, queue
def prepareClBuffer(self): platform = cl.get_platforms() self.ctx = cl.Context(properties=get_gl_sharing_context_properties(),devices=[]) self.queue = cl.CommandQueue(self.ctx) self._cl_buf_pos = cl.GLBuffer(self.ctx, mf.READ_WRITE, int(self.vbo_id[0])) self._cl_buf_vel = cl.GLBuffer(self.ctx, mf.READ_WRITE, int(self.vbo_id[1])) self._cl_p_ww = cl.Buffer(self.ctx, mf.READ_ONLY | mf.COPY_HOST_PTR, hostbuf=self._p_ww) self._cl_p_has_ww = cl.Buffer(self.ctx, mf.READ_ONLY | mf.COPY_HOST_PTR, hostbuf=self._p_ww) self._cl_p_ww_len = numpy.int32(len(self._p_ww)) self.prog = cl.Program(self.ctx, CL_KERNEL).build()
def initialize(self, *args, **kwargs):
plats = cl.get_platforms()
card_dex = len(plats) - 1
if sys.platform == "darwin":
self.ctx = cl.Context(properties=\
get_gl_sharing_context_properties(),
devices=[])
else:
props = [(cl.context_properties.PLATFORM,plats[card_dex])]+\
get_gl_sharing_context_properties()
try:
self.ctx = cl.Context(properties=props, devices=None)
except TypeError:
print 'no GPU contexts will work properly...'
return
self.queue = cl.CommandQueue(self.ctx)
self.verify_cl_extension(*args, **kwargs)
print 'initialized gpu worker using:', self.gpu_cl_extension_key
print 'using:', plats[card_dex], 'given:', plats, 'as options'
def __init__(self, filename):
plats = cl.get_platforms()
from pyopencl.tools import get_gl_sharing_context_properties
import sys
if sys.platform == "darwin":
self.ctx = cl.Context(properties=get_gl_sharing_context_properties(),
devices=[])
else:
self.ctx = cl.Context(properties=[
(cl.context_properties.PLATFORM, plats[0])]
+ get_gl_sharing_context_properties(), devices=None)
self.queue = cl.CommandQueue(self.ctx)
self.loadProgram(filename)
self.kernelargs = None
self.gl_objects = []
self.PreExecute = None
self.PostExecute = None
def __init__(self, filename):
plats = cl.get_platforms()
from pyopencl.tools import get_gl_sharing_context_properties
import sys
if sys.platform == "darwin":
self.ctx = cl.Context(
properties=get_gl_sharing_context_properties(), devices=[])
else:
self.ctx = cl.Context(
properties=[(cl.context_properties.PLATFORM, plats[0])] +
get_gl_sharing_context_properties(),
devices=None)
self.queue = cl.CommandQueue(self.ctx)
self.loadProgram(filename)
self.kernelargs = None
self.gl_objects = []
self.PreExecute = None
self.PostExecute = None
def cl_init_context(self):
"""
Define context and queue.
"""
device = self.cl_pick_device()
platform = device.platform
additional_properties = []
if self.gl_interop:
from pyopencl.tools import get_gl_sharing_context_properties
additional_properties = get_gl_sharing_context_properties()
self.ctx = cl.Context(properties=[(cl.context_properties.PLATFORM, platform)] + additional_properties)
self.queue = cl.CommandQueue(self.ctx, device=device, properties=cl.command_queue_properties.OUT_OF_ORDER_EXEC_MODE_ENABLE)
def __init__(self, gl_positions, gl_colors, velocities, dt=0.001):
# First, we have to initialize the OpenCL context. That means we have
# to get a list of available platforms and select one:
platform = cl.get_platforms()[0]
# Then, we can create a context. Passing
# <code>get_gl_sharing_context_properties()</code> as a property
# ensures that we share state with the active OpenGL context:
self.ctx = cl.Context(
properties=[(cl.context_properties.PLATFORM, platform)] +
get_gl_sharing_context_properties(),
devices=[platform.get_devices()[0]])
# A command queue is necessary for serializing OpenCL commands:
self.queue = cl.CommandQueue(self.ctx)
# Finally, we can compile the kernel:
self.program = cl.Program(self.ctx, kernel_code).build()
# The constructor parameters are stored for later use:
self.gl_positions = gl_positions
self.gl_colors = gl_colors
self.velocities = velocities
# The <code>dt</code> value will later be passed to an OpenCL kernel as
# a 32-bit float. We therefore wrap it in a numpy <code>float32</code>
# object:
self.dt = numpy.float32(dt)
# Next, we generate OpenCL buffers. The positions and colors are
# contained in OpenGL buffers, which we wrap in PyOpenCL's
# <code>GLBuffer</code> class:
self.cl_positions = cl.GLBuffer(self.ctx, cl.mem_flags.READ_WRITE,
self.gl_positions._id)
self.cl_colors = cl.GLBuffer(self.ctx, cl.mem_flags.READ_WRITE,
self.gl_colors._id)
# Note how we had to extract the <code>_id</code>s from the
# <code>ArrayBuffer</code> objects. In pure <i>glitter</i> code, you
# should never (have to) access this value; however for interaction
# with other OpenGL-related libraries, this cannot always be avoided.
# The velocities are given as a numpy array, which is simply uploaded
# into a new OpenCL <code>Buffer</code> object along with the initial
# values of the positions and colors:
self.cl_velocities = cl.Buffer(self.ctx,
cl.mem_flags.READ_ONLY
| cl.mem_flags.COPY_HOST_PTR,
hostbuf=velocities)
self.cl_initial_positions = cl.Buffer(self.ctx,
cl.mem_flags.READ_ONLY
| cl.mem_flags.COPY_HOST_PTR,
hostbuf=self.gl_positions.data)
self.cl_initial_velocities = cl.Buffer(self.ctx,
cl.mem_flags.READ_ONLY
| cl.mem_flags.COPY_HOST_PTR,
hostbuf=self.velocities)
def init_opencl(sharing=True):
global context, command_queue
if context is not None:
return
platform = cl.get_platforms()[-1]
devices = platform.get_devices()
if sharing:
context = cl.Context(
devices=devices,
properties=[(cl.context_properties.PLATFORM, platform)] +
get_gl_sharing_context_properties())
else:
context = cl.Context(devices=devices)
command_queue = cl.CommandQueue(context)
def initialize():
platform = cl.get_platforms()[0]
from pyopencl.tools import get_gl_sharing_context_properties
import sys
if sys.platform == "darwin":
ctx = cl.Context(properties=get_gl_sharing_context_properties(),
devices=[])
else:
# Some OSs prefer clCreateContextFromType, some prefer
# clCreateContext. Try both.
try:
ctx = cl.Context(properties=[
(cl.context_properties.PLATFORM, platform)]
+ get_gl_sharing_context_properties())
except:
ctx = cl.Context(properties=[
(cl.context_properties.PLATFORM, platform)]
+ get_gl_sharing_context_properties(),
devices = [platform.get_devices()[0]])
glClearColor(1, 1, 1, 1)
glColor(0, 0, 1)
vbo = glGenBuffers(1)
glBindBuffer(GL_ARRAY_BUFFER, vbo)
rawGlBufferData(GL_ARRAY_BUFFER, n_vertices * 2 * 4, None, GL_STATIC_DRAW)
glEnableClientState(GL_VERTEX_ARRAY)
glVertexPointer(2, GL_FLOAT, 0, None)
coords_dev = cl.GLBuffer(ctx, cl.mem_flags.READ_WRITE, int(vbo))
prog = cl.Program(ctx, src).build()
queue = cl.CommandQueue(ctx)
cl.enqueue_acquire_gl_objects(queue, [coords_dev])
prog.generate_sin(queue, (n_vertices,), None, coords_dev)
cl.enqueue_release_gl_objects(queue, [coords_dev])
queue.finish()
glFlush()
def clinit():
"""Initialize OpenCL with GL-CL interop.
"""
# import ipdb; ipdb.set_trace()
plats = cl.get_platforms()
# handling OSX
if sys.platform == "darwin":
ctx = cl.Context(properties=get_gl_sharing_context_properties(),
devices=[])
else:
ctx = cl.Context(
properties=[(cl.context_properties.PLATFORM, plats[0])] +
get_gl_sharing_context_properties())
# try:
# ctx = cl.Context(properties=[
# (cl.context_properties.PLATFORM, platform)]
# + get_gl_sharing_context_properties())
# except:
# ctx = cl.Context(properties=[
# (cl.context_properties.PLATFORM, platform)]
# + get_gl_sharing_context_properties(),
# devices = [platform.get_devices()[0]])
queue = cl.CommandQueue(ctx)
return ctx, queue
def initialize():
platform = cl.get_platforms()[0]
from pyopencl.tools import get_gl_sharing_context_properties
import sys
if sys.platform == "darwin":
ctx = cl.Context(properties=get_gl_sharing_context_properties(),
devices=[])
else:
# Some OSs prefer clCreateContextFromType, some prefer
# clCreateContext. Try both.
try:
ctx = cl.Context(
properties=[(cl.context_properties.PLATFORM, platform)] +
get_gl_sharing_context_properties())
except:
ctx = cl.Context(
properties=[(cl.context_properties.PLATFORM, platform)] +
get_gl_sharing_context_properties(),
devices=[platform.get_devices()[0]])
glClearColor(1, 1, 1, 1)
glColor(0, 0, 1)
vbo = glGenBuffers(1)
glBindBuffer(GL_ARRAY_BUFFER, vbo)
rawGlBufferData(GL_ARRAY_BUFFER, n_vertices * 2 * 4, None, GL_STATIC_DRAW)
glEnableClientState(GL_VERTEX_ARRAY)
glVertexPointer(2, GL_FLOAT, 0, None)
coords_dev = cl.GLBuffer(ctx, cl.mem_flags.READ_WRITE, int(vbo))
prog = cl.Program(ctx, src).build()
queue = cl.CommandQueue(ctx)
cl.enqueue_acquire_gl_objects(queue, [coords_dev])
prog.generate_sin(queue, (n_vertices, ), None, coords_dev)
cl.enqueue_release_gl_objects(queue, [coords_dev])
queue.finish()
glFlush()
def __init__(self, filename, *args, **kwargs):
plats = cl.get_platforms()
from pyopencl.tools import get_gl_sharing_context_properties
import sys
if sys.platform == "darwin":
self.ctx = cl.Context(properties=get_gl_sharing_context_properties(),
devices=[])
else:
self.ctx = cl.Context(properties=[
(cl.context_properties.PLATFORM, plats[0])]
+ get_gl_sharing_context_properties(), devices=None)
self.queue = cl.CommandQueue(self.ctx)
self.loadProgram(filename)
self.gl_objects = []
#TODO get these from kwargs
self.kernelargs = None
self.global_size = (0, )
self.local_size = None
self.PreExecute = None
self.PostExecute = None
self.kernelname = filename.split(".")[0]
def clinit(self):
plats = cl.get_platforms()
from pyopencl.tools import get_gl_sharing_context_properties
if sys.platform == "darwin":
self.ctx= cl.create_some_context()
#print cl.context_properties.
#print get_gl_sharing_context_properties()
#print "ctx_props.CONTEXT_PROPERTY_USE_CGL_SHAREGROUP_APPLE", cl.get_apple_cgl_share_group()
print cl.get_apple_cgl_share_group()
#self.ctx = cl.Context(properties=get_gl_sharing_context_properties(), devices=[])
else:
self.ctx = cl.Context(properties=[(cl.context_properties.PLATFORM, plats[0])]
+ get_gl_sharing_context_properties(), devices=None)
self.queue = cl.CommandQueue(self.ctx)
def cl_init_context(self):
"""
Define context and queue.
"""
device = self.cl_pick_device()
platform = device.platform
additional_properties = []
if self.gl_interop:
from pyopencl.tools import get_gl_sharing_context_properties
additional_properties = get_gl_sharing_context_properties()
# Some OSs prefer clCreateContextFromType, some prefer clCreateContext. Try both.
try:
self.ctx = cl.Context(properties=[(cl.context_properties.PLATFORM, platform)] + additional_properties)
except:
self.ctx = cl.Context(properties=[(cl.context_properties.PLATFORM, platform)] + additional_properties, devices=[device])
self.queue = cl.CommandQueue(self.ctx, device=device, properties=cl.command_queue_properties.OUT_OF_ORDER_EXEC_MODE_ENABLE)
def get_cl_context(gl_context):
"""Creates a CL context, with or without given GL context."""
if gl_context is not None: # ... with OpenGL interop?
with gl_context:
assert cl.have_gl(), "GL interoperability not enabled."
from pyopencl.tools import get_gl_sharing_context_properties
cl_platform = cl.get_platforms()[0]
cl_properties = [(cl.context_properties.PLATFORM, cl_platform)] + get_gl_sharing_context_properties()
cl_devices = [cl_platform.get_devices()[-1]] # Only one is allowed!
cl_context = cl.Context(properties=cl_properties, devices=cl_devices)
else: # ... or in stand-alone mode, CL context without GL?
cl_platform = cl.get_platforms()[0] # @UndefinedVariable
cl_properties = [(cl.context_properties.PLATFORM, cl_platform)]
cl_devices = [cl_platform.get_devices()[-1]] # Only one is allowed!
cl_context = cl.Context(properties=cl_properties, devices=cl_devices)
return cl_context
def __init__(self, gpuOnly=True, sharedGlContext=False): super(BaseCalculator, self).__init__() self.platform = cl.get_platforms()[0] self.devices = self.platform.get_devices() properties = None if sharedGlContext: assert cl.have_gl() properties = get_gl_sharing_context_properties() devices = self.devices if gpuOnly and len(self.devices) > 1: devices = [self.devices[0]] self.context = cl.Context(properties=properties, devices=devices) self.queue = None
def get_cl_context(gl_context):
"""Creates a CL context, with or without given GL context."""
if gl_context is not None: # ... with OpenGL interop?
with gl_context:
assert cl.have_gl(), "GL interoperability not enabled."
from pyopencl.tools import get_gl_sharing_context_properties
cl_platform = cl.get_platforms()[0]
cl_properties = [(cl.context_properties.PLATFORM, cl_platform)
] + get_gl_sharing_context_properties()
cl_devices = [cl_platform.get_devices()[-1]
] # Only one is allowed!
cl_context = cl.Context(properties=cl_properties,
devices=cl_devices)
else: # ... or in stand-alone mode, CL context without GL?
cl_platform = cl.get_platforms()[0] # @UndefinedVariable
cl_properties = [(cl.context_properties.PLATFORM, cl_platform)]
cl_devices = [cl_platform.get_devices()[-1]] # Only one is allowed!
cl_context = cl.Context(properties=cl_properties, devices=cl_devices)
return cl_context
def __init__(self, gl_positions, gl_colors, velocities, dt=0.001):
# First, we have to initialize the OpenCL context. That means we have
# to get a list of available platforms and select one:
platform = cl.get_platforms()[0]
# Then, we can create a context. Passing
# <code>get_gl_sharing_context_properties()</code> as a property
# ensures that we share state with the active OpenGL context:
self.ctx = cl.Context(properties=[(cl.context_properties.PLATFORM, platform)] +
get_gl_sharing_context_properties(), devices=[platform.get_devices()[0]])
# A command queue is necessary for serializing OpenCL commands:
self.queue = cl.CommandQueue(self.ctx)
# Finally, we can compile the kernel:
self.program = cl.Program(self.ctx, kernel_code).build()
# The constructor parameters are stored for later use:
self.gl_positions = gl_positions
self.gl_colors = gl_colors
self.velocities = velocities
# The <code>dt</code> value will later be passed to an OpenCL kernel as
# a 32-bit float. We therefore wrap it in a numpy <code>float32</code>
# object:
self.dt = numpy.float32(dt)
# Next, we generate OpenCL buffers. The positions and colors are
# contained in OpenGL buffers, which we wrap in PyOpenCL's
# <code>GLBuffer</code> class:
self.cl_positions = cl.GLBuffer(self.ctx, cl.mem_flags.READ_WRITE, self.gl_positions._id)
self.cl_colors = cl.GLBuffer(self.ctx, cl.mem_flags.READ_WRITE, self.gl_colors._id)
# Note how we had to extract the <code>_id</code>s from the
# <code>ArrayBuffer</code> objects. In pure <i>glitter</i> code, you
# should never (have to) access this value; however for interaction
# with other OpenGL-related libraries, this cannot always be avoided.
# The velocities are given as a numpy array, which is simply uploaded
# into a new OpenCL <code>Buffer</code> object along with the initial
# values of the positions and colors:
self.cl_velocities = cl.Buffer(self.ctx, cl.mem_flags.READ_ONLY |
cl.mem_flags.COPY_HOST_PTR, hostbuf=velocities)
self.cl_initial_positions = cl.Buffer(self.ctx, cl.mem_flags.READ_ONLY |
cl.mem_flags.COPY_HOST_PTR, hostbuf=self.gl_positions.data)
self.cl_initial_velocities = cl.Buffer(self.ctx, cl.mem_flags.READ_ONLY |
cl.mem_flags.COPY_HOST_PTR, hostbuf=self.velocities)
def init_device(cpu_device=False):
# Find a device... default is for GPU
device_type_name = 'gpu'
if cpu_device:
device_type_name = 'cpu'
# Grab OpenCL device calls
device_type = deviceDict[device_type_name]
print('\n============== Grabbing Compute Resources =============\n')
platform = cl.get_platforms()[0]
print('\t\tPlatform: %s' % platform)
device = platform.get_devices(device_type=device_type)
print('\t\tDevice: %s' % device[0])
print('\n=======================================================\n')
context = cl.Context(
devices=device,
properties=[(cl.context_properties.PLATFORM, platform)] +
get_gl_sharing_context_properties())
return device, context
def __init__(self, gl_image, gl_lapl_mask):
platform = cl.get_platforms()[0]
self.ctx = cl.Context(
properties=[(cl.context_properties.PLATFORM, platform)] +
get_gl_sharing_context_properties(),
devices=None)
self.queue = cl.CommandQueue(self.ctx)
self.program = cl.Program(self.ctx, kernel_code).build()
self.shape = gl_image.shape[1], gl_image.shape[0]
self.cl_image = cl.GLTexture(self.ctx, cl.mem_flags.READ_WRITE,
GL_TEXTURE_2D, 0, gl_image._id, 2)
self.cl_lapl_mask = cl.GLTexture(self.ctx, cl.mem_flags.READ_ONLY,
GL_TEXTURE_2D, 0, gl_lapl_mask._id, 2)
if self.use_gl_texture_as_tmp:
self.gl_tmp = Texture2D(gl_image.data)
self.cl_tmp = cl.GLTexture(self.ctx, cl.mem_flags.READ_WRITE,
GL_TEXTURE_2D, 0, self.gl_tmp._id, 2)
else:
self.cl_tmp = cl.Image(
self.ctx, cl.mem_flags.READ_WRITE,
self.cl_image.get_image_info(cl.image_info.FORMAT), self.shape)
def cl_init_context(self):
"""
Define context and queue.
"""
device = self.cl_pick_device()
platform = device.platform
additional_properties = []
from pyopencl.tools import get_gl_sharing_context_properties
additional_properties = get_gl_sharing_context_properties()
# Some OSs prefer clCreateContextFromType, some prefer clCreateContext. Try both.
try:
self.ctx = cl.Context(
properties=[(cl.context_properties.PLATFORM, platform)] +
additional_properties)
except:
self.ctx = cl.Context(
properties=[(cl.context_properties.PLATFORM, platform)] +
additional_properties,
devices=[device])
self.queue = cl.CommandQueue(self.ctx,
device=device,
properties=cl.command_queue_properties.
OUT_OF_ORDER_EXEC_MODE_ENABLE)
# Draw the VBOs
glDrawArrays(GL_POINTS, 0, num_particles)
glDisableClientState(GL_COLOR_ARRAY)
glDisableClientState(GL_VERTEX_ARRAY)
glDisable(GL_BLEND)
glutSwapBuffers()
window = glut_window()
(np_position, np_velocity, gl_position, gl_color) = initial_buffers(num_particles)
platform = cl.get_platforms()[0]
context = cl.Context(properties=[(cl.context_properties.PLATFORM, platform)] + get_gl_sharing_context_properties())
queue = cl.CommandQueue(context)
cl_velocity = cl.Buffer(context, mf.COPY_HOST_PTR, hostbuf=np_velocity)
cl_start_position = cl.Buffer(context, mf.READ_ONLY | mf.COPY_HOST_PTR, hostbuf=np_position)
cl_start_velocity = cl.Buffer(context, mf.READ_ONLY | mf.COPY_HOST_PTR, hostbuf=np_velocity)
cl_gl_position = cl.GLBuffer(context, mf.READ_WRITE, int(gl_position.buffers[0]))
cl_gl_color = cl.GLBuffer(context, mf.READ_WRITE, int(gl_color.buffers[0]))
kernel = """__kernel void particle_fountain(__global float4* position,
__global float4* color,
__global float4* velocity,
__global float4* start_position,
__global float4* start_velocity,
float time_step)
def __init__(self, gl_image, gl_lapl_mask):
platform = cl.get_platforms()[0]
self.ctx = cl.Context(properties=[(cl.context_properties.PLATFORM, platform)] + get_gl_sharing_context_properties(), devices=None)
self.queue = cl.CommandQueue(self.ctx)
self.program = cl.Program(self.ctx, kernel_code).build()
self.shape = gl_image.shape[1], gl_image.shape[0]
self.cl_image = cl.GLTexture(self.ctx, cl.mem_flags.READ_WRITE, GL_TEXTURE_2D, 0, gl_image._id, 2)
self.cl_lapl_mask = cl.GLTexture(self.ctx, cl.mem_flags.READ_ONLY, GL_TEXTURE_2D, 0, gl_lapl_mask._id, 2)
if self.use_gl_texture_as_tmp:
self.gl_tmp = Texture2D(gl_image.data)
self.cl_tmp = cl.GLTexture(self.ctx, cl.mem_flags.READ_WRITE, GL_TEXTURE_2D, 0, self.gl_tmp._id, 2)
else:
self.cl_tmp = cl.Image(self.ctx, cl.mem_flags.READ_WRITE, self.cl_image.get_image_info(cl.image_info.FORMAT), self.shape)
def clinit(self):
from pyopencl.tools import get_gl_sharing_context_properties
plat = cl.get_platforms()
GF9400 = plat[0].get_devices()[1]
self.ctx = cl.Context(devices = [GF9400],properties=get_gl_sharing_context_properties())
self.queue = cl.CommandQueue(self.ctx, properties=cl.command_queue_properties.PROFILING_ENABLE)
def __init__(self, network, step_size=0.00025):
"""
Creates a visualization window for a given network. The network cannot be compiled yet!
"""
self.network = network
#set up timing parameters
self.refresh_rate_ms = 30 #in ms
self.sim_dur_per_refresh = 0.005 # amount of time
self.step_size = step_size
self.num_steps_per_refresh = int(self.sim_dur_per_refresh / self.step_size)
#mouse handling for transforming scene
self.mouse_down = False
self.mouse_old = np.array([0., 0.])
self.rotate = np.array([0., 0., 0.])
self.translate = np.array([0., 0., 0.])
self.initrans = np.array([0., 0., -2.])
self.width = 1024
self.height = 768
self.simulation_time = 0.0
glutInit(sys.argv)
glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH)
glutInitWindowSize(self.width, self.height)
glutInitWindowPosition(0, 0)
self.win = glutCreateWindow('Network')
#gets called by GLUT every frame
glutDisplayFunc(self.draw)
#handle user input
glutKeyboardFunc(self.on_key)
glutMouseFunc(self.on_click)
glutMotionFunc(self.on_mouse_motion)
#this will call draw every 30 ms
glutTimerFunc(self.refresh_rate_ms, self.timer, self.refresh_rate_ms)
#setup OpenGL scene
self.glinit()
#create position and color VBOs
unit_positions = self.network.get_unit_positions()
print 'unit_positions:'
print unit_positions
self.pos_vbo = vbo.VBO(data=unit_positions, usage=GL_DYNAMIC_DRAW, target=GL_ARRAY_BUFFER)
self.pos_vbo.bind()
unit_colors = self.network.get_unit_colors()
print 'unit_colors:'
print unit_colors
self.col_vbo = vbo.VBO(data=unit_colors, usage=GL_DYNAMIC_DRAW, target=GL_ARRAY_BUFFER)
self.col_vbo.bind()
self.network.visualize = True
self.network.color_vbo = self.col_vbo
#create a CL context for the network to use
plats = cl.get_platforms()
if sys.platform == "darwin":
cl_context = cl.Context(properties=get_gl_sharing_context_properties(), devices=[])
else:
props = [(cl.context_properties.PLATFORM, plats[0])] + get_gl_sharing_context_properties()
cl_context = cl.Context(properties=props, devices=None)
self.network.cl_context = cl_context
#compile the network
self.network.compile()
glutMainLoop()
(1.0, 1.0),
(0.0, 0.0),
(1.0, 1.0),
(0.0, 1.0),)
)
geometry_vbo = vbo.VBO(data=pos, usage=GL_DYNAMIC_DRAW, target=GL_ARRAY_BUFFER)
texcoord_vbo = vbo.VBO(data=pos, usage=GL_DYNAMIC_DRAW, target=GL_ARRAY_BUFFER)
glClearColor(1.0, 0.0, 0.0, 1.0)
platform = cl.get_platforms()[0]
from pyopencl.tools import get_gl_sharing_context_properties
import sys
if sys.platform == "darwin":
ctx = cl.Context(properties=get_gl_sharing_context_properties(),
devices=[])
else:
# Some OSs prefer clCreateContextFromType, some prefer
# clCreateContext. Try both.
try:
ctx = cl.Context(properties=[
(cl.context_properties.PLATFORM, platform)]
+ get_gl_sharing_context_properties())
except:
ctx = cl.Context(properties=[
(cl.context_properties.PLATFORM, platform)]
+ get_gl_sharing_context_properties(),
devices = [platform.get_devices()[0]])
def __init__(self, device=None, useGPU: bool = True) -> None:
self._isUsingOpenCL2 = False
self._isDebugBuild = False
self._isUsingGPU = useGPU
self._gl_interop = False
self._clDevice = None
# Show compiled output by setting envrionment flag
self.enableCompilerOutput(OpenCLFlags.ENABLE_COMPILER_OUTPUT)
self.enableCompilerCache(OpenCLFlags.ENABLE_CACHE)
os.environ["AMPLXE_LOG_LEVEL"] = "TRACE"
os.environ["TPSS_DEBUG"] = "1"
if device:
self._device = device
self._platform = device.platform
else:
# Preselect the default platform and device
# Get the OpenCL Platforms
self._platform = cl.get_platforms()[0]
logging.debug('Initialising OpenCL Runtime - {:s}'.format(
self.platform.name))
gpuDevices = self.gpuDevices # get GPU devices of selected platform
cpuDevices = self.cpuDevices # get GPU devices of selected platform
if len(gpuDevices) > 0 and useGPU:
self._device = gpuDevices[0] # take first GPU
logging.debug('Using GPU - {:s} ({:s}) for OpenCL'.format(
self.device.name, self.device.version))
elif len(cpuDevices) > 0:
self._device = cpuDevices[0] # take first CPU
logging.debug('Using CPU for OpenCL')
else:
raise RuntimeError('No OpenCL device currently available')
if self.isUsingGPU() and cl.have_gl() and self.hasGLShareExtension():
from pyopencl.tools import get_gl_sharing_context_properties
# Try setting up an OpenCL context with a Gl_Sharing
try:
self._context = cl.Context(
properties=[(cl.context_properties.PLATFORM,
self.platform)] +
get_gl_sharing_context_properties())
self._gl_interop = True
except:
logging.warning('Issue with GL Sharing at runtime')
self._context = cl.Context(properties=[
(cl.context_properties.PLATFORM, self.platform)
],
devices=[self.device])
else:
self._context = cl.Context(properties=[
(cl.context_properties.PLATFORM, self.platform)
],
devices=[self.device])
p: - start or pause the program\n
q,Esc: - exit the program\n
------------------------------------------------------------------------------\n
\n"""
#-----
# MAIN
#-----
if __name__=="__main__":
printHelp()
window = glut_window()
(np_datax, np_datay, np_dataz, np_life, np_position, np_velocity, np_zmel, gl_position, gl_color) = initial_buffers(num_particles)
platform = cl.get_platforms()[0]
context = cl.Context(properties=[(cl.context_properties.PLATFORM, platform)] + get_gl_sharing_context_properties())
queue = cl.CommandQueue(context)
cl_life = cl.Buffer(context, mf.COPY_HOST_PTR, hostbuf=np_life)
cl_velocity = cl.Buffer(context, mf.COPY_HOST_PTR, hostbuf=np_velocity)
cl_zmel = cl.Buffer(context, mf.COPY_HOST_PTR, hostbuf=np_zmel)
cl_datax = cl.Buffer(context, mf.READ_ONLY | mf.COPY_HOST_PTR, hostbuf=np_datax)
cl_datay = cl.Buffer(context, mf.READ_ONLY | mf.COPY_HOST_PTR, hostbuf=np_datay)
cl_dataz = cl.Buffer(context, mf.READ_ONLY | mf.COPY_HOST_PTR, hostbuf=np_dataz)
cl_start_position = cl.Buffer(context, mf.READ_ONLY | mf.COPY_HOST_PTR, hostbuf=np_position)
cl_start_velocity = cl.Buffer(context, mf.READ_ONLY | mf.COPY_HOST_PTR, hostbuf=np_velocity)
if hasattr(gl_position,'buffers'):
cl_gl_position = cl.GLBuffer(context, mf.READ_WRITE, int(gl_position.buffers[0]))
def init():
platform = cl.get_platforms()[0]
global ctx
from pyopencl.tools import get_gl_sharing_context_properties
import sys
if sys.platform == "darwin":
ctx = cl.Context(properties=get_gl_sharing_context_properties(),
devices=[])
else:
# Some OSs prefer clCreateContextFromType, some prefer
# clCreateContext. Try both.
try:
ctx = cl.Context(properties=[
(cl.context_properties.PLATFORM, platform)]
+ get_gl_sharing_context_properties())
except:
ctx = cl.Context(properties=[
(cl.context_properties.PLATFORM, platform)]
+ get_gl_sharing_context_properties(),
devices = [platform.get_devices()[0]])
global buf
global tex
global tex1
global image
image = read_pgm("lena512.pgm", byteorder='<')
image = image.ravel() # make 1D
size = image_height * image_width
#Texture setup base
tex1 = glGenTextures(1)
glBindTexture(GL_TEXTURE_2D, tex1)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE8, image_width, image_height, 0, GL_RED, GL_UNSIGNED_BYTE, image);
# Texture setup CL
tex = glGenTextures(1)
glBindTexture(GL_TEXTURE_2D, tex)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE8, image_width, image_height, 0, GL_RED, GL_UNSIGNED_BYTE, None);
# Buffer setup
buf = glGenBuffers(1)
glBindBuffer(GL_PIXEL_UNPACK_BUFFER, buf)
glBufferData(GL_PIXEL_UNPACK_BUFFER, image_height * image_width, None, GL_STREAM_DRAW)
# CL setup
global queue
global prog
#image_buf = cl.Buffer(ctx, mf.READ_ONLY | mf.COPY_HOST_PTR, hostbuf=image)
#mem = cl.GLBuffer(ctx, mf.WRITE_ONLY, numpy.float32(buf))
queue = cl.CommandQueue(ctx)
prog = cl.Program(ctx, src).build()
#cl.enqueue_acquire_gl_objects(queue, [mem])
#add_knl = prog.add
#add_knl.set_args(image_buf, mem)
#cl.enqueue_nd_range_kernel(queue, add_knl, image.shape, None)
#cl.enqueue_release_gl_objects(queue, [mem])
#queue.finish()
#glFlush()
# Unbind
glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
glBindTexture(GL_TEXTURE_2D, 0);
glut.glutIdleFunc(idle_cb)
glut.glutDisplayFunc(display_cb)
glut.glutKeyboardFunc(keyboard_cb)
glut.glutReshapeFunc(reshape_cb)
glut.glutMouseFunc(mouse_cb)
glut.glutMotionFunc(mouse_motion_cb)
# must create VBOs before initializing openCL context???
# Initialize simulation controller
controller = Controller(screen_width, screen_height, 0)
camera = Camera(0.05, 10)
# Initialize OpenCL
cl_platform = cl.get_platforms()[0]
cl_context = cl.Context(
properties=[(cl.context_properties.PLATFORM, cl_platform)] +
get_gl_sharing_context_properties())
cl_queue = cl.CommandQueue(cl_context)
cl_program = cl.Program(cl_context, open('gravity.c', 'r').read()).build()
kernel_step = cl_program.gravity
kernel_init = cl_program.initialize
controller.cl_init()
# Begin main loop
initialize_scene()
glut.glutMainLoop()
#glutFullScreen()
return
if __name__ == '__main__':
app = QtGui.QApplication(sys.argv)
f = QtOpenGL.QGLFormat.defaultFormat()
f.setSampleBuffers(True)
QtOpenGL.QGLFormat.setDefaultFormat(f)
canvas = CGLPlotWidget()
gl_context = canvas.context()
gl_context.makeCurrent()
cl_context = cl.Context(properties=get_gl_sharing_context_properties(), devices=[])
plot1 = LinePlot(gl_context, cl_context,
n_vertices, scale=0.5, color=(1, 0, 0))
plot2 = LinePlot(gl_context, cl_context,
n_vertices, scale=1.1, color=(0, .8, .2))
generate_sin = cl.Program(cl_context, src).build().generate_sin
pipe_segment = ComputationalPipe(gl_context, cl_context, (n_vertices,), None,
generate_sin,
plot1.vtx_array.cl_buffer, np.float32(1.1))
plot1.add_pipe_segment(pipe_segment)
def clinit(self):
plats = cl.get_platforms()
from pyopencl.tools import get_gl_sharing_context_properties
self.ctx = cl.Context(properties=get_gl_sharing_context_properties(),
devices=[])
self.queue = cl.CommandQueue(self.ctx)
def __init__(self,
descriptor,
geometry,
moments,
collide,
pop_eq_src='',
boundary_src='',
platform=0,
precision='single',
layout=None,
padding=None,
align=False,
opengl=False):
self.descriptor = descriptor
self.geometry = geometry
self.grid = Grid(self.geometry, padding)
self.time = 0
self.float_type = {
'single': (numpy.float32, 'float'),
'double': (numpy.float64, 'double'),
}.get(precision, None)
self.mako_lookup = TemplateLookup(directories=[Path(__file__).parent])
self.platform = cl.get_platforms()[platform]
if opengl:
try:
self.context = cl.Context(
properties=[(cl.context_properties.PLATFORM,
self.platform)] +
get_gl_sharing_context_properties())
except:
self.context = cl.Context(
properties=[(cl.context_properties.PLATFORM, self.platform)
] + get_gl_sharing_context_properties(),
devices=[self.platform.get_devices()[0]])
else:
self.context = cl.Context(
properties=[(cl.context_properties.PLATFORM, self.platform)])
self.queue = cl.CommandQueue(self.context)
self.memory = Memory(self.descriptor, self.grid, self.context,
self.float_type[0], align, opengl)
self.tick = False
self.moments = moments
self.collide = collide
self.pop_eq_src = pop_eq_src
self.boundary_src = boundary_src
self.layout = layout
self.compiler_args = {
'single': '-cl-single-precision-constant -cl-fast-relaxed-math',
'double': '-cl-fast-relaxed-math'
}.get(precision, None)
self.build_kernel()
self.program.equilibrilize(self.queue, self.grid.size(), self.layout,
self.memory.cl_pop_a,
self.memory.cl_pop_b).wait()
self.material = numpy.ndarray(shape=(self.memory.volume, 1),
dtype=numpy.int32)
def _make_context(platform_id=None, device_id=None):
"""
Actually creates a context and return its ids'
Parameters
----------
platform_id : platform number
int
device_id : device number in the platform
int
"""
if not pyopencl:
raise RuntimeError("PyOpenCL not installed on the system !")
properties = get_gl_sharing_context_properties()
enum_plat = pyopencl.context_properties.PLATFORM
ids = None
if (platform_id is not None) and (device_id is not None):
platform = pyopencl.get_platforms()[platform_id]
device = platform.get_devices()[device_id]
try:
ctx = pyopencl.Context(devices=[device],
properties=[(enum_plat, platform)]
+ properties)
ids = (platform_id, device_id)
except:
ctx = None
elif sys.platform == "darwin":
ctx = pyopencl.Context(properties=properties,
devices=[])
for platform_id, platform in enumerate(pyopencl.get_platforms()):
for device_id, device in enumerate(platform.get_device()):
if ctx.devices[0] == device:
ids = (platform_id, device_id)
else:
# Some OSs prefer clCreateContextFromType, some prefer
# clCreateContext. Try both and loop.
for platform_id, platform in enumerate(pyopencl.get_platforms()):
try:
ctx = pyopencl.Context(properties=properties +
[(enum_plat, platform)])
device = ctx.devices[0]
if device.type != pyopencl.device_type.GPU:
# Wrongly selected non GPU device
ctx = None
raise
except:
for device_id, device in enumerate(platform.get_devices()):
if device.type != pyopencl.device_type.GPU:
continue
try:
ctx = pyopencl.Context(devices=[device],
properties=properties +
[(enum_plat, platform)])
except:
ctx = None
else:
ids = (platform_id, device_id)
break
else:
for device_id, device in enumerate(platform.get_devices()):
if ctx.devices[0] == device:
ids = (platform_id, device_id)
break
break
if ctx:
break
return ctx, ids
